|
98
|
1 ;;; gnus-group.el --- group mode commands for Gnus
|
|
|
2 ;; Copyright (C) 1996,97 Free Software Foundation, Inc.
|
|
|
3
|
|
|
4 ;; Author: Lars Magne Ingebrigtsen <larsi@ifi.uio.no>
|
|
|
5 ;; Keywords: news
|
|
|
6
|
|
|
7 ;; This file is part of GNU Emacs.
|
|
|
8
|
|
|
9 ;; GNU Emacs is free software; you can redistribute it and/or modify
|
|
|
10 ;; it under the terms of the GNU General Public License as published by
|
|
|
11 ;; the Free Software Foundation; either version 2, or (at your option)
|
|
|
12 ;; any later version.
|
|
|
13
|
|
|
14 ;; GNU Emacs is distributed in the hope that it will be useful,
|
|
|
15 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
16 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
17 ;; GNU General Public License for more details.
|
|
|
18
|
|
|
19 ;; You should have received a copy of the GNU General Public License
|
|
|
20 ;; along with GNU Emacs; see the file COPYING. If not, write to the
|
|
|
21 ;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
|
|
22 ;; Boston, MA 02111-1307, USA.
|
|
|
23
|
|
|
24 ;;; Commentary:
|
|
|
25
|
|
|
26 ;;; Code:
|
|
|
27
|
|
|
28 (require 'gnus)
|
|
|
29 (require 'gnus-start)
|
|
|
30 (require 'nnmail)
|
|
|
31 (require 'gnus-spec)
|
|
|
32 (require 'gnus-int)
|
|
|
33 (require 'gnus-range)
|
|
|
34 (require 'gnus-win)
|
|
|
35 (require 'gnus-undo)
|
|
|
36
|
|
|
37 (defcustom gnus-group-archive-directory
|
|
|
38 "/ftp@ftp.hpc.uh.edu:/pub/emacs/ding-list/"
|
|
|
39 "*The address of the (ding) archives."
|
|
|
40 :group 'gnus-group-foreign
|
|
|
41 :type 'directory)
|
|
|
42
|
|
|
43 (defcustom gnus-group-recent-archive-directory
|
|
|
44 "/ftp@ftp.hpc.uh.edu:/pub/emacs/ding-list-recent/"
|
|
|
45 "*The address of the most recent (ding) articles."
|
|
|
46 :group 'gnus-group-foreign
|
|
|
47 :type 'directory)
|
|
|
48
|
|
|
49 (defcustom gnus-no-groups-message "No news is no news"
|
|
|
50 "*Message displayed by Gnus when no groups are available."
|
|
|
51 :group 'gnus-start
|
|
|
52 :type 'string)
|
|
|
53
|
|
|
54 (defcustom gnus-keep-same-level nil
|
|
|
55 "*Non-nil means that the next newsgroup after the current will be on the same level.
|
|
|
56 When you type, for instance, `n' after reading the last article in the
|
|
|
57 current newsgroup, you will go to the next newsgroup. If this variable
|
|
|
58 is nil, the next newsgroup will be the next from the group
|
|
|
59 buffer.
|
|
|
60 If this variable is non-nil, Gnus will either put you in the
|
|
|
61 next newsgroup with the same level, or, if no such newsgroup is
|
|
|
62 available, the next newsgroup with the lowest possible level higher
|
|
|
63 than the current level.
|
|
|
64 If this variable is `best', Gnus will make the next newsgroup the one
|
|
|
65 with the best level."
|
|
|
66 :group 'gnus-group-levels
|
|
|
67 :type '(choice (const nil)
|
|
|
68 (const best)
|
|
|
69 (sexp :tag "other" t)))
|
|
|
70
|
|
|
71 (defcustom gnus-group-goto-unread t
|
|
|
72 "*If non-nil, movement commands will go to the next unread and subscribed group."
|
|
|
73 :link '(custom-manual "(gnus)Group Maneuvering")
|
|
|
74 :group 'gnus-group-various
|
|
|
75 :type 'boolean)
|
|
|
76
|
|
|
77 (defcustom gnus-goto-next-group-when-activating t
|
|
|
78 "*If non-nil, the \\<gnus-group-mode-map>\\[gnus-group-get-new-news-this-group] command will advance point to the next group."
|
|
|
79 :link '(custom-manual "(gnus)Scanning New Messages")
|
|
|
80 :group 'gnus-group-various
|
|
|
81 :type 'boolean)
|
|
|
82
|
|
|
83 (defcustom gnus-permanently-visible-groups nil
|
|
|
84 "*Regexp to match groups that should always be listed in the group buffer.
|
|
|
85 This means that they will still be listed when there are no unread
|
|
|
86 articles in the groups."
|
|
|
87 :group 'gnus-group-listing
|
|
|
88 :type 'regexp)
|
|
|
89
|
|
|
90 (defcustom gnus-list-groups-with-ticked-articles t
|
|
|
91 "*If non-nil, list groups that have only ticked articles.
|
|
|
92 If nil, only list groups that have unread articles."
|
|
|
93 :group 'gnus-group-listing
|
|
|
94 :type 'boolean)
|
|
|
95
|
|
|
96 (defcustom gnus-group-default-list-level gnus-level-subscribed
|
|
|
97 "*Default listing level.
|
|
|
98 Ignored if `gnus-group-use-permanent-levels' is non-nil."
|
|
|
99 :group 'gnus-group-listing
|
|
|
100 :type 'integer)
|
|
|
101
|
|
|
102 (defcustom gnus-group-list-inactive-groups t
|
|
|
103 "*If non-nil, inactive groups will be listed."
|
|
|
104 :group 'gnus-group-listing
|
|
|
105 :group 'gnus-group-levels
|
|
|
106 :type 'boolean)
|
|
|
107
|
|
|
108 (defcustom gnus-group-sort-function 'gnus-group-sort-by-alphabet
|
|
|
109 "*Function used for sorting the group buffer.
|
|
|
110 This function will be called with group info entries as the arguments
|
|
|
111 for the groups to be sorted. Pre-made functions include
|
|
|
112 `gnus-group-sort-by-alphabet', `gnus-group-sort-by-real-name',
|
|
|
113 `gnus-group-sort-by-unread', `gnus-group-sort-by-level',
|
|
|
114 `gnus-group-sort-by-score', `gnus-group-sort-by-method', and
|
|
|
115 `gnus-group-sort-by-rank'.
|
|
|
116
|
|
|
117 This variable can also be a list of sorting functions. In that case,
|
|
|
118 the most significant sort function should be the last function in the
|
|
|
119 list."
|
|
|
120 :group 'gnus-group-listing
|
|
|
121 :link '(custom-manual "(gnus)Sorting Groups")
|
|
|
122 :type '(radio (function-item gnus-group-sort-by-alphabet)
|
|
|
123 (function-item gnus-group-sort-by-real-name)
|
|
|
124 (function-item gnus-group-sort-by-unread)
|
|
|
125 (function-item gnus-group-sort-by-level)
|
|
|
126 (function-item gnus-group-sort-by-score)
|
|
|
127 (function-item gnus-group-sort-by-method)
|
|
|
128 (function-item gnus-group-sort-by-rank)
|
|
|
129 (function :tag "other" nil)))
|
|
|
130
|
|
|
131 (defcustom gnus-group-line-format "%M\%S\%p\%P\%5y: %(%g%)%l\n"
|
|
|
132 "*Format of group lines.
|
|
|
133 It works along the same lines as a normal formatting string,
|
|
|
134 with some simple extensions.
|
|
|
135
|
|
|
136 %M Only marked articles (character, \"*\" or \" \")
|
|
|
137 %S Whether the group is subscribed (character, \"U\", \"K\", \"Z\" or \" \")
|
|
|
138 %L Level of subscribedness (integer)
|
|
|
139 %N Number of unread articles (integer)
|
|
|
140 %I Number of dormant articles (integer)
|
|
|
141 %i Number of ticked and dormant (integer)
|
|
|
142 %T Number of ticked articles (integer)
|
|
|
143 %R Number of read articles (integer)
|
|
|
144 %t Estimated total number of articles (integer)
|
|
|
145 %y Number of unread, unticked articles (integer)
|
|
|
146 %G Group name (string)
|
|
|
147 %g Qualified group name (string)
|
|
|
148 %D Group description (string)
|
|
|
149 %s Select method (string)
|
|
|
150 %o Moderated group (char, \"m\")
|
|
|
151 %p Process mark (char)
|
|
|
152 %O Moderated group (string, \"(m)\" or \"\")
|
|
|
153 %P Topic indentation (string)
|
|
|
154 %m Whether there is new(ish) mail in the group (char, \"%\")
|
|
|
155 %l Whether there are GroupLens predictions for this group (string)
|
|
|
156 %n Select from where (string)
|
|
|
157 %z A string that look like `<%s:%n>' if a foreign select method is used
|
|
100
|
158 %d The date the group was last entered.
|
|
98
|
159 %u User defined specifier. The next character in the format string should
|
|
|
160 be a letter. Gnus will call the function gnus-user-format-function-X,
|
|
|
161 where X is the letter following %u. The function will be passed the
|
|
|
162 current header as argument. The function should return a string, which
|
|
|
163 will be inserted into the buffer just like information from any other
|
|
|
164 group specifier.
|
|
|
165
|
|
|
166 Text between %( and %) will be highlighted with `gnus-mouse-face' when
|
|
|
167 the mouse point move inside the area. There can only be one such area.
|
|
|
168
|
|
|
169 Note that this format specification is not always respected. For
|
|
|
170 reasons of efficiency, when listing killed groups, this specification
|
|
|
171 is ignored altogether. If the spec is changed considerably, your
|
|
|
172 output may end up looking strange when listing both alive and killed
|
|
|
173 groups.
|
|
|
174
|
|
|
175 If you use %o or %O, reading the active file will be slower and quite
|
|
|
176 a bit of extra memory will be used. %D will also worsen performance.
|
|
|
177 Also note that if you change the format specification to include any
|
|
|
178 of these specs, you must probably re-start Gnus to see them go into
|
|
|
179 effect."
|
|
|
180 :group 'gnus-group-visual
|
|
|
181 :type 'string)
|
|
|
182
|
|
|
183 (defcustom gnus-group-mode-line-format "Gnus: %%b {%M\%:%S}"
|
|
|
184 "*The format specification for the group mode line.
|
|
|
185 It works along the same lines as a normal formatting string,
|
|
|
186 with some simple extensions:
|
|
|
187
|
|
|
188 %S The native news server.
|
|
|
189 %M The native select method.
|
|
|
190 %: \":\" if %S isn't \"\"."
|
|
|
191 :group 'gnus-group-visual
|
|
|
192 :type 'string)
|
|
|
193
|
|
|
194 (defcustom gnus-group-mode-hook nil
|
|
|
195 "Hook for Gnus group mode."
|
|
|
196 :group 'gnus-group-various
|
|
|
197 :options '(gnus-topic-mode)
|
|
|
198 :type 'hook)
|
|
|
199
|
|
|
200 (defcustom gnus-group-menu-hook nil
|
|
|
201 "Hook run after the creation of the group mode menu."
|
|
|
202 :group 'gnus-group-various
|
|
|
203 :type 'hook)
|
|
|
204
|
|
|
205 (defcustom gnus-group-catchup-group-hook nil
|
|
|
206 "Hook run when catching up a group from the group buffer."
|
|
|
207 :group 'gnus-group-various
|
|
|
208 :link '(custom-manual "(gnus)Group Data")
|
|
|
209 :type 'hook)
|
|
|
210
|
|
|
211 (defcustom gnus-group-update-group-hook nil
|
|
|
212 "Hook called when updating group lines."
|
|
|
213 :group 'gnus-group-visual
|
|
|
214 :type 'hook)
|
|
|
215
|
|
|
216 (defcustom gnus-group-prepare-function 'gnus-group-prepare-flat
|
|
|
217 "*A function that is called to generate the group buffer.
|
|
|
218 The function is called with three arguments: The first is a number;
|
|
|
219 all group with a level less or equal to that number should be listed,
|
|
|
220 if the second is non-nil, empty groups should also be displayed. If
|
|
|
221 the third is non-nil, it is a number. No groups with a level lower
|
|
|
222 than this number should be displayed.
|
|
|
223
|
|
|
224 The only current function implemented is `gnus-group-prepare-flat'."
|
|
|
225 :group 'gnus-group-listing
|
|
|
226 :type 'function)
|
|
|
227
|
|
|
228 (defcustom gnus-group-prepare-hook nil
|
|
|
229 "Hook called after the group buffer has been generated.
|
|
|
230 If you want to modify the group buffer, you can use this hook."
|
|
|
231 :group 'gnus-group-listing
|
|
|
232 :type 'hook)
|
|
|
233
|
|
|
234 (defcustom gnus-suspend-gnus-hook nil
|
|
|
235 "Hook called when suspending (not exiting) Gnus."
|
|
|
236 :group 'gnus-exit
|
|
|
237 :type 'hook)
|
|
|
238
|
|
|
239 (defcustom gnus-exit-gnus-hook nil
|
|
|
240 "Hook called when exiting Gnus."
|
|
|
241 :group 'gnus-exit
|
|
|
242 :type 'hook)
|
|
|
243
|
|
|
244 (defcustom gnus-after-exiting-gnus-hook nil
|
|
|
245 "Hook called after exiting Gnus."
|
|
|
246 :group 'gnus-exit
|
|
|
247 :type 'hook)
|
|
|
248
|
|
|
249 (defcustom gnus-group-update-hook '(gnus-group-highlight-line)
|
|
|
250 "Hook called when a group line is changed.
|
|
|
251 The hook will not be called if `gnus-visual' is nil.
|
|
|
252
|
|
|
253 The default function `gnus-group-highlight-line' will
|
|
|
254 highlight the line according to the `gnus-group-highlight'
|
|
|
255 variable."
|
|
|
256 :group 'gnus-group-visual
|
|
|
257 :type 'hook)
|
|
|
258
|
|
|
259 (defcustom gnus-useful-groups
|
|
|
260 `(("(ding) mailing list mirrored at sunsite.auc.dk"
|
|
|
261 "emacs.ding"
|
|
|
262 (nntp "sunsite.auc.dk"
|
|
|
263 (nntp-address "sunsite.auc.dk")))
|
|
|
264 ("Gnus help group"
|
|
|
265 "gnus-help"
|
|
|
266 (nndoc "gnus-help"
|
|
|
267 (nndoc-article-type mbox)
|
|
|
268 (eval `(nndoc-address
|
|
|
269 ,(let ((file (nnheader-find-etc-directory
|
|
|
270 "gnus-tut.txt" t)))
|
|
|
271 (unless file
|
|
|
272 (error "Couldn't find doc group"))
|
|
|
273 file))))))
|
|
|
274 "Alist of useful group-server pairs."
|
|
|
275 :group 'gnus-group-listing
|
|
|
276 :type '(repeat (list (string :tag "Description")
|
|
|
277 (string :tag "Name")
|
|
|
278 (sexp :tag "Method"))))
|
|
|
279
|
|
|
280 (defcustom gnus-group-highlight
|
|
|
281 '(;; News.
|
|
|
282 ((and (= unread 0) (not mailp) (eq level 1)) .
|
|
|
283 gnus-group-news-1-empty-face)
|
|
|
284 ((and (not mailp) (eq level 1)) .
|
|
|
285 gnus-group-news-1-face)
|
|
|
286 ((and (= unread 0) (not mailp) (eq level 2)) .
|
|
|
287 gnus-group-news-2-empty-face)
|
|
|
288 ((and (not mailp) (eq level 2)) .
|
|
|
289 gnus-group-news-2-face)
|
|
|
290 ((and (= unread 0) (not mailp) (eq level 3)) .
|
|
|
291 gnus-group-news-3-empty-face)
|
|
|
292 ((and (not mailp) (eq level 3)) .
|
|
|
293 gnus-group-news-3-face)
|
|
|
294 ((and (= unread 0) (not mailp)) .
|
|
|
295 gnus-group-news-low-empty-face)
|
|
|
296 ((and (not mailp)) .
|
|
|
297 gnus-group-news-low-face)
|
|
|
298 ;; Mail.
|
|
|
299 ((and (= unread 0) (eq level 1)) .
|
|
|
300 gnus-group-mail-1-empty-face)
|
|
|
301 ((eq level 1) .
|
|
|
302 gnus-group-mail-1-face)
|
|
|
303 ((and (= unread 0) (eq level 2)) .
|
|
|
304 gnus-group-mail-2-empty-face)
|
|
|
305 ((eq level 2) .
|
|
|
306 gnus-group-mail-2-face)
|
|
|
307 ((and (= unread 0) (eq level 3)) .
|
|
|
308 gnus-group-mail-3-empty-face)
|
|
|
309 ((eq level 3) .
|
|
|
310 gnus-group-mail-3-face)
|
|
|
311 ((= unread 0) .
|
|
|
312 gnus-group-mail-low-empty-face)
|
|
|
313 (t .
|
|
|
314 gnus-group-mail-low-face))
|
|
|
315 "Controls the highlighting of group buffer lines.
|
|
|
316
|
|
|
317 Below is a list of `Form'/`Face' pairs. When deciding how a a
|
|
|
318 particular group line should be displayed, each form is
|
|
|
319 evaluated. The content of the face field after the first true form is
|
|
|
320 used. You can change how those group lines are displayed by
|
|
|
321 editing the face field.
|
|
|
322
|
|
|
323 It is also possible to change and add form fields, but currently that
|
|
|
324 requires an understanding of Lisp expressions. Hopefully this will
|
|
|
325 change in a future release. For now, you can use the following
|
|
|
326 variables in the Lisp expression:
|
|
|
327
|
|
|
328 group: The name of the group.
|
|
|
329 unread: The number of unread articles in the group.
|
|
|
330 method: The select method used.
|
|
|
331 mailp: Whether it's a mail group or not.
|
|
|
332 level: The level of the group.
|
|
|
333 score: The score of the group.
|
|
|
334 ticked: The number of ticked articles."
|
|
|
335 :group 'gnus-group-visual
|
|
|
336 :type '(repeat (cons (sexp :tag "Form") face)))
|
|
|
337
|
|
|
338 (defcustom gnus-new-mail-mark ?%
|
|
|
339 "Mark used for groups with new mail."
|
|
|
340 :group 'gnus-group-visual
|
|
|
341 :type 'character)
|
|
|
342
|
|
|
343 ;;; Internal variables
|
|
|
344
|
|
|
345 (defvar gnus-group-sort-alist-function 'gnus-group-sort-flat
|
|
|
346 "Function for sorting the group buffer.")
|
|
|
347
|
|
|
348 (defvar gnus-group-sort-selected-function 'gnus-group-sort-selected-flat
|
|
|
349 "Function for sorting the selected groups in the group buffer.")
|
|
|
350
|
|
|
351 (defvar gnus-group-indentation-function nil)
|
|
|
352 (defvar gnus-goto-missing-group-function nil)
|
|
|
353 (defvar gnus-group-update-group-function nil)
|
|
|
354 (defvar gnus-group-goto-next-group-function nil
|
|
|
355 "Function to override finding the next group after listing groups.")
|
|
|
356
|
|
|
357 (defvar gnus-group-edit-buffer nil)
|
|
|
358
|
|
|
359 (defvar gnus-group-line-format-alist
|
|
|
360 `((?M gnus-tmp-marked-mark ?c)
|
|
|
361 (?S gnus-tmp-subscribed ?c)
|
|
|
362 (?L gnus-tmp-level ?d)
|
|
|
363 (?N (cond ((eq number t) "*" )
|
|
|
364 ((numberp number)
|
|
|
365 (int-to-string
|
|
|
366 (+ number
|
|
|
367 (gnus-range-length (cdr (assq 'dormant gnus-tmp-marked)))
|
|
|
368 (gnus-range-length (cdr (assq 'tick gnus-tmp-marked))))))
|
|
|
369 (t number)) ?s)
|
|
|
370 (?R gnus-tmp-number-of-read ?s)
|
|
|
371 (?t gnus-tmp-number-total ?d)
|
|
|
372 (?y gnus-tmp-number-of-unread ?s)
|
|
|
373 (?I (gnus-range-length (cdr (assq 'dormant gnus-tmp-marked))) ?d)
|
|
|
374 (?T (gnus-range-length (cdr (assq 'tick gnus-tmp-marked))) ?d)
|
|
|
375 (?i (+ (gnus-range-length (cdr (assq 'dormant gnus-tmp-marked)))
|
|
|
376 (gnus-range-length (cdr (assq 'tick gnus-tmp-marked)))) ?d)
|
|
|
377 (?g gnus-tmp-group ?s)
|
|
|
378 (?G gnus-tmp-qualified-group ?s)
|
|
|
379 (?c (gnus-short-group-name gnus-tmp-group) ?s)
|
|
|
380 (?D gnus-tmp-newsgroup-description ?s)
|
|
|
381 (?o gnus-tmp-moderated ?c)
|
|
|
382 (?O gnus-tmp-moderated-string ?s)
|
|
|
383 (?p gnus-tmp-process-marked ?c)
|
|
|
384 (?s gnus-tmp-news-server ?s)
|
|
|
385 (?n gnus-tmp-news-method ?s)
|
|
|
386 (?P gnus-group-indentation ?s)
|
|
|
387 (?l gnus-tmp-grouplens ?s)
|
|
|
388 (?z gnus-tmp-news-method-string ?s)
|
|
|
389 (?m (gnus-group-new-mail gnus-tmp-group) ?c)
|
|
|
390 (?d (gnus-group-timestamp-string gnus-tmp-group) ?s)
|
|
|
391 (?u gnus-tmp-user-defined ?s)))
|
|
|
392
|
|
|
393 (defvar gnus-group-mode-line-format-alist
|
|
|
394 `((?S gnus-tmp-news-server ?s)
|
|
|
395 (?M gnus-tmp-news-method ?s)
|
|
|
396 (?u gnus-tmp-user-defined ?s)
|
|
|
397 (?: gnus-tmp-colon ?s)))
|
|
|
398
|
|
|
399 (defvar gnus-topic-topology nil
|
|
|
400 "The complete topic hierarchy.")
|
|
|
401
|
|
|
402 (defvar gnus-topic-alist nil
|
|
|
403 "The complete topic-group alist.")
|
|
|
404
|
|
|
405 (defvar gnus-group-marked nil)
|
|
|
406
|
|
|
407 (defvar gnus-group-list-mode nil)
|
|
|
408
|
|
|
409 ;;;
|
|
|
410 ;;; Gnus group mode
|
|
|
411 ;;;
|
|
|
412
|
|
|
413 (put 'gnus-group-mode 'mode-class 'special)
|
|
|
414
|
|
|
415 (when t
|
|
|
416 (gnus-define-keys gnus-group-mode-map
|
|
|
417 " " gnus-group-read-group
|
|
|
418 "=" gnus-group-select-group
|
|
|
419 "\r" gnus-group-select-group
|
|
|
420 "\M-\r" gnus-group-quick-select-group
|
|
|
421 [(meta control return)] gnus-group-select-group-ephemerally
|
|
|
422 "j" gnus-group-jump-to-group
|
|
|
423 "n" gnus-group-next-unread-group
|
|
|
424 "p" gnus-group-prev-unread-group
|
|
|
425 "\177" gnus-group-prev-unread-group
|
|
|
426 [delete] gnus-group-prev-unread-group
|
|
|
427 "N" gnus-group-next-group
|
|
|
428 "P" gnus-group-prev-group
|
|
|
429 "\M-n" gnus-group-next-unread-group-same-level
|
|
|
430 "\M-p" gnus-group-prev-unread-group-same-level
|
|
|
431 "," gnus-group-best-unread-group
|
|
|
432 "." gnus-group-first-unread-group
|
|
|
433 "u" gnus-group-unsubscribe-current-group
|
|
|
434 "U" gnus-group-unsubscribe-group
|
|
|
435 "c" gnus-group-catchup-current
|
|
|
436 "C" gnus-group-catchup-current-all
|
|
|
437 "\M-c" gnus-group-clear-data
|
|
|
438 "l" gnus-group-list-groups
|
|
|
439 "L" gnus-group-list-all-groups
|
|
|
440 "m" gnus-group-mail
|
|
|
441 "g" gnus-group-get-new-news
|
|
|
442 "\M-g" gnus-group-get-new-news-this-group
|
|
|
443 "R" gnus-group-restart
|
|
|
444 "r" gnus-group-read-init-file
|
|
|
445 "B" gnus-group-browse-foreign-server
|
|
|
446 "b" gnus-group-check-bogus-groups
|
|
|
447 "F" gnus-find-new-newsgroups
|
|
|
448 "\C-c\C-d" gnus-group-describe-group
|
|
|
449 "\M-d" gnus-group-describe-all-groups
|
|
|
450 "\C-c\C-a" gnus-group-apropos
|
|
|
451 "\C-c\M-\C-a" gnus-group-description-apropos
|
|
|
452 "a" gnus-group-post-news
|
|
|
453 "\ek" gnus-group-edit-local-kill
|
|
|
454 "\eK" gnus-group-edit-global-kill
|
|
|
455 "\C-k" gnus-group-kill-group
|
|
|
456 "\C-y" gnus-group-yank-group
|
|
|
457 "\C-w" gnus-group-kill-region
|
|
|
458 "\C-x\C-t" gnus-group-transpose-groups
|
|
|
459 "\C-c\C-l" gnus-group-list-killed
|
|
|
460 "\C-c\C-x" gnus-group-expire-articles
|
|
|
461 "\C-c\M-\C-x" gnus-group-expire-all-groups
|
|
|
462 "V" gnus-version
|
|
|
463 "s" gnus-group-save-newsrc
|
|
|
464 "z" gnus-group-suspend
|
|
|
465 "q" gnus-group-exit
|
|
|
466 "Q" gnus-group-quit
|
|
|
467 "?" gnus-group-describe-briefly
|
|
|
468 "\C-c\C-i" gnus-info-find-node
|
|
|
469 "\M-e" gnus-group-edit-group-method
|
|
|
470 "^" gnus-group-enter-server-mode
|
|
|
471 gnus-mouse-2 gnus-mouse-pick-group
|
|
|
472 "<" beginning-of-buffer
|
|
|
473 ">" end-of-buffer
|
|
|
474 "\C-c\C-b" gnus-bug
|
|
|
475 "\C-c\C-s" gnus-group-sort-groups
|
|
|
476 "t" gnus-topic-mode
|
|
|
477 "\C-c\M-g" gnus-activate-all-groups
|
|
|
478 "\M-&" gnus-group-universal-argument
|
|
|
479 "#" gnus-group-mark-group
|
|
|
480 "\M-#" gnus-group-unmark-group)
|
|
|
481
|
|
|
482 (gnus-define-keys (gnus-group-mark-map "M" gnus-group-mode-map)
|
|
|
483 "m" gnus-group-mark-group
|
|
|
484 "u" gnus-group-unmark-group
|
|
|
485 "w" gnus-group-mark-region
|
|
|
486 "m" gnus-group-mark-buffer
|
|
|
487 "r" gnus-group-mark-regexp
|
|
|
488 "U" gnus-group-unmark-all-groups)
|
|
|
489
|
|
|
490 (gnus-define-keys (gnus-group-group-map "G" gnus-group-mode-map)
|
|
|
491 "d" gnus-group-make-directory-group
|
|
|
492 "h" gnus-group-make-help-group
|
|
|
493 "u" gnus-group-make-useful-group
|
|
|
494 "a" gnus-group-make-archive-group
|
|
|
495 "k" gnus-group-make-kiboze-group
|
|
|
496 "m" gnus-group-make-group
|
|
|
497 "E" gnus-group-edit-group
|
|
|
498 "e" gnus-group-edit-group-method
|
|
|
499 "p" gnus-group-edit-group-parameters
|
|
|
500 "v" gnus-group-add-to-virtual
|
|
|
501 "V" gnus-group-make-empty-virtual
|
|
|
502 "D" gnus-group-enter-directory
|
|
|
503 "f" gnus-group-make-doc-group
|
|
|
504 "w" gnus-group-make-web-group
|
|
|
505 "r" gnus-group-rename-group
|
|
|
506 "c" gnus-group-customize
|
|
|
507 "\177" gnus-group-delete-group
|
|
|
508 [delete] gnus-group-delete-group)
|
|
|
509
|
|
|
510 (gnus-define-keys (gnus-group-soup-map "s" gnus-group-group-map)
|
|
|
511 "b" gnus-group-brew-soup
|
|
|
512 "w" gnus-soup-save-areas
|
|
|
513 "s" gnus-soup-send-replies
|
|
|
514 "p" gnus-soup-pack-packet
|
|
|
515 "r" nnsoup-pack-replies)
|
|
|
516
|
|
|
517 (gnus-define-keys (gnus-group-sort-map "S" gnus-group-group-map)
|
|
|
518 "s" gnus-group-sort-groups
|
|
|
519 "a" gnus-group-sort-groups-by-alphabet
|
|
|
520 "u" gnus-group-sort-groups-by-unread
|
|
|
521 "l" gnus-group-sort-groups-by-level
|
|
|
522 "v" gnus-group-sort-groups-by-score
|
|
|
523 "r" gnus-group-sort-groups-by-rank
|
|
|
524 "m" gnus-group-sort-groups-by-method)
|
|
|
525
|
|
|
526 (gnus-define-keys (gnus-group-sort-map "P" gnus-group-group-map)
|
|
|
527 "s" gnus-group-sort-selected-groups
|
|
|
528 "a" gnus-group-sort-selected-groups-by-alphabet
|
|
|
529 "u" gnus-group-sort-selected-groups-by-unread
|
|
|
530 "l" gnus-group-sort-selected-groups-by-level
|
|
|
531 "v" gnus-group-sort-selected-groups-by-score
|
|
|
532 "r" gnus-group-sort-selected-groups-by-rank
|
|
|
533 "m" gnus-group-sort-selected-groups-by-method)
|
|
|
534
|
|
|
535 (gnus-define-keys (gnus-group-list-map "A" gnus-group-mode-map)
|
|
|
536 "k" gnus-group-list-killed
|
|
|
537 "z" gnus-group-list-zombies
|
|
|
538 "s" gnus-group-list-groups
|
|
|
539 "u" gnus-group-list-all-groups
|
|
|
540 "A" gnus-group-list-active
|
|
|
541 "a" gnus-group-apropos
|
|
|
542 "d" gnus-group-description-apropos
|
|
|
543 "m" gnus-group-list-matching
|
|
|
544 "M" gnus-group-list-all-matching
|
|
|
545 "l" gnus-group-list-level)
|
|
|
546
|
|
|
547 (gnus-define-keys (gnus-group-score-map "W" gnus-group-mode-map)
|
|
|
548 "f" gnus-score-flush-cache)
|
|
|
549
|
|
|
550 (gnus-define-keys (gnus-group-help-map "H" gnus-group-mode-map)
|
|
|
551 "d" gnus-group-describe-group
|
|
|
552 "f" gnus-group-fetch-faq)
|
|
|
553
|
|
|
554 (gnus-define-keys (gnus-group-sub-map "S" gnus-group-mode-map)
|
|
|
555 "l" gnus-group-set-current-level
|
|
|
556 "t" gnus-group-unsubscribe-current-group
|
|
|
557 "s" gnus-group-unsubscribe-group
|
|
|
558 "k" gnus-group-kill-group
|
|
|
559 "y" gnus-group-yank-group
|
|
|
560 "w" gnus-group-kill-region
|
|
|
561 "\C-k" gnus-group-kill-level
|
|
|
562 "z" gnus-group-kill-all-zombies))
|
|
|
563
|
|
|
564 (defun gnus-group-make-menu-bar ()
|
|
|
565 (gnus-turn-off-edit-menu 'group)
|
|
|
566 (unless (boundp 'gnus-group-reading-menu)
|
|
|
567
|
|
|
568 (easy-menu-define
|
|
|
569 gnus-group-reading-menu gnus-group-mode-map ""
|
|
|
570 '("Group"
|
|
|
571 ["Read" gnus-group-read-group (gnus-group-group-name)]
|
|
|
572 ["Select" gnus-group-select-group (gnus-group-group-name)]
|
|
|
573 ["See old articles" (gnus-group-select-group 'all)
|
|
|
574 :keys "C-u SPC" :active (gnus-group-group-name)]
|
|
|
575 ["Catch up" gnus-group-catchup-current (gnus-group-group-name)]
|
|
|
576 ["Catch up all articles" gnus-group-catchup-current-all
|
|
|
577 (gnus-group-group-name)]
|
|
|
578 ["Check for new articles" gnus-group-get-new-news-this-group
|
|
|
579 (gnus-group-group-name)]
|
|
|
580 ["Toggle subscription" gnus-group-unsubscribe-current-group
|
|
|
581 (gnus-group-group-name)]
|
|
|
582 ["Kill" gnus-group-kill-group (gnus-group-group-name)]
|
|
|
583 ["Yank" gnus-group-yank-group gnus-list-of-killed-groups]
|
|
|
584 ["Describe" gnus-group-describe-group (gnus-group-group-name)]
|
|
|
585 ["Fetch FAQ" gnus-group-fetch-faq (gnus-group-group-name)]
|
|
|
586 ;; Actually one should check, if any of the marked groups gives t for
|
|
|
587 ;; (gnus-check-backend-function 'request-expire-articles ...)
|
|
|
588 ["Expire articles" gnus-group-expire-articles
|
|
|
589 (or (and (gnus-group-group-name)
|
|
|
590 (gnus-check-backend-function
|
|
|
591 'request-expire-articles
|
|
|
592 (gnus-group-group-name))) gnus-group-marked)]
|
|
|
593 ["Set group level" gnus-group-set-current-level
|
|
|
594 (gnus-group-group-name)]
|
|
|
595 ["Select quick" gnus-group-quick-select-group (gnus-group-group-name)]
|
|
|
596 ["Customize" gnus-group-customize (gnus-group-group-name)]
|
|
|
597 ("Edit"
|
|
|
598 ["Parameters" gnus-group-edit-group-parameters
|
|
|
599 (gnus-group-group-name)]
|
|
|
600 ["Select method" gnus-group-edit-group-method
|
|
|
601 (gnus-group-group-name)]
|
|
|
602 ["Info" gnus-group-edit-group (gnus-group-group-name)]
|
|
|
603 ["Local kill file" gnus-group-edit-local-kill (gnus-group-group-name)]
|
|
|
604 ["Global kill file" gnus-group-edit-global-kill t])
|
|
|
605 ))
|
|
|
606
|
|
|
607 (easy-menu-define
|
|
|
608 gnus-group-group-menu gnus-group-mode-map ""
|
|
|
609 '("Groups"
|
|
|
610 ("Listing"
|
|
|
611 ["List unread subscribed groups" gnus-group-list-groups t]
|
|
|
612 ["List (un)subscribed groups" gnus-group-list-all-groups t]
|
|
|
613 ["List killed groups" gnus-group-list-killed gnus-killed-list]
|
|
|
614 ["List zombie groups" gnus-group-list-zombies gnus-zombie-list]
|
|
|
615 ["List level..." gnus-group-list-level t]
|
|
|
616 ["Describe all groups" gnus-group-describe-all-groups t]
|
|
|
617 ["Group apropos..." gnus-group-apropos t]
|
|
|
618 ["Group and description apropos..." gnus-group-description-apropos t]
|
|
|
619 ["List groups matching..." gnus-group-list-matching t]
|
|
|
620 ["List all groups matching..." gnus-group-list-all-matching t]
|
|
|
621 ["List active file" gnus-group-list-active t])
|
|
|
622 ("Sort"
|
|
|
623 ["Default sort" gnus-group-sort-groups t]
|
|
|
624 ["Sort by method" gnus-group-sort-groups-by-method t]
|
|
|
625 ["Sort by rank" gnus-group-sort-groups-by-rank t]
|
|
|
626 ["Sort by score" gnus-group-sort-groups-by-score t]
|
|
|
627 ["Sort by level" gnus-group-sort-groups-by-level t]
|
|
|
628 ["Sort by unread" gnus-group-sort-groups-by-unread t]
|
|
|
629 ["Sort by name" gnus-group-sort-groups-by-alphabet t])
|
|
|
630 ("Sort process/prefixed"
|
|
|
631 ["Default sort" gnus-group-sort-selected-groups
|
|
|
632 (or (not (boundp 'gnus-topic-mode)) (not gnus-topic-mode))]
|
|
|
633 ["Sort by method" gnus-group-sort-selected-groups-by-method
|
|
|
634 (or (not (boundp 'gnus-topic-mode)) (not gnus-topic-mode))]
|
|
|
635 ["Sort by rank" gnus-group-sort-selected-groups-by-rank
|
|
|
636 (or (not (boundp 'gnus-topic-mode)) (not gnus-topic-mode))]
|
|
|
637 ["Sort by score" gnus-group-sort-selected-groups-by-score
|
|
|
638 (or (not (boundp 'gnus-topic-mode)) (not gnus-topic-mode))]
|
|
|
639 ["Sort by level" gnus-group-sort-selected-groups-by-level
|
|
|
640 (or (not (boundp 'gnus-topic-mode)) (not gnus-topic-mode))]
|
|
|
641 ["Sort by unread" gnus-group-sort-selected-groups-by-unread
|
|
|
642 (or (not (boundp 'gnus-topic-mode)) (not gnus-topic-mode))]
|
|
|
643 ["Sort by name" gnus-group-sort-selected-groups-by-alphabet
|
|
|
644 (or (not (boundp 'gnus-topic-mode)) (not gnus-topic-mode))])
|
|
|
645 ("Mark"
|
|
|
646 ["Mark group" gnus-group-mark-group
|
|
|
647 (and (gnus-group-group-name)
|
|
|
648 (not (memq (gnus-group-group-name) gnus-group-marked)))]
|
|
|
649 ["Unmark group" gnus-group-unmark-group
|
|
|
650 (and (gnus-group-group-name)
|
|
|
651 (memq (gnus-group-group-name) gnus-group-marked))]
|
|
|
652 ["Unmark all" gnus-group-unmark-all-groups gnus-group-marked]
|
|
|
653 ["Mark regexp..." gnus-group-mark-regexp t]
|
|
|
654 ["Mark region" gnus-group-mark-region t]
|
|
|
655 ["Mark buffer" gnus-group-mark-buffer t]
|
|
|
656 ["Execute command" gnus-group-universal-argument
|
|
|
657 (or gnus-group-marked (gnus-group-group-name))])
|
|
|
658 ("Subscribe"
|
|
|
659 ["Subscribe to a group" gnus-group-unsubscribe-group t]
|
|
|
660 ["Kill all newsgroups in region" gnus-group-kill-region t]
|
|
|
661 ["Kill all zombie groups" gnus-group-kill-all-zombies
|
|
|
662 gnus-zombie-list]
|
|
|
663 ["Kill all groups on level..." gnus-group-kill-level t])
|
|
|
664 ("Foreign groups"
|
|
|
665 ["Make a foreign group" gnus-group-make-group t]
|
|
|
666 ["Add a directory group" gnus-group-make-directory-group t]
|
|
|
667 ["Add the help group" gnus-group-make-help-group t]
|
|
|
668 ["Add the archive group" gnus-group-make-archive-group t]
|
|
|
669 ["Make a doc group" gnus-group-make-doc-group t]
|
|
|
670 ["Make a web group" gnus-group-make-web-group t]
|
|
|
671 ["Make a kiboze group" gnus-group-make-kiboze-group t]
|
|
|
672 ["Make a virtual group" gnus-group-make-empty-virtual t]
|
|
|
673 ["Add a group to a virtual" gnus-group-add-to-virtual t]
|
|
|
674 ["Rename group" gnus-group-rename-group
|
|
|
675 (gnus-check-backend-function
|
|
|
676 'request-rename-group (gnus-group-group-name))]
|
|
|
677 ["Delete group" gnus-group-delete-group
|
|
|
678 (gnus-check-backend-function
|
|
|
679 'request-delete-group (gnus-group-group-name))])
|
|
|
680 ("Move"
|
|
|
681 ["Next" gnus-group-next-group t]
|
|
|
682 ["Previous" gnus-group-prev-group t]
|
|
|
683 ["Next unread" gnus-group-next-unread-group t]
|
|
|
684 ["Previous unread" gnus-group-prev-unread-group t]
|
|
|
685 ["Next unread same level" gnus-group-next-unread-group-same-level t]
|
|
|
686 ["Previous unread same level"
|
|
|
687 gnus-group-prev-unread-group-same-level t]
|
|
|
688 ["Jump to group" gnus-group-jump-to-group t]
|
|
|
689 ["First unread group" gnus-group-first-unread-group t]
|
|
|
690 ["Best unread group" gnus-group-best-unread-group t])
|
|
|
691 ["Delete bogus groups" gnus-group-check-bogus-groups t]
|
|
|
692 ["Find new newsgroups" gnus-find-new-newsgroups t]
|
|
|
693 ["Transpose" gnus-group-transpose-groups
|
|
|
694 (gnus-group-group-name)]
|
|
|
695 ["Read a directory as a group..." gnus-group-enter-directory t]
|
|
|
696 ))
|
|
|
697
|
|
|
698 (easy-menu-define
|
|
|
699 gnus-group-misc-menu gnus-group-mode-map ""
|
|
|
700 '("Misc"
|
|
|
701 ("SOUP"
|
|
|
702 ["Pack replies" nnsoup-pack-replies (fboundp 'nnsoup-request-group)]
|
|
|
703 ["Send replies" gnus-soup-send-replies
|
|
|
704 (fboundp 'gnus-soup-pack-packet)]
|
|
|
705 ["Pack packet" gnus-soup-pack-packet (fboundp 'gnus-soup-pack-packet)]
|
|
|
706 ["Save areas" gnus-soup-save-areas (fboundp 'gnus-soup-pack-packet)]
|
|
|
707 ["Brew SOUP" gnus-soup-brew-soup (fboundp 'gnus-soup-pack-packet)])
|
|
|
708 ["Send a bug report" gnus-bug t]
|
|
|
709 ["Send a mail" gnus-group-mail t]
|
|
|
710 ["Post an article..." gnus-group-post-news t]
|
|
|
711 ["Check for new news" gnus-group-get-new-news t]
|
|
|
712 ["Activate all groups" gnus-activate-all-groups t]
|
|
|
713 ["Restart Gnus" gnus-group-restart t]
|
|
|
714 ["Read init file" gnus-group-read-init-file t]
|
|
|
715 ["Browse foreign server" gnus-group-browse-foreign-server t]
|
|
|
716 ["Enter server buffer" gnus-group-enter-server-mode t]
|
|
|
717 ["Expire all expirable articles" gnus-group-expire-all-groups t]
|
|
|
718 ["Generate any kiboze groups" nnkiboze-generate-groups t]
|
|
|
719 ["Gnus version" gnus-version t]
|
|
|
720 ["Save .newsrc files" gnus-group-save-newsrc t]
|
|
|
721 ["Suspend Gnus" gnus-group-suspend t]
|
|
|
722 ["Clear dribble buffer" gnus-group-clear-dribble t]
|
|
|
723 ["Read manual" gnus-info-find-node t]
|
|
|
724 ["Flush score cache" gnus-score-flush-cache t]
|
|
|
725 ["Toggle topics" gnus-topic-mode t]
|
|
|
726 ["Exit from Gnus" gnus-group-exit t]
|
|
|
727 ["Exit without saving" gnus-group-quit t]
|
|
|
728 ))
|
|
|
729
|
|
|
730 (run-hooks 'gnus-group-menu-hook)))
|
|
|
731
|
|
|
732 (defun gnus-group-mode ()
|
|
|
733 "Major mode for reading news.
|
|
|
734
|
|
|
735 All normal editing commands are switched off.
|
|
|
736 \\<gnus-group-mode-map>
|
|
|
737 The group buffer lists (some of) the groups available. For instance,
|
|
|
738 `\\[gnus-group-list-groups]' will list all subscribed groups with unread articles, while `\\[gnus-group-list-zombies]'
|
|
|
739 lists all zombie groups.
|
|
|
740
|
|
|
741 Groups that are displayed can be entered with `\\[gnus-group-read-group]'. To subscribe
|
|
|
742 to a group not displayed, type `\\[gnus-group-unsubscribe-group]'.
|
|
|
743
|
|
|
744 For more in-depth information on this mode, read the manual (`\\[gnus-info-find-node]').
|
|
|
745
|
|
|
746 The following commands are available:
|
|
|
747
|
|
|
748 \\{gnus-group-mode-map}"
|
|
|
749 (interactive)
|
|
|
750 (when (gnus-visual-p 'group-menu 'menu)
|
|
|
751 (gnus-group-make-menu-bar))
|
|
|
752 (kill-all-local-variables)
|
|
|
753 (gnus-simplify-mode-line)
|
|
|
754 (setq major-mode 'gnus-group-mode)
|
|
|
755 (setq mode-name "Group")
|
|
|
756 (gnus-group-set-mode-line)
|
|
|
757 (setq mode-line-process nil)
|
|
|
758 (use-local-map gnus-group-mode-map)
|
|
|
759 (buffer-disable-undo (current-buffer))
|
|
|
760 (setq truncate-lines t)
|
|
|
761 (setq buffer-read-only t)
|
|
|
762 (gnus-set-default-directory)
|
|
|
763 (gnus-update-format-specifications nil 'group 'group-mode)
|
|
|
764 (gnus-update-group-mark-positions)
|
|
|
765 (make-local-hook 'post-command-hook)
|
|
|
766 (gnus-add-hook 'post-command-hook 'gnus-clear-inboxes-moved nil t)
|
|
|
767 (when gnus-use-undo
|
|
|
768 (gnus-undo-mode 1))
|
|
|
769 (run-hooks 'gnus-group-mode-hook))
|
|
|
770
|
|
|
771 (defun gnus-update-group-mark-positions ()
|
|
|
772 (save-excursion
|
|
|
773 (let ((gnus-process-mark 128)
|
|
|
774 (gnus-group-marked '("dummy.group"))
|
|
|
775 (gnus-active-hashtb (make-vector 10 0)))
|
|
|
776 (gnus-set-active "dummy.group" '(0 . 0))
|
|
|
777 (gnus-set-work-buffer)
|
|
|
778 (gnus-group-insert-group-line "dummy.group" 0 nil 0 nil)
|
|
|
779 (goto-char (point-min))
|
|
|
780 (setq gnus-group-mark-positions
|
|
|
781 (list (cons 'process (and (search-forward "\200" nil t)
|
|
|
782 (- (point) 2))))))))
|
|
|
783
|
|
|
784 (defun gnus-clear-inboxes-moved ()
|
|
|
785 (setq nnmail-moved-inboxes nil))
|
|
|
786
|
|
|
787 (defun gnus-mouse-pick-group (e)
|
|
|
788 "Enter the group under the mouse pointer."
|
|
|
789 (interactive "e")
|
|
|
790 (mouse-set-point e)
|
|
|
791 (gnus-group-read-group nil))
|
|
|
792
|
|
|
793 ;; Look at LEVEL and find out what the level is really supposed to be.
|
|
|
794 ;; If LEVEL is non-nil, LEVEL will be returned, if not, what happens
|
|
|
795 ;; will depend on whether `gnus-group-use-permanent-levels' is used.
|
|
|
796 (defun gnus-group-default-level (&optional level number-or-nil)
|
|
|
797 (cond
|
|
|
798 (gnus-group-use-permanent-levels
|
|
|
799 (or (setq gnus-group-use-permanent-levels
|
|
|
800 (or level (if (numberp gnus-group-use-permanent-levels)
|
|
|
801 gnus-group-use-permanent-levels
|
|
|
802 (or gnus-group-default-list-level
|
|
|
803 gnus-level-subscribed))))
|
|
|
804 gnus-group-default-list-level gnus-level-subscribed))
|
|
|
805 (number-or-nil
|
|
|
806 level)
|
|
|
807 (t
|
|
|
808 (or level gnus-group-default-list-level gnus-level-subscribed))))
|
|
|
809
|
|
|
810 (defun gnus-group-setup-buffer ()
|
|
|
811 (switch-to-buffer gnus-group-buffer)
|
|
|
812 (unless (eq major-mode 'gnus-group-mode)
|
|
|
813 (gnus-add-current-to-buffer-list)
|
|
|
814 (gnus-group-mode)
|
|
|
815 (when gnus-carpal
|
|
|
816 (gnus-carpal-setup-buffer 'group))))
|
|
|
817
|
|
|
818 (defun gnus-group-list-groups (&optional level unread lowest)
|
|
|
819 "List newsgroups with level LEVEL or lower that have unread articles.
|
|
|
820 Default is all subscribed groups.
|
|
|
821 If argument UNREAD is non-nil, groups with no unread articles are also
|
|
|
822 listed."
|
|
|
823 (interactive
|
|
|
824 (list (if current-prefix-arg
|
|
|
825 (prefix-numeric-value current-prefix-arg)
|
|
|
826 (or
|
|
|
827 (gnus-group-default-level nil t)
|
|
|
828 gnus-group-default-list-level
|
|
|
829 gnus-level-subscribed))))
|
|
|
830 ;; Just do this here, for no particular good reason.
|
|
|
831 (gnus-clear-inboxes-moved)
|
|
|
832 (unless level
|
|
|
833 (setq level (car gnus-group-list-mode)
|
|
|
834 unread (cdr gnus-group-list-mode)))
|
|
|
835 (setq level (gnus-group-default-level level))
|
|
|
836 (gnus-group-setup-buffer)
|
|
|
837 (gnus-update-format-specifications nil 'group 'group-mode)
|
|
|
838 (let ((case-fold-search nil)
|
|
|
839 (props (text-properties-at (gnus-point-at-bol)))
|
|
|
840 (empty (= (point-min) (point-max)))
|
|
|
841 (group (gnus-group-group-name))
|
|
|
842 number)
|
|
|
843 (set-buffer gnus-group-buffer)
|
|
|
844 (setq number (funcall gnus-group-prepare-function level unread lowest))
|
|
|
845 (when (or (and (numberp number)
|
|
|
846 (zerop number))
|
|
|
847 (zerop (buffer-size)))
|
|
|
848 ;; No groups in the buffer.
|
|
|
849 (gnus-message 5 gnus-no-groups-message))
|
|
|
850 ;; We have some groups displayed.
|
|
|
851 (goto-char (point-max))
|
|
|
852 (when (or (not gnus-group-goto-next-group-function)
|
|
|
853 (not (funcall gnus-group-goto-next-group-function
|
|
|
854 group props)))
|
|
|
855 (cond
|
|
|
856 (empty
|
|
|
857 (goto-char (point-min)))
|
|
|
858 ((not group)
|
|
|
859 ;; Go to the first group with unread articles.
|
|
|
860 (gnus-group-search-forward t))
|
|
|
861 (t
|
|
|
862 ;; Find the right group to put point on. If the current group
|
|
|
863 ;; has disappeared in the new listing, try to find the next
|
|
|
864 ;; one. If no next one can be found, just leave point at the
|
|
|
865 ;; first newsgroup in the buffer.
|
|
|
866 (when (not (gnus-goto-char
|
|
|
867 (text-property-any
|
|
|
868 (point-min) (point-max)
|
|
|
869 'gnus-group (gnus-intern-safe
|
|
|
870 group gnus-active-hashtb))))
|
|
|
871 (let ((newsrc (cdddr (gnus-gethash group gnus-newsrc-hashtb))))
|
|
|
872 (while (and newsrc
|
|
|
873 (not (gnus-goto-char
|
|
|
874 (text-property-any
|
|
|
875 (point-min) (point-max) 'gnus-group
|
|
|
876 (gnus-intern-safe
|
|
|
877 (caar newsrc) gnus-active-hashtb)))))
|
|
|
878 (setq newsrc (cdr newsrc)))
|
|
|
879 (unless newsrc
|
|
|
880 (goto-char (point-max))
|
|
|
881 (forward-line -1)))))))
|
|
|
882 ;; Adjust cursor point.
|
|
|
883 (gnus-group-position-point)))
|
|
|
884
|
|
|
885 (defun gnus-group-list-level (level &optional all)
|
|
|
886 "List groups on LEVEL.
|
|
|
887 If ALL (the prefix), also list groups that have no unread articles."
|
|
|
888 (interactive "nList groups on level: \nP")
|
|
|
889 (gnus-group-list-groups level all level))
|
|
|
890
|
|
|
891 (defun gnus-group-prepare-flat (level &optional all lowest regexp)
|
|
|
892 "List all newsgroups with unread articles of level LEVEL or lower.
|
|
|
893 If ALL is non-nil, list groups that have no unread articles.
|
|
|
894 If LOWEST is non-nil, list all newsgroups of level LOWEST or higher.
|
|
|
895 If REGEXP, only list groups matching REGEXP."
|
|
|
896 (set-buffer gnus-group-buffer)
|
|
|
897 (let ((buffer-read-only nil)
|
|
|
898 (newsrc (cdr gnus-newsrc-alist))
|
|
|
899 (lowest (or lowest 1))
|
|
|
900 info clevel unread group params)
|
|
|
901 (erase-buffer)
|
|
|
902 (when (< lowest gnus-level-zombie)
|
|
|
903 ;; List living groups.
|
|
|
904 (while newsrc
|
|
|
905 (setq info (car newsrc)
|
|
|
906 group (gnus-info-group info)
|
|
|
907 params (gnus-info-params info)
|
|
|
908 newsrc (cdr newsrc)
|
|
|
909 unread (car (gnus-gethash group gnus-newsrc-hashtb)))
|
|
|
910 (and unread ; This group might be bogus
|
|
|
911 (or (not regexp)
|
|
|
912 (string-match regexp group))
|
|
|
913 (<= (setq clevel (gnus-info-level info)) level)
|
|
|
914 (>= clevel lowest)
|
|
|
915 (or all ; We list all groups?
|
|
|
916 (if (eq unread t) ; Unactivated?
|
|
|
917 gnus-group-list-inactive-groups ; We list unactivated
|
|
|
918 (> unread 0)) ; We list groups with unread articles
|
|
|
919 (and gnus-list-groups-with-ticked-articles
|
|
|
920 (cdr (assq 'tick (gnus-info-marks info))))
|
|
|
921 ; And groups with tickeds
|
|
|
922 ;; Check for permanent visibility.
|
|
|
923 (and gnus-permanently-visible-groups
|
|
|
924 (string-match gnus-permanently-visible-groups
|
|
|
925 group))
|
|
|
926 (memq 'visible params)
|
|
|
927 (cdr (assq 'visible params)))
|
|
|
928 (gnus-group-insert-group-line
|
|
|
929 group (gnus-info-level info)
|
|
|
930 (gnus-info-marks info) unread (gnus-info-method info)))))
|
|
|
931
|
|
|
932 ;; List dead groups.
|
|
|
933 (and (>= level gnus-level-zombie) (<= lowest gnus-level-zombie)
|
|
|
934 (gnus-group-prepare-flat-list-dead
|
|
|
935 (setq gnus-zombie-list (sort gnus-zombie-list 'string<))
|
|
|
936 gnus-level-zombie ?Z
|
|
|
937 regexp))
|
|
|
938 (and (>= level gnus-level-killed) (<= lowest gnus-level-killed)
|
|
|
939 (gnus-group-prepare-flat-list-dead
|
|
|
940 (setq gnus-killed-list (sort gnus-killed-list 'string<))
|
|
|
941 gnus-level-killed ?K regexp))
|
|
|
942
|
|
|
943 (gnus-group-set-mode-line)
|
|
|
944 (setq gnus-group-list-mode (cons level all))
|
|
|
945 (run-hooks 'gnus-group-prepare-hook)
|
|
|
946 t))
|
|
|
947
|
|
|
948 (defun gnus-group-prepare-flat-list-dead (groups level mark regexp)
|
|
|
949 ;; List zombies and killed lists somewhat faster, which was
|
|
|
950 ;; suggested by Jack Vinson <vinson@unagi.cis.upenn.edu>. It does
|
|
|
951 ;; this by ignoring the group format specification altogether.
|
|
|
952 (let (group)
|
|
|
953 (if regexp
|
|
|
954 ;; This loop is used when listing groups that match some
|
|
|
955 ;; regexp.
|
|
|
956 (while groups
|
|
|
957 (setq group (pop groups))
|
|
|
958 (when (string-match regexp group)
|
|
|
959 (gnus-add-text-properties
|
|
|
960 (point) (prog1 (1+ (point))
|
|
|
961 (insert " " mark " *: " group "\n"))
|
|
|
962 (list 'gnus-group (gnus-intern-safe group gnus-active-hashtb)
|
|
|
963 'gnus-unread t
|
|
|
964 'gnus-level level))))
|
|
|
965 ;; This loop is used when listing all groups.
|
|
|
966 (while groups
|
|
|
967 (gnus-add-text-properties
|
|
|
968 (point) (prog1 (1+ (point))
|
|
|
969 (insert " " mark " *: "
|
|
|
970 (setq group (pop groups)) "\n"))
|
|
|
971 (list 'gnus-group (gnus-intern-safe group gnus-active-hashtb)
|
|
|
972 'gnus-unread t
|
|
|
973 'gnus-level level))))))
|
|
|
974
|
|
|
975 (defun gnus-group-update-group-line ()
|
|
|
976 "Update the current line in the group buffer."
|
|
|
977 (let* ((buffer-read-only nil)
|
|
|
978 (group (gnus-group-group-name))
|
|
|
979 (entry (and group (gnus-gethash group gnus-newsrc-hashtb)))
|
|
|
980 gnus-group-indentation)
|
|
|
981 (when group
|
|
|
982 (and entry
|
|
|
983 (not (gnus-ephemeral-group-p group))
|
|
|
984 (gnus-dribble-enter
|
|
|
985 (concat "(gnus-group-set-info '"
|
|
|
986 (gnus-prin1-to-string (nth 2 entry))
|
|
|
987 ")")))
|
|
|
988 (setq gnus-group-indentation (gnus-group-group-indentation))
|
|
|
989 (gnus-delete-line)
|
|
|
990 (gnus-group-insert-group-line-info group)
|
|
|
991 (forward-line -1)
|
|
|
992 (gnus-group-position-point))))
|
|
|
993
|
|
|
994 (defun gnus-group-insert-group-line-info (group)
|
|
|
995 "Insert GROUP on the current line."
|
|
|
996 (let ((entry (gnus-gethash group gnus-newsrc-hashtb))
|
|
|
997 (gnus-group-indentation (gnus-group-group-indentation))
|
|
|
998 active info)
|
|
|
999 (if entry
|
|
|
1000 (progn
|
|
|
1001 ;; (Un)subscribed group.
|
|
|
1002 (setq info (nth 2 entry))
|
|
|
1003 (gnus-group-insert-group-line
|
|
|
1004 group (gnus-info-level info) (gnus-info-marks info)
|
|
|
1005 (or (car entry) t) (gnus-info-method info)))
|
|
|
1006 ;; This group is dead.
|
|
|
1007 (gnus-group-insert-group-line
|
|
|
1008 group
|
|
|
1009 (if (member group gnus-zombie-list) gnus-level-zombie gnus-level-killed)
|
|
|
1010 nil
|
|
|
1011 (if (setq active (gnus-active group))
|
|
|
1012 (if (zerop (cdr active))
|
|
|
1013 0
|
|
|
1014 (- (1+ (cdr active)) (car active)))
|
|
|
1015 nil)
|
|
|
1016 nil))))
|
|
|
1017
|
|
|
1018 (defun gnus-group-insert-group-line (gnus-tmp-group gnus-tmp-level
|
|
|
1019 gnus-tmp-marked number
|
|
|
1020 gnus-tmp-method)
|
|
|
1021 "Insert a group line in the group buffer."
|
|
|
1022 (let* ((gnus-tmp-active (gnus-active gnus-tmp-group))
|
|
|
1023 (gnus-tmp-number-total
|
|
|
1024 (if gnus-tmp-active
|
|
|
1025 (1+ (- (cdr gnus-tmp-active) (car gnus-tmp-active)))
|
|
|
1026 0))
|
|
|
1027 (gnus-tmp-number-of-unread
|
|
|
1028 (if (numberp number) (int-to-string (max 0 number))
|
|
|
1029 "*"))
|
|
|
1030 (gnus-tmp-number-of-read
|
|
|
1031 (if (numberp number)
|
|
|
1032 (int-to-string (max 0 (- gnus-tmp-number-total number)))
|
|
|
1033 "*"))
|
|
|
1034 (gnus-tmp-subscribed
|
|
|
1035 (cond ((<= gnus-tmp-level gnus-level-subscribed) ? )
|
|
|
1036 ((<= gnus-tmp-level gnus-level-unsubscribed) ?U)
|
|
|
1037 ((= gnus-tmp-level gnus-level-zombie) ?Z)
|
|
|
1038 (t ?K)))
|
|
|
1039 (gnus-tmp-qualified-group (gnus-group-real-name gnus-tmp-group))
|
|
|
1040 (gnus-tmp-newsgroup-description
|
|
|
1041 (if gnus-description-hashtb
|
|
|
1042 (or (gnus-gethash gnus-tmp-group gnus-description-hashtb) "")
|
|
|
1043 ""))
|
|
|
1044 (gnus-tmp-moderated
|
|
|
1045 (if (and gnus-moderated-hashtb
|
|
|
1046 (gnus-gethash gnus-tmp-group gnus-moderated-hashtb))
|
|
|
1047 ?m ? ))
|
|
|
1048 (gnus-tmp-moderated-string
|
|
|
1049 (if (eq gnus-tmp-moderated ?m) "(m)" ""))
|
|
|
1050 (gnus-tmp-method
|
|
|
1051 (gnus-server-get-method gnus-tmp-group gnus-tmp-method))
|
|
|
1052 (gnus-tmp-news-server (or (cadr gnus-tmp-method) ""))
|
|
|
1053 (gnus-tmp-news-method (or (car gnus-tmp-method) ""))
|
|
|
1054 (gnus-tmp-news-method-string
|
|
|
1055 (if gnus-tmp-method
|
|
|
1056 (format "(%s:%s)" (car gnus-tmp-method)
|
|
|
1057 (cadr gnus-tmp-method)) ""))
|
|
|
1058 (gnus-tmp-marked-mark
|
|
|
1059 (if (and (numberp number)
|
|
|
1060 (zerop number)
|
|
|
1061 (cdr (assq 'tick gnus-tmp-marked)))
|
|
|
1062 ?* ? ))
|
|
|
1063 (gnus-tmp-process-marked
|
|
|
1064 (if (member gnus-tmp-group gnus-group-marked)
|
|
|
1065 gnus-process-mark ? ))
|
|
|
1066 (gnus-tmp-grouplens
|
|
|
1067 (or (and gnus-use-grouplens
|
|
|
1068 (bbb-grouplens-group-p gnus-tmp-group))
|
|
|
1069 ""))
|
|
|
1070 (buffer-read-only nil)
|
|
|
1071 header gnus-tmp-header) ; passed as parameter to user-funcs.
|
|
|
1072 (beginning-of-line)
|
|
|
1073 (gnus-add-text-properties
|
|
|
1074 (point)
|
|
|
1075 (prog1 (1+ (point))
|
|
|
1076 ;; Insert the text.
|
|
|
1077 (eval gnus-group-line-format-spec))
|
|
|
1078 `(gnus-group ,(gnus-intern-safe gnus-tmp-group gnus-active-hashtb)
|
|
|
1079 gnus-unread ,(if (numberp number)
|
|
|
1080 (string-to-int gnus-tmp-number-of-unread)
|
|
|
1081 t)
|
|
|
1082 gnus-marked ,gnus-tmp-marked-mark
|
|
|
1083 gnus-indentation ,gnus-group-indentation
|
|
|
1084 gnus-level ,gnus-tmp-level))
|
|
|
1085 (when (inline (gnus-visual-p 'group-highlight 'highlight))
|
|
|
1086 (forward-line -1)
|
|
|
1087 (run-hooks 'gnus-group-update-hook)
|
|
|
1088 (forward-line))
|
|
|
1089 ;; Allow XEmacs to remove front-sticky text properties.
|
|
|
1090 (gnus-group-remove-excess-properties)))
|
|
|
1091
|
|
|
1092 (defun gnus-group-highlight-line ()
|
|
|
1093 "Highlight the current line according to `gnus-group-highlight'."
|
|
|
1094 (let* ((list gnus-group-highlight)
|
|
|
1095 (p (point))
|
|
|
1096 (end (progn (end-of-line) (point)))
|
|
|
1097 ;; now find out where the line starts and leave point there.
|
|
|
1098 (beg (progn (beginning-of-line) (point)))
|
|
|
1099 (group (gnus-group-group-name))
|
|
|
1100 (entry (gnus-group-entry group))
|
|
|
1101 (unread (if (numberp (car entry)) (car entry) 0))
|
|
|
1102 (active (gnus-active group))
|
|
|
1103 (total (if active (1+ (- (cdr active) (car active))) 0))
|
|
|
1104 (info (nth 2 entry))
|
|
|
1105 (method (gnus-server-get-method group (gnus-info-method info)))
|
|
|
1106 (marked (gnus-info-marks info))
|
|
|
1107 (mailp (memq 'mail (assoc (symbol-name
|
|
|
1108 (car (or method gnus-select-method)))
|
|
|
1109 gnus-valid-select-methods)))
|
|
|
1110 (level (or (gnus-info-level info) 9))
|
|
|
1111 (score (or (gnus-info-score info) 0))
|
|
|
1112 (ticked (gnus-range-length (cdr (assq 'tick marked))))
|
|
|
1113 (group-age (gnus-group-timestamp-delta group))
|
|
|
1114 (inhibit-read-only t))
|
|
|
1115 ;; Eval the cars of the lists until we find a match.
|
|
|
1116 (while (and list
|
|
|
1117 (not (eval (caar list))))
|
|
|
1118 (setq list (cdr list)))
|
|
|
1119 (let ((face (cdar list)))
|
|
|
1120 (unless (eq face (get-text-property beg 'face))
|
|
|
1121 (gnus-put-text-property
|
|
|
1122 beg end 'face
|
|
|
1123 (setq face (if (boundp face) (symbol-value face) face)))
|
|
|
1124 (gnus-extent-start-open beg)))
|
|
|
1125 (goto-char p)))
|
|
|
1126
|
|
|
1127 (defun gnus-group-update-group (group &optional visible-only)
|
|
|
1128 "Update all lines where GROUP appear.
|
|
|
1129 If VISIBLE-ONLY is non-nil, the group won't be displayed if it isn't
|
|
|
1130 already."
|
|
|
1131 (save-excursion
|
|
|
1132 (set-buffer gnus-group-buffer)
|
|
|
1133 ;; The buffer may be narrowed.
|
|
|
1134 (save-restriction
|
|
|
1135 (widen)
|
|
|
1136 (let ((ident (gnus-intern-safe group gnus-active-hashtb))
|
|
|
1137 (loc (point-min))
|
|
|
1138 found buffer-read-only)
|
|
|
1139 ;; Enter the current status into the dribble buffer.
|
|
|
1140 (let ((entry (gnus-gethash group gnus-newsrc-hashtb)))
|
|
|
1141 (when (and entry (not (gnus-ephemeral-group-p group)))
|
|
|
1142 (gnus-dribble-enter
|
|
|
1143 (concat "(gnus-group-set-info '"
|
|
|
1144 (gnus-prin1-to-string (nth 2 entry))
|
|
|
1145 ")"))))
|
|
|
1146 ;; Find all group instances. If topics are in use, each group
|
|
|
1147 ;; may be listed in more than once.
|
|
|
1148 (while (setq loc (text-property-any
|
|
|
1149 loc (point-max) 'gnus-group ident))
|
|
|
1150 (setq found t)
|
|
|
1151 (goto-char loc)
|
|
|
1152 (let ((gnus-group-indentation (gnus-group-group-indentation)))
|
|
|
1153 (gnus-delete-line)
|
|
|
1154 (gnus-group-insert-group-line-info group)
|
|
|
1155 (save-excursion
|
|
|
1156 (forward-line -1)
|
|
|
1157 (run-hooks 'gnus-group-update-group-hook)))
|
|
|
1158 (setq loc (1+ loc)))
|
|
|
1159 (unless (or found visible-only)
|
|
|
1160 ;; No such line in the buffer, find out where it's supposed to
|
|
|
1161 ;; go, and insert it there (or at the end of the buffer).
|
|
|
1162 (if gnus-goto-missing-group-function
|
|
|
1163 (funcall gnus-goto-missing-group-function group)
|
|
|
1164 (let ((entry (cddr (gnus-gethash group gnus-newsrc-hashtb))))
|
|
|
1165 (while (and entry (car entry)
|
|
|
1166 (not
|
|
|
1167 (gnus-goto-char
|
|
|
1168 (text-property-any
|
|
|
1169 (point-min) (point-max)
|
|
|
1170 'gnus-group (gnus-intern-safe
|
|
|
1171 (caar entry) gnus-active-hashtb)))))
|
|
|
1172 (setq entry (cdr entry)))
|
|
|
1173 (or entry (goto-char (point-max)))))
|
|
|
1174 ;; Finally insert the line.
|
|
|
1175 (let ((gnus-group-indentation (gnus-group-group-indentation)))
|
|
|
1176 (gnus-group-insert-group-line-info group)
|
|
|
1177 (save-excursion
|
|
|
1178 (forward-line -1)
|
|
|
1179 (run-hooks 'gnus-group-update-group-hook))))
|
|
|
1180 (when gnus-group-update-group-function
|
|
|
1181 (funcall gnus-group-update-group-function group))
|
|
|
1182 (gnus-group-set-mode-line)))))
|
|
|
1183
|
|
|
1184 (defun gnus-group-set-mode-line ()
|
|
|
1185 "Update the mode line in the group buffer."
|
|
|
1186 (when (memq 'group gnus-updated-mode-lines)
|
|
|
1187 ;; Yes, we want to keep this mode line updated.
|
|
|
1188 (save-excursion
|
|
|
1189 (set-buffer gnus-group-buffer)
|
|
|
1190 (let* ((gformat (or gnus-group-mode-line-format-spec
|
|
|
1191 (setq gnus-group-mode-line-format-spec
|
|
|
1192 (gnus-parse-format
|
|
|
1193 gnus-group-mode-line-format
|
|
|
1194 gnus-group-mode-line-format-alist))))
|
|
|
1195 (gnus-tmp-news-server (cadr gnus-select-method))
|
|
|
1196 (gnus-tmp-news-method (car gnus-select-method))
|
|
|
1197 (gnus-tmp-colon (if (equal gnus-tmp-news-server "") "" ":"))
|
|
|
1198 (max-len 60)
|
|
|
1199 gnus-tmp-header ;Dummy binding for user-defined formats
|
|
|
1200 ;; Get the resulting string.
|
|
|
1201 (modified
|
|
|
1202 (and gnus-dribble-buffer
|
|
|
1203 (buffer-name gnus-dribble-buffer)
|
|
|
1204 (buffer-modified-p gnus-dribble-buffer)
|
|
|
1205 (save-excursion
|
|
|
1206 (set-buffer gnus-dribble-buffer)
|
|
|
1207 (not (zerop (buffer-size))))))
|
|
|
1208 (mode-string (eval gformat)))
|
|
|
1209 ;; Say whether the dribble buffer has been modified.
|
|
|
1210 (setq mode-line-modified
|
|
100
|
1211 (if modified "--**- " "----- "))
|
|
98
|
1212 ;; If the line is too long, we chop it off.
|
|
|
1213 (when (> (length mode-string) max-len)
|
|
|
1214 (setq mode-string (substring mode-string 0 (- max-len 4))))
|
|
|
1215 (prog1
|
|
|
1216 (setq mode-line-buffer-identification
|
|
|
1217 (gnus-mode-line-buffer-identification
|
|
|
1218 (list mode-string)))
|
|
|
1219 (set-buffer-modified-p modified))))))
|
|
|
1220
|
|
|
1221 (defun gnus-group-group-name ()
|
|
|
1222 "Get the name of the newsgroup on the current line."
|
|
|
1223 (let ((group (get-text-property (gnus-point-at-bol) 'gnus-group)))
|
|
|
1224 (and group (symbol-name group))))
|
|
|
1225
|
|
|
1226 (defun gnus-group-group-level ()
|
|
|
1227 "Get the level of the newsgroup on the current line."
|
|
|
1228 (get-text-property (gnus-point-at-bol) 'gnus-level))
|
|
|
1229
|
|
|
1230 (defun gnus-group-group-indentation ()
|
|
|
1231 "Get the indentation of the newsgroup on the current line."
|
|
|
1232 (or (get-text-property (gnus-point-at-bol) 'gnus-indentation)
|
|
|
1233 (and gnus-group-indentation-function
|
|
|
1234 (funcall gnus-group-indentation-function))
|
|
|
1235 ""))
|
|
|
1236
|
|
|
1237 (defun gnus-group-group-unread ()
|
|
|
1238 "Get the number of unread articles of the newsgroup on the current line."
|
|
|
1239 (get-text-property (gnus-point-at-bol) 'gnus-unread))
|
|
|
1240
|
|
|
1241 (defun gnus-group-new-mail (group)
|
|
|
1242 (if (nnmail-new-mail-p (gnus-group-real-name group))
|
|
|
1243 gnus-new-mail-mark
|
|
|
1244 ? ))
|
|
|
1245
|
|
|
1246 (defun gnus-group-level (group)
|
|
|
1247 "Return the estimated level of GROUP."
|
|
|
1248 (or (gnus-info-level (gnus-get-info group))
|
|
|
1249 (and (member group gnus-zombie-list) 8)
|
|
|
1250 9))
|
|
|
1251
|
|
|
1252 (defun gnus-group-search-forward (&optional backward all level first-too)
|
|
|
1253 "Find the next newsgroup with unread articles.
|
|
|
1254 If BACKWARD is non-nil, find the previous newsgroup instead.
|
|
|
1255 If ALL is non-nil, just find any newsgroup.
|
|
|
1256 If LEVEL is non-nil, find group with level LEVEL, or higher if no such
|
|
|
1257 group exists.
|
|
|
1258 If FIRST-TOO, the current line is also eligible as a target."
|
|
|
1259 (let ((way (if backward -1 1))
|
|
|
1260 (low gnus-level-killed)
|
|
|
1261 (beg (point))
|
|
|
1262 pos found lev)
|
|
|
1263 (if (and backward (progn (beginning-of-line)) (bobp))
|
|
|
1264 nil
|
|
|
1265 (unless first-too
|
|
|
1266 (forward-line way))
|
|
|
1267 (while (and
|
|
|
1268 (not (eobp))
|
|
|
1269 (not (setq
|
|
|
1270 found
|
|
|
1271 (and (or all
|
|
|
1272 (and
|
|
|
1273 (let ((unread
|
|
|
1274 (get-text-property (point) 'gnus-unread)))
|
|
|
1275 (and (numberp unread) (> unread 0)))
|
|
|
1276 (setq lev (get-text-property (point)
|
|
|
1277 'gnus-level))
|
|
|
1278 (<= lev gnus-level-subscribed)))
|
|
|
1279 (or (not level)
|
|
|
1280 (and (setq lev (get-text-property (point)
|
|
|
1281 'gnus-level))
|
|
|
1282 (or (= lev level)
|
|
|
1283 (and (< lev low)
|
|
|
1284 (< level lev)
|
|
|
1285 (progn
|
|
|
1286 (setq low lev)
|
|
|
1287 (setq pos (point))
|
|
|
1288 nil))))))))
|
|
|
1289 (zerop (forward-line way)))))
|
|
|
1290 (if found
|
|
|
1291 (progn (gnus-group-position-point) t)
|
|
|
1292 (goto-char (or pos beg))
|
|
|
1293 (and pos t))))
|
|
|
1294
|
|
|
1295 ;;; Gnus group mode commands
|
|
|
1296
|
|
|
1297 ;; Group marking.
|
|
|
1298
|
|
|
1299 (defun gnus-group-mark-group (n &optional unmark no-advance)
|
|
|
1300 "Mark the current group."
|
|
|
1301 (interactive "p")
|
|
|
1302 (let ((buffer-read-only nil)
|
|
|
1303 group)
|
|
|
1304 (while (and (> n 0)
|
|
|
1305 (not (eobp)))
|
|
|
1306 (when (setq group (gnus-group-group-name))
|
|
|
1307 ;; Go to the mark position.
|
|
|
1308 (beginning-of-line)
|
|
|
1309 (forward-char (or (cdr (assq 'process gnus-group-mark-positions)) 2))
|
|
|
1310 (subst-char-in-region
|
|
|
1311 (point) (1+ (point)) (following-char)
|
|
|
1312 (if unmark
|
|
|
1313 (progn
|
|
|
1314 (setq gnus-group-marked (delete group gnus-group-marked))
|
|
|
1315 ? )
|
|
|
1316 (setq gnus-group-marked
|
|
|
1317 (cons group (delete group gnus-group-marked)))
|
|
|
1318 gnus-process-mark)))
|
|
|
1319 (unless no-advance
|
|
|
1320 (gnus-group-next-group 1))
|
|
|
1321 (decf n))
|
|
|
1322 (gnus-summary-position-point)
|
|
|
1323 n))
|
|
|
1324
|
|
|
1325 (defun gnus-group-unmark-group (n)
|
|
|
1326 "Remove the mark from the current group."
|
|
|
1327 (interactive "p")
|
|
|
1328 (gnus-group-mark-group n 'unmark)
|
|
|
1329 (gnus-group-position-point))
|
|
|
1330
|
|
|
1331 (defun gnus-group-unmark-all-groups ()
|
|
|
1332 "Unmark all groups."
|
|
|
1333 (interactive)
|
|
|
1334 (let ((groups gnus-group-marked))
|
|
|
1335 (save-excursion
|
|
|
1336 (while groups
|
|
|
1337 (gnus-group-remove-mark (pop groups)))))
|
|
|
1338 (gnus-group-position-point))
|
|
|
1339
|
|
|
1340 (defun gnus-group-mark-region (unmark beg end)
|
|
|
1341 "Mark all groups between point and mark.
|
|
|
1342 If UNMARK, remove the mark instead."
|
|
|
1343 (interactive "P\nr")
|
|
|
1344 (let ((num (count-lines beg end)))
|
|
|
1345 (save-excursion
|
|
|
1346 (goto-char beg)
|
|
|
1347 (- num (gnus-group-mark-group num unmark)))))
|
|
|
1348
|
|
|
1349 (defun gnus-group-mark-buffer (&optional unmark)
|
|
|
1350 "Mark all groups in the buffer.
|
|
|
1351 If UNMARK, remove the mark instead."
|
|
|
1352 (interactive "P")
|
|
|
1353 (gnus-group-mark-region unmark (point-min) (point-max)))
|
|
|
1354
|
|
|
1355 (defun gnus-group-mark-regexp (regexp)
|
|
|
1356 "Mark all groups that match some regexp."
|
|
|
1357 (interactive "sMark (regexp): ")
|
|
|
1358 (let ((alist (cdr gnus-newsrc-alist))
|
|
|
1359 group)
|
|
|
1360 (while alist
|
|
|
1361 (when (string-match regexp (setq group (gnus-info-group (pop alist))))
|
|
|
1362 (gnus-group-set-mark group))))
|
|
|
1363 (gnus-group-position-point))
|
|
|
1364
|
|
|
1365 (defun gnus-group-remove-mark (group)
|
|
|
1366 "Remove the process mark from GROUP and move point there.
|
|
|
1367 Return nil if the group isn't displayed."
|
|
|
1368 (if (gnus-group-goto-group group)
|
|
|
1369 (save-excursion
|
|
|
1370 (gnus-group-mark-group 1 'unmark t)
|
|
|
1371 t)
|
|
|
1372 (setq gnus-group-marked
|
|
|
1373 (delete group gnus-group-marked))
|
|
|
1374 nil))
|
|
|
1375
|
|
|
1376 (defun gnus-group-set-mark (group)
|
|
|
1377 "Set the process mark on GROUP."
|
|
|
1378 (if (gnus-group-goto-group group)
|
|
|
1379 (save-excursion
|
|
|
1380 (gnus-group-mark-group 1 nil t))
|
|
|
1381 (setq gnus-group-marked (cons group (delete group gnus-group-marked)))))
|
|
|
1382
|
|
|
1383 (defun gnus-group-universal-argument (arg &optional groups func)
|
|
|
1384 "Perform any command on all groups according to the process/prefix convention."
|
|
|
1385 (interactive "P")
|
|
|
1386 (if (eq (setq func (or func
|
|
|
1387 (key-binding
|
|
|
1388 (read-key-sequence
|
|
|
1389 (substitute-command-keys
|
|
|
1390 "\\<gnus-group-mode-map>\\[gnus-group-universal-argument]")))))
|
|
|
1391 'undefined)
|
|
|
1392 (gnus-error 1 "Undefined key")
|
|
|
1393 (gnus-group-iterate arg
|
|
|
1394 (lambda (group)
|
|
|
1395 (command-execute func))))
|
|
|
1396 (gnus-group-position-point))
|
|
|
1397
|
|
|
1398 (defun gnus-group-process-prefix (n)
|
|
|
1399 "Return a list of groups to work on.
|
|
|
1400 Take into consideration N (the prefix) and the list of marked groups."
|
|
|
1401 (cond
|
|
|
1402 (n
|
|
|
1403 (setq n (prefix-numeric-value n))
|
|
|
1404 ;; There is a prefix, so we return a list of the N next
|
|
|
1405 ;; groups.
|
|
|
1406 (let ((way (if (< n 0) -1 1))
|
|
|
1407 (n (abs n))
|
|
|
1408 group groups)
|
|
|
1409 (save-excursion
|
|
|
1410 (while (and (> n 0)
|
|
|
1411 (setq group (gnus-group-group-name)))
|
|
|
1412 (push group groups)
|
|
|
1413 (setq n (1- n))
|
|
|
1414 (gnus-group-next-group way)))
|
|
|
1415 (nreverse groups)))
|
|
100
|
1416 ((gnus-region-active-p)
|
|
98
|
1417 ;; Work on the region between point and mark.
|
|
|
1418 (let ((max (max (point) (mark)))
|
|
|
1419 groups)
|
|
|
1420 (save-excursion
|
|
|
1421 (goto-char (min (point) (mark)))
|
|
|
1422 (while
|
|
|
1423 (and
|
|
|
1424 (push (gnus-group-group-name) groups)
|
|
|
1425 (zerop (gnus-group-next-group 1))
|
|
|
1426 (< (point) max)))
|
|
|
1427 (nreverse groups))))
|
|
|
1428 (gnus-group-marked
|
|
|
1429 ;; No prefix, but a list of marked articles.
|
|
|
1430 (reverse gnus-group-marked))
|
|
|
1431 (t
|
|
|
1432 ;; Neither marked articles or a prefix, so we return the
|
|
|
1433 ;; current group.
|
|
|
1434 (let ((group (gnus-group-group-name)))
|
|
|
1435 (and group (list group))))))
|
|
|
1436
|
|
|
1437 (defun gnus-group-iterate (arg function)
|
|
|
1438 "Iterate FUNCTION over all process/prefixed groups.
|
|
|
1439 FUNCTION will be called with the group name as the paremeter
|
|
|
1440 and with point over the group in question."
|
|
|
1441 (let ((groups (gnus-group-process-prefix arg))
|
|
|
1442 group)
|
|
|
1443 (while (setq group (pop groups))
|
|
|
1444 (gnus-group-remove-mark group)
|
|
|
1445 (funcall function group))))
|
|
|
1446
|
|
|
1447 (put 'gnus-group-iterate 'lisp-indent-function 1)
|
|
|
1448
|
|
|
1449 ;; Selecting groups.
|
|
|
1450
|
|
|
1451 (defun gnus-group-read-group (&optional all no-article group)
|
|
|
1452 "Read news in this newsgroup.
|
|
|
1453 If the prefix argument ALL is non-nil, already read articles become
|
|
|
1454 readable. IF ALL is a number, fetch this number of articles. If the
|
|
|
1455 optional argument NO-ARTICLE is non-nil, no article will be
|
|
|
1456 auto-selected upon group entry. If GROUP is non-nil, fetch that
|
|
|
1457 group."
|
|
|
1458 (interactive "P")
|
|
|
1459 (let ((no-display (eq all 0))
|
|
|
1460 (group (or group (gnus-group-group-name)))
|
|
|
1461 number active marked entry)
|
|
|
1462 (when (eq all 0)
|
|
|
1463 (setq all nil))
|
|
|
1464 (unless group
|
|
|
1465 (error "No group on current line"))
|
|
|
1466 (setq marked (gnus-info-marks
|
|
|
1467 (nth 2 (setq entry (gnus-gethash
|
|
|
1468 group gnus-newsrc-hashtb)))))
|
|
|
1469 ;; This group might be a dead group. In that case we have to get
|
|
|
1470 ;; the number of unread articles from `gnus-active-hashtb'.
|
|
|
1471 (setq number
|
|
|
1472 (cond ((numberp all) all)
|
|
|
1473 (entry (car entry))
|
|
|
1474 ((setq active (gnus-active group))
|
|
|
1475 (- (1+ (cdr active)) (car active)))))
|
|
|
1476 (gnus-summary-read-group
|
|
|
1477 group (or all (and (numberp number)
|
|
|
1478 (zerop (+ number (gnus-range-length
|
|
|
1479 (cdr (assq 'tick marked)))
|
|
|
1480 (gnus-range-length
|
|
|
1481 (cdr (assq 'dormant marked)))))))
|
|
|
1482 no-article nil no-display)))
|
|
|
1483
|
|
|
1484 (defun gnus-group-select-group (&optional all)
|
|
|
1485 "Select this newsgroup.
|
|
|
1486 No article is selected automatically.
|
|
|
1487 If ALL is non-nil, already read articles become readable.
|
|
|
1488 If ALL is a number, fetch this number of articles."
|
|
|
1489 (interactive "P")
|
|
|
1490 (gnus-group-read-group all t))
|
|
|
1491
|
|
|
1492 (defun gnus-group-quick-select-group (&optional all)
|
|
|
1493 "Select the current group \"quickly\".
|
|
|
1494 This means that no highlighting or scoring will be performed.
|
|
|
1495 If ALL (the prefix argument) is 0, don't even generate the summary
|
|
|
1496 buffer."
|
|
|
1497 (interactive "P")
|
|
|
1498 (require 'gnus-score)
|
|
|
1499 (let (gnus-visual
|
|
|
1500 gnus-score-find-score-files-function
|
|
100
|
1501 gnus-home-score-file
|
|
98
|
1502 gnus-apply-kill-hook
|
|
|
1503 gnus-summary-expunge-below)
|
|
|
1504 (gnus-group-read-group all t)))
|
|
|
1505
|
|
|
1506 (defun gnus-group-visible-select-group (&optional all)
|
|
|
1507 "Select the current group without hiding any articles."
|
|
|
1508 (interactive "P")
|
|
|
1509 (let ((gnus-inhibit-limiting t))
|
|
|
1510 (gnus-group-read-group all t)))
|
|
|
1511
|
|
|
1512 (defun gnus-group-select-group-ephemerally ()
|
|
|
1513 "Select the current group without doing any processing whatsoever.
|
|
|
1514 You will actually be entered into a group that's a copy of
|
|
|
1515 the current group; no changes you make while in this group will
|
|
|
1516 be permanent."
|
|
|
1517 (interactive)
|
|
|
1518 (require 'gnus-score)
|
|
|
1519 (let* (gnus-visual
|
|
|
1520 gnus-score-find-score-files-function gnus-apply-kill-hook
|
|
|
1521 gnus-summary-expunge-below gnus-show-threads gnus-suppress-duplicates
|
|
|
1522 gnus-summary-mode-hook gnus-select-group-hook
|
|
|
1523 (group (gnus-group-group-name))
|
|
|
1524 (method (gnus-find-method-for-group group)))
|
|
|
1525 (setq method
|
|
|
1526 `(,(car method) ,(concat (cadr method) "-ephemeral")
|
|
|
1527 (,(intern (format "%s-address" (car method))) ,(cadr method))
|
|
|
1528 ,@(cddr method)))
|
|
|
1529 (gnus-group-read-ephemeral-group
|
|
|
1530 (gnus-group-prefixed-name group method) method)))
|
|
|
1531
|
|
|
1532 ;;;###autoload
|
|
|
1533 (defun gnus-fetch-group (group)
|
|
|
1534 "Start Gnus if necessary and enter GROUP.
|
|
|
1535 Returns whether the fetching was successful or not."
|
|
|
1536 (interactive "sGroup name: ")
|
|
|
1537 (unless (get-buffer gnus-group-buffer)
|
|
|
1538 (gnus))
|
|
|
1539 (gnus-group-read-group nil nil group))
|
|
|
1540
|
|
|
1541 ;; Enter a group that is not in the group buffer. Non-nil is returned
|
|
|
1542 ;; if selection was successful.
|
|
|
1543 (defun gnus-group-read-ephemeral-group (group method &optional activate
|
|
|
1544 quit-config request-only)
|
|
|
1545 "Read GROUP from METHOD as an ephemeral group.
|
|
|
1546 If ACTIVATE, request the group first.
|
|
|
1547 If QUIT-CONFIG, use that window configuration when exiting from the
|
|
|
1548 ephemeral group.
|
|
|
1549 If REQUEST-ONLY, don't actually read the group; just request it.
|
|
|
1550
|
|
|
1551 Return the name of the group is selection was successful."
|
|
|
1552 (let ((group (if (gnus-group-foreign-p group) group
|
|
|
1553 (gnus-group-prefixed-name group method))))
|
|
|
1554 (gnus-sethash
|
|
|
1555 group
|
|
|
1556 `(-1 nil (,group
|
|
|
1557 ,gnus-level-default-subscribed nil nil ,method
|
|
|
1558 ((quit-config .
|
|
|
1559 ,(if quit-config quit-config
|
|
|
1560 (cons gnus-summary-buffer
|
|
|
1561 gnus-current-window-configuration))))))
|
|
|
1562 gnus-newsrc-hashtb)
|
|
|
1563 (set-buffer gnus-group-buffer)
|
|
|
1564 (unless (gnus-check-server method)
|
|
|
1565 (error "Unable to contact server: %s" (gnus-status-message method)))
|
|
|
1566 (when activate
|
|
|
1567 (gnus-activate-group group 'scan)
|
|
|
1568 (unless (gnus-request-group group)
|
|
|
1569 (error "Couldn't request group: %s"
|
|
|
1570 (nnheader-get-report (car method)))))
|
|
|
1571 (if request-only
|
|
|
1572 group
|
|
|
1573 (condition-case ()
|
|
|
1574 (when (gnus-group-read-group t t group)
|
|
|
1575 group)
|
|
|
1576 ;;(error nil)
|
|
|
1577 (quit nil)))))
|
|
|
1578
|
|
|
1579 (defun gnus-group-jump-to-group (group)
|
|
|
1580 "Jump to newsgroup GROUP."
|
|
|
1581 (interactive
|
|
|
1582 (list (completing-read
|
|
|
1583 "Group: " gnus-active-hashtb nil
|
|
|
1584 (gnus-read-active-file-p)
|
|
|
1585 nil
|
|
|
1586 'gnus-group-history)))
|
|
|
1587
|
|
|
1588 (when (equal group "")
|
|
|
1589 (error "Empty group name"))
|
|
|
1590
|
|
|
1591 (unless (gnus-ephemeral-group-p group)
|
|
|
1592 ;; Either go to the line in the group buffer...
|
|
|
1593 (unless (gnus-group-goto-group group)
|
|
|
1594 ;; ... or insert the line.
|
|
|
1595 (gnus-group-update-group group)
|
|
|
1596 (gnus-group-goto-group group)))
|
|
|
1597 ;; Adjust cursor point.
|
|
|
1598 (gnus-group-position-point))
|
|
|
1599
|
|
|
1600 (defun gnus-group-goto-group (group &optional far)
|
|
|
1601 "Goto to newsgroup GROUP.
|
|
|
1602 If FAR, it is likely that the group is not on the current line."
|
|
|
1603 (when group
|
|
|
1604 (if far
|
|
|
1605 (gnus-goto-char
|
|
|
1606 (text-property-any
|
|
|
1607 (point-min) (point-max)
|
|
|
1608 'gnus-group (gnus-intern-safe group gnus-active-hashtb)))
|
|
|
1609 (beginning-of-line)
|
|
|
1610 (cond
|
|
|
1611 ;; It's quite likely that we are on the right line, so
|
|
|
1612 ;; we check the current line first.
|
|
|
1613 ((eq (get-text-property (point) 'gnus-group)
|
|
|
1614 (gnus-intern-safe group gnus-active-hashtb))
|
|
|
1615 (point))
|
|
|
1616 ;; Previous and next line are also likely, so we check them as well.
|
|
|
1617 ((save-excursion
|
|
|
1618 (forward-line -1)
|
|
|
1619 (eq (get-text-property (point) 'gnus-group)
|
|
|
1620 (gnus-intern-safe group gnus-active-hashtb)))
|
|
|
1621 (forward-line -1)
|
|
|
1622 (point))
|
|
|
1623 ((save-excursion
|
|
|
1624 (forward-line 1)
|
|
|
1625 (eq (get-text-property (point) 'gnus-group)
|
|
|
1626 (gnus-intern-safe group gnus-active-hashtb)))
|
|
|
1627 (forward-line 1)
|
|
|
1628 (point))
|
|
|
1629 (t
|
|
|
1630 ;; Search through the entire buffer.
|
|
|
1631 (gnus-goto-char
|
|
|
1632 (text-property-any
|
|
|
1633 (point-min) (point-max)
|
|
|
1634 'gnus-group (gnus-intern-safe group gnus-active-hashtb))))))))
|
|
|
1635
|
|
|
1636 (defun gnus-group-next-group (n &optional silent)
|
|
|
1637 "Go to next N'th newsgroup.
|
|
|
1638 If N is negative, search backward instead.
|
|
|
1639 Returns the difference between N and the number of skips actually
|
|
|
1640 done."
|
|
|
1641 (interactive "p")
|
|
|
1642 (gnus-group-next-unread-group n t nil silent))
|
|
|
1643
|
|
|
1644 (defun gnus-group-next-unread-group (n &optional all level silent)
|
|
|
1645 "Go to next N'th unread newsgroup.
|
|
|
1646 If N is negative, search backward instead.
|
|
|
1647 If ALL is non-nil, choose any newsgroup, unread or not.
|
|
|
1648 If LEVEL is non-nil, choose the next group with level LEVEL, or, if no
|
|
|
1649 such group can be found, the next group with a level higher than
|
|
|
1650 LEVEL.
|
|
|
1651 Returns the difference between N and the number of skips actually
|
|
|
1652 made."
|
|
|
1653 (interactive "p")
|
|
|
1654 (let ((backward (< n 0))
|
|
|
1655 (n (abs n)))
|
|
|
1656 (while (and (> n 0)
|
|
|
1657 (gnus-group-search-forward
|
|
|
1658 backward (or (not gnus-group-goto-unread) all) level))
|
|
|
1659 (setq n (1- n)))
|
|
|
1660 (when (and (/= 0 n)
|
|
|
1661 (not silent))
|
|
|
1662 (gnus-message 7 "No more%s newsgroups%s" (if all "" " unread")
|
|
|
1663 (if level " on this level or higher" "")))
|
|
|
1664 n))
|
|
|
1665
|
|
|
1666 (defun gnus-group-prev-group (n)
|
|
|
1667 "Go to previous N'th newsgroup.
|
|
|
1668 Returns the difference between N and the number of skips actually
|
|
|
1669 done."
|
|
|
1670 (interactive "p")
|
|
|
1671 (gnus-group-next-unread-group (- n) t))
|
|
|
1672
|
|
|
1673 (defun gnus-group-prev-unread-group (n)
|
|
|
1674 "Go to previous N'th unread newsgroup.
|
|
|
1675 Returns the difference between N and the number of skips actually
|
|
|
1676 done."
|
|
|
1677 (interactive "p")
|
|
|
1678 (gnus-group-next-unread-group (- n)))
|
|
|
1679
|
|
|
1680 (defun gnus-group-next-unread-group-same-level (n)
|
|
|
1681 "Go to next N'th unread newsgroup on the same level.
|
|
|
1682 If N is negative, search backward instead.
|
|
|
1683 Returns the difference between N and the number of skips actually
|
|
|
1684 done."
|
|
|
1685 (interactive "p")
|
|
|
1686 (gnus-group-next-unread-group n t (gnus-group-group-level))
|
|
|
1687 (gnus-group-position-point))
|
|
|
1688
|
|
|
1689 (defun gnus-group-prev-unread-group-same-level (n)
|
|
|
1690 "Go to next N'th unread newsgroup on the same level.
|
|
|
1691 Returns the difference between N and the number of skips actually
|
|
|
1692 done."
|
|
|
1693 (interactive "p")
|
|
|
1694 (gnus-group-next-unread-group (- n) t (gnus-group-group-level))
|
|
|
1695 (gnus-group-position-point))
|
|
|
1696
|
|
|
1697 (defun gnus-group-best-unread-group (&optional exclude-group)
|
|
|
1698 "Go to the group with the highest level.
|
|
|
1699 If EXCLUDE-GROUP, do not go to that group."
|
|
|
1700 (interactive)
|
|
|
1701 (goto-char (point-min))
|
|
|
1702 (let ((best 100000)
|
|
|
1703 unread best-point)
|
|
|
1704 (while (not (eobp))
|
|
|
1705 (setq unread (get-text-property (point) 'gnus-unread))
|
|
|
1706 (when (and (numberp unread) (> unread 0))
|
|
|
1707 (when (and (get-text-property (point) 'gnus-level)
|
|
|
1708 (< (get-text-property (point) 'gnus-level) best)
|
|
|
1709 (or (not exclude-group)
|
|
|
1710 (not (equal exclude-group (gnus-group-group-name)))))
|
|
|
1711 (setq best (get-text-property (point) 'gnus-level))
|
|
|
1712 (setq best-point (point))))
|
|
|
1713 (forward-line 1))
|
|
|
1714 (when best-point
|
|
|
1715 (goto-char best-point))
|
|
|
1716 (gnus-summary-position-point)
|
|
|
1717 (and best-point (gnus-group-group-name))))
|
|
|
1718
|
|
|
1719 (defun gnus-group-first-unread-group ()
|
|
|
1720 "Go to the first group with unread articles."
|
|
|
1721 (interactive)
|
|
|
1722 (prog1
|
|
|
1723 (let ((opoint (point))
|
|
|
1724 unread)
|
|
|
1725 (goto-char (point-min))
|
|
|
1726 (if (or (eq (setq unread (gnus-group-group-unread)) t) ; Not active.
|
|
|
1727 (and (numberp unread) ; Not a topic.
|
|
|
1728 (not (zerop unread))) ; Has unread articles.
|
|
|
1729 (zerop (gnus-group-next-unread-group 1))) ; Next unread group.
|
|
|
1730 (point) ; Success.
|
|
|
1731 (goto-char opoint)
|
|
|
1732 nil)) ; Not success.
|
|
|
1733 (gnus-group-position-point)))
|
|
|
1734
|
|
|
1735 (defun gnus-group-enter-server-mode ()
|
|
|
1736 "Jump to the server buffer."
|
|
|
1737 (interactive)
|
|
|
1738 (gnus-enter-server-buffer))
|
|
|
1739
|
|
|
1740 (defun gnus-group-make-group (name &optional method address args)
|
|
|
1741 "Add a new newsgroup.
|
|
|
1742 The user will be prompted for a NAME, for a select METHOD, and an
|
|
|
1743 ADDRESS."
|
|
|
1744 (interactive
|
|
|
1745 (list
|
|
|
1746 (gnus-read-group "Group name: ")
|
|
|
1747 (gnus-read-method "From method: ")))
|
|
|
1748
|
|
|
1749 (let* ((meth (when (and method
|
|
|
1750 (not (gnus-server-equal method gnus-select-method)))
|
|
|
1751 (if address (list (intern method) address)
|
|
|
1752 method)))
|
|
|
1753 (nname (if method (gnus-group-prefixed-name name meth) name))
|
|
|
1754 backend info)
|
|
|
1755 (when (gnus-gethash nname gnus-newsrc-hashtb)
|
|
|
1756 (error "Group %s already exists" nname))
|
|
|
1757 ;; Subscribe to the new group.
|
|
|
1758 (gnus-group-change-level
|
|
|
1759 (setq info (list t nname gnus-level-default-subscribed nil nil meth))
|
|
|
1760 gnus-level-default-subscribed gnus-level-killed
|
|
|
1761 (and (gnus-group-group-name)
|
|
|
1762 (gnus-gethash (gnus-group-group-name)
|
|
|
1763 gnus-newsrc-hashtb))
|
|
|
1764 t)
|
|
|
1765 ;; Make it active.
|
|
|
1766 (gnus-set-active nname (cons 1 0))
|
|
|
1767 (unless (gnus-ephemeral-group-p name)
|
|
|
1768 (gnus-dribble-enter
|
|
|
1769 (concat "(gnus-group-set-info '"
|
|
|
1770 (gnus-prin1-to-string (cdr info)) ")")))
|
|
|
1771 ;; Insert the line.
|
|
|
1772 (gnus-group-insert-group-line-info nname)
|
|
|
1773 (forward-line -1)
|
|
|
1774 (gnus-group-position-point)
|
|
|
1775
|
|
|
1776 ;; Load the backend and try to make the backend create
|
|
|
1777 ;; the group as well.
|
|
|
1778 (when (assoc (symbol-name (setq backend (car (gnus-server-get-method
|
|
|
1779 nil meth))))
|
|
|
1780 gnus-valid-select-methods)
|
|
|
1781 (require backend))
|
|
|
1782 (gnus-check-server meth)
|
|
|
1783 (when (gnus-check-backend-function 'request-create-group nname)
|
|
|
1784 (gnus-request-create-group nname nil args))
|
|
|
1785 t))
|
|
|
1786
|
|
|
1787 (defun gnus-group-delete-group (group &optional force)
|
|
|
1788 "Delete the current group. Only meaningful with mail groups.
|
|
|
1789 If FORCE (the prefix) is non-nil, all the articles in the group will
|
|
|
1790 be deleted. This is \"deleted\" as in \"removed forever from the face
|
|
|
1791 of the Earth\". There is no undo. The user will be prompted before
|
|
|
1792 doing the deletion."
|
|
|
1793 (interactive
|
|
|
1794 (list (gnus-group-group-name)
|
|
|
1795 current-prefix-arg))
|
|
|
1796 (unless group
|
|
|
1797 (error "No group to rename"))
|
|
|
1798 (unless (gnus-check-backend-function 'request-delete-group group)
|
|
|
1799 (error "This backend does not support group deletion"))
|
|
|
1800 (prog1
|
|
|
1801 (if (not (gnus-yes-or-no-p
|
|
|
1802 (format
|
|
|
1803 "Do you really want to delete %s%s? "
|
|
|
1804 group (if force " and all its contents" ""))))
|
|
|
1805 () ; Whew!
|
|
|
1806 (gnus-message 6 "Deleting group %s..." group)
|
|
|
1807 (if (not (gnus-request-delete-group group force))
|
|
|
1808 (gnus-error 3 "Couldn't delete group %s" group)
|
|
|
1809 (gnus-message 6 "Deleting group %s...done" group)
|
|
|
1810 (gnus-group-goto-group group)
|
|
|
1811 (gnus-group-kill-group 1 t)
|
|
|
1812 (gnus-sethash group nil gnus-active-hashtb)
|
|
|
1813 t))
|
|
|
1814 (gnus-group-position-point)))
|
|
|
1815
|
|
|
1816 (defun gnus-group-rename-group (group new-name)
|
|
|
1817 "Rename group from GROUP to NEW-NAME.
|
|
|
1818 When used interactively, GROUP is the group under point
|
|
|
1819 and NEW-NAME will be prompted for."
|
|
|
1820 (interactive
|
|
|
1821 (list
|
|
|
1822 (gnus-group-group-name)
|
|
|
1823 (progn
|
|
|
1824 (unless (gnus-check-backend-function
|
|
|
1825 'request-rename-group (gnus-group-group-name))
|
|
|
1826 (error "This backend does not support renaming groups"))
|
|
|
1827 (gnus-read-group "Rename group to: "
|
|
|
1828 (gnus-group-real-name (gnus-group-group-name))))))
|
|
|
1829
|
|
|
1830 (unless (gnus-check-backend-function 'request-rename-group group)
|
|
|
1831 (error "This backend does not support renaming groups"))
|
|
|
1832 (unless group
|
|
|
1833 (error "No group to rename"))
|
|
|
1834 (when (equal (gnus-group-real-name group) new-name)
|
|
|
1835 (error "Can't rename to the same name"))
|
|
|
1836
|
|
|
1837 ;; We find the proper prefixed name.
|
|
|
1838 (setq new-name
|
|
|
1839 (if (equal (gnus-group-real-name new-name) new-name)
|
|
|
1840 ;; Native group.
|
|
|
1841 new-name
|
|
|
1842 ;; Foreign group.
|
|
|
1843 (gnus-group-prefixed-name
|
|
|
1844 (gnus-group-real-name new-name)
|
|
|
1845 (gnus-info-method (gnus-get-info group)))))
|
|
|
1846
|
|
|
1847 (gnus-message 6 "Renaming group %s to %s..." group new-name)
|
|
|
1848 (prog1
|
|
|
1849 (if (not (gnus-request-rename-group group new-name))
|
|
|
1850 (gnus-error 3 "Couldn't rename group %s to %s" group new-name)
|
|
|
1851 ;; We rename the group internally by killing it...
|
|
|
1852 (gnus-group-goto-group group)
|
|
|
1853 (gnus-group-kill-group)
|
|
|
1854 ;; ... changing its name ...
|
|
|
1855 (setcar (cdar gnus-list-of-killed-groups) new-name)
|
|
|
1856 ;; ... and then yanking it. Magic!
|
|
|
1857 (gnus-group-yank-group)
|
|
|
1858 (gnus-set-active new-name (gnus-active group))
|
|
|
1859 (gnus-message 6 "Renaming group %s to %s...done" group new-name)
|
|
|
1860 new-name)
|
|
|
1861 (gnus-group-position-point)))
|
|
|
1862
|
|
|
1863 (defun gnus-group-edit-group (group &optional part)
|
|
|
1864 "Edit the group on the current line."
|
|
|
1865 (interactive (list (gnus-group-group-name)))
|
|
|
1866 (let ((part (or part 'info))
|
|
|
1867 info)
|
|
|
1868 (unless group
|
|
|
1869 (error "No group on current line"))
|
|
|
1870 (unless (setq info (gnus-get-info group))
|
|
|
1871 (error "Killed group; can't be edited"))
|
|
|
1872 (ignore-errors
|
|
|
1873 (gnus-close-group group))
|
|
|
1874 (gnus-edit-form
|
|
|
1875 ;; Find the proper form to edit.
|
|
|
1876 (cond ((eq part 'method)
|
|
|
1877 (or (gnus-info-method info) "native"))
|
|
|
1878 ((eq part 'params)
|
|
|
1879 (gnus-info-params info))
|
|
|
1880 (t info))
|
|
|
1881 ;; The proper documentation.
|
|
|
1882 (format
|
|
100
|
1883 "Editing the %s for `%s'."
|
|
98
|
1884 (cond
|
|
|
1885 ((eq part 'method) "select method")
|
|
|
1886 ((eq part 'params) "group parameters")
|
|
100
|
1887 (t "group info"))
|
|
|
1888 group)
|
|
98
|
1889 `(lambda (form)
|
|
|
1890 (gnus-group-edit-group-done ',part ,group form)))))
|
|
|
1891
|
|
|
1892 (defun gnus-group-edit-group-method (group)
|
|
|
1893 "Edit the select method of GROUP."
|
|
|
1894 (interactive (list (gnus-group-group-name)))
|
|
|
1895 (gnus-group-edit-group group 'method))
|
|
|
1896
|
|
|
1897 (defun gnus-group-edit-group-parameters (group)
|
|
|
1898 "Edit the group parameters of GROUP."
|
|
|
1899 (interactive (list (gnus-group-group-name)))
|
|
|
1900 (gnus-group-edit-group group 'params))
|
|
|
1901
|
|
|
1902 (defun gnus-group-edit-group-done (part group form)
|
|
|
1903 "Update variables."
|
|
|
1904 (let* ((method (cond ((eq part 'info) (nth 4 form))
|
|
|
1905 ((eq part 'method) form)
|
|
|
1906 (t nil)))
|
|
|
1907 (info (cond ((eq part 'info) form)
|
|
|
1908 ((eq part 'method) (gnus-get-info group))
|
|
|
1909 (t nil)))
|
|
|
1910 (new-group (if info
|
|
|
1911 (if (or (not method)
|
|
|
1912 (gnus-server-equal
|
|
|
1913 gnus-select-method method))
|
|
|
1914 (gnus-group-real-name (car info))
|
|
|
1915 (gnus-group-prefixed-name
|
|
|
1916 (gnus-group-real-name (car info)) method))
|
|
|
1917 nil)))
|
|
|
1918 (when (and new-group
|
|
|
1919 (not (equal new-group group)))
|
|
|
1920 (when (gnus-group-goto-group group)
|
|
|
1921 (gnus-group-kill-group 1))
|
|
|
1922 (gnus-activate-group new-group))
|
|
|
1923 ;; Set the info.
|
|
|
1924 (if (not (and info new-group))
|
|
|
1925 (gnus-group-set-info form (or new-group group) part)
|
|
|
1926 (setq info (gnus-copy-sequence info))
|
|
|
1927 (setcar info new-group)
|
|
|
1928 (unless (gnus-server-equal method "native")
|
|
|
1929 (unless (nthcdr 3 info)
|
|
|
1930 (nconc info (list nil nil)))
|
|
|
1931 (unless (nthcdr 4 info)
|
|
|
1932 (nconc info (list nil)))
|
|
|
1933 (gnus-info-set-method info method))
|
|
|
1934 (gnus-group-set-info info))
|
|
|
1935 (gnus-group-update-group (or new-group group))
|
|
|
1936 (gnus-group-position-point)))
|
|
|
1937
|
|
|
1938 (defun gnus-group-make-useful-group (group method)
|
|
|
1939 (interactive
|
|
|
1940 (let ((entry (assoc (completing-read "Create group: " gnus-useful-groups
|
|
|
1941 nil t)
|
|
|
1942 gnus-useful-groups)))
|
|
|
1943 (list (cadr entry) (caddr entry))))
|
|
|
1944 (setq method (gnus-copy-sequence method))
|
|
|
1945 (let (entry)
|
|
|
1946 (while (setq entry (memq (assq 'eval method) method))
|
|
|
1947 (setcar entry (eval (cadar entry)))))
|
|
|
1948 (gnus-group-make-group group method))
|
|
|
1949
|
|
|
1950 (defun gnus-group-make-help-group ()
|
|
|
1951 "Create the Gnus documentation group."
|
|
|
1952 (interactive)
|
|
|
1953 (let ((name (gnus-group-prefixed-name "gnus-help" '(nndoc "gnus-help")))
|
|
|
1954 (file (nnheader-find-etc-directory "gnus-tut.txt" t))
|
|
|
1955 dir)
|
|
|
1956 (when (gnus-gethash name gnus-newsrc-hashtb)
|
|
|
1957 (error "Documentation group already exists"))
|
|
|
1958 (if (not file)
|
|
|
1959 (gnus-message 1 "Couldn't find doc group")
|
|
|
1960 (gnus-group-make-group
|
|
|
1961 (gnus-group-real-name name)
|
|
|
1962 (list 'nndoc "gnus-help"
|
|
|
1963 (list 'nndoc-address file)
|
|
|
1964 (list 'nndoc-article-type 'mbox)))))
|
|
|
1965 (gnus-group-position-point))
|
|
|
1966
|
|
|
1967 (defun gnus-group-make-doc-group (file type)
|
|
|
1968 "Create a group that uses a single file as the source."
|
|
|
1969 (interactive
|
|
|
1970 (list (read-file-name "File name: ")
|
|
|
1971 (and current-prefix-arg 'ask)))
|
|
|
1972 (when (eq type 'ask)
|
|
|
1973 (let ((err "")
|
|
|
1974 char found)
|
|
|
1975 (while (not found)
|
|
|
1976 (message
|
|
|
1977 "%sFile type (mbox, babyl, digest, forward, mmdf, guess) [mbdfag]: "
|
|
|
1978 err)
|
|
|
1979 (setq found (cond ((= (setq char (read-char)) ?m) 'mbox)
|
|
|
1980 ((= char ?b) 'babyl)
|
|
|
1981 ((= char ?d) 'digest)
|
|
|
1982 ((= char ?f) 'forward)
|
|
|
1983 ((= char ?a) 'mmfd)
|
|
|
1984 (t (setq err (format "%c unknown. " char))
|
|
|
1985 nil))))
|
|
|
1986 (setq type found)))
|
|
|
1987 (let* ((file (expand-file-name file))
|
|
|
1988 (name (gnus-generate-new-group-name
|
|
|
1989 (gnus-group-prefixed-name
|
|
|
1990 (file-name-nondirectory file) '(nndoc "")))))
|
|
|
1991 (gnus-group-make-group
|
|
|
1992 (gnus-group-real-name name)
|
|
|
1993 (list 'nndoc file
|
|
|
1994 (list 'nndoc-address file)
|
|
|
1995 (list 'nndoc-article-type (or type 'guess))))))
|
|
|
1996
|
|
|
1997 (defvar nnweb-type-definition)
|
|
|
1998 (defvar gnus-group-web-type-history nil)
|
|
|
1999 (defvar gnus-group-web-search-history nil)
|
|
|
2000 (defun gnus-group-make-web-group (&optional solid)
|
|
|
2001 "Create an ephemeral nnweb group.
|
|
|
2002 If SOLID (the prefix), create a solid group."
|
|
|
2003 (interactive "P")
|
|
|
2004 (require 'nnweb)
|
|
|
2005 (let* ((group
|
|
|
2006 (if solid (gnus-read-group "Group name: ")
|
|
|
2007 (message-unique-id)))
|
|
|
2008 (type
|
|
|
2009 (completing-read
|
|
|
2010 "Search engine type: "
|
|
|
2011 (mapcar (lambda (elem) (list (symbol-name (car elem))))
|
|
|
2012 nnweb-type-definition)
|
|
|
2013 nil t (cons (or (car gnus-group-web-type-history)
|
|
|
2014 (symbol-name (caar nnweb-type-definition)))
|
|
|
2015 0)
|
|
|
2016 'gnus-group-web-type-history))
|
|
|
2017 (search
|
|
|
2018 (read-string
|
|
|
2019 "Search string: "
|
|
|
2020 (cons (or (car gnus-group-web-search-history) "") 0)
|
|
|
2021 'gnus-group-web-search-history))
|
|
|
2022 (method
|
|
|
2023 `(nnweb ,group (nnweb-search ,search)
|
|
|
2024 (nnweb-type ,(intern type))
|
|
|
2025 (nnweb-ephemeral-p t))))
|
|
|
2026 (if solid
|
|
|
2027 (gnus-group-make-group group "nnweb" "" `(,(intern type) ,search))
|
|
|
2028 (gnus-group-read-ephemeral-group
|
|
|
2029 group method t
|
|
|
2030 (cons (current-buffer)
|
|
|
2031 (if (eq major-mode 'gnus-summary-mode) 'summary 'group))))))
|
|
|
2032
|
|
|
2033 (defun gnus-group-make-archive-group (&optional all)
|
|
|
2034 "Create the (ding) Gnus archive group of the most recent articles.
|
|
|
2035 Given a prefix, create a full group."
|
|
|
2036 (interactive "P")
|
|
|
2037 (let ((group (gnus-group-prefixed-name
|
|
|
2038 (if all "ding.archives" "ding.recent") '(nndir ""))))
|
|
|
2039 (when (gnus-gethash group gnus-newsrc-hashtb)
|
|
|
2040 (error "Archive group already exists"))
|
|
|
2041 (gnus-group-make-group
|
|
|
2042 (gnus-group-real-name group)
|
|
|
2043 (list 'nndir (if all "hpc" "edu")
|
|
|
2044 (list 'nndir-directory
|
|
|
2045 (if all gnus-group-archive-directory
|
|
|
2046 gnus-group-recent-archive-directory))))
|
|
|
2047 (gnus-group-add-parameter group (cons 'to-address "ding@ifi.uio.no"))))
|
|
|
2048
|
|
|
2049 (defun gnus-group-make-directory-group (dir)
|
|
|
2050 "Create an nndir group.
|
|
|
2051 The user will be prompted for a directory. The contents of this
|
|
|
2052 directory will be used as a newsgroup. The directory should contain
|
|
|
2053 mail messages or news articles in files that have numeric names."
|
|
|
2054 (interactive
|
|
|
2055 (list (read-file-name "Create group from directory: ")))
|
|
|
2056 (unless (file-exists-p dir)
|
|
|
2057 (error "No such directory"))
|
|
|
2058 (unless (file-directory-p dir)
|
|
|
2059 (error "Not a directory"))
|
|
|
2060 (let ((ext "")
|
|
|
2061 (i 0)
|
|
|
2062 group)
|
|
|
2063 (while (or (not group) (gnus-gethash group gnus-newsrc-hashtb))
|
|
|
2064 (setq group
|
|
|
2065 (gnus-group-prefixed-name
|
|
|
2066 (concat (file-name-as-directory (directory-file-name dir))
|
|
|
2067 ext)
|
|
|
2068 '(nndir "")))
|
|
|
2069 (setq ext (format "<%d>" (setq i (1+ i)))))
|
|
|
2070 (gnus-group-make-group
|
|
|
2071 (gnus-group-real-name group)
|
|
|
2072 (list 'nndir (gnus-group-real-name group) (list 'nndir-directory dir)))))
|
|
|
2073
|
|
|
2074 (defun gnus-group-make-kiboze-group (group address scores)
|
|
|
2075 "Create an nnkiboze group.
|
|
|
2076 The user will be prompted for a name, a regexp to match groups, and
|
|
|
2077 score file entries for articles to include in the group."
|
|
|
2078 (interactive
|
|
|
2079 (list
|
|
|
2080 (read-string "nnkiboze group name: ")
|
|
|
2081 (read-string "Source groups (regexp): ")
|
|
|
2082 (let ((headers (mapcar (lambda (group) (list group))
|
|
|
2083 '("subject" "from" "number" "date" "message-id"
|
|
|
2084 "references" "chars" "lines" "xref"
|
|
|
2085 "followup" "all" "body" "head")))
|
|
|
2086 scores header regexp regexps)
|
|
|
2087 (while (not (equal "" (setq header (completing-read
|
|
|
2088 "Match on header: " headers nil t))))
|
|
|
2089 (setq regexps nil)
|
|
|
2090 (while (not (equal "" (setq regexp (read-string
|
|
|
2091 (format "Match on %s (string): "
|
|
|
2092 header)))))
|
|
|
2093 (push (list regexp nil nil 'r) regexps))
|
|
|
2094 (push (cons header regexps) scores))
|
|
|
2095 scores)))
|
|
|
2096 (gnus-group-make-group group "nnkiboze" address)
|
|
|
2097 (nnheader-temp-write (gnus-score-file-name (concat "nnkiboze:" group))
|
|
|
2098 (let (emacs-lisp-mode-hook)
|
|
|
2099 (pp scores (current-buffer)))))
|
|
|
2100
|
|
|
2101 (defun gnus-group-add-to-virtual (n vgroup)
|
|
|
2102 "Add the current group to a virtual group."
|
|
|
2103 (interactive
|
|
|
2104 (list current-prefix-arg
|
|
|
2105 (completing-read "Add to virtual group: " gnus-newsrc-hashtb nil t
|
|
|
2106 "nnvirtual:")))
|
|
|
2107 (unless (eq (car (gnus-find-method-for-group vgroup)) 'nnvirtual)
|
|
|
2108 (error "%s is not an nnvirtual group" vgroup))
|
|
|
2109 (gnus-close-group vgroup)
|
|
|
2110 (let* ((groups (gnus-group-process-prefix n))
|
|
|
2111 (method (gnus-info-method (gnus-get-info vgroup))))
|
|
|
2112 (setcar (cdr method)
|
|
|
2113 (concat
|
|
|
2114 (nth 1 method) "\\|"
|
|
|
2115 (mapconcat
|
|
|
2116 (lambda (s)
|
|
|
2117 (gnus-group-remove-mark s)
|
|
|
2118 (concat "\\(^" (regexp-quote s) "$\\)"))
|
|
|
2119 groups "\\|"))))
|
|
|
2120 (gnus-group-position-point))
|
|
|
2121
|
|
|
2122 (defun gnus-group-make-empty-virtual (group)
|
|
|
2123 "Create a new, fresh, empty virtual group."
|
|
|
2124 (interactive "sCreate new, empty virtual group: ")
|
|
|
2125 (let* ((method (list 'nnvirtual "^$"))
|
|
|
2126 (pgroup (gnus-group-prefixed-name group method)))
|
|
|
2127 ;; Check whether it exists already.
|
|
|
2128 (when (gnus-gethash pgroup gnus-newsrc-hashtb)
|
|
|
2129 (error "Group %s already exists." pgroup))
|
|
|
2130 ;; Subscribe the new group after the group on the current line.
|
|
|
2131 (gnus-subscribe-group pgroup (gnus-group-group-name) method)
|
|
|
2132 (gnus-group-update-group pgroup)
|
|
|
2133 (forward-line -1)
|
|
|
2134 (gnus-group-position-point)))
|
|
|
2135
|
|
|
2136 (defun gnus-group-enter-directory (dir)
|
|
|
2137 "Enter an ephemeral nneething group."
|
|
|
2138 (interactive "DDirectory to read: ")
|
|
|
2139 (let* ((method (list 'nneething dir '(nneething-read-only t)))
|
|
|
2140 (leaf (gnus-group-prefixed-name
|
|
|
2141 (file-name-nondirectory (directory-file-name dir))
|
|
|
2142 method))
|
|
|
2143 (name (gnus-generate-new-group-name leaf)))
|
|
|
2144 (unless (gnus-group-read-ephemeral-group
|
|
|
2145 name method t
|
|
|
2146 (cons (current-buffer)
|
|
|
2147 (if (eq major-mode 'gnus-summary-mode)
|
|
|
2148 'summary 'group)))
|
|
|
2149 (error "Couldn't enter %s" dir))))
|
|
|
2150
|
|
|
2151 ;; Group sorting commands
|
|
|
2152 ;; Suggested by Joe Hildebrand <hildjj@idaho.fuentez.com>.
|
|
|
2153
|
|
|
2154 (defun gnus-group-sort-groups (func &optional reverse)
|
|
|
2155 "Sort the group buffer according to FUNC.
|
|
|
2156 If REVERSE, reverse the sorting order."
|
|
|
2157 (interactive (list gnus-group-sort-function current-prefix-arg))
|
|
|
2158 (funcall gnus-group-sort-alist-function
|
|
|
2159 (gnus-make-sort-function func) reverse)
|
|
|
2160 (gnus-group-list-groups))
|
|
|
2161
|
|
|
2162 (defun gnus-group-sort-flat (func reverse)
|
|
|
2163 ;; We peel off the dummy group from the alist.
|
|
|
2164 (when func
|
|
|
2165 (when (equal (car (gnus-info-group gnus-newsrc-alist)) "dummy.group")
|
|
|
2166 (pop gnus-newsrc-alist))
|
|
|
2167 ;; Do the sorting.
|
|
|
2168 (setq gnus-newsrc-alist
|
|
|
2169 (sort gnus-newsrc-alist func))
|
|
|
2170 (when reverse
|
|
|
2171 (setq gnus-newsrc-alist (nreverse gnus-newsrc-alist)))
|
|
|
2172 ;; Regenerate the hash table.
|
|
|
2173 (gnus-make-hashtable-from-newsrc-alist)))
|
|
|
2174
|
|
|
2175 (defun gnus-group-sort-groups-by-alphabet (&optional reverse)
|
|
|
2176 "Sort the group buffer alphabetically by group name.
|
|
|
2177 If REVERSE, sort in reverse order."
|
|
|
2178 (interactive "P")
|
|
|
2179 (gnus-group-sort-groups 'gnus-group-sort-by-alphabet reverse))
|
|
|
2180
|
|
|
2181 (defun gnus-group-sort-groups-by-unread (&optional reverse)
|
|
|
2182 "Sort the group buffer by number of unread articles.
|
|
|
2183 If REVERSE, sort in reverse order."
|
|
|
2184 (interactive "P")
|
|
|
2185 (gnus-group-sort-groups 'gnus-group-sort-by-unread reverse))
|
|
|
2186
|
|
|
2187 (defun gnus-group-sort-groups-by-level (&optional reverse)
|
|
|
2188 "Sort the group buffer by group level.
|
|
|
2189 If REVERSE, sort in reverse order."
|
|
|
2190 (interactive "P")
|
|
|
2191 (gnus-group-sort-groups 'gnus-group-sort-by-level reverse))
|
|
|
2192
|
|
|
2193 (defun gnus-group-sort-groups-by-score (&optional reverse)
|
|
|
2194 "Sort the group buffer by group score.
|
|
|
2195 If REVERSE, sort in reverse order."
|
|
|
2196 (interactive "P")
|
|
|
2197 (gnus-group-sort-groups 'gnus-group-sort-by-score reverse))
|
|
|
2198
|
|
|
2199 (defun gnus-group-sort-groups-by-rank (&optional reverse)
|
|
|
2200 "Sort the group buffer by group rank.
|
|
|
2201 If REVERSE, sort in reverse order."
|
|
|
2202 (interactive "P")
|
|
|
2203 (gnus-group-sort-groups 'gnus-group-sort-by-rank reverse))
|
|
|
2204
|
|
|
2205 (defun gnus-group-sort-groups-by-method (&optional reverse)
|
|
|
2206 "Sort the group buffer alphabetically by backend name.
|
|
|
2207 If REVERSE, sort in reverse order."
|
|
|
2208 (interactive "P")
|
|
|
2209 (gnus-group-sort-groups 'gnus-group-sort-by-method reverse))
|
|
|
2210
|
|
|
2211 ;;; Selected group sorting.
|
|
|
2212
|
|
|
2213 (defun gnus-group-sort-selected-groups (n func &optional reverse)
|
|
|
2214 "Sort the process/prefixed groups."
|
|
|
2215 (interactive (list current-prefix-arg gnus-group-sort-function))
|
|
|
2216 (let ((groups (gnus-group-process-prefix n)))
|
|
|
2217 (funcall gnus-group-sort-selected-function
|
|
|
2218 groups (gnus-make-sort-function func) reverse)
|
|
|
2219 (gnus-group-list-groups)))
|
|
|
2220
|
|
|
2221 (defun gnus-group-sort-selected-flat (groups func reverse)
|
|
|
2222 (let (entries infos)
|
|
|
2223 ;; First find all the group entries for these groups.
|
|
|
2224 (while groups
|
|
|
2225 (push (nthcdr 2 (gnus-gethash (pop groups) gnus-newsrc-hashtb))
|
|
|
2226 entries))
|
|
|
2227 ;; Then sort the infos.
|
|
|
2228 (setq infos
|
|
|
2229 (sort
|
|
|
2230 (mapcar
|
|
|
2231 (lambda (entry) (car entry))
|
|
|
2232 (setq entries (nreverse entries)))
|
|
|
2233 func))
|
|
|
2234 (when reverse
|
|
|
2235 (setq infos (nreverse infos)))
|
|
|
2236 ;; Go through all the infos and replace the old entries
|
|
|
2237 ;; with the new infos.
|
|
|
2238 (while infos
|
|
|
2239 (setcar entries (pop infos))
|
|
|
2240 (pop entries))
|
|
|
2241 ;; Update the hashtable.
|
|
|
2242 (gnus-make-hashtable-from-newsrc-alist)))
|
|
|
2243
|
|
|
2244 (defun gnus-group-sort-selected-groups-by-alphabet (&optional reverse)
|
|
|
2245 "Sort the group buffer alphabetically by group name.
|
|
|
2246 If REVERSE, sort in reverse order."
|
|
|
2247 (interactive "P")
|
|
|
2248 (gnus-group-sort-selected-groups 'gnus-group-sort-by-alphabet reverse))
|
|
|
2249
|
|
|
2250 (defun gnus-group-sort-selected-groups-by-unread (&optional reverse)
|
|
|
2251 "Sort the group buffer by number of unread articles.
|
|
|
2252 If REVERSE, sort in reverse order."
|
|
|
2253 (interactive "P")
|
|
|
2254 (gnus-group-sort-selected-groups 'gnus-group-sort-by-unread reverse))
|
|
|
2255
|
|
|
2256 (defun gnus-group-sort-selected-groups-by-level (&optional reverse)
|
|
|
2257 "Sort the group buffer by group level.
|
|
|
2258 If REVERSE, sort in reverse order."
|
|
|
2259 (interactive "P")
|
|
|
2260 (gnus-group-sort-selected-groups 'gnus-group-sort-by-level reverse))
|
|
|
2261
|
|
|
2262 (defun gnus-group-sort-selected-groups-by-score (&optional reverse)
|
|
|
2263 "Sort the group buffer by group score.
|
|
|
2264 If REVERSE, sort in reverse order."
|
|
|
2265 (interactive "P")
|
|
|
2266 (gnus-group-sort-selected-groups 'gnus-group-sort-by-score reverse))
|
|
|
2267
|
|
|
2268 (defun gnus-group-sort-selected-groups-by-rank (&optional reverse)
|
|
|
2269 "Sort the group buffer by group rank.
|
|
|
2270 If REVERSE, sort in reverse order."
|
|
|
2271 (interactive "P")
|
|
|
2272 (gnus-group-sort-selected-groups 'gnus-group-sort-by-rank reverse))
|
|
|
2273
|
|
|
2274 (defun gnus-group-sort-selected-groups-by-method (&optional reverse)
|
|
|
2275 "Sort the group buffer alphabetically by backend name.
|
|
|
2276 If REVERSE, sort in reverse order."
|
|
|
2277 (interactive "P")
|
|
|
2278 (gnus-group-sort-selected-groups 'gnus-group-sort-by-method reverse))
|
|
|
2279
|
|
|
2280 ;;; Sorting predicates.
|
|
|
2281
|
|
|
2282 (defun gnus-group-sort-by-alphabet (info1 info2)
|
|
|
2283 "Sort alphabetically."
|
|
|
2284 (string< (gnus-info-group info1) (gnus-info-group info2)))
|
|
|
2285
|
|
|
2286 (defun gnus-group-sort-by-real-name (info1 info2)
|
|
|
2287 "Sort alphabetically on real (unprefixed) names."
|
|
|
2288 (string< (gnus-group-real-name (gnus-info-group info1))
|
|
|
2289 (gnus-group-real-name (gnus-info-group info2))))
|
|
|
2290
|
|
|
2291 (defun gnus-group-sort-by-unread (info1 info2)
|
|
|
2292 "Sort by number of unread articles."
|
|
|
2293 (let ((n1 (car (gnus-gethash (gnus-info-group info1) gnus-newsrc-hashtb)))
|
|
|
2294 (n2 (car (gnus-gethash (gnus-info-group info2) gnus-newsrc-hashtb))))
|
|
|
2295 (< (or (and (numberp n1) n1) 0)
|
|
|
2296 (or (and (numberp n2) n2) 0))))
|
|
|
2297
|
|
|
2298 (defun gnus-group-sort-by-level (info1 info2)
|
|
|
2299 "Sort by level."
|
|
|
2300 (< (gnus-info-level info1) (gnus-info-level info2)))
|
|
|
2301
|
|
|
2302 (defun gnus-group-sort-by-method (info1 info2)
|
|
|
2303 "Sort alphabetically by backend name."
|
|
|
2304 (string< (symbol-name (car (gnus-find-method-for-group
|
|
|
2305 (gnus-info-group info1) info1)))
|
|
|
2306 (symbol-name (car (gnus-find-method-for-group
|
|
|
2307 (gnus-info-group info2) info2)))))
|
|
|
2308
|
|
|
2309 (defun gnus-group-sort-by-score (info1 info2)
|
|
|
2310 "Sort by group score."
|
|
|
2311 (< (gnus-info-score info1) (gnus-info-score info2)))
|
|
|
2312
|
|
|
2313 (defun gnus-group-sort-by-rank (info1 info2)
|
|
|
2314 "Sort by level and score."
|
|
|
2315 (let ((level1 (gnus-info-level info1))
|
|
|
2316 (level2 (gnus-info-level info2)))
|
|
|
2317 (or (< level1 level2)
|
|
|
2318 (and (= level1 level2)
|
|
|
2319 (> (gnus-info-score info1) (gnus-info-score info2))))))
|
|
|
2320
|
|
|
2321 ;;; Clearing data
|
|
|
2322
|
|
|
2323 (defun gnus-group-clear-data (&optional arg)
|
|
|
2324 "Clear all marks and read ranges from the current group."
|
|
|
2325 (interactive "P")
|
|
|
2326 (gnus-group-iterate arg
|
|
|
2327 (lambda (group)
|
|
|
2328 (let (info)
|
|
|
2329 (gnus-info-clear-data (setq info (gnus-get-info group)))
|
|
|
2330 (gnus-get-unread-articles-in-group info (gnus-active group) t)
|
|
|
2331 (when (gnus-group-goto-group group)
|
|
|
2332 (gnus-group-update-group-line))))))
|
|
|
2333
|
|
|
2334 (defun gnus-group-clear-data-on-native-groups ()
|
|
|
2335 "Clear all marks and read ranges from all native groups."
|
|
|
2336 (interactive)
|
|
|
2337 (when (gnus-yes-or-no-p "Really clear all data from almost all groups? ")
|
|
|
2338 (let ((alist (cdr gnus-newsrc-alist))
|
|
|
2339 info)
|
|
|
2340 (while (setq info (pop alist))
|
|
|
2341 (when (gnus-group-native-p (gnus-info-group info))
|
|
|
2342 (gnus-info-clear-data info)))
|
|
|
2343 (gnus-get-unread-articles)
|
|
|
2344 (gnus-dribble-enter "")
|
|
|
2345 (when (gnus-y-or-n-p
|
|
|
2346 "Move the cache away to avoid problems in the future? ")
|
|
|
2347 (call-interactively 'gnus-cache-move-cache)))))
|
|
|
2348
|
|
|
2349 (defun gnus-info-clear-data (info)
|
|
|
2350 "Clear all marks and read ranges from INFO."
|
|
|
2351 (let ((group (gnus-info-group info)))
|
|
|
2352 (gnus-undo-register
|
|
|
2353 `(progn
|
|
|
2354 (gnus-info-set-marks ',info ',(gnus-info-marks info) t)
|
|
|
2355 (gnus-info-set-read ',info ',(gnus-info-read info))
|
|
|
2356 (when (gnus-group-goto-group ,group)
|
|
|
2357 (gnus-group-update-group-line))))
|
|
|
2358 (gnus-info-set-read info nil)
|
|
|
2359 (when (gnus-info-marks info)
|
|
|
2360 (gnus-info-set-marks info nil))))
|
|
|
2361
|
|
|
2362 ;; Group catching up.
|
|
|
2363
|
|
|
2364 (defun gnus-group-catchup-current (&optional n all)
|
|
|
2365 "Mark all articles not marked as unread in current newsgroup as read.
|
|
|
2366 If prefix argument N is numeric, the ARG next newsgroups will be
|
|
|
2367 caught up. If ALL is non-nil, marked articles will also be marked as
|
|
|
2368 read. Cross references (Xref: header) of articles are ignored.
|
|
|
2369 The difference between N and actual number of newsgroups that were
|
|
|
2370 caught up is returned."
|
|
|
2371 (interactive "P")
|
|
|
2372 (unless (gnus-group-group-name)
|
|
|
2373 (error "No group on the current line"))
|
|
|
2374 (let ((groups (gnus-group-process-prefix n))
|
|
|
2375 (ret 0))
|
|
|
2376 (if (not
|
|
|
2377 (or (not gnus-interactive-catchup) ;Without confirmation?
|
|
|
2378 gnus-expert-user
|
|
|
2379 (gnus-y-or-n-p
|
|
|
2380 (format
|
|
|
2381 (if all
|
|
|
2382 "Do you really want to mark all articles in %s as read? "
|
|
|
2383 "Mark all unread articles in %s as read? ")
|
|
|
2384 (if (= (length groups) 1)
|
|
|
2385 (car groups)
|
|
|
2386 (format "these %d groups" (length groups)))))))
|
|
|
2387 n
|
|
|
2388 (while groups
|
|
|
2389 ;; Virtual groups have to be given special treatment.
|
|
|
2390 (let ((method (gnus-find-method-for-group (car groups))))
|
|
|
2391 (when (eq 'nnvirtual (car method))
|
|
|
2392 (nnvirtual-catchup-group
|
|
|
2393 (gnus-group-real-name (car groups)) (nth 1 method) all)))
|
|
|
2394 (gnus-group-remove-mark (car groups))
|
|
|
2395 (if (>= (gnus-group-group-level) gnus-level-zombie)
|
|
|
2396 (gnus-message 2 "Dead groups can't be caught up")
|
|
|
2397 (if (prog1
|
|
|
2398 (gnus-group-goto-group (car groups))
|
|
|
2399 (gnus-group-catchup (car groups) all))
|
|
|
2400 (gnus-group-update-group-line)
|
|
|
2401 (setq ret (1+ ret))))
|
|
|
2402 (setq groups (cdr groups)))
|
|
|
2403 (gnus-group-next-unread-group 1)
|
|
|
2404 ret)))
|
|
|
2405
|
|
|
2406 (defun gnus-group-catchup-current-all (&optional n)
|
|
|
2407 "Mark all articles in current newsgroup as read.
|
|
|
2408 Cross references (Xref: header) of articles are ignored."
|
|
|
2409 (interactive "P")
|
|
|
2410 (gnus-group-catchup-current n 'all))
|
|
|
2411
|
|
|
2412 (defun gnus-group-catchup (group &optional all)
|
|
|
2413 "Mark all articles in GROUP as read.
|
|
|
2414 If ALL is non-nil, all articles are marked as read.
|
|
|
2415 The return value is the number of articles that were marked as read,
|
|
|
2416 or nil if no action could be taken."
|
|
|
2417 (let* ((entry (gnus-gethash group gnus-newsrc-hashtb))
|
|
|
2418 (num (car entry)))
|
|
|
2419 ;; Do the updating only if the newsgroup isn't killed.
|
|
|
2420 (if (not (numberp (car entry)))
|
|
|
2421 (gnus-message 1 "Can't catch up %s; non-active group" group)
|
|
|
2422 ;; Do auto-expirable marks if that's required.
|
|
|
2423 (when (gnus-group-auto-expirable-p group)
|
|
|
2424 (gnus-add-marked-articles
|
|
|
2425 group 'expire (gnus-list-of-unread-articles group))
|
|
|
2426 (when all
|
|
|
2427 (let ((marks (nth 3 (nth 2 entry))))
|
|
|
2428 (gnus-add-marked-articles
|
|
|
2429 group 'expire (gnus-uncompress-range (cdr (assq 'tick marks))))
|
|
|
2430 (gnus-add-marked-articles
|
|
|
2431 group 'expire (gnus-uncompress-range (cdr (assq 'tick marks)))))))
|
|
|
2432 (when entry
|
|
|
2433 (gnus-update-read-articles group nil)
|
|
|
2434 ;; Also nix out the lists of marks and dormants.
|
|
|
2435 (when all
|
|
|
2436 (gnus-add-marked-articles group 'tick nil nil 'force)
|
|
|
2437 (gnus-add-marked-articles group 'dormant nil nil 'force))
|
|
|
2438 (let ((gnus-newsgroup-name group))
|
|
|
2439 (run-hooks 'gnus-group-catchup-group-hook))
|
|
|
2440 num))))
|
|
|
2441
|
|
|
2442 (defun gnus-group-expire-articles (&optional n)
|
|
|
2443 "Expire all expirable articles in the current newsgroup."
|
|
|
2444 (interactive "P")
|
|
|
2445 (let ((groups (gnus-group-process-prefix n))
|
|
|
2446 group)
|
|
|
2447 (unless groups
|
|
|
2448 (error "No groups to expire"))
|
|
|
2449 (while (setq group (pop groups))
|
|
|
2450 (gnus-group-remove-mark group)
|
|
|
2451 (when (gnus-check-backend-function 'request-expire-articles group)
|
|
|
2452 (gnus-message 6 "Expiring articles in %s..." group)
|
|
|
2453 (let* ((info (gnus-get-info group))
|
|
|
2454 (expirable (if (gnus-group-total-expirable-p group)
|
|
|
2455 (cons nil (gnus-list-of-read-articles group))
|
|
|
2456 (assq 'expire (gnus-info-marks info))))
|
|
|
2457 (expiry-wait (gnus-group-find-parameter group 'expiry-wait)))
|
|
|
2458 (when expirable
|
|
|
2459 (setcdr
|
|
|
2460 expirable
|
|
|
2461 (gnus-compress-sequence
|
|
|
2462 (if expiry-wait
|
|
|
2463 ;; We set the expiry variables to the group
|
|
|
2464 ;; parameter.
|
|
|
2465 (let ((nnmail-expiry-wait-function nil)
|
|
|
2466 (nnmail-expiry-wait expiry-wait))
|
|
|
2467 (gnus-request-expire-articles
|
|
|
2468 (gnus-uncompress-sequence (cdr expirable)) group))
|
|
|
2469 ;; Just expire using the normal expiry values.
|
|
|
2470 (gnus-request-expire-articles
|
|
|
2471 (gnus-uncompress-sequence (cdr expirable)) group))))
|
|
|
2472 (gnus-close-group group))
|
|
|
2473 (gnus-message 6 "Expiring articles in %s...done" group)))
|
|
|
2474 (gnus-group-position-point))))
|
|
|
2475
|
|
|
2476 (defun gnus-group-expire-all-groups ()
|
|
|
2477 "Expire all expirable articles in all newsgroups."
|
|
|
2478 (interactive)
|
|
|
2479 (save-excursion
|
|
|
2480 (gnus-message 5 "Expiring...")
|
|
|
2481 (let ((gnus-group-marked (mapcar (lambda (info) (gnus-info-group info))
|
|
|
2482 (cdr gnus-newsrc-alist))))
|
|
|
2483 (gnus-group-expire-articles nil)))
|
|
|
2484 (gnus-group-position-point)
|
|
|
2485 (gnus-message 5 "Expiring...done"))
|
|
|
2486
|
|
|
2487 (defun gnus-group-set-current-level (n level)
|
|
|
2488 "Set the level of the next N groups to LEVEL."
|
|
|
2489 (interactive
|
|
|
2490 (list
|
|
|
2491 current-prefix-arg
|
|
|
2492 (string-to-int
|
|
|
2493 (let ((s (read-string
|
|
|
2494 (format "Level (default %s): "
|
|
|
2495 (or (gnus-group-group-level)
|
|
|
2496 gnus-level-default-subscribed)))))
|
|
|
2497 (if (string-match "^\\s-*$" s)
|
|
|
2498 (int-to-string (or (gnus-group-group-level)
|
|
|
2499 gnus-level-default-subscribed))
|
|
|
2500 s)))))
|
|
|
2501 (unless (and (>= level 1) (<= level gnus-level-killed))
|
|
|
2502 (error "Illegal level: %d" level))
|
|
|
2503 (let ((groups (gnus-group-process-prefix n))
|
|
|
2504 group)
|
|
|
2505 (while (setq group (pop groups))
|
|
|
2506 (gnus-group-remove-mark group)
|
|
|
2507 (gnus-message 6 "Changed level of %s from %d to %d"
|
|
|
2508 group (or (gnus-group-group-level) gnus-level-killed)
|
|
|
2509 level)
|
|
|
2510 (gnus-group-change-level
|
|
|
2511 group level (or (gnus-group-group-level) gnus-level-killed))
|
|
|
2512 (gnus-group-update-group-line)))
|
|
|
2513 (gnus-group-position-point))
|
|
|
2514
|
|
|
2515 (defun gnus-group-unsubscribe (&optional n)
|
|
|
2516 "Unsubscribe the current group."
|
|
|
2517 (interactive "P")
|
|
|
2518 (gnus-group-unsubscribe-current-group n 'unsubscribe))
|
|
|
2519
|
|
|
2520 (defun gnus-group-subscribe (&optional n)
|
|
|
2521 "Unsubscribe the current group."
|
|
|
2522 (interactive "P")
|
|
|
2523 (gnus-group-unsubscribe-current-group n 'subscribe))
|
|
|
2524
|
|
|
2525 (defun gnus-group-unsubscribe-current-group (&optional n do-sub)
|
|
|
2526 "Toggle subscription of the current group.
|
|
|
2527 If given numerical prefix, toggle the N next groups."
|
|
|
2528 (interactive "P")
|
|
|
2529 (let ((groups (gnus-group-process-prefix n))
|
|
|
2530 group)
|
|
|
2531 (while groups
|
|
|
2532 (setq group (car groups)
|
|
|
2533 groups (cdr groups))
|
|
|
2534 (gnus-group-remove-mark group)
|
|
|
2535 (gnus-group-unsubscribe-group
|
|
|
2536 group
|
|
|
2537 (cond
|
|
|
2538 ((eq do-sub 'unsubscribe)
|
|
|
2539 gnus-level-default-unsubscribed)
|
|
|
2540 ((eq do-sub 'subscribe)
|
|
|
2541 gnus-level-default-subscribed)
|
|
|
2542 ((<= (gnus-group-group-level) gnus-level-subscribed)
|
|
|
2543 gnus-level-default-unsubscribed)
|
|
|
2544 (t
|
|
|
2545 gnus-level-default-subscribed))
|
|
|
2546 t)
|
|
|
2547 (gnus-group-update-group-line))
|
|
|
2548 (gnus-group-next-group 1)))
|
|
|
2549
|
|
|
2550 (defun gnus-group-unsubscribe-group (group &optional level silent)
|
|
|
2551 "Toggle subscription to GROUP.
|
|
|
2552 Killed newsgroups are subscribed. If SILENT, don't try to update the
|
|
|
2553 group line."
|
|
|
2554 (interactive
|
|
|
2555 (list (completing-read
|
|
|
2556 "Group: " gnus-active-hashtb nil
|
|
|
2557 (gnus-read-active-file-p)
|
|
|
2558 nil
|
|
|
2559 'gnus-group-history)))
|
|
|
2560 (let ((newsrc (gnus-gethash group gnus-newsrc-hashtb)))
|
|
|
2561 (cond
|
|
|
2562 ((string-match "^[ \t]$" group)
|
|
|
2563 (error "Empty group name"))
|
|
|
2564 (newsrc
|
|
|
2565 ;; Toggle subscription flag.
|
|
|
2566 (gnus-group-change-level
|
|
|
2567 newsrc (if level level (if (<= (nth 1 (nth 2 newsrc))
|
|
|
2568 gnus-level-subscribed)
|
|
|
2569 (1+ gnus-level-subscribed)
|
|
|
2570 gnus-level-default-subscribed)))
|
|
|
2571 (unless silent
|
|
|
2572 (gnus-group-update-group group)))
|
|
|
2573 ((and (stringp group)
|
|
|
2574 (or (not (gnus-read-active-file-p))
|
|
|
2575 (gnus-active group)))
|
|
|
2576 ;; Add new newsgroup.
|
|
|
2577 (gnus-group-change-level
|
|
|
2578 group
|
|
|
2579 (if level level gnus-level-default-subscribed)
|
|
|
2580 (or (and (member group gnus-zombie-list)
|
|
|
2581 gnus-level-zombie)
|
|
|
2582 gnus-level-killed)
|
|
|
2583 (when (gnus-group-group-name)
|
|
|
2584 (gnus-gethash (gnus-group-group-name) gnus-newsrc-hashtb)))
|
|
|
2585 (unless silent
|
|
|
2586 (gnus-group-update-group group)))
|
|
|
2587 (t (error "No such newsgroup: %s" group)))
|
|
|
2588 (gnus-group-position-point)))
|
|
|
2589
|
|
|
2590 (defun gnus-group-transpose-groups (n)
|
|
|
2591 "Move the current newsgroup up N places.
|
|
|
2592 If given a negative prefix, move down instead. The difference between
|
|
|
2593 N and the number of steps taken is returned."
|
|
|
2594 (interactive "p")
|
|
|
2595 (unless (gnus-group-group-name)
|
|
|
2596 (error "No group on current line"))
|
|
|
2597 (gnus-group-kill-group 1)
|
|
|
2598 (prog1
|
|
|
2599 (forward-line (- n))
|
|
|
2600 (gnus-group-yank-group)
|
|
|
2601 (gnus-group-position-point)))
|
|
|
2602
|
|
|
2603 (defun gnus-group-kill-all-zombies ()
|
|
|
2604 "Kill all zombie newsgroups."
|
|
|
2605 (interactive)
|
|
|
2606 (setq gnus-killed-list (nconc gnus-zombie-list gnus-killed-list))
|
|
|
2607 (setq gnus-zombie-list nil)
|
|
|
2608 (gnus-group-list-groups))
|
|
|
2609
|
|
|
2610 (defun gnus-group-kill-region (begin end)
|
|
|
2611 "Kill newsgroups in current region (excluding current point).
|
|
|
2612 The killed newsgroups can be yanked by using \\[gnus-group-yank-group]."
|
|
|
2613 (interactive "r")
|
|
|
2614 (let ((lines
|
|
|
2615 ;; Count lines.
|
|
|
2616 (save-excursion
|
|
|
2617 (count-lines
|
|
|
2618 (progn
|
|
|
2619 (goto-char begin)
|
|
|
2620 (beginning-of-line)
|
|
|
2621 (point))
|
|
|
2622 (progn
|
|
|
2623 (goto-char end)
|
|
|
2624 (beginning-of-line)
|
|
|
2625 (point))))))
|
|
|
2626 (goto-char begin)
|
|
|
2627 (beginning-of-line) ;Important when LINES < 1
|
|
|
2628 (gnus-group-kill-group lines)))
|
|
|
2629
|
|
|
2630 (defun gnus-group-kill-group (&optional n discard)
|
|
|
2631 "Kill the next N groups.
|
|
|
2632 The killed newsgroups can be yanked by using \\[gnus-group-yank-group].
|
|
|
2633 However, only groups that were alive can be yanked; already killed
|
|
|
2634 groups or zombie groups can't be yanked.
|
|
|
2635 The return value is the name of the group that was killed, or a list
|
|
|
2636 of groups killed."
|
|
|
2637 (interactive "P")
|
|
|
2638 (let ((buffer-read-only nil)
|
|
|
2639 (groups (gnus-group-process-prefix n))
|
|
|
2640 group entry level out)
|
|
|
2641 (if (< (length groups) 10)
|
|
|
2642 ;; This is faster when there are few groups.
|
|
|
2643 (while groups
|
|
|
2644 (push (setq group (pop groups)) out)
|
|
|
2645 (gnus-group-remove-mark group)
|
|
|
2646 (setq level (gnus-group-group-level))
|
|
|
2647 (gnus-delete-line)
|
|
|
2648 (when (and (not discard)
|
|
|
2649 (setq entry (gnus-gethash group gnus-newsrc-hashtb)))
|
|
|
2650 (gnus-undo-register
|
|
|
2651 `(progn
|
|
|
2652 (gnus-group-goto-group ,(gnus-group-group-name))
|
|
|
2653 (gnus-group-yank-group)))
|
|
|
2654 (push (cons (car entry) (nth 2 entry))
|
|
|
2655 gnus-list-of-killed-groups))
|
|
|
2656 (gnus-group-change-level
|
|
|
2657 (if entry entry group) gnus-level-killed (if entry nil level)))
|
|
|
2658 ;; If there are lots and lots of groups to be killed, we use
|
|
|
2659 ;; this thing instead.
|
|
|
2660 (let (entry)
|
|
|
2661 (setq groups (nreverse groups))
|
|
|
2662 (while groups
|
|
|
2663 (gnus-group-remove-mark (setq group (pop groups)))
|
|
|
2664 (gnus-delete-line)
|
|
|
2665 (push group gnus-killed-list)
|
|
|
2666 (setq gnus-newsrc-alist
|
|
|
2667 (delq (assoc group gnus-newsrc-alist)
|
|
|
2668 gnus-newsrc-alist))
|
|
|
2669 (when gnus-group-change-level-function
|
|
|
2670 (funcall gnus-group-change-level-function group 9 3))
|
|
|
2671 (cond
|
|
|
2672 ((setq entry (gnus-gethash group gnus-newsrc-hashtb))
|
|
|
2673 (push (cons (car entry) (nth 2 entry))
|
|
|
2674 gnus-list-of-killed-groups)
|
|
|
2675 (setcdr (cdr entry) (cdddr entry)))
|
|
|
2676 ((member group gnus-zombie-list)
|
|
|
2677 (setq gnus-zombie-list (delete group gnus-zombie-list)))))
|
|
|
2678 (gnus-make-hashtable-from-newsrc-alist)))
|
|
|
2679
|
|
|
2680 (gnus-group-position-point)
|
|
|
2681 (if (< (length out) 2) (car out) (nreverse out))))
|
|
|
2682
|
|
|
2683 (defun gnus-group-yank-group (&optional arg)
|
|
|
2684 "Yank the last newsgroups killed with \\[gnus-group-kill-group],
|
|
|
2685 inserting it before the current newsgroup. The numeric ARG specifies
|
|
|
2686 how many newsgroups are to be yanked. The name of the newsgroup yanked
|
|
|
2687 is returned, or (if several groups are yanked) a list of yanked groups
|
|
|
2688 is returned."
|
|
|
2689 (interactive "p")
|
|
|
2690 (setq arg (or arg 1))
|
|
|
2691 (let (info group prev out)
|
|
|
2692 (while (>= (decf arg) 0)
|
|
|
2693 (when (not (setq info (pop gnus-list-of-killed-groups)))
|
|
|
2694 (error "No more newsgroups to yank"))
|
|
|
2695 (push (setq group (nth 1 info)) out)
|
|
|
2696 ;; Find which newsgroup to insert this one before - search
|
|
|
2697 ;; backward until something suitable is found. If there are no
|
|
|
2698 ;; other newsgroups in this buffer, just make this newsgroup the
|
|
|
2699 ;; first newsgroup.
|
|
|
2700 (setq prev (gnus-group-group-name))
|
|
|
2701 (gnus-group-change-level
|
|
|
2702 info (gnus-info-level (cdr info)) gnus-level-killed
|
|
|
2703 (and prev (gnus-gethash prev gnus-newsrc-hashtb))
|
|
|
2704 t)
|
|
|
2705 (gnus-group-insert-group-line-info group)
|
|
|
2706 (gnus-undo-register
|
|
|
2707 `(when (gnus-group-goto-group ,group)
|
|
|
2708 (gnus-group-kill-group 1))))
|
|
|
2709 (forward-line -1)
|
|
|
2710 (gnus-group-position-point)
|
|
|
2711 (if (< (length out) 2) (car out) (nreverse out))))
|
|
|
2712
|
|
|
2713 (defun gnus-group-kill-level (level)
|
|
|
2714 "Kill all groups that is on a certain LEVEL."
|
|
|
2715 (interactive "nKill all groups on level: ")
|
|
|
2716 (cond
|
|
|
2717 ((= level gnus-level-zombie)
|
|
|
2718 (setq gnus-killed-list
|
|
|
2719 (nconc gnus-zombie-list gnus-killed-list))
|
|
|
2720 (setq gnus-zombie-list nil))
|
|
|
2721 ((and (< level gnus-level-zombie)
|
|
|
2722 (> level 0)
|
|
|
2723 (or gnus-expert-user
|
|
|
2724 (gnus-yes-or-no-p
|
|
|
2725 (format
|
|
|
2726 "Do you really want to kill all groups on level %d? "
|
|
|
2727 level))))
|
|
|
2728 (let* ((prev gnus-newsrc-alist)
|
|
|
2729 (alist (cdr prev)))
|
|
|
2730 (while alist
|
|
|
2731 (if (= (gnus-info-level (car alist)) level)
|
|
|
2732 (progn
|
|
|
2733 (push (gnus-info-group (car alist)) gnus-killed-list)
|
|
|
2734 (setcdr prev (cdr alist)))
|
|
|
2735 (setq prev alist))
|
|
|
2736 (setq alist (cdr alist)))
|
|
|
2737 (gnus-make-hashtable-from-newsrc-alist)
|
|
|
2738 (gnus-group-list-groups)))
|
|
|
2739 (t
|
|
|
2740 (error "Can't kill; illegal level: %d" level))))
|
|
|
2741
|
|
|
2742 (defun gnus-group-list-all-groups (&optional arg)
|
|
|
2743 "List all newsgroups with level ARG or lower.
|
|
|
2744 Default is gnus-level-unsubscribed, which lists all subscribed and most
|
|
|
2745 unsubscribed groups."
|
|
|
2746 (interactive "P")
|
|
|
2747 (gnus-group-list-groups (or arg gnus-level-unsubscribed) t))
|
|
|
2748
|
|
|
2749 ;; Redefine this to list ALL killed groups if prefix arg used.
|
|
|
2750 ;; Rewritten by engstrom@src.honeywell.com (Eric Engstrom).
|
|
|
2751 (defun gnus-group-list-killed (&optional arg)
|
|
|
2752 "List all killed newsgroups in the group buffer.
|
|
|
2753 If ARG is non-nil, list ALL killed groups known to Gnus. This may
|
|
|
2754 entail asking the server for the groups."
|
|
|
2755 (interactive "P")
|
|
|
2756 ;; Find all possible killed newsgroups if arg.
|
|
|
2757 (when arg
|
|
|
2758 (gnus-get-killed-groups))
|
|
|
2759 (if (not gnus-killed-list)
|
|
|
2760 (gnus-message 6 "No killed groups")
|
|
|
2761 (let (gnus-group-list-mode)
|
|
|
2762 (funcall gnus-group-prepare-function
|
|
|
2763 gnus-level-killed t gnus-level-killed))
|
|
|
2764 (goto-char (point-min)))
|
|
|
2765 (gnus-group-position-point))
|
|
|
2766
|
|
|
2767 (defun gnus-group-list-zombies ()
|
|
|
2768 "List all zombie newsgroups in the group buffer."
|
|
|
2769 (interactive)
|
|
|
2770 (if (not gnus-zombie-list)
|
|
|
2771 (gnus-message 6 "No zombie groups")
|
|
|
2772 (let (gnus-group-list-mode)
|
|
|
2773 (funcall gnus-group-prepare-function
|
|
|
2774 gnus-level-zombie t gnus-level-zombie))
|
|
|
2775 (goto-char (point-min)))
|
|
|
2776 (gnus-group-position-point))
|
|
|
2777
|
|
|
2778 (defun gnus-group-list-active ()
|
|
|
2779 "List all groups that are available from the server(s)."
|
|
|
2780 (interactive)
|
|
|
2781 ;; First we make sure that we have really read the active file.
|
|
|
2782 (unless (gnus-read-active-file-p)
|
|
|
2783 (let ((gnus-read-active-file t))
|
|
|
2784 (gnus-read-active-file)))
|
|
|
2785 ;; Find all groups and sort them.
|
|
|
2786 (let ((groups
|
|
|
2787 (sort
|
|
|
2788 (let (list)
|
|
|
2789 (mapatoms
|
|
|
2790 (lambda (sym)
|
|
|
2791 (and (boundp sym)
|
|
|
2792 (symbol-value sym)
|
|
|
2793 (push (symbol-name sym) list)))
|
|
|
2794 gnus-active-hashtb)
|
|
|
2795 list)
|
|
|
2796 'string<))
|
|
|
2797 (buffer-read-only nil)
|
|
|
2798 group)
|
|
|
2799 (erase-buffer)
|
|
|
2800 (while groups
|
|
|
2801 (gnus-add-text-properties
|
|
|
2802 (point) (prog1 (1+ (point))
|
|
|
2803 (insert " *: "
|
|
|
2804 (setq group (pop groups)) "\n"))
|
|
|
2805 (list 'gnus-group (gnus-intern-safe group gnus-active-hashtb)
|
|
|
2806 'gnus-unread t
|
|
|
2807 'gnus-level (inline (gnus-group-level group)))))
|
|
|
2808 (goto-char (point-min))))
|
|
|
2809
|
|
|
2810 (defun gnus-activate-all-groups (level)
|
|
|
2811 "Activate absolutely all groups."
|
|
|
2812 (interactive (list 7))
|
|
|
2813 (let ((gnus-activate-level level)
|
|
|
2814 (gnus-activate-foreign-newsgroups level))
|
|
|
2815 (gnus-group-get-new-news)))
|
|
|
2816
|
|
|
2817 (defun gnus-group-get-new-news (&optional arg)
|
|
|
2818 "Get newly arrived articles.
|
|
|
2819 If ARG is a number, it specifies which levels you are interested in
|
|
|
2820 re-scanning. If ARG is non-nil and not a number, this will force
|
|
|
2821 \"hard\" re-reading of the active files from all servers."
|
|
|
2822 (interactive "P")
|
|
|
2823 (run-hooks 'gnus-get-new-news-hook)
|
|
|
2824
|
|
|
2825 ;; Read any slave files.
|
|
|
2826 (unless gnus-slave
|
|
|
2827 (gnus-master-read-slave-newsrc))
|
|
|
2828
|
|
|
2829 ;; We might read in new NoCeM messages here.
|
|
|
2830 (when (and gnus-use-nocem
|
|
|
2831 (null arg))
|
|
|
2832 (gnus-nocem-scan-groups))
|
|
|
2833 ;; If ARG is not a number, then we read the active file.
|
|
|
2834 (when (and arg (not (numberp arg)))
|
|
|
2835 (let ((gnus-read-active-file t))
|
|
|
2836 (gnus-read-active-file))
|
|
|
2837 (setq arg nil)
|
|
|
2838
|
|
|
2839 ;; If the user wants it, we scan for new groups.
|
|
|
2840 (when (eq gnus-check-new-newsgroups 'always)
|
|
|
2841 (gnus-find-new-newsgroups)))
|
|
|
2842
|
|
|
2843 (setq arg (gnus-group-default-level arg t))
|
|
|
2844 (if (and gnus-read-active-file (not arg))
|
|
|
2845 (progn
|
|
|
2846 (gnus-read-active-file)
|
|
|
2847 (gnus-get-unread-articles arg))
|
|
|
2848 (let ((gnus-read-active-file (if arg nil gnus-read-active-file)))
|
|
|
2849 (gnus-get-unread-articles arg)))
|
|
|
2850 (run-hooks 'gnus-after-getting-new-news-hook)
|
|
|
2851 (gnus-group-list-groups))
|
|
|
2852
|
|
|
2853 (defun gnus-group-get-new-news-this-group (&optional n)
|
|
|
2854 "Check for newly arrived news in the current group (and the N-1 next groups).
|
|
|
2855 The difference between N and the number of newsgroup checked is returned.
|
|
|
2856 If N is negative, this group and the N-1 previous groups will be checked."
|
|
|
2857 (interactive "P")
|
|
|
2858 (let* ((groups (gnus-group-process-prefix n))
|
|
|
2859 (ret (if (numberp n) (- n (length groups)) 0))
|
|
|
2860 (beg (unless n
|
|
|
2861 (point)))
|
|
|
2862 group)
|
|
|
2863 (while (setq group (pop groups))
|
|
|
2864 (gnus-group-remove-mark group)
|
|
|
2865 ;; Bypass any previous denials from the server.
|
|
|
2866 (gnus-remove-denial (gnus-find-method-for-group group))
|
|
|
2867 (if (gnus-activate-group group 'scan)
|
|
|
2868 (progn
|
|
|
2869 (gnus-get-unread-articles-in-group
|
|
|
2870 (gnus-get-info group) (gnus-active group) t)
|
|
|
2871 (unless (gnus-virtual-group-p group)
|
|
|
2872 (gnus-close-group group))
|
|
|
2873 (gnus-group-update-group group))
|
|
|
2874 (if (eq (gnus-server-status (gnus-find-method-for-group group))
|
|
|
2875 'denied)
|
|
|
2876 (gnus-error 3 "Server denied access")
|
|
|
2877 (gnus-error 3 "%s error: %s" group (gnus-status-message group)))))
|
|
|
2878 (when beg
|
|
|
2879 (goto-char beg))
|
|
|
2880 (when gnus-goto-next-group-when-activating
|
|
|
2881 (gnus-group-next-unread-group 1 t))
|
|
|
2882 (gnus-summary-position-point)
|
|
|
2883 ret))
|
|
|
2884
|
|
|
2885 (defun gnus-group-fetch-faq (group &optional faq-dir)
|
|
|
2886 "Fetch the FAQ for the current group.
|
|
|
2887 If given a prefix argument, prompt for the FAQ dir
|
|
|
2888 to use."
|
|
|
2889 (interactive
|
|
|
2890 (list
|
|
|
2891 (gnus-group-group-name)
|
|
|
2892 (cond (current-prefix-arg
|
|
|
2893 (completing-read
|
|
|
2894 "Faq dir: " (and (listp gnus-group-faq-directory)
|
|
|
2895 (mapcar (lambda (file) (list file))
|
|
|
2896 gnus-group-faq-directory)))))))
|
|
|
2897 (unless group
|
|
|
2898 (error "No group name given"))
|
|
|
2899 (let ((dirs (or faq-dir gnus-group-faq-directory))
|
|
|
2900 dir found file)
|
|
|
2901 (unless (listp dirs)
|
|
|
2902 (setq dirs (list dirs)))
|
|
|
2903 (while (and (not found)
|
|
|
2904 (setq dir (pop dirs)))
|
|
|
2905 (setq file (concat (file-name-as-directory dir)
|
|
|
2906 (gnus-group-real-name group)))
|
|
|
2907 (if (not (file-exists-p file))
|
|
|
2908 (gnus-message 1 "No such file: %s" file)
|
|
|
2909 (let ((enable-local-variables nil))
|
|
|
2910 (find-file file)
|
|
|
2911 (setq found t))))))
|
|
|
2912
|
|
|
2913 (defun gnus-group-describe-group (force &optional group)
|
|
|
2914 "Display a description of the current newsgroup."
|
|
|
2915 (interactive (list current-prefix-arg (gnus-group-group-name)))
|
|
|
2916 (let* ((method (gnus-find-method-for-group group))
|
|
|
2917 (mname (gnus-group-prefixed-name "" method))
|
|
|
2918 desc)
|
|
|
2919 (when (and force
|
|
|
2920 gnus-description-hashtb)
|
|
|
2921 (gnus-sethash mname nil gnus-description-hashtb))
|
|
|
2922 (unless group
|
|
|
2923 (error "No group name given"))
|
|
|
2924 (when (or (and gnus-description-hashtb
|
|
|
2925 ;; We check whether this group's method has been
|
|
|
2926 ;; queried for a description file.
|
|
|
2927 (gnus-gethash mname gnus-description-hashtb))
|
|
|
2928 (setq desc (gnus-group-get-description group))
|
|
|
2929 (gnus-read-descriptions-file method))
|
|
|
2930 (gnus-message 1
|
|
|
2931 (or desc (gnus-gethash group gnus-description-hashtb)
|
|
|
2932 "No description available")))))
|
|
|
2933
|
|
|
2934 ;; Suggested by Per Abrahamsen <amanda@iesd.auc.dk>.
|
|
|
2935 (defun gnus-group-describe-all-groups (&optional force)
|
|
|
2936 "Pop up a buffer with descriptions of all newsgroups."
|
|
|
2937 (interactive "P")
|
|
|
2938 (when force
|
|
|
2939 (setq gnus-description-hashtb nil))
|
|
|
2940 (when (not (or gnus-description-hashtb
|
|
|
2941 (gnus-read-all-descriptions-files)))
|
|
|
2942 (error "Couldn't request descriptions file"))
|
|
|
2943 (let ((buffer-read-only nil)
|
|
|
2944 b)
|
|
|
2945 (erase-buffer)
|
|
|
2946 (mapatoms
|
|
|
2947 (lambda (group)
|
|
|
2948 (setq b (point))
|
|
|
2949 (insert (format " *: %-20s %s\n" (symbol-name group)
|
|
|
2950 (symbol-value group)))
|
|
|
2951 (gnus-add-text-properties
|
|
|
2952 b (1+ b) (list 'gnus-group group
|
|
|
2953 'gnus-unread t 'gnus-marked nil
|
|
|
2954 'gnus-level (1+ gnus-level-subscribed))))
|
|
|
2955 gnus-description-hashtb)
|
|
|
2956 (goto-char (point-min))
|
|
|
2957 (gnus-group-position-point)))
|
|
|
2958
|
|
|
2959 ;; Suggested by Daniel Quinlan <quinlan@best.com>.
|
|
|
2960 (defun gnus-group-apropos (regexp &optional search-description)
|
|
|
2961 "List all newsgroups that have names that match a regexp."
|
|
|
2962 (interactive "sGnus apropos (regexp): ")
|
|
|
2963 (let ((prev "")
|
|
|
2964 (obuf (current-buffer))
|
|
|
2965 groups des)
|
|
|
2966 ;; Go through all newsgroups that are known to Gnus.
|
|
|
2967 (mapatoms
|
|
|
2968 (lambda (group)
|
|
|
2969 (and (symbol-name group)
|
|
|
2970 (string-match regexp (symbol-name group))
|
|
|
2971 (push (symbol-name group) groups)))
|
|
|
2972 gnus-active-hashtb)
|
|
|
2973 ;; Also go through all descriptions that are known to Gnus.
|
|
|
2974 (when search-description
|
|
|
2975 (mapatoms
|
|
|
2976 (lambda (group)
|
|
|
2977 (and (string-match regexp (symbol-value group))
|
|
|
2978 (gnus-active (symbol-name group))
|
|
|
2979 (push (symbol-name group) groups)))
|
|
|
2980 gnus-description-hashtb))
|
|
|
2981 (if (not groups)
|
|
|
2982 (gnus-message 3 "No groups matched \"%s\"." regexp)
|
|
|
2983 ;; Print out all the groups.
|
|
|
2984 (save-excursion
|
|
|
2985 (pop-to-buffer "*Gnus Help*")
|
|
|
2986 (buffer-disable-undo (current-buffer))
|
|
|
2987 (erase-buffer)
|
|
|
2988 (setq groups (sort groups 'string<))
|
|
|
2989 (while groups
|
|
|
2990 ;; Groups may be entered twice into the list of groups.
|
|
|
2991 (when (not (string= (car groups) prev))
|
|
|
2992 (insert (setq prev (car groups)) "\n")
|
|
|
2993 (when (and gnus-description-hashtb
|
|
|
2994 (setq des (gnus-gethash (car groups)
|
|
|
2995 gnus-description-hashtb)))
|
|
|
2996 (insert " " des "\n")))
|
|
|
2997 (setq groups (cdr groups)))
|
|
|
2998 (goto-char (point-min))))
|
|
|
2999 (pop-to-buffer obuf)))
|
|
|
3000
|
|
|
3001 (defun gnus-group-description-apropos (regexp)
|
|
|
3002 "List all newsgroups that have names or descriptions that match a regexp."
|
|
|
3003 (interactive "sGnus description apropos (regexp): ")
|
|
|
3004 (when (not (or gnus-description-hashtb
|
|
|
3005 (gnus-read-all-descriptions-files)))
|
|
|
3006 (error "Couldn't request descriptions file"))
|
|
|
3007 (gnus-group-apropos regexp t))
|
|
|
3008
|
|
|
3009 ;; Suggested by Per Abrahamsen <amanda@iesd.auc.dk>.
|
|
|
3010 (defun gnus-group-list-matching (level regexp &optional all lowest)
|
|
|
3011 "List all groups with unread articles that match REGEXP.
|
|
|
3012 If the prefix LEVEL is non-nil, it should be a number that says which
|
|
|
3013 level to cut off listing groups.
|
|
|
3014 If ALL, also list groups with no unread articles.
|
|
|
3015 If LOWEST, don't list groups with level lower than LOWEST.
|
|
|
3016
|
|
|
3017 This command may read the active file."
|
|
|
3018 (interactive "P\nsList newsgroups matching: ")
|
|
|
3019 ;; First make sure active file has been read.
|
|
|
3020 (when (and level
|
|
|
3021 (> (prefix-numeric-value level) gnus-level-killed))
|
|
|
3022 (gnus-get-killed-groups))
|
|
|
3023 (gnus-group-prepare-flat
|
|
|
3024 (or level gnus-level-subscribed) all (or lowest 1) regexp)
|
|
|
3025 (goto-char (point-min))
|
|
|
3026 (gnus-group-position-point))
|
|
|
3027
|
|
|
3028 (defun gnus-group-list-all-matching (level regexp &optional lowest)
|
|
|
3029 "List all groups that match REGEXP.
|
|
|
3030 If the prefix LEVEL is non-nil, it should be a number that says which
|
|
|
3031 level to cut off listing groups.
|
|
|
3032 If LOWEST, don't list groups with level lower than LOWEST."
|
|
|
3033 (interactive "P\nsList newsgroups matching: ")
|
|
|
3034 (when level
|
|
|
3035 (setq level (prefix-numeric-value level)))
|
|
|
3036 (gnus-group-list-matching (or level gnus-level-killed) regexp t lowest))
|
|
|
3037
|
|
|
3038 ;; Suggested by Jack Vinson <vinson@unagi.cis.upenn.edu>.
|
|
|
3039 (defun gnus-group-save-newsrc (&optional force)
|
|
|
3040 "Save the Gnus startup files.
|
|
|
3041 If FORCE, force saving whether it is necessary or not."
|
|
|
3042 (interactive "P")
|
|
|
3043 (gnus-save-newsrc-file force))
|
|
|
3044
|
|
|
3045 (defun gnus-group-restart (&optional arg)
|
|
|
3046 "Force Gnus to read the .newsrc file."
|
|
|
3047 (interactive "P")
|
|
|
3048 (when (gnus-yes-or-no-p
|
|
|
3049 (format "Are you sure you want to restart Gnus? "))
|
|
|
3050 (gnus-save-newsrc-file)
|
|
|
3051 (gnus-clear-system)
|
|
|
3052 (gnus)))
|
|
|
3053
|
|
|
3054 (defun gnus-group-read-init-file ()
|
|
|
3055 "Read the Gnus elisp init file."
|
|
|
3056 (interactive)
|
|
|
3057 (gnus-read-init-file))
|
|
|
3058
|
|
|
3059 (defun gnus-group-check-bogus-groups (&optional silent)
|
|
|
3060 "Check bogus newsgroups.
|
|
|
3061 If given a prefix, don't ask for confirmation before removing a bogus
|
|
|
3062 group."
|
|
|
3063 (interactive "P")
|
|
|
3064 (gnus-check-bogus-newsgroups (and (not silent) (not gnus-expert-user)))
|
|
|
3065 (gnus-group-list-groups))
|
|
|
3066
|
|
|
3067 (defun gnus-group-edit-global-kill (&optional article group)
|
|
|
3068 "Edit the global kill file.
|
|
|
3069 If GROUP, edit that local kill file instead."
|
|
|
3070 (interactive "P")
|
|
|
3071 (setq gnus-current-kill-article article)
|
|
|
3072 (gnus-kill-file-edit-file group)
|
|
|
3073 (gnus-message
|
|
|
3074 6
|
|
|
3075 (substitute-command-keys
|
|
|
3076 (format "Editing a %s kill file (Type \\[gnus-kill-file-exit] to exit)"
|
|
|
3077 (if group "local" "global")))))
|
|
|
3078
|
|
|
3079 (defun gnus-group-edit-local-kill (article group)
|
|
|
3080 "Edit a local kill file."
|
|
|
3081 (interactive (list nil (gnus-group-group-name)))
|
|
|
3082 (gnus-group-edit-global-kill article group))
|
|
|
3083
|
|
|
3084 (defun gnus-group-force-update ()
|
|
|
3085 "Update `.newsrc' file."
|
|
|
3086 (interactive)
|
|
|
3087 (gnus-save-newsrc-file))
|
|
|
3088
|
|
|
3089 (defun gnus-group-suspend ()
|
|
|
3090 "Suspend the current Gnus session.
|
|
|
3091 In fact, cleanup buffers except for group mode buffer.
|
|
|
3092 The hook gnus-suspend-gnus-hook is called before actually suspending."
|
|
|
3093 (interactive)
|
|
|
3094 (run-hooks 'gnus-suspend-gnus-hook)
|
|
|
3095 ;; Kill Gnus buffers except for group mode buffer.
|
|
|
3096 (let* ((group-buf (get-buffer gnus-group-buffer))
|
|
|
3097 ;; Do this on a separate list in case the user does a ^G before we finish
|
|
|
3098 (gnus-buffer-list
|
|
|
3099 (delete group-buf (delete gnus-dribble-buffer
|
|
|
3100 (append gnus-buffer-list nil)))))
|
|
|
3101 (while gnus-buffer-list
|
|
|
3102 (gnus-kill-buffer (pop gnus-buffer-list)))
|
|
|
3103 (gnus-kill-gnus-frames)
|
|
|
3104 (when group-buf
|
|
|
3105 (setq gnus-buffer-list (list group-buf))
|
|
|
3106 (bury-buffer group-buf)
|
|
|
3107 (delete-windows-on group-buf t))))
|
|
|
3108
|
|
|
3109 (defun gnus-group-clear-dribble ()
|
|
|
3110 "Clear all information from the dribble buffer."
|
|
|
3111 (interactive)
|
|
|
3112 (gnus-dribble-clear)
|
|
|
3113 (gnus-message 7 "Cleared dribble buffer"))
|
|
|
3114
|
|
|
3115 (defun gnus-group-exit ()
|
|
|
3116 "Quit reading news after updating .newsrc.eld and .newsrc.
|
|
|
3117 The hook `gnus-exit-gnus-hook' is called before actually exiting."
|
|
|
3118 (interactive)
|
|
|
3119 (when
|
|
|
3120 (or noninteractive ;For gnus-batch-kill
|
|
|
3121 (not gnus-interactive-exit) ;Without confirmation
|
|
|
3122 gnus-expert-user
|
|
|
3123 (gnus-y-or-n-p "Are you sure you want to quit reading news? "))
|
|
|
3124 (run-hooks 'gnus-exit-gnus-hook)
|
|
|
3125 ;; Offer to save data from non-quitted summary buffers.
|
|
|
3126 (gnus-offer-save-summaries)
|
|
|
3127 ;; Save the newsrc file(s).
|
|
|
3128 (gnus-save-newsrc-file)
|
|
|
3129 ;; Kill-em-all.
|
|
|
3130 (gnus-close-backends)
|
|
|
3131 ;; Reset everything.
|
|
|
3132 (gnus-clear-system)
|
|
|
3133 ;; Allow the user to do things after cleaning up.
|
|
|
3134 (run-hooks 'gnus-after-exiting-gnus-hook)))
|
|
|
3135
|
|
|
3136 (defun gnus-group-quit ()
|
|
|
3137 "Quit reading news without updating .newsrc.eld or .newsrc.
|
|
|
3138 The hook `gnus-exit-gnus-hook' is called before actually exiting."
|
|
|
3139 (interactive)
|
|
|
3140 (when (or noninteractive ;For gnus-batch-kill
|
|
|
3141 (zerop (buffer-size))
|
|
|
3142 (not (gnus-server-opened gnus-select-method))
|
|
|
3143 gnus-expert-user
|
|
|
3144 (not gnus-current-startup-file)
|
|
|
3145 (gnus-yes-or-no-p
|
|
|
3146 (format "Quit reading news without saving %s? "
|
|
|
3147 (file-name-nondirectory gnus-current-startup-file))))
|
|
|
3148 (run-hooks 'gnus-exit-gnus-hook)
|
|
|
3149 (gnus-configure-windows 'group t)
|
|
|
3150 (gnus-dribble-save)
|
|
|
3151 (gnus-close-backends)
|
|
|
3152 (gnus-clear-system)
|
|
|
3153 (gnus-kill-buffer gnus-group-buffer)
|
|
|
3154 ;; Allow the user to do things after cleaning up.
|
|
|
3155 (run-hooks 'gnus-after-exiting-gnus-hook)))
|
|
|
3156
|
|
|
3157 (defun gnus-group-describe-briefly ()
|
|
|
3158 "Give a one line description of the group mode commands."
|
|
|
3159 (interactive)
|
|
|
3160 (gnus-message 7 (substitute-command-keys "\\<gnus-group-mode-map>\\[gnus-group-read-group]:Select \\[gnus-group-next-unread-group]:Forward \\[gnus-group-prev-unread-group]:Backward \\[gnus-group-exit]:Exit \\[gnus-info-find-node]:Run Info \\[gnus-group-describe-briefly]:This help")))
|
|
|
3161
|
|
|
3162 (defun gnus-group-browse-foreign-server (method)
|
|
|
3163 "Browse a foreign news server.
|
|
|
3164 If called interactively, this function will ask for a select method
|
|
|
3165 (nntp, nnspool, etc.) and a server address (eg. nntp.some.where).
|
|
|
3166 If not, METHOD should be a list where the first element is the method
|
|
|
3167 and the second element is the address."
|
|
|
3168 (interactive
|
|
|
3169 (list (let ((how (completing-read
|
|
|
3170 "Which backend: "
|
|
|
3171 (append gnus-valid-select-methods gnus-server-alist)
|
|
|
3172 nil t (cons "nntp" 0) 'gnus-method-history)))
|
|
|
3173 ;; We either got a backend name or a virtual server name.
|
|
|
3174 ;; If the first, we also need an address.
|
|
|
3175 (if (assoc how gnus-valid-select-methods)
|
|
|
3176 (list (intern how)
|
|
|
3177 ;; Suggested by mapjph@bath.ac.uk.
|
|
|
3178 (completing-read
|
|
|
3179 "Address: "
|
|
|
3180 (mapcar (lambda (server) (list server))
|
|
|
3181 gnus-secondary-servers)))
|
|
|
3182 ;; We got a server name, so we find the method.
|
|
|
3183 (gnus-server-to-method how)))))
|
|
|
3184 (gnus-browse-foreign-server method))
|
|
|
3185
|
|
|
3186 (defun gnus-group-set-info (info &optional method-only-group part)
|
|
|
3187 (let* ((entry (gnus-gethash
|
|
|
3188 (or method-only-group (gnus-info-group info))
|
|
|
3189 gnus-newsrc-hashtb))
|
|
|
3190 (part-info info)
|
|
|
3191 (info (if method-only-group (nth 2 entry) info))
|
|
|
3192 method)
|
|
|
3193 (when method-only-group
|
|
|
3194 (unless entry
|
|
|
3195 (error "Trying to change non-existent group %s" method-only-group))
|
|
|
3196 ;; We have received parts of the actual group info - either the
|
|
|
3197 ;; select method or the group parameters. We first check
|
|
|
3198 ;; whether we have to extend the info, and if so, do that.
|
|
|
3199 (let ((len (length info))
|
|
|
3200 (total (if (eq part 'method) 5 6)))
|
|
|
3201 (when (< len total)
|
|
|
3202 (setcdr (nthcdr (1- len) info)
|
|
|
3203 (make-list (- total len) nil)))
|
|
|
3204 ;; Then we enter the new info.
|
|
|
3205 (setcar (nthcdr (1- total) info) part-info)))
|
|
|
3206 (unless entry
|
|
|
3207 ;; This is a new group, so we just create it.
|
|
|
3208 (save-excursion
|
|
|
3209 (set-buffer gnus-group-buffer)
|
|
|
3210 (setq method (gnus-info-method info))
|
|
|
3211 (when (gnus-server-equal method "native")
|
|
|
3212 (setq method nil))
|
|
|
3213 (save-excursion
|
|
|
3214 (set-buffer gnus-group-buffer)
|
|
|
3215 (if method
|
|
|
3216 ;; It's a foreign group...
|
|
|
3217 (gnus-group-make-group
|
|
|
3218 (gnus-group-real-name (gnus-info-group info))
|
|
|
3219 (if (stringp method) method
|
|
|
3220 (prin1-to-string (car method)))
|
|
|
3221 (and (consp method)
|
|
|
3222 (nth 1 (gnus-info-method info))))
|
|
|
3223 ;; It's a native group.
|
|
|
3224 (gnus-group-make-group (gnus-info-group info))))
|
|
|
3225 (gnus-message 6 "Note: New group created")
|
|
|
3226 (setq entry
|
|
|
3227 (gnus-gethash (gnus-group-prefixed-name
|
|
|
3228 (gnus-group-real-name (gnus-info-group info))
|
|
|
3229 (or (gnus-info-method info) gnus-select-method))
|
|
|
3230 gnus-newsrc-hashtb))))
|
|
|
3231 ;; Whether it was a new group or not, we now have the entry, so we
|
|
|
3232 ;; can do the update.
|
|
|
3233 (if entry
|
|
|
3234 (progn
|
|
|
3235 (setcar (nthcdr 2 entry) info)
|
|
|
3236 (when (and (not (eq (car entry) t))
|
|
|
3237 (gnus-active (gnus-info-group info)))
|
|
|
3238 (setcar entry (length (gnus-list-of-unread-articles (car info))))))
|
|
|
3239 (error "No such group: %s" (gnus-info-group info)))))
|
|
|
3240
|
|
|
3241 (defun gnus-group-set-method-info (group select-method)
|
|
|
3242 (gnus-group-set-info select-method group 'method))
|
|
|
3243
|
|
|
3244 (defun gnus-group-set-params-info (group params)
|
|
|
3245 (gnus-group-set-info params group 'params))
|
|
|
3246
|
|
|
3247 (defun gnus-add-marked-articles (group type articles &optional info force)
|
|
|
3248 ;; Add ARTICLES of TYPE to the info of GROUP.
|
|
|
3249 ;; If INFO is non-nil, use that info. If FORCE is non-nil, don't
|
|
|
3250 ;; add, but replace marked articles of TYPE with ARTICLES.
|
|
|
3251 (let ((info (or info (gnus-get-info group)))
|
|
|
3252 (uncompressed '(score bookmark killed))
|
|
|
3253 marked m)
|
|
|
3254 (or (not info)
|
|
|
3255 (and (not (setq marked (nthcdr 3 info)))
|
|
|
3256 (or (null articles)
|
|
|
3257 (setcdr (nthcdr 2 info)
|
|
|
3258 (list (list (cons type (gnus-compress-sequence
|
|
|
3259 articles t)))))))
|
|
|
3260 (and (not (setq m (assq type (car marked))))
|
|
|
3261 (or (null articles)
|
|
|
3262 (setcar marked
|
|
|
3263 (cons (cons type (gnus-compress-sequence articles t) )
|
|
|
3264 (car marked)))))
|
|
|
3265 (if force
|
|
|
3266 (if (null articles)
|
|
|
3267 (setcar (nthcdr 3 info)
|
|
|
3268 (delq (assq type (car marked)) (car marked)))
|
|
|
3269 (setcdr m (gnus-compress-sequence articles t)))
|
|
|
3270 (setcdr m (gnus-compress-sequence
|
|
|
3271 (sort (nconc (gnus-uncompress-range (cdr m))
|
|
|
3272 (copy-sequence articles)) '<) t))))))
|
|
|
3273
|
|
|
3274 ;;;
|
|
|
3275 ;;; Group timestamps
|
|
|
3276 ;;;
|
|
|
3277
|
|
|
3278 (defun gnus-group-set-timestamp ()
|
|
|
3279 "Change the timestamp of the current group to the current time.
|
|
|
3280 This function can be used in hooks like `gnus-select-group-hook'
|
|
|
3281 or `gnus-group-catchup-group-hook'."
|
|
|
3282 (when gnus-newsgroup-name
|
|
|
3283 (let ((time (current-time)))
|
|
|
3284 (setcdr (cdr time) nil)
|
|
|
3285 (gnus-group-set-parameter gnus-newsgroup-name 'timestamp time))))
|
|
|
3286
|
|
|
3287 (defsubst gnus-group-timestamp (group)
|
|
|
3288 "Return the timestamp for GROUP."
|
|
|
3289 (gnus-group-get-parameter group 'timestamp))
|
|
|
3290
|
|
|
3291 (defun gnus-group-timestamp-delta (group)
|
|
|
3292 "Return the offset in seconds from the timestamp for GROUP to the current time, as a floating point number."
|
|
|
3293 (let* ((time (or (gnus-group-timestamp group)
|
|
|
3294 (list 0 0)))
|
|
|
3295 (delta (gnus-time-minus (current-time) time)))
|
|
|
3296 (+ (* (nth 0 delta) 65536.0)
|
|
|
3297 (nth 1 delta))))
|
|
|
3298
|
|
|
3299 (defun gnus-group-timestamp-string (group)
|
|
|
3300 "Return a string of the timestamp for GROUP."
|
|
|
3301 (let ((time (gnus-group-timestamp group)))
|
|
|
3302 (if (not time)
|
|
|
3303 ""
|
|
|
3304 (gnus-time-iso8601 time))))
|
|
|
3305
|
|
|
3306 (provide 'gnus-group)
|
|
|
3307
|
|
|
3308 ;;; gnus-group.el ends here
|
