;;; gnus.el --- a newsreader for GNU Emacs
-
-;; Copyright (C) 1987, 1988, 1989, 1990, 1993, 1994, 1995, 1996, 1997,
-;; 1998, 2000, 2001, 2002 Free Software Foundation, Inc.
+;; Copyright (C) 1987,88,89,90,93,94,95,96,97,98 Free Software Foundation, Inc.
;; Author: Masanobu UMEDA <umerin@flab.flab.fujitsu.junet>
;; Lars Magne Ingebrigtsen <larsi@gnus.org>
(eval '(run-hooks 'gnus-load-hook))
(eval-when-compile (require 'cl))
-(require 'wid-edit)
-(require 'mm-util)
+
+(require 'custom)
+(eval-and-compile
+ (if (< emacs-major-version 20)
+ (require 'gnus-load)))
+(require 'message)
(defgroup gnus nil
"The coffee-brewing, all singing, all dancing, kitchen sink newsreader."
:group 'news
:group 'mail)
-(defgroup gnus-format nil
- "Dealing with formatting issues."
- :group 'news
- :group 'mail)
-
-(defgroup gnus-charset nil
- "Group character set issues."
- :link '(custom-manual "(gnus)Charsets")
- :version "21.1"
- :group 'gnus)
-
(defgroup gnus-cache nil
"Cache interface."
:group 'gnus)
:link '(custom-manual "(gnus)Summary Maneuvering")
:group 'gnus-summary)
-(defgroup gnus-picon nil
- "Show pictures of people, domains, and newsgroups."
- :group 'gnus-visual)
-
(defgroup gnus-summary-mail nil
"Mail group commands."
:link '(custom-manual "(gnus)Mail Group Commands")
"Options related to newsservers and other servers used by Gnus."
:group 'gnus)
-(defgroup gnus-server-visual nil
- "Highlighting and menus in the server buffer."
- :group 'gnus-visual
- :group 'gnus-server)
-
(defgroup gnus-message '((message custom-group))
"Composing replies and followups in Gnus."
:group 'gnus)
:link '(custom-manual "(gnus)Various Various")
:group 'gnus)
-(defgroup gnus-mime nil
- "Variables for controlling the Gnus MIME interface."
- :group 'gnus)
-
(defgroup gnus-exit nil
"Exiting gnus."
:link '(custom-manual "(gnus)Exiting Gnus")
:group 'gnus)
-(defgroup gnus-fun nil
- "Frivolous Gnus extensions."
- :link '(custom-manual "(gnus)Exiting Gnus")
- :group 'gnus)
+(defconst gnus-product-name "Semi-gnus"
+ "Product name of this version of gnus.")
-(defconst gnus-version-number "0.07"
- "Version number for this version of Gnus.")
+(defconst gnus-version-number "6.9.2"
+ "Version number for this version of gnus.")
-(defconst gnus-version (format "Oort Gnus v%s" gnus-version-number)
- "Version string for this version of Gnus.")
+(defconst gnus-version
+ (format "%s %s (based on Gnus 5.6.45; for SEMI 1.11, FLIM 1.12)"
+ gnus-product-name gnus-version-number)
+ "Version string for this version of gnus.")
(defcustom gnus-inhibit-startup-message nil
"If non-nil, the startup message will not be displayed.
:group 'gnus-start
:type 'boolean)
-(unless (fboundp 'gnus-group-remove-excess-properties)
- (defalias 'gnus-group-remove-excess-properties 'ignore))
-
-(unless (fboundp 'gnus-set-text-properties)
- (defalias 'gnus-set-text-properties 'set-text-properties))
+;;; Kludges to help the transition from the old `custom.el'.
(unless (featurep 'gnus-xmas)
(defalias 'gnus-make-overlay 'make-overlay)
(defalias 'gnus-delete-overlay 'delete-overlay)
(defalias 'gnus-overlay-put 'overlay-put)
(defalias 'gnus-move-overlay 'move-overlay)
- (defalias 'gnus-overlay-buffer 'overlay-buffer)
- (defalias 'gnus-overlay-start 'overlay-start)
(defalias 'gnus-overlay-end 'overlay-end)
(defalias 'gnus-extent-detached-p 'ignore)
(defalias 'gnus-extent-start-open 'ignore)
+ (defalias 'gnus-set-text-properties 'set-text-properties)
+ (defalias 'gnus-group-remove-excess-properties 'ignore)
(defalias 'gnus-appt-select-lowest-window 'appt-select-lowest-window)
(defalias 'gnus-mail-strip-quoted-names 'mail-strip-quoted-names)
(defalias 'gnus-character-to-event 'identity)
(defalias 'gnus-add-text-properties 'add-text-properties)
(defalias 'gnus-put-text-property 'put-text-property)
- (defvar gnus-mode-line-image-cache t)
- (if (fboundp 'find-image)
- (defun gnus-mode-line-buffer-identification (line)
- (let ((str (car-safe line)))
- (if (and (stringp str)
- (string-match "^Gnus:" str))
- (progn (add-text-properties
- 0 5
- (list 'display
- (if (eq t gnus-mode-line-image-cache)
- (setq gnus-mode-line-image-cache
- (find-image
- '((:type xpm :file "gnus-pointer.xpm"
- :ascent center)
- (:type xbm :file "gnus-pointer.xbm"
- :ascent center))))
- gnus-mode-line-image-cache)
- 'help-echo "This is Gnus")
- str)
- (list str))
- line)))
- (defalias 'gnus-mode-line-buffer-identification 'identity))
+ (defalias 'gnus-mode-line-buffer-identification 'identity)
(defalias 'gnus-characterp 'numberp)
(defalias 'gnus-deactivate-mark 'deactivate-mark)
(defalias 'gnus-window-edges 'window-edges)
- (defalias 'gnus-key-press-event-p 'numberp)
- ;;(defalias 'gnus-decode-rfc1522 'ignore)
- )
+ (defalias 'gnus-key-press-event-p 'numberp))
;; We define these group faces here to avoid the display
;; update forced when creating new faces.
()))
"Level 3 empty newsgroup face.")
-(defface gnus-group-news-4-face
- '((((class color)
- (background dark))
- (:bold t))
- (((class color)
- (background light))
- (:bold t))
- (t
- ()))
- "Level 4 newsgroup face.")
-
-(defface gnus-group-news-4-empty-face
- '((((class color)
- (background dark))
- ())
- (((class color)
- (background light))
- ())
- (t
- ()))
- "Level 4 empty newsgroup face.")
-
-(defface gnus-group-news-5-face
- '((((class color)
- (background dark))
- (:bold t))
- (((class color)
- (background light))
- (:bold t))
- (t
- ()))
- "Level 5 newsgroup face.")
-
-(defface gnus-group-news-5-empty-face
- '((((class color)
- (background dark))
- ())
- (((class color)
- (background light))
- ())
- (t
- ()))
- "Level 5 empty newsgroup face.")
-
-(defface gnus-group-news-6-face
- '((((class color)
- (background dark))
- (:bold t))
- (((class color)
- (background light))
- (:bold t))
- (t
- ()))
- "Level 6 newsgroup face.")
-
-(defface gnus-group-news-6-empty-face
- '((((class color)
- (background dark))
- ())
- (((class color)
- (background light))
- ())
- (t
- ()))
- "Level 6 empty newsgroup face.")
-
(defface gnus-group-news-low-face
'((((class color)
(background dark))
(defface gnus-splash-face
'((((class color)
(background dark))
- (:foreground "#888888"))
+ (:foreground "ForestGreen"))
(((class color)
(background light))
- (:foreground "#888888"))
+ (:foreground "ForestGreen"))
(t
()))
- "Face for the splash screen.")
+ "Level 1 newsgroup face.")
(defun gnus-splash ()
(save-excursion
(defvar gnus-simple-splash nil)
-;;(format "%02x%02x%02x" 114 66 20) "724214"
-
-(defvar gnus-logo-color-alist
- '((flame "#cc3300" "#ff2200")
- (pine "#c0cc93" "#f8ffb8")
- (moss "#a1cc93" "#d2ffb8")
- (irish "#04cc90" "#05ff97")
- (sky "#049acc" "#05deff")
- (tin "#6886cc" "#82b6ff")
- (velvet "#7c68cc" "#8c82ff")
- (grape "#b264cc" "#cf7df")
- (labia "#cc64c2" "#fd7dff")
- (berry "#cc6485" "#ff7db5")
- (dino "#724214" "#1e3f03")
- (oort "#cccccc" "#888888")
- (storm "#666699" "#99ccff")
- (pdino "#9999cc" "#99ccff")
- (purp "#9999cc" "#666699")
- (neutral "#b4b4b4" "#878787")
- (september "#bf9900" "#ffcc00"))
- "Color alist used for the Gnus logo.")
-
-(defcustom gnus-logo-color-style 'oort
- "*Color styles used for the Gnus logo."
- :type `(choice ,@(mapcar (lambda (elem) (list 'const (car elem)))
- gnus-logo-color-alist))
- :group 'gnus-xmas)
-
-(defvar gnus-logo-colors
- (cdr (assq gnus-logo-color-style gnus-logo-color-alist))
- "Colors used for the Gnus logo.")
-
(defun gnus-group-startup-message (&optional x y)
"Insert startup message in current buffer."
;; Insert the message.
(erase-buffer)
- (cond
- ((and
- (fboundp 'find-image)
- (display-graphic-p)
- (let ((image (find-image
- `((:type xpm :file "gnus.xpm"
- :color-symbols
- (("thing" . ,(car gnus-logo-colors))
- ("shadow" . ,(cadr gnus-logo-colors))
- ("background" . ,(face-background 'default))))
- (:type pbm :file "gnus.pbm"
- ;; Account for the pbm's blackground.
- :background ,(face-foreground 'gnus-splash-face)
- :foreground ,(face-background 'default))
- (:type xbm :file "gnus.xbm"
- ;; Account for the xbm's blackground.
- :background ,(face-foreground 'gnus-splash-face)
- :foreground ,(face-background 'default))))))
- (when image
- (let ((size (image-size image)))
- (insert-char ?\n (max 0 (round (- (window-height)
- (or y (cdr size)) 1) 2)))
- (insert-char ?\ (max 0 (round (- (window-width)
- (or x (car size))) 2)))
- (insert-image image))
- (setq gnus-simple-splash nil)
- t))))
- (t
- (insert
- (format " %s
+ (insert
+ (format " %s
_ ___ _ _
_ ___ __ ___ __ _ ___
__ _ ___ __ ___
__
"
- ""))
- ;; And then hack it.
- (gnus-indent-rigidly (point-min) (point-max)
- (/ (max (- (window-width) (or x 46)) 0) 2))
- (goto-char (point-min))
- (forward-line 1)
- (let* ((pheight (count-lines (point-min) (point-max)))
- (wheight (window-height))
- (rest (- wheight pheight)))
- (insert (make-string (max 0 (* 2 (/ rest 3))) ?\n)))
- ;; Fontify some.
- (put-text-property (point-min) (point-max) 'face 'gnus-splash-face)
- (setq gnus-simple-splash t)))
+ ""))
+ ;; And then hack it.
+ (gnus-indent-rigidly (point-min) (point-max)
+ (/ (max (- (window-width) (or x 46)) 0) 2))
+ (goto-char (point-min))
+ (forward-line 1)
+ (let* ((pheight (count-lines (point-min) (point-max)))
+ (wheight (window-height))
+ (rest (- wheight pheight)))
+ (insert (make-string (max 0 (* 2 (/ rest 3))) ?\n)))
+ ;; Fontify some.
+ (put-text-property (point-min) (point-max) 'face 'gnus-splash-face)
(goto-char (point-min))
(setq mode-line-buffer-identification (concat " " gnus-version))
+ (setq gnus-simple-splash t)
(set-buffer-modified-p t))
(eval-when (load)
;;; Do the rest.
+(require 'custom)
(require 'gnus-util)
(require 'nnheader)
-(defcustom gnus-parameters nil
- "Alist of group parameters.
-
-For example:
- ((\"mail\\\\..*\" (gnus-show-threads nil)
- (gnus-use-scoring nil)
- (gnus-summary-line-format
- \"%U%R%z%I%(%[%d:%ub%-23,23f%]%) %s\\n\")
- (gcc-self . t)
- (display . all))
- (\"mail\\\\.me\" (gnus-use-scoring t))
- (\"list\\\\..*\" (total-expire . t)
- (broken-reply-to . t)))"
- :group 'gnus-group-various
- :type '(repeat (cons regexp
- (repeat sexp))))
-
-(defvar gnus-group-parameters-more nil)
-
-(defmacro gnus-define-group-parameter (param &rest rest)
- "Define a group parameter PARAM.
-REST is a plist of following:
-:type One of `bool', `list' or `nil'.
-:function The name of the function.
-:function-document The documentation of the function.
-:parameter-type The type for customizing the parameter.
-:parameter-document The documentation for the parameter.
-:variable The name of the variable.
-:variable-document The documentation for the variable.
-:variable-group The group for customizing the variable.
-:variable-type The type for customizing the variable.
-:variable-default The default value of the variable."
- (let* ((type (plist-get rest :type))
- (parameter-type (plist-get rest :parameter-type))
- (parameter-document (plist-get rest :parameter-document))
- (function (or (plist-get rest :function)
- (intern (format "gnus-parameter-%s" param))))
- (function-document (or (plist-get rest :function-document) ""))
- (variable (or (plist-get rest :variable)
- (intern (format "gnus-parameter-%s-alist" param))))
- (variable-document (or (plist-get rest :variable-document) ""))
- (variable-group (plist-get rest :variable-group))
- (variable-type (or (plist-get rest :variable-type)
- `(quote (repeat
- (list (regexp :tag "Group")
- ,(car (cdr parameter-type)))))))
- (variable-default (plist-get rest :variable-default)))
- (list
- 'progn
- `(defcustom ,variable ,variable-default
- ,variable-document
- :group 'gnus-group-parameter
- :group ',variable-group
- :type ,variable-type)
- `(setq gnus-group-parameters-more
- (delq (assq ',param gnus-group-parameters-more)
- gnus-group-parameters-more))
- `(add-to-list 'gnus-group-parameters-more
- (list ',param
- ,parameter-type
- ,parameter-document))
- (if (eq type 'bool)
- `(defun ,function (name)
- ,function-document
- (let ((params (gnus-group-find-parameter name))
- val)
- (cond
- ((memq ',param params)
- t)
- ((setq val (assq ',param params))
- (cdr val))
- ((stringp ,variable)
- (string-match ,variable name))
- (,variable
- (let ((alist ,variable)
- elem value)
- (while (setq elem (pop alist))
- (when (and name
- (string-match (car elem) name))
- (setq alist nil
- value (cdr elem))))
- (if (consp value) (car value) value))))))
- `(defun ,function (name)
- ,function-document
- (and name
- (or (gnus-group-find-parameter name ',param ,(and type t))
- (let ((alist ,variable)
- elem value)
- (while (setq elem (pop alist))
- (when (and name
- (string-match (car elem) name))
- (setq alist nil
- value (cdr elem))))
- ,(if type
- 'value
- '(if (consp value) (car value) value))))))))))
-
(defcustom gnus-home-directory "~/"
"Directory variable that specifies the \"home\" directory.
All other Gnus path variables are initialized from this variable."
:group 'gnus-files
:group 'gnus-server
:type 'file)
-
+
;; This function is used to check both the environment variable
;; NNTPSERVER and the /etc/nntpserver file to see whether one can find
;; an nntp server name default.
(and (file-readable-p gnus-nntpserver-file)
(save-excursion
(set-buffer (gnus-get-buffer-create " *gnus nntp*"))
+ (buffer-disable-undo (current-buffer))
(insert-file-contents gnus-nntpserver-file)
(let ((name (buffer-string)))
(prog1
- (if (string-match "\\'[ \t\n]*$" name)
+ (if (string-match "^[ \t\n]*$" name)
nil
name)
(kill-buffer (current-buffer))))))))
(defcustom gnus-select-method
(condition-case nil
- (nconc
- (list 'nntp (or (condition-case nil
- (gnus-getenv-nntpserver)
- (error nil))
- (when (and gnus-default-nntp-server
- (not (string= gnus-default-nntp-server "")))
- gnus-default-nntp-server)
- "news"))
- (if (or (null gnus-nntp-service)
- (equal gnus-nntp-service "nntp"))
- nil
- (list gnus-nntp-service)))
+ (nconc
+ (list 'nntp (or (condition-case nil
+ (gnus-getenv-nntpserver)
+ (error nil))
+ (when (and gnus-default-nntp-server
+ (not (string= gnus-default-nntp-server "")))
+ gnus-default-nntp-server)
+ "news"))
+ (if (or (null gnus-nntp-service)
+ (equal gnus-nntp-service "nntp"))
+ nil
+ (list gnus-nntp-service)))
(error nil))
- "Default method for selecting a newsgroup.
+ "*Default method for selecting a newsgroup.
This variable should be a list, where the first element is how the
news is to be fetched, the second is the address.
-For instance, if you want to get your news via \"flab.flab.edu\" using
-NNTP, you could say:
+For instance, if you want to get your news via NNTP from
+\"flab.flab.edu\", you could say:
\(setq gnus-select-method '(nntp \"flab.flab.edu\"))
:group 'gnus-server
:type 'gnus-select-method)
-(defcustom gnus-message-archive-method "archive"
+(defcustom gnus-message-archive-method
+ `(nnfolder
+ "archive"
+ (nnfolder-directory ,(nnheader-concat message-directory "archive"))
+ (nnfolder-active-file
+ ,(nnheader-concat message-directory "archive/active"))
+ (nnfolder-get-new-mail nil)
+ (nnfolder-inhibit-expiry t))
"*Method used for archiving messages you've sent.
-This should be a mail method."
+This should be a mail method.
+
+It's probably not a very effective to change this variable once you've
+run Gnus once. After doing that, you must edit this server from the
+server buffer."
:group 'gnus-server
:group 'gnus-message
:type 'gnus-select-method)
write in another group, you could say something like:
\(setq gnus-message-archive-group
- '((if (message-news-p)
- \"misc-news\"
- \"misc-mail\")))
+ '((if (message-news-p)
+ \"misc-news\"
+ \"misc-mail\")))
Normally the group names returned by this variable should be
unprefixed -- which implicitly means \"store on the archive server\".
\"nnml+private:mail.misc\", for instance."
:group 'gnus-message
:type '(choice (const :tag "none" nil)
- function
sexp
string))
This is a list where each element is a complete select method (see
`gnus-select-method').
-If, for instance, you want to read your mail with the nnml back end,
+If, for instance, you want to read your mail with the nnml backend,
you could set this variable:
\(setq gnus-secondary-select-methods '((nnml \"\")))"
- :group 'gnus-server
- :type '(repeat gnus-select-method))
+:group 'gnus-server
+:type '(repeat gnus-select-method))
(defvar gnus-backup-default-subscribed-newsgroups
'("news.announce.newusers" "news.groups.questions" "gnu.emacs.gnus")
(defcustom gnus-local-domain nil
"Local domain name without a host name.
The DOMAINNAME environment variable is used instead if it is defined.
-If the function `system-name' returns the full Internet name, there is
+If the `system-name' function returns the full Internet name, there is
no need to set this variable."
:group 'gnus-message
:type '(choice (const :tag "default" nil)
nntp method, you might get acceptable results.
The value of this variable must be a valid select method as discussed
-in the documentation of `gnus-select-method'.
-
-It can also be a list of select methods, as well as the special symbol
-`current', which means to use the current select method. If it is a
-list, Gnus will try all the methods in the list until it finds a match."
+in the documentation of `gnus-select-method'."
:group 'gnus-server
:type '(choice (const :tag "default" nil)
- (const :tag "Google" (nnweb "refer" (nnweb-type google)))
- gnus-select-method
- (repeat :menu-tag "Try multiple"
- :tag "Multiple"
- :value (current (nnweb "refer" (nnweb-type google)))
- (choice :tag "Method"
- (const current)
- (const :tag "Google"
- (nnweb "refer" (nnweb-type google)))
- gnus-select-method))))
+ gnus-select-method))
(defcustom gnus-group-faq-directory
'("/ftp@mirrors.aol.com:/pub/rtfm/usenet/"
+ "/ftp@sunsite.auc.dk:/pub/usenet/"
"/ftp@sunsite.doc.ic.ac.uk:/pub/usenet/news-faqs/"
"/ftp@src.doc.ic.ac.uk:/usenet/news-FAQS/"
"/ftp@ftp.seas.gwu.edu:/pub/rtfm/"
- "/ftp@ftp.pasteur.fr:/pub/FAQ/"
"/ftp@rtfm.mit.edu:/pub/usenet/"
"/ftp@ftp.uni-paderborn.de:/pub/FAQ/"
"/ftp@ftp.sunet.se:/pub/usenet/"
ftp.seas.gwu.edu /pub/rtfm
rtfm.mit.edu /pub/usenet
Europe: ftp.uni-paderborn.de /pub/FAQ
- src.doc.ic.ac.uk /usenet/news-FAQS
+ src.doc.ic.ac.uk /usenet/news-FAQS
ftp.sunet.se /pub/usenet
- ftp.pasteur.fr /pub/FAQ
+ sunsite.auc.dk /pub/usenet
Asia: nctuccca.edu.tw /USENET/FAQ
hwarang.postech.ac.kr /pub/usenet
ftp.hk.super.net /mirror/faqs"
:group 'gnus-summary-marks
:type 'character)
+(defcustom gnus-asynchronous nil
+ "*If non-nil, Gnus will supply backends with data needed for async article fetching."
+ :group 'gnus-asynchronous
+ :type 'boolean)
+
(defcustom gnus-large-newsgroup 200
"*The number of articles which indicates a large newsgroup.
If the number of articles in a newsgroup is greater than this value,
-confirmation is required for selecting the newsgroup.
-If it is `nil', no confirmation is required."
+confirmation is required for selecting the newsgroup."
:group 'gnus-group-select
- :type '(choice (const :tag "No limit" nil)
- integer))
+ :type 'integer)
(defcustom gnus-use-long-file-name (not (memq system-type '(usg-unix-v xenix)))
"*Non-nil means that the default name of a file to save articles in is the group name.
:group 'gnus-meta
:type 'boolean)
+(defcustom gnus-use-demon nil
+ "If non-nil, Gnus might use some demons."
+ :group 'gnus-meta
+ :type 'boolean)
+
(defcustom gnus-use-scoring t
"*If non-nil, enable scoring."
:group 'gnus-meta
:type 'boolean)
+(defcustom gnus-use-picons nil
+ "*If non-nil, display picons."
+ :group 'gnus-meta
+ :type 'boolean)
+
(defcustom gnus-summary-prepare-exit-hook
'(gnus-summary-expire-articles)
"*A hook called when preparing to exit from the summary buffer.
:group 'gnus-summary-format
:type '(radio (function-item gnus-extract-address-components)
(function-item mail-extract-address-components)
+ (function-item std11-extract-address-components)
(function :tag "Other")))
(defcustom gnus-carpal nil
("nnspool" post address)
("nnvirtual" post-mail virtual prompt-address)
("nnmbox" mail respool address)
- ("nnml" post-mail respool address)
+ ("nnml" mail respool address)
("nnmh" mail respool address)
("nndir" post-mail prompt-address physical-address)
("nneething" none address prompt-address physical-address)
("nnfolder" mail respool address)
("nngateway" post-mail address prompt-address physical-address)
("nnweb" none)
- ("nngoogle" post)
- ("nnslashdot" post)
- ("nnultimate" none)
- ("nnrss" none)
- ("nnwfm" none)
- ("nnwarchive" none)
("nnlistserv" none)
- ("nnagent" post-mail)
- ("nnimap" post-mail address prompt-address physical-address)
- ("nnmaildir" mail respool address)
- ("nnnil" none))
+ ("nnagent" post-mail))
"*An alist of valid select methods.
The first element of each list lists should be a string with the name
of the select method. The other elements may be the category of
(const :format "%v " virtual)
(const respool)))))
-(defun gnus-redefine-select-method-widget ()
- "Recomputes the select-method widget based on the value of
-`gnus-valid-select-methods'."
- (define-widget 'gnus-select-method 'list
- "Widget for entering a select method."
- :value '(nntp "")
- :tag "Select Method"
- :args `((choice :tag "Method"
- ,@(mapcar (lambda (entry)
- (list 'const :format "%v\n"
- (intern (car entry))))
- gnus-valid-select-methods)
- (symbol :tag "other"))
- (string :tag "Address")
- (repeat :tag "Options"
- :inline t
- (list :format "%v"
- variable
- (sexp :tag "Value"))))))
-
-(gnus-redefine-select-method-widget)
+(define-widget 'gnus-select-method 'list
+ "Widget for entering a select method."
+ :args `((choice :tag "Method"
+ ,@(mapcar (lambda (entry)
+ (list 'const :format "%v\n"
+ (intern (car entry))))
+ gnus-valid-select-methods))
+ (string :tag "Address")
+ (editable-list :inline t
+ (list :format "%v"
+ variable
+ (sexp :tag "Value")))))
(defcustom gnus-updated-mode-lines '(group article summary tree)
"List of buffers that should update their mode lines.
:type '(choice (const nil)
integer))
-;; There should be special validation for this.
-(define-widget 'gnus-email-address 'string
- "An email address")
-
-(gnus-define-group-parameter
- to-address
- :function-document
- "Return GROUP's to-address."
- :variable-document
- "*Alist of group regexps and correspondent to-addresses."
- :parameter-type '(gnus-email-address :tag "To Address")
- :parameter-document "\
-This will be used when doing followups and posts.
-
-This is primarily useful in mail groups that represent closed
-mailing lists--mailing lists where it's expected that everybody that
-writes to the mailing list is subscribed to it. Since using this
-parameter ensures that the mail only goes to the mailing list itself,
-it means that members won't receive two copies of your followups.
-
-Using `to-address' will actually work whether the group is foreign or
-not. Let's say there's a group on the server that is called
-`fa.4ad-l'. This is a real newsgroup, but the server has gotten the
-articles from a mail-to-news gateway. Posting directly to this group
-is therefore impossible--you have to send mail to the mailing list
-address instead.
-
-The gnus-group-split mail splitting mechanism will behave as if this
-address was listed in gnus-group-split Addresses (see below).")
-
-(gnus-define-group-parameter
- to-list
- :function-document
- "Return GROUP's to-list."
- :variable-document
- "*Alist of group regexps and correspondent to-lists."
- :parameter-type '(gnus-email-address :tag "To List")
- :parameter-document "\
-This address will be used when doing a `a' in the group.
-
-It is totally ignored when doing a followup--except that if it is
-present in a news group, you'll get mail group semantics when doing
-`f'.
-
-The gnus-group-split mail splitting mechanism will behave as if this
-address was listed in gnus-group-split Addresses (see below).")
-
-(gnus-define-group-parameter
- subscribed
- :type bool
- :function-document
- "Return GROUP's subscription status."
- :variable-document
- "*Groups which are automatically considered subscribed."
- :parameter-type '(const :tag "Subscribed" t)
- :parameter-document "\
-Gnus assumed that you are subscribed to the To/List address.
-
-When constructing a list of subscribed groups using
-`gnus-find-subscribed-addresses', Gnus includes the To address given
-above, or the list address (if the To address has not been set).")
-
-(gnus-define-group-parameter
- auto-expire
- :type bool
- :function gnus-group-auto-expirable-p
- :function-document
- "Check whether GROUP is auto-expirable or not."
- :variable gnus-auto-expirable-newsgroups
- :variable-default nil
- :variable-document
- "*Groups in which to automatically mark read articles as expirable.
+(defcustom gnus-auto-expirable-newsgroups nil
+ "*Groups in which to automatically mark read articles as expirable.
If non-nil, this should be a regexp that should match all groups in
which to perform auto-expiry. This only makes sense for mail groups."
- :variable-group nnmail-expire
- :variable-type '(choice (const nil)
- regexp)
- :parameter-type '(const :tag "Automatic Expire" t)
- :parameter-document
- "All articles that are read will be marked as expirable.")
-
-(gnus-define-group-parameter
- total-expire
- :type bool
- :function gnus-group-total-expirable-p
- :function-document
- "Check whether GROUP is total-expirable or not."
- :variable gnus-total-expirable-newsgroups
- :variable-default nil
- :variable-document
- "*Groups in which to perform expiry of all read articles.
+ :group 'nnmail-expire
+ :type '(choice (const nil)
+ regexp))
+
+(defcustom gnus-total-expirable-newsgroups nil
+ "*Groups in which to perform expiry of all read articles.
Use with extreme caution. All groups that match this regexp will be
expiring - which means that all read articles will be deleted after
\(say) one week. (This only goes for mail groups and the like, of
course.)"
- :variable-group nnmail-expire
- :variable-type '(choice (const nil)
- regexp)
- :parameter-type '(const :tag "Total Expire" t)
- :parameter-document
- "All read articles will be put through the expiry process
-
-This happens even if they are not marked as expirable.
-Use with caution.")
-
-(gnus-define-group-parameter
- charset
- :function-document
- "Return the default charset of GROUP."
- :variable gnus-group-charset-alist
- :variable-default
- '(("\\(^\\|:\\)hk\\>\\|\\(^\\|:\\)tw\\>\\|\\<big5\\>" cn-big5)
- ("\\(^\\|:\\)cn\\>\\|\\<chinese\\>" cn-gb-2312)
- ("\\(^\\|:\\)fj\\>\\|\\(^\\|:\\)japan\\>" iso-2022-jp-2)
- ("\\(^\\|:\\)tnn\\>\\|\\(^\\|:\\)pin\\>\\|\\(^\\|:\\)sci.lang.japan" iso-2022-7bit)
- ("\\(^\\|:\\)relcom\\>" koi8-r)
- ("\\(^\\|:\\)fido7\\>" koi8-r)
- ("\\(^\\|:\\)\\(cz\\|hun\\|pl\\|sk\\|hr\\)\\>" iso-8859-2)
- ("\\(^\\|:\\)israel\\>" iso-8859-1)
- ("\\(^\\|:\\)han\\>" euc-kr)
- ("\\(^\\|:\\)alt.chinese.text.big5\\>" chinese-big5)
- ("\\(^\\|:\\)soc.culture.vietnamese\\>" vietnamese-viqr)
- ("\\(^\\|:\\)\\(comp\\|rec\\|alt\\|sci\\|soc\\|news\\|gnu\\|bofh\\)\\>" iso-8859-1))
- :variable-document
- "Alist of regexps (to match group names) and default charsets to be used when reading."
- :variable-group gnus-charset
- :variable-type '(repeat (list (regexp :tag "Group")
- (symbol :tag "Charset")))
- :parameter-type '(symbol :tag "Charset")
- :parameter-document "\
-The default charset to use in the group.")
-
-(gnus-define-group-parameter
- post-method
- :type list
- :function-document
- "Return a posting method for GROUP."
- :variable gnus-post-method-alist
- :variable-document
- "Alist of regexps (to match group names) and method to be used when
-posting an article."
- :variable-group gnus-group-foreign
- :parameter-type
- '(choice :tag "Posting Method"
- (const :tag "Use native server" native)
- (const :tag "Use current server" current)
- (list :convert-widget
- (lambda (widget)
- (list 'sexp :tag "Methods"
- :value gnus-select-method))))
- :parameter-document
- "Posting method for this group.")
-
-(gnus-define-group-parameter
- large-newsgroup-initial
- :type integer
- :function-document
- "Return GROUP's initial input of the number of articles."
- :variable-document
- "*Alist of group regexps and its initial input of the number of articles."
- :parameter-type '(choice :tag "Initial Input for Large Newsgroup"
- (const :tag "All" nil)
- (integer))
- :parameter-document "\
-
-This number will be prompted as the initial value of the number of
-articles to list when the group is a large newsgroup (see
-`gnus-large-newsgroup'). If it is `nil', the default value is the
-total number of articles in the group.")
+ :group 'nnmail-expire
+ :type '(choice (const nil)
+ regexp))
(defcustom gnus-group-uncollapsed-levels 1
"Number of group name elements to leave alone when making a short group name."
(defcustom gnus-group-change-level-function nil
"Function run when a group level is changed.
It is called with three parameters -- GROUP, LEVEL and OLDLEVEL."
- :group 'gnus-group-levels
+ :group 'gnus-group-level
:type 'function)
;;; Face thingies.
(const pick-menu)
(const grouplens-menu)))
-;; Byte-compiler warning.
-(defvar gnus-visual)
-;; Find out whether the gnus-visual TYPE is wanted.
-(defun gnus-visual-p (&optional type class)
- (and gnus-visual ; Has to be non-nil, at least.
- (if (not type) ; We don't care about type.
- gnus-visual
- (if (listp gnus-visual) ; It's a list, so we check it.
- (or (memq type gnus-visual)
- (memq class gnus-visual))
- t))))
-
(defcustom gnus-mouse-face
(condition-case ()
(if (gnus-visual-p 'mouse-face 'highlight)
:group 'gnus-visual
:type 'face)
+(defcustom gnus-article-display-hook
+ (if (and (string-match "XEmacs" emacs-version)
+ (featurep 'xface))
+ '(gnus-article-hide-headers-if-wanted
+ gnus-article-hide-boring-headers
+ gnus-article-treat-overstrike
+ gnus-article-maybe-highlight
+ gnus-article-display-x-face)
+ '(gnus-article-hide-headers-if-wanted
+ gnus-article-hide-boring-headers
+ gnus-article-treat-overstrike
+ gnus-article-maybe-highlight))
+ "*Controls how the article buffer will look.
+
+If you leave the list empty, the article will appear exactly as it is
+stored on the disk. The list entries will hide or highlight various
+parts of the article, making it easier to find the information you
+want."
+ :group 'gnus-article-highlight
+ :group 'gnus-visual
+ :type 'hook
+ :options '(gnus-article-add-buttons
+ gnus-article-add-buttons-to-head
+ gnus-article-emphasize
+ gnus-article-fill-cited-article
+ gnus-article-remove-cr
+ gnus-summary-stop-page-breaking
+ ;; gnus-summary-caesar-message
+ ;; gnus-summary-verbose-headers
+ gnus-summary-toggle-mime
+ gnus-article-hide
+ gnus-article-hide-headers
+ gnus-article-hide-boring-headers
+ gnus-article-hide-signature
+ gnus-article-hide-citation
+ gnus-article-hide-pgp
+ gnus-article-hide-pem
+ gnus-article-highlight
+ gnus-article-highlight-headers
+ gnus-article-highlight-citation
+ gnus-article-highlight-signature
+ gnus-article-date-ut
+ gnus-article-date-local
+ gnus-article-date-lapsed
+ gnus-article-date-original
+ gnus-article-remove-trailing-blank-lines
+ gnus-article-strip-leading-blank-lines
+ gnus-article-strip-multiple-blank-lines
+ gnus-article-strip-blank-lines
+ gnus-article-treat-overstrike
+ gnus-article-display-x-face
+ gnus-smiley-display))
+
(defcustom gnus-article-save-directory gnus-directory
"*Name of the directory articles will be saved in (default \"~/News\")."
:group 'gnus-article-saving
(defvar gnus-plugged t
"Whether Gnus is plugged or not.")
-(defcustom gnus-agent-cache t
- "Whether Gnus use agent cache.
-You also need to enable `gnus-agent'."
- :version "21.3"
- :group 'gnus-agent
- :type 'boolean)
-
-(defcustom gnus-default-charset (mm-guess-mime-charset)
- "Default charset assumed to be used when viewing non-ASCII characters.
-This variable is overridden on a group-to-group basis by the
-gnus-group-charset-alist variable and is only used on groups not
-covered by that variable."
- :type 'symbol
- :group 'gnus-charset)
-
-(defcustom gnus-agent t
- "Whether we want to use the Gnus agent or not.
-Putting (gnus-agentize) in ~/.gnus is obsolete by (setq gnus-agent t)."
- :version "21.3"
- :group 'gnus-agent
- :type 'boolean)
-
\f
;;; Internal variables
-(defvar gnus-agent-gcc-header "X-Gnus-Agent-Gcc")
-(defvar gnus-agent-meta-information-header "X-Gnus-Agent-Meta-Information")
-(defvar gnus-draft-meta-information-header "X-Draft-From")
(defvar gnus-group-get-parameter-function 'gnus-group-get-parameter)
(defvar gnus-original-article-buffer " *Original Article*")
(defvar gnus-newsgroup-name nil)
(defvar gnus-ephemeral-servers nil)
-(defvar gnus-server-method-cache nil)
-
-(defvar gnus-agent-fetching nil
- "Whether Gnus agent is in fetching mode.")
-(defvar gnus-agent-covered-methods nil)
+(defvar gnus-agent nil
+ "Whether we want to use the Gnus agent or not.")
(defvar gnus-command-method nil
- "Dynamically bound variable that says what the current back end is.")
+ "Dynamically bound variable that says what the current backend is.")
(defvar gnus-current-select-method nil
"The current method for selecting a newsgroup.")
(bookmarks . bookmark) (dormant . dormant)
(scored . score) (saved . save)
(cached . cache) (downloadable . download)
- (unsendable . unsend) (forwarded . forward)
- (recent . recent) (seen . seen)))
-
-(defconst gnus-article-special-mark-lists
- '((seen range)
- (killed range)
- (bookmark tuple)
- (score tuple)))
-
-;; Propagate flags to server, with the following exceptions:
-;; `seen' is private to each gnus installation
-;; `cache' is a internal gnus flag for each gnus installation
-;; `download' is a agent flag private to each gnus installation
-;; `unsend' are for nndraft groups only
-;; `score' is not a proper mark
-;; `bookmark': don't propagated it, or fix the bug in update-mark.
-(defconst gnus-article-unpropagated-mark-lists
- '(seen cache download unsend score bookmark)
- "Marks that shouldn't be propagated to back ends.
-Typical marks are those that make no sense in a standalone back end,
-such as a mark that says whether an article is stored in the cache
-\(which doesn't make sense in a standalone back end).")
+ (unsendable . unsend)))
(defvar gnus-headers-retrieved-by nil)
(defvar gnus-article-reply nil)
"bugs@gnus.org (The Gnus Bugfixing Girls + Boys)"
"The mail address of the Gnus maintainers.")
+(defconst semi-gnus-developers
+ "Semi-gnus Developers:
+ semi-gnus-en@meadow.scphys.kyoto-u.ac.jp (In English),\
+ semi-gnus-ja@meadow.scphys.kyoto-u.ac.jp (In Japanese);"
+ "The mail address of the Semi-gnus developers.")
+
+(defcustom gnus-info-filename nil
+ "*Controls language of gnus Info.
+If nil and current-language-environment is Japanese, go to gnus-ja.
+Otherwise go to corresponding Info.
+This variable can be nil, gnus or gnus-ja."
+ :group 'gnus-start
+ :type '(choice (const nil)
+ (const :tag "English" gnus)
+ (const :tag "Japanese" gnus-ja)))
+
(defvar gnus-info-nodes
- '((gnus-group-mode "(gnus)Group Buffer")
- (gnus-summary-mode "(gnus)Summary Buffer")
- (gnus-article-mode "(gnus)Article Buffer")
- (gnus-server-mode "(gnus)Server Buffer")
- (gnus-browse-mode "(gnus)Browse Foreign Server")
- (gnus-tree-mode "(gnus)Tree Display"))
+ '((gnus-group-mode "The Group Buffer")
+ (gnus-summary-mode "The Summary Buffer")
+ (gnus-article-mode "The Article Buffer")
+ (mime/viewer-mode "The Article Buffer")
+ (gnus-server-mode "The Server Buffer")
+ (gnus-browse-mode "Browse Foreign Server")
+ (gnus-tree-mode "Tree Display"))
"Alist of major modes and related Info nodes.")
(defvar gnus-group-buffer "*Group*")
(defvar gnus-variable-list
'(gnus-newsrc-options gnus-newsrc-options-n
- gnus-newsrc-last-checked-date
- gnus-newsrc-alist gnus-server-alist
- gnus-killed-list gnus-zombie-list
- gnus-topic-topology gnus-topic-alist
- gnus-format-specs)
+ gnus-newsrc-last-checked-date
+ gnus-newsrc-alist gnus-server-alist
+ gnus-killed-list gnus-zombie-list
+ gnus-topic-topology gnus-topic-alist
+ gnus-format-specs)
"Gnus variables saved in the quick startup file.")
(defvar gnus-newsrc-alist nil
(defvar gnus-dead-summary nil)
-(defvar gnus-invalid-group-regexp "[: `'\"/]\\|^$"
- "Regexp matching invalid groups.")
-
;;; End of variables.
;; Define some autoload functions Gnus might use.
(when (consp function)
(setq keymap (car (memq 'keymap function)))
(setq function (car function)))
- (unless (fboundp function)
- (autoload function (car package) nil interactive keymap))))
+ (autoload function (car package) nil interactive keymap)))
(if (eq (nth 1 package) ':interactive)
- (nthcdr 3 package)
+ (cdddr package)
(cdr package)))))
- '(("info" :interactive t Info-goto-node)
- ("pp" pp-to-string)
- ("qp" quoted-printable-decode-region quoted-printable-decode-string)
+ '(("info" Info-goto-node)
+ ("hexl" hexl-hex-string-to-integer)
+ ("pp" pp pp-to-string pp-eval-expression)
("ps-print" ps-print-preprint)
+ ("mail-extr" mail-extract-address-components)
+ ("browse-url" browse-url)
("message" :interactive t
message-send-and-exit message-yank-original)
- ("babel" babel-as-string)
- ("nnmail" nnmail-split-fancy nnmail-article-group)
+ ("nnmail" nnmail-split-fancy nnmail-article-group nnmail-date-to-time)
("nnvirtual" nnvirtual-catchup-group nnvirtual-convert-headers)
- ("rmailout" rmail-output rmail-output-to-rmail-file)
+ ("timezone" timezone-make-date-arpa-standard timezone-fix-time
+ timezone-make-sortable-date timezone-make-time-string)
+ ("rmailout" rmail-output)
("rmail" rmail-insert-rmail-file-header rmail-count-new-messages
rmail-show-message rmail-summary-exists
rmail-select-summary rmail-update-summary)
gnus-demon-remove-handler)
("gnus-demon" :interactive t
gnus-demon-init gnus-demon-cancel)
- ("gnus-fun" gnus-convert-gray-x-face-to-xpm gnus-display-x-face-in-from
- gnus-convert-image-to-gray-x-face)
("gnus-salt" gnus-highlight-selected-tree gnus-possibly-generate-tree
gnus-tree-open gnus-tree-close gnus-carpal-setup-buffer)
("gnus-nocem" gnus-nocem-scan-groups gnus-nocem-close
gnus-article-hide-citation-in-followups)
("gnus-kill" gnus-kill gnus-apply-kill-file-internal
gnus-kill-file-edit-file gnus-kill-file-raise-followups-to-author
- gnus-execute gnus-expunge gnus-batch-kill gnus-batch-score)
+ gnus-execute gnus-expunge)
("gnus-cache" gnus-cache-possibly-enter-article gnus-cache-save-buffers
gnus-cache-possibly-remove-articles gnus-cache-request-article
gnus-cache-retrieve-headers gnus-cache-possibly-alter-active
gnus-cache-enter-remove-article gnus-cached-article-p
- gnus-cache-open gnus-cache-close gnus-cache-update-article
- gnus-cache-articles-in-group)
- ("gnus-cache" :interactive t gnus-jog-cache gnus-cache-enter-article
- gnus-cache-remove-article gnus-summary-insert-cached-articles)
- ("gnus-score" :interactive t
- gnus-summary-increase-score gnus-summary-set-score
- gnus-summary-raise-thread gnus-summary-raise-same-subject
- gnus-summary-raise-score gnus-summary-raise-same-subject-and-select
- gnus-summary-lower-thread gnus-summary-lower-same-subject
- gnus-summary-lower-score gnus-summary-lower-same-subject-and-select
- gnus-summary-current-score gnus-score-delta-default
- gnus-score-flush-cache gnus-score-close
- gnus-possibly-score-headers gnus-score-followup-article
- gnus-score-followup-thread)
- ("gnus-score"
- (gnus-summary-score-map keymap) gnus-score-save gnus-score-headers
+ gnus-cache-open gnus-cache-close gnus-cache-update-article)
+ ("gnus-cache" :interactive t gnus-jog-cache gnus-cache-enter-article
+ gnus-cache-remove-article gnus-summary-insert-cached-articles)
+ ("gnus-score" :interactive t
+ gnus-summary-increase-score gnus-summary-set-score
+ gnus-summary-raise-thread gnus-summary-raise-same-subject
+ gnus-summary-raise-score gnus-summary-raise-same-subject-and-select
+ gnus-summary-lower-thread gnus-summary-lower-same-subject
+ gnus-summary-lower-score gnus-summary-lower-same-subject-and-select
+ gnus-summary-current-score gnus-score-default
+ gnus-score-flush-cache gnus-score-close
+ gnus-possibly-score-headers gnus-score-followup-article
+ gnus-score-followup-thread)
+ ("gnus-score"
+ (gnus-summary-score-map keymap) gnus-score-save gnus-score-headers
gnus-current-score-file-nondirectory gnus-score-adaptive
gnus-score-find-trace gnus-score-file-name)
("gnus-cus" :interactive t gnus-group-customize gnus-score-customize)
("gnus-topic" :interactive t gnus-topic-mode)
- ("gnus-topic" gnus-topic-remove-group gnus-topic-set-parameters
- gnus-subscribe-topics)
+ ("gnus-topic" gnus-topic-remove-group gnus-topic-set-parameters)
("gnus-salt" :interactive t gnus-pick-mode gnus-binary-mode)
("gnus-uu" (gnus-uu-extract-map keymap) (gnus-uu-mark-map keymap))
("gnus-uu" :interactive t
gnus-uu-decode-uu-and-save-view gnus-uu-decode-unshar-view
gnus-uu-decode-unshar-and-save-view gnus-uu-decode-save-view
gnus-uu-decode-binhex-view gnus-uu-unmark-thread
- gnus-uu-mark-over gnus-uu-post-news)
- ("gnus-uu" gnus-uu-delete-work-dir gnus-uu-unmark-thread)
+ gnus-uu-mark-over gnus-uu-post-news gnus-uu-post-news)
+ ("gnus-uu" gnus-uu-delete-work-dir gnus-quote-arg-for-sh-or-csh
+ gnus-uu-unmark-thread)
("gnus-msg" (gnus-summary-send-map keymap)
gnus-article-mail gnus-copy-article-buffer gnus-extended-version)
("gnus-msg" :interactive t
- gnus-group-post-news gnus-group-mail gnus-group-news
- gnus-summary-post-news gnus-summary-news-other-window
+ gnus-group-post-news gnus-group-mail gnus-summary-post-news
gnus-summary-followup gnus-summary-followup-with-original
gnus-summary-cancel-article gnus-summary-supersede-article
gnus-post-news gnus-summary-reply gnus-summary-reply-with-original
gnus-summary-wide-reply-with-original
gnus-summary-post-forward gnus-summary-wide-reply-with-original
gnus-summary-post-forward)
- ("gnus-picon" :interactive t gnus-treat-from-picon)
+ ("gnus-picon" :interactive t gnus-article-display-picons
+ gnus-group-display-picons gnus-picons-article-display-x-face
+ gnus-picons-display-x-face)
("gnus-gl" bbb-login bbb-logout bbb-grouplens-group-p
gnus-grouplens-mode)
- ("smiley" :interactive t smiley-region)
+ ("smiley" :interactive t gnus-smiley-display)
("gnus-win" gnus-configure-windows gnus-add-configuration)
("gnus-sum" gnus-summary-insert-line gnus-summary-read-group
gnus-list-of-unread-articles gnus-list-of-read-articles
gnus-group-set-mode-line gnus-group-set-info gnus-group-save-newsrc
gnus-group-setup-buffer gnus-group-get-new-news
gnus-group-make-help-group gnus-group-update-group
- gnus-group-iterate gnus-group-group-name)
+ gnus-clear-inboxes-moved gnus-group-iterate
+ gnus-group-group-name)
("gnus-bcklg" gnus-backlog-request-article gnus-backlog-enter-article
gnus-backlog-remove-article)
("gnus-art" gnus-article-read-summary-keys gnus-article-save
gnus-article-next-page gnus-article-prev-page
gnus-request-article-this-buffer gnus-article-mode
gnus-article-setup-buffer gnus-narrow-to-page
- gnus-article-delete-invisible-text gnus-treat-article)
+ gnus-article-delete-invisible-text gnus-hack-decode-rfc1522)
("gnus-art" :interactive t
gnus-article-hide-headers gnus-article-hide-boring-headers
- gnus-article-treat-overstrike
+ gnus-article-treat-overstrike gnus-article-word-wrap
gnus-article-remove-cr gnus-article-remove-trailing-blank-lines
- gnus-article-display-x-face gnus-article-de-quoted-unreadable
- gnus-article-de-base64-unreadable
- gnus-article-decode-HZ
- gnus-article-wash-html
- gnus-article-unsplit-urls
- gnus-article-hide-pgp
+ gnus-article-display-x-face
+ gnus-article-mime-decode-quoted-printable gnus-article-hide-pgp
gnus-article-hide-pem gnus-article-hide-signature
gnus-article-strip-leading-blank-lines gnus-article-date-local
gnus-article-date-original gnus-article-date-lapsed
-;; gnus-article-show-all-headers
+ gnus-article-show-all-headers
gnus-article-edit-mode gnus-article-edit-article
- gnus-article-edit-done gnus-article-decode-encoded-words
- gnus-start-date-timer gnus-stop-date-timer
- gnus-mime-view-all-parts)
+ gnus-article-edit-done gnus-decode-rfc1522 article-decode-rfc1522
+ gnus-start-date-timer gnus-stop-date-timer)
("gnus-int" gnus-request-type)
("gnus-start" gnus-newsrc-parse-options gnus-1 gnus-no-server-1
gnus-dribble-enter gnus-read-init-file gnus-dribble-touch)
("gnus-async" gnus-async-request-fetched-article gnus-async-prefetch-next
gnus-async-prefetch-article gnus-async-prefetch-remove-group
gnus-async-halt-prefetch)
+ ("pop3-fma" :interactive t
+ pop3-fma-set-pop3-password)
("gnus-agent" gnus-open-agent gnus-agent-get-function
gnus-agent-save-groups gnus-agent-save-active gnus-agent-method-p
gnus-agent-get-undownloaded-list gnus-agent-fetch-session
- gnus-summary-set-agent-mark gnus-agent-save-group-info
- gnus-agent-request-article gnus-agent-retrieve-headers)
+ gnus-summary-set-agent-mark gnus-agent-save-group-info)
("gnus-agent" :interactive t
gnus-unplugged gnus-agentize gnus-agent-batch)
("gnus-vm" :interactive t gnus-summary-save-in-vm
gnus-summary-save-article-vm)
- ("compface" uncompface)
- ("gnus-draft" :interactive t gnus-draft-mode gnus-group-send-queue)
- ("gnus-mlspl" gnus-group-split gnus-group-split-fancy)
- ("gnus-mlspl" :interactive t gnus-group-split-setup
- gnus-group-split-update))))
+ ("gnus-draft" :interactive t gnus-draft-mode gnus-group-send-drafts))))
;;; gnus-sum.el thingies
-(defcustom gnus-summary-line-format "%U%R%z%I%(%[%4L: %-23,23f%]%) %s\n"
+(defcustom gnus-summary-line-format "%U%R%z%I%(%[%4L: %-20,20n%]%) %s\n"
"*The format specification of the lines in the summary buffer.
It works along the same lines as a normal formatting string,
%a Extracted name of the poster (string)
%A Extracted address of the poster (string)
%F Contents of the From: header (string)
-%f Contents of the From: or To: headers (string)
%x Contents of the Xref: header (string)
%D Date of the article (string)
%d Date of the article (string) in DD-MMM format
-%o Date of the article (string) in YYYYMMDD`T'HHMMSS format
%M Message-id of the article (string)
%r References of the article (string)
%c Number of characters in the article (integer)
%L Number of lines in the article (integer)
%I Indentation based on thread level (a string of spaces)
-%B A complex trn-style thread tree (string)
- The variables `gnus-sum-thread-*' can be used for customization.
%T A string with two possible values: 80 spaces if the article
is on thread level two or larger and 0 spaces on level one
%R \"A\" if this article has been replied to, \" \" otherwise (character)
will be inserted into the summary just like information from any other
summary specifier.
+Text between %( and %) will be highlighted with `gnus-mouse-face'
+when the mouse point is placed inside the area. There can only be one
+such area.
+
The %U (status), %R (replied) and %z (zcore) specs have to be handled
with care. For reasons of efficiency, Gnus will compute what column
these characters will end up in, and \"hard-code\" that. This means that
-it is invalid to have these specs after a variable-length spec. Well,
+it is illegal to have these specs after a variable-length spec. Well,
you might not be arrested, but your summary buffer will look strange,
which is bad enough.
-The smart choice is to have these specs as far to the left as
+The smart choice is to have these specs as for to the left as
possible.
-This restriction may disappear in later versions of Gnus.
-
-General format specifiers can also be used.
-See `(gnus)Formatting Variables'."
- :link '(custom-manual "(gnus)Formatting Variables")
+This restriction may disappear in later versions of Gnus."
:type 'string
:group 'gnus-summary-format)
(define-key keymap (pop keys) 'undefined))))
(defvar gnus-article-mode-map
- (let ((keymap (make-sparse-keymap)))
+ (let ((keymap (make-keymap)))
(gnus-suppress-keymap keymap)
keymap))
(defvar gnus-summary-mode-map
"Get hash value of STRING in HASHTABLE."
`(symbol-value (intern-soft ,string ,hashtable)))
-(defmacro gnus-gethash-safe (string hashtable)
- "Get hash value of STRING in HASHTABLE.
-Return nil if not defined."
- `(let ((sym (intern-soft ,string ,hashtable)))
- (and (boundp sym) (symbol-value sym))))
-
(defmacro gnus-sethash (string value hashtable)
"Set hash value. Arguments are STRING, VALUE, and HASHTABLE."
`(set (intern ,string ,hashtable) ,value))
(defmacro gnus-get-info (group)
`(nth 2 (gnus-gethash ,group gnus-newsrc-hashtb)))
+;; Byte-compiler warning.
+(defvar gnus-visual)
+;; Find out whether the gnus-visual TYPE is wanted.
+(defun gnus-visual-p (&optional type class)
+ (and gnus-visual ; Has to be non-nil, at least.
+ (if (not type) ; We don't care about type.
+ gnus-visual
+ (if (listp gnus-visual) ; It's a list, so we check it.
+ (or (memq type gnus-visual)
+ (memq class gnus-visual))
+ t))))
+
;;; Load the compatability functions.
(require 'gnus-ems)
;;; Gnus Utility Functions
;;;
-(defun gnus-find-subscribed-addresses ()
- "Return a regexp matching the addresses of all subscribed mail groups.
-It consists of the `to-address' or `to-list' parameter of all groups
-with a `subscribed' parameter."
- (let (group address addresses)
- (dolist (entry (cdr gnus-newsrc-alist))
- (setq group (car entry))
- (when (gnus-parameter-subscribed group)
- (setq address (mail-strip-quoted-names
- (or (gnus-group-fast-parameter group 'to-address)
- (gnus-group-fast-parameter group 'to-list))))
- (when address
- (add-to-list 'addresses address))))
- (when addresses
- (list (mapconcat 'regexp-quote addresses "\\|")))))
(defmacro gnus-string-or (&rest strings)
"Return the first element of STRINGS that is a non-blank string.
(insert (message gnus-version))
(message gnus-version)))
-(defun gnus-continuum-version (&optional version)
+(defun gnus-continuum-version (version)
"Return VERSION as a floating point number."
- (interactive)
- (unless version
- (setq version gnus-version))
(when (or (string-match "^\\([^ ]+\\)? ?Gnus v?\\([0-9.]+\\)$" version)
(string-match "^\\(.?\\)gnus-\\([0-9.]+\\)$" version))
(let ((alpha (and (match-beginning 1) (match-string 1 version)))
0))
(string-to-number
(if (zerop major)
- (format "%s00%02d%02d"
- (if (member alpha '("(ding)" "d"))
- "4.99"
- (+ 5 (* 0.02
- (abs
- (- (mm-char-int (aref (downcase alpha) 0))
- (mm-char-int ?t))))
- -0.01))
- minor least)
+ (format "%s00%02d%02d"
+ (cond
+ ((member alpha '("(ding)" "d")) "4.99")
+ ((member alpha '("September" "s")) "5.01")
+ ((member alpha '("Red" "r")) "5.03")
+ ((member alpha '("Quassia" "q")) "5.05")
+ ((member alpha '("p")) "5.07")
+ ((member alpha '("o")) "5.09")
+ ((member alpha '("n")) "5.11"))
+ minor least)
(format "%d.%02d%02d" major minor least))))))
-(defun gnus-info-find-node (&optional nodename)
+(defun gnus-info-find-node ()
"Find Info documentation of Gnus."
(interactive)
;; Enlarge info window if needed.
(let (gnus-info-buffer)
- (Info-goto-node (or nodename (cadr (assq major-mode gnus-info-nodes))))
+ (Info-goto-node (format "(%s)%s"
+ (or gnus-info-filename
+ (get-language-info current-language-environment 'gnus-info)
+ "gnus")
+ (cadr (assq major-mode gnus-info-nodes))))
(setq gnus-info-buffer (current-buffer))
(gnus-configure-windows 'info)))
out)
(cond
((= c ?r)
- (push (if (< (point) (mark)) (point) (mark)) out)
- (push (if (> (point) (mark)) (point) (mark)) out))))
+ (push (if (< (point) (mark) (point) (mark))) out)
+ (push (if (> (point) (mark) (point) (mark))) out))))
(setq out (delq 'gnus-prefix-nil out))
(nreverse out)))
(let ((group (or group gnus-newsgroup-name)))
(not (gnus-check-backend-function 'request-replace-article group))))
+(defun gnus-group-total-expirable-p (group)
+ "Check whether GROUP is total-expirable or not."
+ (let ((params (gnus-group-find-parameter group))
+ val)
+ (cond
+ ((memq 'total-expire params)
+ t)
+ ((setq val (assq 'total-expire params)) ; (auto-expire . t)
+ (cdr val))
+ (gnus-total-expirable-newsgroups ; Check var.
+ (string-match gnus-total-expirable-newsgroups group)))))
+
+(defun gnus-group-auto-expirable-p (group)
+ "Check whether GROUP is auto-expirable or not."
+ (let ((params (gnus-group-find-parameter group))
+ val)
+ (cond
+ ((memq 'auto-expire params)
+ t)
+ ((setq val (assq 'auto-expire params)) ; (auto-expire . t)
+ (cdr val))
+ (gnus-auto-expirable-newsgroups ; Check var.
+ (string-match gnus-auto-expirable-newsgroups group)))))
+
(defun gnus-virtual-group-p (group)
"Say whether GROUP is virtual or not."
(memq 'virtual (assoc (symbol-name (car (gnus-find-method-for-group group)))
(defun gnus-news-group-p (group &optional article)
"Return non-nil if GROUP (and ARTICLE) come from a news server."
- (cond ((gnus-member-of-valid 'post group) ;Ordinary news group
- t) ;is news of course.
- ((not (gnus-member-of-valid 'post-mail group)) ;Non-combined.
- nil) ;must be mail then.
- ((vectorp article) ;Has header info.
- (eq (gnus-request-type group (mail-header-id article)) 'news))
- ((null article) ;Hasn't header info
- (eq (gnus-request-type group) 'news)) ;(unknown ==> mail)
- ((< article 0) ;Virtual message
- nil) ;we don't know, guess mail.
- (t ;Has positive number
- (eq (gnus-request-type group article) 'news)))) ;use it.
+ (or (gnus-member-of-valid 'post group) ; Ordinary news group.
+ (and (gnus-member-of-valid 'post-mail group) ; Combined group.
+ (if (or (null article)
+ (not (< article 0)))
+ (eq (gnus-request-type group article) 'news)
+ (if (not (vectorp article))
+ nil
+ ;; It's a real article.
+ (eq (gnus-request-type group (mail-header-id article))
+ 'news))))))
;; Returns a list of writable groups.
(defun gnus-writable-groups ()
(nth 1 method))))
method)))
-(defsubst gnus-server-to-method (server)
- "Map virtual server names to select methods."
- (or (and server (listp server) server)
- (cdr (assoc server gnus-server-method-cache))
- (let ((result
- (or
- ;; Perhaps this is the native server?
- (and (equal server "native") gnus-select-method)
- ;; It should be in the server alist.
- (cdr (assoc server gnus-server-alist))
- ;; It could be in the predefined server alist.
- (cdr (assoc server gnus-predefined-server-alist))
- ;; If not, we look through all the opened server
- ;; to see whether we can find it there.
- (let ((opened gnus-opened-servers))
- (while (and opened
- (not (equal server (format "%s:%s" (caaar opened)
- (cadaar opened)))))
- (pop opened))
- (caar opened))
- ;; It could be a named method, search all servers
- (let ((servers gnus-secondary-select-methods))
- (while (and servers
- (not (equal server (format "%s:%s" (caar servers)
- (cadar servers)))))
- (pop servers))
- (car servers)))))
- (push (cons server result) gnus-server-method-cache)
- result)))
-
(defsubst gnus-server-get-method (group method)
;; Input either a server name, and extended server name, or a
;; select method, and return a select method.
(t
(gnus-server-add-address method))))
+(defun gnus-server-to-method (server)
+ "Map virtual server names to select methods."
+ (or
+ ;; Is this a method, perhaps?
+ (and server (listp server) server)
+ ;; Perhaps this is the native server?
+ (and (equal server "native") gnus-select-method)
+ ;; It should be in the server alist.
+ (cdr (assoc server gnus-server-alist))
+ ;; It could be in the predefined server alist.
+ (cdr (assoc server gnus-predefined-server-alist))
+ ;; If not, we look through all the opened server
+ ;; to see whether we can find it there.
+ (let ((opened gnus-opened-servers))
+ (while (and opened
+ (not (equal server (format "%s:%s" (caaar opened)
+ (cadaar opened)))))
+ (pop opened))
+ (caar opened))))
+
(defmacro gnus-method-equal (ss1 ss2)
"Say whether two servers are equal."
`(let ((s1 ,ss1)
(setq s1 (cdr s1)))
(null s1))))))
-(defun gnus-methods-equal-p (m1 m2)
- (let ((m1 (or m1 gnus-select-method))
- (m2 (or m2 gnus-select-method)))
- (or (equal m1 m2)
- (and (eq (car m1) (car m2))
- (or (not (memq 'address (assoc (symbol-name (car m1))
- gnus-valid-select-methods)))
- (equal (nth 1 m1) (nth 1 m2)))))))
-
(defun gnus-server-equal (m1 m2)
"Say whether two methods are equal."
(let ((m1 (cond ((null m1) gnus-select-method)
(and active
(file-exists-p active))))))
-(defsubst gnus-method-to-server-name (method)
- (concat
- (format "%s" (car method))
- (when (and
- (or (assoc (format "%s" (car method))
- (gnus-methods-using 'address))
- (gnus-server-equal method gnus-message-archive-method))
- (nth 1 method)
- (not (string= (nth 1 method) "")))
- (concat "+" (nth 1 method)))))
-
-(defsubst gnus-method-to-full-server-name (method)
- (format "%s+%s" (car method) (nth 1 method)))
-
(defun gnus-group-prefixed-name (group method)
"Return the whole name from GROUP and METHOD."
(and (stringp method) (setq method (gnus-server-to-method method)))
(if (or (not method)
- (gnus-server-equal method "native")
- (string-match ":" group))
+ (gnus-server-equal method "native"))
group
- (concat (gnus-method-to-server-name method) ":" group)))
+ (concat (format "%s" (car method))
+ (when (and
+ (or (assoc (format "%s" (car method))
+ (gnus-methods-using 'address))
+ (gnus-server-equal method gnus-message-archive-method))
+ (nth 1 method)
+ (not (string= (nth 1 method) "")))
+ (concat "+" (nth 1 method)))
+ ":" group)))
(defun gnus-group-real-prefix (group)
"Return the prefix of the current group name."
possible
(list backend server))))))
-(defsubst gnus-native-method-p (method)
- "Return whether METHOD is the native select method."
- (gnus-method-equal method gnus-select-method))
-
(defsubst gnus-secondary-method-p (method)
"Return whether METHOD is a secondary select method."
(let ((methods gnus-secondary-select-methods)
(gmethod (gnus-server-get-method nil method)))
(while (and methods
- (not (gnus-method-equal
- (gnus-server-get-method nil (car methods))
- gmethod)))
+ (not (equal (gnus-server-get-method nil (car methods))
+ gmethod)))
(setq methods (cdr methods)))
methods))
-(defun gnus-method-simplify (method)
- "Return the shortest uniquely identifying string or method for METHOD."
- (cond ((stringp method)
- method)
- ((gnus-native-method-p method)
- nil)
- ((gnus-secondary-method-p method)
- (format "%s:%s" (nth 0 method) (nth 1 method)))
- (t
- method)))
-
(defun gnus-groups-from-server (server)
"Return a list of all groups that are fetched from SERVER."
(let ((alist (cdr gnus-newsrc-alist))
"Say whether the group is secondary or not."
(gnus-secondary-method-p (gnus-find-method-for-group group)))
-(defun gnus-parameters-get-parameter (group)
- "Return the group parameters for GROUP from `gnus-parameters'."
- (let (params-list)
- (dolist (elem gnus-parameters)
- (when (string-match (car elem) group)
- (setq params-list
- (nconc (gnus-expand-group-parameters
- (car elem) (cdr elem) group)
- params-list))))
- params-list))
-
-(defun gnus-expand-group-parameter (match value group)
- "Use MATCH to expand VALUE in GROUP."
- (with-temp-buffer
- (insert group)
- (goto-char (point-min))
- (while (re-search-forward match nil t)
- (replace-match value))
- (buffer-string)))
-
-(defun gnus-expand-group-parameters (match parameters group)
- "Go through PARAMETERS and expand them according to the match data."
- (let (new)
- (dolist (elem parameters)
- (if (and (stringp (cdr elem))
- (string-match "\\\\[0-9&]" (cdr elem)))
- (push (cons (car elem)
- (gnus-expand-group-parameter match (cdr elem) group))
- new)
- (push elem new)))
- new))
-
-(defun gnus-group-fast-parameter (group symbol &optional allow-list)
- "For GROUP, return the value of SYMBOL.
-
-You should call this in the `gnus-group-buffer' buffer.
-The function `gnus-group-find-parameter' will do that for you."
- ;; The speed trick: No cons'ing and quit early.
- (or (let ((params (funcall gnus-group-get-parameter-function group)))
- ;; Start easy, check the "real" group parameters.
- (gnus-group-parameter-value params symbol allow-list))
- ;; We didn't found it there, try `gnus-parameters'.
- (let ((result nil)
- (head nil)
- (tail gnus-parameters))
- ;; A good old-fashioned non-cl loop.
- (while tail
- (setq head (car tail)
- tail (cdr tail))
- ;; The car is regexp matching for matching the group name.
- (when (string-match (car head) group)
- ;; The cdr is the parameters.
- (setq result (gnus-group-parameter-value (cdr head)
- symbol allow-list))
- (when result
- ;; Expand if necessary.
- (if (and (stringp result) (string-match "\\\\[0-9&]" result))
- (setq result (gnus-expand-group-parameter (car head)
- result group)))
- ;; Exit the loop early.
- (setq tail nil))))
- ;; Done.
- result)))
-
(defun gnus-group-find-parameter (group &optional symbol allow-list)
"Return the group parameters for GROUP.
-If SYMBOL, return the value of that symbol in the group parameters.
-
-If you call this function inside a loop, consider using the faster
-`gnus-group-fast-parameter' instead."
+If SYMBOL, return the value of that symbol in the group parameters."
(save-excursion
(set-buffer gnus-group-buffer)
- (if symbol
- (gnus-group-fast-parameter group symbol allow-list)
- (nconc
- (copy-sequence
- (funcall gnus-group-get-parameter-function group))
- (gnus-parameters-get-parameter group)))))
+ (let ((parameters (funcall gnus-group-get-parameter-function group)))
+ (if symbol
+ (gnus-group-parameter-value parameters symbol allow-list)
+ parameters))))
(defun gnus-group-get-parameter (group &optional symbol allow-list)
"Return the group parameters for GROUP.
(when info
(gnus-info-set-score info (+ (gnus-info-score info) (or score 1))))))
+;; Function written by Stainless Steel Rat <ratinox@peorth.gweep.net>
(defun gnus-short-group-name (group &optional levels)
"Collapse GROUP name LEVELS.
Select methods are stripped and any remote host name is stripped down to
(depth 0)
(skip 1)
(levels (or levels
- gnus-group-uncollapsed-levels
(progn
(while (string-match "\\." group skip)
(setq skip (match-end 0)
depth (+ depth 1)))
depth))))
- ;; Separate foreign select method from group name and collapse.
- ;; If method contains a server, collapse to non-domain server name,
- ;; otherwise collapse to select method.
- (let* ((colon (string-match ":" group))
- (server (and colon (substring group 0 colon)))
- (plus (and server (string-match "+" server))))
- (when server
- (if plus
- (setq foreign (substring server (+ 1 plus)
- (string-match "\\." server))
- group (substring group (+ 1 colon)))
- (setq foreign server
- group (substring group (+ 1 colon))))
- (setq foreign (concat foreign ":")))
- ;; Collapse group name leaving LEVELS uncollapsed elements
- (let* ((slist (split-string group "/"))
- (slen (length slist))
- (dlist (split-string group "\\."))
- (dlen (length dlist))
- glist
- glen
- gsep
- res)
- (if (> slen dlen)
- (setq glist slist
- glen slen
- gsep "/")
- (setq glist dlist
- glen dlen
- gsep "."))
- (setq levels (- glen levels))
- (dolist (g glist)
- (push (if (>= (decf levels) 0)
- (if (zerop (length g))
- ""
- (substring g 0 1))
- g)
- res))
- (concat foreign (mapconcat 'identity (nreverse res) gsep))))))
+ ;; separate foreign select method from group name and collapse.
+ ;; if method contains a server, collapse to non-domain server name,
+ ;; otherwise collapse to select method
+ (when (string-match ":" group)
+ (cond ((string-match "+" group)
+ (let* ((plus (string-match "+" group))
+ (colon (string-match ":" group (or plus 0)))
+ (dot (string-match "\\." group)))
+ (setq foreign (concat
+ (substring group (+ 1 plus)
+ (cond ((null dot) colon)
+ ((< colon dot) colon)
+ ((< dot colon) dot)))
+ ":")
+ group (substring group (+ 1 colon)))))
+ (t
+ (let* ((colon (string-match ":" group)))
+ (setq foreign (concat (substring group 0 (+ 1 colon)))
+ group (substring group (+ 1 colon)))))))
+ ;; collapse group name leaving LEVELS uncollapsed elements
+ (while group
+ (if (and (string-match "\\." group) (> levels 0))
+ (setq name (concat name (substring group 0 1))
+ group (substring group (match-end 0))
+ levels (- levels 1)
+ name (concat name "."))
+ (setq name (concat foreign name group)
+ group nil)))
+ name))
(defun gnus-narrow-to-body ()
"Narrow to the body of an article."
(let ((opened gnus-opened-servers))
(while (and method opened)
(when (and (equal (cadr method) (cadaar opened))
- (equal (car method) (caaar opened))
(not (equal method (caar opened))))
(setq method nil))
(pop opened))
(list (intern server) "")))
gnus-select-method))
-(defun gnus-server-string (server)
- "Return a readable string that describes SERVER."
- (let* ((server (gnus-server-to-method server))
- (address (nth 1 server)))
- (if (and address
- (not (zerop (length address))))
- (format "%s using %s" address (car server))
- (format "%s" (car server)))))
-
(defun gnus-find-method-for-group (group &optional info)
"Find the select method that GROUP uses."
(or gnus-override-method
(and (not group)
gnus-select-method)
- (and (not (gnus-group-entry group)) ;; a new group
- (gnus-group-name-to-method group))
(let ((info (or info (gnus-get-info group)))
method)
(if (or (not info)
(defun gnus-read-group (prompt &optional default)
"Prompt the user for a group name.
-Disallow invalid group names."
+Disallow illegal group names."
(let ((prefix "")
group)
(while (not group)
(when (string-match
- gnus-invalid-group-regexp
+ "[: `'\"/]\\|^$"
(setq group (read-string (concat prefix prompt)
(cons (or default "") 0)
'gnus-group-history)))
- (setq prefix (format "Invalid group name: \"%s\". " group)
+ (setq prefix (format "Illegal group name: \"%s\". " group)
group nil)))
group))
(defun gnus-read-method (prompt)
"Prompt the user for a method.
Allow completion over sensible values."
- (let* ((open-servers
- (mapcar (lambda (i) (cons (format "%s:%s" (caar i) (cadar i)) i))
- gnus-opened-servers))
- (valid-methods
- (let (methods)
- (dolist (method gnus-valid-select-methods)
- (if (or (memq 'prompt-address method)
- (not (assoc (format "%s:" (car method)) open-servers)))
- (push method methods)))
- methods))
- (servers
- (append valid-methods
- open-servers
+ (let* ((servers
+ (append gnus-valid-select-methods
gnus-predefined-server-alist
gnus-server-alist))
(method
((equal method "")
(setq method gnus-select-method))
((assoc method gnus-valid-select-methods)
- (let ((address (if (memq 'prompt-address
- (assoc method gnus-valid-select-methods))
- (read-string "Address: ")
- "")))
- (or (cadr (assoc (format "%s:%s" method address) open-servers))
- (list (intern method) address))))
+ (list (intern method)
+ (if (memq 'prompt-address
+ (assoc method gnus-valid-select-methods))
+ (read-string "Address: ")
+ "")))
((assoc method servers)
method)
(t
(list (intern method) "")))))
-;;; Agent functions
-
-(defun gnus-agent-method-p (method)
- "Say whether METHOD is covered by the agent."
- (member method gnus-agent-covered-methods))
-
-(defun gnus-online (method)
- (not
- (if gnus-plugged
- (eq (cadr (assoc method gnus-opened-servers)) 'offline)
- (gnus-agent-method-p method))))
-
;;; User-level commands.
;;;###autoload
(defun gnus-slave-no-server (&optional arg)
- "Read network news as a slave, without connecting to the local server."
+ "Read network news as a slave, without connecting to local server."
(interactive "P")
(gnus-no-server arg t))
;;;###autoload
(defun gnus-no-server (&optional arg slave)
"Read network news.
-If ARG is a positive number, Gnus will use that as the startup
-level. If ARG is nil, Gnus will be started at level 2. If ARG is
-non-nil and not a positive number, Gnus will prompt the user for the
-name of an NNTP server to use.
-As opposed to `gnus', this command will not connect to the local
-server."
+If ARG is a positive number, Gnus will use that as the
+startup level. If ARG is nil, Gnus will be started at level 2.
+If ARG is non-nil and not a positive number, Gnus will
+prompt the user for the name of an NNTP server to use.
+As opposed to `gnus', this command will not connect to the local server."
(interactive "P")
(gnus-no-server-1 arg slave))
(let ((window (get-buffer-window gnus-group-buffer)))
(cond (window
(select-frame (window-frame window)))
+ ((= (length (frame-list)) 1)
+ (select-frame (make-frame)))
(t
- (select-frame (make-frame)))))
+ (other-frame 1))))
(gnus arg))
-;;(setq thing ? ; this is a comment
-;; more 'yes)
-
;;;###autoload
(defun gnus (&optional arg dont-connect slave)
"Read network news.
startup level. If ARG is non-nil and not a positive number, Gnus will
prompt the user for the name of an NNTP server to use."
(interactive "P")
- (unless (byte-code-function-p (symbol-function 'gnus))
- (message "You should byte-compile Gnus")
- (sit-for 2))
(gnus-1 arg dont-connect slave))
;; Allow redefinition of Gnus functions.
projects / elisp / gnus.git- / blobdiff