Remove nnml-retrieve-groups that is unnecessary and somewhat problematic
[gnus] / lisp / gnus.el
1 ;;; gnus.el --- a newsreader for GNU Emacs
2
3 ;; Copyright (C) 1987-1990, 1993-1998, 2000-2015 Free Software
4 ;; Foundation, Inc.
5
6 ;; Author: Masanobu UMEDA <umerin@flab.flab.fujitsu.junet>
7 ;;      Lars Magne Ingebrigtsen <larsi@gnus.org>
8 ;; Keywords: news, mail
9
10 ;; This file is part of GNU Emacs.
11
12 ;; GNU Emacs is free software: you can redistribute it and/or modify
13 ;; it under the terms of the GNU General Public License as published by
14 ;; the Free Software Foundation, either version 3 of the License, or
15 ;; (at your option) any later version.
16
17 ;; GNU Emacs is distributed in the hope that it will be useful,
18 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
19 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
20 ;; GNU General Public License for more details.
21
22 ;; You should have received a copy of the GNU General Public License
23 ;; along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.
24
25 ;;; Commentary:
26
27 ;;; Code:
28
29 (eval '(run-hooks 'gnus-load-hook))
30
31 (eval-when-compile (require 'cl))
32 (require 'wid-edit)
33 (require 'mm-util)
34 (require 'nnheader)
35 (require 'gnus-compat)
36
37 ;; These are defined afterwards with gnus-define-group-parameter
38 (defvar gnus-ham-process-destinations)
39 (defvar gnus-parameter-ham-marks-alist)
40 (defvar gnus-parameter-spam-marks-alist)
41 (defvar gnus-spam-autodetect)
42 (defvar gnus-spam-autodetect-methods)
43 (defvar gnus-spam-newsgroup-contents)
44 (defvar gnus-spam-process-destinations)
45 (defvar gnus-spam-resend-to)
46 (defvar gnus-ham-resend-to)
47 (defvar gnus-spam-process-newsgroups)
48
49
50 (defgroup gnus nil
51   "The coffee-brewing, all singing, all dancing, kitchen sink newsreader."
52   :group 'news
53   :group 'mail)
54
55 (defgroup gnus-start nil
56   "Starting your favorite newsreader."
57   :group 'gnus)
58
59 (defgroup gnus-format nil
60   "Dealing with formatting issues."
61   :group 'gnus)
62
63 (defgroup gnus-charset nil
64   "Group character set issues."
65   :link '(custom-manual "(gnus)Charsets")
66   :version "21.1"
67   :group 'gnus)
68
69 (defgroup gnus-cache nil
70   "Cache interface."
71   :link '(custom-manual "(gnus)Article Caching")
72   :group 'gnus)
73
74 (defgroup gnus-registry nil
75   "Article Registry."
76   :group 'gnus)
77
78 (defgroup gnus-start-server nil
79   "Server options at startup."
80   :group 'gnus-start)
81
82 ;; These belong to gnus-group.el.
83 (defgroup gnus-group nil
84   "Group buffers."
85   :link '(custom-manual "(gnus)Group Buffer")
86   :group 'gnus)
87
88 (defgroup gnus-group-foreign nil
89   "Foreign groups."
90   :link '(custom-manual "(gnus)Foreign Groups")
91   :group 'gnus-group)
92
93 (defgroup gnus-group-new nil
94   "Automatic subscription of new groups."
95   :group 'gnus-group)
96
97 (defgroup gnus-group-levels nil
98   "Group levels."
99   :link '(custom-manual "(gnus)Group Levels")
100   :group 'gnus-group)
101
102 (defgroup gnus-group-select nil
103   "Selecting a Group."
104   :link '(custom-manual "(gnus)Selecting a Group")
105   :group 'gnus-group)
106
107 (defgroup gnus-group-listing nil
108   "Showing slices of the group list."
109   :link '(custom-manual "(gnus)Listing Groups")
110   :group 'gnus-group)
111
112 (defgroup gnus-group-visual nil
113   "Sorting the group buffer."
114   :link '(custom-manual "(gnus)Group Buffer Format")
115   :group 'gnus-group
116   :group 'gnus-visual)
117
118 (defgroup gnus-group-various nil
119   "Various group options."
120   :link '(custom-manual "(gnus)Scanning New Messages")
121   :group 'gnus-group)
122
123 ;; These belong to gnus-sum.el.
124 (defgroup gnus-summary nil
125   "Summary buffers."
126   :link '(custom-manual "(gnus)Summary Buffer")
127   :group 'gnus)
128
129 (defgroup gnus-summary-exit nil
130   "Leaving summary buffers."
131   :link '(custom-manual "(gnus)Exiting the Summary Buffer")
132   :group 'gnus-summary)
133
134 (defgroup gnus-summary-marks nil
135   "Marks used in summary buffers."
136   :link '(custom-manual "(gnus)Marking Articles")
137   :group 'gnus-summary)
138
139 (defgroup gnus-thread nil
140   "Ordering articles according to replies."
141   :link '(custom-manual "(gnus)Threading")
142   :group 'gnus-summary)
143
144 (defgroup gnus-summary-format nil
145   "Formatting of the summary buffer."
146   :link '(custom-manual "(gnus)Summary Buffer Format")
147   :group 'gnus-summary)
148
149 (defgroup gnus-summary-choose nil
150   "Choosing Articles."
151   :link '(custom-manual "(gnus)Choosing Articles")
152   :group 'gnus-summary)
153
154 (defgroup gnus-summary-maneuvering nil
155   "Summary movement commands."
156   :link '(custom-manual "(gnus)Summary Maneuvering")
157   :group 'gnus-summary)
158
159 (defgroup gnus-picon nil
160   "Show pictures of people, domains, and newsgroups."
161   :group 'gnus-visual)
162
163 (defgroup gnus-summary-mail nil
164   "Mail group commands."
165   :link '(custom-manual "(gnus)Mail Group Commands")
166   :group 'gnus-summary)
167
168 (defgroup gnus-summary-sort nil
169   "Sorting the summary buffer."
170   :link '(custom-manual "(gnus)Sorting the Summary Buffer")
171   :group 'gnus-summary)
172
173 (defgroup gnus-summary-visual nil
174   "Highlighting and menus in the summary buffer."
175   :link '(custom-manual "(gnus)Summary Highlighting")
176   :group 'gnus-visual
177   :group 'gnus-summary)
178
179 (defgroup gnus-summary-various nil
180   "Various summary buffer options."
181   :link '(custom-manual "(gnus)Various Summary Stuff")
182   :group 'gnus-summary)
183
184 (defgroup gnus-summary-pick nil
185   "Pick mode in the summary buffer."
186   :link '(custom-manual "(gnus)Pick and Read")
187   :prefix "gnus-pick-"
188   :group 'gnus-summary)
189
190 (defgroup gnus-summary-tree nil
191   "Tree display of threads in the summary buffer."
192   :link '(custom-manual "(gnus)Tree Display")
193   :prefix "gnus-tree-"
194   :group 'gnus-summary)
195
196 ;; Belongs to gnus-uu.el
197 (defgroup gnus-extract-view nil
198   "Viewing extracted files."
199   :link '(custom-manual "(gnus)Viewing Files")
200   :group 'gnus-extract)
201
202 ;; Belongs to gnus-score.el
203 (defgroup gnus-score nil
204   "Score and kill file handling."
205   :group 'gnus)
206
207 (defgroup gnus-score-kill nil
208   "Kill files."
209   :group 'gnus-score)
210
211 (defgroup gnus-score-adapt nil
212   "Adaptive score files."
213   :group 'gnus-score)
214
215 (defgroup gnus-score-default nil
216   "Default values for score files."
217   :group 'gnus-score)
218
219 (defgroup gnus-score-expire nil
220   "Expiring score rules."
221   :group 'gnus-score)
222
223 (defgroup gnus-score-decay nil
224   "Decaying score rules."
225   :group 'gnus-score)
226
227 (defgroup gnus-score-files nil
228   "Score and kill file names."
229   :group 'gnus-score
230   :group 'gnus-files)
231
232 (defgroup gnus-score-various nil
233   "Various scoring and killing options."
234   :group 'gnus-score)
235
236 ;; Other
237 (defgroup gnus-visual nil
238   "Options controlling the visual fluff."
239   :group 'gnus
240   :group 'faces)
241
242 (defgroup gnus-agent nil
243   "Offline support for Gnus."
244   :group 'gnus)
245
246 (defgroup gnus-files nil
247   "Files used by Gnus."
248   :group 'gnus)
249
250 (defgroup gnus-dribble-file nil
251   "Auto save file."
252   :link '(custom-manual "(gnus)Auto Save")
253   :group 'gnus-files)
254
255 (defgroup gnus-newsrc nil
256   "Storing Gnus state."
257   :group 'gnus-files)
258
259 (defgroup gnus-server nil
260   "Options related to newsservers and other servers used by Gnus."
261   :group 'gnus)
262
263 (defgroup gnus-server-visual nil
264   "Highlighting and menus in the server buffer."
265   :group 'gnus-visual
266   :group 'gnus-server)
267
268 (defgroup gnus-message '((message custom-group))
269   "Composing replies and followups in Gnus."
270   :group 'gnus)
271
272 (defgroup gnus-meta nil
273   "Meta variables controlling major portions of Gnus.
274 In general, modifying these variables does not take effect until Gnus
275 is restarted, and sometimes reloaded."
276   :group 'gnus)
277
278 (defgroup gnus-various nil
279   "Other Gnus options."
280   :link '(custom-manual "(gnus)Various Various")
281   :group 'gnus)
282
283 (defgroup gnus-exit nil
284   "Exiting Gnus."
285   :link '(custom-manual "(gnus)Exiting Gnus")
286   :group 'gnus)
287
288 (defgroup gnus-fun nil
289   "Frivolous Gnus extensions."
290   :link '(custom-manual "(gnus)Exiting Gnus")
291   :group 'gnus)
292
293 (defconst gnus-version-number "0.14"
294   "Version number for this version of Gnus.")
295
296 (defconst gnus-version (format "Ma Gnus v%s" gnus-version-number)
297   "Version string for this version of Gnus.")
298
299 (defcustom gnus-inhibit-startup-message nil
300   "If non-nil, the startup message will not be displayed.
301 This variable is used before `.gnus.el' is loaded, so it should
302 be set in `.emacs' instead."
303   :group 'gnus-start
304   :type 'boolean)
305
306 (unless (featurep 'gnus-xmas)
307   (defalias 'gnus-extent-detached-p 'ignore)
308   (defalias 'gnus-extent-start-open 'ignore)
309   (defalias 'gnus-mail-strip-quoted-names 'mail-strip-quoted-names)
310   (defalias 'gnus-character-to-event 'identity)
311   (defalias 'gnus-assq-delete-all 'assq-delete-all)
312   (defalias 'gnus-add-text-properties 'add-text-properties)
313   (defalias 'gnus-put-text-property 'put-text-property)
314   (defvar gnus-mode-line-image-cache t)
315   (if (fboundp 'find-image)
316       (defun gnus-mode-line-buffer-identification (line)
317         (let ((str (car-safe line))
318               (load-path (append (mm-image-load-path) load-path)))
319           (if (and (display-graphic-p)
320                    (stringp str)
321                    (string-match "^Gnus:" str))
322               (progn (add-text-properties
323                       0 5
324                       (list 'display
325                             (if (eq t gnus-mode-line-image-cache)
326                                 (setq gnus-mode-line-image-cache
327                                       (find-image
328                                        '((:type xpm :file "gnus-pointer.xpm"
329                                                 :ascent center)
330                                          (:type xbm :file "gnus-pointer.xbm"
331                                                 :ascent center))))
332                               gnus-mode-line-image-cache)
333                             'help-echo (format
334                                         "This is %s, %s."
335                                         gnus-version (gnus-emacs-version)))
336                       str)
337                      (list str))
338             line)))
339     (defalias 'gnus-mode-line-buffer-identification 'identity))
340   (defalias 'gnus-deactivate-mark 'deactivate-mark)
341   (defalias 'gnus-window-edges 'window-edges)
342   (defalias 'gnus-key-press-event-p 'numberp)
343   ;;(defalias 'gnus-decode-rfc1522 'ignore)
344   )
345
346 ;; We define these group faces here to avoid the display
347 ;; update forced when creating new faces.
348
349 (defface gnus-group-news-1
350   '((((class color)
351       (background dark))
352      (:foreground "PaleTurquoise" :bold t))
353     (((class color)
354       (background light))
355      (:foreground "ForestGreen" :bold t))
356     (t
357      ()))
358   "Level 1 newsgroup face."
359   :group 'gnus-group)
360 ;; backward-compatibility alias
361 (put 'gnus-group-news-1-face 'face-alias 'gnus-group-news-1)
362 (put 'gnus-group-news-1-face 'obsolete-face "22.1")
363
364 (defface gnus-group-news-1-empty
365   '((((class color)
366       (background dark))
367      (:foreground "PaleTurquoise"))
368     (((class color)
369       (background light))
370      (:foreground "ForestGreen"))
371     (t
372      ()))
373   "Level 1 empty newsgroup face."
374   :group 'gnus-group)
375 ;; backward-compatibility alias
376 (put 'gnus-group-news-1-empty-face 'face-alias 'gnus-group-news-1-empty)
377 (put 'gnus-group-news-1-empty-face 'obsolete-face "22.1")
378
379 (defface gnus-group-news-2
380   '((((class color)
381       (background dark))
382      (:foreground "turquoise" :bold t))
383     (((class color)
384       (background light))
385      (:foreground "CadetBlue4" :bold t))
386     (t
387      ()))
388   "Level 2 newsgroup face."
389   :group 'gnus-group)
390 ;; backward-compatibility alias
391 (put 'gnus-group-news-2-face 'face-alias 'gnus-group-news-2)
392 (put 'gnus-group-news-2-face 'obsolete-face "22.1")
393
394 (defface gnus-group-news-2-empty
395   '((((class color)
396       (background dark))
397      (:foreground "turquoise"))
398     (((class color)
399       (background light))
400      (:foreground "CadetBlue4"))
401     (t
402      ()))
403   "Level 2 empty newsgroup face."
404   :group 'gnus-group)
405 ;; backward-compatibility alias
406 (put 'gnus-group-news-2-empty-face 'face-alias 'gnus-group-news-2-empty)
407 (put 'gnus-group-news-2-empty-face 'obsolete-face "22.1")
408
409 (defface gnus-group-news-3
410   '((((class color)
411       (background dark))
412      (:bold t))
413     (((class color)
414       (background light))
415      (:bold t))
416     (t
417      ()))
418   "Level 3 newsgroup face."
419   :group 'gnus-group)
420 ;; backward-compatibility alias
421 (put 'gnus-group-news-3-face 'face-alias 'gnus-group-news-3)
422 (put 'gnus-group-news-3-face 'obsolete-face "22.1")
423
424 (defface gnus-group-news-3-empty
425   '((((class color)
426       (background dark))
427      ())
428     (((class color)
429       (background light))
430      ())
431     (t
432      ()))
433   "Level 3 empty newsgroup face."
434   :group 'gnus-group)
435 ;; backward-compatibility alias
436 (put 'gnus-group-news-3-empty-face 'face-alias 'gnus-group-news-3-empty)
437 (put 'gnus-group-news-3-empty-face 'obsolete-face "22.1")
438
439 (defface gnus-group-news-4
440   '((((class color)
441       (background dark))
442      (:bold t))
443     (((class color)
444       (background light))
445      (:bold t))
446     (t
447      ()))
448   "Level 4 newsgroup face."
449   :group 'gnus-group)
450 ;; backward-compatibility alias
451 (put 'gnus-group-news-4-face 'face-alias 'gnus-group-news-4)
452 (put 'gnus-group-news-4-face 'obsolete-face "22.1")
453
454 (defface gnus-group-news-4-empty
455   '((((class color)
456       (background dark))
457      ())
458     (((class color)
459       (background light))
460      ())
461     (t
462      ()))
463   "Level 4 empty newsgroup face."
464   :group 'gnus-group)
465 ;; backward-compatibility alias
466 (put 'gnus-group-news-4-empty-face 'face-alias 'gnus-group-news-4-empty)
467 (put 'gnus-group-news-4-empty-face 'obsolete-face "22.1")
468
469 (defface gnus-group-news-5
470   '((((class color)
471       (background dark))
472      (:bold t))
473     (((class color)
474       (background light))
475      (:bold t))
476     (t
477      ()))
478   "Level 5 newsgroup face."
479   :group 'gnus-group)
480 ;; backward-compatibility alias
481 (put 'gnus-group-news-5-face 'face-alias 'gnus-group-news-5)
482 (put 'gnus-group-news-5-face 'obsolete-face "22.1")
483
484 (defface gnus-group-news-5-empty
485   '((((class color)
486       (background dark))
487      ())
488     (((class color)
489       (background light))
490      ())
491     (t
492      ()))
493   "Level 5 empty newsgroup face."
494   :group 'gnus-group)
495 ;; backward-compatibility alias
496 (put 'gnus-group-news-5-empty-face 'face-alias 'gnus-group-news-5-empty)
497 (put 'gnus-group-news-5-empty-face 'obsolete-face "22.1")
498
499 (defface gnus-group-news-6
500   '((((class color)
501       (background dark))
502      (:bold t))
503     (((class color)
504       (background light))
505      (:bold t))
506     (t
507      ()))
508   "Level 6 newsgroup face."
509   :group 'gnus-group)
510 ;; backward-compatibility alias
511 (put 'gnus-group-news-6-face 'face-alias 'gnus-group-news-6)
512 (put 'gnus-group-news-6-face 'obsolete-face "22.1")
513
514 (defface gnus-group-news-6-empty
515   '((((class color)
516       (background dark))
517      ())
518     (((class color)
519       (background light))
520      ())
521     (t
522      ()))
523   "Level 6 empty newsgroup face."
524   :group 'gnus-group)
525 ;; backward-compatibility alias
526 (put 'gnus-group-news-6-empty-face 'face-alias 'gnus-group-news-6-empty)
527 (put 'gnus-group-news-6-empty-face 'obsolete-face "22.1")
528
529 (defface gnus-group-news-low
530   '((((class color)
531       (background dark))
532      (:foreground "DarkTurquoise" :bold t))
533     (((class color)
534       (background light))
535      (:foreground "DarkGreen" :bold t))
536     (t
537      ()))
538   "Low level newsgroup face."
539   :group 'gnus-group)
540 ;; backward-compatibility alias
541 (put 'gnus-group-news-low-face 'face-alias 'gnus-group-news-low)
542 (put 'gnus-group-news-low-face 'obsolete-face "22.1")
543
544 (defface gnus-group-news-low-empty
545   '((((class color)
546       (background dark))
547      (:foreground "DarkTurquoise"))
548     (((class color)
549       (background light))
550      (:foreground "DarkGreen"))
551     (t
552      ()))
553   "Low level empty newsgroup face."
554   :group 'gnus-group)
555 ;; backward-compatibility alias
556 (put 'gnus-group-news-low-empty-face 'face-alias 'gnus-group-news-low-empty)
557 (put 'gnus-group-news-low-empty-face 'obsolete-face "22.1")
558
559 (defface gnus-group-mail-1
560   '((((class color)
561       (background dark))
562      (:foreground "#e1ffe1" :bold t))
563     (((class color)
564       (background light))
565      (:foreground "DeepPink3" :bold t))
566     (t
567      (:bold t)))
568   "Level 1 mailgroup face."
569   :group 'gnus-group)
570 ;; backward-compatibility alias
571 (put 'gnus-group-mail-1-face 'face-alias 'gnus-group-mail-1)
572 (put 'gnus-group-mail-1-face 'obsolete-face "22.1")
573
574 (defface gnus-group-mail-1-empty
575   '((((class color)
576       (background dark))
577      (:foreground "#e1ffe1"))
578     (((class color)
579       (background light))
580      (:foreground "DeepPink3"))
581     (t
582      (:italic t :bold t)))
583   "Level 1 empty mailgroup face."
584   :group 'gnus-group)
585 ;; backward-compatibility alias
586 (put 'gnus-group-mail-1-empty-face 'face-alias 'gnus-group-mail-1-empty)
587 (put 'gnus-group-mail-1-empty-face 'obsolete-face "22.1")
588
589 (defface gnus-group-mail-2
590   '((((class color)
591       (background dark))
592      (:foreground "DarkSeaGreen1" :bold t))
593     (((class color)
594       (background light))
595      (:foreground "HotPink3" :bold t))
596     (t
597      (:bold t)))
598   "Level 2 mailgroup face."
599   :group 'gnus-group)
600 ;; backward-compatibility alias
601 (put 'gnus-group-mail-2-face 'face-alias 'gnus-group-mail-2)
602 (put 'gnus-group-mail-2-face 'obsolete-face "22.1")
603
604 (defface gnus-group-mail-2-empty
605   '((((class color)
606       (background dark))
607      (:foreground "DarkSeaGreen1"))
608     (((class color)
609       (background light))
610      (:foreground "HotPink3"))
611     (t
612      (:bold t)))
613   "Level 2 empty mailgroup face."
614   :group 'gnus-group)
615 ;; backward-compatibility alias
616 (put 'gnus-group-mail-2-empty-face 'face-alias 'gnus-group-mail-2-empty)
617 (put 'gnus-group-mail-2-empty-face 'obsolete-face "22.1")
618
619 (defface gnus-group-mail-3
620   '((((class color)
621       (background dark))
622      (:foreground "aquamarine1" :bold t))
623     (((class color)
624       (background light))
625      (:foreground "magenta4" :bold t))
626     (t
627      (:bold t)))
628   "Level 3 mailgroup face."
629   :group 'gnus-group)
630 ;; backward-compatibility alias
631 (put 'gnus-group-mail-3-face 'face-alias 'gnus-group-mail-3)
632 (put 'gnus-group-mail-3-face 'obsolete-face "22.1")
633
634 (defface gnus-group-mail-3-empty
635   '((((class color)
636       (background dark))
637      (:foreground "aquamarine1"))
638     (((class color)
639       (background light))
640      (:foreground "magenta4"))
641     (t
642      ()))
643   "Level 3 empty mailgroup face."
644   :group 'gnus-group)
645 ;; backward-compatibility alias
646 (put 'gnus-group-mail-3-empty-face 'face-alias 'gnus-group-mail-3-empty)
647 (put 'gnus-group-mail-3-empty-face 'obsolete-face "22.1")
648
649 (defface gnus-group-mail-low
650   '((((class color)
651       (background dark))
652      (:foreground "aquamarine2" :bold t))
653     (((class color)
654       (background light))
655      (:foreground "DeepPink4" :bold t))
656     (t
657      (:bold t)))
658   "Low level mailgroup face."
659   :group 'gnus-group)
660 ;; backward-compatibility alias
661 (put 'gnus-group-mail-low-face 'face-alias 'gnus-group-mail-low)
662 (put 'gnus-group-mail-low-face 'obsolete-face "22.1")
663
664 (defface gnus-group-mail-low-empty
665   '((((class color)
666       (background dark))
667      (:foreground "aquamarine2"))
668     (((class color)
669       (background light))
670      (:foreground "DeepPink4"))
671     (t
672      (:bold t)))
673   "Low level empty mailgroup face."
674   :group 'gnus-group)
675 ;; backward-compatibility alias
676 (put 'gnus-group-mail-low-empty-face 'face-alias 'gnus-group-mail-low-empty)
677 (put 'gnus-group-mail-low-empty-face 'obsolete-face "22.1")
678
679 ;; Summary mode faces.
680
681 (defface gnus-summary-selected '((t (:underline t)))
682   "Face used for selected articles."
683   :group 'gnus-summary)
684 ;; backward-compatibility alias
685 (put 'gnus-summary-selected-face 'face-alias 'gnus-summary-selected)
686 (put 'gnus-summary-selected-face 'obsolete-face "22.1")
687
688 (defface gnus-summary-cancelled
689   '((((class color))
690      (:foreground "yellow" :background "black")))
691   "Face used for canceled articles."
692   :group 'gnus-summary)
693 ;; backward-compatibility alias
694 (put 'gnus-summary-cancelled-face 'face-alias 'gnus-summary-cancelled)
695 (put 'gnus-summary-cancelled-face 'obsolete-face "22.1")
696
697 (defface gnus-summary-high-ticked
698   '((((class color)
699       (background dark))
700      (:foreground "pink" :bold t))
701     (((class color)
702       (background light))
703      (:foreground "firebrick" :bold t))
704     (t
705      (:bold t)))
706   "Face used for high interest ticked articles."
707   :group 'gnus-summary)
708 ;; backward-compatibility alias
709 (put 'gnus-summary-high-ticked-face 'face-alias 'gnus-summary-high-ticked)
710 (put 'gnus-summary-high-ticked-face 'obsolete-face "22.1")
711
712 (defface gnus-summary-low-ticked
713   '((((class color)
714       (background dark))
715      (:foreground "pink" :italic t))
716     (((class color)
717       (background light))
718      (:foreground "firebrick" :italic t))
719     (t
720      (:italic t)))
721   "Face used for low interest ticked articles."
722   :group 'gnus-summary)
723 ;; backward-compatibility alias
724 (put 'gnus-summary-low-ticked-face 'face-alias 'gnus-summary-low-ticked)
725 (put 'gnus-summary-low-ticked-face 'obsolete-face "22.1")
726
727 (defface gnus-summary-normal-ticked
728   '((((class color)
729       (background dark))
730      (:foreground "pink"))
731     (((class color)
732       (background light))
733      (:foreground "firebrick"))
734     (t
735      ()))
736   "Face used for normal interest ticked articles."
737   :group 'gnus-summary)
738 ;; backward-compatibility alias
739 (put 'gnus-summary-normal-ticked-face 'face-alias 'gnus-summary-normal-ticked)
740 (put 'gnus-summary-normal-ticked-face 'obsolete-face "22.1")
741
742 (defface gnus-summary-high-ancient
743   '((((class color)
744       (background dark))
745      (:foreground "SkyBlue" :bold t))
746     (((class color)
747       (background light))
748      (:foreground "RoyalBlue" :bold t))
749     (t
750      (:bold t)))
751   "Face used for high interest ancient articles."
752   :group 'gnus-summary)
753 ;; backward-compatibility alias
754 (put 'gnus-summary-high-ancient-face 'face-alias 'gnus-summary-high-ancient)
755 (put 'gnus-summary-high-ancient-face 'obsolete-face "22.1")
756
757 (defface gnus-summary-low-ancient
758   '((((class color)
759       (background dark))
760      (:foreground "SkyBlue" :italic t))
761     (((class color)
762       (background light))
763      (:foreground "RoyalBlue" :italic t))
764     (t
765      (:italic t)))
766   "Face used for low interest ancient articles."
767   :group 'gnus-summary)
768 ;; backward-compatibility alias
769 (put 'gnus-summary-low-ancient-face 'face-alias 'gnus-summary-low-ancient)
770 (put 'gnus-summary-low-ancient-face 'obsolete-face "22.1")
771
772 (defface gnus-summary-normal-ancient
773   '((((class color)
774       (background dark))
775      (:foreground "SkyBlue"))
776     (((class color)
777       (background light))
778      (:foreground "RoyalBlue"))
779     (t
780      ()))
781   "Face used for normal interest ancient articles."
782   :group 'gnus-summary)
783 ;; backward-compatibility alias
784 (put 'gnus-summary-normal-ancient-face 'face-alias 'gnus-summary-normal-ancient)
785 (put 'gnus-summary-normal-ancient-face 'obsolete-face "22.1")
786
787 (defface gnus-summary-high-undownloaded
788    '((((class color)
789        (background light))
790       (:bold t :foreground "cyan4"))
791      (((class color) (background dark))
792       (:bold t :foreground "LightGray"))
793      (t (:inverse-video t :bold t)))
794   "Face used for high interest uncached articles."
795   :group 'gnus-summary)
796 ;; backward-compatibility alias
797 (put 'gnus-summary-high-undownloaded-face 'face-alias 'gnus-summary-high-undownloaded)
798 (put 'gnus-summary-high-undownloaded-face 'obsolete-face "22.1")
799
800 (defface gnus-summary-low-undownloaded
801    '((((class color)
802        (background light))
803       (:italic t :foreground "cyan4" :bold nil))
804      (((class color) (background dark))
805       (:italic t :foreground "LightGray" :bold nil))
806      (t (:inverse-video t :italic t)))
807   "Face used for low interest uncached articles."
808   :group 'gnus-summary)
809 ;; backward-compatibility alias
810 (put 'gnus-summary-low-undownloaded-face 'face-alias 'gnus-summary-low-undownloaded)
811 (put 'gnus-summary-low-undownloaded-face 'obsolete-face "22.1")
812
813 (defface gnus-summary-normal-undownloaded
814    '((((class color)
815        (background light))
816       (:foreground "cyan4" :bold nil))
817      (((class color) (background dark))
818       (:foreground "LightGray" :bold nil))
819      (t (:inverse-video t)))
820   "Face used for normal interest uncached articles."
821   :group 'gnus-summary)
822 ;; backward-compatibility alias
823 (put 'gnus-summary-normal-undownloaded-face 'face-alias 'gnus-summary-normal-undownloaded)
824 (put 'gnus-summary-normal-undownloaded-face 'obsolete-face "22.1")
825
826 (defface gnus-summary-high-unread
827   '((t
828      (:bold t)))
829   "Face used for high interest unread articles."
830   :group 'gnus-summary)
831 ;; backward-compatibility alias
832 (put 'gnus-summary-high-unread-face 'face-alias 'gnus-summary-high-unread)
833 (put 'gnus-summary-high-unread-face 'obsolete-face "22.1")
834
835 (defface gnus-summary-low-unread
836   '((t
837      (:italic t)))
838   "Face used for low interest unread articles."
839   :group 'gnus-summary)
840 ;; backward-compatibility alias
841 (put 'gnus-summary-low-unread-face 'face-alias 'gnus-summary-low-unread)
842 (put 'gnus-summary-low-unread-face 'obsolete-face "22.1")
843
844 (defface gnus-summary-normal-unread
845   '((t
846      ()))
847   "Face used for normal interest unread articles."
848   :group 'gnus-summary)
849 ;; backward-compatibility alias
850 (put 'gnus-summary-normal-unread-face 'face-alias 'gnus-summary-normal-unread)
851 (put 'gnus-summary-normal-unread-face 'obsolete-face "22.1")
852
853 (defface gnus-summary-high-read
854   '((((class color)
855       (background dark))
856      (:foreground "PaleGreen"
857                   :bold t))
858     (((class color)
859       (background light))
860      (:foreground "DarkGreen"
861                   :bold t))
862     (t
863      (:bold t)))
864   "Face used for high interest read articles."
865   :group 'gnus-summary)
866 ;; backward-compatibility alias
867 (put 'gnus-summary-high-read-face 'face-alias 'gnus-summary-high-read)
868 (put 'gnus-summary-high-read-face 'obsolete-face "22.1")
869
870 (defface gnus-summary-low-read
871   '((((class color)
872       (background dark))
873      (:foreground "PaleGreen"
874                   :italic t))
875     (((class color)
876       (background light))
877      (:foreground "DarkGreen"
878                   :italic t))
879     (t
880      (:italic t)))
881   "Face used for low interest read articles."
882   :group 'gnus-summary)
883 ;; backward-compatibility alias
884 (put 'gnus-summary-low-read-face 'face-alias 'gnus-summary-low-read)
885 (put 'gnus-summary-low-read-face 'obsolete-face "22.1")
886
887 (defface gnus-summary-normal-read
888   '((((class color)
889       (background dark))
890      (:foreground "PaleGreen"))
891     (((class color)
892       (background light))
893      (:foreground "DarkGreen"))
894     (t
895      ()))
896   "Face used for normal interest read articles."
897   :group 'gnus-summary)
898 ;; backward-compatibility alias
899 (put 'gnus-summary-normal-read-face 'face-alias 'gnus-summary-normal-read)
900 (put 'gnus-summary-normal-read-face 'obsolete-face "22.1")
901
902
903 ;;;
904 ;;; Gnus buffers
905 ;;;
906
907 (defvar gnus-buffers nil
908   "List of buffers handled by Gnus.")
909
910 (defun gnus-get-buffer-create (name)
911   "Do the same as `get-buffer-create', but store the created buffer."
912   (or (get-buffer name)
913       (car (push (get-buffer-create name) gnus-buffers))))
914
915 (defun gnus-add-buffer ()
916   "Add the current buffer to the list of Gnus buffers."
917   (push (current-buffer) gnus-buffers))
918
919 (defmacro gnus-kill-buffer (buffer)
920   "Kill BUFFER and remove from the list of Gnus buffers."
921   `(let ((buf ,buffer))
922      (when (gnus-buffer-exists-p buf)
923        (setq gnus-buffers (delete (get-buffer buf) gnus-buffers))
924        (kill-buffer buf))))
925
926 (defun gnus-buffers ()
927   "Return a list of live Gnus buffers."
928   (while (and gnus-buffers
929               (not (buffer-name (car gnus-buffers))))
930     (pop gnus-buffers))
931   (let ((buffers gnus-buffers))
932     (while (cdr buffers)
933       (if (buffer-name (cadr buffers))
934           (pop buffers)
935         (setcdr buffers (cddr buffers)))))
936   gnus-buffers)
937
938 ;;; Splash screen.
939
940 (defvar gnus-group-buffer "*Group*"
941   "Name of the Gnus group buffer.")
942
943 (defface gnus-splash
944   '((((class color)
945       (background dark))
946      (:foreground "#cccccc"))
947     (((class color)
948       (background light))
949      (:foreground "#888888"))
950     (t
951      ()))
952   "Face for the splash screen."
953   :group 'gnus-start)
954 ;; backward-compatibility alias
955 (put 'gnus-splash-face 'face-alias 'gnus-splash)
956 (put 'gnus-splash-face 'obsolete-face "22.1")
957
958 (defun gnus-splash ()
959   (save-excursion
960     (switch-to-buffer (gnus-get-buffer-create gnus-group-buffer))
961     (let ((buffer-read-only nil))
962       (erase-buffer)
963       (unless gnus-inhibit-startup-message
964         (gnus-group-startup-message)
965         (sit-for 0)))))
966
967 (defun gnus-indent-rigidly (start end arg)
968   "Indent rigidly using only spaces and no tabs."
969   (save-excursion
970     (save-restriction
971       (narrow-to-region start end)
972       (let ((tab-width 8))
973         (indent-rigidly start end arg)
974         ;; We translate tabs into spaces -- not everybody uses
975         ;; an 8-character tab.
976         (goto-char (point-min))
977         (while (search-forward "\t" nil t)
978           (replace-match "        " t t))))))
979
980 ;;(format "%02x%02x%02x" 114 66 20) "724214"
981
982 (defvar gnus-logo-color-alist
983   '((flame "#cc3300" "#ff2200")
984     (pine "#c0cc93" "#f8ffb8")
985     (moss "#a1cc93" "#d2ffb8")
986     (irish "#04cc90" "#05ff97")
987     (sky "#049acc" "#05deff")
988     (tin "#6886cc" "#82b6ff")
989     (velvet "#7c68cc" "#8c82ff")
990     (grape "#b264cc" "#cf7df")
991     (labia "#cc64c2" "#fd7dff")
992     (berry "#cc6485" "#ff7db5")
993     (dino "#724214" "#1e3f03")
994     (oort "#cccccc" "#888888")
995     (storm "#666699" "#99ccff")
996     (pdino "#9999cc" "#99ccff")
997     (purp "#9999cc" "#666699")
998     (no "#ff0000" "#ffff00")
999     (neutral "#b4b4b4" "#878787")
1000     (ma "#2020e0" "#8080ff")
1001     (september "#bf9900" "#ffcc00"))
1002   "Color alist used for the Gnus logo.")
1003
1004 (defcustom gnus-logo-color-style 'ma
1005   "*Color styles used for the Gnus logo."
1006   :type `(choice ,@(mapcar (lambda (elem) (list 'const (car elem)))
1007                            gnus-logo-color-alist))
1008   :group 'gnus-xmas)
1009
1010 (defvar gnus-logo-colors
1011   (cdr (assq gnus-logo-color-style gnus-logo-color-alist))
1012   "Colors used for the Gnus logo.")
1013
1014 (declare-function image-size "image.c" (spec &optional pixels frame))
1015
1016 (defun gnus-group-startup-message (&optional x y)
1017   "Insert startup message in current buffer."
1018   ;; Insert the message.
1019   (erase-buffer)
1020   (unless (and
1021            (fboundp 'find-image)
1022            (display-graphic-p)
1023            ;; Make sure the library defining `image-load-path' is
1024            ;; loaded (`find-image' is autoloaded) (and discard the
1025            ;; result).  Else, we may get "defvar ignored because
1026            ;; image-load-path is let-bound" when calling `find-image'
1027            ;; below.
1028            (or (find-image '(nil (:type xpm :file "gnus.xpm"))) t)
1029            (let* ((data-directory (nnheader-find-etc-directory "images/gnus"))
1030                   (image-load-path (cond (data-directory
1031                                           (list data-directory))
1032                                          ((boundp 'image-load-path)
1033                                           (symbol-value 'image-load-path))
1034                                          (t load-path)))
1035                   (image (gnus-splash-svg-color-symbols (find-image
1036                           `((:type svg :file "gnus.svg"
1037                                    :color-symbols
1038                                    (("#bf9900" . ,(car gnus-logo-colors))
1039                                     ("#ffcc00" . ,(cadr gnus-logo-colors))))
1040                             (:type xpm :file "gnus.xpm"
1041                                    :color-symbols
1042                                    (("thing" . ,(car gnus-logo-colors))
1043                                     ("shadow" . ,(cadr gnus-logo-colors))))
1044                             (:type png :file "gnus.png")
1045                             (:type pbm :file "gnus.pbm"
1046                                    ;; Account for the pbm's background.
1047                                    :background ,(face-foreground 'gnus-splash)
1048                                    :foreground ,(face-background 'default))
1049                             (:type xbm :file "gnus.xbm"
1050                                    ;; Account for the xbm's background.
1051                                    :background ,(face-foreground 'gnus-splash)
1052                                    :foreground ,(face-background 'default)))))))
1053              (when image
1054                (let ((size (image-size image)))
1055                  (insert-char ?\n (max 0 (round (- (window-height)
1056                                                    (or y (cdr size)) 1) 2)))
1057                  (insert-char ?\  (max 0 (round (- (window-width)
1058                                                    (or x (car size))) 2)))
1059                  (insert-image image))
1060                (goto-char (point-min))
1061                t)))
1062     (insert
1063      (format "
1064           _    ___ _             _
1065           _ ___ __ ___  __    _ ___
1066           __   _     ___    __  ___
1067               _           ___     _
1068              _  _ __             _
1069              ___   __            _
1070                    __           _
1071                     _      _   _
1072                    _      _    _
1073                       _  _    _
1074                   __  ___
1075                  _   _ _     _
1076                 _   _
1077               _    _
1078              _    _
1079             _
1080           __
1081
1082 "))
1083     ;; And then hack it.
1084     (gnus-indent-rigidly (point-min) (point-max)
1085                          (/ (max (- (window-width) (or x 46)) 0) 2))
1086     (goto-char (point-min))
1087     (forward-line 1)
1088     (let* ((pheight (count-lines (point-min) (point-max)))
1089            (wheight (window-height))
1090            (rest (- wheight pheight)))
1091       (insert (make-string (max 0 (* 2 (/ rest 3))) ?\n)))
1092     ;; Fontify some.
1093     (put-text-property (point-min) (point-max) 'face 'gnus-splash)
1094     (goto-char (point-min))
1095     (setq mode-line-buffer-identification (concat " " gnus-version))
1096     (set-buffer-modified-p t)))
1097
1098 (defun gnus-splash-svg-color-symbols (list)
1099   "Do color-symbol search-and-replace in svg file."
1100   (let ((type (plist-get (cdr list) :type))
1101         (file (plist-get (cdr list) :file))
1102         (color-symbols (plist-get (cdr list) :color-symbols)))
1103     (if (string= type "svg")
1104         (let ((data (with-temp-buffer (insert-file-contents file)
1105                                       (buffer-string))))
1106           (mapc (lambda (rule)
1107                   (setq data (replace-regexp-in-string
1108                               (concat "fill:" (car rule))
1109                               (concat "fill:" (cdr rule)) data)))
1110                 color-symbols)
1111           (cons (car list) (list :type type :data data)))
1112        list)))
1113
1114 (eval-when (load)
1115   (let ((command (format "%s" this-command)))
1116     (when (string-match "gnus" command)
1117       (if (string-match "gnus-other-frame" command)
1118           (gnus-get-buffer-create gnus-group-buffer)
1119         (gnus-splash)))))
1120
1121 ;;; Do the rest.
1122
1123 (require 'gnus-util)
1124 (require 'nnheader)
1125
1126 (defcustom gnus-parameters nil
1127   "Alist of group parameters.
1128
1129 For example:
1130    ((\"mail\\\\..*\"  (gnus-show-threads nil)
1131                   (gnus-use-scoring nil)
1132                   (gnus-summary-line-format
1133                         \"%U%R%z%I%(%[%d:%ub%-23,23f%]%) %s\\n\")
1134                   (gcc-self . t)
1135                   (display . all))
1136      (\"mail\\\\.me\" (gnus-use-scoring  t))
1137      (\"list\\\\..*\" (total-expire . t)
1138                   (broken-reply-to . t)))"
1139   :version "22.1"
1140   :group 'gnus-group-various
1141   :type '(repeat (cons regexp
1142                        (repeat sexp))))
1143
1144 (defcustom gnus-parameters-case-fold-search 'default
1145   "If it is t, ignore case of group names specified in `gnus-parameters'.
1146 If it is nil, don't ignore case.  If it is `default', which is for the
1147 backward compatibility, use the value of `case-fold-search'."
1148   :version "22.1"
1149   :group 'gnus-group-various
1150   :type '(choice :format "%{%t%}:\n %[Value Menu%] %v"
1151                  (const :tag "Use `case-fold-search'" default)
1152                  (const nil)
1153                  (const t)))
1154
1155 (defvar gnus-group-parameters-more nil)
1156
1157 (defmacro gnus-define-group-parameter (param &rest rest)
1158   "Define a group parameter PARAM.
1159 REST is a plist of following:
1160 :type               One of `bool', `list' or nil.
1161 :function           The name of the function.
1162 :function-document  The documentation of the function.
1163 :parameter-type     The type for customizing the parameter.
1164 :parameter-document The documentation for the parameter.
1165 :variable           The name of the variable.
1166 :variable-document  The documentation for the variable.
1167 :variable-group     The group for customizing the variable.
1168 :variable-type      The type for customizing the variable.
1169 :variable-default   The default value of the variable."
1170   (let* ((type (plist-get rest :type))
1171          (parameter-type (plist-get rest :parameter-type))
1172          (parameter-document (plist-get rest :parameter-document))
1173          (function (or (plist-get rest :function)
1174                        (intern (format "gnus-parameter-%s" param))))
1175          (function-document (or (plist-get rest :function-document) ""))
1176          (variable (or (plist-get rest :variable)
1177                        (intern (format "gnus-parameter-%s-alist" param))))
1178          (variable-document (or (plist-get rest :variable-document) ""))
1179          (variable-group (plist-get rest :variable-group))
1180          (variable-type (or (plist-get rest :variable-type)
1181                             `(quote (repeat
1182                                      (list (regexp :tag "Group")
1183                                            ,(car (cdr parameter-type)))))))
1184          (variable-default (plist-get rest :variable-default)))
1185     (list
1186      'progn
1187      `(defcustom ,variable ,variable-default
1188         ,variable-document
1189         :group 'gnus-group-parameter
1190         :group ',variable-group
1191         :type ,variable-type)
1192      `(setq gnus-group-parameters-more
1193             (delq (assq ',param gnus-group-parameters-more)
1194                   gnus-group-parameters-more))
1195      `(add-to-list 'gnus-group-parameters-more
1196                    (list ',param
1197                          ,parameter-type
1198                          ,parameter-document))
1199      (if (eq type 'bool)
1200          `(defun ,function (name)
1201             ,function-document
1202             (let ((params (gnus-group-find-parameter name))
1203                   val)
1204               (cond
1205                ((memq ',param params)
1206                 t)
1207                ((setq val (assq ',param params))
1208                 (cdr val))
1209                ((stringp ,variable)
1210                 (string-match ,variable name))
1211                (,variable
1212                 (let ((alist ,variable)
1213                       elem value)
1214                   (while (setq elem (pop alist))
1215                     (when (and name
1216                                (string-match (car elem) name))
1217                       (setq alist nil
1218                             value (cdr elem))))
1219                   (if (consp value) (car value) value))))))
1220        `(defun ,function (name)
1221           ,function-document
1222           (and name
1223                (or (gnus-group-find-parameter name ',param ,(and type t))
1224                    (let ((alist ,variable)
1225                          elem value)
1226                      (while (setq elem (pop alist))
1227                        (when (and name
1228                                   (string-match (car elem) name))
1229                          (setq alist nil
1230                                value (cdr elem))))
1231                      ,(if type
1232                           'value
1233                         '(if (consp value) (car value) value))))))))))
1234
1235 (defcustom gnus-home-directory "~/"
1236   "Directory variable that specifies the \"home\" directory.
1237 All other Gnus file and directory variables are initialized from this variable.
1238
1239 Note that Gnus is mostly loaded when the `.gnus.el' file is read.
1240 This means that other directory variables that are initialized
1241 from this variable won't be set properly if you set this variable
1242 in `.gnus.el'.  Set this variable in `.emacs' instead."
1243   :group 'gnus-files
1244   :type 'directory)
1245
1246 (defcustom gnus-directory (or (getenv "SAVEDIR")
1247                               (nnheader-concat gnus-home-directory "News/"))
1248   "*Directory variable from which all other Gnus file variables are derived.
1249
1250 Note that Gnus is mostly loaded when the `.gnus.el' file is read.
1251 This means that other directory variables that are initialized from
1252 this variable won't be set properly if you set this variable in `.gnus.el'.
1253 Set this variable in `.emacs' instead."
1254   :group 'gnus-files
1255   :type 'directory)
1256
1257 (defcustom gnus-default-directory nil
1258   "*Default directory for all Gnus buffers."
1259   :group 'gnus-files
1260   :type '(choice (const :tag "current" nil)
1261                  directory))
1262
1263 ;; Site dependent variables.
1264
1265 ;; Should this be obsolete?
1266 (defcustom gnus-default-nntp-server nil
1267   "The hostname of the default NNTP server.
1268 The empty string, or nil, means to use the local host.
1269 You may wish to set this on a site-wide basis.
1270
1271 If you want to change servers, you should use `gnus-select-method'."
1272   :group 'gnus-server
1273   :type '(choice (const :tag "local host" nil)
1274                  (string :tag "host name")))
1275
1276 (defcustom gnus-nntpserver-file "/etc/nntpserver"
1277   "A file with only the name of the nntp server in it."
1278   :group 'gnus-files
1279   :group 'gnus-server
1280   :type 'file)
1281
1282 (defun gnus-getenv-nntpserver ()
1283   "Find default nntp server.
1284 Check the NNTPSERVER environment variable and the
1285 `gnus-nntpserver-file' file."
1286   (or (getenv "NNTPSERVER")
1287       (and (file-readable-p gnus-nntpserver-file)
1288            (with-temp-buffer
1289              (insert-file-contents gnus-nntpserver-file)
1290              (when (re-search-forward "[^ \t\n\r]+" nil t)
1291                (match-string 0))))))
1292
1293 ;; `M-x customize-variable RET gnus-select-method RET' should work without
1294 ;; starting or even loading Gnus.
1295 ;;;###autoload(when (fboundp 'custom-autoload)
1296 ;;;###autoload  (custom-autoload 'gnus-select-method "gnus"))
1297
1298 (defcustom gnus-select-method
1299   (list 'nntp (or (gnus-getenv-nntpserver)
1300                   (when (and gnus-default-nntp-server
1301                              (not (string= gnus-default-nntp-server "")))
1302                     gnus-default-nntp-server)
1303                   "news"))
1304   "Default method for selecting a newsgroup.
1305 This variable should be a list, where the first element is how the
1306 news is to be fetched, the second is the address.
1307
1308 For instance, if you want to get your news via \"flab.flab.edu\" using
1309 NNTP, you could say:
1310
1311 \(setq gnus-select-method \\='(nntp \"flab.flab.edu\"))
1312
1313 If you want to use your local spool, say:
1314
1315 \(setq gnus-select-method (list \\='nnspool (system-name)))
1316
1317 If you use this variable, you must set `gnus-nntp-server' to nil.
1318
1319 There is a lot more to know about select methods and virtual servers -
1320 see the manual for details."
1321   ;; Emacs has set-after since 22.1.
1322   ;set-after '(gnus-default-nntp-server)
1323   :group 'gnus-server
1324   :group 'gnus-start
1325   :initialize 'custom-initialize-default
1326   :type 'gnus-select-method)
1327
1328 (defcustom gnus-message-archive-method "archive"
1329   "*Method used for archiving messages you've sent.
1330 This should be a mail method.
1331
1332 See also `gnus-update-message-archive-method'."
1333   :group 'gnus-server
1334   :group 'gnus-message
1335   :type '(choice (const :tag "Default archive method" "archive")
1336                  gnus-select-method))
1337
1338 (defcustom gnus-update-message-archive-method nil
1339   "Non-nil means always update the saved \"archive\" method.
1340
1341 The archive method is initially set according to the value of
1342 `gnus-message-archive-method' and is saved in the \"~/.newsrc.eld\" file
1343 so that it may be used as a real method of the server which is named
1344 \"archive\" ever since.  If it once has been saved, it will never be
1345 updated if the value of this variable is nil, even if you change the
1346 value of `gnus-message-archive-method' afterward.  If you want the
1347 saved \"archive\" method to be updated whenever you change the value of
1348 `gnus-message-archive-method', set this variable to a non-nil value."
1349   :version "23.1"
1350   :group 'gnus-server
1351   :group 'gnus-message
1352   :type 'boolean)
1353
1354 (defcustom gnus-message-archive-group '((format-time-string "sent.%Y-%m"))
1355   "*Name of the group in which to save the messages you've written.
1356 This can either be a string; a list of strings; or an alist
1357 of regexps/functions/forms to be evaluated to return a string (or a list
1358 of strings).  The functions are called with the name of the current
1359 group (or nil) as a parameter.
1360
1361 If you want to save your mail in one group and the news articles you
1362 write in another group, you could say something like:
1363
1364   (setq gnus-message-archive-group
1365         \\='((if (message-news-p)
1366               \"misc-news\"
1367             \"misc-mail\")))
1368
1369 Normally the group names returned by this variable should be
1370 unprefixed -- which implicitly means \"store on the archive server\".
1371 However, you may wish to store the message on some other server.  In
1372 that case, just return a fully prefixed name of the group --
1373 \"nnml+private:mail.misc\", for instance."
1374   :version "24.1"
1375   :group 'gnus-message
1376   :type '(choice (const :tag "none" nil)
1377                  (const :tag "Weekly" ((format-time-string "sent.%Yw%U")))
1378                  (const :tag "Monthly" ((format-time-string "sent.%Y-%m")))
1379                  (const :tag "Yearly" ((format-time-string "sent.%Y")))
1380                  function
1381                  sexp
1382                  string))
1383
1384 (defcustom gnus-secondary-servers nil
1385   "List of NNTP servers that the user can choose between interactively.
1386 To make Gnus query you for a server, you have to give `gnus' a
1387 non-numeric prefix - `C-u M-x gnus', in short."
1388   :group 'gnus-server
1389   :type '(repeat string))
1390 (make-obsolete-variable 'gnus-secondary-servers 'gnus-select-method "24.1")
1391
1392 (defcustom gnus-secondary-select-methods nil
1393   "A list of secondary methods that will be used for reading news.
1394 This is a list where each element is a complete select method (see
1395 `gnus-select-method').
1396
1397 If, for instance, you want to read your mail with the nnml back end,
1398 you could set this variable:
1399
1400 \(setq gnus-secondary-select-methods \\='((nnml \"\")))"
1401   :group 'gnus-server
1402   :type '(repeat gnus-select-method))
1403
1404 (defcustom gnus-local-domain nil
1405   "Local domain name without a host name.
1406 The DOMAINNAME environment variable is used instead if it is defined.
1407 If the function `system-name' returns the full Internet name, there is
1408 no need to set this variable."
1409   :group 'gnus-message
1410   :type '(choice (const :tag "default" nil)
1411                  string))
1412 (make-obsolete-variable 'gnus-local-domain nil "Emacs 24.1")
1413
1414 ;; Customization variables
1415
1416 (defcustom gnus-refer-article-method 'current
1417   "Preferred method for fetching an article by Message-ID.
1418 The value of this variable must be a valid select method as discussed
1419 in the documentation of `gnus-select-method'.
1420
1421 It can also be a list of select methods, as well as the special symbol
1422 `current', which means to use the current select method.  If it is a
1423 list, Gnus will try all the methods in the list until it finds a match."
1424   :version "24.1"
1425   :group 'gnus-server
1426   :type '(choice (const :tag "default" nil)
1427                  (const current)
1428                  (const :tag "Google" (nnweb "refer" (nnweb-type google)))
1429                  gnus-select-method
1430                  sexp
1431                  (repeat :menu-tag "Try multiple"
1432                          :tag "Multiple"
1433                          :value (current (nnweb "refer" (nnweb-type google)))
1434                          (choice :tag "Method"
1435                                  (const current)
1436                                  (const :tag "Google"
1437                                         (nnweb "refer" (nnweb-type google)))
1438                                  gnus-select-method))))
1439
1440 (defcustom gnus-use-cross-reference t
1441   "*Non-nil means that cross referenced articles will be marked as read.
1442 If nil, ignore cross references.  If t, mark articles as read in
1443 subscribed newsgroups.  If neither t nor nil, mark as read in all
1444 newsgroups."
1445   :group 'gnus-server
1446   :type '(choice (const :tag "off" nil)
1447                  (const :tag "subscribed" t)
1448                  (sexp :format "all"
1449                        :value always)))
1450
1451 (defcustom gnus-process-mark ?#
1452   "*Process mark."
1453   :group 'gnus-group-visual
1454   :group 'gnus-summary-marks
1455   :type 'character)
1456
1457 (defcustom gnus-large-newsgroup 200
1458   "*The number of articles which indicates a large newsgroup.
1459 If the number of articles in a newsgroup is greater than this value,
1460 confirmation is required for selecting the newsgroup.
1461 If it is nil, no confirmation is required.
1462
1463 Also see `gnus-large-ephemeral-newsgroup'."
1464   :group 'gnus-group-select
1465   :type '(choice (const :tag "No limit" nil)
1466                  integer))
1467
1468 (defcustom gnus-use-long-file-name (not (memq system-type '(usg-unix-v)))
1469   "Non-nil means that the default name of a file to save articles in is the group name.
1470 If it's nil, the directory form of the group name is used instead.
1471
1472 If this variable is a list, and the list contains the element
1473 `not-score', long file names will not be used for score files; if it
1474 contains the element `not-save', long file names will not be used for
1475 saving; and if it contains the element `not-kill', long file names
1476 will not be used for kill files.
1477
1478 Note that the default for this variable varies according to what system
1479 type you're using.  On `usg-unix-v' this variable defaults to nil while
1480 on all other systems it defaults to t."
1481   :group 'gnus-start
1482   :type '(radio (sexp :format "Non-nil\n"
1483                       :match (lambda (widget value)
1484                                (and value (not (listp value))))
1485                       :value t)
1486                 (const nil)
1487                 (checklist (const :format "%v " not-score)
1488                            (const :format "%v " not-save)
1489                            (const not-kill))))
1490
1491 (defcustom gnus-kill-files-directory gnus-directory
1492   "*Name of the directory where kill files will be stored (default \"~/News\")."
1493   :group 'gnus-score-files
1494   :group 'gnus-score-kill
1495   :type 'directory)
1496
1497 (defcustom gnus-save-score nil
1498   "*If non-nil, save group scoring info."
1499   :group 'gnus-score-various
1500   :group 'gnus-start
1501   :type 'boolean)
1502
1503 (defcustom gnus-use-undo t
1504   "*If non-nil, allow undoing in Gnus group mode buffers."
1505   :group 'gnus-meta
1506   :type 'boolean)
1507
1508 (defcustom gnus-use-adaptive-scoring nil
1509   "*If non-nil, use some adaptive scoring scheme.
1510 If a list, then the values `word' and `line' are meaningful.  The
1511 former will perform adaption on individual words in the subject
1512 header while `line' will perform adaption on several headers."
1513   :group 'gnus-meta
1514   :group 'gnus-score-adapt
1515   :type '(set (const word) (const line)))
1516
1517 (defcustom gnus-use-cache 'passive
1518   "*If nil, Gnus will ignore the article cache.
1519 If `passive', it will allow entering (and reading) articles
1520 explicitly entered into the cache.  If anything else, use the
1521 cache to the full extent of the law."
1522   :group 'gnus-meta
1523   :group 'gnus-cache
1524   :type '(choice (const :tag "off" nil)
1525                  (const :tag "passive" passive)
1526                  (const :tag "active" t)))
1527
1528 (defcustom gnus-use-trees nil
1529   "*If non-nil, display a thread tree buffer."
1530   :group 'gnus-meta
1531   :type 'boolean)
1532
1533 (defcustom gnus-keep-backlog 20
1534   "*If non-nil, Gnus will keep read articles for later re-retrieval.
1535 If it is a number N, then Gnus will only keep the last N articles
1536 read.  If it is neither nil nor a number, Gnus will keep all read
1537 articles.  This is not a good idea."
1538   :group 'gnus-meta
1539   :type '(choice (const :tag "off" nil)
1540                  integer
1541                  (sexp :format "all"
1542                        :value t)))
1543
1544 (defcustom gnus-suppress-duplicates nil
1545   "*If non-nil, Gnus will mark duplicate copies of the same article as read."
1546   :group 'gnus-meta
1547   :type 'boolean)
1548
1549 (defcustom gnus-use-scoring t
1550   "*If non-nil, enable scoring."
1551   :group 'gnus-meta
1552   :type 'boolean)
1553
1554 (defcustom gnus-summary-prepare-exit-hook
1555   '(gnus-summary-expire-articles)
1556   "*A hook called when preparing to exit from the summary buffer.
1557 It calls `gnus-summary-expire-articles' by default."
1558   :group 'gnus-summary-exit
1559   :type 'hook)
1560
1561 (defcustom gnus-novice-user t
1562   "*Non-nil means that you are a Usenet novice.
1563 If non-nil, verbose messages may be displayed and confirmations may be
1564 required."
1565   :group 'gnus-meta
1566   :type 'boolean)
1567
1568 (defcustom gnus-expert-user nil
1569   "*Non-nil means that you will never be asked for confirmation about anything.
1570 That doesn't mean *anything* anything; particularly destructive
1571 commands will still require prompting."
1572   :group 'gnus-meta
1573   :type 'boolean)
1574
1575 (defcustom gnus-interactive-catchup t
1576   "*If non-nil, require your confirmation when catching up a group."
1577   :group 'gnus-group-select
1578   :type 'boolean)
1579
1580 (defcustom gnus-interactive-exit t
1581   "*If non-nil, require your confirmation when exiting Gnus.
1582 If `quiet', update any active summary buffers automatically
1583 first before exiting."
1584   :group 'gnus-exit
1585   :type '(choice boolean
1586                  (const quiet)))
1587
1588 (defcustom gnus-extract-address-components 'gnus-extract-address-components
1589   "*Function for extracting address components from a From header.
1590 Two pre-defined function exist: `gnus-extract-address-components',
1591 which is the default, quite fast, and too simplistic solution, and
1592 `mail-extract-address-components', which works much better, but is
1593 slower."
1594   :group 'gnus-summary-format
1595   :type '(radio (function-item gnus-extract-address-components)
1596                 (function-item mail-extract-address-components)
1597                 (function :tag "Other")))
1598
1599 (defcustom gnus-shell-command-separator ";"
1600   "String used to separate shell commands."
1601   :group 'gnus-files
1602   :type 'string)
1603
1604 (defcustom gnus-valid-select-methods
1605   '(("nntp" post address prompt-address physical-address cloud)
1606     ("nnspool" post address)
1607     ("nnvirtual" post-mail virtual prompt-address)
1608     ("nnmbox" mail respool address)
1609     ("nnml" post-mail respool address)
1610     ("nnmh" mail respool address)
1611     ("nndir" post-mail prompt-address physical-address)
1612     ("nneething" none address prompt-address physical-address)
1613     ("nndoc" none address prompt-address)
1614     ("nnbabyl" mail address respool)
1615     ("nndraft" post-mail)
1616     ("nnfolder" mail respool address)
1617     ("nngateway" post-mail address prompt-address physical-address)
1618     ("nnweb" none)
1619     ("nnrss" none global)
1620     ("nnagent" post-mail)
1621     ("nnimap" post-mail address prompt-address physical-address respool
1622      server-marks cloud)
1623     ("nnmaildir" mail respool address server-marks)
1624     ("nnnil" none))
1625   "*An alist of valid select methods.
1626 The first element of each list lists should be a string with the name
1627 of the select method.  The other elements may be the category of
1628 this method (i. e., `post', `mail', `none' or whatever) or other
1629 properties that this method has (like being respoolable).
1630 If you implement a new select method, all you should have to change is
1631 this variable.  I think."
1632   :group 'gnus-server
1633   :type '(repeat (group (string :tag "Name")
1634                         (radio-button-choice (const :format "%v " post)
1635                                              (const :format "%v " mail)
1636                                              (const :format "%v " none)
1637                                              (const post-mail))
1638                         (checklist :inline t :greedy t
1639                                    (const :format "%v " address)
1640                                    (const global)
1641                                    (const :format "%v " prompt-address)
1642                                    (const :format "%v " physical-address)
1643                                    (const virtual)
1644                                    (const :format "%v " respool)
1645                                    (const server-marks))))
1646   :version "24.1")
1647
1648 (defun gnus-redefine-select-method-widget ()
1649   "Recomputes the select-method widget based on the value of
1650 `gnus-valid-select-methods'."
1651   (define-widget 'gnus-select-method 'list
1652     "Widget for entering a select method."
1653     :value '(nntp "")
1654     :tag "Select Method"
1655     :args `((choice :tag "Method"
1656                     ,@(mapcar (lambda (entry)
1657                                 (list 'const :format "%v\n"
1658                                       (intern (car entry))))
1659                               gnus-valid-select-methods)
1660                     (symbol :tag "other"))
1661             (string :tag "Address")
1662             (repeat :tag "Options"
1663                     :inline t
1664                     (list :format "%v"
1665                           variable
1666                           (sexp :tag "Value"))))))
1667
1668 (gnus-redefine-select-method-widget)
1669
1670 (defcustom gnus-updated-mode-lines '(group article summary tree)
1671   "List of buffers that should update their mode lines.
1672 The list may contain the symbols `group', `article', `tree' and
1673 `summary'.  If the corresponding symbol is present, Gnus will keep
1674 that mode line updated with information that may be pertinent.
1675 If this variable is nil, screen refresh may be quicker."
1676   :group 'gnus-various
1677   :type '(set (const group)
1678               (const article)
1679               (const summary)
1680               (const tree)))
1681
1682 (defcustom gnus-mode-non-string-length 30
1683   "*Max length of mode-line non-string contents.
1684 If this is nil, Gnus will take space as is needed, leaving the rest
1685 of the mode line intact."
1686   :version "24.1"
1687   :group 'gnus-various
1688   :type '(choice (const nil)
1689                  integer))
1690
1691 ;; There should be special validation for this.
1692 (define-widget 'gnus-email-address 'string
1693   "An email address.")
1694
1695 (gnus-define-group-parameter
1696  to-address
1697  :function-document
1698  "Return GROUP's to-address."
1699  :variable-document
1700  "*Alist of group regexps and correspondent to-addresses."
1701  :variable-group gnus-group-parameter
1702  :parameter-type '(gnus-email-address :tag "To Address")
1703  :parameter-document "\
1704 This will be used when doing followups and posts.
1705
1706 This is primarily useful in mail groups that represent closed
1707 mailing lists--mailing lists where it's expected that everybody that
1708 writes to the mailing list is subscribed to it.  Since using this
1709 parameter ensures that the mail only goes to the mailing list itself,
1710 it means that members won't receive two copies of your followups.
1711
1712 Using `to-address' will actually work whether the group is foreign or
1713 not.  Let's say there's a group on the server that is called
1714 `fa.4ad-l'.  This is a real newsgroup, but the server has gotten the
1715 articles from a mail-to-news gateway.  Posting directly to this group
1716 is therefore impossible--you have to send mail to the mailing list
1717 address instead.
1718
1719 The gnus-group-split mail splitting mechanism will behave as if this
1720 address was listed in gnus-group-split Addresses (see below).")
1721
1722 (gnus-define-group-parameter
1723  to-list
1724  :function-document
1725  "Return GROUP's to-list."
1726  :variable-document
1727  "*Alist of group regexps and correspondent to-lists."
1728  :variable-group gnus-group-parameter
1729  :parameter-type '(gnus-email-address :tag "To List")
1730  :parameter-document "\
1731 This address will be used when doing a `a' in the group.
1732
1733 It is totally ignored when doing a followup--except that if it is
1734 present in a news group, you'll get mail group semantics when doing
1735 `f'.
1736
1737 The gnus-group-split mail splitting mechanism will behave as if this
1738 address was listed in gnus-group-split Addresses (see below).")
1739
1740 (gnus-define-group-parameter
1741  subscribed
1742  :type bool
1743  :function-document
1744  "Return GROUP's subscription status."
1745  :variable-document
1746  "*Groups which are automatically considered subscribed."
1747  :variable-group gnus-group-parameter
1748  :parameter-type '(const :tag "Subscribed" t)
1749  :parameter-document "\
1750 Gnus assumed that you are subscribed to the To/List address.
1751
1752 When constructing a list of subscribed groups using
1753 `gnus-find-subscribed-addresses', Gnus includes the To address given
1754 above, or the list address (if the To address has not been set).")
1755
1756 (gnus-define-group-parameter
1757  auto-expire
1758  :type bool
1759  :function gnus-group-auto-expirable-p
1760  :function-document
1761  "Check whether GROUP is auto-expirable or not."
1762  :variable gnus-auto-expirable-newsgroups
1763  :variable-default nil
1764  :variable-document
1765  "*Groups in which to automatically mark read articles as expirable.
1766 If non-nil, this should be a regexp that should match all groups in
1767 which to perform auto-expiry.  This only makes sense for mail groups."
1768  :variable-group nnmail-expire
1769  :variable-type '(choice (const nil)
1770                          regexp)
1771  :parameter-type '(const :tag "Automatic Expire" t)
1772  :parameter-document
1773  "All articles that are read will be marked as expirable.")
1774
1775 (gnus-define-group-parameter
1776  total-expire
1777  :type bool
1778  :function gnus-group-total-expirable-p
1779  :function-document
1780  "Check whether GROUP is total-expirable or not."
1781  :variable gnus-total-expirable-newsgroups
1782  :variable-default nil
1783  :variable-document
1784  "*Groups in which to perform expiry of all read articles.
1785 Use with extreme caution.  All groups that match this regexp will be
1786 expiring - which means that all read articles will be deleted after
1787 \(say) one week.  (This only goes for mail groups and the like, of
1788 course.)"
1789  :variable-group nnmail-expire
1790  :variable-type '(choice (const nil)
1791                          regexp)
1792  :parameter-type '(const :tag "Total Expire" t)
1793  :parameter-document
1794  "All read articles will be put through the expiry process
1795
1796 This happens even if they are not marked as expirable.
1797 Use with caution.")
1798
1799 (gnus-define-group-parameter
1800  charset
1801  :function-document
1802  "Return the default charset of GROUP."
1803  :variable gnus-group-charset-alist
1804  :variable-default
1805  '(("\\(^\\|:\\)hk\\>\\|\\(^\\|:\\)tw\\>\\|\\<big5\\>" cn-big5)
1806    ("\\(^\\|:\\)cn\\>\\|\\<chinese\\>" cn-gb-2312)
1807    ("\\(^\\|:\\)fj\\>\\|\\(^\\|:\\)japan\\>" iso-2022-jp-2)
1808    ("\\(^\\|:\\)tnn\\>\\|\\(^\\|:\\)pin\\>\\|\\(^\\|:\\)sci.lang.japan" iso-2022-7bit)
1809    ("\\(^\\|:\\)relcom\\>" koi8-r)
1810    ("\\(^\\|:\\)fido7\\>" koi8-r)
1811    ("\\(^\\|:\\)\\(cz\\|hun\\|pl\\|sk\\|hr\\)\\>" iso-8859-2)
1812    ("\\(^\\|:\\)israel\\>" iso-8859-1)
1813    ("\\(^\\|:\\)han\\>" euc-kr)
1814    ("\\(^\\|:\\)alt.chinese.text.big5\\>" chinese-big5)
1815    ("\\(^\\|:\\)soc.culture.vietnamese\\>" vietnamese-viqr)
1816    ("\\(^\\|:\\)\\(comp\\|rec\\|alt\\|sci\\|soc\\|news\\|gnu\\|bofh\\)\\>" iso-8859-1))
1817  :variable-document
1818  "Alist of regexps (to match group names) and default charsets to be used when reading."
1819  :variable-group gnus-charset
1820  :variable-type '(repeat (list (regexp :tag "Group")
1821                                (symbol :tag "Charset")))
1822  :parameter-type '(symbol :tag "Charset")
1823  :parameter-document "\
1824 The default charset to use in the group.")
1825
1826 (gnus-define-group-parameter
1827  post-method
1828  :type list
1829  :function-document
1830  "Return a posting method for GROUP."
1831  :variable gnus-post-method-alist
1832  :variable-document
1833  "Alist of regexps (to match group names) and method to be used when
1834 posting an article."
1835  :variable-group gnus-group-foreign
1836  :parameter-type
1837  '(choice :tag "Posting Method"
1838           (const :tag "Use native server" native)
1839           (const :tag "Use current server" current)
1840           (list :convert-widget
1841                 (lambda (widget)
1842                   (list 'sexp :tag "Methods"
1843                         :value gnus-select-method))))
1844  :parameter-document
1845  "Posting method for this group.")
1846
1847 (gnus-define-group-parameter
1848  large-newsgroup-initial
1849  :type integer
1850  :function-document
1851  "Return GROUP's initial input of the number of articles."
1852  :variable-document
1853  "*Alist of group regexps and its initial input of the number of articles."
1854  :variable-group gnus-group-parameter
1855  :parameter-type '(choice :tag "Initial Input for Large Newsgroup"
1856                           (const :tag "All" nil)
1857                           (integer))
1858  :parameter-document "\
1859
1860 This number will be prompted as the initial value of the number of
1861 articles to list when the group is a large newsgroup (see
1862 `gnus-large-newsgroup').  If it is nil, the default value is the
1863 total number of articles in the group.")
1864
1865 ;; The Gnus registry's ignored groups
1866 (gnus-define-group-parameter
1867  registry-ignore
1868  :type list
1869  :function-document
1870  "Whether this group should be ignored by the registry."
1871  :variable gnus-registry-ignored-groups
1872  :variable-default (mapcar
1873                     (lambda (g) (list g t))
1874                     '("delayed$" "drafts$" "queue$" "INBOX$"
1875                       "^nnmairix:" "^nnir:" "archive"))
1876  :variable-document
1877  "*Groups in which the registry should be turned off."
1878  :variable-group gnus-registry
1879  :variable-type '(repeat
1880                   (list
1881                    (regexp :tag "Group Name Regular Expression")
1882                    (boolean :tag "Ignored")))
1883
1884  :parameter-type '(boolean :tag "Group Ignored by the Registry")
1885  :parameter-document
1886  "Whether the Gnus Registry should ignore this group.")
1887
1888 ;; group parameters for spam processing added by Ted Zlatanov <tzz@lifelogs.com>
1889 (defcustom gnus-install-group-spam-parameters t
1890   "*Disable the group parameters for spam detection.
1891 Enable if `G c' in XEmacs is giving you trouble, and make sure to submit a bug report."
1892   :version "22.1"
1893   :type 'boolean
1894   :group 'gnus-start)
1895
1896 (when gnus-install-group-spam-parameters
1897   (defvar gnus-group-spam-classification-spam t
1898     "Spam group classification (requires spam.el).
1899 This group contains spam messages.  On summary entry, unread messages
1900 will be marked as spam.  On summary exit, the specified spam
1901 processors will be invoked on spam-marked messages, then those
1902 messages will be expired, so the spam processor will only see a
1903 spam-marked message once.")
1904
1905   (defvar gnus-group-spam-classification-ham 'ask
1906     "The ham value for the spam group parameter (requires spam.el).
1907 On summary exit, the specified ham processors will be invoked on
1908 ham-marked messages.  Exercise caution, since the ham processor will
1909 see the same message more than once because there is no ham message
1910 registry.")
1911
1912   (gnus-define-group-parameter
1913    spam-contents
1914    :type list
1915    :function-document
1916    "The spam type (spam, ham, or neither) of the group."
1917    :variable gnus-spam-newsgroup-contents
1918    :variable-default nil
1919    :variable-document
1920    "*Group classification (spam, ham, or neither).  Only
1921 meaningful when spam.el is loaded.  If non-nil, this should be a
1922 list of group name regexps associated with a classification for
1923 each one.  In spam groups, new articles are marked as spam on
1924 summary entry.  There is other behavior associated with ham and
1925 no classification when spam.el is loaded - see the manual."
1926    :variable-group spam
1927    :variable-type '(repeat
1928                     (list :tag "Group contents spam/ham classification"
1929                           (regexp :tag "Group")
1930                           (choice
1931                            (variable-item gnus-group-spam-classification-spam)
1932                            (variable-item gnus-group-spam-classification-ham)
1933                            (const :tag "Unclassified" nil))))
1934
1935    :parameter-type '(list :tag "Group contents spam/ham classification"
1936                           (choice :tag "Group contents classification for spam sorting"
1937                                   (variable-item gnus-group-spam-classification-spam)
1938                                   (variable-item gnus-group-spam-classification-ham)
1939                                   (const :tag "Unclassified" nil)))
1940    :parameter-document
1941    "The spam classification (spam, ham, or neither) of this group.
1942 When a spam group is entered, all unread articles are marked as
1943 spam.  There is other behavior associated with ham and no
1944 classification when spam.el is loaded - see the manual.")
1945
1946   (gnus-define-group-parameter
1947    spam-resend-to
1948    :type list
1949    :function-document
1950    "The address to get spam resent (through spam-report-resend)."
1951    :variable gnus-spam-resend-to
1952    :variable-default nil
1953    :variable-document
1954    "The address to get spam resent (through spam-report-resend)."
1955    :variable-group spam
1956    :variable-type '(repeat
1957                     (list :tag "Group address for resending spam"
1958                           (regexp :tag "Group")
1959                           (string :tag "E-mail address for resending spam (requires the spam-use-resend exit processor)")))
1960    :parameter-type 'string :tag "E-mail address for resending spam (requires the spam-use-resend exit processor)"
1961    :parameter-document
1962    "The address to get spam resent (through spam-report-resend).")
1963
1964   (gnus-define-group-parameter
1965    ham-resend-to
1966    :type list
1967    :function-document
1968    "The address to get ham resent (through spam-report-resend)."
1969    :variable gnus-ham-resend-to
1970    :variable-default nil
1971    :variable-document
1972    "The address to get ham resent (through spam-report-resend)."
1973    :variable-group spam
1974    :variable-type '(repeat
1975                     (list :tag "Group address for resending ham"
1976                           (regexp :tag "Group")
1977                           (string :tag "E-mail address for resending ham (requires the spam-use-resend exit processor)")))
1978    :parameter-type 'string :tag "E-mail address for resending ham (requires the spam-use-resend exit processor)"
1979    :parameter-document
1980    "The address to get ham resent (through spam-report-resend).")
1981
1982   (defvar gnus-group-spam-exit-processor-ifile "ifile"
1983     "OBSOLETE: The ifile summary exit spam processor.")
1984
1985   (defvar gnus-group-spam-exit-processor-stat "stat"
1986     "OBSOLETE: The spam-stat summary exit spam processor.")
1987
1988   (defvar gnus-group-spam-exit-processor-bogofilter "bogofilter"
1989     "OBSOLETE: The Bogofilter summary exit spam processor.")
1990
1991   (defvar gnus-group-spam-exit-processor-blacklist "blacklist"
1992     "OBSOLETE: The Blacklist summary exit spam processor.")
1993
1994   (defvar gnus-group-spam-exit-processor-report-gmane "report-gmane"
1995     "OBSOLETE: The Gmane reporting summary exit spam processor.
1996 Only applicable to NNTP groups with articles from Gmane.  See spam-report.el")
1997
1998   (defvar gnus-group-spam-exit-processor-spamoracle "spamoracle-spam"
1999     "OBSOLETE: The spamoracle summary exit spam processor.")
2000
2001   (defvar gnus-group-ham-exit-processor-ifile "ifile-ham"
2002     "OBSOLETE: The ifile summary exit ham processor.
2003 Only applicable to non-spam (unclassified and ham) groups.")
2004
2005   (defvar gnus-group-ham-exit-processor-bogofilter "bogofilter-ham"
2006     "OBSOLETE: The Bogofilter summary exit ham processor.
2007 Only applicable to non-spam (unclassified and ham) groups.")
2008
2009   (defvar gnus-group-ham-exit-processor-stat "stat-ham"
2010     "OBSOLETE: The spam-stat summary exit ham processor.
2011 Only applicable to non-spam (unclassified and ham) groups.")
2012
2013   (defvar gnus-group-ham-exit-processor-whitelist "whitelist"
2014     "OBSOLETE: The whitelist summary exit ham processor.
2015 Only applicable to non-spam (unclassified and ham) groups.")
2016
2017   (defvar gnus-group-ham-exit-processor-BBDB "bbdb"
2018     "OBSOLETE: The BBDB summary exit ham processor.
2019 Only applicable to non-spam (unclassified and ham) groups.")
2020
2021   (defvar gnus-group-ham-exit-processor-copy "copy"
2022     "OBSOLETE: The ham copy exit ham processor.
2023 Only applicable to non-spam (unclassified and ham) groups.")
2024
2025   (defvar gnus-group-ham-exit-processor-spamoracle "spamoracle-ham"
2026     "OBSOLETE: The spamoracle summary exit ham processor.
2027 Only applicable to non-spam (unclassified and ham) groups.")
2028
2029   (gnus-define-group-parameter
2030    spam-process
2031    :type list
2032    :parameter-type
2033    '(choice
2034      :tag "Spam Summary Exit Processor"
2035      :value nil
2036      (list :tag "Spam Summary Exit Processor Choices"
2037            (set
2038             (const :tag "Spam: Bogofilter"    (spam spam-use-bogofilter))
2039             (const :tag "Spam: Blacklist"     (spam spam-use-blacklist))
2040             (const :tag "Spam: Bsfilter"      (spam spam-use-bsfilter))
2041             (const :tag "Spam: Gmane Report"  (spam spam-use-gmane))
2042             (const :tag "Spam: Resend Message"(spam spam-use-resend))
2043             (const :tag "Spam: ifile"         (spam spam-use-ifile))
2044             (const :tag "Spam: Spam Oracle"   (spam spam-use-spamoracle))
2045             (const :tag "Spam: Spam-stat"     (spam spam-use-stat))
2046             (const :tag "Spam: SpamAssassin"  (spam spam-use-spamassassin))
2047             (const :tag "Spam: CRM114"        (spam spam-use-crm114))
2048             (const :tag "Ham: BBDB"           (ham spam-use-BBDB))
2049             (const :tag "Ham: Bogofilter"     (ham spam-use-bogofilter))
2050             (const :tag "Ham: Bsfilter"       (ham spam-use-bsfilter))
2051             (const :tag "Ham: Copy"           (ham spam-use-ham-copy))
2052             (const :tag "Ham: Resend Message" (ham spam-use-resend))
2053             (const :tag "Ham: ifile"          (ham spam-use-ifile))
2054             (const :tag "Ham: Spam Oracle"    (ham spam-use-spamoracle))
2055             (const :tag "Ham: Spam-stat"      (ham spam-use-stat))
2056             (const :tag "Ham: SpamAssassin"   (ham spam-use-spamassassin))
2057             (const :tag "Ham: CRM114"         (ham spam-use-crm114))
2058             (const :tag "Ham: Whitelist"      (ham spam-use-whitelist))
2059             (variable-item gnus-group-spam-exit-processor-ifile)
2060             (variable-item gnus-group-spam-exit-processor-stat)
2061             (variable-item gnus-group-spam-exit-processor-bogofilter)
2062             (variable-item gnus-group-spam-exit-processor-blacklist)
2063             (variable-item gnus-group-spam-exit-processor-spamoracle)
2064             (variable-item gnus-group-spam-exit-processor-report-gmane)
2065             (variable-item gnus-group-ham-exit-processor-bogofilter)
2066             (variable-item gnus-group-ham-exit-processor-ifile)
2067             (variable-item gnus-group-ham-exit-processor-stat)
2068             (variable-item gnus-group-ham-exit-processor-whitelist)
2069             (variable-item gnus-group-ham-exit-processor-BBDB)
2070             (variable-item gnus-group-ham-exit-processor-spamoracle)
2071             (variable-item gnus-group-ham-exit-processor-copy))))
2072    :function-document
2073    "Which spam or ham processors will be applied when the summary is exited."
2074    :variable gnus-spam-process-newsgroups
2075    :variable-default nil
2076    :variable-document
2077    "*Groups in which to automatically process spam or ham articles with
2078 a backend on summary exit.  If non-nil, this should be a list of group
2079 name regexps that should match all groups in which to do automatic
2080 spam processing, associated with the appropriate processor."
2081    :variable-group spam
2082    :variable-type
2083    '(repeat :tag "Spam/Ham Processors"
2084             (list :tag "Spam Summary Exit Processor Choices"
2085                   (regexp :tag "Group Regexp")
2086                   (set
2087                    :tag "Spam/Ham Summary Exit Processor"
2088                    (const :tag "Spam: Bogofilter"    (spam spam-use-bogofilter))
2089                    (const :tag "Spam: Blacklist"     (spam spam-use-blacklist))
2090                    (const :tag "Spam: Bsfilter"      (spam spam-use-bsfilter))
2091                    (const :tag "Spam: Gmane Report"  (spam spam-use-gmane))
2092                    (const :tag "Spam: Resend Message"(spam spam-use-resend))
2093                    (const :tag "Spam: ifile"         (spam spam-use-ifile))
2094                    (const :tag "Spam: Spam-stat"     (spam spam-use-stat))
2095                    (const :tag "Spam: Spam Oracle"   (spam spam-use-spamoracle))
2096                    (const :tag "Spam: SpamAssassin"  (spam spam-use-spamassassin))
2097                    (const :tag "Spam: CRM114"        (spam spam-use-crm114))
2098                    (const :tag "Ham: BBDB"           (ham spam-use-BBDB))
2099                    (const :tag "Ham: Bogofilter"     (ham spam-use-bogofilter))
2100                    (const :tag "Ham: Bsfilter"       (ham spam-use-bsfilter))
2101                    (const :tag "Ham: Copy"           (ham spam-use-ham-copy))
2102                    (const :tag "Ham: Resend Message" (ham spam-use-resend))
2103                    (const :tag "Ham: ifile"          (ham spam-use-ifile))
2104                    (const :tag "Ham: Spam-stat"      (ham spam-use-stat))
2105                    (const :tag "Ham: Spam Oracle"    (ham spam-use-spamoracle))
2106                    (const :tag "Ham: SpamAssassin"   (ham spam-use-spamassassin))
2107                    (const :tag "Ham: CRM114"         (ham spam-use-crm114))
2108                    (const :tag "Ham: Whitelist"      (ham spam-use-whitelist))
2109                    (variable-item gnus-group-spam-exit-processor-ifile)
2110                    (variable-item gnus-group-spam-exit-processor-stat)
2111                    (variable-item gnus-group-spam-exit-processor-bogofilter)
2112                    (variable-item gnus-group-spam-exit-processor-blacklist)
2113                    (variable-item gnus-group-spam-exit-processor-spamoracle)
2114                    (variable-item gnus-group-spam-exit-processor-report-gmane)
2115                    (variable-item gnus-group-ham-exit-processor-bogofilter)
2116                    (variable-item gnus-group-ham-exit-processor-ifile)
2117                    (variable-item gnus-group-ham-exit-processor-stat)
2118                    (variable-item gnus-group-ham-exit-processor-whitelist)
2119                    (variable-item gnus-group-ham-exit-processor-BBDB)
2120                    (variable-item gnus-group-ham-exit-processor-spamoracle)
2121                    (variable-item gnus-group-ham-exit-processor-copy))))
2122
2123    :parameter-document
2124    "Which spam or ham processors will be applied when the summary is exited.")
2125
2126   (gnus-define-group-parameter
2127    spam-autodetect
2128    :type list
2129    :parameter-type
2130    '(boolean :tag "Spam autodetection")
2131    :function-document
2132    "Should spam be autodetected (with spam-split) in this group?"
2133    :variable gnus-spam-autodetect
2134    :variable-default nil
2135    :variable-document
2136    "*Groups in which spam should be autodetected when they are entered.
2137    Only unseen articles will be examined, unless
2138    spam-autodetect-recheck-messages is set."
2139    :variable-group spam
2140    :variable-type
2141    '(repeat
2142      :tag "Autodetection setting"
2143      (list
2144       (regexp :tag "Group Regexp")
2145       boolean))
2146    :parameter-document
2147    "Spam autodetection.
2148 Only unseen articles will be examined, unless
2149 spam-autodetect-recheck-messages is set.")
2150
2151   (gnus-define-group-parameter
2152    spam-autodetect-methods
2153    :type list
2154    :parameter-type
2155    '(choice :tag "Spam autodetection-specific methods"
2156      (const none)
2157      (const default)
2158      (set :tag "Use specific methods"
2159           (variable-item spam-use-blacklist)
2160           (variable-item spam-use-gmane-xref)
2161           (variable-item spam-use-regex-headers)
2162           (variable-item spam-use-regex-body)
2163           (variable-item spam-use-whitelist)
2164           (variable-item spam-use-BBDB)
2165           (variable-item spam-use-ifile)
2166           (variable-item spam-use-spamoracle)
2167           (variable-item spam-use-crm114)
2168           (variable-item spam-use-spamassassin)
2169           (variable-item spam-use-spamassassin-headers)
2170           (variable-item spam-use-bsfilter)
2171           (variable-item spam-use-bsfilter-headers)
2172           (variable-item spam-use-stat)
2173           (variable-item spam-use-blackholes)
2174           (variable-item spam-use-hashcash)
2175           (variable-item spam-use-bogofilter-headers)
2176           (variable-item spam-use-bogofilter)))
2177    :function-document
2178    "Methods to be used for autodetection in each group"
2179    :variable gnus-spam-autodetect-methods
2180    :variable-default nil
2181    :variable-document
2182    "*Methods for autodetecting spam per group.
2183 Requires the spam-autodetect parameter.  Only unseen articles
2184 will be examined, unless spam-autodetect-recheck-messages is
2185 set."
2186    :variable-group spam
2187    :variable-type
2188    '(repeat
2189      :tag "Autodetection methods"
2190      (list
2191       (regexp :tag "Group Regexp")
2192       (choice
2193        (const none)
2194        (const default)
2195        (set :tag "Use specific methods"
2196         (variable-item spam-use-blacklist)
2197         (variable-item spam-use-gmane-xref)
2198         (variable-item spam-use-regex-headers)
2199         (variable-item spam-use-regex-body)
2200         (variable-item spam-use-whitelist)
2201         (variable-item spam-use-BBDB)
2202         (variable-item spam-use-ifile)
2203         (variable-item spam-use-spamoracle)
2204         (variable-item spam-use-crm114)
2205         (variable-item spam-use-stat)
2206         (variable-item spam-use-blackholes)
2207         (variable-item spam-use-hashcash)
2208         (variable-item spam-use-spamassassin)
2209         (variable-item spam-use-spamassassin-headers)
2210         (variable-item spam-use-bsfilter)
2211         (variable-item spam-use-bsfilter-headers)
2212         (variable-item spam-use-bogofilter-headers)
2213         (variable-item spam-use-bogofilter)))))
2214      :parameter-document
2215    "Spam autodetection methods.
2216 Requires the spam-autodetect parameter.  Only unseen articles
2217 will be examined, unless spam-autodetect-recheck-messages is
2218 set.")
2219
2220   (gnus-define-group-parameter
2221    spam-process-destination
2222    :type list
2223    :parameter-type
2224    '(choice :tag "Destination for spam-processed articles at summary exit"
2225             (string :tag "Move to a group")
2226             (repeat :tag "Move to multiple groups"
2227                     (string :tag "Destination group"))
2228             (const :tag "Expire" nil))
2229    :function-document
2230    "Where spam-processed articles will go at summary exit."
2231    :variable gnus-spam-process-destinations
2232    :variable-default nil
2233    :variable-document
2234    "*Groups in which to explicitly send spam-processed articles to
2235 another group, or expire them (the default).  If non-nil, this should
2236 be a list of group name regexps that should match all groups in which
2237 to do spam-processed article moving, associated with the destination
2238 group or nil for explicit expiration.  This only makes sense for
2239 mail groups."
2240    :variable-group spam
2241    :variable-type
2242    '(repeat
2243      :tag "Spam-processed articles destination"
2244      (list
2245       (regexp :tag "Group Regexp")
2246       (choice
2247        :tag "Destination for spam-processed articles at summary exit"
2248        (string :tag "Move to a group")
2249        (repeat :tag "Move to multiple groups"
2250                (string :tag "Destination group"))
2251        (const :tag "Expire" nil))))
2252    :parameter-document
2253    "Where spam-processed articles will go at summary exit.")
2254
2255   (gnus-define-group-parameter
2256    ham-process-destination
2257    :type list
2258    :parameter-type
2259    '(choice
2260      :tag "Destination for ham articles at summary exit from a spam group"
2261      (string :tag "Move to a group")
2262      (repeat :tag "Move to multiple groups"
2263              (string :tag "Destination group"))
2264      (const :tag "Respool" respool)
2265      (const :tag "Do nothing" nil))
2266    :function-document
2267    "Where ham articles will go at summary exit from a spam group."
2268    :variable gnus-ham-process-destinations
2269    :variable-default nil
2270    :variable-document
2271    "*Groups in which to explicitly send ham articles to
2272 another group, or do nothing (the default).  If non-nil, this should
2273 be a list of group name regexps that should match all groups in which
2274 to do ham article moving, associated with the destination
2275 group or nil for explicit ignoring.  This only makes sense for
2276 mail groups, and only works in spam groups."
2277    :variable-group spam
2278    :variable-type
2279    '(repeat
2280      :tag "Ham articles destination"
2281      (list
2282       (regexp :tag "Group Regexp")
2283       (choice
2284        :tag "Destination for ham articles at summary exit from spam group"
2285        (string :tag "Move to a group")
2286        (repeat :tag "Move to multiple groups"
2287                 (string :tag "Destination group"))
2288        (const :tag "Respool" respool)
2289        (const :tag "Expire" nil))))
2290    :parameter-document
2291    "Where ham articles will go at summary exit from a spam group.")
2292
2293   (gnus-define-group-parameter
2294    ham-marks
2295    :type 'list
2296    :parameter-type '(list :tag "Ham mark choices"
2297                           (set
2298                            (variable-item gnus-del-mark)
2299                            (variable-item gnus-read-mark)
2300                            (variable-item gnus-ticked-mark)
2301                            (variable-item gnus-killed-mark)
2302                            (variable-item gnus-kill-file-mark)
2303                            (variable-item gnus-low-score-mark)))
2304
2305    :parameter-document
2306    "Marks considered ham (positively not spam).  Such articles will be
2307 processed as ham (non-spam) on group exit.  When nil, the global
2308 spam-ham-marks variable takes precedence."
2309    :variable-default '((".*" ((gnus-del-mark
2310                                gnus-read-mark
2311                                gnus-killed-mark
2312                                gnus-kill-file-mark
2313                                gnus-low-score-mark))))
2314    :variable-group spam
2315    :variable-document
2316    "*Groups in which to explicitly set the ham marks to some value.")
2317
2318   (gnus-define-group-parameter
2319    spam-marks
2320    :type 'list
2321    :parameter-type '(list :tag "Spam mark choices"
2322                           (set
2323                            (variable-item gnus-spam-mark)
2324                            (variable-item gnus-killed-mark)
2325                            (variable-item gnus-kill-file-mark)
2326                            (variable-item gnus-low-score-mark)))
2327
2328    :parameter-document
2329    "Marks considered spam.
2330 Such articles will be processed as spam on group exit.  When nil, the global
2331 spam-spam-marks variable takes precedence."
2332    :variable-default '((".*" ((gnus-spam-mark))))
2333    :variable-group spam
2334    :variable-document
2335    "*Groups in which to explicitly set the spam marks to some value."))
2336
2337 (defcustom gnus-group-uncollapsed-levels 1
2338   "Number of group name elements to leave alone when making a short group name."
2339   :group 'gnus-group-visual
2340   :type 'integer)
2341
2342 (defcustom gnus-group-use-permanent-levels nil
2343   "*If non-nil, once you set a level, Gnus will use this level."
2344   :group 'gnus-group-levels
2345   :type 'boolean)
2346
2347 ;; Hooks.
2348
2349 (defcustom gnus-load-hook nil
2350   "A hook run while Gnus is loaded."
2351   :group 'gnus-start
2352   :type 'hook)
2353
2354 (defcustom gnus-apply-kill-hook '(gnus-apply-kill-file)
2355   "A hook called to apply kill files to a group.
2356 This hook is intended to apply a kill file to the selected newsgroup.
2357 The function `gnus-apply-kill-file' is called by default.
2358
2359 Since a general kill file is too heavy to use only for a few
2360 newsgroups, I recommend you to use a lighter hook function.  For
2361 example, if you'd like to apply a kill file to articles which contains
2362 a string `rmgroup' in subject in newsgroup `control', you can use the
2363 following hook:
2364
2365  (setq gnus-apply-kill-hook
2366       (list
2367         (lambda ()
2368           (cond ((string-match \"control\" gnus-newsgroup-name)
2369                  (gnus-kill \"Subject\" \"rmgroup\")
2370                  (gnus-expunge \"X\"))))))"
2371   :group 'gnus-score-kill
2372   :options '(gnus-apply-kill-file)
2373   :type 'hook)
2374
2375 (defcustom gnus-group-change-level-function nil
2376   "Function run when a group level is changed.
2377 It is called with three parameters -- GROUP, LEVEL and OLDLEVEL."
2378   :group 'gnus-group-levels
2379   :type '(choice (const nil)
2380                  function))
2381
2382 ;;; Face thingies.
2383
2384 (defcustom gnus-visual
2385   '(summary-highlight group-highlight article-highlight
2386                       mouse-face
2387                       summary-menu group-menu article-menu
2388                       tree-highlight menu highlight
2389                       browse-menu server-menu
2390                       page-marker tree-menu binary-menu pick-menu)
2391   "*Enable visual features.
2392 If `visual' is disabled, there will be no menus and few faces.  Most of
2393 the visual customization options below will be ignored.  Gnus will use
2394 less space and be faster as a result.
2395
2396 This variable can also be a list of visual elements to switch on.  For
2397 instance, to switch off all visual things except menus, you can say:
2398
2399    (setq gnus-visual \\='(menu))
2400
2401 Valid elements include `summary-highlight', `group-highlight',
2402 `article-highlight', `mouse-face', `summary-menu', `group-menu',
2403 `article-menu', `tree-highlight', `menu', `highlight', `browse-menu',
2404 `server-menu', `page-marker', `tree-menu', `binary-menu', and`pick-menu'."
2405   :group 'gnus-meta
2406   :group 'gnus-visual
2407   :type '(set (const summary-highlight)
2408               (const group-highlight)
2409               (const article-highlight)
2410               (const mouse-face)
2411               (const summary-menu)
2412               (const group-menu)
2413               (const article-menu)
2414               (const tree-highlight)
2415               (const menu)
2416               (const highlight)
2417               (const browse-menu)
2418               (const server-menu)
2419               (const page-marker)
2420               (const tree-menu)
2421               (const binary-menu)
2422               (const pick-menu)))
2423
2424 ;; Byte-compiler warning.
2425 (defvar gnus-visual)
2426 ;; Find out whether the gnus-visual TYPE is wanted.
2427 (defun gnus-visual-p (&optional type class)
2428   (and gnus-visual                      ; Has to be non-nil, at least.
2429        (if (not type)                   ; We don't care about type.
2430            gnus-visual
2431          (if (listp gnus-visual)        ; It's a list, so we check it.
2432              (or (memq type gnus-visual)
2433                  (memq class gnus-visual))
2434            t))))
2435
2436 (defcustom gnus-mouse-face
2437   (condition-case ()
2438       (if (gnus-visual-p 'mouse-face 'highlight)
2439           (if (boundp 'gnus-mouse-face)
2440               (or gnus-mouse-face 'highlight)
2441             'highlight)
2442         'default)
2443     (error 'highlight))
2444   "*Face used for group or summary buffer mouse highlighting.
2445 The line beneath the mouse pointer will be highlighted with this
2446 face."
2447   :group 'gnus-visual
2448   :type 'face)
2449
2450 (defcustom gnus-article-save-directory gnus-directory
2451   "*Name of the directory articles will be saved in (default \"~/News\")."
2452   :group 'gnus-article-saving
2453   :type 'directory)
2454
2455 (defvar gnus-plugged t
2456   "Whether Gnus is plugged or not.")
2457
2458 (defcustom gnus-agent-cache t
2459   "Controls use of the agent cache while plugged.
2460 When set, Gnus will prefer using the locally stored content rather
2461 than re-fetching it from the server.  You also need to enable
2462 `gnus-agent' for this to have any affect."
2463   :version "22.1"
2464   :group 'gnus-agent
2465   :type 'boolean)
2466
2467 (defcustom gnus-default-charset 'undecided
2468   "Default charset assumed to be used when viewing non-ASCII characters.
2469 This variable is overridden on a group-to-group basis by the
2470 `gnus-group-charset-alist' variable and is only used on groups not
2471 covered by that variable."
2472   :type 'symbol
2473   :group 'gnus-charset)
2474
2475 ;; Fixme: Doc reference to agent.
2476 (defcustom gnus-agent t
2477   "Whether we want to use the Gnus agent or not.
2478
2479 You may customize gnus-agent to disable its use.  However, some
2480 back ends have started to use the agent as a client-side cache.
2481 Disabling the agent may result in noticeable loss of performance."
2482   :version "22.1"
2483   :group 'gnus-agent
2484   :type 'boolean)
2485
2486 (defcustom gnus-other-frame-function 'gnus
2487   "Function called by the command `gnus-other-frame' when starting Gnus."
2488   :group 'gnus-start
2489   :type '(choice (function-item gnus)
2490                  (function-item gnus-no-server)
2491                  (function-item gnus-slave)
2492                  (function-item gnus-slave-no-server)))
2493
2494 (defcustom gnus-other-frame-resume-function 'gnus-group-get-new-news
2495   "Function called by the command `gnus-other-frame' when resuming Gnus."
2496   :version "24.4"
2497   :group 'gnus-start
2498   :type '(choice (function-item gnus)
2499                  (function-item gnus-group-get-new-news)
2500                  (function-item gnus-no-server)
2501                  (function-item gnus-slave)
2502                  (function-item gnus-slave-no-server)))
2503
2504 (defcustom gnus-other-frame-parameters nil
2505   "Frame parameters used by `gnus-other-frame' to create a Gnus frame.
2506 This should be an alist for Emacs, or a plist for XEmacs."
2507   :group 'gnus-start
2508   :type (if (featurep 'xemacs)
2509             '(repeat (list :inline t :format "%v"
2510                            (symbol :tag "Property")
2511                            (sexp :tag "Value")))
2512           '(repeat (cons :format "%v"
2513                          (symbol :tag "Parameter")
2514                          (sexp :tag "Value")))))
2515
2516 (defcustom gnus-user-agent '(emacs gnus type)
2517   "Which information should be exposed in the User-Agent header.
2518
2519 Can be a list of symbols or a string.  Valid symbols are `gnus'
2520 \(show Gnus version) and `emacs' \(show Emacs version).  In
2521 addition to the Emacs version, you can add `codename' \(show
2522 \(S)XEmacs codename) or either `config' \(show system
2523 configuration) or `type' \(show system type).  If you set it to
2524 a string, be sure to use a valid format, see RFC 2616."
2525
2526   :version "22.1"
2527   :group 'gnus-message
2528   :type '(choice (list (set :inline t
2529                             (const gnus  :tag "Gnus version")
2530                             (const emacs :tag "Emacs version")
2531                             (choice :tag "system"
2532                                     (const type   :tag "system type")
2533                                     (const config :tag "system configuration"))
2534                             (const codename :tag "Emacs codename")))
2535                  (string)))
2536
2537 ;; Convert old (< 2005-01-10) symbol type values:
2538 (when (symbolp gnus-user-agent)
2539   (setq gnus-user-agent
2540         (cond ((eq gnus-user-agent 'emacs-gnus-config)
2541                '(emacs gnus config))
2542               ((eq gnus-user-agent 'emacs-gnus-type)
2543                '(emacs gnus type))
2544               ((eq gnus-user-agent 'emacs-gnus)
2545                '(emacs gnus))
2546               ((eq gnus-user-agent 'gnus)
2547                '(gnus))
2548               (t gnus-user-agent)))
2549   (gnus-message 1 "Converted `gnus-user-agent' to `%s'." gnus-user-agent)
2550   (sit-for 1)
2551   (if (get 'gnus-user-agent 'saved-value)
2552       (customize-save-variable 'gnus-user-agent gnus-user-agent)
2553     (gnus-message 1 "Edit your init file to make this change permanent.")
2554     (sit-for 2)))
2555
2556 \f
2557 ;;; Internal variables
2558
2559 (defvar gnus-agent-gcc-header "X-Gnus-Agent-Gcc")
2560 (defvar gnus-agent-meta-information-header "X-Gnus-Agent-Meta-Information")
2561 (defvar gnus-agent-method-p-cache nil
2562   ; Reset each time gnus-agent-covered-methods is changed else
2563   ; gnus-agent-method-p may mis-report a methods status.
2564   )
2565 (defvar gnus-agent-target-move-group-header "X-Gnus-Agent-Move-To")
2566 (defvar gnus-draft-meta-information-header "X-Draft-From")
2567 (defvar gnus-group-get-parameter-function 'gnus-group-get-parameter)
2568 (defvar gnus-original-article-buffer " *Original Article*")
2569 (defvar gnus-newsgroup-name nil)
2570 (defvar gnus-ephemeral-servers nil)
2571 (defvar gnus-server-method-cache nil)
2572 (defvar gnus-extended-servers nil)
2573
2574 ;; The carpal mode has been removed, but define the variable for
2575 ;; backwards compatibility.
2576 (defvar gnus-carpal nil)
2577 (make-obsolete-variable 'gnus-carpal nil "Emacs 24.1")
2578
2579 (defvar gnus-agent-fetching nil
2580   "Whether Gnus agent is in fetching mode.")
2581
2582 (defvar gnus-agent-covered-methods nil
2583   "A list of servers, NOT methods, showing which servers are covered by the agent.")
2584
2585 (defvar gnus-command-method nil
2586   "Dynamically bound variable that says what the current back end is.")
2587
2588 (defvar gnus-current-select-method nil
2589   "The current method for selecting a newsgroup.")
2590
2591 (defvar gnus-tree-buffer "*Tree*"
2592   "Buffer where Gnus thread trees are displayed.")
2593
2594 ;; Variable holding the user answers to all method prompts.
2595 (defvar gnus-method-history nil)
2596
2597 ;; Variable holding the user answers to all mail method prompts.
2598 (defvar gnus-mail-method-history nil)
2599
2600 ;; Variable holding the user answers to all group prompts.
2601 (defvar gnus-group-history nil)
2602
2603 (defvar gnus-server-alist nil
2604   "List of available servers.")
2605
2606 (defcustom gnus-cache-directory
2607   (nnheader-concat gnus-directory "cache/")
2608   "*The directory where cached articles will be stored."
2609   :group 'gnus-cache
2610   :type 'directory)
2611
2612 (defvar gnus-predefined-server-alist
2613   `(("cache"
2614      nnspool "cache"
2615      (nnspool-spool-directory ,gnus-cache-directory)
2616      (nnspool-nov-directory ,gnus-cache-directory)
2617      (nnspool-active-file
2618       ,(nnheader-concat gnus-cache-directory "active"))))
2619   "List of predefined (convenience) servers.")
2620
2621 (defconst gnus-article-mark-lists
2622   '((marked . tick) (replied . reply)
2623     (expirable . expire) (killed . killed)
2624     (bookmarks . bookmark) (dormant . dormant)
2625     (scored . score) (saved . save)
2626     (cached . cache) (downloadable . download)
2627     (unsendable . unsend) (forwarded . forward)
2628     (seen . seen) (unexist . unexist)))
2629
2630 (defconst gnus-article-special-mark-lists
2631   '((seen range)
2632     (unexist range)
2633     (killed range)
2634     (bookmark tuple)
2635     (uid tuple)
2636     (active tuple)
2637     (score tuple)))
2638
2639 ;; Propagate flags to server, with the following exceptions:
2640 ;; `seen' is private to each gnus installation
2641 ;; `cache' is a internal gnus flag for each gnus installation
2642 ;; `download' is a agent flag private to each gnus installation
2643 ;; `unsend' are for nndraft groups only
2644 ;; `score' is not a proper mark
2645 ;; `bookmark': don't propagated it, or fix the bug in update-mark.
2646 (defconst gnus-article-unpropagated-mark-lists
2647   '(seen cache download unsend score bookmark unexist)
2648   "Marks that shouldn't be propagated to back ends.
2649 Typical marks are those that make no sense in a standalone back end,
2650 such as a mark that says whether an article is stored in the cache
2651 \(which doesn't make sense in a standalone back end).")
2652
2653 (defvar gnus-headers-retrieved-by nil)
2654 (defvar gnus-article-reply nil)
2655 (defvar gnus-override-method nil)
2656 (defvar gnus-opened-servers nil)
2657
2658 (defvar gnus-current-kill-article nil)
2659
2660 (defvar gnus-have-read-active-file nil)
2661
2662 (defconst gnus-maintainer
2663   "submit@debbugs.gnu.org (The Gnus Bugfixing Girls + Boys)"
2664   "The mail address of the Gnus maintainers.")
2665
2666 (defconst gnus-bug-package
2667   "gnus"
2668   "The package to use in the bug submission.")
2669
2670 (defvar gnus-info-nodes
2671   '((gnus-group-mode "(gnus)Group Buffer")
2672     (gnus-summary-mode "(gnus)Summary Buffer")
2673     (gnus-article-mode "(gnus)Article Buffer")
2674     (gnus-server-mode "(gnus)Server Buffer")
2675     (gnus-browse-mode "(gnus)Browse Foreign Server")
2676     (gnus-tree-mode "(gnus)Tree Display"))
2677   "Alist of major modes and related Info nodes.")
2678
2679 (defvar gnus-summary-buffer "*Summary*")
2680 (defvar gnus-article-buffer "*Article*")
2681 (defvar gnus-server-buffer "*Server*")
2682
2683 (defvar gnus-slave nil
2684   "Whether this Gnus is a slave or not.")
2685
2686 (defvar gnus-batch-mode nil
2687   "Whether this Gnus is running in batch mode or not.")
2688
2689 (defvar gnus-variable-list
2690   '(gnus-newsrc-options gnus-newsrc-options-n
2691                         gnus-newsrc-last-checked-date
2692                         gnus-newsrc-alist gnus-server-alist
2693                         gnus-killed-list gnus-zombie-list
2694                         gnus-topic-topology gnus-topic-alist
2695                         gnus-cloud-sequence
2696                         gnus-cloud-covered-servers
2697                         gnus-cloud-file-timestamps)
2698   "Gnus variables saved in the quick startup file.")
2699
2700 (defvar gnus-newsrc-alist nil
2701   "Assoc list of read articles.
2702 `gnus-newsrc-hashtb' should be kept so that both hold the same information.")
2703
2704 (defvar gnus-registry-alist nil
2705   "Assoc list of registry data.
2706 gnus-registry.el will populate this if it's loaded.")
2707
2708 (defvar gnus-newsrc-hashtb nil
2709   "Hashtable of `gnus-newsrc-alist'.")
2710
2711 (defvar gnus-killed-list nil
2712   "List of killed newsgroups.")
2713
2714 (defvar gnus-killed-hashtb nil
2715   "Hash table equivalent of `gnus-killed-list'.")
2716
2717 (defvar gnus-zombie-list nil
2718   "List of almost dead newsgroups.")
2719
2720 (defvar gnus-description-hashtb nil
2721   "Descriptions of newsgroups.")
2722
2723 (defvar gnus-list-of-killed-groups nil
2724   "List of newsgroups that have recently been killed by the user.")
2725
2726 (defvar gnus-active-hashtb nil
2727   "Hashtable of active articles.")
2728
2729 (defvar gnus-moderated-hashtb nil
2730   "Hashtable of moderated newsgroups.")
2731
2732 ;; Save window configuration.
2733 (defvar gnus-prev-winconf nil)
2734
2735 (defvar gnus-reffed-article-number nil)
2736
2737 (defvar gnus-dead-summary nil)
2738
2739 (defvar gnus-invalid-group-regexp "[: `'\"/]\\|^$"
2740   "Regexp matching invalid groups.")
2741
2742 (defvar gnus-other-frame-object nil
2743   "A frame object which will be created by `gnus-other-frame'.")
2744
2745 ;;; End of variables.
2746
2747 ;; Define some autoload functions Gnus might use.
2748 (eval-and-compile
2749
2750   ;; This little mapcar goes through the list below and marks the
2751   ;; symbols in question as autoloaded functions.
2752   (mapc
2753    (lambda (package)
2754      (let ((interactive (nth 1 (memq ':interactive package))))
2755        (mapcar
2756         (lambda (function)
2757           (let (keymap)
2758             (when (consp function)
2759               (setq keymap (car (memq 'keymap function)))
2760               (setq function (car function)))
2761             (unless (fboundp function)
2762               (autoload function (car package) nil interactive keymap))))
2763         (if (eq (nth 1 package) ':interactive)
2764             (nthcdr 3 package)
2765           (cdr package)))))
2766    '(("info" :interactive t Info-goto-node)
2767      ("pp" pp-to-string)
2768      ("qp" quoted-printable-decode-region quoted-printable-decode-string)
2769      ("ps-print" ps-print-preprint)
2770      ("message" :interactive t
2771       message-send-and-exit message-yank-original)
2772      ("babel" babel-as-string)
2773      ("nnmail" nnmail-split-fancy nnmail-article-group)
2774      ("nnvirtual" nnvirtual-catchup-group nnvirtual-convert-headers)
2775      ;; This is only used in message.el, which has an autoload.
2776      ("rmailout" rmail-output)
2777      ;; Next two used in gnus-util, which has autoloads, and contrib/sendmail.
2778      ("rmail" rmail-count-new-messages rmail-show-message
2779       ;; Next two only used in gnus-util.
2780       rmail-summary-exists rmail-select-summary)
2781      ;; Only used in gnus-util, which has an autoload.
2782      ("rmailsum" rmail-update-summary)
2783      ("gnus-xmas" gnus-xmas-splash)
2784      ("score-mode" :interactive t gnus-score-mode)
2785      ("gnus-mh" gnus-summary-save-article-folder
2786       gnus-Folder-save-name gnus-folder-save-name)
2787      ("gnus-mh" :interactive t gnus-summary-save-in-folder)
2788      ("gnus-demon" gnus-demon-add-scanmail
2789       gnus-demon-add-rescan gnus-demon-add-scan-timestamps
2790       gnus-demon-add-disconnection gnus-demon-add-handler
2791       gnus-demon-remove-handler)
2792      ("gnus-demon" :interactive t
2793       gnus-demon-init gnus-demon-cancel)
2794      ("gnus-fun" gnus-convert-gray-x-face-to-xpm gnus-display-x-face-in-from
2795       gnus-convert-image-to-gray-x-face gnus-convert-face-to-png
2796       gnus-face-from-file)
2797      ("gnus-salt" gnus-highlight-selected-tree gnus-possibly-generate-tree
2798       gnus-tree-open gnus-tree-close)
2799      ("gnus-srvr" gnus-enter-server-buffer gnus-server-set-info
2800       gnus-server-server-name)
2801      ("gnus-srvr" gnus-browse-foreign-server)
2802      ("gnus-cite" :interactive t
2803       gnus-article-highlight-citation gnus-article-hide-citation-maybe
2804       gnus-article-hide-citation gnus-article-fill-cited-article
2805       gnus-article-hide-citation-in-followups
2806       gnus-article-fill-cited-long-lines)
2807      ("gnus-kill" gnus-kill gnus-apply-kill-file-internal
2808       gnus-kill-file-edit-file gnus-kill-file-raise-followups-to-author
2809       gnus-execute gnus-expunge gnus-batch-kill gnus-batch-score)
2810      ("gnus-registry" gnus-try-warping-via-registry
2811       gnus-registry-handle-action)
2812      ("gnus-cache" gnus-cache-possibly-enter-article gnus-cache-save-buffers
2813       gnus-cache-possibly-remove-articles gnus-cache-request-article
2814       gnus-cache-retrieve-headers gnus-cache-possibly-alter-active
2815       gnus-cache-enter-remove-article gnus-cached-article-p
2816       gnus-cache-open gnus-cache-close gnus-cache-update-article
2817       gnus-cache-articles-in-group)
2818      ("gnus-cache" :interactive t gnus-jog-cache gnus-cache-enter-article
2819       gnus-cache-remove-article gnus-summary-insert-cached-articles)
2820      ("gnus-score" :interactive t
2821       gnus-summary-increase-score gnus-summary-set-score
2822       gnus-summary-raise-thread gnus-summary-raise-same-subject
2823       gnus-summary-raise-score gnus-summary-raise-same-subject-and-select
2824       gnus-summary-lower-thread gnus-summary-lower-same-subject
2825       gnus-summary-lower-score gnus-summary-lower-same-subject-and-select
2826       gnus-summary-current-score gnus-score-delta-default
2827       gnus-score-flush-cache gnus-score-close
2828       gnus-possibly-score-headers gnus-score-followup-article
2829       gnus-score-followup-thread)
2830      ("gnus-score"
2831       (gnus-summary-score-map keymap) gnus-score-save gnus-score-headers
2832       gnus-current-score-file-nondirectory gnus-score-adaptive
2833       gnus-score-find-trace gnus-score-file-name)
2834      ("gnus-cus" :interactive t gnus-group-customize gnus-score-customize)
2835      ("gnus-topic" :interactive t gnus-topic-mode)
2836      ("gnus-topic" gnus-topic-remove-group gnus-topic-set-parameters
2837       gnus-subscribe-topics)
2838      ("gnus-salt" :interactive t gnus-pick-mode gnus-binary-mode)
2839      ("gnus-uu" (gnus-uu-extract-map keymap) (gnus-uu-mark-map keymap))
2840      ("gnus-uu" :interactive t
2841       gnus-uu-digest-mail-forward gnus-uu-digest-post-forward
2842       gnus-uu-mark-series gnus-uu-mark-region gnus-uu-mark-buffer
2843       gnus-uu-mark-by-regexp gnus-uu-mark-all
2844       gnus-uu-mark-sparse gnus-uu-mark-thread gnus-uu-decode-uu
2845       gnus-uu-decode-uu-and-save gnus-uu-decode-unshar
2846       gnus-uu-decode-unshar-and-save gnus-uu-decode-save
2847       gnus-uu-decode-binhex gnus-uu-decode-uu-view
2848       gnus-uu-decode-uu-and-save-view gnus-uu-decode-unshar-view
2849       gnus-uu-decode-unshar-and-save-view gnus-uu-decode-save-view
2850       gnus-uu-decode-binhex-view gnus-uu-unmark-thread
2851       gnus-uu-mark-over gnus-uu-post-news gnus-uu-invert-processable)
2852      ("gnus-uu" gnus-uu-delete-work-dir gnus-uu-unmark-thread)
2853      ("gnus-msg" (gnus-summary-send-map keymap)
2854       gnus-article-mail gnus-copy-article-buffer gnus-extended-version)
2855      ("gnus-msg" :interactive t
2856       gnus-group-post-news gnus-group-mail gnus-group-news
2857       gnus-summary-post-news gnus-summary-news-other-window
2858       gnus-summary-followup gnus-summary-followup-with-original
2859       gnus-summary-cancel-article gnus-summary-supersede-article
2860       gnus-post-news gnus-summary-reply gnus-summary-reply-with-original
2861       gnus-summary-mail-forward gnus-summary-mail-other-window
2862       gnus-summary-resend-message gnus-summary-resend-bounced-mail
2863       gnus-summary-wide-reply gnus-summary-followup-to-mail
2864       gnus-summary-followup-to-mail-with-original gnus-bug
2865       gnus-summary-wide-reply-with-original
2866       gnus-summary-post-forward gnus-summary-wide-reply-with-original
2867       gnus-summary-post-forward)
2868      ("gnus-picon" :interactive t gnus-treat-from-picon)
2869      ("smiley" :interactive t smiley-region)
2870      ("gnus-win" gnus-configure-windows gnus-add-configuration)
2871      ("gnus-sum" gnus-summary-insert-line gnus-summary-read-group
2872       gnus-list-of-unread-articles gnus-list-of-read-articles
2873       gnus-offer-save-summaries gnus-make-thread-indent-array
2874       gnus-summary-exit gnus-update-read-articles gnus-summary-last-subject
2875       gnus-summary-skip-intangible gnus-summary-article-number
2876       gnus-data-header gnus-data-find)
2877      ("gnus-group" gnus-group-insert-group-line gnus-group-quit
2878       gnus-group-list-groups gnus-group-first-unread-group
2879       gnus-group-set-mode-line gnus-group-set-info gnus-group-save-newsrc
2880       gnus-group-setup-buffer gnus-group-get-new-news
2881       gnus-group-make-help-group gnus-group-update-group
2882       gnus-group-iterate gnus-group-group-name)
2883      ("gnus-bcklg" gnus-backlog-request-article gnus-backlog-enter-article
2884       gnus-backlog-remove-article)
2885      ("gnus-art" gnus-article-read-summary-keys gnus-article-save
2886       gnus-article-prepare gnus-article-set-window-start
2887       gnus-article-next-page gnus-article-prev-page
2888       gnus-request-article-this-buffer gnus-article-mode
2889       gnus-article-setup-buffer gnus-narrow-to-page
2890       gnus-article-delete-invisible-text gnus-treat-article)
2891      ("gnus-art" :interactive t
2892       gnus-article-hide-headers gnus-article-hide-boring-headers
2893       gnus-article-treat-overstrike
2894       gnus-article-remove-cr gnus-article-remove-trailing-blank-lines
2895       gnus-article-display-x-face gnus-article-de-quoted-unreadable
2896       gnus-article-de-base64-unreadable
2897       gnus-article-decode-HZ
2898       gnus-article-wash-html
2899       gnus-article-unsplit-urls
2900       gnus-article-hide-pem gnus-article-hide-signature
2901       gnus-article-strip-leading-blank-lines gnus-article-date-local
2902       gnus-article-date-original gnus-article-date-lapsed
2903       ;;gnus-article-show-all-headers
2904       gnus-article-edit-mode gnus-article-edit-article
2905       gnus-article-edit-done gnus-article-decode-encoded-words
2906       gnus-start-date-timer gnus-stop-date-timer
2907       gnus-mime-view-all-parts)
2908      ("gnus-int" gnus-request-type)
2909      ("gnus-start" gnus-newsrc-parse-options gnus-1 gnus-no-server-1
2910       gnus-dribble-enter gnus-read-init-file gnus-dribble-touch
2911       gnus-check-reasonable-setup)
2912      ("gnus-dup" gnus-dup-suppress-articles gnus-dup-unsuppress-article
2913       gnus-dup-enter-articles)
2914      ("gnus-range" gnus-copy-sequence)
2915      ("gnus-eform" gnus-edit-form)
2916      ("gnus-logic" gnus-score-advanced)
2917      ("gnus-undo" gnus-undo-mode gnus-undo-register)
2918      ("gnus-async" gnus-async-request-fetched-article gnus-async-prefetch-next
2919       gnus-async-prefetch-article gnus-async-prefetch-remove-group
2920       gnus-async-halt-prefetch)
2921      ("gnus-agent" gnus-open-agent gnus-agent-get-function
2922       gnus-agent-save-active gnus-agent-method-p
2923       gnus-agent-get-undownloaded-list gnus-agent-fetch-session
2924       gnus-summary-set-agent-mark gnus-agent-save-group-info
2925       gnus-agent-request-article gnus-agent-retrieve-headers
2926       gnus-agent-store-article gnus-agent-group-covered-p)
2927      ("gnus-agent" :interactive t
2928       gnus-unplugged gnus-agentize gnus-agent-batch)
2929      ("gnus-vm" :interactive t gnus-summary-save-in-vm
2930       gnus-summary-save-article-vm)
2931      ("compface" uncompface)
2932      ("gnus-draft" :interactive t gnus-draft-mode gnus-group-send-queue)
2933      ("gnus-mlspl" gnus-group-split gnus-group-split-fancy)
2934      ("gnus-mlspl" :interactive t gnus-group-split-setup
2935       gnus-group-split-update)
2936      ("gnus-delay" gnus-delay-initialize))))
2937
2938 ;;; gnus-sum.el thingies
2939
2940
2941 (defcustom gnus-summary-line-format "%U%R%z%I%(%[%4L: %-23,23f%]%) %s\n"
2942   "*The format specification of the lines in the summary buffer.
2943
2944 It works along the same lines as a normal formatting string,
2945 with some simple extensions.
2946
2947 %N          Article number, left padded with spaces (string)
2948 %S          Subject (string)
2949 %s          Subject if it is at the root of a thread, and \"\"
2950             otherwise (string)
2951 %n          Name of the poster (string)
2952 %a          Extracted name of the poster (string)
2953 %A          Extracted address of the poster (string)
2954 %F          Contents of the From: header (string)
2955 %f          Contents of the From: or To: headers (string)
2956 %x          Contents of the Xref: header (string)
2957 %D          Date of the article (string)
2958 %d          Date of the article (string) in DD-MMM format
2959 %o          Date of the article (string) in YYYYMMDD`T'HHMMSS
2960             format
2961 %M          Message-id of the article (string)
2962 %r          References of the article (string)
2963 %c          Number of characters in the article (integer)
2964 %k          Pretty-printed version of the above (string)
2965             For example, \"1.2k\" or \"0.4M\".
2966 %L          Number of lines in the article (integer)
2967 %I          Indentation based on thread level (a string of
2968             spaces)
2969 %B          A complex trn-style thread tree (string)
2970             The variables `gnus-sum-thread-*' can be used for
2971             customization.
2972 %T          A string with two possible values: 80 spaces if the
2973             article is on thread level two or larger and 0 spaces
2974             on level one
2975 %R          \"A\" if this article has been replied to, \" \"
2976             otherwise (character)
2977 %U          \"Read\" status of this article.
2978             See Info node `(gnus)Marking Articles'
2979 %[          Opening bracket (character, \"[\" or \"<\")
2980 %]          Closing bracket (character, \"]\" or \">\")
2981 %>          Spaces of length thread-level (string)
2982 %<          Spaces of length (- 20 thread-level) (string)
2983 %i          Article score (number)
2984 %z          Article zcore (character)
2985 %t          Number of articles under the current thread (number).
2986 %e          Whether the thread is empty or not (character).
2987 %V          Total thread score (number).
2988 %P          The line number (number).
2989 %O          Download mark (character).
2990 %*          If present, indicates desired cursor position
2991             (instead of after first colon).
2992 %u          User defined specifier. The next character in the
2993             format string should be a letter. Gnus will call the
2994             function gnus-user-format-function-X, where X is the
2995             letter following %u. The function will be passed the
2996             current header as argument. The function should
2997             return a string, which will be inserted into the
2998             summary just like information from any other summary
2999             specifier.
3000 &user-date; Age sensitive date format. Various date format is
3001             defined in `gnus-user-date-format-alist'.
3002
3003
3004 The %U (status), %R (replied) and %z (zcore) specs have to be handled
3005 with care.  For reasons of efficiency, Gnus will compute what column
3006 these characters will end up in, and \"hard-code\" that.  This means that
3007 it is invalid to have these specs after a variable-length spec.  Well,
3008 you might not be arrested, but your summary buffer will look strange,
3009 which is bad enough.
3010
3011 The smart choice is to have these specs as far to the left as
3012 possible.
3013
3014 This restriction may disappear in later versions of Gnus.
3015
3016 General format specifiers can also be used.
3017 See Info node `(gnus)Formatting Variables'."
3018   :link '(custom-manual "(gnus)Formatting Variables")
3019   :type 'string
3020   :group 'gnus-summary-format)
3021
3022 ;;;
3023 ;;; Skeleton keymaps
3024 ;;;
3025
3026 (defun gnus-suppress-keymap (keymap)
3027   (suppress-keymap keymap)
3028   (let ((keys `([delete] "\177" "\M-u"))) ;gnus-mouse-2
3029     (while keys
3030       (define-key keymap (pop keys) 'undefined))))
3031
3032 (defvar gnus-article-mode-map
3033   (let ((keymap (make-sparse-keymap)))
3034     (gnus-suppress-keymap keymap)
3035     keymap))
3036 (defvar gnus-summary-mode-map
3037   (let ((keymap (make-keymap)))
3038     (gnus-suppress-keymap keymap)
3039     keymap))
3040 (defvar gnus-group-mode-map
3041   (let ((keymap (make-keymap)))
3042     (gnus-suppress-keymap keymap)
3043     keymap))
3044
3045 \f
3046
3047 ;; Fix by Hallvard B Furuseth <h.b.furuseth@usit.uio.no>.
3048 ;; If you want the cursor to go somewhere else, set these two
3049 ;; functions in some startup hook to whatever you want.
3050 (defalias 'gnus-summary-position-point 'gnus-goto-colon)
3051 (defalias 'gnus-group-position-point 'gnus-goto-colon)
3052
3053 ;;; Various macros and substs.
3054
3055 (defun gnus-header-from (header)
3056   (mail-header-from header))
3057
3058 (defmacro gnus-gethash (string hashtable)
3059   "Get hash value of STRING in HASHTABLE."
3060   `(symbol-value (intern-soft ,string ,hashtable)))
3061
3062 (defmacro gnus-gethash-safe (string hashtable)
3063   "Get hash value of STRING in HASHTABLE.
3064 Return nil if not defined."
3065   `(let ((sym (intern-soft ,string ,hashtable)))
3066      (and (boundp sym) (symbol-value sym))))
3067
3068 (defmacro gnus-sethash (string value hashtable)
3069   "Set hash value.  Arguments are STRING, VALUE, and HASHTABLE."
3070   `(set (intern ,string ,hashtable) ,value))
3071 (put 'gnus-sethash 'edebug-form-spec '(form form form))
3072
3073 (defmacro gnus-group-unread (group)
3074   "Get the currently computed number of unread articles in GROUP."
3075   `(car (gnus-gethash ,group gnus-newsrc-hashtb)))
3076
3077 (defmacro gnus-group-entry (group)
3078   "Get the newsrc entry for GROUP."
3079   `(gnus-gethash ,group gnus-newsrc-hashtb))
3080
3081 (defmacro gnus-active (group)
3082   "Get active info on GROUP."
3083   `(gnus-gethash ,group gnus-active-hashtb))
3084
3085 (defmacro gnus-set-active (group active)
3086   "Set GROUP's active info."
3087   `(gnus-sethash ,group ,active gnus-active-hashtb))
3088
3089 ;; Info access macros.
3090
3091 (defmacro gnus-info-group (info)
3092   `(nth 0 ,info))
3093 (defmacro gnus-info-rank (info)
3094   `(nth 1 ,info))
3095 (defmacro gnus-info-read (info)
3096   `(nth 2 ,info))
3097 (defmacro gnus-info-marks (info)
3098   `(nth 3 ,info))
3099 (defmacro gnus-info-method (info)
3100   `(nth 4 ,info))
3101 (defmacro gnus-info-params (info)
3102   `(nth 5 ,info))
3103
3104 (defmacro gnus-info-level (info)
3105   `(let ((rank (gnus-info-rank ,info)))
3106      (if (consp rank)
3107          (car rank)
3108        rank)))
3109 (defmacro gnus-info-score (info)
3110   `(let ((rank (gnus-info-rank ,info)))
3111      (or (and (consp rank) (cdr rank)) 0)))
3112
3113 (defmacro gnus-info-set-group (info group)
3114   `(setcar ,info ,group))
3115 (defmacro gnus-info-set-rank (info rank)
3116   `(setcar (nthcdr 1 ,info) ,rank))
3117 (defmacro gnus-info-set-read (info read)
3118   `(setcar (nthcdr 2 ,info) ,read))
3119 (defmacro gnus-info-set-marks (info marks &optional extend)
3120   (if extend
3121       `(gnus-info-set-entry ,info ,marks 3)
3122     `(setcar (nthcdr 3 ,info) ,marks)))
3123 (defmacro gnus-info-set-method (info method &optional extend)
3124   (if extend
3125       `(gnus-info-set-entry ,info ,method 4)
3126     `(setcar (nthcdr 4 ,info) ,method)))
3127 (defmacro gnus-info-set-params (info params &optional extend)
3128   (if extend
3129       `(gnus-info-set-entry ,info ,params 5)
3130     `(setcar (nthcdr 5 ,info) ,params)))
3131
3132 (defun gnus-info-set-entry (info entry number)
3133   ;; Extend the info until we have enough elements.
3134   (while (<= (length info) number)
3135     (nconc info (list nil)))
3136   ;; Set the entry.
3137   (setcar (nthcdr number info) entry))
3138
3139 (defmacro gnus-info-set-level (info level)
3140   `(let ((rank (cdr ,info)))
3141      (if (consp (car rank))
3142          (setcar (car rank) ,level)
3143        (setcar rank ,level))))
3144 (defmacro gnus-info-set-score (info score)
3145   `(let ((rank (cdr ,info)))
3146      (if (consp (car rank))
3147          (setcdr (car rank) ,score)
3148        (setcar rank (cons (car rank) ,score)))))
3149
3150 (defmacro gnus-get-info (group)
3151   `(nth 2 (gnus-gethash ,group gnus-newsrc-hashtb)))
3152
3153 (defun gnus-set-info (group info)
3154   (setcar (nthcdr 2 (gnus-gethash group gnus-newsrc-hashtb))
3155           info))
3156
3157 ;;; Load the compatibility functions.
3158
3159 (require 'gnus-ems)
3160
3161 \f
3162 ;;;
3163 ;;; Shutdown
3164 ;;;
3165
3166 (defvar gnus-shutdown-alist nil)
3167
3168 (defun gnus-add-shutdown (function &rest symbols)
3169   "Run FUNCTION whenever one of SYMBOLS is shut down."
3170   (push (cons function symbols) gnus-shutdown-alist))
3171
3172 (defun gnus-shutdown (symbol)
3173   "Shut down everything that waits for SYMBOL."
3174   (dolist (entry gnus-shutdown-alist)
3175     (when (memq symbol (cdr entry))
3176       (funcall (car entry)))))
3177
3178 \f
3179 ;;;
3180 ;;; Gnus Utility Functions
3181 ;;;
3182
3183 (defun gnus-find-subscribed-addresses ()
3184   "Return a regexp matching the addresses of all subscribed mail groups.
3185 It consists of the `to-address' or `to-list' parameter of all groups
3186 with a `subscribed' parameter."
3187   (let (group address addresses)
3188     (dolist (entry (cdr gnus-newsrc-alist))
3189       (setq group (car entry))
3190       (when (gnus-parameter-subscribed group)
3191         (setq address (mail-strip-quoted-names
3192                        (or (gnus-group-fast-parameter group 'to-address)
3193                            (gnus-group-fast-parameter group 'to-list))))
3194         (when address
3195           (add-to-list 'addresses address))))
3196     (when addresses
3197       (list (mapconcat 'regexp-quote addresses "\\|")))))
3198
3199 (defmacro gnus-string-or (&rest strings)
3200   "Return the first element of STRINGS that is a non-blank string.
3201 STRINGS will be evaluated in normal `or' order."
3202   `(gnus-string-or-1 (list ,@strings)))
3203
3204 (defun gnus-string-or-1 (strings)
3205   (let (string)
3206     (while strings
3207       (setq string (pop strings))
3208       (if (string-match "^[ \t]*$" string)
3209           (setq string nil)
3210         (setq strings nil)))
3211     string))
3212
3213 (defun gnus-version (&optional arg)
3214   "Version number of this version of Gnus.
3215 If ARG, insert string at point."
3216   (interactive "P")
3217   (if arg
3218       (insert (message gnus-version))
3219     (message gnus-version)))
3220
3221 (defun gnus-continuum-version (&optional version)
3222   "Return VERSION as a floating point number."
3223   (unless version
3224     (setq version gnus-version))
3225   (when (or (string-match "^\\([^ ]+\\)? ?Gnus v?\\([0-9.]+\\)$" version)
3226             (string-match "^\\(.?\\)gnus-\\([0-9.]+\\)$" version))
3227     (let ((alpha (and (match-beginning 1) (match-string 1 version)))
3228           (number (match-string 2 version))
3229           major minor least)
3230       (unless (string-match
3231                "\\([0-9]\\)\\.\\([0-9]+\\)\\.?\\([0-9]+\\)?" number)
3232         (error "Invalid version string: %s" version))
3233       (setq major (string-to-number (match-string 1 number))
3234             minor (string-to-number (match-string 2 number))
3235             least (if (match-beginning 3)
3236                       (string-to-number (match-string 3 number))
3237                     0))
3238       (string-to-number
3239        (if (zerop major)
3240              (format "%1.2f00%02d%02d"
3241                      (if (member alpha '("(ding)" "d"))
3242                          4.99
3243                        (+ 5 (* 0.02
3244                                (abs
3245                                 (- (mm-char-int (aref (downcase alpha) 0))
3246                                    (mm-char-int ?t))))
3247                           -0.01))
3248                      minor least)
3249          (format "%d.%02d%02d" major minor least))))))
3250
3251 (defun gnus-info-find-node (&optional nodename)
3252   "Find Info documentation of Gnus."
3253   (interactive)
3254   ;; Enlarge info window if needed.
3255   (let (gnus-info-buffer)
3256     (Info-goto-node (or nodename (cadr (assq major-mode gnus-info-nodes))))
3257     (setq gnus-info-buffer (current-buffer))
3258     (gnus-configure-windows 'info)))
3259
3260 ;;;
3261 ;;; gnus-interactive
3262 ;;;
3263
3264 (defvar gnus-current-prefix-symbol nil
3265   "Current prefix symbol.")
3266
3267 (defvar gnus-current-prefix-symbols nil
3268   "List of current prefix symbols.")
3269
3270 (defun gnus-interactive (string &optional params)
3271   "Return a list that can be fed to `interactive'.
3272 See `interactive' for full documentation.
3273
3274 Adds the following specs:
3275
3276 y -- The current symbolic prefix.
3277 Y -- A list of the current symbolic prefix(es).
3278 A -- Article number.
3279 H -- Article header.
3280 g -- Group name."
3281   (let ((i 0)
3282         out c prompt)
3283     (while (< i (length string))
3284       (string-match ".\\([^\n]*\\)\n?" string i)
3285       (setq c (aref string i))
3286       (when (match-end 1)
3287         (setq prompt (match-string 1 string)))
3288       (setq i (match-end 0))
3289       ;; We basically emulate just about everything that
3290       ;; `interactive' does, but add the specs listed above.
3291       (push
3292        (cond
3293         ((= c ?a)
3294          (completing-read prompt obarray 'fboundp t))
3295         ((= c ?b)
3296          (read-buffer prompt (current-buffer) t))
3297         ((= c ?B)
3298          (read-buffer prompt (other-buffer (current-buffer))))
3299         ((= c ?c)
3300          (read-char))
3301         ((= c ?C)
3302          (completing-read prompt obarray 'commandp t))
3303         ((= c ?d)
3304          (point))
3305         ((= c ?D)
3306          (read-directory-name prompt nil default-directory 'lambda))
3307         ((= c ?f)
3308          (read-file-name prompt nil nil 'lambda))
3309         ((= c ?F)
3310          (read-file-name prompt))
3311         ((= c ?k)
3312          (read-key-sequence prompt))
3313         ((= c ?K)
3314          (error "Not implemented spec"))
3315         ((= c ?e)
3316          (error "Not implemented spec"))
3317         ((= c ?m)
3318          (mark))
3319         ((= c ?N)
3320          (error "Not implemented spec"))
3321         ((= c ?n)
3322          (string-to-number (read-from-minibuffer prompt)))
3323         ((= c ?p)
3324          (prefix-numeric-value current-prefix-arg))
3325         ((= c ?P)
3326          current-prefix-arg)
3327         ((= c ?r)
3328          'gnus-prefix-nil)
3329         ((= c ?s)
3330          (read-string prompt))
3331         ((= c ?S)
3332          (intern (read-string prompt)))
3333         ((= c ?v)
3334          (read-variable prompt))
3335         ((= c ?x)
3336          (read-minibuffer prompt))
3337         ((= c ?x)
3338          (eval-minibuffer prompt))
3339         ;; And here the new specs come.
3340         ((= c ?y)
3341          gnus-current-prefix-symbol)
3342         ((= c ?Y)
3343          gnus-current-prefix-symbols)
3344         ((= c ?g)
3345          (gnus-group-group-name))
3346         ((= c ?A)
3347          (gnus-summary-skip-intangible)
3348          (or (get-text-property (point) 'gnus-number)
3349              (gnus-summary-last-subject)))
3350         ((= c ?H)
3351          (gnus-data-header (gnus-data-find (gnus-summary-article-number))))
3352         (t
3353          (error "Non-implemented spec")))
3354        out)
3355       (cond
3356        ((= c ?r)
3357         (push (if (< (point) (mark)) (point) (mark)) out)
3358         (push (if (> (point) (mark)) (point) (mark)) out))))
3359     (setq out (delq 'gnus-prefix-nil out))
3360     (nreverse out)))
3361
3362 (defun gnus-symbolic-argument (&optional arg)
3363   "Read a symbolic argument and a command, and then execute command."
3364   (interactive "P")
3365   (let* ((in-command (this-command-keys))
3366          (command in-command)
3367          gnus-current-prefix-symbols
3368          gnus-current-prefix-symbol
3369          syms)
3370     (while (equal in-command command)
3371       (message "%s-" (key-description (this-command-keys)))
3372       (push (intern (char-to-string (read-char))) syms)
3373       (setq command (read-key-sequence nil t)))
3374     (setq gnus-current-prefix-symbols (nreverse syms)
3375           gnus-current-prefix-symbol (car gnus-current-prefix-symbols))
3376     (call-interactively (key-binding command t))))
3377
3378 ;;; More various functions.
3379
3380 (defsubst gnus-check-backend-function (func group)
3381   "Check whether GROUP supports function FUNC.
3382 GROUP can either be a string (a group name) or a select method."
3383   (ignore-errors
3384     (let ((method (if (stringp group)
3385                       (car (gnus-find-method-for-group group))
3386                     group)))
3387       (unless (featurep method)
3388         (require method))
3389       (fboundp (intern (format "%s-%s" method func))))))
3390
3391 (defun gnus-group-read-only-p (&optional group)
3392   "Check whether GROUP supports editing or not.
3393 If GROUP is nil, `gnus-newsgroup-name' will be checked instead.  Note
3394 that that variable is buffer-local to the summary buffers."
3395   (let ((group (or group gnus-newsgroup-name)))
3396     (not (gnus-check-backend-function 'request-replace-article group))))
3397
3398 (defun gnus-virtual-group-p (group)
3399   "Say whether GROUP is virtual or not."
3400   (memq 'virtual (assoc (symbol-name (car (gnus-find-method-for-group group)))
3401                         gnus-valid-select-methods)))
3402
3403 (defun gnus-news-group-p (group &optional article)
3404   "Return non-nil if GROUP (and ARTICLE) come from a news server."
3405   (cond ((gnus-member-of-valid 'post group) ;Ordinary news group
3406          t)                                 ;is news of course.
3407         ((not (gnus-member-of-valid 'post-mail group)) ;Non-combined.
3408          nil)                           ;must be mail then.
3409         ((vectorp article)              ;Has header info.
3410          (eq (gnus-request-type group (mail-header-id article)) 'news))
3411         ((null article)                        ;Hasn't header info
3412          (eq (gnus-request-type group) 'news)) ;(unknown ==> mail)
3413         ((< article 0)                         ;Virtual message
3414          nil)                           ;we don't know, guess mail.
3415         (t                              ;Has positive number
3416          (eq (gnus-request-type group article) 'news)))) ;use it.
3417
3418 ;; Check whether to use long file names.
3419 (defun gnus-use-long-file-name (symbol)
3420   ;; The variable has to be set...
3421   (and gnus-use-long-file-name
3422        ;; If it isn't a list, then we return t.
3423        (or (not (listp gnus-use-long-file-name))
3424            ;; If it is a list, and the list contains `symbol', we
3425            ;; return nil.
3426            (not (memq symbol gnus-use-long-file-name)))))
3427
3428 ;; Generate a unique new group name.
3429 (defun gnus-generate-new-group-name (leaf)
3430   (let ((name leaf)
3431         (num 0))
3432     (while (gnus-group-entry name)
3433       (setq name (concat leaf "<" (int-to-string (setq num (1+ num))) ">")))
3434     name))
3435
3436 (defun gnus-ephemeral-group-p (group)
3437   "Say whether GROUP is ephemeral or not."
3438   (gnus-group-get-parameter group 'quit-config t))
3439
3440 (defun gnus-group-quit-config (group)
3441   "Return the quit-config of GROUP."
3442   (gnus-group-get-parameter group 'quit-config t))
3443
3444 (defun gnus-kill-ephemeral-group (group)
3445   "Remove ephemeral GROUP from relevant structures."
3446   (gnus-sethash group nil gnus-newsrc-hashtb))
3447
3448 (defun gnus-simplify-mode-line ()
3449   "Make mode lines a bit simpler."
3450   (setq mode-line-modified (cdr gnus-mode-line-modified))
3451   (when (listp mode-line-format)
3452     (make-local-variable 'mode-line-format)
3453     (setq mode-line-format (copy-sequence mode-line-format))
3454     (when (equal (nth 3 mode-line-format) "   ")
3455       (setcar (nthcdr 3 mode-line-format) " "))))
3456
3457 ;;; Servers and groups.
3458
3459 (defsubst gnus-server-add-address (method)
3460   (let ((method-name (symbol-name (car method))))
3461     (if (and (memq 'address (assoc method-name gnus-valid-select-methods))
3462              (not (assq (intern (concat method-name "-address")) method))
3463              (memq 'physical-address (assq (car method)
3464                                            gnus-valid-select-methods)))
3465         (append method (list (list (intern (concat method-name "-address"))
3466                                    (nth 1 method))))
3467       method)))
3468
3469 (defsubst gnus-method-to-server (method &optional nocache no-enter-cache)
3470   (catch 'server-name
3471     (setq method (or method gnus-select-method))
3472
3473     ;; Perhaps it is already in the cache.
3474     (unless nocache
3475       (mapc (lambda (name-method)
3476               (if (equal (cdr name-method) method)
3477                   (throw 'server-name (car name-method))))
3478             gnus-server-method-cache))
3479
3480     (mapc
3481      (lambda (server-alist)
3482        (mapc (lambda (name-method)
3483                (when (gnus-methods-equal-p (cdr name-method) method)
3484                  (unless (member name-method gnus-server-method-cache)
3485                    (push name-method gnus-server-method-cache))
3486                  (throw 'server-name (car name-method))))
3487              server-alist))
3488      (list gnus-server-alist
3489            gnus-predefined-server-alist))
3490
3491     (let* ((name (if (member (cadr method) '(nil ""))
3492                      (format "%s" (car method))
3493                    (format "%s:%s" (car method) (cadr method))))
3494            (name-method (cons name method)))
3495       (when (and (not (member name-method gnus-server-method-cache))
3496                  (not no-enter-cache)
3497                  (not (assoc (car name-method) gnus-server-method-cache)))
3498         (push name-method gnus-server-method-cache))
3499       name)))
3500
3501 (defsubst gnus-server-to-method (server)
3502   "Map virtual server names to select methods."
3503   (or (and server (listp server) server)
3504       (cdr (assoc server gnus-server-method-cache))
3505       (let ((result
3506              (or
3507               ;; Perhaps this is the native server?
3508               (and (equal server "native") gnus-select-method)
3509               ;; It should be in the server alist.
3510               (cdr (assoc server gnus-server-alist))
3511               ;; It could be in the predefined server alist.
3512               (cdr (assoc server gnus-predefined-server-alist))
3513               ;; If not, we look through all the opened server
3514               ;; to see whether we can find it there.
3515               (let ((opened gnus-opened-servers))
3516                 (while (and opened
3517                             (not (equal server (format "%s:%s" (caaar opened)
3518                                                        (cadaar opened)))))
3519                   (pop opened))
3520                 (caar opened))
3521               ;; It could be a named method, search all servers
3522               (let ((servers gnus-secondary-select-methods))
3523                 (while (and servers
3524                             (not (equal server (format "%s:%s" (caar servers)
3525                                                        (cadar servers)))))
3526                   (pop servers))
3527                 (car servers))
3528               ;; This could be some sort of foreign server that I
3529               ;; simply haven't opened (yet).  Do a brute-force scan
3530               ;; of the entire gnus-newsrc-alist for the server name
3531               ;; of every method.  As a side-effect, loads the
3532               ;; gnus-server-method-cache so this only happens once,
3533               ;; if at all.
3534               (let ((alist (cdr gnus-newsrc-alist))
3535                     method match)
3536                 (while alist
3537                   (setq method (gnus-info-method (pop alist)))
3538                   (when (and (not (stringp method))
3539                              (equal server
3540                                     (gnus-method-to-server method nil t)))
3541                     (setq match method
3542                           alist nil)))
3543                 match))))
3544         (when (and result
3545                    (not (assoc server gnus-server-method-cache)))
3546           (push (cons server result) gnus-server-method-cache))
3547         result)))
3548
3549 (defsubst gnus-server-get-method (group method)
3550   ;; Input either a server name, and extended server name, or a
3551   ;; select method, and return a select method.
3552   (cond ((stringp method)
3553          (gnus-server-to-method method))
3554         ((equal method gnus-select-method)
3555          gnus-select-method)
3556         ((and (stringp (car method))
3557               group)
3558          (gnus-server-extend-method group method))
3559         ((and method
3560               (not group)
3561               (equal (cadr method) ""))
3562          method)
3563         (t
3564          (gnus-server-add-address method))))
3565
3566 (defmacro gnus-method-equal (ss1 ss2)
3567   "Say whether two servers are equal."
3568   `(let ((s1 ,ss1)
3569          (s2 ,ss2))
3570      (or (equal s1 s2)
3571          (and (= (length s1) (length s2))
3572               (progn
3573                 (while (and s1 (member (car s1) s2))
3574                   (setq s1 (cdr s1)))
3575                 (null s1))))))
3576
3577 (defun gnus-methods-equal-p (m1 m2)
3578   (let ((m1 (or m1 gnus-select-method))
3579         (m2 (or m2 gnus-select-method)))
3580     (or (equal m1 m2)
3581         (and (eq (car m1) (car m2))
3582              (or (not (memq 'address (assoc (symbol-name (car m1))
3583                                             gnus-valid-select-methods)))
3584                  (equal (nth 1 m1) (nth 1 m2)))))))
3585
3586 (defsubst gnus-sloppily-equal-method-parameters (m1 m2)
3587   ;; Check parameters for sloppy equality.
3588   (let ((p1 (copy-sequence (cddr m1)))
3589         (p2 (copy-sequence (cddr m2)))
3590         e1 e2)
3591     (block nil
3592       (while (setq e1 (pop p1))
3593         (unless (setq e2 (assq (car e1) p2))
3594           ;; The parameter doesn't exist in p2.
3595           (return nil))
3596         (setq p2 (delq e2 p2))
3597         (unless (equal e1 e2)
3598           (if (not (and (stringp (cadr e1))
3599                         (stringp (cadr e2))))
3600               (return nil)
3601             ;; Special-case string parameter comparison so that we
3602             ;; can uniquify them.
3603             (let ((s1 (cadr e1))
3604                   (s2 (cadr e2)))
3605               (when (string-match "/$" s1)
3606                 (setq s1 (directory-file-name s1)))
3607               (when (string-match "/$" s2)
3608                 (setq s2 (directory-file-name s2)))
3609               (unless (equal s1 s2)
3610                 (return nil))))))
3611       ;; If p2 now is empty, they were equal.
3612       (null p2))))
3613
3614 (defun gnus-method-ephemeral-p (method)
3615   (let ((equal nil))
3616     (dolist (ephemeral gnus-ephemeral-servers)
3617       (when (gnus-sloppily-equal-method-parameters method ephemeral)
3618         (setq equal t)))
3619     equal))
3620
3621 (defun gnus-methods-sloppily-equal (m1 m2)
3622   ;; Same method.
3623   (or
3624    (eq m1 m2)
3625    ;; Type and name are equal.
3626    (and
3627     (eq (car m1) (car m2))
3628     (equal (cadr m1) (cadr m2))
3629     (gnus-sloppily-equal-method-parameters m1 m2))))
3630
3631 (defun gnus-server-equal (m1 m2)
3632   "Say whether two methods are equal."
3633   (let ((m1 (cond ((null m1) gnus-select-method)
3634                   ((stringp m1) (gnus-server-to-method m1))
3635                   (t m1)))
3636         (m2 (cond ((null m2) gnus-select-method)
3637                   ((stringp m2) (gnus-server-to-method m2))
3638                   (t m2))))
3639     (gnus-method-equal m1 m2)))
3640
3641 (defun gnus-servers-using-backend (backend)
3642   "Return a list of known servers using BACKEND."
3643   (let ((opened gnus-opened-servers)
3644         out)
3645     (while opened
3646       (when (eq backend (caaar opened))
3647         (push (caar opened) out))
3648       (pop opened))
3649     out))
3650
3651 (defun gnus-archive-server-wanted-p ()
3652   "Say whether the user wants to use the archive server."
3653   (cond
3654    ((or (not gnus-message-archive-method)
3655         (not gnus-message-archive-group))
3656     nil)
3657    ((and gnus-message-archive-method gnus-message-archive-group)
3658     t)
3659    (t
3660     (let ((active (cadr (assq 'nnfolder-active-file
3661                               gnus-message-archive-method))))
3662       (and active
3663            (file-exists-p active))))))
3664
3665 (defsubst gnus-method-to-server-name (method)
3666   (concat
3667    (format "%s" (car method))
3668    (when (and
3669           (or (assoc (format "%s" (car method))
3670                      (gnus-methods-using 'address))
3671               (gnus-server-equal method gnus-message-archive-method))
3672           (nth 1 method)
3673           (not (string= (nth 1 method) "")))
3674      (concat "+" (nth 1 method)))))
3675
3676 (defsubst gnus-method-to-full-server-name (method)
3677   (format "%s+%s" (car method) (nth 1 method)))
3678
3679 (defun gnus-group-prefixed-name (group method &optional full)
3680   "Return the whole name from GROUP and METHOD.
3681 Call with full set to get the fully qualified group name (even if the
3682 server is native)."
3683   (when (stringp method)
3684     (setq method (gnus-server-to-method method)))
3685   (if (or (not method)
3686           (and (not full) (gnus-server-equal method "native"))
3687           ;;;!!! This might not be right.  We'll see...
3688           ;(string-match ":" group)
3689           )
3690       group
3691     (concat (gnus-method-to-server-name method) ":" group)))
3692
3693 (defun gnus-group-full-name (group method)
3694   "Return the full name from GROUP and METHOD, even if the method is native."
3695   (gnus-group-prefixed-name group method t))
3696
3697 (defun gnus-group-guess-full-name-from-command-method (group)
3698   "Guess the full name from GROUP, even if the method is native."
3699   (if (gnus-group-prefixed-p group)
3700       group
3701     (gnus-group-full-name group gnus-command-method)))
3702
3703 (defun gnus-group-real-prefix (group)
3704   "Return the prefix of the current group name."
3705   (if (stringp group)
3706       (if (string-match "^[^:]+:" group)
3707           (substring group 0 (match-end 0))
3708         "")
3709     nil))
3710
3711 (defun gnus-group-short-name (group)
3712   "Return the short group name."
3713   (let ((prefix (gnus-group-real-prefix group)))
3714     (if (< 0 (length prefix))
3715         (substring group (length prefix) nil)
3716       group)))
3717
3718 (defun gnus-group-prefixed-p (group)
3719   "Return the prefix of the current group name."
3720   (< 0 (length (gnus-group-real-prefix group))))
3721
3722 (declare-function gnus-group-decoded-name "gnus-group" (string))
3723
3724 (defun gnus-summary-buffer-name (group)
3725   "Return the summary buffer name of GROUP."
3726   (concat "*Summary " (gnus-group-decoded-name group) "*"))
3727
3728 (defun gnus-group-method (group)
3729   "Return the server or method used for selecting GROUP.
3730 You should probably use `gnus-find-method-for-group' instead."
3731   (let ((prefix (gnus-group-real-prefix group)))
3732     (if (equal prefix "")
3733         gnus-select-method
3734       (let ((servers gnus-opened-servers)
3735             (server "")
3736             backend possible found)
3737         (if (string-match "^[^\\+]+\\+" prefix)
3738             (setq backend (intern (substring prefix 0 (1- (match-end 0))))
3739                   server (substring prefix (match-end 0) (1- (length prefix))))
3740           (setq backend (intern (substring prefix 0 (1- (length prefix))))))
3741         (while servers
3742           (when (eq (caaar servers) backend)
3743             (setq possible (caar servers))
3744             (when (equal (cadaar servers) server)
3745               (setq found (caar servers))))
3746           (pop servers))
3747         (or (car (rassoc found gnus-server-alist))
3748             found
3749             (car (rassoc possible gnus-server-alist))
3750             possible
3751             (list backend server))))))
3752
3753 (defsubst gnus-native-method-p (method)
3754   "Return whether METHOD is the native select method."
3755   (gnus-method-equal method gnus-select-method))
3756
3757 (defsubst gnus-secondary-method-p (method)
3758   "Return whether METHOD is a secondary select method."
3759   (let ((methods gnus-secondary-select-methods)
3760         (gmethod (inline (gnus-server-get-method nil method))))
3761     (while (and methods
3762                 (not (gnus-method-equal
3763                       (inline (gnus-server-get-method nil (car methods)))
3764                       gmethod)))
3765       (setq methods (cdr methods)))
3766     methods))
3767
3768 (defun gnus-method-simplify (method)
3769   "Return the shortest uniquely identifying string or method for METHOD."
3770   (cond ((stringp method)
3771          method)
3772         ((gnus-native-method-p method)
3773          nil)
3774         ((gnus-secondary-method-p method)
3775          (format "%s:%s" (nth 0 method) (nth 1 method)))
3776         (t
3777          method)))
3778
3779 (defun gnus-groups-from-server (server)
3780   "Return a list of all groups that are fetched from SERVER."
3781   (let ((alist (cdr gnus-newsrc-alist))
3782         info groups)
3783     (while (setq info (pop alist))
3784       (when (gnus-server-equal (gnus-info-method info) server)
3785         (push (gnus-info-group info) groups)))
3786     (sort groups 'string<)))
3787
3788 (defun gnus-group-foreign-p (group)
3789   "Say whether a group is foreign or not."
3790   (and (not (gnus-group-native-p group))
3791        (not (gnus-group-secondary-p group))))
3792
3793 (defun gnus-group-native-p (group)
3794   "Say whether the group is native or not."
3795   (not (string-match ":" group)))
3796
3797 (defun gnus-group-secondary-p (group)
3798   "Say whether the group is secondary or not."
3799   (gnus-secondary-method-p (gnus-find-method-for-group group)))
3800
3801 (defun gnus-parameters-get-parameter (group)
3802   "Return the group parameters for GROUP from `gnus-parameters'."
3803   (let ((case-fold-search (if (eq gnus-parameters-case-fold-search 'default)
3804                               case-fold-search
3805                             gnus-parameters-case-fold-search))
3806         params-list)
3807     (dolist (elem gnus-parameters)
3808       (when (string-match (car elem) group)
3809         (setq params-list
3810               (nconc (gnus-expand-group-parameters
3811                       (car elem) (cdr elem) group)
3812                      params-list))))
3813     params-list))
3814
3815 (defun gnus-expand-group-parameter (match value group)
3816   "Use MATCH to expand VALUE in GROUP."
3817   (let ((start (string-match match group)))
3818     (if start
3819         (let ((matched-string (substring group start (match-end 0))))
3820           ;; Build match groups
3821           (string-match match matched-string)
3822           (replace-match value nil nil matched-string))
3823       group)))
3824
3825 (defun gnus-expand-group-parameters (match parameters group)
3826   "Go through PARAMETERS and expand them according to the match data."
3827   (let (new)
3828     (dolist (elem parameters)
3829       (cond
3830        ((and (stringp (cdr elem))
3831              (string-match "\\\\[0-9&]" (cdr elem)))
3832         (push (cons (car elem)
3833                     (gnus-expand-group-parameter match (cdr elem) group))
3834               new))
3835        ;; For `sieve' group parameters, perform substitutions for every
3836        ;; string within the match rule.  This allows for parameters such
3837        ;; as:
3838        ;;  ("list\\.\\(.*\\)"
3839        ;;   (sieve header :is "list-id" "<\\1.domain.org>"))
3840        ((eq 'sieve (car elem))
3841         (push (mapcar (lambda (sieve-elem)
3842                         (if (and (stringp sieve-elem)
3843                                  (string-match "\\\\[0-9&]" sieve-elem))
3844                             (gnus-expand-group-parameter match sieve-elem
3845                                                          group)
3846                           sieve-elem))