|
0
|
1 ;;; gnus.el --- a newsreader for GNU Emacs
|
|
98
|
2 ;; Copyright (C) 1987,88,89,90,93,94,95,96,97 Free Software Foundation, Inc.
|
|
0
|
3
|
|
|
4 ;; Author: Masanobu UMEDA <umerin@flab.flab.fujitsu.junet>
|
|
|
5 ;; Lars Magne Ingebrigtsen <larsi@ifi.uio.no>
|
|
104
|
6 ;; Keywords: news, mail
|
|
0
|
7
|
|
|
8 ;; This file is part of GNU Emacs.
|
|
|
9
|
|
|
10 ;; GNU Emacs is free software; you can redistribute it and/or modify
|
|
|
11 ;; it under the terms of the GNU General Public License as published by
|
|
|
12 ;; the Free Software Foundation; either version 2, or (at your option)
|
|
|
13 ;; any later version.
|
|
|
14
|
|
|
15 ;; GNU Emacs is distributed in the hope that it will be useful,
|
|
|
16 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
17 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
18 ;; GNU General Public License for more details.
|
|
|
19
|
|
|
20 ;; You should have received a copy of the GNU General Public License
|
|
|
21 ;; along with GNU Emacs; see the file COPYING. If not, write to the
|
|
|
22 ;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
|
|
23 ;; Boston, MA 02111-1307, USA.
|
|
|
24
|
|
|
25 ;;; Commentary:
|
|
|
26
|
|
|
27 ;;; Code:
|
|
|
28
|
|
|
29 (eval '(run-hooks 'gnus-load-hook))
|
|
|
30
|
|
98
|
31 (require 'custom)
|
|
|
32 (require 'gnus-load)
|
|
108
|
33 (require 'message)
|
|
70
|
34
|
|
98
|
35 (defgroup gnus nil
|
|
|
36 "The coffee-brewing, all singing, all dancing, kitchen sink newsreader."
|
|
104
|
37 :group 'news
|
|
|
38 :group 'mail)
|
|
70
|
39
|
|
98
|
40 (defgroup gnus-start nil
|
|
|
41 "Starting your favorite newsreader."
|
|
|
42 :group 'gnus)
|
|
70
|
43
|
|
100
|
44 (defgroup gnus-start-server nil
|
|
|
45 "Server options at startup."
|
|
|
46 :group 'gnus-start)
|
|
|
47
|
|
98
|
48 ;; These belong to gnus-group.el.
|
|
|
49 (defgroup gnus-group nil
|
|
|
50 "Group buffers."
|
|
|
51 :link '(custom-manual "(gnus)The Group Buffer")
|
|
|
52 :group 'gnus)
|
|
70
|
53
|
|
98
|
54 (defgroup gnus-group-foreign nil
|
|
|
55 "Foreign groups."
|
|
|
56 :link '(custom-manual "(gnus)Foreign Groups")
|
|
|
57 :group 'gnus-group)
|
|
70
|
58
|
|
100
|
59 (defgroup gnus-group-new nil
|
|
|
60 "Automatic subscription of new groups."
|
|
|
61 :group 'gnus-group)
|
|
|
62
|
|
98
|
63 (defgroup gnus-group-levels nil
|
|
|
64 "Group levels."
|
|
|
65 :link '(custom-manual "(gnus)Group Levels")
|
|
|
66 :group 'gnus-group)
|
|
70
|
67
|
|
98
|
68 (defgroup gnus-group-select nil
|
|
|
69 "Selecting a Group."
|
|
|
70 :link '(custom-manual "(gnus)Selecting a Group")
|
|
|
71 :group 'gnus-group)
|
|
70
|
72
|
|
98
|
73 (defgroup gnus-group-listing nil
|
|
|
74 "Showing slices of the group list."
|
|
|
75 :link '(custom-manual "(gnus)Listing Groups")
|
|
|
76 :group 'gnus-group)
|
|
70
|
77
|
|
98
|
78 (defgroup gnus-group-visual nil
|
|
|
79 "Sorting the group buffer."
|
|
|
80 :link '(custom-manual "(gnus)Group Buffer Format")
|
|
|
81 :group 'gnus-group
|
|
|
82 :group 'gnus-visual)
|
|
70
|
83
|
|
98
|
84 (defgroup gnus-group-various nil
|
|
|
85 "Various group options."
|
|
|
86 :link '(custom-manual "(gnus)Scanning New Messages")
|
|
|
87 :group 'gnus-group)
|
|
70
|
88
|
|
98
|
89 ;; These belong to gnus-sum.el.
|
|
|
90 (defgroup gnus-summary nil
|
|
|
91 "Summary buffers."
|
|
|
92 :link '(custom-manual "(gnus)The Summary Buffer")
|
|
|
93 :group 'gnus)
|
|
70
|
94
|
|
98
|
95 (defgroup gnus-summary-exit nil
|
|
|
96 "Leaving summary buffers."
|
|
|
97 :link '(custom-manual "(gnus)Exiting the Summary Buffer")
|
|
|
98 :group 'gnus-summary)
|
|
70
|
99
|
|
98
|
100 (defgroup gnus-summary-marks nil
|
|
|
101 "Marks used in summary buffers."
|
|
|
102 :link '(custom-manual "(gnus)Marking Articles")
|
|
|
103 :group 'gnus-summary)
|
|
70
|
104
|
|
98
|
105 (defgroup gnus-thread nil
|
|
|
106 "Ordering articles according to replies."
|
|
|
107 :link '(custom-manual "(gnus)Threading")
|
|
|
108 :group 'gnus-summary)
|
|
70
|
109
|
|
98
|
110 (defgroup gnus-summary-format nil
|
|
|
111 "Formatting of the summary buffer."
|
|
|
112 :link '(custom-manual "(gnus)Summary Buffer Format")
|
|
|
113 :group 'gnus-summary)
|
|
70
|
114
|
|
98
|
115 (defgroup gnus-summary-choose nil
|
|
|
116 "Choosing Articles."
|
|
|
117 :link '(custom-manual "(gnus)Choosing Articles")
|
|
|
118 :group 'gnus-summary)
|
|
70
|
119
|
|
98
|
120 (defgroup gnus-summary-maneuvering nil
|
|
|
121 "Summary movement commands."
|
|
|
122 :link '(custom-manual "(gnus)Summary Maneuvering")
|
|
|
123 :group 'gnus-summary)
|
|
70
|
124
|
|
98
|
125 (defgroup gnus-summary-mail nil
|
|
|
126 "Mail group commands."
|
|
|
127 :link '(custom-manual "(gnus)Mail Group Commands")
|
|
|
128 :group 'gnus-summary)
|
|
70
|
129
|
|
98
|
130 (defgroup gnus-summary-sort nil
|
|
|
131 "Sorting the summary buffer."
|
|
|
132 :link '(custom-manual "(gnus)Sorting")
|
|
|
133 :group 'gnus-summary)
|
|
70
|
134
|
|
98
|
135 (defgroup gnus-summary-visual nil
|
|
|
136 "Highlighting and menus in the summary buffer."
|
|
|
137 :link '(custom-manual "(gnus)Summary Highlighting")
|
|
|
138 :group 'gnus-visual
|
|
|
139 :group 'gnus-summary)
|
|
70
|
140
|
|
98
|
141 (defgroup gnus-summary-various nil
|
|
|
142 "Various summary buffer options."
|
|
|
143 :link '(custom-manual "(gnus)Various Summary Stuff")
|
|
|
144 :group 'gnus-summary)
|
|
70
|
145
|
|
167
|
146 (defgroup gnus-summary-pick nil
|
|
|
147 "Pick mode in the summary buffer."
|
|
|
148 :link '(custom-manual "(gnus)Pick and Read")
|
|
|
149 :prefix "gnus-pick-"
|
|
|
150 :group 'gnus-summary)
|
|
|
151
|
|
|
152 (defgroup gnus-summary-tree nil
|
|
|
153 "Tree display of threads in the summary buffer."
|
|
|
154 :link '(custom-manual "(gnus)Tree Display")
|
|
|
155 :prefix "gnus-tree-"
|
|
|
156 :group 'gnus-summary)
|
|
|
157
|
|
98
|
158 ;; Belongs to gnus-uu.el
|
|
|
159 (defgroup gnus-extract-view nil
|
|
|
160 "Viewing extracted files."
|
|
|
161 :link '(custom-manual "(gnus)Viewing Files")
|
|
|
162 :group 'gnus-extract)
|
|
70
|
163
|
|
98
|
164 ;; Belongs to gnus-score.el
|
|
|
165 (defgroup gnus-score nil
|
|
|
166 "Score and kill file handling."
|
|
|
167 :group 'gnus)
|
|
70
|
168
|
|
98
|
169 (defgroup gnus-score-kill nil
|
|
|
170 "Kill files."
|
|
|
171 :group 'gnus-score)
|
|
70
|
172
|
|
98
|
173 (defgroup gnus-score-adapt nil
|
|
|
174 "Adaptive score files."
|
|
|
175 :group 'gnus-score)
|
|
70
|
176
|
|
100
|
177 (defgroup gnus-score-default nil
|
|
|
178 "Default values for score files."
|
|
|
179 :group 'gnus-score)
|
|
|
180
|
|
|
181 (defgroup gnus-score-expire nil
|
|
|
182 "Expiring score rules."
|
|
|
183 :group 'gnus-score)
|
|
|
184
|
|
|
185 (defgroup gnus-score-decay nil
|
|
|
186 "Decaying score rules."
|
|
|
187 :group 'gnus-score)
|
|
|
188
|
|
98
|
189 (defgroup gnus-score-files nil
|
|
|
190 "Score and kill file names."
|
|
|
191 :group 'gnus-score
|
|
|
192 :group 'gnus-files)
|
|
70
|
193
|
|
98
|
194 (defgroup gnus-score-various nil
|
|
|
195 "Various scoring and killing options."
|
|
|
196 :group 'gnus-score)
|
|
70
|
197
|
|
98
|
198 ;; Other
|
|
|
199 (defgroup gnus-visual nil
|
|
|
200 "Options controling the visual fluff."
|
|
104
|
201 :group 'gnus
|
|
|
202 :group 'faces)
|
|
70
|
203
|
|
98
|
204 (defgroup gnus-files nil
|
|
|
205 "Files used by Gnus."
|
|
|
206 :group 'gnus)
|
|
70
|
207
|
|
100
|
208 (defgroup gnus-dribble-file nil
|
|
|
209 "Auto save file."
|
|
|
210 :link '(custom-manual "(gnus)Auto Save")
|
|
|
211 :group 'gnus-files)
|
|
|
212
|
|
|
213 (defgroup gnus-newsrc nil
|
|
|
214 "Storing Gnus state."
|
|
|
215 :group 'gnus-files)
|
|
|
216
|
|
98
|
217 (defgroup gnus-server nil
|
|
|
218 "Options related to newsservers and other servers used by Gnus."
|
|
|
219 :group 'gnus)
|
|
70
|
220
|
|
98
|
221 (defgroup gnus-message '((message custom-group))
|
|
|
222 "Composing replies and followups in Gnus."
|
|
|
223 :group 'gnus)
|
|
70
|
224
|
|
98
|
225 (defgroup gnus-meta nil
|
|
|
226 "Meta variables controling major portions of Gnus.
|
|
|
227 In general, modifying these variables does not take affect until Gnus
|
|
|
228 is restarted, and sometimes reloaded."
|
|
|
229 :group 'gnus)
|
|
70
|
230
|
|
98
|
231 (defgroup gnus-various nil
|
|
|
232 "Other Gnus options."
|
|
|
233 :link '(custom-manual "(gnus)Various Various")
|
|
|
234 :group 'gnus)
|
|
70
|
235
|
|
98
|
236 (defgroup gnus-exit nil
|
|
|
237 "Exiting gnus."
|
|
|
238 :link '(custom-manual "(gnus)Exiting Gnus")
|
|
|
239 :group 'gnus)
|
|
70
|
240
|
|
169
|
241 (defconst gnus-version-number "5.4.62"
|
|
0
|
242 "Version number for this version of Gnus.")
|
|
|
243
|
|
|
244 (defconst gnus-version (format "Gnus v%s" gnus-version-number)
|
|
|
245 "Version string for this version of Gnus.")
|
|
|
246
|
|
98
|
247 (defcustom gnus-inhibit-startup-message nil
|
|
|
248 "If non-nil, the startup message will not be displayed.
|
|
|
249 This variable is used before `.gnus.el' is loaded, so it should
|
|
|
250 be set in `.emacs' instead."
|
|
|
251 :group 'gnus-start
|
|
|
252 :type 'boolean)
|
|
|
253
|
|
|
254 (defcustom gnus-play-startup-jingle nil
|
|
|
255 "If non-nil, play the Gnus jingle at startup."
|
|
|
256 :group 'gnus-start
|
|
|
257 :type 'boolean)
|
|
|
258
|
|
|
259 ;;; Kludges to help the transition from the old `custom.el'.
|
|
|
260
|
|
|
261 (unless (featurep 'gnus-xmas)
|
|
|
262 (defalias 'gnus-make-overlay 'make-overlay)
|
|
|
263 (defalias 'gnus-overlay-put 'overlay-put)
|
|
|
264 (defalias 'gnus-move-overlay 'move-overlay)
|
|
|
265 (defalias 'gnus-overlay-end 'overlay-end)
|
|
|
266 (defalias 'gnus-extent-detached-p 'ignore)
|
|
|
267 (defalias 'gnus-extent-start-open 'ignore)
|
|
|
268 (defalias 'gnus-set-text-properties 'set-text-properties)
|
|
|
269 (defalias 'gnus-group-remove-excess-properties 'ignore)
|
|
|
270 (defalias 'gnus-topic-remove-excess-properties 'ignore)
|
|
|
271 (defalias 'gnus-appt-select-lowest-window 'appt-select-lowest-window)
|
|
|
272 (defalias 'gnus-mail-strip-quoted-names 'mail-strip-quoted-names)
|
|
|
273 (defalias 'gnus-character-to-event 'identity)
|
|
|
274 (defalias 'gnus-add-text-properties 'add-text-properties)
|
|
|
275 (defalias 'gnus-put-text-property 'put-text-property)
|
|
|
276 (defalias 'gnus-mode-line-buffer-identification 'identity)
|
|
|
277 (defalias 'gnus-characterp 'numberp)
|
|
|
278 (defalias 'gnus-key-press-event-p 'numberp))
|
|
|
279
|
|
|
280 ;; The XEmacs people think this is evil, so it must go.
|
|
|
281 (defun custom-face-lookup (&optional fg bg stipple bold italic underline)
|
|
|
282 "Lookup or create a face with specified attributes."
|
|
|
283 (let ((name (intern (format "custom-face-%s-%s-%s-%S-%S-%S"
|
|
|
284 (or fg "default")
|
|
|
285 (or bg "default")
|
|
|
286 (or stipple "default")
|
|
|
287 bold italic underline))))
|
|
|
288 (if (and (custom-facep name)
|
|
|
289 (fboundp 'make-face))
|
|
|
290 ()
|
|
|
291 (copy-face 'default name)
|
|
|
292 (when (and fg
|
|
|
293 (not (string-equal fg "default")))
|
|
|
294 (ignore-errors
|
|
|
295 (set-face-foreground name fg)))
|
|
|
296 (when (and bg
|
|
|
297 (not (string-equal bg "default")))
|
|
|
298 (ignore-errors
|
|
|
299 (set-face-background name bg)))
|
|
|
300 (when (and stipple
|
|
|
301 (not (string-equal stipple "default"))
|
|
|
302 (not (eq stipple 'custom:asis))
|
|
|
303 (fboundp 'set-face-stipple))
|
|
|
304 (set-face-stipple name stipple))
|
|
|
305 (when (and bold
|
|
|
306 (not (eq bold 'custom:asis)))
|
|
|
307 (ignore-errors
|
|
|
308 (make-face-bold name)))
|
|
|
309 (when (and italic
|
|
|
310 (not (eq italic 'custom:asis)))
|
|
|
311 (ignore-errors
|
|
|
312 (make-face-italic name)))
|
|
|
313 (when (and underline
|
|
|
314 (not (eq underline 'custom:asis)))
|
|
|
315 (ignore-errors
|
|
|
316 (set-face-underline-p name t))))
|
|
|
317 name))
|
|
|
318
|
|
|
319 ;; We define these group faces here to avoid the display
|
|
|
320 ;; update forced when creating new faces.
|
|
|
321
|
|
108
|
322 (defface gnus-group-news-1-face
|
|
98
|
323 '((((class color)
|
|
|
324 (background dark))
|
|
|
325 (:foreground "PaleTurquoise" :bold t))
|
|
|
326 (((class color)
|
|
|
327 (background light))
|
|
|
328 (:foreground "ForestGreen" :bold t))
|
|
|
329 (t
|
|
|
330 ()))
|
|
|
331 "Level 1 newsgroup face.")
|
|
|
332
|
|
|
333 (defface gnus-group-news-1-empty-face
|
|
|
334 '((((class color)
|
|
|
335 (background dark))
|
|
|
336 (:foreground "PaleTurquoise"))
|
|
|
337 (((class color)
|
|
|
338 (background light))
|
|
|
339 (:foreground "ForestGreen"))
|
|
|
340 (t
|
|
|
341 ()))
|
|
|
342 "Level 1 empty newsgroup face.")
|
|
|
343
|
|
108
|
344 (defface gnus-group-news-2-face
|
|
98
|
345 '((((class color)
|
|
|
346 (background dark))
|
|
|
347 (:foreground "turquoise" :bold t))
|
|
|
348 (((class color)
|
|
|
349 (background light))
|
|
|
350 (:foreground "CadetBlue4" :bold t))
|
|
|
351 (t
|
|
|
352 ()))
|
|
|
353 "Level 2 newsgroup face.")
|
|
|
354
|
|
|
355 (defface gnus-group-news-2-empty-face
|
|
|
356 '((((class color)
|
|
|
357 (background dark))
|
|
|
358 (:foreground "turquoise"))
|
|
|
359 (((class color)
|
|
|
360 (background light))
|
|
|
361 (:foreground "CadetBlue4"))
|
|
|
362 (t
|
|
|
363 ()))
|
|
|
364 "Level 2 empty newsgroup face.")
|
|
|
365
|
|
108
|
366 (defface gnus-group-news-3-face
|
|
98
|
367 '((((class color)
|
|
|
368 (background dark))
|
|
|
369 (:bold t))
|
|
|
370 (((class color)
|
|
|
371 (background light))
|
|
|
372 (:bold t))
|
|
|
373 (t
|
|
|
374 ()))
|
|
|
375 "Level 3 newsgroup face.")
|
|
|
376
|
|
|
377 (defface gnus-group-news-3-empty-face
|
|
|
378 '((((class color)
|
|
|
379 (background dark))
|
|
|
380 ())
|
|
|
381 (((class color)
|
|
|
382 (background light))
|
|
|
383 ())
|
|
|
384 (t
|
|
|
385 ()))
|
|
|
386 "Level 3 empty newsgroup face.")
|
|
|
387
|
|
108
|
388 (defface gnus-group-news-low-face
|
|
98
|
389 '((((class color)
|
|
|
390 (background dark))
|
|
|
391 (:foreground "DarkTurquoise" :bold t))
|
|
|
392 (((class color)
|
|
|
393 (background light))
|
|
|
394 (:foreground "DarkGreen" :bold t))
|
|
|
395 (t
|
|
|
396 ()))
|
|
|
397 "Low level newsgroup face.")
|
|
|
398
|
|
|
399 (defface gnus-group-news-low-empty-face
|
|
|
400 '((((class color)
|
|
|
401 (background dark))
|
|
|
402 (:foreground "DarkTurquoise"))
|
|
|
403 (((class color)
|
|
|
404 (background light))
|
|
|
405 (:foreground "DarkGreen"))
|
|
|
406 (t
|
|
|
407 ()))
|
|
|
408 "Low level empty newsgroup face.")
|
|
|
409
|
|
108
|
410 (defface gnus-group-mail-1-face
|
|
98
|
411 '((((class color)
|
|
|
412 (background dark))
|
|
|
413 (:foreground "aquamarine1" :bold t))
|
|
|
414 (((class color)
|
|
|
415 (background light))
|
|
|
416 (:foreground "DeepPink3" :bold t))
|
|
|
417 (t
|
|
|
418 (:bold t)))
|
|
|
419 "Level 1 mailgroup face.")
|
|
|
420
|
|
|
421 (defface gnus-group-mail-1-empty-face
|
|
|
422 '((((class color)
|
|
|
423 (background dark))
|
|
|
424 (:foreground "aquamarine1"))
|
|
|
425 (((class color)
|
|
|
426 (background light))
|
|
|
427 (:foreground "DeepPink3"))
|
|
|
428 (t
|
|
|
429 (:italic t :bold t)))
|
|
|
430 "Level 1 empty mailgroup face.")
|
|
|
431
|
|
108
|
432 (defface gnus-group-mail-2-face
|
|
98
|
433 '((((class color)
|
|
|
434 (background dark))
|
|
|
435 (:foreground "aquamarine2" :bold t))
|
|
|
436 (((class color)
|
|
|
437 (background light))
|
|
|
438 (:foreground "HotPink3" :bold t))
|
|
|
439 (t
|
|
|
440 (:bold t)))
|
|
|
441 "Level 2 mailgroup face.")
|
|
|
442
|
|
|
443 (defface gnus-group-mail-2-empty-face
|
|
|
444 '((((class color)
|
|
|
445 (background dark))
|
|
|
446 (:foreground "aquamarine2"))
|
|
|
447 (((class color)
|
|
|
448 (background light))
|
|
|
449 (:foreground "HotPink3"))
|
|
|
450 (t
|
|
|
451 (:bold t)))
|
|
|
452 "Level 2 empty mailgroup face.")
|
|
|
453
|
|
108
|
454 (defface gnus-group-mail-3-face
|
|
98
|
455 '((((class color)
|
|
|
456 (background dark))
|
|
|
457 (:foreground "aquamarine3" :bold t))
|
|
|
458 (((class color)
|
|
|
459 (background light))
|
|
|
460 (:foreground "magenta4" :bold t))
|
|
|
461 (t
|
|
|
462 (:bold t)))
|
|
|
463 "Level 3 mailgroup face.")
|
|
|
464
|
|
|
465 (defface gnus-group-mail-3-empty-face
|
|
|
466 '((((class color)
|
|
|
467 (background dark))
|
|
|
468 (:foreground "aquamarine3"))
|
|
|
469 (((class color)
|
|
|
470 (background light))
|
|
|
471 (:foreground "magenta4"))
|
|
|
472 (t
|
|
|
473 ()))
|
|
|
474 "Level 3 empty mailgroup face.")
|
|
|
475
|
|
108
|
476 (defface gnus-group-mail-low-face
|
|
98
|
477 '((((class color)
|
|
|
478 (background dark))
|
|
|
479 (:foreground "aquamarine4" :bold t))
|
|
|
480 (((class color)
|
|
|
481 (background light))
|
|
|
482 (:foreground "DeepPink4" :bold t))
|
|
|
483 (t
|
|
|
484 (:bold t)))
|
|
|
485 "Low level mailgroup face.")
|
|
|
486
|
|
|
487 (defface gnus-group-mail-low-empty-face
|
|
|
488 '((((class color)
|
|
|
489 (background dark))
|
|
|
490 (:foreground "aquamarine4"))
|
|
|
491 (((class color)
|
|
|
492 (background light))
|
|
|
493 (:foreground "DeepPink4"))
|
|
|
494 (t
|
|
|
495 (:bold t)))
|
|
|
496 "Low level empty mailgroup face.")
|
|
|
497
|
|
|
498 ;; Summary mode faces.
|
|
|
499
|
|
108
|
500 (defface gnus-summary-selected-face '((t
|
|
98
|
501 (:underline t)))
|
|
|
502 "Face used for selected articles.")
|
|
|
503
|
|
108
|
504 (defface gnus-summary-cancelled-face
|
|
98
|
505 '((((class color))
|
|
|
506 (:foreground "yellow" :background "black")))
|
|
|
507 "Face used for cancelled articles.")
|
|
|
508
|
|
|
509 (defface gnus-summary-high-ticked-face
|
|
|
510 '((((class color)
|
|
|
511 (background dark))
|
|
|
512 (:foreground "pink" :bold t))
|
|
|
513 (((class color)
|
|
|
514 (background light))
|
|
|
515 (:foreground "firebrick" :bold t))
|
|
108
|
516 (t
|
|
98
|
517 (:bold t)))
|
|
|
518 "Face used for high interest ticked articles.")
|
|
|
519
|
|
|
520 (defface gnus-summary-low-ticked-face
|
|
|
521 '((((class color)
|
|
|
522 (background dark))
|
|
|
523 (:foreground "pink" :italic t))
|
|
|
524 (((class color)
|
|
|
525 (background light))
|
|
|
526 (:foreground "firebrick" :italic t))
|
|
108
|
527 (t
|
|
98
|
528 (:italic t)))
|
|
|
529 "Face used for low interest ticked articles.")
|
|
|
530
|
|
|
531 (defface gnus-summary-normal-ticked-face
|
|
|
532 '((((class color)
|
|
|
533 (background dark))
|
|
|
534 (:foreground "pink"))
|
|
|
535 (((class color)
|
|
|
536 (background light))
|
|
|
537 (:foreground "firebrick"))
|
|
108
|
538 (t
|
|
98
|
539 ()))
|
|
|
540 "Face used for normal interest ticked articles.")
|
|
108
|
541
|
|
98
|
542 (defface gnus-summary-high-ancient-face
|
|
|
543 '((((class color)
|
|
|
544 (background dark))
|
|
|
545 (:foreground "SkyBlue" :bold t))
|
|
|
546 (((class color)
|
|
|
547 (background light))
|
|
|
548 (:foreground "RoyalBlue" :bold t))
|
|
108
|
549 (t
|
|
98
|
550 (:bold t)))
|
|
|
551 "Face used for high interest ancient articles.")
|
|
|
552
|
|
|
553 (defface gnus-summary-low-ancient-face
|
|
|
554 '((((class color)
|
|
|
555 (background dark))
|
|
|
556 (:foreground "SkyBlue" :italic t))
|
|
|
557 (((class color)
|
|
|
558 (background light))
|
|
|
559 (:foreground "RoyalBlue" :italic t))
|
|
108
|
560 (t
|
|
98
|
561 (:italic t)))
|
|
|
562 "Face used for low interest ancient articles.")
|
|
|
563
|
|
|
564 (defface gnus-summary-normal-ancient-face
|
|
|
565 '((((class color)
|
|
|
566 (background dark))
|
|
|
567 (:foreground "SkyBlue"))
|
|
|
568 (((class color)
|
|
|
569 (background light))
|
|
|
570 (:foreground "RoyalBlue"))
|
|
108
|
571 (t
|
|
98
|
572 ()))
|
|
|
573 "Face used for normal interest ancient articles.")
|
|
108
|
574
|
|
98
|
575 (defface gnus-summary-high-unread-face
|
|
108
|
576 '((t
|
|
98
|
577 (:bold t)))
|
|
|
578 "Face used for high interest unread articles.")
|
|
|
579
|
|
|
580 (defface gnus-summary-low-unread-face
|
|
108
|
581 '((t
|
|
98
|
582 (:italic t)))
|
|
|
583 "Face used for low interest unread articles.")
|
|
|
584
|
|
|
585 (defface gnus-summary-normal-unread-face
|
|
108
|
586 '((t
|
|
98
|
587 ()))
|
|
|
588 "Face used for normal interest unread articles.")
|
|
108
|
589
|
|
98
|
590 (defface gnus-summary-high-read-face
|
|
|
591 '((((class color)
|
|
|
592 (background dark))
|
|
|
593 (:foreground "PaleGreen"
|
|
|
594 :bold t))
|
|
|
595 (((class color)
|
|
|
596 (background light))
|
|
|
597 (:foreground "DarkGreen"
|
|
|
598 :bold t))
|
|
108
|
599 (t
|
|
98
|
600 (:bold t)))
|
|
|
601 "Face used for high interest read articles.")
|
|
|
602
|
|
|
603 (defface gnus-summary-low-read-face
|
|
|
604 '((((class color)
|
|
|
605 (background dark))
|
|
|
606 (:foreground "PaleGreen"
|
|
|
607 :italic t))
|
|
|
608 (((class color)
|
|
|
609 (background light))
|
|
|
610 (:foreground "DarkGreen"
|
|
|
611 :italic t))
|
|
108
|
612 (t
|
|
98
|
613 (:italic t)))
|
|
|
614 "Face used for low interest read articles.")
|
|
|
615
|
|
|
616 (defface gnus-summary-normal-read-face
|
|
|
617 '((((class color)
|
|
|
618 (background dark))
|
|
|
619 (:foreground "PaleGreen"))
|
|
|
620 (((class color)
|
|
|
621 (background light))
|
|
|
622 (:foreground "DarkGreen"))
|
|
108
|
623 (t
|
|
98
|
624 ()))
|
|
|
625 "Face used for normal interest read articles.")
|
|
|
626
|
|
|
627
|
|
|
628 ;;; Splash screen.
|
|
0
|
629
|
|
|
630 (defvar gnus-group-buffer "*Group*")
|
|
70
|
631
|
|
0
|
632 (eval-and-compile
|
|
98
|
633 (autoload 'gnus-play-jingle "gnus-audio"))
|
|
70
|
634
|
|
108
|
635 (defface gnus-splash-face
|
|
98
|
636 '((((class color)
|
|
|
637 (background dark))
|
|
|
638 (:foreground "red"))
|
|
|
639 (((class color)
|
|
|
640 (background light))
|
|
|
641 (:foreground "red"))
|
|
|
642 (t
|
|
|
643 ()))
|
|
|
644 "Level 1 newsgroup face.")
|
|
70
|
645
|
|
98
|
646 (defun gnus-splash ()
|
|
70
|
647 (save-excursion
|
|
98
|
648 (switch-to-buffer gnus-group-buffer)
|
|
0
|
649 (let ((buffer-read-only nil))
|
|
|
650 (erase-buffer)
|
|
98
|
651 (unless gnus-inhibit-startup-message
|
|
|
652 (gnus-group-startup-message)
|
|
|
653 (sit-for 0)
|
|
|
654 (when gnus-play-startup-jingle
|
|
|
655 (gnus-play-jingle))))))
|
|
0
|
656
|
|
|
657 (defun gnus-indent-rigidly (start end arg)
|
|
|
658 "Indent rigidly using only spaces and no tabs."
|
|
|
659 (save-excursion
|
|
|
660 (save-restriction
|
|
|
661 (narrow-to-region start end)
|
|
163
|
662 (let ((tab-width 8))
|
|
|
663 (indent-rigidly start end arg)
|
|
|
664 ;; We translate tabs into spaces -- not everybody uses
|
|
|
665 ;; an 8-character tab.
|
|
|
666 (goto-char (point-min))
|
|
|
667 (while (search-forward "\t" nil t)
|
|
|
668 (replace-match " " t t))))))
|
|
98
|
669
|
|
|
670 (defvar gnus-simple-splash nil)
|
|
0
|
671
|
|
|
672 (defun gnus-group-startup-message (&optional x y)
|
|
|
673 "Insert startup message in current buffer."
|
|
|
674 ;; Insert the message.
|
|
|
675 (erase-buffer)
|
|
|
676 (insert
|
|
|
677 (format " %s
|
|
|
678 _ ___ _ _
|
|
|
679 _ ___ __ ___ __ _ ___
|
|
|
680 __ _ ___ __ ___
|
|
|
681 _ ___ _
|
|
|
682 _ _ __ _
|
|
|
683 ___ __ _
|
|
|
684 __ _
|
|
|
685 _ _ _
|
|
|
686 _ _ _
|
|
|
687 _ _ _
|
|
|
688 __ ___
|
|
|
689 _ _ _ _
|
|
|
690 _ _
|
|
|
691 _ _
|
|
|
692 _ _
|
|
|
693 _
|
|
|
694 __
|
|
|
695
|
|
|
696 "
|
|
|
697 ""))
|
|
|
698 ;; And then hack it.
|
|
|
699 (gnus-indent-rigidly (point-min) (point-max)
|
|
|
700 (/ (max (- (window-width) (or x 46)) 0) 2))
|
|
|
701 (goto-char (point-min))
|
|
|
702 (forward-line 1)
|
|
|
703 (let* ((pheight (count-lines (point-min) (point-max)))
|
|
|
704 (wheight (window-height))
|
|
|
705 (rest (- wheight pheight)))
|
|
|
706 (insert (make-string (max 0 (* 2 (/ rest 3))) ?\n)))
|
|
|
707 ;; Fontify some.
|
|
98
|
708 (put-text-property (point-min) (point-max) 'face 'gnus-splash-face)
|
|
0
|
709 (goto-char (point-min))
|
|
98
|
710 (setq mode-line-buffer-identification (concat " " gnus-version))
|
|
|
711 (setq gnus-simple-splash t)
|
|
|
712 (set-buffer-modified-p t))
|
|
|
713
|
|
|
714 (eval-when (load)
|
|
|
715 (let ((command (format "%s" this-command)))
|
|
|
716 (when (and (string-match "gnus" command)
|
|
|
717 (not (string-match "gnus-other-frame" command)))
|
|
|
718 (gnus-splash))))
|
|
|
719
|
|
|
720 ;;; Do the rest.
|
|
|
721
|
|
|
722 (require 'custom)
|
|
|
723 (require 'gnus-util)
|
|
|
724 (require 'nnheader)
|
|
|
725
|
|
110
|
726 (defcustom gnus-home-directory "~/"
|
|
|
727 "Directory variable that specifies the \"home\" directory.
|
|
|
728 All other Gnus path variables are initialized from this variable."
|
|
|
729 :group 'gnus-files
|
|
|
730 :type 'directory)
|
|
|
731
|
|
|
732 (defcustom gnus-directory (or (getenv "SAVEDIR")
|
|
|
733 (nnheader-concat gnus-home-directory "News/"))
|
|
98
|
734 "Directory variable from which all other Gnus file variables are derived."
|
|
|
735 :group 'gnus-files
|
|
|
736 :type 'directory)
|
|
|
737
|
|
|
738 (defcustom gnus-default-directory nil
|
|
|
739 "*Default directory for all Gnus buffers."
|
|
|
740 :group 'gnus-files
|
|
|
741 :type '(choice (const :tag "current" nil)
|
|
|
742 directory))
|
|
|
743
|
|
|
744 ;; Site dependent variables. These variables should be defined in
|
|
|
745 ;; paths.el.
|
|
|
746
|
|
|
747 (defvar gnus-default-nntp-server nil
|
|
|
748 "Specify a default NNTP server.
|
|
|
749 This variable should be defined in paths.el, and should never be set
|
|
|
750 by the user.
|
|
|
751 If you want to change servers, you should use `gnus-select-method'.
|
|
|
752 See the documentation to that variable.")
|
|
|
753
|
|
|
754 ;; Don't touch this variable.
|
|
|
755 (defvar gnus-nntp-service "nntp"
|
|
|
756 "NNTP service name (\"nntp\" or 119).
|
|
|
757 This is an obsolete variable, which is scarcely used. If you use an
|
|
|
758 nntp server for your newsgroup and want to change the port number
|
|
|
759 used to 899, you would say something along these lines:
|
|
|
760
|
|
|
761 (setq gnus-select-method '(nntp \"my.nntp.server\" (nntp-port-number 899)))")
|
|
|
762
|
|
|
763 (defcustom gnus-nntpserver-file "/etc/nntpserver"
|
|
|
764 "A file with only the name of the nntp server in it."
|
|
|
765 :group 'gnus-files
|
|
|
766 :group 'gnus-server
|
|
|
767 :type 'file)
|
|
|
768
|
|
|
769 ;; This function is used to check both the environment variable
|
|
|
770 ;; NNTPSERVER and the /etc/nntpserver file to see whether one can find
|
|
|
771 ;; an nntp server name default.
|
|
|
772 (defun gnus-getenv-nntpserver ()
|
|
|
773 (or (getenv "NNTPSERVER")
|
|
|
774 (and (file-readable-p gnus-nntpserver-file)
|
|
|
775 (save-excursion
|
|
|
776 (set-buffer (get-buffer-create " *gnus nntp*"))
|
|
|
777 (buffer-disable-undo (current-buffer))
|
|
|
778 (insert-file-contents gnus-nntpserver-file)
|
|
|
779 (let ((name (buffer-string)))
|
|
|
780 (prog1
|
|
|
781 (if (string-match "^[ \t\n]*$" name)
|
|
|
782 nil
|
|
|
783 name)
|
|
|
784 (kill-buffer (current-buffer))))))))
|
|
|
785
|
|
|
786 (defcustom gnus-select-method
|
|
|
787 (ignore-errors
|
|
|
788 (nconc
|
|
|
789 (list 'nntp (or (ignore-errors
|
|
|
790 (gnus-getenv-nntpserver))
|
|
|
791 (when (and gnus-default-nntp-server
|
|
|
792 (not (string= gnus-default-nntp-server "")))
|
|
|
793 gnus-default-nntp-server)
|
|
169
|
794 "news"))
|
|
98
|
795 (if (or (null gnus-nntp-service)
|
|
|
796 (equal gnus-nntp-service "nntp"))
|
|
|
797 nil
|
|
|
798 (list gnus-nntp-service))))
|
|
|
799 "Default method for selecting a newsgroup.
|
|
|
800 This variable should be a list, where the first element is how the
|
|
|
801 news is to be fetched, the second is the address.
|
|
|
802
|
|
|
803 For instance, if you want to get your news via NNTP from
|
|
|
804 \"flab.flab.edu\", you could say:
|
|
|
805
|
|
|
806 \(setq gnus-select-method '(nntp \"flab.flab.edu\"))
|
|
|
807
|
|
|
808 If you want to use your local spool, say:
|
|
|
809
|
|
|
810 \(setq gnus-select-method (list 'nnspool (system-name)))
|
|
|
811
|
|
|
812 If you use this variable, you must set `gnus-nntp-server' to nil.
|
|
|
813
|
|
|
814 There is a lot more to know about select methods and virtual servers -
|
|
|
815 see the manual for details."
|
|
|
816 :group 'gnus-server
|
|
|
817 :type 'gnus-select-method)
|
|
|
818
|
|
108
|
819 (defcustom gnus-message-archive-method
|
|
98
|
820 `(nnfolder
|
|
|
821 "archive"
|
|
|
822 (nnfolder-directory ,(nnheader-concat message-directory "archive"))
|
|
108
|
823 (nnfolder-active-file
|
|
98
|
824 ,(nnheader-concat message-directory "archive/active"))
|
|
|
825 (nnfolder-get-new-mail nil)
|
|
|
826 (nnfolder-inhibit-expiry t))
|
|
|
827 "Method used for archiving messages you've sent.
|
|
|
828 This should be a mail method.
|
|
|
829
|
|
|
830 It's probably not a very effective to change this variable once you've
|
|
|
831 run Gnus once. After doing that, you must edit this server from the
|
|
|
832 server buffer."
|
|
|
833 :group 'gnus-server
|
|
|
834 :group 'gnus-message
|
|
|
835 :type 'gnus-select-method)
|
|
|
836
|
|
|
837 (defcustom gnus-message-archive-group nil
|
|
|
838 "*Name of the group in which to save the messages you've written.
|
|
108
|
839 This can either be a string; a list of strings; or an alist
|
|
98
|
840 of regexps/functions/forms to be evaluated to return a string (or a list
|
|
|
841 of strings). The functions are called with the name of the current
|
|
|
842 group (or nil) as a parameter.
|
|
|
843
|
|
|
844 If you want to save your mail in one group and the news articles you
|
|
|
845 write in another group, you could say something like:
|
|
|
846
|
|
108
|
847 \(setq gnus-message-archive-group
|
|
98
|
848 '((if (message-news-p)
|
|
108
|
849 \"misc-news\"
|
|
98
|
850 \"misc-mail\")))
|
|
|
851
|
|
|
852 Normally the group names returned by this variable should be
|
|
|
853 unprefixed -- which implicitly means \"store on the archive server\".
|
|
|
854 However, you may wish to store the message on some other server. In
|
|
|
855 that case, just return a fully prefixed name of the group --
|
|
|
856 \"nnml+private:mail.misc\", for instance."
|
|
|
857 :group 'gnus-message
|
|
|
858 :type '(choice (const :tag "none" nil)
|
|
|
859 string))
|
|
|
860
|
|
|
861 (defcustom gnus-secondary-servers nil
|
|
|
862 "List of NNTP servers that the user can choose between interactively.
|
|
|
863 To make Gnus query you for a server, you have to give `gnus' a
|
|
|
864 non-numeric prefix - `C-u M-x gnus', in short."
|
|
|
865 :group 'gnus-server
|
|
|
866 :type '(repeat string))
|
|
|
867
|
|
|
868 (defcustom gnus-nntp-server nil
|
|
|
869 "*The name of the host running the NNTP server.
|
|
|
870 This variable is semi-obsolete. Use the `gnus-select-method'
|
|
|
871 variable instead."
|
|
|
872 :group 'gnus-server
|
|
|
873 :type '(choice (const :tag "disable" nil)
|
|
|
874 string))
|
|
|
875
|
|
|
876 (defcustom gnus-secondary-select-methods nil
|
|
|
877 "A list of secondary methods that will be used for reading news.
|
|
|
878 This is a list where each element is a complete select method (see
|
|
|
879 `gnus-select-method').
|
|
|
880
|
|
|
881 If, for instance, you want to read your mail with the nnml backend,
|
|
|
882 you could set this variable:
|
|
70
|
883
|
|
98
|
884 \(setq gnus-secondary-select-methods '((nnml \"\")))"
|
|
|
885 :group 'gnus-server
|
|
|
886 :type '(repeat gnus-select-method))
|
|
|
887
|
|
|
888 (defvar gnus-backup-default-subscribed-newsgroups
|
|
|
889 '("news.announce.newusers" "news.groups.questions" "gnu.emacs.gnus")
|
|
|
890 "Default default new newsgroups the first time Gnus is run.
|
|
|
891 Should be set in paths.el, and shouldn't be touched by the user.")
|
|
|
892
|
|
|
893 (defcustom gnus-local-domain nil
|
|
|
894 "Local domain name without a host name.
|
|
|
895 The DOMAINNAME environment variable is used instead if it is defined.
|
|
|
896 If the `system-name' function returns the full Internet name, there is
|
|
|
897 no need to set this variable."
|
|
|
898 :group 'gnus-message
|
|
|
899 :type '(choice (const :tag "default" nil)
|
|
|
900 string))
|
|
|
901
|
|
108
|
902 (defvar gnus-local-organization nil
|
|
98
|
903 "String with a description of what organization (if any) the user belongs to.
|
|
108
|
904 Obsolete variable; use `message-user-organization' instead.")
|
|
98
|
905
|
|
|
906 ;; Customization variables
|
|
|
907
|
|
|
908 (defcustom gnus-refer-article-method nil
|
|
|
909 "Preferred method for fetching an article by Message-ID.
|
|
|
910 If you are reading news from the local spool (with nnspool), fetching
|
|
|
911 articles by Message-ID is painfully slow. By setting this method to an
|
|
|
912 nntp method, you might get acceptable results.
|
|
|
913
|
|
|
914 The value of this variable must be a valid select method as discussed
|
|
|
915 in the documentation of `gnus-select-method'."
|
|
|
916 :group 'gnus-server
|
|
|
917 :type '(choice (const :tag "default" nil)
|
|
|
918 gnus-select-method))
|
|
|
919
|
|
|
920 (defcustom gnus-group-faq-directory
|
|
|
921 '("/ftp@mirrors.aol.com:/pub/rtfm/usenet/"
|
|
|
922 "/ftp@sunsite.auc.dk:/pub/usenet/"
|
|
|
923 "/ftp@sunsite.doc.ic.ac.uk:/pub/usenet/news-faqs/"
|
|
|
924 "/ftp@src.doc.ic.ac.uk:/usenet/news-FAQS/"
|
|
|
925 "/ftp@ftp.seas.gwu.edu:/pub/rtfm/"
|
|
|
926 "/ftp@rtfm.mit.edu:/pub/usenet/"
|
|
|
927 "/ftp@ftp.uni-paderborn.de:/pub/FAQ/"
|
|
|
928 "/ftp@ftp.sunet.se:/pub/usenet/"
|
|
|
929 "/ftp@nctuccca.edu.tw:/USENET/FAQ/"
|
|
|
930 "/ftp@hwarang.postech.ac.kr:/pub/usenet/"
|
|
|
931 "/ftp@ftp.hk.super.net:/mirror/faqs/")
|
|
|
932 "Directory where the group FAQs are stored.
|
|
|
933 This will most commonly be on a remote machine, and the file will be
|
|
|
934 fetched by ange-ftp.
|
|
|
935
|
|
|
936 This variable can also be a list of directories. In that case, the
|
|
|
937 first element in the list will be used by default. The others can
|
|
|
938 be used when being prompted for a site.
|
|
|
939
|
|
|
940 Note that Gnus uses an aol machine as the default directory. If this
|
|
|
941 feels fundamentally unclean, just think of it as a way to finally get
|
|
|
942 something of value back from them.
|
|
|
943
|
|
|
944 If the default site is too slow, try one of these:
|
|
|
945
|
|
|
946 North America: mirrors.aol.com /pub/rtfm/usenet
|
|
|
947 ftp.seas.gwu.edu /pub/rtfm
|
|
|
948 rtfm.mit.edu /pub/usenet
|
|
|
949 Europe: ftp.uni-paderborn.de /pub/FAQ
|
|
|
950 src.doc.ic.ac.uk /usenet/news-FAQS
|
|
|
951 ftp.sunet.se /pub/usenet
|
|
|
952 sunsite.auc.dk /pub/usenet
|
|
|
953 Asia: nctuccca.edu.tw /USENET/FAQ
|
|
|
954 hwarang.postech.ac.kr /pub/usenet
|
|
|
955 ftp.hk.super.net /mirror/faqs"
|
|
|
956 :group 'gnus-group-various
|
|
|
957 :type '(choice directory
|
|
|
958 (repeat directory)))
|
|
|
959
|
|
|
960 (defcustom gnus-use-cross-reference t
|
|
|
961 "*Non-nil means that cross referenced articles will be marked as read.
|
|
|
962 If nil, ignore cross references. If t, mark articles as read in
|
|
|
963 subscribed newsgroups. If neither t nor nil, mark as read in all
|
|
|
964 newsgroups."
|
|
|
965 :group 'gnus-server
|
|
|
966 :type '(choice (const :tag "off" nil)
|
|
|
967 (const :tag "subscribed" t)
|
|
|
968 (sexp :format "all"
|
|
|
969 :value always)))
|
|
|
970
|
|
|
971 (defcustom gnus-process-mark ?#
|
|
|
972 "*Process mark."
|
|
|
973 :group 'gnus-group-visual
|
|
|
974 :group 'gnus-summary-marks
|
|
|
975 :type 'character)
|
|
|
976
|
|
|
977 (defcustom gnus-asynchronous nil
|
|
|
978 "*If non-nil, Gnus will supply backends with data needed for async article fetching."
|
|
|
979 :group 'gnus-asynchronous
|
|
|
980 :type 'boolean)
|
|
|
981
|
|
|
982 (defcustom gnus-large-newsgroup 200
|
|
|
983 "*The number of articles which indicates a large newsgroup.
|
|
|
984 If the number of articles in a newsgroup is greater than this value,
|
|
|
985 confirmation is required for selecting the newsgroup."
|
|
|
986 :group 'gnus-group-select
|
|
|
987 :type 'integer)
|
|
|
988
|
|
|
989 (defcustom gnus-use-long-file-name (not (memq system-type '(usg-unix-v xenix)))
|
|
|
990 "*Non-nil means that the default name of a file to save articles in is the group name.
|
|
|
991 If it's nil, the directory form of the group name is used instead.
|
|
|
992
|
|
|
993 If this variable is a list, and the list contains the element
|
|
|
994 `not-score', long file names will not be used for score files; if it
|
|
|
995 contains the element `not-save', long file names will not be used for
|
|
|
996 saving; and if it contains the element `not-kill', long file names
|
|
|
997 will not be used for kill files.
|
|
|
998
|
|
|
999 Note that the default for this variable varies according to what system
|
|
|
1000 type you're using. On `usg-unix-v' and `xenix' this variable defaults
|
|
|
1001 to nil while on all other systems it defaults to t."
|
|
|
1002 :group 'gnus-start
|
|
|
1003 :type 'boolean)
|
|
|
1004
|
|
|
1005 (defcustom gnus-kill-files-directory gnus-directory
|
|
|
1006 "*Name of the directory where kill files will be stored (default \"~/News\")."
|
|
|
1007 :group 'gnus-score-files
|
|
|
1008 :group 'gnus-score-kill
|
|
|
1009 :type 'directory)
|
|
|
1010
|
|
|
1011 (defcustom gnus-save-score nil
|
|
|
1012 "*If non-nil, save group scoring info."
|
|
|
1013 :group 'gnus-score-various
|
|
|
1014 :group 'gnus-start
|
|
|
1015 :type 'boolean)
|
|
|
1016
|
|
|
1017 (defcustom gnus-use-undo t
|
|
|
1018 "*If non-nil, allow undoing in Gnus group mode buffers."
|
|
|
1019 :group 'gnus-meta
|
|
|
1020 :type 'boolean)
|
|
|
1021
|
|
|
1022 (defcustom gnus-use-adaptive-scoring nil
|
|
|
1023 "*If non-nil, use some adaptive scoring scheme.
|
|
|
1024 If a list, then the values `word' and `line' are meaningful. The
|
|
|
1025 former will perform adaption on individual words in the subject
|
|
|
1026 header while `line' will perform adaption on several headers."
|
|
|
1027 :group 'gnus-meta
|
|
|
1028 :group 'gnus-score-adapt
|
|
|
1029 :type '(set (const word) (const line)))
|
|
|
1030
|
|
|
1031 (defcustom gnus-use-cache 'passive
|
|
|
1032 "*If nil, Gnus will ignore the article cache.
|
|
|
1033 If `passive', it will allow entering (and reading) articles
|
|
|
1034 explicitly entered into the cache. If anything else, use the
|
|
|
1035 cache to the full extent of the law."
|
|
|
1036 :group 'gnus-meta
|
|
|
1037 :group 'gnus-cache
|
|
|
1038 :type '(choice (const :tag "off" nil)
|
|
|
1039 (const :tag "passive" passive)
|
|
|
1040 (const :tag "active" t)))
|
|
70
|
1041
|
|
98
|
1042 (defcustom gnus-use-trees nil
|
|
|
1043 "*If non-nil, display a thread tree buffer."
|
|
|
1044 :group 'gnus-meta
|
|
|
1045 :type 'boolean)
|
|
|
1046
|
|
|
1047 (defcustom gnus-use-grouplens nil
|
|
|
1048 "*If non-nil, use GroupLens ratings."
|
|
|
1049 :group 'gnus-meta
|
|
|
1050 :type 'boolean)
|
|
|
1051
|
|
|
1052 (defcustom gnus-keep-backlog nil
|
|
|
1053 "*If non-nil, Gnus will keep read articles for later re-retrieval.
|
|
|
1054 If it is a number N, then Gnus will only keep the last N articles
|
|
|
1055 read. If it is neither nil nor a number, Gnus will keep all read
|
|
|
1056 articles. This is not a good idea."
|
|
|
1057 :group 'gnus-meta
|
|
|
1058 :type '(choice (const :tag "off" nil)
|
|
|
1059 integer
|
|
108
|
1060 (sexp :format "all"
|
|
98
|
1061 :value t)))
|
|
|
1062
|
|
|
1063 (defcustom gnus-use-nocem nil
|
|
|
1064 "*If non-nil, Gnus will read NoCeM cancel messages."
|
|
|
1065 :group 'gnus-meta
|
|
|
1066 :type 'boolean)
|
|
|
1067
|
|
|
1068 (defcustom gnus-suppress-duplicates nil
|
|
|
1069 "*If non-nil, Gnus will mark duplicate copies of the same article as read."
|
|
|
1070 :group 'gnus-meta
|
|
|
1071 :type 'boolean)
|
|
|
1072
|
|
|
1073 (defcustom gnus-use-demon nil
|
|
|
1074 "If non-nil, Gnus might use some demons."
|
|
|
1075 :group 'gnus-meta
|
|
|
1076 :type 'boolean)
|
|
|
1077
|
|
|
1078 (defcustom gnus-use-scoring t
|
|
|
1079 "*If non-nil, enable scoring."
|
|
|
1080 :group 'gnus-meta
|
|
|
1081 :type 'boolean)
|
|
|
1082
|
|
|
1083 (defcustom gnus-use-picons nil
|
|
|
1084 "*If non-nil, display picons."
|
|
|
1085 :group 'gnus-meta
|
|
|
1086 :type 'boolean)
|
|
|
1087
|
|
108
|
1088 (defcustom gnus-summary-prepare-exit-hook
|
|
98
|
1089 '(gnus-summary-expire-articles)
|
|
|
1090 "A hook called when preparing to exit from the summary buffer.
|
|
|
1091 It calls `gnus-summary-expire-articles' by default."
|
|
|
1092 :group 'gnus-summary-exit
|
|
|
1093 :type 'hook)
|
|
|
1094
|
|
|
1095 (defcustom gnus-novice-user t
|
|
|
1096 "*Non-nil means that you are a usenet novice.
|
|
|
1097 If non-nil, verbose messages may be displayed and confirmations may be
|
|
|
1098 required."
|
|
|
1099 :group 'gnus-meta
|
|
|
1100 :type 'boolean)
|
|
|
1101
|
|
|
1102 (defcustom gnus-expert-user nil
|
|
|
1103 "*Non-nil means that you will never be asked for confirmation about anything.
|
|
|
1104 And that means *anything*."
|
|
|
1105 :group 'gnus-meta
|
|
|
1106 :type 'boolean)
|
|
|
1107
|
|
|
1108 (defcustom gnus-interactive-catchup t
|
|
|
1109 "*If non-nil, require your confirmation when catching up a group."
|
|
|
1110 :group 'gnus-group-select
|
|
|
1111 :type 'boolean)
|
|
|
1112
|
|
|
1113 (defcustom gnus-interactive-exit t
|
|
|
1114 "*If non-nil, require your confirmation when exiting Gnus."
|
|
|
1115 :group 'gnus-exit
|
|
|
1116 :type 'boolean)
|
|
|
1117
|
|
|
1118 (defcustom gnus-extract-address-components 'gnus-extract-address-components
|
|
|
1119 "*Function for extracting address components from a From header.
|
|
|
1120 Two pre-defined function exist: `gnus-extract-address-components',
|
|
|
1121 which is the default, quite fast, and too simplistic solution, and
|
|
|
1122 `mail-extract-address-components', which works much better, but is
|
|
|
1123 slower."
|
|
|
1124 :group 'gnus-summary-format
|
|
|
1125 :type '(radio (function-item gnus-extract-address-components)
|
|
|
1126 (function-item mail-extract-address-components)
|
|
|
1127 (function :tag "Other")))
|
|
|
1128
|
|
|
1129 (defcustom gnus-carpal nil
|
|
|
1130 "*If non-nil, display clickable icons."
|
|
|
1131 :group 'gnus-meta
|
|
|
1132 :type 'boolean)
|
|
|
1133
|
|
|
1134 (defcustom gnus-shell-command-separator ";"
|
|
|
1135 "String used to separate to shell commands."
|
|
|
1136 :group 'gnus-files
|
|
|
1137 :type 'string)
|
|
|
1138
|
|
|
1139 (defcustom gnus-valid-select-methods
|
|
|
1140 '(("nntp" post address prompt-address physical-address)
|
|
|
1141 ("nnspool" post address)
|
|
|
1142 ("nnvirtual" post-mail virtual prompt-address)
|
|
|
1143 ("nnmbox" mail respool address)
|
|
|
1144 ("nnml" mail respool address)
|
|
|
1145 ("nnmh" mail respool address)
|
|
|
1146 ("nndir" post-mail prompt-address physical-address)
|
|
|
1147 ("nneething" none address prompt-address physical-address)
|
|
|
1148 ("nndoc" none address prompt-address)
|
|
|
1149 ("nnbabyl" mail address respool)
|
|
|
1150 ("nnkiboze" post virtual)
|
|
|
1151 ("nnsoup" post-mail address)
|
|
|
1152 ("nndraft" post-mail)
|
|
|
1153 ("nnfolder" mail respool address)
|
|
|
1154 ("nngateway" none address prompt-address physical-address)
|
|
|
1155 ("nnweb" none))
|
|
|
1156 "An alist of valid select methods.
|
|
|
1157 The first element of each list lists should be a string with the name
|
|
|
1158 of the select method. The other elements may be the category of
|
|
|
1159 this method (i. e., `post', `mail', `none' or whatever) or other
|
|
|
1160 properties that this method has (like being respoolable).
|
|
|
1161 If you implement a new select method, all you should have to change is
|
|
|
1162 this variable. I think."
|
|
|
1163 :group 'gnus-server
|
|
|
1164 :type '(repeat (group (string :tag "Name")
|
|
|
1165 (radio-button-choice (const :format "%v " post)
|
|
|
1166 (const :format "%v " mail)
|
|
|
1167 (const :format "%v " none)
|
|
|
1168 (const post-mail))
|
|
|
1169 (checklist :inline t
|
|
|
1170 (const :format "%v " address)
|
|
|
1171 (const :format "%v " prompt-address)
|
|
|
1172 (const :format "%v " virtual)
|
|
|
1173 (const respool)))))
|
|
|
1174
|
|
|
1175 (define-widget 'gnus-select-method 'list
|
|
|
1176 "Widget for entering a select method."
|
|
|
1177 :args `((choice :tag "Method"
|
|
|
1178 ,@(mapcar (lambda (entry)
|
|
|
1179 (list 'const :format "%v\n"
|
|
|
1180 (intern (car entry))))
|
|
|
1181 gnus-valid-select-methods))
|
|
|
1182 (string :tag "Address")
|
|
|
1183 (editable-list :inline t
|
|
|
1184 (list :format "%v"
|
|
108
|
1185 variable
|
|
98
|
1186 (sexp :tag "Value")))))
|
|
|
1187
|
|
|
1188 (defcustom gnus-updated-mode-lines '(group article summary tree)
|
|
|
1189 "List of buffers that should update their mode lines.
|
|
|
1190 The list may contain the symbols `group', `article', `tree' and
|
|
|
1191 `summary'. If the corresponding symbol is present, Gnus will keep
|
|
|
1192 that mode line updated with information that may be pertinent.
|
|
|
1193 If this variable is nil, screen refresh may be quicker."
|
|
|
1194 :group 'gnus-various
|
|
|
1195 :type '(set (const group)
|
|
|
1196 (const article)
|
|
|
1197 (const summary)
|
|
|
1198 (const tree)))
|
|
|
1199
|
|
|
1200 ;; Added by Keinonen Kari <kk85613@cs.tut.fi>.
|
|
|
1201 (defcustom gnus-mode-non-string-length nil
|
|
|
1202 "*Max length of mode-line non-string contents.
|
|
|
1203 If this is nil, Gnus will take space as is needed, leaving the rest
|
|
|
1204 of the modeline intact. Note that the default of nil is unlikely
|
|
|
1205 to be desirable; see the manual for further details."
|
|
|
1206 :group 'gnus-various
|
|
|
1207 :type '(choice (const nil)
|
|
|
1208 integer))
|
|
70
|
1209
|
|
98
|
1210 (defcustom gnus-auto-expirable-newsgroups nil
|
|
|
1211 "*Groups in which to automatically mark read articles as expirable.
|
|
|
1212 If non-nil, this should be a regexp that should match all groups in
|
|
|
1213 which to perform auto-expiry. This only makes sense for mail groups."
|
|
100
|
1214 :group 'nnmail-expire
|
|
98
|
1215 :type '(choice (const nil)
|
|
|
1216 regexp))
|
|
|
1217
|
|
|
1218 (defcustom gnus-total-expirable-newsgroups nil
|
|
|
1219 "*Groups in which to perform expiry of all read articles.
|
|
|
1220 Use with extreme caution. All groups that match this regexp will be
|
|
|
1221 expiring - which means that all read articles will be deleted after
|
|
|
1222 \(say) one week. (This only goes for mail groups and the like, of
|
|
|
1223 course.)"
|
|
100
|
1224 :group 'nnmail-expire
|
|
98
|
1225 :type '(choice (const nil)
|
|
|
1226 regexp))
|
|
|
1227
|
|
|
1228 (defcustom gnus-group-uncollapsed-levels 1
|
|
|
1229 "Number of group name elements to leave alone when making a short group name."
|
|
|
1230 :group 'gnus-group-visual
|
|
|
1231 :type 'integer)
|
|
|
1232
|
|
|
1233 (defcustom gnus-group-use-permanent-levels nil
|
|
|
1234 "*If non-nil, once you set a level, Gnus will use this level."
|
|
|
1235 :group 'gnus-group-levels
|
|
|
1236 :type 'boolean)
|
|
|
1237
|
|
|
1238 ;; Hooks.
|
|
|
1239
|
|
|
1240 (defcustom gnus-load-hook nil
|
|
|
1241 "A hook run while Gnus is loaded."
|
|
|
1242 :group 'gnus-start
|
|
|
1243 :type 'hook)
|
|
|
1244
|
|
|
1245 (defcustom gnus-apply-kill-hook '(gnus-apply-kill-file)
|
|
|
1246 "A hook called to apply kill files to a group.
|
|
|
1247 This hook is intended to apply a kill file to the selected newsgroup.
|
|
|
1248 The function `gnus-apply-kill-file' is called by default.
|
|
|
1249
|
|
|
1250 Since a general kill file is too heavy to use only for a few
|
|
|
1251 newsgroups, I recommend you to use a lighter hook function. For
|
|
|
1252 example, if you'd like to apply a kill file to articles which contains
|
|
|
1253 a string `rmgroup' in subject in newsgroup `control', you can use the
|
|
|
1254 following hook:
|
|
|
1255
|
|
|
1256 (setq gnus-apply-kill-hook
|
|
|
1257 (list
|
|
|
1258 (lambda ()
|
|
|
1259 (cond ((string-match \"control\" gnus-newsgroup-name)
|
|
|
1260 (gnus-kill \"Subject\" \"rmgroup\")
|
|
|
1261 (gnus-expunge \"X\"))))))"
|
|
|
1262 :group 'gnus-score-kill
|
|
|
1263 :options '(gnus-apply-kill-file)
|
|
|
1264 :type 'hook)
|
|
|
1265
|
|
|
1266 (defcustom gnus-group-change-level-function nil
|
|
|
1267 "Function run when a group level is changed.
|
|
|
1268 It is called with three parameters -- GROUP, LEVEL and OLDLEVEL."
|
|
|
1269 :group 'gnus-group-level
|
|
|
1270 :type 'function)
|
|
|
1271
|
|
|
1272 ;;; Face thingies.
|
|
|
1273
|
|
108
|
1274 (defcustom gnus-visual
|
|
|
1275 '(summary-highlight group-highlight article-highlight
|
|
98
|
1276 mouse-face
|
|
|
1277 summary-menu group-menu article-menu
|
|
|
1278 tree-highlight menu highlight
|
|
|
1279 browse-menu server-menu
|
|
|
1280 page-marker tree-menu binary-menu pick-menu
|
|
|
1281 grouplens-menu)
|
|
|
1282 "Enable visual features.
|
|
|
1283 If `visual' is disabled, there will be no menus and few faces. Most of
|
|
|
1284 the visual customization options below will be ignored. Gnus will use
|
|
|
1285 less space and be faster as a result.
|
|
|
1286
|
|
|
1287 This variable can also be a list of visual elements to switch on. For
|
|
|
1288 instance, to switch off all visual things except menus, you can say:
|
|
|
1289
|
|
|
1290 (setq gnus-visual '(menu))
|
|
|
1291
|
|
|
1292 Valid elements include `summary-highlight', `group-highlight',
|
|
|
1293 `article-highlight', `mouse-face', `summary-menu', `group-menu',
|
|
|
1294 `article-menu', `tree-highlight', `menu', `highlight', `browse-menu',
|
|
|
1295 `server-menu', `page-marker', `tree-menu', `binary-menu', `pick-menu',
|
|
|
1296 and `grouplens-menu'."
|
|
|
1297 :group 'gnus-meta
|
|
|
1298 :group 'gnus-visual
|
|
|
1299 :type '(set (const summary-highlight)
|
|
|
1300 (const group-highlight)
|
|
|
1301 (const article-highlight)
|
|
|
1302 (const mouse-face)
|
|
|
1303 (const summary-menu)
|
|
|
1304 (const group-menu)
|
|
|
1305 (const article-menu)
|
|
|
1306 (const tree-highlight)
|
|
|
1307 (const menu)
|
|
|
1308 (const highlight)
|
|
|
1309 (const browse-menu)
|
|
|
1310 (const server-menu)
|
|
|
1311 (const page-marker)
|
|
|
1312 (const tree-menu)
|
|
|
1313 (const binary-menu)
|
|
|
1314 (const pick-menu)
|
|
|
1315 (const grouplens-menu)))
|
|
|
1316
|
|
|
1317 (defcustom gnus-mouse-face
|
|
|
1318 (condition-case ()
|
|
|
1319 (if (gnus-visual-p 'mouse-face 'highlight)
|
|
|
1320 (if (boundp 'gnus-mouse-face)
|
|
|
1321 (or gnus-mouse-face 'highlight)
|
|
|
1322 'highlight)
|
|
|
1323 'default)
|
|
|
1324 (error 'highlight))
|
|
|
1325 "Face used for group or summary buffer mouse highlighting.
|
|
|
1326 The line beneath the mouse pointer will be highlighted with this
|
|
|
1327 face."
|
|
|
1328 :group 'gnus-visual
|
|
|
1329 :type 'face)
|
|
|
1330
|
|
|
1331 (defcustom gnus-article-display-hook
|
|
|
1332 (if (and (string-match "XEmacs" emacs-version)
|
|
|
1333 (featurep 'xface))
|
|
|
1334 '(gnus-article-hide-headers-if-wanted
|
|
|
1335 gnus-article-hide-boring-headers
|
|
|
1336 gnus-article-treat-overstrike
|
|
|
1337 gnus-article-maybe-highlight
|
|
|
1338 gnus-article-display-x-face)
|
|
|
1339 '(gnus-article-hide-headers-if-wanted
|
|
|
1340 gnus-article-hide-boring-headers
|
|
|
1341 gnus-article-treat-overstrike
|
|
|
1342 gnus-article-maybe-highlight))
|
|
|
1343 "Controls how the article buffer will look.
|
|
|
1344
|
|
|
1345 If you leave the list empty, the article will appear exactly as it is
|
|
|
1346 stored on the disk. The list entries will hide or highlight various
|
|
|
1347 parts of the article, making it easier to find the information you
|
|
|
1348 want."
|
|
|
1349 :group 'gnus-article-highlight
|
|
|
1350 :group 'gnus-visual
|
|
|
1351 :type 'hook
|
|
|
1352 :options '(gnus-article-add-buttons
|
|
|
1353 gnus-article-add-buttons-to-head
|
|
|
1354 gnus-article-emphasize
|
|
|
1355 gnus-article-fill-cited-article
|
|
|
1356 gnus-article-remove-cr
|
|
|
1357 gnus-article-de-quoted-unreadable
|
|
|
1358 gnus-summary-stop-page-breaking
|
|
|
1359 ;; gnus-summary-caesar-message
|
|
|
1360 ;; gnus-summary-verbose-headers
|
|
|
1361 gnus-summary-toggle-mime
|
|
|
1362 gnus-article-hide
|
|
|
1363 gnus-article-hide-headers
|
|
|
1364 gnus-article-hide-boring-headers
|
|
|
1365 gnus-article-hide-signature
|
|
|
1366 gnus-article-hide-citation
|
|
|
1367 gnus-article-hide-pgp
|
|
|
1368 gnus-article-hide-pem
|
|
|
1369 gnus-article-highlight
|
|
|
1370 gnus-article-highlight-headers
|
|
|
1371 gnus-article-highlight-citation
|
|
|
1372 gnus-article-highlight-signature
|
|
|
1373 gnus-article-date-ut
|
|
|
1374 gnus-article-date-local
|
|
|
1375 gnus-article-date-lapsed
|
|
|
1376 gnus-article-date-original
|
|
|
1377 gnus-article-remove-trailing-blank-lines
|
|
|
1378 gnus-article-strip-leading-blank-lines
|
|
|
1379 gnus-article-strip-multiple-blank-lines
|
|
|
1380 gnus-article-strip-blank-lines
|
|
136
|
1381 gnus-article-treat-overstrike
|
|
|
1382 gnus-article-display-x-face
|
|
|
1383 gnus-smiley-display))
|
|
108
|
1384
|
|
|
1385 (defcustom gnus-article-save-directory gnus-directory
|
|
|
1386 "*Name of the directory articles will be saved in (default \"~/News\")."
|
|
|
1387 :group 'gnus-article-saving
|
|
|
1388 :type 'directory)
|
|
70
|
1389
|
|
98
|
1390
|
|
|
1391 ;;; Internal variables
|
|
|
1392
|
|
|
1393 (defvar gnus-group-get-parameter-function 'gnus-group-get-parameter)
|
|
|
1394 (defvar gnus-original-article-buffer " *Original Article*")
|
|
|
1395 (defvar gnus-newsgroup-name nil)
|
|
|
1396
|
|
|
1397 (defvar gnus-current-select-method nil
|
|
|
1398 "The current method for selecting a newsgroup.")
|
|
|
1399
|
|
|
1400 (defvar gnus-tree-buffer "*Tree*"
|
|
|
1401 "Buffer where Gnus thread trees are displayed.")
|
|
|
1402
|
|
|
1403 ;; Dummy variable.
|
|
|
1404 (defvar gnus-use-generic-from nil)
|
|
|
1405
|
|
|
1406 ;; Variable holding the user answers to all method prompts.
|
|
|
1407 (defvar gnus-method-history nil)
|
|
|
1408 (defvar gnus-group-history nil)
|
|
|
1409
|
|
|
1410 ;; Variable holding the user answers to all mail method prompts.
|
|
|
1411 (defvar gnus-mail-method-history nil)
|
|
|
1412
|
|
|
1413 ;; Variable holding the user answers to all group prompts.
|
|
|
1414 (defvar gnus-group-history nil)
|
|
|
1415
|
|
|
1416 (defvar gnus-server-alist nil
|
|
|
1417 "List of available servers.")
|
|
|
1418
|
|
|
1419 (defvar gnus-predefined-server-alist
|
|
|
1420 `(("cache"
|
|
|
1421 (nnspool "cache"
|
|
|
1422 (nnspool-spool-directory "~/News/cache/")
|
|
|
1423 (nnspool-nov-directory "~/News/cache/")
|
|
|
1424 (nnspool-active-file "~/News/cache/active"))))
|
|
|
1425 "List of predefined (convenience) servers.")
|
|
|
1426
|
|
|
1427 (defvar gnus-topic-indentation "") ;; Obsolete variable.
|
|
|
1428
|
|
|
1429 (defconst gnus-article-mark-lists
|
|
|
1430 '((marked . tick) (replied . reply)
|
|
|
1431 (expirable . expire) (killed . killed)
|
|
|
1432 (bookmarks . bookmark) (dormant . dormant)
|
|
|
1433 (scored . score) (saved . save)
|
|
|
1434 (cached . cache)))
|
|
|
1435
|
|
|
1436 (defvar gnus-headers-retrieved-by nil)
|
|
|
1437 (defvar gnus-article-reply nil)
|
|
|
1438 (defvar gnus-override-method nil)
|
|
|
1439 (defvar gnus-article-check-size nil)
|
|
|
1440 (defvar gnus-opened-servers nil)
|
|
|
1441
|
|
|
1442 (defvar gnus-current-kill-article nil)
|
|
|
1443
|
|
|
1444 (defvar gnus-have-read-active-file nil)
|
|
|
1445
|
|
|
1446 (defconst gnus-maintainer
|
|
118
|
1447 "bugs@gnus.org (The Gnus Bugfixing Girls + Boys)"
|
|
98
|
1448 "The mail address of the Gnus maintainers.")
|
|
|
1449
|
|
|
1450 (defvar gnus-info-nodes
|
|
|
1451 '((gnus-group-mode "(gnus)The Group Buffer")
|
|
|
1452 (gnus-summary-mode "(gnus)The Summary Buffer")
|
|
|
1453 (gnus-article-mode "(gnus)The Article Buffer")
|
|
|
1454 (mime/viewer-mode "(gnus)The Article Buffer")
|
|
|
1455 (gnus-server-mode "(gnus)The Server Buffer")
|
|
|
1456 (gnus-browse-mode "(gnus)Browse Foreign Server")
|
|
|
1457 (gnus-tree-mode "(gnus)Tree Display"))
|
|
|
1458 "Alist of major modes and related Info nodes.")
|
|
|
1459
|
|
|
1460 (defvar gnus-group-buffer "*Group*")
|
|
|
1461 (defvar gnus-summary-buffer "*Summary*")
|
|
|
1462 (defvar gnus-article-buffer "*Article*")
|
|
|
1463 (defvar gnus-server-buffer "*Server*")
|
|
|
1464
|
|
|
1465 (defvar gnus-buffer-list nil
|
|
|
1466 "Gnus buffers that should be killed on exit.")
|
|
|
1467
|
|
|
1468 (defvar gnus-slave nil
|
|
|
1469 "Whether this Gnus is a slave or not.")
|
|
|
1470
|
|
|
1471 (defvar gnus-batch-mode nil
|
|
|
1472 "Whether this Gnus is running in batch mode or not.")
|
|
|
1473
|
|
|
1474 (defvar gnus-variable-list
|
|
|
1475 '(gnus-newsrc-options gnus-newsrc-options-n
|
|
|
1476 gnus-newsrc-last-checked-date
|
|
|
1477 gnus-newsrc-alist gnus-server-alist
|
|
|
1478 gnus-killed-list gnus-zombie-list
|
|
|
1479 gnus-topic-topology gnus-topic-alist
|
|
|
1480 gnus-format-specs)
|
|
|
1481 "Gnus variables saved in the quick startup file.")
|
|
|
1482
|
|
|
1483 (defvar gnus-newsrc-alist nil
|
|
|
1484 "Assoc list of read articles.
|
|
|
1485 gnus-newsrc-hashtb should be kept so that both hold the same information.")
|
|
|
1486
|
|
|
1487 (defvar gnus-newsrc-hashtb nil
|
|
|
1488 "Hashtable of gnus-newsrc-alist.")
|
|
|
1489
|
|
|
1490 (defvar gnus-killed-list nil
|
|
|
1491 "List of killed newsgroups.")
|
|
|
1492
|
|
|
1493 (defvar gnus-killed-hashtb nil
|
|
|
1494 "Hash table equivalent of gnus-killed-list.")
|
|
|
1495
|
|
|
1496 (defvar gnus-zombie-list nil
|
|
|
1497 "List of almost dead newsgroups.")
|
|
|
1498
|
|
|
1499 (defvar gnus-description-hashtb nil
|
|
|
1500 "Descriptions of newsgroups.")
|
|
|
1501
|
|
|
1502 (defvar gnus-list-of-killed-groups nil
|
|
|
1503 "List of newsgroups that have recently been killed by the user.")
|
|
|
1504
|
|
|
1505 (defvar gnus-active-hashtb nil
|
|
|
1506 "Hashtable of active articles.")
|
|
|
1507
|
|
|
1508 (defvar gnus-moderated-hashtb nil
|
|
|
1509 "Hashtable of moderated newsgroups.")
|
|
|
1510
|
|
|
1511 ;; Save window configuration.
|
|
|
1512 (defvar gnus-prev-winconf nil)
|
|
|
1513
|
|
|
1514 (defvar gnus-reffed-article-number nil)
|
|
|
1515
|
|
|
1516 ;;; Let the byte-compiler know that we know about this variable.
|
|
|
1517 (defvar rmail-default-rmail-file)
|
|
|
1518
|
|
|
1519 (defvar gnus-dead-summary nil)
|
|
|
1520
|
|
|
1521 ;;; End of variables.
|
|
|
1522
|
|
|
1523 ;; Define some autoload functions Gnus might use.
|
|
|
1524 (eval-and-compile
|
|
|
1525
|
|
|
1526 ;; This little mapcar goes through the list below and marks the
|
|
|
1527 ;; symbols in question as autoloaded functions.
|
|
|
1528 (mapcar
|
|
|
1529 (lambda (package)
|
|
|
1530 (let ((interactive (nth 1 (memq ':interactive package))))
|
|
|
1531 (mapcar
|
|
|
1532 (lambda (function)
|
|
|
1533 (let (keymap)
|
|
|
1534 (when (consp function)
|
|
|
1535 (setq keymap (car (memq 'keymap function)))
|
|
|
1536 (setq function (car function)))
|
|
|
1537 (autoload function (car package) nil interactive keymap)))
|
|
|
1538 (if (eq (nth 1 package) ':interactive)
|
|
|
1539 (cdddr package)
|
|
|
1540 (cdr package)))))
|
|
|
1541 '(("metamail" metamail-buffer)
|
|
|
1542 ("info" Info-goto-node)
|
|
|
1543 ("hexl" hexl-hex-string-to-integer)
|
|
|
1544 ("pp" pp pp-to-string pp-eval-expression)
|
|
|
1545 ("ps-print" ps-print-preprint)
|
|
|
1546 ("mail-extr" mail-extract-address-components)
|
|
|
1547 ("message" :interactive t
|
|
|
1548 message-send-and-exit message-yank-original)
|
|
|
1549 ("nnmail" nnmail-split-fancy nnmail-article-group nnmail-date-to-time)
|
|
|
1550 ("nnvirtual" nnvirtual-catchup-group nnvirtual-convert-headers)
|
|
|
1551 ("timezone" timezone-make-date-arpa-standard timezone-fix-time
|
|
|
1552 timezone-make-sortable-date timezone-make-time-string)
|
|
|
1553 ("rmailout" rmail-output)
|
|
|
1554 ("rmail" rmail-insert-rmail-file-header rmail-count-new-messages
|
|
|
1555 rmail-show-message)
|
|
|
1556 ("gnus-audio" :interactive t gnus-audio-play)
|
|
|
1557 ("gnus-xmas" gnus-xmas-splash)
|
|
|
1558 ("gnus-soup" :interactive t
|
|
|
1559 gnus-group-brew-soup gnus-brew-soup gnus-soup-add-article
|
|
|
1560 gnus-soup-send-replies gnus-soup-save-areas gnus-soup-pack-packet)
|
|
|
1561 ("nnsoup" nnsoup-pack-replies)
|
|
|
1562 ("score-mode" :interactive t gnus-score-mode)
|
|
|
1563 ("gnus-mh" gnus-summary-save-article-folder
|
|
|
1564 gnus-Folder-save-name gnus-folder-save-name)
|
|
|
1565 ("gnus-mh" :interactive t gnus-summary-save-in-folder)
|
|
|
1566 ("gnus-demon" gnus-demon-add-nocem gnus-demon-add-scanmail
|
|
|
1567 gnus-demon-add-rescan gnus-demon-add-scan-timestamps
|
|
|
1568 gnus-demon-add-disconnection gnus-demon-add-handler
|
|
|
1569 gnus-demon-remove-handler)
|
|
|
1570 ("gnus-demon" :interactive t
|
|
|
1571 gnus-demon-init gnus-demon-cancel)
|
|
|
1572 ("gnus-salt" gnus-highlight-selected-tree gnus-possibly-generate-tree
|
|
|
1573 gnus-tree-open gnus-tree-close gnus-carpal-setup-buffer)
|
|
|
1574 ("gnus-nocem" gnus-nocem-scan-groups gnus-nocem-close
|
|
|
1575 gnus-nocem-unwanted-article-p)
|
|
|
1576 ("gnus-srvr" gnus-enter-server-buffer gnus-server-set-info)
|
|
|
1577 ("gnus-srvr" gnus-browse-foreign-server)
|
|
|
1578 ("gnus-cite" :interactive t
|
|
|
1579 gnus-article-highlight-citation gnus-article-hide-citation-maybe
|
|
|
1580 gnus-article-hide-citation gnus-article-fill-cited-article
|
|
|
1581 gnus-article-hide-citation-in-followups)
|
|
|
1582 ("gnus-kill" gnus-kill gnus-apply-kill-file-internal
|
|
|
1583 gnus-kill-file-edit-file gnus-kill-file-raise-followups-to-author
|
|
|
1584 gnus-execute gnus-expunge)
|
|
|
1585 ("gnus-cache" gnus-cache-possibly-enter-article gnus-cache-save-buffers
|
|
|
1586 gnus-cache-possibly-remove-articles gnus-cache-request-article
|
|
|
1587 gnus-cache-retrieve-headers gnus-cache-possibly-alter-active
|
|
|
1588 gnus-cache-enter-remove-article gnus-cached-article-p
|
|
|
1589 gnus-cache-open gnus-cache-close gnus-cache-update-article)
|
|
|
1590 ("gnus-cache" :interactive t gnus-jog-cache gnus-cache-enter-article
|
|
|
1591 gnus-cache-remove-article gnus-summary-insert-cached-articles)
|
|
|
1592 ("gnus-score" :interactive t
|
|
|
1593 gnus-summary-increase-score gnus-summary-set-score
|
|
|
1594 gnus-summary-raise-thread gnus-summary-raise-same-subject
|
|
|
1595 gnus-summary-raise-score gnus-summary-raise-same-subject-and-select
|
|
|
1596 gnus-summary-lower-thread gnus-summary-lower-same-subject
|
|
|
1597 gnus-summary-lower-score gnus-summary-lower-same-subject-and-select
|
|
|
1598 gnus-summary-current-score gnus-score-default
|
|
|
1599 gnus-score-flush-cache gnus-score-close
|
|
|
1600 gnus-possibly-score-headers gnus-score-followup-article
|
|
|
1601 gnus-score-followup-thread)
|
|
|
1602 ("gnus-score"
|
|
|
1603 (gnus-summary-score-map keymap) gnus-score-save gnus-score-headers
|
|
|
1604 gnus-current-score-file-nondirectory gnus-score-adaptive
|
|
|
1605 gnus-score-find-trace gnus-score-file-name)
|
|
|
1606 ("gnus-cus" :interactive t gnus-group-customize gnus-score-customize)
|
|
|
1607 ("gnus-topic" :interactive t gnus-topic-mode)
|
|
|
1608 ("gnus-topic" gnus-topic-remove-group gnus-topic-set-parameters)
|
|
|
1609 ("gnus-salt" :interactive t gnus-pick-mode gnus-binary-mode)
|
|
|
1610 ("gnus-uu" (gnus-uu-extract-map keymap) (gnus-uu-mark-map keymap))
|
|
|
1611 ("gnus-uu" :interactive t
|
|
|
1612 gnus-uu-digest-mail-forward gnus-uu-digest-post-forward
|
|
|
1613 gnus-uu-mark-series gnus-uu-mark-region gnus-uu-mark-buffer
|
|
|
1614 gnus-uu-mark-by-regexp gnus-uu-mark-all
|
|
|
1615 gnus-uu-mark-sparse gnus-uu-mark-thread gnus-uu-decode-uu
|
|
|
1616 gnus-uu-decode-uu-and-save gnus-uu-decode-unshar
|
|
|
1617 gnus-uu-decode-unshar-and-save gnus-uu-decode-save
|
|
|
1618 gnus-uu-decode-binhex gnus-uu-decode-uu-view
|
|
|
1619 gnus-uu-decode-uu-and-save-view gnus-uu-decode-unshar-view
|
|
|
1620 gnus-uu-decode-unshar-and-save-view gnus-uu-decode-save-view
|
|
|
1621 gnus-uu-decode-binhex-view)
|
|
100
|
1622 ("gnus-uu" gnus-uu-delete-work-dir gnus-quote-arg-for-sh-or-csh)
|
|
98
|
1623 ("gnus-msg" (gnus-summary-send-map keymap)
|
|
|
1624 gnus-article-mail gnus-copy-article-buffer gnus-extended-version)
|
|
|
1625 ("gnus-msg" :interactive t
|
|
|
1626 gnus-group-post-news gnus-group-mail gnus-summary-post-news
|
|
|
1627 gnus-summary-followup gnus-summary-followup-with-original
|
|
|
1628 gnus-summary-cancel-article gnus-summary-supersede-article
|
|
|
1629 gnus-post-news gnus-summary-reply gnus-summary-reply-with-original
|
|
|
1630 gnus-summary-mail-forward gnus-summary-mail-other-window
|
|
|
1631 gnus-summary-resend-message gnus-summary-resend-bounced-mail
|
|
|
1632 gnus-bug)
|
|
|
1633 ("gnus-picon" :interactive t gnus-article-display-picons
|
|
|
1634 gnus-group-display-picons gnus-picons-article-display-x-face
|
|
|
1635 gnus-picons-display-x-face)
|
|
108
|
1636 ("gnus-gl" bbb-login bbb-logout bbb-grouplens-group-p
|
|
98
|
1637 gnus-grouplens-mode)
|
|
|
1638 ("smiley" :interactive t gnus-smiley-display)
|
|
|
1639 ("gnus-win" gnus-configure-windows gnus-add-configuration)
|
|
|
1640 ("gnus-sum" gnus-summary-insert-line gnus-summary-read-group
|
|
|
1641 gnus-list-of-unread-articles gnus-list-of-read-articles
|
|
|
1642 gnus-offer-save-summaries gnus-make-thread-indent-array
|
|
|
1643 gnus-summary-exit gnus-update-read-articles)
|
|
|
1644 ("gnus-group" gnus-group-insert-group-line gnus-group-quit
|
|
|
1645 gnus-group-list-groups gnus-group-first-unread-group
|
|
|
1646 gnus-group-set-mode-line gnus-group-set-info gnus-group-save-newsrc
|
|
|
1647 gnus-group-setup-buffer gnus-group-get-new-news
|
|
|
1648 gnus-group-make-help-group gnus-group-update-group)
|
|
|
1649 ("gnus-bcklg" gnus-backlog-request-article gnus-backlog-enter-article
|
|
|
1650 gnus-backlog-remove-article)
|
|
|
1651 ("gnus-art" gnus-article-read-summary-keys gnus-article-save
|
|
|
1652 gnus-article-prepare gnus-article-set-window-start
|
|
|
1653 gnus-article-next-page gnus-article-prev-page
|
|
|
1654 gnus-request-article-this-buffer gnus-article-mode
|
|
108
|
1655 gnus-article-setup-buffer gnus-narrow-to-page
|
|
155
|
1656 gnus-article-delete-invisible-text gnus-hack-decode-rfc1522)
|
|
98
|
1657 ("gnus-art" :interactive t
|
|
|
1658 gnus-article-hide-headers gnus-article-hide-boring-headers
|
|
|
1659 gnus-article-treat-overstrike gnus-article-word-wrap
|
|
|
1660 gnus-article-remove-cr gnus-article-remove-trailing-blank-lines
|
|
|
1661 gnus-article-display-x-face gnus-article-de-quoted-unreadable
|
|
|
1662 gnus-article-mime-decode-quoted-printable gnus-article-hide-pgp
|
|
|
1663 gnus-article-hide-pem gnus-article-hide-signature
|
|
|
1664 gnus-article-strip-leading-blank-lines gnus-article-date-local
|
|
|
1665 gnus-article-date-original gnus-article-date-lapsed
|
|
108
|
1666 gnus-article-show-all-headers
|
|
98
|
1667 gnus-article-edit-mode gnus-article-edit-article
|
|
|
1668 gnus-article-edit-done gnus-decode-rfc1522 article-decode-rfc1522)
|
|
|
1669 ("gnus-int" gnus-request-type)
|
|
|
1670 ("gnus-start" gnus-newsrc-parse-options gnus-1 gnus-no-server-1
|
|
|
1671 gnus-dribble-enter)
|
|
|
1672 ("gnus-dup" gnus-dup-suppress-articles gnus-dup-unsuppress-article
|
|
|
1673 gnus-dup-enter-articles)
|
|
|
1674 ("gnus-range" gnus-copy-sequence)
|
|
|
1675 ("gnus-eform" gnus-edit-form)
|
|
|
1676 ("gnus-move" :interactive t
|
|
|
1677 gnus-group-move-group-to-server gnus-change-server)
|
|
|
1678 ("gnus-logic" gnus-score-advanced)
|
|
|
1679 ("gnus-undo" gnus-undo-mode gnus-undo-register)
|
|
|
1680 ("gnus-async" gnus-async-request-fetched-article gnus-async-prefetch-next
|
|
|
1681 gnus-async-prefetch-article gnus-async-prefetch-remove-group
|
|
|
1682 gnus-async-halt-prefetch)
|
|
|
1683 ("gnus-vm" :interactive t gnus-summary-save-in-vm
|
|
|
1684 gnus-summary-save-article-vm))))
|
|
|
1685
|
|
|
1686 ;;; gnus-sum.el thingies
|
|
|
1687
|
|
|
1688
|
|
|
1689 (defcustom gnus-summary-line-format "%U\%R\%z\%I\%(%[%4L: %-20,20n%]%) %s\n"
|
|
|
1690 "*The format specification of the lines in the summary buffer.
|
|
|
1691
|
|
|
1692 It works along the same lines as a normal formatting string,
|
|
|
1693 with some simple extensions.
|
|
|
1694
|
|
|
1695 %N Article number, left padded with spaces (string)
|
|
|
1696 %S Subject (string)
|
|
|
1697 %s Subject if it is at the root of a thread, and \"\" otherwise (string)
|
|
|
1698 %n Name of the poster (string)
|
|
|
1699 %a Extracted name of the poster (string)
|
|
|
1700 %A Extracted address of the poster (string)
|
|
|
1701 %F Contents of the From: header (string)
|
|
|
1702 %x Contents of the Xref: header (string)
|
|
|
1703 %D Date of the article (string)
|
|
|
1704 %d Date of the article (string) in DD-MMM format
|
|
|
1705 %M Message-id of the article (string)
|
|
|
1706 %r References of the article (string)
|
|
|
1707 %c Number of characters in the article (integer)
|
|
|
1708 %L Number of lines in the article (integer)
|
|
|
1709 %I Indentation based on thread level (a string of spaces)
|
|
|
1710 %T A string with two possible values: 80 spaces if the article
|
|
|
1711 is on thread level two or larger and 0 spaces on level one
|
|
|
1712 %R \"A\" if this article has been replied to, \" \" otherwise (character)
|
|
|
1713 %U Status of this article (character, \"R\", \"K\", \"-\" or \" \")
|
|
|
1714 %[ Opening bracket (character, \"[\" or \"<\")
|
|
|
1715 %] Closing bracket (character, \"]\" or \">\")
|
|
|
1716 %> Spaces of length thread-level (string)
|
|
|
1717 %< Spaces of length (- 20 thread-level) (string)
|
|
|
1718 %i Article score (number)
|
|
|
1719 %z Article zcore (character)
|
|
|
1720 %t Number of articles under the current thread (number).
|
|
|
1721 %e Whether the thread is empty or not (character).
|
|
|
1722 %l GroupLens score (string).
|
|
|
1723 %V Total thread score (number).
|
|
|
1724 %P The line number (number).
|
|
|
1725 %u User defined specifier. The next character in the format string should
|
|
|
1726 be a letter. Gnus will call the function gnus-user-format-function-X,
|
|
|
1727 where X is the letter following %u. The function will be passed the
|
|
|
1728 current header as argument. The function should return a string, which
|
|
|
1729 will be inserted into the summary just like information from any other
|
|
|
1730 summary specifier.
|
|
70
|
1731
|
|
98
|
1732 Text between %( and %) will be highlighted with `gnus-mouse-face'
|
|
|
1733 when the mouse point is placed inside the area. There can only be one
|
|
|
1734 such area.
|
|
|
1735
|
|
|
1736 The %U (status), %R (replied) and %z (zcore) specs have to be handled
|
|
|
1737 with care. For reasons of efficiency, Gnus will compute what column
|
|
|
1738 these characters will end up in, and \"hard-code\" that. This means that
|
|
|
1739 it is illegal to have these specs after a variable-length spec. Well,
|
|
|
1740 you might not be arrested, but your summary buffer will look strange,
|
|
|
1741 which is bad enough.
|
|
|
1742
|
|
|
1743 The smart choice is to have these specs as for to the left as
|
|
|
1744 possible.
|
|
|
1745
|
|
|
1746 This restriction may disappear in later versions of Gnus."
|
|
|
1747 :type 'string
|
|
|
1748 :group 'gnus-summary-format)
|
|
|
1749
|
|
|
1750 ;;;
|
|
|
1751 ;;; Skeleton keymaps
|
|
|
1752 ;;;
|
|
|
1753
|
|
|
1754 (defun gnus-suppress-keymap (keymap)
|
|
|
1755 (suppress-keymap keymap)
|
|
108
|
1756 (let ((keys `([delete] "\177" "\M-u"))) ;gnus-mouse-2
|
|
98
|
1757 (while keys
|
|
|
1758 (define-key keymap (pop keys) 'undefined))))
|
|
|
1759
|
|
|
1760 (defvar gnus-article-mode-map
|
|
|
1761 (let ((keymap (make-keymap)))
|
|
|
1762 (gnus-suppress-keymap keymap)
|
|
|
1763 keymap))
|
|
108
|
1764 (defvar gnus-summary-mode-map
|
|
98
|
1765 (let ((keymap (make-keymap)))
|
|
|
1766 (gnus-suppress-keymap keymap)
|
|
|
1767 keymap))
|
|
|
1768 (defvar gnus-group-mode-map
|
|
|
1769 (let ((keymap (make-keymap)))
|
|
|
1770 (gnus-suppress-keymap keymap)
|
|
|
1771 keymap))
|
|
|
1772
|
|
|
1773
|
|
|
1774
|
|
|
1775 ;; Fix by Hallvard B Furuseth <h.b.furuseth@usit.uio.no>.
|
|
|
1776 ;; If you want the cursor to go somewhere else, set these two
|
|
|
1777 ;; functions in some startup hook to whatever you want.
|
|
|
1778 (defalias 'gnus-summary-position-point 'gnus-goto-colon)
|
|
|
1779 (defalias 'gnus-group-position-point 'gnus-goto-colon)
|
|
|
1780
|
|
|
1781 ;;; Various macros and substs.
|
|
|
1782
|
|
|
1783 (defun gnus-header-from (header)
|
|
|
1784 (mail-header-from header))
|
|
|
1785
|
|
|
1786 (defmacro gnus-gethash (string hashtable)
|
|
|
1787 "Get hash value of STRING in HASHTABLE."
|
|
|
1788 `(symbol-value (intern-soft ,string ,hashtable)))
|
|
|
1789
|
|
|
1790 (defmacro gnus-sethash (string value hashtable)
|
|
|
1791 "Set hash value. Arguments are STRING, VALUE, and HASHTABLE."
|
|
|
1792 `(set (intern ,string ,hashtable) ,value))
|
|
|
1793 (put 'gnus-sethash 'edebug-form-spec '(form form form))
|
|
|
1794
|
|
|
1795 (defmacro gnus-group-unread (group)
|
|
|
1796 "Get the currently computed number of unread articles in GROUP."
|
|
|
1797 `(car (gnus-gethash ,group gnus-newsrc-hashtb)))
|
|
|
1798
|
|
|
1799 (defmacro gnus-group-entry (group)
|
|
|
1800 "Get the newsrc entry for GROUP."
|
|
|
1801 `(gnus-gethash ,group gnus-newsrc-hashtb))
|
|
|
1802
|
|
|
1803 (defmacro gnus-active (group)
|
|
|
1804 "Get active info on GROUP."
|
|
|
1805 `(gnus-gethash ,group gnus-active-hashtb))
|
|
|
1806
|
|
|
1807 (defmacro gnus-set-active (group active)
|
|
|
1808 "Set GROUP's active info."
|
|
|
1809 `(gnus-sethash ,group ,active gnus-active-hashtb))
|
|
70
|
1810
|
|
98
|
1811 (defun gnus-alive-p ()
|
|
|
1812 "Say whether Gnus is running or not."
|
|
|
1813 (and gnus-group-buffer
|
|
|
1814 (get-buffer gnus-group-buffer)
|
|
|
1815 (save-excursion
|
|
|
1816 (set-buffer gnus-group-buffer)
|
|
|
1817 (eq major-mode 'gnus-group-mode))))
|
|
|
1818
|
|
|
1819 ;; Info access macros.
|
|
|
1820
|
|
|
1821 (defmacro gnus-info-group (info)
|
|
|
1822 `(nth 0 ,info))
|
|
|
1823 (defmacro gnus-info-rank (info)
|
|
|
1824 `(nth 1 ,info))
|
|
|
1825 (defmacro gnus-info-read (info)
|
|
|
1826 `(nth 2 ,info))
|
|
|
1827 (defmacro gnus-info-marks (info)
|
|
|
1828 `(nth 3 ,info))
|
|
|
1829 (defmacro gnus-info-method (info)
|
|
|
1830 `(nth 4 ,info))
|
|
|
1831 (defmacro gnus-info-params (info)
|
|
|
1832 `(nth 5 ,info))
|
|
|
1833
|
|
|
1834 (defmacro gnus-info-level (info)
|
|
|
1835 `(let ((rank (gnus-info-rank ,info)))
|
|
|
1836 (if (consp rank)
|
|
|
1837 (car rank)
|
|
|
1838 rank)))
|
|
|
1839 (defmacro gnus-info-score (info)
|
|
|
1840 `(let ((rank (gnus-info-rank ,info)))
|
|
|
1841 (or (and (consp rank) (cdr rank)) 0)))
|
|
|
1842
|
|
|
1843 (defmacro gnus-info-set-group (info group)
|
|
|
1844 `(setcar ,info ,group))
|
|
|
1845 (defmacro gnus-info-set-rank (info rank)
|
|
|
1846 `(setcar (nthcdr 1 ,info) ,rank))
|
|
|
1847 (defmacro gnus-info-set-read (info read)
|
|
|
1848 `(setcar (nthcdr 2 ,info) ,read))
|
|
|
1849 (defmacro gnus-info-set-marks (info marks &optional extend)
|
|
|
1850 (if extend
|
|
|
1851 `(gnus-info-set-entry ,info ,marks 3)
|
|
|
1852 `(setcar (nthcdr 3 ,info) ,marks)))
|
|
|
1853 (defmacro gnus-info-set-method (info method &optional extend)
|
|
|
1854 (if extend
|
|
|
1855 `(gnus-info-set-entry ,info ,method 4)
|
|
|
1856 `(setcar (nthcdr 4 ,info) ,method)))
|
|
|
1857 (defmacro gnus-info-set-params (info params &optional extend)
|
|
|
1858 (if extend
|
|
|
1859 `(gnus-info-set-entry ,info ,params 5)
|
|
|
1860 `(setcar (nthcdr 5 ,info) ,params)))
|
|
|
1861
|
|
|
1862 (defun gnus-info-set-entry (info entry number)
|
|
|
1863 ;; Extend the info until we have enough elements.
|
|
|
1864 (while (<= (length info) number)
|
|
|
1865 (nconc info (list nil)))
|
|
|
1866 ;; Set the entry.
|
|
|
1867 (setcar (nthcdr number info) entry))
|
|
|
1868
|
|
|
1869 (defmacro gnus-info-set-level (info level)
|
|
|
1870 `(let ((rank (cdr ,info)))
|
|
|
1871 (if (consp (car rank))
|
|
|
1872 (setcar (car rank) ,level)
|
|
|
1873 (setcar rank ,level))))
|
|
|
1874 (defmacro gnus-info-set-score (info score)
|
|
|
1875 `(let ((rank (cdr ,info)))
|
|
|
1876 (if (consp (car rank))
|
|
|
1877 (setcdr (car rank) ,score)
|
|
|
1878 (setcar rank (cons (car rank) ,score)))))
|
|
|
1879
|
|
|
1880 (defmacro gnus-get-info (group)
|
|
|
1881 `(nth 2 (gnus-gethash ,group gnus-newsrc-hashtb)))
|
|
|
1882
|
|
|
1883 ;; Byte-compiler warning.
|
|
|
1884 (defvar gnus-visual)
|
|
|
1885 ;; Find out whether the gnus-visual TYPE is wanted.
|
|
|
1886 (defun gnus-visual-p (&optional type class)
|
|
|
1887 (and gnus-visual ; Has to be non-nil, at least.
|
|
|
1888 (if (not type) ; We don't care about type.
|
|
|
1889 gnus-visual
|
|
|
1890 (if (listp gnus-visual) ; It's a list, so we check it.
|
|
|
1891 (or (memq type gnus-visual)
|
|
|
1892 (memq class gnus-visual))
|
|
|
1893 t))))
|
|
|
1894
|
|
|
1895 ;;; Load the compatability functions.
|
|
|
1896
|
|
|
1897 (require 'gnus-ems)
|
|
70
|
1898
|
|
98
|
1899
|
|
|
1900 ;;;
|
|
|
1901 ;;; Shutdown
|
|
|
1902 ;;;
|
|
|
1903
|
|
|
1904 (defvar gnus-shutdown-alist nil)
|
|
|
1905
|
|
|
1906 (defun gnus-add-shutdown (function &rest symbols)
|
|
|
1907 "Run FUNCTION whenever one of SYMBOLS is shut down."
|
|
|
1908 (push (cons function symbols) gnus-shutdown-alist))
|
|
|
1909
|
|
|
1910 (defun gnus-shutdown (symbol)
|
|
|
1911 "Shut down everything that waits for SYMBOL."
|
|
|
1912 (let ((alist gnus-shutdown-alist)
|
|
|
1913 entry)
|
|
|
1914 (while (setq entry (pop alist))
|
|
|
1915 (when (memq symbol (cdr entry))
|
|
|
1916 (funcall (car entry))))))
|
|
|
1917
|
|
|
1918
|
|
|
1919 ;;;
|
|
|
1920 ;;; Gnus Utility Functions
|
|
|
1921 ;;;
|
|
|
1922
|
|
163
|
1923 (defmacro gnus-string-or (&rest strings)
|
|
|
1924 "Return the first element of STRINGS that is a non-blank string.
|
|
|
1925 STRINGS will be evaluated in normal `or' order."
|
|
|
1926 `(gnus-string-or-1 ',strings))
|
|
|
1927
|
|
|
1928 (defun gnus-string-or-1 (strings)
|
|
|
1929 (let (string)
|
|
|
1930 (while strings
|
|
|
1931 (setq string (eval (pop strings)))
|
|
|
1932 (if (string-match "^[ \t]*$" string)
|
|
|
1933 (setq string nil)
|
|
|
1934 (setq strings nil)))
|
|
|
1935 string))
|
|
|
1936
|
|
98
|
1937 ;; Add the current buffer to the list of buffers to be killed on exit.
|
|
|
1938 (defun gnus-add-current-to-buffer-list ()
|
|
|
1939 (or (memq (current-buffer) gnus-buffer-list)
|
|
|
1940 (push (current-buffer) gnus-buffer-list)))
|
|
|
1941
|
|
|
1942 (defun gnus-version (&optional arg)
|
|
|
1943 "Version number of this version of Gnus.
|
|
|
1944 If ARG, insert string at point."
|
|
|
1945 (interactive "P")
|
|
|
1946 (let ((methods gnus-valid-select-methods)
|
|
|
1947 (mess gnus-version)
|
|
|
1948 meth)
|
|
|
1949 ;; Go through all the legal select methods and add their version
|
|
|
1950 ;; numbers to the total version string. Only the backends that are
|
|
|
1951 ;; currently in use will have their message numbers taken into
|
|
|
1952 ;; consideration.
|
|
|
1953 (while methods
|
|
|
1954 (setq meth (intern (concat (caar methods) "-version")))
|
|
|
1955 (and (boundp meth)
|
|
|
1956 (stringp (symbol-value meth))
|
|
|
1957 (setq mess (concat mess "; " (symbol-value meth))))
|
|
|
1958 (setq methods (cdr methods)))
|
|
|
1959 (if arg
|
|
|
1960 (insert (message mess))
|
|
|
1961 (message mess))))
|
|
|
1962
|
|
|
1963 (defun gnus-continuum-version (version)
|
|
|
1964 "Return VERSION as a floating point number."
|
|
|
1965 (when (or (string-match "^\\([^ ]+\\)? ?Gnus v?\\([0-9.]+\\)$" version)
|
|
|
1966 (string-match "^\\(.?\\)gnus-\\([0-9.]+\\)$" version))
|
|
|
1967 (let* ((alpha (and (match-beginning 1) (match-string 1 version)))
|
|
|
1968 (number (match-string 2 version))
|
|
|
1969 major minor least)
|
|
|
1970 (string-match "\\([0-9]\\)\\.\\([0-9]+\\)\\.?\\([0-9]+\\)?" number)
|
|
|
1971 (setq major (string-to-number (match-string 1 number)))
|
|
|
1972 (setq minor (string-to-number (match-string 2 number)))
|
|
|
1973 (setq least (if (match-beginning 3)
|
|
|
1974 (string-to-number (match-string 3 number))
|
|
|
1975 0))
|
|
|
1976 (string-to-number
|
|
|
1977 (if (zerop major)
|
|
|
1978 (format "%s00%02d%02d"
|
|
108
|
1979 (cond
|
|
98
|
1980 ((member alpha '("(ding)" "d")) "4.99")
|
|
|
1981 ((member alpha '("September" "s")) "5.01")
|
|
|
1982 ((member alpha '("Red" "r")) "5.03"))
|
|
|
1983 minor least)
|
|
|
1984 (format "%d.%02d%02d" major minor least))))))
|
|
|
1985
|
|
|
1986 (defun gnus-info-find-node ()
|
|
|
1987 "Find Info documentation of Gnus."
|
|
|
1988 (interactive)
|
|
|
1989 ;; Enlarge info window if needed.
|
|
|
1990 (let (gnus-info-buffer)
|
|
|
1991 (Info-goto-node (cadr (assq major-mode gnus-info-nodes)))
|
|
|
1992 (setq gnus-info-buffer (current-buffer))
|
|
|
1993 (gnus-configure-windows 'info)))
|
|
|
1994
|
|
|
1995 ;;; More various functions.
|
|
70
|
1996
|
|
98
|
1997 (defun gnus-group-read-only-p (&optional group)
|
|
|
1998 "Check whether GROUP supports editing or not.
|
|
|
1999 If GROUP is nil, `gnus-newsgroup-name' will be checked instead. Note
|
|
|
2000 that that variable is buffer-local to the summary buffers."
|
|
|
2001 (let ((group (or group gnus-newsgroup-name)))
|
|
|
2002 (not (gnus-check-backend-function 'request-replace-article group))))
|
|
|
2003
|
|
|
2004 (defun gnus-group-total-expirable-p (group)
|
|
|
2005 "Check whether GROUP is total-expirable or not."
|
|
|
2006 (let ((params (gnus-group-find-parameter group))
|
|
|
2007 val)
|
|
|
2008 (cond
|
|
|
2009 ((memq 'total-expire params)
|
|
|
2010 t)
|
|
|
2011 ((setq val (assq 'total-expire params)) ; (auto-expire . t)
|
|
|
2012 (cdr val))
|
|
|
2013 (gnus-total-expirable-newsgroups ; Check var.
|
|
|
2014 (string-match gnus-total-expirable-newsgroups group)))))
|
|
|
2015
|
|
|
2016 (defun gnus-group-auto-expirable-p (group)
|
|
169
|
2017 "Check whether GROUP is auto-expirable or not."
|
|
98
|
2018 (let ((params (gnus-group-find-parameter group))
|
|
|
2019 val)
|
|
|
2020 (cond
|
|
|
2021 ((memq 'auto-expire params)
|
|
|
2022 t)
|
|
|
2023 ((setq val (assq 'auto-expire params)) ; (auto-expire . t)
|
|
|
2024 (cdr val))
|
|
|
2025 (gnus-auto-expirable-newsgroups ; Check var.
|
|
|
2026 (string-match gnus-auto-expirable-newsgroups group)))))
|
|
|
2027
|
|
|
2028 (defun gnus-virtual-group-p (group)
|
|
|
2029 "Say whether GROUP is virtual or not."
|
|
|
2030 (memq 'virtual (assoc (symbol-name (car (gnus-find-method-for-group group)))
|
|
|
2031 gnus-valid-select-methods)))
|
|
|
2032
|
|
|
2033 (defun gnus-news-group-p (group &optional article)
|
|
|
2034 "Return non-nil if GROUP (and ARTICLE) come from a news server."
|
|
|
2035 (or (gnus-member-of-valid 'post group) ; Ordinary news group.
|
|
|
2036 (and (gnus-member-of-valid 'post-mail group) ; Combined group.
|
|
|
2037 (eq (gnus-request-type group article) 'news))))
|
|
|
2038
|
|
|
2039 ;; Returns a list of writable groups.
|
|
|
2040 (defun gnus-writable-groups ()
|
|
|
2041 (let ((alist gnus-newsrc-alist)
|
|
|
2042 groups group)
|
|
|
2043 (while (setq group (car (pop alist)))
|
|
|
2044 (unless (gnus-group-read-only-p group)
|
|
|
2045 (push group groups)))
|
|
|
2046 (nreverse groups)))
|
|
|
2047
|
|
|
2048 ;; Check whether to use long file names.
|
|
|
2049 (defun gnus-use-long-file-name (symbol)
|
|
|
2050 ;; The variable has to be set...
|
|
|
2051 (and gnus-use-long-file-name
|
|
|
2052 ;; If it isn't a list, then we return t.
|
|
|
2053 (or (not (listp gnus-use-long-file-name))
|
|
|
2054 ;; If it is a list, and the list contains `symbol', we
|
|
|
2055 ;; return nil.
|
|
|
2056 (not (memq symbol gnus-use-long-file-name)))))
|
|
|
2057
|
|
|
2058 ;; Generate a unique new group name.
|
|
|
2059 (defun gnus-generate-new-group-name (leaf)
|
|
|
2060 (let ((name leaf)
|
|
|
2061 (num 0))
|
|
|
2062 (while (gnus-gethash name gnus-newsrc-hashtb)
|
|
|
2063 (setq name (concat leaf "<" (int-to-string (setq num (1+ num))) ">")))
|
|
|
2064 name))
|
|
|
2065
|
|
|
2066 (defun gnus-ephemeral-group-p (group)
|
|
|
2067 "Say whether GROUP is ephemeral or not."
|
|
|
2068 (gnus-group-get-parameter group 'quit-config))
|
|
|
2069
|
|
|
2070 (defun gnus-group-quit-config (group)
|
|
|
2071 "Return the quit-config of GROUP."
|
|
|
2072 (gnus-group-get-parameter group 'quit-config))
|
|
|
2073
|
|
|
2074 (defun gnus-kill-ephemeral-group (group)
|
|
|
2075 "Remove ephemeral GROUP from relevant structures."
|
|
|
2076 (gnus-sethash group nil gnus-newsrc-hashtb))
|
|
|
2077
|
|
|
2078 (defun gnus-simplify-mode-line ()
|
|
|
2079 "Make mode lines a bit simpler."
|
|
|
2080 (setq mode-line-modified "-- ")
|
|
|
2081 (when (listp mode-line-format)
|
|
|
2082 (make-local-variable 'mode-line-format)
|
|
|
2083 (setq mode-line-format (copy-sequence mode-line-format))
|
|
|
2084 (when (equal (nth 3 mode-line-format) " ")
|
|
|
2085 (setcar (nthcdr 3 mode-line-format) " "))))
|
|
|
2086
|
|
|
2087 ;;; Servers and groups.
|
|
0
|
2088
|
|
|
2089 (defsubst gnus-server-add-address (method)
|
|
|
2090 (let ((method-name (symbol-name (car method))))
|
|
|
2091 (if (and (memq 'address (assoc method-name gnus-valid-select-methods))
|
|
98
|
2092 (not (assq (intern (concat method-name "-address")) method))
|
|
108
|
2093 (memq 'physical-address (assq (car method)
|
|
98
|
2094 gnus-valid-select-methods)))
|
|
0
|
2095 (append method (list (list (intern (concat method-name "-address"))
|
|
|
2096 (nth 1 method))))
|
|
|
2097 method)))
|
|
|
2098
|
|
|
2099 (defsubst gnus-server-get-method (group method)
|
|
|
2100 ;; Input either a server name, and extended server name, or a
|
|
|
2101 ;; select method, and return a select method.
|
|
|
2102 (cond ((stringp method)
|
|
|
2103 (gnus-server-to-method method))
|
|
|
2104 ((equal method gnus-select-method)
|
|
|
2105 gnus-select-method)
|
|
|
2106 ((and (stringp (car method)) group)
|
|
|
2107 (gnus-server-extend-method group method))
|
|
|
2108 ((and method (not group)
|
|
|
2109 (equal (cadr method) ""))
|
|
|
2110 method)
|
|
|
2111 (t
|
|
|
2112 (gnus-server-add-address method))))
|
|
|
2113
|
|
|
2114 (defun gnus-server-to-method (server)
|
|
|
2115 "Map virtual server names to select methods."
|
|
108
|
2116 (or
|
|
0
|
2117 ;; Is this a method, perhaps?
|
|
|
2118 (and server (listp server) server)
|
|
|
2119 ;; Perhaps this is the native server?
|
|
|
2120 (and (equal server "native") gnus-select-method)
|
|
|
2121 ;; It should be in the server alist.
|
|
|
2122 (cdr (assoc server gnus-server-alist))
|
|
98
|
2123 ;; It could be in the predefined server alist.
|
|
|
2124 (cdr (assoc server gnus-predefined-server-alist))
|
|
0
|
2125 ;; If not, we look through all the opened server
|
|
|
2126 ;; to see whether we can find it there.
|
|
|
2127 (let ((opened gnus-opened-servers))
|
|
|
2128 (while (and opened
|
|
|
2129 (not (equal server (format "%s:%s" (caaar opened)
|
|
|
2130 (cadaar opened)))))
|
|
|
2131 (pop opened))
|
|
|
2132 (caar opened))))
|
|
|
2133
|
|
|
2134 (defmacro gnus-method-equal (ss1 ss2)
|
|
|
2135 "Say whether two servers are equal."
|
|
|
2136 `(let ((s1 ,ss1)
|
|
|
2137 (s2 ,ss2))
|
|
|
2138 (or (equal s1 s2)
|
|
|
2139 (and (= (length s1) (length s2))
|
|
|
2140 (progn
|
|
|
2141 (while (and s1 (member (car s1) s2))
|
|
|
2142 (setq s1 (cdr s1)))
|
|
|
2143 (null s1))))))
|
|
|
2144
|
|
|
2145 (defun gnus-server-equal (m1 m2)
|
|
|
2146 "Say whether two methods are equal."
|
|
|
2147 (let ((m1 (cond ((null m1) gnus-select-method)
|
|
|
2148 ((stringp m1) (gnus-server-to-method m1))
|
|
|
2149 (t m1)))
|
|
|
2150 (m2 (cond ((null m2) gnus-select-method)
|
|
|
2151 ((stringp m2) (gnus-server-to-method m2))
|
|
|
2152 (t m2))))
|
|
|
2153 (gnus-method-equal m1 m2)))
|
|
|
2154
|
|
|
2155 (defun gnus-servers-using-backend (backend)
|
|
|
2156 "Return a list of known servers using BACKEND."
|
|
|
2157 (let ((opened gnus-opened-servers)
|
|
|
2158 out)
|
|
|
2159 (while opened
|
|
|
2160 (when (eq backend (caaar opened))
|
|
|
2161 (push (caar opened) out))
|
|
|
2162 (pop opened))
|
|
|
2163 out))
|
|
|
2164
|
|
2
|
2165 (defun gnus-archive-server-wanted-p ()
|
|
|
2166 "Say whether the user wants to use the archive server."
|
|
108
|
2167 (cond
|
|
2
|
2168 ((or (not gnus-message-archive-method)
|
|
|
2169 (not gnus-message-archive-group))
|
|
|
2170 nil)
|
|
|
2171 ((and gnus-message-archive-method gnus-message-archive-group)
|
|
|
2172 t)
|
|
|
2173 (t
|
|
|
2174 (let ((active (cadr (assq 'nnfolder-active-file
|
|
|
2175 gnus-message-archive-method))))
|
|
|
2176 (and active
|
|
|
2177 (file-exists-p active))))))
|
|
|
2178
|
|
0
|
2179 (defun gnus-group-prefixed-name (group method)
|
|
|
2180 "Return the whole name from GROUP and METHOD."
|
|
|
2181 (and (stringp method) (setq method (gnus-server-to-method method)))
|
|
2
|
2182 (if (not method)
|
|
|
2183 group
|
|
|
2184 (concat (format "%s" (car method))
|
|
98
|
2185 (when (and
|
|
|
2186 (or (assoc (format "%s" (car method))
|
|
|
2187 (gnus-methods-using 'address))
|
|
|
2188 (gnus-server-equal method gnus-message-archive-method))
|
|
|
2189 (nth 1 method)
|
|
|
2190 (not (string= (nth 1 method) "")))
|
|
|
2191 (concat "+" (nth 1 method)))
|
|
2
|
2192 ":" group)))
|
|
0
|
2193
|
|
|
2194 (defun gnus-group-real-prefix (group)
|
|
|
2195 "Return the prefix of the current group name."
|
|
|
2196 (if (string-match "^[^:]+:" group)
|
|
|
2197 (substring group 0 (match-end 0))
|
|
|
2198 ""))
|
|
|
2199
|
|
|
2200 (defun gnus-group-method (group)
|
|
98
|
2201 "Return the server or method used for selecting GROUP.
|
|
|
2202 You should probably use `gnus-find-method-for-group' instead."
|
|
0
|
2203 (let ((prefix (gnus-group-real-prefix group)))
|
|
|
2204 (if (equal prefix "")
|
|
|
2205 gnus-select-method
|
|
|
2206 (let ((servers gnus-opened-servers)
|
|
|
2207 (server "")
|
|
|
2208 backend possible found)
|
|
|
2209 (if (string-match "^[^\\+]+\\+" prefix)
|
|
|
2210 (setq backend (intern (substring prefix 0 (1- (match-end 0))))
|
|
|
2211 server (substring prefix (match-end 0) (1- (length prefix))))
|
|
|
2212 (setq backend (intern (substring prefix 0 (1- (length prefix))))))
|
|
|
2213 (while servers
|
|
|
2214 (when (eq (caaar servers) backend)
|
|
|
2215 (setq possible (caar servers))
|
|
|
2216 (when (equal (cadaar servers) server)
|
|
|
2217 (setq found (caar servers))))
|
|
|
2218 (pop servers))
|
|
|
2219 (or (car (rassoc found gnus-server-alist))
|
|
|
2220 found
|
|
|
2221 (car (rassoc possible gnus-server-alist))
|
|
|
2222 possible
|
|
|
2223 (list backend server))))))
|
|
|
2224
|
|
|
2225 (defsubst gnus-secondary-method-p (method)
|
|
|
2226 "Return whether METHOD is a secondary select method."
|
|
|
2227 (let ((methods gnus-secondary-select-methods)
|
|
|
2228 (gmethod (gnus-server-get-method nil method)))
|
|
|
2229 (while (and methods
|
|
|
2230 (not (equal (gnus-server-get-method nil (car methods))
|
|
|
2231 gmethod)))
|
|
|
2232 (setq methods (cdr methods)))
|
|
|
2233 methods))
|
|
|
2234
|
|
|
2235 (defun gnus-group-foreign-p (group)
|
|
|
2236 "Say whether a group is foreign or not."
|
|
|
2237 (and (not (gnus-group-native-p group))
|
|
|
2238 (not (gnus-group-secondary-p group))))
|
|
|
2239
|
|
|
2240 (defun gnus-group-native-p (group)
|
|
|
2241 "Say whether the group is native or not."
|
|
|
2242 (not (string-match ":" group)))
|
|
|
2243
|
|
|
2244 (defun gnus-group-secondary-p (group)
|
|
|
2245 "Say whether the group is secondary or not."
|
|
|
2246 (gnus-secondary-method-p (gnus-find-method-for-group group)))
|
|
|
2247
|
|
98
|
2248 (defun gnus-group-find-parameter (group &optional symbol)
|
|
|
2249 "Return the group parameters for GROUP.
|
|
|
2250 If SYMBOL, return the value of that symbol in the group parameters."
|
|
|
2251 (save-excursion
|
|
|
2252 (set-buffer gnus-group-buffer)
|
|
|
2253 (let ((parameters (funcall gnus-group-get-parameter-function group)))
|
|
|
2254 (if symbol
|
|
|
2255 (gnus-group-parameter-value parameters symbol)
|
|
|
2256 parameters))))
|
|
|
2257
|
|
0
|
2258 (defun gnus-group-get-parameter (group &optional symbol)
|
|
98
|
2259 "Return the group parameters for GROUP.
|
|
0
|
2260 If SYMBOL, return the value of that symbol in the group parameters."
|
|
|
2261 (let ((params (gnus-info-params (gnus-get-info group))))
|
|
|
2262 (if symbol
|
|
|
2263 (gnus-group-parameter-value params symbol)
|
|
|
2264 params)))
|
|
|
2265
|
|
|
2266 (defun gnus-group-parameter-value (params symbol)
|
|
|
2267 "Return the value of SYMBOL in group PARAMS."
|
|
|
2268 (or (car (memq symbol params)) ; It's either a simple symbol
|
|
|
2269 (cdr (assq symbol params)))) ; or a cons.
|
|
|
2270
|
|
|
2271 (defun gnus-group-add-parameter (group param)
|
|
|
2272 "Add parameter PARAM to GROUP."
|
|
|
2273 (let ((info (gnus-get-info group)))
|
|
114
|
2274 (when info
|
|
|
2275 (gnus-group-remove-parameter group (if (consp param) (car param) param))
|
|
0
|
2276 ;; Cons the new param to the old one and update.
|
|
|
2277 (gnus-group-set-info (cons param (gnus-info-params info))
|
|
|
2278 group 'params))))
|
|
|
2279
|
|
|
2280 (defun gnus-group-set-parameter (group name value)
|
|
|
2281 "Set parameter NAME to VALUE in GROUP."
|
|
|
2282 (let ((info (gnus-get-info group)))
|
|
114
|
2283 (when info
|
|
|
2284 (gnus-group-remove-parameter group name)
|
|
0
|
2285 (let ((old-params (gnus-info-params info))
|
|
|
2286 (new-params (list (cons name value))))
|
|
|
2287 (while old-params
|
|
98
|
2288 (when (or (not (listp (car old-params)))
|
|
|
2289 (not (eq (caar old-params) name)))
|
|
|
2290 (setq new-params (append new-params (list (car old-params)))))
|
|
0
|
2291 (setq old-params (cdr old-params)))
|
|
|
2292 (gnus-group-set-info new-params group 'params)))))
|
|
|
2293
|
|
114
|
2294 (defun gnus-group-remove-parameter (group name)
|
|
|
2295 "Remove parameter NAME from GROUP."
|
|
|
2296 (let ((info (gnus-get-info group)))
|
|
|
2297 (when info
|
|
|
2298 (let ((params (gnus-info-params info)))
|
|
|
2299 (when params
|
|
|
2300 (setq params (delq name params))
|
|
|
2301 (while (assq name params)
|
|
|
2302 (setq params (delq (assq name params) params)))
|
|
|
2303 (gnus-info-set-params info params))))))
|
|
|
2304
|
|
0
|
2305 (defun gnus-group-add-score (group &optional score)
|
|
|
2306 "Add SCORE to the GROUP score.
|
|
|
2307 If SCORE is nil, add 1 to the score of GROUP."
|
|
|
2308 (let ((info (gnus-get-info group)))
|
|
|
2309 (when info
|
|
|
2310 (gnus-info-set-score info (+ (gnus-info-score info) (or score 1))))))
|
|
|
2311
|
|
98
|
2312 ;; Function written by Stainless Steel Rat <ratinox@peorth.gweep.net>
|
|
0
|
2313 (defun gnus-short-group-name (group &optional levels)
|
|
98
|
2314 "Collapse GROUP name LEVELS.
|
|
|
2315 Select methods are stripped and any remote host name is stripped down to
|
|
|
2316 just the host name."
|
|
|
2317 (let* ((name "") (foreign "") (depth -1) (skip 1)
|
|
0
|
2318 (levels (or levels
|
|
|
2319 (progn
|
|
|
2320 (while (string-match "\\." group skip)
|
|
|
2321 (setq skip (match-end 0)
|
|
|
2322 depth (+ depth 1)))
|
|
|
2323 depth))))
|
|
98
|
2324 ;; separate foreign select method from group name and collapse.
|
|
|
2325 ;; if method contains a server, collapse to non-domain server name,
|
|
|
2326 ;; otherwise collapse to select method
|
|
|
2327 (when (string-match ":" group)
|
|
|
2328 (cond ((string-match "+" group)
|
|
|
2329 (let* ((plus (string-match "+" group))
|
|
|
2330 (colon (string-match ":" group (or plus 0)))
|
|
|
2331 (dot (string-match "\\." group)))
|
|
|
2332 (setq foreign (concat
|
|
|
2333 (substring group (+ 1 plus)
|
|
|
2334 (cond ((null dot) colon)
|
|
|
2335 ((< colon dot) colon)
|
|
|
2336 ((< dot colon) dot)))
|
|
|
2337 ":")
|
|
|
2338 group (substring group (+ 1 colon)))))
|
|
|
2339 (t
|
|
|
2340 (let* ((colon (string-match ":" group)))
|
|
|
2341 (setq foreign (concat (substring group 0 (+ 1 colon)))
|
|
|
2342 group (substring group (+ 1 colon)))))))
|
|
|
2343 ;; collapse group name leaving LEVELS uncollapsed elements
|
|
0
|
2344 (while group
|
|
98
|
2345 (if (and (string-match "\\." group) (> levels 0))
|
|
0
|
2346 (setq name (concat name (substring group 0 1))
|
|
|
2347 group (substring group (match-end 0))
|
|
|
2348 levels (- levels 1)
|
|
|
2349 name (concat name "."))
|
|
|
2350 (setq name (concat foreign name group)
|
|
|
2351 group nil)))
|
|
|
2352 name))
|
|
|
2353
|
|
104
|
2354 (defun gnus-narrow-to-body ()
|
|
|
2355 "Narrow to the body of an article."
|
|
|
2356 (narrow-to-region
|
|
|
2357 (progn
|
|
|
2358 (goto-char (point-min))
|
|
|
2359 (or (search-forward "\n\n" nil t)
|
|
|
2360 (point-max)))
|
|
|
2361 (point-max)))
|
|
|
2362
|
|
0
|
2363
|
|
|
2364 ;;;
|
|
|
2365 ;;; Kill file handling.
|
|
|
2366 ;;;
|
|
|
2367
|
|
|
2368 (defun gnus-apply-kill-file ()
|
|
|
2369 "Apply a kill file to the current newsgroup.
|
|
|
2370 Returns the number of articles marked as read."
|
|
|
2371 (if (or (file-exists-p (gnus-newsgroup-kill-file nil))
|
|
|
2372 (file-exists-p (gnus-newsgroup-kill-file gnus-newsgroup-name)))
|
|
|
2373 (gnus-apply-kill-file-internal)
|
|
|
2374 0))
|
|
|
2375
|
|
|
2376 (defun gnus-kill-save-kill-buffer ()
|
|
|
2377 (let ((file (gnus-newsgroup-kill-file gnus-newsgroup-name)))
|
|
|
2378 (when (get-file-buffer file)
|
|
|
2379 (save-excursion
|
|
|
2380 (set-buffer (get-file-buffer file))
|
|
98
|
2381 (when (buffer-modified-p)
|
|
|
2382 (save-buffer))
|
|
0
|
2383 (kill-buffer (current-buffer))))))
|
|
|
2384
|
|
98
|
2385 (defcustom gnus-kill-file-name "KILL"
|
|
|
2386 "Suffix of the kill files."
|
|
|
2387 :group 'gnus-score-kill
|
|
|
2388 :group 'gnus-score-files
|
|
|
2389 :type 'string)
|
|
0
|
2390
|
|
|
2391 (defun gnus-newsgroup-kill-file (newsgroup)
|
|
|
2392 "Return the name of a kill file name for NEWSGROUP.
|
|
|
2393 If NEWSGROUP is nil, return the global kill file name instead."
|
|
108
|
2394 (cond
|
|
0
|
2395 ;; The global KILL file is placed at top of the directory.
|
|
|
2396 ((or (null newsgroup)
|
|
|
2397 (string-equal newsgroup ""))
|
|
|
2398 (expand-file-name gnus-kill-file-name
|
|
|
2399 gnus-kill-files-directory))
|
|
|
2400 ;; Append ".KILL" to newsgroup name.
|
|
|
2401 ((gnus-use-long-file-name 'not-kill)
|
|
|
2402 (expand-file-name (concat (gnus-newsgroup-savable-name newsgroup)
|
|
|
2403 "." gnus-kill-file-name)
|
|
|
2404 gnus-kill-files-directory))
|
|
|
2405 ;; Place "KILL" under the hierarchical directory.
|
|
|
2406 (t
|
|
|
2407 (expand-file-name (concat (gnus-newsgroup-directory-form newsgroup)
|
|
|
2408 "/" gnus-kill-file-name)
|
|
|
2409 gnus-kill-files-directory))))
|
|
|
2410
|
|
98
|
2411 ;;; Server things.
|
|
0
|
2412
|
|
|
2413 (defun gnus-member-of-valid (symbol group)
|
|
|
2414 "Find out if GROUP has SYMBOL as part of its \"valid\" spec."
|
|
|
2415 (memq symbol (assoc
|
|
|
2416 (symbol-name (car (gnus-find-method-for-group group)))
|
|
|
2417 gnus-valid-select-methods)))
|
|
|
2418
|
|
|
2419 (defun gnus-method-option-p (method option)
|
|
|
2420 "Return non-nil if select METHOD has OPTION as a parameter."
|
|
|
2421 (when (stringp method)
|
|
|
2422 (setq method (gnus-server-to-method method)))
|
|
|
2423 (memq option (assoc (format "%s" (car method))
|
|
|
2424 gnus-valid-select-methods)))
|
|
|
2425
|
|
98
|
2426 (defun gnus-similar-server-opened (method)
|
|
|
2427 (let ((opened gnus-opened-servers))
|
|
|
2428 (while (and method opened)
|
|
|
2429 (when (and (equal (cadr method) (cadaar opened))
|
|
|
2430 (not (equal method (caar opened))))
|
|
|
2431 (setq method nil))
|
|
|
2432 (pop opened))
|
|
|
2433 (not method)))
|
|
32
|
2434
|
|
110
|
2435 (defun gnus-server-extend-method (group method)
|
|
|
2436 ;; This function "extends" a virtual server. If the server is
|
|
|
2437 ;; "hello", and the select method is ("hello" (my-var "something"))
|
|
|
2438 ;; in the group "alt.alt", this will result in a new virtual server
|
|
|
2439 ;; called "hello+alt.alt".
|
|
|
2440 (if (or (not (inline (gnus-similar-server-opened method)))
|
|
|
2441 (not (cddr method)))
|
|
|
2442 method
|
|
|
2443 `(,(car method) ,(concat (cadr method) "+" group)
|
|
|
2444 (,(intern (format "%s-address" (car method))) ,(cadr method))
|
|
|
2445 ,@(cddr method))))
|
|
|
2446
|
|
2
|
2447 (defun gnus-server-status (method)
|
|
|
2448 "Return the status of METHOD."
|
|
|
2449 (nth 1 (assoc method gnus-opened-servers)))
|
|
|
2450
|
|
0
|
2451 (defun gnus-group-name-to-method (group)
|
|
98
|
2452 "Guess a select method based on GROUP."
|
|
0
|
2453 (if (string-match ":" group)
|
|
|
2454 (let ((server (substring group 0 (match-beginning 0))))
|
|
|
2455 (if (string-match "\\+" server)
|
|
|
2456 (list (intern (substring server 0 (match-beginning 0)))
|
|
|
2457 (substring server (match-end 0)))
|
|
|
2458 (list (intern server) "")))
|
|
|
2459 gnus-select-method))
|
|
|
2460
|
|
|
2461 (defun gnus-find-method-for-group (group &optional info)
|
|
|
2462 "Find the select method that GROUP uses."
|
|
|
2463 (or gnus-override-method
|
|
|
2464 (and (not group)
|
|
|
2465 gnus-select-method)
|
|
|
2466 (let ((info (or info (gnus-get-info group)))
|
|
|
2467 method)
|
|
|
2468 (if (or (not info)
|
|
|
2469 (not (setq method (gnus-info-method info)))
|
|
|
2470 (equal method "native"))
|
|
|
2471 gnus-select-method
|
|
|
2472 (setq method
|
|
|
2473 (cond ((stringp method)
|
|
110
|
2474 (inline (gnus-server-to-method method)))
|
|
98
|
2475 ((stringp (cadr method))
|
|
110
|
2476 (inline (gnus-server-extend-method group method)))
|
|
0
|
2477 (t
|
|
|
2478 method)))
|
|
|
2479 (cond ((equal (cadr method) "")
|
|
|
2480 method)
|
|
|
2481 ((null (cadr method))
|
|
|
2482 (list (car method) ""))
|
|
|
2483 (t
|
|
|
2484 (gnus-server-add-address method)))))))
|
|
|
2485
|
|
110
|
2486 (defsubst gnus-check-backend-function (func group)
|
|
98
|
2487 "Check whether GROUP supports function FUNC.
|
|
|
2488 GROUP can either be a string (a group name) or a select method."
|
|
|
2489 (ignore-errors
|
|
|
2490 (let ((method (if (stringp group)
|
|
|
2491 (car (gnus-find-method-for-group group))
|
|
|
2492 group)))
|
|
|
2493 (unless (featurep method)
|
|
|
2494 (require method))
|
|
|
2495 (fboundp (intern (format "%s-%s" method func))))))
|
|
0
|
2496
|
|
|
2497 (defun gnus-methods-using (feature)
|
|
|
2498 "Find all methods that have FEATURE."
|
|
|
2499 (let ((valids gnus-valid-select-methods)
|
|
|
2500 outs)
|
|
|
2501 (while valids
|
|
98
|
2502 (when (memq feature (car valids))
|
|
|
2503 (push (car valids) outs))
|
|
0
|
2504 (setq valids (cdr valids)))
|
|
|
2505 outs))
|
|
|
2506
|
|
98
|
2507 (defun gnus-read-group (prompt &optional default)
|
|
|
2508 "Prompt the user for a group name.
|
|
|
2509 Disallow illegal group names."
|
|
|
2510 (let ((prefix "")
|
|
|
2511 group)
|
|
|
2512 (while (not group)
|
|
|
2513 (when (string-match
|
|
|
2514 "[: `'\"/]\\|^$"
|
|
|
2515 (setq group (read-string (concat prefix prompt)
|
|
|
2516 (cons (or default "") 0)
|
|
|
2517 'gnus-group-history)))
|
|
|
2518 (setq prefix (format "Illegal group name: \"%s\". " group)
|
|
|
2519 group nil)))
|
|
|
2520 group))
|
|
70
|
2521
|
|
98
|
2522 (defun gnus-read-method (prompt)
|
|
|
2523 "Prompt the user for a method.
|
|
|
2524 Allow completion over sensible values."
|
|
|
2525 (let ((method
|
|
|
2526 (completing-read
|
|
|
2527 prompt (append gnus-valid-select-methods gnus-predefined-server-alist
|
|
|
2528 gnus-server-alist)
|
|
|
2529 nil t nil 'gnus-method-history)))
|
|
108
|
2530 (cond
|
|
98
|
2531 ((equal method "")
|
|
|
2532 (setq method gnus-select-method))
|
|
|
2533 ((assoc method gnus-valid-select-methods)
|
|
|
2534 (list (intern method)
|
|
|
2535 (if (memq 'prompt-address
|
|
|
2536 (assoc method gnus-valid-select-methods))
|
|
|
2537 (read-string "Address: ")
|
|
|
2538 "")))
|
|
|
2539 ((assoc method gnus-server-alist)
|
|
|
2540 method)
|
|
|
2541 (t
|
|
|
2542 (list (intern method) "")))))
|
|
70
|
2543
|
|
98
|
2544 ;;; User-level commands.
|
|
70
|
2545
|
|
98
|
2546 ;;;###autoload
|
|
|
2547 (defun gnus-slave-no-server (&optional arg)
|
|
|
2548 "Read network news as a slave, without connecting to local server"
|
|
|
2549 (interactive "P")
|
|
|
2550 (gnus-no-server arg t))
|
|
70
|
2551
|
|
98
|
2552 ;;;###autoload
|
|
|
2553 (defun gnus-no-server (&optional arg slave)
|
|
|
2554 "Read network news.
|
|
|
2555 If ARG is a positive number, Gnus will use that as the
|
|
|
2556 startup level. If ARG is nil, Gnus will be started at level 2.
|
|
|
2557 If ARG is non-nil and not a positive number, Gnus will
|
|
|
2558 prompt the user for the name of an NNTP server to use.
|
|
|
2559 As opposed to `gnus', this command will not connect to the local server."
|
|
|
2560 (interactive "P")
|
|
|
2561 (gnus-no-server-1 arg slave))
|
|
70
|
2562
|
|
98
|
2563 ;;;###autoload
|
|
|
2564 (defun gnus-slave (&optional arg)
|
|
|
2565 "Read news as a slave."
|
|
|
2566 (interactive "P")
|
|
|
2567 (gnus arg nil 'slave))
|
|
70
|
2568
|
|
98
|
2569 ;;;###autoload
|
|
|
2570 (defun gnus-other-frame (&optional arg)
|
|
|
2571 "Pop up a frame to read news."
|
|
|
2572 (interactive "P")
|
|
|
2573 (let ((window (get-buffer-window gnus-group-buffer)))
|
|
|
2574 (cond (window
|
|
|
2575 (select-frame (window-frame window)))
|
|
|
2576 ((= (length (frame-list)) 1)
|
|
|
2577 (select-frame (make-frame)))
|
|
|
2578 (t
|
|
|
2579 (other-frame 1))))
|
|
|
2580 (gnus arg))
|
|
70
|
2581
|
|
98
|
2582 ;;;###autoload
|
|
|
2583 (defun gnus (&optional arg dont-connect slave)
|
|
|
2584 "Read network news.
|
|
|
2585 If ARG is non-nil and a positive number, Gnus will use that as the
|
|
|
2586 startup level. If ARG is non-nil and not a positive number, Gnus will
|
|
|
2587 prompt the user for the name of an NNTP server to use."
|
|
|
2588 (interactive "P")
|
|
|
2589 (gnus-1 arg dont-connect slave))
|
|
0
|
2590
|
|
|
2591 ;; Allow redefinition of Gnus functions.
|
|
|
2592
|
|
|
2593 (gnus-ems-redefine)
|
|
|
2594
|
|
|
2595 (provide 'gnus)
|
|
|
2596
|
|
|
2597 ;;; gnus.el ends here
|
