git.chise.org Git - elisp/gnus.git-/blob - lisp/gnus.el

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