Mercurial > emacs
comparison lisp/gnus.el @ 13401:178d730efae2
entered into RCS
| author | Lars Magne Ingebrigtsen <larsi@gnus.org> |
|---|---|
| date | Sat, 04 Nov 1995 03:54:42 +0000 |
| parents | |
| children | 9426437410bf |
comparison
equal
deleted
inserted
replaced
| 13400:4a57cda2a39a | 13401:178d730efae2 |
|---|---|
| 1 ;;; gnus.el --- a newsreader for GNU Emacs | |
| 2 ;; Copyright (C) 1987,88,89,90,93,94,95 Free Software Foundation, Inc. | |
| 3 | |
| 4 ;; Author: Masanobu UMEDA <umerin@flab.flab.fujitsu.junet> | |
| 5 ;; Lars Magne Ingebrigtsen <larsi@ifi.uio.no> | |
| 6 ;; Keywords: news | |
| 7 | |
| 8 ;; This file is part of GNU Emacs. | |
| 9 | |
| 10 ;; GNU Emacs is free software; you can redistribute it and/or modify | |
| 11 ;; it under the terms of the GNU General Public License as published by | |
| 12 ;; the Free Software Foundation; either version 2, or (at your option) | |
| 13 ;; any later version. | |
| 14 | |
| 15 ;; GNU Emacs is distributed in the hope that it will be useful, | |
| 16 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of | |
| 17 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
| 18 ;; GNU General Public License for more details. | |
| 19 | |
| 20 ;; You should have received a copy of the GNU General Public License | |
| 21 ;; along with GNU Emacs; see the file COPYING. If not, write to | |
| 22 ;; the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. | |
| 23 | |
| 24 ;;; Commentary: | |
| 25 | |
| 26 ;; Although Gnus looks suspiciously like GNUS, it isn't quite the same | |
| 27 ;; beast. Most internal structures have been changed. If you have | |
| 28 ;; written packages that depend on any of the hash tables, | |
| 29 ;; `gnus-newsrc-alist', `gnus-killed-assoc', marked lists, the .newsrc | |
| 30 ;; buffer, or internal knowledge of the `nntp-header-' macros, or | |
| 31 ;; dependence on the buffers having a certain format, your code will | |
| 32 ;; fail. | |
| 33 | |
| 34 ;;; Code: | |
| 35 | |
| 36 (eval '(run-hooks 'gnus-load-hook)) | |
| 37 | |
| 38 (require 'mail-utils) | |
| 39 (require 'timezone) | |
| 40 (require 'nnheader) | |
| 41 | |
| 42 ;; Site dependent variables. These variables should be defined in | |
| 43 ;; paths.el. | |
| 44 | |
| 45 (defvar gnus-default-nntp-server nil | |
| 46 "Specify a default NNTP server. | |
| 47 This variable should be defined in paths.el, and should never be set | |
| 48 by the user. | |
| 49 If you want to change servers, you should use `gnus-select-method'. | |
| 50 See the documentation to that variable.") | |
| 51 | |
| 52 (defconst gnus-backup-default-subscribed-newsgroups | |
| 53 '("news.announce.newusers" "news.groups.questions" "gnu.emacs.gnus") | |
| 54 "Default default new newsgroups the first time Gnus is run. | |
| 55 Should be set in paths.el, and shouldn't be touched by the user.") | |
| 56 | |
| 57 (defvar gnus-local-domain nil | |
| 58 "Local domain name without a host name. | |
| 59 The DOMAINNAME environment variable is used instead if it is defined. | |
| 60 If the `system-name' function returns the full Internet name, there is | |
| 61 no need to set this variable.") | |
| 62 | |
| 63 (defvar gnus-local-organization nil | |
| 64 "String with a description of what organization (if any) the user belongs to. | |
| 65 The ORGANIZATION environment variable is used instead if it is defined. | |
| 66 If this variable contains a function, this function will be called | |
| 67 with the current newsgroup name as the argument. The function should | |
| 68 return a string. | |
| 69 | |
| 70 In any case, if the string (either in the variable, in the environment | |
| 71 variable, or returned by the function) is a file name, the contents of | |
| 72 this file will be used as the organization.") | |
| 73 | |
| 74 (defvar gnus-use-generic-from nil | |
| 75 "If nil, the full host name will be the system name prepended to the domain name. | |
| 76 If this is a string, the full host name will be this string. | |
| 77 If this is non-nil, non-string, the domain name will be used as the | |
| 78 full host name.") | |
| 79 | |
| 80 (defvar gnus-use-generic-path nil | |
| 81 "If nil, use the NNTP server name in the Path header. | |
| 82 If stringp, use this; if non-nil, use no host name (user name only).") | |
| 83 | |
| 84 | |
| 85 ;; Customization variables | |
| 86 | |
| 87 ;; Don't touch this variable. | |
| 88 (defvar gnus-nntp-service "nntp" | |
| 89 "*NNTP service name (\"nntp\" or 119). | |
| 90 This is an obsolete variable, which is scarcely used. If you use an | |
| 91 nntp server for your newsgroup and want to change the port number | |
| 92 used to 899, you would say something along these lines: | |
| 93 | |
| 94 (setq gnus-select-method '(nntp \"my.nntp.server\" (nntp-port-number 899)))") | |
| 95 | |
| 96 (defvar gnus-select-method | |
| 97 (nconc | |
| 98 (list 'nntp (or (getenv "NNTPSERVER") | |
| 99 (if (and gnus-default-nntp-server | |
| 100 (not (string= gnus-default-nntp-server ""))) | |
| 101 gnus-default-nntp-server) | |
| 102 (system-name))) | |
| 103 (if (or (null gnus-nntp-service) | |
| 104 (equal gnus-nntp-service "nntp")) | |
| 105 nil | |
| 106 (list gnus-nntp-service))) | |
| 107 "*Default method for selecting a newsgroup. | |
| 108 This variable should be a list, where the first element is how the | |
| 109 news is to be fetched, the second is the address. | |
| 110 | |
| 111 For instance, if you want to get your news via NNTP from | |
| 112 \"flab.flab.edu\", you could say: | |
| 113 | |
| 114 (setq gnus-select-method '(nntp \"flab.flab.edu\")) | |
| 115 | |
| 116 If you want to use your local spool, say: | |
| 117 | |
| 118 (setq gnus-select-method (list 'nnspool (system-name))) | |
| 119 | |
| 120 If you use this variable, you must set `gnus-nntp-server' to nil. | |
| 121 | |
| 122 There is a lot more to know about select methods and virtual servers - | |
| 123 see the manual for details.") | |
| 124 | |
| 125 ;; Added by Sudish Joseph <joseph@cis.ohio-state.edu>. | |
| 126 (defvar gnus-post-method nil | |
| 127 "*Preferred method for posting USENET news. | |
| 128 If this variable is nil, Gnus will use the current method to decide | |
| 129 which method to use when posting. If it is non-nil, it will override | |
| 130 the current method. This method will not be used in mail groups and | |
| 131 the like, only in \"real\" newsgroups. | |
| 132 | |
| 133 The value must be a valid method as discussed in the documentation of | |
| 134 `gnus-select-method'.") | |
| 135 | |
| 136 (defvar gnus-refer-article-method nil | |
| 137 "*Preferred method for fetching an article by Message-ID. | |
| 138 If you are reading news from the local spool (with nnspool), fetching | |
| 139 articles by Message-ID is painfully slow. By setting this method to an | |
| 140 nntp method, you might get acceptable results. | |
| 141 | |
| 142 The value of this variable must be a valid select method as discussed | |
| 143 in the documentation of `gnus-select-method'") | |
| 144 | |
| 145 (defvar gnus-secondary-select-methods nil | |
| 146 "*A list of secondary methods that will be used for reading news. | |
| 147 This is a list where each element is a complete select method (see | |
| 148 `gnus-select-method'). | |
| 149 | |
| 150 If, for instance, you want to read your mail with the nnml backend, | |
| 151 you could set this variable: | |
| 152 | |
| 153 (setq gnus-secondary-select-methods '((nnml \"\")))") | |
| 154 | |
| 155 (defvar gnus-secondary-servers nil | |
| 156 "*List of NNTP servers that the user can choose between interactively. | |
| 157 To make Gnus query you for a server, you have to give `gnus' a | |
| 158 non-numeric prefix - `C-u M-x gnus', in short.") | |
| 159 | |
| 160 (defvar gnus-nntp-server nil | |
| 161 "*The name of the host running the NNTP server. | |
| 162 This variable is semi-obsolete. Use the `gnus-select-method' | |
| 163 variable instead.") | |
| 164 | |
| 165 (defvar gnus-startup-file "~/.newsrc" | |
| 166 "*Your `.newsrc' file. | |
| 167 `.newsrc-SERVER' will be used instead if that exists.") | |
| 168 | |
| 169 (defvar gnus-init-file "~/.gnus" | |
| 170 "*Your Gnus elisp startup file. | |
| 171 If a file with the .el or .elc suffixes exist, it will be read | |
| 172 instead.") | |
| 173 | |
| 174 (defvar gnus-group-faq-directory | |
| 175 "/ftp@mirrors.aol.com:/pub/rtfm/usenet/" | |
| 176 "*Directory where the group FAQs are stored. | |
| 177 This will most commonly be on a remote machine, and the file will be | |
| 178 fetched by ange-ftp. | |
| 179 | |
| 180 Note that Gnus uses an aol machine as the default directory. If this | |
| 181 feels fundamentally unclean, just think of it as a way to finally get | |
| 182 something of value back from them. | |
| 183 | |
| 184 If the default site is too slow, try one of these: | |
| 185 | |
| 186 North America: ftp.uu.net /usenet/news.answers | |
| 187 mirrors.aol.com /pub/rtfm/usenet | |
| 188 ftp.seas.gwu.edu /pub/rtfm | |
| 189 rtfm.mit.edu /pub/usenet/news.answers | |
| 190 Europe: ftp.uni-paderborn.de /pub/FAQ | |
| 191 ftp.Germany.EU.net /pub/newsarchive/news.answers | |
| 192 ftp.sunet.se /pub/usenet | |
| 193 Asia: nctuccca.edu.tw /USENET/FAQ | |
| 194 hwarang.postech.ac.kr /pub/usenet/news.answers | |
| 195 ftp.hk.super.net /mirror/faqs") | |
| 196 | |
| 197 (defvar gnus-group-archive-directory | |
| 198 "/ftp@ftp.hpc.uh.edu:/pub/emacs/ding-list/" | |
| 199 "*The address of the (ding) archives.") | |
| 200 | |
| 201 (defvar gnus-group-recent-archive-directory | |
| 202 "/ftp@ftp.hpc.uh.edu:/pub/emacs/ding-list-recent/" | |
| 203 "*The address of the most recent (ding) articles.") | |
| 204 | |
| 205 (defvar gnus-default-subscribed-newsgroups nil | |
| 206 "*This variable lists what newsgroups should be subscribed the first time Gnus is used. | |
| 207 It should be a list of strings. | |
| 208 If it is `t', Gnus will not do anything special the first time it is | |
| 209 started; it'll just use the normal newsgroups subscription methods.") | |
| 210 | |
| 211 (defvar gnus-use-cross-reference t | |
| 212 "*Non-nil means that cross referenced articles will be marked as read. | |
| 213 If nil, ignore cross references. If t, mark articles as read in | |
| 214 subscribed newsgroups. If neither t nor nil, mark as read in all | |
| 215 newsgroups.") | |
| 216 | |
| 217 (defvar gnus-use-dribble-file t | |
| 218 "*Non-nil means that Gnus will use a dribble file to store user updates. | |
| 219 If Emacs should crash without saving the .newsrc files, complete | |
| 220 information can be restored from the dribble file.") | |
| 221 | |
| 222 (defvar gnus-asynchronous nil | |
| 223 "*If non-nil, Gnus will supply backends with data needed for async article fetching.") | |
| 224 | |
| 225 (defvar gnus-asynchronous-article-function nil | |
| 226 "*Function for picking articles to pre-fetch, possibly.") | |
| 227 | |
| 228 (defvar gnus-score-file-single-match-alist nil | |
| 229 "*Alist mapping regexps to lists of score files. | |
| 230 Each element of this alist should be of the form | |
| 231 (\"REGEXP\" [ \"SCORE-FILE-1\" ] [ \"SCORE-FILE-2\" ] ... ) | |
| 232 | |
| 233 If the name of a group is matched by REGEXP, the corresponding scorefiles | |
| 234 will be used for that group. | |
| 235 The first match found is used, subsequent matching entries are ignored (to | |
| 236 use multiple matches, see gnus-score-file-multiple-match-alist). | |
| 237 | |
| 238 These score files are loaded in addition to any files returned by | |
| 239 gnus-score-find-score-files-function (which see).") | |
| 240 | |
| 241 (defvar gnus-score-file-multiple-match-alist nil | |
| 242 "*Alist mapping regexps to lists of score files. | |
| 243 Each element of this alist should be of the form | |
| 244 (\"REGEXP\" [ \"SCORE-FILE-1\" ] [ \"SCORE-FILE-2\" ] ... ) | |
| 245 | |
| 246 If the name of a group is matched by REGEXP, the corresponding scorefiles | |
| 247 will be used for that group. | |
| 248 If multiple REGEXPs match a group, the score files corresponding to each | |
| 249 match will be used (for only one match to be used, see | |
| 250 gnus-score-file-single-match-alist). | |
| 251 | |
| 252 These score files are loaded in addition to any files returned by | |
| 253 gnus-score-find-score-files-function (which see).") | |
| 254 | |
| 255 | |
| 256 (defvar gnus-score-file-suffix "SCORE" | |
| 257 "*Suffix of the score files.") | |
| 258 | |
| 259 (defvar gnus-adaptive-file-suffix "ADAPT" | |
| 260 "*Suffix of the adaptive score files.") | |
| 261 | |
| 262 (defvar gnus-score-find-score-files-function 'gnus-score-find-bnews | |
| 263 "*Function used to find score files. | |
| 264 The function will be called with the group name as the argument, and | |
| 265 should return a list of score files to apply to that group. The score | |
| 266 files do not actually have to exist. | |
| 267 | |
| 268 Predefined values are: | |
| 269 | |
| 270 gnus-score-find-single: Only apply the group's own score file. | |
| 271 gnus-score-find-hierarchical: Also apply score files from parent groups. | |
| 272 gnus-score-find-bnews: Apply score files whose names matches. | |
| 273 | |
| 274 See the documentation to these functions for more information. | |
| 275 | |
| 276 This variable can also be a list of functions to be called. Each | |
| 277 function should either return a list of score files, or a list of | |
| 278 score alists.") | |
| 279 | |
| 280 (defvar gnus-score-interactive-default-score 1000 | |
| 281 "*Scoring commands will raise/lower the score with this number as the default.") | |
| 282 | |
| 283 (defvar gnus-large-newsgroup 200 | |
| 284 "*The number of articles which indicates a large newsgroup. | |
| 285 If the number of articles in a newsgroup is greater than this value, | |
| 286 confirmation is required for selecting the newsgroup.") | |
| 287 | |
| 288 ;; Suggested by Andrew Eskilsson <pi92ae@lelle.pt.hk-r.se>. | |
| 289 (defvar gnus-no-groups-message "No news is horrible news" | |
| 290 "*Message displayed by Gnus when no groups are available.") | |
| 291 | |
| 292 (defvar gnus-use-long-file-name (not (memq system-type '(usg-unix-v xenix))) | |
| 293 "*Non-nil means that the default name of a file to save articles in is the group name. | |
| 294 If it's nil, the directory form of the group name is used instead. | |
| 295 | |
| 296 If this variable is a list, and the list contains the element | |
| 297 `not-score', long file names will not be used for score files; if it | |
| 298 contains the element `not-save', long file names will not be used for | |
| 299 saving; and if it contains the element `not-kill', long file names | |
| 300 will not be used for kill files.") | |
| 301 | |
| 302 (defvar gnus-article-save-directory (or (getenv "SAVEDIR") "~/News/") | |
| 303 "*Name of the directory articles will be saved in (default \"~/News\"). | |
| 304 Initialized from the SAVEDIR environment variable.") | |
| 305 | |
| 306 (defvar gnus-kill-files-directory (or (getenv "SAVEDIR") "~/News/") | |
| 307 "*Name of the directory where kill files will be stored (default \"~/News\"). | |
| 308 Initialized from the SAVEDIR environment variable.") | |
| 309 | |
| 310 (defvar gnus-default-article-saver 'gnus-summary-save-in-rmail | |
| 311 "*A function to save articles in your favorite format. | |
| 312 The function must be interactively callable (in other words, it must | |
| 313 be an Emacs command). | |
| 314 | |
| 315 Gnus provides the following functions: | |
| 316 | |
| 317 * gnus-summary-save-in-rmail (Rmail format) | |
| 318 * gnus-summary-save-in-mail (Unix mail format) | |
| 319 * gnus-summary-save-in-folder (MH folder) | |
| 320 * gnus-summary-save-in-file (article format). | |
| 321 * gnus-summary-save-in-vm (use VM's folder format).") | |
| 322 | |
| 323 (defvar gnus-rmail-save-name (function gnus-plain-save-name) | |
| 324 "*A function generating a file name to save articles in Rmail format. | |
| 325 The function is called with NEWSGROUP, HEADERS, and optional LAST-FILE.") | |
| 326 | |
| 327 (defvar gnus-mail-save-name (function gnus-plain-save-name) | |
| 328 "*A function generating a file name to save articles in Unix mail format. | |
| 329 The function is called with NEWSGROUP, HEADERS, and optional LAST-FILE.") | |
| 330 | |
| 331 (defvar gnus-folder-save-name (function gnus-folder-save-name) | |
| 332 "*A function generating a file name to save articles in MH folder. | |
| 333 The function is called with NEWSGROUP, HEADERS, and optional LAST-FOLDER.") | |
| 334 | |
| 335 (defvar gnus-file-save-name (function gnus-numeric-save-name) | |
| 336 "*A function generating a file name to save articles in article format. | |
| 337 The function is called with NEWSGROUP, HEADERS, and optional | |
| 338 LAST-FILE.") | |
| 339 | |
| 340 (defvar gnus-split-methods nil | |
| 341 "*Variable used to suggest where articles are to be saved. | |
| 342 The syntax of this variable is the same as `nnmail-split-methods'. | |
| 343 | |
| 344 For instance, if you would like to save articles related to Gnus in | |
| 345 the file \"gnus-stuff\", and articles related to VM in \"vm-stuff\", | |
| 346 you could set this variable to something like: | |
| 347 | |
| 348 '((\"^Subject:.*gnus\\|^Newsgroups:.*gnus\" \"gnus-stuff\") | |
| 349 (\"^Subject:.*vm\\|^Xref:.*vm\" \"vm-stuff\"))") | |
| 350 | |
| 351 (defvar gnus-save-score nil | |
| 352 "*If non-nil, save group scoring info.") | |
| 353 | |
| 354 (defvar gnus-use-adaptive-scoring nil | |
| 355 "*If non-nil, use some adaptive scoring scheme.") | |
| 356 | |
| 357 (defvar gnus-use-cache nil | |
| 358 "*If non-nil, Gnus will cache (some) articles locally.") | |
| 359 | |
| 360 (defvar gnus-use-scoring t | |
| 361 "*If non-nil, enable scoring.") | |
| 362 | |
| 363 (defvar gnus-fetch-old-headers nil | |
| 364 "*Non-nil means that Gnus will try to build threads by grabbing old headers. | |
| 365 If an unread article in the group refers to an older, already read (or | |
| 366 just marked as read) article, the old article will not normally be | |
| 367 displayed in the Summary buffer. If this variable is non-nil, Gnus | |
| 368 will attempt to grab the headers to the old articles, and thereby | |
| 369 build complete threads. If it has the value `some', only enough | |
| 370 headers to connect otherwise loose threads will be displayed. | |
| 371 | |
| 372 The server has to support XOVER for any of this to work.") | |
| 373 | |
| 374 ;see gnus-cus.el | |
| 375 ;(defvar gnus-visual t | |
| 376 ; "*If non-nil, will do various highlighting. | |
| 377 ;If nil, no mouse highlights (or any other highlights) will be | |
| 378 ;performed. This might speed up Gnus some when generating large group | |
| 379 ;and summary buffers.") | |
| 380 | |
| 381 (defvar gnus-novice-user t | |
| 382 "*Non-nil means that you are a usenet novice. | |
| 383 If non-nil, verbose messages may be displayed and confirmations may be | |
| 384 required.") | |
| 385 | |
| 386 (defvar gnus-expert-user nil | |
| 387 "*Non-nil means that you will never be asked for confirmation about anything. | |
| 388 And that means *anything*.") | |
| 389 | |
| 390 (defvar gnus-verbose 7 | |
| 391 "*Integer that says how verbose Gnus should be. | |
| 392 The higher the number, the more messages Gnus will flash to say what | |
| 393 it's doing. At zero, Gnus will be totally mute; at five, Gnus will | |
| 394 display most important messages; and at ten, Gnus will keep on | |
| 395 jabbering all the time.") | |
| 396 | |
| 397 (defvar gnus-keep-same-level nil | |
| 398 "*Non-nil means that the next newsgroup after the current will be on the same level. | |
| 399 When you type, for instance, `n' after reading the last article in the | |
| 400 current newsgroup, you will go to the next newsgroup. If this variable | |
| 401 is nil, the next newsgroup will be the next from the group | |
| 402 buffer. | |
| 403 If this variable is non-nil, Gnus will either put you in the | |
| 404 next newsgroup with the same level, or, if no such newsgroup is | |
| 405 available, the next newsgroup with the lowest possible level higher | |
| 406 than the current level. | |
| 407 If this variable is `best', Gnus will make the next newsgroup the one | |
| 408 with the best level.") | |
| 409 | |
| 410 (defvar gnus-summary-make-false-root 'adopt | |
| 411 "*nil means that Gnus won't gather loose threads. | |
| 412 If the root of a thread has expired or been read in a previous | |
| 413 session, the information necessary to build a complete thread has been | |
| 414 lost. Instead of having many small sub-threads from this original thread | |
| 415 scattered all over the summary buffer, Gnus can gather them. | |
| 416 | |
| 417 If non-nil, Gnus will try to gather all loose sub-threads from an | |
| 418 original thread into one large thread. | |
| 419 | |
| 420 If this variable is non-nil, it should be one of `none', `adopt', | |
| 421 `dummy' or `empty'. | |
| 422 | |
| 423 If this variable is `none', Gnus will not make a false root, but just | |
| 424 present the sub-threads after another. | |
| 425 If this variable is `dummy', Gnus will create a dummy root that will | |
| 426 have all the sub-threads as children. | |
| 427 If this variable is `adopt', Gnus will make one of the \"children\" | |
| 428 the parent and mark all the step-children as such. | |
| 429 If this variable is `empty', the \"children\" are printed with empty | |
| 430 subject fields. (Or rather, they will be printed with a string | |
| 431 given by the `gnus-summary-same-subject' variable.)") | |
| 432 | |
| 433 (defvar gnus-summary-gather-subject-limit nil | |
| 434 "*Maximum length of subject comparisons when gathering loose threads. | |
| 435 Use nil to compare full subjects. Setting this variable to a low | |
| 436 number will help gather threads that have been corrupted by | |
| 437 newsreaders chopping off subject lines, but it might also mean that | |
| 438 unrelated articles that have subject that happen to begin with the | |
| 439 same few characters will be incorrectly gathered. | |
| 440 | |
| 441 If this variable is `fuzzy', Gnus will use a fuzzy algorithm when | |
| 442 comparing subjects.") | |
| 443 | |
| 444 ;; Added by Per Abrahamsen <amanda@iesd.auc.dk>. | |
| 445 (defvar gnus-summary-same-subject "" | |
| 446 "*String indicating that the current article has the same subject as the previous. | |
| 447 This variable will only be used if the value of | |
| 448 `gnus-summary-make-false-root' is `empty'.") | |
| 449 | |
| 450 (defvar gnus-summary-goto-unread t | |
| 451 "*If non-nil, marking commands will go to the next unread article.") | |
| 452 | |
| 453 (defvar gnus-group-goto-unread t | |
| 454 "*If non-nil, movement commands will go to the next unread and subscribed group.") | |
| 455 | |
| 456 (defvar gnus-check-new-newsgroups t | |
| 457 "*Non-nil means that Gnus will add new newsgroups at startup. | |
| 458 If this variable is `ask-server', Gnus will ask the server for new | |
| 459 groups since the last time it checked. This means that the killed list | |
| 460 is no longer necessary, so you could set `gnus-save-killed-list' to | |
| 461 nil. | |
| 462 | |
| 463 A variant is to have this variable be a list of select methods. Gnus | |
| 464 will then use the `ask-server' method on all these select methods to | |
| 465 query for new groups from all those servers. | |
| 466 | |
| 467 Eg. | |
| 468 (setq gnus-check-new-newsgroups | |
| 469 '((nntp \"some.server\") (nntp \"other.server\"))) | |
| 470 | |
| 471 If this variable is nil, then you have to tell Gnus explicitly to | |
| 472 check for new newsgroups with \\<gnus-group-mode-map>\\[gnus-find-new-newsgroups].") | |
| 473 | |
| 474 (defvar gnus-check-bogus-newsgroups nil | |
| 475 "*Non-nil means that Gnus will check and remove bogus newsgroup at startup. | |
| 476 If this variable is nil, then you have to tell Gnus explicitly to | |
| 477 check for bogus newsgroups with \\<gnus-group-mode-map>\\[gnus-group-check-bogus-groups].") | |
| 478 | |
| 479 (defvar gnus-read-active-file t | |
| 480 "*Non-nil means that Gnus will read the entire active file at startup. | |
| 481 If this variable is nil, Gnus will only know about the groups in your | |
| 482 `.newsrc' file. | |
| 483 | |
| 484 If this variable is `some', Gnus will try to only read the relevant | |
| 485 parts of the active file from the server. Not all servers support | |
| 486 this, and it might be quite slow with other servers, but this should | |
| 487 generally be faster than both the t and nil value. | |
| 488 | |
| 489 If you set this variable to nil or `some', you probably still want to | |
| 490 be told about new newsgroups that arrive. To do that, set | |
| 491 `gnus-check-new-newsgroups' to `ask-server'. This may not work | |
| 492 properly with all servers.") | |
| 493 | |
| 494 (defvar gnus-level-subscribed 5 | |
| 495 "*Groups with levels less than or equal to this variable are subscribed.") | |
| 496 | |
| 497 (defvar gnus-level-unsubscribed 7 | |
| 498 "*Groups with levels less than or equal to this variable are unsubscribed. | |
| 499 Groups with levels less than `gnus-level-subscribed', which should be | |
| 500 less than this variable, are subscribed.") | |
| 501 | |
| 502 (defvar gnus-level-zombie 8 | |
| 503 "*Groups with this level are zombie groups.") | |
| 504 | |
| 505 (defvar gnus-level-killed 9 | |
| 506 "*Groups with this level are killed.") | |
| 507 | |
| 508 (defvar gnus-level-default-subscribed 3 | |
| 509 "*New subscribed groups will be subscribed at this level.") | |
| 510 | |
| 511 (defvar gnus-level-default-unsubscribed 6 | |
| 512 "*New unsubscribed groups will be unsubscribed at this level.") | |
| 513 | |
| 514 (defvar gnus-activate-foreign-newsgroups 4 | |
| 515 "*If nil, Gnus will not check foreign newsgroups at startup. | |
| 516 If it is non-nil, it should be a number between one and nine. Foreign | |
| 517 newsgroups that have a level lower or equal to this number will be | |
| 518 activated on startup. For instance, if you want to active all | |
| 519 subscribed newsgroups, but not the rest, you'd set this variable to | |
| 520 `gnus-level-subscribed'. | |
| 521 | |
| 522 If you subscribe to lots of newsgroups from different servers, startup | |
| 523 might take a while. By setting this variable to nil, you'll save time, | |
| 524 but you won't be told how many unread articles there are in the | |
| 525 groups.") | |
| 526 | |
| 527 (defvar gnus-save-newsrc-file t | |
| 528 "*Non-nil means that Gnus will save the `.newsrc' file. | |
| 529 Gnus always saves its own startup file, which is called | |
| 530 \".newsrc.eld\". The file called \".newsrc\" is in a format that can | |
| 531 be readily understood by other newsreaders. If you don't plan on | |
| 532 using other newsreaders, set this variable to nil to save some time on | |
| 533 exit.") | |
| 534 | |
| 535 (defvar gnus-save-killed-list t | |
| 536 "*If non-nil, save the list of killed groups to the startup file. | |
| 537 This will save both time (when starting and quitting) and space (both | |
| 538 memory and disk), but it will also mean that Gnus has no record of | |
| 539 which groups are new and which are old, so the automatic new | |
| 540 newsgroups subscription methods become meaningless. You should always | |
| 541 set `gnus-check-new-newsgroups' to `ask-server' or nil if you set this | |
| 542 variable to nil.") | |
| 543 | |
| 544 (defvar gnus-interactive-catchup t | |
| 545 "*If non-nil, require your confirmation when catching up a group.") | |
| 546 | |
| 547 (defvar gnus-interactive-post t | |
| 548 "*If non-nil, group name will be asked for when posting.") | |
| 549 | |
| 550 (defvar gnus-interactive-exit t | |
| 551 "*If non-nil, require your confirmation when exiting Gnus.") | |
| 552 | |
| 553 (defvar gnus-kill-killed t | |
| 554 "*If non-nil, Gnus will apply kill files to already killed articles. | |
| 555 If it is nil, Gnus will never apply kill files to articles that have | |
| 556 already been through the scoring process, which might very well save lots | |
| 557 of time.") | |
| 558 | |
| 559 (defvar gnus-extract-address-components 'gnus-extract-address-components | |
| 560 "*Function for extracting address components from a From header. | |
| 561 Two pre-defined function exist: `gnus-extract-address-components', | |
| 562 which is the default, quite fast, and too simplistic solution, and | |
| 563 `mail-extract-address-components', which works much better, but is | |
| 564 slower.") | |
| 565 | |
| 566 (defvar gnus-summary-default-score 0 | |
| 567 "*Default article score level. | |
| 568 If this variable is nil, scoring will be disabled.") | |
| 569 | |
| 570 (defvar gnus-summary-zcore-fuzz 0 | |
| 571 "*Fuzziness factor for the zcore in the summary buffer. | |
| 572 Articles with scores closer than this to `gnus-summary-default-score' | |
| 573 will not be marked.") | |
| 574 | |
| 575 (defvar gnus-simplify-subject-fuzzy-regexp nil | |
| 576 "*Regular expression that will be removed from subject strings if | |
| 577 fuzzy subject simplification is selected.") | |
| 578 | |
| 579 (defvar gnus-group-default-list-level gnus-level-subscribed | |
| 580 "*Default listing level. | |
| 581 Ignored if `gnus-group-use-permanent-levels' is non-nil.") | |
| 582 | |
| 583 (defvar gnus-group-use-permanent-levels nil | |
| 584 "*If non-nil, once you set a level, Gnus will use this level.") | |
| 585 | |
| 586 (defvar gnus-show-mime nil | |
| 587 "*If non-nil, do mime processing of articles. | |
| 588 The articles will simply be fed to the function given by | |
| 589 `gnus-show-mime-method'.") | |
| 590 | |
| 591 (defvar gnus-strict-mime t | |
| 592 "*If nil, decode MIME header even if there is not Mime-Version field.") | |
| 593 | |
| 594 (defvar gnus-show-mime-method (function metamail-buffer) | |
| 595 "*Function to process a MIME message. | |
| 596 The function is called from the article buffer.") | |
| 597 | |
| 598 (defvar gnus-show-threads t | |
| 599 "*If non-nil, display threads in summary mode.") | |
| 600 | |
| 601 (defvar gnus-thread-hide-subtree nil | |
| 602 "*If non-nil, hide all threads initially. | |
| 603 If threads are hidden, you have to run the command | |
| 604 `gnus-summary-show-thread' by hand or use `gnus-select-article-hook' | |
| 605 to expose hidden threads.") | |
| 606 | |
| 607 (defvar gnus-thread-hide-killed t | |
| 608 "*If non-nil, hide killed threads automatically.") | |
| 609 | |
| 610 (defvar gnus-thread-ignore-subject nil | |
| 611 "*If non-nil, ignore subjects and do all threading based on the Reference header. | |
| 612 If nil, which is the default, articles that have different subjects | |
| 613 from their parents will start separate threads.") | |
| 614 | |
| 615 (defvar gnus-thread-indent-level 4 | |
| 616 "*Number that says how much each sub-thread should be indented.") | |
| 617 | |
| 618 (defvar gnus-ignored-newsgroups | |
| 619 (purecopy (mapconcat 'identity | |
| 620 '("^to\\." ; not "real" groups | |
| 621 "^[0-9. \t]+ " ; all digits in name | |
| 622 "[][\"#'()]" ; bogus characters | |
| 623 ) | |
| 624 "\\|")) | |
| 625 "*A regexp to match uninteresting newsgroups in the active file. | |
| 626 Any lines in the active file matching this regular expression are | |
| 627 removed from the newsgroup list before anything else is done to it, | |
| 628 thus making them effectively non-existent.") | |
| 629 | |
| 630 (defvar gnus-ignored-headers | |
| 631 "^Path:\\|^Posting-Version:\\|^Article-I.D.:\\|^Expires:\\|^Date-Received:\\|^References:\\|^Control:\\|^Xref:\\|^Lines:\\|^Posted:\\|^Relay-Version:\\|^Message-ID:\\|^Nf-ID:\\|^Nf-From:\\|^Approved:\\|^Sender:\\|^Received:\\|^Mail-from:" | |
| 632 "*All headers that match this regexp will be hidden. | |
| 633 If `gnus-visible-headers' is non-nil, this variable will be ignored.") | |
| 634 | |
| 635 (defvar gnus-visible-headers "^From:\\|^Newsgroups:\\|^Subject:\\|^Date:\\|^Followup-To:\\|^Reply-To:\\|^Organization:\\|^Summary:\\|^Keywords:\\|^To:\\|^Cc:" | |
| 636 "*All headers that do not match this regexp will be hidden. | |
| 637 If this variable is non-nil, `gnus-ignored-headers' will be ignored.") | |
| 638 | |
| 639 (defvar gnus-sorted-header-list | |
| 640 '("^From:" "^Subject:" "^Summary:" "^Keywords:" "^Newsgroups:" "^To:" | |
| 641 "^Cc:" "^Date:" "^Organization:") | |
| 642 "*This variable is a list of regular expressions. | |
| 643 If it is non-nil, headers that match the regular expressions will | |
| 644 be placed first in the article buffer in the sequence specified by | |
| 645 this list.") | |
| 646 | |
| 647 (defvar gnus-show-all-headers nil | |
| 648 "*If non-nil, don't hide any headers.") | |
| 649 | |
| 650 (defvar gnus-save-all-headers t | |
| 651 "*If non-nil, don't remove any headers before saving.") | |
| 652 | |
| 653 (defvar gnus-inhibit-startup-message nil | |
| 654 "*If non-nil, the startup message will not be displayed.") | |
| 655 | |
| 656 (defvar gnus-signature-separator "^-- *$" | |
| 657 "Regexp matching signature separator.") | |
| 658 | |
| 659 (defvar gnus-auto-extend-newsgroup t | |
| 660 "*If non-nil, extend newsgroup forward and backward when requested.") | |
| 661 | |
| 662 (defvar gnus-auto-select-first t | |
| 663 "*If non-nil, select the first unread article when entering a group. | |
| 664 If you want to prevent automatic selection of the first unread article | |
| 665 in some newsgroups, set the variable to nil in | |
| 666 `gnus-select-group-hook'.") | |
| 667 | |
| 668 (defvar gnus-auto-select-next t | |
| 669 "*If non-nil, offer to go to the next group from the end of the previous. | |
| 670 If the value is t and the next newsgroup is empty, Gnus will exit | |
| 671 summary mode and go back to group mode. If the value is neither nil | |
| 672 nor t, Gnus will select the following unread newsgroup. In | |
| 673 particular, if the value is the symbol `quietly', the next unread | |
| 674 newsgroup will be selected without any confirmations.") | |
| 675 | |
| 676 (defvar gnus-auto-select-same nil | |
| 677 "*If non-nil, select the next article with the same subject.") | |
| 678 | |
| 679 (defvar gnus-summary-check-current nil | |
| 680 "*If non-nil, consider the current article when moving. | |
| 681 The \"unread\" movement commands will stay on the same line if the | |
| 682 current article is unread.") | |
| 683 | |
| 684 (defvar gnus-auto-center-summary t | |
| 685 "*If non-nil, always center the current summary buffer.") | |
| 686 | |
| 687 (defvar gnus-break-pages t | |
| 688 "*If non-nil, do page breaking on articles. | |
| 689 The page delimiter is specified by the `gnus-page-delimiter' | |
| 690 variable.") | |
| 691 | |
| 692 (defvar gnus-page-delimiter "^\^L" | |
| 693 "*Regexp describing what to use as article page delimiters. | |
| 694 The default value is \"^\^L\", which is a form linefeed at the | |
| 695 beginning of a line.") | |
| 696 | |
| 697 (defvar gnus-use-full-window t | |
| 698 "*If non-nil, use the entire Emacs screen.") | |
| 699 | |
| 700 (defvar gnus-window-configuration nil | |
| 701 "Obsolete variable. See `gnus-buffer-configuration'.") | |
| 702 | |
| 703 (defvar gnus-buffer-configuration | |
| 704 '((group ([group 1.0 point] | |
| 705 (if gnus-carpal [group-carpal 4]))) | |
| 706 (summary ([summary 1.0 point] | |
| 707 (if gnus-carpal [summary-carpal 4]))) | |
| 708 (article ([summary 0.25 point] | |
| 709 (if gnus-carpal [summary-carpal 4]) | |
| 710 [article 1.0])) | |
| 711 (server ([server 1.0 point] | |
| 712 (if gnus-carpal [server-carpal 2]))) | |
| 713 (browse ([browse 1.0 point] | |
| 714 (if gnus-carpal [browse-carpal 2]))) | |
| 715 (group-mail ([mail 1.0 point])) | |
| 716 (summary-mail ([mail 1.0 point])) | |
| 717 (summary-reply ([article 0.5] | |
| 718 [mail 1.0 point])) | |
| 719 (info ([nil 1.0 point])) | |
| 720 (summary-faq ([summary 0.25] | |
| 721 [faq 1.0 point])) | |
| 722 (edit-group ([group 0.5] | |
| 723 [edit-group 1.0 point])) | |
| 724 (edit-server ([server 0.5] | |
| 725 [edit-server 1.0 point])) | |
| 726 (edit-score ([summary 0.25] | |
| 727 [edit-score 1.0 point])) | |
| 728 (post ([post 1.0 point])) | |
| 729 (reply ([article 0.5] | |
| 730 [mail 1.0 point])) | |
| 731 (mail-forward ([mail 1.0 point])) | |
| 732 (post-forward ([post 1.0 point])) | |
| 733 (reply-yank ([mail 1.0 point])) | |
| 734 (followup ([article 0.5] | |
| 735 [post 1.0 point])) | |
| 736 (followup-yank ([post 1.0 point]))) | |
| 737 "Window configuration for all possible Gnus buffers. | |
| 738 This variable is a list of lists. Each of these lists has a NAME and | |
| 739 a RULE. The NAMEs are commonsense names like `group', which names a | |
| 740 rule used when displaying the group buffer; `summary', which names a | |
| 741 rule for what happens when you enter a group and do not display an | |
| 742 article buffer; and so on. See the value of this variable for a | |
| 743 complete list of NAMEs. | |
| 744 | |
| 745 Each RULE is a list of vectors. The first element in this vector is | |
| 746 the name of the buffer to be displayed; the second element is the | |
| 747 percentage of the screen this buffer is to occupy (a number in the | |
| 748 0.0-0.99 range); the optional third element is `point', which should | |
| 749 be present to denote which buffer point is to go to after making this | |
| 750 buffer configuration.") | |
| 751 | |
| 752 (defvar gnus-window-to-buffer | |
| 753 '((group . gnus-group-buffer) | |
| 754 (summary . gnus-summary-buffer) | |
| 755 (article . gnus-article-buffer) | |
| 756 (server . gnus-server-buffer) | |
| 757 (browse . "*Gnus Browse Server*") | |
| 758 (edit-group . gnus-group-edit-buffer) | |
| 759 (edit-server . gnus-server-edit-buffer) | |
| 760 (group-carpal . gnus-carpal-group-buffer) | |
| 761 (summary-carpal . gnus-carpal-summary-buffer) | |
| 762 (server-carpal . gnus-carpal-server-buffer) | |
| 763 (browse-carpal . gnus-carpal-browse-buffer) | |
| 764 (edit-score . gnus-score-edit-buffer) | |
| 765 (mail . gnus-mail-buffer) | |
| 766 (post . gnus-post-news-buffer) | |
| 767 (faq . gnus-faq-buffer)) | |
| 768 "Mapping from short symbols to buffer names or buffer variables.") | |
| 769 | |
| 770 (defvar gnus-carpal nil | |
| 771 "*If non-nil, display clickable icons.") | |
| 772 | |
| 773 (defvar gnus-subscribe-newsgroup-method 'gnus-subscribe-zombies | |
| 774 "*Function called with a group name when new group is detected. | |
| 775 A few pre-made functions are supplied: `gnus-subscribe-randomly' | |
| 776 inserts new groups at the beginning of the list of groups; | |
| 777 `gnus-subscribe-alphabetically' inserts new groups in strict | |
| 778 alphabetic order; `gnus-subscribe-hierarchically' inserts new groups | |
| 779 in hierarchical newsgroup order; `gnus-subscribe-interactively' asks | |
| 780 for your decision.") | |
| 781 | |
| 782 ;; Suggested by a bug report by Hallvard B Furuseth. | |
| 783 ;; <h.b.furuseth@usit.uio.no>. | |
| 784 (defvar gnus-subscribe-options-newsgroup-method | |
| 785 (function gnus-subscribe-alphabetically) | |
| 786 "*This function is called to subscribe newsgroups mentioned on \"options -n\" lines. | |
| 787 If, for instance, you want to subscribe to all newsgroups in the | |
| 788 \"no\" and \"alt\" hierarchies, you'd put the following in your | |
| 789 .newsrc file: | |
| 790 | |
| 791 options -n no.all alt.all | |
| 792 | |
| 793 Gnus will the subscribe all new newsgroups in these hierarchies with | |
| 794 the subscription method in this variable.") | |
| 795 | |
| 796 (defvar gnus-subscribe-hierarchical-interactive nil | |
| 797 "*If non-nil, Gnus will offer to subscribe hierarchically. | |
| 798 When a new hierarchy appears, Gnus will ask the user: | |
| 799 | |
| 800 'alt.binaries': Do you want to subscribe to this hierarchy? ([d]ys): | |
| 801 | |
| 802 If the user pressed `d', Gnus will descend the hierarchy, `y' will | |
| 803 subscribe to all newsgroups in the hierarchy and `s' will skip this | |
| 804 hierarchy in its entirety.") | |
| 805 | |
| 806 (defvar gnus-group-sort-function 'gnus-group-sort-by-alphabet | |
| 807 "*Function used for sorting the group buffer. | |
| 808 This function will be called with group info entries as the arguments | |
| 809 for the groups to be sorted. Pre-made functions include | |
| 810 `gnus-group-sort-by-alphabet', `gnus-group-sort-by-unread' and | |
| 811 `gnus-group-sort-by-level'") | |
| 812 | |
| 813 ;; Mark variables suggested by Thomas Michanek | |
| 814 ;; <Thomas.Michanek@telelogic.se>. | |
| 815 (defvar gnus-unread-mark ? | |
| 816 "*Mark used for unread articles.") | |
| 817 (defvar gnus-ticked-mark ?! | |
| 818 "*Mark used for ticked articles.") | |
| 819 (defvar gnus-dormant-mark ?? | |
| 820 "*Mark used for dormant articles.") | |
| 821 (defvar gnus-del-mark ?r | |
| 822 "*Mark used for del'd articles.") | |
| 823 (defvar gnus-read-mark ?R | |
| 824 "*Mark used for read articles.") | |
| 825 (defvar gnus-expirable-mark ?E | |
| 826 "*Mark used for expirable articles.") | |
| 827 (defvar gnus-killed-mark ?K | |
| 828 "*Mark used for killed articles.") | |
| 829 (defvar gnus-kill-file-mark ?X | |
| 830 "*Mark used for articles killed by kill files.") | |
| 831 (defvar gnus-low-score-mark ?Y | |
| 832 "*Mark used for articles with a low score.") | |
| 833 (defvar gnus-catchup-mark ?C | |
| 834 "*Mark used for articles that are caught up.") | |
| 835 (defvar gnus-replied-mark ?A | |
| 836 "*Mark used for articles that have been replied to.") | |
| 837 (defvar gnus-process-mark ?# | |
| 838 "*Process mark.") | |
| 839 (defvar gnus-ancient-mark ?O | |
| 840 "*Mark used for ancient articles.") | |
| 841 (defvar gnus-canceled-mark ?G | |
| 842 "*Mark used for canceled articles.") | |
| 843 (defvar gnus-score-over-mark ?+ | |
| 844 "*Score mark used for articles with high scores.") | |
| 845 (defvar gnus-score-below-mark ?- | |
| 846 "*Score mark used for articles with low scores.") | |
| 847 (defvar gnus-empty-thread-mark ? | |
| 848 "*There is no thread under the article.") | |
| 849 (defvar gnus-not-empty-thread-mark ?= | |
| 850 "*There is a thread under the article.") | |
| 851 (defvar gnus-dummy-mark ?Z | |
| 852 "*This is a dummy article.") | |
| 853 | |
| 854 (defvar gnus-view-pseudo-asynchronously nil | |
| 855 "*If non-nil, Gnus will view pseudo-articles asynchronously.") | |
| 856 | |
| 857 (defvar gnus-view-pseudos nil | |
| 858 "*If `automatic', pseudo-articles will be viewed automatically. | |
| 859 If `not-confirm', pseudos will be viewed automatically, and the user | |
| 860 will not be asked to confirm the command.") | |
| 861 | |
| 862 (defvar gnus-view-pseudos-separately t | |
| 863 "*If non-nil, one pseudo-article will be created for each file to be viewed. | |
| 864 If nil, all files that use the same viewing command will be given as a | |
| 865 list of parameters to that command.") | |
| 866 | |
| 867 (defvar gnus-group-line-format "%M%S%p%5y: %(%g%)\n" | |
| 868 "*Format of group lines. | |
| 869 It works along the same lines as a normal formatting string, | |
| 870 with some simple extensions. | |
| 871 | |
| 872 %M Only marked articles (character, \"*\" or \" \") | |
| 873 %S Whether the group is subscribed (character, \"U\", \"K\", \"Z\" or \" \") | |
| 874 %L Level of subscribedness (integer) | |
| 875 %N Number of unread articles (integer) | |
| 876 %I Number of dormant articles (integer) | |
| 877 %i Number of ticked and dormant (integer) | |
| 878 %T Number of ticked articles (integer) | |
| 879 %R Number of read articles (integer) | |
| 880 %t Total number of articles (integer) | |
| 881 %y Number of unread, unticked articles (integer) | |
| 882 %G Group name (string) | |
| 883 %g Qualified group name (string) | |
| 884 %D Group description (string) | |
| 885 %s Select method (string) | |
| 886 %o Moderated group (char, \"m\") | |
| 887 %p Process mark (char) | |
| 888 %O Moderated group (string, \"(m)\" or \"\") | |
| 889 %n Select from where (string) | |
| 890 %z A string that look like `<%s:%n>' if a foreign select method is used | |
| 891 %u User defined specifier. The next character in the format string should | |
| 892 be a letter. Gnus will call the function gnus-user-format-function-X, | |
| 893 where X is the letter following %u. The function will be passed the | |
| 894 current header as argument. The function should return a string, which | |
| 895 will be inserted into the buffer just like information from any other | |
| 896 group specifier. | |
| 897 | |
| 898 Text between %( and %) will be highlighted with `gnus-mouse-face' when | |
| 899 the mouse point move inside the area. There can only be one such area. | |
| 900 | |
| 901 Note that this format specification is not always respected. For | |
| 902 reasons of efficiency, when listing killed groups, this specification | |
| 903 is ignored altogether. If the spec is changed considerably, your | |
| 904 output may end up looking strange when listing both alive and killed | |
| 905 groups. | |
| 906 | |
| 907 If you use %o or %O, reading the active file will be slower and quite | |
| 908 a bit of extra memory will be used. %D will also worsen performance. | |
| 909 Also note that if you change the format specification to include any | |
| 910 of these specs, you must probably re-start Gnus to see them go into | |
| 911 effect.") | |
| 912 | |
| 913 (defvar gnus-summary-line-format "%U%R%z%I%(%[%4L: %-20,20n%]%) %s\n" | |
| 914 "*The format specification of the lines in the summary buffer. | |
| 915 | |
| 916 It works along the same lines as a normal formatting string, | |
| 917 with some simple extensions. | |
| 918 | |
| 919 %N Article number, left padded with spaces (string) | |
| 920 %S Subject (string) | |
| 921 %s Subject if it is at the root of a thread, and \"\" otherwise (string) | |
| 922 %n Name of the poster (string) | |
| 923 %a Extracted name of the poster (string) | |
| 924 %A Extracted address of the poster (string) | |
| 925 %F Contents of the From: header (string) | |
| 926 %x Contents of the Xref: header (string) | |
| 927 %D Date of the article (string) | |
| 928 %d Date of the article (string) in DD-MMM format | |
| 929 %M Message-id of the article (string) | |
| 930 %r References of the article (string) | |
| 931 %c Number of characters in the article (integer) | |
| 932 %L Number of lines in the article (integer) | |
| 933 %I Indentation based on thread level (a string of spaces) | |
| 934 %T A string with two possible values: 80 spaces if the article | |
| 935 is on thread level two or larger and 0 spaces on level one | |
| 936 %R \"A\" if this article has been replied to, \" \" otherwise (character) | |
| 937 %U Status of this article (character, \"R\", \"K\", \"-\" or \" \") | |
| 938 %[ Opening bracket (character, \"[\" or \"<\") | |
| 939 %] Closing bracket (character, \"]\" or \">\") | |
| 940 %> Spaces of length thread-level (string) | |
| 941 %< Spaces of length (- 20 thread-level) (string) | |
| 942 %i Article score (number) | |
| 943 %z Article zcore (character) | |
| 944 %t Number of articles under the current thread (number). | |
| 945 %e Whether the thread is empty or not (character). | |
| 946 %u User defined specifier. The next character in the format string should | |
| 947 be a letter. Gnus will call the function gnus-user-format-function-X, | |
| 948 where X is the letter following %u. The function will be passed the | |
| 949 current header as argument. The function should return a string, which | |
| 950 will be inserted into the summary just like information from any other | |
| 951 summary specifier. | |
| 952 | |
| 953 Text between %( and %) will be highlighted with `gnus-mouse-face' | |
| 954 when the mouse point is placed inside the area. There can only be one | |
| 955 such area. | |
| 956 | |
| 957 The %U (status), %R (replied) and %z (zcore) specs have to be handled | |
| 958 with care. For reasons of efficiency, Gnus will compute what column | |
| 959 these characters will end up in, and \"hard-code\" that. This means that | |
| 960 it is illegal to have these specs after a variable-length spec. Well, | |
| 961 you might not be arrested, but your summary buffer will look strange, | |
| 962 which is bad enough. | |
| 963 | |
| 964 The smart choice is to have these specs as for to the left as | |
| 965 possible. | |
| 966 | |
| 967 This restriction may disappear in later versions of Gnus.") | |
| 968 | |
| 969 (defvar gnus-summary-dummy-line-format "* : : %S\n" | |
| 970 "*The format specification for the dummy roots in the summary buffer. | |
| 971 It works along the same lines as a normal formatting string, | |
| 972 with some simple extensions. | |
| 973 | |
| 974 %S The subject") | |
| 975 | |
| 976 (defvar gnus-summary-mode-line-format "Gnus %G/%A %Z" | |
| 977 "*The format specification for the summary mode line.") | |
| 978 | |
| 979 (defvar gnus-article-mode-line-format "Gnus %G/%A %S" | |
| 980 "*The format specification for the article mode line.") | |
| 981 | |
| 982 (defvar gnus-group-mode-line-format "Gnus List of groups {%M:%S} " | |
| 983 "*The format specification for the group mode line.") | |
| 984 | |
| 985 (defvar gnus-valid-select-methods | |
| 986 '(("nntp" post address prompt-address) | |
| 987 ("nnspool" post) | |
| 988 ("nnvirtual" none virtual prompt-address) | |
| 989 ("nnmbox" mail respool) | |
| 990 ("nnml" mail respool) | |
| 991 ("nnmh" mail respool) | |
| 992 ("nndir" none prompt-address address) | |
| 993 ("nneething" none prompt-address) | |
| 994 ("nndigest" none) | |
| 995 ("nndoc" none prompt-address) | |
| 996 ("nnbabyl" mail respool) | |
| 997 ("nnkiboze" post virtual) | |
| 998 ;;("nnsoup" post) | |
| 999 ("nnfolder" mail respool)) | |
| 1000 "An alist of valid select methods. | |
| 1001 The first element of each list lists should be a string with the name | |
| 1002 of the select method. The other elements may be be the category of | |
| 1003 this method (ie. `post', `mail', `none' or whatever) or other | |
| 1004 properties that this method has (like being respoolable). | |
| 1005 If you implement a new select method, all you should have to change is | |
| 1006 this variable. I think.") | |
| 1007 | |
| 1008 (defvar gnus-updated-mode-lines '(group article summary) | |
| 1009 "*List of buffers that should update their mode lines. | |
| 1010 The list may contain the symbols `group', `article' and `summary'. If | |
| 1011 the corresponding symbol is present, Gnus will keep that mode line | |
| 1012 updated with information that may be pertinent. | |
| 1013 If this variable is nil, screen refresh may be quicker.") | |
| 1014 | |
| 1015 ;; Added by Keinonen Kari <kk85613@cs.tut.fi>. | |
| 1016 (defvar gnus-mode-non-string-length 21 | |
| 1017 "*Max length of mode-line non-string contents. | |
| 1018 If this is nil, Gnus will take space as is needed, leaving the rest | |
| 1019 of the modeline intact.") | |
| 1020 | |
| 1021 ;see gnus-cus.el | |
| 1022 ;(defvar gnus-mouse-face 'highlight | |
| 1023 ; "*Face used for mouse highlighting in Gnus. | |
| 1024 ;No mouse highlights will be done if `gnus-visual' is nil.") | |
| 1025 | |
| 1026 (defvar gnus-summary-mark-below nil | |
| 1027 "*Mark all articles with a score below this variable as read. | |
| 1028 This variable is local to each summary buffer and usually set by the | |
| 1029 score file.") | |
| 1030 | |
| 1031 (defvar gnus-thread-sort-functions '(gnus-thread-sort-by-number) | |
| 1032 "*List of functions used for sorting threads in the summary buffer. | |
| 1033 By default, threads are sorted by article number. | |
| 1034 | |
| 1035 Each function takes two threads and return non-nil if the first thread | |
| 1036 should be sorted before the other. If you use more than one function, | |
| 1037 the primary sort function should be the last. | |
| 1038 | |
| 1039 Ready-mady functions include `gnus-thread-sort-by-number', | |
| 1040 `gnus-thread-sort-by-author', `gnus-thread-sort-by-subject', | |
| 1041 `gnus-thread-sort-by-date', `gnus-thread-sort-by-score' and | |
| 1042 `gnus-thread-sort-by-total-score' (see `gnus-thread-score-function').") | |
| 1043 | |
| 1044 (defvar gnus-thread-score-function '+ | |
| 1045 "*Function used for calculating the total score of a thread. | |
| 1046 | |
| 1047 The function is called with the scores of the article and each | |
| 1048 subthread and should then return the score of the thread. | |
| 1049 | |
| 1050 Some functions you can use are `+', `max', or `min'.") | |
| 1051 | |
| 1052 (defvar gnus-options-subscribe nil | |
| 1053 "*All new groups matching this regexp will be subscribed unconditionally. | |
| 1054 Note that this variable deals only with new newsgroups. This variable | |
| 1055 does not affect old newsgroups.") | |
| 1056 | |
| 1057 (defvar gnus-options-not-subscribe nil | |
| 1058 "*All new groups matching this regexp will be ignored. | |
| 1059 Note that this variable deals only with new newsgroups. This variable | |
| 1060 does not affect old (already subscribed) newsgroups.") | |
| 1061 | |
| 1062 (defvar gnus-auto-expirable-newsgroups nil | |
| 1063 "*Groups in which to automatically mark read articles as expirable. | |
| 1064 If non-nil, this should be a regexp that should match all groups in | |
| 1065 which to perform auto-expiry. This only makes sense for mail groups.") | |
| 1066 | |
| 1067 (defvar gnus-hidden-properties '(invisible t intangible t) | |
| 1068 "Property list to use for hiding text.") | |
| 1069 | |
| 1070 (defvar gnus-modtime-botch nil | |
| 1071 "*Non-nil means .newsrc should be deleted prior to save. Its use is | |
| 1072 due to the bogus appearance that .newsrc was modified on disc.") | |
| 1073 | |
| 1074 ;; Hooks. | |
| 1075 | |
| 1076 (defvar gnus-group-mode-hook nil | |
| 1077 "*A hook for Gnus group mode.") | |
| 1078 | |
| 1079 (defvar gnus-summary-mode-hook nil | |
| 1080 "*A hook for Gnus summary mode. | |
| 1081 This hook is run before any variables are set in the summary buffer.") | |
| 1082 | |
| 1083 (defvar gnus-article-mode-hook nil | |
| 1084 "*A hook for Gnus article mode.") | |
| 1085 | |
| 1086 (defun gnus-summary-prepare-exit-hook nil | |
| 1087 "*A hook called when preparing to exit from the summary buffer. | |
| 1088 It calls `gnus-summary-expire-articles' by default.") | |
| 1089 (add-hook 'gnus-summary-prepare-exit-hook 'gnus-summary-expire-articles) | |
| 1090 | |
| 1091 (defun gnus-summary-exit-hook nil | |
| 1092 "*A hook called on exit from the summary buffer.") | |
| 1093 | |
| 1094 (defvar gnus-open-server-hook nil | |
| 1095 "*A hook called just before opening connection to the news server.") | |
| 1096 | |
| 1097 (defvar gnus-load-hook nil | |
| 1098 "*A hook run while Gnus is loaded.") | |
| 1099 | |
| 1100 (defvar gnus-startup-hook nil | |
| 1101 "*A hook called at startup. | |
| 1102 This hook is called after Gnus is connected to the NNTP server.") | |
| 1103 | |
| 1104 (defvar gnus-get-new-news-hook nil | |
| 1105 "*A hook run just before Gnus checks for new news.") | |
| 1106 | |
| 1107 (defvar gnus-group-prepare-function 'gnus-group-prepare-flat | |
| 1108 "*A function that is called to generate the group buffer. | |
| 1109 The function is called with three arguments: The first is a number; | |
| 1110 all group with a level less or equal to that number should be listed, | |
| 1111 if the second is non-nil, empty groups should also be displayed. If | |
| 1112 the third is non-nil, it is a number. No groups with a level lower | |
| 1113 than this number should be displayed. | |
| 1114 | |
| 1115 The only current function implemented is `gnus-group-prepare-flat'.") | |
| 1116 | |
| 1117 (defvar gnus-group-prepare-hook nil | |
| 1118 "*A hook called after the group buffer has been generated. | |
| 1119 If you want to modify the group buffer, you can use this hook.") | |
| 1120 | |
| 1121 (defvar gnus-summary-prepare-hook nil | |
| 1122 "*A hook called after the summary buffer has been generated. | |
| 1123 If you want to modify the summary buffer, you can use this hook.") | |
| 1124 | |
| 1125 (defvar gnus-article-prepare-hook nil | |
| 1126 "*A hook called after an article has been prepared in the article buffer. | |
| 1127 If you want to run a special decoding program like nkf, use this hook.") | |
| 1128 | |
| 1129 ;(defvar gnus-article-display-hook nil | |
| 1130 ; "*A hook called after the article is displayed in the article buffer. | |
| 1131 ;The hook is designed to change the contents of the article | |
| 1132 ;buffer. Typical functions that this hook may contain are | |
| 1133 ;`gnus-article-hide-headers' (hide selected headers), | |
| 1134 ;`gnus-article-maybe-highlight' (perform fancy article highlighting), | |
| 1135 ;`gnus-article-hide-signature' (hide signature) and | |
| 1136 ;`gnus-article-treat-overstrike' (turn \"^H_\" into bold characters).") | |
| 1137 ;(add-hook 'gnus-article-display-hook 'gnus-article-hide-headers-if-wanted) | |
| 1138 ;(add-hook 'gnus-article-display-hook 'gnus-article-treat-overstrike) | |
| 1139 ;(add-hook 'gnus-article-display-hook 'gnus-article-maybe-highlight) | |
| 1140 | |
| 1141 (defvar gnus-article-x-face-command | |
| 1142 "{ echo '/* Width=48, Height=48 */'; uncompface; } | icontopbm | xv -quit -" | |
| 1143 "String or function to be executed to display an X-Face header. | |
| 1144 If it is a string, the command will be executed in a sub-shell | |
| 1145 asynchronously. The compressed face will be piped to this command.") | |
| 1146 | |
| 1147 (defvar gnus-article-x-face-too-ugly nil | |
| 1148 "Regexp matching posters whose face shouldn't be shown automatically.") | |
| 1149 | |
| 1150 (defvar gnus-select-group-hook nil | |
| 1151 "*A hook called when a newsgroup is selected. | |
| 1152 | |
| 1153 If you'd like to simplify subjects like the | |
| 1154 `gnus-summary-next-same-subject' command does, you can use the | |
| 1155 following hook: | |
| 1156 | |
| 1157 (setq gnus-select-group-hook | |
| 1158 (list | |
| 1159 (lambda () | |
| 1160 (mapcar (lambda (header) | |
| 1161 (mail-header-set-subject | |
| 1162 header | |
| 1163 (gnus-simplify-subject | |
| 1164 (mail-header-subject header) 're-only))) | |
| 1165 gnus-newsgroup-headers))))") | |
| 1166 | |
| 1167 (defvar gnus-select-article-hook | |
| 1168 '(gnus-summary-show-thread) | |
| 1169 "*A hook called when an article is selected. | |
| 1170 The default hook shows conversation thread subtrees of the selected | |
| 1171 article automatically using `gnus-summary-show-thread'.") | |
| 1172 | |
| 1173 (defvar gnus-apply-kill-hook '(gnus-apply-kill-file) | |
| 1174 "*A hook called to apply kill files to a group. | |
| 1175 This hook is intended to apply a kill file to the selected newsgroup. | |
| 1176 The function `gnus-apply-kill-file' is called by default. | |
| 1177 | |
| 1178 Since a general kill file is too heavy to use only for a few | |
| 1179 newsgroups, I recommend you to use a lighter hook function. For | |
| 1180 example, if you'd like to apply a kill file to articles which contains | |
| 1181 a string `rmgroup' in subject in newsgroup `control', you can use the | |
| 1182 following hook: | |
| 1183 | |
| 1184 (setq gnus-apply-kill-hook | |
| 1185 (list | |
| 1186 (lambda () | |
| 1187 (cond ((string-match \"control\" gnus-newsgroup-name) | |
| 1188 (gnus-kill \"Subject\" \"rmgroup\") | |
| 1189 (gnus-expunge \"X\"))))))") | |
| 1190 | |
| 1191 (defvar gnus-visual-mark-article-hook | |
| 1192 (list 'gnus-highlight-selected-summary) | |
| 1193 "*Hook run after selecting an article in the summary buffer. | |
| 1194 It is meant to be used for highlighting the article in some way. It | |
| 1195 is not run if `gnus-visual' is nil.") | |
| 1196 | |
| 1197 (defvar gnus-exit-group-hook nil | |
| 1198 "*A hook called when exiting (not quitting) summary mode.") | |
| 1199 | |
| 1200 (defvar gnus-suspend-gnus-hook nil | |
| 1201 "*A hook called when suspending (not exiting) Gnus.") | |
| 1202 | |
| 1203 (defvar gnus-exit-gnus-hook nil | |
| 1204 "*A hook called when exiting Gnus.") | |
| 1205 | |
| 1206 (defvar gnus-save-newsrc-hook nil | |
| 1207 "*A hook called when saving the newsrc file.") | |
| 1208 | |
| 1209 (defvar gnus-summary-update-hook | |
| 1210 (list 'gnus-summary-highlight-line) | |
| 1211 "*A hook called when a summary line is changed. | |
| 1212 The hook will not be called if `gnus-visual' is nil. | |
| 1213 | |
| 1214 The default function `gnus-summary-highlight-line' will | |
| 1215 highlight the line according to the `gnus-summary-highlight' | |
| 1216 variable.") | |
| 1217 | |
| 1218 (defvar gnus-mark-article-hook (list 'gnus-summary-mark-unread-as-read) | |
| 1219 "*A hook called when an article is selected for the first time. | |
| 1220 The hook is intended to mark an article as read (or unread) | |
| 1221 automatically when it is selected.") | |
| 1222 | |
| 1223 ;; Remove any hilit infestation. | |
| 1224 (add-hook 'gnus-startup-hook | |
| 1225 (lambda () | |
| 1226 (remove-hook 'gnus-summary-prepare-hook | |
| 1227 'hilit-rehighlight-buffer-quietly) | |
| 1228 (remove-hook 'gnus-summary-prepare-hook 'hilit-install-line-hooks) | |
| 1229 (setq gnus-mark-article-hook '(gnus-summary-mark-unread-as-read)) | |
| 1230 (remove-hook 'gnus-article-prepare-hook | |
| 1231 'hilit-rehighlight-buffer-quietly))) | |
| 1232 | |
| 1233 | |
| 1234 | |
| 1235 ;; Internal variables | |
| 1236 | |
| 1237 ;; Avoid highlighting in kill files. | |
| 1238 (defvar gnus-summary-inhibit-highlight nil) | |
| 1239 (defvar gnus-newsgroup-selected-overlay nil) | |
| 1240 | |
| 1241 (defvar gnus-article-mode-map nil) | |
| 1242 (defvar gnus-dribble-buffer nil) | |
| 1243 (defvar gnus-headers-retrieved-by nil) | |
| 1244 (defvar gnus-article-reply nil) | |
| 1245 (defvar gnus-override-method nil) | |
| 1246 (defvar gnus-article-check-size nil) | |
| 1247 | |
| 1248 (defvar gnus-current-score-file nil) | |
| 1249 (defvar gnus-internal-global-score-files nil) | |
| 1250 (defvar gnus-score-file-list nil) | |
| 1251 (defvar gnus-scores-exclude-files nil) | |
| 1252 | |
| 1253 (defvar gnus-current-move-group nil) | |
| 1254 | |
| 1255 (defvar gnus-newsgroup-dependencies nil) | |
| 1256 (defvar gnus-newsgroup-threads nil) | |
| 1257 (defvar gnus-newsgroup-async nil) | |
| 1258 (defconst gnus-group-edit-buffer "*Gnus edit newsgroup*") | |
| 1259 | |
| 1260 (defvar gnus-newsgroup-adaptive nil) | |
| 1261 | |
| 1262 (defvar gnus-summary-display-table nil) | |
| 1263 | |
| 1264 (defconst gnus-group-line-format-alist | |
| 1265 (list (list ?M 'marked ?c) | |
| 1266 (list ?S 'subscribed ?c) | |
| 1267 (list ?L 'level ?d) | |
| 1268 (list ?N 'number ?s) | |
| 1269 (list ?I 'number-of-dormant ?d) | |
| 1270 (list ?T 'number-of-ticked ?d) | |
| 1271 (list ?R 'number-of-read ?s) | |
| 1272 (list ?t 'number-total ?d) | |
| 1273 (list ?y 'number-of-unread-unticked ?s) | |
| 1274 (list ?i 'number-of-ticked-and-dormant ?d) | |
| 1275 (list ?g 'group ?s) | |
| 1276 (list ?G 'qualified-group ?s) | |
| 1277 (list ?D 'newsgroup-description ?s) | |
| 1278 (list ?o 'moderated ?c) | |
| 1279 (list ?O 'moderated-string ?s) | |
| 1280 (list ?p 'process-marked ?c) | |
| 1281 (list ?s 'news-server ?s) | |
| 1282 (list ?n 'news-method ?s) | |
| 1283 (list ?z 'news-method-string ?s) | |
| 1284 (list ?u 'user-defined ?s))) | |
| 1285 | |
| 1286 (defconst gnus-summary-line-format-alist | |
| 1287 (list (list ?N 'number ?d) | |
| 1288 (list ?S 'subject ?s) | |
| 1289 (list ?s 'subject-or-nil ?s) | |
| 1290 (list ?n 'name ?s) | |
| 1291 (list ?A '(car (cdr (funcall gnus-extract-address-components from))) | |
| 1292 ?s) | |
| 1293 (list ?a '(or (car (funcall gnus-extract-address-components from)) | |
| 1294 from) ?s) | |
| 1295 (list ?F 'from ?s) | |
| 1296 (list ?x (macroexpand '(mail-header-xref header)) ?s) | |
| 1297 (list ?D (macroexpand '(mail-header-date header)) ?s) | |
| 1298 (list ?d '(gnus-dd-mmm (mail-header-date header)) ?s) | |
| 1299 (list ?M (macroexpand '(mail-header-id header)) ?s) | |
| 1300 (list ?r (macroexpand '(mail-header-references header)) ?s) | |
| 1301 (list ?c '(or (mail-header-chars header) 0) ?d) | |
| 1302 (list ?L 'lines ?d) | |
| 1303 (list ?I 'indentation ?s) | |
| 1304 (list ?T '(if (= level 0) "" (make-string (frame-width) ? )) ?s) | |
| 1305 (list ?R 'replied ?c) | |
| 1306 (list ?\[ 'opening-bracket ?c) | |
| 1307 (list ?\] 'closing-bracket ?c) | |
| 1308 (list ?\> '(make-string level ? ) ?s) | |
| 1309 (list ?\< '(make-string (max 0 (- 20 level)) ? ) ?s) | |
| 1310 (list ?i 'score ?d) | |
| 1311 (list ?z 'score-char ?c) | |
| 1312 (list ?U 'unread ?c) | |
| 1313 (list ?t '(gnus-summary-number-of-articles-in-thread | |
| 1314 (and (boundp 'thread) (car thread))) | |
| 1315 ?d) | |
| 1316 (list ?e '(gnus-summary-number-of-articles-in-thread | |
| 1317 (and (boundp 'thread) (car thread)) t) | |
| 1318 ?c) | |
| 1319 (list ?u 'user-defined ?s)) | |
| 1320 "An alist of format specifications that can appear in summary lines, | |
| 1321 and what variables they correspond with, along with the type of the | |
| 1322 variable (string, integer, character, etc).") | |
| 1323 | |
| 1324 (defconst gnus-summary-dummy-line-format-alist | |
| 1325 (list (list ?S 'subject ?s) | |
| 1326 (list ?N 'number ?d) | |
| 1327 (list ?u 'user-defined ?s))) | |
| 1328 | |
| 1329 (defconst gnus-summary-mode-line-format-alist | |
| 1330 (list (list ?G 'group-name ?s) | |
| 1331 (list ?g '(gnus-short-group-name group-name) ?s) | |
| 1332 (list ?A 'article-number ?d) | |
| 1333 (list ?Z 'unread-and-unselected ?s) | |
| 1334 (list ?V 'gnus-version ?s) | |
| 1335 (list ?U 'unread ?d) | |
| 1336 (list ?S 'subject ?s) | |
| 1337 (list ?e 'unselected ?d) | |
| 1338 (list ?u 'user-defined ?s) | |
| 1339 (list ?s '(gnus-current-score-file-nondirectory) ?s))) | |
| 1340 | |
| 1341 (defconst gnus-group-mode-line-format-alist | |
| 1342 (list (list ?S 'news-server ?s) | |
| 1343 (list ?M 'news-method ?s) | |
| 1344 (list ?u 'user-defined ?s))) | |
| 1345 | |
| 1346 (defvar gnus-have-read-active-file nil) | |
| 1347 | |
| 1348 (defconst gnus-maintainer | |
| 1349 "gnus-bug@ifi.uio.no (The Gnus Bugfixing Girls + Boys)" | |
| 1350 "The mail address of the Gnus maintainers.") | |
| 1351 | |
| 1352 (defconst gnus-version "Gnus v5.1" | |
| 1353 "Version number for this version of Gnus.") | |
| 1354 | |
| 1355 (defvar gnus-info-nodes | |
| 1356 '((gnus-group-mode "(gnus)The Group Buffer") | |
| 1357 (gnus-summary-mode "(gnus)The Summary Buffer") | |
| 1358 (gnus-article-mode "(gnus)The Article Buffer")) | |
| 1359 "Assoc list of major modes and related Info nodes.") | |
| 1360 | |
| 1361 (defvar gnus-group-buffer "*Group*") | |
| 1362 (defvar gnus-summary-buffer "*Summary*") | |
| 1363 (defvar gnus-article-buffer "*Article*") | |
| 1364 (defvar gnus-server-buffer "*Server*") | |
| 1365 | |
| 1366 (defvar gnus-work-buffer " *gnus work*") | |
| 1367 | |
| 1368 (defvar gnus-buffer-list nil | |
| 1369 "Gnus buffers that should be killed on exit.") | |
| 1370 | |
| 1371 (defvar gnus-server-alist nil | |
| 1372 "List of available servers.") | |
| 1373 | |
| 1374 (defvar gnus-variable-list | |
| 1375 '(gnus-newsrc-options gnus-newsrc-options-n | |
| 1376 gnus-newsrc-last-checked-date | |
| 1377 gnus-newsrc-alist gnus-server-alist | |
| 1378 gnus-killed-list gnus-zombie-list) | |
| 1379 "Gnus variables saved in the quick startup file.") | |
| 1380 | |
| 1381 (defvar gnus-overload-functions | |
| 1382 '((news-inews gnus-inews-news "rnewspost")) | |
| 1383 "Functions overloaded by gnus. | |
| 1384 It is a list of `(original overload &optional file)'.") | |
| 1385 | |
| 1386 (defvar gnus-newsrc-options nil | |
| 1387 "Options line in the .newsrc file.") | |
| 1388 | |
| 1389 (defvar gnus-newsrc-options-n nil | |
| 1390 "List of regexps representing groups to be subscribed/ignored unconditionally.") | |
| 1391 | |
| 1392 (defvar gnus-newsrc-last-checked-date nil | |
| 1393 "Date Gnus last asked server for new newsgroups.") | |
| 1394 | |
| 1395 (defvar gnus-newsrc-alist nil | |
| 1396 "Assoc list of read articles. | |
| 1397 gnus-newsrc-hashtb should be kept so that both hold the same information.") | |
| 1398 | |
| 1399 (defvar gnus-newsrc-hashtb nil | |
| 1400 "Hashtable of gnus-newsrc-alist.") | |
| 1401 | |
| 1402 (defvar gnus-killed-list nil | |
| 1403 "List of killed newsgroups.") | |
| 1404 | |
| 1405 (defvar gnus-killed-hashtb nil | |
| 1406 "Hash table equivalent of gnus-killed-list.") | |
| 1407 | |
| 1408 (defvar gnus-zombie-list nil | |
| 1409 "List of almost dead newsgroups.") | |
| 1410 | |
| 1411 (defvar gnus-description-hashtb nil | |
| 1412 "Descriptions of newsgroups.") | |
| 1413 | |
| 1414 (defvar gnus-list-of-killed-groups nil | |
| 1415 "List of newsgroups that have recently been killed by the user.") | |
| 1416 | |
| 1417 (defvar gnus-active-hashtb nil | |
| 1418 "Hashtable of active articles.") | |
| 1419 | |
| 1420 (defvar gnus-moderated-list nil | |
| 1421 "List of moderated newsgroups.") | |
| 1422 | |
| 1423 (defvar gnus-group-marked nil) | |
| 1424 | |
| 1425 (defvar gnus-current-startup-file nil | |
| 1426 "Startup file for the current host.") | |
| 1427 | |
| 1428 (defvar gnus-last-search-regexp nil | |
| 1429 "Default regexp for article search command.") | |
| 1430 | |
| 1431 (defvar gnus-last-shell-command nil | |
| 1432 "Default shell command on article.") | |
| 1433 | |
| 1434 (defvar gnus-current-select-method nil | |
| 1435 "The current method for selecting a newsgroup.") | |
| 1436 | |
| 1437 (defvar gnus-group-list-mode nil) | |
| 1438 | |
| 1439 (defvar gnus-article-internal-prepare-hook nil) | |
| 1440 | |
| 1441 (defvar gnus-newsgroup-name nil) | |
| 1442 (defvar gnus-newsgroup-begin nil) | |
| 1443 (defvar gnus-newsgroup-end nil) | |
| 1444 (defvar gnus-newsgroup-last-rmail nil) | |
| 1445 (defvar gnus-newsgroup-last-mail nil) | |
| 1446 (defvar gnus-newsgroup-last-folder nil) | |
| 1447 (defvar gnus-newsgroup-last-file nil) | |
| 1448 (defvar gnus-newsgroup-auto-expire nil) | |
| 1449 (defvar gnus-newsgroup-active nil) | |
| 1450 | |
| 1451 (defvar gnus-newsgroup-unreads nil | |
| 1452 "List of unread articles in the current newsgroup.") | |
| 1453 | |
| 1454 (defvar gnus-newsgroup-unselected nil | |
| 1455 "List of unselected unread articles in the current newsgroup.") | |
| 1456 | |
| 1457 (defvar gnus-newsgroup-reads nil | |
| 1458 "Alist of read articles and article marks in the current newsgroup.") | |
| 1459 | |
| 1460 (defvar gnus-newsgroup-marked nil | |
| 1461 "List of ticked articles in the current newsgroup (a subset of unread art).") | |
| 1462 | |
| 1463 (defvar gnus-newsgroup-killed nil | |
| 1464 "List of ranges of articles that have been through the scoring process.") | |
| 1465 | |
| 1466 (defvar gnus-newsgroup-kill-headers nil) | |
| 1467 | |
| 1468 (defvar gnus-newsgroup-replied nil | |
| 1469 "List of articles that have been replied to in the current newsgroup.") | |
| 1470 | |
| 1471 (defvar gnus-newsgroup-expirable nil | |
| 1472 "List of articles in the current newsgroup that can be expired.") | |
| 1473 | |
| 1474 (defvar gnus-newsgroup-processable nil | |
| 1475 "List of articles in the current newsgroup that can be processed.") | |
| 1476 | |
| 1477 (defvar gnus-newsgroup-bookmarks nil | |
| 1478 "List of articles in the current newsgroup that have bookmarks.") | |
| 1479 | |
| 1480 (defvar gnus-newsgroup-dormant nil | |
| 1481 "List of dormant articles in the current newsgroup.") | |
| 1482 | |
| 1483 (defvar gnus-newsgroup-scored nil | |
| 1484 "List of scored articles in the current newsgroup.") | |
| 1485 | |
| 1486 (defvar gnus-newsgroup-headers nil | |
| 1487 "List of article headers in the current newsgroup.") | |
| 1488 (defvar gnus-newsgroup-headers-hashtb-by-number nil) | |
| 1489 | |
| 1490 (defvar gnus-newsgroup-ancient nil | |
| 1491 "List of `gnus-fetch-old-headers' articles in the current newsgroup.") | |
| 1492 | |
| 1493 (defvar gnus-current-article nil) | |
| 1494 (defvar gnus-article-current nil) | |
| 1495 (defvar gnus-current-headers nil) | |
| 1496 (defvar gnus-have-all-headers nil) | |
| 1497 (defvar gnus-last-article nil) | |
| 1498 (defvar gnus-newsgroup-history nil) | |
| 1499 (defvar gnus-current-kill-article nil) | |
| 1500 | |
| 1501 ;; Save window configuration. | |
| 1502 (defvar gnus-prev-winconf nil) | |
| 1503 | |
| 1504 ;; Format specs | |
| 1505 (defvar gnus-summary-line-format-spec nil) | |
| 1506 (defvar gnus-summary-dummy-line-format-spec nil) | |
| 1507 (defvar gnus-group-line-format-spec nil) | |
| 1508 (defvar gnus-summary-mode-line-format-spec nil) | |
| 1509 (defvar gnus-article-mode-line-format-spec nil) | |
| 1510 (defvar gnus-group-mode-line-format-spec nil) | |
| 1511 (defvar gnus-summary-mark-positions nil) | |
| 1512 (defvar gnus-group-mark-positions nil) | |
| 1513 | |
| 1514 (defvar gnus-summary-expunge-below nil) | |
| 1515 (defvar gnus-reffed-article-number nil) | |
| 1516 | |
| 1517 ; Let the byte-compiler know that we know about this variable. | |
| 1518 (defvar rmail-default-rmail-file) | |
| 1519 | |
| 1520 (defvar gnus-cache-removeable-articles nil) | |
| 1521 | |
| 1522 (defconst gnus-summary-local-variables | |
| 1523 '(gnus-newsgroup-name | |
| 1524 gnus-newsgroup-begin gnus-newsgroup-end | |
| 1525 gnus-newsgroup-last-rmail gnus-newsgroup-last-mail | |
| 1526 gnus-newsgroup-last-folder gnus-newsgroup-last-file | |
| 1527 gnus-newsgroup-auto-expire gnus-newsgroup-unreads | |
| 1528 gnus-newsgroup-unselected gnus-newsgroup-marked | |
| 1529 gnus-newsgroup-reads | |
| 1530 gnus-newsgroup-replied gnus-newsgroup-expirable | |
| 1531 gnus-newsgroup-processable gnus-newsgroup-killed | |
| 1532 gnus-newsgroup-bookmarks gnus-newsgroup-dormant | |
| 1533 gnus-newsgroup-headers gnus-newsgroup-headers-hashtb-by-number | |
| 1534 gnus-current-article gnus-current-headers gnus-have-all-headers | |
| 1535 gnus-last-article gnus-article-internal-prepare-hook | |
| 1536 gnus-newsgroup-dependencies gnus-newsgroup-selected-overlay | |
| 1537 gnus-newsgroup-scored gnus-newsgroup-kill-headers | |
| 1538 gnus-newsgroup-threads gnus-newsgroup-async | |
| 1539 gnus-score-alist gnus-current-score-file gnus-summary-expunge-below | |
| 1540 gnus-summary-mark-below gnus-newsgroup-active gnus-scores-exclude-files | |
| 1541 gnus-newsgroup-history gnus-newsgroup-ancient | |
| 1542 (gnus-newsgroup-adaptive . gnus-use-adaptive-scoring) | |
| 1543 gnus-cache-removeable-articles) | |
| 1544 "Variables that are buffer-local to the summary buffers.") | |
| 1545 | |
| 1546 (defconst gnus-bug-message | |
| 1547 "Sending a bug report to the Gnus Towers. | |
| 1548 ======================================== | |
| 1549 | |
| 1550 The buffer below is a mail buffer. When you press `C-c C-c', it will | |
| 1551 be sent to the Gnus Bug Exterminators. | |
| 1552 | |
| 1553 At the bottom of the buffer you'll see lots of variable settings. | |
| 1554 Please do not delete those. They will tell the Bug People what your | |
| 1555 environment is, so that it will be easier to locate the bugs. | |
| 1556 | |
| 1557 If you have found a bug that makes Emacs go \"beep\", set | |
| 1558 debug-on-error to t (`M-x set-variable RET debug-on-error RET t RET') | |
| 1559 and include the backtrace in your bug report. | |
| 1560 | |
| 1561 Please describe the bug in annoying, painstaking detail. | |
| 1562 | |
| 1563 Thank you for your help in stamping out bugs. | |
| 1564 ") | |
| 1565 | |
| 1566 ;;; End of variables. | |
| 1567 | |
| 1568 ;; Define some autoload functions Gnus might use. | |
| 1569 (eval-and-compile | |
| 1570 | |
| 1571 ;; Various | |
| 1572 (autoload 'metamail-buffer "metamail") | |
| 1573 (autoload 'Info-goto-node "info") | |
| 1574 (autoload 'hexl-hex-string-to-integer "hexl") | |
| 1575 (autoload 'pp "pp") | |
| 1576 (autoload 'pp-to-string "pp") | |
| 1577 (autoload 'pp-eval-expression "pp") | |
| 1578 (autoload 'mail-extract-address-components "mail-extr") | |
| 1579 | |
| 1580 (autoload 'nnmail-split-fancy "nnmail") | |
| 1581 (autoload 'nnvirtual-catchup-group "nnvirtual") | |
| 1582 | |
| 1583 ;; timezone | |
| 1584 (autoload 'timezone-make-date-arpa-standard "timezone") | |
| 1585 (autoload 'timezone-fix-time "timezone") | |
| 1586 (autoload 'timezone-make-sortable-date "timezone") | |
| 1587 (autoload 'timezone-make-time-string "timezone") | |
| 1588 | |
| 1589 ;; rmail & friends | |
| 1590 (autoload 'mail-position-on-field "sendmail") | |
| 1591 (autoload 'mail-setup "sendmail") | |
| 1592 (autoload 'rmail-output "rmailout") | |
| 1593 (autoload 'news-mail-other-window "rnewspost") | |
| 1594 (autoload 'news-reply-yank-original "rnewspost") | |
| 1595 (autoload 'news-caesar-buffer-body "rnewspost") | |
| 1596 (autoload 'rmail-insert-rmail-file-header "rmail") | |
| 1597 (autoload 'rmail-count-new-messages "rmail") | |
| 1598 (autoload 'rmail-show-message "rmail") | |
| 1599 | |
| 1600 ;; gnus-soup | |
| 1601 ;;(autoload 'gnus-group-brew-soup "gnus-soup" nil t) | |
| 1602 ;;(autoload 'gnus-brew-soup "gnus-soup" nil t) | |
| 1603 ;;(autoload 'gnus-soup-add-article "gnus-soup" nil t) | |
| 1604 ;;(autoload 'gnus-soup-send-replies "gnus-soup" nil t) | |
| 1605 ;;(autoload 'gnus-soup-save-areas "gnus-soup" nil t) | |
| 1606 ;;(autoload 'gnus-soup-pack-packet "gnus-soup" nil t) | |
| 1607 ;;(autoload 'nnsoup-pack-replies "nnsoup" nil t) | |
| 1608 | |
| 1609 ;; gnus-mh | |
| 1610 (autoload 'gnus-mail-reply-using-mhe "gnus-mh") | |
| 1611 (autoload 'gnus-mail-forward-using-mhe "gnus-mh") | |
| 1612 (autoload 'gnus-mail-other-window-using-mhe "gnus-mh") | |
| 1613 (autoload 'gnus-summary-save-in-folder "gnus-mh" nil t) | |
| 1614 (autoload 'gnus-summary-save-article-folder "gnus-mh") | |
| 1615 (autoload 'gnus-Folder-save-name "gnus-mh") | |
| 1616 (autoload 'gnus-folder-save-name "gnus-mh") | |
| 1617 | |
| 1618 ;; gnus-vis misc | |
| 1619 (autoload 'gnus-group-make-menu-bar "gnus-vis") | |
| 1620 (autoload 'gnus-summary-make-menu-bar "gnus-vis") | |
| 1621 (autoload 'gnus-server-make-menu-bar "gnus-vis") | |
| 1622 (autoload 'gnus-article-make-menu-bar "gnus-vis") | |
| 1623 (autoload 'gnus-browse-make-menu-bar "gnus-vis") | |
| 1624 (autoload 'gnus-highlight-selected-summary "gnus-vis") | |
| 1625 (autoload 'gnus-summary-highlight-line "gnus-vis") | |
| 1626 (autoload 'gnus-carpal-setup-buffer "gnus-vis") | |
| 1627 | |
| 1628 ;; gnus-vis article | |
| 1629 (autoload 'gnus-article-push-button "gnus-vis" nil t) | |
| 1630 (autoload 'gnus-article-press-button "gnus-vis" nil t) | |
| 1631 (autoload 'gnus-article-highlight "gnus-vis" nil t) | |
| 1632 (autoload 'gnus-article-highlight-some "gnus-vis" nil t) | |
| 1633 (autoload 'gnus-article-hide "gnus-vis" nil t) | |
| 1634 (autoload 'gnus-article-hide-signature "gnus-vis" nil t) | |
| 1635 (autoload 'gnus-article-highlight-headers "gnus-vis" nil t) | |
| 1636 (autoload 'gnus-article-highlight-signature "gnus-vis" nil t) | |
| 1637 (autoload 'gnus-article-add-buttons "gnus-vis" nil t) | |
| 1638 (autoload 'gnus-article-next-button "gnus-vis" nil t) | |
| 1639 (autoload 'gnus-article-add-button "gnus-vis") | |
| 1640 | |
| 1641 ;; gnus-cite | |
| 1642 (autoload 'gnus-article-highlight-citation "gnus-cite" nil t) | |
| 1643 (autoload 'gnus-article-hide-citation-maybe "gnus-cite" nil t) | |
| 1644 (autoload 'gnus-article-hide-citation "gnus-cite" nil t) | |
| 1645 | |
| 1646 ;; gnus-kill | |
| 1647 (autoload 'gnus-kill "gnus-kill") | |
| 1648 (autoload 'gnus-apply-kill-file-internal "gnus-kill") | |
| 1649 (autoload 'gnus-kill-file-edit-file "gnus-kill") | |
| 1650 (autoload 'gnus-kill-file-raise-followups-to-author "gnus-kill") | |
| 1651 (autoload 'gnus-execute "gnus-kill") | |
| 1652 (autoload 'gnus-expunge "gnus-kill") | |
| 1653 | |
| 1654 ;; gnus-cache | |
| 1655 (autoload 'gnus-cache-possibly-enter-article "gnus-cache") | |
| 1656 (autoload 'gnus-cache-save-buffers "gnus-cache") | |
| 1657 (autoload 'gnus-cache-possibly-remove-articles "gnus-cache") | |
| 1658 (autoload 'gnus-cache-request-article "gnus-cache") | |
| 1659 (autoload 'gnus-cache-retrieve-headers "gnus-cache") | |
| 1660 (autoload 'gnus-cache-possibly-alter-active "gnus-cache") | |
| 1661 (autoload 'gnus-jog-cache "gnus-cache" nil t) | |
| 1662 (autoload 'gnus-cache-enter-remove-article "gnus-cache") | |
| 1663 | |
| 1664 ;; gnus-score | |
| 1665 (autoload 'gnus-summary-increase-score "gnus-score" nil t) | |
| 1666 (autoload 'gnus-summary-lower-score "gnus-score" nil t) | |
| 1667 (autoload 'gnus-summary-score-map "gnus-score" nil nil 'keymap) | |
| 1668 (autoload 'gnus-score-save "gnus-score") | |
| 1669 (autoload 'gnus-score-headers "gnus-score") | |
| 1670 (autoload 'gnus-current-score-file-nondirectory "gnus-score") | |
| 1671 (autoload 'gnus-score-adaptive "gnus-score") | |
| 1672 (autoload 'gnus-score-remove-lines-adaptive "gnus-score") | |
| 1673 (autoload 'gnus-score-find-trace "gnus-score") | |
| 1674 | |
| 1675 ;; gnus-edit | |
| 1676 (autoload 'gnus-score-customize "gnus-edit" nil t) | |
| 1677 | |
| 1678 ;; gnus-uu | |
| 1679 (autoload 'gnus-uu-extract-map "gnus-uu" nil nil 'keymap) | |
| 1680 (autoload 'gnus-uu-mark-map "gnus-uu" nil nil 'keymap) | |
| 1681 (autoload 'gnus-uu-digest-mail-forward "gnus-uu" nil t) | |
| 1682 (autoload 'gnus-uu-digest-post-forward "gnus-uu" nil t) | |
| 1683 (autoload 'gnus-uu-mark-series "gnus-uu" nil t) | |
| 1684 (autoload 'gnus-uu-mark-region "gnus-uu" nil t) | |
| 1685 (autoload 'gnus-uu-mark-by-regexp "gnus-uu" nil t) | |
| 1686 (autoload 'gnus-uu-mark-all "gnus-uu" nil t) | |
| 1687 (autoload 'gnus-uu-mark-sparse "gnus-uu" nil t) | |
| 1688 (autoload 'gnus-uu-mark-thread "gnus-uu" nil t) | |
| 1689 (autoload 'gnus-uu-decode-uu "gnus-uu" nil t) | |
| 1690 (autoload 'gnus-uu-decode-uu-and-save "gnus-uu" nil t) | |
| 1691 (autoload 'gnus-uu-decode-unshar "gnus-uu" nil t) | |
| 1692 (autoload 'gnus-uu-decode-unshar-and-save "gnus-uu" nil t) | |
| 1693 (autoload 'gnus-uu-decode-save "gnus-uu" nil t) | |
| 1694 (autoload 'gnus-uu-decode-binhex "gnus-uu" nil t) | |
| 1695 (autoload 'gnus-uu-decode-uu-view "gnus-uu" nil t) | |
| 1696 (autoload 'gnus-uu-decode-uu-and-save-view "gnus-uu" nil t) | |
| 1697 (autoload 'gnus-uu-decode-unshar-view "gnus-uu" nil t) | |
| 1698 (autoload 'gnus-uu-decode-unshar-and-save-view "gnus-uu" nil t) | |
| 1699 (autoload 'gnus-uu-decode-save-view "gnus-uu" nil t) | |
| 1700 (autoload 'gnus-uu-decode-binhex-view "gnus-uu" nil t) | |
| 1701 | |
| 1702 ;; gnus-msg | |
| 1703 (autoload 'gnus-summary-send-map "gnus-msg" nil nil 'keymap) | |
| 1704 (autoload 'gnus-group-post-news "gnus-msg" nil t) | |
| 1705 (autoload 'gnus-group-mail "gnus-msg" nil t) | |
| 1706 (autoload 'gnus-summary-post-news "gnus-msg" nil t) | |
| 1707 (autoload 'gnus-summary-followup "gnus-msg" nil t) | |
| 1708 (autoload 'gnus-summary-followup-with-original "gnus-msg" nil t) | |
| 1709 (autoload 'gnus-summary-followup-and-reply "gnus-msg" nil t) | |
| 1710 (autoload 'gnus-summary-followup-and-reply-with-original "gnus-msg" nil t) | |
| 1711 (autoload 'gnus-summary-cancel-article "gnus-msg" nil t) | |
| 1712 (autoload 'gnus-summary-supersede-article "gnus-msg" nil t) | |
| 1713 (autoload 'gnus-post-news "gnus-msg" nil t) | |
| 1714 (autoload 'gnus-inews-news "gnus-msg" nil t) | |
| 1715 (autoload 'gnus-cancel-news "gnus-msg" nil t) | |
| 1716 (autoload 'gnus-summary-reply "gnus-msg" nil t) | |
| 1717 (autoload 'gnus-summary-reply-with-original "gnus-msg" nil t) | |
| 1718 (autoload 'gnus-summary-mail-forward "gnus-msg" nil t) | |
| 1719 (autoload 'gnus-summary-mail-other-window "gnus-msg" nil t) | |
| 1720 (autoload 'gnus-mail-reply-using-mail "gnus-msg") | |
| 1721 (autoload 'gnus-mail-yank-original "gnus-msg") | |
| 1722 (autoload 'gnus-mail-send-and-exit "gnus-msg") | |
| 1723 (autoload 'gnus-mail-forward-using-mail "gnus-msg") | |
| 1724 (autoload 'gnus-mail-other-window-using-mail "gnus-msg") | |
| 1725 (autoload 'gnus-article-mail "gnus-msg") | |
| 1726 (autoload 'gnus-bug "gnus-msg" nil t) | |
| 1727 | |
| 1728 ;; gnus-vm | |
| 1729 (autoload 'gnus-summary-save-in-vm "gnus-vm" nil t) | |
| 1730 (autoload 'gnus-summary-save-article-vm "gnus-vm" nil t) | |
| 1731 (autoload 'gnus-mail-forward-using-vm "gnus-vm") | |
| 1732 (autoload 'gnus-mail-reply-using-vm "gnus-vm") | |
| 1733 (autoload 'gnus-mail-other-window-using-vm "gnus-vm" nil t) | |
| 1734 (autoload 'gnus-yank-article "gnus-vm" nil t) | |
| 1735 | |
| 1736 ) | |
| 1737 | |
| 1738 | |
| 1739 | |
| 1740 ;; Fix by Hallvard B Furuseth <h.b.furuseth@usit.uio.no>. | |
| 1741 ;; If you want the cursor to go somewhere else, set these two | |
| 1742 ;; functions in some startup hook to whatever you want. | |
| 1743 (defalias 'gnus-summary-position-cursor 'gnus-goto-colon) | |
| 1744 (defalias 'gnus-group-position-cursor 'gnus-goto-colon) | |
| 1745 | |
| 1746 ;;; Various macros and substs. | |
| 1747 | |
| 1748 (defmacro gnus-eval-in-buffer-window (buffer &rest forms) | |
| 1749 "Pop to BUFFER, evaluate FORMS, and then returns to original window." | |
| 1750 (` (let ((GnusStartBufferWindow (selected-window))) | |
| 1751 (unwind-protect | |
| 1752 (progn | |
| 1753 (pop-to-buffer (, buffer)) | |
| 1754 (,@ forms)) | |
| 1755 (select-window GnusStartBufferWindow))))) | |
| 1756 | |
| 1757 (defmacro gnus-gethash (string hashtable) | |
| 1758 "Get hash value of STRING in HASHTABLE." | |
| 1759 ;;(` (symbol-value (abbrev-symbol (, string) (, hashtable)))) | |
| 1760 ;;(` (abbrev-expansion (, string) (, hashtable))) | |
| 1761 (` (symbol-value (intern-soft (, string) (, hashtable))))) | |
| 1762 | |
| 1763 (defmacro gnus-sethash (string value hashtable) | |
| 1764 "Set hash value. Arguments are STRING, VALUE, and HASHTABLE." | |
| 1765 ;; We cannot use define-abbrev since it only accepts string as value. | |
| 1766 ;; (set (intern string hashtable) value)) | |
| 1767 (` (set (intern (, string) (, hashtable)) (, value)))) | |
| 1768 | |
| 1769 (defsubst gnus-buffer-substring (beg end) | |
| 1770 (buffer-substring (match-beginning beg) (match-end end))) | |
| 1771 | |
| 1772 ;; modified by MORIOKA Tomohiko <morioka@jaist.ac.jp> | |
| 1773 ;; function `substring' might cut on a middle of multi-octet | |
| 1774 ;; character. | |
| 1775 (defun gnus-truncate-string (str width) | |
| 1776 (substring str 0 width)) | |
| 1777 | |
| 1778 ;; Added by Geoffrey T. Dairiki <dairiki@u.washington.edu>. A safe way | |
| 1779 ;; to limit the length of a string. This function is necessary since | |
| 1780 ;; `(substr "abc" 0 30)' pukes with "Args out of range". | |
| 1781 (defsubst gnus-limit-string (str width) | |
| 1782 (if (> (length str) width) | |
| 1783 (substring str 0 width) | |
| 1784 str)) | |
| 1785 | |
| 1786 (defsubst gnus-simplify-subject-re (subject) | |
| 1787 "Remove \"Re:\" from subject lines." | |
| 1788 (let ((case-fold-search t)) | |
| 1789 (if (string-match "^re: *" subject) | |
| 1790 (substring subject (match-end 0)) | |
| 1791 subject))) | |
| 1792 | |
| 1793 (defsubst gnus-goto-char (point) | |
| 1794 (and point (goto-char point))) | |
| 1795 | |
| 1796 (defmacro gnus-buffer-exists-p (buffer) | |
| 1797 (` (and (, buffer) | |
| 1798 (funcall (if (stringp (, buffer)) 'get-buffer 'buffer-name) | |
| 1799 (, buffer))))) | |
| 1800 | |
| 1801 (defmacro gnus-kill-buffer (buffer) | |
| 1802 (` (if (gnus-buffer-exists-p (, buffer)) | |
| 1803 (kill-buffer (, buffer))))) | |
| 1804 | |
| 1805 (defsubst gnus-point-at-bol () | |
| 1806 "Return point at the beginning of line." | |
| 1807 (let ((p (point))) | |
| 1808 (beginning-of-line) | |
| 1809 (prog1 | |
| 1810 (point) | |
| 1811 (goto-char p)))) | |
| 1812 | |
| 1813 (defsubst gnus-point-at-eol () | |
| 1814 "Return point at the beginning of line." | |
| 1815 (let ((p (point))) | |
| 1816 (end-of-line) | |
| 1817 (prog1 | |
| 1818 (point) | |
| 1819 (goto-char p)))) | |
| 1820 | |
| 1821 ;; Delete the current line (and the next N lines.); | |
| 1822 (defmacro gnus-delete-line (&optional n) | |
| 1823 (` (delete-region (progn (beginning-of-line) (point)) | |
| 1824 (progn (forward-line (, (or n 1))) (point))))) | |
| 1825 | |
| 1826 ;; Suggested by Brian Edmonds <edmonds@cs.ubc.ca>. | |
| 1827 (defvar gnus-init-inhibit nil) | |
| 1828 (defun gnus-read-init-file (&optional inhibit-next) | |
| 1829 (if gnus-init-inhibit | |
| 1830 (setq gnus-init-inhibit nil) | |
| 1831 (setq gnus-init-inhibit inhibit-next) | |
| 1832 (and gnus-init-file | |
| 1833 (or (and (file-exists-p gnus-init-file) | |
| 1834 ;; Don't try to load a directory. | |
| 1835 (not (file-directory-p gnus-init-file))) | |
| 1836 (file-exists-p (concat gnus-init-file ".el")) | |
| 1837 (file-exists-p (concat gnus-init-file ".elc"))) | |
| 1838 (load gnus-init-file nil t)))) | |
| 1839 | |
| 1840 ;;; Load the user startup file. | |
| 1841 ;; (eval '(gnus-read-init-file 'inhibit)) | |
| 1842 | |
| 1843 ;;; Load the compatability functions. | |
| 1844 | |
| 1845 (require 'gnus-cus) | |
| 1846 (require 'gnus-ems) | |
| 1847 | |
| 1848 | |
| 1849 ;;; | |
| 1850 ;;; Gnus Utility Functions | |
| 1851 ;;; | |
| 1852 | |
| 1853 (defun gnus-extract-address-components (from) | |
| 1854 (let (name address) | |
| 1855 ;; First find the address - the thing with the @ in it. This may | |
| 1856 ;; not be accurate in mail addresses, but does the trick most of | |
| 1857 ;; the time in news messages. | |
| 1858 (if (string-match "\\b[^@ \t<>]+[!@][^@ \t<>]+\\b" from) | |
| 1859 (setq address (substring from (match-beginning 0) (match-end 0)))) | |
| 1860 ;; Then we check whether the "name <address>" format is used. | |
| 1861 (and address | |
| 1862 ;; Fix by MORIOKA Tomohiko <morioka@jaist.ac.jp> | |
| 1863 ;; Linear white space is not required. | |
| 1864 (string-match (concat "[ \t]*<" (regexp-quote address) ">") from) | |
| 1865 (and (setq name (substring from 0 (match-beginning 0))) | |
| 1866 ;; Strip any quotes from the name. | |
| 1867 (string-match "\".*\"" name) | |
| 1868 (setq name (substring name 1 (1- (match-end 0)))))) | |
| 1869 ;; If not, then "address (name)" is used. | |
| 1870 (or name | |
| 1871 (and (string-match "(.+)" from) | |
| 1872 (setq name (substring from (1+ (match-beginning 0)) | |
| 1873 (1- (match-end 0))))) | |
| 1874 (and (string-match "()" from) | |
| 1875 (setq name address)) | |
| 1876 ;; Fix by MORIOKA Tomohiko <morioka@jaist.ac.jp>. | |
| 1877 ;; XOVER might not support folded From headers. | |
| 1878 (and (string-match "(.*" from) | |
| 1879 (setq name (substring from (1+ (match-beginning 0)) | |
| 1880 (match-end 0))))) | |
| 1881 ;; Fix by Hallvard B Furuseth <h.b.furuseth@usit.uio.no>. | |
| 1882 (list (or name from) (or address from)))) | |
| 1883 | |
| 1884 (defun gnus-fetch-field (field) | |
| 1885 "Return the value of the header FIELD of current article." | |
| 1886 (save-excursion | |
| 1887 (save-restriction | |
| 1888 (let ((case-fold-search t)) | |
| 1889 (gnus-narrow-to-headers) | |
| 1890 (mail-fetch-field field))))) | |
| 1891 | |
| 1892 (defun gnus-goto-colon () | |
| 1893 (beginning-of-line) | |
| 1894 (search-forward ":" (gnus-point-at-eol) t)) | |
| 1895 | |
| 1896 (defun gnus-narrow-to-headers () | |
| 1897 (widen) | |
| 1898 (save-excursion | |
| 1899 (narrow-to-region | |
| 1900 (goto-char (point-min)) | |
| 1901 (if (search-forward "\n\n" nil t) | |
| 1902 (1- (point)) | |
| 1903 (point-max))))) | |
| 1904 | |
| 1905 (defvar gnus-old-specs nil) | |
| 1906 | |
| 1907 (defun gnus-update-format-specifications () | |
| 1908 (gnus-make-thread-indent-array) | |
| 1909 | |
| 1910 (let ((formats '(summary summary-dummy group | |
| 1911 summary-mode group-mode article-mode)) | |
| 1912 old-format new-format) | |
| 1913 (while formats | |
| 1914 (setq new-format (symbol-value | |
| 1915 (intern (format "gnus-%s-line-format" (car formats))))) | |
| 1916 (or (and (setq old-format (cdr (assq (car formats) gnus-old-specs))) | |
| 1917 (equal old-format new-format)) | |
| 1918 (set (intern (format "gnus-%s-line-format-spec" (car formats))) | |
| 1919 (gnus-parse-format | |
| 1920 new-format | |
| 1921 (symbol-value | |
| 1922 (intern (format "gnus-%s-line-format-alist" | |
| 1923 (if (eq (car formats) 'article-mode) | |
| 1924 'summary-mode (car formats)))))))) | |
| 1925 (setq gnus-old-specs (cons (cons (car formats) new-format) | |
| 1926 (delq (car formats) gnus-old-specs))) | |
| 1927 (setq formats (cdr formats)))) | |
| 1928 | |
| 1929 (gnus-update-group-mark-positions) | |
| 1930 (gnus-update-summary-mark-positions) | |
| 1931 | |
| 1932 (if (and (string-match "%D" gnus-group-line-format) | |
| 1933 (not gnus-description-hashtb) | |
| 1934 gnus-read-active-file) | |
| 1935 (gnus-read-all-descriptions-files))) | |
| 1936 | |
| 1937 (defun gnus-update-summary-mark-positions () | |
| 1938 (save-excursion | |
| 1939 (let ((gnus-replied-mark 129) | |
| 1940 (gnus-score-below-mark 130) | |
| 1941 (gnus-score-over-mark 130) | |
| 1942 (thread nil) | |
| 1943 pos) | |
| 1944 (gnus-set-work-buffer) | |
| 1945 (gnus-summary-insert-line | |
| 1946 nil [0 "" "" "" "" "" 0 0 ""] 0 nil 128 t nil "" nil 1) | |
| 1947 (goto-char (point-min)) | |
| 1948 (setq pos (list (cons 'unread (and (search-forward "\200" nil t) | |
| 1949 (- (point) 2))))) | |
| 1950 (goto-char (point-min)) | |
| 1951 (setq pos (cons (cons 'replied (and (search-forward "\201" nil t) | |
| 1952 (- (point) 2))) pos)) | |
| 1953 (goto-char (point-min)) | |
| 1954 (setq pos (cons (cons 'score (and (search-forward "\202" nil t) | |
| 1955 (- (point) 2))) pos)) | |
| 1956 (setq gnus-summary-mark-positions pos)))) | |
| 1957 | |
| 1958 (defun gnus-update-group-mark-positions () | |
| 1959 (save-excursion | |
| 1960 (let ((gnus-process-mark 128) | |
| 1961 (gnus-group-marked '("dummy.group"))) | |
| 1962 (gnus-sethash "dummy.group" '(0 . 0) gnus-active-hashtb) | |
| 1963 (gnus-set-work-buffer) | |
| 1964 (gnus-group-insert-group-line nil "dummy.group" 0 nil 0 nil) | |
| 1965 (goto-char (point-min)) | |
| 1966 (setq gnus-group-mark-positions | |
| 1967 (list (cons 'process (and (search-forward "\200" nil t) | |
| 1968 (- (point) 2)))))))) | |
| 1969 | |
| 1970 (defun gnus-mouse-face-function (form) | |
| 1971 (` (let ((string (, form))) | |
| 1972 (put-text-property 0 (length string) 'mouse-face gnus-mouse-face string) | |
| 1973 string))) | |
| 1974 | |
| 1975 (defun gnus-max-width-function (el max-width) | |
| 1976 (or (numberp max-width) (signal 'wrong-type-argument '(numberp max-width))) | |
| 1977 (` (let* ((val (eval (, el))) | |
| 1978 (valstr (if (numberp val) | |
| 1979 (int-to-string val) val))) | |
| 1980 (if (> (length valstr) (, max-width)) | |
| 1981 (substring valstr 0 (, max-width)) | |
| 1982 valstr)))) | |
| 1983 | |
| 1984 (defun gnus-parse-format (format spec-alist) | |
| 1985 ;; This function parses the FORMAT string with the help of the | |
| 1986 ;; SPEC-ALIST and returns a list that can be eval'ed to return the | |
| 1987 ;; string. If the FORMAT string contains the specifiers %( and %) | |
| 1988 ;; the text between them will have the mouse-face text property. | |
| 1989 (if (string-match "\\`\\(.*\\)%(\\(.*\\)%)\\(.*\n?\\)\\'" format) | |
| 1990 (if (and gnus-visual gnus-mouse-face) | |
| 1991 (let ((pre (substring format (match-beginning 1) (match-end 1))) | |
| 1992 (button (substring format (match-beginning 2) (match-end 2))) | |
| 1993 (post (substring format (match-beginning 3) (match-end 3)))) | |
| 1994 (list 'concat | |
| 1995 (gnus-parse-simple-format pre spec-alist) | |
| 1996 (gnus-mouse-face-function | |
| 1997 (gnus-parse-simple-format button spec-alist)) | |
| 1998 (gnus-parse-simple-format post spec-alist))) | |
| 1999 (gnus-parse-simple-format | |
| 2000 (concat (substring format (match-beginning 1) (match-end 1)) | |
| 2001 (substring format (match-beginning 2) (match-end 2)) | |
| 2002 (substring format (match-beginning 3) (match-end 3))) | |
| 2003 spec-alist)) | |
| 2004 (gnus-parse-simple-format format spec-alist))) | |
| 2005 | |
| 2006 (defun gnus-parse-simple-format (format spec-alist) | |
| 2007 ;; This function parses the FORMAT string with the help of the | |
| 2008 ;; SPEC-ALIST and returns a list that can be eval'ed to return the | |
| 2009 ;; string. The list will consist of the symbol `format', a format | |
| 2010 ;; specification string, and a list of forms depending on the | |
| 2011 ;; SPEC-ALIST. | |
| 2012 (let ((max-width 0) | |
| 2013 spec flist fstring newspec elem beg) | |
| 2014 (save-excursion | |
| 2015 (gnus-set-work-buffer) | |
| 2016 (insert format) | |
| 2017 (goto-char (point-min)) | |
| 2018 (while (re-search-forward "%[-0-9]*\\(,[0-9]+\\)?\\([^0-9]\\)\\(.\\)?" nil t) | |
| 2019 (setq spec (string-to-char (buffer-substring (match-beginning 2) | |
| 2020 (match-end 2)))) | |
| 2021 ;; First check if there are any specs that look anything like | |
| 2022 ;; "%12,12A", ie. with a "max width specification". These have | |
| 2023 ;; to be treated specially. | |
| 2024 (if (setq beg (match-beginning 1)) | |
| 2025 (setq max-width | |
| 2026 (string-to-int | |
| 2027 (buffer-substring (1+ (match-beginning 1)) (match-end 1)))) | |
| 2028 (setq max-width 0) | |
| 2029 (setq beg (match-beginning 2))) | |
| 2030 ;; Find the specification from `spec-alist'. | |
| 2031 (if (not (setq elem (cdr (assq spec spec-alist)))) | |
| 2032 (setq elem '("*" ?s))) | |
| 2033 ;; Treat user defined format specifiers specially | |
| 2034 (and (eq (car elem) 'user-defined) | |
| 2035 (setq elem | |
| 2036 (list | |
| 2037 (list (intern (concat "gnus-user-format-function-" | |
| 2038 (buffer-substring | |
| 2039 (match-beginning 3) | |
| 2040 (match-end 3)))) | |
| 2041 'header) | |
| 2042 ?s)) | |
| 2043 (delete-region (match-beginning 3) (match-end 3))) | |
| 2044 (if (not (zerop max-width)) | |
| 2045 (let ((el (car elem))) | |
| 2046 (cond ((= (car (cdr elem)) ?c) | |
| 2047 (setq el (list 'char-to-string el))) | |
| 2048 ((= (car (cdr elem)) ?d) | |
| 2049 (numberp el) (setq el (list 'int-to-string el)))) | |
| 2050 (setq flist (cons (gnus-max-width-function el max-width) | |
| 2051 flist)) | |
| 2052 (setq newspec ?s)) | |
| 2053 (setq flist (cons (car elem) flist)) | |
| 2054 (setq newspec (car (cdr elem)))) | |
| 2055 ;; Remove the old specification (and possibly a ",12" string). | |
| 2056 (delete-region beg (match-end 2)) | |
| 2057 ;; Insert the new specification. | |
| 2058 (goto-char beg) | |
| 2059 (insert newspec)) | |
| 2060 (setq fstring (buffer-substring 1 (point-max)))) | |
| 2061 (cons 'format (cons fstring (nreverse flist))))) | |
| 2062 | |
| 2063 (defun gnus-set-work-buffer () | |
| 2064 (if (get-buffer gnus-work-buffer) | |
| 2065 (progn | |
| 2066 (set-buffer gnus-work-buffer) | |
| 2067 (erase-buffer)) | |
| 2068 (set-buffer (get-buffer-create gnus-work-buffer)) | |
| 2069 (kill-all-local-variables) | |
| 2070 (buffer-disable-undo (current-buffer)) | |
| 2071 (gnus-add-current-to-buffer-list))) | |
| 2072 | |
| 2073 ;; Article file names when saving. | |
| 2074 | |
| 2075 (defun gnus-Numeric-save-name (newsgroup headers &optional last-file) | |
| 2076 "Generate file name from NEWSGROUP, HEADERS, and optional LAST-FILE. | |
| 2077 If variable `gnus-use-long-file-name' is nil, it is ~/News/News.group/num. | |
| 2078 Otherwise, it is like ~/News/news/group/num." | |
| 2079 (let ((default | |
| 2080 (expand-file-name | |
| 2081 (concat (if (gnus-use-long-file-name 'not-save) | |
| 2082 (gnus-capitalize-newsgroup newsgroup) | |
| 2083 (gnus-newsgroup-directory-form newsgroup)) | |
| 2084 "/" (int-to-string (mail-header-number headers))) | |
| 2085 (or gnus-article-save-directory "~/News")))) | |
| 2086 (if (and last-file | |
| 2087 (string-equal (file-name-directory default) | |
| 2088 (file-name-directory last-file)) | |
| 2089 (string-match "^[0-9]+$" (file-name-nondirectory last-file))) | |
| 2090 default | |
| 2091 (or last-file default)))) | |
| 2092 | |
| 2093 (defun gnus-numeric-save-name (newsgroup headers &optional last-file) | |
| 2094 "Generate file name from NEWSGROUP, HEADERS, and optional LAST-FILE. | |
| 2095 If variable `gnus-use-long-file-name' is non-nil, it is | |
| 2096 ~/News/news.group/num. Otherwise, it is like ~/News/news/group/num." | |
| 2097 (let ((default | |
| 2098 (expand-file-name | |
| 2099 (concat (if (gnus-use-long-file-name 'not-save) | |
| 2100 newsgroup | |
| 2101 (gnus-newsgroup-directory-form newsgroup)) | |
| 2102 "/" (int-to-string (mail-header-number headers))) | |
| 2103 (or gnus-article-save-directory "~/News")))) | |
| 2104 (if (and last-file | |
| 2105 (string-equal (file-name-directory default) | |
| 2106 (file-name-directory last-file)) | |
| 2107 (string-match "^[0-9]+$" (file-name-nondirectory last-file))) | |
| 2108 default | |
| 2109 (or last-file default)))) | |
| 2110 | |
| 2111 (defun gnus-Plain-save-name (newsgroup headers &optional last-file) | |
| 2112 "Generate file name from NEWSGROUP, HEADERS, and optional LAST-FILE. | |
| 2113 If variable `gnus-use-long-file-name' is non-nil, it is | |
| 2114 ~/News/News.group. Otherwise, it is like ~/News/news/group/news." | |
| 2115 (or last-file | |
| 2116 (expand-file-name | |
| 2117 (if (gnus-use-long-file-name 'not-save) | |
| 2118 (gnus-capitalize-newsgroup newsgroup) | |
| 2119 (concat (gnus-newsgroup-directory-form newsgroup) "/news")) | |
| 2120 (or gnus-article-save-directory "~/News")))) | |
| 2121 | |
| 2122 (defun gnus-plain-save-name (newsgroup headers &optional last-file) | |
| 2123 "Generate file name from NEWSGROUP, HEADERS, and optional LAST-FILE. | |
| 2124 If variable `gnus-use-long-file-name' is non-nil, it is | |
| 2125 ~/News/news.group. Otherwise, it is like ~/News/news/group/news." | |
| 2126 (or last-file | |
| 2127 (expand-file-name | |
| 2128 (if (gnus-use-long-file-name 'not-save) | |
| 2129 newsgroup | |
| 2130 (concat (gnus-newsgroup-directory-form newsgroup) "/news")) | |
| 2131 (or gnus-article-save-directory "~/News")))) | |
| 2132 | |
| 2133 ;; For subscribing new newsgroup | |
| 2134 | |
| 2135 (defun gnus-subscribe-hierarchical-interactive (groups) | |
| 2136 (let ((groups (sort groups 'string<)) | |
| 2137 prefixes prefix start ans group starts) | |
| 2138 (while groups | |
| 2139 (setq prefixes (list "^")) | |
| 2140 (while (and groups prefixes) | |
| 2141 (while (not (string-match (car prefixes) (car groups))) | |
| 2142 (setq prefixes (cdr prefixes))) | |
| 2143 (setq prefix (car prefixes)) | |
| 2144 (setq start (1- (length prefix))) | |
| 2145 (if (and (string-match "[^\\.]\\." (car groups) start) | |
| 2146 (cdr groups) | |
| 2147 (setq prefix | |
| 2148 (concat "^" (substring (car groups) 0 (match-end 0)))) | |
| 2149 (string-match prefix (car (cdr groups)))) | |
| 2150 (progn | |
| 2151 (setq prefixes (cons prefix prefixes)) | |
| 2152 (message "Descend hierarchy %s? ([y]nsq): " | |
| 2153 (substring prefix 1 (1- (length prefix)))) | |
| 2154 (setq ans (read-char)) | |
| 2155 (cond ((= ans ?n) | |
| 2156 (while (and groups | |
| 2157 (string-match prefix | |
| 2158 (setq group (car groups)))) | |
| 2159 (setq gnus-killed-list | |
| 2160 (cons group gnus-killed-list)) | |
| 2161 (gnus-sethash group group gnus-killed-hashtb) | |
| 2162 (setq groups (cdr groups))) | |
| 2163 (setq starts (cdr starts))) | |
| 2164 ((= ans ?s) | |
| 2165 (while (and groups | |
| 2166 (string-match prefix | |
| 2167 (setq group (car groups)))) | |
| 2168 (gnus-sethash group group gnus-killed-hashtb) | |
| 2169 (gnus-subscribe-alphabetically (car groups)) | |
| 2170 (setq groups (cdr groups))) | |
| 2171 (setq starts (cdr starts))) | |
| 2172 ((= ans ?q) | |
| 2173 (while groups | |
| 2174 (setq group (car groups)) | |
| 2175 (setq gnus-killed-list (cons group gnus-killed-list)) | |
| 2176 (gnus-sethash group group gnus-killed-hashtb) | |
| 2177 (setq groups (cdr groups)))) | |
| 2178 (t nil))) | |
| 2179 (message "Subscribe %s? ([n]yq)" (car groups)) | |
| 2180 (setq ans (read-char)) | |
| 2181 (setq group (car groups)) | |
| 2182 (cond ((= ans ?y) | |
| 2183 (gnus-subscribe-alphabetically (car groups)) | |
| 2184 (gnus-sethash group group gnus-killed-hashtb)) | |
| 2185 ((= ans ?q) | |
| 2186 (while groups | |
| 2187 (setq group (car groups)) | |
| 2188 (setq gnus-killed-list (cons group gnus-killed-list)) | |
| 2189 (gnus-sethash group group gnus-killed-hashtb) | |
| 2190 (setq groups (cdr groups)))) | |
| 2191 (t | |
| 2192 (setq gnus-killed-list (cons group gnus-killed-list)) | |
| 2193 (gnus-sethash group group gnus-killed-hashtb))) | |
| 2194 (setq groups (cdr groups))))))) | |
| 2195 | |
| 2196 (defun gnus-subscribe-randomly (newsgroup) | |
| 2197 "Subscribe new NEWSGROUP by making it the first newsgroup." | |
| 2198 (gnus-subscribe-newsgroup newsgroup)) | |
| 2199 | |
| 2200 (defun gnus-subscribe-alphabetically (newgroup) | |
| 2201 "Subscribe new NEWSGROUP and insert it in alphabetical order." | |
| 2202 ;; Basic ideas by mike-w@cs.aukuni.ac.nz (Mike Williams) | |
| 2203 (let ((groups (cdr gnus-newsrc-alist)) | |
| 2204 before) | |
| 2205 (while (and (not before) groups) | |
| 2206 (if (string< newgroup (car (car groups))) | |
| 2207 (setq before (car (car groups))) | |
| 2208 (setq groups (cdr groups)))) | |
| 2209 (gnus-subscribe-newsgroup newgroup before))) | |
| 2210 | |
| 2211 (defun gnus-subscribe-hierarchically (newgroup) | |
| 2212 "Subscribe new NEWSGROUP and insert it in hierarchical newsgroup order." | |
| 2213 ;; Basic ideas by mike-w@cs.aukuni.ac.nz (Mike Williams) | |
| 2214 (save-excursion | |
| 2215 (set-buffer (find-file-noselect gnus-current-startup-file)) | |
| 2216 (let ((groupkey newgroup) | |
| 2217 before) | |
| 2218 (while (and (not before) groupkey) | |
| 2219 (goto-char (point-min)) | |
| 2220 (let ((groupkey-re | |
| 2221 (concat "^\\(" (regexp-quote groupkey) ".*\\)[!:]"))) | |
| 2222 (while (and (re-search-forward groupkey-re nil t) | |
| 2223 (progn | |
| 2224 (setq before (buffer-substring | |
| 2225 (match-beginning 1) (match-end 1))) | |
| 2226 (string< before newgroup))))) | |
| 2227 ;; Remove tail of newsgroup name (eg. a.b.c -> a.b) | |
| 2228 (setq groupkey | |
| 2229 (if (string-match "^\\(.*\\)\\.[^.]+$" groupkey) | |
| 2230 (substring groupkey (match-beginning 1) (match-end 1))))) | |
| 2231 (gnus-subscribe-newsgroup newgroup before)))) | |
| 2232 | |
| 2233 (defun gnus-subscribe-interactively (newsgroup) | |
| 2234 "Subscribe new NEWSGROUP interactively. | |
| 2235 It is inserted in hierarchical newsgroup order if subscribed. If not, | |
| 2236 it is killed." | |
| 2237 (if (gnus-y-or-n-p (format "Subscribe new newsgroup: %s " newsgroup)) | |
| 2238 (gnus-subscribe-hierarchically newsgroup) | |
| 2239 (setq gnus-killed-list (cons newsgroup gnus-killed-list)))) | |
| 2240 | |
| 2241 (defun gnus-subscribe-zombies (newsgroup) | |
| 2242 "Make new NEWSGROUP a zombie group." | |
| 2243 (setq gnus-zombie-list (cons newsgroup gnus-zombie-list))) | |
| 2244 | |
| 2245 (defun gnus-subscribe-newsgroup (newsgroup &optional next) | |
| 2246 "Subscribe new NEWSGROUP. | |
| 2247 If NEXT is non-nil, it is inserted before NEXT. Otherwise it is made | |
| 2248 the first newsgroup." | |
| 2249 ;; We subscribe the group by changing its level to `subscribed'. | |
| 2250 (gnus-group-change-level | |
| 2251 newsgroup gnus-level-default-subscribed | |
| 2252 gnus-level-killed (gnus-gethash (or next "dummy.group") gnus-newsrc-hashtb)) | |
| 2253 (gnus-message 5 "Subscribe newsgroup: %s" newsgroup)) | |
| 2254 | |
| 2255 ;; For directories | |
| 2256 | |
| 2257 (defun gnus-newsgroup-directory-form (newsgroup) | |
| 2258 "Make hierarchical directory name from NEWSGROUP name." | |
| 2259 (let ((newsgroup (gnus-newsgroup-saveable-name newsgroup)) | |
| 2260 (len (length newsgroup)) | |
| 2261 idx) | |
| 2262 ;; If this is a foreign group, we don't want to translate the | |
| 2263 ;; entire name. | |
| 2264 (if (setq idx (string-match ":" newsgroup)) | |
| 2265 (aset newsgroup idx ?/) | |
| 2266 (setq idx 0)) | |
| 2267 ;; Replace all occurrences of `.' with `/'. | |
| 2268 (while (< idx len) | |
| 2269 (if (= (aref newsgroup idx) ?.) | |
| 2270 (aset newsgroup idx ?/)) | |
| 2271 (setq idx (1+ idx))) | |
| 2272 newsgroup)) | |
| 2273 | |
| 2274 (defun gnus-newsgroup-saveable-name (group) | |
| 2275 ;; Replace any slashes in a group name (eg. an ange-ftp nndoc group) | |
| 2276 ;; with dots. | |
| 2277 (gnus-replace-chars-in-string group ?/ ?.)) | |
| 2278 | |
| 2279 (defun gnus-make-directory (dir) | |
| 2280 "Make DIRECTORY recursively." | |
| 2281 ;; Why don't we use `(make-directory dir 'parents)'? That's just one | |
| 2282 ;; of the many mysteries of the universe. | |
| 2283 (let* ((dir (expand-file-name dir default-directory)) | |
| 2284 dirs err) | |
| 2285 (if (string-match "/$" dir) | |
| 2286 (setq dir (substring dir 0 (match-beginning 0)))) | |
| 2287 ;; First go down the path until we find a directory that exists. | |
| 2288 (while (not (file-exists-p dir)) | |
| 2289 (setq dirs (cons dir dirs)) | |
| 2290 (string-match "/[^/]+$" dir) | |
| 2291 (setq dir (substring dir 0 (match-beginning 0)))) | |
| 2292 ;; Then create all the subdirs. | |
| 2293 (while (and dirs (not err)) | |
| 2294 (condition-case () | |
| 2295 (make-directory (car dirs)) | |
| 2296 (error (setq err t))) | |
| 2297 (setq dirs (cdr dirs))) | |
| 2298 ;; We return whether we were successful or not. | |
| 2299 (not dirs))) | |
| 2300 | |
| 2301 (defun gnus-capitalize-newsgroup (newsgroup) | |
| 2302 "Capitalize NEWSGROUP name." | |
| 2303 (and (not (zerop (length newsgroup))) | |
| 2304 (concat (char-to-string (upcase (aref newsgroup 0))) | |
| 2305 (substring newsgroup 1)))) | |
| 2306 | |
| 2307 ;; Var | |
| 2308 | |
| 2309 (defun gnus-simplify-subject (subject &optional re-only) | |
| 2310 "Remove `Re:' and words in parentheses. | |
| 2311 If optional argument RE-ONLY is non-nil, strip `Re:' only." | |
| 2312 (let ((case-fold-search t)) ;Ignore case. | |
| 2313 ;; Remove `Re:' and `Re^N:'. | |
| 2314 (if (string-match "^re:[ \t]*" subject) | |
| 2315 (setq subject (substring subject (match-end 0)))) | |
| 2316 ;; Remove words in parentheses from end. | |
| 2317 (or re-only | |
| 2318 (while (string-match "[ \t\n]*([^()]*)[ \t\n]*\\'" subject) | |
| 2319 (setq subject (substring subject 0 (match-beginning 0))))) | |
| 2320 ;; Return subject string. | |
| 2321 subject)) | |
| 2322 | |
| 2323 ;; Remove any leading "re:"s, any trailing paren phrases, and simplify | |
| 2324 ;; all whitespace. | |
| 2325 (defun gnus-simplify-subject-fuzzy (subject) | |
| 2326 (let ((case-fold-search t)) | |
| 2327 (save-excursion | |
| 2328 (gnus-set-work-buffer) | |
| 2329 (insert subject) | |
| 2330 (inline (gnus-simplify-buffer-fuzzy)) | |
| 2331 (buffer-string)))) | |
| 2332 | |
| 2333 (defun gnus-simplify-buffer-fuzzy () | |
| 2334 (goto-char (point-min)) | |
| 2335 ;; Fix by Stainless Steel Rat <ratinox@ccs.neu.edu>. | |
| 2336 (while (re-search-forward "^[ \t]*\\(re\\|fwd\\)[[{(^0-9]*[])}]?[:;][ \t]*" | |
| 2337 nil t) | |
| 2338 (replace-match "" t t)) | |
| 2339 (goto-char (point-min)) | |
| 2340 (while (re-search-forward "[ \t\n]*([^()]*)[ \t\n]*$" nil t) | |
| 2341 (replace-match "" t t)) | |
| 2342 (goto-char (point-min)) | |
| 2343 (while (re-search-forward "[ \t]+" nil t) | |
| 2344 (replace-match " " t t)) | |
| 2345 (goto-char (point-min)) | |
| 2346 (while (re-search-forward "[ \t]+$" nil t) | |
| 2347 (replace-match "" t t)) | |
| 2348 (goto-char (point-min)) | |
| 2349 (while (re-search-forward "^[ \t]+" nil t) | |
| 2350 (replace-match "" t t)) | |
| 2351 (if gnus-simplify-subject-fuzzy-regexp | |
| 2352 (while (re-search-forward gnus-simplify-subject-fuzzy-regexp nil t) | |
| 2353 (replace-match "" t t)))) | |
| 2354 | |
| 2355 ;; Add the current buffer to the list of buffers to be killed on exit. | |
| 2356 (defun gnus-add-current-to-buffer-list () | |
| 2357 (or (memq (current-buffer) gnus-buffer-list) | |
| 2358 (setq gnus-buffer-list (cons (current-buffer) gnus-buffer-list)))) | |
| 2359 | |
| 2360 (defun gnus-string> (s1 s2) | |
| 2361 (not (or (string< s1 s2) | |
| 2362 (string= s1 s2)))) | |
| 2363 | |
| 2364 ;; Functions accessing headers. | |
| 2365 ;; Functions are more convenient than macros in some cases. | |
| 2366 | |
| 2367 (defun gnus-header-number (header) | |
| 2368 (mail-header-number header)) | |
| 2369 | |
| 2370 (defun gnus-header-subject (header) | |
| 2371 (mail-header-subject header)) | |
| 2372 | |
| 2373 (defun gnus-header-from (header) | |
| 2374 (mail-header-from header)) | |
| 2375 | |
| 2376 (defun gnus-header-xref (header) | |
| 2377 (mail-header-xref header)) | |
| 2378 | |
| 2379 (defun gnus-header-lines (header) | |
| 2380 (mail-header-lines header)) | |
| 2381 | |
| 2382 (defun gnus-header-date (header) | |
| 2383 (mail-header-date header)) | |
| 2384 | |
| 2385 (defun gnus-header-id (header) | |
| 2386 (mail-header-id header)) | |
| 2387 | |
| 2388 (defun gnus-header-message-id (header) | |
| 2389 (mail-header-id header)) | |
| 2390 | |
| 2391 (defun gnus-header-chars (header) | |
| 2392 (mail-header-chars header)) | |
| 2393 | |
| 2394 (defun gnus-header-references (header) | |
| 2395 (mail-header-references header)) | |
| 2396 | |
| 2397 ;;; General various misc type functions. | |
| 2398 | |
| 2399 (defun gnus-clear-system () | |
| 2400 "Clear all variables and buffers." | |
| 2401 ;; Clear Gnus variables. | |
| 2402 (let ((variables gnus-variable-list)) | |
| 2403 (while variables | |
| 2404 (set (car variables) nil) | |
| 2405 (setq variables (cdr variables)))) | |
| 2406 ;; Clear other internal variables. | |
| 2407 (setq gnus-list-of-killed-groups nil | |
| 2408 gnus-have-read-active-file nil | |
| 2409 gnus-newsrc-alist nil | |
| 2410 gnus-newsrc-hashtb nil | |
| 2411 gnus-killed-list nil | |
| 2412 gnus-zombie-list nil | |
| 2413 gnus-killed-hashtb nil | |
| 2414 gnus-active-hashtb nil | |
| 2415 gnus-moderated-list nil | |
| 2416 gnus-description-hashtb nil | |
| 2417 gnus-newsgroup-headers nil | |
| 2418 gnus-newsgroup-headers-hashtb-by-number nil | |
| 2419 gnus-newsgroup-name nil | |
| 2420 gnus-server-alist nil | |
| 2421 gnus-current-select-method nil) | |
| 2422 ;; Reset any score variables. | |
| 2423 (and (boundp 'gnus-score-cache) | |
| 2424 (set 'gnus-score-cache nil)) | |
| 2425 (and (boundp 'gnus-internal-global-score-files) | |
| 2426 (set 'gnus-internal-global-score-files nil)) | |
| 2427 ;; Kill the startup file. | |
| 2428 (and gnus-current-startup-file | |
| 2429 (get-file-buffer gnus-current-startup-file) | |
| 2430 (kill-buffer (get-file-buffer gnus-current-startup-file))) | |
| 2431 ;; Save any cache buffers. | |
| 2432 (and gnus-use-cache (gnus-cache-save-buffers)) | |
| 2433 ;; Clear the dribble buffer. | |
| 2434 (gnus-dribble-clear) | |
| 2435 ;; Kill global KILL file buffer. | |
| 2436 (if (get-file-buffer (gnus-newsgroup-kill-file nil)) | |
| 2437 (kill-buffer (get-file-buffer (gnus-newsgroup-kill-file nil)))) | |
| 2438 (gnus-kill-buffer nntp-server-buffer) | |
| 2439 ;; Kill Gnus buffers. | |
| 2440 (while gnus-buffer-list | |
| 2441 (gnus-kill-buffer (car gnus-buffer-list)) | |
| 2442 (setq gnus-buffer-list (cdr gnus-buffer-list)))) | |
| 2443 | |
| 2444 (defun gnus-windows-old-to-new (setting) | |
| 2445 ;; First we take care of the really, really old Gnus 3 actions. | |
| 2446 (if (symbolp setting) | |
| 2447 (setq setting | |
| 2448 (cond ((memq setting '(SelectArticle)) | |
| 2449 'article) | |
| 2450 ((memq setting '(SelectSubject ExpandSubject)) | |
| 2451 'summary) | |
| 2452 ((memq setting '(SelectNewsgroup ExitNewsgroup)) | |
| 2453 'group) | |
| 2454 (t setting)))) | |
| 2455 (if (or (listp setting) | |
| 2456 (not (and gnus-window-configuration | |
| 2457 (memq setting '(group summary article))))) | |
| 2458 setting | |
| 2459 (let* ((setting (if (eq setting 'group) | |
| 2460 (if (assq 'newsgroup gnus-window-configuration) | |
| 2461 'newsgroup | |
| 2462 'newsgroups) setting)) | |
| 2463 (elem (car (cdr (assq setting gnus-window-configuration)))) | |
| 2464 (total (apply '+ elem)) | |
| 2465 (types '(group summary article)) | |
| 2466 (pbuf (if (eq setting 'newsgroups) 'group 'summary)) | |
| 2467 (i 0) | |
| 2468 perc | |
| 2469 out) | |
| 2470 (while (< i 3) | |
| 2471 (or (not (numberp (nth i elem))) | |
| 2472 (zerop (nth i elem)) | |
| 2473 (progn | |
| 2474 (setq perc (/ (* 1.0 (nth 0 elem)) total)) | |
| 2475 (setq out (cons (if (eq pbuf (nth i types)) | |
| 2476 (vector (nth i types) perc 'point) | |
| 2477 (vector (nth i types) perc)) | |
| 2478 out)))) | |
| 2479 (setq i (1+ i))) | |
| 2480 (list (nreverse out))))) | |
| 2481 | |
| 2482 (defun gnus-add-configuration (conf) | |
| 2483 (setq gnus-buffer-configuration | |
| 2484 (cons conf (delq (assq (car conf) gnus-buffer-configuration) | |
| 2485 gnus-buffer-configuration)))) | |
| 2486 | |
| 2487 (defun gnus-configure-windows (setting &optional force) | |
| 2488 (setq setting (gnus-windows-old-to-new setting)) | |
| 2489 (let ((r (if (symbolp setting) | |
| 2490 (cdr (assq setting gnus-buffer-configuration)) | |
| 2491 setting)) | |
| 2492 (in-buf (current-buffer)) | |
| 2493 rule val w height hor ohor heights sub jump-buffer | |
| 2494 rel total to-buf all-visible) | |
| 2495 (or r (error "No such setting: %s" setting)) | |
| 2496 | |
| 2497 (if (and (not force) (setq all-visible (gnus-all-windows-visible-p r))) | |
| 2498 ;; All the windows mentioned are already visible, so we just | |
| 2499 ;; put point in the assigned buffer, and do not touch the | |
| 2500 ;; winconf. | |
| 2501 (select-window (get-buffer-window all-visible t)) | |
| 2502 | |
| 2503 | |
| 2504 ;; Either remove all windows or just remove all Gnus windows. | |
| 2505 (if gnus-use-full-window | |
| 2506 (delete-other-windows) | |
| 2507 (gnus-remove-some-windows) | |
| 2508 (switch-to-buffer nntp-server-buffer)) | |
| 2509 | |
| 2510 (while r | |
| 2511 (setq hor (car r) | |
| 2512 ohor nil) | |
| 2513 | |
| 2514 ;; We have to do the (possible) horizontal splitting before the | |
| 2515 ;; vertical. | |
| 2516 (if (and (listp (car hor)) | |
| 2517 (eq (car (car hor)) 'horizontal)) | |
| 2518 (progn | |
| 2519 (split-window | |
| 2520 nil | |
| 2521 (if (integerp (nth 1 (car hor))) | |
| 2522 (nth 1 (car hor)) | |
| 2523 (- (frame-width) (floor (* (frame-width) (nth 1 (car hor)))))) | |
| 2524 t) | |
| 2525 (setq hor (cdr hor)))) | |
| 2526 | |
| 2527 ;; Go through the rules and eval the elements that are to be | |
| 2528 ;; evaled. | |
| 2529 (while hor | |
| 2530 (if (setq val (if (vectorp (car hor)) (car hor) (eval (car hor)))) | |
| 2531 (progn | |
| 2532 ;; Expand short buffer name. | |
| 2533 (setq w (aref val 0)) | |
| 2534 (and (setq w (cdr (assq w gnus-window-to-buffer))) | |
| 2535 (progn | |
| 2536 (setq val (apply 'vector (mapcar 'identity val))) | |
| 2537 (aset val 0 w))) | |
| 2538 (setq ohor (cons val ohor)))) | |
| 2539 (setq hor (cdr hor))) | |
| 2540 (setq rule (cons (nreverse ohor) rule)) | |
| 2541 (setq r (cdr r))) | |
| 2542 (setq rule (nreverse rule)) | |
| 2543 | |
| 2544 ;; We tally the window sizes. | |
| 2545 (setq total (window-height)) | |
| 2546 (while rule | |
| 2547 (setq hor (car rule)) | |
| 2548 (if (and (listp (car hor)) (eq (car (car hor)) 'horizontal)) | |
| 2549 (setq hor (cdr hor))) | |
| 2550 (setq sub 0) | |
| 2551 (while hor | |
| 2552 (setq rel (aref (car hor) 1) | |
| 2553 heights (cons | |
| 2554 (cond ((and (floatp rel) (= 1.0 rel)) | |
| 2555 'x) | |
| 2556 ((integerp rel) | |
| 2557 rel) | |
| 2558 (t | |
| 2559 (max (floor (* total rel)) 4))) | |
| 2560 heights) | |
| 2561 sub (+ sub (if (numberp (car heights)) (car heights) 0)) | |
| 2562 hor (cdr hor))) | |
| 2563 (setq heights (nreverse heights) | |
| 2564 hor (car rule)) | |
| 2565 | |
| 2566 ;; We then go through these heighs and create windows for them. | |
| 2567 (while heights | |
| 2568 (setq height (car heights) | |
| 2569 heights (cdr heights)) | |
| 2570 (and (eq height 'x) | |
| 2571 (setq height (- total sub))) | |
| 2572 (and heights | |
| 2573 (split-window nil height)) | |
| 2574 (setq to-buf (aref (car hor) 0)) | |
| 2575 (switch-to-buffer | |
| 2576 (cond ((not to-buf) | |
| 2577 in-buf) | |
| 2578 ((symbolp to-buf) | |
| 2579 (symbol-value (aref (car hor) 0))) | |
| 2580 (t | |
| 2581 (aref (car hor) 0)))) | |
| 2582 (and (> (length (car hor)) 2) | |
| 2583 (eq (aref (car hor) 2) 'point) | |
| 2584 (setq jump-buffer (current-buffer))) | |
| 2585 (other-window 1) | |
| 2586 (setq hor (cdr hor))) | |
| 2587 | |
| 2588 (setq rule (cdr rule))) | |
| 2589 | |
| 2590 ;; Finally, we pop to the buffer that's supposed to have point. | |
| 2591 (or jump-buffer (error "Missing `point' in spec for %s" setting)) | |
| 2592 | |
| 2593 (select-window (get-buffer-window jump-buffer t)) | |
| 2594 (set-buffer jump-buffer)))) | |
| 2595 | |
| 2596 (defun gnus-all-windows-visible-p (rule) | |
| 2597 (let (invisible hor jump-buffer val buffer) | |
| 2598 ;; Go through the rules and eval the elements that are to be | |
| 2599 ;; evaled. | |
| 2600 (while (and rule (not invisible)) | |
| 2601 (setq hor (car rule) | |
| 2602 rule (cdr rule)) | |
| 2603 (while (and hor (not invisible)) | |
| 2604 (if (setq val (if (vectorp (car hor)) | |
| 2605 (car hor) | |
| 2606 (if (not (eq (car (car hor)) 'horizontal)) | |
| 2607 (eval (car hor))))) | |
| 2608 (progn | |
| 2609 ;; Expand short buffer name. | |
| 2610 (setq buffer (or (cdr (assq (aref val 0) gnus-window-to-buffer)) | |
| 2611 (aref val 0))) | |
| 2612 (setq buffer (if (symbolp buffer) (symbol-value buffer) | |
| 2613 buffer)) | |
| 2614 (and (> (length val) 2) (eq 'point (aref val 2)) | |
| 2615 (setq jump-buffer buffer)) | |
| 2616 (setq invisible (not (and buffer (get-buffer-window buffer)))))) | |
| 2617 (setq hor (cdr hor)))) | |
| 2618 (and (not invisible) jump-buffer))) | |
| 2619 | |
| 2620 (defun gnus-window-top-edge (&optional window) | |
| 2621 (nth 1 (window-edges window))) | |
| 2622 | |
| 2623 (defun gnus-remove-some-windows () | |
| 2624 (let ((buffers gnus-window-to-buffer) | |
| 2625 buf bufs lowest-buf lowest) | |
| 2626 (save-excursion | |
| 2627 ;; Remove windows on all known Gnus buffers. | |
| 2628 (while buffers | |
| 2629 (setq buf (cdr (car buffers))) | |
| 2630 (if (symbolp buf) | |
| 2631 (setq buf (and (boundp buf) (symbol-value buf)))) | |
| 2632 (and buf | |
| 2633 (get-buffer-window buf) | |
| 2634 (progn | |
| 2635 (setq bufs (cons buf bufs)) | |
| 2636 (pop-to-buffer buf) | |
| 2637 (if (or (not lowest) | |
| 2638 (< (gnus-window-top-edge) lowest)) | |
| 2639 (progn | |
| 2640 (setq lowest (gnus-window-top-edge)) | |
| 2641 (setq lowest-buf buf))))) | |
| 2642 (setq buffers (cdr buffers))) | |
| 2643 ;; Remove windows on *all* summary buffers. | |
| 2644 (let (wins) | |
| 2645 (walk-windows | |
| 2646 (lambda (win) | |
| 2647 (let ((buf (window-buffer win))) | |
| 2648 (if (string-match "^\\*Summary" (buffer-name buf)) | |
| 2649 (progn | |
| 2650 (setq bufs (cons buf bufs)) | |
| 2651 (pop-to-buffer buf) | |
| 2652 (if (or (not lowest) | |
| 2653 (< (gnus-window-top-edge) lowest)) | |
| 2654 (progn | |
| 2655 (setq lowest-buf buf) | |
| 2656 (setq lowest (gnus-window-top-edge)))))))))) | |
| 2657 (and lowest-buf | |
| 2658 (progn | |
| 2659 (pop-to-buffer lowest-buf) | |
| 2660 (switch-to-buffer nntp-server-buffer))) | |
| 2661 (while bufs | |
| 2662 (and (not (eq (car bufs) lowest-buf)) | |
| 2663 (delete-windows-on (car bufs))) | |
| 2664 (setq bufs (cdr bufs)))))) | |
| 2665 | |
| 2666 (defun gnus-version () | |
| 2667 "Version numbers of this version of Gnus." | |
| 2668 (interactive) | |
| 2669 (let ((methods gnus-valid-select-methods) | |
| 2670 (mess gnus-version) | |
| 2671 meth) | |
| 2672 ;; Go through all the legal select methods and add their version | |
| 2673 ;; numbers to the total version string. Only the backends that are | |
| 2674 ;; currently in use will have their message numbers taken into | |
| 2675 ;; consideration. | |
| 2676 (while methods | |
| 2677 (setq meth (intern (concat (car (car methods)) "-version"))) | |
| 2678 (and (boundp meth) | |
| 2679 (stringp (symbol-value meth)) | |
| 2680 (setq mess (concat mess "; " (symbol-value meth)))) | |
| 2681 (setq methods (cdr methods))) | |
| 2682 (gnus-message 2 mess))) | |
| 2683 | |
| 2684 (defun gnus-info-find-node () | |
| 2685 "Find Info documentation of Gnus." | |
| 2686 (interactive) | |
| 2687 ;; Enlarge info window if needed. | |
| 2688 (let ((mode major-mode)) | |
| 2689 (gnus-configure-windows 'info) | |
| 2690 (Info-goto-node (car (cdr (assq mode gnus-info-nodes)))))) | |
| 2691 | |
| 2692 (defun gnus-overload-functions (&optional overloads) | |
| 2693 "Overload functions specified by optional argument OVERLOADS. | |
| 2694 If nothing is specified, use the variable gnus-overload-functions." | |
| 2695 (let ((defs nil) | |
| 2696 (overloads (or overloads gnus-overload-functions))) | |
| 2697 (while overloads | |
| 2698 (setq defs (car overloads)) | |
| 2699 (setq overloads (cdr overloads)) | |
| 2700 ;; Load file before overloading function if necessary. Make | |
| 2701 ;; sure we cannot use `require' always. | |
| 2702 (and (not (fboundp (car defs))) | |
| 2703 (car (cdr (cdr defs))) | |
| 2704 (load (car (cdr (cdr defs))) nil 'nomessage)) | |
| 2705 (fset (car defs) (car (cdr defs)))))) | |
| 2706 | |
| 2707 (defun gnus-replace-chars-in-string (string &rest pairs) | |
| 2708 "Replace characters in STRING from FROM to TO." | |
| 2709 (let ((string (substring string 0)) ;Copy string. | |
| 2710 (len (length string)) | |
| 2711 (idx 0) | |
| 2712 sym to) | |
| 2713 (or (zerop (% (length pairs) 2)) | |
| 2714 (error "Odd number of translation pairs")) | |
| 2715 (setplist 'sym pairs) | |
| 2716 ;; Replace all occurrences of FROM with TO. | |
| 2717 (while (< idx len) | |
| 2718 (if (setq to (get 'sym (aref string idx))) | |
| 2719 (aset string idx to)) | |
| 2720 (setq idx (1+ idx))) | |
| 2721 string)) | |
| 2722 | |
| 2723 (defun gnus-days-between (date1 date2) | |
| 2724 ;; Return the number of days between date1 and date2. | |
| 2725 (- (gnus-day-number date1) (gnus-day-number date2))) | |
| 2726 | |
| 2727 (defun gnus-day-number (date) | |
| 2728 (let ((dat (mapcar (lambda (s) (and s (string-to-int s)) ) | |
| 2729 (timezone-parse-date date)))) | |
| 2730 (timezone-absolute-from-gregorian | |
| 2731 (nth 1 dat) (nth 2 dat) (car dat)))) | |
| 2732 | |
| 2733 ;; Returns a floating point number that says how many seconds have | |
| 2734 ;; lapsed between Jan 1 12:00:00 1970 and DATE. | |
| 2735 (defun gnus-seconds-since-epoch (date) | |
| 2736 (let* ((tdate (mapcar (lambda (ti) (and ti (string-to-int ti))) | |
| 2737 (timezone-parse-date date))) | |
| 2738 (ttime (mapcar (lambda (ti) (and ti (string-to-int ti))) | |
| 2739 (timezone-parse-time | |
| 2740 (aref (timezone-parse-date date) 3)))) | |
| 2741 (edate (mapcar (lambda (ti) (and ti (string-to-int ti))) | |
| 2742 (timezone-parse-date "Jan 1 12:00:00 1970"))) | |
| 2743 (tday (- (timezone-absolute-from-gregorian | |
| 2744 (nth 1 tdate) (nth 2 tdate) (nth 0 tdate)) | |
| 2745 (timezone-absolute-from-gregorian | |
| 2746 (nth 1 edate) (nth 2 edate) (nth 0 edate))))) | |
| 2747 (+ (nth 2 ttime) | |
| 2748 (* (nth 1 ttime) 60) | |
| 2749 (* 1.0 (nth 0 ttime) 60 60) | |
| 2750 (* 1.0 tday 60 60 24)))) | |
| 2751 | |
| 2752 (defun gnus-file-newer-than (file date) | |
| 2753 (let ((fdate (nth 5 (file-attributes file)))) | |
| 2754 (or (> (car fdate) (car date)) | |
| 2755 (and (= (car fdate) (car date)) | |
| 2756 (> (nth 1 fdate) (nth 1 date)))))) | |
| 2757 | |
| 2758 (defun gnus-group-read-only-p (&optional group) | |
| 2759 "Check whether GROUP supports editing or not. | |
| 2760 If GROUP is nil, `gnus-newsgroup-name' will be checked instead. Note | |
| 2761 that that variable is buffer-local to the summary buffers." | |
| 2762 (let ((group (or group gnus-newsgroup-name))) | |
| 2763 (not (gnus-check-backend-function 'request-replace-article group)))) | |
| 2764 | |
| 2765 ;; Two silly functions to ensure that all `y-or-n-p' questions clear | |
| 2766 ;; the echo area. | |
| 2767 (defun gnus-y-or-n-p (prompt) | |
| 2768 (prog1 | |
| 2769 (y-or-n-p prompt) | |
| 2770 (message ""))) | |
| 2771 | |
| 2772 (defun gnus-yes-or-no-p (prompt) | |
| 2773 (prog1 | |
| 2774 (yes-or-no-p prompt) | |
| 2775 (message ""))) | |
| 2776 | |
| 2777 ;; Check whether to use long file names. | |
| 2778 (defun gnus-use-long-file-name (symbol) | |
| 2779 ;; The variable has to be set... | |
| 2780 (and gnus-use-long-file-name | |
| 2781 ;; If it isn't a list, then we return t. | |
| 2782 (or (not (listp gnus-use-long-file-name)) | |
| 2783 ;; If it is a list, and the list contains `symbol', we | |
| 2784 ;; return nil. | |
| 2785 (not (memq symbol gnus-use-long-file-name))))) | |
| 2786 | |
| 2787 ;; I suspect there's a better way, but I haven't taken the time to do | |
| 2788 ;; it yet. -erik selberg@cs.washington.edu | |
| 2789 (defun gnus-dd-mmm (messy-date) | |
| 2790 "Return a string like DD-MMM from a big messy string" | |
| 2791 (let ((datevec (timezone-parse-date messy-date))) | |
| 2792 (format "%2s-%s" | |
| 2793 (or (aref datevec 2) "??") | |
| 2794 (capitalize | |
| 2795 (or (car | |
| 2796 (nth (1- (string-to-number (aref datevec 1))) | |
| 2797 timezone-months-assoc)) | |
| 2798 "???"))))) | |
| 2799 | |
| 2800 ;; Make a hash table (default and minimum size is 255). | |
| 2801 ;; Optional argument HASHSIZE specifies the table size. | |
| 2802 (defun gnus-make-hashtable (&optional hashsize) | |
| 2803 (make-vector (if hashsize (max (gnus-create-hash-size hashsize) 255) 255) 0)) | |
| 2804 | |
| 2805 ;; Make a number that is suitable for hashing; bigger than MIN and one | |
| 2806 ;; less than 2^x. | |
| 2807 (defun gnus-create-hash-size (min) | |
| 2808 (let ((i 1)) | |
| 2809 (while (< i min) | |
| 2810 (setq i (* 2 i))) | |
| 2811 (1- i))) | |
| 2812 | |
| 2813 ;; Show message if message has a lower level than `gnus-verbose'. | |
| 2814 ;; Guide-line for numbers: | |
| 2815 ;; 1 - error messages, 3 - non-serious error messages, 5 - messages | |
| 2816 ;; for things that take a long time, 7 - not very important messages | |
| 2817 ;; on stuff, 9 - messages inside loops. | |
| 2818 (defun gnus-message (level &rest args) | |
| 2819 (if (<= level gnus-verbose) | |
| 2820 (apply 'message args) | |
| 2821 ;; We have to do this format thingie here even if the result isn't | |
| 2822 ;; shown - the return value has to be the same as the return value | |
| 2823 ;; from `message'. | |
| 2824 (apply 'format args))) | |
| 2825 | |
| 2826 ;; Generate a unique new group name. | |
| 2827 (defun gnus-generate-new-group-name (leaf) | |
| 2828 (let ((name leaf) | |
| 2829 (num 0)) | |
| 2830 (while (gnus-gethash name gnus-newsrc-hashtb) | |
| 2831 (setq name (concat leaf "<" (int-to-string (setq num (1+ num))) ">"))) | |
| 2832 name)) | |
| 2833 | |
| 2834 (defun gnus-ephemeral-group-p (group) | |
| 2835 "Say whether GROUP is ephemeral or not." | |
| 2836 (assoc 'quit-config (gnus-find-method-for-group group))) | |
| 2837 | |
| 2838 (defun gnus-group-quit-config (group) | |
| 2839 "Return the quit-config of GROUP." | |
| 2840 (cdr (assoc 'quit-config (gnus-find-method-for-group group)))) | |
| 2841 | |
| 2842 ;;; List and range functions | |
| 2843 | |
| 2844 (defun gnus-last-element (list) | |
| 2845 "Return last element of LIST." | |
| 2846 (while (cdr list) | |
| 2847 (setq list (cdr list))) | |
| 2848 (car list)) | |
| 2849 | |
| 2850 (defun gnus-copy-sequence (list) | |
| 2851 "Do a complete, total copy of a list." | |
| 2852 (if (and (consp list) (not (consp (cdr list)))) | |
| 2853 (cons (car list) (cdr list)) | |
| 2854 (mapcar (lambda (elem) (if (consp elem) | |
| 2855 (if (consp (cdr elem)) | |
| 2856 (gnus-copy-sequence elem) | |
| 2857 (cons (car elem) (cdr elem))) | |
| 2858 elem)) | |
| 2859 list))) | |
| 2860 | |
| 2861 (defun gnus-set-difference (list1 list2) | |
| 2862 "Return a list of elements of LIST1 that do not appear in LIST2." | |
| 2863 (let ((list1 (copy-sequence list1))) | |
| 2864 (while list2 | |
| 2865 (setq list1 (delq (car list2) list1)) | |
| 2866 (setq list2 (cdr list2))) | |
| 2867 list1)) | |
| 2868 | |
| 2869 (defun gnus-sorted-complement (list1 list2) | |
| 2870 "Return a list of elements of LIST1 that do not appear in LIST2. | |
| 2871 Both lists have to be sorted over <." | |
| 2872 (let (out) | |
| 2873 (if (or (null list1) (null list2)) | |
| 2874 (or list1 list2) | |
| 2875 (while (and list1 list2) | |
| 2876 (cond ((= (car list1) (car list2)) | |
| 2877 (setq list1 (cdr list1) | |
| 2878 list2 (cdr list2))) | |
| 2879 ((< (car list1) (car list2)) | |
| 2880 (setq out (cons (car list1) out)) | |
| 2881 (setq list1 (cdr list1))) | |
| 2882 (t | |
| 2883 (setq out (cons (car list2) out)) | |
| 2884 (setq list2 (cdr list2))))) | |
| 2885 (nconc (nreverse out) (or list1 list2))))) | |
| 2886 | |
| 2887 (defun gnus-intersection (list1 list2) | |
| 2888 (let ((result nil)) | |
| 2889 (while list2 | |
| 2890 (if (memq (car list2) list1) | |
| 2891 (setq result (cons (car list2) result))) | |
| 2892 (setq list2 (cdr list2))) | |
| 2893 result)) | |
| 2894 | |
| 2895 (defun gnus-sorted-intersection (list1 list2) | |
| 2896 ;; LIST1 and LIST2 have to be sorted over <. | |
| 2897 (let (out) | |
| 2898 (while (and list1 list2) | |
| 2899 (cond ((= (car list1) (car list2)) | |
| 2900 (setq out (cons (car list1) out) | |
| 2901 list1 (cdr list1) | |
| 2902 list2 (cdr list2))) | |
| 2903 ((< (car list1) (car list2)) | |
| 2904 (setq list1 (cdr list1))) | |
| 2905 (t | |
| 2906 (setq list2 (cdr list2))))) | |
| 2907 (nreverse out))) | |
| 2908 | |
| 2909 (defun gnus-set-sorted-intersection (list1 list2) | |
| 2910 ;; LIST1 and LIST2 have to be sorted over <. | |
| 2911 ;; This function modifies LIST1. | |
| 2912 (let* ((top (cons nil list1)) | |
| 2913 (prev top)) | |
| 2914 (while (and list1 list2) | |
| 2915 (cond ((= (car list1) (car list2)) | |
| 2916 (setq prev list1 | |
| 2917 list1 (cdr list1) | |
| 2918 list2 (cdr list2))) | |
| 2919 ((< (car list1) (car list2)) | |
| 2920 (setcdr prev (cdr list1)) | |
| 2921 (setq list1 (cdr list1))) | |
| 2922 (t | |
| 2923 (setq list2 (cdr list2))))) | |
| 2924 (setcdr prev nil) | |
| 2925 (cdr top))) | |
| 2926 | |
| 2927 (defun gnus-compress-sequence (numbers &optional always-list) | |
| 2928 "Convert list of numbers to a list of ranges or a single range. | |
| 2929 If ALWAYS-LIST is non-nil, this function will always release a list of | |
| 2930 ranges." | |
| 2931 (let* ((first (car numbers)) | |
| 2932 (last (car numbers)) | |
| 2933 result) | |
| 2934 (if (null numbers) | |
| 2935 nil | |
| 2936 (if (not (listp (cdr numbers))) | |
| 2937 numbers | |
| 2938 (while numbers | |
| 2939 (cond ((= last (car numbers)) nil) ;Omit duplicated number | |
| 2940 ((= (1+ last) (car numbers)) ;Still in sequence | |
| 2941 (setq last (car numbers))) | |
| 2942 (t ;End of one sequence | |
| 2943 (setq result | |
| 2944 (cons (if (= first last) first | |
| 2945 (cons first last)) result)) | |
| 2946 (setq first (car numbers)) | |
| 2947 (setq last (car numbers)))) | |
| 2948 (setq numbers (cdr numbers))) | |
| 2949 (if (and (not always-list) (null result)) | |
| 2950 (if (= first last) (list first) (cons first last)) | |
| 2951 (nreverse (cons (if (= first last) first (cons first last)) | |
| 2952 result))))))) | |
| 2953 | |
| 2954 (defalias 'gnus-uncompress-sequence 'gnus-uncompress-range) | |
| 2955 (defun gnus-uncompress-range (ranges) | |
| 2956 "Expand a list of ranges into a list of numbers. | |
| 2957 RANGES is either a single range on the form `(num . num)' or a list of | |
| 2958 these ranges." | |
| 2959 (let (first last result) | |
| 2960 (cond | |
| 2961 ((null ranges) | |
| 2962 nil) | |
| 2963 ((not (listp (cdr ranges))) | |
| 2964 (setq first (car ranges)) | |
| 2965 (setq last (cdr ranges)) | |
| 2966 (while (<= first last) | |
| 2967 (setq result (cons first result)) | |
| 2968 (setq first (1+ first))) | |
| 2969 (nreverse result)) | |
| 2970 (t | |
| 2971 (while ranges | |
| 2972 (if (atom (car ranges)) | |
| 2973 (if (numberp (car ranges)) | |
| 2974 (setq result (cons (car ranges) result))) | |
| 2975 (setq first (car (car ranges))) | |
| 2976 (setq last (cdr (car ranges))) | |
| 2977 (while (<= first last) | |
| 2978 (setq result (cons first result)) | |
| 2979 (setq first (1+ first)))) | |
| 2980 (setq ranges (cdr ranges))) | |
| 2981 (nreverse result))))) | |
| 2982 | |
| 2983 (defun gnus-add-to-range (ranges list) | |
| 2984 "Return a list of ranges that has all articles from both RANGES and LIST. | |
| 2985 Note: LIST has to be sorted over `<'." | |
| 2986 (if (not ranges) | |
| 2987 (gnus-compress-sequence list t) | |
| 2988 (setq list (copy-sequence list)) | |
| 2989 (or (listp (cdr ranges)) | |
| 2990 (setq ranges (list ranges))) | |
| 2991 (let ((out ranges) | |
| 2992 ilist lowest highest temp) | |
| 2993 (while (and ranges list) | |
| 2994 (setq ilist list) | |
| 2995 (setq lowest (or (and (atom (car ranges)) (car ranges)) | |
| 2996 (car (car ranges)))) | |
| 2997 (while (and list (cdr list) (< (car (cdr list)) lowest)) | |
| 2998 (setq list (cdr list))) | |
| 2999 (if (< (car ilist) lowest) | |
| 3000 (progn | |
| 3001 (setq temp list) | |
| 3002 (setq list (cdr list)) | |
| 3003 (setcdr temp nil) | |
| 3004 (setq out (nconc (gnus-compress-sequence ilist t) out)))) | |
| 3005 (setq highest (or (and (atom (car ranges)) (car ranges)) | |
| 3006 (cdr (car ranges)))) | |
| 3007 (while (and list (<= (car list) highest)) | |
| 3008 (setq list (cdr list))) | |
| 3009 (setq ranges (cdr ranges))) | |
| 3010 (if list | |
| 3011 (setq out (nconc (gnus-compress-sequence list t) out))) | |
| 3012 (setq out (sort out (lambda (r1 r2) | |
| 3013 (< (or (and (atom r1) r1) (car r1)) | |
| 3014 (or (and (atom r2) r2) (car r2)))))) | |
| 3015 (setq ranges out) | |
| 3016 (while ranges | |
| 3017 (if (atom (car ranges)) | |
| 3018 (if (cdr ranges) | |
| 3019 (if (atom (car (cdr ranges))) | |
| 3020 (if (= (1+ (car ranges)) (car (cdr ranges))) | |
| 3021 (progn | |
| 3022 (setcar ranges (cons (car ranges) | |
| 3023 (car (cdr ranges)))) | |
| 3024 (setcdr ranges (cdr (cdr ranges))))) | |
| 3025 (if (= (1+ (car ranges)) (car (car (cdr ranges)))) | |
| 3026 (progn | |
| 3027 (setcar (car (cdr ranges)) (car ranges)) | |
| 3028 (setcar ranges (car (cdr ranges))) | |
| 3029 (setcdr ranges (cdr (cdr ranges))))))) | |
| 3030 (if (cdr ranges) | |
| 3031 (if (atom (car (cdr ranges))) | |
| 3032 (if (= (1+ (cdr (car ranges))) (car (cdr ranges))) | |
| 3033 (progn | |
| 3034 (setcdr (car ranges) (car (cdr ranges))) | |
| 3035 (setcdr ranges (cdr (cdr ranges))))) | |
| 3036 (if (= (1+ (cdr (car ranges))) (car (car (cdr ranges)))) | |
| 3037 (progn | |
| 3038 (setcdr (car ranges) (cdr (car (cdr ranges)))) | |
| 3039 (setcdr ranges (cdr (cdr ranges)))))))) | |
| 3040 (setq ranges (cdr ranges))) | |
| 3041 out))) | |
| 3042 | |
| 3043 (defun gnus-remove-from-range (ranges list) | |
| 3044 "Return a list of ranges that has all articles from LIST removed from RANGES. | |
| 3045 Note: LIST has to be sorted over `<'." | |
| 3046 ;; !!! This function shouldn't look like this, but I've got a headache. | |
| 3047 (gnus-compress-sequence | |
| 3048 (gnus-sorted-complement | |
| 3049 (gnus-uncompress-range ranges) list))) | |
| 3050 | |
| 3051 (defun gnus-member-of-range (number ranges) | |
| 3052 (if (not (listp (cdr ranges))) | |
| 3053 (and (>= number (car ranges)) | |
| 3054 (<= number (cdr ranges))) | |
| 3055 (let ((not-stop t)) | |
| 3056 (while (and ranges | |
| 3057 (if (numberp (car ranges)) | |
| 3058 (>= number (car ranges)) | |
| 3059 (>= number (car (car ranges)))) | |
| 3060 not-stop) | |
| 3061 (if (if (numberp (car ranges)) | |
| 3062 (= number (car ranges)) | |
| 3063 (and (>= number (car (car ranges))) | |
| 3064 (<= number (cdr (car ranges))))) | |
| 3065 (setq not-stop nil)) | |
| 3066 (setq ranges (cdr ranges))) | |
| 3067 (not not-stop)))) | |
| 3068 | |
| 3069 | |
| 3070 ;;; | |
| 3071 ;;; Gnus group mode | |
| 3072 ;;; | |
| 3073 | |
| 3074 (defvar gnus-group-mode-map nil) | |
| 3075 (defvar gnus-group-group-map nil) | |
| 3076 (defvar gnus-group-mark-map nil) | |
| 3077 (defvar gnus-group-list-map nil) | |
| 3078 (defvar gnus-group-sub-map nil) | |
| 3079 (put 'gnus-group-mode 'mode-class 'special) | |
| 3080 | |
| 3081 (if gnus-group-mode-map | |
| 3082 nil | |
| 3083 (setq gnus-group-mode-map (make-keymap)) | |
| 3084 (suppress-keymap gnus-group-mode-map) | |
| 3085 (define-key gnus-group-mode-map " " 'gnus-group-read-group) | |
| 3086 (define-key gnus-group-mode-map "=" 'gnus-group-select-group) | |
| 3087 (define-key gnus-group-mode-map "\r" 'gnus-group-select-group) | |
| 3088 (define-key gnus-group-mode-map "j" 'gnus-group-jump-to-group) | |
| 3089 (define-key gnus-group-mode-map "n" 'gnus-group-next-unread-group) | |
| 3090 (define-key gnus-group-mode-map "p" 'gnus-group-prev-unread-group) | |
| 3091 (define-key gnus-group-mode-map "\177" 'gnus-group-prev-unread-group) | |
| 3092 (define-key gnus-group-mode-map "N" 'gnus-group-next-group) | |
| 3093 (define-key gnus-group-mode-map "P" 'gnus-group-prev-group) | |
| 3094 (define-key gnus-group-mode-map | |
| 3095 "\M-n" 'gnus-group-next-unread-group-same-level) | |
| 3096 (define-key gnus-group-mode-map | |
| 3097 "\M-p" 'gnus-group-prev-unread-group-same-level) | |
| 3098 (define-key gnus-group-mode-map "," 'gnus-group-best-unread-group) | |
| 3099 (define-key gnus-group-mode-map "." 'gnus-group-first-unread-group) | |
| 3100 (define-key gnus-group-mode-map "u" 'gnus-group-unsubscribe-current-group) | |
| 3101 (define-key gnus-group-mode-map "U" 'gnus-group-unsubscribe-group) | |
| 3102 (define-key gnus-group-mode-map "c" 'gnus-group-catchup-current) | |
| 3103 (define-key gnus-group-mode-map "C" 'gnus-group-catchup-current-all) | |
| 3104 (define-key gnus-group-mode-map "l" 'gnus-group-list-groups) | |
| 3105 (define-key gnus-group-mode-map "L" 'gnus-group-list-all-groups) | |
| 3106 (define-key gnus-group-mode-map "m" 'gnus-group-mail) | |
| 3107 (define-key gnus-group-mode-map "g" 'gnus-group-get-new-news) | |
| 3108 (define-key gnus-group-mode-map "\M-g" 'gnus-group-get-new-news-this-group) | |
| 3109 (define-key gnus-group-mode-map "R" 'gnus-group-restart) | |
| 3110 (define-key gnus-group-mode-map "r" 'gnus-group-read-init-file) | |
| 3111 (define-key gnus-group-mode-map "B" 'gnus-group-browse-foreign-server) | |
| 3112 (define-key gnus-group-mode-map "b" 'gnus-group-check-bogus-groups) | |
| 3113 (define-key gnus-group-mode-map "F" 'gnus-find-new-newsgroups) | |
| 3114 (define-key gnus-group-mode-map "\C-c\C-d" 'gnus-group-describe-group) | |
| 3115 (define-key gnus-group-mode-map "\M-d" 'gnus-group-describe-all-groups) | |
| 3116 (define-key gnus-group-mode-map "\C-c\C-a" 'gnus-group-apropos) | |
| 3117 (define-key gnus-group-mode-map "\C-c\M-\C-a" 'gnus-group-description-apropos) | |
| 3118 (define-key gnus-group-mode-map "a" 'gnus-group-post-news) | |
| 3119 (define-key gnus-group-mode-map "\ek" 'gnus-group-edit-local-kill) | |
| 3120 (define-key gnus-group-mode-map "\eK" 'gnus-group-edit-global-kill) | |
| 3121 (define-key gnus-group-mode-map "\C-k" 'gnus-group-kill-group) | |
| 3122 (define-key gnus-group-mode-map "\C-y" 'gnus-group-yank-group) | |
| 3123 (define-key gnus-group-mode-map "\C-w" 'gnus-group-kill-region) | |
| 3124 (define-key gnus-group-mode-map "\C-x\C-t" 'gnus-group-transpose-groups) | |
| 3125 (define-key gnus-group-mode-map "\C-c\C-l" 'gnus-group-list-killed) | |
| 3126 (define-key gnus-group-mode-map "\C-c\C-x" 'gnus-group-expire-articles) | |
| 3127 (define-key gnus-group-mode-map "\C-c\M-\C-x" 'gnus-group-expire-all-groups) | |
| 3128 (define-key gnus-group-mode-map "V" 'gnus-version) | |
| 3129 (define-key gnus-group-mode-map "s" 'gnus-group-save-newsrc) | |
| 3130 (define-key gnus-group-mode-map "z" 'gnus-group-suspend) | |
| 3131 (define-key gnus-group-mode-map "Z" 'gnus-group-clear-dribble) | |
| 3132 (define-key gnus-group-mode-map "q" 'gnus-group-exit) | |
| 3133 (define-key gnus-group-mode-map "Q" 'gnus-group-quit) | |
| 3134 (define-key gnus-group-mode-map "\M-f" 'gnus-group-fetch-faq) | |
| 3135 (define-key gnus-group-mode-map "?" 'gnus-group-describe-briefly) | |
| 3136 (define-key gnus-group-mode-map "\C-c\C-i" 'gnus-info-find-node) | |
| 3137 (define-key gnus-group-mode-map "\M-e" 'gnus-group-edit-group-method) | |
| 3138 (define-key gnus-group-mode-map "^" 'gnus-group-enter-server-mode) | |
| 3139 (define-key gnus-group-mode-map gnus-mouse-2 'gnus-mouse-pick-group) | |
| 3140 (define-key gnus-group-mode-map "<" 'beginning-of-buffer) | |
| 3141 (define-key gnus-group-mode-map ">" 'end-of-buffer) | |
| 3142 (define-key gnus-group-mode-map "\C-c\C-b" 'gnus-bug) | |
| 3143 (define-key gnus-group-mode-map "\C-c\C-s" 'gnus-group-sort-groups) | |
| 3144 | |
| 3145 (define-key gnus-group-mode-map "#" 'gnus-group-mark-group) | |
| 3146 (define-key gnus-group-mode-map "\M-#" 'gnus-group-unmark-group) | |
| 3147 (define-prefix-command 'gnus-group-mark-map) | |
| 3148 (define-key gnus-group-mode-map "M" 'gnus-group-mark-map) | |
| 3149 (define-key gnus-group-mark-map "m" 'gnus-group-mark-group) | |
| 3150 (define-key gnus-group-mark-map "u" 'gnus-group-unmark-group) | |
| 3151 (define-key gnus-group-mark-map "w" 'gnus-group-mark-region) | |
| 3152 | |
| 3153 (define-prefix-command 'gnus-group-group-map) | |
| 3154 (define-key gnus-group-mode-map "G" 'gnus-group-group-map) | |
| 3155 (define-key gnus-group-group-map "d" 'gnus-group-make-directory-group) | |
| 3156 (define-key gnus-group-group-map "h" 'gnus-group-make-help-group) | |
| 3157 (define-key gnus-group-group-map "a" 'gnus-group-make-archive-group) | |
| 3158 (define-key gnus-group-group-map "k" 'gnus-group-make-kiboze-group) | |
| 3159 (define-key gnus-group-group-map "m" 'gnus-group-make-group) | |
| 3160 (define-key gnus-group-group-map "E" 'gnus-group-edit-group) | |
| 3161 (define-key gnus-group-group-map "e" 'gnus-group-edit-group-method) | |
| 3162 (define-key gnus-group-group-map "p" 'gnus-group-edit-group-parameters) | |
| 3163 (define-key gnus-group-group-map "v" 'gnus-group-add-to-virtual) | |
| 3164 (define-key gnus-group-group-map "V" 'gnus-group-make-empty-virtual) | |
| 3165 (define-key gnus-group-group-map "D" 'gnus-group-enter-directory) | |
| 3166 (define-key gnus-group-group-map "f" 'gnus-group-make-doc-group) | |
| 3167 ;;(define-key gnus-group-group-map "sb" 'gnus-group-brew-soup) | |
| 3168 ;;(define-key gnus-group-group-map "sw" 'gnus-soup-save-areas) | |
| 3169 ;;(define-key gnus-group-group-map "ss" 'gnus-soup-send-replies) | |
| 3170 ;;(define-key gnus-group-group-map "sp" 'gnus-soup-pack-packet) | |
| 3171 ;;(define-key gnus-group-group-map "sr" 'nnsoup-pack-replies) | |
| 3172 | |
| 3173 (define-prefix-command 'gnus-group-list-map) | |
| 3174 (define-key gnus-group-mode-map "A" 'gnus-group-list-map) | |
| 3175 (define-key gnus-group-list-map "k" 'gnus-group-list-killed) | |
| 3176 (define-key gnus-group-list-map "z" 'gnus-group-list-zombies) | |
| 3177 (define-key gnus-group-list-map "s" 'gnus-group-list-groups) | |
| 3178 (define-key gnus-group-list-map "u" 'gnus-group-list-all-groups) | |
| 3179 (define-key gnus-group-list-map "a" 'gnus-group-apropos) | |
| 3180 (define-key gnus-group-list-map "d" 'gnus-group-description-apropos) | |
| 3181 (define-key gnus-group-list-map "m" 'gnus-group-list-matching) | |
| 3182 (define-key gnus-group-list-map "M" 'gnus-group-list-all-matching) | |
| 3183 | |
| 3184 (define-prefix-command 'gnus-group-sub-map) | |
| 3185 (define-key gnus-group-mode-map "S" 'gnus-group-sub-map) | |
| 3186 (define-key gnus-group-sub-map "l" 'gnus-group-set-current-level) | |
| 3187 (define-key gnus-group-sub-map "t" 'gnus-group-unsubscribe-current-group) | |
| 3188 (define-key gnus-group-sub-map "s" 'gnus-group-unsubscribe-group) | |
| 3189 (define-key gnus-group-sub-map "k" 'gnus-group-kill-group) | |
| 3190 (define-key gnus-group-sub-map "y" 'gnus-group-yank-group) | |
| 3191 (define-key gnus-group-sub-map "w" 'gnus-group-kill-region) | |
| 3192 (define-key gnus-group-sub-map "z" 'gnus-group-kill-all-zombies)) | |
| 3193 | |
| 3194 (defun gnus-group-mode () | |
| 3195 "Major mode for reading news. | |
| 3196 | |
| 3197 All normal editing commands are switched off. | |
| 3198 \\<gnus-group-mode-map> | |
| 3199 The group buffer lists (some of) the groups available. For instance, | |
| 3200 `\\[gnus-group-list-groups]' will list all subscribed groups with unread articles, while `\\[gnus-group-list-zombies]' | |
| 3201 lists all zombie groups. | |
| 3202 | |
| 3203 Groups that are displayed can be entered with `\\[gnus-group-read-group]'. To subscribe | |
| 3204 to a group not displayed, type `\\[gnus-group-unsubscribe-group]'. | |
| 3205 | |
| 3206 For more in-depth information on this mode, read the manual (`\\[gnus-info-find-node]'). | |
| 3207 | |
| 3208 The following commands are available: | |
| 3209 | |
| 3210 \\{gnus-group-mode-map}" | |
| 3211 (interactive) | |
| 3212 (if gnus-visual (gnus-group-make-menu-bar)) | |
| 3213 (kill-all-local-variables) | |
| 3214 (setq mode-line-modified "-- ") | |
| 3215 (make-local-variable 'mode-line-format) | |
| 3216 (setq mode-line-format (copy-sequence mode-line-format)) | |
| 3217 (and (equal (nth 3 mode-line-format) " ") | |
| 3218 (setcar (nthcdr 3 mode-line-format) "")) | |
| 3219 (setq major-mode 'gnus-group-mode) | |
| 3220 (setq mode-name "Group") | |
| 3221 (gnus-group-set-mode-line) | |
| 3222 (setq mode-line-process nil) | |
| 3223 (use-local-map gnus-group-mode-map) | |
| 3224 (buffer-disable-undo (current-buffer)) | |
| 3225 (setq truncate-lines t) | |
| 3226 (setq buffer-read-only t) | |
| 3227 (run-hooks 'gnus-group-mode-hook)) | |
| 3228 | |
| 3229 (defun gnus-mouse-pick-group (e) | |
| 3230 (interactive "e") | |
| 3231 (mouse-set-point e) | |
| 3232 (gnus-group-read-group nil)) | |
| 3233 | |
| 3234 ;; Look at LEVEL and find out what the level is really supposed to be. | |
| 3235 ;; If LEVEL is non-nil, LEVEL will be returned, if not, what happens | |
| 3236 ;; will depend on whether `gnus-group-use-permanent-levels' is used. | |
| 3237 (defun gnus-group-default-level (&optional level number-or-nil) | |
| 3238 (cond | |
| 3239 (gnus-group-use-permanent-levels | |
| 3240 (setq gnus-group-default-list-level | |
| 3241 (or level gnus-group-default-list-level)) | |
| 3242 (or gnus-group-default-list-level gnus-level-subscribed)) | |
| 3243 (number-or-nil | |
| 3244 level) | |
| 3245 (t | |
| 3246 (or level gnus-group-default-list-level gnus-level-subscribed)))) | |
| 3247 | |
| 3248 | |
| 3249 (defvar gnus-tmp-prev-perm nil) | |
| 3250 | |
| 3251 ;;;###autoload | |
| 3252 (defun gnus-no-server (&optional arg) | |
| 3253 "Read network news. | |
| 3254 If ARG is a positive number, Gnus will use that as the | |
| 3255 startup level. If ARG is nil, Gnus will be started at level 2. | |
| 3256 If ARG is non-nil and not a positive number, Gnus will | |
| 3257 prompt the user for the name of an NNTP server to use. | |
| 3258 As opposed to `gnus', this command will not connect to the local server." | |
| 3259 (interactive "P") | |
| 3260 (let ((perm | |
| 3261 (cons gnus-group-use-permanent-levels gnus-group-default-list-level))) | |
| 3262 (setq gnus-tmp-prev-perm nil) | |
| 3263 (setq gnus-group-use-permanent-levels t) | |
| 3264 (gnus (or arg (1- gnus-level-default-subscribed)) t) | |
| 3265 (setq gnus-tmp-prev-perm perm))) | |
| 3266 | |
| 3267 ;;;###autoload | |
| 3268 (defun gnus (&optional arg dont-connect) | |
| 3269 "Read network news. | |
| 3270 If ARG is non-nil and a positive number, Gnus will use that as the | |
| 3271 startup level. If ARG is non-nil and not a positive number, Gnus will | |
| 3272 prompt the user for the name of an NNTP server to use." | |
| 3273 (interactive "P") | |
| 3274 (if (get-buffer gnus-group-buffer) | |
| 3275 (progn | |
| 3276 (switch-to-buffer gnus-group-buffer) | |
| 3277 (gnus-group-get-new-news)) | |
| 3278 | |
| 3279 (gnus-clear-system) | |
| 3280 | |
| 3281 (nnheader-init-server-buffer) | |
| 3282 ;; We do this if `gnus-no-server' has been run. | |
| 3283 (if gnus-tmp-prev-perm | |
| 3284 (setq gnus-group-use-permanent-levels (car gnus-tmp-prev-perm) | |
| 3285 gnus-group-default-list-level (cdr gnus-tmp-prev-perm) | |
| 3286 gnus-tmp-prev-perm nil)) | |
| 3287 (gnus-read-init-file) | |
| 3288 | |
| 3289 (gnus-group-setup-buffer) | |
| 3290 (let ((buffer-read-only nil)) | |
| 3291 (erase-buffer) | |
| 3292 (if (not gnus-inhibit-startup-message) | |
| 3293 (progn | |
| 3294 (gnus-group-startup-message) | |
| 3295 (sit-for 0)))) | |
| 3296 | |
| 3297 (let ((level (and arg (numberp arg) (> arg 0) arg)) | |
| 3298 did-connect) | |
| 3299 (unwind-protect | |
| 3300 (progn | |
| 3301 (or dont-connect | |
| 3302 (setq did-connect | |
| 3303 (gnus-start-news-server (and arg (not level)))))) | |
| 3304 (if (and (not dont-connect) | |
| 3305 (not did-connect)) | |
| 3306 (gnus-group-quit) | |
| 3307 (run-hooks 'gnus-startup-hook) | |
| 3308 ;; NNTP server is successfully open. | |
| 3309 | |
| 3310 ;; Find the current startup file name. | |
| 3311 (setq gnus-current-startup-file | |
| 3312 (gnus-make-newsrc-file gnus-startup-file)) | |
| 3313 | |
| 3314 ;; Read the dribble file. | |
| 3315 (and gnus-use-dribble-file (gnus-dribble-read-file)) | |
| 3316 | |
| 3317 (gnus-summary-make-display-table) | |
| 3318 (gnus-setup-news nil level) | |
| 3319 (gnus-group-list-groups level) | |
| 3320 (gnus-configure-windows 'group)))))) | |
| 3321 | |
| 3322 (defun gnus-unload () | |
| 3323 "Unload all Gnus features." | |
| 3324 (interactive) | |
| 3325 (or (boundp 'load-history) | |
| 3326 (error "Sorry, `gnus-unload' is not implemented in this Emacs version.")) | |
| 3327 (let ((history load-history) | |
| 3328 feature) | |
| 3329 (while history | |
| 3330 (and (string-match "^gnus" (car (car history))) | |
| 3331 (setq feature (cdr (assq 'provide (car history)))) | |
| 3332 (unload-feature feature 'force)) | |
| 3333 (setq history (cdr history))))) | |
| 3334 | |
| 3335 (defun gnus-group-startup-message (&optional x y) | |
| 3336 "Insert startup message in current buffer." | |
| 3337 ;; Insert the message. | |
| 3338 (erase-buffer) | |
| 3339 (insert | |
| 3340 (format " | |
| 3341 _ ___ _ _ | |
| 3342 _ ___ __ ___ __ _ ___ | |
| 3343 __ _ ___ __ ___ | |
| 3344 _ ___ _ | |
| 3345 _ _ __ _ | |
| 3346 ___ __ _ | |
| 3347 __ _ | |
| 3348 _ _ _ | |
| 3349 _ _ _ | |
| 3350 _ _ _ | |
| 3351 __ ___ | |
| 3352 _ _ _ _ | |
| 3353 _ _ | |
| 3354 _ _ | |
| 3355 _ _ | |
| 3356 _ | |
| 3357 __ | |
| 3358 | |
| 3359 | |
| 3360 Gnus * A newsreader for Emacsen | |
| 3361 A Praxis release * larsi@ifi.uio.no | |
| 3362 " | |
| 3363 gnus-version)) | |
| 3364 ;; And then hack it. | |
| 3365 ;; 18 is the longest line. | |
| 3366 (indent-rigidly (point-min) (point-max) | |
| 3367 (/ (max (- (window-width) (or x 46)) 0) 2)) | |
| 3368 (goto-char (point-min)) | |
| 3369 (let* ((pheight (count-lines (point-min) (point-max))) | |
| 3370 (wheight (window-height)) | |
| 3371 (rest (- wheight pheight))) | |
| 3372 (insert (make-string (max 0 (* 2 (/ rest 3))) ?\n))) | |
| 3373 | |
| 3374 | |
| 3375 | |
| 3376 ;; Fontify some. | |
| 3377 (goto-char (point-min)) | |
| 3378 (search-forward "Praxis") | |
| 3379 (put-text-property (match-beginning 0) (match-end 0) 'face 'bold) | |
| 3380 (goto-char (point-min))) | |
| 3381 | |
| 3382 (defun gnus-group-startup-message-old (&optional x y) | |
| 3383 "Insert startup message in current buffer." | |
| 3384 ;; Insert the message. | |
| 3385 (erase-buffer) | |
| 3386 (insert | |
| 3387 (format " | |
| 3388 %s | |
| 3389 A newsreader | |
| 3390 for GNU Emacs | |
| 3391 | |
| 3392 Based on GNUS | |
| 3393 written by | |
| 3394 Masanobu UMEDA | |
| 3395 | |
| 3396 A Praxis Release | |
| 3397 larsi@ifi.uio.no | |
| 3398 " | |
| 3399 gnus-version)) | |
| 3400 ;; And then hack it. | |
| 3401 ;; 18 is the longest line. | |
| 3402 (indent-rigidly (point-min) (point-max) | |
| 3403 (/ (max (- (window-width) (or x 28)) 0) 2)) | |
| 3404 (goto-char (point-min)) | |
| 3405 ;; +4 is fuzzy factor. | |
| 3406 (insert-char ?\n (/ (max (- (window-height) (or y 12)) 0) 2)) | |
| 3407 | |
| 3408 ;; Fontify some. | |
| 3409 (goto-char (point-min)) | |
| 3410 (search-forward "Praxis") | |
| 3411 (put-text-property (match-beginning 0) (match-end 0) 'face 'bold) | |
| 3412 (goto-char (point-min))) | |
| 3413 | |
| 3414 (defun gnus-group-setup-buffer () | |
| 3415 (or (get-buffer gnus-group-buffer) | |
| 3416 (progn | |
| 3417 (switch-to-buffer gnus-group-buffer) | |
| 3418 (gnus-add-current-to-buffer-list) | |
| 3419 (gnus-group-mode) | |
| 3420 (and gnus-carpal (gnus-carpal-setup-buffer 'group))))) | |
| 3421 | |
| 3422 (defun gnus-group-list-groups (&optional level unread) | |
| 3423 "List newsgroups with level LEVEL or lower that have unread articles. | |
| 3424 Default is all subscribed groups. | |
| 3425 If argument UNREAD is non-nil, groups with no unread articles are also | |
| 3426 listed." | |
| 3427 (interactive (list (if current-prefix-arg | |
| 3428 (prefix-numeric-value current-prefix-arg) | |
| 3429 (or | |
| 3430 (gnus-group-default-level nil t) | |
| 3431 gnus-group-default-list-level | |
| 3432 gnus-level-subscribed)))) | |
| 3433 (or level | |
| 3434 (setq level (car gnus-group-list-mode) | |
| 3435 unread (cdr gnus-group-list-mode))) | |
| 3436 (setq level (gnus-group-default-level level)) | |
| 3437 (gnus-group-setup-buffer) ;May call from out of group buffer | |
| 3438 (let ((case-fold-search nil) | |
| 3439 (group (gnus-group-group-name))) | |
| 3440 (funcall gnus-group-prepare-function level unread nil) | |
| 3441 (if (zerop (buffer-size)) | |
| 3442 (gnus-message 5 gnus-no-groups-message) | |
| 3443 (goto-char (point-min)) | |
| 3444 (if (not group) | |
| 3445 ;; Go to the first group with unread articles. | |
| 3446 (gnus-group-search-forward nil nil nil t) | |
| 3447 ;; Find the right group to put point on. If the current group | |
| 3448 ;; has disapeared in the new listing, try to find the next | |
| 3449 ;; one. If no next one can be found, just leave point at the | |
| 3450 ;; first newsgroup in the buffer. | |
| 3451 (if (not (gnus-goto-char | |
| 3452 (text-property-any (point-min) (point-max) | |
| 3453 'gnus-group (intern group)))) | |
| 3454 (let ((newsrc (nthcdr 3 (gnus-gethash group gnus-newsrc-hashtb)))) | |
| 3455 (while (and newsrc | |
| 3456 (not (gnus-goto-char | |
| 3457 (text-property-any | |
| 3458 (point-min) (point-max) 'gnus-group | |
| 3459 (intern (car (car newsrc))))))) | |
| 3460 (setq newsrc (cdr newsrc))) | |
| 3461 (or newsrc (progn (goto-char (point-max)) | |
| 3462 (forward-line -1)))))) | |
| 3463 ;; Adjust cursor point. | |
| 3464 (gnus-group-position-cursor)))) | |
| 3465 | |
| 3466 (defun gnus-group-prepare-flat (level &optional all lowest regexp) | |
| 3467 "List all newsgroups with unread articles of level LEVEL or lower. | |
| 3468 If ALL is non-nil, list groups that have no unread articles. | |
| 3469 If LOWEST is non-nil, list all newsgroups of level LOWEST or higher. | |
| 3470 If REGEXP, only list groups matching REGEXP." | |
| 3471 (set-buffer gnus-group-buffer) | |
| 3472 (let ((buffer-read-only nil) | |
| 3473 (newsrc (cdr gnus-newsrc-alist)) | |
| 3474 (lowest (or lowest 1)) | |
| 3475 info clevel unread group) | |
| 3476 (erase-buffer) | |
| 3477 (if (< lowest gnus-level-zombie) | |
| 3478 ;; List living groups. | |
| 3479 (while newsrc | |
| 3480 (setq info (car newsrc) | |
| 3481 group (car info) | |
| 3482 newsrc (cdr newsrc) | |
| 3483 unread (car (gnus-gethash group gnus-newsrc-hashtb))) | |
| 3484 (and unread ; This group might be bogus | |
| 3485 (or (not regexp) | |
| 3486 (string-match regexp group)) | |
| 3487 (<= (setq clevel (car (cdr info))) level) | |
| 3488 (>= clevel lowest) | |
| 3489 (or all ; We list all groups? | |
| 3490 (eq unread t) ; We list unactivated groups | |
| 3491 (> unread 0) ; We list groups with unread articles | |
| 3492 (cdr (assq 'tick (nth 3 info)))) ; And groups with tickeds | |
| 3493 (gnus-group-insert-group-line | |
| 3494 nil group (car (cdr info)) (nth 3 info) unread (nth 4 info))))) | |
| 3495 | |
| 3496 ;; List dead groups. | |
| 3497 (and (>= level gnus-level-zombie) (<= lowest gnus-level-zombie) | |
| 3498 (gnus-group-prepare-flat-list-dead | |
| 3499 (setq gnus-zombie-list (sort gnus-zombie-list 'string<)) | |
| 3500 gnus-level-zombie ?Z | |
| 3501 regexp)) | |
| 3502 (and (>= level gnus-level-killed) (<= lowest gnus-level-killed) | |
| 3503 (gnus-group-prepare-flat-list-dead | |
| 3504 (setq gnus-killed-list (sort gnus-killed-list 'string<)) | |
| 3505 gnus-level-killed ?K regexp)) | |
| 3506 | |
| 3507 (gnus-group-set-mode-line) | |
| 3508 (setq gnus-group-list-mode (cons level all)) | |
| 3509 (run-hooks 'gnus-group-prepare-hook))) | |
| 3510 | |
| 3511 (defun gnus-group-prepare-flat-list-dead (groups level mark regexp) | |
| 3512 ;; List zombies and killed lists somehwat faster, which was | |
| 3513 ;; suggested by Jack Vinson <vinson@unagi.cis.upenn.edu>. It does | |
| 3514 ;; this by ignoring the group format specification altogether. | |
| 3515 (let (group beg) | |
| 3516 (while groups | |
| 3517 (setq group (car groups) | |
| 3518 groups (cdr groups)) | |
| 3519 (if (or (not regexp) | |
| 3520 (string-match regexp group)) | |
| 3521 (progn | |
| 3522 (setq beg (point)) | |
| 3523 (insert (format " %c *: %s\n" mark group)) | |
| 3524 (add-text-properties | |
| 3525 beg (1+ beg) | |
| 3526 (list 'gnus-group (intern group) | |
| 3527 'gnus-unread t | |
| 3528 'gnus-level level))))))) | |
| 3529 | |
| 3530 (defun gnus-group-real-name (group) | |
| 3531 "Find the real name of a foreign newsgroup." | |
| 3532 (if (string-match ":[^:]+$" group) | |
| 3533 (substring group (1+ (match-beginning 0))) | |
| 3534 group)) | |
| 3535 | |
| 3536 (defun gnus-group-prefixed-name (group method) | |
| 3537 "Return the whole name from GROUP and METHOD." | |
| 3538 (and (stringp method) (setq method (gnus-server-to-method method))) | |
| 3539 (concat (format "%s" (car method)) | |
| 3540 (if (and | |
| 3541 (assoc (format "%s" (car method)) (gnus-methods-using 'address)) | |
| 3542 (not (string= (nth 1 method) ""))) | |
| 3543 (concat "+" (nth 1 method))) | |
| 3544 ":" group)) | |
| 3545 | |
| 3546 (defun gnus-group-real-prefix (group) | |
| 3547 "Return the prefix of the current group name." | |
| 3548 (if (string-match "^[^:]+:" group) | |
| 3549 (substring group 0 (match-end 0)) | |
| 3550 "")) | |
| 3551 | |
| 3552 (defun gnus-group-method-name (group) | |
| 3553 "Return the method used for selecting GROUP." | |
| 3554 (let ((prefix (gnus-group-real-prefix group))) | |
| 3555 (if (equal prefix "") | |
| 3556 gnus-select-method | |
| 3557 (if (string-match "^[^\\+]+\\+" prefix) | |
| 3558 (list (intern (substring prefix 0 (1- (match-end 0)))) | |
| 3559 (substring prefix (match-end 0) (1- (length prefix)))) | |
| 3560 (list (intern (substring prefix 0 (1- (length prefix)))) ""))))) | |
| 3561 | |
| 3562 (defun gnus-group-foreign-p (group) | |
| 3563 "Return nil if GROUP is native, non-nil if it is foreign." | |
| 3564 (string-match ":" group)) | |
| 3565 | |
| 3566 (defun gnus-group-set-info (info &optional method-only-group part) | |
| 3567 (let* ((entry (gnus-gethash | |
| 3568 (or method-only-group (car info)) gnus-newsrc-hashtb)) | |
| 3569 (part-info info) | |
| 3570 (info (if method-only-group (nth 2 entry) info))) | |
| 3571 (if (not method-only-group) | |
| 3572 () | |
| 3573 (or entry | |
| 3574 (error "Trying to change non-existent group %s" method-only-group)) | |
| 3575 ;; We have recevied parts of the actual group info - either the | |
| 3576 ;; select method or the group parameters. We first check | |
| 3577 ;; whether we have to extend the info, and if so, do that. | |
| 3578 (let ((len (length info)) | |
| 3579 (total (if (eq part 'method) 5 6))) | |
| 3580 (and (< len total) | |
| 3581 (setcdr (nthcdr (1- len) info) | |
| 3582 (make-list (- total len) nil))) | |
| 3583 ;; Then we enter the new info. | |
| 3584 (setcar (nthcdr (1- total) info) part-info))) | |
| 3585 ;; We uncompress some lists of marked articles. | |
| 3586 (let (marked) | |
| 3587 (if (not (setq marked (nth 3 info))) | |
| 3588 () | |
| 3589 (while marked | |
| 3590 (or (eq 'score (car (car marked))) | |
| 3591 (eq 'bookmark (car (car marked))) | |
| 3592 (eq 'killed (car (car marked))) | |
| 3593 (setcdr (car marked) | |
| 3594 (gnus-uncompress-range (cdr (car marked))))) | |
| 3595 (setq marked (cdr marked))))) | |
| 3596 (if entry | |
| 3597 () | |
| 3598 ;; This is a new group, so we just create it. | |
| 3599 (save-excursion | |
| 3600 (set-buffer gnus-group-buffer) | |
| 3601 (if (nth 4 info) | |
| 3602 ;; It's a foreign group... | |
| 3603 (gnus-group-make-group | |
| 3604 (gnus-group-real-name (car info)) | |
| 3605 (prin1-to-string (car (nth 4 info))) | |
| 3606 (nth 1 (nth 4 info))) | |
| 3607 ;; It's a native group. | |
| 3608 (gnus-group-make-group (car info))) | |
| 3609 (gnus-message 6 "Note: New group created") | |
| 3610 (setq entry | |
| 3611 (gnus-gethash (gnus-group-prefixed-name | |
| 3612 (gnus-group-real-name (car info)) | |
| 3613 (or (nth 4 info) gnus-select-method)) | |
| 3614 gnus-newsrc-hashtb)))) | |
| 3615 ;; Whether it was a new group or not, we now have the entry, so we | |
| 3616 ;; can do the update. | |
| 3617 (if entry | |
| 3618 (progn | |
| 3619 (setcar (nthcdr 2 entry) info) | |
| 3620 (if (and (not (eq (car entry) t)) | |
| 3621 (gnus-gethash (car info) gnus-active-hashtb)) | |
| 3622 (let ((marked (nth 3 info))) | |
| 3623 (setcar entry | |
| 3624 (max 0 (- (length (gnus-list-of-unread-articles | |
| 3625 (car info))) | |
| 3626 (length (cdr (assq 'tick marked))) | |
| 3627 (length (cdr (assq 'dormant marked))))))))) | |
| 3628 (error "No such group: %s" (car info))))) | |
| 3629 | |
| 3630 (defun gnus-group-set-method-info (group select-method) | |
| 3631 (gnus-group-set-info select-method group 'method)) | |
| 3632 | |
| 3633 (defun gnus-group-set-params-info (group params) | |
| 3634 (gnus-group-set-info params group 'params)) | |
| 3635 | |
| 3636 (defun gnus-group-update-group-line () | |
| 3637 "This function updates the current line in the newsgroup buffer and | |
| 3638 moves the point to the colon." | |
| 3639 (let* ((buffer-read-only nil) | |
| 3640 (group (gnus-group-group-name)) | |
| 3641 (entry (and group (gnus-gethash group gnus-newsrc-hashtb)))) | |
| 3642 (if (and entry (not (gnus-ephemeral-group-p group))) | |
| 3643 (gnus-dribble-enter | |
| 3644 (concat "(gnus-group-set-info '" (prin1-to-string (nth 2 entry)) | |
| 3645 ")"))) | |
| 3646 (beginning-of-line) | |
| 3647 (delete-region (point) (progn (forward-line 1) (point))) | |
| 3648 (gnus-group-insert-group-line-info group) | |
| 3649 (forward-line -1) | |
| 3650 (gnus-group-position-cursor))) | |
| 3651 | |
| 3652 (defun gnus-group-insert-group-line-info (group) | |
| 3653 (let ((entry (gnus-gethash group gnus-newsrc-hashtb)) | |
| 3654 active info) | |
| 3655 (if entry | |
| 3656 (progn | |
| 3657 (setq info (nth 2 entry)) | |
| 3658 (gnus-group-insert-group-line | |
| 3659 nil group (nth 1 info) (nth 3 info) (car entry) (nth 4 info))) | |
| 3660 (setq active (gnus-gethash group gnus-active-hashtb)) | |
| 3661 (gnus-group-insert-group-line | |
| 3662 nil group | |
| 3663 (if (member group gnus-zombie-list) gnus-level-zombie gnus-level-killed) | |
| 3664 nil (if active (- (1+ (cdr active)) (car active)) 0) nil)))) | |
| 3665 | |
| 3666 (defun gnus-group-insert-group-line (gformat group level marked number method) | |
| 3667 (let* ((gformat (or gformat gnus-group-line-format-spec)) | |
| 3668 (active (gnus-gethash group gnus-active-hashtb)) | |
| 3669 (number-total (if active (1+ (- (cdr active) (car active))) 0)) | |
| 3670 (number-of-dormant (length (cdr (assq 'dormant marked)))) | |
| 3671 (number-of-ticked (length (cdr (assq 'tick marked)))) | |
| 3672 (number-of-ticked-and-dormant | |
| 3673 (+ number-of-ticked number-of-dormant)) | |
| 3674 (number-of-unread-unticked | |
| 3675 (if (numberp number) (int-to-string (max 0 number)) | |
| 3676 "*")) | |
| 3677 (number-of-read | |
| 3678 (if (numberp number) | |
| 3679 (max 0 (- number-total number)) | |
| 3680 "*")) | |
| 3681 (subscribed (cond ((<= level gnus-level-subscribed) ? ) | |
| 3682 ((<= level gnus-level-unsubscribed) ?U) | |
| 3683 ((= level gnus-level-zombie) ?Z) | |
| 3684 (t ?K))) | |
| 3685 (qualified-group (gnus-group-real-name group)) | |
| 3686 (newsgroup-description | |
| 3687 (if gnus-description-hashtb | |
| 3688 (or (gnus-gethash group gnus-description-hashtb) "") | |
| 3689 "")) | |
| 3690 (moderated (if (member group gnus-moderated-list) ?m ? )) | |
| 3691 (moderated-string (if (eq moderated ?m) "(m)" "")) | |
| 3692 (method (gnus-server-get-method group method)) | |
| 3693 (news-server (or (car (cdr method)) "")) | |
| 3694 (news-method (or (car method) "")) | |
| 3695 (news-method-string | |
| 3696 (if method (format "(%s:%s)" (car method) (car (cdr method))) "")) | |
| 3697 (marked (if (and | |
| 3698 (numberp number) | |
| 3699 (zerop number) | |
| 3700 (> number-of-ticked 0)) | |
| 3701 ?* ? )) | |
| 3702 (number (if (eq number t) "*" (+ number number-of-dormant | |
| 3703 number-of-ticked))) | |
| 3704 (process-marked (if (member group gnus-group-marked) | |
| 3705 gnus-process-mark ? )) | |
| 3706 (buffer-read-only nil) | |
| 3707 header ; passed as parameter to user-funcs. | |
| 3708 b) | |
| 3709 (beginning-of-line) | |
| 3710 (setq b (point)) | |
| 3711 ;; Insert the text. | |
| 3712 (insert (eval gformat)) | |
| 3713 | |
| 3714 (add-text-properties | |
| 3715 b (1+ b) (list 'gnus-group (intern group) | |
| 3716 'gnus-unread (if (numberp number) | |
| 3717 (string-to-int number-of-unread-unticked) | |
| 3718 t) | |
| 3719 'gnus-marked marked | |
| 3720 'gnus-level level)))) | |
| 3721 | |
| 3722 (defun gnus-group-update-group (group &optional visible-only) | |
| 3723 "Update newsgroup info of GROUP. | |
| 3724 If VISIBLE-ONLY is non-nil, the group won't be displayed if it isn't already." | |
| 3725 (save-excursion | |
| 3726 (set-buffer gnus-group-buffer) | |
| 3727 (let ((buffer-read-only nil) | |
| 3728 visible) | |
| 3729 (let ((entry (gnus-gethash group gnus-newsrc-hashtb))) | |
| 3730 (if (and entry | |
| 3731 (not (gnus-ephemeral-group-p group))) | |
| 3732 (gnus-dribble-enter | |
| 3733 (concat "(gnus-group-set-info '" (prin1-to-string (nth 2 entry)) | |
| 3734 ")")))) | |
| 3735 ;; Buffer may be narrowed. | |
| 3736 (save-restriction | |
| 3737 (widen) | |
| 3738 ;; Search a line to modify. If the buffer is large, the search | |
| 3739 ;; takes long time. In most cases, current point is on the line | |
| 3740 ;; we are looking for. So, first of all, check current line. | |
| 3741 (if (or (progn | |
| 3742 (beginning-of-line) | |
| 3743 (eq (get-text-property (point) 'gnus-group) | |
| 3744 (intern group))) | |
| 3745 (progn | |
| 3746 (gnus-goto-char | |
| 3747 (text-property-any | |
| 3748 (point-min) (point-max) 'gnus-group (intern group))))) | |
| 3749 ;; GROUP is listed in current buffer. So, delete old line. | |
| 3750 (progn | |
| 3751 (setq visible t) | |
| 3752 (beginning-of-line) | |
| 3753 (delete-region (point) (progn (forward-line 1) (point)))) | |
| 3754 ;; No such line in the buffer, find out where it's supposed to | |
| 3755 ;; go, and insert it there (or at the end of the buffer). | |
| 3756 ;; Fix by Per Abrahamsen <amanda@iesd.auc.dk>. | |
| 3757 (or visible-only | |
| 3758 (let ((entry | |
| 3759 (cdr (cdr (gnus-gethash group gnus-newsrc-hashtb))))) | |
| 3760 (while (and entry | |
| 3761 (car entry) | |
| 3762 (not | |
| 3763 (gnus-goto-char | |
| 3764 (text-property-any | |
| 3765 (point-min) (point-max) | |
| 3766 'gnus-group (intern (car (car entry))))))) | |
| 3767 (setq entry (cdr entry))) | |
| 3768 (or entry (goto-char (point-max))))))) | |
| 3769 (if (or visible (not visible-only)) | |
| 3770 (gnus-group-insert-group-line-info group)) | |
| 3771 (gnus-group-set-mode-line)))) | |
| 3772 | |
| 3773 (defun gnus-group-set-mode-line () | |
| 3774 (if (memq 'group gnus-updated-mode-lines) | |
| 3775 (let* ((gformat (or gnus-group-mode-line-format-spec | |
| 3776 (setq gnus-group-mode-line-format-spec | |
| 3777 (gnus-parse-format | |
| 3778 gnus-group-mode-line-format | |
| 3779 gnus-group-mode-line-format-alist)))) | |
| 3780 (news-server (car (cdr gnus-select-method))) | |
| 3781 (news-method (car gnus-select-method)) | |
| 3782 (max-len 60) | |
| 3783 (mode-string (eval gformat))) | |
| 3784 (setq mode-string (eval gformat)) | |
| 3785 (if (> (length mode-string) max-len) | |
| 3786 (setq mode-string (substring mode-string 0 (- max-len 4)))) | |
| 3787 (setq mode-line-buffer-identification mode-string) | |
| 3788 (set-buffer-modified-p t)))) | |
| 3789 | |
| 3790 (defun gnus-group-group-name () | |
| 3791 "Get the name of the newsgroup on the current line." | |
| 3792 (let ((group (get-text-property (gnus-point-at-bol) 'gnus-group))) | |
| 3793 (and group (symbol-name group)))) | |
| 3794 | |
| 3795 (defun gnus-group-group-level () | |
| 3796 "Get the level of the newsgroup on the current line." | |
| 3797 (get-text-property (gnus-point-at-bol) 'gnus-level)) | |
| 3798 | |
| 3799 (defun gnus-group-group-unread () | |
| 3800 "Get the number of unread articles of the newsgroup on the current line." | |
| 3801 (get-text-property (gnus-point-at-bol) 'gnus-unread)) | |
| 3802 | |
| 3803 (defun gnus-group-search-forward (&optional backward all level first-too) | |
| 3804 "Find the next newsgroup with unread articles. | |
| 3805 If BACKWARD is non-nil, find the previous newsgroup instead. | |
| 3806 If ALL is non-nil, just find any newsgroup. | |
| 3807 If LEVEL is non-nil, find group with level LEVEL, or higher if no such | |
| 3808 group exists. | |
| 3809 If FIRST-TOO, the current line is also eligible as a target." | |
| 3810 (let ((way (if backward -1 1)) | |
| 3811 (low gnus-level-killed) | |
| 3812 (beg (point)) | |
| 3813 pos found lev) | |
| 3814 (if (and backward (progn (beginning-of-line)) (bobp)) | |
| 3815 nil | |
| 3816 (or first-too (forward-line way)) | |
| 3817 (while (and | |
| 3818 (not (eobp)) | |
| 3819 (not (setq | |
| 3820 found | |
| 3821 (and (or all | |
| 3822 (and | |
| 3823 (let ((unread | |
| 3824 (get-text-property (point) 'gnus-unread))) | |
| 3825 (or (eq unread t) (and unread (> unread 0)))) | |
| 3826 (setq lev (get-text-property (point) | |
| 3827 'gnus-level)) | |
| 3828 (<= lev gnus-level-subscribed))) | |
| 3829 (or (not level) | |
| 3830 (and (setq lev (get-text-property (point) | |
| 3831 'gnus-level)) | |
| 3832 (or (= lev level) | |
| 3833 (and (< lev low) | |
| 3834 (< level lev) | |
| 3835 (progn | |
| 3836 (setq low lev) | |
| 3837 (setq pos (point)) | |
| 3838 nil)))))))) | |
| 3839 (zerop (forward-line way))))) | |
| 3840 (if found | |
| 3841 (progn (gnus-group-position-cursor) t) | |
| 3842 (goto-char (or pos beg)) | |
| 3843 (and pos t)))) | |
| 3844 | |
| 3845 ;;; Gnus group mode commands | |
| 3846 | |
| 3847 ;; Group marking. | |
| 3848 | |
| 3849 (defun gnus-group-mark-group (n &optional unmark no-advance) | |
| 3850 "Mark the current group." | |
| 3851 (interactive "p") | |
| 3852 (let ((buffer-read-only nil) | |
| 3853 group) | |
| 3854 (while | |
| 3855 (and (> n 0) | |
| 3856 (setq group (gnus-group-group-name)) | |
| 3857 (progn | |
| 3858 (beginning-of-line) | |
| 3859 (forward-char | |
| 3860 (or (cdr (assq 'process gnus-group-mark-positions)) 2)) | |
| 3861 (delete-char 1) | |
| 3862 (if unmark | |
| 3863 (progn | |
| 3864 (insert " ") | |
| 3865 (setq gnus-group-marked (delete group gnus-group-marked))) | |
| 3866 (insert "#") | |
| 3867 (setq gnus-group-marked | |
| 3868 (cons group (delete group gnus-group-marked)))) | |
| 3869 t) | |
| 3870 (or no-advance (zerop (gnus-group-next-group 1)))) | |
| 3871 (setq n (1- n))) | |
| 3872 (gnus-summary-position-cursor) | |
| 3873 n)) | |
| 3874 | |
| 3875 (defun gnus-group-unmark-group (n) | |
| 3876 "Remove the mark from the current group." | |
| 3877 (interactive "p") | |
| 3878 (gnus-group-mark-group n 'unmark)) | |
| 3879 | |
| 3880 (defun gnus-group-mark-region (unmark beg end) | |
| 3881 "Mark all groups between point and mark. | |
| 3882 If UNMARK, remove the mark instead." | |
| 3883 (interactive "P\nr") | |
| 3884 (let ((num (count-lines beg end))) | |
| 3885 (save-excursion | |
| 3886 (goto-char beg) | |
| 3887 (- num (gnus-group-mark-group num unmark))))) | |
| 3888 | |
| 3889 (defun gnus-group-remove-mark (group) | |
| 3890 (and (gnus-group-goto-group group) | |
| 3891 (save-excursion | |
| 3892 (gnus-group-mark-group 1 'unmark t)))) | |
| 3893 | |
| 3894 ;; Return a list of groups to work on. Take into consideration N (the | |
| 3895 ;; prefix) and the list of marked groups. | |
| 3896 (defun gnus-group-process-prefix (n) | |
| 3897 (cond (n | |
| 3898 (setq n (prefix-numeric-value n)) | |
| 3899 ;; There is a prefix, so we return a list of the N next | |
| 3900 ;; groups. | |
| 3901 (let ((way (if (< n 0) -1 1)) | |
| 3902 (n (abs n)) | |
| 3903 group groups) | |
| 3904 (save-excursion | |
| 3905 (while (and (> n 0) | |
| 3906 (setq group (gnus-group-group-name))) | |
| 3907 (setq groups (cons group groups)) | |
| 3908 (setq n (1- n)) | |
| 3909 (forward-line way))) | |
| 3910 (nreverse groups))) | |
| 3911 (gnus-group-marked | |
| 3912 ;; No prefix, but a list of marked articles. | |
| 3913 (reverse gnus-group-marked)) | |
| 3914 (t | |
| 3915 ;; Neither marked articles or a prefix, so we return the | |
| 3916 ;; current group. | |
| 3917 (let ((group (gnus-group-group-name))) | |
| 3918 (and group (list group)))))) | |
| 3919 | |
| 3920 ;; Selecting groups. | |
| 3921 | |
| 3922 (defun gnus-group-read-group (&optional all no-article group) | |
| 3923 "Read news in this newsgroup. | |
| 3924 If the prefix argument ALL is non-nil, already read articles become | |
| 3925 readable. If the optional argument NO-ARTICLE is non-nil, no article | |
| 3926 will be auto-selected upon group entry." | |
| 3927 (interactive "P") | |
| 3928 (let ((group (or group (gnus-group-group-name))) | |
| 3929 number active marked entry) | |
| 3930 (or group (error "No group on current line")) | |
| 3931 (setq marked | |
| 3932 (nth 3 (nth 2 (setq entry (gnus-gethash group gnus-newsrc-hashtb))))) | |
| 3933 ;; This group might be a dead group. In that case we have to get | |
| 3934 ;; the number of unread articles from `gnus-active-hashtb'. | |
| 3935 (if entry | |
| 3936 (setq number (car entry)) | |
| 3937 (if (setq active (gnus-gethash group gnus-active-hashtb)) | |
| 3938 (setq number (- (1+ (cdr active)) (car active))))) | |
| 3939 (gnus-summary-read-group | |
| 3940 group (or all (and (numberp number) | |
| 3941 (zerop (+ number (length (cdr (assq 'tick marked))) | |
| 3942 (length (cdr (assq 'dormant marked))))))) | |
| 3943 no-article))) | |
| 3944 | |
| 3945 (defun gnus-group-select-group (&optional all) | |
| 3946 "Select this newsgroup. | |
| 3947 No article is selected automatically. | |
| 3948 If argument ALL is non-nil, already read articles become readable." | |
| 3949 (interactive "P") | |
| 3950 (gnus-group-read-group all t)) | |
| 3951 | |
| 3952 (defun gnus-group-select-group-all () | |
| 3953 "Select the current group and display all articles in it." | |
| 3954 (interactive) | |
| 3955 (gnus-group-select-group 'all)) | |
| 3956 | |
| 3957 ;; Enter a group that is not in the group buffer. Non-nil is returned | |
| 3958 ;; if selection was successful. | |
| 3959 (defun gnus-group-read-ephemeral-group | |
| 3960 (group method &optional activate quit-config) | |
| 3961 (let ((group (if (gnus-group-foreign-p group) group | |
| 3962 (gnus-group-prefixed-name group method)))) | |
| 3963 (gnus-sethash | |
| 3964 group | |
| 3965 (list t nil (list group gnus-level-default-subscribed nil nil | |
| 3966 (append method | |
| 3967 (list | |
| 3968 (list 'quit-config | |
| 3969 (if quit-config quit-config | |
| 3970 (cons (current-buffer) 'summary))))))) | |
| 3971 gnus-newsrc-hashtb) | |
| 3972 (set-buffer gnus-group-buffer) | |
| 3973 (or (gnus-check-server method) | |
| 3974 (error "Unable to contact server: %s" (gnus-status-message method))) | |
| 3975 (if activate (or (gnus-request-group group) | |
| 3976 (error "Couldn't request group"))) | |
| 3977 (condition-case () | |
| 3978 (gnus-group-read-group t t group) | |
| 3979 (error nil) | |
| 3980 (quit nil)) | |
| 3981 (not (equal major-mode 'gnus-group-mode)))) | |
| 3982 | |
| 3983 (defun gnus-group-jump-to-group (group) | |
| 3984 "Jump to newsgroup GROUP." | |
| 3985 (interactive | |
| 3986 (list (completing-read | |
| 3987 "Group: " gnus-active-hashtb nil | |
| 3988 (memq gnus-select-method gnus-have-read-active-file)))) | |
| 3989 | |
| 3990 (if (equal group "") | |
| 3991 (error "Empty group name")) | |
| 3992 | |
| 3993 (let ((b (text-property-any | |
| 3994 (point-min) (point-max) 'gnus-group (intern group)))) | |
| 3995 (if b | |
| 3996 ;; Either go to the line in the group buffer... | |
| 3997 (goto-char b) | |
| 3998 ;; ... or insert the line. | |
| 3999 (or | |
| 4000 (gnus-gethash group gnus-active-hashtb) | |
| 4001 (gnus-activate-group group) | |
| 4002 (error "%s error: %s" group (gnus-status-message group))) | |
| 4003 | |
| 4004 (gnus-group-update-group group) | |
| 4005 (goto-char (text-property-any | |
| 4006 (point-min) (point-max) 'gnus-group (intern group))))) | |
| 4007 ;; Adjust cursor point. | |
| 4008 (gnus-group-position-cursor)) | |
| 4009 | |
| 4010 (defun gnus-group-goto-group (group) | |
| 4011 "Goto to newsgroup GROUP." | |
| 4012 (let ((b (text-property-any (point-min) (point-max) | |
| 4013 'gnus-group (intern group)))) | |
| 4014 (and b (goto-char b)))) | |
| 4015 | |
| 4016 (defun gnus-group-next-group (n) | |
| 4017 "Go to next N'th newsgroup. | |
| 4018 If N is negative, search backward instead. | |
| 4019 Returns the difference between N and the number of skips actually | |
| 4020 done." | |
| 4021 (interactive "p") | |
| 4022 (gnus-group-next-unread-group n t)) | |
| 4023 | |
| 4024 (defun gnus-group-next-unread-group (n &optional all level) | |
| 4025 "Go to next N'th unread newsgroup. | |
| 4026 If N is negative, search backward instead. | |
| 4027 If ALL is non-nil, choose any newsgroup, unread or not. | |
| 4028 If LEVEL is non-nil, choose the next group with level LEVEL, or, if no | |
| 4029 such group can be found, the next group with a level higher than | |
| 4030 LEVEL. | |
| 4031 Returns the difference between N and the number of skips actually | |
| 4032 made." | |
| 4033 (interactive "p") | |
| 4034 (let ((backward (< n 0)) | |
| 4035 (n (abs n))) | |
| 4036 (while (and (> n 0) | |
| 4037 (gnus-group-search-forward | |
| 4038 backward (or (not gnus-group-goto-unread) all) level)) | |
| 4039 (setq n (1- n))) | |
| 4040 (if (/= 0 n) (gnus-message 7 "No more%s newsgroups%s" (if all "" " unread") | |
| 4041 (if level " on this level or higher" ""))) | |
| 4042 n)) | |
| 4043 | |
| 4044 (defun gnus-group-prev-group (n) | |
| 4045 "Go to previous N'th newsgroup. | |
| 4046 Returns the difference between N and the number of skips actually | |
| 4047 done." | |
| 4048 (interactive "p") | |
| 4049 (gnus-group-next-unread-group (- n) t)) | |
| 4050 | |
| 4051 (defun gnus-group-prev-unread-group (n) | |
| 4052 "Go to previous N'th unread newsgroup. | |
| 4053 Returns the difference between N and the number of skips actually | |
| 4054 done." | |
| 4055 (interactive "p") | |
| 4056 (gnus-group-next-unread-group (- n))) | |
| 4057 | |
| 4058 (defun gnus-group-next-unread-group-same-level (n) | |
| 4059 "Go to next N'th unread newsgroup on the same level. | |
| 4060 If N is negative, search backward instead. | |
| 4061 Returns the difference between N and the number of skips actually | |
| 4062 done." | |
| 4063 (interactive "p") | |
| 4064 (gnus-group-next-unread-group n t (gnus-group-group-level)) | |
| 4065 (gnus-group-position-cursor)) | |
| 4066 | |
| 4067 (defun gnus-group-prev-unread-group-same-level (n) | |
| 4068 "Go to next N'th unread newsgroup on the same level. | |
| 4069 Returns the difference between N and the number of skips actually | |
| 4070 done." | |
| 4071 (interactive "p") | |
| 4072 (gnus-group-next-unread-group (- n) t (gnus-group-group-level)) | |
| 4073 (gnus-group-position-cursor)) | |
| 4074 | |
| 4075 (defun gnus-group-best-unread-group (&optional exclude-group) | |
| 4076 "Go to the group with the highest level. | |
| 4077 If EXCLUDE-GROUP, do not go to that group." | |
| 4078 (interactive) | |
| 4079 (goto-char (point-min)) | |
| 4080 (let ((best 100000) | |
| 4081 unread best-point) | |
| 4082 (while (setq unread (get-text-property (point) 'gnus-unread)) | |
| 4083 (if (and (numberp unread) (> unread 0)) | |
| 4084 (progn | |
| 4085 (if (and (< (get-text-property (point) 'gnus-level) best) | |
| 4086 (or (not exclude-group) | |
| 4087 (not (equal exclude-group (gnus-group-group-name))))) | |
| 4088 (progn | |
| 4089 (setq best (get-text-property (point) 'gnus-level)) | |
| 4090 (setq best-point (point)))))) | |
| 4091 (forward-line 1)) | |
| 4092 (if best-point (goto-char best-point)) | |
| 4093 (gnus-summary-position-cursor) | |
| 4094 (and best-point (gnus-group-group-name)))) | |
| 4095 | |
| 4096 (defun gnus-group-first-unread-group () | |
| 4097 "Go to the first group with unread articles." | |
| 4098 (interactive) | |
| 4099 (prog1 | |
| 4100 (let ((opoint (point)) | |
| 4101 unread) | |
| 4102 (goto-char (point-min)) | |
| 4103 (if (or (eq (setq unread (gnus-group-group-unread)) t) ; Not active. | |
| 4104 (not (zerop unread)) ; Has unread articles. | |
| 4105 (zerop (gnus-group-next-unread-group 1))) ; Next unread group. | |
| 4106 (point) ; Success. | |
| 4107 (goto-char opoint) | |
| 4108 nil)) ; Not success. | |
| 4109 (gnus-group-position-cursor))) | |
| 4110 | |
| 4111 (defun gnus-group-enter-server-mode () | |
| 4112 "Jump to the server buffer." | |
| 4113 (interactive) | |
| 4114 (gnus-server-setup-buffer) | |
| 4115 (gnus-configure-windows 'server) | |
| 4116 (gnus-server-prepare)) | |
| 4117 | |
| 4118 (defun gnus-group-make-group (name &optional method address) | |
| 4119 "Add a new newsgroup. | |
| 4120 The user will be prompted for a NAME, for a select METHOD, and an | |
| 4121 ADDRESS." | |
| 4122 (interactive | |
| 4123 (cons | |
| 4124 (read-string "Group name: ") | |
| 4125 (let ((method | |
| 4126 (completing-read | |
| 4127 "Method: " (append gnus-valid-select-methods gnus-server-alist) | |
| 4128 nil t))) | |
| 4129 (if (assoc method gnus-valid-select-methods) | |
| 4130 (list method | |
| 4131 (if (memq 'prompt-address | |
| 4132 (assoc method gnus-valid-select-methods)) | |
| 4133 (read-string "Address: ") | |
| 4134 "")) | |
| 4135 (list method nil))))) | |
| 4136 | |
| 4137 (let* ((meth (and method (if address (list (intern method) address) method))) | |
| 4138 (nname (if method (gnus-group-prefixed-name name meth) name)) | |
| 4139 info) | |
| 4140 (and (gnus-gethash nname gnus-newsrc-hashtb) | |
| 4141 (error "Group %s already exists" nname)) | |
| 4142 (gnus-group-change-level | |
| 4143 (setq info (list t nname gnus-level-default-subscribed nil nil meth)) | |
| 4144 gnus-level-default-subscribed gnus-level-killed | |
| 4145 (and (gnus-group-group-name) | |
| 4146 (gnus-gethash (gnus-group-group-name) | |
| 4147 gnus-newsrc-hashtb)) | |
| 4148 t) | |
| 4149 (gnus-sethash nname (cons 1 0) gnus-active-hashtb) | |
| 4150 (or (gnus-ephemeral-group-p name) | |
| 4151 (gnus-dribble-enter | |
| 4152 (concat "(gnus-group-set-info '" (prin1-to-string (cdr info)) ")"))) | |
| 4153 (gnus-group-insert-group-line-info nname) | |
| 4154 | |
| 4155 (if (assoc method gnus-valid-select-methods) | |
| 4156 (require (intern method))) | |
| 4157 (and (gnus-check-backend-function 'request-create-group nname) | |
| 4158 (gnus-request-create-group nname)))) | |
| 4159 | |
| 4160 (defun gnus-group-edit-group (group &optional part) | |
| 4161 "Edit the group on the current line." | |
| 4162 (interactive (list (gnus-group-group-name))) | |
| 4163 (let ((done-func '(lambda () | |
| 4164 "Exit editing mode and update the information." | |
| 4165 (interactive) | |
| 4166 (gnus-group-edit-group-done 'part 'group))) | |
| 4167 (part (or part 'info)) | |
| 4168 (winconf (current-window-configuration)) | |
| 4169 info) | |
| 4170 (or group (error "No group on current line")) | |
| 4171 (or (setq info (nth 2 (gnus-gethash group gnus-newsrc-hashtb))) | |
| 4172 (error "Killed group; can't be edited")) | |
| 4173 (set-buffer (get-buffer-create gnus-group-edit-buffer)) | |
| 4174 (gnus-configure-windows 'edit-group) | |
| 4175 (gnus-add-current-to-buffer-list) | |
| 4176 (emacs-lisp-mode) | |
| 4177 ;; Suggested by Hallvard B Furuseth <h.b.furuseth@usit.uio.no>. | |
| 4178 (use-local-map (copy-keymap emacs-lisp-mode-map)) | |
| 4179 (local-set-key "\C-c\C-c" done-func) | |
| 4180 (make-local-variable 'gnus-prev-winconf) | |
| 4181 (setq gnus-prev-winconf winconf) | |
| 4182 ;; We modify the func to let it know what part it is editing. | |
| 4183 (setcar (cdr (nth 4 done-func)) (list 'quote part)) | |
| 4184 (setcar (cdr (cdr (nth 4 done-func))) group) | |
| 4185 (erase-buffer) | |
| 4186 (insert | |
| 4187 (cond | |
| 4188 ((eq part 'method) | |
| 4189 ";; Type `C-c C-c' after editing the select method.\n\n") | |
| 4190 ((eq part 'params) | |
| 4191 ";; Type `C-c C-c' after editing the group parameters.\n\n") | |
| 4192 ((eq part 'info) | |
| 4193 ";; Type `C-c C-c' after editing the group info.\n\n"))) | |
| 4194 (let ((cinfo (gnus-copy-sequence info)) | |
| 4195 marked) | |
| 4196 (if (not (setq marked (nth 3 cinfo))) | |
| 4197 () | |
| 4198 (while marked | |
| 4199 (or (eq 'score (car (car marked))) | |
| 4200 (eq 'bookmark (car (car marked))) | |
| 4201 (eq 'killed (car (car marked))) | |
| 4202 (not (numberp (car (cdr (car marked))))) | |
| 4203 (setcdr (car marked) | |
| 4204 (gnus-compress-sequence (sort (cdr (car marked)) '<) t))) | |
| 4205 (setq marked (cdr marked)))) | |
| 4206 (insert | |
| 4207 (pp-to-string | |
| 4208 (cond ((eq part 'method) | |
| 4209 (or (nth 4 info) "native")) | |
| 4210 ((eq part 'params) | |
| 4211 (nth 5 info)) | |
| 4212 (t | |
| 4213 cinfo))) | |
| 4214 "\n")))) | |
| 4215 | |
| 4216 (defun gnus-group-edit-group-method (group) | |
| 4217 "Edit the select method of GROUP." | |
| 4218 (interactive (list (gnus-group-group-name))) | |
| 4219 (gnus-group-edit-group group 'method)) | |
| 4220 | |
| 4221 (defun gnus-group-edit-group-parameters (group) | |
| 4222 "Edit the group parameters of GROUP." | |
| 4223 (interactive (list (gnus-group-group-name))) | |
| 4224 (gnus-group-edit-group group 'params)) | |
| 4225 | |
| 4226 (defun gnus-group-edit-group-done (part group) | |
| 4227 "Get info from buffer, update variables and jump to the group buffer." | |
| 4228 (set-buffer (get-buffer-create gnus-group-edit-buffer)) | |
| 4229 (goto-char (point-min)) | |
| 4230 (let ((form (read (current-buffer))) | |
| 4231 (winconf gnus-prev-winconf)) | |
| 4232 (if (eq part 'info) | |
| 4233 (gnus-group-set-info form) | |
| 4234 (gnus-group-set-info form group part)) | |
| 4235 (kill-buffer (current-buffer)) | |
| 4236 (and winconf (set-window-configuration winconf)) | |
| 4237 (set-buffer gnus-group-buffer) | |
| 4238 (gnus-group-update-group (gnus-group-group-name)) | |
| 4239 (gnus-group-position-cursor))) | |
| 4240 | |
| 4241 (defun gnus-group-make-help-group () | |
| 4242 "Create the Gnus documentation group." | |
| 4243 (interactive) | |
| 4244 (let ((path (cons (concat installation-directory "etc/") load-path)) | |
| 4245 (name (gnus-group-prefixed-name "gnus-help" '(nndoc "gnus-help"))) | |
| 4246 file) | |
| 4247 (and (gnus-gethash name gnus-newsrc-hashtb) | |
| 4248 (error "Documentation group already exists")) | |
| 4249 (while (and path | |
| 4250 (not (file-exists-p | |
| 4251 (setq file (concat (file-name-as-directory (car path)) | |
| 4252 "gnus-tut.txt"))))) | |
| 4253 (setq path (cdr path))) | |
| 4254 (if (not path) | |
| 4255 (message "Couldn't find doc group") | |
| 4256 (gnus-group-make-group | |
| 4257 (gnus-group-real-name name) | |
| 4258 (list 'nndoc name | |
| 4259 (list 'nndoc-address file) | |
| 4260 (list 'nndoc-article-type 'mbox))))) | |
| 4261 (gnus-group-position-cursor)) | |
| 4262 | |
| 4263 (defun gnus-group-make-doc-group (file type) | |
| 4264 "Create a group that uses a single file as the source." | |
| 4265 (interactive | |
| 4266 (list (read-file-name "File name: ") | |
| 4267 (let ((err "") | |
| 4268 found char) | |
| 4269 (while (not found) | |
| 4270 (message "%sFile type (mbox, babyl, digest) [mbd]: " err) | |
| 4271 (setq found (cond ((= (setq char (read-char)) ?m) 'mbox) | |
| 4272 ((= char ?b) 'babyl) | |
| 4273 ((= char ?d) 'digest) | |
| 4274 (t (setq err (format "%c unknown. " char)) | |
| 4275 nil)))) | |
| 4276 found))) | |
| 4277 (let* ((file (expand-file-name file)) | |
| 4278 (name (gnus-generate-new-group-name | |
| 4279 (gnus-group-prefixed-name | |
| 4280 (file-name-nondirectory file) '(nndoc ""))))) | |
| 4281 (gnus-group-make-group | |
| 4282 (gnus-group-real-name name) | |
| 4283 (list 'nndoc name | |
| 4284 (list 'nndoc-address file) | |
| 4285 (list 'nndoc-article-type type))))) | |
| 4286 | |
| 4287 (defun gnus-group-make-archive-group (&optional all) | |
| 4288 "Create the (ding) Gnus archive group of the most recent articles. | |
| 4289 Given a prefix, create a full group." | |
| 4290 (interactive "P") | |
| 4291 (let ((group (gnus-group-prefixed-name | |
| 4292 (if all "ding.archives" "ding.recent") '(nndir "")))) | |
| 4293 (and (gnus-gethash group gnus-newsrc-hashtb) | |
| 4294 (error "Archive group already exists")) | |
| 4295 (gnus-group-make-group | |
| 4296 (gnus-group-real-name group) | |
| 4297 "nndir" | |
| 4298 (if all gnus-group-archive-directory | |
| 4299 gnus-group-recent-archive-directory))) | |
| 4300 (gnus-group-position-cursor)) | |
| 4301 | |
| 4302 (defun gnus-group-make-directory-group (dir) | |
| 4303 "Create an nndir group. | |
| 4304 The user will be prompted for a directory. The contents of this | |
| 4305 directory will be used as a newsgroup. The directory should contain | |
| 4306 mail messages or news articles in files that have numeric names." | |
| 4307 (interactive | |
| 4308 (list (read-file-name "Create group from directory: "))) | |
| 4309 (or (file-exists-p dir) (error "No such directory")) | |
| 4310 (or (file-directory-p dir) (error "Not a directory")) | |
| 4311 (gnus-group-make-group dir "nndir" dir) | |
| 4312 (gnus-group-position-cursor)) | |
| 4313 | |
| 4314 (defun gnus-group-make-kiboze-group (group address scores) | |
| 4315 "Create an nnkiboze group. | |
| 4316 The user will be prompted for a name, a regexp to match groups, and | |
| 4317 score file entries for articles to include in the group." | |
| 4318 (interactive | |
| 4319 (list | |
| 4320 (read-string "nnkiboze group name: ") | |
| 4321 (read-string "Source groups (regexp): ") | |
| 4322 (let ((headers (mapcar (lambda (group) (list group)) | |
| 4323 '("subject" "from" "number" "date" "message-id" | |
| 4324 "references" "chars" "lines" "xref"))) | |
| 4325 scores header regexp regexps) | |
| 4326 (while (not (equal "" (setq header (completing-read | |
| 4327 "Match on header: " headers nil t)))) | |
| 4328 (setq regexps nil) | |
| 4329 (while (not (equal "" (setq regexp (read-string | |
| 4330 (format "Match on %s (string): " | |
| 4331 header))))) | |
| 4332 (setq regexps (cons (list regexp nil nil 'r) regexps))) | |
| 4333 (setq scores (cons (cons header regexps) scores))) | |
| 4334 scores))) | |
| 4335 (gnus-group-make-group group "nnkiboze" address) | |
| 4336 (save-excursion | |
| 4337 (gnus-set-work-buffer) | |
| 4338 (let (emacs-lisp-mode-hook) | |
| 4339 (pp scores (current-buffer))) | |
| 4340 (write-region (point-min) (point-max) | |
| 4341 (concat (or gnus-kill-files-directory "~/News") | |
| 4342 "nnkiboze:" group "." gnus-score-file-suffix))) | |
| 4343 (gnus-group-position-cursor)) | |
| 4344 | |
| 4345 (defun gnus-group-add-to-virtual (n vgroup) | |
| 4346 "Add the current group to a virtual group." | |
| 4347 (interactive | |
| 4348 (list current-prefix-arg | |
| 4349 (completing-read "Add to virtual group: " gnus-newsrc-hashtb nil t | |
| 4350 "nnvirtual:"))) | |
| 4351 (or (eq (car (gnus-find-method-for-group vgroup)) 'nnvirtual) | |
| 4352 (error "%s is not an nnvirtual group" vgroup)) | |
| 4353 (let* ((groups (gnus-group-process-prefix n)) | |
| 4354 (method (nth 4 (nth 2 (gnus-gethash vgroup gnus-newsrc-hashtb))))) | |
| 4355 (setcar (cdr method) | |
| 4356 (concat | |
| 4357 (nth 1 method) "\\|" | |
| 4358 (mapconcat | |
| 4359 (lambda (s) | |
| 4360 (gnus-group-remove-mark s) | |
| 4361 (concat "\\(^" (regexp-quote s) "$\\)")) | |
| 4362 groups "\\|")))) | |
| 4363 (gnus-group-position-cursor)) | |
| 4364 | |
| 4365 (defun gnus-group-make-empty-virtual (group) | |
| 4366 "Create a new, fresh, empty virtual group." | |
| 4367 (interactive "sCreate new, empty virtual group: ") | |
| 4368 (let* ((method (list 'nnvirtual "^$")) | |
| 4369 (pgroup (gnus-group-prefixed-name group method))) | |
| 4370 ;; Check whether it exists already. | |
| 4371 (and (gnus-gethash pgroup gnus-newsrc-hashtb) | |
| 4372 (error "Group %s already exists." pgroup)) | |
| 4373 ;; Subscribe the new group after the group on the current line. | |
| 4374 (gnus-subscribe-group pgroup (gnus-group-group-name) method) | |
| 4375 (gnus-group-update-group pgroup) | |
| 4376 (forward-line -1) | |
| 4377 (gnus-group-position-cursor))) | |
| 4378 | |
| 4379 (defun gnus-group-enter-directory (dir) | |
| 4380 "Enter an ephemeral nneething group." | |
| 4381 (interactive "DDirectory to read: ") | |
| 4382 (let* ((method (list 'nneething dir)) | |
| 4383 (leaf (gnus-group-prefixed-name | |
| 4384 (file-name-nondirectory (directory-file-name dir)) | |
| 4385 method)) | |
| 4386 (name (gnus-generate-new-group-name leaf))) | |
| 4387 (let ((nneething-read-only t)) | |
| 4388 (or (gnus-group-read-ephemeral-group | |
| 4389 name method t | |
| 4390 (cons (current-buffer) (if (eq major-mode 'gnus-summary-mode) | |
| 4391 'summary 'group))) | |
| 4392 (error "Couldn't enter %s" dir))))) | |
| 4393 | |
| 4394 ;; Group sorting commands | |
| 4395 ;; Suggested by Joe Hildebrand <hildjj@idaho.fuentez.com>. | |
| 4396 | |
| 4397 (defun gnus-group-sort-groups () | |
| 4398 "Sort the group buffer using `gnus-group-sort-function'." | |
| 4399 (interactive) | |
| 4400 (setq gnus-newsrc-alist | |
| 4401 (sort (cdr gnus-newsrc-alist) gnus-group-sort-function)) | |
| 4402 (gnus-make-hashtable-from-newsrc-alist) | |
| 4403 (gnus-group-list-groups)) | |
| 4404 | |
| 4405 (defun gnus-group-sort-by-alphabet (info1 info2) | |
| 4406 (string< (car info1) (car info2))) | |
| 4407 | |
| 4408 (defun gnus-group-sort-by-unread (info1 info2) | |
| 4409 (let ((n1 (car (gnus-gethash (car info1) gnus-newsrc-hashtb))) | |
| 4410 (n2 (car (gnus-gethash (car info2) gnus-newsrc-hashtb)))) | |
| 4411 (< (or (and (numberp n1) n1) 0) | |
| 4412 (or (and (numberp n2) n2) 0)))) | |
| 4413 | |
| 4414 (defun gnus-group-sort-by-level (info1 info2) | |
| 4415 (< (nth 1 info1) (nth 1 info2))) | |
| 4416 | |
| 4417 ;; Group catching up. | |
| 4418 | |
| 4419 (defun gnus-group-catchup-current (&optional n all) | |
| 4420 "Mark all articles not marked as unread in current newsgroup as read. | |
| 4421 If prefix argument N is numeric, the ARG next newsgroups will be | |
| 4422 caught up. If ALL is non-nil, marked articles will also be marked as | |
| 4423 read. Cross references (Xref: header) of articles are ignored. | |
| 4424 The difference between N and actual number of newsgroups that were | |
| 4425 caught up is returned." | |
| 4426 (interactive "P") | |
| 4427 (if (not (or (not gnus-interactive-catchup) ;Without confirmation? | |
| 4428 gnus-expert-user | |
| 4429 (gnus-y-or-n-p | |
| 4430 (if all | |
| 4431 "Do you really want to mark all articles as read? " | |
| 4432 "Mark all unread articles as read? ")))) | |
| 4433 n | |
| 4434 (let ((groups (gnus-group-process-prefix n)) | |
| 4435 (ret 0)) | |
| 4436 (while groups | |
| 4437 ;; Virtual groups have to be given special treatment. | |
| 4438 (let ((method (gnus-find-method-for-group (car groups)))) | |
| 4439 (if (eq 'nnvirtual (car method)) | |
| 4440 (nnvirtual-catchup-group | |
| 4441 (gnus-group-real-name (car groups)) (nth 1 method) all))) | |
| 4442 (gnus-group-remove-mark (car groups)) | |
| 4443 (if (prog1 | |
| 4444 (gnus-group-goto-group (car groups)) | |
| 4445 (gnus-group-catchup (car groups) all)) | |
| 4446 (gnus-group-update-group-line) | |
| 4447 (setq ret (1+ ret))) | |
| 4448 (setq groups (cdr groups))) | |
| 4449 (gnus-group-next-unread-group 1) | |
| 4450 ret))) | |
| 4451 | |
| 4452 (defun gnus-group-catchup-current-all (&optional n) | |
| 4453 "Mark all articles in current newsgroup as read. | |
| 4454 Cross references (Xref: header) of articles are ignored." | |
| 4455 (interactive "P") | |
| 4456 (gnus-group-catchup-current n 'all)) | |
| 4457 | |
| 4458 (defun gnus-group-catchup (group &optional all) | |
| 4459 "Mark all articles in GROUP as read. | |
| 4460 If ALL is non-nil, all articles are marked as read. | |
| 4461 The return value is the number of articles that were marked as read, | |
| 4462 or nil if no action could be taken." | |
| 4463 (let* ((entry (gnus-gethash group gnus-newsrc-hashtb)) | |
| 4464 (num (car entry)) | |
| 4465 (marked (nth 3 (nth 2 entry)))) | |
| 4466 (if (not (numberp (car entry))) | |
| 4467 (gnus-message 1 "Can't catch up; non-active group") | |
| 4468 ;; Do the updating only if the newsgroup isn't killed. | |
| 4469 (if (not entry) | |
| 4470 () | |
| 4471 (gnus-update-read-articles | |
| 4472 group (and (not all) (append (cdr (assq 'tick marked)) | |
| 4473 (cdr (assq 'dormant marked)))) | |
| 4474 nil (and (not all) (cdr (assq 'tick marked)))) | |
| 4475 (and all | |
| 4476 (setq marked (nth 3 (nth 2 entry))) | |
| 4477 (setcar (nthcdr 3 (nth 2 entry)) | |
| 4478 (delq (assq 'dormant marked) | |
| 4479 (nth 3 (nth 2 entry))))))) | |
| 4480 num)) | |
| 4481 | |
| 4482 (defun gnus-group-expire-articles (&optional n) | |
| 4483 "Expire all expirable articles in the current newsgroup." | |
| 4484 (interactive "P") | |
| 4485 (let ((groups (gnus-group-process-prefix n)) | |
| 4486 group) | |
| 4487 (or groups (error "No groups to expire")) | |
| 4488 (while groups | |
| 4489 (setq group (car groups) | |
| 4490 groups (cdr groups)) | |
| 4491 (gnus-group-remove-mark group) | |
| 4492 (if (not (gnus-check-backend-function 'request-expire-articles group)) | |
| 4493 () | |
| 4494 (let* ((info (nth 2 (gnus-gethash group gnus-newsrc-hashtb))) | |
| 4495 (expirable (if (memq 'total-expire (nth 5 info)) | |
| 4496 (cons nil (gnus-list-of-read-articles group)) | |
| 4497 (assq 'expire (nth 3 info))))) | |
| 4498 (and expirable | |
| 4499 (setcdr expirable | |
| 4500 (gnus-request-expire-articles | |
| 4501 (cdr expirable) group)))))))) | |
| 4502 | |
| 4503 (defun gnus-group-expire-all-groups () | |
| 4504 "Expire all expirable articles in all newsgroups." | |
| 4505 (interactive) | |
| 4506 (save-excursion | |
| 4507 (gnus-message 5 "Expiring...") | |
| 4508 (let ((gnus-group-marked (mapcar (lambda (info) (car info)) | |
| 4509 (cdr gnus-newsrc-alist)))) | |
| 4510 (gnus-group-expire-articles nil))) | |
| 4511 (gnus-group-position-cursor) | |
| 4512 (gnus-message 5 "Expiring...done")) | |
| 4513 | |
| 4514 (defun gnus-group-set-current-level (n level) | |
| 4515 "Set the level of the next N groups to LEVEL." | |
| 4516 (interactive "P\nnLevel: ") | |
| 4517 (or (and (>= level 1) (<= level gnus-level-killed)) | |
| 4518 (error "Illegal level: %d" level)) | |
| 4519 (let ((groups (gnus-group-process-prefix n)) | |
| 4520 group) | |
| 4521 (while groups | |
| 4522 (setq group (car groups) | |
| 4523 groups (cdr groups)) | |
| 4524 (gnus-group-remove-mark group) | |
| 4525 (gnus-message 6 "Changed level of %s from %d to %d" | |
| 4526 group (gnus-group-group-level) level) | |
| 4527 (gnus-group-change-level group level | |
| 4528 (gnus-group-group-level)) | |
| 4529 (gnus-group-update-group-line))) | |
| 4530 (gnus-group-position-cursor)) | |
| 4531 | |
| 4532 (defun gnus-group-unsubscribe-current-group (&optional n) | |
| 4533 "Toggle subscription of the current group. | |
| 4534 If given numerical prefix, toggle the N next groups." | |
| 4535 (interactive "P") | |
| 4536 (let ((groups (gnus-group-process-prefix n)) | |
| 4537 group) | |
| 4538 (while groups | |
| 4539 (setq group (car groups) | |
| 4540 groups (cdr groups)) | |
| 4541 (gnus-group-remove-mark group) | |
| 4542 (gnus-group-unsubscribe-group | |
| 4543 group (if (<= (gnus-group-group-level) gnus-level-subscribed) | |
| 4544 gnus-level-default-unsubscribed | |
| 4545 gnus-level-default-subscribed)) | |
| 4546 (gnus-group-update-group-line)) | |
| 4547 (gnus-group-next-group 1))) | |
| 4548 | |
| 4549 (defun gnus-group-unsubscribe-group (group &optional level) | |
| 4550 "Toggle subscribe from/to unsubscribe GROUP. | |
| 4551 New newsgroup is added to .newsrc automatically." | |
| 4552 (interactive | |
| 4553 (list (completing-read | |
| 4554 "Group: " gnus-active-hashtb nil | |
| 4555 (memq gnus-select-method gnus-have-read-active-file)))) | |
| 4556 (let ((newsrc (gnus-gethash group gnus-newsrc-hashtb))) | |
| 4557 (cond | |
| 4558 ((string-match "^[ \t]$" group) | |
| 4559 (error "Empty group name")) | |
| 4560 (newsrc | |
| 4561 ;; Toggle subscription flag. | |
| 4562 (gnus-group-change-level | |
| 4563 newsrc (if level level (if (<= (nth 1 (nth 2 newsrc)) | |
| 4564 gnus-level-subscribed) | |
| 4565 (1+ gnus-level-subscribed) | |
| 4566 gnus-level-default-subscribed))) | |
| 4567 (gnus-group-update-group group)) | |
| 4568 ((and (stringp group) | |
| 4569 (or (not (memq gnus-select-method gnus-have-read-active-file)) | |
| 4570 (gnus-gethash group gnus-active-hashtb))) | |
| 4571 ;; Add new newsgroup. | |
| 4572 (gnus-group-change-level | |
| 4573 group | |
| 4574 (if level level gnus-level-default-subscribed) | |
| 4575 (or (and (member group gnus-zombie-list) | |
| 4576 gnus-level-zombie) | |
| 4577 gnus-level-killed) | |
| 4578 (and (gnus-group-group-name) | |
| 4579 (gnus-gethash (gnus-group-group-name) gnus-newsrc-hashtb))) | |
| 4580 (gnus-group-update-group group)) | |
| 4581 (t (error "No such newsgroup: %s" group))) | |
| 4582 (gnus-group-position-cursor))) | |
| 4583 | |
| 4584 (defun gnus-group-transpose-groups (n) | |
| 4585 "Move the current newsgroup up N places. | |
| 4586 If given a negative prefix, move down instead. The difference between | |
| 4587 N and the number of steps taken is returned." | |
| 4588 (interactive "p") | |
| 4589 (or (gnus-group-group-name) | |
| 4590 (error "No group on current line")) | |
| 4591 (gnus-group-kill-group 1) | |
| 4592 (prog1 | |
| 4593 (forward-line (- n)) | |
| 4594 (gnus-group-yank-group) | |
| 4595 (gnus-group-position-cursor))) | |
| 4596 | |
| 4597 (defun gnus-group-kill-all-zombies () | |
| 4598 "Kill all zombie newsgroups." | |
| 4599 (interactive) | |
| 4600 (setq gnus-killed-list (nconc gnus-zombie-list gnus-killed-list)) | |
| 4601 (setq gnus-zombie-list nil) | |
| 4602 (gnus-group-list-groups)) | |
| 4603 | |
| 4604 (defun gnus-group-kill-region (begin end) | |
| 4605 "Kill newsgroups in current region (excluding current point). | |
| 4606 The killed newsgroups can be yanked by using \\[gnus-group-yank-group]." | |
| 4607 (interactive "r") | |
| 4608 (let ((lines | |
| 4609 ;; Count lines. | |
| 4610 (save-excursion | |
| 4611 (count-lines | |
| 4612 (progn | |
| 4613 (goto-char begin) | |
| 4614 (beginning-of-line) | |
| 4615 (point)) | |
| 4616 (progn | |
| 4617 (goto-char end) | |
| 4618 (beginning-of-line) | |
| 4619 (point)))))) | |
| 4620 (goto-char begin) | |
| 4621 (beginning-of-line) ;Important when LINES < 1 | |
| 4622 (gnus-group-kill-group lines))) | |
| 4623 | |
| 4624 (defun gnus-group-kill-group (&optional n) | |
| 4625 "The the next N groups. | |
| 4626 The killed newsgroups can be yanked by using \\[gnus-group-yank-group]. | |
| 4627 However, only groups that were alive can be yanked; already killed | |
| 4628 groups or zombie groups can't be yanked. | |
| 4629 The return value is the name of the (last) group that was killed." | |
| 4630 (interactive "P") | |
| 4631 (let ((buffer-read-only nil) | |
| 4632 (groups (gnus-group-process-prefix n)) | |
| 4633 group entry level) | |
| 4634 (while groups | |
| 4635 (setq group (car groups) | |
| 4636 groups (cdr groups)) | |
| 4637 (gnus-group-remove-mark group) | |
| 4638 (setq level (gnus-group-group-level)) | |
| 4639 (gnus-delete-line) | |
| 4640 (if (setq entry (gnus-gethash group gnus-newsrc-hashtb)) | |
| 4641 (setq gnus-list-of-killed-groups | |
| 4642 (cons (cons (car entry) (nth 2 entry)) | |
| 4643 gnus-list-of-killed-groups))) | |
| 4644 (gnus-group-change-level | |
| 4645 (if entry entry group) gnus-level-killed (if entry nil level))) | |
| 4646 (gnus-group-position-cursor) | |
| 4647 group)) | |
| 4648 | |
| 4649 (defun gnus-group-yank-group (&optional arg) | |
| 4650 "Yank the last newsgroups killed with \\[gnus-group-kill-group], | |
| 4651 inserting it before the current newsgroup. The numeric ARG specifies | |
| 4652 how many newsgroups are to be yanked. The name of the (last) | |
| 4653 newsgroup yanked is returned." | |
| 4654 (interactive "p") | |
| 4655 (if (not arg) (setq arg 1)) | |
| 4656 (let (info group prev) | |
| 4657 (while (>= (setq arg (1- arg)) 0) | |
| 4658 (if (not (setq info (car gnus-list-of-killed-groups))) | |
| 4659 (error "No more newsgroups to yank")) | |
| 4660 (setq group (nth 2 info)) | |
| 4661 ;; Find which newsgroup to insert this one before - search | |
| 4662 ;; backward until something suitable is found. If there are no | |
| 4663 ;; other newsgroups in this buffer, just make this newsgroup the | |
| 4664 ;; first newsgroup. | |
| 4665 (setq prev (gnus-group-group-name)) | |
| 4666 (gnus-group-change-level | |
| 4667 info (nth 2 info) gnus-level-killed | |
| 4668 (and prev (gnus-gethash prev gnus-newsrc-hashtb)) | |
| 4669 t) | |
| 4670 (gnus-group-insert-group-line-info (nth 1 info)) | |
| 4671 (setq gnus-list-of-killed-groups | |
| 4672 (cdr gnus-list-of-killed-groups))) | |
| 4673 (forward-line -1) | |
| 4674 (gnus-group-position-cursor) | |
| 4675 group)) | |
| 4676 | |
| 4677 (defun gnus-group-list-all-groups (&optional arg) | |
| 4678 "List all newsgroups with level ARG or lower. | |
| 4679 Default is gnus-level-unsubscribed, which lists all subscribed and most | |
| 4680 unsubscribed groups." | |
| 4681 (interactive "P") | |
| 4682 (gnus-group-list-groups (or arg gnus-level-unsubscribed) t)) | |
| 4683 | |
| 4684 (defun gnus-group-list-killed () | |
| 4685 "List all killed newsgroups in the group buffer." | |
| 4686 (interactive) | |
| 4687 (if (not gnus-killed-list) | |
| 4688 (gnus-message 6 "No killed groups") | |
| 4689 (let (gnus-group-list-mode) | |
| 4690 (funcall gnus-group-prepare-function | |
| 4691 gnus-level-killed t gnus-level-killed)) | |
| 4692 (goto-char (point-min))) | |
| 4693 (gnus-group-position-cursor)) | |
| 4694 | |
| 4695 (defun gnus-group-list-zombies () | |
| 4696 "List all zombie newsgroups in the group buffer." | |
| 4697 (interactive) | |
| 4698 (if (not gnus-zombie-list) | |
| 4699 (gnus-message 6 "No zombie groups") | |
| 4700 (let (gnus-group-list-mode) | |
| 4701 (funcall gnus-group-prepare-function | |
| 4702 gnus-level-zombie t gnus-level-zombie)) | |
| 4703 (goto-char (point-min))) | |
| 4704 (gnus-group-position-cursor)) | |
| 4705 | |
| 4706 (defun gnus-group-get-new-news (&optional arg) | |
| 4707 "Get newly arrived articles. | |
| 4708 If ARG is non-nil, it should be a number between one and nine to | |
| 4709 specify which levels you are interested in re-scanning." | |
| 4710 (interactive "P") | |
| 4711 (run-hooks 'gnus-get-new-news-hook) | |
| 4712 (setq arg (gnus-group-default-level arg t)) | |
| 4713 (if (and gnus-read-active-file (not arg)) | |
| 4714 (progn | |
| 4715 (gnus-read-active-file) | |
| 4716 (gnus-get-unread-articles (or arg (1+ gnus-level-subscribed)))) | |
| 4717 (let ((gnus-read-active-file (if arg nil gnus-read-active-file))) | |
| 4718 (gnus-get-unread-articles (or arg (1+ gnus-level-subscribed))))) | |
| 4719 (gnus-group-list-groups)) | |
| 4720 | |
| 4721 (defun gnus-group-get-new-news-this-group (&optional n) | |
| 4722 "Check for newly arrived news in the current group (and the N-1 next groups). | |
| 4723 The difference between N and the number of newsgroup checked is returned. | |
| 4724 If N is negative, this group and the N-1 previous groups will be checked." | |
| 4725 (interactive "P") | |
| 4726 (let* ((groups (gnus-group-process-prefix n)) | |
| 4727 (ret (if (numberp n) (- n (length groups)) 0)) | |
| 4728 group) | |
| 4729 (while groups | |
| 4730 (setq group (car groups) | |
| 4731 groups (cdr groups)) | |
| 4732 (gnus-group-remove-mark group) | |
| 4733 (or (gnus-get-new-news-in-group group) | |
| 4734 (progn | |
| 4735 (ding) | |
| 4736 (message "%s error: %s" group (gnus-status-message group)) | |
| 4737 (sit-for 2)))) | |
| 4738 (gnus-group-next-unread-group 1 t) | |
| 4739 (gnus-summary-position-cursor) | |
| 4740 ret)) | |
| 4741 | |
| 4742 (defun gnus-get-new-news-in-group (group) | |
| 4743 (and group | |
| 4744 (gnus-activate-group group) | |
| 4745 (progn | |
| 4746 (gnus-get-unread-articles-in-group | |
| 4747 (nth 2 (gnus-gethash group gnus-newsrc-hashtb)) | |
| 4748 (gnus-gethash group gnus-active-hashtb)) | |
| 4749 (gnus-group-update-group-line) | |
| 4750 t))) | |
| 4751 | |
| 4752 (defun gnus-group-fetch-faq (group) | |
| 4753 "Fetch the FAQ for the current group." | |
| 4754 (interactive (list (gnus-group-real-name (gnus-group-group-name)))) | |
| 4755 (or group (error "No group name given")) | |
| 4756 (let ((file (concat gnus-group-faq-directory (gnus-group-real-name group)))) | |
| 4757 (if (not (file-exists-p file)) | |
| 4758 (error "No such file: %s" file) | |
| 4759 (find-file file)))) | |
| 4760 | |
| 4761 (defun gnus-group-describe-group (force &optional group) | |
| 4762 "Display a description of the current newsgroup." | |
| 4763 (interactive (list current-prefix-arg (gnus-group-group-name))) | |
| 4764 (and force (setq gnus-description-hashtb nil)) | |
| 4765 (let ((method (gnus-find-method-for-group group)) | |
| 4766 desc) | |
| 4767 (or group (error "No group name given")) | |
| 4768 (and (or (and gnus-description-hashtb | |
| 4769 ;; We check whether this group's method has been | |
| 4770 ;; queried for a description file. | |
| 4771 (gnus-gethash | |
| 4772 (gnus-group-prefixed-name "" method) | |
| 4773 gnus-description-hashtb)) | |
| 4774 (setq desc (gnus-group-get-description group)) | |
| 4775 (gnus-read-descriptions-file method)) | |
| 4776 (message | |
| 4777 (or desc (gnus-gethash group gnus-description-hashtb) | |
| 4778 "No description available"))))) | |
| 4779 | |
| 4780 ;; Suggested by Per Abrahamsen <amanda@iesd.auc.dk>. | |
| 4781 (defun gnus-group-describe-all-groups (&optional force) | |
| 4782 "Pop up a buffer with descriptions of all newsgroups." | |
| 4783 (interactive "P") | |
| 4784 (and force (setq gnus-description-hashtb nil)) | |
| 4785 (if (not (or gnus-description-hashtb | |
| 4786 (gnus-read-all-descriptions-files))) | |
| 4787 (error "Couldn't request descriptions file")) | |
| 4788 (let ((buffer-read-only nil) | |
| 4789 b) | |
| 4790 (erase-buffer) | |
| 4791 (mapatoms | |
| 4792 (lambda (group) | |
| 4793 (setq b (point)) | |
| 4794 (insert (format " *: %-20s %s\n" (symbol-name group) | |
| 4795 (symbol-value group))) | |
| 4796 (add-text-properties | |
| 4797 b (1+ b) (list 'gnus-group group | |
| 4798 'gnus-unread t 'gnus-marked nil | |
| 4799 'gnus-level (1+ gnus-level-subscribed)))) | |
| 4800 gnus-description-hashtb) | |
| 4801 (goto-char (point-min)) | |
| 4802 (gnus-group-position-cursor))) | |
| 4803 | |
| 4804 ;; Suggested by by Daniel Quinlan <quinlan@best.com>. | |
| 4805 (defun gnus-group-apropos (regexp &optional search-description) | |
| 4806 "List all newsgroups that have names that match a regexp." | |
| 4807 (interactive "sGnus apropos (regexp): ") | |
| 4808 (let ((prev "") | |
| 4809 (obuf (current-buffer)) | |
| 4810 groups des) | |
| 4811 ;; Go through all newsgroups that are known to Gnus. | |
| 4812 (mapatoms | |
| 4813 (lambda (group) | |
| 4814 (and (symbol-name group) | |
| 4815 (string-match regexp (symbol-name group)) | |
| 4816 (setq groups (cons (symbol-name group) groups)))) | |
| 4817 gnus-active-hashtb) | |
| 4818 ;; Go through all descriptions that are known to Gnus. | |
| 4819 (if search-description | |
| 4820 (mapatoms | |
| 4821 (lambda (group) | |
| 4822 (and (string-match regexp (symbol-value group)) | |
| 4823 (gnus-gethash (symbol-name group) gnus-active-hashtb) | |
| 4824 (setq groups (cons (symbol-name group) groups)))) | |
| 4825 gnus-description-hashtb)) | |
| 4826 (if (not groups) | |
| 4827 (gnus-message 3 "No groups matched \"%s\"." regexp) | |
| 4828 ;; Print out all the groups. | |
| 4829 (save-excursion | |
| 4830 (pop-to-buffer "*Gnus Help*") | |
| 4831 (buffer-disable-undo (current-buffer)) | |
| 4832 (erase-buffer) | |
| 4833 (setq groups (sort groups 'string<)) | |
| 4834 (while groups | |
| 4835 ;; Groups may be entered twice into the list of groups. | |
| 4836 (if (not (string= (car groups) prev)) | |
| 4837 (progn | |
| 4838 (insert (setq prev (car groups)) "\n") | |
| 4839 (if (and gnus-description-hashtb | |
| 4840 (setq des (gnus-gethash (car groups) | |
| 4841 gnus-description-hashtb))) | |
| 4842 (insert " " des "\n")))) | |
| 4843 (setq groups (cdr groups))) | |
| 4844 (goto-char (point-min)))) | |
| 4845 (pop-to-buffer obuf))) | |
| 4846 | |
| 4847 (defun gnus-group-description-apropos (regexp) | |
| 4848 "List all newsgroups that have names or descriptions that match a regexp." | |
| 4849 (interactive "sGnus description apropos (regexp): ") | |
| 4850 (if (not (or gnus-description-hashtb | |
| 4851 (gnus-read-all-descriptions-files))) | |
| 4852 (error "Couldn't request descriptions file")) | |
| 4853 (gnus-group-apropos regexp t)) | |
| 4854 | |
| 4855 ;; Suggested by Per Abrahamsen <amanda@iesd.auc.dk>. | |
| 4856 (defun gnus-group-list-matching (level regexp &optional all lowest) | |
| 4857 "List all groups with unread articles that match REGEXP. | |
| 4858 If the prefix LEVEL is non-nil, it should be a number that says which | |
| 4859 level to cut off listing groups. | |
| 4860 If ALL, also list groups with no unread articles. | |
| 4861 If LOWEST, don't list groups with level lower than LOWEST." | |
| 4862 (interactive "P\nsList newsgroups matching: ") | |
| 4863 (gnus-group-prepare-flat (or level gnus-level-subscribed) | |
| 4864 all (or lowest 1) regexp) | |
| 4865 (goto-char (point-min)) | |
| 4866 (gnus-group-position-cursor)) | |
| 4867 | |
| 4868 (defun gnus-group-list-all-matching (level regexp &optional lowest) | |
| 4869 "List all groups that match REGEXP. | |
| 4870 If the prefix LEVEL is non-nil, it should be a number that says which | |
| 4871 level to cut off listing groups. | |
| 4872 If LOWEST, don't list groups with level lower than LOWEST." | |
| 4873 (interactive "P\nsList newsgroups matching: ") | |
| 4874 (gnus-group-list-matching (or level gnus-level-killed) regexp t lowest)) | |
| 4875 | |
| 4876 ;; Suggested by Jack Vinson <vinson@unagi.cis.upenn.edu>. | |
| 4877 (defun gnus-group-save-newsrc () | |
| 4878 "Save the Gnus startup files." | |
| 4879 (interactive) | |
| 4880 (gnus-save-newsrc-file)) | |
| 4881 | |
| 4882 (defun gnus-group-restart (&optional arg) | |
| 4883 "Force Gnus to read the .newsrc file." | |
| 4884 (interactive "P") | |
| 4885 (gnus-save-newsrc-file) | |
| 4886 (gnus-setup-news 'force) | |
| 4887 (gnus-group-list-groups arg)) | |
| 4888 | |
| 4889 (defun gnus-group-read-init-file () | |
| 4890 "Read the Gnus elisp init file." | |
| 4891 (interactive) | |
| 4892 (gnus-read-init-file)) | |
| 4893 | |
| 4894 (defun gnus-group-check-bogus-groups (&optional silent) | |
| 4895 "Check bogus newsgroups. | |
| 4896 If given a prefix, don't ask for confirmation before removing a bogus | |
| 4897 group." | |
| 4898 (interactive "P") | |
| 4899 (gnus-check-bogus-newsgroups (and (not silent) (not gnus-expert-user))) | |
| 4900 (gnus-group-list-groups)) | |
| 4901 | |
| 4902 (defun gnus-group-edit-global-kill (&optional article group) | |
| 4903 "Edit the global kill file. | |
| 4904 If GROUP, edit that local kill file instead." | |
| 4905 (interactive "P") | |
| 4906 (setq gnus-current-kill-article article) | |
| 4907 (gnus-kill-file-edit-file group) | |
| 4908 (gnus-message | |
| 4909 6 | |
| 4910 (substitute-command-keys | |
| 4911 "Editing a global kill file (Type \\[gnus-kill-file-exit] to exit)"))) | |
| 4912 | |
| 4913 (defun gnus-group-edit-local-kill (article group) | |
| 4914 "Edit a local kill file." | |
| 4915 (interactive (list nil (gnus-group-group-name))) | |
| 4916 (gnus-group-edit-global-kill article group)) | |
| 4917 | |
| 4918 (defun gnus-group-force-update () | |
| 4919 "Update `.newsrc' file." | |
| 4920 (interactive) | |
| 4921 (gnus-save-newsrc-file)) | |
| 4922 | |
| 4923 (defun gnus-group-suspend () | |
| 4924 "Suspend the current Gnus session. | |
| 4925 In fact, cleanup buffers except for group mode buffer. | |
| 4926 The hook gnus-suspend-gnus-hook is called before actually suspending." | |
| 4927 (interactive) | |
| 4928 (run-hooks 'gnus-suspend-gnus-hook) | |
| 4929 ;; Kill Gnus buffers except for group mode buffer. | |
| 4930 (let ((group-buf (get-buffer gnus-group-buffer))) | |
| 4931 ;; Do this on a separate list in case the user does a ^G before we finish | |
| 4932 (let ((gnus-buffer-list | |
| 4933 (delq group-buf (delq gnus-dribble-buffer | |
| 4934 (append gnus-buffer-list nil))))) | |
| 4935 (while gnus-buffer-list | |
| 4936 (gnus-kill-buffer (car gnus-buffer-list)) | |
| 4937 (setq gnus-buffer-list (cdr gnus-buffer-list)))) | |
| 4938 (if group-buf | |
| 4939 (progn | |
| 4940 (setq gnus-buffer-list (list group-buf)) | |
| 4941 (bury-buffer group-buf) | |
| 4942 (delete-windows-on group-buf t))))) | |
| 4943 | |
| 4944 (defun gnus-group-clear-dribble () | |
| 4945 "Clear all information from the dribble buffer." | |
| 4946 (interactive) | |
| 4947 (gnus-dribble-clear)) | |
| 4948 | |
| 4949 (defun gnus-group-exit () | |
| 4950 "Quit reading news after updating .newsrc.eld and .newsrc. | |
| 4951 The hook `gnus-exit-gnus-hook' is called before actually exiting." | |
| 4952 (interactive) | |
| 4953 (if (or noninteractive ;For gnus-batch-kill | |
| 4954 (not (gnus-server-opened gnus-select-method)) ;NNTP connection closed | |
| 4955 (not gnus-interactive-exit) ;Without confirmation | |
| 4956 gnus-expert-user | |
| 4957 (gnus-y-or-n-p "Are you sure you want to quit reading news? ")) | |
| 4958 (progn | |
| 4959 (run-hooks 'gnus-exit-gnus-hook) | |
| 4960 ;; Offer to save data from non-quitted summary buffers. | |
| 4961 (gnus-offer-save-summaries) | |
| 4962 ;; Save the newsrc file(s). | |
| 4963 (gnus-save-newsrc-file) | |
| 4964 ;; Kill-em-all. | |
| 4965 (gnus-close-backends) | |
| 4966 ;; Reset everything. | |
| 4967 (gnus-clear-system)))) | |
| 4968 | |
| 4969 (defun gnus-close-backends () | |
| 4970 ;; Send a close request to all backends that support such a request. | |
| 4971 (let ((methods gnus-valid-select-methods) | |
| 4972 func) | |
| 4973 (while methods | |
| 4974 (if (fboundp (setq func (intern (concat (car (car methods)) | |
| 4975 "-request-close")))) | |
| 4976 (funcall func)) | |
| 4977 (setq methods (cdr methods))))) | |
| 4978 | |
| 4979 (defun gnus-group-quit () | |
| 4980 "Quit reading news without updating .newsrc.eld or .newsrc. | |
| 4981 The hook `gnus-exit-gnus-hook' is called before actually exiting." | |
| 4982 (interactive) | |
| 4983 (if (or noninteractive ;For gnus-batch-kill | |
| 4984 (zerop (buffer-size)) | |
| 4985 (not (gnus-server-opened gnus-select-method)) | |
| 4986 gnus-expert-user | |
| 4987 (not gnus-current-startup-file) | |
| 4988 (gnus-yes-or-no-p | |
| 4989 (format "Quit reading news without saving %s? " | |
| 4990 (file-name-nondirectory gnus-current-startup-file)))) | |
| 4991 (progn | |
| 4992 (run-hooks 'gnus-exit-gnus-hook) | |
| 4993 (if gnus-use-full-window | |
| 4994 (delete-other-windows) | |
| 4995 (gnus-remove-some-windows)) | |
| 4996 (gnus-dribble-save) | |
| 4997 (gnus-close-backends) | |
| 4998 (gnus-clear-system)))) | |
| 4999 | |
| 5000 (defun gnus-offer-save-summaries () | |
| 5001 (save-excursion | |
| 5002 (let ((buflist (buffer-list)) | |
| 5003 buffers bufname) | |
| 5004 (while buflist | |
| 5005 (and (setq bufname (buffer-name (car buflist))) | |
| 5006 (string-match "Summary" bufname) | |
| 5007 (save-excursion | |
| 5008 (set-buffer bufname) | |
| 5009 ;; We check that this is, indeed, a summary buffer. | |
| 5010 (eq major-mode 'gnus-summary-mode)) | |
| 5011 (setq buffers (cons bufname buffers))) | |
| 5012 (setq buflist (cdr buflist))) | |
| 5013 (and buffers | |
| 5014 (map-y-or-n-p | |
| 5015 "Update summary buffer %s? " | |
| 5016 (lambda (buf) | |
| 5017 (set-buffer buf) | |
| 5018 (gnus-summary-exit)) | |
| 5019 buffers))))) | |
| 5020 | |
| 5021 (defun gnus-group-describe-briefly () | |
| 5022 "Give a one line description of the group mode commands." | |
| 5023 (interactive) | |
| 5024 (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"))) | |
| 5025 | |
| 5026 (defun gnus-group-browse-foreign-server (method) | |
| 5027 "Browse a foreign news server. | |
| 5028 If called interactively, this function will ask for a select method | |
| 5029 (nntp, nnspool, etc.) and a server address (eg. nntp.some.where). | |
| 5030 If not, METHOD should be a list where the first element is the method | |
| 5031 and the second element is the address." | |
| 5032 (interactive | |
| 5033 (list (let ((how (completing-read | |
| 5034 "Which backend: " | |
| 5035 (append gnus-valid-select-methods gnus-server-alist) | |
| 5036 nil t "nntp"))) | |
| 5037 ;; We either got a backend name or a virtual server name. | |
| 5038 ;; If the first, we also need an address. | |
| 5039 (if (assoc how gnus-valid-select-methods) | |
| 5040 (list (intern how) | |
| 5041 ;; Suggested by mapjph@bath.ac.uk. | |
| 5042 (completing-read | |
| 5043 "Address: " | |
| 5044 (mapcar (lambda (server) (list server)) | |
| 5045 gnus-secondary-servers))) | |
| 5046 ;; We got a server name, so we find the method. | |
| 5047 (gnus-server-to-method how))))) | |
| 5048 (gnus-browse-foreign-server method)) | |
| 5049 | |
| 5050 | |
| 5051 ;;; | |
| 5052 ;;; Browse Server Mode | |
| 5053 ;;; | |
| 5054 | |
| 5055 (defvar gnus-browse-mode-hook nil) | |
| 5056 (defvar gnus-browse-mode-map nil) | |
| 5057 (put 'gnus-browse-mode 'mode-class 'special) | |
| 5058 | |
| 5059 (if gnus-browse-mode-map | |
| 5060 nil | |
| 5061 (setq gnus-browse-mode-map (make-keymap)) | |
| 5062 (suppress-keymap gnus-browse-mode-map) | |
| 5063 (define-key gnus-browse-mode-map " " 'gnus-browse-read-group) | |
| 5064 (define-key gnus-browse-mode-map "=" 'gnus-browse-select-group) | |
| 5065 (define-key gnus-browse-mode-map "n" 'gnus-browse-next-group) | |
| 5066 (define-key gnus-browse-mode-map "p" 'gnus-browse-prev-group) | |
| 5067 (define-key gnus-browse-mode-map "\177" 'gnus-browse-prev-group) | |
| 5068 (define-key gnus-browse-mode-map "N" 'gnus-browse-next-group) | |
| 5069 (define-key gnus-browse-mode-map "P" 'gnus-browse-prev-group) | |
| 5070 (define-key gnus-browse-mode-map "\M-n" 'gnus-browse-next-group) | |
| 5071 (define-key gnus-browse-mode-map "\M-p" 'gnus-browse-prev-group) | |
| 5072 (define-key gnus-browse-mode-map "\r" 'gnus-browse-select-group) | |
| 5073 (define-key gnus-browse-mode-map "u" 'gnus-browse-unsubscribe-current-group) | |
| 5074 (define-key gnus-browse-mode-map "l" 'gnus-browse-exit) | |
| 5075 (define-key gnus-browse-mode-map "L" 'gnus-browse-exit) | |
| 5076 (define-key gnus-browse-mode-map "q" 'gnus-browse-exit) | |
| 5077 (define-key gnus-browse-mode-map "Q" 'gnus-browse-exit) | |
| 5078 (define-key gnus-browse-mode-map "\C-c\C-c" 'gnus-browse-exit) | |
| 5079 (define-key gnus-browse-mode-map "?" 'gnus-browse-describe-briefly) | |
| 5080 (define-key gnus-browse-mode-map "\C-c\C-i" 'gnus-info-find-node) | |
| 5081 ) | |
| 5082 | |
| 5083 (defvar gnus-browse-current-method nil) | |
| 5084 (defvar gnus-browse-return-buffer nil) | |
| 5085 | |
| 5086 (defvar gnus-browse-buffer "*Gnus Browse Server*") | |
| 5087 | |
| 5088 (defun gnus-browse-foreign-server (method &optional return-buffer) | |
| 5089 (setq gnus-browse-current-method method) | |
| 5090 (setq gnus-browse-return-buffer return-buffer) | |
| 5091 (let ((gnus-select-method method) | |
| 5092 groups group) | |
| 5093 (gnus-message 5 "Connecting to %s..." (nth 1 method)) | |
| 5094 (or (gnus-check-server method) | |
| 5095 (error "Unable to contact server: %s" (gnus-status-message method))) | |
| 5096 (or (gnus-request-list method) | |
| 5097 (error "Couldn't request list: %s" (gnus-status-message method))) | |
| 5098 (get-buffer-create gnus-browse-buffer) | |
| 5099 (gnus-add-current-to-buffer-list) | |
| 5100 (and gnus-carpal (gnus-carpal-setup-buffer 'browse)) | |
| 5101 (gnus-configure-windows 'browse) | |
| 5102 (buffer-disable-undo (current-buffer)) | |
| 5103 (let ((buffer-read-only nil)) | |
| 5104 (erase-buffer)) | |
| 5105 (gnus-browse-mode) | |
| 5106 (setq mode-line-buffer-identification | |
| 5107 (format | |
| 5108 "Gnus Browse Server {%s:%s}" (car method) (car (cdr method)))) | |
| 5109 (save-excursion | |
| 5110 (set-buffer nntp-server-buffer) | |
| 5111 (let ((cur (current-buffer))) | |
| 5112 (goto-char (point-min)) | |
| 5113 (or (string= gnus-ignored-newsgroups "") | |
| 5114 (delete-matching-lines gnus-ignored-newsgroups)) | |
| 5115 (while (re-search-forward | |
| 5116 "\\(^[^ \t]+\\)[ \t]+[0-9]+[ \t]+[0-9]+" nil t) | |
| 5117 (goto-char (match-end 1)) | |
| 5118 (setq groups (cons (cons (buffer-substring (match-beginning 1) | |
| 5119 (match-end 1)) | |
| 5120 (max 0 (- (1+ (read cur)) (read cur)))) | |
| 5121 groups))))) | |
| 5122 (setq groups (sort groups | |
| 5123 (lambda (l1 l2) | |
| 5124 (string< (car l1) (car l2))))) | |
| 5125 (let ((buffer-read-only nil)) | |
| 5126 (while groups | |
| 5127 (setq group (car groups)) | |
| 5128 (insert | |
| 5129 (format "K%7d: %s\n" (cdr group) (car group))) | |
| 5130 (setq groups (cdr groups)))) | |
| 5131 (switch-to-buffer (current-buffer)) | |
| 5132 (goto-char (point-min)) | |
| 5133 (gnus-group-position-cursor))) | |
| 5134 | |
| 5135 (defun gnus-browse-mode () | |
| 5136 "Major mode for browsing a foreign server. | |
| 5137 | |
| 5138 All normal editing commands are switched off. | |
| 5139 | |
| 5140 \\<gnus-browse-mode-map> | |
| 5141 The only things you can do in this buffer is | |
| 5142 | |
| 5143 1) `\\[gnus-browse-unsubscribe-current-group]' to subscribe to a group. | |
| 5144 The group will be inserted into the group buffer upon exit from this | |
| 5145 buffer. | |
| 5146 | |
| 5147 2) `\\[gnus-browse-read-group]' to read a group ephemerally. | |
| 5148 | |
| 5149 3) `\\[gnus-browse-exit]' to return to the group buffer." | |
| 5150 (interactive) | |
| 5151 (kill-all-local-variables) | |
| 5152 (if gnus-visual (gnus-browse-make-menu-bar)) | |
| 5153 (setq mode-line-modified "-- ") | |
| 5154 (make-local-variable 'mode-line-format) | |
| 5155 (setq mode-line-format (copy-sequence mode-line-format)) | |
| 5156 (and (equal (nth 3 mode-line-format) " ") | |
| 5157 (setcar (nthcdr 3 mode-line-format) "")) | |
| 5158 (setq major-mode 'gnus-browse-mode) | |
| 5159 (setq mode-name "Browse Server") | |
| 5160 (setq mode-line-process nil) | |
| 5161 (use-local-map gnus-browse-mode-map) | |
| 5162 (buffer-disable-undo (current-buffer)) | |
| 5163 (setq truncate-lines t) | |
| 5164 (setq buffer-read-only t) | |
| 5165 (run-hooks 'gnus-browse-mode-hook)) | |
| 5166 | |
| 5167 (defun gnus-browse-read-group (&optional no-article) | |
| 5168 "Enter the group at the current line." | |
| 5169 (interactive) | |
| 5170 (let ((group (gnus-browse-group-name))) | |
| 5171 (or (gnus-group-read-ephemeral-group | |
| 5172 group gnus-browse-current-method nil | |
| 5173 (cons (current-buffer) 'browse)) | |
| 5174 (error "Couldn't enter %s" group)))) | |
| 5175 | |
| 5176 (defun gnus-browse-select-group () | |
| 5177 "Select the current group." | |
| 5178 (interactive) | |
| 5179 (gnus-browse-read-group 'no)) | |
| 5180 | |
| 5181 (defun gnus-browse-next-group (n) | |
| 5182 "Go to the next group." | |
| 5183 (interactive "p") | |
| 5184 (prog1 | |
| 5185 (forward-line n) | |
| 5186 (gnus-group-position-cursor))) | |
| 5187 | |
| 5188 (defun gnus-browse-prev-group (n) | |
| 5189 "Go to the next group." | |
| 5190 (interactive "p") | |
| 5191 (gnus-browse-next-group (- n))) | |
| 5192 | |
| 5193 (defun gnus-browse-unsubscribe-current-group (arg) | |
| 5194 "(Un)subscribe to the next ARG groups." | |
| 5195 (interactive "p") | |
| 5196 (and (eobp) | |
| 5197 (error "No group at current line.")) | |
| 5198 (let ((ward (if (< arg 0) -1 1)) | |
| 5199 (arg (abs arg))) | |
| 5200 (while (and (> arg 0) | |
| 5201 (not (eobp)) | |
| 5202 (gnus-browse-unsubscribe-group) | |
| 5203 (zerop (gnus-browse-next-group ward))) | |
| 5204 (setq arg (1- arg))) | |
| 5205 (gnus-group-position-cursor) | |
| 5206 (if (/= 0 arg) (gnus-message 7 "No more newsgroups")) | |
| 5207 arg)) | |
| 5208 | |
| 5209 (defun gnus-browse-group-name () | |
| 5210 (save-excursion | |
| 5211 (beginning-of-line) | |
| 5212 (if (not (re-search-forward ": \\(.*\\)$" (gnus-point-at-eol) t)) | |
| 5213 () | |
| 5214 (gnus-group-prefixed-name | |
| 5215 (buffer-substring (match-beginning 1) (match-end 1)) | |
| 5216 gnus-browse-current-method)))) | |
| 5217 | |
| 5218 (defun gnus-browse-unsubscribe-group () | |
| 5219 "Toggle subscription of the current group in the browse buffer." | |
| 5220 (let ((sub nil) | |
| 5221 (buffer-read-only nil) | |
| 5222 group) | |
| 5223 (save-excursion | |
| 5224 (beginning-of-line) | |
| 5225 ;; If this group it killed, then we want to subscribe it. | |
| 5226 (if (= (following-char) ?K) (setq sub t)) | |
| 5227 (setq group (gnus-browse-group-name)) | |
| 5228 (delete-char 1) | |
| 5229 (if sub | |
| 5230 (progn | |
| 5231 (gnus-group-change-level | |
| 5232 (list t group gnus-level-default-subscribed | |
| 5233 nil nil gnus-browse-current-method) | |
| 5234 gnus-level-default-subscribed gnus-level-killed | |
| 5235 (and (car (nth 1 gnus-newsrc-alist)) | |
| 5236 (gnus-gethash (car (nth 1 gnus-newsrc-alist)) | |
| 5237 gnus-newsrc-hashtb)) | |
| 5238 t) | |
| 5239 (insert ? )) | |
| 5240 (gnus-group-change-level | |
| 5241 group gnus-level-killed gnus-level-default-subscribed) | |
| 5242 (insert ?K))) | |
| 5243 t)) | |
| 5244 | |
| 5245 (defun gnus-browse-exit () | |
| 5246 "Quit browsing and return to the group buffer." | |
| 5247 (interactive) | |
| 5248 (if (eq major-mode 'gnus-browse-mode) | |
| 5249 (kill-buffer (current-buffer))) | |
| 5250 (if gnus-browse-return-buffer | |
| 5251 (gnus-configure-windows 'server 'force) | |
| 5252 (gnus-configure-windows 'group 'force) | |
| 5253 (gnus-group-list-groups nil))) | |
| 5254 | |
| 5255 (defun gnus-browse-describe-briefly () | |
| 5256 "Give a one line description of the group mode commands." | |
| 5257 (interactive) | |
| 5258 (gnus-message 6 | |
| 5259 (substitute-command-keys "\\<gnus-browse-mode-map>\\[gnus-group-next-group]:Forward \\[gnus-group-prev-group]:Backward \\[gnus-browse-exit]:Exit \\[gnus-info-find-node]:Run Info \\[gnus-browse-describe-briefly]:This help"))) | |
| 5260 | |
| 5261 | |
| 5262 ;;; | |
| 5263 ;;; Gnus summary mode | |
| 5264 ;;; | |
| 5265 | |
| 5266 (defvar gnus-summary-mode-map nil) | |
| 5267 (defvar gnus-summary-mark-map nil) | |
| 5268 (defvar gnus-summary-mscore-map nil) | |
| 5269 (defvar gnus-summary-article-map nil) | |
| 5270 (defvar gnus-summary-thread-map nil) | |
| 5271 (defvar gnus-summary-goto-map nil) | |
| 5272 (defvar gnus-summary-exit-map nil) | |
| 5273 (defvar gnus-summary-interest-map nil) | |
| 5274 (defvar gnus-summary-sort-map nil) | |
| 5275 (defvar gnus-summary-backend-map nil) | |
| 5276 (defvar gnus-summary-save-map nil) | |
| 5277 (defvar gnus-summary-wash-map nil) | |
| 5278 (defvar gnus-summary-wash-hide-map nil) | |
| 5279 (defvar gnus-summary-wash-highlight-map nil) | |
| 5280 (defvar gnus-summary-wash-time-map nil) | |
| 5281 (defvar gnus-summary-help-map nil) | |
| 5282 | |
| 5283 (put 'gnus-summary-mode 'mode-class 'special) | |
| 5284 | |
| 5285 (if gnus-summary-mode-map | |
| 5286 nil | |
| 5287 (setq gnus-summary-mode-map (make-keymap)) | |
| 5288 (suppress-keymap gnus-summary-mode-map) | |
| 5289 | |
| 5290 ;; Non-orthogonal keys | |
| 5291 | |
| 5292 (define-key gnus-summary-mode-map " " 'gnus-summary-next-page) | |
| 5293 (define-key gnus-summary-mode-map "\177" 'gnus-summary-prev-page) | |
| 5294 (define-key gnus-summary-mode-map "\r" 'gnus-summary-scroll-up) | |
| 5295 (define-key gnus-summary-mode-map "n" 'gnus-summary-next-unread-article) | |
| 5296 (define-key gnus-summary-mode-map "p" 'gnus-summary-prev-unread-article) | |
| 5297 (define-key gnus-summary-mode-map "N" 'gnus-summary-next-article) | |
| 5298 (define-key gnus-summary-mode-map "P" 'gnus-summary-prev-article) | |
| 5299 (define-key gnus-summary-mode-map "\M-\C-n" 'gnus-summary-next-same-subject) | |
| 5300 (define-key gnus-summary-mode-map "\M-\C-p" 'gnus-summary-prev-same-subject) | |
| 5301 (define-key gnus-summary-mode-map "\M-n" 'gnus-summary-next-unread-subject) | |
| 5302 (define-key gnus-summary-mode-map "\M-p" 'gnus-summary-prev-unread-subject) | |
| 5303 (define-key gnus-summary-mode-map "." 'gnus-summary-first-unread-article) | |
| 5304 (define-key gnus-summary-mode-map "," 'gnus-summary-best-unread-article) | |
| 5305 (define-key gnus-summary-mode-map | |
| 5306 "\M-s" 'gnus-summary-search-article-forward) | |
| 5307 (define-key gnus-summary-mode-map | |
| 5308 "\M-r" 'gnus-summary-search-article-backward) | |
| 5309 (define-key gnus-summary-mode-map "<" 'gnus-summary-beginning-of-article) | |
| 5310 (define-key gnus-summary-mode-map ">" 'gnus-summary-end-of-article) | |
| 5311 (define-key gnus-summary-mode-map "j" 'gnus-summary-goto-subject) | |
| 5312 (define-key gnus-summary-mode-map "^" 'gnus-summary-refer-parent-article) | |
| 5313 (define-key gnus-summary-mode-map "\M-^" 'gnus-summary-refer-article) | |
| 5314 (define-key gnus-summary-mode-map "u" 'gnus-summary-tick-article-forward) | |
| 5315 (define-key gnus-summary-mode-map "!" 'gnus-summary-tick-article-forward) | |
| 5316 (define-key gnus-summary-mode-map "U" 'gnus-summary-tick-article-backward) | |
| 5317 (define-key gnus-summary-mode-map "d" 'gnus-summary-mark-as-read-forward) | |
| 5318 (define-key gnus-summary-mode-map "D" 'gnus-summary-mark-as-read-backward) | |
| 5319 (define-key gnus-summary-mode-map "E" 'gnus-summary-mark-as-expirable) | |
| 5320 (define-key gnus-summary-mode-map "\M-u" 'gnus-summary-clear-mark-forward) | |
| 5321 (define-key gnus-summary-mode-map "\M-U" 'gnus-summary-clear-mark-backward) | |
| 5322 (define-key gnus-summary-mode-map | |
| 5323 "k" 'gnus-summary-kill-same-subject-and-select) | |
| 5324 (define-key gnus-summary-mode-map "\C-k" 'gnus-summary-kill-same-subject) | |
| 5325 (define-key gnus-summary-mode-map "\M-\C-k" 'gnus-summary-kill-thread) | |
| 5326 (define-key gnus-summary-mode-map "\M-\C-l" 'gnus-summary-lower-thread) | |
| 5327 (define-key gnus-summary-mode-map "e" 'gnus-summary-edit-article) | |
| 5328 (define-key gnus-summary-mode-map "#" 'gnus-summary-mark-as-processable) | |
| 5329 (define-key gnus-summary-mode-map "\M-#" 'gnus-summary-unmark-as-processable) | |
| 5330 (define-key gnus-summary-mode-map "\M-\C-t" 'gnus-summary-toggle-threads) | |
| 5331 (define-key gnus-summary-mode-map "\M-\C-s" 'gnus-summary-show-thread) | |
| 5332 (define-key gnus-summary-mode-map "\M-\C-h" 'gnus-summary-hide-thread) | |
| 5333 (define-key gnus-summary-mode-map "\M-\C-f" 'gnus-summary-next-thread) | |
| 5334 (define-key gnus-summary-mode-map "\M-\C-b" 'gnus-summary-prev-thread) | |
| 5335 (define-key gnus-summary-mode-map "\M-\C-u" 'gnus-summary-up-thread) | |
| 5336 (define-key gnus-summary-mode-map "\M-\C-d" 'gnus-summary-down-thread) | |
| 5337 (define-key gnus-summary-mode-map "&" 'gnus-summary-execute-command) | |
| 5338 (define-key gnus-summary-mode-map "c" 'gnus-summary-catchup-and-exit) | |
| 5339 (define-key gnus-summary-mode-map "\C-w" 'gnus-summary-mark-region-as-read) | |
| 5340 (define-key gnus-summary-mode-map "\C-t" 'gnus-summary-toggle-truncation) | |
| 5341 (define-key gnus-summary-mode-map "?" 'gnus-summary-mark-as-dormant) | |
| 5342 (define-key gnus-summary-mode-map | |
| 5343 "\C-c\M-\C-s" 'gnus-summary-show-all-expunged) | |
| 5344 (define-key gnus-summary-mode-map | |
| 5345 "\C-c\C-s\C-n" 'gnus-summary-sort-by-number) | |
| 5346 (define-key gnus-summary-mode-map | |
| 5347 "\C-c\C-s\C-a" 'gnus-summary-sort-by-author) | |
| 5348 (define-key gnus-summary-mode-map | |
| 5349 "\C-c\C-s\C-s" 'gnus-summary-sort-by-subject) | |
| 5350 (define-key gnus-summary-mode-map "\C-c\C-s\C-d" 'gnus-summary-sort-by-date) | |
| 5351 (define-key gnus-summary-mode-map "\C-c\C-s\C-i" 'gnus-summary-sort-by-score) | |
| 5352 (define-key gnus-summary-mode-map "=" 'gnus-summary-expand-window) | |
| 5353 (define-key gnus-summary-mode-map | |
| 5354 "\C-x\C-s" 'gnus-summary-reselect-current-group) | |
| 5355 (define-key gnus-summary-mode-map "\M-g" 'gnus-summary-rescan-group) | |
| 5356 (define-key gnus-summary-mode-map "w" 'gnus-summary-stop-page-breaking) | |
| 5357 (define-key gnus-summary-mode-map "\C-c\C-r" 'gnus-summary-caesar-message) | |
| 5358 (define-key gnus-summary-mode-map "\M-t" 'gnus-summary-toggle-mime) | |
| 5359 (define-key gnus-summary-mode-map "f" 'gnus-summary-followup) | |
| 5360 (define-key gnus-summary-mode-map "F" 'gnus-summary-followup-with-original) | |
| 5361 (define-key gnus-summary-mode-map "C" 'gnus-summary-cancel-article) | |
| 5362 (define-key gnus-summary-mode-map "r" 'gnus-summary-reply) | |
| 5363 (define-key gnus-summary-mode-map "R" 'gnus-summary-reply-with-original) | |
| 5364 (define-key gnus-summary-mode-map "\C-c\C-f" 'gnus-summary-mail-forward) | |
| 5365 (define-key gnus-summary-mode-map "o" 'gnus-summary-save-article) | |
| 5366 (define-key gnus-summary-mode-map "\C-o" 'gnus-summary-save-article-mail) | |
| 5367 (define-key gnus-summary-mode-map "|" 'gnus-summary-pipe-output) | |
| 5368 (define-key gnus-summary-mode-map "\M-k" 'gnus-summary-edit-local-kill) | |
| 5369 (define-key gnus-summary-mode-map "\M-K" 'gnus-summary-edit-global-kill) | |
| 5370 (define-key gnus-summary-mode-map "V" 'gnus-version) | |
| 5371 (define-key gnus-summary-mode-map "\C-c\C-d" 'gnus-summary-describe-group) | |
| 5372 (define-key gnus-summary-mode-map "q" 'gnus-summary-exit) | |
| 5373 (define-key gnus-summary-mode-map "Q" 'gnus-summary-exit-no-update) | |
| 5374 (define-key gnus-summary-mode-map "\C-c\C-i" 'gnus-info-find-node) | |
| 5375 (define-key gnus-summary-mode-map gnus-mouse-2 'gnus-mouse-pick-article) | |
| 5376 (define-key gnus-summary-mode-map "m" 'gnus-summary-mail-other-window) | |
| 5377 (define-key gnus-summary-mode-map "a" 'gnus-summary-post-news) | |
| 5378 (define-key gnus-summary-mode-map | |
| 5379 "x" 'gnus-summary-remove-lines-marked-as-read) | |
| 5380 ; (define-key gnus-summary-mode-map "X" 'gnus-summary-remove-lines-marked-with) | |
| 5381 (define-key gnus-summary-mode-map "s" 'gnus-summary-isearch-article) | |
| 5382 (define-key gnus-summary-mode-map "t" 'gnus-summary-toggle-header) | |
| 5383 (define-key gnus-summary-mode-map "g" 'gnus-summary-show-article) | |
| 5384 ; (define-key gnus-summary-mode-map "?" 'gnus-summary-describe-briefly) | |
| 5385 (define-key gnus-summary-mode-map "l" 'gnus-summary-goto-last-article) | |
| 5386 (define-key gnus-summary-mode-map "\C-c\C-v\C-v" 'gnus-uu-decode-uu-view) | |
| 5387 (define-key gnus-summary-mode-map "\C-d" 'gnus-summary-enter-digest-group) | |
| 5388 (define-key gnus-summary-mode-map "v" 'gnus-summary-verbose-headers) | |
| 5389 (define-key gnus-summary-mode-map "\C-c\C-b" 'gnus-bug) | |
| 5390 | |
| 5391 | |
| 5392 ;; Sort of orthogonal keymap | |
| 5393 (define-prefix-command 'gnus-summary-mark-map) | |
| 5394 (define-key gnus-summary-mode-map "M" 'gnus-summary-mark-map) | |
| 5395 (define-key gnus-summary-mark-map "t" 'gnus-summary-tick-article-forward) | |
| 5396 (define-key gnus-summary-mark-map "!" 'gnus-summary-tick-article-forward) | |
| 5397 (define-key gnus-summary-mark-map "d" 'gnus-summary-mark-as-read-forward) | |
| 5398 (define-key gnus-summary-mark-map "r" 'gnus-summary-mark-as-read-forward) | |
| 5399 (define-key gnus-summary-mark-map "c" 'gnus-summary-clear-mark-forward) | |
| 5400 (define-key gnus-summary-mark-map " " 'gnus-summary-clear-mark-forward) | |
| 5401 (define-key gnus-summary-mark-map "e" 'gnus-summary-mark-as-expirable) | |
| 5402 (define-key gnus-summary-mark-map "x" 'gnus-summary-mark-as-expirable) | |
| 5403 (define-key gnus-summary-mark-map "?" 'gnus-summary-mark-as-dormant) | |
| 5404 (define-key gnus-summary-mark-map "b" 'gnus-summary-set-bookmark) | |
| 5405 (define-key gnus-summary-mark-map "B" 'gnus-summary-remove-bookmark) | |
| 5406 (define-key gnus-summary-mark-map "#" 'gnus-summary-mark-as-processable) | |
| 5407 (define-key gnus-summary-mark-map "\M-#" 'gnus-summary-unmark-as-processable) | |
| 5408 (define-key gnus-summary-mark-map | |
| 5409 "\M-r" 'gnus-summary-remove-lines-marked-as-read) | |
| 5410 (define-key gnus-summary-mark-map | |
| 5411 "\M-\C-r" 'gnus-summary-remove-lines-marked-with) | |
| 5412 (define-key gnus-summary-mark-map "D" 'gnus-summary-show-all-dormant) | |
| 5413 (define-key gnus-summary-mark-map "\M-D" 'gnus-summary-hide-all-dormant) | |
| 5414 (define-key gnus-summary-mark-map "S" 'gnus-summary-show-all-expunged) | |
| 5415 (define-key gnus-summary-mark-map "C" 'gnus-summary-catchup) | |
| 5416 (define-key gnus-summary-mark-map "H" 'gnus-summary-catchup-to-here) | |
| 5417 (define-key gnus-summary-mark-map "\C-c" 'gnus-summary-catchup-all) | |
| 5418 (define-key gnus-summary-mark-map | |
| 5419 "k" 'gnus-summary-kill-same-subject-and-select) | |
| 5420 (define-key gnus-summary-mark-map "K" 'gnus-summary-kill-same-subject) | |
| 5421 | |
| 5422 (define-prefix-command 'gnus-summary-mscore-map) | |
| 5423 (define-key gnus-summary-mark-map "V" 'gnus-summary-mscore-map) | |
| 5424 (define-key gnus-summary-mscore-map "c" 'gnus-summary-clear-above) | |
| 5425 (define-key gnus-summary-mscore-map "u" 'gnus-summary-tick-above) | |
| 5426 (define-key gnus-summary-mscore-map "m" 'gnus-summary-mark-above) | |
| 5427 (define-key gnus-summary-mscore-map "k" 'gnus-summary-kill-below) | |
| 5428 | |
| 5429 (define-key gnus-summary-mark-map "P" 'gnus-uu-mark-map) | |
| 5430 | |
| 5431 (define-key gnus-summary-mode-map "S" 'gnus-summary-send-map) | |
| 5432 | |
| 5433 (define-prefix-command 'gnus-summary-goto-map) | |
| 5434 (define-key gnus-summary-mode-map "G" 'gnus-summary-goto-map) | |
| 5435 (define-key gnus-summary-goto-map "n" 'gnus-summary-next-unread-article) | |
| 5436 (define-key gnus-summary-goto-map "p" 'gnus-summary-prev-unread-article) | |
| 5437 (define-key gnus-summary-goto-map "N" 'gnus-summary-next-article) | |
| 5438 (define-key gnus-summary-goto-map "P" 'gnus-summary-prev-article) | |
| 5439 (define-key gnus-summary-goto-map "\C-n" 'gnus-summary-next-same-subject) | |
| 5440 (define-key gnus-summary-goto-map "\C-p" 'gnus-summary-prev-same-subject) | |
| 5441 (define-key gnus-summary-goto-map "\M-n" 'gnus-summary-next-unread-subject) | |
| 5442 (define-key gnus-summary-goto-map "\M-p" 'gnus-summary-prev-unread-subject) | |
| 5443 (define-key gnus-summary-goto-map "f" 'gnus-summary-first-unread-article) | |
| 5444 (define-key gnus-summary-goto-map "b" 'gnus-summary-best-unread-article) | |
| 5445 (define-key gnus-summary-goto-map "g" 'gnus-summary-goto-subject) | |
| 5446 (define-key gnus-summary-goto-map "l" 'gnus-summary-goto-last-article) | |
| 5447 (define-key gnus-summary-goto-map "p" 'gnus-summary-pop-article) | |
| 5448 | |
| 5449 | |
| 5450 (define-prefix-command 'gnus-summary-thread-map) | |
| 5451 (define-key gnus-summary-mode-map "T" 'gnus-summary-thread-map) | |
| 5452 (define-key gnus-summary-thread-map "k" 'gnus-summary-kill-thread) | |
| 5453 (define-key gnus-summary-thread-map "l" 'gnus-summary-lower-thread) | |
| 5454 (define-key gnus-summary-thread-map "i" 'gnus-summary-raise-thread) | |
| 5455 (define-key gnus-summary-thread-map "T" 'gnus-summary-toggle-threads) | |
| 5456 (define-key gnus-summary-thread-map "s" 'gnus-summary-show-thread) | |
| 5457 (define-key gnus-summary-thread-map "S" 'gnus-summary-show-all-threads) | |
| 5458 (define-key gnus-summary-thread-map "h" 'gnus-summary-hide-thread) | |
| 5459 (define-key gnus-summary-thread-map "H" 'gnus-summary-hide-all-threads) | |
| 5460 (define-key gnus-summary-thread-map "n" 'gnus-summary-next-thread) | |
| 5461 (define-key gnus-summary-thread-map "p" 'gnus-summary-prev-thread) | |
| 5462 (define-key gnus-summary-thread-map "u" 'gnus-summary-up-thread) | |
| 5463 (define-key gnus-summary-thread-map "d" 'gnus-summary-down-thread) | |
| 5464 (define-key gnus-summary-thread-map "#" 'gnus-uu-mark-thread) | |
| 5465 | |
| 5466 | |
| 5467 (define-prefix-command 'gnus-summary-exit-map) | |
| 5468 (define-key gnus-summary-mode-map "Z" 'gnus-summary-exit-map) | |
| 5469 (define-key gnus-summary-exit-map "c" 'gnus-summary-catchup-and-exit) | |
| 5470 (define-key gnus-summary-exit-map "C" 'gnus-summary-catchup-all-and-exit) | |
| 5471 (define-key gnus-summary-exit-map "E" 'gnus-summary-exit-no-update) | |
| 5472 (define-key gnus-summary-exit-map "Q" 'gnus-summary-exit) | |
| 5473 (define-key gnus-summary-exit-map "Z" 'gnus-summary-exit) | |
| 5474 (define-key gnus-summary-exit-map | |
| 5475 "n" 'gnus-summary-catchup-and-goto-next-group) | |
| 5476 (define-key gnus-summary-exit-map "R" 'gnus-summary-reselect-current-group) | |
| 5477 (define-key gnus-summary-exit-map "G" 'gnus-summary-rescan-group) | |
| 5478 (define-key gnus-summary-exit-map "N" 'gnus-summary-next-group) | |
| 5479 (define-key gnus-summary-exit-map "P" 'gnus-summary-prev-group) | |
| 5480 | |
| 5481 | |
| 5482 (define-prefix-command 'gnus-summary-article-map) | |
| 5483 (define-key gnus-summary-mode-map "A" 'gnus-summary-article-map) | |
| 5484 (define-key gnus-summary-article-map " " 'gnus-summary-next-page) | |
| 5485 (define-key gnus-summary-article-map "n" 'gnus-summary-next-page) | |
| 5486 (define-key gnus-summary-article-map "\177" 'gnus-summary-prev-page) | |
| 5487 (define-key gnus-summary-article-map "p" 'gnus-summary-prev-page) | |
| 5488 (define-key gnus-summary-article-map "\r" 'gnus-summary-scroll-up) | |
| 5489 (define-key gnus-summary-article-map "<" 'gnus-summary-beginning-of-article) | |
| 5490 (define-key gnus-summary-article-map ">" 'gnus-summary-end-of-article) | |
| 5491 (define-key gnus-summary-article-map "b" 'gnus-summary-beginning-of-article) | |
| 5492 (define-key gnus-summary-article-map "e" 'gnus-summary-end-of-article) | |
| 5493 (define-key gnus-summary-article-map "^" 'gnus-summary-refer-parent-article) | |
| 5494 (define-key gnus-summary-article-map "r" 'gnus-summary-refer-parent-article) | |
| 5495 (define-key gnus-summary-article-map "g" 'gnus-summary-show-article) | |
| 5496 (define-key gnus-summary-article-map "s" 'gnus-summary-isearch-article) | |
| 5497 | |
| 5498 | |
| 5499 | |
| 5500 (define-prefix-command 'gnus-summary-wash-map) | |
| 5501 (define-key gnus-summary-mode-map "W" 'gnus-summary-wash-map) | |
| 5502 | |
| 5503 (define-prefix-command 'gnus-summary-wash-hide-map) | |
| 5504 (define-key gnus-summary-wash-map "W" 'gnus-summary-wash-hide-map) | |
| 5505 (define-key gnus-summary-wash-hide-map "a" 'gnus-article-hide) | |
| 5506 (define-key gnus-summary-wash-hide-map "h" 'gnus-article-hide-headers) | |
| 5507 (define-key gnus-summary-wash-hide-map "s" 'gnus-article-hide-signature) | |
| 5508 (define-key gnus-summary-wash-hide-map "c" 'gnus-article-hide-citation) | |
| 5509 (define-key gnus-summary-wash-hide-map | |
| 5510 "\C-c" 'gnus-article-hide-citation-maybe) | |
| 5511 | |
| 5512 (define-prefix-command 'gnus-summary-wash-highlight-map) | |
| 5513 (define-key gnus-summary-wash-map "H" 'gnus-summary-wash-highlight-map) | |
| 5514 (define-key gnus-summary-wash-highlight-map "a" 'gnus-article-highlight) | |
| 5515 (define-key gnus-summary-wash-highlight-map | |
| 5516 "h" 'gnus-article-highlight-headers) | |
| 5517 (define-key gnus-summary-wash-highlight-map | |
| 5518 "c" 'gnus-article-highlight-citation) | |
| 5519 (define-key gnus-summary-wash-highlight-map | |
| 5520 "s" 'gnus-article-highlight-signature) | |
| 5521 | |
| 5522 (define-prefix-command 'gnus-summary-wash-time-map) | |
| 5523 (define-key gnus-summary-wash-map "T" 'gnus-summary-wash-time-map) | |
| 5524 (define-key gnus-summary-wash-time-map "z" 'gnus-article-date-ut) | |
| 5525 (define-key gnus-summary-wash-time-map "u" 'gnus-article-date-ut) | |
| 5526 (define-key gnus-summary-wash-time-map "l" 'gnus-article-date-local) | |
| 5527 (define-key gnus-summary-wash-time-map "e" 'gnus-article-date-lapsed) | |
| 5528 | |
| 5529 (define-key gnus-summary-wash-map "b" 'gnus-article-add-buttons) | |
| 5530 (define-key gnus-summary-wash-map "o" 'gnus-article-treat-overstrike) | |
| 5531 (define-key gnus-summary-wash-map "w" 'gnus-article-word-wrap) | |
| 5532 (define-key gnus-summary-wash-map "c" 'gnus-article-remove-cr) | |
| 5533 (define-key gnus-summary-wash-map "q" 'gnus-article-de-quoted-unreadable) | |
| 5534 (define-key gnus-summary-wash-map "f" 'gnus-article-display-x-face) | |
| 5535 (define-key gnus-summary-wash-map "l" 'gnus-summary-stop-page-breaking) | |
| 5536 (define-key gnus-summary-wash-map "r" 'gnus-summary-caesar-message) | |
| 5537 (define-key gnus-summary-wash-map "t" 'gnus-summary-toggle-header) | |
| 5538 (define-key gnus-summary-wash-map "m" 'gnus-summary-toggle-mime) | |
| 5539 | |
| 5540 | |
| 5541 (define-prefix-command 'gnus-summary-help-map) | |
| 5542 (define-key gnus-summary-mode-map "H" 'gnus-summary-help-map) | |
| 5543 (define-key gnus-summary-help-map "v" 'gnus-version) | |
| 5544 (define-key gnus-summary-help-map "f" 'gnus-summary-fetch-faq) | |
| 5545 (define-key gnus-summary-help-map "d" 'gnus-summary-describe-group) | |
| 5546 (define-key gnus-summary-help-map "h" 'gnus-summary-describe-briefly) | |
| 5547 (define-key gnus-summary-help-map "i" 'gnus-info-find-node) | |
| 5548 | |
| 5549 | |
| 5550 (define-prefix-command 'gnus-summary-backend-map) | |
| 5551 (define-key gnus-summary-mode-map "B" 'gnus-summary-backend-map) | |
| 5552 (define-key gnus-summary-backend-map "e" 'gnus-summary-expire-articles) | |
| 5553 (define-key gnus-summary-backend-map "\M-\C-e" | |
| 5554 'gnus-summary-expire-articles-now) | |
| 5555 (define-key gnus-summary-backend-map "\177" 'gnus-summary-delete-article) | |
| 5556 (define-key gnus-summary-backend-map "m" 'gnus-summary-move-article) | |
| 5557 (define-key gnus-summary-backend-map "r" 'gnus-summary-respool-article) | |
| 5558 (define-key gnus-summary-backend-map "w" 'gnus-summary-edit-article) | |
| 5559 (define-key gnus-summary-backend-map "c" 'gnus-summary-copy-article) | |
| 5560 (define-key gnus-summary-backend-map "q" 'gnus-summary-fancy-query) | |
| 5561 (define-key gnus-summary-backend-map "i" 'gnus-summary-import-article) | |
| 5562 | |
| 5563 | |
| 5564 (define-prefix-command 'gnus-summary-save-map) | |
| 5565 (define-key gnus-summary-mode-map "O" 'gnus-summary-save-map) | |
| 5566 (define-key gnus-summary-save-map "o" 'gnus-summary-save-article) | |
| 5567 (define-key gnus-summary-save-map "m" 'gnus-summary-save-article-mail) | |
| 5568 (define-key gnus-summary-save-map "r" 'gnus-summary-save-article-rmail) | |
| 5569 (define-key gnus-summary-save-map "f" 'gnus-summary-save-article-file) | |
| 5570 (define-key gnus-summary-save-map "h" 'gnus-summary-save-article-folder) | |
| 5571 (define-key gnus-summary-save-map "v" 'gnus-summary-save-article-vm) | |
| 5572 (define-key gnus-summary-save-map "p" 'gnus-summary-pipe-output) | |
| 5573 ; (define-key gnus-summary-save-map "s" 'gnus-soup-add-article) | |
| 5574 | |
| 5575 (define-key gnus-summary-mode-map "X" 'gnus-uu-extract-map) | |
| 5576 | |
| 5577 (define-key gnus-summary-mode-map "\M-&" 'gnus-summary-universal-argument) | |
| 5578 ; (define-key gnus-summary-various-map "\C-s" 'gnus-summary-search-article-forward) | |
| 5579 ; (define-key gnus-summary-various-map "\C-r" 'gnus-summary-search-article-backward) | |
| 5580 ; (define-key gnus-summary-various-map "r" 'gnus-summary-refer-article) | |
| 5581 ; (define-key gnus-summary-various-map "&" 'gnus-summary-execute-command) | |
| 5582 ; (define-key gnus-summary-various-map "T" 'gnus-summary-toggle-truncation) | |
| 5583 ; (define-key gnus-summary-various-map "e" 'gnus-summary-expand-window) | |
| 5584 (define-key gnus-summary-article-map "D" 'gnus-summary-enter-digest-group) | |
| 5585 ; (define-key gnus-summary-various-map "k" 'gnus-summary-edit-local-kill) | |
| 5586 ; (define-key gnus-summary-various-map "K" 'gnus-summary-edit-global-kill) | |
| 5587 | |
| 5588 (define-key gnus-summary-mode-map "V" 'gnus-summary-score-map) | |
| 5589 | |
| 5590 ; (define-prefix-command 'gnus-summary-sort-map) | |
| 5591 ; (define-key gnus-summary-various-map "s" 'gnus-summary-sort-map) | |
| 5592 ; (define-key gnus-summary-sort-map "n" 'gnus-summary-sort-by-number) | |
| 5593 ; (define-key gnus-summary-sort-map "a" 'gnus-summary-sort-by-author) | |
| 5594 ; (define-key gnus-summary-sort-map "s" 'gnus-summary-sort-by-subject) | |
| 5595 ; (define-key gnus-summary-sort-map "d" 'gnus-summary-sort-by-date) | |
| 5596 ; (define-key gnus-summary-sort-map "i" 'gnus-summary-sort-by-score) | |
| 5597 | |
| 5598 (define-key gnus-summary-mode-map "I" 'gnus-summary-increase-score) | |
| 5599 (define-key gnus-summary-mode-map "L" 'gnus-summary-lower-score) | |
| 5600 ) | |
| 5601 | |
| 5602 | |
| 5603 | |
| 5604 | |
| 5605 (defun gnus-summary-mode (&optional group) | |
| 5606 "Major mode for reading articles. | |
| 5607 | |
| 5608 All normal editing commands are switched off. | |
| 5609 \\<gnus-summary-mode-map> | |
| 5610 Each line in this buffer represents one article. To read an | |
| 5611 article, you can, for instance, type `\\[gnus-summary-next-page]'. To move forwards | |
| 5612 and backwards while displaying articles, type `\\[gnus-summary-next-unread-article]' and `\\[gnus-summary-prev-unread-article]', | |
| 5613 respectively. | |
| 5614 | |
| 5615 You can also post articles and send mail from this buffer. To | |
| 5616 follow up an article, type `\\[gnus-summary-followup]'. To mail a reply to the author | |
| 5617 of an article, type `\\[gnus-summary-reply]'. | |
| 5618 | |
| 5619 There are approx. one gazillion commands you can execute in this | |
| 5620 buffer; read the info pages for more information (`\\[gnus-info-find-node]'). | |
| 5621 | |
| 5622 The following commands are available: | |
| 5623 | |
| 5624 \\{gnus-summary-mode-map}" | |
| 5625 (interactive) | |
| 5626 (if gnus-visual (gnus-summary-make-menu-bar)) | |
| 5627 (kill-all-local-variables) | |
| 5628 (let ((locals gnus-summary-local-variables)) | |
| 5629 (while locals | |
| 5630 (if (consp (car locals)) | |
| 5631 (progn | |
| 5632 (make-local-variable (car (car locals))) | |
| 5633 (set (car (car locals)) (eval (cdr (car locals))))) | |
| 5634 (make-local-variable (car locals)) | |
| 5635 (set (car locals) nil)) | |
| 5636 (setq locals (cdr locals)))) | |
| 5637 (gnus-make-thread-indent-array) | |
| 5638 (setq mode-line-modified "-- ") | |
| 5639 (make-local-variable 'mode-line-format) | |
| 5640 (setq mode-line-format (copy-sequence mode-line-format)) | |
| 5641 (and (equal (nth 3 mode-line-format) " ") | |
| 5642 (setcar (nthcdr 3 mode-line-format) "")) | |
| 5643 (setq major-mode 'gnus-summary-mode) | |
| 5644 (setq mode-name "Summary") | |
| 5645 (make-local-variable 'minor-mode-alist) | |
| 5646 (use-local-map gnus-summary-mode-map) | |
| 5647 (buffer-disable-undo (current-buffer)) | |
| 5648 (setq buffer-read-only t) ;Disable modification | |
| 5649 (setq truncate-lines t) | |
| 5650 (setq selective-display t) | |
| 5651 (setq selective-display-ellipses t) ;Display `...' | |
| 5652 (setq buffer-display-table gnus-summary-display-table) | |
| 5653 (setq gnus-newsgroup-name group) | |
| 5654 (run-hooks 'gnus-summary-mode-hook)) | |
| 5655 | |
| 5656 (defun gnus-summary-make-display-table () | |
| 5657 ;; Change the display table. Odd characters have a tendency to mess | |
| 5658 ;; up nicely formatted displays - we make all possible glyphs | |
| 5659 ;; display only a single character. | |
| 5660 | |
| 5661 ;; We start from the standard display table, if any. | |
| 5662 (setq gnus-summary-display-table | |
| 5663 (or (copy-sequence standard-display-table) | |
| 5664 (make-display-table))) | |
| 5665 ;; Nix out all the control chars... | |
| 5666 (let ((i 32)) | |
| 5667 (while (>= (setq i (1- i)) 0) | |
| 5668 (aset gnus-summary-display-table i [??]))) | |
| 5669 ;; ... but not newline and cr, of course. (cr is necessary for the | |
| 5670 ;; selective display). | |
| 5671 (aset gnus-summary-display-table ?\n nil) | |
| 5672 (aset gnus-summary-display-table ?\r nil) | |
| 5673 ;; We nix out any glyphs over 126 that are not set already. | |
| 5674 (let ((i 256)) | |
| 5675 (while (>= (setq i (1- i)) 127) | |
| 5676 ;; Only modify if the entry is nil. | |
| 5677 (or (aref gnus-summary-display-table i) | |
| 5678 (aset gnus-summary-display-table i [??]))))) | |
| 5679 | |
| 5680 (defun gnus-summary-clear-local-variables () | |
| 5681 (let ((locals gnus-summary-local-variables)) | |
| 5682 (while locals | |
| 5683 (if (consp (car locals)) | |
| 5684 (and (vectorp (car (car locals))) | |
| 5685 (set (car (car locals)) nil)) | |
| 5686 (and (vectorp (car locals)) | |
| 5687 (set (car locals) nil))) | |
| 5688 (setq locals (cdr locals))))) | |
| 5689 | |
| 5690 ;; Some summary mode macros. | |
| 5691 | |
| 5692 ;; Return a header specified by a NUMBER. | |
| 5693 (defun gnus-get-header-by-number (number) | |
| 5694 (save-excursion | |
| 5695 (set-buffer gnus-summary-buffer) | |
| 5696 (or gnus-newsgroup-headers-hashtb-by-number | |
| 5697 (gnus-make-headers-hashtable-by-number)) | |
| 5698 (gnus-gethash (int-to-string number) | |
| 5699 gnus-newsgroup-headers-hashtb-by-number))) | |
| 5700 | |
| 5701 ;; Fast version of the function above. | |
| 5702 (defmacro gnus-get-header-by-num (number) | |
| 5703 (` (gnus-gethash (int-to-string (, number)) | |
| 5704 gnus-newsgroup-headers-hashtb-by-number))) | |
| 5705 | |
| 5706 (defmacro gnus-summary-search-forward (&optional unread subject backward) | |
| 5707 "Search for article forward. | |
| 5708 If UNREAD is non-nil, only unread articles are selected. | |
| 5709 If SUBJECT is non-nil, the article which has the same subject will be | |
| 5710 searched for. | |
| 5711 If BACKWARD is non-nil, the search will be performed backwards instead." | |
| 5712 (` (gnus-summary-search-subject (, backward) (, unread) (, subject)))) | |
| 5713 | |
| 5714 (defmacro gnus-summary-search-backward (&optional unread subject) | |
| 5715 "Search for article backward. | |
| 5716 If 1st optional argument UNREAD is non-nil, only unread article is selected. | |
| 5717 If 2nd optional argument SUBJECT is non-nil, the article which has | |
| 5718 the same subject will be searched for." | |
| 5719 (` (gnus-summary-search-forward (, unread) (, subject) t))) | |
| 5720 | |
| 5721 (defmacro gnus-summary-article-number (&optional number-or-nil) | |
| 5722 "The article number of the article on the current line. | |
| 5723 If there isn's an article number here, then we return the current | |
| 5724 article number." | |
| 5725 (if number-or-nil | |
| 5726 '(get-text-property (gnus-point-at-bol) 'gnus-number) | |
| 5727 '(or (get-text-property (gnus-point-at-bol) 'gnus-number) | |
| 5728 gnus-current-article))) | |
| 5729 | |
| 5730 (defmacro gnus-summary-thread-level () | |
| 5731 "The thread level of the article on the current line." | |
| 5732 '(or (get-text-property (gnus-point-at-bol) 'gnus-level) | |
| 5733 0)) | |
| 5734 | |
| 5735 (defmacro gnus-summary-article-mark () | |
| 5736 "The mark on the current line." | |
| 5737 '(get-text-property (gnus-point-at-bol) 'gnus-mark)) | |
| 5738 | |
| 5739 (defun gnus-summary-subject-string () | |
| 5740 "Return current subject string or nil if nothing." | |
| 5741 (let ((article (gnus-summary-article-number)) | |
| 5742 header) | |
| 5743 (and article | |
| 5744 (setq header (gnus-get-header-by-num article)) | |
| 5745 (vectorp header) | |
| 5746 (mail-header-subject header)))) | |
| 5747 | |
| 5748 ;; Various summary mode internalish functions. | |
| 5749 | |
| 5750 (defun gnus-mouse-pick-article (e) | |
| 5751 (interactive "e") | |
| 5752 (mouse-set-point e) | |
| 5753 (gnus-summary-next-page nil t)) | |
| 5754 | |
| 5755 (defun gnus-summary-setup-buffer (group) | |
| 5756 "Initialize summary buffer." | |
| 5757 (let ((buffer (concat "*Summary " group "*"))) | |
| 5758 (if (get-buffer buffer) | |
| 5759 (progn | |
| 5760 (set-buffer buffer) | |
| 5761 (not gnus-newsgroup-begin)) | |
| 5762 ;; Fix by Sudish Joseph <joseph@cis.ohio-state.edu> | |
| 5763 (setq gnus-summary-buffer (set-buffer (get-buffer-create buffer))) | |
| 5764 (gnus-add-current-to-buffer-list) | |
| 5765 (gnus-summary-mode group) | |
| 5766 (and gnus-carpal (gnus-carpal-setup-buffer 'summary)) | |
| 5767 (setq gnus-newsgroup-name group) | |
| 5768 t))) | |
| 5769 | |
| 5770 (defun gnus-set-global-variables () | |
| 5771 ;; Set the global equivalents of the summary buffer-local variables | |
| 5772 ;; to the latest values they had. These reflect the summary buffer | |
| 5773 ;; that was in action when the last article was fetched. | |
| 5774 (if (eq major-mode 'gnus-summary-mode) | |
| 5775 (progn | |
| 5776 (setq gnus-summary-buffer (current-buffer)) | |
| 5777 (let ((name gnus-newsgroup-name) | |
| 5778 (marked gnus-newsgroup-marked) | |
| 5779 (unread gnus-newsgroup-unreads) | |
| 5780 (headers gnus-current-headers) | |
| 5781 (score-file gnus-current-score-file)) | |
| 5782 (save-excursion | |
| 5783 (set-buffer gnus-group-buffer) | |
| 5784 (setq gnus-newsgroup-name name) | |
| 5785 (setq gnus-newsgroup-marked marked) | |
| 5786 (setq gnus-newsgroup-unreads unread) | |
| 5787 (setq gnus-current-headers headers) | |
| 5788 (setq gnus-current-score-file score-file)))))) | |
| 5789 | |
| 5790 (defun gnus-summary-insert-dummy-line (sformat subject number) | |
| 5791 (if (not sformat) | |
| 5792 (setq sformat gnus-summary-dummy-line-format-spec)) | |
| 5793 (let (b) | |
| 5794 (beginning-of-line) | |
| 5795 (setq b (point)) | |
| 5796 (insert (eval sformat)) | |
| 5797 (add-text-properties | |
| 5798 b (1+ b) | |
| 5799 (list 'gnus-number number | |
| 5800 'gnus-mark gnus-dummy-mark | |
| 5801 'gnus-level 0)))) | |
| 5802 | |
| 5803 (defvar gnus-thread-indent-array nil) | |
| 5804 (defvar gnus-thread-indent-array-level gnus-thread-indent-level) | |
| 5805 (defun gnus-make-thread-indent-array () | |
| 5806 (let ((n 200)) | |
| 5807 (if (and gnus-thread-indent-array | |
| 5808 (= gnus-thread-indent-level gnus-thread-indent-array-level)) | |
| 5809 nil | |
| 5810 (setq gnus-thread-indent-array (make-vector 201 "") | |
| 5811 gnus-thread-indent-array-level gnus-thread-indent-level) | |
| 5812 (while (>= n 0) | |
| 5813 (aset gnus-thread-indent-array n | |
| 5814 (make-string (* n gnus-thread-indent-level) ? )) | |
| 5815 (setq n (1- n)))))) | |
| 5816 | |
| 5817 (defun gnus-summary-insert-line | |
| 5818 (sformat header level current unread replied expirable subject-or-nil | |
| 5819 &optional dummy score process) | |
| 5820 (or sformat (setq sformat gnus-summary-line-format-spec)) | |
| 5821 (let* ((indentation (aref gnus-thread-indent-array level)) | |
| 5822 (lines (mail-header-lines header)) | |
| 5823 (score (or score gnus-summary-default-score 0)) | |
| 5824 (score-char | |
| 5825 (if (or (null gnus-summary-default-score) | |
| 5826 (<= (abs (- score gnus-summary-default-score)) | |
| 5827 gnus-summary-zcore-fuzz)) ? | |
| 5828 (if (< score gnus-summary-default-score) | |
| 5829 gnus-score-below-mark gnus-score-over-mark))) | |
| 5830 (replied (cond (process gnus-process-mark) | |
| 5831 (replied gnus-replied-mark) | |
| 5832 (t gnus-unread-mark))) | |
| 5833 (from (mail-header-from header)) | |
| 5834 (name (cond | |
| 5835 ((string-match "(.+)" from) | |
| 5836 (substring from (1+ (match-beginning 0)) (1- (match-end 0)))) | |
| 5837 ((string-match "<[^>]+> *$" from) | |
| 5838 (let ((beg (match-beginning 0))) | |
| 5839 (or (and (string-match "^\"[^\"]*\"" from) | |
| 5840 (substring from (1+ (match-beginning 0)) | |
| 5841 (1- (match-end 0)))) | |
| 5842 (substring from 0 beg)))) | |
| 5843 (t from))) | |
| 5844 (subject (mail-header-subject header)) | |
| 5845 (number (mail-header-number header)) | |
| 5846 (opening-bracket (if dummy ?\< ?\[)) | |
| 5847 (closing-bracket (if dummy ?\> ?\])) | |
| 5848 (buffer-read-only nil) | |
| 5849 (b (progn (beginning-of-line) (point)))) | |
| 5850 (or (numberp lines) (setq lines 0)) | |
| 5851 (insert (eval sformat)) | |
| 5852 (add-text-properties | |
| 5853 b (1+ b) (list 'gnus-number number | |
| 5854 'gnus-mark (or unread gnus-unread-mark) | |
| 5855 'gnus-level level)))) | |
| 5856 | |
| 5857 (defun gnus-summary-update-line (&optional dont-update) | |
| 5858 ;; Update summary line after change. | |
| 5859 (or (not gnus-summary-default-score) | |
| 5860 gnus-summary-inhibit-highlight | |
| 5861 (let ((gnus-summary-inhibit-highlight t) | |
| 5862 (article (gnus-summary-article-number))) | |
| 5863 (progn | |
| 5864 (or dont-update | |
| 5865 (if (and gnus-summary-mark-below | |
| 5866 (< (gnus-summary-article-score) | |
| 5867 gnus-summary-mark-below)) | |
| 5868 (and (not (memq article gnus-newsgroup-marked)) | |
| 5869 (not (memq article gnus-newsgroup-dormant)) | |
| 5870 (memq article gnus-newsgroup-unreads) | |
| 5871 (gnus-summary-mark-article-as-read gnus-low-score-mark)) | |
| 5872 (and (eq (gnus-summary-article-mark) gnus-low-score-mark) | |
| 5873 (gnus-summary-mark-article-as-unread gnus-unread-mark)))) | |
| 5874 (and gnus-visual | |
| 5875 (run-hooks 'gnus-summary-update-hook)))))) | |
| 5876 | |
| 5877 (defun gnus-summary-update-lines (&optional beg end) | |
| 5878 ;; Mark article as read (or not) by taking into account scores. | |
| 5879 (let ((beg (or beg (point-min))) | |
| 5880 (end (or end (point-max)))) | |
| 5881 (if (or (not gnus-summary-default-score) | |
| 5882 gnus-summary-inhibit-highlight) | |
| 5883 () | |
| 5884 (let ((gnus-summary-inhibit-highlight t) | |
| 5885 article) | |
| 5886 (save-excursion | |
| 5887 (set-buffer gnus-summary-buffer) | |
| 5888 (goto-char beg) | |
| 5889 (beginning-of-line) | |
| 5890 (while (and (not (eobp)) (< (point) end)) | |
| 5891 (if (and gnus-summary-mark-below | |
| 5892 (< (or (cdr (assq | |
| 5893 (setq article (get-text-property | |
| 5894 (point) 'gnus-number)) | |
| 5895 gnus-newsgroup-scored)) | |
| 5896 gnus-summary-default-score 0) | |
| 5897 gnus-summary-mark-below)) | |
| 5898 ;; We want to possibly mark it as read... | |
| 5899 (and (not (memq article gnus-newsgroup-marked)) | |
| 5900 (not (memq article gnus-newsgroup-dormant)) | |
| 5901 (memq article gnus-newsgroup-unreads) | |
| 5902 (gnus-summary-mark-article-as-read gnus-low-score-mark)) | |
| 5903 ;; We want to possibly mark it as unread. | |
| 5904 (and (eq (get-text-property (point) 'gnus-mark) | |
| 5905 gnus-low-score-mark) | |
| 5906 (gnus-summary-mark-article-as-unread gnus-unread-mark))) | |
| 5907 ;; Do the visual highlights at the same time. | |
| 5908 (and gnus-visual (run-hooks 'gnus-summary-update-hook)) | |
| 5909 (forward-line 1))))))) | |
| 5910 | |
| 5911 (defvar gnus-tmp-gathered nil) | |
| 5912 | |
| 5913 (defun gnus-summary-number-of-articles-in-thread (thread &optional char) | |
| 5914 ;; Sum up all elements (and sub-elements) in a list. | |
| 5915 (let* ((number | |
| 5916 ;; Fix by Luc Van Eycken <Luc.VanEycken@esat.kuleuven.ac.be>. | |
| 5917 (if (and (consp thread) (cdr thread)) | |
| 5918 (apply | |
| 5919 '+ 1 (mapcar | |
| 5920 'gnus-summary-number-of-articles-in-thread | |
| 5921 (cdr thread))) | |
| 5922 1))) | |
| 5923 (if char | |
| 5924 (if (> number 1) gnus-not-empty-thread-mark | |
| 5925 gnus-empty-thread-mark) | |
| 5926 number))) | |
| 5927 | |
| 5928 (defun gnus-summary-read-group | |
| 5929 (group &optional show-all no-article kill-buffer) | |
| 5930 "Start reading news in newsgroup GROUP. | |
| 5931 If SHOW-ALL is non-nil, already read articles are also listed. | |
| 5932 If NO-ARTICLE is non-nil, no article is selected initially." | |
| 5933 (gnus-message 5 "Retrieving newsgroup: %s..." group) | |
| 5934 (let* ((new-group (gnus-summary-setup-buffer group)) | |
| 5935 (quit-config (gnus-group-quit-config group)) | |
| 5936 (did-select (and new-group (gnus-select-newsgroup group show-all)))) | |
| 5937 (cond | |
| 5938 ((not new-group) | |
| 5939 (gnus-set-global-variables) | |
| 5940 (gnus-kill-buffer kill-buffer) | |
| 5941 (gnus-configure-windows 'summary 'force) | |
| 5942 (gnus-set-mode-line 'summary) | |
| 5943 (gnus-summary-position-cursor) | |
| 5944 (message "") | |
| 5945 t) | |
| 5946 ((null did-select) | |
| 5947 (and (eq major-mode 'gnus-summary-mode) | |
| 5948 (not (equal (current-buffer) kill-buffer)) | |
| 5949 (progn | |
| 5950 (kill-buffer (current-buffer)) | |
| 5951 (if (not quit-config) | |
| 5952 (progn | |
| 5953 (set-buffer gnus-group-buffer) | |
| 5954 (gnus-group-jump-to-group group) | |
| 5955 (gnus-group-next-unread-group 1)) | |
| 5956 (if (not (buffer-name (car quit-config))) | |
| 5957 (gnus-configure-windows 'group 'force) | |
| 5958 (set-buffer (car quit-config)) | |
| 5959 (and (eq major-mode 'gnus-summary-mode) | |
| 5960 (gnus-set-global-variables)) | |
| 5961 (gnus-configure-windows (cdr quit-config)))))) | |
| 5962 (message "Can't select group") | |
| 5963 nil) | |
| 5964 ((eq did-select 'quit) | |
| 5965 (and (eq major-mode 'gnus-summary-mode) | |
| 5966 (not (equal (current-buffer) kill-buffer)) | |
| 5967 (kill-buffer (current-buffer))) | |
| 5968 (gnus-kill-buffer kill-buffer) | |
| 5969 (if (not quit-config) | |
| 5970 (progn | |
| 5971 (set-buffer gnus-group-buffer) | |
| 5972 (gnus-group-jump-to-group group) | |
| 5973 (gnus-group-next-unread-group 1) | |
| 5974 (gnus-configure-windows 'group 'force)) | |
| 5975 (if (not (buffer-name (car quit-config))) | |
| 5976 (gnus-configure-windows 'group 'force) | |
| 5977 (set-buffer (car quit-config)) | |
| 5978 (and (eq major-mode 'gnus-summary-mode) | |
| 5979 (gnus-set-global-variables)) | |
| 5980 (gnus-configure-windows (cdr quit-config)))) | |
| 5981 (signal 'quit nil)) | |
| 5982 (t | |
| 5983 (gnus-set-global-variables) | |
| 5984 ;; Save the active value in effect when the group was entered. | |
| 5985 (setq gnus-newsgroup-active | |
| 5986 (gnus-copy-sequence | |
| 5987 (gnus-gethash gnus-newsgroup-name gnus-active-hashtb))) | |
| 5988 ;; You can change the subjects in this hook. | |
| 5989 (run-hooks 'gnus-select-group-hook) | |
| 5990 ;; Do score processing. | |
| 5991 (and gnus-use-scoring (gnus-possibly-score-headers)) | |
| 5992 (gnus-update-format-specifications) | |
| 5993 ;; Generate the summary buffer. | |
| 5994 (gnus-summary-prepare) | |
| 5995 (if (zerop (buffer-size)) | |
| 5996 (cond (gnus-newsgroup-dormant | |
| 5997 (gnus-summary-show-all-dormant)) | |
| 5998 ((and gnus-newsgroup-scored show-all) | |
| 5999 (gnus-summary-show-all-expunged)))) | |
| 6000 ;; Function `gnus-apply-kill-file' must be called in this hook. | |
| 6001 (run-hooks 'gnus-apply-kill-hook) | |
| 6002 (if (zerop (buffer-size)) | |
| 6003 (progn | |
| 6004 ;; This newsgroup is empty. | |
| 6005 (gnus-summary-catchup-and-exit nil t) ;Without confirmations. | |
| 6006 (gnus-message 6 "No unread news") | |
| 6007 (gnus-kill-buffer kill-buffer) | |
| 6008 nil) | |
| 6009 ;;(save-excursion | |
| 6010 ;; (if kill-buffer | |
| 6011 ;; (let ((gnus-summary-buffer kill-buffer)) | |
| 6012 ;; (gnus-configure-windows 'group)))) | |
| 6013 ;; Hide conversation thread subtrees. We cannot do this in | |
| 6014 ;; gnus-summary-prepare-hook since kill processing may not | |
| 6015 ;; work with hidden articles. | |
| 6016 (and gnus-show-threads | |
| 6017 gnus-thread-hide-subtree | |
| 6018 (gnus-summary-hide-all-threads)) | |
| 6019 ;; Show first unread article if requested. | |
| 6020 (goto-char (point-min)) | |
| 6021 (if (and (not no-article) | |
| 6022 gnus-auto-select-first | |
| 6023 (gnus-summary-first-unread-article)) | |
| 6024 () | |
| 6025 (gnus-configure-windows 'summary 'force)) | |
| 6026 (gnus-set-mode-line 'summary) | |
| 6027 (gnus-summary-position-cursor) | |
| 6028 ;; If in async mode, we send some info to the backend. | |
| 6029 (and gnus-newsgroup-async | |
| 6030 (setq gnus-newsgroup-threads (nreverse gnus-newsgroup-threads)) | |
| 6031 (gnus-request-asynchronous | |
| 6032 gnus-newsgroup-name | |
| 6033 (if (and gnus-asynchronous-article-function | |
| 6034 (fboundp gnus-asynchronous-article-function)) | |
| 6035 (funcall gnus-asynchronous-article-function | |
| 6036 gnus-newsgroup-threads) | |
| 6037 gnus-newsgroup-threads))) | |
| 6038 (gnus-kill-buffer kill-buffer) | |
| 6039 (if (not (get-buffer-window gnus-group-buffer)) | |
| 6040 () | |
| 6041 ;; gotta use windows, because recenter does wierd stuff if | |
| 6042 ;; the current buffer ain't the displayed window. | |
| 6043 (let ((owin (selected-window))) | |
| 6044 (select-window (get-buffer-window gnus-group-buffer)) | |
| 6045 (and (gnus-group-goto-group group) | |
| 6046 (recenter)) | |
| 6047 (select-window owin)))) | |
| 6048 t)))) | |
| 6049 | |
| 6050 (defun gnus-summary-prepare () | |
| 6051 ;; Generate the summary buffer. | |
| 6052 (let ((buffer-read-only nil)) | |
| 6053 (erase-buffer) | |
| 6054 (gnus-summary-prepare-threads | |
| 6055 (if gnus-show-threads | |
| 6056 (gnus-gather-threads | |
| 6057 (gnus-sort-threads | |
| 6058 (if (and gnus-summary-expunge-below | |
| 6059 (not gnus-fetch-old-headers)) | |
| 6060 (gnus-make-threads-and-expunge) | |
| 6061 (gnus-make-threads)))) | |
| 6062 gnus-newsgroup-headers) | |
| 6063 'cull) | |
| 6064 (gnus-summary-update-lines) | |
| 6065 ;; Create the header hashtb. | |
| 6066 (gnus-make-headers-hashtable-by-number) | |
| 6067 ;; Call hooks for modifying summary buffer. | |
| 6068 ;; Suggested by sven@tde.LTH.Se (Sven Mattisson). | |
| 6069 (goto-char (point-min)) | |
| 6070 (run-hooks 'gnus-summary-prepare-hook))) | |
| 6071 | |
| 6072 (defun gnus-gather-threads (threads) | |
| 6073 "Gather threads that have lost their roots." | |
| 6074 (if (not gnus-summary-make-false-root) | |
| 6075 threads | |
| 6076 (let ((hashtb (gnus-make-hashtable 1023)) | |
| 6077 (prev threads) | |
| 6078 (result threads) | |
| 6079 subject hthread whole-subject) | |
| 6080 (while threads | |
| 6081 (setq whole-subject | |
| 6082 (setq subject (mail-header-subject (car (car threads))))) | |
| 6083 (if gnus-summary-gather-subject-limit | |
| 6084 (or (and (numberp gnus-summary-gather-subject-limit) | |
| 6085 (> (length subject) gnus-summary-gather-subject-limit) | |
| 6086 (setq subject | |
| 6087 (substring subject 0 | |
| 6088 gnus-summary-gather-subject-limit))) | |
| 6089 (and (eq 'fuzzy gnus-summary-gather-subject-limit) | |
| 6090 (setq subject (gnus-simplify-subject-fuzzy subject)))) | |
| 6091 (setq subject (gnus-simplify-subject-re subject))) | |
| 6092 (if (setq hthread | |
| 6093 (gnus-gethash subject hashtb)) | |
| 6094 (progn | |
| 6095 (or (stringp (car (car hthread))) | |
| 6096 (setcar hthread (list whole-subject (car hthread)))) | |
| 6097 (setcdr (car hthread) (nconc (cdr (car hthread)) | |
| 6098 (list (car threads)))) | |
| 6099 (setcdr prev (cdr threads)) | |
| 6100 (setq threads prev)) | |
| 6101 (gnus-sethash subject threads hashtb)) | |
| 6102 (setq prev threads) | |
| 6103 (setq threads (cdr threads))) | |
| 6104 result))) | |
| 6105 | |
| 6106 (defun gnus-make-threads () | |
| 6107 ;; This function takes the dependencies already made by | |
| 6108 ;; `gnus-get-newsgroup-headers' and builds the trees. First we go | |
| 6109 ;; through the dependecies in the hash table and finds all the | |
| 6110 ;; roots. Roots do not refer back to any valid articles. | |
| 6111 (gnus-message 6 "Threading...") | |
| 6112 (let (roots new-roots) | |
| 6113 (and gnus-fetch-old-headers | |
| 6114 (eq gnus-headers-retrieved-by 'nov) | |
| 6115 (gnus-build-old-threads)) | |
| 6116 (mapatoms | |
| 6117 (lambda (refs) | |
| 6118 (if (not (car (symbol-value refs))) | |
| 6119 (setq roots (append (cdr (symbol-value refs)) roots)) | |
| 6120 ;; Ok, these refer back to valid articles, but if | |
| 6121 ;; `gnus-thread-ignore-subject' is nil, we have to check that | |
| 6122 ;; the root has the same subject as its children. The children | |
| 6123 ;; that do not are made into roots and removed from the list | |
| 6124 ;; of children. | |
| 6125 (or gnus-thread-ignore-subject | |
| 6126 (let* ((prev (symbol-value refs)) | |
| 6127 (subject (gnus-simplify-subject-re | |
| 6128 (mail-header-subject (car prev)))) | |
| 6129 (headers (cdr prev))) | |
| 6130 (while headers | |
| 6131 (if (not (string= subject | |
| 6132 (gnus-simplify-subject-re | |
| 6133 (mail-header-subject (car headers))))) | |
| 6134 (progn | |
| 6135 (setq new-roots (cons (car headers) new-roots)) | |
| 6136 (setcdr prev (cdr headers))) | |
| 6137 (setq prev headers)) | |
| 6138 (setq headers (cdr headers))))))) | |
| 6139 gnus-newsgroup-dependencies) | |
| 6140 | |
| 6141 ;; We enter the new roots into the dependencies structure to | |
| 6142 ;; ensure that any possible later thread-regeneration will be | |
| 6143 ;; possible. | |
| 6144 (let ((r new-roots)) | |
| 6145 (while r | |
| 6146 (gnus-sethash (concat (mail-header-id (car r)) ".boo") | |
| 6147 (list nil (car r)) gnus-newsgroup-dependencies) | |
| 6148 (setq r (cdr r)))) | |
| 6149 | |
| 6150 (setq roots (nconc new-roots roots)) | |
| 6151 | |
| 6152 (prog1 | |
| 6153 (mapcar 'gnus-trim-thread | |
| 6154 (apply 'append | |
| 6155 (mapcar 'gnus-cut-thread | |
| 6156 (mapcar 'gnus-make-sub-thread roots)))) | |
| 6157 (gnus-message 6 "Threading...done")))) | |
| 6158 | |
| 6159 | |
| 6160 (defun gnus-make-threads-and-expunge () | |
| 6161 ;; This function takes the dependencies already made by | |
| 6162 ;; `gnus-get-newsgroup-headers' and builds the trees. First we go | |
| 6163 ;; through the dependecies in the hash table and finds all the | |
| 6164 ;; roots. Roots do not refer back to any valid articles. | |
| 6165 (gnus-message 6 "Threading...") | |
| 6166 (let ((default (or gnus-summary-default-score 0)) | |
| 6167 (below gnus-summary-expunge-below) | |
| 6168 roots article new-roots) | |
| 6169 (and gnus-fetch-old-headers | |
| 6170 (eq gnus-headers-retrieved-by 'nov) | |
| 6171 (gnus-build-old-threads)) | |
| 6172 (mapatoms | |
| 6173 (lambda (refs) | |
| 6174 (if (not (car (symbol-value refs))) | |
| 6175 ;; These articles do not refer back to any other articles - | |
| 6176 ;; they are roots. | |
| 6177 (let ((headers (cdr (symbol-value refs)))) | |
| 6178 ;; We weed out the low-scored articles. | |
| 6179 (while headers | |
| 6180 (if (not (< (or (cdr (assq (mail-header-number (car headers)) | |
| 6181 gnus-newsgroup-scored)) default) | |
| 6182 below)) | |
| 6183 ;; It is over. | |
| 6184 (setq roots (cons (car headers) roots)) | |
| 6185 ;; It is below, so we mark it as read. | |
| 6186 (setq gnus-newsgroup-unreads | |
| 6187 (delq (mail-header-number (car headers)) | |
| 6188 gnus-newsgroup-unreads)) | |
| 6189 (setq gnus-newsgroup-reads | |
| 6190 (cons (cons (mail-header-number (car headers)) | |
| 6191 gnus-low-score-mark) | |
| 6192 gnus-newsgroup-reads))) | |
| 6193 (setq headers (cdr headers)))) | |
| 6194 ;; Ok, these refer back to valid articles, but if | |
| 6195 ;; `gnus-thread-ignore-subject' is nil, we have to check that | |
| 6196 ;; the root has the same subject as its children. The children | |
| 6197 ;; that do not are made into roots and removed from the list | |
| 6198 ;; of children. | |
| 6199 (or gnus-thread-ignore-subject | |
| 6200 (let* ((prev (symbol-value refs)) | |
| 6201 (subject (gnus-simplify-subject-re | |
| 6202 (mail-header-subject (car prev)))) | |
| 6203 (headers (cdr prev))) | |
| 6204 (while headers | |
| 6205 (if (not (string= subject | |
| 6206 (gnus-simplify-subject-re | |
| 6207 (mail-header-subject (car headers))))) | |
| 6208 (progn | |
| 6209 (if (not (< (or (cdr (assq (mail-header-number | |
| 6210 (car headers)) | |
| 6211 gnus-newsgroup-scored)) | |
| 6212 default) below)) | |
| 6213 (setq new-roots (cons (car headers) new-roots)) | |
| 6214 (setq gnus-newsgroup-unreads | |
| 6215 (delq (mail-header-number (car headers)) | |
| 6216 gnus-newsgroup-unreads)) | |
| 6217 (setq gnus-newsgroup-reads | |
| 6218 (cons (cons (mail-header-number (car headers)) | |
| 6219 gnus-low-score-mark) | |
| 6220 gnus-newsgroup-reads))) | |
| 6221 (setcdr prev (cdr headers))) | |
| 6222 (setq prev headers)) | |
| 6223 (setq headers (cdr headers))))) | |
| 6224 ;; If this article is expunged, some of the children might be | |
| 6225 ;; roots. | |
| 6226 (if (< (or (cdr (assq (mail-header-number (car (symbol-value refs))) | |
| 6227 gnus-newsgroup-scored)) default) | |
| 6228 below) | |
| 6229 (let* ((prev (symbol-value refs)) | |
| 6230 (headers (cdr prev))) | |
| 6231 (while headers | |
| 6232 (setq article (mail-header-number (car headers))) | |
| 6233 (if (not (< (or (cdr (assq article gnus-newsgroup-scored)) | |
| 6234 default) below)) | |
| 6235 (progn (setq new-roots (cons (car headers) new-roots)) | |
| 6236 (setq prev headers)) | |
| 6237 (setq gnus-newsgroup-unreads | |
| 6238 (delq article gnus-newsgroup-unreads)) | |
| 6239 (setq gnus-newsgroup-reads | |
| 6240 (cons (cons article gnus-low-score-mark) | |
| 6241 gnus-newsgroup-reads)) | |
| 6242 (setcdr prev (cdr headers))) | |
| 6243 (setq headers (cdr headers)))) | |
| 6244 ;; It was not expunged, but we look at expunged children. | |
| 6245 (let* ((prev (symbol-value refs)) | |
| 6246 (headers (cdr prev)) | |
| 6247 article) | |
| 6248 (while headers | |
| 6249 (setq article (mail-header-number (car headers))) | |
| 6250 (if (not (< (or (cdr (assq article gnus-newsgroup-scored)) | |
| 6251 default) below)) | |
| 6252 (setq prev headers) | |
| 6253 (setq gnus-newsgroup-unreads | |
| 6254 (delq article gnus-newsgroup-unreads)) | |
| 6255 (setq gnus-newsgroup-reads | |
| 6256 (cons (cons article gnus-low-score-mark) | |
| 6257 gnus-newsgroup-reads)) | |
| 6258 (setcdr prev (cdr headers))) | |
| 6259 (setq headers (cdr headers))))))) | |
| 6260 gnus-newsgroup-dependencies) | |
| 6261 | |
| 6262 ;; We enter the new roots into the dependencies structure to | |
| 6263 ;; ensure that any possible later thread-regeneration will be | |
| 6264 ;; possible. | |
| 6265 (let ((r new-roots)) | |
| 6266 (while r | |
| 6267 (gnus-sethash (concat (mail-header-id (car r)) ".boo") | |
| 6268 (list nil (car r)) gnus-newsgroup-dependencies) | |
| 6269 (setq r (cdr r)))) | |
| 6270 | |
| 6271 (setq roots (nconc new-roots roots)) | |
| 6272 | |
| 6273 (prog1 | |
| 6274 (mapcar 'gnus-trim-thread | |
| 6275 (apply 'append | |
| 6276 (mapcar 'gnus-cut-thread | |
| 6277 (mapcar 'gnus-make-sub-thread roots)))) | |
| 6278 (gnus-message 6 "Threading...done")))) | |
| 6279 | |
| 6280 | |
| 6281 (defun gnus-cut-thread (thread) | |
| 6282 ;; Remove leaf dormant or ancient articles from THREAD. | |
| 6283 (let ((head (car thread)) | |
| 6284 (tail (apply 'append (mapcar 'gnus-cut-thread (cdr thread))))) | |
| 6285 (if (and (null tail) | |
| 6286 (let ((number (mail-header-number head))) | |
| 6287 (or (memq number gnus-newsgroup-ancient) | |
| 6288 (memq number gnus-newsgroup-dormant) | |
| 6289 (and gnus-summary-expunge-below | |
| 6290 (eq gnus-fetch-old-headers 'some) | |
| 6291 (< (or (cdr (assq number gnus-newsgroup-scored)) | |
| 6292 gnus-summary-default-score 0) | |
| 6293 gnus-summary-expunge-below) | |
| 6294 (progn | |
| 6295 (setq gnus-newsgroup-unreads | |
| 6296 (delq number gnus-newsgroup-unreads)) | |
| 6297 (setq gnus-newsgroup-reads | |
| 6298 (cons (cons number gnus-low-score-mark) | |
| 6299 gnus-newsgroup-reads)) | |
| 6300 t))))) | |
| 6301 nil | |
| 6302 (list (cons head tail))))) | |
| 6303 | |
| 6304 (defun gnus-trim-thread (thread) | |
| 6305 ;; Remove root ancient articles with only one child from THREAD. | |
| 6306 (if (and (eq gnus-fetch-old-headers 'some) | |
| 6307 (memq (mail-header-number (car thread)) gnus-newsgroup-ancient) | |
| 6308 (= (length thread) 2)) | |
| 6309 (gnus-trim-thread (nth 1 thread)) | |
| 6310 thread)) | |
| 6311 | |
| 6312 (defun gnus-make-sub-thread (root) | |
| 6313 ;; This function makes a sub-tree for a node in the tree. | |
| 6314 (let ((children (reverse (cdr (gnus-gethash (downcase (mail-header-id root)) | |
| 6315 gnus-newsgroup-dependencies))))) | |
| 6316 (cons root (mapcar 'gnus-make-sub-thread children)))) | |
| 6317 | |
| 6318 (defun gnus-build-old-threads () | |
| 6319 ;; Look at all the articles that refer back to old articles, and | |
| 6320 ;; fetch the headers for the articles that aren't there. This will | |
| 6321 ;; build complete threads - if the roots haven't been expired by the | |
| 6322 ;; server, that is. | |
| 6323 (let (id heads) | |
| 6324 (mapatoms | |
| 6325 (lambda (refs) | |
| 6326 (if (not (car (symbol-value refs))) | |
| 6327 (progn | |
| 6328 (setq heads (cdr (symbol-value refs))) | |
| 6329 (while heads | |
| 6330 (if (not (memq (mail-header-number (car heads)) | |
| 6331 gnus-newsgroup-dormant)) | |
| 6332 (progn | |
| 6333 (setq id (symbol-name refs)) | |
| 6334 (while (and (setq id (gnus-build-get-header id)) | |
| 6335 (not (car (gnus-gethash | |
| 6336 id gnus-newsgroup-dependencies))))) | |
| 6337 (setq heads nil)) | |
| 6338 (setq heads (cdr heads))))))) | |
| 6339 gnus-newsgroup-dependencies))) | |
| 6340 | |
| 6341 (defun gnus-build-get-header (id) | |
| 6342 ;; Look through the buffer of NOV lines and find the header to | |
| 6343 ;; ID. Enter this line into the dependencies hash table, and return | |
| 6344 ;; the id of the parent article (if any). | |
| 6345 (let ((deps gnus-newsgroup-dependencies) | |
| 6346 found header) | |
| 6347 (prog1 | |
| 6348 (save-excursion | |
| 6349 (set-buffer nntp-server-buffer) | |
| 6350 (goto-char (point-min)) | |
| 6351 (while (and (not found) (search-forward id nil t)) | |
| 6352 (beginning-of-line) | |
| 6353 (setq found (looking-at | |
| 6354 (format "^[^\t]*\t[^\t]*\t[^\t]*\t[^\t]*\t%s" | |
| 6355 (regexp-quote id)))) | |
| 6356 (or found (beginning-of-line 2))) | |
| 6357 (if found | |
| 6358 (let (ref) | |
| 6359 (beginning-of-line) | |
| 6360 (and | |
| 6361 (setq header (gnus-nov-parse-line | |
| 6362 (read (current-buffer)) deps)) | |
| 6363 (setq ref (mail-header-references header)) | |
| 6364 (string-match "\\(<[^>]+>\\) *$" ref) | |
| 6365 (substring ref (match-beginning 1) (match-end 1)))))) | |
| 6366 (and header | |
| 6367 (setq gnus-newsgroup-headers (cons header gnus-newsgroup-headers) | |
| 6368 gnus-newsgroup-ancient (cons (mail-header-number header) | |
| 6369 gnus-newsgroup-ancient)))))) | |
| 6370 | |
| 6371 ;; Re-build the thread containing ID. | |
| 6372 (defun gnus-rebuild-thread (id) | |
| 6373 (let ((dep gnus-newsgroup-dependencies) | |
| 6374 (buffer-read-only nil) | |
| 6375 parent headers refs thread art) | |
| 6376 (while (and id (setq headers | |
| 6377 (car (setq art (gnus-gethash (downcase id) dep))))) | |
| 6378 (setq parent art) | |
| 6379 (setq id (and (setq refs (mail-header-references headers)) | |
| 6380 (string-match "\\(<[^>]+>\\) *$" refs) | |
| 6381 (substring refs (match-beginning 1) (match-end 1))))) | |
| 6382 (setq thread (gnus-make-sub-thread (car parent))) | |
| 6383 (gnus-rebuild-remove-articles thread) | |
| 6384 (let ((beg (point))) | |
| 6385 (gnus-summary-prepare-threads (list thread)) | |
| 6386 (gnus-summary-update-lines beg (point))))) | |
| 6387 | |
| 6388 ;; Delete all lines in the summary buffer that correspond to articles | |
| 6389 ;; in this thread. | |
| 6390 (defun gnus-rebuild-remove-articles (thread) | |
| 6391 (and (gnus-summary-goto-subject (mail-header-number (car thread))) | |
| 6392 (gnus-delete-line)) | |
| 6393 (mapcar (lambda (th) (gnus-rebuild-remove-articles th)) (cdr thread))) | |
| 6394 | |
| 6395 (defun gnus-sort-threads (threads) | |
| 6396 ;; Sort threads as specified in `gnus-thread-sort-functions'. | |
| 6397 (let ((fun gnus-thread-sort-functions)) | |
| 6398 (while fun | |
| 6399 (gnus-message 6 "Sorting with %S..." fun) | |
| 6400 (setq threads (sort threads (car fun)) | |
| 6401 fun (cdr fun)))) | |
| 6402 (if gnus-thread-sort-functions | |
| 6403 (gnus-message 6 "Sorting...done")) | |
| 6404 threads) | |
| 6405 | |
| 6406 ;; Written by Hallvard B Furuseth <h.b.furuseth@usit.uio.no>. | |
| 6407 (defmacro gnus-thread-header (thread) | |
| 6408 ;; Return header of first article in THREAD. | |
| 6409 ;; Note that THREAD must never, evr be anything else than a variable - | |
| 6410 ;; using some other form will lead to serious barfage. | |
| 6411 (or (symbolp thread) (signal 'wrong-type-argument '(symbolp thread))) | |
| 6412 ;; (8% speedup to gnus-summary-prepare, just for fun :-) | |
| 6413 (list 'byte-code "\10\211:\203\17\0\211@;\203\16\0A@@\207" ; | |
| 6414 (vector thread) 2)) | |
| 6415 | |
| 6416 (defun gnus-thread-sort-by-number (h1 h2) | |
| 6417 "Sort threads by root article number." | |
| 6418 (< (mail-header-number (gnus-thread-header h1)) | |
| 6419 (mail-header-number (gnus-thread-header h2)))) | |
| 6420 | |
| 6421 (defun gnus-thread-sort-by-author (h1 h2) | |
| 6422 "Sort threads by root author." | |
| 6423 (string-lessp | |
| 6424 (let ((extract (funcall | |
| 6425 gnus-extract-address-components | |
| 6426 (mail-header-from (gnus-thread-header h1))))) | |
| 6427 (or (car extract) (cdr extract))) | |
| 6428 (let ((extract (funcall | |
| 6429 gnus-extract-address-components | |
| 6430 (mail-header-from (gnus-thread-header h2))))) | |
| 6431 (or (car extract) (cdr extract))))) | |
| 6432 | |
| 6433 (defun gnus-thread-sort-by-subject (h1 h2) | |
| 6434 "Sort threads by root subject." | |
| 6435 (string-lessp | |
| 6436 (downcase (gnus-simplify-subject-re | |
| 6437 (mail-header-subject (gnus-thread-header h1)))) | |
| 6438 (downcase (gnus-simplify-subject-re | |
| 6439 (mail-header-subject (gnus-thread-header h2)))))) | |
| 6440 | |
| 6441 (defun gnus-thread-sort-by-date (h1 h2) | |
| 6442 "Sort threads by root article date." | |
| 6443 (string-lessp | |
| 6444 (gnus-sortable-date (mail-header-date (gnus-thread-header h1))) | |
| 6445 (gnus-sortable-date (mail-header-date (gnus-thread-header h2))))) | |
| 6446 | |
| 6447 (defun gnus-thread-sort-by-score (h1 h2) | |
| 6448 "Sort threads by root article score. | |
| 6449 Unscored articles will be counted as having a score of zero." | |
| 6450 (> (or (cdr (assq (mail-header-number (gnus-thread-header h1)) | |
| 6451 gnus-newsgroup-scored)) | |
| 6452 gnus-summary-default-score 0) | |
| 6453 (or (cdr (assq (mail-header-number (gnus-thread-header h2)) | |
| 6454 gnus-newsgroup-scored)) | |
| 6455 gnus-summary-default-score 0))) | |
| 6456 | |
| 6457 (defun gnus-thread-sort-by-total-score (h1 h2) | |
| 6458 "Sort threads by the sum of all scores in the thread. | |
| 6459 Unscored articles will be counted as having a score of zero." | |
| 6460 (> (gnus-thread-total-score h1) (gnus-thread-total-score h2))) | |
| 6461 | |
| 6462 (defun gnus-thread-total-score (thread) | |
| 6463 ;; This function find the total score of THREAD. | |
| 6464 (if (consp thread) | |
| 6465 (if (stringp (car thread)) | |
| 6466 (apply gnus-thread-score-function 0 | |
| 6467 (mapcar 'gnus-thread-total-score-1 (cdr thread))) | |
| 6468 (gnus-thread-total-score-1 thread)) | |
| 6469 (gnus-thread-total-score-1 (list thread)))) | |
| 6470 | |
| 6471 (defun gnus-thread-total-score-1 (root) | |
| 6472 ;; This function find the total score of the thread below ROOT. | |
| 6473 (setq root (car root)) | |
| 6474 (apply gnus-thread-score-function | |
| 6475 (or (cdr (assq (mail-header-number root) gnus-newsgroup-scored)) | |
| 6476 gnus-summary-default-score 0) | |
| 6477 (mapcar 'gnus-thread-total-score | |
| 6478 (cdr (gnus-gethash (downcase (mail-header-id root)) | |
| 6479 gnus-newsgroup-dependencies))))) | |
| 6480 | |
| 6481 ;; Added by Per Abrahamsen <amanda@iesd.auc.dk>. | |
| 6482 (defvar gnus-tmp-prev-subject "") | |
| 6483 | |
| 6484 (defun gnus-summary-prepare-threads (threads &optional cull) | |
| 6485 "Prepare summary buffer from THREADS and indentation LEVEL. | |
| 6486 THREADS is either a list of `(PARENT [(CHILD1 [(GRANDCHILD ...]...) ...])' | |
| 6487 or a straight list of headers." | |
| 6488 (message "Generating summary...") | |
| 6489 (let ((level 0) | |
| 6490 thread header number subject stack state gnus-tmp-gathered) | |
| 6491 (if (vectorp (car threads)) | |
| 6492 ;; If this is a straight (sic) list of headers, then a | |
| 6493 ;; threaded summary display isn't required, so we just create | |
| 6494 ;; an unthreaded one. | |
| 6495 (gnus-summary-prepare-unthreaded threads cull) | |
| 6496 | |
| 6497 ;; Do the threaded display. | |
| 6498 | |
| 6499 (while (or threads stack) | |
| 6500 | |
| 6501 (if threads | |
| 6502 ;; If there are some threads, we do them before the | |
| 6503 ;; threads on the stack. | |
| 6504 (setq thread threads | |
| 6505 header (car (car thread))) | |
| 6506 ;; There were no current threads, so we pop something off | |
| 6507 ;; the stack. | |
| 6508 (setq state (car stack) | |
| 6509 level (car state) | |
| 6510 thread (cdr state) | |
| 6511 stack (cdr stack) | |
| 6512 header (car (car thread)))) | |
| 6513 | |
| 6514 (if (stringp header) | |
| 6515 (progn | |
| 6516 ;; The header is a dummy root. | |
| 6517 (cond | |
| 6518 ((eq gnus-summary-make-false-root 'adopt) | |
| 6519 ;; We let the first article adopt the rest. | |
| 6520 (let ((th (car (cdr (car thread))))) | |
| 6521 (while (cdr th) | |
| 6522 (setq th (cdr th))) | |
| 6523 (setcdr th (cdr (cdr (car thread)))) | |
| 6524 (setq gnus-tmp-gathered | |
| 6525 (nconc (mapcar | |
| 6526 (lambda (h) (mail-header-number (car h))) | |
| 6527 (cdr (cdr (car thread)))) | |
| 6528 gnus-tmp-gathered)) | |
| 6529 (setcdr (cdr (car thread)) nil)) | |
| 6530 (setq level -1)) | |
| 6531 ((eq gnus-summary-make-false-root 'empty) | |
| 6532 ;; We print adopted articles with empty subject fields. | |
| 6533 (setq gnus-tmp-gathered | |
| 6534 (nconc (mapcar | |
| 6535 (lambda (h) (mail-header-number (car h))) | |
| 6536 (cdr (cdr (car thread)))) | |
| 6537 gnus-tmp-gathered)) | |
| 6538 (setq level -1)) | |
| 6539 ((eq gnus-summary-make-false-root 'dummy) | |
| 6540 ;; We output a dummy root. | |
| 6541 (gnus-summary-insert-dummy-line | |
| 6542 nil header (mail-header-number | |
| 6543 (car (car (cdr (car thread))))))) | |
| 6544 (t | |
| 6545 ;; We do not make a root for the gathered | |
| 6546 ;; sub-threads at all. | |
| 6547 (setq level -1)))) | |
| 6548 | |
| 6549 (setq number (mail-header-number header) | |
| 6550 subject (mail-header-subject header)) | |
| 6551 | |
| 6552 ;; Do the async thing. | |
| 6553 (and gnus-newsgroup-async | |
| 6554 (setq gnus-newsgroup-threads | |
| 6555 (cons (cons number (mail-header-lines header)) | |
| 6556 gnus-newsgroup-threads))) | |
| 6557 | |
| 6558 ;; We may have to root out some bad articles... | |
| 6559 (and cull | |
| 6560 (= level 0) | |
| 6561 (cond ((and (memq (setq number (mail-header-number header)) | |
| 6562 gnus-newsgroup-dormant) | |
| 6563 (null thread)) | |
| 6564 (setq header nil)) | |
| 6565 ((and gnus-summary-expunge-below | |
| 6566 (< (or (cdr (assq number gnus-newsgroup-scored)) | |
| 6567 gnus-summary-default-score 0) | |
| 6568 gnus-summary-expunge-below)) | |
| 6569 (setq header nil) | |
| 6570 (setq gnus-newsgroup-unreads | |
| 6571 (delq number gnus-newsgroup-unreads)) | |
| 6572 (setq gnus-newsgroup-reads | |
| 6573 (cons (cons number gnus-low-score-mark) | |
| 6574 gnus-newsgroup-reads))))) | |
| 6575 | |
| 6576 (and | |
| 6577 header | |
| 6578 (progn | |
| 6579 (inline | |
| 6580 (gnus-summary-insert-line | |
| 6581 nil header level nil | |
| 6582 (cond | |
| 6583 ((memq number gnus-newsgroup-marked) gnus-ticked-mark) | |
| 6584 ((memq number gnus-newsgroup-dormant) gnus-dormant-mark) | |
| 6585 ((memq number gnus-newsgroup-unreads) gnus-unread-mark) | |
| 6586 ((memq number gnus-newsgroup-expirable) gnus-expirable-mark) | |
| 6587 (t (or (cdr (assq number gnus-newsgroup-reads)) | |
| 6588 gnus-ancient-mark))) | |
| 6589 (memq number gnus-newsgroup-replied) | |
| 6590 (memq number gnus-newsgroup-expirable) | |
| 6591 (cond | |
| 6592 ((and gnus-thread-ignore-subject | |
| 6593 (not (string= | |
| 6594 (gnus-simplify-subject-re gnus-tmp-prev-subject) | |
| 6595 (gnus-simplify-subject-re subject)))) | |
| 6596 subject) | |
| 6597 ((zerop level) | |
| 6598 (if (and (eq gnus-summary-make-false-root 'empty) | |
| 6599 (memq number gnus-tmp-gathered)) | |
| 6600 gnus-summary-same-subject | |
| 6601 subject)) | |
| 6602 (t gnus-summary-same-subject)) | |
| 6603 (and (eq gnus-summary-make-false-root 'adopt) | |
| 6604 (memq number gnus-tmp-gathered)) | |
| 6605 (cdr (assq number gnus-newsgroup-scored)) | |
| 6606 (memq number gnus-newsgroup-processable)) | |
| 6607 | |
| 6608 (setq gnus-tmp-prev-subject subject))))) | |
| 6609 | |
| 6610 (if (nth 1 thread) | |
| 6611 (setq stack (cons (cons (max 0 level) (nthcdr 1 thread)) stack))) | |
| 6612 (setq level (1+ level)) | |
| 6613 (setq threads (cdr (car thread)))))) | |
| 6614 (message "Generating summary...done")) | |
| 6615 | |
| 6616 | |
| 6617 | |
| 6618 (defun gnus-summary-prepare-unthreaded (headers &optional cull) | |
| 6619 (let (header number) | |
| 6620 | |
| 6621 ;; Do the async thing, if that is required. | |
| 6622 (if gnus-newsgroup-async | |
| 6623 (setq gnus-newsgroup-threads | |
| 6624 (mapcar (lambda (h) | |
| 6625 (cons (mail-header-number h) (mail-header-lines h))) | |
| 6626 headers))) | |
| 6627 | |
| 6628 (while headers | |
| 6629 (setq header (car headers) | |
| 6630 headers (cdr headers) | |
| 6631 number (mail-header-number header)) | |
| 6632 | |
| 6633 ;; We may have to root out some bad articles... | |
| 6634 (cond | |
| 6635 ((and cull | |
| 6636 (memq (setq number (mail-header-number header)) | |
| 6637 gnus-newsgroup-dormant))) | |
| 6638 ((and cull gnus-summary-expunge-below | |
| 6639 (< (or (cdr (assq number gnus-newsgroup-scored)) | |
| 6640 gnus-summary-default-score 0) | |
| 6641 gnus-summary-expunge-below)) | |
| 6642 (setq gnus-newsgroup-unreads | |
| 6643 (delq number gnus-newsgroup-unreads)) | |
| 6644 (setq gnus-newsgroup-reads | |
| 6645 (cons (cons number gnus-low-score-mark) | |
| 6646 gnus-newsgroup-reads))) | |
| 6647 (t | |
| 6648 (gnus-summary-insert-line | |
| 6649 nil header 0 nil | |
| 6650 (cond ((memq number gnus-newsgroup-marked) gnus-ticked-mark) | |
| 6651 ((memq number gnus-newsgroup-dormant) gnus-dormant-mark) | |
| 6652 ((memq number gnus-newsgroup-unreads) gnus-unread-mark) | |
| 6653 ((memq number gnus-newsgroup-expirable) gnus-expirable-mark) | |
| 6654 (t (or (cdr (assq number gnus-newsgroup-reads)) | |
| 6655 gnus-ancient-mark))) | |
| 6656 (memq number gnus-newsgroup-replied) | |
| 6657 (memq number gnus-newsgroup-expirable) | |
| 6658 (mail-header-subject header) nil | |
| 6659 (cdr (assq number gnus-newsgroup-scored)) | |
| 6660 (memq number gnus-newsgroup-processable))))))) | |
| 6661 | |
| 6662 (defun gnus-select-newsgroup (group &optional read-all) | |
| 6663 "Select newsgroup GROUP. | |
| 6664 If READ-ALL is non-nil, all articles in the group are selected." | |
| 6665 (let* ((entry (gnus-gethash group gnus-newsrc-hashtb)) | |
| 6666 (info (nth 2 entry)) | |
| 6667 articles) | |
| 6668 | |
| 6669 (or (gnus-check-server | |
| 6670 (setq gnus-current-select-method (gnus-find-method-for-group group))) | |
| 6671 (error "Couldn't open server")) | |
| 6672 | |
| 6673 (or (and entry (not (eq (car entry) t))) ; Either it's active... | |
| 6674 (gnus-activate-group group) ; Or we can activate it... | |
| 6675 (progn ; Or we bug out. | |
| 6676 (kill-buffer (current-buffer)) | |
| 6677 (error "Couldn't request group %s: %s" | |
| 6678 group (gnus-status-message group)))) | |
| 6679 | |
| 6680 (setq gnus-newsgroup-name group) | |
| 6681 (setq gnus-newsgroup-unselected nil) | |
| 6682 (setq gnus-newsgroup-unreads (gnus-list-of-unread-articles group)) | |
| 6683 | |
| 6684 (and gnus-asynchronous | |
| 6685 (gnus-check-backend-function | |
| 6686 'request-asynchronous gnus-newsgroup-name) | |
| 6687 (setq gnus-newsgroup-async | |
| 6688 (gnus-request-asynchronous gnus-newsgroup-name))) | |
| 6689 | |
| 6690 (setq articles (gnus-articles-to-read group read-all)) | |
| 6691 | |
| 6692 (cond | |
| 6693 ((null articles) | |
| 6694 (gnus-message 3 "Couldn't select newsgroup") | |
| 6695 'quit) | |
| 6696 ((eq articles 0) nil) | |
| 6697 (t | |
| 6698 ;; Init the dependencies hash table. | |
| 6699 (setq gnus-newsgroup-dependencies | |
| 6700 (gnus-make-hashtable (length articles))) | |
| 6701 ;; Retrieve the headers and read them in. | |
| 6702 (gnus-message 5 "Fetching headers...") | |
| 6703 (setq gnus-newsgroup-headers | |
| 6704 (if (eq 'nov (setq gnus-headers-retrieved-by | |
| 6705 ;; This is a naughty hack. To get the | |
| 6706 ;; retrieval of old headers to work, we | |
| 6707 ;; set `nntp-nov-gap' to nil (locally), | |
| 6708 ;; and then just retrieve the headers. | |
| 6709 ;; Mucho magic. | |
| 6710 (if gnus-fetch-old-headers | |
| 6711 (let (nntp-nov-gap) | |
| 6712 (gnus-retrieve-headers | |
| 6713 (if (not (eq 1 (car articles))) | |
| 6714 (cons 1 articles) | |
| 6715 articles) | |
| 6716 gnus-newsgroup-name)) | |
| 6717 (gnus-retrieve-headers | |
| 6718 articles gnus-newsgroup-name)))) | |
| 6719 (progn | |
| 6720 (gnus-get-newsgroup-headers-xover articles)) | |
| 6721 ;; If we were to fetch old headers, but the backend didn't | |
| 6722 ;; support XOVER, then it is possible we fetched one article | |
| 6723 ;; that we shouldn't have. If that's the case, we remove it. | |
| 6724 (if (or (not gnus-fetch-old-headers) | |
| 6725 (eq 1 (car articles))) | |
| 6726 () | |
| 6727 (save-excursion | |
| 6728 (set-buffer nntp-server-buffer) | |
| 6729 (goto-char (point-min)) | |
| 6730 (and | |
| 6731 (looking-at "[0-9]+[ \t]+1[ \t]") ; This is not a NOV line. | |
| 6732 (delete-region ; So we delete this head. | |
| 6733 (point) | |
| 6734 (search-forward "\n.\n" nil t))))) | |
| 6735 (gnus-get-newsgroup-headers))) | |
| 6736 (gnus-message 5 "Fetching headers...done") | |
| 6737 ;; Remove canceled articles from the list of unread articles. | |
| 6738 (setq gnus-newsgroup-unreads | |
| 6739 (gnus-set-sorted-intersection | |
| 6740 gnus-newsgroup-unreads | |
| 6741 (mapcar (lambda (headers) (mail-header-number headers)) | |
| 6742 gnus-newsgroup-headers))) | |
| 6743 ;; Adjust and set lists of article marks. | |
| 6744 (and info | |
| 6745 (let (marked) | |
| 6746 (gnus-adjust-marked-articles info) | |
| 6747 (setq gnus-newsgroup-marked | |
| 6748 (copy-sequence | |
| 6749 (cdr (assq 'tick (setq marked (nth 3 info)))))) | |
| 6750 (setq gnus-newsgroup-replied | |
| 6751 (copy-sequence (cdr (assq 'reply marked)))) | |
| 6752 (setq gnus-newsgroup-expirable | |
| 6753 (copy-sequence (cdr (assq 'expire marked)))) | |
| 6754 (setq gnus-newsgroup-killed | |
| 6755 (copy-sequence (cdr (assq 'killed marked)))) | |
| 6756 (setq gnus-newsgroup-bookmarks | |
| 6757 (copy-sequence (cdr (assq 'bookmark marked)))) | |
| 6758 (setq gnus-newsgroup-dormant | |
| 6759 (copy-sequence (cdr (assq 'dormant marked)))) | |
| 6760 (setq gnus-newsgroup-scored | |
| 6761 (copy-sequence (cdr (assq 'score marked)))) | |
| 6762 (setq gnus-newsgroup-processable nil))) | |
| 6763 ;; Check whether auto-expire is to be done in this group. | |
| 6764 (setq gnus-newsgroup-auto-expire | |
| 6765 (or (and (stringp gnus-auto-expirable-newsgroups) | |
| 6766 (string-match gnus-auto-expirable-newsgroups group)) | |
| 6767 (memq 'auto-expire (nth 5 info)))) | |
| 6768 ;; First and last article in this newsgroup. | |
| 6769 (and gnus-newsgroup-headers | |
| 6770 (setq gnus-newsgroup-begin | |
| 6771 (mail-header-number (car gnus-newsgroup-headers))) | |
| 6772 (setq gnus-newsgroup-end | |
| 6773 (mail-header-number | |
| 6774 (gnus-last-element gnus-newsgroup-headers)))) | |
| 6775 (setq gnus-reffed-article-number -1) | |
| 6776 ;; GROUP is successfully selected. | |
| 6777 (or gnus-newsgroup-headers t))))) | |
| 6778 | |
| 6779 (defun gnus-articles-to-read (group read-all) | |
| 6780 ;; Find out what articles the user wants to read. | |
| 6781 (let* ((articles | |
| 6782 ;; Select all articles if `read-all' is non-nil, or if all the | |
| 6783 ;; unread articles are dormant articles. | |
| 6784 (if (or read-all | |
| 6785 (= (length gnus-newsgroup-unreads) | |
| 6786 (length gnus-newsgroup-dormant))) | |
| 6787 (gnus-uncompress-range | |
| 6788 (gnus-gethash group gnus-active-hashtb)) | |
| 6789 gnus-newsgroup-unreads)) | |
| 6790 (scored-list (gnus-killed-articles gnus-newsgroup-killed articles)) | |
| 6791 (scored (length scored-list)) | |
| 6792 (number (length articles)) | |
| 6793 (marked (+ (length gnus-newsgroup-marked) | |
| 6794 (length gnus-newsgroup-dormant))) | |
| 6795 (select | |
| 6796 (cond | |
| 6797 ((numberp read-all) | |
| 6798 read-all) | |
| 6799 (t | |
| 6800 (condition-case () | |
| 6801 (cond ((and (or (<= scored marked) | |
| 6802 (= scored number)) | |
| 6803 (numberp gnus-large-newsgroup) | |
| 6804 (> number gnus-large-newsgroup)) | |
| 6805 (let ((input | |
| 6806 (read-string | |
| 6807 (format | |
| 6808 "How many articles from %s (default %d): " | |
| 6809 gnus-newsgroup-name number)))) | |
| 6810 (if (string-match "^[ \t]*$" input) | |
| 6811 number input))) | |
| 6812 ((and (> scored marked) (< scored number)) | |
| 6813 (let ((input | |
| 6814 (read-string | |
| 6815 (format | |
| 6816 "%s %s (%d scored, %d total): " | |
| 6817 "How many articles from" | |
| 6818 group scored number)))) | |
| 6819 (if (string-match "^[ \t]*$" input) | |
| 6820 number input))) | |
| 6821 (t number)) | |
| 6822 (quit nil)))))) | |
| 6823 (setq select (if (stringp select) (string-to-number select) select)) | |
| 6824 (if (or (null select) (zerop select)) | |
| 6825 select | |
| 6826 (if (and (not (zerop scored)) (<= (abs select) scored)) | |
| 6827 (progn | |
| 6828 (setq articles (sort scored-list '<)) | |
| 6829 (setq number (length articles))) | |
| 6830 (setq articles (copy-sequence articles))) | |
| 6831 | |
| 6832 (if (< (abs select) number) | |
| 6833 (if (< select 0) | |
| 6834 ;; Select the N oldest articles. | |
| 6835 (setcdr (nthcdr (1- (abs select)) articles) nil) | |
| 6836 ;; Select the N most recent articles. | |
| 6837 (setq articles (nthcdr (- number select) articles)))) | |
| 6838 (setq gnus-newsgroup-unselected | |
| 6839 (gnus-sorted-intersection | |
| 6840 gnus-newsgroup-unreads | |
| 6841 (gnus-sorted-complement gnus-newsgroup-unreads articles))) | |
| 6842 articles))) | |
| 6843 | |
| 6844 (defun gnus-killed-articles (killed articles) | |
| 6845 (let (out) | |
| 6846 (while articles | |
| 6847 (if (inline (gnus-member-of-range (car articles) killed)) | |
| 6848 (setq out (cons (car articles) out))) | |
| 6849 (setq articles (cdr articles))) | |
| 6850 out)) | |
| 6851 | |
| 6852 (defun gnus-adjust-marked-articles (info &optional active) | |
| 6853 "Remove all marked articles that are no longer legal." | |
| 6854 (let ((marked-lists (nth 3 info)) | |
| 6855 (active (or active (gnus-gethash (car info) gnus-active-hashtb))) | |
| 6856 m prev) | |
| 6857 ;; There are many types of marked articles. | |
| 6858 (while marked-lists | |
| 6859 (setq m (cdr (setq prev (car marked-lists)))) | |
| 6860 (cond ((or (eq 'tick (car prev)) (eq 'dormant (car prev))) | |
| 6861 ;; Make sure that all ticked articles are a subset of the | |
| 6862 ;; unread/unselected articles. | |
| 6863 (while m | |
| 6864 (if (or (memq (car m) gnus-newsgroup-unreads) | |
| 6865 (memq (car m) gnus-newsgroup-unselected)) | |
| 6866 (setq prev m) | |
| 6867 (setcdr prev (cdr m))) | |
| 6868 (setq m (cdr m)))) | |
| 6869 ((eq 'score (car prev)) | |
| 6870 ;; Scored articles should be a subset of | |
| 6871 ;; unread/unselected articles. | |
| 6872 (while m | |
| 6873 (if (or (memq (car (car m)) gnus-newsgroup-unreads) | |
| 6874 (memq (car (car m)) gnus-newsgroup-unreads)) | |
| 6875 (setq prev m) | |
| 6876 (setcdr prev (cdr m))) | |
| 6877 (setq m (cdr m)))) | |
| 6878 ((eq 'bookmark (car prev)) | |
| 6879 ;; Bookmarks should be a subset of active articles. | |
| 6880 (while m | |
| 6881 (if (< (car (car m)) (car active)) | |
| 6882 (setcdr prev (cdr m)) | |
| 6883 (setq prev m)) | |
| 6884 (setq m (cdr m)))) | |
| 6885 ((eq 'killed (car prev)) | |
| 6886 ;; Articles that have been through the kill process are | |
| 6887 ;; to be a subset of active articles. | |
| 6888 (while (and m (< (or (and (numberp (car m)) (car m)) | |
| 6889 (cdr (car m))) | |
| 6890 (car active))) | |
| 6891 (setcdr prev (cdr m)) | |
| 6892 (setq m (cdr m))) | |
| 6893 (if (and m (< (or (and (numberp (car m)) (car m)) | |
| 6894 (car (car m))) | |
| 6895 (car active))) | |
| 6896 (setcar (if (numberp (car m)) m (car m)) (car active)))) | |
| 6897 ((or (eq 'reply (car prev)) (eq 'expire (car prev))) | |
| 6898 ;; The replied and expirable articles have to be articles | |
| 6899 ;; that are active. | |
| 6900 (while m | |
| 6901 (if (< (car m) (car active)) | |
| 6902 (setcdr prev (cdr m)) | |
| 6903 (setq prev m)) | |
| 6904 (setq m (cdr m))))) | |
| 6905 (setq marked-lists (cdr marked-lists))) | |
| 6906 ;; Remove all lists that are empty. | |
| 6907 (setq marked-lists (nth 3 info)) | |
| 6908 (if marked-lists | |
| 6909 (progn | |
| 6910 (while (= 1 (length (car marked-lists))) | |
| 6911 (setq marked-lists (cdr marked-lists))) | |
| 6912 (setq m (cdr (setq prev marked-lists))) | |
| 6913 (while m | |
| 6914 (if (= 1 (length (car m))) | |
| 6915 (setcdr prev (cdr m)) | |
| 6916 (setq prev m)) | |
| 6917 (setq m (cdr m))) | |
| 6918 (setcar (nthcdr 3 info) marked-lists))) | |
| 6919 ;; Finally, if there are no marked lists at all left, and if there | |
| 6920 ;; are no elements after the lists in the info list, we just chop | |
| 6921 ;; the info list off before the marked lists. | |
| 6922 (and (null marked-lists) | |
| 6923 (not (nthcdr 4 info)) | |
| 6924 (setcdr (nthcdr 2 info) nil))) | |
| 6925 info) | |
| 6926 | |
| 6927 (defun gnus-set-marked-articles | |
| 6928 (info ticked replied expirable killed dormant bookmark score) | |
| 6929 "Enter the various lists of marked articles into the newsgroup info list." | |
| 6930 (let (newmarked) | |
| 6931 (and ticked (setq newmarked (cons (cons 'tick ticked) nil))) | |
| 6932 (and replied (setq newmarked (cons (cons 'reply replied) newmarked))) | |
| 6933 (and expirable (setq newmarked (cons (cons 'expire expirable) | |
| 6934 newmarked))) | |
| 6935 (and killed (setq newmarked (cons (cons 'killed killed) newmarked))) | |
| 6936 (and dormant (setq newmarked (cons (cons 'dormant dormant) newmarked))) | |
| 6937 (and bookmark (setq newmarked (cons (cons 'bookmark bookmark) | |
| 6938 newmarked))) | |
| 6939 (and score (setq newmarked (cons (cons 'score score) newmarked))) | |
| 6940 (if (nthcdr 3 info) | |
| 6941 (progn | |
| 6942 (setcar (nthcdr 3 info) newmarked) | |
| 6943 (and (not newmarked) | |
| 6944 (not (nthcdr 4 info)) | |
| 6945 (setcdr (nthcdr 2 info) nil))) | |
| 6946 (if newmarked | |
| 6947 (setcdr (nthcdr 2 info) (list newmarked)))))) | |
| 6948 | |
| 6949 (defun gnus-add-marked-articles (group type articles &optional info force) | |
| 6950 ;; Add ARTICLES of TYPE to the info of GROUP. | |
| 6951 ;; If INFO is non-nil, use that info. If FORCE is non-nil, don't | |
| 6952 ;; add, but replace marked articles of TYPE with ARTICLES. | |
| 6953 (let ((info (or info (nth 2 (gnus-gethash group gnus-newsrc-hashtb)))) | |
| 6954 marked m) | |
| 6955 (or (not info) | |
| 6956 (and (not (setq marked (nthcdr 3 info))) | |
| 6957 (setcdr (nthcdr 2 info) (list (list (cons type articles))))) | |
| 6958 (and (not (setq m (assq type (car marked)))) | |
| 6959 (setcar marked (cons (cons type articles) (car marked)))) | |
| 6960 (if force | |
| 6961 (setcdr m articles) | |
| 6962 (nconc m articles))))) | |
| 6963 | |
| 6964 (defun gnus-set-mode-line (where) | |
| 6965 "This function sets the mode line of the article or summary buffers. | |
| 6966 If WHERE is `summary', the summary mode line format will be used." | |
| 6967 (if (memq where gnus-updated-mode-lines) | |
| 6968 (let (mode-string) | |
| 6969 (save-excursion | |
| 6970 (set-buffer gnus-summary-buffer) | |
| 6971 (let* ((mformat (if (eq where 'article) | |
| 6972 gnus-article-mode-line-format-spec | |
| 6973 gnus-summary-mode-line-format-spec)) | |
| 6974 (group-name gnus-newsgroup-name) | |
| 6975 (article-number (or gnus-current-article 0)) | |
| 6976 (unread (- (length gnus-newsgroup-unreads) | |
| 6977 (length gnus-newsgroup-dormant))) | |
| 6978 (unread-and-unticked | |
| 6979 (- unread (length gnus-newsgroup-marked))) | |
| 6980 (unselected (length gnus-newsgroup-unselected)) | |
| 6981 (unread-and-unselected | |
| 6982 (cond ((and (zerop unread-and-unticked) | |
| 6983 (zerop unselected)) "") | |
| 6984 ((zerop unselected) | |
| 6985 (format "{%d more}" unread-and-unticked)) | |
| 6986 (t (format "{%d(+%d) more}" | |
| 6987 unread-and-unticked unselected)))) | |
| 6988 (subject | |
| 6989 (if gnus-current-headers | |
| 6990 (mail-header-subject gnus-current-headers) "")) | |
| 6991 (max-len (and gnus-mode-non-string-length | |
| 6992 (- (frame-width) gnus-mode-non-string-length))) | |
| 6993 header);; passed as argument to any user-format-funcs | |
| 6994 (setq mode-string (eval mformat)) | |
| 6995 (or (numberp max-len) | |
| 6996 (setq max-len (length mode-string))) | |
| 6997 (if (< max-len 4) (setq max-len 4)) | |
| 6998 (if (> (length mode-string) max-len) | |
| 6999 ;; modified by MORIOKA Tomohiko <morioka@jaist.ac.jp> | |
| 7000 ;; function `substring' might cut on a middle | |
| 7001 ;; of multi-octet character. | |
| 7002 (setq mode-string | |
| 7003 (concat (gnus-truncate-string mode-string (- max-len 3)) | |
| 7004 "..."))) | |
| 7005 (setq mode-string (format (format "%%-%ds" max-len) | |
| 7006 mode-string)))) | |
| 7007 (setq mode-line-buffer-identification mode-string) | |
| 7008 (set-buffer-modified-p t)))) | |
| 7009 | |
| 7010 (defun gnus-create-xref-hashtb (from-newsgroup headers unreads) | |
| 7011 "Go through the HEADERS list and add all Xrefs to a hash table. | |
| 7012 The resulting hash table is returned, or nil if no Xrefs were found." | |
| 7013 (let* ((from-method (gnus-find-method-for-group from-newsgroup)) | |
| 7014 (prefix (if (and | |
| 7015 (gnus-group-foreign-p from-newsgroup) | |
| 7016 (not (memq 'virtual | |
| 7017 (assoc (symbol-name (car from-method)) | |
| 7018 gnus-valid-select-methods)))) | |
| 7019 (gnus-group-real-prefix from-newsgroup))) | |
| 7020 (xref-hashtb (make-vector 63 0)) | |
| 7021 start group entry number xrefs header) | |
| 7022 (while headers | |
| 7023 (setq header (car headers)) | |
| 7024 (if (and (setq xrefs (mail-header-xref header)) | |
| 7025 (not (memq (mail-header-number header) unreads))) | |
| 7026 (progn | |
| 7027 (setq start 0) | |
| 7028 (while (string-match "\\([^ ]+\\):\\([0-9]+\\)" xrefs start) | |
| 7029 (setq start (match-end 0)) | |
| 7030 (setq group (concat prefix (substring xrefs (match-beginning 1) | |
| 7031 (match-end 1)))) | |
| 7032 (setq number | |
| 7033 (string-to-int (substring xrefs (match-beginning 2) | |
| 7034 (match-end 2)))) | |
| 7035 (if (setq entry (gnus-gethash group xref-hashtb)) | |
| 7036 (setcdr entry (cons number (cdr entry))) | |
| 7037 (gnus-sethash group (cons number nil) xref-hashtb))))) | |
| 7038 (setq headers (cdr headers))) | |
| 7039 (if start xref-hashtb nil))) | |
| 7040 | |
| 7041 (defun gnus-mark-xrefs-as-read (from-newsgroup headers unreads expirable) | |
| 7042 "Look through all the headers and mark the Xrefs as read." | |
| 7043 (let ((virtual (memq 'virtual | |
| 7044 (assoc (symbol-name (car (gnus-find-method-for-group | |
| 7045 from-newsgroup))) | |
| 7046 gnus-valid-select-methods))) | |
| 7047 name entry info xref-hashtb idlist method | |
| 7048 nth4) | |
| 7049 (save-excursion | |
| 7050 (set-buffer gnus-group-buffer) | |
| 7051 (if (setq xref-hashtb | |
| 7052 (gnus-create-xref-hashtb from-newsgroup headers unreads)) | |
| 7053 (mapatoms | |
| 7054 (lambda (group) | |
| 7055 (if (string= from-newsgroup (setq name (symbol-name group))) | |
| 7056 () | |
| 7057 (setq idlist (symbol-value group)) | |
| 7058 ;; Dead groups are not updated. | |
| 7059 (if (and (prog1 | |
| 7060 (setq entry (gnus-gethash name gnus-newsrc-hashtb) | |
| 7061 info (nth 2 entry)) | |
| 7062 (if (stringp (setq nth4 (nth 4 info))) | |
| 7063 (setq nth4 (gnus-server-to-method nth4)))) | |
| 7064 ;; Only do the xrefs if the group has the same | |
| 7065 ;; select method as the group we have just read. | |
| 7066 (or (gnus-methods-equal-p | |
| 7067 nth4 (gnus-find-method-for-group from-newsgroup)) | |
| 7068 virtual | |
| 7069 (equal nth4 | |
| 7070 (setq method (gnus-find-method-for-group | |
| 7071 from-newsgroup))) | |
| 7072 (and (equal (car nth4) (car method)) | |
| 7073 (equal (nth 1 nth4) (nth 1 method)))) | |
| 7074 gnus-use-cross-reference | |
| 7075 (or (not (eq gnus-use-cross-reference t)) | |
| 7076 virtual | |
| 7077 ;; Only do cross-references on subscribed | |
| 7078 ;; groups, if that is what is wanted. | |
| 7079 (<= (nth 1 info) gnus-level-subscribed))) | |
| 7080 (gnus-group-make-articles-read name idlist expirable)))) | |
| 7081 xref-hashtb))))) | |
| 7082 | |
| 7083 (defun gnus-group-make-articles-read (group articles expirable) | |
| 7084 (let* ((num 0) | |
| 7085 (entry (gnus-gethash group gnus-newsrc-hashtb)) | |
| 7086 (info (nth 2 entry)) | |
| 7087 (active (gnus-gethash group gnus-active-hashtb)) | |
| 7088 exps expirable range) | |
| 7089 ;; First peel off all illegal article numbers. | |
| 7090 (if active | |
| 7091 (let ((ids articles) | |
| 7092 (ticked (cdr (assq 'tick (nth 3 info)))) | |
| 7093 (dormant (cdr (assq 'dormant (nth 3 info)))) | |
| 7094 id first) | |
| 7095 (setq exps nil) | |
| 7096 (while ids | |
| 7097 (setq id (car ids)) | |
| 7098 (if (and first (> id (cdr active))) | |
| 7099 (progn | |
| 7100 ;; We'll end up in this situation in one particular | |
| 7101 ;; obscure situation. If you re-scan a group and get | |
| 7102 ;; a new article that is cross-posted to a different | |
| 7103 ;; group that has not been re-scanned, you might get | |
| 7104 ;; crossposted article that has a higher number than | |
| 7105 ;; Gnus believes possible. So we re-activate this | |
| 7106 ;; group as well. This might mean doing the | |
| 7107 ;; crossposting thingie will *increase* the number | |
| 7108 ;; of articles in some groups. Tsk, tsk. | |
| 7109 (setq active (or (gnus-activate-group group) active)))) | |
| 7110 (if (or (> id (cdr active)) | |
| 7111 (< id (car active)) | |
| 7112 (memq id ticked) | |
| 7113 (memq id dormant)) | |
| 7114 (setq articles (delq id articles))) | |
| 7115 (and (memq id expirable) | |
| 7116 (setq exps (cons id exps))) | |
| 7117 (setq ids (cdr ids))))) | |
| 7118 ;; Update expirable articles. | |
| 7119 (gnus-add-marked-articles nil 'expirable exps info) | |
| 7120 (and active | |
| 7121 (null (nth 2 info)) | |
| 7122 (> (car active) 1) | |
| 7123 (setcar (nthcdr 2 info) (cons 1 (1- (car active))))) | |
| 7124 (setcar (nthcdr 2 info) | |
| 7125 (setq range | |
| 7126 (gnus-add-to-range | |
| 7127 (nth 2 info) | |
| 7128 (setq articles (sort articles '<))))) | |
| 7129 ;; Then we have to re-compute how many unread | |
| 7130 ;; articles there are in this group. | |
| 7131 (if active | |
| 7132 (progn | |
| 7133 (cond | |
| 7134 ((not range) | |
| 7135 (setq num (- (1+ (cdr active)) (car active)))) | |
| 7136 ((not (listp (cdr range))) | |
| 7137 (setq num (- (cdr active) (- (1+ (cdr range)) | |
| 7138 (car range))))) | |
| 7139 (t | |
| 7140 (while range | |
| 7141 (if (numberp (car range)) | |
| 7142 (setq num (1+ num)) | |
| 7143 (setq num (+ num (- (1+ (cdr (car range))) | |
| 7144 (car (car range)))))) | |
| 7145 (setq range (cdr range))) | |
| 7146 (setq num (- (cdr active) num)))) | |
| 7147 ;; Update the number of unread articles. | |
| 7148 (setcar | |
| 7149 entry | |
| 7150 (max 0 (- num | |
| 7151 (length (cdr (assq 'tick (nth 3 info)))) | |
| 7152 (length | |
| 7153 (cdr (assq 'dormant (nth 3 info))))))) | |
| 7154 ;; Update the group buffer. | |
| 7155 (gnus-group-update-group group t))))) | |
| 7156 | |
| 7157 (defun gnus-methods-equal-p (m1 m2) | |
| 7158 (let ((m1 (or m1 gnus-select-method)) | |
| 7159 (m2 (or m2 gnus-select-method))) | |
| 7160 (or (equal m1 m2) | |
| 7161 (and (eq (car m1) (car m2)) | |
| 7162 (or (not (memq 'address (assoc (symbol-name (car m1)) | |
| 7163 gnus-valid-select-methods))) | |
| 7164 (equal (nth 1 m1) (nth 1 m2))))))) | |
| 7165 | |
| 7166 (defsubst gnus-header-value () | |
| 7167 (buffer-substring (match-end 0) (gnus-point-at-eol))) | |
| 7168 | |
| 7169 (defvar gnus-newsgroup-none-id 0) | |
| 7170 | |
| 7171 (defun gnus-get-newsgroup-headers () | |
| 7172 (setq gnus-article-internal-prepare-hook nil) | |
| 7173 (let ((cur nntp-server-buffer) | |
| 7174 (dependencies gnus-newsgroup-dependencies) | |
| 7175 headers id dep end ref) | |
| 7176 (save-excursion | |
| 7177 (set-buffer nntp-server-buffer) | |
| 7178 (goto-char (point-min)) | |
| 7179 ;; Search to the beginning of the next header. Error messages | |
| 7180 ;; do not begin with 2 or 3. | |
| 7181 (while (re-search-forward "^[23][0-9]+ " nil t) | |
| 7182 (let ((header (make-vector 9 nil)) | |
| 7183 (case-fold-search t) | |
| 7184 (p (point)) | |
| 7185 in-reply-to) | |
| 7186 (setq id nil | |
| 7187 ref nil) | |
| 7188 (mail-header-set-number header (read cur)) | |
| 7189 ;; This implementation of this function, with nine | |
| 7190 ;; search-forwards instead of the one re-search-forward and | |
| 7191 ;; a case (which basically was the old function) is actually | |
| 7192 ;; about twice as fast, even though it looks messier. You | |
| 7193 ;; can't have everything, I guess. Speed and elegance | |
| 7194 ;; doesn't always come hand in hand. | |
| 7195 (save-restriction | |
| 7196 (narrow-to-region (point) (or (save-excursion | |
| 7197 (search-forward "\n.\n" nil t)) | |
| 7198 (point))) | |
| 7199 (if (search-forward "\nfrom: " nil t) | |
| 7200 (mail-header-set-from header (gnus-header-value)) | |
| 7201 (mail-header-set-from header "(nobody)")) | |
| 7202 (goto-char p) | |
| 7203 (if (search-forward "\nsubject: " nil t) | |
| 7204 (mail-header-set-subject header (gnus-header-value)) | |
| 7205 (mail-header-set-subject header "(none)")) | |
| 7206 (goto-char p) | |
| 7207 (and (search-forward "\nxref: " nil t) | |
| 7208 (mail-header-set-xref header (gnus-header-value))) | |
| 7209 (goto-char p) | |
| 7210 (or (numberp (and (search-forward "\nlines: " nil t) | |
| 7211 (mail-header-set-lines header (read cur)))) | |
| 7212 (mail-header-set-lines header 0)) | |
| 7213 (goto-char p) | |
| 7214 (and (search-forward "\ndate: " nil t) | |
| 7215 (mail-header-set-date header (gnus-header-value))) | |
| 7216 (goto-char p) | |
| 7217 (if (search-forward "\nmessage-id: " nil t) | |
| 7218 (mail-header-set-id header (setq id (gnus-header-value))) | |
| 7219 ;; If there was no message-id, we just fake one to make | |
| 7220 ;; subsequent routines simpler. | |
| 7221 (mail-header-set-id | |
| 7222 header | |
| 7223 (setq id (concat "none+" | |
| 7224 (int-to-string | |
| 7225 (setq gnus-newsgroup-none-id | |
| 7226 (1+ gnus-newsgroup-none-id))))))) | |
| 7227 (goto-char p) | |
| 7228 (if (search-forward "\nreferences: " nil t) | |
| 7229 (progn | |
| 7230 (mail-header-set-references header (gnus-header-value)) | |
| 7231 (setq end (match-end 0)) | |
| 7232 (save-excursion | |
| 7233 (setq ref | |
| 7234 (downcase | |
| 7235 (buffer-substring | |
| 7236 (progn | |
| 7237 (end-of-line) | |
| 7238 (search-backward ">" end t) | |
| 7239 (1+ (point))) | |
| 7240 (progn | |
| 7241 (search-backward "<" end t) | |
| 7242 (point))))))) | |
| 7243 ;; Get the references from the in-reply-to header if there | |
| 7244 ;; ware no references and the in-reply-to header looks | |
| 7245 ;; promising. | |
| 7246 (if (and (search-forward "\nin-reply-to: " nil t) | |
| 7247 (setq in-reply-to (gnus-header-value)) | |
| 7248 (string-match "<[^>]+>" in-reply-to)) | |
| 7249 (progn | |
| 7250 (mail-header-set-references | |
| 7251 header | |
| 7252 (setq ref (substring in-reply-to (match-beginning 0) | |
| 7253 (match-end 0)))) | |
| 7254 (setq ref (downcase ref))) | |
| 7255 (setq ref "none"))) | |
| 7256 ;; We do some threading while we read the headers. The | |
| 7257 ;; message-id and the last reference are both entered into | |
| 7258 ;; the same hash table. Some tippy-toeing around has to be | |
| 7259 ;; done in case an article has arrived before the article | |
| 7260 ;; which it refers to. | |
| 7261 (if (boundp (setq dep (intern (downcase id) dependencies))) | |
| 7262 (if (car (symbol-value dep)) | |
| 7263 ;; An article with this Message-ID has already | |
| 7264 ;; been seen, so we ignore this one, except we add | |
| 7265 ;; any additional Xrefs (in case the two articles | |
| 7266 ;; came from different servers. | |
| 7267 (progn | |
| 7268 (mail-header-set-xref | |
| 7269 (car (symbol-value dep)) | |
| 7270 (concat (or (mail-header-xref | |
| 7271 (car (symbol-value dep))) "") | |
| 7272 (or (mail-header-xref header) ""))) | |
| 7273 (setq header nil)) | |
| 7274 (setcar (symbol-value dep) header)) | |
| 7275 (set dep (list header))) | |
| 7276 (if header | |
| 7277 (progn | |
| 7278 (if (boundp (setq dep (intern ref dependencies))) | |
| 7279 (setcdr (symbol-value dep) | |
| 7280 (cons header (cdr (symbol-value dep)))) | |
| 7281 (set dep (list nil header))) | |
| 7282 (setq headers (cons header headers)))) | |
| 7283 (goto-char (point-max)))))) | |
| 7284 (nreverse headers))) | |
| 7285 | |
| 7286 ;; The following macros and functions were written by Felix Lee | |
| 7287 ;; <flee@cse.psu.edu>. | |
| 7288 | |
| 7289 (defmacro gnus-nov-read-integer () | |
| 7290 '(prog1 | |
| 7291 (if (= (following-char) ?\t) | |
| 7292 0 | |
| 7293 (let ((num (condition-case nil (read buffer) (error nil)))) | |
| 7294 (if (numberp num) num 0))) | |
| 7295 (or (eobp) (forward-char 1)))) | |
| 7296 | |
| 7297 (defmacro gnus-nov-skip-field () | |
| 7298 '(search-forward "\t" eol 'move)) | |
| 7299 | |
| 7300 (defmacro gnus-nov-field () | |
| 7301 '(buffer-substring (point) (if (gnus-nov-skip-field) (1- (point)) eol))) | |
| 7302 | |
| 7303 ;; Goes through the xover lines and returns a list of vectors | |
| 7304 (defun gnus-get-newsgroup-headers-xover (sequence) | |
| 7305 "Parse the news overview data in the server buffer, and return a | |
| 7306 list of headers that match SEQUENCE (see `nntp-retrieve-headers')." | |
| 7307 ;; Get the Xref when the users reads the articles since most/some | |
| 7308 ;; NNTP servers do not include Xrefs when using XOVER. | |
| 7309 (setq gnus-article-internal-prepare-hook '(gnus-article-get-xrefs)) | |
| 7310 (let ((cur nntp-server-buffer) | |
| 7311 (dependencies gnus-newsgroup-dependencies) | |
| 7312 number headers header) | |
| 7313 (save-excursion | |
| 7314 (set-buffer nntp-server-buffer) | |
| 7315 (goto-char (point-min)) | |
| 7316 (while (and sequence (not (eobp))) | |
| 7317 (setq number (read cur)) | |
| 7318 (while (and sequence (< (car sequence) number)) | |
| 7319 (setq sequence (cdr sequence))) | |
| 7320 (and sequence | |
| 7321 (eq number (car sequence)) | |
| 7322 (progn | |
| 7323 (setq sequence (cdr sequence)) | |
| 7324 (if (setq header | |
| 7325 (inline (gnus-nov-parse-line number dependencies))) | |
| 7326 (setq headers (cons header headers))))) | |
| 7327 (forward-line 1)) | |
| 7328 (setq headers (nreverse headers))) | |
| 7329 headers)) | |
| 7330 | |
| 7331 ;; This function has to be called with point after the article number | |
| 7332 ;; on the beginning of the line. | |
| 7333 (defun gnus-nov-parse-line (number dependencies) | |
| 7334 (let ((none 0) | |
| 7335 (eol (gnus-point-at-eol)) | |
| 7336 (buffer (current-buffer)) | |
| 7337 header ref id dep) | |
| 7338 | |
| 7339 ;; overview: [num subject from date id refs chars lines misc] | |
| 7340 (narrow-to-region (point) eol) | |
| 7341 (or (eobp) (forward-char)) | |
| 7342 | |
| 7343 (condition-case nil | |
| 7344 (setq header | |
| 7345 (vector | |
| 7346 number ; number | |
| 7347 (gnus-nov-field) ; subject | |
| 7348 (gnus-nov-field) ; from | |
| 7349 (gnus-nov-field) ; date | |
| 7350 (setq id (or (gnus-nov-field) | |
| 7351 (concat "none+" | |
| 7352 (int-to-string | |
| 7353 (setq none (1+ none)))))) ; id | |
| 7354 (progn | |
| 7355 (save-excursion | |
| 7356 (let ((beg (point))) | |
| 7357 (search-forward "\t" eol) | |
| 7358 (if (search-backward ">" beg t) | |
| 7359 (setq ref | |
| 7360 (downcase | |
| 7361 (buffer-substring | |
| 7362 (1+ (point)) | |
| 7363 (progn | |
| 7364 (search-backward "<" beg t) | |
| 7365 (point))))) | |
| 7366 (setq ref nil)))) | |
| 7367 (gnus-nov-field)) ; refs | |
| 7368 (gnus-nov-read-integer) ; chars | |
| 7369 (gnus-nov-read-integer) ; lines | |
| 7370 (if (= (following-char) ?\n) | |
| 7371 nil | |
| 7372 (gnus-nov-field)) ; misc | |
| 7373 )) | |
| 7374 (error (progn | |
| 7375 (ding) | |
| 7376 (message "Strange nov line.") | |
| 7377 (setq header nil) | |
| 7378 (goto-char eol)))) | |
| 7379 | |
| 7380 (widen) | |
| 7381 | |
| 7382 ;; We build the thread tree. | |
| 7383 (and header | |
| 7384 (if (boundp (setq dep (intern (downcase id) dependencies))) | |
| 7385 (if (car (symbol-value dep)) | |
| 7386 ;; An article with this Message-ID has already been seen, | |
| 7387 ;; so we ignore this one, except we add any additional | |
| 7388 ;; Xrefs (in case the two articles came from different | |
| 7389 ;; servers. | |
| 7390 (progn | |
| 7391 (mail-header-set-xref | |
| 7392 (car (symbol-value dep)) | |
| 7393 (concat (or (mail-header-xref (car (symbol-value dep))) "") | |
| 7394 (or (mail-header-xref header) ""))) | |
| 7395 (setq header nil)) | |
| 7396 (setcar (symbol-value dep) header)) | |
| 7397 (set dep (list header)))) | |
| 7398 (if header | |
| 7399 (progn | |
| 7400 (if (boundp (setq dep (intern (or ref "none") | |
| 7401 dependencies))) | |
| 7402 (setcdr (symbol-value dep) | |
| 7403 (cons header (cdr (symbol-value dep)))) | |
| 7404 (set dep (list nil header))))) | |
| 7405 header)) | |
| 7406 | |
| 7407 (defun gnus-article-get-xrefs () | |
| 7408 "Fill in the Xref value in `gnus-current-headers', if necessary. | |
| 7409 This is meant to be called in `gnus-article-internal-prepare-hook'." | |
| 7410 (let ((headers (save-excursion (set-buffer gnus-summary-buffer) | |
| 7411 gnus-current-headers))) | |
| 7412 (or (not gnus-use-cross-reference) | |
| 7413 (not headers) | |
| 7414 (and (mail-header-xref headers) | |
| 7415 (not (string= (mail-header-xref headers) ""))) | |
| 7416 (let ((case-fold-search t) | |
| 7417 xref) | |
| 7418 (save-restriction | |
| 7419 (gnus-narrow-to-headers) | |
| 7420 (goto-char (point-min)) | |
| 7421 (if (or (and (eq (downcase (following-char)) ?x) | |
| 7422 (looking-at "Xref:")) | |
| 7423 (search-forward "\nXref:" nil t)) | |
| 7424 (progn | |
| 7425 (goto-char (1+ (match-end 0))) | |
| 7426 (setq xref (buffer-substring (point) | |
| 7427 (progn (end-of-line) (point)))) | |
| 7428 (mail-header-set-xref headers xref)))))))) | |
| 7429 | |
| 7430 (defalias 'gnus-find-header-by-number 'gnus-get-header-by-number) | |
| 7431 (make-obsolete 'gnus-find-header-by-number 'gnus-get-header-by-number) | |
| 7432 | |
| 7433 (defun gnus-make-headers-hashtable-by-number () | |
| 7434 "Make hashtable for the variable gnus-newsgroup-headers by number." | |
| 7435 (save-excursion | |
| 7436 (set-buffer gnus-summary-buffer) | |
| 7437 (let ((headers gnus-newsgroup-headers) | |
| 7438 header) | |
| 7439 (setq gnus-newsgroup-headers-hashtb-by-number | |
| 7440 (gnus-make-hashtable (length headers))) | |
| 7441 (while headers | |
| 7442 (setq header (car headers)) | |
| 7443 (gnus-sethash (int-to-string (mail-header-number header)) | |
| 7444 header gnus-newsgroup-headers-hashtb-by-number) | |
| 7445 (setq headers (cdr headers)))))) | |
| 7446 | |
| 7447 (defun gnus-more-header-backward () | |
| 7448 "Find new header backward." | |
| 7449 (let ((first (car (gnus-gethash gnus-newsgroup-name gnus-active-hashtb))) | |
| 7450 (artnum gnus-newsgroup-begin) | |
| 7451 (header nil)) | |
| 7452 (while (and (not header) | |
| 7453 (> artnum first)) | |
| 7454 (setq artnum (1- artnum)) | |
| 7455 (setq header (gnus-read-header artnum))) | |
| 7456 header)) | |
| 7457 | |
| 7458 (defun gnus-more-header-forward (&optional backward) | |
| 7459 "Find new header forward. | |
| 7460 If BACKWARD, find new header backward instead." | |
| 7461 (if backward | |
| 7462 (gnus-more-header-backward) | |
| 7463 (let ((last (cdr (gnus-gethash gnus-newsgroup-name gnus-active-hashtb))) | |
| 7464 (artnum gnus-newsgroup-end) | |
| 7465 (header nil)) | |
| 7466 (while (and (not header) | |
| 7467 (< artnum last)) | |
| 7468 (setq artnum (1+ artnum)) | |
| 7469 (setq header (gnus-read-header artnum))) | |
| 7470 header))) | |
| 7471 | |
| 7472 (defun gnus-extend-newsgroup (header &optional backward) | |
| 7473 "Extend newsgroup selection with HEADER. | |
| 7474 Optional argument BACKWARD means extend toward backward." | |
| 7475 (if header | |
| 7476 (let ((artnum (mail-header-number header))) | |
| 7477 (setq gnus-newsgroup-headers | |
| 7478 (if backward | |
| 7479 (cons header gnus-newsgroup-headers) | |
| 7480 (nconc gnus-newsgroup-headers (list header)))) | |
| 7481 (setq gnus-newsgroup-unselected | |
| 7482 (delq artnum gnus-newsgroup-unselected)) | |
| 7483 (setq gnus-newsgroup-begin (min gnus-newsgroup-begin artnum)) | |
| 7484 (setq gnus-newsgroup-end (max gnus-newsgroup-end artnum))))) | |
| 7485 | |
| 7486 (defun gnus-summary-work-articles (n) | |
| 7487 "Return a list of articles to be worked upon. The prefix argument, | |
| 7488 the list of process marked articles, and the current article will be | |
| 7489 taken into consideration." | |
| 7490 (let (articles) | |
| 7491 (if (and n (numberp n)) | |
| 7492 (let ((backward (< n 0)) | |
| 7493 (n (abs n))) | |
| 7494 (save-excursion | |
| 7495 (while (and (> n 0) | |
| 7496 (setq articles (cons (gnus-summary-article-number) | |
| 7497 articles)) | |
| 7498 (gnus-summary-search-forward nil nil backward)) | |
| 7499 (setq n (1- n)))) | |
| 7500 (sort articles (function <))) | |
| 7501 (or (reverse gnus-newsgroup-processable) | |
| 7502 (list (gnus-summary-article-number)))))) | |
| 7503 | |
| 7504 (defun gnus-summary-search-group (&optional backward use-level) | |
| 7505 "Search for next unread newsgroup. | |
| 7506 If optional argument BACKWARD is non-nil, search backward instead." | |
| 7507 (save-excursion | |
| 7508 (set-buffer gnus-group-buffer) | |
| 7509 (if (gnus-group-search-forward | |
| 7510 backward nil (if use-level (gnus-group-group-level) nil)) | |
| 7511 (gnus-group-group-name)))) | |
| 7512 | |
| 7513 (defun gnus-summary-best-group (&optional exclude-group) | |
| 7514 "Find the name of the best unread group. | |
| 7515 If EXCLUDE-GROUP, do not go to this group." | |
| 7516 (save-excursion | |
| 7517 (set-buffer gnus-group-buffer) | |
| 7518 (save-excursion | |
| 7519 (gnus-group-best-unread-group exclude-group)))) | |
| 7520 | |
| 7521 (defun gnus-subject-equal (s1 s2) | |
| 7522 (cond | |
| 7523 ((null gnus-summary-gather-subject-limit) | |
| 7524 (equal (gnus-simplify-subject-re s1) | |
| 7525 (gnus-simplify-subject-re s2))) | |
| 7526 ((eq gnus-summary-gather-subject-limit 'fuzzy) | |
| 7527 (equal (gnus-simplify-subject-fuzzy s1) | |
| 7528 (gnus-simplify-subject-fuzzy s2))) | |
| 7529 ((numberp gnus-summary-gather-subject-limit) | |
| 7530 (equal (gnus-limit-string s1 gnus-summary-gather-subject-limit) | |
| 7531 (gnus-limit-string s2 gnus-summary-gather-subject-limit))) | |
| 7532 (t | |
| 7533 (equal s1 s2)))) | |
| 7534 | |
| 7535 (defun gnus-summary-search-subject (&optional backward unread subject) | |
| 7536 "Search for article forward. | |
| 7537 If BACKWARD is non-nil, search backward. | |
| 7538 If UNREAD is non-nil, only unread articles are selected. | |
| 7539 If SUBJECT is non-nil, the article which has the same subject will be | |
| 7540 searched for." | |
| 7541 (let ((func (if backward 'previous-single-property-change | |
| 7542 'next-single-property-change)) | |
| 7543 (beg (point)) | |
| 7544 (did t) | |
| 7545 pos psubject) | |
| 7546 (beginning-of-line) | |
| 7547 (and gnus-summary-check-current unread | |
| 7548 (eq (get-text-property (point) 'gnus-mark) gnus-unread-mark) | |
| 7549 (setq did nil)) | |
| 7550 (if (not did) | |
| 7551 () | |
| 7552 (forward-char (if backward (if (bobp) 0 -1) (if (eobp) 0 1))) | |
| 7553 (while | |
| 7554 (and | |
| 7555 (setq pos (funcall func (point) 'gnus-number)) | |
| 7556 (goto-char (if backward (1- pos) pos)) | |
| 7557 (setq did | |
| 7558 (not (and | |
| 7559 (or (not unread) | |
| 7560 (eq (get-text-property (point) 'gnus-mark) | |
| 7561 gnus-unread-mark)) | |
| 7562 (or (not subject) | |
| 7563 (and (setq psubject | |
| 7564 (inline (gnus-summary-subject-string))) | |
| 7565 (inline | |
| 7566 (gnus-subject-equal subject psubject))))))) | |
| 7567 (if backward (if (bobp) nil (forward-char -1) t) | |
| 7568 (if (eobp) nil (forward-char 1) t))))) | |
| 7569 (if did | |
| 7570 (progn (goto-char beg) nil) | |
| 7571 (prog1 | |
| 7572 (get-text-property (point) 'gnus-number) | |
| 7573 (gnus-summary-show-thread) | |
| 7574 (gnus-summary-position-cursor))))) | |
| 7575 | |
| 7576 (defun gnus-summary-pseudo-article () | |
| 7577 "The thread level of the article on the current line." | |
| 7578 (get-text-property (gnus-point-at-bol) 'gnus-pseudo)) | |
| 7579 | |
| 7580 (defalias 'gnus-summary-score 'gnus-summary-article-score) | |
| 7581 (make-obsolete 'gnus-summary-score 'gnus-summary-article-score) | |
| 7582 (defun gnus-summary-article-score () | |
| 7583 "Return current article score." | |
| 7584 (or (cdr (assq (gnus-summary-article-number) gnus-newsgroup-scored)) | |
| 7585 gnus-summary-default-score 0)) | |
| 7586 | |
| 7587 (defun gnus-summary-recenter () | |
| 7588 "Center point in the summary window. | |
| 7589 If `gnus-auto-center-summary' is nil, or the article buffer isn't | |
| 7590 displayed, no centering will be performed." | |
| 7591 ;; Suggested by earle@mahendo.JPL.NASA.GOV (Greg Earle). | |
| 7592 ;; Recenter only when requested. Suggested by popovich@park.cs.columbia.edu. | |
| 7593 (let* ((top (cond ((< (window-height) 4) 0) | |
| 7594 ((< (window-height) 7) 1) | |
| 7595 (t 2))) | |
| 7596 (height (1- (window-height))) | |
| 7597 (bottom (save-excursion (goto-char (point-max)) | |
| 7598 (forward-line (- height)) | |
| 7599 (point))) | |
| 7600 (window (get-buffer-window (current-buffer)))) | |
| 7601 (and | |
| 7602 ;; The user has to want it, | |
| 7603 gnus-auto-center-summary | |
| 7604 ;; the article buffer must be displayed, | |
| 7605 (get-buffer-window gnus-article-buffer) | |
| 7606 ;; Set the window start to either `bottom', which is the biggest | |
| 7607 ;; possible valid number, or the second line from the top, | |
| 7608 ;; whichever is the least. | |
| 7609 (set-window-start | |
| 7610 window (min bottom (save-excursion (forward-line (- top)) (point))))))) | |
| 7611 | |
| 7612 ;; Function written by Stainless Steel Rat <ratinox@ccs.neu.edu>. | |
| 7613 (defun gnus-short-group-name (group &optional levels) | |
| 7614 "Collapse GROUP name LEVELS." | |
| 7615 (let* ((name "") (foreign "") (depth -1) (skip 1) | |
| 7616 (levels (or levels | |
| 7617 (progn | |
| 7618 (while (string-match "\\." group skip) | |
| 7619 (setq skip (match-end 0) | |
| 7620 depth (+ depth 1))) | |
| 7621 depth)))) | |
| 7622 (if (string-match ":" group) | |
| 7623 (setq foreign (substring group 0 (match-end 0)) | |
| 7624 group (substring group (match-end 0)))) | |
| 7625 (while group | |
| 7626 (if (and (string-match "\\." group) (> levels 0)) | |
| 7627 (setq name (concat name (substring group 0 1)) | |
| 7628 group (substring group (match-end 0)) | |
| 7629 levels (- levels 1) | |
| 7630 name (concat name ".")) | |
| 7631 (setq name (concat foreign name group) | |
| 7632 group nil))) | |
| 7633 name)) | |
| 7634 | |
| 7635 (defun gnus-summary-jump-to-group (newsgroup) | |
| 7636 "Move point to NEWSGROUP in group mode buffer." | |
| 7637 ;; Keep update point of group mode buffer if visible. | |
| 7638 (if (eq (current-buffer) (get-buffer gnus-group-buffer)) | |
| 7639 (save-window-excursion | |
| 7640 ;; Take care of tree window mode. | |
| 7641 (if (get-buffer-window gnus-group-buffer) | |
| 7642 (pop-to-buffer gnus-group-buffer)) | |
| 7643 (gnus-group-jump-to-group newsgroup)) | |
| 7644 (save-excursion | |
| 7645 ;; Take care of tree window mode. | |
| 7646 (if (get-buffer-window gnus-group-buffer) | |
| 7647 (pop-to-buffer gnus-group-buffer) | |
| 7648 (set-buffer gnus-group-buffer)) | |
| 7649 (gnus-group-jump-to-group newsgroup)))) | |
| 7650 | |
| 7651 ;; This function returns a list of article numbers based on the | |
| 7652 ;; difference between the ranges of read articles in this group and | |
| 7653 ;; the range of active articles. | |
| 7654 (defun gnus-list-of-unread-articles (group) | |
| 7655 (let* ((read (nth 2 (nth 2 (gnus-gethash group gnus-newsrc-hashtb)))) | |
| 7656 (active (gnus-gethash group gnus-active-hashtb)) | |
| 7657 (last (cdr active)) | |
| 7658 first nlast unread) | |
| 7659 ;; If none are read, then all are unread. | |
| 7660 (if (not read) | |
| 7661 (setq first (car active)) | |
| 7662 ;; If the range of read articles is a single range, then the | |
| 7663 ;; first unread article is the article after the last read | |
| 7664 ;; article. Sounds logical, doesn't it? | |
| 7665 (if (not (listp (cdr read))) | |
| 7666 (setq first (1+ (cdr read))) | |
| 7667 ;; `read' is a list of ranges. | |
| 7668 (if (/= (setq nlast (or (and (numberp (car read)) (car read)) | |
| 7669 (car (car read)))) 1) | |
| 7670 (setq first 1)) | |
| 7671 (while read | |
| 7672 (if first | |
| 7673 (while (< first nlast) | |
| 7674 (setq unread (cons first unread)) | |
| 7675 (setq first (1+ first)))) | |
| 7676 (setq first (1+ (if (atom (car read)) (car read) (cdr (car read))))) | |
| 7677 (setq nlast (if (atom (car (cdr read))) | |
| 7678 (car (cdr read)) | |
| 7679 (car (car (cdr read))))) | |
| 7680 (setq read (cdr read))))) | |
| 7681 ;; And add the last unread articles. | |
| 7682 (while (<= first last) | |
| 7683 (setq unread (cons first unread)) | |
| 7684 (setq first (1+ first))) | |
| 7685 ;; Return the list of unread articles. | |
| 7686 (nreverse unread))) | |
| 7687 | |
| 7688 (defun gnus-list-of-read-articles (group) | |
| 7689 (let ((info (nth 2 (gnus-gethash group gnus-newsrc-hashtb))) | |
| 7690 (active (gnus-gethash group gnus-active-hashtb))) | |
| 7691 (and info active | |
| 7692 (gnus-sorted-complement | |
| 7693 (gnus-uncompress-range active) | |
| 7694 (gnus-list-of-unread-articles group))))) | |
| 7695 | |
| 7696 ;; Various summary commands | |
| 7697 | |
| 7698 (defun gnus-summary-universal-argument () | |
| 7699 "Perform any operation on all articles marked with the process mark." | |
| 7700 (interactive) | |
| 7701 (gnus-set-global-variables) | |
| 7702 (let ((articles (reverse gnus-newsgroup-processable)) | |
| 7703 func) | |
| 7704 (or articles (error "No articles marked")) | |
| 7705 (or (setq func (key-binding (read-key-sequence "C-c C-u"))) | |
| 7706 (error "Undefined key")) | |
| 7707 (while articles | |
| 7708 (gnus-summary-goto-subject (car articles)) | |
| 7709 (command-execute func) | |
| 7710 (gnus-summary-remove-process-mark (car articles)) | |
| 7711 (setq articles (cdr articles))))) | |
| 7712 | |
| 7713 (defun gnus-summary-toggle-truncation (&optional arg) | |
| 7714 "Toggle truncation of summary lines. | |
| 7715 With arg, turn line truncation on iff arg is positive." | |
| 7716 (interactive "P") | |
| 7717 (setq truncate-lines | |
| 7718 (if (null arg) (not truncate-lines) | |
| 7719 (> (prefix-numeric-value arg) 0))) | |
| 7720 (redraw-display)) | |
| 7721 | |
| 7722 (defun gnus-summary-reselect-current-group (&optional all) | |
| 7723 "Once exit and then reselect the current newsgroup. | |
| 7724 The prefix argument ALL means to select all articles." | |
| 7725 (interactive "P") | |
| 7726 (gnus-set-global-variables) | |
| 7727 (let ((current-subject (gnus-summary-article-number)) | |
| 7728 (group gnus-newsgroup-name)) | |
| 7729 (setq gnus-newsgroup-begin nil) | |
| 7730 (gnus-summary-exit t) | |
| 7731 ;; We have to adjust the point of group mode buffer because the | |
| 7732 ;; current point was moved to the next unread newsgroup by | |
| 7733 ;; exiting. | |
| 7734 (gnus-summary-jump-to-group group) | |
| 7735 (gnus-group-read-group all t) | |
| 7736 (gnus-summary-goto-subject current-subject))) | |
| 7737 | |
| 7738 (defun gnus-summary-rescan-group (&optional all) | |
| 7739 "Exit the newsgroup, ask for new articles, and select the newsgroup." | |
| 7740 (interactive "P") | |
| 7741 (gnus-set-global-variables) | |
| 7742 ;; Fix by Ilja Weis <kult@uni-paderborn.de>. | |
| 7743 (let ((group gnus-newsgroup-name)) | |
| 7744 (gnus-summary-exit) | |
| 7745 (gnus-summary-jump-to-group group) | |
| 7746 (save-excursion | |
| 7747 (set-buffer gnus-group-buffer) | |
| 7748 (gnus-group-get-new-news-this-group 1)) | |
| 7749 (gnus-summary-jump-to-group group) | |
| 7750 (gnus-group-read-group all))) | |
| 7751 | |
| 7752 (defun gnus-summary-update-info () | |
| 7753 (let* ((group gnus-newsgroup-name)) | |
| 7754 (if gnus-newsgroup-kill-headers | |
| 7755 (setq gnus-newsgroup-killed | |
| 7756 (gnus-compress-sequence | |
| 7757 (nconc | |
| 7758 (gnus-set-sorted-intersection | |
| 7759 (gnus-uncompress-range gnus-newsgroup-killed) | |
| 7760 (setq gnus-newsgroup-unselected | |
| 7761 (sort gnus-newsgroup-unselected '<))) | |
| 7762 (setq gnus-newsgroup-unreads | |
| 7763 (sort gnus-newsgroup-unreads '<))) t))) | |
| 7764 (or (listp (cdr gnus-newsgroup-killed)) | |
| 7765 (setq gnus-newsgroup-killed (list gnus-newsgroup-killed))) | |
| 7766 (let ((headers gnus-newsgroup-headers)) | |
| 7767 (gnus-close-group group) | |
| 7768 (run-hooks 'gnus-exit-group-hook) | |
| 7769 (gnus-update-read-articles | |
| 7770 group gnus-newsgroup-unreads gnus-newsgroup-unselected | |
| 7771 gnus-newsgroup-marked | |
| 7772 t gnus-newsgroup-replied gnus-newsgroup-expirable | |
| 7773 gnus-newsgroup-killed gnus-newsgroup-dormant | |
| 7774 gnus-newsgroup-bookmarks | |
| 7775 (and gnus-save-score gnus-newsgroup-scored)) | |
| 7776 (and gnus-use-cross-reference | |
| 7777 (gnus-mark-xrefs-as-read | |
| 7778 group headers gnus-newsgroup-unreads gnus-newsgroup-expirable)) | |
| 7779 ;; Do adaptive scoring, and possibly save score files. | |
| 7780 (and gnus-newsgroup-adaptive | |
| 7781 (gnus-score-adaptive)) | |
| 7782 (and gnus-use-scoring | |
| 7783 (fboundp 'gnus-score-save) | |
| 7784 (funcall 'gnus-score-save)) | |
| 7785 ;; Do not switch windows but change the buffer to work. | |
| 7786 (set-buffer gnus-group-buffer) | |
| 7787 (or (gnus-ephemeral-group-p gnus-newsgroup-name) | |
| 7788 (gnus-group-update-group group))))) | |
| 7789 | |
| 7790 (defun gnus-summary-exit (&optional temporary) | |
| 7791 "Exit reading current newsgroup, and then return to group selection mode. | |
| 7792 gnus-exit-group-hook is called with no arguments if that value is non-nil." | |
| 7793 (interactive) | |
| 7794 (gnus-set-global-variables) | |
| 7795 (gnus-kill-save-kill-buffer) | |
| 7796 (let* ((group gnus-newsgroup-name) | |
| 7797 (quit-config (gnus-group-quit-config gnus-newsgroup-name)) | |
| 7798 (mode major-mode) | |
| 7799 (buf (current-buffer))) | |
| 7800 (run-hooks 'gnus-summary-prepare-exit-hook) | |
| 7801 ;; Make all changes in this group permanent. | |
| 7802 (gnus-summary-update-info) | |
| 7803 (set-buffer buf) | |
| 7804 (and gnus-use-cache (gnus-cache-possibly-remove-articles)) | |
| 7805 ;; Make sure where I was, and go to next newsgroup. | |
| 7806 (set-buffer gnus-group-buffer) | |
| 7807 (or quit-config | |
| 7808 (progn | |
| 7809 (gnus-group-jump-to-group group) | |
| 7810 (gnus-group-next-unread-group 1))) | |
| 7811 (if temporary | |
| 7812 nil ;Nothing to do. | |
| 7813 ;; We set all buffer-local variables to nil. It is unclear why | |
| 7814 ;; this is needed, but if we don't, buffer-local variables are | |
| 7815 ;; not garbage-collected, it seems. This would the lead to en | |
| 7816 ;; ever-growing Emacs. | |
| 7817 (set-buffer buf) | |
| 7818 (gnus-summary-clear-local-variables) | |
| 7819 ;; We clear the global counterparts of the buffer-local | |
| 7820 ;; variables as well, just to be on the safe side. | |
| 7821 (gnus-configure-windows 'group 'force) | |
| 7822 (gnus-summary-clear-local-variables) | |
| 7823 ;; Return to group mode buffer. | |
| 7824 (if (eq mode 'gnus-summary-mode) | |
| 7825 (gnus-kill-buffer buf)) | |
| 7826 (if (get-buffer gnus-article-buffer) | |
| 7827 (bury-buffer gnus-article-buffer)) | |
| 7828 (setq gnus-current-select-method gnus-select-method) | |
| 7829 (pop-to-buffer gnus-group-buffer) | |
| 7830 (if (not quit-config) | |
| 7831 (progn | |
| 7832 (gnus-group-jump-to-group group) | |
| 7833 (gnus-group-next-unread-group 1)) | |
| 7834 (if (not (buffer-name (car quit-config))) | |
| 7835 (gnus-configure-windows 'group 'force) | |
| 7836 (set-buffer (car quit-config)) | |
| 7837 (and (eq major-mode 'gnus-summary-mode) | |
| 7838 (gnus-set-global-variables)) | |
| 7839 (gnus-configure-windows (cdr quit-config)))) | |
| 7840 (run-hooks 'gnus-summary-exit-hook)))) | |
| 7841 | |
| 7842 (defalias 'gnus-summary-quit 'gnus-summary-exit-no-update) | |
| 7843 (defun gnus-summary-exit-no-update (&optional no-questions) | |
| 7844 "Quit reading current newsgroup without updating read article info." | |
| 7845 (interactive) | |
| 7846 (gnus-set-global-variables) | |
| 7847 (let* ((group gnus-newsgroup-name) | |
| 7848 (quit-config (gnus-group-quit-config group))) | |
| 7849 (if (or no-questions | |
| 7850 gnus-expert-user | |
| 7851 (gnus-y-or-n-p "Do you really wanna quit reading this group? ")) | |
| 7852 (progn | |
| 7853 (gnus-close-group group) | |
| 7854 (gnus-summary-clear-local-variables) | |
| 7855 (set-buffer gnus-group-buffer) | |
| 7856 (gnus-summary-clear-local-variables) | |
| 7857 ;; Return to group selection mode. | |
| 7858 (gnus-configure-windows 'group 'force) | |
| 7859 (if (get-buffer gnus-summary-buffer) | |
| 7860 (kill-buffer gnus-summary-buffer)) | |
| 7861 (if (get-buffer gnus-article-buffer) | |
| 7862 (bury-buffer gnus-article-buffer)) | |
| 7863 (if (equal (gnus-group-group-name) group) | |
| 7864 (gnus-group-next-unread-group 1)) | |
| 7865 (if quit-config | |
| 7866 (progn | |
| 7867 (if (not (buffer-name (car quit-config))) | |
| 7868 (gnus-configure-windows 'group 'force) | |
| 7869 (set-buffer (car quit-config)) | |
| 7870 (and (eq major-mode 'gnus-summary-mode) | |
| 7871 (gnus-set-global-variables)) | |
| 7872 (gnus-configure-windows (cdr quit-config))))))))) | |
| 7873 | |
| 7874 ;; Suggested by Andrew Eskilsson <pi92ae@pt.hk-r.se>. | |
| 7875 (defun gnus-summary-fetch-faq (group) | |
| 7876 "Fetch the FAQ for the current group." | |
| 7877 (interactive (list gnus-newsgroup-name)) | |
| 7878 (let (gnus-faq-buffer) | |
| 7879 (and (setq gnus-faq-buffer (gnus-group-fetch-faq group)) | |
| 7880 (gnus-configure-windows 'summary-faq)))) | |
| 7881 | |
| 7882 ;; Suggested by Per Abrahamsen <amanda@iesd.auc.dk>. | |
| 7883 (defun gnus-summary-describe-group (&optional force) | |
| 7884 "Describe the current newsgroup." | |
| 7885 (interactive "P") | |
| 7886 (gnus-group-describe-group force gnus-newsgroup-name)) | |
| 7887 | |
| 7888 (defun gnus-summary-describe-briefly () | |
| 7889 "Describe summary mode commands briefly." | |
| 7890 (interactive) | |
| 7891 (gnus-message 6 | |
| 7892 (substitute-command-keys "\\<gnus-summary-mode-map>\\[gnus-summary-next-page]:Select \\[gnus-summary-next-unread-article]:Forward \\[gnus-summary-prev-unread-article]:Backward \\[gnus-summary-exit]:Exit \\[gnus-info-find-node]:Run Info \\[gnus-summary-describe-briefly]:This help"))) | |
| 7893 | |
| 7894 ;; Walking around group mode buffer from summary mode. | |
| 7895 | |
| 7896 (defun gnus-summary-next-group (&optional no-article target-group backward) | |
| 7897 "Exit current newsgroup and then select next unread newsgroup. | |
| 7898 If prefix argument NO-ARTICLE is non-nil, no article is selected | |
| 7899 initially. If NEXT-GROUP, go to this group. If BACKWARD, go to | |
| 7900 previous group instead." | |
| 7901 (interactive "P") | |
| 7902 (gnus-set-global-variables) | |
| 7903 (let ((current-group gnus-newsgroup-name) | |
| 7904 (current-buffer (current-buffer)) | |
| 7905 entered) | |
| 7906 ;; First we semi-exit this group to update Xrefs and all variables. | |
| 7907 ;; We can't do a real exit, because the window conf must remain | |
| 7908 ;; the same in case the user is prompted for info, and we don't | |
| 7909 ;; want the window conf to change before that... | |
| 7910 (gnus-summary-exit t) | |
| 7911 (while (not entered) | |
| 7912 ;; Then we find what group we are supposed to enter. | |
| 7913 (set-buffer gnus-group-buffer) | |
| 7914 (gnus-group-jump-to-group current-group) | |
| 7915 (setq target-group | |
| 7916 (or target-group | |
| 7917 (if (eq gnus-keep-same-level 'best) | |
| 7918 (gnus-summary-best-group gnus-newsgroup-name) | |
| 7919 (gnus-summary-search-group backward gnus-keep-same-level)))) | |
| 7920 (if (not target-group) | |
| 7921 ;; There are no further groups, so we return to the group | |
| 7922 ;; buffer. | |
| 7923 (progn | |
| 7924 (gnus-message 5 "Returning to the group buffer") | |
| 7925 (setq entered t) | |
| 7926 (set-buffer current-buffer) | |
| 7927 (gnus-summary-exit)) | |
| 7928 ;; We try to enter the target group. | |
| 7929 (gnus-group-jump-to-group target-group) | |
| 7930 (let ((unreads (gnus-group-group-unread))) | |
| 7931 (if (and (or (eq t unreads) | |
| 7932 (and unreads (not (zerop unreads)))) | |
| 7933 (gnus-summary-read-group | |
| 7934 target-group nil no-article current-buffer)) | |
| 7935 (setq entered t) | |
| 7936 (setq current-group target-group | |
| 7937 target-group nil))))))) | |
| 7938 | |
| 7939 (defun gnus-summary-next-group-old (&optional no-article group backward) | |
| 7940 "Exit current newsgroup and then select next unread newsgroup. | |
| 7941 If prefix argument NO-ARTICLE is non-nil, no article is selected initially. | |
| 7942 If BACKWARD, go to previous group instead." | |
| 7943 (interactive "P") | |
| 7944 (gnus-set-global-variables) | |
| 7945 (let ((ingroup gnus-newsgroup-name) | |
| 7946 (sumbuf (current-buffer)) | |
| 7947 num) | |
| 7948 (set-buffer gnus-group-buffer) | |
| 7949 (if (and group | |
| 7950 (or (and (numberp (setq num (car (gnus-gethash | |
| 7951 group gnus-newsrc-hashtb)))) | |
| 7952 (< num 1)) | |
| 7953 (null num))) | |
| 7954 (progn | |
| 7955 (gnus-group-jump-to-group group) | |
| 7956 (setq group nil)) | |
| 7957 (gnus-group-jump-to-group ingroup)) | |
| 7958 (gnus-summary-search-group backward) | |
| 7959 (let ((group (or group (gnus-summary-search-group backward)))) | |
| 7960 (set-buffer sumbuf) | |
| 7961 (gnus-summary-exit t) ;Update all information. | |
| 7962 (if (null group) | |
| 7963 (gnus-summary-exit-no-update t) | |
| 7964 (gnus-group-jump-to-group ingroup) | |
| 7965 (setq group (gnus-summary-search-group backward)) | |
| 7966 (gnus-message 5 "Selecting %s..." group) | |
| 7967 (set-buffer gnus-group-buffer) | |
| 7968 ;; We are now in group mode buffer. | |
| 7969 ;; Make sure group mode buffer point is on GROUP. | |
| 7970 (gnus-group-jump-to-group group) | |
| 7971 (if (not (eq gnus-auto-select-next 'quietly)) | |
| 7972 (progn | |
| 7973 (gnus-summary-read-group group nil no-article sumbuf) | |
| 7974 (and (string= gnus-newsgroup-name ingroup) | |
| 7975 (bufferp sumbuf) (buffer-name sumbuf) | |
| 7976 (progn | |
| 7977 (set-buffer (setq gnus-summary-buffer sumbuf)) | |
| 7978 (gnus-summary-exit-no-update t)))) | |
| 7979 (let ((prevgroup group)) | |
| 7980 (gnus-group-jump-to-group ingroup) | |
| 7981 (setq group (gnus-summary-search-group backward)) | |
| 7982 (gnus-summary-read-group group nil no-article sumbuf) | |
| 7983 (while (and (string= gnus-newsgroup-name ingroup) | |
| 7984 (bufferp sumbuf) | |
| 7985 (buffer-name sumbuf) | |
| 7986 (not (string= prevgroup (gnus-group-group-name)))) | |
| 7987 (set-buffer gnus-group-buffer) | |
| 7988 (gnus-summary-read-group | |
| 7989 (setq prevgroup (gnus-group-group-name)) | |
| 7990 nil no-article sumbuf)) | |
| 7991 (and (string= prevgroup (gnus-group-group-name)) | |
| 7992 ;; We have reached the final group in the group | |
| 7993 ;; buffer. | |
| 7994 (progn | |
| 7995 (if (buffer-name sumbuf) | |
| 7996 (progn | |
| 7997 (set-buffer sumbuf) | |
| 7998 (gnus-summary-exit))))))))))) | |
| 7999 | |
| 8000 (defun gnus-summary-prev-group (&optional no-article) | |
| 8001 "Exit current newsgroup and then select previous unread newsgroup. | |
| 8002 If prefix argument NO-ARTICLE is non-nil, no article is selected initially." | |
| 8003 (interactive "P") | |
| 8004 (gnus-summary-next-group no-article nil t)) | |
| 8005 | |
| 8006 ;; Walking around summary lines. | |
| 8007 | |
| 8008 (defun gnus-summary-first-subject (&optional unread) | |
| 8009 "Go to the first unread subject. | |
| 8010 If UNREAD is non-nil, go to the first unread article. | |
| 8011 Returns nil if there are no unread articles." | |
| 8012 (interactive "P") | |
| 8013 (prog1 | |
| 8014 (cond ((not unread) | |
| 8015 (goto-char (point-min))) | |
| 8016 ((gnus-goto-char | |
| 8017 (text-property-any | |
| 8018 (point-min) (point-max) 'gnus-mark gnus-unread-mark)) | |
| 8019 t) | |
| 8020 (t | |
| 8021 ;; There are no unread articles. | |
| 8022 (gnus-message 3 "No more unread articles") | |
| 8023 nil)) | |
| 8024 (gnus-summary-position-cursor))) | |
| 8025 | |
| 8026 (defun gnus-summary-next-subject (n &optional unread dont-display) | |
| 8027 "Go to next N'th summary line. | |
| 8028 If N is negative, go to the previous N'th subject line. | |
| 8029 If UNREAD is non-nil, only unread articles are selected. | |
| 8030 The difference between N and the actual number of steps taken is | |
| 8031 returned." | |
| 8032 (interactive "p") | |
| 8033 (let ((backward (< n 0)) | |
| 8034 (n (abs n))) | |
| 8035 (while (and (> n 0) | |
| 8036 (gnus-summary-search-forward unread nil backward)) | |
| 8037 (setq n (1- n))) | |
| 8038 (if (/= 0 n) (gnus-message 7 "No more%s articles" | |
| 8039 (if unread " unread" ""))) | |
| 8040 (or dont-display | |
| 8041 (progn | |
| 8042 (gnus-summary-recenter) | |
| 8043 (gnus-summary-position-cursor))) | |
| 8044 n)) | |
| 8045 | |
| 8046 (defun gnus-summary-next-unread-subject (n) | |
| 8047 "Go to next N'th unread summary line." | |
| 8048 (interactive "p") | |
| 8049 (gnus-summary-next-subject n t)) | |
| 8050 | |
| 8051 (defun gnus-summary-prev-subject (n &optional unread) | |
| 8052 "Go to previous N'th summary line. | |
| 8053 If optional argument UNREAD is non-nil, only unread article is selected." | |
| 8054 (interactive "p") | |
| 8055 (gnus-summary-next-subject (- n) unread)) | |
| 8056 | |
| 8057 (defun gnus-summary-prev-unread-subject (n) | |
| 8058 "Go to previous N'th unread summary line." | |
| 8059 (interactive "p") | |
| 8060 (gnus-summary-next-subject (- n) t)) | |
| 8061 | |
| 8062 (defun gnus-summary-goto-subject (article) | |
| 8063 "Go the subject line of ARTICLE." | |
| 8064 (interactive | |
| 8065 (list | |
| 8066 (string-to-int | |
| 8067 (completing-read "Article number: " | |
| 8068 (mapcar | |
| 8069 (lambda (headers) | |
| 8070 (list | |
| 8071 (int-to-string (mail-header-number headers)))) | |
| 8072 gnus-newsgroup-headers) | |
| 8073 nil 'require-match)))) | |
| 8074 (or article (error "No article number")) | |
| 8075 (let ((b (point))) | |
| 8076 (if (not (gnus-goto-char (text-property-any (point-min) (point-max) | |
| 8077 'gnus-number article))) | |
| 8078 () | |
| 8079 (gnus-summary-show-thread) | |
| 8080 ;; Skip dummy articles. | |
| 8081 (if (eq (gnus-summary-article-mark) gnus-dummy-mark) | |
| 8082 (forward-line 1)) | |
| 8083 (prog1 | |
| 8084 (if (not (eobp)) | |
| 8085 article | |
| 8086 (goto-char b) | |
| 8087 nil) | |
| 8088 (gnus-summary-position-cursor))))) | |
| 8089 | |
| 8090 ;; Walking around summary lines with displaying articles. | |
| 8091 | |
| 8092 (defun gnus-summary-expand-window (&optional arg) | |
| 8093 "Make the summary buffer take up the entire Emacs frame. | |
| 8094 Given a prefix, will force an `article' buffer configuration." | |
| 8095 (interactive "P") | |
| 8096 (gnus-set-global-variables) | |
| 8097 (if arg | |
| 8098 (gnus-configure-windows 'article 'force) | |
| 8099 (gnus-configure-windows 'summary 'force))) | |
| 8100 | |
| 8101 (defun gnus-summary-display-article (article &optional all-header) | |
| 8102 "Display ARTICLE in article buffer." | |
| 8103 (gnus-set-global-variables) | |
| 8104 (if (null article) | |
| 8105 nil | |
| 8106 (prog1 | |
| 8107 (gnus-article-prepare article all-header) | |
| 8108 (gnus-summary-show-thread) | |
| 8109 (if (eq (gnus-summary-article-mark) gnus-dummy-mark) | |
| 8110 (progn | |
| 8111 (forward-line 1) | |
| 8112 (gnus-summary-position-cursor))) | |
| 8113 (run-hooks 'gnus-select-article-hook) | |
| 8114 (gnus-summary-recenter) | |
| 8115 (gnus-summary-goto-subject article) | |
| 8116 ;; Successfully display article. | |
| 8117 (gnus-summary-update-line) | |
| 8118 (gnus-article-set-window-start | |
| 8119 (cdr (assq article gnus-newsgroup-bookmarks))) | |
| 8120 t))) | |
| 8121 | |
| 8122 (defun gnus-summary-select-article (&optional all-headers force pseudo article) | |
| 8123 "Select the current article. | |
| 8124 If ALL-HEADERS is non-nil, show all header fields. If FORCE is | |
| 8125 non-nil, the article will be re-fetched even if it already present in | |
| 8126 the article buffer. If PSEUDO is non-nil, pseudo-articles will also | |
| 8127 be displayed." | |
| 8128 (and (not pseudo) (gnus-summary-pseudo-article) | |
| 8129 (error "This is a pseudo-article.")) | |
| 8130 (let ((article (or article (gnus-summary-article-number))) | |
| 8131 (all-headers (not (not all-headers))) ;Must be T or NIL. | |
| 8132 did) | |
| 8133 (prog1 | |
| 8134 (save-excursion | |
| 8135 (set-buffer gnus-summary-buffer) | |
| 8136 (if (or (null gnus-current-article) | |
| 8137 (null gnus-article-current) | |
| 8138 (null (get-buffer gnus-article-buffer)) | |
| 8139 (not (eq article (cdr gnus-article-current))) | |
| 8140 (not (equal (car gnus-article-current) gnus-newsgroup-name)) | |
| 8141 force) | |
| 8142 ;; The requested article is different from the current article. | |
| 8143 (progn | |
| 8144 (gnus-summary-display-article article all-headers) | |
| 8145 (setq did article)) | |
| 8146 (if (or all-headers gnus-show-all-headers) | |
| 8147 (gnus-article-show-all-headers)) | |
| 8148 nil)) | |
| 8149 (if did | |
| 8150 (gnus-article-set-window-start | |
| 8151 (cdr (assq article gnus-newsgroup-bookmarks))))))) | |
| 8152 | |
| 8153 (defun gnus-summary-set-current-mark (&optional current-mark) | |
| 8154 "Obsolete function." | |
| 8155 nil) | |
| 8156 | |
| 8157 (defun gnus-summary-next-article (&optional unread subject backward) | |
| 8158 "Select the next article. | |
| 8159 If UNREAD, only unread articles are selected. | |
| 8160 If SUBJECT, only articles with SUBJECT are selected. | |
| 8161 If BACKWARD, the previous article is selected instead of the next." | |
| 8162 (interactive "P") | |
| 8163 (gnus-set-global-variables) | |
| 8164 (let (header) | |
| 8165 (cond | |
| 8166 ;; Is there such an article? | |
| 8167 ((and (gnus-summary-search-forward unread subject backward) | |
| 8168 (or (gnus-summary-display-article (gnus-summary-article-number)) | |
| 8169 (eq (gnus-summary-article-mark) gnus-canceled-mark))) | |
| 8170 (gnus-summary-position-cursor)) | |
| 8171 ;; If not, we try the first unread, if that is wanted. | |
| 8172 ((and subject | |
| 8173 gnus-auto-select-same | |
| 8174 (or (gnus-summary-first-unread-article) | |
| 8175 (eq (gnus-summary-article-mark) gnus-canceled-mark))) | |
| 8176 (gnus-summary-position-cursor) | |
| 8177 (gnus-message 6 "Wrapped")) | |
| 8178 ;; Try to get next/previous article not displayed in this group. | |
| 8179 ((and gnus-auto-extend-newsgroup | |
| 8180 (not unread) (not subject) | |
| 8181 (setq header (gnus-more-header-forward backward))) | |
| 8182 (gnus-extend-newsgroup header backward) | |
| 8183 (let ((buffer-read-only nil)) | |
| 8184 (goto-char (if backward (point-min) (point-max))) | |
| 8185 (gnus-summary-prepare-threads (list header))) | |
| 8186 (gnus-summary-goto-article (if backward gnus-newsgroup-begin | |
| 8187 gnus-newsgroup-end))) | |
| 8188 ;; Go to next/previous group. | |
| 8189 (t | |
| 8190 (or (gnus-ephemeral-group-p gnus-newsgroup-name) | |
| 8191 (gnus-summary-jump-to-group gnus-newsgroup-name)) | |
| 8192 (let ((cmd last-command-char) | |
| 8193 (group | |
| 8194 (if (eq gnus-keep-same-level 'best) | |
| 8195 (gnus-summary-best-group gnus-newsgroup-name) | |
| 8196 (gnus-summary-search-group backward gnus-keep-same-level)))) | |
| 8197 ;; For some reason, the group window gets selected. We change | |
| 8198 ;; it back. | |
| 8199 (select-window (get-buffer-window (current-buffer))) | |
| 8200 ;; Keep just the event type of CMD. | |
| 8201 ;(and (listp cmd) (setq cmd (car cmd))) | |
| 8202 ;; Select next unread newsgroup automagically. | |
| 8203 (cond | |
| 8204 ((not gnus-auto-select-next) | |
| 8205 (gnus-message 7 "No more%s articles" (if unread " unread" ""))) | |
| 8206 ((eq gnus-auto-select-next 'quietly) | |
| 8207 ;; Select quietly. | |
| 8208 (if (gnus-ephemeral-group-p gnus-newsgroup-name) | |
| 8209 (gnus-summary-exit) | |
| 8210 (gnus-message 7 "No more%s articles (%s)..." | |
| 8211 (if unread " unread" "") | |
| 8212 (if group (concat "selecting " group) | |
| 8213 "exiting")) | |
| 8214 (gnus-summary-next-group nil group backward))) | |
| 8215 (t | |
| 8216 (let ((keystrokes '(?\C-n ?\C-p)) | |
| 8217 key) | |
| 8218 (while (or (null key) (memq key keystrokes)) | |
| 8219 (gnus-message | |
| 8220 7 "No more%s articles%s" (if unread " unread" "") | |
| 8221 (if (and group | |
| 8222 (not (gnus-ephemeral-group-p gnus-newsgroup-name))) | |
| 8223 (format " (Type %s for %s [%s])" | |
| 8224 (single-key-description cmd) group | |
| 8225 (car (gnus-gethash group gnus-newsrc-hashtb))) | |
| 8226 (format " (Type %s to exit %s)" | |
| 8227 (single-key-description cmd) | |
| 8228 gnus-newsgroup-name))) | |
| 8229 ;; Confirm auto selection. | |
| 8230 (let* ((event (read-char))) | |
| 8231 (setq key (if (listp event) (car event) event)) | |
| 8232 (if (memq key keystrokes) | |
| 8233 (let ((obuf (current-buffer))) | |
| 8234 (switch-to-buffer gnus-group-buffer) | |
| 8235 (and group | |
| 8236 (gnus-group-jump-to-group group)) | |
| 8237 (condition-case () | |
| 8238 (execute-kbd-macro (char-to-string key)) | |
| 8239 (error (ding) nil)) | |
| 8240 (setq group (gnus-group-group-name)) | |
| 8241 (switch-to-buffer obuf))))) | |
| 8242 (if (equal key cmd) | |
| 8243 (if (or (not group) | |
| 8244 (gnus-ephemeral-group-p gnus-newsgroup-name)) | |
| 8245 (gnus-summary-exit) | |
| 8246 (gnus-summary-next-group nil group backward)) | |
| 8247 (execute-kbd-macro (char-to-string key))))))))))) | |
| 8248 | |
| 8249 (defun gnus-summary-next-unread-article () | |
| 8250 "Select unread article after current one." | |
| 8251 (interactive) | |
| 8252 (gnus-summary-next-article t (and gnus-auto-select-same | |
| 8253 (gnus-summary-subject-string)))) | |
| 8254 | |
| 8255 (defun gnus-summary-prev-article (&optional unread subject) | |
| 8256 "Select the article after the current one. | |
| 8257 If UNREAD is non-nil, only unread articles are selected." | |
| 8258 (interactive "P") | |
| 8259 (gnus-summary-next-article unread subject t)) | |
| 8260 | |
| 8261 (defun gnus-summary-prev-unread-article () | |
| 8262 "Select unred article before current one." | |
| 8263 (interactive) | |
| 8264 (gnus-summary-prev-article t (and gnus-auto-select-same | |
| 8265 (gnus-summary-subject-string)))) | |
| 8266 | |
| 8267 (defun gnus-summary-next-page (&optional lines circular) | |
| 8268 "Show next page of selected article. | |
| 8269 If end of article, select next article. | |
| 8270 Argument LINES specifies lines to be scrolled up. | |
| 8271 If CIRCULAR is non-nil, go to the start of the article instead of | |
| 8272 instead of selecting the next article when reaching the end of the | |
| 8273 current article." | |
| 8274 (interactive "P") | |
| 8275 (setq gnus-summary-buffer (current-buffer)) | |
| 8276 (gnus-set-global-variables) | |
| 8277 (let ((article (gnus-summary-article-number)) | |
| 8278 (endp nil)) | |
| 8279 (gnus-configure-windows 'article) | |
| 8280 (if (or (null gnus-current-article) | |
| 8281 (null gnus-article-current) | |
| 8282 (/= article (cdr gnus-article-current)) | |
| 8283 (not (equal (car gnus-article-current) gnus-newsgroup-name))) | |
| 8284 ;; Selected subject is different from current article's. | |
| 8285 (gnus-summary-display-article article) | |
| 8286 (gnus-eval-in-buffer-window | |
| 8287 gnus-article-buffer | |
| 8288 (setq endp (gnus-article-next-page lines))) | |
| 8289 (if endp | |
| 8290 (cond (circular | |
| 8291 (gnus-summary-beginning-of-article)) | |
| 8292 (lines | |
| 8293 (gnus-message 3 "End of message")) | |
| 8294 ((null lines) | |
| 8295 (gnus-summary-next-unread-article))))) | |
| 8296 (gnus-summary-recenter) | |
| 8297 (gnus-summary-position-cursor))) | |
| 8298 | |
| 8299 (defun gnus-summary-prev-page (&optional lines) | |
| 8300 "Show previous page of selected article. | |
| 8301 Argument LINES specifies lines to be scrolled down." | |
| 8302 (interactive "P") | |
| 8303 (gnus-set-global-variables) | |
| 8304 (let ((article (gnus-summary-article-number))) | |
| 8305 (gnus-configure-windows 'article) | |
| 8306 (if (or (null gnus-current-article) | |
| 8307 (null gnus-article-current) | |
| 8308 (/= article (cdr gnus-article-current)) | |
| 8309 (not (equal (car gnus-article-current) gnus-newsgroup-name))) | |
| 8310 ;; Selected subject is different from current article's. | |
| 8311 (gnus-summary-display-article article) | |
| 8312 (gnus-summary-recenter) | |
| 8313 (gnus-eval-in-buffer-window gnus-article-buffer | |
| 8314 (gnus-article-prev-page lines)))) | |
| 8315 (gnus-summary-position-cursor)) | |
| 8316 | |
| 8317 (defun gnus-summary-scroll-up (lines) | |
| 8318 "Scroll up (or down) one line current article. | |
| 8319 Argument LINES specifies lines to be scrolled up (or down if negative)." | |
| 8320 (interactive "p") | |
| 8321 (gnus-set-global-variables) | |
| 8322 (gnus-configure-windows 'article) | |
| 8323 (or (gnus-summary-select-article nil nil 'pseudo) | |
| 8324 (gnus-eval-in-buffer-window | |
| 8325 gnus-article-buffer | |
| 8326 (cond ((> lines 0) | |
| 8327 (if (gnus-article-next-page lines) | |
| 8328 (gnus-message 3 "End of message"))) | |
| 8329 ((< lines 0) | |
| 8330 (gnus-article-prev-page (- lines)))))) | |
| 8331 (gnus-summary-recenter) | |
| 8332 (gnus-summary-position-cursor)) | |
| 8333 | |
| 8334 (defun gnus-summary-next-same-subject () | |
| 8335 "Select next article which has the same subject as current one." | |
| 8336 (interactive) | |
| 8337 (gnus-set-global-variables) | |
| 8338 (gnus-summary-next-article nil (gnus-summary-subject-string))) | |
| 8339 | |
| 8340 (defun gnus-summary-prev-same-subject () | |
| 8341 "Select previous article which has the same subject as current one." | |
| 8342 (interactive) | |
| 8343 (gnus-set-global-variables) | |
| 8344 (gnus-summary-prev-article nil (gnus-summary-subject-string))) | |
| 8345 | |
| 8346 (defun gnus-summary-next-unread-same-subject () | |
| 8347 "Select next unread article which has the same subject as current one." | |
| 8348 (interactive) | |
| 8349 (gnus-set-global-variables) | |
| 8350 (gnus-summary-next-article t (gnus-summary-subject-string))) | |
| 8351 | |
| 8352 (defun gnus-summary-prev-unread-same-subject () | |
| 8353 "Select previous unread article which has the same subject as current one." | |
| 8354 (interactive) | |
| 8355 (gnus-set-global-variables) | |
| 8356 (gnus-summary-prev-article t (gnus-summary-subject-string))) | |
| 8357 | |
| 8358 (defun gnus-summary-first-unread-article () | |
| 8359 "Select the first unread article. | |
| 8360 Return nil if there are no unread articles." | |
| 8361 (interactive) | |
| 8362 (gnus-set-global-variables) | |
| 8363 (prog1 | |
| 8364 (if (gnus-summary-first-subject t) | |
| 8365 (progn | |
| 8366 (gnus-summary-show-thread) | |
| 8367 (gnus-summary-first-subject t) | |
| 8368 (gnus-summary-display-article (gnus-summary-article-number)))) | |
| 8369 (gnus-summary-position-cursor))) | |
| 8370 | |
| 8371 (defun gnus-summary-best-unread-article () | |
| 8372 "Select the unread article with the highest score." | |
| 8373 (interactive) | |
| 8374 (gnus-set-global-variables) | |
| 8375 (let ((best -1000000) | |
| 8376 article score) | |
| 8377 (save-excursion | |
| 8378 (or (gnus-summary-first-subject t) | |
| 8379 (error "No unread articles")) | |
| 8380 (while | |
| 8381 (and | |
| 8382 (progn | |
| 8383 (and (> (setq score (gnus-summary-article-score)) best) | |
| 8384 (setq best score | |
| 8385 article (gnus-summary-article-number))) | |
| 8386 t) | |
| 8387 (gnus-summary-search-subject nil t)))) | |
| 8388 (if (not article) | |
| 8389 (error "No unread articles") | |
| 8390 (gnus-summary-goto-article article)) | |
| 8391 (gnus-summary-position-cursor))) | |
| 8392 | |
| 8393 (defun gnus-summary-goto-article (article &optional all-headers) | |
| 8394 "Fetch ARTICLE and display it if it exists. | |
| 8395 If ALL-HEADERS is non-nil, no header lines are hidden." | |
| 8396 (interactive | |
| 8397 (list | |
| 8398 (string-to-int | |
| 8399 (completing-read | |
| 8400 "Article number: " | |
| 8401 (mapcar (lambda (headers) | |
| 8402 (list (int-to-string (mail-header-number headers)))) | |
| 8403 gnus-newsgroup-headers) | |
| 8404 nil 'require-match)))) | |
| 8405 (prog1 | |
| 8406 (and (gnus-summary-goto-subject article) | |
| 8407 (gnus-summary-display-article article all-headers)) | |
| 8408 (gnus-summary-position-cursor))) | |
| 8409 | |
| 8410 (defun gnus-summary-goto-last-article () | |
| 8411 "Go to the previously read article." | |
| 8412 (interactive) | |
| 8413 (prog1 | |
| 8414 (and gnus-last-article | |
| 8415 (gnus-summary-goto-article gnus-last-article)) | |
| 8416 (gnus-summary-position-cursor))) | |
| 8417 | |
| 8418 (defun gnus-summary-pop-article (number) | |
| 8419 "Pop one article off the history and go to the previous. | |
| 8420 NUMBER articles will be popped off." | |
| 8421 (interactive "p") | |
| 8422 (let (to) | |
| 8423 (setq gnus-newsgroup-history | |
| 8424 (cdr (setq to (nthcdr number gnus-newsgroup-history)))) | |
| 8425 (if to | |
| 8426 (gnus-summary-goto-article (car to)) | |
| 8427 (error "Article history empty"))) | |
| 8428 (gnus-summary-position-cursor)) | |
| 8429 | |
| 8430 ;; Summary article oriented commands | |
| 8431 | |
| 8432 (defun gnus-summary-refer-parent-article (n) | |
| 8433 "Refer parent article N times. | |
| 8434 The difference between N and the number of articles fetched is returned." | |
| 8435 (interactive "p") | |
| 8436 (gnus-set-global-variables) | |
| 8437 (while | |
| 8438 (and | |
| 8439 (> n 0) | |
| 8440 (let ((ref (mail-header-references (gnus-get-header-by-num | |
| 8441 (gnus-summary-article-number))))) | |
| 8442 (if (and ref (not (equal ref "")) | |
| 8443 (string-match "<[^<>]*>[ \t]*$" ref)) | |
| 8444 (gnus-summary-refer-article | |
| 8445 (substring ref (match-beginning 0) (match-end 0))) | |
| 8446 (gnus-message 1 "No references in article %d" | |
| 8447 (gnus-summary-article-number)) | |
| 8448 nil))) | |
| 8449 (setq n (1- n))) | |
| 8450 (gnus-summary-position-cursor) | |
| 8451 n) | |
| 8452 | |
| 8453 (defun gnus-summary-refer-article (message-id) | |
| 8454 "Refer article specified by MESSAGE-ID. | |
| 8455 NOTE: This command only works with newsgroups that use real or simulated NNTP." | |
| 8456 (interactive "sMessage-ID: ") | |
| 8457 (if (or (not (stringp message-id)) | |
| 8458 (zerop (length message-id))) | |
| 8459 () | |
| 8460 ;; Construct the correct Message-ID if necessary. | |
| 8461 ;; Suggested by tale@pawl.rpi.edu. | |
| 8462 (or (string-match "^<" message-id) | |
| 8463 (setq message-id (concat "<" message-id))) | |
| 8464 (or (string-match ">$" message-id) | |
| 8465 (setq message-id (concat message-id ">"))) | |
| 8466 (let ((header (car (gnus-gethash (downcase message-id) | |
| 8467 gnus-newsgroup-dependencies)))) | |
| 8468 (if header | |
| 8469 (or (gnus-summary-goto-article (mail-header-number header)) | |
| 8470 ;; The header has been read, but the article had been | |
| 8471 ;; expunged, so we insert it again. | |
| 8472 (progn | |
| 8473 (gnus-summary-insert-line | |
| 8474 nil header 0 nil gnus-read-mark nil nil | |
| 8475 (mail-header-subject header)) | |
| 8476 (forward-line -1) | |
| 8477 (mail-header-number header))) | |
| 8478 (let ((gnus-override-method gnus-refer-article-method) | |
| 8479 (gnus-ancient-mark gnus-read-mark) | |
| 8480 (tmp-point (window-start | |
| 8481 (get-buffer-window gnus-article-buffer))) | |
| 8482 number tmp-buf) | |
| 8483 (and gnus-refer-article-method | |
| 8484 (gnus-check-server gnus-refer-article-method)) | |
| 8485 ;; Save the old article buffer. | |
| 8486 (save-excursion | |
| 8487 (set-buffer (gnus-article-setup-buffer)) | |
| 8488 (gnus-kill-buffer " *temp Article*") | |
| 8489 (setq tmp-buf (rename-buffer " *temp Article*"))) | |
| 8490 (prog1 | |
| 8491 (if (gnus-article-prepare | |
| 8492 message-id nil (gnus-read-header message-id)) | |
| 8493 (progn | |
| 8494 (setq number (mail-header-number gnus-current-headers)) | |
| 8495 (gnus-rebuild-thread message-id) | |
| 8496 (gnus-summary-goto-subject number) | |
| 8497 (if (null gnus-use-full-window) | |
| 8498 (progn | |
| 8499 (delete-windows-on tmp-buf) | |
| 8500 (gnus-configure-windows 'article 'force))) | |
| 8501 (gnus-summary-recenter) | |
| 8502 (gnus-article-set-window-start | |
| 8503 (cdr (assq number gnus-newsgroup-bookmarks))) | |
| 8504 (and gnus-visual | |
| 8505 (run-hooks 'gnus-visual-mark-article-hook)) | |
| 8506 message-id) | |
| 8507 ;; We restore the old article buffer. | |
| 8508 (save-excursion | |
| 8509 (kill-buffer gnus-article-buffer) | |
| 8510 (set-buffer tmp-buf) | |
| 8511 (rename-buffer gnus-article-buffer) | |
| 8512 (let ((buffer-read-only nil)) | |
| 8513 (and tmp-point | |
| 8514 (set-window-start (get-buffer-window (current-buffer)) | |
| 8515 tmp-point))))))))))) | |
| 8516 | |
| 8517 (defun gnus-summary-enter-digest-group () | |
| 8518 "Enter a digest group based on the current article." | |
| 8519 (interactive) | |
| 8520 (gnus-set-global-variables) | |
| 8521 (gnus-summary-select-article) | |
| 8522 ;; We do not want a narrowed article. | |
| 8523 (gnus-summary-stop-page-breaking) | |
| 8524 (let ((name (format "%s-%d" | |
| 8525 (gnus-group-prefixed-name | |
| 8526 gnus-newsgroup-name (list 'nndoc "")) | |
| 8527 gnus-current-article)) | |
| 8528 (ogroup gnus-newsgroup-name) | |
| 8529 (buf (current-buffer))) | |
| 8530 (if (gnus-group-read-ephemeral-group | |
| 8531 name (list 'nndoc name | |
| 8532 (list 'nndoc-address (get-buffer gnus-article-buffer)) | |
| 8533 '(nndoc-article-type digest)) | |
| 8534 t) | |
| 8535 (setcdr (nthcdr 4 (nth 2 (gnus-gethash name gnus-newsrc-hashtb))) | |
| 8536 (list (list (cons 'to-group ogroup)))) | |
| 8537 (switch-to-buffer buf) | |
| 8538 (gnus-set-global-variables) | |
| 8539 (gnus-configure-windows 'summary) | |
| 8540 (gnus-message 3 "Article not a digest?")))) | |
| 8541 | |
| 8542 (defun gnus-summary-isearch-article () | |
| 8543 "Do incremental search forward on current article." | |
| 8544 (interactive) | |
| 8545 (gnus-set-global-variables) | |
| 8546 (gnus-summary-select-article) | |
| 8547 (gnus-eval-in-buffer-window | |
| 8548 gnus-article-buffer (isearch-forward))) | |
| 8549 | |
| 8550 (defun gnus-summary-search-article-forward (regexp &optional backward) | |
| 8551 "Search for an article containing REGEXP forward. | |
| 8552 If BACKWARD, search backward instead." | |
| 8553 (interactive | |
| 8554 (list (read-string | |
| 8555 (format "Search article %s (regexp%s): " | |
| 8556 (if current-prefix-arg "backward" "forward") | |
| 8557 (if gnus-last-search-regexp | |
| 8558 (concat ", default " gnus-last-search-regexp) | |
| 8559 ""))) | |
| 8560 current-prefix-arg)) | |
| 8561 (gnus-set-global-variables) | |
| 8562 (if (string-equal regexp "") | |
| 8563 (setq regexp (or gnus-last-search-regexp "")) | |
| 8564 (setq gnus-last-search-regexp regexp)) | |
| 8565 (if (gnus-summary-search-article regexp backward) | |
| 8566 (gnus-article-set-window-start | |
| 8567 (cdr (assq (gnus-summary-article-number) gnus-newsgroup-bookmarks))) | |
| 8568 (error "Search failed: \"%s\"" regexp))) | |
| 8569 | |
| 8570 (defun gnus-summary-search-article-backward (regexp) | |
| 8571 "Search for an article containing REGEXP backward." | |
| 8572 (interactive | |
| 8573 (list (read-string | |
| 8574 (format "Search article backward (regexp%s): " | |
| 8575 (if gnus-last-search-regexp | |
| 8576 (concat ", default " gnus-last-search-regexp) | |
| 8577 ""))))) | |
| 8578 (gnus-summary-search-article-forward regexp 'backward)) | |
| 8579 | |
| 8580 (defun gnus-summary-search-article (regexp &optional backward) | |
| 8581 "Search for an article containing REGEXP. | |
| 8582 Optional argument BACKWARD means do search for backward. | |
| 8583 gnus-select-article-hook is not called during the search." | |
| 8584 (let ((gnus-select-article-hook nil) ;Disable hook. | |
| 8585 (gnus-mark-article-hook nil) ;Inhibit marking as read. | |
| 8586 (re-search | |
| 8587 (if backward | |
| 8588 (function re-search-backward) (function re-search-forward))) | |
| 8589 (found nil) | |
| 8590 (last nil)) | |
| 8591 ;; Hidden thread subtrees must be searched for ,too. | |
| 8592 (gnus-summary-show-all-threads) | |
| 8593 (if (eobp) (forward-line -1)) | |
| 8594 ;; First of all, search current article. | |
| 8595 ;; We don't want to read article again from NNTP server nor reset | |
| 8596 ;; current point. | |
| 8597 (gnus-summary-select-article) | |
| 8598 (gnus-message 9 "Searching article: %d..." gnus-current-article) | |
| 8599 (setq last gnus-current-article) | |
| 8600 (gnus-eval-in-buffer-window | |
| 8601 gnus-article-buffer | |
| 8602 (save-restriction | |
| 8603 (widen) | |
| 8604 ;; Begin search from current point. | |
| 8605 (setq found (funcall re-search regexp nil t)))) | |
| 8606 ;; Then search next articles. | |
| 8607 (while (and (not found) | |
| 8608 (gnus-summary-display-article | |
| 8609 (gnus-summary-search-subject backward nil nil))) | |
| 8610 (gnus-message 9 "Searching article: %d..." gnus-current-article) | |
| 8611 (gnus-eval-in-buffer-window | |
| 8612 gnus-article-buffer | |
| 8613 (save-restriction | |
| 8614 (widen) | |
| 8615 (goto-char (if backward (point-max) (point-min))) | |
| 8616 (setq found (funcall re-search regexp nil t))))) | |
| 8617 (message "") | |
| 8618 ;; Adjust article pointer. | |
| 8619 (or (eq last gnus-current-article) | |
| 8620 (setq gnus-last-article last)) | |
| 8621 ;; Return T if found such article. | |
| 8622 found)) | |
| 8623 | |
| 8624 (defun gnus-summary-execute-command (header regexp command &optional backward) | |
| 8625 "Search forward for an article whose HEADER matches REGEXP and execute COMMAND. | |
| 8626 If HEADER is an empty string (or nil), the match is done on the entire | |
| 8627 article. If BACKWARD (the prefix) is non-nil, search backward instead." | |
| 8628 (interactive | |
| 8629 (list (let ((completion-ignore-case t)) | |
| 8630 (completing-read | |
| 8631 "Header name: " | |
| 8632 (mapcar (lambda (string) (list string)) | |
| 8633 '("Number" "Subject" "From" "Lines" "Date" | |
| 8634 "Message-ID" "Xref" "References")) | |
| 8635 nil 'require-match)) | |
| 8636 (read-string "Regexp: ") | |
| 8637 (read-key-sequence "Command: ") | |
| 8638 current-prefix-arg)) | |
| 8639 (gnus-set-global-variables) | |
| 8640 ;; Hidden thread subtrees must be searched as well. | |
| 8641 (gnus-summary-show-all-threads) | |
| 8642 ;; We don't want to change current point nor window configuration. | |
| 8643 (save-excursion | |
| 8644 (save-window-excursion | |
| 8645 (gnus-message 6 "Executing %s..." (key-description command)) | |
| 8646 ;; We'd like to execute COMMAND interactively so as to give arguments. | |
| 8647 (gnus-execute header regexp | |
| 8648 (` (lambda () | |
| 8649 (call-interactively '(, (key-binding command))))) | |
| 8650 backward) | |
| 8651 (gnus-message 6 "Executing %s...done" (key-description command))))) | |
| 8652 | |
| 8653 (defun gnus-summary-beginning-of-article () | |
| 8654 "Scroll the article back to the beginning." | |
| 8655 (interactive) | |
| 8656 (gnus-set-global-variables) | |
| 8657 (gnus-summary-select-article) | |
| 8658 (gnus-configure-windows 'article) | |
| 8659 (gnus-eval-in-buffer-window | |
| 8660 gnus-article-buffer | |
| 8661 (widen) | |
| 8662 (goto-char (point-min)) | |
| 8663 (and gnus-break-pages (gnus-narrow-to-page)))) | |
| 8664 | |
| 8665 (defun gnus-summary-end-of-article () | |
| 8666 "Scroll to the end of the article." | |
| 8667 (interactive) | |
| 8668 (gnus-set-global-variables) | |
| 8669 (gnus-summary-select-article) | |
| 8670 (gnus-configure-windows 'article) | |
| 8671 (gnus-eval-in-buffer-window | |
| 8672 gnus-article-buffer | |
| 8673 (widen) | |
| 8674 (goto-char (point-max)) | |
| 8675 (recenter -3) | |
| 8676 (and gnus-break-pages (gnus-narrow-to-page)))) | |
| 8677 | |
| 8678 (defun gnus-summary-show-article () | |
| 8679 "Force re-fetching of the current article." | |
| 8680 (interactive) | |
| 8681 (gnus-set-global-variables) | |
| 8682 (gnus-summary-select-article nil 'force) | |
| 8683 (gnus-configure-windows 'article) | |
| 8684 (gnus-summary-position-cursor)) | |
| 8685 | |
| 8686 (defun gnus-summary-verbose-headers (&optional arg) | |
| 8687 "Toggle permanent full header display. | |
| 8688 If ARG is a positive number, turn header display on. | |
| 8689 If ARG is a negative number, turn header display off." | |
| 8690 (interactive "P") | |
| 8691 (gnus-set-global-variables) | |
| 8692 (gnus-summary-toggle-header arg) | |
| 8693 (setq gnus-show-all-headers | |
| 8694 (cond ((or (not (numberp arg)) | |
| 8695 (zerop arg)) | |
| 8696 (not gnus-show-all-headers)) | |
| 8697 ((natnump arg) | |
| 8698 t)))) | |
| 8699 | |
| 8700 (defun gnus-summary-toggle-header (&optional arg) | |
| 8701 "Show the headers if they are hidden, or hide them if they are shown. | |
| 8702 If ARG is a positive number, show the entire header. | |
| 8703 If ARG is a negative number, hide the unwanted header lines." | |
| 8704 (interactive "P") | |
| 8705 (gnus-set-global-variables) | |
| 8706 (save-excursion | |
| 8707 (set-buffer gnus-article-buffer) | |
| 8708 (let ((buffer-read-only nil)) | |
| 8709 (if (numberp arg) | |
| 8710 (if (> arg 0) (remove-text-properties (point-min) (point-max) | |
| 8711 gnus-hidden-properties) | |
| 8712 (if (< arg 0) (run-hooks 'gnus-article-display-hook))) | |
| 8713 (if (text-property-any (point-min) (point-max) 'invisible t) | |
| 8714 (remove-text-properties | |
| 8715 (point-min) (point-max) gnus-hidden-properties) | |
| 8716 ;; We hide the headers. This song and dance act below is | |
| 8717 ;; done because `gnus-have-all-headers' is buffer-local to | |
| 8718 ;; the summary buffer, and we only want to temporarily | |
| 8719 ;; change it in that buffer. Ugh. | |
| 8720 (let ((have gnus-have-all-headers)) | |
| 8721 (save-excursion | |
| 8722 (set-buffer gnus-summary-buffer) | |
| 8723 (setq gnus-have-all-headers nil) | |
| 8724 (save-excursion | |
| 8725 (set-buffer gnus-article-buffer) | |
| 8726 (run-hooks 'gnus-article-display-hook)) | |
| 8727 (setq gnus-have-all-headers have))))) | |
| 8728 (set-window-point (get-buffer-window (current-buffer)) (point-min))))) | |
| 8729 | |
| 8730 (defun gnus-summary-show-all-headers () | |
| 8731 "Make all header lines visible." | |
| 8732 (interactive) | |
| 8733 (gnus-set-global-variables) | |
| 8734 (gnus-article-show-all-headers)) | |
| 8735 | |
| 8736 (defun gnus-summary-toggle-mime (&optional arg) | |
| 8737 "Toggle MIME processing. | |
| 8738 If ARG is a positive number, turn MIME processing on." | |
| 8739 (interactive "P") | |
| 8740 (gnus-set-global-variables) | |
| 8741 (setq gnus-show-mime | |
| 8742 (if (null arg) (not gnus-show-mime) | |
| 8743 (> (prefix-numeric-value arg) 0))) | |
| 8744 (gnus-summary-select-article t 'force)) | |
| 8745 | |
| 8746 (defun gnus-summary-caesar-message (&optional arg) | |
| 8747 "Caesar rotate the current article by 13. | |
| 8748 The numerical prefix specifies how manu places to rotate each letter | |
| 8749 forward." | |
| 8750 (interactive "P") | |
| 8751 (gnus-set-global-variables) | |
| 8752 (gnus-summary-select-article) | |
| 8753 (let ((mail-header-separator "")) | |
| 8754 (gnus-eval-in-buffer-window | |
| 8755 gnus-article-buffer | |
| 8756 (save-restriction | |
| 8757 (widen) | |
| 8758 (let ((start (window-start))) | |
| 8759 (news-caesar-buffer-body arg) | |
| 8760 (set-window-start (get-buffer-window (current-buffer)) start)))))) | |
| 8761 | |
| 8762 (defun gnus-summary-stop-page-breaking () | |
| 8763 "Stop page breaking in the current article." | |
| 8764 (interactive) | |
| 8765 (gnus-set-global-variables) | |
| 8766 (gnus-summary-select-article) | |
| 8767 (gnus-eval-in-buffer-window gnus-article-buffer (widen))) | |
| 8768 | |
| 8769 ;; Suggested by Brian Edmonds <bedmonds@prodigy.bc.ca>. | |
| 8770 | |
| 8771 (defun gnus-summary-move-article (&optional n to-newsgroup select-method) | |
| 8772 "Move the current article to a different newsgroup. | |
| 8773 If N is a positive number, move the N next articles. | |
| 8774 If N is a negative number, move the N previous articles. | |
| 8775 If N is nil and any articles have been marked with the process mark, | |
| 8776 move those articles instead. | |
| 8777 If TO-NEWSGROUP is string, do not prompt for a newsgroup to move to. | |
| 8778 If SELECT-METHOD is symbol, do not move to a specific newsgroup, but | |
| 8779 re-spool using this method. | |
| 8780 For this function to work, both the current newsgroup and the | |
| 8781 newsgroup that you want to move to have to support the `request-move' | |
| 8782 and `request-accept' functions. (Ie. mail newsgroups at present.)" | |
| 8783 (interactive "P") | |
| 8784 (gnus-set-global-variables) | |
| 8785 (or (gnus-check-backend-function 'request-move-article gnus-newsgroup-name) | |
| 8786 (error "The current newsgroup does not support article moving")) | |
| 8787 (let ((articles (gnus-summary-work-articles n)) | |
| 8788 (prefix (gnus-group-real-prefix gnus-newsgroup-name)) | |
| 8789 art-group to-method sel-met) | |
| 8790 (if (and (not to-newsgroup) (not select-method)) | |
| 8791 (setq to-newsgroup | |
| 8792 (completing-read | |
| 8793 (format "Where do you want to move %s? %s" | |
| 8794 (if (> (length articles) 1) | |
| 8795 (format "these %d articles" (length articles)) | |
| 8796 "this article") | |
| 8797 (if gnus-current-move-group | |
| 8798 (format "(%s default) " gnus-current-move-group) | |
| 8799 "")) | |
| 8800 gnus-active-hashtb nil nil prefix))) | |
| 8801 (if to-newsgroup | |
| 8802 (progn | |
| 8803 (if (or (string= to-newsgroup "") (string= to-newsgroup prefix)) | |
| 8804 (setq to-newsgroup (or gnus-current-move-group ""))) | |
| 8805 (or (gnus-gethash to-newsgroup gnus-active-hashtb) | |
| 8806 (gnus-activate-group to-newsgroup) | |
| 8807 (error "No such group: %s" to-newsgroup)) | |
| 8808 (setq gnus-current-move-group to-newsgroup))) | |
| 8809 (setq to-method (if select-method (list select-method "") | |
| 8810 (gnus-find-method-for-group to-newsgroup))) | |
| 8811 (or (gnus-check-backend-function 'request-accept-article (car to-method)) | |
| 8812 (error "%s does not support article copying" (car to-method))) | |
| 8813 (or (gnus-check-server to-method) | |
| 8814 (error "Can't open server %s" (car to-method))) | |
| 8815 (gnus-message 6 "Moving to %s: %s..." | |
| 8816 (or select-method to-newsgroup) articles) | |
| 8817 (while articles | |
| 8818 (if (setq art-group | |
| 8819 (gnus-request-move-article | |
| 8820 (car articles) ; Article to move | |
| 8821 gnus-newsgroup-name ; From newsgrouo | |
| 8822 (nth 1 (gnus-find-method-for-group | |
| 8823 gnus-newsgroup-name)) ; Server | |
| 8824 (list 'gnus-request-accept-article | |
| 8825 (if select-method | |
| 8826 (list 'quote select-method) | |
| 8827 to-newsgroup) | |
| 8828 (not (cdr articles))) ; Accept form | |
| 8829 (not (cdr articles)))) ; Only save nov last time | |
| 8830 (let* ((buffer-read-only nil) | |
| 8831 (entry | |
| 8832 (or | |
| 8833 (gnus-gethash (car art-group) gnus-newsrc-hashtb) | |
| 8834 (gnus-gethash | |
| 8835 (gnus-group-prefixed-name | |
| 8836 (car art-group) | |
| 8837 (if select-method (list select-method "") | |
| 8838 (gnus-find-method-for-group to-newsgroup))) | |
| 8839 gnus-newsrc-hashtb))) | |
| 8840 (info (nth 2 entry)) | |
| 8841 (article (car articles))) | |
| 8842 (gnus-summary-goto-subject article) | |
| 8843 (beginning-of-line) | |
| 8844 (delete-region (point) (progn (forward-line 1) (point))) | |
| 8845 ;; Update the group that has been moved to. | |
| 8846 (if (not info) | |
| 8847 () ; This group does not exist yet. | |
| 8848 (if (not (memq article gnus-newsgroup-unreads)) | |
| 8849 (setcar (cdr (cdr info)) | |
| 8850 (gnus-add-to-range (nth 2 info) | |
| 8851 (list (cdr art-group))))) | |
| 8852 ;; Copy any marks over to the new group. | |
| 8853 (let ((marks '((tick . gnus-newsgroup-marked) | |
| 8854 (dormant . gnus-newsgroup-dormant) | |
| 8855 (expire . gnus-newsgroup-expirable) | |
| 8856 (bookmark . gnus-newsgroup-bookmarks) | |
| 8857 (reply . gnus-newsgroup-replied))) | |
| 8858 (to-article (cdr art-group))) | |
| 8859 (while marks | |
| 8860 (if (memq article (symbol-value (cdr (car marks)))) | |
| 8861 (gnus-add-marked-articles | |
| 8862 (car info) (car (car marks)) (list to-article) info)) | |
| 8863 (setq marks (cdr marks))))) | |
| 8864 ;; Update marks. | |
| 8865 (setq gnus-newsgroup-marked (delq article gnus-newsgroup-marked)) | |
| 8866 (setq gnus-newsgroup-unreads (delq article gnus-newsgroup-unreads)) | |
| 8867 (setq gnus-newsgroup-dormant | |
| 8868 (delq article gnus-newsgroup-dormant)) | |
| 8869 (setq gnus-newsgroup-reads | |
| 8870 (cons (cons article gnus-canceled-mark) | |
| 8871 gnus-newsgroup-reads))) | |
| 8872 (gnus-message 1 "Couldn't move article %s" (car articles))) | |
| 8873 (gnus-summary-remove-process-mark (car articles)) | |
| 8874 (setq articles (cdr articles))) | |
| 8875 (gnus-set-mode-line 'summary))) | |
| 8876 | |
| 8877 (defun gnus-summary-respool-article (&optional n respool-method) | |
| 8878 "Respool the current article. | |
| 8879 The article will be squeezed through the mail spooling process again, | |
| 8880 which means that it will be put in some mail newsgroup or other | |
| 8881 depending on `nnmail-split-methods'. | |
| 8882 If N is a positive number, respool the N next articles. | |
| 8883 If N is a negative number, respool the N previous articles. | |
| 8884 If N is nil and any articles have been marked with the process mark, | |
| 8885 respool those articles instead. | |
| 8886 | |
| 8887 Respooling can be done both from mail groups and \"real\" newsgroups. | |
| 8888 In the former case, the articles in question will be moved from the | |
| 8889 current group into whatever groups they are destined to. In the | |
| 8890 latter case, they will be copied into the relevant groups." | |
| 8891 (interactive "P") | |
| 8892 (gnus-set-global-variables) | |
| 8893 (let ((respool-methods (gnus-methods-using 'respool)) | |
| 8894 (methname | |
| 8895 (symbol-name (car (gnus-find-method-for-group gnus-newsgroup-name))))) | |
| 8896 (or respool-method | |
| 8897 (setq respool-method | |
| 8898 (completing-read | |
| 8899 "What method do you want to use when respooling? " | |
| 8900 respool-methods nil t methname))) | |
| 8901 (or (string= respool-method "") | |
| 8902 (if (assoc (symbol-name | |
| 8903 (car (gnus-find-method-for-group gnus-newsgroup-name))) | |
| 8904 respool-methods) | |
| 8905 (gnus-summary-move-article n nil (intern respool-method)) | |
| 8906 (gnus-summary-copy-article n nil (intern respool-method)))))) | |
| 8907 | |
| 8908 ;; Suggested by gregj@unidata.com (Gregory J. Grubbs). | |
| 8909 (defun gnus-summary-copy-article (&optional n to-newsgroup select-method) | |
| 8910 "Move the current article to a different newsgroup. | |
| 8911 If N is a positive number, move the N next articles. | |
| 8912 If N is a negative number, move the N previous articles. | |
| 8913 If N is nil and any articles have been marked with the process mark, | |
| 8914 move those articles instead. | |
| 8915 If TO-NEWSGROUP is string, do not prompt for a newsgroup to move to. | |
| 8916 If SELECT-METHOD is symbol, do not move to a specific newsgroup, but | |
| 8917 re-spool using this method. | |
| 8918 For this function to work, the newsgroup that you want to move to have | |
| 8919 to support the `request-move' and `request-accept' | |
| 8920 functions. (Ie. mail newsgroups at present.)" | |
| 8921 (interactive "P") | |
| 8922 (gnus-set-global-variables) | |
| 8923 (let ((articles (gnus-summary-work-articles n)) | |
| 8924 (copy-buf (get-buffer-create "*copy work*")) | |
| 8925 (prefix (gnus-group-real-prefix gnus-newsgroup-name)) | |
| 8926 art-group to-method) | |
| 8927 (buffer-disable-undo copy-buf) | |
| 8928 (if (and (not to-newsgroup) (not select-method)) | |
| 8929 (setq to-newsgroup | |
| 8930 (completing-read | |
| 8931 (format "Where do you want to copy %s? %s" | |
| 8932 (if (> (length articles) 1) | |
| 8933 (format "these %d articles" (length articles)) | |
| 8934 "this article") | |
| 8935 (if gnus-current-move-group | |
| 8936 (format "(%s default) " gnus-current-move-group) | |
| 8937 "")) | |
| 8938 gnus-active-hashtb nil nil prefix))) | |
| 8939 (if to-newsgroup | |
| 8940 (progn | |
| 8941 (if (or (string= to-newsgroup "") (string= to-newsgroup prefix)) | |
| 8942 (setq to-newsgroup (or gnus-current-move-group ""))) | |
| 8943 (or (gnus-gethash to-newsgroup gnus-active-hashtb) | |
| 8944 (gnus-activate-group to-newsgroup) | |
| 8945 (error "No such group: %s" to-newsgroup)) | |
| 8946 (setq gnus-current-move-group to-newsgroup))) | |
| 8947 (setq to-method (if select-method (list select-method "") | |
| 8948 (gnus-find-method-for-group to-newsgroup))) | |
| 8949 (or (gnus-check-backend-function 'request-accept-article (car to-method)) | |
| 8950 (error "%s does not support article copying" (car to-method))) | |
| 8951 (or (gnus-check-server to-method) | |
| 8952 (error "Can't open server %s" (car to-method))) | |
| 8953 (while articles | |
| 8954 (gnus-message 6 "Copying to %s: %s..." | |
| 8955 (or select-method to-newsgroup) articles) | |
| 8956 (if (setq art-group | |
| 8957 (save-excursion | |
| 8958 (set-buffer copy-buf) | |
| 8959 (gnus-request-article-this-buffer | |
| 8960 (car articles) gnus-newsgroup-name) | |
| 8961 (gnus-request-accept-article | |
| 8962 (if select-method (quote select-method) to-newsgroup) | |
| 8963 (not (cdr articles))))) | |
| 8964 (let* ((entry | |
| 8965 (or | |
| 8966 (gnus-gethash (car art-group) gnus-newsrc-hashtb) | |
| 8967 (gnus-gethash | |
| 8968 (gnus-group-prefixed-name | |
| 8969 (car art-group) | |
| 8970 (if select-method (list select-method "") | |
| 8971 (gnus-find-method-for-group to-newsgroup))) | |
| 8972 gnus-newsrc-hashtb))) | |
| 8973 (info (nth 2 entry)) | |
| 8974 (article (car articles))) | |
| 8975 ;; We copy the info over to the new group. | |
| 8976 (if (not info) | |
| 8977 () ; This group does not exist (yet). | |
| 8978 (if (not (memq article gnus-newsgroup-unreads)) | |
| 8979 (setcar (cdr (cdr info)) | |
| 8980 (gnus-add-to-range (nth 2 info) | |
| 8981 (list (cdr art-group))))) | |
| 8982 ;; Copy any marks over to the new group. | |
| 8983 (let ((marks '((tick . gnus-newsgroup-marked) | |
| 8984 (dormant . gnus-newsgroup-dormant) | |
| 8985 (expire . gnus-newsgroup-expirable) | |
| 8986 (bookmark . gnus-newsgroup-bookmarks) | |
| 8987 (reply . gnus-newsgroup-replied))) | |
| 8988 (to-article (cdr art-group))) | |
| 8989 (while marks | |
| 8990 (if (memq article (symbol-value (cdr (car marks)))) | |
| 8991 (gnus-add-marked-articles | |
| 8992 (car info) (car (car marks)) (list to-article) info)) | |
| 8993 (setq marks (cdr marks)))))) | |
| 8994 (gnus-message 1 "Couldn't copy article %s" (car articles))) | |
| 8995 (gnus-summary-remove-process-mark (car articles)) | |
| 8996 (setq articles (cdr articles))) | |
| 8997 (kill-buffer copy-buf))) | |
| 8998 | |
| 8999 (defun gnus-summary-import-article (file) | |
| 9000 "Import a random file into a mail newsgroup." | |
| 9001 (interactive "fImport file: ") | |
| 9002 (let ((group gnus-newsgroup-name) | |
| 9003 atts) | |
| 9004 (or (gnus-check-backend-function 'request-accept-article group) | |
| 9005 (error "%s does not support article importing" group)) | |
| 9006 (or (file-readable-p file) | |
| 9007 (not (file-regular-p file)) | |
| 9008 (error "Can't read %s" file)) | |
| 9009 (save-excursion | |
| 9010 (set-buffer (get-buffer-create " *import file*")) | |
| 9011 (buffer-disable-undo (current-buffer)) | |
| 9012 (erase-buffer) | |
| 9013 (insert-file-contents file) | |
| 9014 (goto-char (point-min)) | |
| 9015 (if (nnheader-article-p) | |
| 9016 () | |
| 9017 (setq atts (file-attributes file)) | |
| 9018 (insert "From: " (read-string "From: ") "\n" | |
| 9019 "Subject: " (read-string "Subject: ") "\n" | |
| 9020 "Date: " (current-time-string (nth 5 atts)) "\n" | |
| 9021 "Chars: " (int-to-string (nth 7 atts)) "\n\n")) | |
| 9022 (gnus-request-accept-article group t) | |
| 9023 (kill-buffer (current-buffer))))) | |
| 9024 | |
| 9025 (defun gnus-summary-expire-articles () | |
| 9026 "Expire all articles that are marked as expirable in the current group." | |
| 9027 (interactive) | |
| 9028 (if (not (gnus-check-backend-function | |
| 9029 'request-expire-articles gnus-newsgroup-name)) | |
| 9030 () | |
| 9031 (let* ((info (nth 2 (gnus-gethash gnus-newsgroup-name | |
| 9032 gnus-newsrc-hashtb))) | |
| 9033 (total (memq 'total-expire (nth 5 info))) | |
| 9034 (expirable (if total | |
| 9035 (gnus-list-of-read-articles gnus-newsgroup-name) | |
| 9036 (setq gnus-newsgroup-expirable | |
| 9037 (sort gnus-newsgroup-expirable '<)))) | |
| 9038 es) | |
| 9039 (if (not expirable) | |
| 9040 () | |
| 9041 (gnus-message 6 "Expiring articles...") | |
| 9042 ;; The list of articles that weren't expired is returned. | |
| 9043 (setq es (gnus-request-expire-articles expirable gnus-newsgroup-name)) | |
| 9044 (or total (setq gnus-newsgroup-expirable es)) | |
| 9045 ;; We go through the old list of expirable, and mark all | |
| 9046 ;; really expired articles as non-existant. | |
| 9047 (or (eq es expirable) ;If nothing was expired, we don't mark. | |
| 9048 (let ((gnus-use-cache nil)) | |
| 9049 (while expirable | |
| 9050 (or (memq (car expirable) es) | |
| 9051 (gnus-summary-mark-article | |
| 9052 (car expirable) gnus-canceled-mark)) | |
| 9053 (setq expirable (cdr expirable))))) | |
| 9054 (gnus-message 6 "Expiring articles...done"))))) | |
| 9055 | |
| 9056 (defun gnus-summary-expire-articles-now () | |
| 9057 "Expunge all expirable articles in the current group. | |
| 9058 This means that *all* articles that are marked as expirable will be | |
| 9059 deleted forever, right now." | |
| 9060 (interactive) | |
| 9061 (or gnus-expert-user | |
| 9062 (gnus-y-or-n-p | |
| 9063 "Are you really, really, really sure you want to expunge? ") | |
| 9064 (error "Phew!")) | |
| 9065 (let ((nnmail-expiry-wait -1) | |
| 9066 (nnmail-expiry-wait-function nil)) | |
| 9067 (gnus-summary-expire-articles))) | |
| 9068 | |
| 9069 ;; Suggested by Jack Vinson <vinson@unagi.cis.upenn.edu>. | |
| 9070 (defun gnus-summary-delete-article (&optional n) | |
| 9071 "Delete the N next (mail) articles. | |
| 9072 This command actually deletes articles. This is not a marking | |
| 9073 command. The article will disappear forever from you life, never to | |
| 9074 return. | |
| 9075 If N is negative, delete backwards. | |
| 9076 If N is nil and articles have been marked with the process mark, | |
| 9077 delete these instead." | |
| 9078 (interactive "P") | |
| 9079 (or (gnus-check-backend-function 'request-expire-articles | |
| 9080 gnus-newsgroup-name) | |
| 9081 (error "The current newsgroup does not support article deletion.")) | |
| 9082 ;; Compute the list of articles to delete. | |
| 9083 (let ((articles (gnus-summary-work-articles n)) | |
| 9084 not-deleted) | |
| 9085 (if (and gnus-novice-user | |
| 9086 (not (gnus-y-or-n-p | |
| 9087 (format "Do you really want to delete %s forever? " | |
| 9088 (if (> (length articles) 1) "these articles" | |
| 9089 "this article"))))) | |
| 9090 () | |
| 9091 ;; Delete the articles. | |
| 9092 (setq not-deleted (gnus-request-expire-articles | |
| 9093 articles gnus-newsgroup-name 'force)) | |
| 9094 (while articles | |
| 9095 (gnus-summary-remove-process-mark (car articles)) | |
| 9096 ;; The backend might not have been able to delete the article | |
| 9097 ;; after all. | |
| 9098 (or (memq (car articles) not-deleted) | |
| 9099 (gnus-summary-mark-article (car articles) gnus-canceled-mark)) | |
| 9100 (setq articles (cdr articles)))) | |
| 9101 (gnus-summary-position-cursor) | |
| 9102 (gnus-set-mode-line 'summary) | |
| 9103 not-deleted)) | |
| 9104 | |
| 9105 (defun gnus-summary-edit-article (&optional force) | |
| 9106 "Enter into a buffer and edit the current article. | |
| 9107 This will have permanent effect only in mail groups. | |
| 9108 If FORCE is non-nil, allow editing of articles even in read-only | |
| 9109 groups." | |
| 9110 (interactive "P") | |
| 9111 (or force | |
| 9112 (not (gnus-group-read-only-p)) | |
| 9113 (error "The current newsgroup does not support article editing.")) | |
| 9114 (gnus-summary-select-article t) | |
| 9115 (gnus-configure-windows 'article) | |
| 9116 (select-window (get-buffer-window gnus-article-buffer)) | |
| 9117 (gnus-message 6 "C-c C-c to end edits") | |
| 9118 (setq buffer-read-only nil) | |
| 9119 (text-mode) | |
| 9120 (use-local-map (copy-keymap (current-local-map))) | |
| 9121 (local-set-key "\C-c\C-c" 'gnus-summary-edit-article-done) | |
| 9122 (buffer-enable-undo) | |
| 9123 (widen) | |
| 9124 (goto-char (point-min)) | |
| 9125 (search-forward "\n\n" nil t)) | |
| 9126 | |
| 9127 (defun gnus-summary-edit-article-done () | |
| 9128 "Make edits to the current article permanent." | |
| 9129 (interactive) | |
| 9130 (if (gnus-group-read-only-p) | |
| 9131 (progn | |
| 9132 (gnus-summary-edit-article-postpone) | |
| 9133 (message "The current newsgroup does not support article editing.") | |
| 9134 (ding)) | |
| 9135 (let ((buf (buffer-substring-no-properties (point-min) (point-max)))) | |
| 9136 (erase-buffer) | |
| 9137 (insert buf) | |
| 9138 (if (not (gnus-request-replace-article | |
| 9139 (cdr gnus-article-current) (car gnus-article-current) | |
| 9140 (current-buffer))) | |
| 9141 (error "Couldn't replace article.") | |
| 9142 (gnus-article-mode) | |
| 9143 (use-local-map gnus-article-mode-map) | |
| 9144 (setq buffer-read-only t) | |
| 9145 (buffer-disable-undo (current-buffer)) | |
| 9146 (gnus-configure-windows 'summary)) | |
| 9147 (and gnus-visual (run-hooks 'gnus-visual-mark-article-hook))))) | |
| 9148 | |
| 9149 (defun gnus-summary-edit-article-postpone () | |
| 9150 "Postpone changes to the current article." | |
| 9151 (interactive) | |
| 9152 (gnus-article-mode) | |
| 9153 (use-local-map gnus-article-mode-map) | |
| 9154 (setq buffer-read-only t) | |
| 9155 (buffer-disable-undo (current-buffer)) | |
| 9156 (gnus-configure-windows 'summary) | |
| 9157 (and gnus-visual (run-hooks 'gnus-visual-mark-article-hook))) | |
| 9158 | |
| 9159 (defun gnus-summary-fancy-query () | |
| 9160 "Query where the fancy respool algorithm would put this article." | |
| 9161 (interactive) | |
| 9162 (gnus-summary-select-article) | |
| 9163 (save-excursion | |
| 9164 (set-buffer gnus-article-buffer) | |
| 9165 (save-restriction | |
| 9166 (goto-char (point-min)) | |
| 9167 (search-forward "\n\n") | |
| 9168 (narrow-to-region (point-min) (point)) | |
| 9169 (pp-eval-expression (list 'quote (nnmail-split-fancy)))))) | |
| 9170 | |
| 9171 ;; Summary score commands. | |
| 9172 | |
| 9173 ;; Suggested by boubaker@cenatls.cena.dgac.fr. | |
| 9174 | |
| 9175 (defun gnus-summary-raise-score (n) | |
| 9176 "Raise the score of the current article by N." | |
| 9177 (interactive "p") | |
| 9178 (gnus-summary-set-score (+ (gnus-summary-article-score) n))) | |
| 9179 | |
| 9180 (defun gnus-summary-set-score (n) | |
| 9181 "Set the score of the current article to N." | |
| 9182 (interactive "p") | |
| 9183 ;; Skip dummy header line. | |
| 9184 (save-excursion | |
| 9185 (gnus-summary-show-thread) | |
| 9186 (if (eq (gnus-summary-article-mark) gnus-dummy-mark) | |
| 9187 (forward-line 1)) | |
| 9188 (let ((buffer-read-only nil)) | |
| 9189 ;; Set score. | |
| 9190 (gnus-summary-update-mark | |
| 9191 (if (= n (or gnus-summary-default-score 0)) ? | |
| 9192 (if (< n (or gnus-summary-default-score 0)) | |
| 9193 gnus-score-below-mark gnus-score-over-mark)) 'score)) | |
| 9194 (let* ((article (gnus-summary-article-number)) | |
| 9195 (score (assq article gnus-newsgroup-scored))) | |
| 9196 (if score (setcdr score n) | |
| 9197 (setq gnus-newsgroup-scored | |
| 9198 (cons (cons article n) gnus-newsgroup-scored)))) | |
| 9199 (gnus-summary-update-line))) | |
| 9200 | |
| 9201 (defun gnus-summary-current-score () | |
| 9202 "Return the score of the current article." | |
| 9203 (interactive) | |
| 9204 (message "%s" (gnus-summary-article-score))) | |
| 9205 | |
| 9206 ;; Summary marking commands. | |
| 9207 | |
| 9208 (defun gnus-summary-raise-same-subject-and-select (score) | |
| 9209 "Raise articles which has the same subject with SCORE and select the next." | |
| 9210 (interactive "p") | |
| 9211 (let ((subject (gnus-summary-subject-string))) | |
| 9212 (gnus-summary-raise-score score) | |
| 9213 (while (gnus-summary-search-subject nil nil subject) | |
| 9214 (gnus-summary-raise-score score)) | |
| 9215 (gnus-summary-next-article t))) | |
| 9216 | |
| 9217 (defun gnus-summary-raise-same-subject (score) | |
| 9218 "Raise articles which has the same subject with SCORE." | |
| 9219 (interactive "p") | |
| 9220 (let ((subject (gnus-summary-subject-string))) | |
| 9221 (gnus-summary-raise-score score) | |
| 9222 (while (gnus-summary-search-subject nil nil subject) | |
| 9223 (gnus-summary-raise-score score)) | |
| 9224 (gnus-summary-next-subject 1 t))) | |
| 9225 | |
| 9226 (defun gnus-score-default (level) | |
| 9227 (if level (prefix-numeric-value level) | |
| 9228 gnus-score-interactive-default-score)) | |
| 9229 | |
| 9230 (defun gnus-summary-raise-thread (&optional score) | |
| 9231 "Raise the score of the articles in the current thread with SCORE." | |
| 9232 (interactive "P") | |
| 9233 (setq score (gnus-score-default score)) | |
| 9234 (let (e) | |
| 9235 (save-excursion | |
| 9236 (let ((level (gnus-summary-thread-level))) | |
| 9237 (gnus-summary-raise-score score) | |
| 9238 (while (and (zerop (gnus-summary-next-subject 1 nil t)) | |
| 9239 (> (gnus-summary-thread-level) level)) | |
| 9240 (gnus-summary-raise-score score)) | |
| 9241 (setq e (point)))) | |
| 9242 (let ((gnus-summary-check-current t)) | |
| 9243 (or (zerop (gnus-summary-next-subject 1 t)) | |
| 9244 (goto-char e)))) | |
| 9245 (gnus-summary-recenter) | |
| 9246 (gnus-summary-position-cursor) | |
| 9247 (gnus-set-mode-line 'summary)) | |
| 9248 | |
| 9249 (defun gnus-summary-lower-same-subject-and-select (score) | |
| 9250 "Raise articles which has the same subject with SCORE and select the next." | |
| 9251 (interactive "p") | |
| 9252 (gnus-summary-raise-same-subject-and-select (- score))) | |
| 9253 | |
| 9254 (defun gnus-summary-lower-same-subject (score) | |
| 9255 "Raise articles which has the same subject with SCORE." | |
| 9256 (interactive "p") | |
| 9257 (gnus-summary-raise-same-subject (- score))) | |
| 9258 | |
| 9259 (defun gnus-summary-lower-thread (&optional score) | |
| 9260 "Lower score of articles in the current thread with SCORE." | |
| 9261 (interactive "P") | |
| 9262 (gnus-summary-raise-thread (- (1- (gnus-score-default score))))) | |
| 9263 | |
| 9264 (defun gnus-summary-kill-same-subject-and-select (&optional unmark) | |
| 9265 "Mark articles which has the same subject as read, and then select the next. | |
| 9266 If UNMARK is positive, remove any kind of mark. | |
| 9267 If UNMARK is negative, tick articles." | |
| 9268 (interactive "P") | |
| 9269 (if unmark | |
| 9270 (setq unmark (prefix-numeric-value unmark))) | |
| 9271 (let ((count | |
| 9272 (gnus-summary-mark-same-subject | |
| 9273 (gnus-summary-subject-string) unmark))) | |
| 9274 ;; Select next unread article. If auto-select-same mode, should | |
| 9275 ;; select the first unread article. | |
| 9276 (gnus-summary-next-article t (and gnus-auto-select-same | |
| 9277 (gnus-summary-subject-string))) | |
| 9278 (gnus-message 7 "%d article%s marked as %s" | |
| 9279 count (if (= count 1) " is" "s are") | |
| 9280 (if unmark "unread" "read")))) | |
| 9281 | |
| 9282 (defun gnus-summary-kill-same-subject (&optional unmark) | |
| 9283 "Mark articles which has the same subject as read. | |
| 9284 If UNMARK is positive, remove any kind of mark. | |
| 9285 If UNMARK is negative, tick articles." | |
| 9286 (interactive "P") | |
| 9287 (if unmark | |
| 9288 (setq unmark (prefix-numeric-value unmark))) | |
| 9289 (let ((count | |
| 9290 (gnus-summary-mark-same-subject | |
| 9291 (gnus-summary-subject-string) unmark))) | |
| 9292 ;; If marked as read, go to next unread subject. | |
| 9293 (if (null unmark) | |
| 9294 ;; Go to next unread subject. | |
| 9295 (gnus-summary-next-subject 1 t)) | |
| 9296 (gnus-message 7 "%d articles are marked as %s" | |
| 9297 count (if unmark "unread" "read")))) | |
| 9298 | |
| 9299 (defun gnus-summary-mark-same-subject (subject &optional unmark) | |
| 9300 "Mark articles with same SUBJECT as read, and return marked number. | |
| 9301 If optional argument UNMARK is positive, remove any kinds of marks. | |
| 9302 If optional argument UNMARK is negative, mark articles as unread instead." | |
| 9303 (let ((count 1)) | |
| 9304 (save-excursion | |
| 9305 (cond | |
| 9306 ((null unmark) ; Mark as read. | |
| 9307 (while (and | |
| 9308 (progn | |
| 9309 (gnus-summary-mark-article-as-read gnus-killed-mark) | |
| 9310 (gnus-summary-show-thread) t) | |
| 9311 (gnus-summary-search-forward nil subject)) | |
| 9312 (setq count (1+ count)))) | |
| 9313 ((> unmark 0) ; Tick. | |
| 9314 (while (and | |
| 9315 (progn | |
| 9316 (gnus-summary-mark-article-as-unread gnus-ticked-mark) | |
| 9317 (gnus-summary-show-thread) t) | |
| 9318 (gnus-summary-search-forward nil subject)) | |
| 9319 (setq count (1+ count)))) | |
| 9320 (t ; Mark as unread. | |
| 9321 (while (and | |
| 9322 (progn | |
| 9323 (gnus-summary-mark-article-as-unread gnus-unread-mark) | |
| 9324 (gnus-summary-show-thread) t) | |
| 9325 (gnus-summary-search-forward nil subject)) | |
| 9326 (setq count (1+ count))))) | |
| 9327 (gnus-set-mode-line 'summary) | |
| 9328 ;; Return the number of marked articles. | |
| 9329 count))) | |
| 9330 | |
| 9331 (defun gnus-summary-mark-as-processable (n &optional unmark) | |
| 9332 "Set the process mark on the next N articles. | |
| 9333 If N is negative, mark backward instead. If UNMARK is non-nil, remove | |
| 9334 the process mark instead. The difference between N and the actual | |
| 9335 number of articles marked is returned." | |
| 9336 (interactive "p") | |
| 9337 (let ((backward (< n 0)) | |
| 9338 (n (abs n))) | |
| 9339 (while (and | |
| 9340 (> n 0) | |
| 9341 (if unmark | |
| 9342 (gnus-summary-remove-process-mark | |
| 9343 (gnus-summary-article-number)) | |
| 9344 (gnus-summary-set-process-mark (gnus-summary-article-number))) | |
| 9345 (zerop (gnus-summary-next-subject (if backward -1 1) nil t))) | |
| 9346 (setq n (1- n))) | |
| 9347 (if (/= 0 n) (gnus-message 7 "No more articles")) | |
| 9348 (gnus-summary-recenter) | |
| 9349 (gnus-summary-position-cursor) | |
| 9350 n)) | |
| 9351 | |
| 9352 (defun gnus-summary-unmark-as-processable (n) | |
| 9353 "Remove the process mark from the next N articles. | |
| 9354 If N is negative, mark backward instead. The difference between N and | |
| 9355 the actual number of articles marked is returned." | |
| 9356 (interactive "p") | |
| 9357 (gnus-summary-mark-as-processable n t)) | |
| 9358 | |
| 9359 (defun gnus-summary-unmark-all-processable () | |
| 9360 "Remove the process mark from all articles." | |
| 9361 (interactive) | |
| 9362 (save-excursion | |
| 9363 (while gnus-newsgroup-processable | |
| 9364 (gnus-summary-remove-process-mark (car gnus-newsgroup-processable)))) | |
| 9365 (gnus-summary-position-cursor)) | |
| 9366 | |
| 9367 (defun gnus-summary-mark-as-expirable (n) | |
| 9368 "Mark N articles forward as expirable. | |
| 9369 If N is negative, mark backward instead. The difference between N and | |
| 9370 the actual number of articles marked is returned." | |
| 9371 (interactive "p") | |
| 9372 (gnus-summary-mark-forward n gnus-expirable-mark)) | |
| 9373 | |
| 9374 (defun gnus-summary-mark-article-as-replied (article) | |
| 9375 "Mark ARTICLE replied and update the summary line." | |
| 9376 (setq gnus-newsgroup-replied (cons article gnus-newsgroup-replied)) | |
| 9377 (let ((buffer-read-only nil)) | |
| 9378 (if (gnus-summary-goto-subject article) | |
| 9379 (progn | |
| 9380 (gnus-summary-update-mark gnus-replied-mark 'replied) | |
| 9381 t)))) | |
| 9382 | |
| 9383 (defun gnus-summary-set-bookmark (article) | |
| 9384 "Set a bookmark in current article." | |
| 9385 (interactive (list (gnus-summary-article-number))) | |
| 9386 (if (or (not (get-buffer gnus-article-buffer)) | |
| 9387 (not gnus-current-article) | |
| 9388 (not gnus-article-current) | |
| 9389 (not (equal gnus-newsgroup-name (car gnus-article-current)))) | |
| 9390 (error "No current article selected")) | |
| 9391 ;; Remove old bookmark, if one exists. | |
| 9392 (let ((old (assq article gnus-newsgroup-bookmarks))) | |
| 9393 (if old (setq gnus-newsgroup-bookmarks | |
| 9394 (delq old gnus-newsgroup-bookmarks)))) | |
| 9395 ;; Set the new bookmark, which is on the form | |
| 9396 ;; (article-number . line-number-in-body). | |
| 9397 (setq gnus-newsgroup-bookmarks | |
| 9398 (cons | |
| 9399 (cons article | |
| 9400 (save-excursion | |
| 9401 (set-buffer gnus-article-buffer) | |
| 9402 (count-lines | |
| 9403 (min (point) | |
| 9404 (save-excursion | |
| 9405 (goto-char (point-min)) | |
| 9406 (search-forward "\n\n" nil t) | |
| 9407 (point))) | |
| 9408 (point)))) | |
| 9409 gnus-newsgroup-bookmarks)) | |
| 9410 (gnus-message 6 "A bookmark has been added to the current article.")) | |
| 9411 | |
| 9412 (defun gnus-summary-remove-bookmark (article) | |
| 9413 "Remove the bookmark from the current article." | |
| 9414 (interactive (list (gnus-summary-article-number))) | |
| 9415 ;; Remove old bookmark, if one exists. | |
| 9416 (let ((old (assq article gnus-newsgroup-bookmarks))) | |
| 9417 (if old | |
| 9418 (progn | |
| 9419 (setq gnus-newsgroup-bookmarks | |
| 9420 (delq old gnus-newsgroup-bookmarks)) | |
| 9421 (gnus-message 6 "Removed bookmark.")) | |
| 9422 (gnus-message 6 "No bookmark in current article.")))) | |
| 9423 | |
| 9424 ;; Suggested by Daniel Quinlan <quinlan@best.com>. | |
| 9425 (defun gnus-summary-mark-as-dormant (n) | |
| 9426 "Mark N articles forward as dormant. | |
| 9427 If N is negative, mark backward instead. The difference between N and | |
| 9428 the actual number of articles marked is returned." | |
| 9429 (interactive "p") | |
| 9430 (gnus-summary-mark-forward n gnus-dormant-mark)) | |
| 9431 | |
| 9432 (defun gnus-summary-set-process-mark (article) | |
| 9433 "Set the process mark on ARTICLE and update the summary line." | |
| 9434 (setq gnus-newsgroup-processable (cons article gnus-newsgroup-processable)) | |
| 9435 (let ((buffer-read-only nil)) | |
| 9436 (if (gnus-summary-goto-subject article) | |
| 9437 (progn | |
| 9438 (gnus-summary-show-thread) | |
| 9439 (and (eq (gnus-summary-article-mark) gnus-dummy-mark) | |
| 9440 (forward-line 1)) | |
| 9441 (gnus-summary-update-mark gnus-process-mark 'replied) | |
| 9442 t)))) | |
| 9443 | |
| 9444 (defun gnus-summary-remove-process-mark (article) | |
| 9445 "Remove the process mark from ARTICLE and update the summary line." | |
| 9446 (setq gnus-newsgroup-processable (delq article gnus-newsgroup-processable)) | |
| 9447 (let ((buffer-read-only nil)) | |
| 9448 (if (gnus-summary-goto-subject article) | |
| 9449 (progn | |
| 9450 (gnus-summary-show-thread) | |
| 9451 (and (eq (gnus-summary-article-mark) gnus-dummy-mark) | |
| 9452 (forward-line 1)) | |
| 9453 (gnus-summary-update-mark ? 'replied) | |
| 9454 (if (memq article gnus-newsgroup-replied) | |
| 9455 (gnus-summary-update-mark gnus-replied-mark 'replied)) | |
| 9456 t)))) | |
| 9457 | |
| 9458 (defun gnus-summary-mark-forward (n &optional mark no-expire) | |
| 9459 "Mark N articles as read forwards. | |
| 9460 If N is negative, mark backwards instead. | |
| 9461 Mark with MARK. If MARK is ? , ?! or ??, articles will be | |
| 9462 marked as unread. | |
| 9463 The difference between N and the actual number of articles marked is | |
| 9464 returned." | |
| 9465 (interactive "p") | |
| 9466 (gnus-set-global-variables) | |
| 9467 (let ((backward (< n 0)) | |
| 9468 (gnus-summary-goto-unread | |
| 9469 (and gnus-summary-goto-unread | |
| 9470 (not (memq mark (list gnus-unread-mark | |
| 9471 gnus-ticked-mark gnus-dormant-mark))))) | |
| 9472 (n (abs n)) | |
| 9473 (mark (or mark gnus-del-mark))) | |
| 9474 (while (and (> n 0) | |
| 9475 (gnus-summary-mark-article nil mark no-expire) | |
| 9476 (zerop (gnus-summary-next-subject | |
| 9477 (if backward -1 1) gnus-summary-goto-unread t))) | |
| 9478 (setq n (1- n))) | |
| 9479 (if (/= 0 n) (gnus-message 7 "No more %sarticles" (if mark "" "unread "))) | |
| 9480 (gnus-summary-recenter) | |
| 9481 (gnus-summary-position-cursor) | |
| 9482 (gnus-set-mode-line 'summary) | |
| 9483 n)) | |
| 9484 | |
| 9485 (defun gnus-summary-mark-article-as-read (mark) | |
| 9486 "Mark the current article quickly as read with MARK." | |
| 9487 (let ((article (gnus-summary-article-number))) | |
| 9488 (setq gnus-newsgroup-unreads (delq article gnus-newsgroup-unreads)) | |
| 9489 (setq gnus-newsgroup-marked (delq article gnus-newsgroup-marked)) | |
| 9490 (setq gnus-newsgroup-dormant (delq article gnus-newsgroup-dormant)) | |
| 9491 (setq gnus-newsgroup-reads | |
| 9492 (cons (cons article mark) gnus-newsgroup-reads)) | |
| 9493 ;; Possibly remove from cache, if that is used. | |
| 9494 (and gnus-use-cache (gnus-cache-enter-remove-article article)) | |
| 9495 (and gnus-newsgroup-auto-expire | |
| 9496 (or (= mark gnus-killed-mark) (= mark gnus-del-mark) | |
| 9497 (= mark gnus-catchup-mark) (= mark gnus-low-score-mark) | |
| 9498 (= mark gnus-read-mark)) | |
| 9499 (progn | |
| 9500 (setq mark gnus-expirable-mark) | |
| 9501 (setq gnus-newsgroup-expirable | |
| 9502 (cons article gnus-newsgroup-expirable)))) | |
| 9503 (while (eq (gnus-summary-article-mark) gnus-dummy-mark) | |
| 9504 (forward-line 1)) | |
| 9505 ;; Fix the mark. | |
| 9506 (gnus-summary-update-mark mark 'unread) | |
| 9507 t)) | |
| 9508 | |
| 9509 (defun gnus-summary-mark-article-as-unread (mark) | |
| 9510 "Mark the current article quickly as unread with MARK." | |
| 9511 (let ((article (gnus-summary-article-number))) | |
| 9512 (or (memq article gnus-newsgroup-unreads) | |
| 9513 (setq gnus-newsgroup-unreads (cons article gnus-newsgroup-unreads))) | |
| 9514 (setq gnus-newsgroup-marked (delq article gnus-newsgroup-marked)) | |
| 9515 (setq gnus-newsgroup-dormant (delq article gnus-newsgroup-dormant)) | |
| 9516 (setq gnus-newsgroup-expirable (delq article gnus-newsgroup-expirable)) | |
| 9517 (setq gnus-newsgroup-reads | |
| 9518 (delq (assq article gnus-newsgroup-reads) | |
| 9519 gnus-newsgroup-reads)) | |
| 9520 (if (= mark gnus-ticked-mark) | |
| 9521 (setq gnus-newsgroup-marked (cons article gnus-newsgroup-marked))) | |
| 9522 (if (= mark gnus-dormant-mark) | |
| 9523 (setq gnus-newsgroup-dormant (cons article gnus-newsgroup-dormant))) | |
| 9524 | |
| 9525 ;; See whether the article is to be put in the cache. | |
| 9526 (and gnus-use-cache | |
| 9527 (vectorp (gnus-get-header-by-num article)) | |
| 9528 (save-excursion | |
| 9529 (gnus-cache-possibly-enter-article | |
| 9530 gnus-newsgroup-name article | |
| 9531 (gnus-get-header-by-num article) | |
| 9532 (= mark gnus-ticked-mark) | |
| 9533 (= mark gnus-dormant-mark) (= mark gnus-unread-mark)))) | |
| 9534 | |
| 9535 (while (eq (gnus-summary-article-mark) gnus-dummy-mark) | |
| 9536 (forward-line 1)) | |
| 9537 ;; Fix the mark. | |
| 9538 (gnus-summary-update-mark mark 'unread) | |
| 9539 t)) | |
| 9540 | |
| 9541 (defun gnus-summary-mark-article (&optional article mark no-expire) | |
| 9542 "Mark ARTICLE with MARK. MARK can be any character. | |
| 9543 Four MARK strings are reserved: `? ' (unread), `?!' (ticked), `??' | |
| 9544 (dormant) and `?E' (expirable). | |
| 9545 If MARK is nil, then the default character `?D' is used. | |
| 9546 If ARTICLE is nil, then the article on the current line will be | |
| 9547 marked." | |
| 9548 (and (stringp mark) | |
| 9549 (setq mark (aref mark 0))) | |
| 9550 ;; If no mark is given, then we check auto-expiring. | |
| 9551 (and (not no-expire) | |
| 9552 gnus-newsgroup-auto-expire | |
| 9553 (or (not mark) | |
| 9554 (and (numberp mark) | |
| 9555 (or (= mark gnus-killed-mark) (= mark gnus-del-mark) | |
| 9556 (= mark gnus-catchup-mark) (= mark gnus-low-score-mark) | |
| 9557 (= mark gnus-read-mark)))) | |
| 9558 (setq mark gnus-expirable-mark)) | |
| 9559 (let* ((mark (or mark gnus-del-mark)) | |
| 9560 (article (or article (gnus-summary-article-number)))) | |
| 9561 (or article (error "No article on current line")) | |
| 9562 (if (or (= mark gnus-unread-mark) | |
| 9563 (= mark gnus-ticked-mark) | |
| 9564 (= mark gnus-dormant-mark)) | |
| 9565 (gnus-mark-article-as-unread article mark) | |
| 9566 (gnus-mark-article-as-read article mark)) | |
| 9567 | |
| 9568 ;; See whether the article is to be put in the cache. | |
| 9569 (and gnus-use-cache | |
| 9570 (not (= mark gnus-canceled-mark)) | |
| 9571 (vectorp (gnus-get-header-by-num article)) | |
| 9572 (save-excursion | |
| 9573 (gnus-cache-possibly-enter-article | |
| 9574 gnus-newsgroup-name article | |
| 9575 (gnus-get-header-by-num article) | |
| 9576 (= mark gnus-ticked-mark) | |
| 9577 (= mark gnus-dormant-mark) (= mark gnus-unread-mark)))) | |
| 9578 | |
| 9579 (if (gnus-summary-goto-subject article) | |
| 9580 (let ((buffer-read-only nil)) | |
| 9581 (gnus-summary-show-thread) | |
| 9582 (and (eq (gnus-summary-article-mark) gnus-dummy-mark) | |
| 9583 (forward-line 1)) | |
| 9584 ;; Fix the mark. | |
| 9585 (gnus-summary-update-mark mark 'unread) | |
| 9586 t)))) | |
| 9587 | |
| 9588 (defun gnus-summary-update-mark (mark type) | |
| 9589 (beginning-of-line) | |
| 9590 (let ((forward (cdr (assq type gnus-summary-mark-positions))) | |
| 9591 (buffer-read-only nil) | |
| 9592 plist) | |
| 9593 (if (not forward) | |
| 9594 () | |
| 9595 (forward-char forward) | |
| 9596 (setq plist (text-properties-at (point))) | |
| 9597 (delete-char 1) | |
| 9598 (insert mark) | |
| 9599 (and plist (add-text-properties (1- (point)) (point) plist)) | |
| 9600 (and (eq type 'unread) | |
| 9601 (progn | |
| 9602 (add-text-properties (1- (point)) (point) (list 'gnus-mark mark)) | |
| 9603 (gnus-summary-update-line (eq mark gnus-unread-mark))))))) | |
| 9604 | |
| 9605 (defun gnus-mark-article-as-read (article &optional mark) | |
| 9606 "Enter ARTICLE in the pertinent lists and remove it from others." | |
| 9607 ;; Make the article expirable. | |
| 9608 (let ((mark (or mark gnus-del-mark))) | |
| 9609 (if (= mark gnus-expirable-mark) | |
| 9610 (setq gnus-newsgroup-expirable (cons article gnus-newsgroup-expirable)) | |
| 9611 (setq gnus-newsgroup-expirable (delq article gnus-newsgroup-expirable))) | |
| 9612 ;; Remove from unread and marked lists. | |
| 9613 (setq gnus-newsgroup-unreads (delq article gnus-newsgroup-unreads)) | |
| 9614 (setq gnus-newsgroup-marked (delq article gnus-newsgroup-marked)) | |
| 9615 (setq gnus-newsgroup-dormant (delq article gnus-newsgroup-dormant)) | |
| 9616 (setq gnus-newsgroup-reads | |
| 9617 (cons (cons article mark) gnus-newsgroup-reads)) | |
| 9618 ;; Possibly remove from cache, if that is used. | |
| 9619 (and gnus-use-cache (gnus-cache-enter-remove-article article)))) | |
| 9620 | |
| 9621 (defun gnus-mark-article-as-unread (article &optional mark) | |
| 9622 "Enter ARTICLE in the pertinent lists and remove it from others." | |
| 9623 (let ((mark (or mark gnus-ticked-mark))) | |
| 9624 ;; Add to unread list. | |
| 9625 (or (memq article gnus-newsgroup-unreads) | |
| 9626 (setq gnus-newsgroup-unreads (cons article gnus-newsgroup-unreads))) | |
| 9627 (setq gnus-newsgroup-marked (delq article gnus-newsgroup-marked)) | |
| 9628 (setq gnus-newsgroup-dormant (delq article gnus-newsgroup-dormant)) | |
| 9629 (setq gnus-newsgroup-expirable (delq article gnus-newsgroup-expirable)) | |
| 9630 (setq gnus-newsgroup-reads | |
| 9631 (delq (assq article gnus-newsgroup-reads) | |
| 9632 gnus-newsgroup-reads)) | |
| 9633 (if (= mark gnus-ticked-mark) | |
| 9634 (setq gnus-newsgroup-marked (cons article gnus-newsgroup-marked))) | |
| 9635 (if (= mark gnus-dormant-mark) | |
| 9636 (setq gnus-newsgroup-dormant (cons article gnus-newsgroup-dormant))))) | |
| 9637 | |
| 9638 (defalias 'gnus-summary-mark-as-unread-forward | |
| 9639 'gnus-summary-tick-article-forward) | |
| 9640 (make-obsolete 'gnus-summary-mark-as-unread-forward | |
| 9641 'gnus-summary-tick-article-forward) | |
| 9642 (defun gnus-summary-tick-article-forward (n) | |
| 9643 "Tick N articles forwards. | |
| 9644 If N is negative, tick backwards instead. | |
| 9645 The difference between N and the number of articles ticked is returned." | |
| 9646 (interactive "p") | |
| 9647 (gnus-summary-mark-forward n gnus-ticked-mark)) | |
| 9648 | |
| 9649 (defalias 'gnus-summary-mark-as-unread-backward | |
| 9650 'gnus-summary-tick-article-backward) | |
| 9651 (make-obsolete 'gnus-summary-mark-as-unread-backward | |
| 9652 'gnus-summary-tick-article-backward) | |
| 9653 (defun gnus-summary-tick-article-backward (n) | |
| 9654 "Tick N articles backwards. | |
| 9655 The difference between N and the number of articles ticked is returned." | |
| 9656 (interactive "p") | |
| 9657 (gnus-summary-mark-forward (- n) gnus-ticked-mark)) | |
| 9658 | |
| 9659 (defalias 'gnus-summary-mark-as-unread 'gnus-summary-tick-article) | |
| 9660 (make-obsolete 'gnus-summary-mark-as-unread 'gnus-summary-tick-article) | |
| 9661 (defun gnus-summary-tick-article (&optional article clear-mark) | |
| 9662 "Mark current article as unread. | |
| 9663 Optional 1st argument ARTICLE specifies article number to be marked as unread. | |
| 9664 Optional 2nd argument CLEAR-MARK remove any kinds of mark." | |
| 9665 (gnus-summary-mark-article article (if clear-mark gnus-unread-mark | |
| 9666 gnus-ticked-mark))) | |
| 9667 | |
| 9668 (defun gnus-summary-mark-as-read-forward (n) | |
| 9669 "Mark N articles as read forwards. | |
| 9670 If N is negative, mark backwards instead. | |
| 9671 The difference between N and the actual number of articles marked is | |
| 9672 returned." | |
| 9673 (interactive "p") | |
| 9674 (gnus-summary-mark-forward n gnus-del-mark t)) | |
| 9675 | |
| 9676 (defun gnus-summary-mark-as-read-backward (n) | |
| 9677 "Mark the N articles as read backwards. | |
| 9678 The difference between N and the actual number of articles marked is | |
| 9679 returned." | |
| 9680 (interactive "p") | |
| 9681 (gnus-summary-mark-forward (- n) gnus-del-mark t)) | |
| 9682 | |
| 9683 (defun gnus-summary-mark-as-read (&optional article mark) | |
| 9684 "Mark current article as read. | |
| 9685 ARTICLE specifies the article to be marked as read. | |
| 9686 MARK specifies a string to be inserted at the beginning of the line." | |
| 9687 (gnus-summary-mark-article article mark)) | |
| 9688 | |
| 9689 (defun gnus-summary-clear-mark-forward (n) | |
| 9690 "Clear marks from N articles forward. | |
| 9691 If N is negative, clear backward instead. | |
| 9692 The difference between N and the number of marks cleared is returned." | |
| 9693 (interactive "p") | |
| 9694 (gnus-summary-mark-forward n gnus-unread-mark)) | |
| 9695 | |
| 9696 (defun gnus-summary-clear-mark-backward (n) | |
| 9697 "Clear marks from N articles backward. | |
| 9698 The difference between N and the number of marks cleared is returned." | |
| 9699 (interactive "p") | |
| 9700 (gnus-summary-mark-forward (- n) gnus-unread-mark)) | |
| 9701 | |
| 9702 (defun gnus-summary-mark-unread-as-read () | |
| 9703 "Intended to be used by `gnus-summary-mark-article-hook'." | |
| 9704 (or (memq gnus-current-article gnus-newsgroup-marked) | |
| 9705 (memq gnus-current-article gnus-newsgroup-dormant) | |
| 9706 (memq gnus-current-article gnus-newsgroup-expirable) | |
| 9707 (gnus-summary-mark-article gnus-current-article gnus-read-mark))) | |
| 9708 | |
| 9709 (defun gnus-summary-mark-region-as-read (point mark all) | |
| 9710 "Mark all unread articles between point and mark as read. | |
| 9711 If given a prefix, mark all articles between point and mark as read, | |
| 9712 even ticked and dormant ones." | |
| 9713 (interactive "r\nP") | |
| 9714 (save-excursion | |
| 9715 (goto-char point) | |
| 9716 (beginning-of-line) | |
| 9717 (while (and | |
| 9718 (< (point) mark) | |
| 9719 (progn | |
| 9720 (and | |
| 9721 (or all | |
| 9722 (and | |
| 9723 (not (memq (gnus-summary-article-number) | |
| 9724 gnus-newsgroup-marked)) | |
| 9725 (not (memq (gnus-summary-article-number) | |
| 9726 gnus-newsgroup-dormant)))) | |
| 9727 (gnus-summary-mark-article | |
| 9728 (gnus-summary-article-number) gnus-del-mark)) | |
| 9729 t) | |
| 9730 (zerop (forward-line 1)))))) | |
| 9731 | |
| 9732 ;; Fix by Per Abrahamsen <amanda@iesd.auc.dk>. | |
| 9733 (defalias 'gnus-summary-delete-marked-as-read | |
| 9734 'gnus-summary-remove-lines-marked-as-read) | |
| 9735 (make-obsolete 'gnus-summary-delete-marked-as-read | |
| 9736 'gnus-summary-remove-lines-marked-as-read) | |
| 9737 (defun gnus-summary-remove-lines-marked-as-read () | |
| 9738 "Remove lines that are marked as read." | |
| 9739 (interactive) | |
| 9740 (gnus-summary-remove-lines-marked-with | |
| 9741 (concat (mapconcat | |
| 9742 (lambda (char) (char-to-string (symbol-value char))) | |
| 9743 '(gnus-del-mark gnus-read-mark gnus-ancient-mark | |
| 9744 gnus-killed-mark gnus-kill-file-mark | |
| 9745 gnus-low-score-mark gnus-expirable-mark | |
| 9746 gnus-canceled-mark gnus-catchup-mark) | |
| 9747 "")))) | |
| 9748 | |
| 9749 (defalias 'gnus-summary-delete-marked-with | |
| 9750 'gnus-summary-remove-lines-marked-with) | |
| 9751 (make-obsolete 'gnus-summary-delete-marked-with | |
| 9752 'gnus-summary-remove-lines-marked-with) | |
| 9753 ;; Rewrite by Daniel Quinlan <quinlan@best.com>. | |
| 9754 (defun gnus-summary-remove-lines-marked-with (marks) | |
| 9755 "Remove lines that are marked with MARKS (e.g. \"DK\")." | |
| 9756 (interactive "sMarks: ") | |
| 9757 ;; Fix by Sudish Joseph <joseph@cis.ohio-state.edu>. | |
| 9758 (gnus-set-global-variables) | |
| 9759 (let ((buffer-read-only nil) | |
| 9760 (orig-article (gnus-summary-article-number)) | |
| 9761 (marks (concat "^[" marks "]"))) | |
| 9762 (goto-char (point-min)) | |
| 9763 (if gnus-newsgroup-adaptive | |
| 9764 (gnus-score-remove-lines-adaptive marks) | |
| 9765 (while (re-search-forward marks nil t) | |
| 9766 (gnus-delete-line))) | |
| 9767 ;; If we use dummy roots, we have to do an additional sweep over | |
| 9768 ;; the buffer. | |
| 9769 (if (not (eq gnus-summary-make-false-root 'dummy)) | |
| 9770 () | |
| 9771 (goto-char (point-min)) | |
| 9772 (setq marks (concat "^[" (char-to-string gnus-dummy-mark) "]")) | |
| 9773 (while (re-search-forward marks nil t) | |
| 9774 (if (gnus-subject-equal | |
| 9775 (gnus-summary-subject-string) | |
| 9776 (progn | |
| 9777 (forward-line 1) | |
| 9778 (gnus-summary-subject-string))) | |
| 9779 () | |
| 9780 (forward-line -1) | |
| 9781 (gnus-delete-line)))) | |
| 9782 (or (zerop (buffer-size)) | |
| 9783 (gnus-summary-goto-subject orig-article) | |
| 9784 (if (eobp) | |
| 9785 (gnus-summary-prev-subject 1) | |
| 9786 (gnus-summary-position-cursor))))) | |
| 9787 | |
| 9788 (defun gnus-summary-expunge-below (&optional score) | |
| 9789 "Remove articles with score less than SCORE." | |
| 9790 (interactive "P") | |
| 9791 (gnus-set-global-variables) | |
| 9792 (setq score (if score | |
| 9793 (prefix-numeric-value score) | |
| 9794 (or gnus-summary-default-score 0))) | |
| 9795 (save-excursion | |
| 9796 (set-buffer gnus-summary-buffer) | |
| 9797 (goto-char (point-min)) | |
| 9798 (let ((buffer-read-only nil) | |
| 9799 beg) | |
| 9800 (while (not (eobp)) | |
| 9801 (if (< (gnus-summary-article-score) score) | |
| 9802 (progn | |
| 9803 (setq beg (point)) | |
| 9804 (forward-line 1) | |
| 9805 (delete-region beg (point))) | |
| 9806 (forward-line 1))) | |
| 9807 ;; Adjust point. | |
| 9808 (or (zerop (buffer-size)) | |
| 9809 (if (eobp) | |
| 9810 (gnus-summary-prev-subject 1) | |
| 9811 (gnus-summary-position-cursor)))))) | |
| 9812 | |
| 9813 (defun gnus-summary-mark-below (score mark) | |
| 9814 "Mark articles with score less than SCORE with MARK." | |
| 9815 (interactive "P\ncMark: ") | |
| 9816 (gnus-set-global-variables) | |
| 9817 (setq score (if score | |
| 9818 (prefix-numeric-value score) | |
| 9819 (or gnus-summary-default-score 0))) | |
| 9820 (save-excursion | |
| 9821 (set-buffer gnus-summary-buffer) | |
| 9822 (goto-char (point-min)) | |
| 9823 (while (not (eobp)) | |
| 9824 (and (< (gnus-summary-article-score) score) | |
| 9825 (gnus-summary-mark-article nil mark)) | |
| 9826 (forward-line 1)))) | |
| 9827 | |
| 9828 (defun gnus-summary-kill-below (&optional score) | |
| 9829 "Mark articles with score below SCORE as read." | |
| 9830 (interactive "P") | |
| 9831 (gnus-set-global-variables) | |
| 9832 (gnus-summary-mark-below score gnus-killed-mark)) | |
| 9833 | |
| 9834 (defun gnus-summary-clear-above (&optional score) | |
| 9835 "Clear all marks from articles with score above SCORE." | |
| 9836 (interactive "P") | |
| 9837 (gnus-set-global-variables) | |
| 9838 (gnus-summary-mark-above score gnus-unread-mark)) | |
| 9839 | |
| 9840 (defun gnus-summary-tick-above (&optional score) | |
| 9841 "Tick all articles with score above SCORE." | |
| 9842 (interactive "P") | |
| 9843 (gnus-set-global-variables) | |
| 9844 (gnus-summary-mark-above score gnus-ticked-mark)) | |
| 9845 | |
| 9846 (defun gnus-summary-mark-above (score mark) | |
| 9847 "Mark articles with score over SCORE with MARK." | |
| 9848 (interactive "P\ncMark: ") | |
| 9849 (gnus-set-global-variables) | |
| 9850 (setq score (if score | |
| 9851 (prefix-numeric-value score) | |
| 9852 (or gnus-summary-default-score 0))) | |
| 9853 (save-excursion | |
| 9854 (set-buffer gnus-summary-buffer) | |
| 9855 (goto-char (point-min)) | |
| 9856 (while (not (eobp)) | |
| 9857 (if (> (gnus-summary-article-score) score) | |
| 9858 (progn | |
| 9859 (gnus-summary-mark-article nil mark) | |
| 9860 (forward-line 1)) | |
| 9861 (forward-line 1))))) | |
| 9862 | |
| 9863 ;; Suggested by Daniel Quinlan <quinlan@best.com>. | |
| 9864 (defun gnus-summary-show-all-expunged () | |
| 9865 "Display all the hidden articles that were expunged for low scores." | |
| 9866 (interactive) | |
| 9867 (gnus-set-global-variables) | |
| 9868 (let ((buffer-read-only nil)) | |
| 9869 (let ((scored gnus-newsgroup-scored) | |
| 9870 headers h) | |
| 9871 (while scored | |
| 9872 (or (gnus-summary-goto-subject (car (car scored))) | |
| 9873 (and (setq h (gnus-get-header-by-num (car (car scored)))) | |
| 9874 (< (cdr (car scored)) gnus-summary-expunge-below) | |
| 9875 (setq headers (cons h headers)))) | |
| 9876 (setq scored (cdr scored))) | |
| 9877 (or headers (error "No expunged articles hidden.")) | |
| 9878 (goto-char (point-min)) | |
| 9879 (save-excursion | |
| 9880 (gnus-summary-update-lines | |
| 9881 (point) | |
| 9882 (progn | |
| 9883 (gnus-summary-prepare-unthreaded (nreverse headers)) | |
| 9884 (point))))) | |
| 9885 (goto-char (point-min)) | |
| 9886 (gnus-summary-position-cursor))) | |
| 9887 | |
| 9888 (defun gnus-summary-show-all-dormant () | |
| 9889 "Display all the hidden articles that are marked as dormant." | |
| 9890 (interactive) | |
| 9891 (gnus-set-global-variables) | |
| 9892 (let ((buffer-read-only nil)) | |
| 9893 (let ((dormant gnus-newsgroup-dormant) | |
| 9894 headers h) | |
| 9895 (while dormant | |
| 9896 (or (gnus-summary-goto-subject (car dormant)) | |
| 9897 (and (setq h (gnus-get-header-by-num (car dormant))) | |
| 9898 (setq headers (cons h headers)))) | |
| 9899 (setq dormant (cdr dormant))) | |
| 9900 (or headers (error "No dormant articles hidden.")) | |
| 9901 (goto-char (point-min)) | |
| 9902 (save-excursion | |
| 9903 (gnus-summary-update-lines | |
| 9904 (point) | |
| 9905 (progn | |
| 9906 (gnus-summary-prepare-unthreaded (nreverse headers)) | |
| 9907 (point))))) | |
| 9908 (goto-char (point-min)) | |
| 9909 (gnus-summary-position-cursor))) | |
| 9910 | |
| 9911 (defun gnus-summary-hide-all-dormant () | |
| 9912 "Hide all dormant articles." | |
| 9913 (interactive) | |
| 9914 (gnus-set-global-variables) | |
| 9915 (gnus-summary-remove-lines-marked-with (char-to-string gnus-dormant-mark)) | |
| 9916 (gnus-summary-position-cursor)) | |
| 9917 | |
| 9918 (defun gnus-summary-catchup (&optional all quietly to-here not-mark) | |
| 9919 "Mark all articles not marked as unread in this newsgroup as read. | |
| 9920 If prefix argument ALL is non-nil, all articles are marked as read. | |
| 9921 If QUIETLY is non-nil, no questions will be asked. | |
| 9922 If TO-HERE is non-nil, it should be a point in the buffer. All | |
| 9923 articles before this point will be marked as read. | |
| 9924 The number of articles marked as read is returned." | |
| 9925 (interactive "P") | |
| 9926 (gnus-set-global-variables) | |
| 9927 (prog1 | |
| 9928 (if (or quietly | |
| 9929 (not gnus-interactive-catchup) ;Without confirmation? | |
| 9930 gnus-expert-user | |
| 9931 (gnus-y-or-n-p | |
| 9932 (if all | |
| 9933 "Mark absolutely all articles as read? " | |
| 9934 "Mark all unread articles as read? "))) | |
| 9935 (if (and not-mark | |
| 9936 (not gnus-newsgroup-adaptive) | |
| 9937 (not gnus-newsgroup-auto-expire)) | |
| 9938 (progn | |
| 9939 (and all (setq gnus-newsgroup-marked nil | |
| 9940 gnus-newsgroup-dormant nil)) | |
| 9941 (setq gnus-newsgroup-unreads | |
| 9942 (append gnus-newsgroup-marked gnus-newsgroup-dormant))) | |
| 9943 ;; We actually mark all articles as canceled, which we | |
| 9944 ;; have to do when using auto-expiry or adaptive scoring. | |
| 9945 (gnus-summary-show-all-threads) | |
| 9946 (if (gnus-summary-first-subject (not all)) | |
| 9947 (while (and | |
| 9948 (if to-here (< (point) to-here) t) | |
| 9949 (gnus-summary-mark-article-as-read gnus-catchup-mark) | |
| 9950 (gnus-summary-search-subject nil (not all))))) | |
| 9951 (or to-here | |
| 9952 (setq gnus-newsgroup-unreads | |
| 9953 (append gnus-newsgroup-marked | |
| 9954 gnus-newsgroup-dormant))))) | |
| 9955 (let ((method (gnus-find-method-for-group gnus-newsgroup-name))) | |
| 9956 (if (and (not to-here) (eq 'nnvirtual (car method))) | |
| 9957 (nnvirtual-catchup-group | |
| 9958 (gnus-group-real-name gnus-newsgroup-name) (nth 1 method) all))) | |
| 9959 (gnus-summary-position-cursor))) | |
| 9960 | |
| 9961 (defun gnus-summary-catchup-to-here (&optional all) | |
| 9962 "Mark all unticked articles before the current one as read. | |
| 9963 If ALL is non-nil, also mark ticked and dormant articles as read." | |
| 9964 (interactive "P") | |
| 9965 (gnus-set-global-variables) | |
| 9966 (save-excursion | |
| 9967 (and (zerop (forward-line -1)) | |
| 9968 (progn | |
| 9969 (end-of-line) | |
| 9970 (gnus-summary-catchup all t (point)) | |
| 9971 (gnus-set-mode-line 'summary)))) | |
| 9972 (gnus-summary-position-cursor)) | |
| 9973 | |
| 9974 (defun gnus-summary-catchup-all (&optional quietly) | |
| 9975 "Mark all articles in this newsgroup as read." | |
| 9976 (interactive "P") | |
| 9977 (gnus-set-global-variables) | |
| 9978 (gnus-summary-catchup t quietly)) | |
| 9979 | |
| 9980 (defun gnus-summary-catchup-and-exit (&optional all quietly) | |
| 9981 "Mark all articles not marked as unread in this newsgroup as read, then exit. | |
| 9982 If prefix argument ALL is non-nil, all articles are marked as read." | |
| 9983 (interactive "P") | |
| 9984 (gnus-set-global-variables) | |
| 9985 (gnus-summary-catchup all quietly nil 'fast) | |
| 9986 ;; Select next newsgroup or exit. | |
| 9987 (if (and (eq gnus-auto-select-next 'quietly) | |
| 9988 (not (gnus-ephemeral-group-p gnus-newsgroup-name))) | |
| 9989 (gnus-summary-next-group nil) | |
| 9990 (gnus-summary-exit))) | |
| 9991 | |
| 9992 (defun gnus-summary-catchup-all-and-exit (&optional quietly) | |
| 9993 "Mark all articles in this newsgroup as read, and then exit." | |
| 9994 (interactive "P") | |
| 9995 (gnus-set-global-variables) | |
| 9996 (gnus-summary-catchup-and-exit t quietly)) | |
| 9997 | |
| 9998 ;; Suggested by "Arne Eofsson" <arne@hodgkin.mbi.ucla.edu>. | |
| 9999 (defun gnus-summary-catchup-and-goto-next-group (&optional all) | |
| 10000 "Mark all articles in this group as read and select the next group. | |
| 10001 If given a prefix, mark all articles, unread as well as ticked, as | |
| 10002 read." | |
| 10003 (interactive "P") | |
| 10004 (gnus-set-global-variables) | |
| 10005 (gnus-summary-catchup all) | |
| 10006 (gnus-summary-next-group)) | |
| 10007 | |
| 10008 ;; Thread-based commands. | |
| 10009 | |
| 10010 (defun gnus-summary-toggle-threads (&optional arg) | |
| 10011 "Toggle showing conversation threads. | |
| 10012 If ARG is positive number, turn showing conversation threads on." | |
| 10013 (interactive "P") | |
| 10014 (gnus-set-global-variables) | |
| 10015 (let ((current (or (gnus-summary-article-number) gnus-newsgroup-end))) | |
| 10016 (setq gnus-show-threads | |
| 10017 (if (null arg) (not gnus-show-threads) | |
| 10018 (> (prefix-numeric-value arg) 0))) | |
| 10019 (gnus-summary-prepare) | |
| 10020 (gnus-summary-goto-subject current) | |
| 10021 (gnus-summary-position-cursor))) | |
| 10022 | |
| 10023 (defun gnus-summary-show-all-threads () | |
| 10024 "Show all threads." | |
| 10025 (interactive) | |
| 10026 (gnus-set-global-variables) | |
| 10027 (save-excursion | |
| 10028 (let ((buffer-read-only nil)) | |
| 10029 (subst-char-in-region (point-min) (point-max) ?\^M ?\n t))) | |
| 10030 (gnus-summary-position-cursor)) | |
| 10031 | |
| 10032 (defun gnus-summary-show-thread () | |
| 10033 "Show thread subtrees. | |
| 10034 Returns nil if no thread was there to be shown." | |
| 10035 (interactive) | |
| 10036 (gnus-set-global-variables) | |
| 10037 (let ((buffer-read-only nil) | |
| 10038 (orig (prog1 (point) (gnus-summary-hide-thread))) | |
| 10039 ;; first goto end then to beg, to have point at beg after let | |
| 10040 (end (progn (end-of-line) (point))) | |
| 10041 (beg (progn (beginning-of-line) (point)))) | |
| 10042 (prog1 | |
| 10043 ;; Any hidden lines here? | |
| 10044 (search-forward "\r" end t) | |
| 10045 (subst-char-in-region beg end ?\^M ?\n t) | |
| 10046 (goto-char orig) | |
| 10047 (gnus-summary-position-cursor)))) | |
| 10048 | |
| 10049 (defun gnus-summary-hide-all-threads () | |
| 10050 "Hide all thread subtrees." | |
| 10051 (interactive) | |
| 10052 (gnus-set-global-variables) | |
| 10053 (save-excursion | |
| 10054 (goto-char (point-min)) | |
| 10055 (gnus-summary-hide-thread) | |
| 10056 (while (and (not (eobp)) (zerop (forward-line 1))) | |
| 10057 (gnus-summary-hide-thread))) | |
| 10058 (gnus-summary-position-cursor)) | |
| 10059 | |
| 10060 (defun gnus-summary-hide-thread () | |
| 10061 "Hide thread subtrees. | |
| 10062 Returns nil if no threads were there to be hidden." | |
| 10063 (interactive) | |
| 10064 (gnus-set-global-variables) | |
| 10065 (let ((buffer-read-only nil) | |
| 10066 (start (point)) | |
| 10067 (level (gnus-summary-thread-level)) | |
| 10068 (end (point))) | |
| 10069 ;; Go forward until either the buffer ends or the subthread | |
| 10070 ;; ends. | |
| 10071 (if (eobp) | |
| 10072 () | |
| 10073 (while (and (zerop (forward-line 1)) | |
| 10074 (> (gnus-summary-thread-level) level)) | |
| 10075 (setq end (point))) | |
| 10076 (prog1 | |
| 10077 (save-excursion | |
| 10078 (goto-char end) | |
| 10079 (search-backward "\n" start t)) | |
| 10080 (subst-char-in-region start end ?\n ?\^M t) | |
| 10081 (forward-line -1) | |
| 10082 (gnus-summary-position-cursor))))) | |
| 10083 | |
| 10084 (defun gnus-summary-go-to-next-thread (&optional previous) | |
| 10085 "Go to the same level (or less) next thread. | |
| 10086 If PREVIOUS is non-nil, go to previous thread instead. | |
| 10087 Return the article number moved to, or nil if moving was impossible." | |
| 10088 (let ((level (gnus-summary-thread-level)) | |
| 10089 (article (gnus-summary-article-number))) | |
| 10090 (if previous | |
| 10091 (while (and (zerop (forward-line -1)) | |
| 10092 (> (gnus-summary-thread-level) level))) | |
| 10093 (while (and (save-excursion | |
| 10094 (forward-line 1) | |
| 10095 (not (eobp))) | |
| 10096 (zerop (forward-line 1)) | |
| 10097 (> (gnus-summary-thread-level) level)))) | |
| 10098 (gnus-summary-recenter) | |
| 10099 (gnus-summary-position-cursor) | |
| 10100 (let ((oart (gnus-summary-article-number))) | |
| 10101 (and (/= oart article) oart)))) | |
| 10102 | |
| 10103 (defun gnus-summary-next-thread (n) | |
| 10104 "Go to the same level next N'th thread. | |
| 10105 If N is negative, search backward instead. | |
| 10106 Returns the difference between N and the number of skips actually | |
| 10107 done." | |
| 10108 (interactive "p") | |
| 10109 (gnus-set-global-variables) | |
| 10110 (let ((backward (< n 0)) | |
| 10111 (n (abs n))) | |
| 10112 (while (and (> n 0) | |
| 10113 (gnus-summary-go-to-next-thread backward)) | |
| 10114 (setq n (1- n))) | |
| 10115 (gnus-summary-position-cursor) | |
| 10116 (if (/= 0 n) (gnus-message 7 "No more threads")) | |
| 10117 n)) | |
| 10118 | |
| 10119 (defun gnus-summary-prev-thread (n) | |
| 10120 "Go to the same level previous N'th thread. | |
| 10121 Returns the difference between N and the number of skips actually | |
| 10122 done." | |
| 10123 (interactive "p") | |
| 10124 (gnus-set-global-variables) | |
| 10125 (gnus-summary-next-thread (- n))) | |
| 10126 | |
| 10127 (defun gnus-summary-go-down-thread (&optional same) | |
| 10128 "Go down one level in the current thread. | |
| 10129 If SAME is non-nil, also move to articles of the same level." | |
| 10130 (let ((level (gnus-summary-thread-level)) | |
| 10131 (start (point))) | |
| 10132 (if (and (zerop (forward-line 1)) | |
| 10133 (> (gnus-summary-thread-level) level)) | |
| 10134 t | |
| 10135 (goto-char start) | |
| 10136 nil))) | |
| 10137 | |
| 10138 (defun gnus-summary-go-up-thread () | |
| 10139 "Go up one level in the current thread." | |
| 10140 (let ((level (gnus-summary-thread-level)) | |
| 10141 (start (point))) | |
| 10142 (while (and (zerop (forward-line -1)) | |
| 10143 (>= (gnus-summary-thread-level) level))) | |
| 10144 (if (>= (gnus-summary-thread-level) level) | |
| 10145 (progn | |
| 10146 (goto-char start) | |
| 10147 nil) | |
| 10148 t))) | |
| 10149 | |
| 10150 (defun gnus-summary-down-thread (n) | |
| 10151 "Go down thread N steps. | |
| 10152 If N is negative, go up instead. | |
| 10153 Returns the difference between N and how many steps down that were | |
| 10154 taken." | |
| 10155 (interactive "p") | |
| 10156 (gnus-set-global-variables) | |
| 10157 (let ((up (< n 0)) | |
| 10158 (n (abs n))) | |
| 10159 (while (and (> n 0) | |
| 10160 (if up (gnus-summary-go-up-thread) | |
| 10161 (gnus-summary-go-down-thread))) | |
| 10162 (setq n (1- n))) | |
| 10163 (gnus-summary-position-cursor) | |
| 10164 (if (/= 0 n) (gnus-message 7 "Can't go further")) | |
| 10165 n)) | |
| 10166 | |
| 10167 (defun gnus-summary-up-thread (n) | |
| 10168 "Go up thread N steps. | |
| 10169 If N is negative, go up instead. | |
| 10170 Returns the difference between N and how many steps down that were | |
| 10171 taken." | |
| 10172 (interactive "p") | |
| 10173 (gnus-set-global-variables) | |
| 10174 (gnus-summary-down-thread (- n))) | |
| 10175 | |
| 10176 (defun gnus-summary-kill-thread (&optional unmark) | |
| 10177 "Mark articles under current thread as read. | |
| 10178 If the prefix argument is positive, remove any kinds of marks. | |
| 10179 If the prefix argument is negative, tick articles instead." | |
| 10180 (interactive "P") | |
| 10181 (gnus-set-global-variables) | |
| 10182 (if unmark | |
| 10183 (setq unmark (prefix-numeric-value unmark))) | |
| 10184 (let ((killing t) | |
| 10185 (level (gnus-summary-thread-level))) | |
| 10186 (save-excursion | |
| 10187 ;; Expand the thread. | |
| 10188 (gnus-summary-show-thread) | |
| 10189 (while killing | |
| 10190 ;; Mark the article... | |
| 10191 (cond ((null unmark) (gnus-summary-mark-article-as-read | |
| 10192 gnus-killed-mark)) | |
| 10193 ((> unmark 0) (gnus-summary-mark-article-as-unread | |
| 10194 gnus-unread-mark)) | |
| 10195 (t (gnus-summary-mark-article-as-unread gnus-ticked-mark))) | |
| 10196 ;; ...and go forward until either the buffer ends or the subtree | |
| 10197 ;; ends. | |
| 10198 (if (not (and (zerop (forward-line 1)) | |
| 10199 (> (gnus-summary-thread-level) level))) | |
| 10200 (setq killing nil)))) | |
| 10201 ;; Hide killed subtrees. | |
| 10202 (and (null unmark) | |
| 10203 gnus-thread-hide-killed | |
| 10204 (gnus-summary-hide-thread)) | |
| 10205 ;; If marked as read, go to next unread subject. | |
| 10206 (if (null unmark) | |
| 10207 ;; Go to next unread subject. | |
| 10208 (gnus-summary-next-subject 1 t))) | |
| 10209 (gnus-set-mode-line 'summary)) | |
| 10210 | |
| 10211 ;; Summary sorting commands | |
| 10212 | |
| 10213 (defun gnus-summary-sort-by-number (&optional reverse) | |
| 10214 "Sort summary buffer by article number. | |
| 10215 Argument REVERSE means reverse order." | |
| 10216 (interactive "P") | |
| 10217 (gnus-set-global-variables) | |
| 10218 (gnus-summary-sort | |
| 10219 ;; `gnus-summary-article-number' is a macro, and `sort-subr' wants | |
| 10220 ;; a function, so we wrap it. | |
| 10221 (cons (lambda () (gnus-summary-article-number)) | |
| 10222 'gnus-thread-sort-by-number) reverse)) | |
| 10223 | |
| 10224 (defun gnus-summary-sort-by-author (&optional reverse) | |
| 10225 "Sort summary buffer by author name alphabetically. | |
| 10226 If case-fold-search is non-nil, case of letters is ignored. | |
| 10227 Argument REVERSE means reverse order." | |
| 10228 (interactive "P") | |
| 10229 (gnus-set-global-variables) | |
| 10230 (gnus-summary-sort | |
| 10231 (cons | |
| 10232 (lambda () | |
| 10233 (let* ((header (gnus-get-header-by-num (gnus-summary-article-number))) | |
| 10234 (extract (funcall | |
| 10235 gnus-extract-address-components | |
| 10236 (mail-header-from header)))) | |
| 10237 (concat (or (car extract) (cdr extract)) | |
| 10238 "\r" (int-to-string (mail-header-number header)) | |
| 10239 "\r" (mail-header-subject header)))) | |
| 10240 'gnus-thread-sort-by-author) | |
| 10241 reverse)) | |
| 10242 | |
| 10243 (defun gnus-summary-sort-by-subject (&optional reverse) | |
| 10244 "Sort summary buffer by subject alphabetically. `Re:'s are ignored. | |
| 10245 If case-fold-search is non-nil, case of letters is ignored. | |
| 10246 Argument REVERSE means reverse order." | |
| 10247 (interactive "P") | |
| 10248 (gnus-set-global-variables) | |
| 10249 (gnus-summary-sort | |
| 10250 (cons | |
| 10251 (lambda () | |
| 10252 (let* ((header (gnus-get-header-by-num (gnus-summary-article-number))) | |
| 10253 (extract (funcall | |
| 10254 gnus-extract-address-components | |
| 10255 (mail-header-from header)))) | |
| 10256 (concat | |
| 10257 (downcase (gnus-simplify-subject (gnus-summary-subject-string) t)) | |
| 10258 "\r" (int-to-string (mail-header-number header)) | |
| 10259 "\r" (or (car extract) (cdr extract))))) | |
| 10260 'gnus-thread-sort-by-subject) | |
| 10261 reverse)) | |
| 10262 | |
| 10263 (defun gnus-summary-sort-by-date (&optional reverse) | |
| 10264 "Sort summary buffer by date. | |
| 10265 Argument REVERSE means reverse order." | |
| 10266 (interactive "P") | |
| 10267 (gnus-set-global-variables) | |
| 10268 (gnus-summary-sort | |
| 10269 (cons | |
| 10270 (lambda () | |
| 10271 (gnus-sortable-date | |
| 10272 (mail-header-date | |
| 10273 (gnus-get-header-by-num (gnus-summary-article-number))))) | |
| 10274 'gnus-thread-sort-by-date) | |
| 10275 reverse)) | |
| 10276 | |
| 10277 (defun gnus-summary-sort-by-score (&optional reverse) | |
| 10278 "Sort summary buffer by score. | |
| 10279 Argument REVERSE means reverse order." | |
| 10280 (interactive "P") | |
| 10281 (gnus-set-global-variables) | |
| 10282 (gnus-summary-sort | |
| 10283 (cons (lambda () (gnus-summary-article-score)) | |
| 10284 'gnus-thread-sort-by-score) | |
| 10285 (not reverse))) | |
| 10286 | |
| 10287 (defvar gnus-summary-already-sorted nil) | |
| 10288 (defun gnus-summary-sort (predicate reverse) | |
| 10289 ;; Sort summary buffer by PREDICATE. REVERSE means reverse order. | |
| 10290 (if gnus-summary-already-sorted | |
| 10291 () | |
| 10292 (let (buffer-read-only) | |
| 10293 (if (not gnus-show-threads) | |
| 10294 ;; We do untreaded sorting... | |
| 10295 (progn | |
| 10296 (goto-char (point-min)) | |
| 10297 (sort-subr reverse 'forward-line 'end-of-line (car predicate))) | |
| 10298 ;; ... or we do threaded sorting. | |
| 10299 (let ((gnus-thread-sort-functions (list (cdr predicate))) | |
| 10300 (gnus-summary-prepare-hook nil) | |
| 10301 (gnus-summary-already-sorted nil)) | |
| 10302 ;; We do that by simply regenerating the threads. | |
| 10303 (gnus-summary-prepare) | |
| 10304 (and gnus-show-threads | |
| 10305 gnus-thread-hide-subtree | |
| 10306 (gnus-summary-hide-all-threads)) | |
| 10307 ;; If in async mode, we send some info to the backend. | |
| 10308 (and gnus-newsgroup-async | |
| 10309 (setq gnus-newsgroup-threads (nreverse gnus-newsgroup-threads)) | |
| 10310 (gnus-request-asynchronous | |
| 10311 gnus-newsgroup-name | |
| 10312 (if (and gnus-asynchronous-article-function | |
| 10313 (fboundp gnus-asynchronous-article-function)) | |
| 10314 (funcall gnus-asynchronous-article-function | |
| 10315 gnus-newsgroup-threads) | |
| 10316 gnus-newsgroup-threads)))))))) | |
| 10317 | |
| 10318 | |
| 10319 (defun gnus-sortable-date (date) | |
| 10320 "Make sortable string by string-lessp from DATE. | |
| 10321 Timezone package is used." | |
| 10322 (let* ((date (timezone-fix-time date nil nil)) ;[Y M D H M S] | |
| 10323 (year (aref date 0)) | |
| 10324 (month (aref date 1)) | |
| 10325 (day (aref date 2))) | |
| 10326 (timezone-make-sortable-date | |
| 10327 year month day | |
| 10328 (timezone-make-time-string | |
| 10329 (aref date 3) (aref date 4) (aref date 5))))) | |
| 10330 | |
| 10331 | |
| 10332 ;; Summary saving commands. | |
| 10333 | |
| 10334 (defun gnus-summary-save-article (&optional n) | |
| 10335 "Save the current article using the default saver function. | |
| 10336 If N is a positive number, save the N next articles. | |
| 10337 If N is a negative number, save the N previous articles. | |
| 10338 If N is nil and any articles have been marked with the process mark, | |
| 10339 save those articles instead. | |
| 10340 The variable `gnus-default-article-saver' specifies the saver function." | |
| 10341 (interactive "P") | |
| 10342 (gnus-set-global-variables) | |
| 10343 (let ((articles (gnus-summary-work-articles n))) | |
| 10344 (while articles | |
| 10345 (let ((header (gnus-get-header-by-num (car articles)))) | |
| 10346 (if (vectorp header) | |
| 10347 (progn | |
| 10348 (save-window-excursion | |
| 10349 (gnus-summary-select-article t nil nil (car articles))) | |
| 10350 (or gnus-save-all-headers | |
| 10351 (gnus-article-hide-headers t)) | |
| 10352 ;; Remove any X-Gnus lines. | |
| 10353 (save-excursion | |
| 10354 (save-restriction | |
| 10355 (set-buffer gnus-article-buffer) | |
| 10356 (let ((buffer-read-only nil)) | |
| 10357 (goto-char (point-min)) | |
| 10358 (narrow-to-region (point) (or (search-forward "\n\n" nil t) | |
| 10359 (point-max))) | |
| 10360 (while (re-search-forward "^X-Gnus" nil t) | |
| 10361 (beginning-of-line) | |
| 10362 (delete-region (point) | |
| 10363 (progn (forward-line 1) (point)))) | |
| 10364 (widen)))) | |
| 10365 (save-window-excursion | |
| 10366 (if gnus-default-article-saver | |
| 10367 (funcall gnus-default-article-saver) | |
| 10368 (error "No default saver is defined.")))) | |
| 10369 (if (assq 'name header) | |
| 10370 (gnus-copy-file (cdr (assq 'name header))) | |
| 10371 (gnus-message 1 "Article %d is unsaveable" (car articles))))) | |
| 10372 (gnus-summary-remove-process-mark (car articles)) | |
| 10373 (setq articles (cdr articles))) | |
| 10374 (gnus-summary-position-cursor) | |
| 10375 n)) | |
| 10376 | |
| 10377 (defun gnus-summary-pipe-output (&optional arg) | |
| 10378 "Pipe the current article to a subprocess. | |
| 10379 If N is a positive number, pipe the N next articles. | |
| 10380 If N is a negative number, pipe the N previous articles. | |
| 10381 If N is nil and any articles have been marked with the process mark, | |
| 10382 pipe those articles instead." | |
| 10383 (interactive "P") | |
| 10384 (gnus-set-global-variables) | |
| 10385 (let ((gnus-default-article-saver 'gnus-summary-save-in-pipe)) | |
| 10386 (gnus-summary-save-article arg))) | |
| 10387 | |
| 10388 (defun gnus-summary-save-article-mail (&optional arg) | |
| 10389 "Append the current article to an mail file. | |
| 10390 If N is a positive number, save the N next articles. | |
| 10391 If N is a negative number, save the N previous articles. | |
| 10392 If N is nil and any articles have been marked with the process mark, | |
| 10393 save those articles instead." | |
| 10394 (interactive "P") | |
| 10395 (gnus-set-global-variables) | |
| 10396 (let ((gnus-default-article-saver 'gnus-summary-save-in-mail)) | |
| 10397 (gnus-summary-save-article arg))) | |
| 10398 | |
| 10399 (defun gnus-summary-save-article-rmail (&optional arg) | |
| 10400 "Append the current article to an rmail file. | |
| 10401 If N is a positive number, save the N next articles. | |
| 10402 If N is a negative number, save the N previous articles. | |
| 10403 If N is nil and any articles have been marked with the process mark, | |
| 10404 save those articles instead." | |
| 10405 (interactive "P") | |
| 10406 (gnus-set-global-variables) | |
| 10407 (let ((gnus-default-article-saver 'gnus-summary-save-in-rmail)) | |
| 10408 (gnus-summary-save-article arg))) | |
| 10409 | |
| 10410 (defun gnus-summary-save-article-file (&optional arg) | |
| 10411 "Append the current article to a file. | |
| 10412 If N is a positive number, save the N next articles. | |
| 10413 If N is a negative number, save the N previous articles. | |
| 10414 If N is nil and any articles have been marked with the process mark, | |
| 10415 save those articles instead." | |
| 10416 (interactive "P") | |
| 10417 (gnus-set-global-variables) | |
| 10418 (let ((gnus-default-article-saver 'gnus-summary-save-in-file)) | |
| 10419 (gnus-summary-save-article arg))) | |
| 10420 | |
| 10421 (defun gnus-read-save-file-name (prompt default-name) | |
| 10422 (let ((methods gnus-split-methods) | |
| 10423 split-name) | |
| 10424 (if (not gnus-split-methods) | |
| 10425 () | |
| 10426 (save-excursion | |
| 10427 (set-buffer gnus-article-buffer) | |
| 10428 (gnus-narrow-to-headers) | |
| 10429 (while methods | |
| 10430 (goto-char (point-min)) | |
| 10431 (and (condition-case () | |
| 10432 (re-search-forward (car (car methods)) nil t) | |
| 10433 (error nil)) | |
| 10434 (setq split-name (cons (nth 1 (car methods)) split-name))) | |
| 10435 (setq methods (cdr methods))) | |
| 10436 (widen))) | |
| 10437 (cond ((null split-name) | |
| 10438 (read-file-name | |
| 10439 (concat prompt " (default " | |
| 10440 (file-name-nondirectory default-name) ") ") | |
| 10441 (file-name-directory default-name) | |
| 10442 default-name)) | |
| 10443 ((= 1 (length split-name)) | |
| 10444 (read-file-name | |
| 10445 (concat prompt " (default " (car split-name) ") ") | |
| 10446 gnus-article-save-directory | |
| 10447 (concat gnus-article-save-directory (car split-name)))) | |
| 10448 (t | |
| 10449 (setq split-name (mapcar (lambda (el) (list el)) | |
| 10450 (nreverse split-name))) | |
| 10451 (let ((result (completing-read | |
| 10452 (concat prompt " ") | |
| 10453 split-name nil nil))) | |
| 10454 (concat gnus-article-save-directory | |
| 10455 (if (string= result "") | |
| 10456 (car (car split-name)) | |
| 10457 result))))))) | |
| 10458 | |
| 10459 (defun gnus-summary-save-in-rmail (&optional filename) | |
| 10460 "Append this article to Rmail file. | |
| 10461 Optional argument FILENAME specifies file name. | |
| 10462 Directory to save to is default to `gnus-article-save-directory' which | |
| 10463 is initialized from the SAVEDIR environment variable." | |
| 10464 (interactive) | |
| 10465 (gnus-set-global-variables) | |
| 10466 (let ((default-name | |
| 10467 (funcall gnus-rmail-save-name gnus-newsgroup-name | |
| 10468 gnus-current-headers gnus-newsgroup-last-rmail))) | |
| 10469 (or filename | |
| 10470 (setq filename (gnus-read-save-file-name | |
| 10471 "Save in rmail file:" default-name))) | |
| 10472 (gnus-make-directory (file-name-directory filename)) | |
| 10473 (gnus-eval-in-buffer-window | |
| 10474 gnus-article-buffer | |
| 10475 (save-excursion | |
| 10476 (save-restriction | |
| 10477 (widen) | |
| 10478 (gnus-output-to-rmail filename)))) | |
| 10479 ;; Remember the directory name to save articles | |
| 10480 (setq gnus-newsgroup-last-rmail filename))) | |
| 10481 | |
| 10482 (defun gnus-summary-save-in-mail (&optional filename) | |
| 10483 "Append this article to Unix mail file. | |
| 10484 Optional argument FILENAME specifies file name. | |
| 10485 Directory to save to is default to `gnus-article-save-directory' which | |
| 10486 is initialized from the SAVEDIR environment variable." | |
| 10487 (interactive) | |
| 10488 (gnus-set-global-variables) | |
| 10489 (let ((default-name | |
| 10490 (funcall gnus-mail-save-name gnus-newsgroup-name | |
| 10491 gnus-current-headers gnus-newsgroup-last-mail))) | |
| 10492 (or filename | |
| 10493 (setq filename (gnus-read-save-file-name | |
| 10494 "Save in Unix mail file:" default-name))) | |
| 10495 (setq filename | |
| 10496 (expand-file-name filename | |
| 10497 (and default-name | |
| 10498 (file-name-directory default-name)))) | |
| 10499 (gnus-make-directory (file-name-directory filename)) | |
| 10500 (gnus-eval-in-buffer-window | |
| 10501 gnus-article-buffer | |
| 10502 (save-excursion | |
| 10503 (save-restriction | |
| 10504 (widen) | |
| 10505 (if (and (file-readable-p filename) (mail-file-babyl-p filename)) | |
| 10506 (gnus-output-to-rmail filename) | |
| 10507 (rmail-output filename 1 t t))))) | |
| 10508 ;; Remember the directory name to save articles. | |
| 10509 (setq gnus-newsgroup-last-mail filename))) | |
| 10510 | |
| 10511 (defun gnus-summary-save-in-file (&optional filename) | |
| 10512 "Append this article to file. | |
| 10513 Optional argument FILENAME specifies file name. | |
| 10514 Directory to save to is default to `gnus-article-save-directory' which | |
| 10515 is initialized from the SAVEDIR environment variable." | |
| 10516 (interactive) | |
| 10517 (gnus-set-global-variables) | |
| 10518 (let ((default-name | |
| 10519 (funcall gnus-file-save-name gnus-newsgroup-name | |
| 10520 gnus-current-headers gnus-newsgroup-last-file))) | |
| 10521 (or filename | |
| 10522 (setq filename (gnus-read-save-file-name | |
| 10523 "Save in file:" default-name))) | |
| 10524 (gnus-make-directory (file-name-directory filename)) | |
| 10525 (gnus-eval-in-buffer-window | |
| 10526 gnus-article-buffer | |
| 10527 (save-excursion | |
| 10528 (save-restriction | |
| 10529 (widen) | |
| 10530 (gnus-output-to-file filename)))) | |
| 10531 ;; Remember the directory name to save articles. | |
| 10532 (setq gnus-newsgroup-last-file filename))) | |
| 10533 | |
| 10534 (defun gnus-summary-save-in-pipe (&optional command) | |
| 10535 "Pipe this article to subprocess." | |
| 10536 (interactive) | |
| 10537 (gnus-set-global-variables) | |
| 10538 (let ((command (read-string "Shell command on article: " | |
| 10539 gnus-last-shell-command))) | |
| 10540 (if (string-equal command "") | |
| 10541 (setq command gnus-last-shell-command)) | |
| 10542 (gnus-eval-in-buffer-window | |
| 10543 gnus-article-buffer | |
| 10544 (save-restriction | |
| 10545 (widen) | |
| 10546 (shell-command-on-region (point-min) (point-max) command nil))) | |
| 10547 (setq gnus-last-shell-command command))) | |
| 10548 | |
| 10549 ;; Summary extract commands | |
| 10550 | |
| 10551 (defun gnus-summary-insert-pseudos (pslist &optional not-view) | |
| 10552 (let ((buffer-read-only nil) | |
| 10553 (article (gnus-summary-article-number)) | |
| 10554 b) | |
| 10555 (or (gnus-summary-goto-subject article) | |
| 10556 (error (format "No such article: %d" article))) | |
| 10557 (gnus-summary-position-cursor) | |
| 10558 ;; If all commands are to be bunched up on one line, we collect | |
| 10559 ;; them here. | |
| 10560 (if gnus-view-pseudos-separately | |
| 10561 () | |
| 10562 (let ((ps (setq pslist (sort pslist 'gnus-pseudos<))) | |
| 10563 files action) | |
| 10564 (while ps | |
| 10565 (setq action (cdr (assq 'action (car ps)))) | |
| 10566 (setq files (list (cdr (assq 'name (car ps))))) | |
| 10567 (while (and ps (cdr ps) | |
| 10568 (string= (or action "1") | |
| 10569 (or (cdr (assq 'action (car (cdr ps)))) "2"))) | |
| 10570 (setq files (cons (cdr (assq 'name (car (cdr ps)))) files)) | |
| 10571 (setcdr ps (cdr (cdr ps)))) | |
| 10572 (if (not files) | |
| 10573 () | |
| 10574 (if (not (string-match "%s" action)) | |
| 10575 (setq files (cons " " files))) | |
| 10576 (setq files (cons " " files)) | |
| 10577 (and (assq 'execute (car ps)) | |
| 10578 (setcdr (assq 'execute (car ps)) | |
| 10579 (funcall (if (string-match "%s" action) | |
| 10580 'format 'concat) | |
| 10581 action | |
| 10582 (mapconcat (lambda (f) f) files " "))))) | |
| 10583 (setq ps (cdr ps))))) | |
| 10584 (if (and gnus-view-pseudos (not not-view)) | |
| 10585 (while pslist | |
| 10586 (and (assq 'execute (car pslist)) | |
| 10587 (gnus-execute-command (cdr (assq 'execute (car pslist))) | |
| 10588 (eq gnus-view-pseudos 'not-confirm))) | |
| 10589 (setq pslist (cdr pslist))) | |
| 10590 (save-excursion | |
| 10591 (while pslist | |
| 10592 (gnus-summary-goto-subject (or (cdr (assq 'article (car pslist))) | |
| 10593 (gnus-summary-article-number))) | |
| 10594 (forward-line 1) | |
| 10595 (setq b (point)) | |
| 10596 (insert " " (file-name-nondirectory | |
| 10597 (cdr (assq 'name (car pslist)))) | |
| 10598 ": " (or (cdr (assq 'execute (car pslist))) "") "\n") | |
| 10599 (add-text-properties | |
| 10600 b (1+ b) (list 'gnus-number gnus-reffed-article-number | |
| 10601 'gnus-mark gnus-unread-mark | |
| 10602 'gnus-level 0 | |
| 10603 'gnus-pseudo (car pslist))) | |
| 10604 (forward-line -1) | |
| 10605 (gnus-sethash (int-to-string gnus-reffed-article-number) | |
| 10606 (car pslist) gnus-newsgroup-headers-hashtb-by-number) | |
| 10607 (setq gnus-newsgroup-unreads | |
| 10608 (cons gnus-reffed-article-number gnus-newsgroup-unreads)) | |
| 10609 (setq gnus-reffed-article-number (1- gnus-reffed-article-number)) | |
| 10610 (setq pslist (cdr pslist))))))) | |
| 10611 | |
| 10612 (defun gnus-pseudos< (p1 p2) | |
| 10613 (let ((c1 (cdr (assq 'action p1))) | |
| 10614 (c2 (cdr (assq 'action p2)))) | |
| 10615 (and c1 c2 (string< c1 c2)))) | |
| 10616 | |
| 10617 (defun gnus-request-pseudo-article (props) | |
| 10618 (cond ((assq 'execute props) | |
| 10619 (gnus-execute-command (cdr (assq 'execute props))))) | |
| 10620 (let ((gnus-current-article (gnus-summary-article-number))) | |
| 10621 (run-hooks 'gnus-mark-article-hook))) | |
| 10622 | |
| 10623 (defun gnus-execute-command (command &optional automatic) | |
| 10624 (save-excursion | |
| 10625 (gnus-article-setup-buffer) | |
| 10626 (set-buffer gnus-article-buffer) | |
| 10627 (let ((command (if automatic command (read-string "Command: " command))) | |
| 10628 (buffer-read-only nil)) | |
| 10629 (erase-buffer) | |
| 10630 (insert "$ " command "\n\n") | |
| 10631 (if gnus-view-pseudo-asynchronously | |
| 10632 (start-process "gnus-execute" nil "sh" "-c" command) | |
| 10633 (call-process "sh" nil t nil "-c" command))))) | |
| 10634 | |
| 10635 (defun gnus-copy-file (file &optional to) | |
| 10636 "Copy FILE to TO." | |
| 10637 (interactive | |
| 10638 (list (read-file-name "Copy file: " default-directory) | |
| 10639 (read-file-name "Copy file to: " default-directory))) | |
| 10640 (gnus-set-global-variables) | |
| 10641 (or to (setq to (read-file-name "Copy file to: " default-directory))) | |
| 10642 (and (file-directory-p to) | |
| 10643 (setq to (concat (file-name-as-directory to) | |
| 10644 (file-name-nondirectory file)))) | |
| 10645 (copy-file file to)) | |
| 10646 | |
| 10647 ;; Summary kill commands. | |
| 10648 | |
| 10649 (defun gnus-summary-edit-global-kill (article) | |
| 10650 "Edit the \"global\" kill file." | |
| 10651 (interactive (list (gnus-summary-article-number))) | |
| 10652 (gnus-set-global-variables) | |
| 10653 (gnus-group-edit-global-kill article)) | |
| 10654 | |
| 10655 (defun gnus-summary-edit-local-kill () | |
| 10656 "Edit a local kill file applied to the current newsgroup." | |
| 10657 (interactive) | |
| 10658 (gnus-set-global-variables) | |
| 10659 (setq gnus-current-headers | |
| 10660 (gnus-gethash | |
| 10661 (int-to-string (gnus-summary-article-number)) | |
| 10662 gnus-newsgroup-headers-hashtb-by-number)) | |
| 10663 (gnus-set-global-variables) | |
| 10664 (gnus-group-edit-local-kill | |
| 10665 (gnus-summary-article-number) gnus-newsgroup-name)) | |
| 10666 | |
| 10667 | |
| 10668 ;;; | |
| 10669 ;;; Gnus article mode | |
| 10670 ;;; | |
| 10671 | |
| 10672 (put 'gnus-article-mode 'mode-class 'special) | |
| 10673 | |
| 10674 (defvar gnus-boogaboo nil) | |
| 10675 | |
| 10676 (if gnus-article-mode-map | |
| 10677 nil | |
| 10678 (setq gnus-article-mode-map (make-keymap)) | |
| 10679 (suppress-keymap gnus-article-mode-map) | |
| 10680 (define-key gnus-article-mode-map " " 'gnus-article-next-page) | |
| 10681 (define-key gnus-article-mode-map "\177" 'gnus-article-prev-page) | |
| 10682 (define-key gnus-article-mode-map "\C-c^" 'gnus-article-refer-article) | |
| 10683 (define-key gnus-article-mode-map "h" 'gnus-article-show-summary) | |
| 10684 (define-key gnus-article-mode-map "s" 'gnus-article-show-summary) | |
| 10685 (define-key gnus-article-mode-map "\C-c\C-m" 'gnus-article-mail) | |
| 10686 (define-key gnus-article-mode-map "?" 'gnus-article-describe-briefly) | |
| 10687 (define-key gnus-article-mode-map gnus-mouse-2 'gnus-article-push-button) | |
| 10688 (define-key gnus-article-mode-map "\r" 'gnus-article-press-button) | |
| 10689 (define-key gnus-article-mode-map "\t" 'gnus-article-next-button) | |
| 10690 (define-key gnus-article-mode-map "\C-c\C-b" 'gnus-bug) | |
| 10691 | |
| 10692 ;; Duplicate almost all summary keystrokes in the article mode map. | |
| 10693 (let ((commands | |
| 10694 (list | |
| 10695 "p" "N" "P" "\M-\C-n" "\M-\C-p" | |
| 10696 "\M-n" "\M-p" "." "," "\M-s" "\M-r" "<" ">" "j" | |
| 10697 "u" "!" "U" "d" "D" "E" "\M-u" "\M-U" "k" "\C-k" "\M-\C-k" | |
| 10698 "\M-\C-l" "e" "#" "\M-#" "\M-\C-t" "\M-\C-s" "\M-\C-h" | |
| 10699 "\M-\C-f" "\M-\C-b" "\M-\C-u" "\M-\C-d" "&" "\C-w" | |
| 10700 "\C-t" "?" "\C-c\M-\C-s" "\C-c\C-s\C-n" "\C-c\C-s\C-a" | |
| 10701 "\C-c\C-s\C-s" "\C-c\C-s\C-d" "\C-c\C-s\C-i" "\C-x\C-s" | |
| 10702 "\M-g" "w" "\C-c\C-r" "\M-t" "C" | |
| 10703 "o" "\C-o" "|" "\M-k" "\M-K" "V" "\C-c\C-d" | |
| 10704 "\C-c\C-i" "x" "X" "t" "g" "?" "l" | |
| 10705 "\C-c\C-v\C-v" "\C-d" "v" | |
| 10706 ;; "Mt" "M!" "Md" "Mr" | |
| 10707 ;; "Mc" "M " "Me" "Mx" "M?" "Mb" "MB" "M#" "M\M-#" "M\M-r" | |
| 10708 ;; "M\M-\C-r" "MD" "M\M-D" "MS" "MC" "MH" "M\C-c" "Mk" "MK" | |
| 10709 ;; "Ms" "Mc" "Mu" "Mm" "Mk" "Gn" "Gp" "GN" "GP" "G\C-n" "G\C-p" | |
| 10710 ;; "G\M-n" "G\M-p" "Gf" "Gb" "Gg" "Gl" "Gp" "Tk" "Tl" "Ti" "TT" | |
| 10711 ;; "Ts" "TS" "Th" "TH" "Tn" "Tp" "Tu" "Td" "T#" "A " "An" "A\177" "Ap" | |
| 10712 ;; "A\r" "A<" "A>" "Ab" "Ae" "A^" "Ar" "Aw" "Ac" "Ag" "At" "Am" | |
| 10713 ;; "As" "Wh" "Ws" "Wc" "Wo" "Ww" "Wd" "Wq" "Wf" "Wt" "W\C-t" | |
| 10714 ;; "WT" "WA" "Wa" "WH" "WC" "WS" "Wb" "Hv" "Hf" "Hd" "Hh" "Hi" | |
| 10715 ;; "Be" "B\177" "Bm" "Br" "Bw" "Bc" "Bq" "Bi" "Oo" "Om" "Or" | |
| 10716 ;; "Of" "Oh" "Ov" "Op" "Vu" "V\C-s" "V\C-r" "Vr" "V&" "VT" "Ve" | |
| 10717 ;; "VD" "Vk" "VK" "Vsn" "Vsa" "Vss" "Vsd" "Vsi" | |
| 10718 ))) | |
| 10719 (while (and gnus-boogaboo commands) ; disabled | |
| 10720 (define-key gnus-article-mode-map (car commands) | |
| 10721 'gnus-article-summary-command) | |
| 10722 (setq commands (cdr commands)))) | |
| 10723 | |
| 10724 (let ((commands (list "q" "Q" "c" "r" "R" "\C-c\C-f" "m" "a" "f" "F" | |
| 10725 ;; "Zc" "ZC" "ZE" "ZQ" "ZZ" "Zn" "ZR" "ZG" "ZN" "ZP" | |
| 10726 "=" "n" "^" "\M-^"))) | |
| 10727 (while (and gnus-boogaboo commands) ; disabled | |
| 10728 (define-key gnus-article-mode-map (car commands) | |
| 10729 'gnus-article-summary-command-nosave) | |
| 10730 (setq commands (cdr commands))))) | |
| 10731 | |
| 10732 | |
| 10733 (defun gnus-article-mode () | |
| 10734 "Major mode for displaying an article. | |
| 10735 | |
| 10736 All normal editing commands are switched off. | |
| 10737 | |
| 10738 The following commands are available: | |
| 10739 | |
| 10740 \\<gnus-article-mode-map> | |
| 10741 \\[gnus-article-next-page]\t Scroll the article one page forwards | |
| 10742 \\[gnus-article-prev-page]\t Scroll the article one page backwards | |
| 10743 \\[gnus-article-refer-article]\t Go to the article referred to by an article id near point | |
| 10744 \\[gnus-article-show-summary]\t Display the summary buffer | |
| 10745 \\[gnus-article-mail]\t Send a reply to the address near point | |
| 10746 \\[gnus-article-describe-briefly]\t Describe the current mode briefly | |
| 10747 \\[gnus-info-find-node]\t Go to the Gnus info node" | |
| 10748 (interactive) | |
| 10749 (if gnus-visual (gnus-article-make-menu-bar)) | |
| 10750 (kill-all-local-variables) | |
| 10751 (setq mode-line-modified "-- ") | |
| 10752 (make-local-variable 'mode-line-format) | |
| 10753 (setq mode-line-format (copy-sequence mode-line-format)) | |
| 10754 (and (equal (nth 3 mode-line-format) " ") | |
| 10755 (setcar (nthcdr 3 mode-line-format) "")) | |
| 10756 (setq mode-name "Article") | |
| 10757 (setq major-mode 'gnus-article-mode) | |
| 10758 (make-local-variable 'minor-mode-alist) | |
| 10759 (or (assq 'gnus-show-mime minor-mode-alist) | |
| 10760 (setq minor-mode-alist | |
| 10761 (cons (list 'gnus-show-mime " MIME") minor-mode-alist))) | |
| 10762 (use-local-map gnus-article-mode-map) | |
| 10763 (make-local-variable 'page-delimiter) | |
| 10764 (setq page-delimiter gnus-page-delimiter) | |
| 10765 (buffer-disable-undo (current-buffer)) | |
| 10766 (setq buffer-read-only t) ;Disable modification | |
| 10767 (run-hooks 'gnus-article-mode-hook)) | |
| 10768 | |
| 10769 (defun gnus-article-setup-buffer () | |
| 10770 "Initialize article mode buffer." | |
| 10771 ;; Returns the article buffer. | |
| 10772 (if (get-buffer gnus-article-buffer) | |
| 10773 (save-excursion | |
| 10774 (set-buffer gnus-article-buffer) | |
| 10775 (buffer-disable-undo (current-buffer)) | |
| 10776 (setq buffer-read-only t) | |
| 10777 (gnus-add-current-to-buffer-list) | |
| 10778 (or (eq major-mode 'gnus-article-mode) | |
| 10779 (gnus-article-mode)) | |
| 10780 (current-buffer)) | |
| 10781 (save-excursion | |
| 10782 (set-buffer (get-buffer-create gnus-article-buffer)) | |
| 10783 (gnus-add-current-to-buffer-list) | |
| 10784 (gnus-article-mode) | |
| 10785 (current-buffer)))) | |
| 10786 | |
| 10787 ;; Set article window start at LINE, where LINE is the number of lines | |
| 10788 ;; from the head of the article. | |
| 10789 (defun gnus-article-set-window-start (&optional line) | |
| 10790 (set-window-start | |
| 10791 (get-buffer-window gnus-article-buffer) | |
| 10792 (save-excursion | |
| 10793 (set-buffer gnus-article-buffer) | |
| 10794 (goto-char (point-min)) | |
| 10795 (if (not line) | |
| 10796 (point-min) | |
| 10797 (gnus-message 6 "Moved to bookmark") | |
| 10798 (search-forward "\n\n" nil t) | |
| 10799 (forward-line line) | |
| 10800 (point))))) | |
| 10801 | |
| 10802 (defun gnus-request-article-this-buffer (article group) | |
| 10803 "Get an article and insert it into this buffer." | |
| 10804 (setq group (or group gnus-newsgroup-name)) | |
| 10805 | |
| 10806 ;; Open server if it has closed. | |
| 10807 (gnus-check-server (gnus-find-method-for-group group)) | |
| 10808 | |
| 10809 ;; Using `gnus-request-article' directly will insert the article into | |
| 10810 ;; `nntp-server-buffer' - so we'll save some time by not having to | |
| 10811 ;; copy it from the server buffer into the article buffer. | |
| 10812 | |
| 10813 ;; We only request an article by message-id when we do not have the | |
| 10814 ;; headers for it, so we'll have to get those. | |
| 10815 (and (stringp article) | |
| 10816 (let ((gnus-override-method gnus-refer-article-method)) | |
| 10817 (gnus-read-header article))) | |
| 10818 | |
| 10819 ;; If the article number is negative, that means that this article | |
| 10820 ;; doesn't belong in this newsgroup (possibly), so we find its | |
| 10821 ;; message-id and request it by id instead of number. | |
| 10822 (if (not (numberp article)) | |
| 10823 () | |
| 10824 (save-excursion | |
| 10825 (set-buffer gnus-summary-buffer) | |
| 10826 (let ((header (gnus-get-header-by-num article))) | |
| 10827 (if (< article 0) | |
| 10828 (if (vectorp header) | |
| 10829 ;; It's a real article. | |
| 10830 (setq article (mail-header-id header)) | |
| 10831 ;; It is an extracted pseudo-article. | |
| 10832 (setq article 'pseudo) | |
| 10833 (gnus-request-pseudo-article header))) | |
| 10834 | |
| 10835 (let ((method (gnus-find-method-for-group gnus-newsgroup-name))) | |
| 10836 (if (not (eq (car method) 'nneething)) | |
| 10837 () | |
| 10838 (let ((dir (concat (file-name-as-directory (nth 1 method)) | |
| 10839 (mail-header-subject header)))) | |
| 10840 (if (file-directory-p dir) | |
| 10841 (progn | |
| 10842 (setq article 'nneething) | |
| 10843 (gnus-group-enter-directory dir))))))))) | |
| 10844 | |
| 10845 ;; Check the cache. | |
| 10846 (if (and gnus-use-cache | |
| 10847 (numberp article) | |
| 10848 (gnus-cache-request-article article group)) | |
| 10849 'article | |
| 10850 ;; Get the article and put into the article buffer. | |
| 10851 (if (or (stringp article) (numberp article)) | |
| 10852 (progn | |
| 10853 (erase-buffer) | |
| 10854 ;; There may be some overlays that we have to kill... | |
| 10855 (insert "i") | |
| 10856 (let ((overlays (overlays-at (point-min)))) | |
| 10857 (while overlays | |
| 10858 (delete-overlay (car overlays)) | |
| 10859 (setq overlays (cdr overlays)))) | |
| 10860 (erase-buffer) | |
| 10861 (let ((gnus-override-method | |
| 10862 (and (stringp article) gnus-refer-article-method))) | |
| 10863 (and (gnus-request-article article group (current-buffer)) | |
| 10864 'article))) | |
| 10865 article))) | |
| 10866 | |
| 10867 (defun gnus-read-header (id) | |
| 10868 "Read the headers of article ID and enter them into the Gnus system." | |
| 10869 (let (header) | |
| 10870 (if (not (setq header | |
| 10871 (car (if (let ((gnus-nov-is-evil t)) | |
| 10872 (gnus-retrieve-headers | |
| 10873 (list id) gnus-newsgroup-name)) | |
| 10874 (gnus-get-newsgroup-headers))))) | |
| 10875 nil | |
| 10876 (if (stringp id) | |
| 10877 (mail-header-set-number header gnus-reffed-article-number)) | |
| 10878 (setq gnus-newsgroup-headers (cons header gnus-newsgroup-headers)) | |
| 10879 (gnus-sethash (int-to-string (mail-header-number header)) header | |
| 10880 gnus-newsgroup-headers-hashtb-by-number) | |
| 10881 (if (stringp id) | |
| 10882 (setq gnus-reffed-article-number (1- gnus-reffed-article-number))) | |
| 10883 (setq gnus-current-headers header) | |
| 10884 header))) | |
| 10885 | |
| 10886 (defun gnus-article-prepare (article &optional all-headers header) | |
| 10887 "Prepare ARTICLE in article mode buffer. | |
| 10888 ARTICLE should either be an article number or a Message-ID. | |
| 10889 If ARTICLE is an id, HEADER should be the article headers. | |
| 10890 If ALL-HEADERS is non-nil, no headers are hidden." | |
| 10891 (save-excursion | |
| 10892 ;; Make sure we start in a summary buffer. | |
| 10893 (or (eq major-mode 'gnus-summary-mode) | |
| 10894 (set-buffer gnus-summary-buffer)) | |
| 10895 (setq gnus-summary-buffer (current-buffer)) | |
| 10896 ;; Make sure the connection to the server is alive. | |
| 10897 (or (gnus-server-opened (gnus-find-method-for-group gnus-newsgroup-name)) | |
| 10898 (progn | |
| 10899 (gnus-check-server | |
| 10900 (gnus-find-method-for-group gnus-newsgroup-name)) | |
| 10901 (gnus-request-group gnus-newsgroup-name t))) | |
| 10902 (let* ((article (if header (mail-header-number header) article)) | |
| 10903 (summary-buffer (current-buffer)) | |
| 10904 (internal-hook gnus-article-internal-prepare-hook) | |
| 10905 (group gnus-newsgroup-name) | |
| 10906 result) | |
| 10907 (save-excursion | |
| 10908 (gnus-article-setup-buffer) | |
| 10909 (set-buffer gnus-article-buffer) | |
| 10910 (if (not (setq result (let ((buffer-read-only nil)) | |
| 10911 (gnus-request-article-this-buffer | |
| 10912 article group)))) | |
| 10913 ;; There is no such article. | |
| 10914 (save-excursion | |
| 10915 (if (not (numberp article)) | |
| 10916 () | |
| 10917 (setq gnus-article-current | |
| 10918 (cons gnus-newsgroup-name article)) | |
| 10919 (set-buffer gnus-summary-buffer) | |
| 10920 (setq gnus-current-article article) | |
| 10921 (gnus-summary-mark-article article gnus-canceled-mark)) | |
| 10922 (gnus-message 1 "No such article (may be canceled)") | |
| 10923 (ding) | |
| 10924 nil) | |
| 10925 (if (or (eq result 'pseudo) (eq result 'nneething)) | |
| 10926 (progn | |
| 10927 (save-excursion | |
| 10928 (set-buffer summary-buffer) | |
| 10929 (setq gnus-last-article gnus-current-article | |
| 10930 gnus-newsgroup-history (cons gnus-current-article | |
| 10931 gnus-newsgroup-history) | |
| 10932 gnus-current-article 0 | |
| 10933 gnus-current-headers nil | |
| 10934 gnus-article-current nil) | |
| 10935 (if (eq result 'nneething) | |
| 10936 (gnus-configure-windows 'summary) | |
| 10937 (gnus-configure-windows 'article)) | |
| 10938 (gnus-set-global-variables)) | |
| 10939 (gnus-set-mode-line 'article)) | |
| 10940 ;; The result from the `request' was an actual article - | |
| 10941 ;; or at least some text that is now displayed in the | |
| 10942 ;; article buffer. | |
| 10943 (if (and (numberp article) | |
| 10944 (not (eq article gnus-current-article))) | |
| 10945 ;; Seems like a new article has been selected. | |
| 10946 ;; `gnus-current-article' must be an article number. | |
| 10947 (save-excursion | |
| 10948 (set-buffer summary-buffer) | |
| 10949 (setq gnus-last-article gnus-current-article | |
| 10950 gnus-newsgroup-history (cons gnus-current-article | |
| 10951 gnus-newsgroup-history) | |
| 10952 gnus-current-article article | |
| 10953 gnus-current-headers | |
| 10954 (gnus-get-header-by-num gnus-current-article) | |
| 10955 gnus-article-current | |
| 10956 (cons gnus-newsgroup-name gnus-current-article)) | |
| 10957 (gnus-summary-show-thread) | |
| 10958 (run-hooks 'gnus-mark-article-hook) | |
| 10959 (gnus-set-mode-line 'summary) | |
| 10960 (and gnus-visual | |
| 10961 (run-hooks 'gnus-visual-mark-article-hook)) | |
| 10962 ;; Set the global newsgroup variables here. | |
| 10963 ;; Suggested by Jim Sisolak | |
| 10964 ;; <sisolak@trans4.neep.wisc.edu>. | |
| 10965 (gnus-set-global-variables) | |
| 10966 (setq gnus-have-all-headers | |
| 10967 (or all-headers gnus-show-all-headers)) | |
| 10968 (and gnus-use-cache | |
| 10969 (vectorp (gnus-get-header-by-number article)) | |
| 10970 (gnus-cache-possibly-enter-article | |
| 10971 group article | |
| 10972 (gnus-get-header-by-number article) | |
| 10973 (memq article gnus-newsgroup-marked) | |
| 10974 (memq article gnus-newsgroup-dormant) | |
| 10975 (memq article gnus-newsgroup-unreads))))) | |
| 10976 ;; Hooks for getting information from the article. | |
| 10977 ;; This hook must be called before being narrowed. | |
| 10978 (let (buffer-read-only) | |
| 10979 (run-hooks 'internal-hook) | |
| 10980 (run-hooks 'gnus-article-prepare-hook) | |
| 10981 ;; Decode MIME message. | |
| 10982 (if (and gnus-show-mime | |
| 10983 (or (not gnus-strict-mime) | |
| 10984 (gnus-fetch-field "Mime-Version"))) | |
| 10985 (funcall gnus-show-mime-method)) | |
| 10986 ;; Perform the article display hooks. | |
| 10987 (run-hooks 'gnus-article-display-hook)) | |
| 10988 ;; Do page break. | |
| 10989 (goto-char (point-min)) | |
| 10990 (and gnus-break-pages (gnus-narrow-to-page)) | |
| 10991 (gnus-set-mode-line 'article) | |
| 10992 (gnus-configure-windows 'article) | |
| 10993 (goto-char (point-min)) | |
| 10994 t)))))) | |
| 10995 | |
| 10996 (defun gnus-article-show-all-headers () | |
| 10997 "Show all article headers in article mode buffer." | |
| 10998 (save-excursion | |
| 10999 (gnus-article-setup-buffer) | |
| 11000 (set-buffer gnus-article-buffer) | |
| 11001 (let ((buffer-read-only nil)) | |
| 11002 (remove-text-properties (point-min) (point-max) | |
| 11003 gnus-hidden-properties)))) | |
| 11004 | |
| 11005 (defun gnus-article-hide-headers-if-wanted () | |
| 11006 "Hide unwanted headers if `gnus-have-all-headers' is nil. | |
| 11007 Provided for backwards compatability." | |
| 11008 (or (save-excursion (set-buffer gnus-summary-buffer) gnus-have-all-headers) | |
| 11009 (gnus-article-hide-headers))) | |
| 11010 | |
| 11011 (defun gnus-article-hide-headers (&optional delete) | |
| 11012 "Hide unwanted headers and possibly sort them as well." | |
| 11013 (interactive "P") | |
| 11014 (save-excursion | |
| 11015 (set-buffer gnus-article-buffer) | |
| 11016 (save-restriction | |
| 11017 (let ((sorted gnus-sorted-header-list) | |
| 11018 (buffer-read-only nil) | |
| 11019 want-list beg want-l) | |
| 11020 ;; First we narrow to just the headers. | |
| 11021 (widen) | |
| 11022 (goto-char (point-min)) | |
| 11023 ;; Hide any "From " lines at the beginning of (mail) articles. | |
| 11024 (while (looking-at "From ") | |
| 11025 (forward-line 1)) | |
| 11026 (or (bobp) | |
| 11027 (add-text-properties (point-min) (point) gnus-hidden-properties)) | |
| 11028 ;; Then treat the rest of the header lines. | |
| 11029 (narrow-to-region | |
| 11030 (point) | |
| 11031 (progn (search-forward "\n\n" nil t) (forward-line -1) (point))) | |
| 11032 ;; Then we use the two regular expressions | |
| 11033 ;; `gnus-ignored-headers' and `gnus-visible-headers' to | |
| 11034 ;; select which header lines is to remain visible in the | |
| 11035 ;; article buffer. | |
| 11036 (goto-char (point-min)) | |
| 11037 (while (re-search-forward "^[^ \t]*:" nil t) | |
| 11038 (beginning-of-line) | |
| 11039 ;; We add the headers we want to keep to a list and delete | |
| 11040 ;; them from the buffer. | |
| 11041 (if (or (and (stringp gnus-visible-headers) | |
| 11042 (looking-at gnus-visible-headers)) | |
| 11043 (and (not (stringp gnus-visible-headers)) | |
| 11044 (stringp gnus-ignored-headers) | |
| 11045 (not (looking-at gnus-ignored-headers)))) | |
| 11046 (progn | |
| 11047 (setq beg (point)) | |
| 11048 (forward-line 1) | |
| 11049 ;; Be sure to get multi-line headers... | |
| 11050 (re-search-forward "^[^ \t]*:" nil t) | |
| 11051 (beginning-of-line) | |
| 11052 (setq want-list | |
| 11053 (cons (buffer-substring beg (point)) want-list)) | |
| 11054 (delete-region beg (point)) | |
| 11055 (goto-char beg)) | |
| 11056 (forward-line 1))) | |
| 11057 ;; Next we perform the sorting by looking at | |
| 11058 ;; `gnus-sorted-header-list'. | |
| 11059 (goto-char (point-min)) | |
| 11060 (while (and sorted want-list) | |
| 11061 (setq want-l want-list) | |
| 11062 (while (and want-l | |
| 11063 (not (string-match (car sorted) (car want-l)))) | |
| 11064 (setq want-l (cdr want-l))) | |
| 11065 (if want-l | |
| 11066 (progn | |
| 11067 (insert (car want-l)) | |
| 11068 (setq want-list (delq (car want-l) want-list)))) | |
| 11069 (setq sorted (cdr sorted))) | |
| 11070 ;; Any headers that were not matched by the sorted list we | |
| 11071 ;; just tack on the end of the visible header list. | |
| 11072 (while want-list | |
| 11073 (insert (car want-list)) | |
| 11074 (setq want-list (cdr want-list))) | |
| 11075 ;; And finally we make the unwanted headers invisible. | |
| 11076 (if delete | |
| 11077 (delete-region (point) (point-max)) | |
| 11078 ;; Suggested by Sudish Joseph <joseph@cis.ohio-state.edu>. | |
| 11079 (add-text-properties (point) (point-max) gnus-hidden-properties)))))) | |
| 11080 | |
| 11081 ;; Written by Per Abrahamsen <amanda@iesd.auc.dk>. | |
| 11082 (defun gnus-article-treat-overstrike () | |
| 11083 "Translate overstrikes into bold text." | |
| 11084 (interactive) | |
| 11085 (save-excursion | |
| 11086 (set-buffer gnus-article-buffer) | |
| 11087 (let ((buffer-read-only nil)) | |
| 11088 (while (search-forward "\b" nil t) | |
| 11089 (let ((next (following-char)) | |
| 11090 (previous (char-after (- (point) 2)))) | |
| 11091 (cond ((eq next previous) | |
| 11092 (put-text-property (- (point) 2) (point) | |
| 11093 'invisible t) | |
| 11094 (put-text-property (point) (1+ (point)) | |
| 11095 'face 'bold)) | |
| 11096 ((eq next ?_) | |
| 11097 (put-text-property (1- (point)) (1+ (point)) | |
| 11098 'invisible t) | |
| 11099 (put-text-property (1- (point)) (point) | |
| 11100 'face 'underline)) | |
| 11101 ((eq previous ?_) | |
| 11102 (put-text-property (- (point) 2) (point) | |
| 11103 'invisible t) | |
| 11104 (put-text-property (point) (1+ (point)) | |
| 11105 'face 'underline)))))))) | |
| 11106 | |
| 11107 (defun gnus-article-word-wrap () | |
| 11108 "Format too long lines." | |
| 11109 (interactive) | |
| 11110 (save-excursion | |
| 11111 (set-buffer gnus-article-buffer) | |
| 11112 (let ((buffer-read-only nil)) | |
| 11113 (goto-char (point-min)) | |
| 11114 (search-forward "\n\n" nil t) | |
| 11115 (end-of-line 1) | |
| 11116 (let ((paragraph-start "^[>|#:<;* ]*[ \t]*$") | |
| 11117 (adaptive-fill-regexp "[ \t]*\\([|#:<;>*]+ *\\)?") | |
| 11118 (adaptive-fill-mode t)) | |
| 11119 (while (not (eobp)) | |
| 11120 (and (>= (current-column) (min fill-column (window-width))) | |
| 11121 (/= (preceding-char) ?:) | |
| 11122 (fill-paragraph nil)) | |
| 11123 (end-of-line 2)))))) | |
| 11124 | |
| 11125 (defun gnus-article-remove-cr () | |
| 11126 "Remove carriage returns from an article." | |
| 11127 (interactive) | |
| 11128 (save-excursion | |
| 11129 (set-buffer gnus-article-buffer) | |
| 11130 (let ((buffer-read-only nil)) | |
| 11131 (goto-char (point-min)) | |
| 11132 (while (search-forward "\r" nil t) | |
| 11133 (replace-match "" t t))))) | |
| 11134 | |
| 11135 (defun gnus-article-display-x-face (&optional force) | |
| 11136 "Look for an X-Face header and display it if present." | |
| 11137 (interactive (list 'force)) | |
| 11138 (save-excursion | |
| 11139 (set-buffer gnus-article-buffer) | |
| 11140 (let ((inhibit-point-motion-hooks t) | |
| 11141 (case-fold-search nil) | |
| 11142 from) | |
| 11143 (save-restriction | |
| 11144 (goto-char (point-min)) | |
| 11145 (search-forward "\n\n") | |
| 11146 (narrow-to-region (point-min) (point)) | |
| 11147 (goto-char (point-min)) | |
| 11148 (setq from (mail-fetch-field "from")) | |
| 11149 (if (not (and gnus-article-x-face-command | |
| 11150 (or force | |
| 11151 (not gnus-article-x-face-too-ugly) | |
| 11152 (and gnus-article-x-face-too-ugly from | |
| 11153 (not (string-match gnus-article-x-face-too-ugly | |
| 11154 from)))) | |
| 11155 (progn | |
| 11156 (goto-char (point-min)) | |
| 11157 (re-search-forward "^X-Face: " nil t)))) | |
| 11158 nil | |
| 11159 (let ((beg (point)) | |
| 11160 (end (1- (re-search-forward "^\\($\\|[^ \t]\\)" nil t)))) | |
| 11161 (if (symbolp gnus-article-x-face-command) | |
| 11162 (and (or (fboundp gnus-article-x-face-command) | |
| 11163 (error "%s is not a function" | |
| 11164 gnus-article-x-face-command)) | |
| 11165 (funcall gnus-article-x-face-command beg end)) | |
| 11166 (call-process-region beg end "sh" nil 0 nil | |
| 11167 "-c" gnus-article-x-face-command)))))))) | |
| 11168 | |
| 11169 (defun gnus-article-de-quoted-unreadable (&optional force) | |
| 11170 "Do a naive translation of a quoted-printable-encoded article. | |
| 11171 This is in no way, shape or form meant as a replacement for real MIME | |
| 11172 processing, but is simply a stop-gap measure until MIME support is | |
| 11173 written. | |
| 11174 If FORCE, decode the article whether it is marked as quoted-printable | |
| 11175 or not." | |
| 11176 (interactive (list 'force)) | |
| 11177 (save-excursion | |
| 11178 (set-buffer gnus-article-buffer) | |
| 11179 (let ((case-fold-search t) | |
| 11180 (buffer-read-only nil) | |
| 11181 (type (gnus-fetch-field "content-transfer-encoding"))) | |
| 11182 (if (or force (and type (string-match "quoted-printable" type))) | |
| 11183 (progn | |
| 11184 (goto-char (point-min)) | |
| 11185 (search-forward "\n\n" nil 'move) | |
| 11186 (gnus-mime-decode-quoted-printable (point) (point-max))))))) | |
| 11187 | |
| 11188 (defun gnus-mime-decode-quoted-printable (from to) | |
| 11189 ;; Decode quoted-printable from region between FROM and TO. | |
| 11190 (save-excursion | |
| 11191 (goto-char from) | |
| 11192 (while (search-forward "=" to t) | |
| 11193 (cond ((eq (following-char) ?\n) | |
| 11194 (delete-char -1) | |
| 11195 (delete-char 1)) | |
| 11196 ((looking-at "[0-9A-F][0-9A-F]") | |
| 11197 (delete-char -1) | |
| 11198 (insert (hexl-hex-string-to-integer | |
| 11199 (buffer-substring (point) (+ 2 (point))))) | |
| 11200 (delete-char 2)) | |
| 11201 ((looking-at "=") | |
| 11202 (delete-char 1)) | |
| 11203 ((gnus-message 3 "Malformed MIME quoted-printable message")))))) | |
| 11204 | |
| 11205 (defvar gnus-article-time-units | |
| 11206 (list (cons 'year (* 365.25 24 60 60)) | |
| 11207 (cons 'week (* 7 24 60 60)) | |
| 11208 (cons 'day (* 24 60 60)) | |
| 11209 (cons 'hour (* 60 60)) | |
| 11210 (cons 'minute 60) | |
| 11211 (cons 'second 1))) | |
| 11212 | |
| 11213 (defun gnus-article-date-ut (&optional type) | |
| 11214 "Convert DATE date to universal time in the current article. | |
| 11215 If TYPE is `local', convert to local time; if it is `lapsed', output | |
| 11216 how much time has lapsed since DATE." | |
| 11217 (interactive (list 'ut)) | |
| 11218 (let ((date (mail-header-date (or gnus-current-headers | |
| 11219 (gnus-get-header-by-number | |
| 11220 (gnus-summary-article-number))""))) | |
| 11221 (date-regexp "^Date: \\|^X-Sent: ")) | |
| 11222 (if (or (not date) | |
| 11223 (string= date "")) | |
| 11224 () | |
| 11225 (save-excursion | |
| 11226 (set-buffer gnus-article-buffer) | |
| 11227 (let ((buffer-read-only nil)) | |
| 11228 (goto-char (point-min)) | |
| 11229 (if (and (re-search-forward date-regexp nil t) | |
| 11230 (progn | |
| 11231 (beginning-of-line) | |
| 11232 (looking-at date-regexp))) | |
| 11233 (delete-region (gnus-point-at-bol) | |
| 11234 (progn (end-of-line) (1+ (point)))) | |
| 11235 (goto-char (point-min)) | |
| 11236 (goto-char (- (search-forward "\n\n") 2))) | |
| 11237 (insert | |
| 11238 (cond | |
| 11239 ((eq type 'local) | |
| 11240 (concat "Date: " (condition-case () | |
| 11241 (timezone-make-date-arpa-standard date) | |
| 11242 (error date)) | |
| 11243 "\n")) | |
| 11244 ((eq type 'ut) | |
| 11245 (concat "Date: " | |
| 11246 (condition-case () | |
| 11247 (timezone-make-date-arpa-standard date nil "UT") | |
| 11248 (error date)) | |
| 11249 "\n")) | |
| 11250 ((eq type 'lapsed) | |
| 11251 ;; If the date is seriously mangled, the timezone | |
| 11252 ;; functions are liable to bug out, so we condition-case | |
| 11253 ;; the entire thing. | |
| 11254 (let* ((real-sec (condition-case () | |
| 11255 (- (gnus-seconds-since-epoch | |
| 11256 (timezone-make-date-arpa-standard | |
| 11257 (current-time-string) | |
| 11258 (current-time-zone) "UT")) | |
| 11259 (gnus-seconds-since-epoch | |
| 11260 (timezone-make-date-arpa-standard | |
| 11261 date nil "UT"))) | |
| 11262 (error 0))) | |
| 11263 (sec (abs real-sec)) | |
| 11264 num prev) | |
| 11265 (if (zerop sec) | |
| 11266 "X-Sent: Now\n" | |
| 11267 (concat | |
| 11268 "X-Sent: " | |
| 11269 (mapconcat | |
| 11270 (lambda (unit) | |
| 11271 (if (zerop (setq num (ffloor (/ sec (cdr unit))))) | |
| 11272 "" | |
| 11273 (setq sec (- sec (* num (cdr unit)))) | |
| 11274 (prog1 | |
| 11275 (concat (if prev ", " "") (int-to-string | |
| 11276 (floor num)) | |
| 11277 " " (symbol-name (car unit)) | |
| 11278 (if (> num 1) "s" "")) | |
| 11279 (setq prev t)))) | |
| 11280 gnus-article-time-units "") | |
| 11281 (if (> real-sec 0) | |
| 11282 " ago\n" | |
| 11283 " in the future\n"))))) | |
| 11284 (t | |
| 11285 (error "Unknown conversion type: %s" type))))))))) | |
| 11286 | |
| 11287 (defun gnus-article-date-local () | |
| 11288 "Convert the current article date to the local timezone." | |
| 11289 (interactive) | |
| 11290 (gnus-article-date-ut 'local)) | |
| 11291 | |
| 11292 (defun gnus-article-date-lapsed () | |
| 11293 "Convert the current article date to time lapsed since it was sent." | |
| 11294 (interactive) | |
| 11295 (gnus-article-date-ut 'lapsed)) | |
| 11296 | |
| 11297 (defun gnus-article-maybe-highlight () | |
| 11298 "Do some article highlighting if `gnus-visual' is non-nil." | |
| 11299 (if gnus-visual (gnus-article-highlight-some))) | |
| 11300 | |
| 11301 ;; Article savers. | |
| 11302 | |
| 11303 (defun gnus-output-to-rmail (file-name) | |
| 11304 "Append the current article to an Rmail file named FILE-NAME." | |
| 11305 (require 'rmail) | |
| 11306 ;; Most of these codes are borrowed from rmailout.el. | |
| 11307 (setq file-name (expand-file-name file-name)) | |
| 11308 (setq rmail-default-rmail-file file-name) | |
| 11309 (let ((artbuf (current-buffer)) | |
| 11310 (tmpbuf (get-buffer-create " *Gnus-output*"))) | |
| 11311 (save-excursion | |
| 11312 (or (get-file-buffer file-name) | |
| 11313 (file-exists-p file-name) | |
| 11314 (if (gnus-yes-or-no-p | |
| 11315 (concat "\"" file-name "\" does not exist, create it? ")) | |
| 11316 (let ((file-buffer (create-file-buffer file-name))) | |
| 11317 (save-excursion | |
| 11318 (set-buffer file-buffer) | |
| 11319 (rmail-insert-rmail-file-header) | |
| 11320 (let ((require-final-newline nil)) | |
| 11321 (write-region (point-min) (point-max) file-name t 1))) | |
| 11322 (kill-buffer file-buffer)) | |
| 11323 (error "Output file does not exist"))) | |
| 11324 (set-buffer tmpbuf) | |
| 11325 (buffer-disable-undo (current-buffer)) | |
| 11326 (erase-buffer) | |
| 11327 (insert-buffer-substring artbuf) | |
| 11328 (gnus-convert-article-to-rmail) | |
| 11329 ;; Decide whether to append to a file or to an Emacs buffer. | |
| 11330 (let ((outbuf (get-file-buffer file-name))) | |
| 11331 (if (not outbuf) | |
| 11332 (append-to-file (point-min) (point-max) file-name) | |
| 11333 ;; File has been visited, in buffer OUTBUF. | |
| 11334 (set-buffer outbuf) | |
| 11335 (let ((buffer-read-only nil) | |
| 11336 (msg (and (boundp 'rmail-current-message) | |
| 11337 (symbol-value 'rmail-current-message)))) | |
| 11338 ;; If MSG is non-nil, buffer is in RMAIL mode. | |
| 11339 (if msg | |
| 11340 (progn (widen) | |
| 11341 (narrow-to-region (point-max) (point-max)))) | |
| 11342 (insert-buffer-substring tmpbuf) | |
| 11343 (if msg | |
| 11344 (progn | |
| 11345 (goto-char (point-min)) | |
| 11346 (widen) | |
| 11347 (search-backward "\^_") | |
| 11348 (narrow-to-region (point) (point-max)) | |
| 11349 (goto-char (1+ (point-min))) | |
| 11350 (rmail-count-new-messages t) | |
| 11351 (rmail-show-message msg))))))) | |
| 11352 (kill-buffer tmpbuf))) | |
| 11353 | |
| 11354 (defun gnus-output-to-file (file-name) | |
| 11355 "Append the current article to a file named FILE-NAME." | |
| 11356 (setq file-name (expand-file-name file-name)) | |
| 11357 (let ((artbuf (current-buffer)) | |
| 11358 (tmpbuf (get-buffer-create " *Gnus-output*"))) | |
| 11359 (save-excursion | |
| 11360 (set-buffer tmpbuf) | |
| 11361 (buffer-disable-undo (current-buffer)) | |
| 11362 (erase-buffer) | |
| 11363 (insert-buffer-substring artbuf) | |
| 11364 ;; Append newline at end of the buffer as separator, and then | |
| 11365 ;; save it to file. | |
| 11366 (goto-char (point-max)) | |
| 11367 (insert "\n") | |
| 11368 (append-to-file (point-min) (point-max) file-name)) | |
| 11369 (kill-buffer tmpbuf))) | |
| 11370 | |
| 11371 (defun gnus-convert-article-to-rmail () | |
| 11372 "Convert article in current buffer to Rmail message format." | |
| 11373 (let ((buffer-read-only nil)) | |
| 11374 ;; Convert article directly into Babyl format. | |
| 11375 ;; Suggested by Rob Austein <sra@lcs.mit.edu> | |
| 11376 (goto-char (point-min)) | |
| 11377 (insert "\^L\n0, unseen,,\n*** EOOH ***\n") | |
| 11378 (while (search-forward "\n\^_" nil t) ;single char | |
| 11379 (replace-match "\n^_" t t)) ;2 chars: "^" and "_" | |
| 11380 (goto-char (point-max)) | |
| 11381 (insert "\^_"))) | |
| 11382 | |
| 11383 (defun gnus-narrow-to-page (&optional arg) | |
| 11384 "Make text outside current page invisible except for page delimiter. | |
| 11385 A numeric arg specifies to move forward or backward by that many pages, | |
| 11386 thus showing a page other than the one point was originally in." | |
| 11387 (interactive "P") | |
| 11388 (setq arg (if arg (prefix-numeric-value arg) 0)) | |
| 11389 (save-excursion | |
| 11390 (forward-page -1) ;Beginning of current page. | |
| 11391 (widen) | |
| 11392 (if (> arg 0) | |
| 11393 (forward-page arg) | |
| 11394 (if (< arg 0) | |
| 11395 (forward-page (1- arg)))) | |
| 11396 ;; Find the end of the page. | |
| 11397 (forward-page) | |
| 11398 ;; If we stopped due to end of buffer, stay there. | |
| 11399 ;; If we stopped after a page delimiter, put end of restriction | |
| 11400 ;; at the beginning of that line. | |
| 11401 ;; These are commented out. | |
| 11402 ;; (if (save-excursion (beginning-of-line) | |
| 11403 ;; (looking-at page-delimiter)) | |
| 11404 ;; (beginning-of-line)) | |
| 11405 (narrow-to-region (point) | |
| 11406 (progn | |
| 11407 ;; Find the top of the page. | |
| 11408 (forward-page -1) | |
| 11409 ;; If we found beginning of buffer, stay there. | |
| 11410 ;; If extra text follows page delimiter on same line, | |
| 11411 ;; include it. | |
| 11412 ;; Otherwise, show text starting with following line. | |
| 11413 (if (and (eolp) (not (bobp))) | |
| 11414 (forward-line 1)) | |
| 11415 (point))))) | |
| 11416 | |
| 11417 (defun gnus-gmt-to-local () | |
| 11418 "Rewrite Date header described in GMT to local in current buffer. | |
| 11419 Intended to be used with gnus-article-prepare-hook." | |
| 11420 (save-excursion | |
| 11421 (save-restriction | |
| 11422 (widen) | |
| 11423 (goto-char (point-min)) | |
| 11424 (narrow-to-region (point-min) | |
| 11425 (progn (search-forward "\n\n" nil 'move) (point))) | |
| 11426 (goto-char (point-min)) | |
| 11427 (if (re-search-forward "^Date:[ \t]\\(.*\\)$" nil t) | |
| 11428 (let ((buffer-read-only nil) | |
| 11429 (date (buffer-substring-no-properties | |
| 11430 (match-beginning 1) (match-end 1)))) | |
| 11431 (delete-region (match-beginning 1) (match-end 1)) | |
| 11432 (insert | |
| 11433 (timezone-make-date-arpa-standard | |
| 11434 date nil (current-time-zone)))))))) | |
| 11435 | |
| 11436 | |
| 11437 ;; Article mode commands | |
| 11438 | |
| 11439 (defun gnus-article-next-page (&optional lines) | |
| 11440 "Show next page of current article. | |
| 11441 If end of article, return non-nil. Otherwise return nil. | |
| 11442 Argument LINES specifies lines to be scrolled up." | |
| 11443 (interactive "P") | |
| 11444 (move-to-window-line -1) | |
| 11445 ;; Fixed by enami@ptgd.sony.co.jp (enami tsugutomo) | |
| 11446 (if (save-excursion | |
| 11447 (end-of-line) | |
| 11448 (and (pos-visible-in-window-p) ;Not continuation line. | |
| 11449 (eobp))) | |
| 11450 ;; Nothing in this page. | |
| 11451 (if (or (not gnus-break-pages) | |
| 11452 (save-excursion | |
| 11453 (save-restriction | |
| 11454 (widen) (forward-line 1) (eobp)))) ;Real end-of-buffer? | |
| 11455 t ;Nothing more. | |
| 11456 (gnus-narrow-to-page 1) ;Go to next page. | |
| 11457 nil) | |
| 11458 ;; More in this page. | |
| 11459 (condition-case () | |
| 11460 (scroll-up lines) | |
| 11461 (end-of-buffer | |
| 11462 ;; Long lines may cause an end-of-buffer error. | |
| 11463 (goto-char (point-max)))) | |
| 11464 nil)) | |
| 11465 | |
| 11466 (defun gnus-article-prev-page (&optional lines) | |
| 11467 "Show previous page of current article. | |
| 11468 Argument LINES specifies lines to be scrolled down." | |
| 11469 (interactive "P") | |
| 11470 (move-to-window-line 0) | |
| 11471 (if (and gnus-break-pages | |
| 11472 (bobp) | |
| 11473 (not (save-restriction (widen) (bobp)))) ;Real beginning-of-buffer? | |
| 11474 (progn | |
| 11475 (gnus-narrow-to-page -1) ;Go to previous page. | |
| 11476 (goto-char (point-max)) | |
| 11477 (recenter -1)) | |
| 11478 (scroll-down lines))) | |
| 11479 | |
| 11480 (defun gnus-article-refer-article () | |
| 11481 "Read article specified by message-id around point." | |
| 11482 (interactive) | |
| 11483 (search-forward ">" nil t) ;Move point to end of "<....>". | |
| 11484 (if (re-search-backward "\\(<[^<> \t\n]+>\\)" nil t) | |
| 11485 (let ((message-id | |
| 11486 (buffer-substring (match-beginning 1) (match-end 1)))) | |
| 11487 (set-buffer gnus-summary-buffer) | |
| 11488 (gnus-summary-refer-article message-id)) | |
| 11489 (error "No references around point"))) | |
| 11490 | |
| 11491 (defun gnus-article-show-summary () | |
| 11492 "Reconfigure windows to show summary buffer." | |
| 11493 (interactive) | |
| 11494 (gnus-configure-windows 'article) | |
| 11495 (gnus-summary-goto-subject gnus-current-article)) | |
| 11496 | |
| 11497 (defun gnus-article-describe-briefly () | |
| 11498 "Describe article mode commands briefly." | |
| 11499 (interactive) | |
| 11500 (gnus-message 6 | |
| 11501 (substitute-command-keys "\\<gnus-article-mode-map>\\[gnus-article-next-page]:Next page \\[gnus-article-prev-page]:Prev page \\[gnus-article-show-summary]:Show summary \\[gnus-info-find-node]:Run Info \\[gnus-article-describe-briefly]:This help"))) | |
| 11502 | |
| 11503 (defun gnus-article-summary-command () | |
| 11504 "Execute the last keystroke in the summary buffer." | |
| 11505 (interactive) | |
| 11506 (let ((obuf (current-buffer)) | |
| 11507 (owin (current-window-configuration)) | |
| 11508 func) | |
| 11509 (switch-to-buffer gnus-summary-buffer 'norecord) | |
| 11510 (setq func (lookup-key (current-local-map) (this-command-keys))) | |
| 11511 (call-interactively func) | |
| 11512 (set-buffer obuf) | |
| 11513 (set-window-configuration owin) | |
| 11514 (set-window-point (get-buffer-window (current-buffer)) (point)))) | |
| 11515 | |
| 11516 (defun gnus-article-summary-command-nosave () | |
| 11517 "Execute the last keystroke in the summary buffer." | |
| 11518 (interactive) | |
| 11519 (let (func) | |
| 11520 (pop-to-buffer gnus-summary-buffer 'norecord) | |
| 11521 (setq func (lookup-key (current-local-map) (this-command-keys))) | |
| 11522 (call-interactively func))) | |
| 11523 | |
| 11524 | |
| 11525 ;; Basic ideas by emv@math.lsa.umich.edu (Edward Vielmetti) | |
| 11526 | |
| 11527 ;;;###autoload | |
| 11528 (defalias 'gnus-batch-kill 'gnus-batch-score) | |
| 11529 ;;;###autoload | |
| 11530 (defun gnus-batch-score () | |
| 11531 "Run batched scoring. | |
| 11532 Usage: emacs -batch -l gnus -f gnus-batch-score <newsgroups> ... | |
| 11533 Newsgroups is a list of strings in Bnews format. If you want to score | |
| 11534 the comp hierarchy, you'd say \"comp.all\". If you would not like to | |
| 11535 score the alt hierarchy, you'd say \"!alt.all\"." | |
| 11536 (interactive) | |
| 11537 (let* ((yes-and-no | |
| 11538 (gnus-newsrc-parse-options | |
| 11539 (apply (function concat) | |
| 11540 (mapcar (lambda (g) (concat g " ")) | |
| 11541 command-line-args-left)))) | |
| 11542 (gnus-expert-user t) | |
| 11543 (nnmail-spool-file nil) | |
| 11544 (gnus-use-dribble-file nil) | |
| 11545 (yes (car yes-and-no)) | |
| 11546 (no (cdr yes-and-no)) | |
| 11547 group newsrc entry | |
| 11548 ;; Disable verbose message. | |
| 11549 gnus-novice-user gnus-large-newsgroup) | |
| 11550 ;; Eat all arguments. | |
| 11551 (setq command-line-args-left nil) | |
| 11552 ;; Start Gnus. | |
| 11553 (gnus) | |
| 11554 ;; Apply kills to specified newsgroups in command line arguments. | |
| 11555 (setq newsrc (cdr gnus-newsrc-alist)) | |
| 11556 (while newsrc | |
| 11557 (setq group (car (car newsrc))) | |
| 11558 (setq entry (gnus-gethash group gnus-newsrc-hashtb)) | |
| 11559 (if (and (<= (nth 1 (car newsrc)) gnus-level-subscribed) | |
| 11560 (and (car entry) | |
| 11561 (or (eq (car entry) t) | |
| 11562 (not (zerop (car entry))))) | |
| 11563 (if yes (string-match yes group) t) | |
| 11564 (or (null no) (not (string-match no group)))) | |
| 11565 (progn | |
| 11566 (gnus-summary-read-group group nil t) | |
| 11567 (and (eq (current-buffer) (get-buffer gnus-summary-buffer)) | |
| 11568 (gnus-summary-exit)))) | |
| 11569 (setq newsrc (cdr newsrc))) | |
| 11570 ;; Exit Emacs. | |
| 11571 (switch-to-buffer gnus-group-buffer) | |
| 11572 (gnus-group-save-newsrc))) | |
| 11573 | |
| 11574 (defun gnus-apply-kill-file () | |
| 11575 "Apply a kill file to the current newsgroup. | |
| 11576 Returns the number of articles marked as read." | |
| 11577 (if (or (file-exists-p (gnus-newsgroup-kill-file nil)) | |
| 11578 (file-exists-p (gnus-newsgroup-kill-file gnus-newsgroup-name))) | |
| 11579 (gnus-apply-kill-file-internal) | |
| 11580 0)) | |
| 11581 | |
| 11582 (defun gnus-kill-save-kill-buffer () | |
| 11583 (save-excursion | |
| 11584 (let ((file (gnus-newsgroup-kill-file gnus-newsgroup-name))) | |
| 11585 (if (get-file-buffer file) | |
| 11586 (progn | |
| 11587 (set-buffer (get-file-buffer file)) | |
| 11588 (and (buffer-modified-p) (save-buffer)) | |
| 11589 (kill-buffer (current-buffer))))))) | |
| 11590 | |
| 11591 (defvar gnus-kill-file-name "KILL" | |
| 11592 "Suffix of the kill files.") | |
| 11593 | |
| 11594 (defun gnus-newsgroup-kill-file (newsgroup) | |
| 11595 "Return the name of a kill file name for NEWSGROUP. | |
| 11596 If NEWSGROUP is nil, return the global kill file name instead." | |
| 11597 (cond ((or (null newsgroup) | |
| 11598 (string-equal newsgroup "")) | |
| 11599 ;; The global KILL file is placed at top of the directory. | |
| 11600 (expand-file-name gnus-kill-file-name | |
| 11601 (or gnus-kill-files-directory "~/News"))) | |
| 11602 ((gnus-use-long-file-name 'not-kill) | |
| 11603 ;; Append ".KILL" to newsgroup name. | |
| 11604 (expand-file-name (concat (gnus-newsgroup-saveable-name newsgroup) | |
| 11605 "." gnus-kill-file-name) | |
| 11606 (or gnus-kill-files-directory "~/News"))) | |
| 11607 (t | |
| 11608 ;; Place "KILL" under the hierarchical directory. | |
| 11609 (expand-file-name (concat (gnus-newsgroup-directory-form newsgroup) | |
| 11610 "/" gnus-kill-file-name) | |
| 11611 (or gnus-kill-files-directory "~/News"))))) | |
| 11612 | |
| 11613 | |
| 11614 ;;; | |
| 11615 ;;; Dribble file | |
| 11616 ;;; | |
| 11617 | |
| 11618 (defvar gnus-dribble-ignore nil) | |
| 11619 (defvar gnus-dribble-eval-file nil) | |
| 11620 | |
| 11621 (defun gnus-dribble-file-name () | |
| 11622 (concat gnus-current-startup-file "-dribble")) | |
| 11623 | |
| 11624 (defun gnus-dribble-enter (string) | |
| 11625 (if (and (not gnus-dribble-ignore) | |
| 11626 gnus-dribble-buffer | |
| 11627 (buffer-name gnus-dribble-buffer)) | |
| 11628 (let ((obuf (current-buffer))) | |
| 11629 (set-buffer gnus-dribble-buffer) | |
| 11630 (insert string "\n") | |
| 11631 (set-window-point (get-buffer-window (current-buffer)) (point-max)) | |
| 11632 (set-buffer obuf)))) | |
| 11633 | |
| 11634 (defun gnus-dribble-read-file () | |
| 11635 (let ((dribble-file (gnus-dribble-file-name))) | |
| 11636 (save-excursion | |
| 11637 (set-buffer (setq gnus-dribble-buffer | |
| 11638 (get-buffer-create | |
| 11639 (file-name-nondirectory dribble-file)))) | |
| 11640 (gnus-add-current-to-buffer-list) | |
| 11641 (erase-buffer) | |
| 11642 (set-visited-file-name dribble-file) | |
| 11643 (buffer-disable-undo (current-buffer)) | |
| 11644 (bury-buffer (current-buffer)) | |
| 11645 (set-buffer-modified-p nil) | |
| 11646 (let ((auto (make-auto-save-file-name)) | |
| 11647 (gnus-dribble-ignore t)) | |
| 11648 (if (or (file-exists-p auto) (file-exists-p dribble-file)) | |
| 11649 (progn | |
| 11650 (if (file-newer-than-file-p auto dribble-file) | |
| 11651 (setq dribble-file auto)) | |
| 11652 (insert-file-contents dribble-file) | |
| 11653 (if (not (zerop (buffer-size))) | |
| 11654 (set-buffer-modified-p t)) | |
| 11655 (if (gnus-y-or-n-p | |
| 11656 "Auto-save file exists. Do you want to read it? ") | |
| 11657 (setq gnus-dribble-eval-file t)))))))) | |
| 11658 | |
| 11659 (defun gnus-dribble-eval-file () | |
| 11660 (if (not gnus-dribble-eval-file) | |
| 11661 () | |
| 11662 (setq gnus-dribble-eval-file nil) | |
| 11663 (save-excursion | |
| 11664 (let ((gnus-dribble-ignore t)) | |
| 11665 (set-buffer gnus-dribble-buffer) | |
| 11666 (eval-buffer (current-buffer)))))) | |
| 11667 | |
| 11668 (defun gnus-dribble-delete-file () | |
| 11669 (if (file-exists-p (gnus-dribble-file-name)) | |
| 11670 (delete-file (gnus-dribble-file-name))) | |
| 11671 (if gnus-dribble-buffer | |
| 11672 (save-excursion | |
| 11673 (set-buffer gnus-dribble-buffer) | |
| 11674 (let ((auto (make-auto-save-file-name))) | |
| 11675 (if (file-exists-p auto) | |
| 11676 (delete-file auto)) | |
| 11677 (erase-buffer) | |
| 11678 (set-buffer-modified-p nil))))) | |
| 11679 | |
| 11680 (defun gnus-dribble-save () | |
| 11681 (if (and gnus-dribble-buffer | |
| 11682 (buffer-name gnus-dribble-buffer)) | |
| 11683 (save-excursion | |
| 11684 (set-buffer gnus-dribble-buffer) | |
| 11685 (save-buffer)))) | |
| 11686 | |
| 11687 (defun gnus-dribble-clear () | |
| 11688 (save-excursion | |
| 11689 (if (gnus-buffer-exists-p gnus-dribble-buffer) | |
| 11690 (progn | |
| 11691 (set-buffer gnus-dribble-buffer) | |
| 11692 (erase-buffer) | |
| 11693 (set-buffer-modified-p nil) | |
| 11694 (setq buffer-saved-size (buffer-size)))))) | |
| 11695 | |
| 11696 ;;; | |
| 11697 ;;; Server Communication | |
| 11698 ;;; | |
| 11699 | |
| 11700 (defun gnus-start-news-server (&optional confirm) | |
| 11701 "Open a method for getting news. | |
| 11702 If CONFIRM is non-nil, the user will be asked for an NNTP server." | |
| 11703 (let (how) | |
| 11704 (if gnus-current-select-method | |
| 11705 ;; Stream is already opened. | |
| 11706 nil | |
| 11707 ;; Open NNTP server. | |
| 11708 (if (null gnus-nntp-service) (setq gnus-nntp-server nil)) | |
| 11709 (if confirm | |
| 11710 (progn | |
| 11711 ;; Read server name with completion. | |
| 11712 (setq gnus-nntp-server | |
| 11713 (completing-read "NNTP server: " | |
| 11714 (mapcar (lambda (server) (list server)) | |
| 11715 (cons (list gnus-nntp-server) | |
| 11716 gnus-secondary-servers)) | |
| 11717 nil nil gnus-nntp-server)))) | |
| 11718 | |
| 11719 (if (and gnus-nntp-server | |
| 11720 (stringp gnus-nntp-server) | |
| 11721 (not (string= gnus-nntp-server ""))) | |
| 11722 (setq gnus-select-method | |
| 11723 (cond ((or (string= gnus-nntp-server "") | |
| 11724 (string= gnus-nntp-server "::")) | |
| 11725 (list 'nnspool (system-name))) | |
| 11726 ((string-match "^:" gnus-nntp-server) | |
| 11727 (list 'nnmh gnus-nntp-server | |
| 11728 (list 'nnmh-directory | |
| 11729 (file-name-as-directory | |
| 11730 (expand-file-name | |
| 11731 (concat "~/" (substring | |
| 11732 gnus-nntp-server 1))))) | |
| 11733 (list 'nnmh-get-new-mail nil))) | |
| 11734 (t | |
| 11735 (list 'nntp gnus-nntp-server))))) | |
| 11736 | |
| 11737 (setq how (car gnus-select-method)) | |
| 11738 (cond ((eq how 'nnspool) | |
| 11739 (require 'nnspool) | |
| 11740 (gnus-message 5 "Looking up local news spool...")) | |
| 11741 ((eq how 'nnmh) | |
| 11742 (require 'nnmh) | |
| 11743 (gnus-message 5 "Looking up mh spool...")) | |
| 11744 (t | |
| 11745 (require 'nntp))) | |
| 11746 (setq gnus-current-select-method gnus-select-method) | |
| 11747 (run-hooks 'gnus-open-server-hook) | |
| 11748 (or | |
| 11749 ;; gnus-open-server-hook might have opened it | |
| 11750 (gnus-server-opened gnus-select-method) | |
| 11751 (gnus-open-server gnus-select-method) | |
| 11752 (gnus-y-or-n-p | |
| 11753 (format | |
| 11754 "%s open error: '%s'. Continue? " | |
| 11755 (nth 1 gnus-select-method) | |
| 11756 (gnus-status-message gnus-select-method))) | |
| 11757 (progn | |
| 11758 (gnus-message 1 "Couldn't open server on %s" | |
| 11759 (nth 1 gnus-select-method)) | |
| 11760 (ding) | |
| 11761 nil))))) | |
| 11762 | |
| 11763 (defun gnus-check-server (&optional method) | |
| 11764 "If the news server is down, start it up again." | |
| 11765 (let ((method (if method method gnus-select-method))) | |
| 11766 (and (stringp method) | |
| 11767 (setq method (gnus-server-to-method method))) | |
| 11768 (if (gnus-server-opened method) | |
| 11769 ;; Stream is already opened. | |
| 11770 t | |
| 11771 ;; Open server. | |
| 11772 (gnus-message 5 "Opening server %s on %s..." (car method) (nth 1 method)) | |
| 11773 (run-hooks 'gnus-open-server-hook) | |
| 11774 (prog1 | |
| 11775 (gnus-open-server method) | |
| 11776 (message ""))))) | |
| 11777 | |
| 11778 (defun gnus-nntp-message (&optional message) | |
| 11779 "Check the status of the NNTP server. | |
| 11780 If the status of the server is clear and MESSAGE is non-nil, MESSAGE | |
| 11781 is returned insted of the status string." | |
| 11782 (let ((status (gnus-status-message (gnus-find-method-for-group | |
| 11783 gnus-newsgroup-name))) | |
| 11784 (message (or message ""))) | |
| 11785 (if (and (stringp status) (> (length status) 0)) | |
| 11786 status message))) | |
| 11787 | |
| 11788 (defun gnus-get-function (method function) | |
| 11789 (and (stringp method) | |
| 11790 (setq method (gnus-server-to-method method))) | |
| 11791 (let ((func (intern (format "%s-%s" (car method) function)))) | |
| 11792 (if (not (fboundp func)) | |
| 11793 (progn | |
| 11794 (require (car method)) | |
| 11795 (if (not (fboundp func)) | |
| 11796 (error "No such function: %s" func)))) | |
| 11797 func)) | |
| 11798 | |
| 11799 ;;; Interface functions to the backends. | |
| 11800 | |
| 11801 (defun gnus-open-server (method) | |
| 11802 (funcall (gnus-get-function method 'open-server) | |
| 11803 (nth 1 method) (nthcdr 2 method))) | |
| 11804 | |
| 11805 (defun gnus-close-server (method) | |
| 11806 (funcall (gnus-get-function method 'close-server) (nth 1 method))) | |
| 11807 | |
| 11808 (defun gnus-request-list (method) | |
| 11809 (funcall (gnus-get-function method 'request-list) (nth 1 method))) | |
| 11810 | |
| 11811 (defun gnus-request-list-newsgroups (method) | |
| 11812 (funcall (gnus-get-function method 'request-list-newsgroups) (nth 1 method))) | |
| 11813 | |
| 11814 (defun gnus-request-newgroups (date method) | |
| 11815 (funcall (gnus-get-function method 'request-newgroups) | |
| 11816 date (nth 1 method))) | |
| 11817 | |
| 11818 (defun gnus-server-opened (method) | |
| 11819 (funcall (gnus-get-function method 'server-opened) (nth 1 method))) | |
| 11820 | |
| 11821 (defun gnus-status-message (method) | |
| 11822 (let ((method (if (stringp method) (gnus-find-method-for-group method) | |
| 11823 method))) | |
| 11824 (funcall (gnus-get-function method 'status-message) (nth 1 method)))) | |
| 11825 | |
| 11826 (defun gnus-request-group (group &optional dont-check) | |
| 11827 (let ((method (gnus-find-method-for-group group))) | |
| 11828 (funcall (gnus-get-function method 'request-group) | |
| 11829 (gnus-group-real-name group) (nth 1 method) dont-check))) | |
| 11830 | |
| 11831 (defun gnus-request-asynchronous (group &optional articles) | |
| 11832 (let ((method (gnus-find-method-for-group group))) | |
| 11833 (funcall (gnus-get-function method 'request-asynchronous) | |
| 11834 (gnus-group-real-name group) (nth 1 method) articles))) | |
| 11835 | |
| 11836 (defun gnus-list-active-group (group) | |
| 11837 (let ((method (gnus-find-method-for-group group)) | |
| 11838 (func 'list-active-group)) | |
| 11839 (and (gnus-check-backend-function func group) | |
| 11840 (funcall (gnus-get-function method func) | |
| 11841 (gnus-group-real-name group) (nth 1 method))))) | |
| 11842 | |
| 11843 (defun gnus-request-group-description (group) | |
| 11844 (let ((method (gnus-find-method-for-group group)) | |
| 11845 (func 'request-group-description)) | |
| 11846 (and (gnus-check-backend-function func group) | |
| 11847 (funcall (gnus-get-function method func) | |
| 11848 (gnus-group-real-name group) (nth 1 method))))) | |
| 11849 | |
| 11850 (defun gnus-close-group (group) | |
| 11851 (let ((method (gnus-find-method-for-group group))) | |
| 11852 (funcall (gnus-get-function method 'close-group) | |
| 11853 (gnus-group-real-name group) (nth 1 method)))) | |
| 11854 | |
| 11855 (defun gnus-retrieve-headers (articles group) | |
| 11856 (let ((method (gnus-find-method-for-group group))) | |
| 11857 (if (and gnus-use-cache (numberp (car articles))) | |
| 11858 (gnus-cache-retrieve-headers articles group) | |
| 11859 (funcall (gnus-get-function method 'retrieve-headers) | |
| 11860 articles (gnus-group-real-name group) (nth 1 method))))) | |
| 11861 | |
| 11862 (defun gnus-retrieve-groups (groups method) | |
| 11863 (funcall (gnus-get-function method 'retrieve-groups) groups (nth 1 method))) | |
| 11864 | |
| 11865 (defun gnus-request-article (article group &optional buffer) | |
| 11866 (let ((method (gnus-find-method-for-group group))) | |
| 11867 (funcall (gnus-get-function method 'request-article) | |
| 11868 article (gnus-group-real-name group) (nth 1 method) buffer))) | |
| 11869 | |
| 11870 (defun gnus-request-head (article group) | |
| 11871 (let ((method (gnus-find-method-for-group group))) | |
| 11872 (funcall (gnus-get-function method 'request-head) | |
| 11873 article (gnus-group-real-name group) (nth 1 method)))) | |
| 11874 | |
| 11875 (defun gnus-request-body (article group) | |
| 11876 (let ((method (gnus-find-method-for-group group))) | |
| 11877 (funcall (gnus-get-function method 'request-body) | |
| 11878 article (gnus-group-real-name group) (nth 1 method)))) | |
| 11879 | |
| 11880 ;; Fix by Sudish Joseph <joseph@cis.ohio-state.edu>. | |
| 11881 (defun gnus-request-post-buffer (post group subject header artbuf | |
| 11882 info follow-to respect-poster) | |
| 11883 (let* ((info (or info (and group (nth 2 (gnus-gethash | |
| 11884 group gnus-newsrc-hashtb))))) | |
| 11885 (method | |
| 11886 (if (and gnus-post-method | |
| 11887 ;; Fix by Sudish Joseph <joseph@cis.ohio-state.edu>. | |
| 11888 (memq 'post (assoc | |
| 11889 (format "%s" (car (gnus-find-method-for-group | |
| 11890 gnus-newsgroup-name))) | |
| 11891 gnus-valid-select-methods))) | |
| 11892 gnus-post-method | |
| 11893 (gnus-find-method-for-group gnus-newsgroup-name)))) | |
| 11894 (or (gnus-check-server method) | |
| 11895 (error "Can't open server %s:%s" (car method) (nth 1 method))) | |
| 11896 (let ((mail-self-blind nil) | |
| 11897 (mail-archive-file-name nil)) | |
| 11898 (funcall (gnus-get-function method 'request-post-buffer) | |
| 11899 post group subject header artbuf info follow-to | |
| 11900 respect-poster)))) | |
| 11901 | |
| 11902 (defun gnus-request-post (method &optional force) | |
| 11903 (and (stringp method) | |
| 11904 (setq method (gnus-server-to-method method))) | |
| 11905 (and (not force) gnus-post-method | |
| 11906 (memq 'post (assoc (format "%s" (car method)) | |
| 11907 gnus-valid-select-methods)) | |
| 11908 (setq method gnus-post-method)) | |
| 11909 (funcall (gnus-get-function method 'request-post) | |
| 11910 (nth 1 method))) | |
| 11911 | |
| 11912 (defun gnus-request-expire-articles (articles group &optional force) | |
| 11913 (let ((method (gnus-find-method-for-group group))) | |
| 11914 (funcall (gnus-get-function method 'request-expire-articles) | |
| 11915 articles (gnus-group-real-name group) (nth 1 method) | |
| 11916 force))) | |
| 11917 | |
| 11918 (defun gnus-request-move-article | |
| 11919 (article group server accept-function &optional last) | |
| 11920 (let ((method (gnus-find-method-for-group group))) | |
| 11921 (funcall (gnus-get-function method 'request-move-article) | |
| 11922 article (gnus-group-real-name group) | |
| 11923 (nth 1 method) accept-function last))) | |
| 11924 | |
| 11925 (defun gnus-request-accept-article (group &optional last) | |
| 11926 (let ((func (if (symbolp group) group | |
| 11927 (car (gnus-find-method-for-group group))))) | |
| 11928 (funcall (intern (format "%s-request-accept-article" func)) | |
| 11929 (if (stringp group) (gnus-group-real-name group) group) | |
| 11930 last))) | |
| 11931 | |
| 11932 (defun gnus-request-replace-article (article group buffer) | |
| 11933 (let ((func (car (gnus-find-method-for-group group)))) | |
| 11934 (funcall (intern (format "%s-request-replace-article" func)) | |
| 11935 article (gnus-group-real-name group) buffer))) | |
| 11936 | |
| 11937 (defun gnus-request-create-group (group) | |
| 11938 (let ((method (gnus-find-method-for-group group))) | |
| 11939 (funcall (gnus-get-function method 'request-create-group) | |
| 11940 (gnus-group-real-name group) (nth 1 method)))) | |
| 11941 | |
| 11942 (defun gnus-member-of-valid (symbol group) | |
| 11943 (memq symbol (assoc | |
| 11944 (format "%s" (car (gnus-find-method-for-group group))) | |
| 11945 gnus-valid-select-methods))) | |
| 11946 | |
| 11947 (defun gnus-secondary-method-p (method) | |
| 11948 (let ((methods gnus-secondary-select-methods) | |
| 11949 (gmethod (gnus-server-get-method nil method))) | |
| 11950 (while (and methods | |
| 11951 (not (equal (gnus-server-get-method nil (car methods)) | |
| 11952 gmethod))) | |
| 11953 (setq methods (cdr methods))) | |
| 11954 methods)) | |
| 11955 | |
| 11956 (defun gnus-find-method-for-group (group &optional info) | |
| 11957 (or gnus-override-method | |
| 11958 (and (not group) | |
| 11959 gnus-select-method) | |
| 11960 (let ((info (or info (nth 2 (gnus-gethash group gnus-newsrc-hashtb)))) | |
| 11961 method) | |
| 11962 (if (or (not info) | |
| 11963 (not (setq method (nth 4 info)))) | |
| 11964 (setq method gnus-select-method) | |
| 11965 (setq method | |
| 11966 (cond ((stringp method) | |
| 11967 (gnus-server-to-method method)) | |
| 11968 ((stringp (car method)) | |
| 11969 (gnus-server-extend-method group method)) | |
| 11970 (t | |
| 11971 method)))) | |
| 11972 (gnus-server-add-address method)))) | |
| 11973 | |
| 11974 (defun gnus-check-backend-function (func group) | |
| 11975 (let ((method (if (stringp group) (car (gnus-find-method-for-group group)) | |
| 11976 group))) | |
| 11977 (fboundp (intern (format "%s-%s" method func))))) | |
| 11978 | |
| 11979 (defun gnus-methods-using (method) | |
| 11980 (let ((valids gnus-valid-select-methods) | |
| 11981 outs) | |
| 11982 (while valids | |
| 11983 (if (memq method (car valids)) | |
| 11984 (setq outs (cons (car valids) outs))) | |
| 11985 (setq valids (cdr valids))) | |
| 11986 outs)) | |
| 11987 | |
| 11988 ;;; | |
| 11989 ;;; Active & Newsrc File Handling | |
| 11990 ;;; | |
| 11991 | |
| 11992 ;; Newsrc related functions. | |
| 11993 ;; Gnus internal format of gnus-newsrc-alist: | |
| 11994 ;; (("alt.general" 3 (1 . 1)) | |
| 11995 ;; ("alt.misc" 3 ((1 . 10) (12 . 15))) | |
| 11996 ;; ("alt.test" 7 (1 . 99) (45 57 93)) ...) | |
| 11997 ;; The first item is the group name; the second is the subscription | |
| 11998 ;; level; the third is either a range of a list of ranges of read | |
| 11999 ;; articles, the optional fourth element is a list of marked articles, | |
| 12000 ;; the optional fifth element is the select method. | |
| 12001 ;; | |
| 12002 ;; Gnus internal format of gnus-newsrc-hashtb: | |
| 12003 ;; (95 ("alt.general" 3 (1 . 1)) ("alt.misc" 3 ((1 . 10) (12 . 15))) ...) | |
| 12004 ;; This is the entry for "alt.misc". The first element is the number | |
| 12005 ;; of unread articles in "alt.misc". The cdr of this entry is the | |
| 12006 ;; element *before* "alt.misc" in gnus-newsrc-alist, which makes is | |
| 12007 ;; trivial to remove or add new elements into gnus-newsrc-alist | |
| 12008 ;; without scanning the entire list. So, to get the actual information | |
| 12009 ;; of "alt.misc", you'd say something like | |
| 12010 ;; (nth 2 (gnus-gethash "alt.misc" gnus-newsrc-hashtb)) | |
| 12011 ;; | |
| 12012 ;; Gnus internal format of gnus-active-hashtb: | |
| 12013 ;; ((1 . 1)) | |
| 12014 ;; (5 . 10)) | |
| 12015 ;; (67 . 99)) ...) | |
| 12016 ;; The only element in each entry in this hash table is a range of | |
| 12017 ;; (possibly) available articles. (Articles in this range may have | |
| 12018 ;; been expired or canceled.) | |
| 12019 ;; | |
| 12020 ;; Gnus internal format of gnus-killed-list and gnus-zombie-list: | |
| 12021 ;; ("alt.misc" "alt.test" "alt.general" ...) | |
| 12022 | |
| 12023 (defun gnus-setup-news (&optional rawfile level) | |
| 12024 "Setup news information. | |
| 12025 If RAWFILE is non-nil, the .newsrc file will also be read. | |
| 12026 If LEVEL is non-nil, the news will be set up at level LEVEL." | |
| 12027 (let ((init (not (and gnus-newsrc-alist gnus-active-hashtb (not rawfile))))) | |
| 12028 ;; Clear some variables to re-initialize news information. | |
| 12029 (if init (setq gnus-newsrc-alist nil | |
| 12030 gnus-active-hashtb nil)) | |
| 12031 | |
| 12032 ;; Read the newsrc file and create `gnus-newsrc-hashtb'. | |
| 12033 (if init (gnus-read-newsrc-file rawfile)) | |
| 12034 | |
| 12035 ;; If we don't read the complete active file, we fill in the | |
| 12036 ;; hashtb here. | |
| 12037 (if (or (null gnus-read-active-file) | |
| 12038 (eq gnus-read-active-file 'some)) | |
| 12039 (gnus-update-active-hashtb-from-killed)) | |
| 12040 | |
| 12041 ;; Read the active file and create `gnus-active-hashtb'. | |
| 12042 ;; If `gnus-read-active-file' is nil, then we just create an empty | |
| 12043 ;; hash table. The partial filling out of the hash table will be | |
| 12044 ;; done in `gnus-get-unread-articles'. | |
| 12045 (and gnus-read-active-file | |
| 12046 (not level) | |
| 12047 (gnus-read-active-file)) | |
| 12048 | |
| 12049 (or gnus-active-hashtb | |
| 12050 (setq gnus-active-hashtb (make-vector 4095 0))) | |
| 12051 | |
| 12052 ;; Possibly eval the dribble file. | |
| 12053 (and init gnus-use-dribble-file (gnus-dribble-eval-file)) | |
| 12054 | |
| 12055 (gnus-update-format-specifications) | |
| 12056 | |
| 12057 ;; Find new newsgroups and treat them. | |
| 12058 (if (and init gnus-check-new-newsgroups gnus-read-active-file (not level) | |
| 12059 (gnus-server-opened gnus-select-method)) | |
| 12060 (gnus-find-new-newsgroups)) | |
| 12061 | |
| 12062 ;; Find the number of unread articles in each non-dead group. | |
| 12063 (let ((gnus-read-active-file (and (not level) gnus-read-active-file))) | |
| 12064 (gnus-get-unread-articles (or level (1+ gnus-level-subscribed)))) | |
| 12065 | |
| 12066 (if (and init gnus-check-bogus-newsgroups | |
| 12067 gnus-read-active-file (not level) | |
| 12068 (gnus-server-opened gnus-select-method)) | |
| 12069 (gnus-check-bogus-newsgroups)))) | |
| 12070 | |
| 12071 (defun gnus-find-new-newsgroups () | |
| 12072 "Search for new newsgroups and add them. | |
| 12073 Each new newsgroup will be treated with `gnus-subscribe-newsgroup-method.' | |
| 12074 The `-n' option line from .newsrc is respected." | |
| 12075 (interactive) | |
| 12076 (or (gnus-check-first-time-used) | |
| 12077 (if (or (consp gnus-check-new-newsgroups) | |
| 12078 (eq gnus-check-new-newsgroups 'ask-server)) | |
| 12079 (gnus-ask-server-for-new-groups) | |
| 12080 (let ((groups 0) | |
| 12081 group new-newsgroups) | |
| 12082 (gnus-message 5 "Looking for new newsgroups...") | |
| 12083 (or gnus-have-read-active-file (gnus-read-active-file)) | |
| 12084 (setq gnus-newsrc-last-checked-date (current-time-string)) | |
| 12085 (if (not gnus-killed-hashtb) (gnus-make-hashtable-from-killed)) | |
| 12086 ;; Go though every newsgroup in `gnus-active-hashtb' and compare | |
| 12087 ;; with `gnus-newsrc-hashtb' and `gnus-killed-hashtb'. | |
| 12088 (mapatoms | |
| 12089 (lambda (sym) | |
| 12090 (if (or (null (setq group (symbol-name sym))) | |
| 12091 (null (symbol-value sym)) | |
| 12092 (gnus-gethash group gnus-killed-hashtb) | |
| 12093 (gnus-gethash group gnus-newsrc-hashtb)) | |
| 12094 () | |
| 12095 (let ((do-sub (gnus-matches-options-n group))) | |
| 12096 (cond | |
| 12097 ((eq do-sub 'subscribe) | |
| 12098 (setq groups (1+ groups)) | |
| 12099 (gnus-sethash group group gnus-killed-hashtb) | |
| 12100 (funcall gnus-subscribe-options-newsgroup-method group)) | |
| 12101 ((eq do-sub 'ignore) | |
| 12102 nil) | |
| 12103 (t | |
| 12104 (setq groups (1+ groups)) | |
| 12105 (gnus-sethash group group gnus-killed-hashtb) | |
| 12106 (if gnus-subscribe-hierarchical-interactive | |
| 12107 (setq new-newsgroups (cons group new-newsgroups)) | |
| 12108 (funcall gnus-subscribe-newsgroup-method group))))))) | |
| 12109 gnus-active-hashtb) | |
| 12110 (if new-newsgroups | |
| 12111 (gnus-subscribe-hierarchical-interactive new-newsgroups)) | |
| 12112 ;; Suggested by Per Abrahamsen <amanda@iesd.auc.dk>. | |
| 12113 (if (> groups 0) | |
| 12114 (gnus-message 6 "%d new newsgroup%s arrived." | |
| 12115 groups (if (> groups 1) "s have" " has")) | |
| 12116 (gnus-message 6 "No new newsgroups.")))))) | |
| 12117 | |
| 12118 (defun gnus-matches-options-n (group) | |
| 12119 ;; Returns `subscribe' if the group is to be uncoditionally | |
| 12120 ;; subscribed, `ignore' if it is to be ignored, and nil if there is | |
| 12121 ;; no match for the group. | |
| 12122 | |
| 12123 ;; First we check the two user variables. | |
| 12124 (cond | |
| 12125 ((and gnus-options-subscribe | |
| 12126 (string-match gnus-options-subscribe group)) | |
| 12127 'subscribe) | |
| 12128 ((and gnus-options-not-subscribe | |
| 12129 (string-match gnus-options-not-subscribe group)) | |
| 12130 'ignore) | |
| 12131 ;; Then we go through the list that was retrieved from the .newsrc | |
| 12132 ;; file. This list has elements on the form | |
| 12133 ;; `(REGEXP . {ignore,subscribe})'. The first match found (the list | |
| 12134 ;; is in the reverse order of the options line) is returned. | |
| 12135 (t | |
| 12136 (let ((regs gnus-newsrc-options-n)) | |
| 12137 (while (and regs | |
| 12138 (not (string-match (car (car regs)) group))) | |
| 12139 (setq regs (cdr regs))) | |
| 12140 (and regs (cdr (car regs))))))) | |
| 12141 | |
| 12142 (defun gnus-ask-server-for-new-groups () | |
| 12143 (let* ((date (or gnus-newsrc-last-checked-date (current-time-string))) | |
| 12144 (methods (cons gnus-select-method | |
| 12145 (append | |
| 12146 (and (consp gnus-check-new-newsgroups) | |
| 12147 gnus-check-new-newsgroups) | |
| 12148 gnus-secondary-select-methods))) | |
| 12149 (groups 0) | |
| 12150 (new-date (current-time-string)) | |
| 12151 (hashtb (gnus-make-hashtable 100)) | |
| 12152 group new-newsgroups got-new method) | |
| 12153 ;; Go through both primary and secondary select methods and | |
| 12154 ;; request new newsgroups. | |
| 12155 (while methods | |
| 12156 (setq method (gnus-server-get-method nil (car methods))) | |
| 12157 (and (gnus-check-server method) | |
| 12158 (gnus-request-newgroups date method) | |
| 12159 (save-excursion | |
| 12160 (setq got-new t) | |
| 12161 (set-buffer nntp-server-buffer) | |
| 12162 ;; Enter all the new groups in a hashtable. | |
| 12163 (gnus-active-to-gnus-format method hashtb 'ignore))) | |
| 12164 (setq methods (cdr methods))) | |
| 12165 (and got-new (setq gnus-newsrc-last-checked-date new-date)) | |
| 12166 ;; Now all new groups from all select methods are in `hashtb'. | |
| 12167 (mapatoms | |
| 12168 (lambda (group-sym) | |
| 12169 (setq group (symbol-name group-sym)) | |
| 12170 (if (or (null group) | |
| 12171 (null (symbol-value group-sym)) | |
| 12172 (gnus-gethash group gnus-newsrc-hashtb) | |
| 12173 (member group gnus-zombie-list) | |
| 12174 (member group gnus-killed-list)) | |
| 12175 ;; The group is already known. | |
| 12176 () | |
| 12177 (and (symbol-value group-sym) | |
| 12178 (gnus-sethash group (symbol-value group-sym) gnus-active-hashtb)) | |
| 12179 (let ((do-sub (gnus-matches-options-n group))) | |
| 12180 (cond ((eq do-sub 'subscribe) | |
| 12181 (setq groups (1+ groups)) | |
| 12182 (gnus-sethash group group gnus-killed-hashtb) | |
| 12183 (funcall | |
| 12184 gnus-subscribe-options-newsgroup-method group)) | |
| 12185 ((eq do-sub 'ignore) | |
| 12186 nil) | |
| 12187 (t | |
| 12188 (setq groups (1+ groups)) | |
| 12189 (gnus-sethash group group gnus-killed-hashtb) | |
| 12190 (if gnus-subscribe-hierarchical-interactive | |
| 12191 (setq new-newsgroups (cons group new-newsgroups)) | |
| 12192 (funcall gnus-subscribe-newsgroup-method group))))))) | |
| 12193 hashtb) | |
| 12194 (if new-newsgroups | |
| 12195 (gnus-subscribe-hierarchical-interactive new-newsgroups)) | |
| 12196 ;; Suggested by Per Abrahamsen <amanda@iesd.auc.dk>. | |
| 12197 (if (> groups 0) | |
| 12198 (gnus-message 6 "%d new newsgroup%s arrived." | |
| 12199 groups (if (> groups 1) "s have" " has"))) | |
| 12200 got-new)) | |
| 12201 | |
| 12202 (defun gnus-check-first-time-used () | |
| 12203 (if (or (> (length gnus-newsrc-alist) 1) | |
| 12204 (file-exists-p gnus-startup-file) | |
| 12205 (file-exists-p (concat gnus-startup-file ".el")) | |
| 12206 (file-exists-p (concat gnus-startup-file ".eld"))) | |
| 12207 nil | |
| 12208 (gnus-message 6 "First time user; subscribing you to default groups") | |
| 12209 (or gnus-have-read-active-file (gnus-read-active-file)) | |
| 12210 (setq gnus-newsrc-last-checked-date (current-time-string)) | |
| 12211 (let ((groups gnus-default-subscribed-newsgroups) | |
| 12212 group) | |
| 12213 (if (eq groups t) | |
| 12214 nil | |
| 12215 (setq groups (or groups gnus-backup-default-subscribed-newsgroups)) | |
| 12216 (mapatoms | |
| 12217 (lambda (sym) | |
| 12218 (if (null (setq group (symbol-name sym))) | |
| 12219 () | |
| 12220 (let ((do-sub (gnus-matches-options-n group))) | |
| 12221 (cond | |
| 12222 ((eq do-sub 'subscribe) | |
| 12223 (gnus-sethash group group gnus-killed-hashtb) | |
| 12224 (funcall gnus-subscribe-options-newsgroup-method group)) | |
| 12225 ((eq do-sub 'ignore) | |
| 12226 nil) | |
| 12227 (t | |
| 12228 (setq gnus-killed-list (cons group gnus-killed-list))))))) | |
| 12229 gnus-active-hashtb) | |
| 12230 (while groups | |
| 12231 (if (gnus-gethash (car groups) gnus-active-hashtb) | |
| 12232 (gnus-group-change-level | |
| 12233 (car groups) gnus-level-default-subscribed gnus-level-killed)) | |
| 12234 (setq groups (cdr groups))) | |
| 12235 (gnus-group-make-help-group) | |
| 12236 (and gnus-novice-user | |
| 12237 (gnus-message 7 "`A k' to list killed groups")))))) | |
| 12238 | |
| 12239 (defun gnus-subscribe-group (group previous &optional method) | |
| 12240 (gnus-group-change-level | |
| 12241 (if method | |
| 12242 (list t group gnus-level-default-subscribed nil nil method) | |
| 12243 group) | |
| 12244 gnus-level-default-subscribed gnus-level-killed previous t)) | |
| 12245 | |
| 12246 ;; `gnus-group-change-level' is the fundamental function for changing | |
| 12247 ;; subscription levels of newsgroups. This might mean just changing | |
| 12248 ;; from level 1 to 2, which is pretty trivial, from 2 to 6 or back | |
| 12249 ;; again, which subscribes/unsubscribes a group, which is equally | |
| 12250 ;; trivial. Changing from 1-7 to 8-9 means that you kill a group, and | |
| 12251 ;; from 8-9 to 1-7 means that you remove the group from the list of | |
| 12252 ;; killed (or zombie) groups and add them to the (kinda) subscribed | |
| 12253 ;; groups. And last but not least, moving from 8 to 9 and 9 to 8, | |
| 12254 ;; which is trivial. | |
| 12255 ;; ENTRY can either be a string (newsgroup name) or a list (if | |
| 12256 ;; FROMKILLED is t, it's a list on the format (NUM INFO-LIST), | |
| 12257 ;; otherwise it's a list in the format of the `gnus-newsrc-hashtb' | |
| 12258 ;; entries. | |
| 12259 ;; LEVEL is the new level of the group, OLDLEVEL is the old level and | |
| 12260 ;; PREVIOUS is the group (in hashtb entry format) to insert this group | |
| 12261 ;; after. | |
| 12262 (defun gnus-group-change-level (entry level &optional oldlevel | |
| 12263 previous fromkilled) | |
| 12264 (let (group info active num) | |
| 12265 ;; Glean what info we can from the arguments | |
| 12266 (if (consp entry) | |
| 12267 (if fromkilled (setq group (nth 1 entry)) | |
| 12268 (setq group (car (nth 2 entry)))) | |
| 12269 (setq group entry)) | |
| 12270 (if (and (stringp entry) | |
| 12271 oldlevel | |
| 12272 (< oldlevel gnus-level-zombie)) | |
| 12273 (setq entry (gnus-gethash entry gnus-newsrc-hashtb))) | |
| 12274 (if (and (not oldlevel) | |
| 12275 (consp entry)) | |
| 12276 (setq oldlevel (car (cdr (nth 2 entry))))) | |
| 12277 (if (stringp previous) | |
| 12278 (setq previous (gnus-gethash previous gnus-newsrc-hashtb))) | |
| 12279 | |
| 12280 (if (and (>= oldlevel gnus-level-zombie) | |
| 12281 (gnus-gethash group gnus-newsrc-hashtb)) | |
| 12282 ;; We are trying to subscribe a group that is already | |
| 12283 ;; subscribed. | |
| 12284 () ; Do nothing. | |
| 12285 | |
| 12286 (or (gnus-ephemeral-group-p group) | |
| 12287 (gnus-dribble-enter | |
| 12288 (format "(gnus-group-change-level %S %S %S %S %S)" | |
| 12289 group level oldlevel (car (nth 2 previous)) fromkilled))) | |
| 12290 | |
| 12291 ;; Then we remove the newgroup from any old structures, if needed. | |
| 12292 ;; If the group was killed, we remove it from the killed or zombie | |
| 12293 ;; list. If not, and it is in fact going to be killed, we remove | |
| 12294 ;; it from the newsrc hash table and assoc. | |
| 12295 (cond ((>= oldlevel gnus-level-zombie) | |
| 12296 (if (= oldlevel gnus-level-zombie) | |
| 12297 (setq gnus-zombie-list (delete group gnus-zombie-list)) | |
| 12298 (setq gnus-killed-list (delete group gnus-killed-list)))) | |
| 12299 (t | |
| 12300 (if (and (>= level gnus-level-zombie) | |
| 12301 entry) | |
| 12302 (progn | |
| 12303 (gnus-sethash (car (nth 2 entry)) nil gnus-newsrc-hashtb) | |
| 12304 (if (nth 3 entry) | |
| 12305 (setcdr (gnus-gethash (car (nth 3 entry)) | |
| 12306 gnus-newsrc-hashtb) | |
| 12307 (cdr entry))) | |
| 12308 (setcdr (cdr entry) (cdr (cdr (cdr entry)))))))) | |
| 12309 | |
| 12310 ;; Finally we enter (if needed) the list where it is supposed to | |
| 12311 ;; go, and change the subscription level. If it is to be killed, | |
| 12312 ;; we enter it into the killed or zombie list. | |
| 12313 (cond ((>= level gnus-level-zombie) | |
| 12314 ;; Remove from the hash table. | |
| 12315 (gnus-sethash group nil gnus-newsrc-hashtb) | |
| 12316 (or (gnus-group-foreign-p group) | |
| 12317 ;; We do not enter foreign groups into the list of dead | |
| 12318 ;; groups. | |
| 12319 (if (= level gnus-level-zombie) | |
| 12320 (setq gnus-zombie-list (cons group gnus-zombie-list)) | |
| 12321 (setq gnus-killed-list (cons group gnus-killed-list))))) | |
| 12322 (t | |
| 12323 ;; If the list is to be entered into the newsrc assoc, and | |
| 12324 ;; it was killed, we have to create an entry in the newsrc | |
| 12325 ;; hashtb format and fix the pointers in the newsrc assoc. | |
| 12326 (if (>= oldlevel gnus-level-zombie) | |
| 12327 (progn | |
| 12328 (if (listp entry) | |
| 12329 (progn | |
| 12330 (setq info (cdr entry)) | |
| 12331 (setq num (car entry))) | |
| 12332 (setq active (gnus-gethash group gnus-active-hashtb)) | |
| 12333 (setq num | |
| 12334 (if active (- (1+ (cdr active)) (car active)) t)) | |
| 12335 ;; Check whether the group is foreign. If so, the | |
| 12336 ;; foreign select method has to be entered into the | |
| 12337 ;; info. | |
| 12338 (let ((method (gnus-group-method-name group))) | |
| 12339 (if (eq method gnus-select-method) | |
| 12340 (setq info (list group level nil)) | |
| 12341 (setq info (list group level nil nil method))))) | |
| 12342 (or previous | |
| 12343 (setq previous | |
| 12344 (let ((p gnus-newsrc-alist)) | |
| 12345 (while (cdr (cdr p)) | |
| 12346 (setq p (cdr p))) | |
| 12347 p))) | |
| 12348 (setq entry (cons info (cdr (cdr previous)))) | |
| 12349 (if (cdr previous) | |
| 12350 (progn | |
| 12351 (setcdr (cdr previous) entry) | |
| 12352 (gnus-sethash group (cons num (cdr previous)) | |
| 12353 gnus-newsrc-hashtb)) | |
| 12354 (setcdr previous entry) | |
| 12355 (gnus-sethash group (cons num previous) | |
| 12356 gnus-newsrc-hashtb)) | |
| 12357 (if (cdr entry) | |
| 12358 (setcdr (gnus-gethash (car (car (cdr entry))) | |
| 12359 gnus-newsrc-hashtb) | |
| 12360 entry))) | |
| 12361 ;; It was alive, and it is going to stay alive, so we | |
| 12362 ;; just change the level and don't change any pointers or | |
| 12363 ;; hash table entries. | |
| 12364 (setcar (cdr (car (cdr (cdr entry)))) level))))))) | |
| 12365 | |
| 12366 (defun gnus-kill-newsgroup (newsgroup) | |
| 12367 "Obsolete function. Kills a newsgroup." | |
| 12368 (gnus-group-change-level | |
| 12369 (gnus-gethash newsgroup gnus-newsrc-hashtb) gnus-level-killed)) | |
| 12370 | |
| 12371 (defun gnus-check-bogus-newsgroups (&optional confirm) | |
| 12372 "Remove bogus newsgroups. | |
| 12373 If CONFIRM is non-nil, the user has to confirm the deletion of every | |
| 12374 newsgroup." | |
| 12375 (let ((newsrc (cdr gnus-newsrc-alist)) | |
| 12376 bogus group entry) | |
| 12377 (gnus-message 5 "Checking bogus newsgroups...") | |
| 12378 (or gnus-have-read-active-file (gnus-read-active-file)) | |
| 12379 ;; Find all bogus newsgroup that are subscribed. | |
| 12380 (while newsrc | |
| 12381 (setq group (car (car newsrc))) | |
| 12382 (if (or (gnus-gethash group gnus-active-hashtb) ; Active | |
| 12383 (nth 4 (car newsrc)) ; Foreign | |
| 12384 (and confirm | |
| 12385 (not (gnus-y-or-n-p | |
| 12386 (format "Remove bogus newsgroup: %s " group))))) | |
| 12387 ;; Don't remove. | |
| 12388 () | |
| 12389 ;; Found a bogus newsgroup. | |
| 12390 (setq bogus (cons group bogus))) | |
| 12391 (setq newsrc (cdr newsrc))) | |
| 12392 ;; Remove all bogus subscribed groups by first killing them, and | |
| 12393 ;; then removing them from the list of killed groups. | |
| 12394 (while bogus | |
| 12395 (and (setq entry (gnus-gethash (car bogus) gnus-newsrc-hashtb)) | |
| 12396 (progn | |
| 12397 (gnus-group-change-level entry gnus-level-killed) | |
| 12398 (setq gnus-killed-list (delete (car bogus) gnus-killed-list)))) | |
| 12399 (setq bogus (cdr bogus))) | |
| 12400 ;; Then we remove all bogus groups from the list of killed and | |
| 12401 ;; zombie groups. They are are removed without confirmation. | |
| 12402 (let ((dead-lists '(gnus-killed-list gnus-zombie-list)) | |
| 12403 killed) | |
| 12404 (while dead-lists | |
| 12405 (setq killed (symbol-value (car dead-lists))) | |
| 12406 (while killed | |
| 12407 (setq group (car killed)) | |
| 12408 (or (gnus-gethash group gnus-active-hashtb) | |
| 12409 ;; The group is bogus. | |
| 12410 (set (car dead-lists) | |
| 12411 (delete group (symbol-value (car dead-lists))))) | |
| 12412 (setq killed (cdr killed))) | |
| 12413 (setq dead-lists (cdr dead-lists)))) | |
| 12414 (gnus-message 5 "Checking bogus newsgroups...done"))) | |
| 12415 | |
| 12416 (defun gnus-check-duplicate-killed-groups () | |
| 12417 "Remove duplicates from the list of killed groups." | |
| 12418 (interactive) | |
| 12419 (let ((killed gnus-killed-list)) | |
| 12420 (while killed | |
| 12421 (gnus-message 9 "%d" (length killed)) | |
| 12422 (setcdr killed (delete (car killed) (cdr killed))) | |
| 12423 (setq killed (cdr killed))))) | |
| 12424 | |
| 12425 ;; Go though `gnus-newsrc-alist' and compare with `gnus-active-hashtb' | |
| 12426 ;; and compute how many unread articles there are in each group. | |
| 12427 (defun gnus-get-unread-articles (&optional level) | |
| 12428 (let* ((newsrc (cdr gnus-newsrc-alist)) | |
| 12429 (level (or level (1+ gnus-level-subscribed))) | |
| 12430 (foreign-level | |
| 12431 (min | |
| 12432 (cond ((and gnus-activate-foreign-newsgroups | |
| 12433 (not (numberp gnus-activate-foreign-newsgroups))) | |
| 12434 (1+ gnus-level-subscribed)) | |
| 12435 ((numberp gnus-activate-foreign-newsgroups) | |
| 12436 gnus-activate-foreign-newsgroups) | |
| 12437 (t 0)) | |
| 12438 level)) | |
| 12439 info group active virtuals method) | |
| 12440 (gnus-message 5 "Checking new news...") | |
| 12441 | |
| 12442 (while newsrc | |
| 12443 (setq info (car newsrc) | |
| 12444 group (car info) | |
| 12445 active (gnus-gethash group gnus-active-hashtb)) | |
| 12446 | |
| 12447 ;; Check newsgroups. If the user doesn't want to check them, or | |
| 12448 ;; they can't be checked (for instance, if the news server can't | |
| 12449 ;; be reached) we just set the number of unread articles in this | |
| 12450 ;; newsgroup to t. This means that Gnus thinks that there are | |
| 12451 ;; unread articles, but it has no idea how many. | |
| 12452 (if (and (setq method (nth 4 info)) | |
| 12453 (not (gnus-server-equal gnus-select-method | |
| 12454 (gnus-server-get-method nil method))) | |
| 12455 (not (gnus-secondary-method-p method))) | |
| 12456 ;; These groups are foreign. Check the level. | |
| 12457 (if (<= (nth 1 info) foreign-level) | |
| 12458 (if (eq (car (if (stringp method) | |
| 12459 (gnus-server-to-method method) | |
| 12460 (nth 4 info))) 'nnvirtual) | |
| 12461 ;; We have to activate the virtual groups after all | |
| 12462 ;; the others, so we just pop them on a list for | |
| 12463 ;; now. | |
| 12464 (setq virtuals (cons info virtuals)) | |
| 12465 (and (setq active (gnus-activate-group (car info))) | |
| 12466 ;; Close the groups as we look at them! | |
| 12467 (gnus-close-group group)))) | |
| 12468 | |
| 12469 ;; These groups are native or secondary. | |
| 12470 (if (and (not gnus-read-active-file) | |
| 12471 (<= (nth 1 info) level)) | |
| 12472 (progn | |
| 12473 (or gnus-read-active-file (gnus-check-server method)) | |
| 12474 (setq active (gnus-activate-group (car info)))))) | |
| 12475 | |
| 12476 (if active | |
| 12477 (gnus-get-unread-articles-in-group info active) | |
| 12478 ;; The group couldn't be reached, so we nix out the number of | |
| 12479 ;; unread articles and stuff. | |
| 12480 (gnus-sethash group nil gnus-active-hashtb) | |
| 12481 (setcar (gnus-gethash group gnus-newsrc-hashtb) t)) | |
| 12482 | |
| 12483 (setq newsrc (cdr newsrc))) | |
| 12484 | |
| 12485 ;; Activate the virtual groups. This has to be done after all the | |
| 12486 ;; other groups. | |
| 12487 ;; !!! If one virtual group contains another virtual group, even | |
| 12488 ;; doing it this way might cause problems. | |
| 12489 (while virtuals | |
| 12490 (and (setq active (gnus-activate-group (car (car virtuals)))) | |
| 12491 (gnus-get-unread-articles-in-group (car virtuals) active)) | |
| 12492 (setq virtuals (cdr virtuals))) | |
| 12493 | |
| 12494 (gnus-message 5 "Checking new news...done"))) | |
| 12495 | |
| 12496 ;; Create a hash table out of the newsrc alist. The `car's of the | |
| 12497 ;; alist elements are used as keys. | |
| 12498 (defun gnus-make-hashtable-from-newsrc-alist () | |
| 12499 (let ((alist gnus-newsrc-alist) | |
| 12500 (ohashtb gnus-newsrc-hashtb) | |
| 12501 prev) | |
| 12502 (setq gnus-newsrc-hashtb (gnus-make-hashtable (length alist))) | |
| 12503 (setq alist | |
| 12504 (setq prev (setq gnus-newsrc-alist | |
| 12505 (if (equal (car (car gnus-newsrc-alist)) | |
| 12506 "dummy.group") | |
| 12507 gnus-newsrc-alist | |
| 12508 (cons (list "dummy.group" 0 nil) alist))))) | |
| 12509 (while alist | |
| 12510 (gnus-sethash (car (car alist)) | |
| 12511 (cons (and ohashtb (car (gnus-gethash | |
| 12512 (car (car alist)) ohashtb))) | |
| 12513 prev) gnus-newsrc-hashtb) | |
| 12514 (setq prev alist | |
| 12515 alist (cdr alist))))) | |
| 12516 | |
| 12517 (defun gnus-make-hashtable-from-killed () | |
| 12518 "Create a hash table from the killed and zombie lists." | |
| 12519 (let ((lists '(gnus-killed-list gnus-zombie-list)) | |
| 12520 list) | |
| 12521 (setq gnus-killed-hashtb | |
| 12522 (gnus-make-hashtable | |
| 12523 (+ (length gnus-killed-list) (length gnus-zombie-list)))) | |
| 12524 (while lists | |
| 12525 (setq list (symbol-value (car lists))) | |
| 12526 (setq lists (cdr lists)) | |
| 12527 (while list | |
| 12528 (gnus-sethash (car list) (car list) gnus-killed-hashtb) | |
| 12529 (setq list (cdr list)))))) | |
| 12530 | |
| 12531 (defun gnus-get-unread-articles-in-group (info active) | |
| 12532 (let* ((range (nth 2 info)) | |
| 12533 (num 0) | |
| 12534 (marked (nth 3 info))) | |
| 12535 ;; If a cache is present, we may have to alter the active info. | |
| 12536 (and gnus-use-cache | |
| 12537 (gnus-cache-possibly-alter-active (car info) active)) | |
| 12538 ;; Modify the list of read articles according to what articles | |
| 12539 ;; are available; then tally the unread articles and add the | |
| 12540 ;; number to the group hash table entry. | |
| 12541 (cond | |
| 12542 ((zerop (cdr active)) | |
| 12543 (setq num 0)) | |
| 12544 ((not range) | |
| 12545 (setq num (- (1+ (cdr active)) (car active)))) | |
| 12546 ((not (listp (cdr range))) | |
| 12547 ;; Fix a single (num . num) range according to the | |
| 12548 ;; active hash table. | |
| 12549 ;; Fix by Carsten Bormann <cabo@Informatik.Uni-Bremen.DE>. | |
| 12550 (and (< (cdr range) (car active)) (setcdr range (1- (car active)))) | |
| 12551 (and (> (cdr range) (cdr active)) (setcdr range (cdr active))) | |
| 12552 ;; Compute number of unread articles. | |
| 12553 (setq num (max 0 (- (cdr active) (- (1+ (cdr range)) (car range)))))) | |
| 12554 (t | |
| 12555 ;; The read list is a list of ranges. Fix them according to | |
| 12556 ;; the active hash table. | |
| 12557 ;; First peel off any elements that are below the lower | |
| 12558 ;; active limit. | |
| 12559 (while (and (cdr range) | |
| 12560 (>= (car active) | |
| 12561 (or (and (atom (car (cdr range))) (car (cdr range))) | |
| 12562 (car (car (cdr range)))))) | |
| 12563 (if (numberp (car range)) | |
| 12564 (setcar range | |
| 12565 (cons (car range) | |
| 12566 (or (and (numberp (car (cdr range))) | |
| 12567 (car (cdr range))) | |
| 12568 (cdr (car (cdr range)))))) | |
| 12569 (setcdr (car range) | |
| 12570 (or (and (numberp (nth 1 range)) (nth 1 range)) | |
| 12571 (cdr (car (cdr range)))))) | |
| 12572 (setcdr range (cdr (cdr range)))) | |
| 12573 ;; Adjust the first element to be the same as the lower limit. | |
| 12574 (if (and (not (atom (car range))) | |
| 12575 (< (cdr (car range)) (car active))) | |
| 12576 (setcdr (car range) (1- (car active)))) | |
| 12577 ;; Then we want to peel off any elements that are higher | |
| 12578 ;; than the upper active limit. | |
| 12579 (let ((srange range)) | |
| 12580 ;; Go past all legal elements. | |
| 12581 (while (and (cdr srange) | |
| 12582 (<= (or (and (atom (car (cdr srange))) | |
| 12583 (car (cdr srange))) | |
| 12584 (car (car (cdr srange)))) (cdr active))) | |
| 12585 (setq srange (cdr srange))) | |
| 12586 (if (cdr srange) | |
| 12587 ;; Nuke all remaining illegal elements. | |
| 12588 (setcdr srange nil)) | |
| 12589 | |
| 12590 ;; Adjust the final element. | |
| 12591 (if (and (not (atom (car srange))) | |
| 12592 (> (cdr (car srange)) (cdr active))) | |
| 12593 (setcdr (car srange) (cdr active)))) | |
| 12594 ;; Compute the number of unread articles. | |
| 12595 (while range | |
| 12596 (setq num (+ num (- (1+ (or (and (atom (car range)) (car range)) | |
| 12597 (cdr (car range)))) | |
| 12598 (or (and (atom (car range)) (car range)) | |
| 12599 (car (car range)))))) | |
| 12600 (setq range (cdr range))) | |
| 12601 (setq num (max 0 (- (cdr active) num))))) | |
| 12602 (and info | |
| 12603 (progn | |
| 12604 (and (assq 'tick marked) | |
| 12605 (inline (gnus-remove-illegal-marked-articles | |
| 12606 (assq 'tick marked) (nth 2 info)))) | |
| 12607 (and (assq 'dormant marked) | |
| 12608 (inline (gnus-remove-illegal-marked-articles | |
| 12609 (assq 'dormant marked) (nth 2 info)))) | |
| 12610 (setcar | |
| 12611 (gnus-gethash (car info) gnus-newsrc-hashtb) | |
| 12612 (setq num (max 0 (- num (length (cdr (assq 'tick marked))) | |
| 12613 (length (cdr (assq 'dormant marked))))))))) | |
| 12614 num)) | |
| 12615 | |
| 12616 (defun gnus-remove-illegal-marked-articles (marked ranges) | |
| 12617 (let ((m (cdr marked))) | |
| 12618 ;; Make sure that all ticked articles are a subset of the unread | |
| 12619 ;; articles. | |
| 12620 (while m | |
| 12621 (if (gnus-member-of-range (car m) ranges) | |
| 12622 (setcdr marked (cdr m)) | |
| 12623 (setq marked m)) | |
| 12624 (setq m (cdr m))))) | |
| 12625 | |
| 12626 (defun gnus-activate-group (group) | |
| 12627 ;; Check whether a group has been activated or not. | |
| 12628 (let ((method (gnus-find-method-for-group group)) | |
| 12629 active) | |
| 12630 (and (gnus-check-server method) | |
| 12631 ;; We escape all bugs and quit here to make it possible to | |
| 12632 ;; continue if a group is so out-there that it reports bugs | |
| 12633 ;; and stuff. | |
| 12634 (condition-case () | |
| 12635 (gnus-request-group group) | |
| 12636 (error nil) | |
| 12637 (quit nil)) | |
| 12638 (save-excursion | |
| 12639 (set-buffer nntp-server-buffer) | |
| 12640 (goto-char (point-min)) | |
| 12641 ;; Parse the result we got from `gnus-request-group'. | |
| 12642 (and (looking-at "[0-9]+ [0-9]+ \\([0-9]+\\) [0-9]+") | |
| 12643 (progn | |
| 12644 (goto-char (match-beginning 1)) | |
| 12645 (gnus-sethash | |
| 12646 group (setq active (cons (read (current-buffer)) | |
| 12647 (read (current-buffer)))) | |
| 12648 gnus-active-hashtb)) | |
| 12649 ;; Return the new active info. | |
| 12650 active))))) | |
| 12651 | |
| 12652 (defun gnus-update-read-articles | |
| 12653 (group unread unselected ticked &optional domarks replied expirable killed | |
| 12654 dormant bookmark score) | |
| 12655 "Update the list of read and ticked articles in GROUP using the | |
| 12656 UNREAD and TICKED lists. | |
| 12657 Note: UNSELECTED has to be sorted over `<'. | |
| 12658 Returns whether the updating was successful." | |
| 12659 (let* ((active (or gnus-newsgroup-active | |
| 12660 (gnus-gethash group gnus-active-hashtb))) | |
| 12661 (entry (gnus-gethash group gnus-newsrc-hashtb)) | |
| 12662 (info (nth 2 entry)) | |
| 12663 (marked (nth 3 info)) | |
| 12664 (prev 1) | |
| 12665 (unread (sort (copy-sequence unread) (function <))) | |
| 12666 read) | |
| 12667 (if (or (not info) (not active)) | |
| 12668 ;; There is no info on this group if it was, in fact, | |
| 12669 ;; killed. Gnus stores no information on killed groups, so | |
| 12670 ;; there's nothing to be done. | |
| 12671 ;; One could store the information somewhere temporarily, | |
| 12672 ;; perhaps... Hmmm... | |
| 12673 () | |
| 12674 ;; Remove any negative articles numbers. | |
| 12675 (while (and unread (< (car unread) 0)) | |
| 12676 (setq unread (cdr unread))) | |
| 12677 ;; Remove any expired article numbers | |
| 12678 (while (and unread (< (car unread) (car active))) | |
| 12679 (setq unread (cdr unread))) | |
| 12680 (while (and ticked (< (car ticked) (car active))) | |
| 12681 (setq ticked (cdr ticked))) | |
| 12682 (while (and dormant (< (car dormant) (car active))) | |
| 12683 (setq dormant (cdr dormant))) | |
| 12684 (setq unread (sort (append unselected unread) '<)) | |
| 12685 ;; Compute the ranges of read articles by looking at the list of | |
| 12686 ;; unread articles. | |
| 12687 (while unread | |
| 12688 (if (/= (car unread) prev) | |
| 12689 (setq read (cons (if (= prev (1- (car unread))) prev | |
| 12690 (cons prev (1- (car unread)))) read))) | |
| 12691 (setq prev (1+ (car unread))) | |
| 12692 (setq unread (cdr unread))) | |
| 12693 (if (<= prev (cdr active)) | |
| 12694 (setq read (cons (cons prev (cdr active)) read))) | |
| 12695 ;; Enter this list into the group info. | |
| 12696 (setcar (cdr (cdr info)) | |
| 12697 (if (> (length read) 1) (nreverse read) read)) | |
| 12698 ;; Enter the list of ticked articles. | |
| 12699 (gnus-set-marked-articles | |
| 12700 info ticked | |
| 12701 (if domarks replied (cdr (assq 'reply marked))) | |
| 12702 (if domarks expirable (cdr (assq 'expire marked))) | |
| 12703 (if domarks killed (cdr (assq 'killed marked))) | |
| 12704 (if domarks dormant (cdr (assq 'dormant marked))) | |
| 12705 (if domarks bookmark (cdr (assq 'bookmark marked))) | |
| 12706 (if domarks score (cdr (assq 'score marked)))) | |
| 12707 ;; Set the number of unread articles in gnus-newsrc-hashtb. | |
| 12708 (gnus-get-unread-articles-in-group | |
| 12709 info (gnus-gethash group gnus-active-hashtb)) | |
| 12710 t))) | |
| 12711 | |
| 12712 (defun gnus-make-articles-unread (group articles) | |
| 12713 "Mark ARTICLES in GROUP as unread." | |
| 12714 (let* ((info (nth 2 (or (gnus-gethash group gnus-newsrc-hashtb) | |
| 12715 (gnus-gethash (gnus-group-real-name group) | |
| 12716 gnus-newsrc-hashtb)))) | |
| 12717 (ranges (nth 2 info)) | |
| 12718 news) | |
| 12719 (while articles | |
| 12720 (and (gnus-member-of-range (car articles) ranges) | |
| 12721 (setq news (cons (car articles) news))) | |
| 12722 (setq articles (cdr articles))) | |
| 12723 (if (not news) | |
| 12724 () | |
| 12725 (setcar (nthcdr 2 info) | |
| 12726 (gnus-remove-from-range (nth 2 info) (nreverse news))) | |
| 12727 (gnus-group-update-group group t)))) | |
| 12728 | |
| 12729 ;; Enter all dead groups into the hashtb. | |
| 12730 (defun gnus-update-active-hashtb-from-killed () | |
| 12731 (let ((hashtb (setq gnus-active-hashtb (make-vector 4095 0))) | |
| 12732 (lists (list gnus-killed-list gnus-zombie-list)) | |
| 12733 killed) | |
| 12734 (while lists | |
| 12735 (setq killed (car lists)) | |
| 12736 (while killed | |
| 12737 (gnus-sethash (car killed) nil hashtb) | |
| 12738 (setq killed (cdr killed))) | |
| 12739 (setq lists (cdr lists))))) | |
| 12740 | |
| 12741 ;; Get the active file(s) from the backend(s). | |
| 12742 (defun gnus-read-active-file () | |
| 12743 (gnus-group-set-mode-line) | |
| 12744 (let ((methods (if (gnus-check-server gnus-select-method) | |
| 12745 ;; The native server is available. | |
| 12746 (cons gnus-select-method gnus-secondary-select-methods) | |
| 12747 ;; The native server is down, so we just do the | |
| 12748 ;; secondary ones. | |
| 12749 gnus-secondary-select-methods)) | |
| 12750 list-type) | |
| 12751 (setq gnus-have-read-active-file nil) | |
| 12752 (save-excursion | |
| 12753 (set-buffer nntp-server-buffer) | |
| 12754 (while methods | |
| 12755 (let* ((method (gnus-server-get-method nil (car methods))) | |
| 12756 (where (nth 1 method)) | |
| 12757 (mesg (format "Reading active file%s via %s..." | |
| 12758 (if (and where (not (zerop (length where)))) | |
| 12759 (concat " from " where) "") | |
| 12760 (car method)))) | |
| 12761 (gnus-message 5 mesg) | |
| 12762 (if (not (gnus-check-server method)) | |
| 12763 () | |
| 12764 (cond | |
| 12765 ((and (eq gnus-read-active-file 'some) | |
| 12766 (gnus-check-backend-function 'retrieve-groups (car method))) | |
| 12767 (let ((newsrc (cdr gnus-newsrc-alist)) | |
| 12768 (gmethod (gnus-server-get-method nil method)) | |
| 12769 groups) | |
| 12770 (while newsrc | |
| 12771 (and (gnus-server-equal | |
| 12772 (gnus-find-method-for-group | |
| 12773 (car (car newsrc)) (car newsrc)) | |
| 12774 gmethod) | |
| 12775 (setq groups (cons (gnus-group-real-name | |
| 12776 (car (car newsrc))) groups))) | |
| 12777 (setq newsrc (cdr newsrc))) | |
| 12778 (gnus-check-server method) | |
| 12779 (setq list-type (gnus-retrieve-groups groups method)) | |
| 12780 (cond | |
| 12781 ((not list-type) | |
| 12782 (gnus-message | |
| 12783 1 "Cannot read partial active file from %s server." | |
| 12784 (car method)) | |
| 12785 (ding) | |
| 12786 (sit-for 2)) | |
| 12787 ((eq list-type 'active) | |
| 12788 (gnus-active-to-gnus-format method gnus-active-hashtb)) | |
| 12789 (t | |
| 12790 (gnus-groups-to-gnus-format method gnus-active-hashtb))))) | |
| 12791 (t | |
| 12792 (if (not (gnus-request-list method)) | |
| 12793 (progn | |
| 12794 (gnus-message 1 "Cannot read active file from %s server." | |
| 12795 (car method)) | |
| 12796 (ding)) | |
| 12797 (gnus-active-to-gnus-format method) | |
| 12798 ;; We mark this active file as read. | |
| 12799 (setq gnus-have-read-active-file | |
| 12800 (cons method gnus-have-read-active-file)) | |
| 12801 (gnus-message 5 "%sdone" mesg)))))) | |
| 12802 (setq methods (cdr methods)))))) | |
| 12803 | |
| 12804 ;; Read an active file and place the results in `gnus-active-hashtb'. | |
| 12805 (defun gnus-active-to-gnus-format (method &optional hashtb ignore-errors) | |
| 12806 (let ((cur (current-buffer)) | |
| 12807 (hashtb (or hashtb | |
| 12808 (if (and gnus-active-hashtb | |
| 12809 (not (equal method gnus-select-method))) | |
| 12810 gnus-active-hashtb | |
| 12811 (setq gnus-active-hashtb | |
| 12812 (if (equal method gnus-select-method) | |
| 12813 (gnus-make-hashtable | |
| 12814 (count-lines (point-min) (point-max))) | |
| 12815 (gnus-make-hashtable 4096)))))) | |
| 12816 (flag-hashtb (gnus-make-hashtable 60))) | |
| 12817 ;; Delete unnecessary lines. | |
| 12818 (goto-char (point-min)) | |
| 12819 (while (search-forward "\nto." nil t) | |
| 12820 (delete-region (1+ (match-beginning 0)) | |
| 12821 (progn (forward-line 1) (point)))) | |
| 12822 (or (string= gnus-ignored-newsgroups "") | |
| 12823 (progn | |
| 12824 (goto-char (point-min)) | |
| 12825 (delete-matching-lines gnus-ignored-newsgroups))) | |
| 12826 ;; Make the group names readable as a lisp expression even if they | |
| 12827 ;; contain special characters. | |
| 12828 ;; Fix by Luc Van Eycken <Luc.VanEycken@esat.kuleuven.ac.be>. | |
| 12829 (goto-char (point-max)) | |
| 12830 (while (re-search-backward "[][';?()#]" nil t) | |
| 12831 (insert ?\\)) | |
| 12832 ;; If these are groups from a foreign select method, we insert the | |
| 12833 ;; group prefix in front of the group names. | |
| 12834 (and method (not (gnus-server-equal | |
| 12835 (gnus-server-get-method nil method) | |
| 12836 (gnus-server-get-method nil gnus-select-method))) | |
| 12837 (let ((prefix (gnus-group-prefixed-name "" method))) | |
| 12838 (goto-char (point-min)) | |
| 12839 (while (and (not (eobp)) | |
| 12840 (progn (insert prefix) | |
| 12841 (zerop (forward-line 1))))))) | |
| 12842 ;; Store the active file in a hash table. | |
| 12843 (goto-char (point-min)) | |
| 12844 (if (string-match "%[oO]" gnus-group-line-format) | |
| 12845 ;; Suggested by Brian Edmonds <edmonds@cs.ubc.ca>. | |
| 12846 ;; If we want information on moderated groups, we use this | |
| 12847 ;; loop... | |
| 12848 (let* ((mod-hashtb (make-vector 7 0)) | |
| 12849 (m (intern "m" mod-hashtb)) | |
| 12850 group max min) | |
| 12851 (while (not (eobp)) | |
| 12852 (condition-case nil | |
| 12853 (progn | |
| 12854 (narrow-to-region (point) (gnus-point-at-eol)) | |
| 12855 (setq group (let ((obarray hashtb)) (read cur))) | |
| 12856 (if (and (numberp (setq max (read cur))) | |
| 12857 (numberp (setq min (read cur))) | |
| 12858 (progn | |
| 12859 (skip-chars-forward " \t") | |
| 12860 (not | |
| 12861 (or (= (following-char) ?=) | |
| 12862 (= (following-char) ?x) | |
| 12863 (= (following-char) ?j))))) | |
| 12864 (set group (cons min max)) | |
| 12865 (set group nil)) | |
| 12866 ;; Enter moderated groups into a list. | |
| 12867 (if (eq (let ((obarray mod-hashtb)) (read cur)) m) | |
| 12868 (setq gnus-moderated-list | |
| 12869 (cons (symbol-name group) gnus-moderated-list)))) | |
| 12870 (error | |
| 12871 (and group | |
| 12872 (symbolp group) | |
| 12873 (set group nil)))) | |
| 12874 (widen) | |
| 12875 (forward-line 1))) | |
| 12876 ;; And if we do not care about moderation, we use this loop, | |
| 12877 ;; which is faster. | |
| 12878 (let (group max min) | |
| 12879 (while (not (eobp)) | |
| 12880 (condition-case () | |
| 12881 (progn | |
| 12882 (narrow-to-region (point) (gnus-point-at-eol)) | |
| 12883 ;; group gets set to a symbol interned in the hash table | |
| 12884 ;; (what a hack!!) - jwz | |
| 12885 (setq group (let ((obarray hashtb)) (read cur))) | |
| 12886 (if (and (numberp (setq max (read cur))) | |
| 12887 (numberp (setq min (read cur))) | |
| 12888 (progn | |
| 12889 (skip-chars-forward " \t") | |
| 12890 (not | |
| 12891 (or (= (following-char) ?=) | |
| 12892 (= (following-char) ?x) | |
| 12893 (= (following-char) ?j))))) | |
| 12894 (set group (cons min max)) | |
| 12895 (set group nil))) | |
| 12896 (error | |
| 12897 (progn | |
| 12898 (and group | |
| 12899 (symbolp group) | |
| 12900 (set group nil)) | |
| 12901 (or ignore-errors | |
| 12902 (gnus-message 3 "Warning - illegal active: %s" | |
| 12903 (buffer-substring | |
| 12904 (gnus-point-at-bol) (gnus-point-at-eol))))))) | |
| 12905 (widen) | |
| 12906 (forward-line 1)))))) | |
| 12907 | |
| 12908 (defun gnus-groups-to-gnus-format (method &optional hashtb) | |
| 12909 ;; Parse a "groups" active file. | |
| 12910 (let ((cur (current-buffer)) | |
| 12911 (hashtb (or hashtb | |
| 12912 (if (and method gnus-active-hashtb) | |
| 12913 gnus-active-hashtb | |
| 12914 (setq gnus-active-hashtb | |
| 12915 (gnus-make-hashtable | |
| 12916 (count-lines (point-min) (point-max))))))) | |
| 12917 (prefix (and method | |
| 12918 (not (gnus-server-equal | |
| 12919 (gnus-server-get-method nil method) | |
| 12920 (gnus-server-get-method nil gnus-select-method))) | |
| 12921 (gnus-group-prefixed-name "" method)))) | |
| 12922 | |
| 12923 (goto-char (point-min)) | |
| 12924 ;; We split this into to separate loops, one with the prefix | |
| 12925 ;; and one without to speed the reading up somewhat. | |
| 12926 (if prefix | |
| 12927 (let (min max opoint group) | |
| 12928 (while (not (eobp)) | |
| 12929 (condition-case () | |
| 12930 (progn | |
| 12931 (read cur) (read cur) | |
| 12932 (setq min (read cur) | |
| 12933 max (read cur) | |
| 12934 opoint (point)) | |
| 12935 (skip-chars-forward " \t") | |
| 12936 (insert prefix) | |
| 12937 (goto-char opoint) | |
| 12938 (set (let ((obarray hashtb)) (read cur)) | |
| 12939 (cons min max))) | |
| 12940 (error (and group (symbolp group) (set group nil)))) | |
| 12941 (forward-line 1))) | |
| 12942 (let (min max group) | |
| 12943 (while (not (eobp)) | |
| 12944 (condition-case () | |
| 12945 (if (= (following-char) ?2) | |
| 12946 (progn | |
| 12947 (read cur) (read cur) | |
| 12948 (setq min (read cur) | |
| 12949 max (read cur)) | |
| 12950 (set (setq group (let ((obarray hashtb)) (read cur))) | |
| 12951 (cons min max)))) | |
| 12952 (error (and group (symbolp group) (set group nil)))) | |
| 12953 (forward-line 1)))))) | |
| 12954 | |
| 12955 (defun gnus-read-newsrc-file (&optional force) | |
| 12956 "Read startup file. | |
| 12957 If FORCE is non-nil, the .newsrc file is read." | |
| 12958 ;; Reset variables that might be defined in the .newsrc.eld file. | |
| 12959 (let ((variables gnus-variable-list)) | |
| 12960 (while variables | |
| 12961 (set (car variables) nil) | |
| 12962 (setq variables (cdr variables)))) | |
| 12963 (let* ((newsrc-file gnus-current-startup-file) | |
| 12964 (quick-file (concat newsrc-file ".el"))) | |
| 12965 (save-excursion | |
| 12966 ;; We always load the .newsrc.eld file. If always contains | |
| 12967 ;; much information that can not be gotten from the .newsrc | |
| 12968 ;; file (ticked articles, killed groups, foreign methods, etc.) | |
| 12969 (gnus-read-newsrc-el-file quick-file) | |
| 12970 | |
| 12971 (if (or force | |
| 12972 (and (file-newer-than-file-p newsrc-file quick-file) | |
| 12973 (file-newer-than-file-p newsrc-file | |
| 12974 (concat quick-file "d"))) | |
| 12975 (not gnus-newsrc-alist)) | |
| 12976 ;; We read the .newsrc file. Note that if there if a | |
| 12977 ;; .newsrc.eld file exists, it has already been read, and | |
| 12978 ;; the `gnus-newsrc-hashtb' has been created. While reading | |
| 12979 ;; the .newsrc file, Gnus will only use the information it | |
| 12980 ;; can find there for changing the data already read - | |
| 12981 ;; ie. reading the .newsrc file will not trash the data | |
| 12982 ;; already read (except for read articles). | |
| 12983 (save-excursion | |
| 12984 (gnus-message 5 "Reading %s..." newsrc-file) | |
| 12985 (set-buffer (find-file-noselect newsrc-file)) | |
| 12986 (buffer-disable-undo (current-buffer)) | |
| 12987 (gnus-newsrc-to-gnus-format) | |
| 12988 (kill-buffer (current-buffer)) | |
| 12989 (gnus-message 5 "Reading %s...done" newsrc-file)))))) | |
| 12990 | |
| 12991 (defun gnus-read-newsrc-el-file (file) | |
| 12992 (let ((ding-file (concat file "d"))) | |
| 12993 ;; We always, always read the .eld file. | |
| 12994 (gnus-message 5 "Reading %s..." ding-file) | |
| 12995 (let (gnus-newsrc-assoc) | |
| 12996 (condition-case nil | |
| 12997 (load ding-file t t t) | |
| 12998 (error nil)) | |
| 12999 (and gnus-newsrc-assoc (setq gnus-newsrc-alist gnus-newsrc-assoc))) | |
| 13000 (let ((inhibit-quit t)) | |
| 13001 (gnus-uncompress-newsrc-alist)) | |
| 13002 (gnus-make-hashtable-from-newsrc-alist) | |
| 13003 (if (not (file-newer-than-file-p file ding-file)) | |
| 13004 () | |
| 13005 ;; Old format quick file | |
| 13006 (gnus-message 5 "Reading %s..." file) | |
| 13007 ;; The .el file is newer than the .eld file, so we read that one | |
| 13008 ;; as well. | |
| 13009 (gnus-read-old-newsrc-el-file file)))) | |
| 13010 | |
| 13011 ;; Parse the old-style quick startup file | |
| 13012 (defun gnus-read-old-newsrc-el-file (file) | |
| 13013 (let (newsrc killed marked group m) | |
| 13014 (prog1 | |
| 13015 (let ((gnus-killed-assoc nil) | |
| 13016 gnus-marked-assoc gnus-newsrc-alist gnus-newsrc-assoc) | |
| 13017 (prog1 | |
| 13018 (condition-case nil | |
| 13019 (load file t t t) | |
| 13020 (error nil)) | |
| 13021 (setq newsrc gnus-newsrc-assoc | |
| 13022 killed gnus-killed-assoc | |
| 13023 marked gnus-marked-assoc))) | |
| 13024 (setq gnus-newsrc-alist nil) | |
| 13025 (while newsrc | |
| 13026 (setq group (car newsrc)) | |
| 13027 (let ((info (nth 2 (gnus-gethash (car group) gnus-newsrc-hashtb)))) | |
| 13028 (if info | |
| 13029 (progn | |
| 13030 (setcar (nthcdr 2 info) (cdr (cdr group))) | |
| 13031 (setcar (cdr info) | |
| 13032 (if (nth 1 group) gnus-level-default-subscribed | |
| 13033 gnus-level-default-unsubscribed)) | |
| 13034 (setq gnus-newsrc-alist (cons info gnus-newsrc-alist))) | |
| 13035 (setq gnus-newsrc-alist | |
| 13036 (cons | |
| 13037 (setq info | |
| 13038 (list (car group) | |
| 13039 (if (nth 1 group) gnus-level-default-subscribed | |
| 13040 gnus-level-default-unsubscribed) | |
| 13041 (cdr (cdr group)))) | |
| 13042 gnus-newsrc-alist))) | |
| 13043 (if (setq m (assoc (car group) marked)) | |
| 13044 (setcdr (cdr (cdr info)) | |
| 13045 (cons (list (cons 'tick (cdr m))) nil)))) | |
| 13046 (setq newsrc (cdr newsrc))) | |
| 13047 (setq newsrc killed) | |
| 13048 (while newsrc | |
| 13049 (setcar newsrc (car (car newsrc))) | |
| 13050 (setq newsrc (cdr newsrc))) | |
| 13051 (setq gnus-killed-list killed)) | |
| 13052 ;; The .el file version of this variable does not begin with | |
| 13053 ;; "options", while the .eld version does, so we just add it if it | |
| 13054 ;; isn't there. | |
| 13055 (and | |
| 13056 gnus-newsrc-options | |
| 13057 (progn | |
| 13058 (and (not (string-match "^ *options" gnus-newsrc-options)) | |
| 13059 (setq gnus-newsrc-options (concat "options " gnus-newsrc-options))) | |
| 13060 (and (not (string-match "\n$" gnus-newsrc-options)) | |
| 13061 (setq gnus-newsrc-options (concat gnus-newsrc-options "\n"))) | |
| 13062 ;; Finally, if we read some options lines, we parse them. | |
| 13063 (or (string= gnus-newsrc-options "") | |
| 13064 (gnus-newsrc-parse-options gnus-newsrc-options)))) | |
| 13065 | |
| 13066 (setq gnus-newsrc-alist (nreverse gnus-newsrc-alist)) | |
| 13067 (gnus-make-hashtable-from-newsrc-alist))) | |
| 13068 | |
| 13069 (defun gnus-make-newsrc-file (file) | |
| 13070 "Make server dependent file name by catenating FILE and server host name." | |
| 13071 (let* ((file (expand-file-name file nil)) | |
| 13072 (real-file (concat file "-" (nth 1 gnus-select-method)))) | |
| 13073 (if (or (file-exists-p real-file) | |
| 13074 (file-exists-p (concat real-file ".el")) | |
| 13075 (file-exists-p (concat real-file ".eld"))) | |
| 13076 real-file file))) | |
| 13077 | |
| 13078 (defun gnus-uncompress-newsrc-alist () | |
| 13079 ;; Uncompress all lists of marked articles in the newsrc assoc. | |
| 13080 (let ((newsrc gnus-newsrc-alist) | |
| 13081 marked) | |
| 13082 (while newsrc | |
| 13083 (if (not (setq marked (nth 3 (car newsrc)))) | |
| 13084 () | |
| 13085 (while marked | |
| 13086 (or (eq 'score (car (car marked))) | |
| 13087 (eq 'bookmark (car (car marked))) | |
| 13088 (eq 'killed (car (car marked))) | |
| 13089 (setcdr (car marked) (gnus-uncompress-range (cdr (car marked))))) | |
| 13090 (setq marked (cdr marked)))) | |
| 13091 (setq newsrc (cdr newsrc))))) | |
| 13092 | |
| 13093 (defun gnus-compress-newsrc-alist () | |
| 13094 ;; Compress all lists of marked articles in the newsrc assoc. | |
| 13095 (let ((newsrc gnus-newsrc-alist) | |
| 13096 marked) | |
| 13097 (while newsrc | |
| 13098 (if (not (setq marked (nth 3 (car newsrc)))) | |
| 13099 () | |
| 13100 (while marked | |
| 13101 (or (eq 'score (car (car marked))) | |
| 13102 (eq 'bookmark (car (car marked))) | |
| 13103 (eq 'killed (car (car marked))) | |
| 13104 (setcdr (car marked) | |
| 13105 (condition-case () | |
| 13106 (gnus-compress-sequence | |
| 13107 (sort (cdr (car marked)) '<) t) | |
| 13108 (error (cdr (car marked)))))) | |
| 13109 (setq marked (cdr marked)))) | |
| 13110 (setq newsrc (cdr newsrc))))) | |
| 13111 | |
| 13112 (defun gnus-newsrc-to-gnus-format () | |
| 13113 (setq gnus-newsrc-options "") | |
| 13114 (setq gnus-newsrc-options-n nil) | |
| 13115 | |
| 13116 (or gnus-active-hashtb | |
| 13117 (setq gnus-active-hashtb (make-vector 4095 0))) | |
| 13118 (let ((buf (current-buffer)) | |
| 13119 (already-read (> (length gnus-newsrc-alist) 1)) | |
| 13120 group subscribed options-symbol newsrc Options-symbol | |
| 13121 symbol reads num1) | |
| 13122 (goto-char (point-min)) | |
| 13123 ;; We intern the symbol `options' in the active hashtb so that we | |
| 13124 ;; can `eq' against it later. | |
| 13125 (set (setq options-symbol (intern "options" gnus-active-hashtb)) nil) | |
| 13126 (set (setq Options-symbol (intern "Options" gnus-active-hashtb)) nil) | |
| 13127 | |
| 13128 (while (not (eobp)) | |
| 13129 ;; We first read the first word on the line by narrowing and | |
| 13130 ;; then reading into `gnus-active-hashtb'. Most groups will | |
| 13131 ;; already exist in that hashtb, so this will save some string | |
| 13132 ;; space. | |
| 13133 (narrow-to-region | |
| 13134 (point) | |
| 13135 (progn (skip-chars-forward "^ \t!:\n") (point))) | |
| 13136 (goto-char (point-min)) | |
| 13137 (setq symbol | |
| 13138 (and (/= (point-min) (point-max)) | |
| 13139 (let ((obarray gnus-active-hashtb)) (read buf)))) | |
| 13140 (widen) | |
| 13141 ;; Now, the symbol we have read is either `options' or a group | |
| 13142 ;; name. If it is an options line, we just add it to a string. | |
| 13143 (cond | |
| 13144 ((or (eq symbol options-symbol) | |
| 13145 (eq symbol Options-symbol)) | |
| 13146 (setq gnus-newsrc-options | |
| 13147 ;; This concatting is quite inefficient, but since our | |
| 13148 ;; thorough studies show that approx 99.37% of all | |
| 13149 ;; .newsrc files only contain a single options line, we | |
| 13150 ;; don't give a damn, frankly, my dear. | |
| 13151 (concat gnus-newsrc-options | |
| 13152 (buffer-substring | |
| 13153 (gnus-point-at-bol) | |
| 13154 ;; Options may continue on the next line. | |
| 13155 (or (and (re-search-forward "^[^ \t]" nil 'move) | |
| 13156 (progn (beginning-of-line) (point))) | |
| 13157 (point))))) | |
| 13158 (forward-line -1)) | |
| 13159 (symbol | |
| 13160 (or (boundp symbol) (set symbol nil)) | |
| 13161 ;; It was a group name. | |
| 13162 (setq subscribed (= (following-char) ?:) | |
| 13163 group (symbol-name symbol) | |
| 13164 reads nil) | |
| 13165 (if (eolp) | |
| 13166 ;; If the line ends here, this is clearly a buggy line, so | |
| 13167 ;; we put point a the beginning of line and let the cond | |
| 13168 ;; below do the error handling. | |
| 13169 (beginning-of-line) | |
| 13170 ;; We skip to the beginning of the ranges. | |
| 13171 (skip-chars-forward "!: \t")) | |
| 13172 ;; We are now at the beginning of the list of read articles. | |
| 13173 ;; We read them range by range. | |
| 13174 (while | |
| 13175 (cond | |
| 13176 ((looking-at "[0-9]+") | |
| 13177 ;; We narrow and read a number instead of buffer-substring/ | |
| 13178 ;; string-to-int because it's faster. narrow/widen is | |
| 13179 ;; faster than save-restriction/narrow, and save-restriction | |
| 13180 ;; produces a garbage object. | |
| 13181 (setq num1 (progn | |
| 13182 (narrow-to-region (match-beginning 0) (match-end 0)) | |
| 13183 (read buf))) | |
| 13184 (widen) | |
| 13185 ;; If the next character is a dash, then this is a range. | |
| 13186 (if (= (following-char) ?-) | |
| 13187 (progn | |
| 13188 ;; We read the upper bound of the range. | |
| 13189 (forward-char 1) | |
| 13190 (if (not (looking-at "[0-9]+")) | |
| 13191 ;; This is a buggy line, by we pretend that | |
| 13192 ;; it's kinda OK. Perhaps the user should be | |
| 13193 ;; dinged? | |
| 13194 (setq reads (cons num1 reads)) | |
| 13195 (setq reads | |
| 13196 (cons | |
| 13197 (cons num1 | |
| 13198 (progn | |
| 13199 (narrow-to-region (match-beginning 0) | |
| 13200 (match-end 0)) | |
| 13201 (read buf))) | |
| 13202 reads)) | |
| 13203 (widen))) | |
| 13204 ;; It was just a simple number, so we add it to the | |
| 13205 ;; list of ranges. | |
| 13206 (setq reads (cons num1 reads))) | |
| 13207 ;; If the next char in ?\n, then we have reached the end | |
| 13208 ;; of the line and return nil. | |
| 13209 (/= (following-char) ?\n)) | |
| 13210 ((= (following-char) ?\n) | |
| 13211 ;; End of line, so we end. | |
| 13212 nil) | |
| 13213 (t | |
| 13214 ;; Not numbers and not eol, so this might be a buggy | |
| 13215 ;; line... | |
| 13216 (or (eobp) | |
| 13217 ;; If it was eob instead of ?\n, we allow it. | |
| 13218 (progn | |
| 13219 ;; The line was buggy. | |
| 13220 (setq group nil) | |
| 13221 (gnus-message 3 "Mangled line: %s" | |
| 13222 (buffer-substring (gnus-point-at-bol) | |
| 13223 (gnus-point-at-eol))) | |
| 13224 (ding) | |
| 13225 (sit-for 1))) | |
| 13226 nil)) | |
| 13227 ;; Skip past ", ". Spaces are illegal in these ranges, but | |
| 13228 ;; we allow them, because it's a common mistake to put a | |
| 13229 ;; space after the comma. | |
| 13230 (skip-chars-forward ", ")) | |
| 13231 | |
| 13232 ;; We have already read .newsrc.eld, so we gently update the | |
| 13233 ;; data in the hash table with the information we have just | |
| 13234 ;; read. | |
| 13235 (if (not group) | |
| 13236 () | |
| 13237 (let ((info (nth 2 (gnus-gethash group gnus-newsrc-hashtb))) | |
| 13238 level) | |
| 13239 (if info | |
| 13240 ;; There is an entry for this file in the alist. | |
| 13241 (progn | |
| 13242 (setcar (nthcdr 2 info) (nreverse reads)) | |
| 13243 ;; We update the level very gently. In fact, we | |
| 13244 ;; only change it if there's been a status change | |
| 13245 ;; from subscribed to unsubscribed, or vice versa. | |
| 13246 (setq level (nth 1 info)) | |
| 13247 (cond ((and (<= level gnus-level-subscribed) | |
| 13248 (not subscribed)) | |
| 13249 (setq level (if reads | |
| 13250 gnus-level-default-unsubscribed | |
| 13251 (1+ gnus-level-default-unsubscribed)))) | |
| 13252 ((and (> level gnus-level-subscribed) subscribed) | |
| 13253 (setq level gnus-level-default-subscribed))) | |
| 13254 (setcar (cdr info) level)) | |
| 13255 ;; This is a new group. | |
| 13256 (setq info (list group | |
| 13257 (if subscribed | |
| 13258 gnus-level-default-subscribed | |
| 13259 (if reads | |
| 13260 (1+ gnus-level-subscribed) | |
| 13261 gnus-level-default-unsubscribed)) | |
| 13262 (nreverse reads)))) | |
| 13263 (setq newsrc (cons info newsrc)))))) | |
| 13264 (forward-line 1)) | |
| 13265 | |
| 13266 (setq newsrc (nreverse newsrc)) | |
| 13267 | |
| 13268 (if (not already-read) | |
| 13269 () | |
| 13270 ;; We now have two newsrc lists - `newsrc', which is what we | |
| 13271 ;; have read from .newsrc, and `gnus-newsrc-alist', which is | |
| 13272 ;; what we've read from .newsrc.eld. We have to merge these | |
| 13273 ;; lists. We do this by "attaching" any (foreign) groups in the | |
| 13274 ;; gnus-newsrc-alist to the (native) group that precedes them. | |
| 13275 (let ((rc (cdr gnus-newsrc-alist)) | |
| 13276 (prev gnus-newsrc-alist) | |
| 13277 entry mentry) | |
| 13278 (while rc | |
| 13279 (or (null (nth 4 (car rc))) ; It's a native group. | |
| 13280 (assoc (car (car rc)) newsrc) ; It's already in the alist. | |
| 13281 (if (setq entry (assoc (car (car prev)) newsrc)) | |
| 13282 (setcdr (setq mentry (memq entry newsrc)) | |
| 13283 (cons (car rc) (cdr mentry))) | |
| 13284 (setq newsrc (cons (car rc) newsrc)))) | |
| 13285 (setq prev rc | |
| 13286 rc (cdr rc))))) | |
| 13287 | |
| 13288 (setq gnus-newsrc-alist newsrc) | |
| 13289 ;; We make the newsrc hashtb. | |
| 13290 (gnus-make-hashtable-from-newsrc-alist) | |
| 13291 | |
| 13292 ;; Finally, if we read some options lines, we parse them. | |
| 13293 (or (string= gnus-newsrc-options "") | |
| 13294 (gnus-newsrc-parse-options gnus-newsrc-options)))) | |
| 13295 | |
| 13296 ;; Parse options lines to find "options -n !all rec.all" and stuff. | |
| 13297 ;; The return value will be a list on the form | |
| 13298 ;; ((regexp1 . ignore) | |
| 13299 ;; (regexp2 . subscribe)...) | |
| 13300 ;; When handling new newsgroups, groups that match a `ignore' regexp | |
| 13301 ;; will be ignored, and groups that match a `subscribe' regexp will be | |
| 13302 ;; subscribed. A line like | |
| 13303 ;; options -n !all rec.all | |
| 13304 ;; will lead to a list that looks like | |
| 13305 ;; (("^rec\\..+" . subscribe) | |
| 13306 ;; ("^.+" . ignore)) | |
| 13307 ;; So all "rec.*" groups will be subscribed, while all the other | |
| 13308 ;; groups will be ignored. Note that "options -n !all rec.all" is very | |
| 13309 ;; different from "options -n rec.all !all". | |
| 13310 (defun gnus-newsrc-parse-options (options) | |
| 13311 (let (out eol) | |
| 13312 (save-excursion | |
| 13313 (gnus-set-work-buffer) | |
| 13314 (insert (regexp-quote options)) | |
| 13315 ;; First we treat all continuation lines. | |
| 13316 (goto-char (point-min)) | |
| 13317 (while (re-search-forward "\n[ \t]+" nil t) | |
| 13318 (replace-match " " t t)) | |
| 13319 ;; Then we transform all "all"s into ".+"s. | |
| 13320 (goto-char (point-min)) | |
| 13321 (while (re-search-forward "\\ball\\b" nil t) | |
| 13322 (replace-match ".+" t t)) | |
| 13323 (goto-char (point-min)) | |
| 13324 ;; We remove all other options than the "-n" ones. | |
| 13325 (while (re-search-forward "[ \t]-[^n][^-]*" nil t) | |
| 13326 (replace-match " ") | |
| 13327 (forward-char -1)) | |
| 13328 (goto-char (point-min)) | |
| 13329 | |
| 13330 ;; We are only interested in "options -n" lines - we | |
| 13331 ;; ignore the other option lines. | |
| 13332 (while (re-search-forward "[ \t]-n" nil t) | |
| 13333 (setq eol | |
| 13334 (or (save-excursion | |
| 13335 (and (re-search-forward "[ \t]-n" (gnus-point-at-eol) t) | |
| 13336 (- (point) 2))) | |
| 13337 (gnus-point-at-eol))) | |
| 13338 ;; Search for all "words"... | |
| 13339 (while (re-search-forward "[^ \t,\n]+" eol t) | |
| 13340 (if (= (char-after (match-beginning 0)) ?!) | |
| 13341 ;; If the word begins with a bang (!), this is a "not" | |
| 13342 ;; spec. We put this spec (minus the bang) and the | |
| 13343 ;; symbol `ignore' into the list. | |
| 13344 (setq out (cons (cons (concat | |
| 13345 "^" (buffer-substring | |
| 13346 (1+ (match-beginning 0)) | |
| 13347 (match-end 0))) | |
| 13348 'ignore) out)) | |
| 13349 ;; There was no bang, so this is a "yes" spec. | |
| 13350 (setq out (cons (cons (concat | |
| 13351 "^" (buffer-substring (match-beginning 0) | |
| 13352 (match-end 0))) | |
| 13353 'subscribe) out))))) | |
| 13354 | |
| 13355 (setq gnus-newsrc-options-n out)))) | |
| 13356 | |
| 13357 | |
| 13358 (defun gnus-save-newsrc-file () | |
| 13359 "Save .newsrc file." | |
| 13360 ;; Note: We cannot save .newsrc file if all newsgroups are removed | |
| 13361 ;; from the variable gnus-newsrc-alist. | |
| 13362 (and (or gnus-newsrc-alist gnus-killed-list) | |
| 13363 gnus-current-startup-file | |
| 13364 (progn | |
| 13365 (run-hooks 'gnus-save-newsrc-hook) | |
| 13366 (save-excursion | |
| 13367 (if (and gnus-use-dribble-file | |
| 13368 (or (not gnus-dribble-buffer) | |
| 13369 (not (buffer-name gnus-dribble-buffer)) | |
| 13370 (zerop (save-excursion | |
| 13371 (set-buffer gnus-dribble-buffer) | |
| 13372 (buffer-size))))) | |
| 13373 (gnus-message 4 "(No changes need to be saved)") | |
| 13374 (if gnus-save-newsrc-file | |
| 13375 (progn | |
| 13376 (gnus-message 5 "Saving %s..." gnus-current-startup-file) | |
| 13377 ;; Make backup file of master newsrc. | |
| 13378 (gnus-gnus-to-newsrc-format) | |
| 13379 (gnus-message 5 "Saving %s...done" | |
| 13380 gnus-current-startup-file))) | |
| 13381 ;; Quickly loadable .newsrc. | |
| 13382 (set-buffer (get-buffer-create " *Gnus-newsrc*")) | |
| 13383 (setq buffer-file-name (concat gnus-current-startup-file ".eld")) | |
| 13384 (gnus-add-current-to-buffer-list) | |
| 13385 (buffer-disable-undo (current-buffer)) | |
| 13386 (erase-buffer) | |
| 13387 (gnus-message 5 "Saving %s.eld..." gnus-current-startup-file) | |
| 13388 (gnus-gnus-to-quick-newsrc-format) | |
| 13389 (save-buffer) | |
| 13390 (kill-buffer (current-buffer)) | |
| 13391 (gnus-message 5 "Saving %s.eld...done" gnus-current-startup-file) | |
| 13392 (gnus-dribble-delete-file)))))) | |
| 13393 | |
| 13394 (defun gnus-gnus-to-quick-newsrc-format () | |
| 13395 "Insert Gnus variables such as gnus-newsrc-alist in lisp format." | |
| 13396 (insert ";; Gnus startup file.\n") | |
| 13397 (insert ";; Never delete this file - touch .newsrc instead to force Gnus\n") | |
| 13398 (insert ";; to read .newsrc.\n") | |
| 13399 (insert "(setq gnus-newsrc-file-version " | |
| 13400 (prin1-to-string gnus-version) ")\n") | |
| 13401 (let ((variables gnus-variable-list) | |
| 13402 (inhibit-quit t) | |
| 13403 (gnus-newsrc-alist (cdr gnus-newsrc-alist)) | |
| 13404 variable) | |
| 13405 ;; insert lisp expressions. | |
| 13406 (gnus-compress-newsrc-alist) | |
| 13407 (while variables | |
| 13408 (setq variable (car variables)) | |
| 13409 (and (boundp variable) | |
| 13410 (symbol-value variable) | |
| 13411 (or gnus-save-killed-list (not (eq variable 'gnus-killed-list))) | |
| 13412 (insert "(setq " (symbol-name variable) " '" | |
| 13413 (prin1-to-string (symbol-value variable)) | |
| 13414 ")\n")) | |
| 13415 (setq variables (cdr variables))) | |
| 13416 (gnus-uncompress-newsrc-alist))) | |
| 13417 | |
| 13418 | |
| 13419 (defun gnus-gnus-to-newsrc-format () | |
| 13420 ;; Generate and save the .newsrc file. | |
| 13421 (let ((newsrc (cdr gnus-newsrc-alist)) | |
| 13422 info ranges range) | |
| 13423 (save-excursion | |
| 13424 (set-buffer (create-file-buffer gnus-current-startup-file)) | |
| 13425 (setq buffer-file-name gnus-current-startup-file) | |
| 13426 (buffer-disable-undo (current-buffer)) | |
| 13427 (erase-buffer) | |
| 13428 ;; Write options. | |
| 13429 (if gnus-newsrc-options (insert gnus-newsrc-options)) | |
| 13430 ;; Write subscribed and unsubscribed. | |
| 13431 (while newsrc | |
| 13432 (setq info (car newsrc)) | |
| 13433 (if (not (nth 4 info)) ;Don't write foreign groups to .newsrc. | |
| 13434 (progn | |
| 13435 (insert (car info) (if (> (nth 1 info) gnus-level-subscribed) | |
| 13436 "!" ":")) | |
| 13437 (if (setq ranges (nth 2 info)) | |
| 13438 (progn | |
| 13439 (insert " ") | |
| 13440 (if (not (listp (cdr ranges))) | |
| 13441 (if (= (car ranges) (cdr ranges)) | |
| 13442 (insert (int-to-string (car ranges))) | |
| 13443 (insert (int-to-string (car ranges)) "-" | |
| 13444 (int-to-string (cdr ranges)))) | |
| 13445 (while ranges | |
| 13446 (setq range (car ranges) | |
| 13447 ranges (cdr ranges)) | |
| 13448 (if (or (atom range) (= (car range) (cdr range))) | |
| 13449 (insert (int-to-string | |
| 13450 (or (and (atom range) range) | |
| 13451 (car range)))) | |
| 13452 (insert (int-to-string (car range)) "-" | |
| 13453 (int-to-string (cdr range)))) | |
| 13454 (if ranges (insert ",")))))) | |
| 13455 (insert "\n"))) | |
| 13456 (setq newsrc (cdr newsrc))) | |
| 13457 ;; It has been reported that sometime the modtime on the .newsrc | |
| 13458 ;; file seems to be off. We really do want to overwrite it, so | |
| 13459 ;; we clear the modtime here before saving. It's a bit odd, | |
| 13460 ;; though... | |
| 13461 ;; sometimes the modtime clear isn't sufficient. most brute force: | |
| 13462 ;; delete the silly thing entirely first. but this fails to provide | |
| 13463 ;; such niceties as .newsrc~ creation. | |
| 13464 (if gnus-modtime-botch | |
| 13465 (delete-file gnus-startup-file) | |
| 13466 (clear-visited-file-modtime)) | |
| 13467 (save-buffer) | |
| 13468 (kill-buffer (current-buffer))))) | |
| 13469 | |
| 13470 (defun gnus-read-all-descriptions-files () | |
| 13471 (let ((methods (cons gnus-select-method gnus-secondary-select-methods))) | |
| 13472 (while methods | |
| 13473 (gnus-read-descriptions-file (car methods)) | |
| 13474 (setq methods (cdr methods))) | |
| 13475 t)) | |
| 13476 | |
| 13477 (defun gnus-read-descriptions-file (&optional method) | |
| 13478 (let ((method (or method gnus-select-method))) | |
| 13479 ;; We create the hashtable whether we manage to read the desc file | |
| 13480 ;; to avoid trying to re-read after a failed read. | |
| 13481 (or gnus-description-hashtb | |
| 13482 (setq gnus-description-hashtb | |
| 13483 (gnus-make-hashtable (length gnus-active-hashtb)))) | |
| 13484 ;; Mark this method's desc file as read. | |
| 13485 (gnus-sethash (gnus-group-prefixed-name "" method) "Has read" | |
| 13486 gnus-description-hashtb) | |
| 13487 | |
| 13488 (gnus-message 5 "Reading descriptions file via %s..." (car method)) | |
| 13489 (cond | |
| 13490 ((not (gnus-check-server method)) | |
| 13491 (gnus-message 1 "Couldn't open server") | |
| 13492 nil) | |
| 13493 ((not (gnus-request-list-newsgroups method)) | |
| 13494 (gnus-message 1 "Couldn't read newsgroups descriptions") | |
| 13495 nil) | |
| 13496 (t | |
| 13497 (let (group) | |
| 13498 (save-excursion | |
| 13499 (save-restriction | |
| 13500 (set-buffer nntp-server-buffer) | |
| 13501 (goto-char (point-min)) | |
| 13502 (if (or (search-forward "\n.\n" nil t) | |
| 13503 (goto-char (point-max))) | |
| 13504 (progn | |
| 13505 (beginning-of-line) | |
| 13506 (narrow-to-region (point-min) (point)))) | |
| 13507 (goto-char (point-min)) | |
| 13508 (while (not (eobp)) | |
| 13509 ;; If we get an error, we set group to 0, which is not a | |
| 13510 ;; symbol... | |
| 13511 (setq group | |
| 13512 (condition-case () | |
| 13513 (let ((obarray gnus-description-hashtb)) | |
| 13514 ;; Group is set to a symbol interned in this | |
| 13515 ;; hash table. | |
| 13516 (read nntp-server-buffer)) | |
| 13517 (error 0))) | |
| 13518 (skip-chars-forward " \t") | |
| 13519 ;; ... which leads to this line being effectively ignored. | |
| 13520 (and (symbolp group) | |
| 13521 (set group (buffer-substring | |
| 13522 (point) (progn (end-of-line) (point))))) | |
| 13523 (forward-line 1)))) | |
| 13524 (gnus-message 5 "Reading descriptions file...done") | |
| 13525 t))))) | |
| 13526 | |
| 13527 (defun gnus-group-get-description (group) | |
| 13528 ;; Get the description of a group by sending XGTITLE to the server. | |
| 13529 (and (gnus-request-group-description group) | |
| 13530 (save-excursion | |
| 13531 (set-buffer nntp-server-buffer) | |
| 13532 (goto-char (point-min)) | |
| 13533 (and (looking-at "[^ \t]+[ \t]+\\(.*\\)") | |
| 13534 (buffer-substring (match-beginning 1) (match-end 1)))))) | |
| 13535 | |
| 13536 ;;; | |
| 13537 ;;; Server | |
| 13538 ;;; | |
| 13539 | |
| 13540 (defvar gnus-server-mode-hook nil | |
| 13541 "Hook run in `gnus-server-mode' buffers.") | |
| 13542 | |
| 13543 (defconst gnus-server-line-format " {%(%h:%w%)}\n" | |
| 13544 "Format of server lines. | |
| 13545 It works along the same lines as a normal formatting string, | |
| 13546 with some simple extensions.") | |
| 13547 | |
| 13548 (defvar gnus-server-mode-line-format "Gnus List of servers" | |
| 13549 "The format specification for the server mode line.") | |
| 13550 | |
| 13551 (defconst gnus-server-line-format-alist | |
| 13552 (list (list ?h 'how ?s) | |
| 13553 (list ?n 'name ?s) | |
| 13554 (list ?w 'where ?s) | |
| 13555 )) | |
| 13556 | |
| 13557 (defconst gnus-server-mode-line-format-alist | |
| 13558 (list (list ?S 'news-server ?s) | |
| 13559 (list ?M 'news-method ?s) | |
| 13560 (list ?u 'user-defined ?s))) | |
| 13561 | |
| 13562 (defvar gnus-server-line-format-spec nil) | |
| 13563 (defvar gnus-server-mode-line-format-spec nil) | |
| 13564 (defvar gnus-server-killed-servers nil) | |
| 13565 | |
| 13566 (defvar gnus-server-mode-map nil) | |
| 13567 (put 'gnus-server-mode 'mode-class 'special) | |
| 13568 | |
| 13569 (if gnus-server-mode-map | |
| 13570 nil | |
| 13571 (setq gnus-server-mode-map (make-sparse-keymap)) | |
| 13572 (suppress-keymap gnus-server-mode-map) | |
| 13573 (define-key gnus-server-mode-map " " 'gnus-server-read-server) | |
| 13574 (define-key gnus-server-mode-map "\r" 'gnus-server-read-server) | |
| 13575 (define-key gnus-server-mode-map gnus-mouse-2 'gnus-server-pick-server) | |
| 13576 (define-key gnus-server-mode-map "q" 'gnus-server-exit) | |
| 13577 (define-key gnus-server-mode-map "l" 'gnus-server-list-servers) | |
| 13578 (define-key gnus-server-mode-map "k" 'gnus-server-kill-server) | |
| 13579 (define-key gnus-server-mode-map "y" 'gnus-server-yank-server) | |
| 13580 (define-key gnus-server-mode-map "c" 'gnus-server-copy-server) | |
| 13581 (define-key gnus-server-mode-map "a" 'gnus-server-add-server) | |
| 13582 (define-key gnus-server-mode-map "e" 'gnus-server-edit-server)) | |
| 13583 | |
| 13584 (defun gnus-server-mode () | |
| 13585 "Major mode for listing and editing servers. | |
| 13586 | |
| 13587 All normal editing commands are switched off. | |
| 13588 \\<gnus-server-mode-map> | |
| 13589 | |
| 13590 For more in-depth information on this mode, read the manual (`\\[gnus-info-find-node]'). | |
| 13591 | |
| 13592 The following commands are available: | |
| 13593 | |
| 13594 \\{gnus-server-mode-map}" | |
| 13595 (interactive) | |
| 13596 (if gnus-visual (gnus-server-make-menu-bar)) | |
| 13597 (kill-all-local-variables) | |
| 13598 (setq mode-line-modified "-- ") | |
| 13599 (make-local-variable 'mode-line-format) | |
| 13600 (setq mode-line-format (copy-sequence mode-line-format)) | |
| 13601 (and (equal (nth 3 mode-line-format) " ") | |
| 13602 (setcar (nthcdr 3 mode-line-format) "")) | |
| 13603 (setq major-mode 'gnus-server-mode) | |
| 13604 (setq mode-name "Server") | |
| 13605 ; (gnus-group-set-mode-line) | |
| 13606 (setq mode-line-process nil) | |
| 13607 (use-local-map gnus-server-mode-map) | |
| 13608 (buffer-disable-undo (current-buffer)) | |
| 13609 (setq truncate-lines t) | |
| 13610 (setq buffer-read-only t) | |
| 13611 (run-hooks 'gnus-server-mode-hook)) | |
| 13612 | |
| 13613 (defun gnus-server-insert-server-line (sformat name method) | |
| 13614 (let* ((sformat (or sformat gnus-server-line-format-spec)) | |
| 13615 (how (car method)) | |
| 13616 (where (nth 1 method)) | |
| 13617 b) | |
| 13618 (beginning-of-line) | |
| 13619 (setq b (point)) | |
| 13620 ;; Insert the text. | |
| 13621 (insert (eval sformat)) | |
| 13622 (add-text-properties b (1+ b) (list 'gnus-server (intern name))))) | |
| 13623 | |
| 13624 (defun gnus-server-setup-buffer () | |
| 13625 (if (get-buffer gnus-server-buffer) | |
| 13626 () | |
| 13627 (save-excursion | |
| 13628 (set-buffer (get-buffer-create gnus-server-buffer)) | |
| 13629 (gnus-server-mode) | |
| 13630 (and gnus-carpal (gnus-carpal-setup-buffer 'server))))) | |
| 13631 | |
| 13632 (defun gnus-server-prepare () | |
| 13633 (setq gnus-server-mode-line-format-spec | |
| 13634 (gnus-parse-format gnus-server-mode-line-format | |
| 13635 gnus-server-mode-line-format-alist)) | |
| 13636 (setq gnus-server-line-format-spec | |
| 13637 (gnus-parse-format gnus-server-line-format | |
| 13638 gnus-server-line-format-alist)) | |
| 13639 (let ((alist gnus-server-alist) | |
| 13640 (buffer-read-only nil)) | |
| 13641 (erase-buffer) | |
| 13642 (while alist | |
| 13643 (gnus-server-insert-server-line nil (car (car alist)) (cdr (car alist))) | |
| 13644 (setq alist (cdr alist)))) | |
| 13645 (goto-char (point-min)) | |
| 13646 (gnus-server-position-cursor)) | |
| 13647 | |
| 13648 (defun gnus-server-server-name () | |
| 13649 (let ((server (get-text-property (gnus-point-at-bol) 'gnus-server))) | |
| 13650 (and server (symbol-name server)))) | |
| 13651 | |
| 13652 (defalias 'gnus-server-position-cursor 'gnus-goto-colon) | |
| 13653 | |
| 13654 (defconst gnus-server-edit-buffer "*Gnus edit server*") | |
| 13655 | |
| 13656 (defun gnus-server-update-server (server) | |
| 13657 (save-excursion | |
| 13658 (set-buffer gnus-server-buffer) | |
| 13659 (let ((buffer-read-only nil) | |
| 13660 (info (cdr (assoc server gnus-server-alist)))) | |
| 13661 (gnus-dribble-enter | |
| 13662 (concat "(gnus-server-set-info \"" server "\" '" | |
| 13663 (prin1-to-string info) ")")) | |
| 13664 ;; Buffer may be narrowed. | |
| 13665 (save-restriction | |
| 13666 (widen) | |
| 13667 (if (gnus-server-goto-server server) | |
| 13668 (delete-region (progn (beginning-of-line) (point)) | |
| 13669 (progn (forward-line 1) (point)))) | |
| 13670 (let ((entry (assoc server gnus-server-alist))) | |
| 13671 (gnus-server-insert-server-line nil (car entry) (cdr entry)) | |
| 13672 (gnus-server-position-cursor)))))) | |
| 13673 | |
| 13674 (defun gnus-server-set-info (server info) | |
| 13675 ;; Enter a select method into the virtual server alist. | |
| 13676 (gnus-dribble-enter | |
| 13677 (concat "(gnus-server-set-info \"" server "\" '" | |
| 13678 (prin1-to-string info) ")")) | |
| 13679 (let* ((server (nth 1 info)) | |
| 13680 (entry (assoc server gnus-server-alist))) | |
| 13681 (if entry (setcdr entry info) | |
| 13682 (setq gnus-server-alist | |
| 13683 (nconc gnus-server-alist (list (cons server info))))))) | |
| 13684 | |
| 13685 (defun gnus-server-to-method (server) | |
| 13686 ;; Map virtual server names to select methods. | |
| 13687 (or (and (equal server "native") gnus-select-method) | |
| 13688 (cdr (assoc server gnus-server-alist)))) | |
| 13689 | |
| 13690 (defun gnus-server-extend-method (group method) | |
| 13691 ;; This function "extends" a virtual server. If the server is | |
| 13692 ;; "hello", and the select method is ("hello" (my-var "something")) | |
| 13693 ;; in the group "alt.alt", this will result in a new virtual server | |
| 13694 ;; called "helly+alt.alt". | |
| 13695 (let ((entry | |
| 13696 (gnus-copy-sequence | |
| 13697 (if (equal (car method) "native") gnus-select-method | |
| 13698 (cdr (assoc (car method) gnus-server-alist)))))) | |
| 13699 (setcar (cdr entry) (concat (nth 1 entry) "+" group)) | |
| 13700 (nconc entry (cdr method)))) | |
| 13701 | |
| 13702 (defun gnus-server-get-method (group method) | |
| 13703 ;; Input either a server name, and extended server name, or a | |
| 13704 ;; select method, and return a select method. | |
| 13705 (cond ((stringp method) | |
| 13706 (gnus-server-to-method method)) | |
| 13707 ((and (stringp (car method)) group) | |
| 13708 (gnus-server-extend-method group method)) | |
| 13709 (t | |
| 13710 (gnus-server-add-address method)))) | |
| 13711 | |
| 13712 (defun gnus-server-add-address (method) | |
| 13713 (let ((method-name (symbol-name (car method)))) | |
| 13714 (if (and (memq 'address (assoc method-name gnus-valid-select-methods)) | |
| 13715 (not (assq (intern (concat method-name "-address")) method))) | |
| 13716 (append method (list (list (intern (concat method-name "-address")) | |
| 13717 (nth 1 method)))) | |
| 13718 method))) | |
| 13719 | |
| 13720 (defun gnus-server-equal (s1 s2) | |
| 13721 (or (equal s1 s2) | |
| 13722 (and (= (length s1) (length s2)) | |
| 13723 (progn | |
| 13724 (while (and s1 (member (car s1) s2)) | |
| 13725 (setq s1 (cdr s1))) | |
| 13726 (null s1))))) | |
| 13727 | |
| 13728 ;;; Interactive server functions. | |
| 13729 | |
| 13730 (defun gnus-server-kill-server (server) | |
| 13731 "Kill the server on the current line." | |
| 13732 (interactive (list (gnus-server-server-name))) | |
| 13733 (or (gnus-server-goto-server server) | |
| 13734 (if server (error "No such server: %s" server) | |
| 13735 (error "No server on the current line"))) | |
| 13736 (gnus-dribble-enter "") | |
| 13737 (let ((buffer-read-only nil)) | |
| 13738 (delete-region (progn (beginning-of-line) (point)) | |
| 13739 (progn (forward-line 1) (point)))) | |
| 13740 (setq gnus-server-killed-servers | |
| 13741 (cons (assoc server gnus-server-alist) gnus-server-killed-servers)) | |
| 13742 (setq gnus-server-alist (delq (car gnus-server-killed-servers) | |
| 13743 gnus-server-alist)) | |
| 13744 (gnus-server-position-cursor)) | |
| 13745 | |
| 13746 (defun gnus-server-yank-server () | |
| 13747 "Yank the previously killed server." | |
| 13748 (interactive) | |
| 13749 (or gnus-server-killed-servers | |
| 13750 (error "No killed servers to be yanked")) | |
| 13751 (let ((alist gnus-server-alist) | |
| 13752 (server (gnus-server-server-name)) | |
| 13753 (killed (car gnus-server-killed-servers))) | |
| 13754 (if (not server) | |
| 13755 (setq gnus-server-alist (nconc gnus-server-alist (list killed))) | |
| 13756 (if (string= server (car (car gnus-server-alist))) | |
| 13757 (setq gnus-server-alist (cons killed gnus-server-alist)) | |
| 13758 (while (and (cdr alist) | |
| 13759 (not (string= server (car (car (cdr alist)))))) | |
| 13760 (setq alist (cdr alist))) | |
| 13761 (setcdr alist (cons killed (cdr alist))))) | |
| 13762 (gnus-server-update-server (car killed)) | |
| 13763 (setq gnus-server-killed-servers (cdr gnus-server-killed-servers)) | |
| 13764 (gnus-server-position-cursor))) | |
| 13765 | |
| 13766 (defun gnus-server-exit () | |
| 13767 "Return to the group buffer." | |
| 13768 (interactive) | |
| 13769 (kill-buffer (current-buffer)) | |
| 13770 (switch-to-buffer gnus-group-buffer)) | |
| 13771 | |
| 13772 (defun gnus-server-list-servers () | |
| 13773 "List all available servers." | |
| 13774 (interactive) | |
| 13775 (let ((cur (gnus-server-server-name))) | |
| 13776 (gnus-server-prepare) | |
| 13777 (if cur (gnus-server-goto-server cur) | |
| 13778 (goto-char (point-max)) | |
| 13779 (forward-line -1)) | |
| 13780 (gnus-server-position-cursor))) | |
| 13781 | |
| 13782 (defun gnus-server-copy-server (from to) | |
| 13783 (interactive | |
| 13784 (list | |
| 13785 (or (gnus-server-server-name) | |
| 13786 (error "No server on the current line")) | |
| 13787 (read-string "Copy to: "))) | |
| 13788 (or from (error "No server on current line")) | |
| 13789 (or (and to (not (string= to ""))) (error "No name to copy to")) | |
| 13790 (and (assoc to gnus-server-alist) (error "%s already exists" to)) | |
| 13791 (or (assoc from gnus-server-alist) | |
| 13792 (error "%s: no such server" from)) | |
| 13793 (let ((to-entry (gnus-copy-sequence (assoc from gnus-server-alist)))) | |
| 13794 (setcar to-entry to) | |
| 13795 (setcar (nthcdr 2 to-entry) to) | |
| 13796 (setq gnus-server-killed-servers | |
| 13797 (cons to-entry gnus-server-killed-servers)) | |
| 13798 (gnus-server-yank-server))) | |
| 13799 | |
| 13800 (defun gnus-server-add-server (how where) | |
| 13801 (interactive | |
| 13802 (list (intern (completing-read "Server method: " | |
| 13803 gnus-valid-select-methods nil t)) | |
| 13804 (read-string "Server name: "))) | |
| 13805 (setq gnus-server-killed-servers | |
| 13806 (cons (list where how where) gnus-server-killed-servers)) | |
| 13807 (gnus-server-yank-server)) | |
| 13808 | |
| 13809 (defun gnus-server-goto-server (server) | |
| 13810 "Jump to a server line." | |
| 13811 (interactive | |
| 13812 (list (completing-read "Goto server: " gnus-server-alist nil t))) | |
| 13813 (let ((to (text-property-any (point-min) (point-max) | |
| 13814 'gnus-server (intern server)))) | |
| 13815 (and to | |
| 13816 (progn | |
| 13817 (goto-char to) | |
| 13818 (gnus-server-position-cursor))))) | |
| 13819 | |
| 13820 (defun gnus-server-edit-server (server) | |
| 13821 "Edit the server on the current line." | |
| 13822 (interactive (list (gnus-server-server-name))) | |
| 13823 (or server | |
| 13824 (error "No server on current line")) | |
| 13825 (let ((winconf (current-window-configuration))) | |
| 13826 (get-buffer-create gnus-server-edit-buffer) | |
| 13827 (gnus-configure-windows 'edit-server) | |
| 13828 (gnus-add-current-to-buffer-list) | |
| 13829 (emacs-lisp-mode) | |
| 13830 (make-local-variable 'gnus-prev-winconf) | |
| 13831 (setq gnus-prev-winconf winconf) | |
| 13832 (use-local-map (copy-keymap (current-local-map))) | |
| 13833 (let ((done-func '(lambda () | |
| 13834 "Exit editing mode and update the information." | |
| 13835 (interactive) | |
| 13836 (gnus-server-edit-server-done 'group)))) | |
| 13837 (setcar (cdr (nth 4 done-func)) server) | |
| 13838 (local-set-key "\C-c\C-c" done-func)) | |
| 13839 (erase-buffer) | |
| 13840 (insert ";; Type `C-c C-c' after you have edited the server.\n\n") | |
| 13841 (insert (pp-to-string (cdr (assoc server gnus-server-alist)))))) | |
| 13842 | |
| 13843 (defun gnus-server-edit-server-done (server) | |
| 13844 (interactive) | |
| 13845 (set-buffer (get-buffer-create gnus-server-edit-buffer)) | |
| 13846 (goto-char (point-min)) | |
| 13847 (let ((form (read (current-buffer))) | |
| 13848 (winconf gnus-prev-winconf)) | |
| 13849 (gnus-server-set-info server form) | |
| 13850 (kill-buffer (current-buffer)) | |
| 13851 (and winconf (set-window-configuration winconf)) | |
| 13852 (set-buffer gnus-server-buffer) | |
| 13853 (gnus-server-update-server (gnus-server-server-name)) | |
| 13854 (gnus-server-list-servers) | |
| 13855 (gnus-server-position-cursor))) | |
| 13856 | |
| 13857 (defun gnus-server-read-server (server) | |
| 13858 "Browse a server." | |
| 13859 (interactive (list (gnus-server-server-name))) | |
| 13860 (gnus-browse-foreign-server (gnus-server-to-method server) (current-buffer))) | |
| 13861 | |
| 13862 (defun gnus-mouse-pick-server (e) | |
| 13863 (interactive "e") | |
| 13864 (mouse-set-point e) | |
| 13865 (gnus-server-read-server (gnus-server-server-name))) | |
| 13866 | |
| 13867 ;;; | |
| 13868 ;;; entry points into gnus-score.el | |
| 13869 ;;; | |
| 13870 | |
| 13871 ;;; Finding score files. | |
| 13872 | |
| 13873 (defvar gnus-global-score-files nil | |
| 13874 "*List of global score files and directories. | |
| 13875 Set this variable if you want to use people's score files. One entry | |
| 13876 for each score file or each score file directory. Gnus will decide | |
| 13877 by itself what score files are applicable to which group. | |
| 13878 | |
| 13879 Say you want to use the single score file | |
| 13880 \"/ftp.ifi.uio.no@ftp:/pub/larsi/ding/score/soc.motss.SCORE\" and all | |
| 13881 score files in the \"/ftp.some-where:/pub/score\" directory. | |
| 13882 | |
| 13883 (setq gnus-global-score-files | |
| 13884 '(\"/ftp.ifi.uio.no:/pub/larsi/ding/score/soc.motss.SCORE\" | |
| 13885 \"/ftp.some-where:/pub/score\"))") | |
| 13886 | |
| 13887 (defun gnus-score-score-files (group) | |
| 13888 "Return a list of all possible score files." | |
| 13889 ;; Search and set any global score files. | |
| 13890 (and gnus-global-score-files | |
| 13891 (or gnus-internal-global-score-files | |
| 13892 (gnus-score-search-global-directories gnus-global-score-files))) | |
| 13893 ;; Fix the kill-file dir variable. | |
| 13894 (setq gnus-kill-files-directory | |
| 13895 (file-name-as-directory | |
| 13896 (or gnus-kill-files-directory "~/News/"))) | |
| 13897 ;; If we can't read it, there are no score files. | |
| 13898 (if (not (file-exists-p (expand-file-name gnus-kill-files-directory))) | |
| 13899 (setq gnus-score-file-list nil) | |
| 13900 (if (gnus-use-long-file-name 'not-score) | |
| 13901 ;; We want long file names. | |
| 13902 (if (or (not gnus-score-file-list) | |
| 13903 (not (car gnus-score-file-list)) | |
| 13904 (gnus-file-newer-than gnus-kill-files-directory | |
| 13905 (car gnus-score-file-list))) | |
| 13906 (setq gnus-score-file-list | |
| 13907 (cons (nth 5 (file-attributes gnus-kill-files-directory)) | |
| 13908 (nreverse | |
| 13909 (directory-files | |
| 13910 gnus-kill-files-directory t | |
| 13911 (gnus-score-file-regexp)))))) | |
| 13912 ;; We do not use long file names, so we have to do some | |
| 13913 ;; directory traversing. | |
| 13914 (let ((mdir (length (expand-file-name gnus-kill-files-directory))) | |
| 13915 (suffixes (list gnus-score-file-suffix gnus-adaptive-file-suffix)) | |
| 13916 dir files suffix) | |
| 13917 (while suffixes | |
| 13918 (setq dir (expand-file-name | |
| 13919 (concat gnus-kill-files-directory | |
| 13920 (gnus-replace-chars-in-string group ?. ?/)))) | |
| 13921 (setq dir (gnus-replace-chars-in-string dir ?: ?/)) | |
| 13922 (setq suffix (car suffixes) | |
| 13923 suffixes (cdr suffixes)) | |
| 13924 (if (file-exists-p (concat dir "/" suffix)) | |
| 13925 (setq files (cons (concat dir "/" suffix) files))) | |
| 13926 (while (>= (1+ (length dir)) mdir) | |
| 13927 (and (file-exists-p (concat dir "/all/" suffix)) | |
| 13928 (setq files (cons (concat dir "/all/" suffix) files))) | |
| 13929 (string-match "/[^/]*$" dir) | |
| 13930 (setq dir (substring dir 0 (match-beginning 0))))) | |
| 13931 (setq gnus-score-file-list | |
| 13932 (cons nil (nreverse files))))) | |
| 13933 (cdr gnus-score-file-list))) | |
| 13934 | |
| 13935 (defun gnus-score-file-regexp () | |
| 13936 (concat "\\(" gnus-score-file-suffix | |
| 13937 "\\|" gnus-adaptive-file-suffix "\\)$")) | |
| 13938 | |
| 13939 (defun gnus-score-find-bnews (group) | |
| 13940 "Return a list of score files for GROUP. | |
| 13941 The score files are those files in the ~/News directory which matches | |
| 13942 GROUP using BNews sys file syntax." | |
| 13943 (let* ((sfiles (append (gnus-score-score-files group) | |
| 13944 gnus-internal-global-score-files)) | |
| 13945 (kill-dir (file-name-as-directory | |
| 13946 (expand-file-name gnus-kill-files-directory))) | |
| 13947 (klen (length kill-dir)) | |
| 13948 ofiles not-match regexp) | |
| 13949 (save-excursion | |
| 13950 (set-buffer (get-buffer-create "*gnus score files*")) | |
| 13951 (buffer-disable-undo (current-buffer)) | |
| 13952 ;; Go through all score file names and create regexp with them | |
| 13953 ;; as the source. | |
| 13954 (while sfiles | |
| 13955 (erase-buffer) | |
| 13956 (insert (car sfiles)) | |
| 13957 (goto-char (point-min)) | |
| 13958 ;; First remove the suffix itself. | |
| 13959 (re-search-forward (concat "." (gnus-score-file-regexp))) | |
| 13960 (replace-match "" t t) | |
| 13961 (goto-char (point-min)) | |
| 13962 (if (looking-at (regexp-quote kill-dir)) | |
| 13963 ;; If the file name was just "SCORE", `klen' is one character | |
| 13964 ;; too much. | |
| 13965 (delete-char (min (1- (point-max)) klen)) | |
| 13966 (goto-char (point-max)) | |
| 13967 (search-backward "/") | |
| 13968 (delete-region (1+ (point)) (point-min))) | |
| 13969 ;; If short file names were used, we have to translate slashes. | |
| 13970 (goto-char (point-min)) | |
| 13971 (while (re-search-forward "[/:]" nil t) | |
| 13972 (replace-match "." t t)) | |
| 13973 ;; Cludge to get rid of "nntp+" problems. | |
| 13974 (goto-char (point-min)) | |
| 13975 (and (looking-at "nn[a-z]+\\+") | |
| 13976 (progn | |
| 13977 (search-forward "+") | |
| 13978 (forward-char -1) | |
| 13979 (insert "\\"))) | |
| 13980 ;; Translate ".all" to "[./].*"; | |
| 13981 (while (search-forward ".all" nil t) | |
| 13982 (replace-match "[./:].*" t t)) | |
| 13983 (goto-char (point-min)) | |
| 13984 ;; Translate "all" to ".*". | |
| 13985 (while (search-forward "all" nil t) | |
| 13986 (replace-match ".*" t t)) | |
| 13987 (goto-char (point-min)) | |
| 13988 ;; Deal with "not."s. | |
| 13989 (if (looking-at "not.") | |
| 13990 (progn | |
| 13991 (setq not-match t) | |
| 13992 (setq regexp (buffer-substring 5 (point-max)))) | |
| 13993 (setq regexp (buffer-substring 1 (point-max))) | |
| 13994 (setq not-match nil)) | |
| 13995 ;; Finally - if this resulting regexp matches the group name, | |
| 13996 ;; we add this score file to the list of score files | |
| 13997 ;; applicable to this group. | |
| 13998 (if (or (and not-match | |
| 13999 (not (string-match regexp group))) | |
| 14000 (and (not not-match) | |
| 14001 (string-match regexp group))) | |
| 14002 (setq ofiles (cons (car sfiles) ofiles))) | |
| 14003 (setq sfiles (cdr sfiles))) | |
| 14004 (kill-buffer (current-buffer)) | |
| 14005 ;; Slight kludge here - the last score file returned should be | |
| 14006 ;; the local score file, whether it exists or not. This is so | |
| 14007 ;; that any score commands the user enters will go to the right | |
| 14008 ;; file, and not end up in some global score file. | |
| 14009 (let ((localscore | |
| 14010 (expand-file-name | |
| 14011 (if (gnus-use-long-file-name 'not-score) | |
| 14012 (concat gnus-kill-files-directory group "." | |
| 14013 gnus-score-file-suffix) | |
| 14014 (concat gnus-kill-files-directory | |
| 14015 (gnus-replace-chars-in-string group ?. ?/ ?: ?/) | |
| 14016 "/" gnus-score-file-suffix))))) | |
| 14017 ;; The localest score file might already be there, but it's | |
| 14018 ;; supposed to be the very last file, so we delete it from the | |
| 14019 ;; list if it's already there, and add it to the head of the | |
| 14020 ;; list. | |
| 14021 (setq ofiles (cons localscore (delete localscore ofiles)))) | |
| 14022 (nreverse ofiles)))) | |
| 14023 | |
| 14024 (defun gnus-score-find-single (group) | |
| 14025 "Return list containing the score file for GROUP." | |
| 14026 (list (gnus-score-file-name group gnus-adaptive-file-suffix) | |
| 14027 (gnus-score-file-name group))) | |
| 14028 | |
| 14029 (defun gnus-score-find-hierarchical (group) | |
| 14030 "Return list of score files for GROUP. | |
| 14031 This includes the score file for the group and all its parents." | |
| 14032 (let ((all (copy-sequence '(nil))) | |
| 14033 (start 0)) | |
| 14034 (while (string-match "\\." group (1+ start)) | |
| 14035 (setq start (match-beginning 0)) | |
| 14036 (setq all (cons (substring group 0 start) all))) | |
| 14037 (setq all (cons group all)) | |
| 14038 (nconc | |
| 14039 (mapcar (lambda (newsgroup) | |
| 14040 (gnus-score-file-name newsgroup gnus-adaptive-file-suffix)) | |
| 14041 (setq all (nreverse all))) | |
| 14042 (mapcar 'gnus-score-file-name all)))) | |
| 14043 | |
| 14044 (defvar gnus-score-file-alist-cache nil) | |
| 14045 | |
| 14046 (defun gnus-score-find-alist (group) | |
| 14047 "Return list of score files for GROUP. | |
| 14048 The list is determined from the variable gnus-score-file-alist." | |
| 14049 (let ((alist gnus-score-file-multiple-match-alist) | |
| 14050 score-files) | |
| 14051 ;; if this group has been seen before, return the cached entry | |
| 14052 (if (setq score-files (assoc group gnus-score-file-alist-cache)) | |
| 14053 (cdr score-files) ;ensures caching groups with no matches | |
| 14054 ;; handle the multiple match alist | |
| 14055 (while alist | |
| 14056 (and (string-match (car (car alist)) group) | |
| 14057 (setq score-files | |
| 14058 (nconc score-files (copy-sequence (cdr (car alist)))))) | |
| 14059 (setq alist (cdr alist))) | |
| 14060 (setq alist gnus-score-file-single-match-alist) | |
| 14061 ;; handle the single match alist | |
| 14062 (while alist | |
| 14063 (and (string-match (car (car alist)) group) | |
| 14064 ;; progn used just in case ("regexp") has no files | |
| 14065 ;; and score-files is still nil. -sj | |
| 14066 ;; this can be construed as a "stop searching here" feature :> | |
| 14067 ;; and used to simplify regexps in the single-alist | |
| 14068 (progn | |
| 14069 (setq score-files | |
| 14070 (nconc score-files (copy-sequence (cdr (car alist))))) | |
| 14071 (setq alist nil))) | |
| 14072 (setq alist (cdr alist))) | |
| 14073 ;; cache the score files | |
| 14074 (setq gnus-score-file-alist-cache | |
| 14075 (cons (cons group score-files) gnus-score-file-alist-cache)) | |
| 14076 score-files))) | |
| 14077 | |
| 14078 | |
| 14079 (defun gnus-possibly-score-headers (&optional trace) | |
| 14080 (let ((func gnus-score-find-score-files-function) | |
| 14081 score-files) | |
| 14082 (and func (not (listp func)) | |
| 14083 (setq func (list func))) | |
| 14084 ;; Go through all the functions for finding score files (or actual | |
| 14085 ;; scores) and add them to a list. | |
| 14086 (setq score-files (gnus-score-find-alist gnus-newsgroup-name)) | |
| 14087 (while func | |
| 14088 (and (symbolp (car func)) | |
| 14089 (fboundp (car func)) | |
| 14090 (setq score-files | |
| 14091 (nconc score-files (funcall (car func) gnus-newsgroup-name)))) | |
| 14092 (setq func (cdr func))) | |
| 14093 (if score-files (gnus-score-headers score-files trace)))) | |
| 14094 | |
| 14095 (defun gnus-score-file-name (newsgroup &optional suffix) | |
| 14096 "Return the name of a score file for NEWSGROUP." | |
| 14097 (let ((suffix (or suffix gnus-score-file-suffix))) | |
| 14098 (cond | |
| 14099 ((or (null newsgroup) | |
| 14100 (string-equal newsgroup "")) | |
| 14101 ;; The global score file is placed at top of the directory. | |
| 14102 (expand-file-name | |
| 14103 suffix (or gnus-kill-files-directory "~/News"))) | |
| 14104 ((gnus-use-long-file-name 'not-score) | |
| 14105 ;; Append ".SCORE" to newsgroup name. | |
| 14106 (expand-file-name (concat (gnus-newsgroup-saveable-name newsgroup) | |
| 14107 "." suffix) | |
| 14108 (or gnus-kill-files-directory "~/News"))) | |
| 14109 (t | |
| 14110 ;; Place "SCORE" under the hierarchical directory. | |
| 14111 (expand-file-name (concat (gnus-newsgroup-directory-form newsgroup) | |
| 14112 "/" suffix) | |
| 14113 (or gnus-kill-files-directory "~/News")))))) | |
| 14114 | |
| 14115 (defun gnus-score-search-global-directories (files) | |
| 14116 "Scan all global score directories for score files." | |
| 14117 ;; Set the variable `gnus-internal-global-score-files' to all | |
| 14118 ;; available global score files. | |
| 14119 (interactive (list gnus-global-score-files)) | |
| 14120 (let (out) | |
| 14121 (while files | |
| 14122 (if (string-match "/$" (car files)) | |
| 14123 (setq out (nconc (directory-files | |
| 14124 (car files) t | |
| 14125 (concat (gnus-score-file-regexp) "$")))) | |
| 14126 (setq out (cons (car files) out))) | |
| 14127 (setq files (cdr files))) | |
| 14128 (setq gnus-internal-global-score-files out))) | |
| 14129 | |
| 14130 ;; Allow redefinition of Gnus functions. | |
| 14131 | |
| 14132 (gnus-ems-redefine) | |
| 14133 | |
| 14134 (provide 'gnus) | |
| 14135 | |
| 14136 ;;; gnus.el ends here |