+Fri Feb 9 09:56:45 1996 Lars Magne Ingebrigtsen <larsi@ifi.uio.no>
+
+ * gnus-picon.el (gnus-picons-convert-x-face): Changed to use
+ pbmplus,
+
+ * gnus.el (gnus-buffer-configuration): One quote too many.
+
+ * gnus-kill.el (gnus-execute): Allow searching bodies.
+
+ * gnus.el (gnus-summary-execute-command): Accept "Body" searches.
+
+Fri Feb 9 09:44:04 1996 Lars Magne Ingebrigtsen <larsi@eistla.ifi.uio.no>
+
+ * nnmail.el (nnmail-time-since): Reversed time.
+
+ * nnml.el (nnml-request-expire-articles): Set lower limit
+ correctly.
+
+Fri Feb 9 05:40:39 1996 Lars Ingebrigtsen <lars@eyesore.no>
+
+ * nntp.el (nntp-open-server-semi-internal): Report errors better.
+
+Thu Feb 8 00:36:09 1996 Lars Ingebrigtsen <lars@eyesore.no>
+
+ * gnus.el (gnus-group-jump-to-group): Don't jump to ephemeral
+ groups.
+ (gnus-summary-catchup-and-goto-next-group): Allow quiet going.
+
+ * gnus-topic.el (gnus-topic-move-group): Allow removal of groups.
+ (gnus-topic-remove-group): New command and keystroke.
+
+ * nnsoup.el (nnsoup-read-areas): Message.
+
+ * nndoc.el (nndoc-possibly-change-buffer): Return nil when the
+ file doesn't exist.
+ (nndoc-close-server): Really close.
+
+ * gnus.el (gnus-update-format-specifications): Would not update
+ format specs.
+
+ * gnus-topic.el (gnus-topic-remove-topic): Accept a list-level.
+ (gnus-group-prepare-topics): List dead groups.
+
+Wed Feb 7 00:04:23 1996 Lars Ingebrigtsen <lars@eyesore.no>
+
+ * gnus.el (gnus-summary-hide-thread): Hide the last thread.
+
+ * gnus-kill.el (gnus-kill): Provide.
+ (gnus-execute-1): Accept forms.
+
+ * nnheader.el (nnheader-temp-write): New macro.
+
+ * gnus-soup.el (gnus-soup-group-brew): Pack ticked.
+ (gnus-soup-write-replies): Be silent.
+
+ * gnus-msg.el (gnus-bug-mail-send-and-exit): Kill gnus-bug buffer
+ after sending.
+
+ * gnus.el (gnus-setup-news): Find new newsgroups even if
+ gnus-read-active-file is nil.
+
+ * gnus-soup.el (gnus-soup-group-brew): Would pack too few
+ articles.
+
+ * nneething.el (nneething-request-type): New function.
+ (nneething-request-post): Removed.
+
+ * nnvirtual.el (nnvirtual-find-group-art): Never return `(nil)'.
+
+ * nndoc.el (nndoc-rnews-body-end): Really go to the end.
+
+ * nnsoup.el (nnsoup-read-areas): Would calculate new article
+ boundary +1.
+ (nnsoup-index-buffer): Check whether the file exists before
+ reading it.
+ (nnsoup-retrieve-headers): Ditto.
+
+ * gnus-topic.el (gnus-topic-goto-missing-group): New function.
+
+Tue Feb 6 22:33:50 1996 Lars Ingebrigtsen <lars@eyesore.no>
+
+ * gnus.el (gnus-goto-missing-group-function): New variable.
+
+ * nnmail.el (nnmail-time-since): Don't alter time.
+ (nnmail-days-to-time): Would give wrong result.
+
+ * gnus.el (gnus-article-de-quoted-unreadable): Decode headers
+ before body.
+
+Tue Feb 6 09:51:14 1996 Morioka Tomohiko <morioka@jaist.ac.jp>
+
+ * gnus.el (gnus-article-show-hidden-text): Don't use `(1+
+ (point))'. It does not work in Mule.
+
+Mon Feb 5 13:03:47 1996 Wes Hardaker <hardaker@teal.ece.ucdavis.edu>
+
+ * gnus-picon.el (gnus-group-display-picons): Delete buffer on exit.
+ (gnus-article-display-picons): Ditto.
+
+Tue Feb 6 00:26:44 1996 Lars Ingebrigtsen <lars@eyesore.no>
+
+ * gnus-salt.el (gnus-tree-recenter): Recenter the tree buffer.
+
+ * gnus-cite.el (gnus-article-toggle-cited-text): Bind
+ `buffer-read-only'.
+
+ * gnus.el (gnus-configure-windows): Don't search all frames unless
+ when using a frame split.
+ (gnus-summary-mode-map): Change `W t'.
+
+Mon Feb 5 23:41:09 1996 Lars Ingebrigtsen <lars@eyesore.no>
+
+ * gnus-score.el (gnus-short-name-score-file-cache): New variable.
+ (gnus-score-score-files): Use it.
+ (gnus-score-flush-cache): Ditto.
+
+Mon Feb 4 23:55:30 1996 Morioka Tomohiko <morioka@jaist.ac.jp>
+
+ * gnus.el (gnus-configure-windows): Check minibuffer only frame.
+
+Mon Feb 5 22:36:24 1996 Lars Ingebrigtsen <lars@eyesore.no>
+
+ * nnsoup.el (nnsoup-old-functions): New variable.
+ (nnsoup-revert-variables): New command.
+
Mon Feb 5 17:54:07 1996 Lars Magne Ingebrigtsen <larsi@eistla.ifi.uio.no>
* nnvirtual.el (nnvirtual-update-marked): Copy empty mark lists.
* gnus.el (gnus-summary-read-group): Allow entry with no-display.
+ * gnus.el: 0.36 is released.
+
Sat Feb 3 11:56:53 1996 Steven L. Baur <steve@miranova.com>
* gnus-uu.el (gnus-uu-default-view-rules): Added rule for playing of
* gnus.el (gnus-summary-edit-article): Make sure we're in the
summary buffer.
+ * gnus.el: 0.35 is released.
+
Sun Feb 4 14:05:20 1996 Lars Magne Ingebrigtsen <larsi@eistla.ifi.uio.no>
* nndoc.el (nndoc-guess-digest-type): Too strict body-begin for
+++ /dev/null
-From lars Thu Feb 23 23:20:38 1995
-From: larsi@ifi.uio.no (ding)
-Date: Fri Feb 24 13:40:45 1995
-Subject: This is a test version of this group
-Message-ID: <lars-doc0@eyesore.no>
-
-This group will look something like this, but the stuff in here is of
-little worth right now.
-
-For real documentation, you'll have to read the source code. Or you
-can read the info file, which is pretty comprehensive, if somewhat out
-of date.
-
-Gnus is currently in beta.
-
-When you happen upon a bug, please drop me a note.
-
-
-From lars Thu Feb 23 23:20:38 1995
-From: larsi@ifi.uio.no (ding)
-Date: Fri Feb 24 13:40:45 1995
-Subject: So you want to use the new Gnus
-Message-ID: <lars-doc1@eyesore.no>
-
-Actually, since you are reading this, chances are you are already
-using the new Gnus. Congratulations.
-
-This entire newsgroup you are reading is, in fact, no real newsgroup
-at all, in the traditional sense. It is an example of one of the
-"foreign" select methods that Gnus may use.
-
-The text you are now reading is stored in the "etc" directory with the
-rest of the Emacs sources. You are using the "nndir" backend for
-accessing it. Scary, isn't it?
-
-This isn't the real documentation. `M-x info', `m gnus <RET>' to read
-that. This "newsgroup" is intended as a kinder, gentler way of getting
-people started.
-
-Gnus is a rewrite of GNUS 4.1, written by Masanobu Umeda. The rewrite
-was done by moi, yours truly, your humble servant, Lars Magne
-Ingebrigtsen. If you have a WWW browser, you can investigate to your
-heart's delight at "http://www.ifi.uio.no/~larsi/larsi.html".
-
-Much code (especially the score code) was written by Per Abrahamsen.
-
-;; Copyright (C) 1995 Free Software Foundation, Inc.
-
-;; Author: Lars Magne Ingebrigtsen <larsi@ifi.uio.no>
-;; Keywords: news
-
-;; This file is part of GNU Emacs.
-
-;; GNU Emacs is free software; you can redistribute it and/or modify
-;; it under the terms of the GNU General Public License as published by
-;; the Free Software Foundation; either version 2, or (at your option)
-;; any later version.
-
-;; GNU Emacs is distributed in the hope that it will be useful,
-;; but WITHOUT ANY WARRANTY; without even the implied warranty of
-;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-;; GNU General Public License for more details.
-
-;; You should have received a copy of the GNU General Public License
-;; along with GNU Emacs; see the file COPYING. If not, write to
-;; the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
-
-From lars Thu Feb 23 23:20:38 1995
-From: larsi@ifi.uio.no (ding)
-Date: Fri Feb 24 13:40:45 1995
-Subject: Starting up
-Message-ID: <lars-doc2@eyesore.no>
-
-If you are having problems with Gnus not finding your server, you have
-to set `gnus-select-method'. A "method" is a way of specifying *how*
-the news is to be found, and from *where*.
-
-Say you want to read news from you local, friendly nntp server
-"news.my.local.server".
-
-(setq gnus-select-method '(nntp "news.my.local.server"))
-
-Quite easy, huh?
-
-From the news spool:
-
-(setq gnus-select-method '(nnspool ""))
-
-From your mh-e spool:
-
-(setq gnus-select-method '(nnmh ""))
-
-There's a whole bunch of other methods for reading mail and news, see
-the "Foreign groups" article for that.
-
-
-From lars Thu Feb 23 23:20:38 1995
-From: larsi@ifi.uio.no (ding)
-Date: Fri Feb 24 13:40:45 1995
-Subject: Where are all the groups, then?
-Message-ID: <lars-doc3@eyesore.no>
-
-If this is the first time you have used a newsreader, you won't have a
-.newsrc file. This means that Gnus will think that all the newsgroups
-on the server are "new", and kill them all.
-
-If you have a .newsrc file, the new groups will be processed with the
-function in the `gnus-subscribe-newsgroup-method' variable, which is
-`gnus-subscribe-zombies' by default.
-
-This means that all the groups have been made into "zombies" - not
-quite dead, but not exactly alive, either.
-
-Jump back to the *Group* buffer, and type `C-c C-z' to list all the
-zombie groups. Look though the list, and subscribe to the groups you
-want to read by pressing `u' on the one you think look interesting.
-
-If all the groups have been killed, type `C-c C-k' to list all the
-killed groups. Subscribe to them the same way.
-
-When you are satisfied, press `M-z' to kill all the zombie groups.
-
-Now you should have a nice list of all groups you are interested in.
-
-(If you later want to subscribe to more groups, press `C-c C-k' to
-list all the kill groups, and repeat. You can also type `U' and be
-prompted for groups to subscribe to.)
-
-
-From lars Thu Feb 23 23:20:38 1995
-From: larsi@ifi.uio.no (ding)
-Date: Fri Feb 24 13:40:45 1995
-Subject: I want to read my mail!
-Message-ID: <lars-doc4@eyesore.no>
-
-Yes, Virginia, you can read mail with Gnus.
-
-First you have to decide which mail backend you want to use. You have
-nnml, which is a one-file-one-mail backend, which is quite nice, but
-apt to make your systems administrator go crazy and come after you
-with a shotgun.
-
-nnmbox uses a Unix mail box to store mail. Nice, but slow.
-
-nnmh uses mh-e folders, which is also a one-file-one-mail thingie, but
-slower than nnml. (It doesn't support NOV files.)
-
-So if you want to go with nnmbox, you can simply say:
-
-(setq gnus-secondary-select-methods '((nnmbox "")))
-
-(The same for the other methods, kind of.)
-
-You should also set `nnmail-split-methods' to something sensible:
-
-(setq nnmail-split-methods
- '(("mail.junk" "From:.*Lars")
- ("mail.misc "")))
-
-This will put all mail from me in you junk mail group, and the rest in
-"mail.misc".
-
-These groups will be subscribe the same way as the normal groups, so
-you will probably find them among the zombie groups after you set
-these variables and re-start Gnus.
-
-
-From lars Thu Feb 23 23:20:38 1995
-From: larsi@ifi.uio.no (ding)
-Date: Fri Feb 24 13:40:45 1995
-Subject: Foreign newsgroups
-Message-ID: <lars-doc5@eyesore.no>
-
-These are groups that do not come from `gnus-select-method'.
-
-Say you want to read "alt.furniture.couches" from "news.funet.fi". You
-can then either type `B news.funet.fi <RET>' to browse that server and
-subscribe to that group, or you can type
-`M-a alt.furniture.couches<RET>nntp<RET>news.funet.fi<RET>', if you
-like to type a lot.
-
-If you want to read a directory as a newsgroup, you can create an
-nndir group, much the same way. There's a shorthand for that,
-though. If, for instance, you want to read the (ding) list archives,
-you could type `D /ftp <RET>'.
-
-There's lots more to know about foreign groups, but you have to read
-the info pages to find out more.
-
-
-From lars Thu Feb 23 23:20:38 1995
-From: larsi@ifi.uio.no (ding)
-Date: Fri Feb 24 13:40:45 1995
-Subject: Low level changes in GNUS, or, Wrong type argument: stringp, nil
-Message-ID: <lars-doc6@eyesore.no>
-
-Gnus really isn't GNUS, even though it looks like it. If you scrape
-the surface, you'll find that most things have changed.
-
-This means that old code that relies on GNUS internals will fail.
-
-In particular, `gnus-newsrc-hashtb', `gnus-newsrc-assoc',
-`gnus-killed-list', the `nntp-header-' macros and the display formats
-have all changed. If you have some code lying around that depend on
-these, or change these, you'll have to re-write your code.
-
-Old hilit19 code does not work at all. In fact, you should probably
-remove all hihit code from all the Gnus hooks
-(`gnus-group-prepare-hook', `gnus-summary-prepare-hook' and
-`gnus-summary-article-hook'). (Well, at the very least the first
-two.) Gnus provides various integrated functions for highlighting,
-which are both faster and more accurated.
-
-There is absolutely no chance, whatsoever, of getting Gnus to work
-with Emacs 18.
-
-
-From lars Thu Feb 23 23:20:38 1995
-From: larsi@ifi.uio.no (ding)
-Date: Fri Feb 24 13:40:45 1995
-Subject: Bugs & stuff
-Message-ID: <lars-doc7@eyesore.no>
-
-If you want to report a bug, please type `M-x gnus-bug'. This will
-give me a precice overview of your Gnus and Emacs version numbers,
-along with a look at all Gnus variables you have changed.
-
-Du not expect a reply back, but your bug should be fixed in the next
-version. If the bug persists, please re-submit your bug report.
-
-When a bug occurs, I need a recipe for how to trigger the bug. You
-have to tell me exactly what you do to uncover the bug, and you should
-(setq debug-on-error t) and send me the backtrace along with the bug
-report.
-
-If I am not able to reproduce the bug, I won't be able to fix it.
-
-I would, of course, prefer that you locate the bug, fix it, and mail
-me the patches, but one can't have everything.
-
-If you have any questions on usage, the "ding@ifi.uio.no" mailing list
-is where to post the questions.
-
-
-From lars Thu Feb 23 23:20:38 1995
-From: larsi@ifi.uio.no (ding)
-Date: Fri Feb 24 13:40:45 1995
-Subject: How do I re-scan my mail groups?
-Message-ID: <lars-doc8@eyesore.no>
-
-Reading the active file from the nntp server is a drag.
-
-Just press `M-g' on the mail groups, and they will be re-scanned.
-
-You can also re-scan all the mail groups by putting them on level 1
-(`1 S'), and saying `1 g' to re-scan all level 1 groups.
-
-
-From lars Thu Feb 23 23:20:38 1995
-From: larsi@ifi.uio.no (ding)
-Date: Fri Feb 24 13:40:45 1995
-Subject: How do I set up virtual newsgroups?
-Message-ID: <lars-doc9@eyesore.no>
-
-Virtual newsgroups are collections of other newsgroups. Why people
-want this is beyond me, but here goes:
-
-Create the group by saying
-
-`M-a my.virtual.newsgroup<RET>nnvirtual<RET>^rec\.aquaria\.*<RET>'
-
-This will create the group "nnvirtual:my.virtual.newsgroup", which
-will collect all articles from all the groups in the "rec.aquaria"
-hierarchy.
-
-If you want to edit the regular expression, just type `M-e' on the
-group line.
-
-Note that all the groups that are part of the virtual group have to be
-alive. This means that the cannot, absolutely not, be zombie or
-killed. They can be unsubscribed; that's no problem.
-
-You can combine groups from different servers in the same virtual
-newsgroup, something that may actually be useful. Say you have the
-group "comp.headers" on the server "news.server.no" and the same group
-on "news.server.edu". If people have posted articles with Distribution
-headers that stop propagation of their articles, combining these two
-newsgroups into one virtual newsgroup should give you a better view of
-what's going on.
-
-One caveat, though: The virtual group article numbers from the first
-source group (group A) will always be lower than the article numbers
-from the second (group B). This means that Gnus will believe that
-articles from group A are older than articles from group B. Threading
-will lessen these problems, but it might be a good idea to sort the
-threads over the date of the articles to get a correct feel for the
-flow of the groups:
-
-(setq gnus-thread-sort-functions '(gnus-thread-sort-by-date))
-
-If you only want this in virtual groups, you could say something along
-the lines of:
-
-(setq gnus-select-group-hook
- (lambda ()
- (if (eq 'nnvirtual (car (gnus-find-method-for-group
- gnus-newsgroup-name)))
- (progn
- (make-local-variable 'gnus-thread-sort-functions)
- (setq gnus-thread-sort-functions '(gnus-thread-sort-by-date))))))
-
-
-From lars Thu Feb 23 23:20:38 1995
-From: larsi@ifi.uio.no (ding)
-Date: Fri Feb 24 13:40:45 1995
-Subject: I want to kiboze everything in sight!
-Message-ID: <lars-doc10@eyesore.no>
-
-The nnkiboze backend collects articles that you are interested in from
-groups you are interested in. Below is a description for how you can
-gather all posts from me, and all posts about Gnus in the gnu.emacs
-hierarchy in one handy, easy to read group.
-
-Gnus will let you eat up all available machine resources, grinding
-everything to a halt. Including your nntp server. Who says Gnus isn't
-friendly?
-
-You want to do this, of course.
-
-Create an nnkiboze group the normal way:
-
-`M-a my.group<RET>nnkiboze<RET>^gnu.emacs.*<RET>'
-
-You now have a shiny new group that you can't enter. How...
-practical.
-
-But just wait, it gets worse.
-
-You now have to create a score file.
-
-`C-x C-f ~/News/nnkiboze:my.group.SCORE<RET>'
-
-Put something like the following in this file:
-
-(setq gnus-score-alist
- '(("from"
- ("Ingebrigtsen" nil 1000)
- ("lmi" nil 5000))
- ("subject"
- ("Gnus" nil 10000))
- (touched)))
-
-Save the file, and go to a shell window.
-
-Type:
-
-$ emacs -batch -l ~/.emacs -l nnkiboze -f nnkiboze-generate-groups
-
-Wait a few hours, and all articles from me, or articles about Gnus,
-will appear, as if by magic, in the nnkiboze group. You really want
-that, of course.
-
-Gnus actually grabs the headers of all the groups that supply the
-nnkiboze group with articles, so this isn't very kind. Pleasy only do
-it at night (`at' is a fine command), and please, *please*, limit the
-number of groups that supply articles to the group. If you specify ""
-as the address of this group, nnkiboze will ask for headers from *all*
-groups, and this is megs and megs and megs of data.
-
-Use it, don't abuse it. Be nice.
-
-
-
-
(defun gnus-cache-enter-remove-article (article)
"Mark ARTICLE for later possible removal."
- (push article gnus-cache-removable-articles))
+ (when article
+ (push article gnus-cache-removable-articles)))
(defun gnus-cache-possibly-remove-articles ()
"Possibly remove some of the removable articles."
(require 'gnus)
(require 'gnus-msg)
(require 'gnus-ems)
+(eval-when-compile (require 'cl))
(eval-and-compile
(autoload 'gnus-article-add-button "gnus-vis"))
(defun gnus-article-toggle-cited-text (region)
"Toggle hiding the text in REGION."
- (funcall
- (if (text-property-any
- (car region) (cdr region)
- (car gnus-hidden-properties) (cadr gnus-hidden-properties))
- 'remove-text-properties 'add-text-properties)
- (car region) (cdr region) gnus-hidden-properties))
+ (let (buffer-read-only)
+ (funcall
+ (if (text-property-any
+ (car region) (cdr region)
+ (car gnus-hidden-properties) (cadr gnus-hidden-properties))
+ 'remove-text-properties 'add-text-properties)
+ (car region) (cdr region) gnus-hidden-properties)))
(defun gnus-article-hide-citation-maybe (&optional arg force)
"Toggle hiding of cited text that has an attribution line.
(require 'custom)
(require 'gnus-ems)
(require 'browse-url)
+(eval-when-compile (require 'cl))
;; The following is just helper functions and data, not ment to be set
;; by the user.
(require 'custom)
(require 'gnus-score)
+(eval-when-compile (require 'cl))
(defconst gnus-score-custom-data
'((tag . "Score")
;;; Code:
+(eval-when-compile (require 'cl))
+
(defvar gnus-mouse-2 [mouse-2])
(defalias 'gnus-make-overlay 'make-overlay)
;;; Code:
(require 'gnus)
+(eval-when-compile (require 'cl))
(defvar gnus-kill-file-mode-hook nil
"*A hook for Gnus kill file mode.")
(or (stringp value)
(setq value (prin1-to-string value)))
(setq did-kill (string-match regexp value)))
- (if (stringp form) ;Keyboard macro.
- (execute-kbd-macro form)
- (funcall form))))
+ (cond ((stringp form) ;Keyboard macro.
+ (execute-kbd-macro form))
+ ((gnus-functionp form)
+ (funcall form))
+ (t
+ (eval form)))))
;; Search article body.
(let ((gnus-current-article nil) ;Save article pointer.
(gnus-last-article nil)
(save-excursion
(let ((killed-no 0)
function article header)
- (if (or (null field)
- (string-equal field "")
- (not (fboundp
- (setq function
- (intern-soft
- (concat "mail-header-" (downcase field)))))))
- (error "Unknown header field: \"%s\"" field)
- ;; Get access function of header filed.
- (setq function `(lambda (h) (,function h)))
- ;; Starting from the current article.
- (while (or (and (not article)
- (setq article (gnus-summary-article-number))
- t)
- (setq article
- (gnus-summary-search-forward
- (not ignore-marked) nil backward)))
- (and (or (null gnus-newsgroup-kill-headers)
- (memq article gnus-newsgroup-kill-headers))
- (vectorp (setq header (gnus-summary-article-header article)))
- (gnus-execute-1 function regexp form header)
- (setq killed-no (1+ killed-no))))
- killed-no))))
-
+ (cond
+ ;; Search body.
+ ((or (null field)
+ (string-equal field ""))
+ (setq function nil))
+ ;; Get access function of header field.
+ ((fboundp
+ (setq function
+ (intern-soft
+ (concat "mail-header-" (downcase field)))))
+ (setq function `(lambda (h) (,function h))))
+ ;; Signal error.
+ (t
+ (error "Unknown header field: \"%s\"" field)))
+ ;; Starting from the current article.
+ (while (or (and (not article)
+ (setq article (gnus-summary-article-number))
+ t)
+ (setq article
+ (gnus-summary-search-forward
+ (not ignore-marked) nil backward)))
+ (and (or (null gnus-newsgroup-kill-headers)
+ (memq article gnus-newsgroup-kill-headers))
+ (vectorp (setq header (gnus-summary-article-header article)))
+ (gnus-execute-1 function regexp form header)
+ (setq killed-no (1+ killed-no))))
+ killed-no)))
+
+(provide 'gnus-kill)
+
+;;; gnus-kill.el ends here
\ No newline at end of file
(defun gnus-bug-mail-send-and-exit ()
"Send the bug message and exit."
(interactive)
- (and (get-buffer "*Gnus Help Bug*")
- (kill-buffer "*Gnus Help Bug*"))
- (gnus-mail-send-and-exit))
+ (let ((cur (current-buffer)))
+ (and (get-buffer "*Gnus Help Bug*")
+ (kill-buffer "*Gnus Help Bug*"))
+ (gnus-mail-send-and-exit)
+ (when (buffer-name cur)
+ (kill-buffer cur))))
(defun gnus-debug ()
"Attemps to go through the Gnus source file and report what variables have been changed.
(require 'xpm)
(require 'annotations)
+(eval-when-compile (require 'cl))
(defvar gnus-picons-buffer "*Icon Buffer*"
"Buffer name to display the icons in if gnus-picons-display-where is 'picons.")
Some people may want to add \"unknown\" to this list."
)
-(setq gnus-group-annotations nil)
-(setq gnus-article-annotations nil)
+(defvar gnus-group-annotations nil)
+(defvar gnus-article-annotations nil)
+(defvar gnus-x-face-annotations nil)
(defun gnus-picons-remove (plist)
(let ((listitem (car plist)))
((stringp variable)
variable)))
+(defvar gnus-picons-x-face-file-name
+ (format "/tmp/picon-xface.%s.xbm" (user-login-name))
+ "The name of the file in which to store the converted X-face header.")
+
+(defvar gnus-picons-convert-x-face (format "{ echo '/* Width=48, Height=48 */'; uncompface; } | icontopbm | pbmtoxbm > %s" gnus-picons-x-face-file-name)
+ "Command to convert the x-face header into a xbm file."
+)
+
+(defun gnus-picons-article-display-x-face ()
+ "Display the x-face header bitmap in the 'gnus-picons-display-where buffer."
+ ;; delete any old ones.
+ (gnus-picons-remove gnus-x-face-annotations)
+ (setq gnus-x-face-annotations nil)
+ ;; display the new one.
+ (let ((gnus-article-x-face-command 'gnus-picons-display-x-face))
+ (gnus-article-display-x-face)))
+
+(defun gnus-picons-display-x-face (beg end)
+ "Function to display the x-face header in the picons window.
+To use: (setq gnus-article-x-face-command 'gnus-picons-display-x-face)"
+ (interactive)
+ ;; convert the x-face header to a .xbm file
+ (let ((process-connection-type nil)
+ (process nil))
+ (process-kill-without-query
+ (setq process (start-process
+ "gnus-x-face" nil "sh" "-c" gnus-picons-convert-x-face)))
+ (process-send-region "gnus-x-face" beg end)
+ (process-send-eof "gnus-x-face")
+ ;; wait for it.
+ (while (not (equal (process-status process) 'exit))
+ (sleep-for .1)))
+ ;; display it
+ (save-excursion
+ (set-buffer (gnus-get-buffer-name gnus-picons-display-where))
+ (gnus-add-current-to-buffer-list)
+ (beginning-of-buffer)
+ (let ((iconpoint (point)))
+ (if (not (looking-at "^$"))
+ (if buffer-read-only
+ (progn
+ (toggle-read-only)
+ (open-line 1)
+ (toggle-read-only)
+ )
+ (open-line 1)))
+ (end-of-line)
+ ;; append the annotation to gnus-article-annotations for deletion.
+ (setq gnus-x-face-annotations
+ (append
+ (gnus-picons-try-to-find-face
+ gnus-picons-x-face-file-name iconpoint)
+ gnus-x-face-annotations)))
+ ;; delete the tmp file
+ (delete-file gnus-picons-x-face-file-name)))
+
(defun gnus-article-display-picons ()
- "Display faces for an author and his/her domain in gnus-picons-display-where."
+"Display faces for an author and his/her domain in gnus-picons-display-where."
(interactive)
(if (and (featurep 'xpm)
(or (not (fboundp 'device-type)) (equal (device-type) 'x)))
"\\1")
"\\." "/")) "/")))
(switch-to-buffer (gnus-get-buffer-name gnus-picons-display-where))
+ (gnus-add-current-to-buffer-list)
(beginning-of-buffer)
(setq iconpoint (point))
(if (not (looking-at "^$"))
(let
((iconpoint (point)))
(switch-to-buffer (gnus-get-buffer-name gnus-picons-display-where))
+ (gnus-add-current-to-buffer-list)
(beginning-of-buffer)
(cond
((listp gnus-group-annotations)
)
)
-
(defun gnus-picons-try-to-find-face (path ipoint)
"If PATH exists, display it as a bitmap. Returns t if succedded."
- (if (file-exists-p path)
- (progn
-; (insert (format "yes: %s\n" path))
- (setq gl (make-glyph path))
- (set-glyph-face gl 'default)
- (list (make-annotation gl ipoint 'text)))
-; (insert (format "no: %s\n" path))
- nil))
+ (when (file-exists-p path)
+ (let ((gl (make-glyph path)))
+ (set-glyph-face gl 'default)
+ (list (make-annotation gl ipoint 'text)))))
(defun gnus-picons-reverse-domain-path (str)
"a/b/c/d -> d/c/b/a"
(concat (replace-in-string str "^.*/\\([_a-zA-Z0-9-]+\\)$" "\\1") "/"
(gnus-picons-reverse-domain-path
(replace-in-string str "^\\(.*\\)/[_a-zA-Z0-9-]+$" "\\1")))))
+
+(provide 'gnus-picon)
+
+;;; gnus-picon.el ends here
(defun gnus-tree-recenter ()
"Center point in the tree window."
(let ((selected (selected-window))
- (cur-window (get-buffer-window (current-buffer) t)))
- (when cur-window
- (select-window cur-window)
+ (tree-window (get-buffer-window gnus-tree-buffer t)))
+ (when tree-window
+ (select-window tree-window)
(when gnus-selected-tree-overlay
(goto-char (or (gnus-overlay-end gnus-selected-tree-overlay) 1)))
(let* ((top (cond ((< (window-height) 4) 0)
;; possible valid number, or the second line from the top,
;; whichever is the least.
(set-window-start
- cur-window (min bottom (save-excursion
- (forward-line (- top)) (point)))))
+ tree-window (min bottom (save-excursion
+ (forward-line (- top)) (point)))))
(select-window selected))))
(defun gnus-get-tree-buffer ()
(defvar gnus-internal-global-score-files nil)
(defvar gnus-score-file-list nil)
+(defvar gnus-short-name-score-file-cache nil)
+
(defvar gnus-score-help-winconf nil)
(defvar gnus-adaptive-score-alist gnus-default-adaptive-score-alist)
(defvar gnus-score-trace nil)
(defun gnus-score-flush-cache ()
"Flush the cache of score files."
(interactive)
- (setq gnus-score-cache nil)
+ (setq gnus-score-cache nil
+ gnus-short-name-score-file-cache nil)
(gnus-message 6 "The score cache is now flushed"))
(defun gnus-score-close ()
;; We do not use long file names, so we have to do some
;; directory traversing.
(setq gnus-score-file-list
- (cons nil (gnus-score-score-files-1 gnus-kill-files-directory)))
+ (cons nil
+ (or gnus-short-name-score-file-cache
+ (setq gnus-short-name-score-file-cache
+ (gnus-score-score-files-1
+ gnus-kill-files-directory)))))
;; We want long file names.
(when (or (not gnus-score-file-list)
(not (car gnus-score-file-list))
(require 'gnus-msg)
(require 'gnus)
+(eval-when-compile (require 'cl))
;;; User Variables:
;; Return the MSG buf.
msg-buf)))
-(defun gnus-soup-group-brew (group)
- "Enter GROUP and add all articles to a SOUP package."
+(defun gnus-soup-group-brew (group &optional not-all)
+ "Enter GROUP and add all articles to a SOUP package.
+If NOT-ALL, don't pack ticked articles."
(let ((gnus-expert-user t)
(gnus-large-newsgroup nil))
- (when (gnus-summary-read-group group)
- (let ((gnus-newsgroup-processable
- (nreverse
- (gnus-sorted-complement
- gnus-newsgroup-unreads
- (append gnus-newsgroup-dormant gnus-newsgroup-marked)))))
- (gnus-soup-add-article nil)))
- (gnus-summary-exit)))
+ (when (gnus-summary-read-group group nil t)
+ (let ((gnus-newsgroup-processable
+ (if (not not-all)
+ (reverse (append gnus-newsgroup-marked
+ gnus-newsgroup-unreads))
+ (reverse gnus-newsgroup-unreads))))
+ (gnus-soup-add-article nil))
+ (gnus-summary-exit))))
(defun gnus-soup-insert-idx (offset header)
;; [number subject from date id references chars lines xref]
(gnus-soup-parse-areas (concat gnus-soup-directory "AREAS")))))
(defun gnus-soup-write-areas ()
- "Write all areas to disk."
+ "Write the AREAS file."
(interactive)
- (if (not gnus-soup-areas)
- ()
- (save-excursion
- (set-buffer (find-file-noselect
- (concat gnus-soup-directory "AREAS")))
- (buffer-disable-undo (current-buffer))
- (erase-buffer)
+ (when gnus-soup-areas
+ (nnheader-temp-write (concat gnus-soup-directory "AREAS")
(let ((areas gnus-soup-areas)
area)
- (while areas
- (setq area (car areas)
- areas (cdr areas))
- (insert (format "%s\t%s\t%s%s\n"
- (gnus-soup-area-prefix area)
- (gnus-soup-area-name area)
- (gnus-soup-area-encoding area)
- (if (or (gnus-soup-area-description area)
- (gnus-soup-area-number area))
- (concat "\t" (or (gnus-soup-area-description
- area)
- "")
- (if (gnus-soup-area-number area)
- (concat "\t"
- (int-to-string
- (gnus-soup-area-number
- area)))
- "")) "")))))
- (write-region (point-min) (point-max)
- (concat gnus-soup-directory "AREAS") nil 'silent)
- (set-buffer-modified-p nil)
- (kill-buffer (current-buffer)))))
+ (while (setq area (pop areas))
+ (insert
+ (format
+ "%s\t%s\t%s%s\n"
+ (gnus-soup-area-prefix area)
+ (gnus-soup-area-name area)
+ (gnus-soup-area-encoding area)
+ (if (or (gnus-soup-area-description area)
+ (gnus-soup-area-number area))
+ (concat "\t" (or (gnus-soup-area-description
+ area) "")
+ (if (gnus-soup-area-number area)
+ (concat "\t" (int-to-string
+ (gnus-soup-area-number area)))
+ "")) ""))))))))
(defun gnus-soup-write-replies (dir areas)
- (or (file-directory-p dir)
- (gnus-make-directory dir))
- (save-excursion
- (set-buffer (find-file-noselect (concat dir "REPLIES")))
- (buffer-disable-undo (current-buffer))
- (erase-buffer)
+ "Write a REPLIES file in DIR containing AREAS."
+ (nnheader-temp-write (concat dir "REPLIES")
(let (area)
- (while areas
- (setq area (car areas)
- areas (cdr areas))
+ (while (setq area (pop areas))
(insert (format "%s\t%s\t%s\n"
(gnus-soup-reply-prefix area)
(gnus-soup-reply-kind area)
- (gnus-soup-reply-encoding area)))))
- (write-region (point-min) (point-max) (concat dir "REPLIES") nil 'silent)
- (set-buffer-modified-p nil)
- (kill-buffer (current-buffer))))
+ (gnus-soup-reply-encoding area)))))))
(defun gnus-soup-area (group)
(gnus-soup-read-areas)
;;; Internal variables.
+(defvar gnus-inserted-opened-servers nil)
+
(defconst gnus-server-line-format-alist
(` ((?h how ?s)
(?n name ?s)
(when gnus-carpal
(gnus-carpal-setup-buffer 'server)))))
-(fset 'gnus-server-position-point 'gnus-goto-colon)
-
(defun gnus-server-prepare ()
(setq gnus-server-mode-line-format-spec
(gnus-parse-format gnus-server-mode-line-format
(let ((alist gnus-server-alist)
(buffer-read-only nil)
(opened gnus-opened-servers)
- done server)
+ done server op-ser)
(erase-buffer)
+ (setq gnus-inserted-opened-servers nil)
;; First we do the real list of servers.
(while alist
(push (cdr (setq server (pop alist))) done)
(while opened
(unless (member (car (car opened)) done)
(gnus-server-insert-server-line
- (format "%s:%s" (car (car (car opened))) (nth 1 (car (car opened))))
- (car (car opened))))
+ (setq op-ser (format "%s:%s" (car (car (car opened)))
+ (nth 1 (car (car opened)))))
+ (car (car opened)))
+ (push (list op-ser (caar opened)) gnus-inserted-opened-servers))
(setq opened (cdr opened))))
(goto-char (point-min))
(gnus-server-position-point))
(defun gnus-server-set-info (server info)
;; Enter a select method into the virtual server alist.
- (gnus-dribble-enter
- (concat "(gnus-server-set-info \"" server "\" '"
- (prin1-to-string info) ")"))
- (let* ((server (nth 1 info))
- (entry (assoc server gnus-server-alist)))
- (if entry (setcdr entry info)
- (setq gnus-server-alist
- (nconc gnus-server-alist (list (cons server info)))))))
+ (when (and server info)
+ (gnus-dribble-enter
+ (concat "(gnus-server-set-info \"" server "\" '"
+ (prin1-to-string info) ")"))
+ (let* ((server (nth 1 info))
+ (entry (assoc server gnus-server-alist)))
+ (if entry (setcdr entry info)
+ (setq gnus-server-alist
+ (nconc gnus-server-alist (list (cons server info))))))))
;;; Interactive server functions.
(defun gnus-server-edit-server (server)
"Edit the server on the current line."
(interactive (list (gnus-server-server-name)))
- (or server
- (error "No server on current line"))
+ (unless server
+ (error "No server on current line"))
+ (unless (assoc server gnus-server-alist)
+ (error "This server can't be edited"))
(let ((winconf (current-window-configuration)))
(get-buffer-create gnus-server-edit-buffer)
(gnus-configure-windows 'edit-server)
(list "Gnus")))
(gnus-topic-enter-dribble))
-(defun gnus-group-prepare-topics (level &optional all lowest regexp list-topic)
+(defun gnus-group-prepare-topics (level &optional all lowest regexp list-topic topic-level)
"List all newsgroups with unread articles of level LEVEL or lower, and
use the `gnus-group-topics' to sort the groups.
If ALL is non-nil, list groups that have no unread articles.
(let ((buffer-read-only nil)
(lowest (or lowest 1))
tlist info)
-
+
(unless list-topic
(erase-buffer))
;; List dead groups?
- (when nil
(when (and (>= level gnus-level-zombie) (<= lowest gnus-level-zombie))
(gnus-group-prepare-flat-list-dead
(setq gnus-zombie-list (sort gnus-zombie-list 'string<))
(gnus-group-prepare-flat-list-dead
(setq gnus-killed-list (sort gnus-killed-list 'string<))
gnus-level-killed ?K
- regexp)))
+ regexp))
;; Use topics.
(when (< lowest gnus-level-zombie)
(if list-topic
(let ((top (gnus-topic-find-topology list-topic)))
- (gnus-topic-prepare-topic (cdr top) (car top) level all))
- (gnus-topic-prepare-topic gnus-topic-topology 0 level all))))
+ (gnus-topic-prepare-topic (cdr top) (car top)
+ (or topic-level level) all))
+ (gnus-topic-prepare-topic gnus-topic-topology 0
+ (or topic-level level) all))))
(gnus-group-set-mode-line)
(setq gnus-group-list-mode (cons level all))
(topic (reverse topic))
(all-entries entries)
(unread 0)
- info entry end)
+ info entry end active)
;; Insert any sub-topics.
(while topic
(incf unread
(setq end (point))
(goto-char beg)
;; Insert all the groups that belong in this topic.
- (while (setq info (nth 2 (setq entry (pop entries))))
+ (while (setq entry (pop entries))
(when visiblep
- (gnus-group-insert-group-line
- (gnus-info-group info)
- (gnus-info-level info) (gnus-info-marks info)
- (car entry) (gnus-info-method info)))
+ (if (stringp entry)
+ (gnus-group-insert-group-line
+ entry (if (member entry gnus-zombie-list) 8 9)
+ nil (- (1+ (cdr (setq active (gnus-active entry))))
+ (car active)) nil)
+ (when (setq info (nth 2 entry))
+ (gnus-group-insert-group-line
+ (gnus-info-group info)
+ (gnus-info-level info) (gnus-info-marks info)
+ (car entry) (gnus-info-method info)))))
(when (numberp (car entry))
(incf unread (car entry))))
(goto-char beg)
(defun gnus-topic-find-groups (topic &optional level all)
"Return entries for all visible groups in TOPIC."
(let ((groups (cdr (assoc topic gnus-topic-alist)))
- info clevel unread group w lowest gtopic params visible-groups entry)
+ info clevel unread group lowest params visible-groups entry active)
(setq lowest (or lowest 1))
(setq level (or level 7))
;; We go through the newsrc to look for matches.
(while groups
- (setq entry (gnus-gethash (pop groups) gnus-newsrc-hashtb)
+ (setq entry (gnus-gethash (setq group (pop groups)) gnus-newsrc-hashtb)
info (nth 2 entry)
- group (gnus-info-group info)
params (gnus-info-params info)
- unread (car entry))
+ active (gnus-active group)
+ unread (or (car entry)
+ (and (not (equal group "dummy.group"))
+ active
+ (- (1+ (cdr active)) (car active))))
+ clevel (or (gnus-info-level info)
+ (if (member group gnus-zombie-list) 8 9)))
(and
unread ; nil means that the group is dead.
- (<= (setq clevel (gnus-info-level info)) level)
+ (<= clevel level)
(>= clevel lowest) ; Is inside the level we want.
(or all
(and gnus-group-list-inactive-groups
(memq 'visible params)
(cdr (assq 'visible params)))
;; Add this group to the list of visible groups.
- (push entry visible-groups)))
+ (push (or entry group) visible-groups)))
(nreverse visible-groups)))
-(defun gnus-topic-remove-topic (&optional insert total-remove hide)
+(defun gnus-topic-remove-topic (&optional insert total-remove hide in-level)
"Remove the current topic."
(let ((topic (gnus-group-topic-name))
(level (gnus-group-topic-level))
(setcdr (cdr (car (cdr (gnus-topic-find-topology topic))))
(list hide)))
(unless total-remove
- (gnus-topic-insert-topic topic)))))
+ (gnus-topic-insert-topic topic in-level)))))
-(defun gnus-topic-insert-topic (topic)
+(defun gnus-topic-insert-topic (topic &optional level)
"Insert TOPIC."
(gnus-group-prepare-topics
(car gnus-group-list-mode) (cdr gnus-group-list-mode)
- nil nil topic))
+ nil nil topic level))
(defun gnus-topic-fold (&optional insert)
"Remove/insert the current topic."
(gnus-topic-remove-topic
(or insert (not (gnus-topic-visible-p))))
(let ((gnus-topic-topology gnus-topic-active-topology)
- (gnus-topic-alist gnus-topic-active-alist))
+ (gnus-topic-alist gnus-topic-active-alist)
+ (gnus-group-list-mode (cons 5 t)))
(gnus-topic-remove-topic
- (or insert (not (gnus-topic-visible-p))))))))))
+ (or insert (not (gnus-topic-visible-p))) nil nil 9)))))))
(defun gnus-group-topic-p ()
"Return non-nil if the current line is a topic."
(gnus-group-goto-group group)
(gnus-group-position-point))))
+(defun gnus-topic-goto-missing-group (group)
+ "Place point where GROUP is supposed to be inserted."
+ (let* ((topic (gnus-group-topic group))
+ (groups (cdr (assoc topic gnus-topic-alist)))
+ (g (cdr (member group groups)))
+ (unfound t))
+ (while (and g unfound)
+ (when (gnus-group-goto-group (pop g))
+ (beginning-of-line)
+ (setq unfound nil)))
+ (when unfound
+ (setq g (cdr (member group (reverse groups))))
+ (while (and g unfound)
+ (when (gnus-group-goto-group (pop g))
+ (forward-line 1)
+ (setq unfound nil)))
+ (when unfound
+ (gnus-topic-goto-topic topic)
+ (forward-line 1)))))
+
(defun gnus-topic-update-topic-line (&optional topic level)
(unless topic
(setq topic gnus-topic-topology)
"#" gnus-topic-mark-topic
"n" gnus-topic-create-topic
"m" gnus-topic-move-group
+ "D" gnus-topic-remove-group
"c" gnus-topic-copy-group
"h" gnus-topic-hide-topic
"s" gnus-topic-show-topic
("Groups"
["Copy" gnus-topic-copy-group t]
["Move" gnus-topic-move-group t]
+ ["Remove" gnus-topic-remove-group t]
["Copy matching" gnus-topic-copy-matching t]
["Move matching" gnus-topic-move-matching t])
("Topics"
(setq gnus-group-goto-next-group-function
'gnus-topic-goto-next-group)
(setq gnus-group-change-level-function 'gnus-topic-change-level)
+ (setq gnus-goto-missing-group-function 'gnus-topic-goto-missing-group)
(run-hooks 'gnus-topic-mode-hook)
;; We check the topology.
(gnus-topic-check-topology))
(let ((groups (gnus-group-process-prefix n))
(topicl (assoc topic gnus-topic-alist))
entry)
- (unless topicl
- (error "No such topic: %s" topic))
(mapcar (lambda (g)
(gnus-group-remove-mark g)
(when (and
(setq entry (assoc (gnus-group-topic g) gnus-topic-alist))
(not copyp))
(setcdr entry (delete g (cdr entry))))
- (nconc topicl (list g)))
+ (when topicl
+ (nconc topicl (list g))))
groups)
(gnus-group-position-point))
(gnus-topic-enter-dribble)
(gnus-group-list-groups))
+(defun gnus-topic-remove-group (n)
+ "Remove the current group the topic."
+ (interactive "P")
+ (gnus-topic-move-group n nil))
+
(defun gnus-topic-copy-group (n topic)
"Copy the current group to a topic."
(interactive
(interactive "P")
(gnus-topic-grok-active)
(let ((gnus-topic-topology gnus-topic-active-topology)
- (gnus-topic-alist gnus-topic-active-alist))
+ (gnus-topic-alist gnus-topic-active-alist)
+ gnus-killed-list gnus-zombie-list)
(gnus-group-list-groups 9 nil 1)))
(provide 'gnus-topic)
("\\.\\(wav\\|aiff\\|hcom\\|u[blw]\\|s[bfw]\\|voc\\|smp\\)$"
"sox -v .5 %s -t .au -u - > /dev/audio")
("\\.au$" "cat %s > /dev/audio")
- ("\\.mid?i$" "playmidi -f")
+ ("\\.midi?$" "playmidi -f")
("\\.mod$" "str32")
("\\.ps$" "ghostview")
("\\.dvi$" "xdvi")
(summary 0.25 point)
(if gnus-carpal '(summary-carpal 4))
(article 1.0))
- (vertical '((height . 5) (width . 15)
- (user-position . t)
- (left . -1) (top . 1))
+ (vertical ((height . 5) (width . 15)
+ (user-position . t)
+ (left . -1) (top . 1))
(picons 1.0))))
(gnus-use-trees
'(vertical 1.0
(defvar gnus-topic-indentation "") ;; Obsolete variable.
+(defvar gnus-goto-missing-group-function nil)
+
(defvar gnus-override-subscribe-method nil)
(defvar gnus-group-goto-next-group-function nil
"gnus-bug@ifi.uio.no (The Gnus Bugfixing Girls + Boys)"
"The mail address of the Gnus maintainers.")
-(defconst gnus-version "September Gnus v0.36"
+(defconst gnus-version "September Gnus v0.37"
"Version number for this version of Gnus.")
(defvar gnus-info-nodes
gnus-summary-mail-forward gnus-summary-mail-other-window
gnus-bug)
("gnus-picon" :interactive t gnus-article-display-picons
- gnus-group-display-picons)
+ gnus-group-display-picons gnus-picons-article-display-x-face)
("gnus-vm" gnus-vm-mail-setup)
("gnus-vm" :interactive t gnus-summary-save-in-vm
gnus-summary-save-article-vm gnus-yank-article))))
;; Make the indentation array.
(gnus-make-thread-indent-array)
+ ;; See whether all the stored info needs to be flushed.
(when (or force
- (and (assq 'version gnus-format-specs)
- (not (equal emacs-version
- (cdr (assq 'version gnus-format-specs))))))
+ (not (equal emacs-version
+ (cdr (assq 'version gnus-format-specs)))))
(setq gnus-format-specs nil))
+ ;; Go through all the formats and see whether they need updating.
(let ((types '(summary summary-dummy group
- summary-mode group-mode article-mode))
- old-format new-format entry type val)
- (while types
- (setq type (pop types))
+ summary-mode group-mode article-mode))
+ new-format entry type val)
+ (while (setq type (pop types))
(setq new-format (symbol-value
(intern (format "gnus-%s-line-format" type))))
(setq entry (cdr (assq type gnus-format-specs)))
(if (and entry
(equal (car entry) new-format))
+ ;; Use the old format.
(set (intern (format "gnus-%s-line-format-spec" type))
- (car (cdr entry)))
+ (cadr entry))
+ ;; This is a new format.
(setq val
(if (not (stringp new-format))
;; This is a function call or something.
(if (eq type 'article-mode)
'summary-mode type))))
(not (string-match "mode$" (symbol-name type))))))
- (set (intern (format "gnus-%s-line-format-spec" type)) val)
+ ;; Enter the new format spec into the list.
(if entry
- (setcar (cdr entry) val)
- (push (list type new-format val) gnus-format-specs)))))
+ (progn
+ (setcar (cdr entry) val)
+ (setcar entry new-format))
+ (push (list type new-format val) gnus-format-specs))
+ (set (intern (format "gnus-%s-line-format-spec" type)) val))))
(gnus-update-group-mark-positions)
(gnus-update-summary-mark-positions)
+ ;; See whether we need to read the description file.
(if (and (string-match "%[-,0-9]*D" gnus-group-line-format)
(not gnus-description-hashtb)
gnus-read-active-file)
(gnus-read-all-descriptions-files)))
(defun gnus-update-summary-mark-positions ()
+ "Compute where the summary marks are to go."
(save-excursion
(let ((gnus-replied-mark 129)
(gnus-score-below-mark 130)
(when result
(select-window result))))))
+(defvar gnus-frame-split-p nil)
+
(defun gnus-configure-windows (setting &optional force)
(setq setting (gnus-windows-old-to-new setting))
(let ((split (if (symbolp setting)
rule val w height hor ohor heights sub jump-buffer
rel total to-buf all-visible)
+ (setq gnus-frame-split-p nil)
+
(unless split
(error "No such setting: %s" setting))
- (if (and (not force) (setq all-visible (gnus-all-windows-visible-p split)))
+ (if (and (not force)
+ (setq all-visible (gnus-all-windows-visible-p split)))
;; All the windows mentioned are already visible, so we just
;; put point in the assigned buffer, and do not touch the
;; winconf.
(let ((frame (selected-frame)))
(unwind-protect
(if gnus-use-full-window
- (mapcar (lambda (frame)
- (select-frame frame)
- (delete-other-windows))
- (frame-list))
+ ;; We want to remove all other windows.
+ (if (not gnus-frame-split-p)
+ ;; This is not a `frame' split, so we ignore the
+ ;; other frames.
+ (delete-other-windows)
+ ;; This is a `frame' split, so we delete all windows
+ ;; on all frames.
+ (mapcar
+ (lambda (frame)
+ (unless (eq (cdr (assq 'minibuffer
+ (frame-parameters frame)))
+ 'only)
+ (select-frame frame)
+ (delete-other-windows)))
+ (frame-list)))
+ ;; Just remove some windows.
(gnus-remove-some-windows)
(switch-to-buffer nntp-server-buffer))
(select-frame frame)))
win
t))))
(t
+ (when (eq type 'frame)
+ (setq gnus-frame-split-p t))
(let ((n (mapcar 'gnus-all-windows-visible-p
(cdr (cdr split))))
(win t))
(gnus-delete-line)
(gnus-group-insert-group-line-info group))
(setq loc (1+ loc)))
- (if (or found visible-only)
- ()
+ (unless (or found visible-only)
;; No such line in the buffer, find out where it's supposed to
;; go, and insert it there (or at the end of the buffer).
- ;; Fix by Per Abrahamsen <amanda@iesd.auc.dk>.
- (let ((entry (cdr (cdr (gnus-gethash group gnus-newsrc-hashtb)))))
- (while (and entry (car entry)
- (not
- (gnus-goto-char
- (text-property-any
- (point-min) (point-max)
- 'gnus-group (gnus-intern-safe
- (car (car entry))
- gnus-active-hashtb)))))
- (setq entry (cdr entry)))
- (or entry (goto-char (point-max))))
+ (if gnus-goto-missing-group-function
+ (funcall gnus-goto-missing-group-function group)
+ (let ((entry (cdr (cdr (gnus-gethash group gnus-newsrc-hashtb)))))
+ (while (and entry (car entry)
+ (not
+ (gnus-goto-char
+ (text-property-any
+ (point-min) (point-max)
+ 'gnus-group (gnus-intern-safe
+ (car (car entry))
+ gnus-active-hashtb)))))
+ (setq entry (cdr entry)))
+ (or entry (goto-char (point-max)))))
;; Finally insert the line.
(let ((gnus-group-indentation (gnus-group-group-indentation)))
(gnus-group-insert-group-line-info group)))
(let ((b (text-property-any
(point-min) (point-max)
'gnus-group (gnus-intern-safe group gnus-active-hashtb))))
- (if b
- ;; Either go to the line in the group buffer...
- (goto-char b)
- ;; ... or insert the line.
- (or
- (gnus-active group)
- (gnus-activate-group group)
- (error "%s error: %s" group (gnus-status-message group)))
-
- (gnus-group-update-group group)
- (goto-char (text-property-any
- (point-min) (point-max)
- 'gnus-group (gnus-intern-safe group gnus-active-hashtb)))))
- ;; Adjust cursor point.
- (gnus-group-position-point))
+ (unless (gnus-ephemeral-group-p group)
+ (if b
+ ;; Either go to the line in the group buffer...
+ (goto-char b)
+ ;; ... or insert the line.
+ (or
+ (gnus-active group)
+ (gnus-activate-group group)
+ (error "%s error: %s" group (gnus-status-message group)))
+
+ (gnus-group-update-group group)
+ (goto-char (text-property-any
+ (point-min) (point-max)
+ 'gnus-group (gnus-intern-safe group gnus-active-hashtb)))))
+ ;; Adjust cursor point.
+ (gnus-group-position-point)))
(defun gnus-group-goto-group (group)
"Goto to newsgroup GROUP."
"f" gnus-article-display-x-face
"l" gnus-summary-stop-page-breaking
"r" gnus-summary-caesar-message
- "t" gnus-summary-toggle-header
+ "t" gnus-article-hide-headers
"v" gnus-summary-verbose-headers
"m" gnus-summary-toggle-mime)
(gnus-summary-update-info)
;; Make sure where I was, and go to next newsgroup.
(set-buffer gnus-group-buffer)
- (or quit-config
- (progn
- (gnus-group-jump-to-group group)
- (gnus-group-next-unread-group 1)))
+ (unless quit-config
+ (gnus-group-jump-to-group group)
+ (gnus-group-next-unread-group 1))
(run-hooks 'gnus-summary-exit-hook)
(if temporary
nil ;Nothing to do.
"Header name: "
(mapcar (lambda (string) (list string))
'("Number" "Subject" "From" "Lines" "Date"
- "Message-ID" "Xref" "References"))
+ "Message-ID" "Xref" "References" "Body"))
nil 'require-match))
(read-string "Regexp: ")
(read-key-sequence "Command: ")
current-prefix-arg))
+ (when (equal header "Body")
+ (setq header ""))
(gnus-set-global-variables)
;; Hidden thread subtrees must be searched as well.
(gnus-summary-show-all-threads)
(gnus-set-global-variables)
(save-excursion
(gnus-summary-catchup all))
- (gnus-summary-next-article t))
+ (gnus-summary-next-article t nil nil t))
;; Thread-based commands.
;; ends.
(when (and (not (eobp))
(or (zerop (gnus-summary-next-thread 1 t))
- (goto-char (gnus-data-pos (car (gnus-data-list 'rev))))))
+ (goto-char (point-max))))
(setq end (point))
(prog1
(if (and (> (point) start)
(cond
;; We first check `gnus-original-article-buffer'.
((and (equal (car gnus-original-article) group)
- (eq (cdr gnus-original-article) article))
+ (eq (cdr gnus-original-article) article)
+ (get-buffer gnus-original-article-buffer))
(insert-buffer-substring gnus-original-article-buffer)
'article)
;; Check the backlog.
(type (gnus-fetch-field "content-transfer-encoding")))
(when (or force
(and type (string-match "quoted-printable" type)))
+ (gnus-headers-decode-quoted-printable)
(goto-char (point-min))
(search-forward "\n\n" nil 'move)
- (gnus-mime-decode-quoted-printable (point) (point-max))
- (gnus-headers-decode-quoted-printable)))))
+ (gnus-mime-decode-quoted-printable (point) (point-max))))))
(defun gnus-mime-decode-quoted-printable (from to)
"Decode Quoted-Printable in the region between FROM and TO."
(beg (point)))
(while (gnus-goto-char (text-property-any
beg (point-max) 'gnus-type type))
+ (setq beg (point))
+ (forward-char)
(if hide
- (add-text-properties (point) (setq beg (1+ (point)))
- gnus-hidden-properties)
- (remove-text-properties (point) (setq beg (1+ (point)))
- gnus-hidden-properties)))
+ (add-text-properties beg (point) gnus-hidden-properties)
+ (remove-text-properties beg (point) gnus-hidden-properties))
+ (setq beg (point)))
t)))
(defvar gnus-article-time-units
(gnus-update-format-specifications)
;; Find new newsgroups and treat them.
- (if (and init gnus-check-new-newsgroups gnus-read-active-file (not level)
+ (if (and init gnus-check-new-newsgroups (not level)
(gnus-check-server gnus-select-method))
(gnus-find-new-newsgroups))
(require 'nnheader)
(require 'rmail)
(require 'nnmail)
+(eval-when-compile (require 'cl))
(defvar nnbabyl-mbox-file (expand-file-name "~/RMAIL")
"The name of the rmail box file in the users home directory.")
(require 'nnheader)
(require 'nnmh)
(require 'nnml)
+(eval-when-compile (require 'cl))
(eval-and-compile
(autoload 'mail-send-and-exit "sendmail"))
(require 'nnheader)
(require 'rmail)
(require 'nnmail)
+(eval-when-compile (require 'cl))
(defvar nndoc-article-type 'guess
"*Type of the file.
(news
(article-begin . "^Path:"))
(rnews
- (article-begin . "^#! *rnews +\\([0-9]\\)+ *\n")
+ (article-begin . "^#! *rnews +\\([0-9]+\\) *\n")
(body-end-function . nndoc-rnews-body-end))
(mbox
(article-begin .
(slack-digest
(article-begin . "^------------------------------*[\n \t]+")
(head-end . "^ ?$")
+ (body-end-function . nndoc-digest-body-end)
(body-begin . "^ ?$")
(file-end . "^End of")
(prepare-body . nndoc-prepare-digest-body))
(defun nndoc-request-group (group &optional server dont-check)
"Select news GROUP."
- (save-excursion
- (let (number)
- (cond
- ((not (nndoc-possibly-change-buffer group server))
- (nnheader-report 'nndoc "No such file or buffer: %s"
- nndoc-address))
- (dont-check
- (nnheader-report 'nndoc "Selected group %s" group)
- t)
- ((zerop (setq number (length nndoc-dissection-alist)))
- (nndoc-close-group group)
- (nnheader-report 'nndoc "No articles in group %s" group))
- (t
- (save-excursion
- (set-buffer nntp-server-buffer)
- (erase-buffer)
- (insert (format "211 %d %d %d %s\n" number 1 number group))
- t))))))
+ (let (number)
+ (cond
+ ((not (nndoc-possibly-change-buffer group server))
+ (nnheader-report 'nndoc "No such file or buffer: %s"
+ nndoc-address))
+ (dont-check
+ (nnheader-report 'nndoc "Selected group %s" group)
+ t)
+ ((zerop (setq number (length nndoc-dissection-alist)))
+ (nndoc-close-group group)
+ (nnheader-report 'nndoc "No articles in group %s" group))
+ (t
+ (nnheader-insert "211 %d %d %d %s\n" number 1 number group)))))
(defun nndoc-request-type (group &optional article)
(cond ((not article) 'unknown)
(and (stringp nndoc-address)
(file-exists-p nndoc-address)
(not (file-directory-p nndoc-address))))
- (setq nndoc-group-alist
- (cons (cons group (setq nndoc-current-buffer
- (get-buffer-create
- (concat " *nndoc " group "*"))))
- nndoc-group-alist))
+ (push (cons group (setq nndoc-current-buffer
+ (get-buffer-create
+ (concat " *nndoc " group "*"))))
+ nndoc-group-alist)
(setq nndoc-dissection-alist nil)
(save-excursion
(set-buffer nndoc-current-buffer)
(if (stringp nndoc-address)
(insert-file-contents nndoc-address)
(insert-buffer-substring nndoc-address)))))
- (when (and nndoc-current-buffer
- (not nndoc-dissection-alist))
+ ;; Initialize the nndoc structures according to this new document.
+ (if (not (and nndoc-current-buffer
+ (not nndoc-dissection-alist)))
+ (nndoc-close-server)
(save-excursion
(set-buffer nndoc-current-buffer)
(nndoc-set-delims)
(nndoc-dissect-buffer)))
- t))
+ ;; Return whether we managed to select a file.
+ nndoc-current-buffer))
;; MIME (RFC 1341) digest hack by Ulrik Dickow <dickow@nbi.dk>.
(defun nndoc-guess-digest-type ()
+ "Guess what digest type the current document is."
(let ((case-fold-search t) ; We match a bit too much, keep it simple.
boundary-id b-delimiter entry)
(goto-char (point-min))
; (concat "\n--" boundary-id "\\(--\\)?[\n \t]+"))
(cons 'file-end (concat "\n--" boundary-id "--[ \t]*$"))))
'mime-digest)
+ ;; Standard digest.
((and (re-search-forward (concat "^" (make-string 70 ?-) "\n\n") nil t)
(re-search-forward
(concat "\n\n" (make-string 30 ?-) "\n\n") nil t))
'digest)))
(defun nndoc-set-delims ()
+ "Set the nndoc delimiter variables according to the type of the document."
(let ((vars '(nndoc-file-begin
nndoc-first-article
nndoc-article-end nndoc-head-begin nndoc-head-end
(while (setq defs (cdr (assq nndoc-article-type nndoc-type-alist))
guess (assq 'guess defs))
(setq nndoc-article-type (funcall (cdr guess))))
+ ;; Set the nndoc variables.
(while defs
(set (intern (format "nndoc-%s" (car (car defs))))
(cdr (pop defs))))))
(beginning-of-line)))
(defun nndoc-dissect-buffer ()
+ "Go through the document and partition it into heads/bodies/articles."
(let ((i 0)
(first t)
head-begin head-end body-begin body-end)
(nndoc-search nndoc-first-article)
(nndoc-search nndoc-article-begin))
(setq first nil)
- (when nndoc-head-begin
- (nndoc-search nndoc-head-begin))
- (if (and nndoc-file-end
+ (when nndoc-head-begin
+ (nndoc-search nndoc-head-begin))
+ (if (and nndoc-file-end
(looking-at nndoc-file-end))
(goto-char (point-max))
(setq head-begin (point))
(and (re-search-backward nndoc-article-begin nil t)
(setq end (point))
(search-forward "\n\n" beg t)
- (re-search-backward "^Content-Length:[ \t]*\\([0-9]+\\) *$" end t)
+ (re-search-backward
+ "^Content-Length:[ \t]*\\([0-9]+\\) *$" end t)
(setq len (string-to-int (match-string 1)))
(search-forward "\n\n" beg t)
(or (= (setq len (+ (point) len)) (point-max))
(goto-char len))))
(defun nndoc-rnews-body-end ()
- (save-excursion
- (and (re-search-backward nndoc-article-begin nil t)
- (goto-char (+ (point) (string-to-int (match-string 1)))))))
+ (and (re-search-backward nndoc-article-begin nil t)
+ (forward-line 1)
+ (goto-char (+ (point) (string-to-int (match-string 1))))))
(defun nndoc-transform-clari-briefs (article)
(goto-char (point-min))
(eval-when-compile (require 'cl))
(defvar nneething-map-file-directory "~/.nneething/"
- "*Map files directory.")
+ "*Where nneething stores the map files.")
+
+(defvar nneething-map-file ".nneething"
+ "*Name of the map files.")
(defvar nneething-exclude-files nil
"*Regexp saying what files to exclude from the group.
If this variable is nil, no files will be excluded.")
-(defvar nneething-map-file ".nneething"
- "*Name of map files.")
-
\f
+;;; Internal variables.
+
(defconst nneething-version "nneething 1.0"
"nneething version.")
(defvar nneething-status-string "")
(defvar nneething-group-alist nil)
+(defvar nneething-message-id-number 0)
+(defvar nneething-work-buffer " *nneething work*")
+
\f
(defvar nneething-directory nil)
(defvar nneething-read-only nil)
(defvar nneething-active nil)
(defvar nneething-server-variables
- `((nneething-directory ,nneething-directory)
- (nneething-current-directory nil)
- (nneething-status-string "")
- (nneething-group-alist)))
+ `((nneething-directory ,nneething-directory)
+ (nneething-current-directory nil)
+ (nneething-status-string "")
+ (nneething-group-alist)))
\f
;;; Interface functions.
-(defun nneething-retrieve-headers (sequence &optional newsgroup server fetch-old)
- (nneething-possibly-change-directory newsgroup)
+(defun nneething-retrieve-headers (articles &optional group server fetch-old)
+ (nneething-possibly-change-directory group)
(save-excursion
(set-buffer nntp-server-buffer)
(erase-buffer)
- (let* ((number (length sequence))
+ (let* ((number (length articles))
(count 0)
(large (and (numberp nnmail-large-newsgroup)
(> number nnmail-large-newsgroup)))
article file)
- (if (stringp (car sequence))
+ (if (stringp (car articles))
'headers
- (while sequence
- (setq article (car sequence))
+ (while (setq article (pop articles))
(setq file (nneething-file-name article))
- (if (and (file-exists-p file)
- (or (file-directory-p file)
- (not (zerop (nth 7 (file-attributes file))))))
- (progn
- (insert (format "221 %d Article retrieved.\n" article))
- (nneething-insert-head file)
- (insert ".\n")))
+ (when (and (file-exists-p file)
+ (or (file-directory-p file)
+ (not (zerop (nth 7 (file-attributes file))))))
+ (insert (format "221 %d Article retrieved.\n" article))
+ (nneething-insert-head file)
+ (insert ".\n"))
- (setq sequence (cdr sequence)
- count (1+ count))
+ (incf count)
(and large
(zerop (% count 20))
(message "nneething: Receiving headers... %d%%"
(/ (* count 100) number))))
- (and large (message "nneething: Receiving headers...done"))
+ (when large
+ (message "nneething: Receiving headers...done"))
- ;; Fold continuation lines.
- (goto-char (point-min))
- (while (re-search-forward "\\(\r?\n[ \t]+\\)+" nil t)
- (replace-match " " t t))
+ (nnheader-fold-continuation-lines)
'headers))))
(defun nneething-open-server (server &optional defs)
- (setq nneething-status-string "")
+ (nnheader-report 'nneething "")
(nnheader-init-server-buffer))
(defun nneething-close-server (&optional server)
+ (setq nneething-current-directory nil)
t)
(defun nneething-server-opened (&optional server)
- t)
+ nneething-current-directory)
(defun nneething-status-message (&optional server)
nneething-status-string)
-(defun nneething-request-article (id &optional newsgroup server buffer)
- (nneething-possibly-change-directory newsgroup)
- (let ((file (if (stringp id) nil (nneething-file-name id)))
+(defun nneething-request-article (id &optional group server buffer)
+ (nneething-possibly-change-directory group)
+ (let ((file (unless (stringp id) (nneething-file-name id)))
(nntp-server-buffer (or buffer nntp-server-buffer)))
(and (stringp file) ; We did not request by Message-ID.
(file-exists-p file) ; The file exists.
(defun nneething-request-group (group &optional dir dont-check)
(nneething-possibly-change-directory group dir)
- (or dont-check (nneething-create-mapping))
- (save-excursion
- (set-buffer nntp-server-buffer)
- (erase-buffer)
+ (unless dont-check
+ (nneething-create-mapping)
(if (> (car nneething-active) (cdr nneething-active))
- (insert (format "211 0 1 0 %s\n" group))
- (insert (format "211 %d %d %d %s\n"
- (- (1+ (cdr nneething-active)) (car nneething-active))
- (car nneething-active) (cdr nneething-active)
- group)))
- t))
+ (nnheader-insert "211 0 1 0 %s\n" group)
+ (nnheader-insert
+ "211 %d %d %d %s\n"
+ (- (1+ (cdr nneething-active)) (car nneething-active))
+ (car nneething-active) (cdr nneething-active)
+ group)))
+ t)
(defun nneething-request-list (&optional server dir)
- (save-excursion
- (set-buffer nntp-server-buffer)
- (erase-buffer))
- nil)
+ (nnheader-report 'nneething "LIST is not implemented."))
(defun nneething-request-newgroups (date &optional server)
- (save-excursion
- (set-buffer nntp-server-buffer)
- (erase-buffer))
- nil)
+ (nnheader-report 'nneething "NEWSGROUPS is not implemented."))
-(defun nneething-request-post (&optional server)
- (mail-send-and-exit nil))
+(defun nneething-request-type (group &optional article)
+ 'unknown)
(defun nneething-close-group (group &optional server)
+ (setq nneething-current-directory nil)
t)
\f
;;; Internal functions.
(defun nneething-possibly-change-directory (group &optional dir)
- (if (not group)
- ()
+ (when group
(if (and nneething-group
(string= group nneething-group))
t
(setq nneething-map nil)
(setq nneething-active (cons 1 0))
(nneething-create-mapping)
- (setq nneething-group-alist
- (cons (list group dir nneething-map nneething-active)
- nneething-group-alist)))))))
+ (push (list group dir nneething-map nneething-active)
+ nneething-group-alist))))))
(defun nneething-map-file ()
;; We make sure that the .nneething directory exists.
- (or (file-exists-p nneething-map-file-directory)
- (make-directory nneething-map-file-directory 'parents))
+ (unless (file-exists-p nneething-map-file-directory)
+ (make-directory nneething-map-file-directory 'parents))
;; We store it in a special directory under the user's home dir.
(concat (file-name-as-directory nneething-map-file-directory)
nneething-group nneething-map-file))
(write-region (point-min) (point-max) map-file nil 'nomesg)
(kill-buffer (current-buffer))))))
-(defvar nneething-message-id-number 0)
-(defvar nneething-work-buffer " *nneething work*")
-
(defun nneething-insert-head (file)
- (and (nneething-get-head file)
- (insert-buffer-substring nneething-work-buffer)))
+ "Insert the head of FILE."
+ (when (nneething-get-head file)
+ (insert-buffer-substring nneething-work-buffer)))
(defun nneething-make-head (file)
+ "Create a head by looking at the file attributes of FILE."
(let ((atts (file-attributes file)))
- (insert "Subject: " (file-name-nondirectory file) "\n"
- "Message-ID: <nneething-"
- (int-to-string
- (setq nneething-message-id-number
- (1+ nneething-message-id-number)))
- "@" (system-name) ">\n"
- "Date: " (current-time-string (nth 5 atts)) "\n"
- (nneething-from-line (nth 2 atts))
- "Chars: " (int-to-string (nth 7 atts)) "\n")))
+ (insert
+ "Subject: " (file-name-nondirectory file) "\n"
+ "Message-ID: <nneething-"
+ (int-to-string (incf nneething-message-id-number))
+ "@" (system-name) ">\n"
+ "Date: " (current-time-string (nth 5 atts)) "\n"
+ (nneething-from-line (nth 2 atts))
+ "Chars: " (int-to-string (nth 7 atts)) "\n")))
(defun nneething-from-line (uid)
+ "Return a From header based of UID."
(let ((login (condition-case nil
(user-login-name uid)
(error
(if name (concat " (" name ")") "") "\n")))
(defun nneething-get-head (file)
+ "Either find the head in FILE or make a head for FILE."
(save-excursion
(set-buffer (get-buffer-create nneething-work-buffer))
(setq case-fold-search nil)
t))))
(defun nneething-file-name (article)
+ "Return the file name of ARTICLE."
(concat (file-name-as-directory nneething-directory)
(if (numberp article)
(cadr (assq article nneething-map))
(erase-buffer)
(current-buffer))
+(defmacro nnheader-temp-write (file &rest forms)
+ "Create a new buffer, evaluate FORM there, and write the buffer to FILE."
+ `(save-excursion
+ (let ((nnheader-temp-file ,file)
+ (nnheader-temp-cur-buffer
+ (nnheader-set-temp-buffer
+ (generate-new-buffer-name " *nnheader temp*"))))
+ (unless (file-directory-p (file-name-directory nnheader-temp-file))
+ (make-directory (file-name-directory nnheader-temp-file) t))
+ (unwind-protect
+ (prog1
+ (progn
+ ,@forms)
+ (when nnheader-temp-file
+ (set-buffer nnheader-temp-cur-buffer)
+ (write-region (point-min) (point-max)
+ nnheader-temp-file nil 'nomesg)))
+ (when (buffer-name nnheader-temp-cur-buffer)
+ (kill-buffer nnheader-temp-cur-buffer))))))
+
+(put 'nnheader-temp-write 'lisp-indent-function 1)
+(put 'nnheader-temp-write 'lisp-indent-hook 1)
+(put 'nnheader-temp-write 'edebug-form-spec '(file &rest form))
+
(defvar jka-compr-compression-info-list)
(defvar nnheader-numerical-files
(if (boundp 'jka-compr-compression-info-list)
(require 'nnheader)
(require 'gnus)
(require 'gnus-score)
+(eval-when-compile (require 'cl))
(defvar nnkiboze-directory
(expand-file-name (or gnus-article-save-directory "~/News/"))
(defun nnmail-days-to-time (days)
"Convert DAYS into time."
- (let ((seconds (* 1.0 days 60 60 24))
- (rest (expt 2 16)))
- (list (round (/ seconds rest))
- ;;;!!!Error error error. I'm not a mathematician, though.
- (condition-case ()
- (% (round seconds) rest)
- (error 0)))))
+ (let* ((seconds (* 1.0 days 60 60 24))
+ (rest (expt 2 16))
+ (ms (round (/ seconds rest))))
+ (list ms (round (- seconds (* ms rest))))))
(defun nnmail-time-since (time)
"Return the time since TIME, which is either an internal time or a date."
+ (when (stringp time)
+ ;; Convert date strings to internal time.
+ (setq time (nnmail-date-to-time time)))
(let* ((current (current-time))
- rest)
- (when (stringp time)
- (setq time (nnmail-date-to-time time)))
- (setq rest (if (< (nth 1 current) (nth 1 time)) (expt 2 16)))
- (setcar (cdr time) (- (+ (or rest 0) (nth 1 current)) (nth 1 time)))
- (setcar time (- (+ (car current) (if rest -1 0)) (car time)))
- time))
+ (rest (if (< (nth 1 current) (nth 1 time)) (expt 2 16))))
+ (list (- (+ (car current) (if rest -1 0)) (car time))
+ (- (+ (or rest 0) (nth 1 current)) (nth 1 time)))))
;; Function taken from rmail.el.
(defun nnmail-move-inbox (inbox)
(require 'nnheader)
(require 'rmail)
(require 'nnmail)
+(eval-when-compile (require 'cl))
(defvar nnmbox-mbox-file (expand-file-name "~/mbox")
"The name of the mail box file in the user's home directory.")
(nnml-nov-delete-article newsgroup number))
(push number rest))))
(let ((active (nth 1 (assoc newsgroup nnml-group-alist))))
- (and active
- (setcar active (or (and active-articles
- (apply 'min active-articles))
- 0)))
+ (when active
+ (setcar active (or (and active-articles
+ (apply 'min active-articles))
+ (1+ (cdr active)))))
(nnmail-save-active nnml-group-alist nnml-active-file))
(nnml-save-nov)
(message "")
(let ((areas (cddr (assoc nnsoup-current-group nnsoup-group-alist)))
(articles sequence)
(use-nov t)
- useful-areas this-area-seq)
+ useful-areas this-area-seq msg-buf)
(if (stringp (car sequence))
;; We don't support fetching by Message-ID.
'headers
(while useful-areas
(goto-char (point-max))
(let ((b (point))
- (number (car (nth 1 (car useful-areas)))))
- (insert-buffer-substring
- (nnsoup-index-buffer
- (gnus-soup-area-prefix
- (nth 2 (car useful-areas)))))
- (goto-char b)
- ;; We have to remove the index number entires and
- ;; insert article numbers instead.
- (while (looking-at "[0-9]+")
- (replace-match (int-to-string number) t t)
- (incf number)
- (forward-line 1)))
+ (number (car (nth 1 (car useful-areas))))
+ (index-buffer (nnsoup-index-buffer
+ (gnus-soup-area-prefix
+ (nth 2 (car useful-areas))))))
+ (when index-buffer
+ (insert-buffer-substring index-buffer)
+ (goto-char b)
+ ;; We have to remove the index number entires and
+ ;; insert article numbers instead.
+ (while (looking-at "[0-9]+")
+ (replace-match (int-to-string number) t t)
+ (incf number)
+ (forward-line 1))))
(setq useful-areas (cdr useful-areas)))
'nov)
;; We insert HEADs.
(setq articles (car (car useful-areas))
useful-areas (cdr useful-areas))
(while articles
- (goto-char (point-max))
- (insert (format "221 %d Article retrieved.\n" (car articles)))
- (insert-buffer-substring
- (nnsoup-narrow-to-article
- (car articles) (cdr (car useful-areas)) 'head))
- (goto-char (point-max))
- (insert ".\n")
+ (when (setq msg-buf
+ (nnsoup-narrow-to-article
+ (car articles) (cdr (car useful-areas)) 'head))
+ (goto-char (point-max))
+ (insert (format "221 %d Article retrieved.\n" (car articles)))
+ (insert-buffer-substring msg-buf)
+ (goto-char (point-max))
+ (insert ".\n"))
(setq articles (cdr articles))))
- ;; Fold continuation lines.
- (goto-char (point-min))
- (while (re-search-forward "\\(\r?\n[ \t]+\\)+" nil t)
- (replace-match " " t t))
+ (nnheader-fold-continuation-lines)
'headers)))))
(defun nnsoup-open-server (server &optional defs)
(while (setq area (pop areas))
;; Change the name to the permanent name and move the files.
(setq cur-prefix (nnsoup-next-prefix))
+ (message "Incorporating file %s..." cur-prefix)
(when (file-exists-p
(setq file (concat nnsoup-tmp-directory
(gnus-soup-area-prefix area) ".IDX")))
nnsoup-group-alist)
;; There are already articles in this group, so we add this
;; info to the end of the entry.
- (let ((e (cddr entry)))
- (while (cdr e)
- (setq e (cdr e)))
- (setcdr e (list (list (cons (setq lnum (1+ (cdr (car (car e)))))
- (+ lnum number))
- area))))
+ (nconc entry (list (list (cons (1+ (setq lnum (cdadr entry)))
+ (+ lnum number))
+ area)))
(setcdr (cadr entry) (+ lnum number)))))
(nnsoup-write-active-file)))
(let* ((file (concat prefix (if message ".MSG" ".IDX")))
(buffer-name (concat " *nnsoup " file "*")))
(or (get-buffer buffer-name) ; File aready loaded.
- (save-excursion ; Load the file.
- (set-buffer (get-buffer-create buffer-name))
- (buffer-disable-undo (current-buffer))
- (push (cons nnsoup-current-group (current-buffer)) nnsoup-buffers)
- (insert-file-contents (concat nnsoup-directory file))
- (current-buffer)))))
+ (when (file-exists-p (concat nnsoup-directory file))
+ (save-excursion ; Load the file.
+ (set-buffer (get-buffer-create buffer-name))
+ (buffer-disable-undo (current-buffer))
+ (push (cons nnsoup-current-group (current-buffer)) nnsoup-buffers)
+ (insert-file-contents (concat nnsoup-directory file))
+ (current-buffer))))))
(defun nnsoup-file (prefix &optional message)
(expand-file-name
(defun nnsoup-narrow-to-article (article &optional area head)
(let* ((area (or area (nnsoup-article-to-area article nnsoup-current-group)))
(prefix (gnus-soup-area-prefix (nth 1 area)))
- beg end msg-buf)
- (setq msg-buf (nnsoup-index-buffer prefix 'msg))
+ (msg-buf (nnsoup-index-buffer prefix 'msg))
+ beg end)
(save-excursion
(cond
+ ;; There is no MSG file.
+ ((null msg-buf)
+ nil)
+
;; We use the index file to find out where the article begins and ends.
((and (= (gnus-soup-encoding-index
(gnus-soup-area-encoding (nth 1 area)))
(setq areas (cdr areas)))
(and areas (car areas))))
+(defvar nnsoup-old-functions
+ (list gnus-inews-article-function send-mail-function))
+
;;;###autoload
(defun nnsoup-set-variables ()
"Use the SOUP methods for posting news and mailing mail."
(setq gnus-inews-article-function 'nnsoup-request-post)
(setq send-mail-function 'nnsoup-request-mail))
+;;;###autoload
+(defun nnsoup-revert-variables ()
+ "Revert posting and mailing methods to the standard Emacs methods."
+ (interactive)
+ (setq gnus-inews-article-function (car nnsoup-old-functions))
+ (setq send-mail-function (cadr nnsoup-old-functions)))
+
(defun nnsoup-store-reply (kind)
;; Mostly stolen from `sendmail.el'.
(let ((tembuf (generate-new-buffer " sendmail temp"))
(while (re-search-forward "^#! *rnews" nil t)
(incf num)))
(message "Stored %d messages" num)))
+ (nnsoup-write-replies)
(kill-buffer tembuf))))
(defun nnsoup-kind-to-prefix (kind)
(require 'nnheader)
(require 'nntp)
(require 'timezone)
+(eval-when-compile (require 'cl))
(defvar nnspool-inews-program news-inews-program
"Program to post news.
(require 'rnews)
(require 'sendmail)
(require 'nnheader)
+(eval-when-compile (require 'cl))
(eval-and-compile
(unless (fboundp 'open-network-stream)
(defun nntp-server-opened (&optional server)
"Say whether a connection to SERVER has been opened."
- (and (equal server nntp-current-server)
+ (and (or (not server)
+ (equal server nntp-current-server))
nntp-server-buffer
(buffer-name nntp-server-buffer)
nntp-server-process
(when proc
(delete-process (process-name proc)))
(nntp-close-server server)
- (setq nntp-status-string
- (message "Connection timed out to server %s." server))
+ (nnheader-report
+ 'nntp (message "Connection timed out to server %s" server))
(ding)
(sit-for 1)))
(nntp-wait-for-response "^[23].*\r?\n" 'slow)
(error nil)
(quit nil)))
- (or status (nntp-close-server-internal server))
- (and nntp-server-process
- (progn
- (set-process-sentinel
- nntp-server-process 'nntp-default-sentinel)
- ;; You can send commands at startup like AUTHINFO here.
- ;; Added by Hallvard B Furuseth <h.b.furuseth@usit.uio.no>
- (run-hooks 'nntp-server-opened-hook))))
+ (unless status
+ (nntp-close-server-internal server)
+ (nnheader-report
+ 'nntp "Couldn't open connection to %s" server))
+ (when nntp-server-process
+ (set-process-sentinel
+ nntp-server-process 'nntp-default-sentinel)
+ ;; You can send commands at startup like AUTHINFO here.
+ ;; Added by Hallvard B Furuseth <h.b.furuseth@usit.uio.no>
+ (run-hooks 'nntp-server-opened-hook)))
((null server)
- (setq nntp-status-string "NNTP server is not specified."))
+ (nnheader-report 'nntp "NNTP server is not specified."))
(t ; We couldn't open the server.
- (setq nntp-status-string
- (buffer-substring (point-min) (point-max)))))
+ (nnheader-report
+ 'nntp (buffer-substring (point-min) (point-max)))))
(and timer (cancel-timer timer))
(message "")
(or status
"Return the real group and article for virtual GROUP and ARTICLE."
(nnvirtual-possibly-change-group group nil t)
(let ((mart (assq article nnvirtual-mapping)))
- (cons (cadr mart) (caddr mart))))
+ (when mart
+ (cons (cadr mart) (caddr mart)))))
\f
;;; Internal functions.
+Thu Feb 8 17:34:33 1996 Lars Ingebrigtsen <lars@eyesore.no>
+
+ * gnus.texi (Topic Commands): Addition.
+
Mon Feb 5 05:24:01 1996 Lars Ingebrigtsen <lars@eyesore.no>
* gnus.texi (Article Washing): Addition.
distribution point for the new and spiffy versions of Gnus, also know as
The Site That Destroys Newsrcs And Drives People Mad.
-During the first extended alpha period of develpment, the new Gnus was
+During the first extended alpha period of development, the new Gnus was
called ``(ding) Gnus''. @dfn{(ding)}, is, of course, short for @dfn{ding
is not Gnus}, which is a total and utter lie, but who cares? (Besides,
the ``Gnus'' in this abbreviation should probably be pronounced ``news'' as
In any case, after spending all that energy with coming up with a new
and spiffy name, we decided that the name was @emph{too} spiffy, so we
-renamamed it back again to ``Gnus''. But in mixed case. ``Gnus'' vs.
+renamed it back again to ``Gnus''. But in mixed case. ``Gnus'' vs.
``@sc{gnus}''. New vs. old.
Incidentally, the next Gnus generation will be called ``September Gnus'',
@end table
-If you ever see Gnus act noncompliantly to the texts mentioned above,
+If you ever see Gnus act non-compliantly to the texts mentioned above,
don't hesitate to drop a note to Gnus Towers and let us know.
@item
Brian Edmonds has written @code{gnus-bbdb}.
@item
-Ricardo Nassif did the proof-reading.
+Ricardo Nassif and Mark Borges did the proff-reading (sic).
@item
Kevin Davidson came up with the name @dfn{ding}, so blame him.
@item
Peter Arius, Stainless Steel Rat, Ulrik Dickow, Jack Vinson, Daniel
-Quinlan, Frank D. Cringle, Geoffrey T. Dairiki and Andrew Eskilsson have
+Quinlan, Frank D. Cringle, Geoffrey T. Dairiki, and Andrew Eskilsson have
all contributed code and suggestions.
@end itemize
Gnus will see whether @code{gnus-nntpserver-file} (default
@file{/etc/nntpserver}) has any opinions in the matter. It that fails
as well, Gnus will will try to use the machine that is running Emacs as
-an @sc{nntp} server. That's a longshot, though.
+an @sc{nntp} server. That's a long-shot, though.
@vindex gnus-nntp-server
If @code{gnus-nntp-server} is set, this variable will override
information from all of them. (The slave files will be read in the
sequence they were created, so the latest changes will have precedence.)
-Information from the slave files has, of course, presedence over the
+Information from the slave files has, of course, precedence over the
information in the normal (i. e., master) @code{.newsrc} file.
group and I don't care whether Gnus has been started or not''. This is
perhaps more useful for people who write code than for users, but the
command @code{gnus-fetch-group} provides this functionality in any
-case. It takes the group name as a paramenter.
+case. It takes the group name as a parameter.
@node New Groups
@vindex gnus-auto-subscribed-groups
Yet another variable that meddles here is
@code{gnus-auto-subscribed-groups}. It works exactly like
-@code{gnus-options-subscribe}, and is therefore really superfluos, but I
+@code{gnus-options-subscribe}, and is therefore really superfluous, but I
thought it would be nice to have two of these. This variable is more
meant for setting some ground rules, while the other variable is used
more for user fiddling. By default this variable makes all new groups
@code{t} by default. If it is @code{nil}, inactive groups won't be
listed.
-@vindex gnus-group-use-permament-levels
-If @code{gnus-group-use-permament-levels} is non-@code{nil}, once you
+@vindex gnus-group-use-permanent-levels
+If @code{gnus-group-use-permanent-levels} is non-@code{nil}, once you
give a level prefix to @kbd{g} or @kbd{l}, all subsequent commands will
use this level as the ``work'' level.
@vindex gnus-group-recent-archive-directory
Make a Gnus archive group (@code{gnus-group-make-archive-group}). By
default a group pointing to the most recent articles will be created
-(@code{gnus-group-recent-archibe-directory}), but given a prefix, a full
+(@code{gnus-group-recent-archive-directory}), but given a prefix, a full
group will be created from from @code{gnus-group-archive-directory}.
@item G k
didn't think much about it---a backend to read directories. Big deal.
@code{ange-ftp} changes that picture dramatically. For instance, if you
-enter @file{"/ftp@@sina.tcamc.uh.edu:/pub/emacs/ding-list/"} as the the
+enter @file{"/ftp.hpc.uh.edu:/pub/emacs/ding-list/"} as the the
directory name, ange-ftp will actually allow you to read this directory
over at @samp{sina} as a newsgroup. Distributed news ahoy!
that. Say you have an old @file{RMAIL} file with mail that you now want
to split into your new @code{nnml} groups. You look at that file using
@code{nndoc}, set the process mark on all the articles in the buffer
-(@kbd{M P b}, for instance), and then respool (@kbd{B r}) using
+(@kbd{M P b}, for instance), and then re-spool (@kbd{B r}) using
@code{nnml}. If all goes well, all the mail in the @file{RMAIL} file is
now also stored in lots of @code{nnml} directories, and you can delete
that pesky @file{RMAIL} file. If you have the guts!
@vindex nndoc-article-type
This should be one of @code{mbox}, @code{babyl}, @code{digest},
@code{mmdf}, @code{forward}, @code{news}, @code{rnews},
-@code{mime-difest}, @code{clari-briefs}, or @code{guess}.
+@code{mime-digest}, @code{clari-briefs}, or @code{guess}.
@item nndoc-post-type
@vindex nndoc-post-type
Of course, us Unix Weenie types of human beans use things like
@code{uucp} and, like, @code{nntpd} and set up proper news and mail
-transport things like Ghod inteded. And then we just use normal
+transport things like Ghod intended. And then we just use normal
newsreaders.
However, it can sometimes be convenient to do something a that's a bit
@item gnus-soup-packet-directory
@vindex gnus-soup-packet-directory
-Wehre Gnus will look for reply packets. The default is @file{~/}.
+Where Gnus will look for reply packets. The default is @file{~/}.
@item gnus-soup-packet-regexp
@vindex gnus-soup-packet-regexp
@item nnsoup-replies-format-type
@vindex nnsoup-replies-format-type
The @sc{soup} format of the replies packets. The default is @samp{?n}
-(rnews), and I don't think you should touch that variable. I probaly
+(rnews), and I don't think you should touch that variable. I probably
shouldn't even have documented it. Drats! Too late!
@item nnsoup-replies-index-type
mail if you're not using a mail backend---you have to do a lot of magic
invocations first. At the time when you have finished drawing the
pentagram, lightened the candles, and sacrificed the goat, you really
-shouldn't be too suprised when Gnus moves your mail.
+shouldn't be too surprised when Gnus moves your mail.
@vindex nnmail-use-procmail
If @code{nnmail-use-procmail} is non-@code{nil}, the mail backends will
(setq nnmail-split-fancy
'(| ;; Messages duplicates go to a separate group.
("gnus-warning" "duplication of message" "duplicate")
- ;; Message from deamons, postmaster, and the like to another.
+ ;; Message from daemons, postmaster, and the like to another.
(any mail "mail.misc")
;; Other rules.
[ ... ] ))
@end table
@vindex gnus-permanently-visible-groups
-@cindex visible group paramenter
+@cindex visible group parameter
Groups that match the @code{gnus-permanently-visible-groups} regexp will
always be shown, whether they have unread articles or not. You can also
add the @code{visible} element to the group parameters in question to
@kindex C-c C-s (Group)
@findex gnus-group-sort-groups
@vindex gnus-group-sort-function
-The @kbd{C-c C-s} (@code{gnus-group-srot-groups}) command sorts the
+The @kbd{C-c C-s} (@code{gnus-group-sort-groups}) command sorts the
group buffer according to the function(s) given by the
@code{gnus-group-sort-function} variable. Available sorting functions
include:
@cindex unloading
If you wish to completely unload Gnus and all its adherents, you can use
the @code{gnus-unload} command. This command is also very handy when
-trying to custoize meta-variables.
+trying to customize meta-variables.
Note:
(@code{gnus-topic-copy-group}). This command understands the
process/prefix convention (@pxref{Process/Prefix}).
+@item T D
+@kindex T D (Group)
+@findex gnus-topic-remove-group
+Remove a group from the current topic (@code{gnus-topic-remove-group}).
+This command understands the process/prefix convention
+(@pxref{Process/Prefix}).
+
@item T M
@kindex T M (Group)
@findex gnus-topic-move-matching
@item C-y
@kindex C-y (Group)
@findex gnus-topic-yank-group
-Yank the previosuly killed group or topic (@code{gnus-topic-yank-group}).
+Yank the previously killed group or topic (@code{gnus-topic-yank-group}).
Note that all topics will be yanked before all groups.
@item T r
@item A T
@kindex A T (Group)
@findex gnus-topic-list-active
-List all groups that Gnus knows about in a topicsified way
+List all groups that Gnus knows about in a topics-ified way
(@code{gnus-topic-list-active}).
@end table
centered at all times. This makes things quite tidy, but if you have a
slow network connection, or simply do not like this un-Emacsism, you can
set this variable to @code{nil} to get the normal Emacs scrolling
-action. This will also inhibit horizontal recentering of the summary
+action. This will also inhibit horizontal re-centering of the summary
buffer, which might make it more inconvenient to read extremely long
threads.
headers of the message won't be altered---but lots of headers that say
@samp{Resent-To}, @samp{Resent-From} and so on will be added. This
means that you actually send a mail to someone that has a @samp{To}
-header that (proabbly) points to yourself. This will confuse people.
+header that (probably) points to yourself. This will confuse people.
So, natcherly you'll only do that if you're really eVIl.
This command is mainly used if you have several accounts and want to
@item gnus-forward-included-headers
@vindex gnus-forward-included-headers
Regexp matching header lines to be included in forwarded messages. It
-usese the same regexp as @code{gnus-visible-headers} by default.
+uses the same regexp as @code{gnus-visible-headers} by default.
@end table
@vindex gnus-mail-reply-method
@item gnus-mail-reply-method
-This function is used to compose replies. The three functions avaibale
+This function is used to compose replies. The three functions available
are:
@findex gnus-mail-reply-using-vm
@vindex gnus-mail-forward-method
@item gnus-mail-forward-method
-This function is used to forward messages. The three functions avaibale
+This function is used to forward messages. The three functions available
are:
@findex gnus-mail-forward-using-vm
@vindex gnus-mail-other-window-method
@item gnus-mail-other-window-method
-This function is used to send mails. The three functions avaibale are:
+This function is used to send mails. The three functions available are:
@findex gnus-mail-other-window-using-vm
@findex gnus-mail-other-window-using-mhe
@item gnus-local-domain
@vindex gnus-local-domain
@cindex domain
-The local doman name excluding the host name. If your host is called
+The local domain name excluding the host name. If your host is called
@samp{"narfi.ifi.uio.no"}, then this variable should be
@samp{"ifi.uio.no"}.
@item gnus-local-domain
@vindex gnus-local-domain
@cindex domain
-The local doman name excluding the host name. If your host is called
+The local domain name excluding the host name. If your host is called
@samp{"narfi.ifi.uio.no"}, then this variable should be
@samp{"ifi.uio.no"}.
@findex gnus-mailing-list-groups
@cindex mailing lists
-If your newsserver offer groups that are really mailing lists that are
+If your news server offers groups that are really mailing lists that are
gatewayed to the @sc{nntp} server, you can read those groups without
problems, but you can't post/followup to them without some difficulty.
One solution is to add a @code{to-address} to the group parameters
use to store sent messages. It is @code{(nnfolder "archive"
(nnfolder-directory "~/Mail/archive/"))} by default, but you can use any
mail select method (@code{nnml}, @code{nnmbox}, etc.). However,
-@code{nnfolder} is a quite likable select method for doing this sort of
+@code{nnfolder} is a quite likeable select method for doing this sort of
thing. If you don't like the default directory chosen, you could say
something like:
@item
Articles that are ``saved'' (in some manner or other; not necessarily
-religously) are marked with an @samp{S} in the second column
+religiously) are marked with an @samp{S} in the second column
(@code{gnus-saved-mark}.
@item
in the second column by default. So if you have a cached, saved,
replied article that you have process-marked, what will that look like?
-Nothing much. The presedence rules go as follows: process -> cache ->
+Nothing much. The precedence rules go as follows: process -> cache ->
replied -> saved. So if the article is in the cache and is replied,
you'll only see the cache mark and not the replied mark.
@item M P v
@kindex M P v (Summary)
@findex gnus-uu-mark-over
-Mark all articles that have a score above the prefix argumnet
+Mark all articles that have a score above the prefix argument
(@code{gnus-uu-mark-over}).
@item M P s
@findex gnus-summary-limit-mark-excluded-as-read
Mark all excluded unread articles as read
(@code{gnus-summary-limit-mark-excluded-as-read}). If given a prefix,
-also mark exluded ticked and dormant articles as read.
+also mark excluded ticked and dormant articles as read.
@end table
unwanted headers before saving the article.
@vindex gnus-saved-headers
-If the preceeding variable is @code{nil}, all headers that match the
+If the preceding variable is @code{nil}, all headers that match the
@code{gnus-saved-headers} regexp will be kept, while the rest will be
deleted before saving.
and every article in. The prompting action is controlled by
the @code{gnus-prompt-before-saving} variable, which is @code{always} by
default, giving you that excessive prompting action you know and
-loathe. If you set this variable to @code{t} instead, you'll be promted
+loathe. If you set this variable to @code{t} instead, you'll be prompted
just once for each series of articles you save. If you like to really
have Gnus do all your thinking for you, you can even set this variable
to @code{nil}, which means that you will never be prompted for files to
to unpack the archive and see if any of the files in the archive can be
viewed. For instance, if you have a gzipped tar file @file{pics.tar.gz}
containing the files @file{pic1.jpg} and @file{pic2.gif}, Gnus will
-uncompress and detar the main file, and then view the two pictures.
+uncompress and de-tar the main file, and then view the two pictures.
This unpacking process is recursive, so if the archive contains archives
of archives, it'll all be unpacked.
* Article Highlighting:: You want to make the article look like fruit salad.
* Article Hiding:: You also want to make certain info go away.
* Article Washing:: Lots of way-neat functions to make life better.
-* Article Buttons:: Clcik on URLs, Message-IDs, addresses and the like.
+* Article Buttons:: Click on URLs, Message-IDs, addresses and the like.
* Article Date:: Grumble, UT!
@end menu
@item gnus-cite-prefix-regexp
@vindex gnus-cite-prefix-regexp
-Regexp mathcing the longest possible citation prefix on a line.
+Regexp matching the longest possible citation prefix on a line.
@item gnus-cite-max-prefix
@vindex gnus-cite-max-prefix
@vindex gnus-cite-attribution-prefix
Regexp matching the beginning of an attribution line.
-@item gnus-cite-addtribution-suffix
-@vindex gnus-cite-addtribution-suffix
+@item gnus-cite-attribution-suffix
+@vindex gnus-cite-attribution-suffix
Regexp matching the end of an attribution line.
@item gnus-cite-attribution-face
@cindex article hiding
Or rather, hiding certain things in each article. There usually is much
-too much gruft in most articles.
+too much cruft in most articles.
@table @kbd
@kindex M-x gnus-pick-mode
Gnus provides a summary buffer minor mode that allows
this---@code{gnus-pick-mode}. This basically means that a few process
-mark commands becode one-keystroke commands to allow easy marking, and
+mark commands become one-keystroke commands to allow easy marking, and
it makes one additional command for switching to the summary buffer
available.
@findex gnus-summary-expire-articles-now
Expunge all the expirable articles in the group
(@code{gnus-summary-expire-articles-now}). This means that @strong{all}
-articles that are eligeble for expiry in the current group will
+articles that are eligible for expiry in the current group will
disappear forever into that big @file{/dev/null} in the sky.
@item B DEL
@item B q
@kindex B q (Summary)
@findex gnus-summary-respool-query
-If you want to respool an article, you might be curious as to what group
-the article will end up in before you do the respooling. This command
+If you want to re-spool an article, you might be curious as to what group
+the article will end up in before you do the re-spooling. This command
will tell you (@code{gnus-summary-fancy-query}).
@end table
some author. Uses the same match types as the @code{From} header uses.
@item Thread
-This match key will add a ascore entry on all articles that are part of
+This match key will add a score entry on all articles that are part of
a thread. Uses the same match types as the @code{References} header
uses.
@end table
@end lisp
You may also consider doing something similar with @code{expunge}.
-@item Negated charater classes
+@item Negated character classes
If you say stuff like @code{[^abcd]*}, you may get unexpected results.
That will match newlines, which might lead to, well, The Unknown. Say
@code{[^abcd\n]*} instead.
you may have noticed, 100% + 25% is actually 125% (yup, I saw y'all
reaching for that calculator there). However, the special number
@code{1.0} is used to signal that this buffer should soak up all the
-rest of the space avaiable after the rest of the buffers have taken
+rest of the space available after the rest of the buffers have taken
whatever they need. There should be only one buffer with the @code{1.0}
size spec per split.
@xref{(elisp)Frame Parameters}.
Here's a list of all possible keys for
-@code{gnus-buffer-configuaration}:
+@code{gnus-buffer-configuration}:
@code{group}, @code{summary}, @code{article}, @code{server},
@code{browse}, @code{group-mail}, @code{summary-mail},
To set the whole thing in motion, though, you have to set
@code{gnus-use-demon} to @code{t}.
-@vindex gnus-use-demon
-To set the whole thing in motion, though, you have to set
-@code{gnus-use-demon} to @code{t}.
-
So, if you want to add a handler, you could put something like this in
your @file{.gnus} file:
@end table
So if you only want highlighting in the article buffer and menus in all
-buffers, you couls say something like:
+buffers, you could say something like:
@lisp
(setq gnus-visual '(article-highlight menu))
@table @code
@item gnus-auto-center-summary
-Set this to @code{nil} to inhibit Gnus from recentering the summary
+Set this to @code{nil} to inhibit Gnus from re-centering the summary
buffer all the time.
@item gnus-visible-headers
It is also important to remember that I have no memory whatsoever. If
you send a bug report, and I send you a reply, and then you send back
just ``No, it's not! Moron!'', I will have no idea what you are insulting
-me about. Always overexplain everything. It's much easier for all of
+me about. Always over-explain everything. It's much easier for all of
us---if I don't have all the information I need, I will just mail you
and ask for more info, and everything takes more time.
@menu
* A Programmer@'s Guide to Gnus:: Rilly, rilly technical stuff.
-* Emacs for Heathens:: A short intruduction to Emacsian terms.
+* Emacs for Heathens:: A short introduction to Emacsian terms.
* Frequently Asked Questions:: A question-and-answer session.
@end menu
considering the highest and lowest article numbers, but some articles
may have been cancelled. Gnus just discards the total-number, so
whether one should take the bother to generate it properly (if that is a
-problem) is left as an excercise to the reader.
+problem) is left as an exercise to the reader.
@example
group-status = [ error / info ] eol
would generally expect that if one later fetches article number 4, for
instance, some sort of asynchronous fetching of the articles after 4
(which might be 5, 6, 7 or 11, 3, 909 depending on the order in that
-alist) would be fetched asynchronouly, but that is left up to the
+alist) would be fetched asynchronously, but that is left up to the
backend. Gnus doesn't care.
There should be no result data from this function.
almost suspect that the author looked at the @sc{nov} specification and
just shamelessly @emph{stole} the entire thing, and one would be right.
-@dfn{Header} is a severly overloaded term. ``Header'' is used in RFC1036
+@dfn{Header} is a severely overloaded term. ``Header'' is used in RFC1036
to talk about lines in the head of an article (eg., @code{From}). It is
used by many people as a synonym for ``head''---``the header and the
body''. (That should be avoided, in my opinion.) And Gnus uses a format
-interanally that it calls ``header'', which is what I'm talking about
+internally that it calls ``header'', which is what I'm talking about
here. This is a 9-element vector, basically, with each header (ouch)
having one slot.
These slots are, in order: @code{number}, @code{subject}, @code{from},
@code{date}, @code{id}, @code{references}, @code{chars}, @code{lines},
@code{xref}. There are macros for accessing and setting these slots --
-they all have predicatable names beginning with @code{mail-header-} and
+they all have predictable names beginning with @code{mail-header-} and
@code{mail-header-set-}, respectively.
The @code{xref} slot is really a @code{misc} slot. Any extra info will
(1 2 3 4 5)
@end example
-is a perfectly valid range, although a pretty longwinded one. This is
+is a perfectly valid range, although a pretty long-winded one. This is
also legal:
@example
question. It also lists the highest and lowest current article numbers
in each group.
-Here's an exceprt from a typical active file:
+Here's an excerpt from a typical active file:
@example
soc.motss 296030 293865 y
normally used to get capital letters and stuff. You probably use it all
the time. The control key is normally marked ``CTRL'' or something like
that. The meta key is, funnily enough, never marked as such on any
-keyboards. The one I'm curretly at has a key that's marked ``Alt'', which
+keyboards. The one I'm currently at has a key that's marked ``Alt'', which
is the meta key on this keyboard. It's usually located somewhere to the
left hand side of the keyboard, usually on the bottom row.
how Gnus works.
If you have put that thing in your @code{.emacs} file, it will be read
-and @code{eval}ed (which is lispese for ``run'') the next time you start
+and @code{eval}ed (which is lisp-ese for ``run'') the next time you start
Emacs. If you want to change the variable right away, simply say
@kbd{C-x C-e} after the closing parenthesis. That will @code{eval} the
previous ``form'', which here is a simple @code{setq} statement.
projects / gnus / commitdiff