This is ../info/gnus, produced by makeinfo version 4.8 from gnus.texi. This file documents Gnus, the GNU Emacs newsreader. Copyright (C) 1995,96 Free Software Foundation, Inc. Permission is granted to make and distribute verbatim copies of this manual provided the copyright notice and this permission notice are preserved on all copies. Permission is granted to copy and distribute modified versions of this manual under the conditions for verbatim copying, provided also that the entire resulting derived work is distributed under the terms of a permission notice identical to this one. Permission is granted to copy and distribute translations of this manual into another language, under the above conditions for modified versions.  File: gnus, Node: Windows Configuration, Next: Compilation, Prev: Formatting Variables, Up: Various 8.4 Windows Configuration ========================= No, there's nothing here about X, so be quiet. If `gnus-use-full-window' non-`nil', Gnus will delete all other windows and occupy the entire Emacs screen by itself. It is `t' by default. `gnus-buffer-configuration' describes how much space each Gnus buffer should be given. Here's an excerpt of this variable: ((group (vertical 1.0 (group 1.0 point) (if gnus-carpal (group-carpal 4)))) (article (vertical 1.0 (summary 0.25 point) (article 1.0)))) This is an alist. The "key" is a symbol that names some action or other. For instance, when displaying the group buffer, the window configuration function will use `group' as the key. A full list of possible names is listed below. The "value" (i. e., the "split") says how much space each buffer should occupy. To take the `article' split as an example - (article (vertical 1.0 (summary 0.25 point) (article 1.0))) This "split" says that the summary buffer should occupy 25% of upper half of the screen, and that it is placed over the article buffer. As you may have noticed, 100% + 25% is actually 125% (yup, I saw y'all reaching for that calculator there). However, the special number `1.0' is used to signal that this buffer should soak up all the rest of the space available after the rest of the buffers have taken whatever they need. There should be only one buffer with the `1.0' size spec per split. Point will be put in the buffer that has the optional third element `point'. Here's a more complicated example: (article (vertical 1.0 (group 4) (summary 0.25 point) (if gnus-carpal (summary-carpal 4)) (article 1.0))) If the size spec is an integer instead of a floating point number, then that number will be used to say how many lines a buffer should occupy, not a percentage. If the "split" looks like something that can be `eval'ed (to be precise--if the `car' of the split is a function or a subr), this split will be `eval'ed. If the result is non-`nil', it will be used as a split. This means that there will be three buffers if `gnus-carpal' is `nil', and four buffers if `gnus-carpal' is non-`nil'. Not complicated enough for you? Well, try this on for size: (article (horizontal 1.0 (vertical 0.5 (group 1.0) (gnus-carpal 4)) (vertical 1.0 (summary 0.25 point) (summary-carpal 4) (article 1.0)))) Whoops. Two buffers with the mystery 100% tag. And what's that `horizontal' thingie? If the first element in one of the split is `horizontal', Gnus will split the window horizontally, giving you two windows side-by-side. Inside each of these strips you may carry on all you like in the normal fashion. The number following `horizontal' says what percentage of the screen is to be given to this strip. For each split, there _must_ be one element that has the 100% tag. The splitting is never accurate, and this buffer will eat any leftover lines from the splits. To be slightly more formal, here's a definition of what a legal split may look like: split = frame | horizontal | vertical | buffer | form frame = "(frame " size *split ")" horizontal = "(horizontal " size *split ")" vertical = "(vertical " size *split ")" buffer = "(" buffer-name " " size *[ "point" ] ")" size = number | frame-params buffer-name = group | article | summary ... The limitations are that the `frame' split can only appear as the top-level split. FORM should be an Emacs Lisp form that should return a valid split. We see that each split is fully recursive, and may contain any number of `vertical' and `horizontal' splits. Finding the right sizes can be a bit complicated. No window may be less than `gnus-window-min-height' (default 2) characters high, and all windows must be at least `gnus-window-min-width' (default 1) characters wide. Gnus will try to enforce this before applying the splits. If you want to use the normal Emacs window width/height limit, you can just set these two variables to `nil'. If you're not familiar with Emacs terminology, `horizontal' and `vertical' splits may work the opposite way of what you'd expect. Windows inside a `horizontal' split are shown side-by-side, and windows within a `vertical' split are shown above each other. If you want to experiment with window placement, a good tip is to call `gnus-configure-frame' directly with a split. This is the function that does all the real work when splitting buffers. Below is a pretty nonsensical configuration with 5 windows; two for the group buffer and three for the article buffer. (I said it was nonsensical.) If you `eval' the statement below, you can get an idea of how that would look straight away, without going through the normal Gnus channels. Play with it until you're satisfied, and then use `gnus-add-configuration' to add your new creation to the buffer configuration list. (gnus-configure-frame '(horizontal 1.0 (vertical 10 (group 1.0) (article 0.3 point)) (vertical 1.0 (article 1.0) (horizontal 4 (group 1.0) (article 10))))) You might want to have several frames as well. No prob--just use the `frame' split: (gnus-configure-frame '(frame 1.0 (vertical 1.0 (summary 0.25 point) (article 1.0)) (vertical ((height . 5) (width . 15) (user-position . t) (left . -1) (top . 1)) (picon 1.0)))) This split will result in the familiar summary/article window configuration in the first (or "main") frame, while a small additional frame will be created where picons will be shown. As you can see, instead of the normal `1.0' top-level spec, each additional split should have a frame parameter alist as the size spec. *Note Frame Parameters: (elisp)Frame Parameters. Here's a list of all possible keys for `gnus-buffer-configuration': `group', `summary', `article', `server', `browse', `group-mail', `summary-mail', `summary-reply', `info', `summary-faq', `edit-group', `edit-server', `reply', `reply-yank', `followup', `followup-yank', `edit-score'. Since the `gnus-buffer-configuration' variable is so long and complicated, there's a function you can use to ease changing the config of a single setting: `gnus-add-configuration'. If, for instance, you want to change the `article' setting, you could say: (gnus-add-configuration '(article (vertical 1.0 (group 4) (summary .25 point) (article 1.0)))) You'd typically stick these `gnus-add-configuration' calls in your `.gnus' file or in some startup hook - they should be run after Gnus has been loaded.  File: gnus, Node: Compilation, Next: Mode Lines, Prev: Windows Configuration, Up: Various 8.5 Compilation =============== Remember all those line format specification variables? `gnus-summary-line-format', `gnus-group-line-format', and so on. Now, Gnus will of course heed whatever these variables are, but, unfortunately, changing them will mean a quite significant slow-down. (The default values of these variables have byte-compiled functions associated with them, while the user-generated versions do not, of course.) To help with this, you can run `M-x gnus-compile' after you've fiddled around with the variables and feel that you're (kind of) satisfied. This will result in the new specs being byte-compiled, and you'll get top speed again.  File: gnus, Node: Mode Lines, Next: Highlighting and Menus, Prev: Compilation, Up: Various 8.6 Mode Lines ============== `gnus-updated-mode-lines' says what buffers should keep their mode lines updated. It is a list of symbols. Supported symbols include `group', `article', `summary', `server', `browse', and `tree'. If the corresponding symbol is present, Gnus will keep that mode line updated with information that may be pertinent. If this variable is `nil', screen refresh may be quicker. By default, Gnus displays information on the current article in the mode lines of the summary and article buffers. The information Gnus wishes to display (eg. the subject of the article) is often longer than the mode lines, and therefore have to be cut off at some point. The `gnus-mode-non-string-length' variable says how long the other elements on the line is (i.e., the non-info part). If you put additional elements on the mode line (eg. a clock), you should modify this variable: (add-hook 'display-time-hook (lambda () (setq gnus-mode-non-string-length (+ 21 (if line-number-mode 5 0) (if column-number-mode 4 0) (length display-time-string))))) If this variable is `nil' (which is the default), the mode line strings won't be chopped off, and they won't be padded either.  File: gnus, Node: Highlighting and Menus, Next: Buttons, Prev: Mode Lines, Up: Various 8.7 Highlighting and Menus ========================== The `gnus-visual' variable controls most of the prettifying Gnus aspects. If `nil', Gnus won't attempt to create menus or use fancy colors or fonts. This will also inhibit loading the `gnus-vis.el' file. This variable can be a list of visual properties that are enabled. The following elements are legal, and are all included by default: `group-highlight' Do highlights in the group buffer. `summary-highlight' Do highlights in the summary buffer. `article-highlight' Do highlights in the article buffer. `highlight' Turn on highlighting in all buffers. `group-menu' Create menus in the group buffer. `summary-menu' Create menus in the summary buffers. `article-menu' Create menus in the article buffer. `browse-menu' Create menus in the browse buffer. `server-menu' Create menus in the server buffer. `score-menu' Create menus in the score buffers. `menu' Create menus in all buffers. So if you only want highlighting in the article buffer and menus in all buffers, you could say something like: (setq gnus-visual '(article-highlight menu)) If you want only highlighting and no menus whatsoever, you'd say: (setq gnus-visual '(highlight)) If `gnus-visual' is `t', highlighting and menus will be used in all Gnus buffers. Other general variables that influence the look of all buffers include: `gnus-mouse-face' This is the face (i.e., font) used for mouse highlighting in Gnus. No mouse highlights will be done if `gnus-visual' is `nil'. `gnus-display-type' This variable is symbol indicating the display type Emacs is running under. The symbol should be one of `color', `grayscale' or `mono'. If Gnus guesses this display attribute wrongly, either set this variable in your `~/.emacs' or set the resource `Emacs.displayType' in your `~/.Xdefaults'. `gnus-background-mode' This is a symbol indicating the Emacs background brightness. The symbol should be one of `light' or `dark'. If Gnus guesses this frame attribute wrongly, either set this variable in your `~/.emacs' or set the resource `Emacs.backgroundMode' in your `~/.Xdefaults'. `gnus-display-type'. There are hooks associated with the creation of all the different menus: `gnus-article-menu-hook' Hook called after creating the article mode menu. `gnus-group-menu-hook' Hook called after creating the group mode menu. `gnus-summary-menu-hook' Hook called after creating the summary mode menu. `gnus-server-menu-hook' Hook called after creating the server mode menu. `gnus-browse-menu-hook' Hook called after creating the browse mode menu. `gnus-score-menu-hook' Hook called after creating the score mode menu.  File: gnus, Node: Buttons, Next: Daemons, Prev: Highlighting and Menus, Up: Various 8.8 Buttons =========== Those new-fangled "mouse" contraptions is very popular with the young, hep kids who don't want to learn the proper way to do things these days. Why, I remember way back in the summer of '89, when I was using Emacs on a Tops 20 system. Three hundred users on one single machine, and every user was running Simula compilers. Bah! Right. Well, you can make Gnus display bufferfuls of buttons you can click to do anything by setting `gnus-carpal' to `t'. Pretty simple, really. Tell the chiropractor I sent you. `gnus-carpal-mode-hook' Hook run in all carpal mode buffers. `gnus-carpal-button-face' Face used on buttons. `gnus-carpal-header-face' Face used on carpal buffer headers. `gnus-carpal-group-buffer-buttons' Buttons in the group buffer. `gnus-carpal-summary-buffer-buttons' Buttons in the summary buffer. `gnus-carpal-server-buffer-buttons' Buttons in the server buffer. `gnus-carpal-browse-buffer-buttons' Buttons in the browse buffer. All the `buttons' variables are lists. The elements in these list is either a cons cell where the car contains a text to be displayed and the cdr contains a function symbol, or a simple string.  File: gnus, Node: Daemons, Next: NoCeM, Prev: Buttons, Up: Various 8.9 Daemons =========== Gnus, being larger than any program ever written (allegedly), does lots of strange stuff that you may wish to have done while you're not present. For instance, you may want it to check for new mail once in a while. Or you may want it to close down all connections to all servers when you leave Emacs idle. And stuff like that. Gnus will let you do stuff like that by defining various "handlers". Each handler consists of three elements: A FUNCTION, a TIME, and an IDLE parameter. Here's an example of a handler that closes connections when Emacs has been idle for thirty minutes: (gnus-demon-close-connections nil 30) Here's a handler that scans for PGP headers every hour when Emacs is idle: (gnus-demon-scan-pgp 60 t) This TIME parameter and than IDLE parameter works together in a strange, but wonderful fashion. Basically, if IDLE is `nil', then the function will be called every TIME minutes. If IDLE is `t', then the function will be called after TIME minutes only if Emacs is idle. So if Emacs is never idle, the function will never be called. But once Emacs goes idle, the function will be called every TIME minutes. If IDLE is a number and TIME is a number, the function will be called every TIME minutes only when Emacs has been idle for IDLE minutes. If IDLE is a number and TIME is `nil', the function will be called once every time Emacs has been idle for IDLE minutes. And if TIME is a string, it should look like `07:31', and the function will then be called once every day somewhere near that time. Modified by the IDLE parameter, of course. (When I say "minute" here, I really mean `gnus-demon-timestep' seconds. This is `60' by default. If you change that variable, all the timings in the handlers will be affected.) To set the whole thing in motion, though, you have to set `gnus-use-demon' to `t'. So, if you want to add a handler, you could put something like this in your `.gnus' file: (gnus-demon-add-handler 'gnus-demon-close-connections nil 30) Some ready-made functions to do this has been created: `gnus-demon-add-nocem', `gnus-demon-add-disconnection', and `gnus-demon-add-scanmail'. Just put those functions in your `.gnus' if you want those abilities. If you add handlers to `gnus-demon-handlers' directly, you should run `gnus-demon-init' to make the changes take hold. To cancel all daemons, you can use the `gnus-demon-cancel' function. Note that adding daemons can be pretty naughty if you overdo it. Adding functions that scan all news and mail from all servers every two seconds is a sure-fire way of getting booted off any respectable system. So behave.  File: gnus, Node: NoCeM, Next: Picons, Prev: Daemons, Up: Various 8.10 NoCeM ========== "Spamming" is posting the same article lots and lots of times. Spamming is bad. Spamming is evil. Spamming is usually canceled within a day or so by various anti-spamming agencies. These agencies usually also send out "NoCeM" messages. NoCeM is pronounced "no see-'em", and means what the name implies--these are messages that make the offending articles, like, go away. What use are these NoCeM messages if the articles are canceled anyway? Some sites do not honor cancel messages and some sites just honor cancels from a select few people. Then you may wish to make use of the NoCeM messages, which are distributed in the `alt.nocem.misc' newsgroup. Gnus can read and parse the messages in this group automatically, and this will make spam disappear. There are some variables to customize, of course: `gnus-use-nocem' Set this variable to `t' to set the ball rolling. It is `nil' by default. `gnus-nocem-groups' Gnus will look for NoCeM messages in the groups in this list. The default is `("alt.nocem.misc" "news.admin.net-abuse.announce")'. `gnus-nocem-issuers' There are many people issuing NoCeM messages. This list says what people you want to listen to. The default is `("Automoose-1" "clewis@ferret.ocunix.on.ca;" "jem@xpat.com;" "red@redpoll.mrfs.oh.us (Richard E. Depew)")'; fine, upstanding citizens all of them. Known despammers that you can put in this list include: `clewis@ferret.ocunix.on.ca;' Chris Lewis--Major Canadian despammer who has probably canceled more usenet abuse than anybody else. `Automoose-1' The CancelMoose[tm] on autopilot. The CancelMoose[tm] is reputed to be Norwegian, and was the person(s) who invented NoCeM. `jem@xpat.com;' Jem--Korean despammer who is getting very busy these days. `red@redpoll.mrfs.oh.us (Richard E. Depew)' Richard E. Depew--lone American despammer. He mostly cancels binary postings to non-binary groups and removes spews (regurgitated articles). You do not have to heed NoCeM messages from all these people--just the ones you want to listen to. `gnus-nocem-directory' This is where Gnus will store its NoCeM cache files. The default is `~/News/NoCeM/'. `gnus-nocem-expiry-wait' The number of days before removing old NoCeM entries from the cache. The default is 15. If you make it shorter Gnus will be faster, but you might then see old spam.  File: gnus, Node: Picons, Next: Various Various, Prev: NoCeM, Up: Various 8.11 Picons =========== So... You want to slow down your news reader even more! This is a good way to do so. Its also a great way to impress people staring over your shoulder as you read news. * Menu: * Picon Basics:: What are picons and How do I get them. * Picon Requirements:: Don't go further if you aren't using XEmacs. * Easy Picons:: Displaying Picons -- the easy way. * Hard Picons:: The way you should do it. You'll learn something. * Picon Configuration:: Other variables you can trash/tweak/munge/play with.  File: gnus, Node: Picon Basics, Next: Picon Requirements, Up: Picons 8.11.1 Picon Basics ------------------- What are Picons? To quote directly from the Picons Web site (`http://www.cs.indiana.edu/picons/ftp/index.html'): "Picons" is short for "personal icons". They're small, constrained images used to represent users and domains on the net, organized into databases so that the appropriate image for a given e-mail address can be found. Besides users and domains, there are picon databases for Usenet newsgroups and weather forecasts. The picons are in either monochrome `XBM' format or color `XPM' and `GIF' formats. Please see the above mentioned web site for instructions on obtaining and installing the picons databases, or the following ftp site: `http://www.cs.indiana.edu/picons/ftp/index.html'. Gnus expects picons to be installed into a location pointed to by `gnus-picons-database'.  File: gnus, Node: Picon Requirements, Next: Easy Picons, Prev: Picon Basics, Up: Picons 8.11.2 Picon Requirements ------------------------- To use have Gnus display Picons for you, you must be running XEmacs 19.13 or greater since all other versions of Emacs aren't yet able to display images. Additionally, you must have `xpm' support compiled into XEmacs. If you want to display faces from `X-Face' headers, you must have the `netpbm' utilities installed, or munge the `gnus-picons-convert-x-face' variable to use something else.  File: gnus, Node: Easy Picons, Next: Hard Picons, Prev: Picon Requirements, Up: Picons 8.11.3 Easy Picons ------------------ To enable displaying picons, simply put the following line in your `~/.gnus' file and start Gnus. (setq gnus-use-picons t) (add-hook 'gnus-article-display-hook 'gnus-article-display-picons t) (add-hook 'gnus-summary-prepare-hook 'gnus-group-display-picons t) (add-hook 'gnus-article-display-hook 'gnus-picons-article-display-x-face)  File: gnus, Node: Hard Picons, Next: Picon Configuration, Prev: Easy Picons, Up: Picons 8.11.4 Hard Picons ------------------ Gnus can display picons for you as you enter and leave groups and articles. It knows how to interact with three sections of the picons database. Namely, it can display the picons newsgroup pictures, author's face picture(s), and the authors domain. To enable this feature, you need to first decide where to display them. `gnus-picons-display-where' Where the picon images should be displayed. It is `picons' by default (which by default maps to the buffer `*Picons*'). Other valid places could be `article', `summary', or `"*scratch*"' for all I care. Just make sure that you've made the buffer visible using the standard Gnus window configuration routines - *Note Windows Configuration::. Note: If you set `gnus-use-picons' to `t', it will set up your window configuration for you to include the `picons' buffer. Now that you've made that decision, you need to add the following functions to the appropriate hooks so these pictures will get displayed at the right time. `gnus-article-display-picons' Looks up and display the picons for the author and the author's domain in the `gnus-picons-display-where' buffer. Should be added to the `gnus-article-display-hook'. `gnus-group-display-picons' Displays picons representing the current group. This function should be added to the `gnus-summary-prepare-hook' or to the `gnus-article-display-hook' if `gnus-picons-display-where' is set to `article'. `gnus-picons-article-display-x-face' Decodes and displays the X-Face header if present. This function should be added to `gnus-article-display-hook'. Note: You must append them to the hook, so make sure to specify 't' to the append flag of `add-hook': (add-hook 'gnus-article-display-hook 'gnus-article-display-picons t)  File: gnus, Node: Picon Configuration, Prev: Hard Picons, Up: Picons 8.11.5 Picon Configuration -------------------------- The following variables offer further control over how things are done, where things are located, and other useless stuff you really don't need to worry about. `gnus-picons-database' The location of the picons database. Should point to a directory containing the `news', `domains', `users' (and so on) subdirectories. Defaults to `/usr/local/faces'. `gnus-picons-news-directory' Sub-directory of the faces database containing the icons for newsgroups. `gnus-picons-user-directories' List of subdirectories to search in `gnus-picons-database' for user faces. Defaults to `("local" "users" "usenix" "misc/MISC")'. `gnus-picons-domain-directories' List of subdirectories to search in `gnus-picons-database' for domain name faces. Defaults to `("domains")'. Some people may want to add `unknown' to this list. `gnus-picons-convert-x-face' The command to use to convert the `X-Face' header to an X bitmap (`xbm'). Defaults to `(format "{ echo '/* Width=48, Height=48 */'; uncompface; } | icontopbm | pbmtoxbm > %s" gnus-picons-x-face-file-name)' `gnus-picons-x-face-file-name' Names a temporary file to store the `X-Face' bitmap in. Defaults to `(format "/tmp/picon-xface.%s.xbm" (user-login-name))'. `gnus-picons-buffer' The name of the buffer that `picons' points to. Defaults to `*Icon Buffer*'.  File: gnus, Node: Various Various, Prev: Picons, Up: Various 8.12 Various Various ==================== `gnus-verbose' This variable is an integer between zero and ten. The higher the value, the more messages will be displayed. If this variable is zero, Gnus will never flash any messages, if it is seven (which is the default), most important messages will be shown, and if it is ten, Gnus won't ever shut up, but will flash so many messages it will make your head swim. `gnus-verbose-backends' This variable works the same way as `gnus-verbose', but it applies to the Gnus backends instead of Gnus proper. `nnheader-max-head-length' When the backends read straight heads of articles, they all try to read as little as possible. This variable (default `4096') specifies the absolute max length the backends will try to read before giving up on finding a separator line between the head and the body. If this variable is `nil', there is no upper read bound. If it is `t', the backends won't try to read the articles piece by piece, but read the entire articles. This makes sense with some versions of `ange-ftp'. `nnheader-file-name-translation-alist' This is an alist that says how to translate characters in file names. For instance, if `:' is illegal as a file character in file names on your system (you OS/2 user you), you could say something like: (setq nnheader-file-name-translation-alist '((?: . ?_))) In fact, this is the default value for this variable on OS/2 and MS Windows (phooey) systems. `gnus-hidden-properties' This is a list of properties to use to hide "invisible" text. It is `(invisible t intangible t)' by default on most systems, which makes invisible text invisible and intangible. `gnus-parse-headers-hook' A hook called before parsing headers. It can be used, for instance, to gather statistics on the headers fetched, or perhaps you'd like to prune some headers. I don't see why you'd want that, though.  File: gnus, Node: The End, Next: Appendices, Prev: Various, Up: Top 9 The End ********* Well, that's the manual--you can get on with your life now. Keep in touch. Say hello to your cats from me. My *ghod*--I just can't stand goodbyes. Sniffle. Ol' Charles Reznikoff said it pretty well, so I leave the floor to him: *Te Deum* Not because of victories I sing, having none, but for the common sunshine, the breeze, the largess of the spring. Not for victory but for the day's work done as well as I was able; not for a seat upon the dais but at the common table.  File: gnus, Node: Appendices, Next: Index, Prev: The End, Up: Top 10 Appendices ************* * Menu: * History:: How Gnus got where it is today. * Terminology:: We use really difficult, like, words here. * Customization:: Tailoring Gnus to your needs. * Troubleshooting:: What you might try if things do not work. * A Programmers Guide to Gnus:: Rilly, rilly technical stuff. * Emacs for Heathens:: A short introduction to Emacsian terms. * Frequently Asked Questions:: A question-and-answer session.  File: gnus, Node: History, Next: Terminology, Up: Appendices 10.1 History ============ GNUS was written by Masanobu UMEDA. When autumn crept up in '94, Lars Magne Ingebrigtsen grew bored and decided to rewrite Gnus. If you want to investigate the person responsible for this outrage, you can point your (feh!) web browser to `http://www.ifi.uio.no/~larsi/'. This is also the primary distribution point for the new and spiffy versions of Gnus, and is known as The Site That Destroys Newsrcs And Drives People Mad. During the first extended alpha period of development, the new Gnus was called "(ding) Gnus". "(ding)", is, of course, short for "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 UMEDA intended, which makes it a more appropriate name, don't you think?) In any case, after spending all that energy on coming up with a new and spunky name, we decided that the name was _too_ spunky, so we renamed it back again to "Gnus". But in mixed case. "Gnus" vs. "GNUS". New vs. old. The first "proper" release of Gnus 5 was done in November 1995 when it was included in the Emacs 19.30 distribution. In May 1996 the next Gnus generation (aka. "September Gnus") was released under the name "Gnus 5.2". * Menu: * Why?:: What's the point of Gnus? * Compatibility:: Just how compatible is Gnus with GNUS? * Conformity:: Gnus tries to conform to all standards. * Emacsen:: Gnus can be run on a few modern Emacsen. * Contributors:: Oodles of people. * New Features:: Pointers to some of the new stuff in Gnus. * Newest Features:: Features so new that they haven't been written yet.  File: gnus, Node: Why?, Next: Compatibility, Up: History 10.1.1 Why? ----------- What's the point of Gnus? I want to provide a "rad", "happening", "way cool" and "hep" newsreader, that lets you do anything you can think of. That was my original motivation, but while working on Gnus, it has become clear to me that this generation of newsreaders really belong in the stone age. Newsreaders haven't developed much since the infancy of the net. If the volume continues to rise with the current rate of increase, all current newsreaders will be pretty much useless. How do you deal with newsgroups that have thousands of new articles each day? How do you keep track of millions of people who post? Gnus offers no real solutions to these questions, but I would very much like to see Gnus being used as a testing ground for new methods of reading and fetching news. Expanding on UMEDA-san's wise decision to separate the newsreader from the backends, Gnus now offers a simple interface for anybody who wants to write new backends for fetching mail and news from different sources. I have added hooks for customizations everywhere I could imagine useful. By doing so, I'm inviting every one of you to explore and invent. May Gnus never be complete. `C-u 100 M-x hail-emacs'.  File: gnus, Node: Compatibility, Next: Conformity, Prev: Why?, Up: History 10.1.2 Compatibility -------------------- Gnus was designed to be fully compatible with GNUS. Almost all key bindings have been kept. More key bindings have been added, of course, but only in one or two obscure cases have old bindings been changed. Our motto is: In a cloud bones of steel. All commands have kept their names. Some internal functions have changed their names. The `gnus-uu' package has changed drastically. *note Decoding Articles::. One major compatibility question is the presence of several summary buffers. All variables that are relevant while reading a group are buffer-local to the summary buffer they belong in. Although many important variables have their values copied into their global counterparts whenever a command is executed in the summary buffer, this change might lead to incorrect values being used unless you are careful. All code that relies on knowledge of GNUS internals will probably fail. To take two examples: Sorting `gnus-newsrc-alist' (or changing it in any way, as a matter of fact) is strictly verboten. Gnus maintains a hash table that points to the entries in this alist (which speeds up many functions), and changing the alist directly will lead to peculiar results. Old hilit19 code does not work at all. In fact, you should probably remove all hilit code from all Gnus hooks (`gnus-group-prepare-hook' and `gnus-summary-prepare-hook'). Gnus provides various integrated functions for highlighting. These are faster and more accurate. To make life easier for everybody, Gnus will by default remove all hilit calls from all hilit hooks. Uncleanliness! Away! Packages like `expire-kill' will no longer work. As a matter of fact, you should probably remove all old GNUS packages (and other code) when you start using Gnus. More likely than not, Gnus already does what you have written code to make GNUS do. (Snicker.) Even though old methods of doing things are still supported, only the new methods are documented in this manual. If you detect a new method of doing something while reading this manual, that does not mean you have to stop doing it the old way. Gnus understands all GNUS startup files. Overall, a casual user who hasn't written much code that depends on GNUS internals should suffer no problems. If problems occur, please let me know by issuing that magic command `M-x gnus-bug'.  File: gnus, Node: Conformity, Next: Emacsen, Prev: Compatibility, Up: History 10.1.3 Conformity ----------------- No rebels without a clue here, ma'am. We conform to all standards known to (wo)man. Except for those standards and/or conventions we disagree with, of course. *RFC 822* There are no known breaches of this standard. *RFC 1036* There are no known breaches of this standard, either. *Usenet Seal of Approval* Gnus hasn't been formally through the Seal process, but I have read through the Seal text and I think Gnus would pass. *Son-of-RFC 1036* We do have some breaches to this one. _MIME_ Gnus does no MIME handling, and this standard-to-be seems to think that MIME is the bees' knees, so we have major breakage here. _X-Newsreader_ This is considered to be a "vanity header", while I consider it to be consumer information. After seeing so many badly formatted articles coming from `tin' and `Netscape' I know not to use either of those for posting articles. I would not have known that if it wasn't for the `X-Newsreader' header. _References_ Gnus does line breaking on this header. I infer from RFC1036 that being conservative in what you output is not creating 5000-character lines, so it seems like a good idea to me. However, this standard-to-be says that whitespace in the `References' header is to be preserved, so... It doesn't matter one way or the other to Gnus, so if somebody tells me what The Way is, I'll change it. Or not. If you ever notice Gnus acting non-compliantly with regards to the texts mentioned above, don't hesitate to drop a note to Gnus Towers and let us know.  File: gnus, Node: Emacsen, Next: Contributors, Prev: Conformity, Up: History 10.1.4 Emacsen -------------- Gnus should work on : * Emacs 19.30 and up. * XEmacs 19.13 and up. * Mule versions based on Emacs 19.30 and up. Gnus will absolutely not work on any Emacsen older than that. Not reliably, at least. There are some vague differences between Gnus on the various platforms: * The mouse-face on Gnus lines under Emacs and Mule is delimited to certain parts of the lines while they cover the entire line under XEmacs. * The same with current-article marking--XEmacs puts an underline under the entire summary line while Emacs and Mule are nicer and kinder. * XEmacs features more graphics--a logo and a toolbar. * Citation highlighting us better under Emacs and Mule than under XEmacs. * Emacs 19.26-19.28 have tangible hidden headers, which can be a bit confusing.  File: gnus, Node: Contributors, Next: New Features, Prev: Emacsen, Up: History 10.1.5 Contributors ------------------- The new Gnus version couldn't have been done without the help of all the people on the (ding) mailing list. Every day for over a year I have gotten billions of nice bug reports from them, filling me with joy, every single one of them. Smooches. The people on the list have been tried beyond endurance, what with my "oh, that's a neat idea , yup, I'll release it right away no wait, that doesn't work at all , yup, I'll ship that one off right away no, wait, that absolutely does not work" policy for releases. Micro$oft--bah. Amateurs. I'm _much_ worse. (Or is that "worser"? "much worser"? "worsest"?) I would like to take this opportunity to thank the Academy for... oops, wrong show. * Masanobu UMEDA The writer of the original GNUS. * Per Abrahamsen Custom, scoring, highlighting and SOUP code (as well as numerous other things). * Luis Fernandes Design and graphics. * Wes Hardaker `gnus-picon.el' and the manual section on "picons" (*note Picons::). * Brad Miller `gnus-gl.el' and the GroupLens manual section (*note GroupLens::). * Sudish Joseph Innumerable bug fixes. * Ilja Weis `gnus-topic.el'. * Steven L. Baur Lots and lots of bugs detections and fixes. * Vladimir Alexiev The refcard and reference booklets. * Felix Lee & JWZ I stole some pieces from the XGnus distribution by Felix Lee and JWZ. * Scott Byer `nnfolder.el' enhancements & rewrite. * Peter Mutsaers Orphan article scoring code. * Ken Raeburn POP mail support. * Hallvard B Furuseth Various bits and pieces, especially dealing with .newsrc files. * Brian Edmonds `gnus-bbdb.el'. * Ricardo Nassif and Mark Borges Proof-reading. * Kevin Davidson Came up with the name "ding", so blame him. Peter Arius, Stainless Steel Rat, Ulrik Dickow, Jack Vinson, Daniel Quinlan, Frank D. Cringle, Geoffrey T. Dairiki, Fabrice Popineau and Andrew Eskilsson have all contributed code and suggestions.  File: gnus, Node: New Features, Next: Newest Features, Prev: Contributors, Up: History 10.1.6 New Features ------------------- * The look of all buffers can be changed by setting format-like variables (*note Group Buffer Format:: and *note Summary Buffer Format::). * Local spool and several NNTP servers can be used at once (*note Select Methods::). * You can combine groups into virtual groups (*note Virtual Groups::). * You can read a number of different mail formats (*note Getting Mail::). All the mail backends implement a convenient mail expiry scheme (*note Expiring Mail::). * Gnus can use various strategies for gathering threads that have lost their roots (thereby gathering loose sub-threads into one thread) or it can go back and retrieve enough headers to build a complete thread (*note Customizing Threading::). * Killed groups can be displayed in the group buffer, and you can read them as well (*note Listing Groups::). * Gnus can do partial group updates--you do not have to retrieve the entire active file just to check for new articles in a few groups (*note The Active File::). * Gnus implements a sliding scale of subscribedness to groups (*note Group Levels::). * You can score articles according to any number of criteria (*note Scoring::). You can even get Gnus to find out how to score articles for you (*note Adaptive Scoring::). * Gnus maintains a dribble buffer that is auto-saved the normal Emacs manner, so it should be difficult to lose much data on what you have read if your machine should go down (*note Auto Save::). * Gnus now has its own startup file (`.gnus') to avoid cluttering up the `.emacs' file. * You can set the process mark on both groups and articles and perform operations on all the marked items (*note Process/Prefix::). * You can grep through a subset of groups and create a group from the results (*note Kibozed Groups::). * You can list subsets of groups according to, well, anything (*note Listing Groups::). * You can browse foreign servers and subscribe to groups from those servers (*note Browse Foreign Server::). * Gnus can fetch articles asynchronously on a second connection to the server (*note Asynchronous Fetching::). * You can cache articles locally (*note Article Caching::). * The uudecode functions have been expanded and generalized (*note Decoding Articles::). * You can still post uuencoded articles, which was a little-known feature of GNUS' past (*note Uuencoding and Posting::). * Fetching parents (and other articles) now actually works without glitches (*note Finding the Parent::). * Gnus can fetch FAQs and group descriptions (*note Group Information::). * Digests (and other files) can be used as the basis for groups (*note Document Groups::). * Articles can be highlighted and customized (*note Customizing Articles::). * URLs and other external references can be buttonized (*note Article Buttons::). * You can do lots of strange stuff with the Gnus window & frame configuration (*note Windows Configuration::). * You can click on buttons instead of using the keyboard (*note Buttons::). * Gnus can use NoCeM files to weed out spam (*note NoCeM::). This is, of course, just a _short_ overview of the _most_ important new features. No, really. There are tons more. Yes, we have feeping creaturism in full effect, but nothing too gratuitous, I would hope.  File: gnus, Node: Newest Features, Prev: New Features, Up: History 10.1.7 Newest Features ---------------------- Also known as the "todo list". Sure to be implemented before the next millennium. Be afraid. Be very afraid. * Native MIME support is something that should be done. * A better and simpler method for specifying mail composing methods. * Allow posting through mail-to-news gateways. * Really do unbinhexing. And much, much, much more. There is more to come than has already been implemented. (But that's always true, isn't it?) `' is where the actual up-to-the-second todo list is located, so if you're really curious, you could point your Web browser over that-a-way.  File: gnus, Node: Terminology, Next: Customization, Prev: History, Up: Appendices 10.2 Terminology ================ "news" This is what you are supposed to use this thing for--reading news. News is generally fetched from a nearby NNTP server, and is generally publicly available to everybody. If you post news, the entire world is likely to read just what you have written, and they'll all snigger mischievously. Behind your back. "mail" Everything that's delivered to you personally is mail. Some news/mail readers (like Gnus) blur the distinction between mail and news, but there is a difference. Mail is private. News is public. Mailing is not posting, and replying is not following up. "reply" Send a mail to the person who has written what you are reading. "follow up" Post an article to the current newsgroup responding to the article you are reading. "backend" Gnus gets fed articles from a number of backends, both news and mail backends. Gnus does not handle the underlying media, so to speak--this is all done by the backends. "native" Gnus will always use one method (and backend) as the "native", or default, way of getting news. "foreign" You can also have any number of foreign groups active at the same time. These are groups that use different backends for getting news. "secondary" Secondary backends are somewhere half-way between being native and being foreign, but they mostly act like they are native. "article" A nessage that has been posted as news. "mail message" A message that has been mailed. "message" A mail message or news article "head" The top part of a message, where administrative information (etc.) is put. "body" The rest of an article. Everything that is not in the head is in the body. "header" A line from the head of an article. "headers" A collection of such lines, or a collection of heads. Or even a collection of NOV lines. "NOV" When Gnus enters a group, it asks the backend for the headers of all unread articles in the group. Most servers support the News OverView format, which is more compact and much faster to read and parse than the normal HEAD format. "level" Each group is subscribed at some "level" or other (1-9). The ones that have a lower level are "more" subscribed than the groups with a higher level. In fact, groups on levels 1-5 are considered "subscribed"; 6-7 are "unsubscribed"; 8 are "zombies"; and 9 are "killed". Commands for listing groups and scanning for new articles will all use the numeric prefix as "working level". "killed groups" No information on killed groups is stored or updated, which makes killed groups much easier to handle than subscribed groups. "zombie groups" Just like killed groups, only slightly less dead. "active file" The news server has to keep track of what articles it carries, and what groups exist. All this information in stored in the active file, which is rather large, as you might surmise. "bogus groups" A group that exists in the `.newsrc' file, but isn't known to the server (i. e., it isn't in the active file), is a _bogus group_. This means that the group probably doesn't exist (any more). "server" A machine than one can connect to and get news (or mail) from. "select method" A structure that specifies the backend, the server and the virtual server parameters. "virtual server" A named select method. Since a select methods defines all there is to know about connecting to a (physical) server, taking the who things as a whole is a virtual server.  File: gnus, Node: Customization, Next: Troubleshooting, Prev: Terminology, Up: Appendices 10.3 Customization ================== All variables are properly documented elsewhere in this manual. This section is designed to give general pointers on how to customize Gnus for some quite common situations. * Menu: * Slow/Expensive Connection:: You run a local Emacs and get the news elsewhere. * Slow Terminal Connection:: You run a remote Emacs. * Little Disk Space:: You feel that having large setup files is icky. * Slow Machine:: You feel like buying a faster machine.  File: gnus, Node: Slow/Expensive Connection, Next: Slow Terminal Connection, Up: Customization 10.3.1 Slow/Expensive NNTP Connection ------------------------------------- If you run Emacs on a machine locally, and get your news from a machine over some very thin strings, you want to cut down on the amount of data Gnus has to get from the NNTP server. `gnus-read-active-file' Set this to `nil', which will inhibit Gnus from requesting the entire active file from the server. This file is often v. large. You also have to set `gnus-check-new-news' and `gnus-check-bogus-newsgroups' to `nil' to make sure that Gnus doesn't suddenly decide to fetch the active file anyway. `gnus-nov-is-evil' This one has to be `nil'. If not, grabbing article headers from the NNTP server will not be very fast. Not all NNTP servers support XOVER; Gnus will detect this by itself.  File: gnus, Node: Slow Terminal Connection, Next: Little Disk Space, Prev: Slow/Expensive Connection, Up: Customization 10.3.2 Slow Terminal Connection ------------------------------- Let's say you use your home computer for dialing up the system that runs Emacs and Gnus. If your modem is slow, you want to reduce the amount of data that is sent over the wires as much as possible. `gnus-auto-center-summary' Set this to `nil' to inhibit Gnus from re-centering the summary buffer all the time. If it is `vertical', do only vertical re-centering. If it is neither `nil' nor `vertical', do both horizontal and vertical recentering. `gnus-visible-headers' Cut down on the headers that are included in the articles to the minimum. You can, in fact, make do without them altogether--most of the useful data is in the summary buffer, anyway. Set this variable to `^NEVVVVER' or `From:', or whatever you feel you need. `gnus-article-display-hook' Set this hook to all the available hiding commands: (setq gnus-article-display-hook '(gnus-article-hide-headers gnus-article-hide-signature gnus-article-hide-citation)) `gnus-use-full-window' By setting this to `nil', you can make all the windows smaller. While this doesn't really cut down much generally, it means that you have to see smaller portions of articles before deciding that you didn't want to read them anyway. `gnus-thread-hide-subtree' If this is non-`nil', all threads in the summary buffer will be hidden initially. `gnus-updated-mode-lines' If this is `nil', Gnus will not put information in the buffer mode lines, which might save some time.  File: gnus, Node: Little Disk Space, Next: Slow Machine, Prev: Slow Terminal Connection, Up: Customization 10.3.3 Little Disk Space ------------------------ The startup files can get rather large, so you may want to cut their sizes a bit if you are running out of space. `gnus-save-newsrc-file' If this is `nil', Gnus will never save `.newsrc'--it will only save `.newsrc.eld'. This means that you will not be able to use any other newsreaders than Gnus. This variable is `t' by default. `gnus-save-killed-list' If this is `nil', Gnus will not save the list of dead groups. You should also set `gnus-check-new-newsgroups' to `ask-server' and `gnus-check-bogus-newsgroups' to `nil' if you set this variable to `nil'. This variable is `t' by default.  File: gnus, Node: Slow Machine, Prev: Little Disk Space, Up: Customization 10.3.4 Slow Machine ------------------- If you have a slow machine, or are just really impatient, there are a few things you can do to make Gnus run faster. Set`gnus-check-new-newsgroups' and `gnus-check-bogus-newsgroups' to `nil' to make startup faster. Set `gnus-show-threads', `gnus-use-cross-reference' and `gnus-nov-is-evil' to `nil' to make entering and exiting the summary buffer faster. Set `gnus-article-display-hook' to `nil' to make article processing a bit faster.  File: gnus, Node: Troubleshooting, Next: A Programmers Guide to Gnus, Prev: Customization, Up: Appendices 10.4 Troubleshooting ==================== Gnus works _so_ well straight out of the box--I can't imagine any problems, really. Ahem. 1. Make sure your computer is switched on. 2. Make sure that you really load the current Gnus version. If you have been running GNUS, you need to exit Emacs and start it up again before Gnus will work. 3. Try doing an `M-x gnus-version'. If you get something that looks like `Gnus v5.46; nntp 4.0' you have the right files loaded. If, on the other hand, you get something like `NNTP 3.x' or `nntp flee', you have some old `.el' files lying around. Delete these. 4. Read the help group (`G h' in the group buffer) for a FAQ and a how-to. If all else fails, report the problem as a bug. If you find a bug in Gnus, you can report it with the `M-x gnus-bug' command. `M-x set-variable RET debug-on-error RET t RET', and send me the backtrace. I will fix bugs, but I can only fix them if you send me a precise description as to how to reproduce the bug. You really can never be too detailed in a bug report. Always use the `M-x gnus-bug' command when you make bug reports, even if it creates a 10Kb mail each time you use it, and even if you have sent me your environment 500 times before. I don't care. I want the full info each time. 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 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. If the problem you're seeing is very visual, and you can't quite explain it, copy the Emacs window to a file (with `xwd', for instance), put it somewhere it can be reached, and include the URL of the picture in the bug report.a If you just need help, you are better off asking on `gnu.emacs.gnus'. I'm not very helpful. You can also ask on the ding mailing list--`ding@ifi.uio.no'. Write to `ding-request@ifi.uio.no' to subscribe.  File: gnus, Node: A Programmers Guide to Gnus, Next: Emacs for Heathens, Prev: Troubleshooting, Up: Appendices 10.5 A Programmer's Guide to Gnus ================================= It is my hope that other people will figure out smart stuff that Gnus can do, and that other people will write those smart things as well. To facilitate that I thought it would be a good idea to describe the inner workings of Gnus. And some of the not-so-inner workings, while I'm at it. You can never expect the internals of a program not to change, but I will be defining (in some details) the interface between Gnus and its backends (this is written in stone), the format of the score files (ditto), data structures (some are less likely to change than others) and general method of operations. * Menu: * Backend Interface:: How Gnus communicates with the servers. * Score File Syntax:: A BNF definition of the score file standard. * Headers:: How Gnus stores headers internally. * Ranges:: A handy format for storing mucho numbers. * Group Info:: The group info format. * Emacs/XEmacs Code:: Gnus can be run under all modern Emacsen. * Various File Formats:: Formats of files that Gnus use.  File: gnus, Node: Backend Interface, Next: Score File Syntax, Up: A Programmers Guide to Gnus 10.5.1 Backend Interface ------------------------ Gnus doesn't know anything about NNTP, spools, mail or virtual groups. It only knows how to talk to "virtual servers". A virtual server is a "backend" and some "backend variables". As examples of the first, we have `nntp', `nnspool' and `nnmbox'. As examples of the latter we have `nntp-port-number' and `nnmbox-directory'. When Gnus asks for information from a backend--say `nntp'--on something, it will normally include a virtual server name in the function parameters. (If not, the backend should use the "current" virtual server.) For instance, `nntp-request-list' takes a virtual server as its only (optional) parameter. If this virtual server hasn't been opened, the function should fail. Note that a virtual server name has no relation to some physical server name. Take this example: (nntp "odd-one" (nntp-address "ifi.uio.no") (nntp-port-number 4324)) Here the virtual server name is `odd-one' while the name of the physical server is `ifi.uio.no'. The backends should be able to switch between several virtual servers. The standard backends implement this by keeping an alist of virtual server environments that it pulls down/pushes up when needed. There are two groups of interface functions: "required functions", which must be present, and "optional functions", which Gnus will always check whether are present before attempting to call. All these functions are expected to return data in the buffer `nntp-server-buffer' (` *nntpd*'), which is somewhat unfortunately named, but we'll have to live with it. When I talk about "resulting data", I always refer to the data in that buffer. When I talk about "return value", I talk about the function value returned by the function call. Some backends could be said to be "server-forming" backends, and some might be said to not be. The latter are backends that generally only operate on one group at a time, and have no concept of "server" - they have a group, and they deliver info on that group and nothing more. In the examples and definitions I will refer to the imaginary backend `nnchoke'. * Menu: * Required Backend Functions:: Functions that must be implemented. * Optional Backend Functions:: Functions that need not be implemented. * Writing New Backends:: Extending old backends.  File: gnus, Node: Required Backend Functions, Next: Optional Backend Functions, Up: Backend Interface 10.5.1.1 Required Backend Functions ................................... `(nnchoke-retrieve-headers ARTICLES &optional GROUP SERVER FETCH-OLD)' ARTICLES is either a range of article numbers or a list of `Message-ID's. Current backends do not fully support either--only sequences (lists) of article numbers, and most backends do not support retrieval of `Message-ID's. But they should try for both. The result data should either be HEADs or NOV lines, and the result value should either be `headers' or `nov' to reflect this. This might later be expanded to `various', which will be a mixture of HEADs and NOV lines, but this is currently not supported by Gnus. If FETCH-OLD is non-`nil' it says to try to fetch "extra headers, in some meaning of the word. This is generally done by fetching (at most) FETCH-OLD extra headers less than the smallest article number in `articles', and fill in the gaps as well. The presence of this parameter can be ignored if the backend finds it cumbersome to follow the request. If this is non-`nil' and not a number, do maximum fetches. Here's an example HEAD: 221 1056 Article retrieved. Path: ifi.uio.no!sturles From: sturles@ifi.uio.no (Sturle Sunde) Newsgroups: ifi.discussion Subject: Re: Something very droll Date: 27 Oct 1994 14:02:57 +0100 Organization: Dept. of Informatics, University of Oslo, Norway Lines: 26 Message-ID: <38o8e1$a0o@holmenkollen.ifi.uio.no> References: <38jdmq$4qu@visbur.ifi.uio.no> NNTP-Posting-Host: holmenkollen.ifi.uio.no . So a `headers' return value would imply that there's a number of these in the data buffer. Here's a BNF definition of such a buffer: headers = *head head = error / valid-head error-message = [ "4" / "5" ] 2number " " eol valid-head = valid-message *header "." eol valid-message = "221 " " Article retrieved." eol header = eol If the return value is `nov', the data buffer should contain "network overview database" lines. These are basically fields separated by tabs. nov-buffer = *nov-line nov-line = 8*9 [ field ] eol field = For a closer explanation what should be in those fields, *note Headers::. `(nnchoke-open-server SERVER &optional DEFINITIONS)' SERVER is here the virtual server name. DEFINITIONS is a list of `(VARIABLE VALUE)' pairs that defines this virtual server. If the server can't be opened, no error should be signaled. The backend may then choose to refuse further attempts at connecting to this server. In fact, it should do so. If the server is opened already, this function should return a non-`nil' value. There should be no data returned. `(nnchoke-close-server &optional SERVER)' Close connection to SERVER and free all resources connected to it. Return `nil' if the server couldn't be closed for some reason. There should be no data returned. `(nnchoke-request-close)' Close connection to all servers and free all resources that the backend have reserved. All buffers that have been created by that backend should be killed. (Not the `nntp-server-buffer', though.) This function is generally only called when Gnus is shutting down. There should be no data returned. `(nnchoke-server-opened &optional SERVER)' If SERVER is the current virtual server, and the connection to the physical server is alive, then this function should return a non-`nil' vlue. This function should under no circumstances attempt to reconnect to a server that is has lost connection to. There should be no data returned. `(nnchoke-status-message &optional SERVER)' This function should return the last error message from SERVER. There should be no data returned. `(nnchoke-request-article ARTICLE &optional GROUP SERVER TO-BUFFER)' The result data from this function should be the article specified by ARTICLE. This might either be a `Message-ID' or a number. It is optional whether to implement retrieval by `Message-ID', but it would be nice if that were possible. If TO-BUFFER is non-`nil', the result data should be returned in this buffer instead of the normal data buffer. This is to make it possible to avoid copying large amounts of data from one buffer to another, and Gnus mainly request articles to be inserted directly into its article buffer. If it is at all possible, this function should return a cons cell where the car is the group name the article was fetched from, and the cdr is the article number. This will enable Gnus to find out what the real group and article numbers are when fetching articles by `Message-ID'. If this isn't possible, `t' should be returned on successful article retrievement. `(nnchoke-open-group GROUP &optional SERVER)' Make GROUP the current group. There should be no data returned by this function. `(nnchoke-request-group GROUP &optional SERVER)' Get data on GROUP. This function also has the side effect of making GROUP the current group. Here's an example of some result data and a definition of the same: 211 56 1000 1059 ifi.discussion The first number is the status, which should be `211'. Next is the total number of articles in the group, the lowest article number, the highest article number, and finally the group name. Note that the total number of articles may be less than one might think while just considering the highest and lowest article numbers, but some articles may have been canceled. 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 exercise to the reader. group-status = [ error / info ] eol error = [ "4" / "5" ] 2 " " info = "211 " 3* [ " " ] `(nnchoke-close-group GROUP &optional SERVER)' Close GROUP and free any resources connected to it. This will be a no-op on most backends. There should be no data returned. `(nnchoke-request-list &optional SERVER)' Return a list of all groups available on SERVER. And that means _all_. Here's an example from a server that only carries two groups: ifi.test 0000002200 0000002000 y ifi.discussion 3324 3300 n On each line we have a group name, then the highest article number in that group, the lowest article number, and finally a flag. active-file = *active-line active-line = name " " " " " " flags eol name = flags = "n" / "y" / "m" / "x" / "j" / "=" name The flag says whether the group is read-only (`n'), is moderated (`m'), is dead (`x'), is aliased to some other group (`=other-group' or none of the above (`y'). `(nnchoke-request-post &optional SERVER)' This function should post the current buffer. It might return whether the posting was successful or not, but that's not required. If, for instance, the posting is done asynchronously, it has generally not been completed by the time this function concludes. In that case, this function should set up some kind of sentinel to beep the user loud and clear if the posting could not be completed. There should be no result data from this function.  File: gnus, Node: Optional Backend Functions, Next: Writing New Backends, Prev: Required Backend Functions, Up: Backend Interface 10.5.1.2 Optional Backend Functions ................................... `(nnchoke-retrieve-groups GROUPS &optional SERVER)' GROUPS is a list of groups, and this function should request data on all those groups. How it does it is of no concern to Gnus, but it should attempt to do this in a speedy fashion. The return value of this function can be either `active' or `group', which says what the format of the result data is. The former is in the same format as the data from `nnchoke-request-list', while the latter is a buffer full of lines in the same format as `nnchoke-request-group' gives. group-buffer = *active-line / *group-status `(nnchoke-request-update-info GROUP INFO &optional SERVER)' A Gnus group info (*note Group Info::) is handed to the backend for alterations. This comes in handy if the backend really carries all the information (as is the case with virtual an imap groups). This function may alter the info in any manner it sees fit, and should return the (altered) group info. This function may alter the group info destructively, so no copying is needed before boogeying. There should be no result data from this function. `(nnchoke-request-type GROUP &optional ARTICLE)' When the user issues commands for "sending news" (`F' in the summary buffer, for instance), Gnus has to know whether the article the user is following up is news or mail. This function should return `news' if ARTICLE in GROUP is news, `mail' if it is mail and `unknown' if the type can't be decided. (The ARTICLE parameter is necessary in `nnvirtual' groups which might very well combine mail groups and news groups.) There should be no result data from this function. `(nnchoke-request-update-mark GROUP ARTICLE MARK)' If the user tries to set a mark that the backend doesn't like, this function may change the mark. Gnus will use whatever this function returns as the mark for ARTICLE instead of the original MARK. If the backend doesn't care, it must return the original MARK, and not `nil' or any other type of garbage. The only use for this that I can see is what `nnvirtual' does with it--if a component group is auto-expirable, marking an article as read in the virtual group should result in the article being marked as expirable. There should be no result data from this function. `(nnchoke-request-scan &optional GROUP SERVER)' This function may be called at any time (by Gnus or anything else) to request that the backend check for incoming articles, in one way or another. A mail backend will typically read the spool file or query the POP server when this function is invoked. The GROUP doesn't have to be heeded--if the backend decides that it is too much work just scanning for a single group, it may do a total scan of all groups. It would be nice, however, to keep things local if that's practical. There should be no result data from this function. `(nnchoke-request-asynchronous GROUP &optional SERVER ARTICLES)' This is a request to fetch articles asynchronously later. ARTICLES is an alist of (ARTICLE-NUMBER LINE-NUMBER). One 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 asynchronously, but that is left up to the backend. Gnus doesn't care. There should be no result data from this function. `(nnchoke-request-group-description GROUP &optional SERVER)' The result data from this function should be a description of GROUP. description-line = name description eol name = description = `(nnchoke-request-list-newsgroups &optional SERVER)' The result data from this function should be the description of all groups available on the server. description-buffer = *description-line `(nnchoke-request-newgroups DATE &optional SERVER)' The result data from this function should be all groups that were created after `date', which is in normal human-readable date format. The data should be in the active buffer format. `(nnchoke-request-create-group GROUP &optional SERVER)' This function should create an empty group with name GROUP. There should be no return data. `(nnchoke-request-expire-articles ARTICLES &optional GROUP SERVER FORCE)' This function should run the expiry process on all articles in the ARTICLES range (which is currently a simple list of article numbers.) It is left up to the backend to decide how old articles should be before they are removed by this function. If FORCE is non-`nil', all ARTICLES should be deleted, no matter how new they are. This function should return a list of articles that it did not/was not able to delete. There should be no result data returned. `(nnchoke-request-move-article ARTICLE GROUP SERVER ACCEPT-FORM' &optional LAST) This function should move ARTICLE (which is a number) from GROUP by calling ACCEPT-FORM. This function should ready the article in question for moving by removing any header lines it has added to the article, and generally should "tidy up" the article. Then it should `eval' ACCEPT-FORM in the buffer where the "tidy" article is. This will do the actual copying. If this `eval' returns a non-`nil' value, the article should be removed. If LAST is `nil', that means that there is a high likelihood that there will be more requests issued shortly, so that allows some optimizations. The function should return a cons where the car is the group name and the cdr is the article number that the article was entered as. There should be no data returned. `(nnchoke-request-accept-article GROUP &optional SERVER LAST)' This function takes the current buffer and inserts it into GROUP. If LAST in `nil', that means that there will be more calls to this function in short order. The function should return a cons where the car is the group name and the cdr is the article number that the article was entered as. There should be no data returned. `(nnchoke-request-replace-article ARTICLE GROUP BUFFER)' This function should remove ARTICLE (which is a number) from GROUP and insert BUFFER there instead. There should be no data returned. `(nnchoke-request-delete-group GROUP FORCE &optional SERVER)' This function should delete GROUP. If FORCE, it should really delete all the articles in the group, and then delete the group itself. (If there is such a thing as "the group itself".) There should be no data returned. `(nnchoke-request-rename-group GROUP NEW-NAME &optional SERVER)' This function should rename GROUP into NEW-NAME. All articles that are in GROUP should move to NEW-NAME. There should be no data returned.  File: gnus, Node: Writing New Backends, Prev: Optional Backend Functions, Up: Backend Interface 10.5.1.3 Writing New Backends ............................. The various backends share many similarities. `nnml' is just like `nnspool', but it allows you to edit the articles on the server. `nnmh' is just like `nnml', but it doesn't use an active file, and it doesn't maintain overview databases. `nndir' is just like `nnml', but it has no concept of "groups", and it doesn't allow editing articles. It would make sense if it were possible to "inherit" functions from backends when writing new backends. And, indeed, you can do that if you want to. (You don't have to if you don't want to, of course.) All the backends declare their public variables and functions by using a package called `nnoo'. To inherit functions from other backends (and allow other backends to inherit functions from the current backend), you should use the following macros: following. `nnoo-declare' This macro declares the first parameter to be a child of the subsequent parameters. For instance: (nnoo-declare nndir nnml nnmh) `nndir' has here declared that it intends to inherit functions from both `nnml' and `nnmh'. `defvoo' This macro is equivalent to `defvar', but registers the variable as a public server variable. Most state-oriented variables should be declared with `defvoo' instead of `defvar'. In addition to the normal `defvar' parameters, it takes a list of variables in the parent backends to map the variable to when executing a function in those backends. (defvoo nndir-directory nil "Where nndir will look for groups." nnml-current-directory nnmh-current-directory) This means that `nnml-current-directory' will be set to `nndir-directory' when an `nnml' function is called on behalf of `nndir'. (The same with `nnmh'.) `nnoo-define-basics' This macro defines some common functions that almost all backends should have. (nnoo-define-basics nndir) `deffoo' This macro is just like `defun' and takes the same parameters. In addition to doing the normal `defun' things, it registers the function as being public so that other backends can inherit it. `nnoo-map-functions' This macro allows mapping of functions from the current backend to functions from the parent backends. (nnoo-map-functions nndir (nnml-retrieve-headers 0 nndir-current-group 0 0) (nnmh-request-article 0 nndir-current-group 0 0)) This means that when `nndir-retrieve-headers' is called, the first, third, and fourth parameters will be passed on to `nnml-retrieve-headers', while the second parameter is set to the value of `nndir-current-group'. `nnoo-import' This macro allows importing functions from backends. It should be the last thing in the source file, since it will only define functions that haven't already been defined. (nnoo-import nndir (nnmh nnmh-request-list nnmh-request-newgroups) (nnml)) This means that calls to `nndir-request-list' should just be passed on to `nnmh-request-list', while all public functions from `nnml' that haven't been defined in `nndir' yet should be defined now. Below is a slightly shortened version of the `nndir' backend. ;;; nndir.el --- single directory newsgroup access for Gnus ;; Copyright (C) 1995,96 Free Software Foundation, Inc. ;;; Code: (require 'nnheader) (require 'nnmh) (require 'nnml) (require 'nnoo) (eval-when-compile (require 'cl)) (nnoo-declare nndir nnml nnmh) (defvoo nndir-directory nil "Where nndir will look for groups." nnml-current-directory nnmh-current-directory) (defvoo nndir-nov-is-evil nil "*Non-nil means that nndir will never retrieve NOV headers." nnml-nov-is-evil) (defvoo nndir-current-group "" nil nnml-current-group nnmh-current-group) (defvoo nndir-top-directory nil nil nnml-directory nnmh-directory) (defvoo nndir-get-new-mail nil nil nnml-get-new-mail nnmh-get-new-mail) (defvoo nndir-status-string "" nil nnmh-status-string) (defconst nndir-version "nndir 1.0") ;;; Interface functions. (nnoo-define-basics nndir) (deffoo nndir-open-server (server &optional defs) (setq nndir-directory (or (cadr (assq 'nndir-directory defs)) server)) (unless (assq 'nndir-directory defs) (push `(nndir-directory ,server) defs)) (push `(nndir-current-group ,(file-name-nondirectory (directory-file-name nndir-directory))) defs) (push `(nndir-top-directory ,(file-name-directory (directory-file-name nndir-directory))) defs) (nnoo-change-server 'nndir server defs)) (nnoo-map-functions nndir (nnml-retrieve-headers 0 nndir-current-group 0 0) (nnmh-request-article 0 nndir-current-group 0 0) (nnmh-request-group nndir-current-group 0 0) (nnmh-close-group nndir-current-group 0)) (nnoo-import nndir (nnmh nnmh-status-message nnmh-request-list nnmh-request-newgroups)) (provide 'nndir)  File: gnus, Node: Score File Syntax, Next: Headers, Prev: Backend Interface, Up: A Programmers Guide to Gnus 10.5.2 Score File Syntax ------------------------ Score files are meant to be easily parsable, but yet extremely mallable. It was decided that something that had the same read syntax as an Emacs Lisp list would fit that spec. Here's a typical score file: (("summary" ("win95" -10000 nil s) ("Gnus")) ("from" ("Lars" -1000)) (mark -100)) BNF definition of a score file: score-file = "" / "(" *element ")" element = rule / atom rule = string-rule / number-rule / date-rule string-rule = "(" quote string-header quote space *string-match ")" number-rule = "(" quote number-header quote space *number-match ")" date-rule = "(" quote date-header quote space *date-match ")" quote = string-header = "subject" / "from" / "references" / "message-id" / "xref" / "body" / "head" / "all" / "followup" number-header = "lines" / "chars" date-header = "date" string-match = "(" quote quote [ "" / [ space score [ "" / space date [ "" / [ space string-match-t ] ] ] ] ] ")" score = "nil" / date = "nil" / string-match-t = "nil" / "s" / "substring" / "S" / "Substring" / "r" / "regex" / "R" / "Regex" / "e" / "exact" / "E" / "Exact" / "f" / "fuzzy" / "F" / "Fuzzy" number-match = "(" [ "" / [ space score [ "" / space date [ "" / [ space number-match-t ] ] ] ] ] ")" number-match-t = "nil" / "=" / "<" / ">" / ">=" / "<=" date-match = "(" quote quote [ "" / [ space score [ "" / space date [ "" / [ space date-match-t ] ] ] ] ")" date-match-t = "nil" / "at" / "before" / "after" atom = "(" [ required-atom / optional-atom ] ")" required-atom = mark / expunge / mark-and-expunge / files / exclude-files / read-only / touched optional-atom = adapt / local / eval mark = "mark" space nil-or-number nil-or-number = "nil" / expunge = "expunge" space nil-or-number mark-and-expunge = "mark-and-expunge" space nil-or-number files = "files" *[ space ] exclude-files = "exclude-files" *[ space ] read-only = "read-only" [ space "nil" / space "t" ] adapt = "adapt" [ space "nil" / space "t" / space adapt-rule ] adapt-rule = "(" *[ *[ "(" ")" ] ")" local = "local" *[ space "(" space
")" ] eval = "eval" space space = *[ " " / / ] Any unrecognized elements in a score file should be ignored, but not discarded. As you can see, white space is needed, but the type and amount of white space is irrelevant. This means that formatting of the score file is left up to the programmer--if it's simpler to just spew it all out on one looong line, then that's ok. The meaning of the various atoms are explained elsewhere in this manual.  File: gnus, Node: Headers, Next: Ranges, Prev: Score File Syntax, Up: A Programmers Guide to Gnus 10.5.3 Headers -------------- Gnus uses internally a format for storing article headers that corresponds to the NOV format in a mysterious fashion. One could almost suspect that the author looked at the NOV specification and just shamelessly _stole_ the entire thing, and one would be right. "Header" is a severely overloaded term. "Header" is used in RFC1036 to talk about lines in the head of an article (eg., `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 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: `number', `subject', `from', `date', `id', `references', `chars', `lines', `xref'. There are macros for accessing and setting these slots - they all have predictable names beginning with `mail-header-' and `mail-header-set-', respectively. The `xref' slot is really a `misc' slot. Any extra info will be put in there.  File: gnus, Node: Ranges, Next: Group Info, Prev: Headers, Up: A Programmers Guide to Gnus 10.5.4 Ranges ------------- GNUS introduced a concept that I found so useful that I've started using it a lot and have elaborated on it greatly. The question is simple: If you have a large amount of objects that are identified by numbers (say, articles, to take a _wild_ example) that you want to callify as being "included", a normal sequence isn't very useful. (A 200,000 length sequence is a bit long-winded.) The solution is as simple as the question: You just collapse the sequence. (1 2 3 4 5 6 10 11 12) is transformed into ((1 . 6) (10 . 12)) To avoid having those nasty `(13 . 13)' elements to denote a lonesome object, a `13' is a valid element: ((1 . 6) 7 (10 . 12)) This means that comparing two ranges to find out whether they are equal is slightly tricky: ((1 . 5) 7 8 (10 . 12)) and ((1 . 5) (7 . 8) (10 . 12)) are equal. In fact, any non-descending list is a range: (1 2 3 4 5) is a perfectly valid range, although a pretty long-winded one. This is also legal: (1 . 5) and is equal to the previous range. Here's a BNF definition of ranges. Of course, one must remember the semantic requirement that the numbers are non-descending. (Any number of repetition of the same number is allowed, but apt to disappear in range handling.) range = simple-range / normal-range simple-range = "(" number " . " number ")" normal-range = "(" start-contents ")" contents = "" / simple-range *[ " " contents ] / number *[ " " contents ] Gnus currently uses ranges to keep track of read articles and article marks. I plan on implementing a number of range operators in C if The Powers That Be are willing to let me. (I haven't asked yet, because I need to do some more thinking on what operators I need to make life totally range-based without ever having to convert back to normal sequences.)  File: gnus, Node: Group Info, Next: Emacs/XEmacs Code, Prev: Ranges, Up: A Programmers Guide to Gnus 10.5.5 Group Info ----------------- Gnus stores all permanent info on groups in a "group info" list. This list is from three to six elements (or more) long and exhaustively describes the group. Here are two example group infos; one is a very simple group while the second is a more complex one: ("no.group" 5 (1 . 54324)) ("nnml:my.mail" 3 ((1 . 5) 9 (20 . 55)) ((tick (15 . 19)) (replied 3 6 (19 . 3))) (nnml "") (auto-expire (to-address "ding@ifi.uio.no"))) The first element is the group name as Gnus knows the group; the second is the group level; the third is the read articles in range format; the fourth is a list of article marks lists; the fifth is the select method; and the sixth contains the group parameters. Here's a BNF definition of the group info format: info = "(" group space level space read [ "" / [ space marks-list [ "" / [ space method [ "" / space parameters ] ] ] ] ] ")" group = quote quote level = read = range marks-lists = nil / "(" *marks ")" marks = "(" range ")" method = "(" *elisp-forms ")" parameters = "(" *elisp-forms ")" Actually that `marks' rule is a fib. A `marks' is a `' consed on to a `range', but that's a bitch to say in pseudo-BNF.  File: gnus, Node: Emacs/XEmacs Code, Next: Various File Formats, Prev: Group Info, Up: A Programmers Guide to Gnus 10.5.6 Emacs/XEmacs Code ------------------------ While Gnus runs under Emacs, XEmacs and Mule, I decided that one of the platforms must be the primary one. I chose Emacs. Not because I don't like XEmacs or Mule, but because it comes first alphabetically. This means that Gnus will byte-compile under Emacs with nary a warning, while XEmacs will pump out gigabytes of warnings while byte-compiling. As I use byte-compilation warnings to help me root out trivial errors in Gnus, that's very useful. I've also consistently used Emacs function interfaces, but have used Gnusey aliases for the functions. To take an example: Emacs defines a `run-at-time' function while XEmacs defines a `start-itimer' function. I then define a function called `gnus-run-at-time' that takes the same parameters as the Emacs `run-at-time'. When running Gnus under Emacs, the former function is just an alias for the latter. However, when running under XEmacs, the former is an alias for the following function: (defun gnus-xmas-run-at-time (time repeat function &rest args) (start-itimer "gnus-run-at-time" `(lambda () (,function ,@args)) time repeat)) This sort of thing has been done for bunches of functions. Gnus does not redefine any native Emacs functions while running under XEmacs - it does this `defalias' thing with Gnus equivalents instead. Cleaner all over. Of course, I could have chosen XEmacs as my native platform and done mapping functions the other way around. But I didn't. The performance hit these indirections impose on Gnus under XEmacs should be slight.  File: gnus, Node: Various File Formats, Prev: Emacs/XEmacs Code, Up: A Programmers Guide to Gnus 10.5.7 Various File Formats --------------------------- * Menu: * Active File Format:: Information on articles and groups available. * Newsgroups File Format:: Group descriptions.  File: gnus, Node: Active File Format, Next: Newsgroups File Format, Up: Various File Formats 10.5.7.1 Active File Format ........................... The active file lists all groups that are available on the server in question. It also lists the highest and lowest current article numbers in each group. Here's an excerpt from a typical active file: soc.motss 296030 293865 y alt.binaries.pictures.fractals 3922 3913 n comp.sources.unix 1605 1593 m comp.binaries.ibm.pc 5097 5089 y no.general 1000 900 y Here's a pseudo-BNF definition of this file: active = *group-line group-line = group space high-number space low-number space flag group = space = " " high-number = low-number = flag = "y" / "n" / "m" / "j" / "x" / "=" group  File: gnus, Node: Newsgroups File Format, Prev: Active File Format, Up: Various File Formats 10.5.7.2 Newsgroups File Format ............................... The newsgroups file lists groups along with their descriptions. Not all groups on the server have to be listed, and not all groups in the file have to exist on the server. The file is meant purely as information to the user. The format is quite simple; a group name, a tab, and the description. Here's the definition: newsgroups = *line line = group tab description group = tab = description =  File: gnus, Node: Emacs for Heathens, Next: Frequently Asked Questions, Prev: A Programmers Guide to Gnus, Up: Appendices 10.6 Emacs for Heathens ======================= Believe it or not, but some people who use Gnus haven't really used Emacs much before they embarked on their journey on the Gnus Love Boat. If you are one of those unfortunates whom "`M-C-a'", "kill the region", and "set `gnus-flargblossen' to an alist where the key is a regexp that is used for matching on the group name" are magical phrases with little or no meaning, then this appendix is for you. If you are already familiar with Emacs, just ignore this and go fondle your cat instead. * Menu: * Keystrokes:: Entering text and executing commands. * Emacs Lisp:: The built-in Emacs programming language.  File: gnus, Node: Keystrokes, Next: Emacs Lisp, Up: Emacs for Heathens 10.6.1 Keystrokes ----------------- * Q: What is an experienced Emacs user? * A: A person who wishes that the terminal had pedals. Yes, when you use Emacs, you are apt to use the control key, the shift key and the meta key a lot. This is very annoying to some people (notably `vi'le users), and the rest of us just love the hell out of it. Just give up and submit. Emacs really does stand for "Escape-Meta-Alt-Control-Shift", and not "Editing Macros", as you may have heard from other disreputable sources (like the Emacs author). The shift key is normally located near your pinky fingers, and are 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 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. Now, us Emacs people doesn't say "press the meta-control-m key", because that's just too inconvenient. We say "press the `M-C-m' key". `M-' is the prefix that means "meta" and "C-" is the prefix that means "control". So "press `C-k'" means "press down the control key, and hold it down while you press `k'". "Press `M-C-k'" means "press down and hold down the meta key and the control key and then press `k'". Simple, ay? This is somewhat complicated by the fact that not all keyboards have a meta key. In that case you can use the "escape" key. Then `M-k' means "press escape, release escape, press `k'". That's much more work than if you have a meta key, so if that's the case, I respectfully suggest you get a real keyboard with a meta key. You can't live without it.  File: gnus, Node: Emacs Lisp, Prev: Keystrokes, Up: Emacs for Heathens 10.6.2 Emacs Lisp ----------------- Emacs is the King of Editors because it's really a Lisp interpreter. Each and every key you tap runs some Emacs Lisp code snippet, and since Emacs Lisp is an interpreted language, that means that you can configure any key to run any arbitrary code. You just, like, do it. Gnus is written in Emacs Lisp, and is run as a bunch of interpreted functions. (These are byte-compiled for speed, but it's still interpreted.) If you decide that you don't like the way Gnus does certain things, it's trivial to have it do something a different way. (Well, at least if you know how to write Lisp code.) However, that's beyond the scope of this manual, so we are simply going to talk about some common constructs that you normally use in your `.emacs' file to customize Gnus. If you want to set the variable `gnus-florgbnize' to four (4), you write the following: (setq gnus-florgbnize 4) This function (really "special form") `setq' is the one that can set a variable to some value. This is really all you need to know. Now you can go and fill your `.emacs' file with lots of these to change how Gnus works. If you have put that thing in your `.emacs' file, it will be read and `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 `C-x C-e' after the closing parenthesis. That will `eval' the previous "form", which here is a simple `setq' statement. Go ahead--just try it, if you're located at your Emacs. After you `C-x C-e', you will see `4' appear in the echo area, which is the return value of the form you `eval'ed. Some pitfalls: If the manual says "set `gnus-read-active-file' to `some'", that means: (setq gnus-read-active-file 'some) On the other hand, if the manual says "set `gnus-nntp-server' to `nntp.ifi.uio.no'", that means: (setq gnus-nntp-server "nntp.ifi.uio.no") So be careful not to mix up strings (the latter) with symbols (the former). The manual is unambiguous, but it can be confusing. \input texinfo  File: gnus, Node: Frequently Asked Questions, Prev: Emacs for Heathens, Up: Appendices 10.7 Frequently Asked Questions =============================== This is the Gnus Frequently Asked Questions list. If you have a Web browser, the official hypertext version is at `http://www.miranova.com/~steve/gnus-faq.html>', and has probably been updated since you got this manual. * Menu: * Installation FAQ:: Installation of Gnus. * Customization FAQ:: Customizing Gnus. * Reading News FAQ:: News Reading Questions. * Reading Mail FAQ:: Mail Reading Questions.  File: gnus, Node: Installation FAQ, Next: Customization FAQ, Up: Frequently Asked Questions 10.7.1 Installation ------------------- * Q1.1 What is the latest version of Gnus? The latest (and greatest) version is 5.0.10. You might also run across something called _September Gnus_. September Gnus is the alpha version of the next major release of Gnus. It is currently not stable enough to run unless you are prepared to debug lisp. * Q1.2 Where do I get Gnus? Any of the following locations: - `ftp://ftp.ifi.uio.no/pub/emacs/gnus/gnus.tar.gz' - `ftp://ftp.pilgrim.umass.edu/pub/misc/ding/' - `gopher://gopher.pilgrim.umass.edu/11/pub/misc/ding/' - `ftp://aphrodite.nectar.cs.cmu.edu/pub/ding-gnus/' - `ftp://ftp.solace.mh.se:/pub/gnu/elisp/' * Q1.3 Which version of Emacs do I need? At least GNU Emacs 19.28, or XEmacs 19.12 is recommended. GNU Emacs 19.25 has been reported to work under certain circumstances, but it doesn't _officially_ work on it. 19.27 has also been reported to work. Gnus has been reported to work under OS/2 as well as Unix. * Q1.4 Where is timezone.el? Upgrade to XEmacs 19.13. In earlier versions of XEmacs this file was placed with Gnus 4.1.3, but that has been corrected. * Q1.5 When I run Gnus on XEmacs 19.13 I get weird error messages. You're running an old version of Gnus. Upgrade to at least version 5.0.4. * Q1.6 How do I unsubscribe from the Mailing List? Send an e-mail message to `ding-request@ifi.uio.no' with the magic word _unsubscribe_ somewhere in it, and you will be removed. If you are reading the digest version of the list, send an e-mail message to `ding-rn-digests-d-request@moe.shore.net' with _unsubscribe_ as the subject and you will be removed. * Q1.7 How do I run Gnus on both Emacs and XEmacs? The basic answer is to byte-compile under XEmacs, and then you can run under either Emacsen. There is, however, a potential version problem with easymenu.el with Gnu Emacs prior to 19.29. Per Abrahamsen writes : The internal easymenu.el interface changed between 19.28 and 19.29 in order to make it possible to create byte compiled files that can be shared between Gnu Emacs and XEmacs. The change is upward compatible, but not downward compatible. This gives the following compatibility table: Compiled with: | Can be used with: ----------------+-------------------------------------- 19.28 | 19.28 19.29 19.29 | 19.29 XEmacs XEmacs | 19.29 XEmacs If you have Gnu Emacs 19.28 or earlier, or XEmacs 19.12 or earlier, get a recent version of auc-menu.el from `ftp://ftp.iesd.auc.dk/pub/emacs-lisp/auc-menu.el', and install it under the name easymenu.el somewhere early in your load path. * Q1.8 What resources are available? There is the newsgroup Gnu.emacs.gnus. Discussion of Gnus 5.x is now taking place there. There is also a mailing list, send mail to `ding-request@ifi.uio.no' with the magic word _subscribe_ somewhere in it. _NOTE:_ the traffic on this list is heavy so you may not want to be on it (unless you use Gnus as your mailer reader, that is). The mailing list is mainly for developers and testers. Gnus has a home World Wide Web page at `http://www.ifi.uio.no/~larsi/ding.html'. Gnus has a write up in the X Windows Applications FAQ at `http://www.ee.ryerson.ca:8080/~elf/xapps/Q-III.html'. The Gnus manual is also available on the World Wide Web. The canonical source is in Norway at `http://www.ifi.uio.no/~larsi/ding-manual/gnus_toc.html'. There are three mirrors in the United States: 1. `http://www.miranova.com/gnus-man/' 2. `http://www.pilgrim.umass.edu/pub/misc/ding/manual/gnus_toc.html' 3. `http://www.rtd.com/~woo/gnus/' PostScript copies of the Gnus Reference card are available from `ftp://ftp.cs.ualberta.ca/pub/oolog/gnus/'. They are mirrored at `ftp://ftp.pilgrim.umass.edu/pub/misc/ding/refcard/' in the United States. And `ftp://marvin.fkphy.uni-duesseldorf.de/pub/gnus/' in Germany. An online version of the Gnus FAQ is available at `http://www.miranova.com/~steve/gnus-faq.html'. Off-line formats are also available: ASCII: `ftp://ftp.miranova.com/pub/gnus/gnus-faq' PostScript: `ftp://ftp.miranova.com/pub/gnus/gnus-faq.ps'. * Q1.9 Gnus hangs on connecting to NNTP server I am running XEmacs on SunOS and Gnus prints a message about Connecting to NNTP server and then just hangs. Ben Wing writes : I wonder if you're hitting the infamous _libresolv_ problem. The basic problem is that under SunOS you can compile either with DNS or NIS name lookup libraries but not both. Try substituting the IP address and see if that works; if so, you need to download the sources and recompile. * Q1.10 Mailcrypt 3.4 doesn't work This problem is verified to still exist in Gnus 5.0.9 and MailCrypt 3.4. The answer comes from Peter Arius . I found out that mailcrypt uses `gnus-eval-in-buffer-window', which is a macro. It seems as if you have compiled mailcrypt with plain old GNUS in load path, and the XEmacs byte compiler has inserted that macro definition into `mc-toplev.elc'. The solution is to recompile `mc-toplev.el' with Gnus 5 in load-path, and it works fine. Steve Baur adds : The problem also manifests itself if neither GNUS 4 nor Gnus 5 is in the load-path. * Q1.11 What other packages work with Gnus? - Mailcrypt. Mailcrypt is an Emacs interface to PGP. It works, it installs without hassle, and integrates very easily. Mailcrypt can be obtained from `ftp://cag.lcs.mit.edu/pub/patl/mailcrypt-3.4.tar.gz'. - Tiny Mime. Tiny Mime is an Emacs MUA interface to MIME. Installation is a two-step process unlike most other packages, so you should be prepared to move the byte-compiled code somewhere. There are currently two versions of this package available. It can be obtained from `ftp://ftp.jaist.ac.jp/pub/GNU/elisp/'. Be sure to apply the supplied patch. It works with Gnus through version 5.0.9. In order for all dependencies to work correctly the load sequence is as follows: (load "tm-setup") (load "gnus") (load "mime-compose") _NOTE:_ Loading the package disables citation highlighting by default. To get the old behavior back, use the `M-t' command.  File: gnus, Node: Customization FAQ, Next: Reading News FAQ, Prev: Installation FAQ, Up: Frequently Asked Questions 10.7.2 Customization -------------------- * Q2.1 Custom Edit does not work under XEmacs The custom package has not been ported to XEmacs. * Q2.2 How do I quote messages? I see lots of messages with quoted material in them. I am wondering how to have Gnus do it for me. This is Gnus, so there are a number of ways of doing this. You can use the built-in commands to do this. There are the `F' and `R' keys from the summary buffer which automatically include the article being responded to. These commands are also selectable as Followup and Yank and Reply and Yank in the Post menu. `C-c C-y' grabs the previous message and prefixes each line with `ail-indentation-spaces' spaces or `mail-yank-prefix' if that is non-nil, unless you have set your own `mail-citation-hook', which will be called to to do the job. You might also consider the Supercite package, which allows for pretty arbitrarily complex quoting styles. Some people love it, some people hate it. * Q2.3 How can I keep my nnvirtual:* groups sorted? How can I most efficiently arrange matters so as to keep my nnvirtual:* (etc) groups at the top of my group selection buffer, whilst keeping everything sorted in alphabetical order. If you don't subscribe often to new groups then the easiest way is to first sort the groups and then manually kill and yank the virtuals wherever you want them. * Q2.4 Any good suggestions on stuff for an all.SCORE file? Here is a collection of suggestions from the Gnus mailing list. 1. From "Dave Disser" I like blasting anything without lowercase letters. Weeds out most of the make $$ fast, as well as the lame titles like "IBM" and "HP-UX" with no further description. (("Subject" ("^\\(Re: \\)?[^a-z]*$" -200 nil R))) 2. From "Peter Arius" The most vital entries in my (still young) all.SCORE: (("xref" ("alt.fan.oj-simpson" -1000 nil s)) ("subject" ("\\<\\(make\\|fast\\|big\\)\\s-*\\(money\\|cash\\|bucks?\\)\\>" -1000 nil r) ("$$$$" -1000 nil s))) 3. From "Per Abrahamsen" (("subject" ;; CAPS OF THE WORLD, UNITE ("^..[^a-z]+$" -1 nil R) ;; $$$ Make Money $$$ (Try work) ("$" -1 nil s) ;; I'm important! And I have exclamation marks to prove it! ("!" -1 nil s))) 4. From "heddy boubaker" I would like to contribute with mine. ( (read-only t) ("subject" ;; ALL CAPS SUBJECTS ("^\\([Rr][Ee]: +\\)?[^a-z]+$" -1 nil R) ;; $$$ Make Money $$$ ("$$" -10 nil s) ;; Empty subjects are worthless! ("^ *\\([(<]none[>)]\\|(no subject\\( given\\)?)\\)? *$" -10 nil r) ;; Sometimes interesting announces occur! ("ANN?OU?NC\\(E\\|ING\\)" +10 nil r) ;; Some people think they're on mailing lists ("\\(un\\)?sub?scribe" -100 nil r) ;; Stop Micro$oft NOW!! ("\\(m\\(icro\\)?[s$]\\(oft\\|lot\\)?-?\\)?wind?\\(ows\\|aube\\|oze\\)?[- ]*\\('?95\\|NT\\|3[.]1\\|32\\)" -1001 nil r) ;; I've nothing to buy ("\\(for\\|4\\)[- ]*sale" -100 nil r) ;; SELF-DISCIPLINED people ("\\[[^a-z0-9 \t\n][^a-z0-9 \t\n]\\]" +100 nil r) ) ("from" ;; To keep track of posters from my site (".dgac.fr" +1000 nil s)) ("followup" ;; Keep track of answers to my posts ("boubaker" +1000 nil s)) ("lines" ;; Some people have really nothing to say!! (1 -10 nil <=)) (mark -100) (expunge -1000) ) 5. From "Christopher Jones" The sample `all.SCORE' files from Per and boubaker could be augmented with: (("subject" ;; No junk mail please! ("please ignore" -500 nil s) ("test" -500 nil e)) ) 6. From "Brian Edmonds" Augment any of the above with a fast method of scoring down excessively cross posted articles. ("xref" ;; the more cross posting, the exponentially worse the article ("^xref: \\S-+ \\S-+ \\S-+ \\S-+" -1 nil r) ("^xref: \\S-+ \\S-+ \\S-+ \\S-+ \\S-+" -2 nil r) ("^xref: \\S-+ \\S-+ \\S-+ \\S-+ \\S-+ \\S-+" -4 nil r) ("^xref: \\S-+ \\S-+ \\S-+ \\S-+ \\S-+ \\S-+ \\S-+" -8 nil r) ("^xref: \\S-+ \\S-+ \\S-+ \\S-+ \\S-+ \\S-+ \\S-+ \\S-+" -16 nil r) ("^xref: \\S-+ \\S-+ \\S-+ \\S-+ \\S-+ \\S-+ \\S-+ \\S-+ \\S-+" -32 nil r) ("^xref: \\S-+ \\S-+ \\S-+ \\S-+ \\S-+ \\S-+ \\S-+ \\S-+ \\S-+ \\S-+" -64 nil r) ("^xref: \\S-+ \\S-+ \\S-+ \\S-+ \\S-+ \\S-+ \\S-+ \\S-+ \\S-+ \\S-+ \\S-+" -128 nil r) ("^xref: \\S-+ \\S-+ \\S-+ \\S-+ \\S-+ \\S-+ \\S-+ \\S-+ \\S-+ \\S-+ \\S-+ \\S-+" -256 nil r) ("^xref: \\S-+ \\S-+ \\S-+ \\S-+ \\S-+ \\S-+ \\S-+ \\S-+ \\S-+ \\S-+ \\S-+ \\S-+ \\S-+" -512 nil r)) * Q2.5 What do I use to yank-through when replying? You should probably reply and followup with `R' and `F', instead of `r' and `f', which solves your problem. But you could try something like: (defconst mail-yank-ignored-headers "^.*:" "Delete these headers from old message when it's inserted in a reply.") * Q2.6 I don't like the default WWW browser Now when choosing an URL Gnus starts up a W3 buffer, I would like it to always use Netscape (I don't browse in text-mode ;-). 1. Activate `Customize...' from the `Help' menu. 2. Scroll down to the `WWW Browser' field. 3. Click `mouse-2' on `WWW Browser'. 4. Select `Netscape' from the pop up menu. 5. Press `C-c C-c' If you are using XEmacs then to specify Netscape do (setq gnus-button-url 'gnus-netscape-open-url) * Q2.7 What, if any, relation is between "ask-server" and "(setq gnus-read-active-file 'some)"? In order for Gnus to show you the complete list of newsgroups, it will either have to either store the list locally, or ask the server to transmit the list. You enable the first with (setq gnus-save-killed-list t) and the second with (setq gnus-read-active-file t) If both are disabled, Gnus will not know what newsgroups exists. There is no option to get the list by casting a spell. * Q2.8 Moving between groups is slow. Per Abrahamsen writes: Do you call `define-key' or something like that in one of the summary mode hooks? This would force Emacs to recalculate the keyboard shortcuts. Removing the call should speed up `M-x gnus-summary-mode RET' by a couple of orders of magnitude. You can use (define-key gnus-summary-mode-map KEY COMMAND) in your `.gnus' instead.  File: gnus, Node: Reading News FAQ, Next: Reading Mail FAQ, Prev: Customization FAQ, Up: Frequently Asked Questions 10.7.3 Reading News ------------------- * Q3.1 How do I convert my kill files to score files? A kill-to-score translator was written by Ethan Bradford . It is available from `http://baugi.ifi.uio.no/~larsi/ding-various/gnus-kill-to-score.el'. * Q3.2 My news server has a lot of groups, and killing groups is painfully slow. Don't do that then. The best way to get rid of groups that should be dead is to edit your newsrc directly. This problem will be addressed in the near future. * Q3.3 How do I use an NNTP server with authentication? Put the following into your .gnus: (add-hook 'nntp-server-opened-hook 'nntp-send-authinfo) * Q3.4 Not reading the first article. How do I avoid reading the first article when a group is selected? 1. Use `RET' to select the group instead of `SPC'. 2. `(setq gnus-auto-select first nil)' 3. Luis Fernandes writes: This is what I use...customize as necessary... ;;; Don't auto-select first article if reading sources, or archives or ;;; jobs postings, etc. and just display the summary buffer (add-hook 'gnus-select-group-hook (function (lambda () (cond ((string-match "sources" gnus-newsgroup-name) (setq gnus-auto-select-first nil)) ((string-match "jobs" gnus-newsgroup-name) (setq gnus-auto-select-first nil)) ((string-match "comp\\.archives" gnus-newsgroup-name) (setq gnus-auto-select-first nil)) ((string-match "reviews" gnus-newsgroup-name) (setq gnus-auto-select-first nil)) ((string-match "announce" gnus-newsgroup-name) (setq gnus-auto-select-first nil)) ((string-match "binaries" gnus-newsgroup-name) (setq gnus-auto-select-first nil)) (t (setq gnus-auto-select-first t)))))) 4. Per Abrahamsen writes: Another possibility is to create an `all.binaries.all.SCORE' file like this: ((local (gnus-auto-select-first nil))) and insert (setq gnus-auto-select-first t) in your `.gnus'. * Q3.5 Why aren't BBDB known posters marked in the summary buffer? Brian Edmonds writes: Due to changes in Gnus 5.0, `bbdb-gnus.el' no longer marks known posters in the summary buffer. An updated version, `gnus-bbdb.el' is available at the locations listed below. This package also supports autofiling of incoming mail to folders specified in the BBDB. Extensive instructions are included as comments in the file. Send mail to `majordomo@edmonds.home.cs.ubc.ca' with the following line in the body of the message: _get misc gnus-bbdb.el_. Or get it from the World Wide Web: `http://www.cs.ubc.ca/spider/edmonds/gnus-bbdb.el'.  File: gnus, Node: Reading Mail FAQ, Prev: Reading News FAQ, Up: Frequently Asked Questions 10.7.4 Reading Mail ------------------- * Q4.1 What does the message "Buffer has changed on disk" mean in a mail group? Your filter program should not deliver mail directly to your folders, instead it should put the mail into spool files. Gnus will then move the mail safely from the spool files into the folders. This will eliminate the problem. Look it up in the manual, in the section entitled "Mail & Procmail". * Q4.2 How do you make articles un-expirable? I am using nnml to read news and have used `gnus-auto-expirable-newsgroups' to automagically expire articles in some groups (Gnus being one of them). Sometimes there are interesting articles in these groups that I want to keep. Is there any way of explicitly marking an article as un-expirable - that is mark it as read but not expirable? Use `u', `!', `d' or `M-u' in the summary buffer. You just remove the `E' mark by setting some other mark. It's not necessary to tick the articles. * Q4.3 How do I delete bogus nnml: groups? My problem is that I have various mail (nnml) groups generated while experimenting with Gnus. How do I remove them now? Setting the level to 9 does not help. Also `gnus-group-check-bogus-groups' does not recognize them. Removing mail groups is tricky at the moment. (It's on the to-do list, though.) You basically have to kill the groups in Gnus, shut down Gnus, edit the active file to exclude these groups, and probably remove the nnml directories that contained these groups as well. Then start Gnus back up again. * Q4.4 What happened to my new mail groups? I got new mail, but I have never seen the groups they should have been placed in. They are probably there, but as zombies. Press `A z' to list zombie groups, and then subscribe to the groups you want with `u'. This is all documented quite nicely in the user's manual. * Q4.5 Not scoring mail groups How do you _totally_ turn off scoring in mail groups? Use an nnbabyl:all.SCORE (or nnmh, or nnml, or whatever) file containing: ((adapt ignore) (local (gnus-use-scoring nil)) (exclude-files "all.SCORE"))  File: gnus, Node: Index, Next: Key Index, Prev: Appendices, Up: Top 11 Index ******** [index] * Menu: * *: Group Line Specification. (line 114) * .newsrc: Startup Files. (line 6) * 1153 digest: Document Groups. (line 28) * <: Customizing Threading. (line 6) * >: Customizing Threading. (line 6) * activating groups: Scanning New Messages. (line 20) * active file <1>: Terminology. (line 90) * active file: The Active File. (line 6) * adaptive scoring: Adaptive Scoring. (line 6) * adopting articles: Customizing Threading. (line 126) * ange-ftp: Group Information. (line 7) * archived messages: Archived Messages. (line 6) * article: Terminology. (line 45) * article backlog: Article Backlog. (line 6) * article buffer: The Article Buffer. (line 6) * article caching: Article Caching. (line 6) * article customization: Customizing Articles. (line 6) * article expiry: Expiring Mail. (line 6) * article hiding: Article Hiding. (line 6) * article marking: Marking Articles. (line 6) * article scrolling: Paging the Article. (line 6) * article threading: Threading. (line 6) * article ticking: Marking Articles. (line 6) * article washing: Article Washing. (line 6) * asynchronous article fetching: Asynchronous Fetching. (line 6) * authentification: NNTP. (line 23) * authinfo: NNTP. (line 23) * auto-expire: Group Parameters. (line 63) * auto-save: Auto Save. (line 6) * babyl: Document Groups. (line 9) * backend: Terminology. (line 27) * backlog: Article Backlog. (line 6) * bbb-summary-rate-article: Rating Articles. (line 15) * binary groups: Binary Groups. (line 6) * body: Terminology. (line 58) * bogus groups <1>: Terminology. (line 95) * bogus groups: Group Maintenance. (line 6) * bookmarks: Other Marks. (line 6) * bouncing mail: Summary Mail Commands. (line 33) * broken-reply-to: Group Parameters. (line 52) * browsing servers: Browse Foreign Server. (line 6) * bugs <1>: Troubleshooting. (line 27) * bugs: Compatibility. (line 53) * buttons <1>: Buttons. (line 6) * buttons: Article Buttons. (line 6) * byte-compilation: Compilation. (line 6) * caching: Article Caching. (line 6) * canceling articles: Canceling and Superseding. (line 6) * CancelMoose[tm]: NoCeM. (line 48) * characters in file names: Various Various. (line 29) * Chris Lewis: NoCeM. (line 44) * ClariNet Briefs: Foreign Groups. (line 58) * click: Buttons. (line 6) * compatibility: Compatibility. (line 6) * compilation: Compilation. (line 6) * composing mail: Summary Mail Commands. (line 6) * composing news: Summary Post Commands. (line 6) * contributors: Contributors. (line 6) * copy mail: Mail Group Commands. (line 32) * cross-posting: Exiting the Summary Buffer. (line 90) * crosspost: Splitting Mail. (line 45) * crosspost mail: Mail Group Commands. (line 36) * crossposts: Scoring Tips. (line 7) * customizing threading: Customizing Threading. (line 6) * daemons: Daemons. (line 6) * decoding articles: Decoding Articles. (line 6) * delete-file: Mail Backend Variables. (line 91) * deleting headers: Hiding Headers. (line 6) * deleting incoming files: Mail Backend Variables. (line 80) * demons: Daemons. (line 6) * describing groups: Group Information. (line 13) * digest: Document Groups. (line 28) * ding mailing list: Troubleshooting. (line 53) * directory groups: Directory Groups. (line 6) * disk space: Little Disk Space. (line 6) * display-time: Mode Lines. (line 13) * documentation group: Document Groups. (line 6) * dribble file: Auto Save. (line 6) * duplicate mails: Duplicates. (line 6) * dynamic IP addresses: NNTP. (line 68) * elm: Mail and Procmail. (line 6) * Emacs: Emacsen. (line 6) * Emacsen <1>: Emacs/XEmacs Code. (line 6) * Emacsen: Emacsen. (line 6) * exiting Gnus: Exiting Gnus. (line 6) * exiting groups: Exiting the Summary Buffer. (line 6) * expirable mark: Read Articles. (line 6) * expiry-wait: Group Parameters. (line 73) * fancy mail splitting: Fancy Mail Splitting. (line 6) * FAQ: Group Information. (line 7) * file commands: File Commands. (line 6) * file names: Various Various. (line 29) * first time usage: The First Time. (line 6) * follow up: Terminology. (line 23) * followup: Composing Messages. (line 6) * foreign: Terminology. (line 36) * foreign groups: Select Methods. (line 6) * foreign servers: Browse Foreign Server. (line 6) * formatting variables: Formatting Variables. (line 6) * forwarded messages: Document Groups. (line 22) * fuzzy article gathering: Customizing Threading. (line 51) * Gcc: Archived Messages. (line 24) * general customization: Customization. (line 6) * global score files: Global Score Files. (line 6) * gnu.emacs.gnus: Troubleshooting. (line 53) * gnus: Starting Up. (line 6) * gnus-activate-all-groups: Scanning New Messages. (line 20) * gnus-activate-foreign-newsgroups: Foreign Groups. (line 83) * gnus-activate-level: Group Levels. (line 63) * gnus-adaptive-file-suffix: Adaptive Scoring. (line 77) * gnus-add-configuration: Windows Configuration. (line 160) * gnus-after-getting-new-news-hook: Scanning New Messages. (line 29) * gnus-ancient-mark: Read Articles. (line 18) * gnus-apply-kill-file: Kill Files. (line 62) * gnus-apply-kill-file-unless-scored: Kill Files. (line 62) * gnus-apply-kill-hook: Kill Files. (line 62) * gnus-article-add-buttons: Article Washing. (line 67) * gnus-article-add-buttons-to-head: Article Washing. (line 70) * gnus-article-button-face: Article Buttons. (line 63) * gnus-article-date-lapsed: Article Date. (line 18) * gnus-article-date-local: Article Date. (line 15) * gnus-article-date-original: Article Date. (line 22) * gnus-article-date-ut: Article Date. (line 11) * gnus-article-de-quoted-unreadable: Article Washing. (line 47) * gnus-article-describe-briefly: Article Keymap. (line 34) * gnus-article-display-hook <1>: Hiding Headers. (line 66) * gnus-article-display-hook <2>: Hard Picons. (line 28) * gnus-article-display-hook <3>: Customizing Articles. (line 6) * gnus-article-display-hook: Misc Article. (line 17) * gnus-article-display-picons: Hard Picons. (line 34) * gnus-article-display-x-face: Article Washing. (line 50) * gnus-article-fill-cited-article: Article Washing. (line 37) * gnus-article-hide: Article Hiding. (line 10) * gnus-article-hide-boring-headers <1>: Article Hiding. (line 17) * gnus-article-hide-boring-headers: Hiding Headers. (line 66) * gnus-article-hide-citation: Article Hiding. (line 27) * gnus-article-hide-citation-in-followups: Article Hiding. (line 59) * gnus-article-hide-headers: Article Hiding. (line 13) * gnus-article-hide-pgp: Article Hiding. (line 24) * gnus-article-hide-signature: Article Hiding. (line 21) * gnus-article-highlight: Article Highlighting. (line 10) * gnus-article-highlight-citation: Article Highlighting. (line 23) * gnus-article-highlight-headers: Article Highlighting. (line 13) * gnus-article-highlight-signature: Article Highlighting. (line 66) * gnus-article-mail: Article Keymap. (line 26) * gnus-article-maybe-highlight: Customizing Articles. (line 10) * gnus-article-menu-hook: Highlighting and Menus. (line 83) * gnus-article-mode-hook: Misc Article. (line 23) * gnus-article-mode-line-format: Misc Article. (line 25) * gnus-article-mouse-face: Article Buttons. (line 66) * gnus-article-next-button: Article Keymap. (line 38) * gnus-article-next-page: Article Keymap. (line 15) * gnus-article-prepare-hook: Misc Article. (line 11) * gnus-article-prev-button: Article Keymap. (line 42) * gnus-article-prev-page: Article Keymap. (line 18) * gnus-article-refer-article: Article Keymap. (line 21) * gnus-article-remove-cr: Article Washing. (line 40) * gnus-article-remove-trailing-blank-lines: Article Washing. (line 43) * gnus-article-save-directory: Saving Articles. (line 101) * gnus-article-show-summary: Article Keymap. (line 30) * gnus-article-sort-by-author: Sorting. (line 51) * gnus-article-sort-by-date: Sorting. (line 51) * gnus-article-sort-by-number: Sorting. (line 51) * gnus-article-sort-by-score: Sorting. (line 51) * gnus-article-sort-by-subject: Sorting. (line 51) * gnus-article-sort-functions: Sorting. (line 51) * gnus-article-treat-overstrike: Article Washing. (line 34) * gnus-article-x-face-command: Article Washing. (line 50) * gnus-article-x-face-too-ugly: Article Washing. (line 50) * gnus-asynchronous: Asynchronous Fetching. (line 35) * gnus-asynchronous-article-function: Asynchronous Fetching. (line 45) * gnus-auto-center-summary: Summary Maneuvering. (line 62) * gnus-auto-expirable-newsgroups: Expiring Mail. (line 27) * gnus-auto-extend-newsgroup: Choosing Articles. (line 60) * gnus-auto-select-first: Selecting a Group. (line 52) * gnus-auto-select-next: Summary Maneuvering. (line 37) * gnus-auto-select-same: Summary Maneuvering. (line 52) * gnus-auto-subscribed-groups: New Groups. (line 66) * gnus-background-mode: Highlighting and Menus. (line 73) * gnus-binary-mode: Binary Groups. (line 6) * gnus-binary-mode-hook: Binary Groups. (line 15) * gnus-binary-show-article: Binary Groups. (line 12) * gnus-boring-article-headers: Hiding Headers. (line 66) * gnus-break-pages: Misc Article. (line 28) * gnus-browse-describe-briefly: Browse Foreign Server. (line 47) * gnus-browse-exit: Browse Foreign Server. (line 44) * gnus-browse-menu-hook: Highlighting and Menus. (line 95) * gnus-browse-mode: Browse Foreign Server. (line 11) * gnus-browse-read-group: Browse Foreign Server. (line 32) * gnus-browse-select-group: Browse Foreign Server. (line 36) * gnus-browse-unsubscribe-current-group: Browse Foreign Server. (line 39) * gnus-buffer-configuration: Windows Configuration. (line 12) * gnus-bug <1>: Compatibility. (line 53) * gnus-bug: Troubleshooting. (line 27) * gnus-build-sparse-threads: Customizing Threading. (line 26) * gnus-button-alist: Article Buttons. (line 16) * gnus-button-url-regexp: Article Buttons. (line 59) * gnus-cache-active-file: Article Caching. (line 51) * gnus-cache-directory: Article Caching. (line 15) * gnus-cache-enter-article: Persistent Articles. (line 22) * gnus-cache-enter-articles: Article Caching. (line 29) * gnus-cache-generate-active: Article Caching. (line 51) * gnus-cache-generate-nov-databases: Article Caching. (line 51) * gnus-cache-remove-article: Persistent Articles. (line 25) * gnus-cache-remove-articles: Article Caching. (line 29) * gnus-cached-mark: Other Marks. (line 19) * gnus-canceled-mark: Read Articles. (line 34) * gnus-carpal: Buttons. (line 14) * gnus-carpal-browse-buffer-buttons: Buttons. (line 37) * gnus-carpal-button-face: Buttons. (line 22) * gnus-carpal-group-buffer-buttons: Buttons. (line 28) * gnus-carpal-header-face: Buttons. (line 25) * gnus-carpal-mode-hook: Buttons. (line 19) * gnus-carpal-server-buffer-buttons: Buttons. (line 34) * gnus-carpal-summary-buffer-buttons: Buttons. (line 31) * gnus-catchup-mark: Read Articles. (line 31) * gnus-check-bogus-newsgroups: Startup Variables. (line 15) * gnus-check-new-newsgroups: New Groups. (line 76) * gnus-cite-attribution-face: Article Highlighting. (line 61) * gnus-cite-attribution-prefix: Article Highlighting. (line 55) * gnus-cite-attribution-suffix: Article Highlighting. (line 58) * gnus-cite-face-list: Article Highlighting. (line 39) * gnus-cite-hide-absolute: Article Hiding. (line 35) * gnus-cite-hide-percentage: Article Hiding. (line 31) * gnus-cite-max-prefix: Article Highlighting. (line 36) * gnus-cite-minimum-match-count: Article Highlighting. (line 51) * gnus-cite-parse-max-size: Article Highlighting. (line 27) * gnus-cite-prefix-regexp: Article Highlighting. (line 32) * gnus-cited-lines-visible: Article Hiding. (line 54) * gnus-cited-text-button-line-format: Article Hiding. (line 39) * gnus-compile: Compilation. (line 6) * gnus-configure-frame: Windows Configuration. (line 112) * gnus-dead-summary-mode: Exiting the Summary Buffer. (line 57) * gnus-default-adaptive-score-alist: Adaptive Scoring. (line 15) * gnus-default-article-saver: Saving Articles. (line 65) * gnus-default-subscribed-newsgroups: The First Time. (line 9) * gnus-del-mark: Read Articles. (line 9) * gnus-demon-add-disconnection: Daemons. (line 58) * gnus-demon-add-handler: Daemons. (line 56) * gnus-demon-add-nocem: Daemons. (line 58) * gnus-demon-add-scanmail: Daemons. (line 58) * gnus-demon-cancel: Daemons. (line 63) * gnus-demon-handlers: Daemons. (line 63) * gnus-demon-init: Daemons. (line 63) * gnus-demon-timestep: Daemons. (line 46) * gnus-display-type: Highlighting and Menus. (line 66) * gnus-dormant-mark: Unread Articles. (line 17) * gnus-dribble-directory: Auto Save. (line 19) * gnus-empty-thread-mark: Other Marks. (line 26) * gnus-exit-gnus-hook: Exiting Gnus. (line 19) * gnus-exit-group-hook: Exiting the Summary Buffer. (line 55) * gnus-expert-user: Interactive. (line 14) * gnus-expirable-mark: Read Articles. (line 49) * gnus-extract-address-components: Summary Buffer Format. (line 12) * gnus-fetch-group: Fetching a Group. (line 6) * gnus-fetch-old-headers: Customizing Threading. (line 13) * gnus-file-save-name: Saving Articles. (line 80) * gnus-find-new-newsgroups: Group Maintenance. (line 11) * gnus-folder-save-name: Saving Articles. (line 90) * gnus-Folder-save-name: Saving Articles. (line 90) * gnus-folder-save-name: Saving Articles. (line 90) * gnus-gather-threads-by-references: Customizing Threading. (line 108) * gnus-gather-threads-by-subject: Customizing Threading. (line 104) * gnus-generate-horizontal-tree: Tree Display. (line 76) * gnus-generate-tree-function: Tree Display. (line 76) * gnus-generate-vertical-tree: Tree Display. (line 76) * gnus-get-new-news-hook: Scanning New Messages. (line 27) * gnus-global-score-files: Global Score Files. (line 14) * gnus-goto-next-group-when-activating: Scanning New Messages. (line 14) * gnus-group-add-to-virtual: Foreign Groups. (line 77) * gnus-group-apropos: Listing Groups. (line 53) * gnus-group-archive-directory: Foreign Groups. (line 41) * gnus-group-best-unread-group: Group Maneuvering. (line 40) * gnus-group-brew-soup: SOUP Commands. (line 7) * gnus-group-browse-foreign-server <1>: Browse Foreign Server. (line 7) * gnus-group-browse-foreign-server: Finding the News. (line 40) * gnus-group-catchup-current: Selecting a Group. (line 36) * gnus-group-catchup-current-all: Selecting a Group. (line 41) * gnus-group-catchup-group-hook: Selecting a Group. (line 36) * gnus-group-check-bogus-groups: Group Maintenance. (line 7) * gnus-group-default-list-level: Group Levels. (line 51) * gnus-group-delete-group: Foreign Groups. (line 66) * gnus-group-describe-all-groups: Group Information. (line 17) * gnus-group-describe-briefly: Group Information. (line 24) * gnus-group-describe-group: Group Information. (line 13) * gnus-group-description-apropos: Listing Groups. (line 57) * gnus-group-edit-global-kill: Kill Files. (line 46) * gnus-group-edit-group: Foreign Groups. (line 30) * gnus-group-edit-group-method: Foreign Groups. (line 22) * gnus-group-edit-group-parameters: Foreign Groups. (line 26) * gnus-group-edit-local-kill: Kill Files. (line 43) * gnus-group-enter-directory: Foreign Groups. (line 54) * gnus-group-enter-server-mode: Misc Group Stuff. (line 13) * gnus-group-exit: Exiting Gnus. (line 14) * gnus-group-expire-all-groups: Group Maintenance. (line 20) * gnus-group-expire-articles: Group Maintenance. (line 16) * gnus-group-faq-directory: Summary Group Information. (line 7) * gnus-group-fetch-faq: Group Information. (line 7) * gnus-group-first-unread-group: Group Maneuvering. (line 44) * gnus-group-get-new-news: Scanning New Messages. (line 7) * gnus-group-get-new-news-this-group: Scanning New Messages. (line 14) * gnus-group-goto-unread: Group Maneuvering. (line 47) * gnus-group-highlight: Group Highlighting. (line 6) * gnus-group-highlight-line: Group Highlighting. (line 59) * gnus-group-jump-to-group: Group Maneuvering. (line 35) * gnus-group-kill-all-zombies: Subscription Commands. (line 35) * gnus-group-kill-group: Subscription Commands. (line 19) * gnus-group-kill-level: Subscription Commands. (line 38) * gnus-group-kill-region: Subscription Commands. (line 32) * gnus-group-line-format: Group Line Specification. (line 21) * gnus-group-list-active: Listing Groups. (line 46) * gnus-group-list-all-groups: Listing Groups. (line 18) * gnus-group-list-all-matching: Listing Groups. (line 43) * gnus-group-list-groups: Listing Groups. (line 10) * gnus-group-list-inactive-groups: Group Levels. (line 55) * gnus-group-list-killed: Listing Groups. (line 30) * gnus-group-list-level: Listing Groups. (line 25) * gnus-group-list-matching: Listing Groups. (line 39) * gnus-group-list-zombies: Listing Groups. (line 36) * gnus-group-mail: Misc Group Stuff. (line 21) * gnus-group-make-archive-group: Foreign Groups. (line 41) * gnus-group-make-directory-group: Foreign Groups. (line 34) * gnus-group-make-doc-group: Foreign Groups. (line 58) * gnus-group-make-empty-virtual: Foreign Groups. (line 73) * gnus-group-make-group: Foreign Groups. (line 11) * gnus-group-make-help-group: Foreign Groups. (line 38) * gnus-group-make-kiboze-group: Foreign Groups. (line 48) * gnus-group-mark-buffer: Marking Groups. (line 30) * gnus-group-mark-group: Marking Groups. (line 17) * gnus-group-mark-regexp: Marking Groups. (line 33) * gnus-group-mark-region: Marking Groups. (line 27) * gnus-group-menu-hook: Highlighting and Menus. (line 86) * gnus-group-mode-hook: Misc Group Stuff. (line 27) * gnus-group-mode-line-format: Group Modeline Specification. (line 6) * gnus-group-next-group <1>: Group Maneuvering. (line 19) * gnus-group-next-group: Browse Foreign Server. (line 26) * gnus-group-next-unread-group: Group Maneuvering. (line 10) * gnus-group-next-unread-group-same-level: Group Maneuvering. (line 25) * gnus-group-post-news: Misc Group Stuff. (line 17) * gnus-group-prepare-hook: Misc Group Stuff. (line 31) * gnus-group-prev-group <1>: Browse Foreign Server. (line 29) * gnus-group-prev-group: Group Maneuvering. (line 22) * gnus-group-prev-unread-group: Group Maneuvering. (line 15) * gnus-group-prev-unread-group-same-level: Group Maneuvering. (line 29) * gnus-group-quick-select-group: Selecting a Group. (line 24) * gnus-group-quit: Exiting Gnus. (line 17) * gnus-group-read-group: Selecting a Group. (line 7) * gnus-group-read-init-file: File Commands. (line 7) * gnus-group-recent-archive-directory: Foreign Groups. (line 41) * gnus-group-rename-group: Foreign Groups. (line 16) * gnus-group-restart: Scanning New Messages. (line 24) * gnus-group-save-newsrc: File Commands. (line 11) * gnus-group-select-group: Selecting a Group. (line 17) * gnus-group-set-current-level: Group Levels. (line 16) * gnus-group-sort-by-alphabet: Sorting Groups. (line 11) * gnus-group-sort-by-level: Sorting Groups. (line 14) * gnus-group-sort-by-method: Sorting Groups. (line 27) * gnus-group-sort-by-rank: Sorting Groups. (line 20) * gnus-group-sort-by-score: Sorting Groups. (line 17) * gnus-group-sort-by-unread: Sorting Groups. (line 24) * gnus-group-sort-function: Sorting Groups. (line 6) * gnus-group-sort-groups: Sorting Groups. (line 6) * gnus-group-sort-groups-by-alphabet: Sorting Groups. (line 38) * gnus-group-sort-groups-by-level: Sorting Groups. (line 46) * gnus-group-sort-groups-by-method: Sorting Groups. (line 58) * gnus-group-sort-groups-by-rank: Sorting Groups. (line 54) * gnus-group-sort-groups-by-score: Sorting Groups. (line 50) * gnus-group-sort-groups-by-unread: Sorting Groups. (line 42) * gnus-group-suspend: Exiting Gnus. (line 9) * gnus-group-transpose-groups: Subscription Commands. (line 26) * gnus-group-uncollapsed-levels: Group Line Specification. (line 101) * gnus-group-universal-argument: Marking Groups. (line 38) * gnus-group-unmark-all-groups: Marking Groups. (line 24) * gnus-group-unmark-group: Marking Groups. (line 21) * gnus-group-unsubscribe-current-group: Subscription Commands. (line 8) * gnus-group-unsubscribe-group: Subscription Commands. (line 13) * gnus-group-update-hook: Group Highlighting. (line 59) * gnus-group-use-permanent-levels: Group Levels. (line 59) * gnus-group-visible-select-group: Selecting a Group. (line 31) * gnus-group-yank-group: Subscription Commands. (line 23) * gnus-grouplens-override-scoring: Displaying Predictions. (line 12) * gnus-header-button-alist: Article Buttons. (line 50) * gnus-header-face-alist: Article Highlighting. (line 13) * gnus-hidden-properties: Various Various. (line 41) * gnus-ignored-headers: Hiding Headers. (line 34) * gnus-ignored-newsgroups: The Active File. (line 10) * gnus-inews-article-hook: Followups To Yourself. (line 21) * gnus-info-find-node <1>: Summary Group Information. (line 25) * gnus-info-find-node: Group Information. (line 27) * gnus-inhibit-startup-message: Startup Variables. (line 24) * gnus-init-file: File Commands. (line 7) * gnus-insert-pseudo-articles: Viewing Files. (line 32) * gnus-interactive-catchup: Interactive. (line 19) * gnus-interactive-exit: Interactive. (line 23) * gnus-jog-cache: Article Caching. (line 37) * gnus-keep-backlog: Article Backlog. (line 15) * gnus-keep-same-level: Group Levels. (line 44) * gnus-kill-file-mark: Read Articles. (line 25) * gnus-kill-file-mode-hook: Kill Files. (line 70) * gnus-kill-file-name: Kill Files. (line 51) * gnus-kill-files-directory: Score Variables. (line 20) * gnus-kill-killed: Score Variables. (line 11) * gnus-kill-save-kill-file: Kill Files. (line 57) * gnus-kill-summary-on-exit: Exiting the Summary Buffer. (line 57) * gnus-killed-mark: Read Articles. (line 22) * gnus-large-newsgroup: Selecting a Group. (line 44) * gnus-level-default-subscribed: Group Levels. (line 38) * gnus-level-default-unsubscribed: Group Levels. (line 38) * gnus-level-killed: Group Levels. (line 20) * gnus-level-subscribed: Group Levels. (line 20) * gnus-level-unsubscribed: Group Levels. (line 20) * gnus-level-zombie: Group Levels. (line 20) * gnus-list-groups-with-ticked-articles: Listing Groups. (line 66) * gnus-load-hook: Startup Variables. (line 7) * gnus-low-score-mark: Read Articles. (line 28) * gnus-mail-save-name: Saving Articles. (line 75) * gnus-mailing-list-groups: Mail and Post. (line 10) * gnus-mark-article-hook: Choosing Articles. (line 70) * gnus-message-archive-group: Archived Messages. (line 24) * gnus-message-archive-method: Archived Messages. (line 11) * gnus-mode-non-string-length: Mode Lines. (line 13) * gnus-mouse-face: Highlighting and Menus. (line 62) * gnus-move-split-methods: Mail Group Commands. (line 61) * gnus-nntp-server: Finding the News. (line 30) * gnus-nntpserver-file: Finding the News. (line 23) * gnus-no-groups-message: Startup Variables. (line 29) * gnus-no-server: The Server is Down. (line 18) * gnus-nocem-directory: NoCeM. (line 64) * gnus-nocem-expiry-wait: NoCeM. (line 68) * gnus-nocem-groups: NoCeM. (line 31) * gnus-nocem-issuers: NoCeM. (line 35) * gnus-not-empty-thread-mark: Other Marks. (line 26) * gnus-nov-is-evil: Exiting the Summary Buffer. (line 107) * gnus-novice-user: Interactive. (line 7) * gnus-numeric-save-name: Saving Articles. (line 113) * gnus-Numeric-save-name: Saving Articles. (line 110) * gnus-options-not-subscribe: New Groups. (line 59) * gnus-options-subscribe: New Groups. (line 59) * gnus-other-frame: Starting Up. (line 10) * gnus-outgoing-message-group: Archived Messages. (line 88) * gnus-page-delimiter: Misc Article. (line 37) * gnus-parse-headers-hook: Various Various. (line 46) * gnus-permanently-visible-groups <1>: Listing Groups. (line 61) * gnus-permanently-visible-groups: Misc Group Stuff. (line 36) * gnus-pick-display-summary: Pick and Read. (line 53) * gnus-pick-mode: Pick and Read. (line 11) * gnus-pick-mode-hook: Pick and Read. (line 63) * gnus-pick-start-reading: Pick and Read. (line 53) * gnus-picons-buffer: Picon Configuration. (line 39) * gnus-picons-convert-x-face <1>: Picon Configuration. (line 29) * gnus-picons-convert-x-face: Picon Requirements. (line 12) * gnus-picons-database <1>: Picon Basics. (line 21) * gnus-picons-database: Picon Configuration. (line 11) * gnus-picons-display-where: Hard Picons. (line 13) * gnus-picons-domain-directories: Picon Configuration. (line 24) * gnus-picons-news-directory: Picon Configuration. (line 16) * gnus-picons-user-directories: Picon Configuration. (line 20) * gnus-picons-x-face-file-name: Picon Configuration. (line 35) * gnus-plain-save-name: Saving Articles. (line 70) * gnus-Plain-save-name: Saving Articles. (line 116) * gnus-plain-save-name: Saving Articles. (line 119) * gnus-post-method: Posting Server. (line 11) * gnus-process-mark: Other Marks. (line 30) * gnus-prompt-before-saving: Saving Articles. (line 53) * gnus-read-active-file: The Active File. (line 17) * gnus-read-mark: Read Articles. (line 14) * gnus-refer-article-method: Finding the Parent. (line 24) * gnus-replied-mark: Other Marks. (line 15) * gnus-rmail-save-name: Saving Articles. (line 70) * gnus-save-all-headers: Saving Articles. (line 12) * gnus-save-killed-list: Startup Files. (line 27) * gnus-save-newsrc-file: Startup Files. (line 21) * gnus-save-newsrc-hook: Startup Files. (line 39) * gnus-save-quick-newsrc-hook: Startup Files. (line 39) * gnus-save-score: Score Variables. (line 39) * gnus-save-standard-newsrc-hook: Startup Files. (line 39) * gnus-saved-headers: Saving Articles. (line 15) * gnus-saved-mark: Other Marks. (line 22) * gnus-score-after-write-file-function: Score Variables. (line 109) * gnus-score-below-mark: Score Variables. (line 58) * gnus-score-change-score-file: Summary Score Commands. (line 41) * gnus-score-customize: Summary Score Commands. (line 58) * gnus-score-edit-current-scores: Summary Score Commands. (line 45) * gnus-score-edit-done: Score File Editing. (line 14) * gnus-score-edit-file: Summary Score Commands. (line 50) * gnus-score-edit-insert-date: Score File Editing. (line 18) * gnus-score-exact-adapt-limit: Adaptive Scoring. (line 81) * gnus-score-expiry-days: Score Variables. (line 96) * gnus-score-file-suffix: Score Variables. (line 25) * gnus-score-find-bnews: Score Variables. (line 70) * gnus-score-find-hierarchical: Score Variables. (line 82) * gnus-score-find-score-files-function: Score Variables. (line 62) * gnus-score-find-single: Score Variables. (line 67) * gnus-score-find-trace: Summary Score Commands. (line 27) * gnus-score-flush-cache <1>: Group Score Commands. (line 9) * gnus-score-flush-cache: Summary Score Commands. (line 54) * gnus-score-followup-article: Followups To Yourself. (line 14) * gnus-score-followup-thread: Followups To Yourself. (line 18) * gnus-score-interactive-default-score: Score Variables. (line 44) * gnus-score-menu-hook: Highlighting and Menus. (line 98) * gnus-score-mimic-keymap: Summary Score Commands. (line 182) * gnus-score-mode-hook: Score File Editing. (line 31) * gnus-score-over-mark: Score Variables. (line 54) * gnus-score-pretty-print: Score File Editing. (line 23) * gnus-score-search-global-directories: Global Score Files. (line 27) * gnus-score-set-expunge-below: Summary Score Commands. (line 76) * gnus-score-set-mark-below: Summary Score Commands. (line 72) * gnus-score-uncacheable-files: Score Variables. (line 29) * gnus-secondary-select-methods: Finding the News. (line 47) * gnus-secondary-servers: Finding the News. (line 34) * gnus-select-article-hook: Choosing Articles. (line 66) * gnus-select-group-hook: Selecting a Group. (line 52) * gnus-select-method: Finding the News. (line 6) * gnus-selected-tree-face: Tree Display. (line 22) * gnus-sent-message-ids-file: Post. (line 9) * gnus-sent-message-ids-length: Post. (line 19) * gnus-server-add-server: Server Commands. (line 7) * gnus-server-close-server: Unavailable Servers. (line 32) * gnus-server-copy-server: Server Commands. (line 25) * gnus-server-deny-server: Unavailable Servers. (line 36) * gnus-server-edit-server: Server Commands. (line 10) * gnus-server-exit: Server Commands. (line 16) * gnus-server-kill-server: Server Commands. (line 19) * gnus-server-line-format: Server Buffer Format. (line 6) * gnus-server-list-servers: Server Commands. (line 28) * gnus-server-menu-hook: Highlighting and Menus. (line 92) * gnus-server-mode-hook: The Server Buffer. (line 38) * gnus-server-mode-line-format: Server Buffer Format. (line 22) * gnus-server-open-server: Unavailable Servers. (line 28) * gnus-server-read-server: Server Commands. (line 13) * gnus-server-remove-denials: Unavailable Servers. (line 39) * gnus-server-yank-server: Server Commands. (line 22) * gnus-show-all-headers: Hiding Headers. (line 9) * gnus-show-mime: Using MIME. (line 16) * gnus-show-mime-method: Using MIME. (line 16) * gnus-show-threads: Customizing Threading. (line 7) * gnus-signature-face: Article Highlighting. (line 66) * gnus-signature-limit: Article Hiding. (line 73) * gnus-signature-separator: Article Highlighting. (line 66) * gnus-simplify-ignored-prefixes: Customizing Threading. (line 60) * gnus-simplify-subject-fuzzy-regexp: Customizing Threading. (line 55) * gnus-single-article-buffer: Misc Article. (line 7) * gnus-sorted-header-list: Hiding Headers. (line 52) * gnus-soup-add-article: SOUP Commands. (line 25) * gnus-soup-directory: SOUP Commands. (line 34) * gnus-soup-pack-packet: SOUP Commands. (line 19) * gnus-soup-packer: SOUP Commands. (line 46) * gnus-soup-packet-directory: SOUP Commands. (line 54) * gnus-soup-packet-regexp: SOUP Commands. (line 57) * gnus-soup-prefix-file: SOUP Commands. (line 42) * gnus-soup-replies-directory: SOUP Commands. (line 38) * gnus-soup-save-areas: SOUP Commands. (line 12) * gnus-soup-send-replies: SOUP Commands. (line 15) * gnus-soup-unpacker: SOUP Commands. (line 50) * gnus-souped-mark: Read Articles. (line 37) * gnus-sparse-mark: Read Articles. (line 40) * gnus-split-methods: Saving Articles. (line 121) * gnus-startup-file: Startup Files. (line 35) * gnus-startup-hook: Startup Variables. (line 12) * gnus-strict-mime: Using MIME. (line 16) * gnus-subscribe-alphabetically: New Groups. (line 21) * gnus-subscribe-hierarchical-interactive: New Groups. (line 34) * gnus-subscribe-hierarchically: New Groups. (line 24) * gnus-subscribe-interactively: New Groups. (line 27) * gnus-subscribe-killed: New Groups. (line 31) * gnus-subscribe-newsgroup-method: New Groups. (line 6) * gnus-subscribe-options-newsgroup-method: New Groups. (line 50) * gnus-subscribe-randomly: New Groups. (line 18) * gnus-subscribe-zombies: New Groups. (line 13) * gnus-summary-beginning-of-article: Paging the Article. (line 28) * gnus-summary-best-unread-article: Choosing Articles. (line 44) * gnus-summary-bubble-group: Group Score. (line 19) * gnus-summary-caesar-message: Article Washing. (line 18) * gnus-summary-cancel-article: Canceling and Superseding. (line 11) * gnus-summary-catchup: Setting Marks. (line 34) * gnus-summary-catchup-all: Setting Marks. (line 38) * gnus-summary-catchup-all-and-exit: Exiting the Summary Buffer. (line 29) * gnus-summary-catchup-and-exit: Exiting the Summary Buffer. (line 25) * gnus-summary-catchup-and-goto-next-group: Exiting the Summary Buffer. (line 33) * gnus-summary-catchup-to-here: Setting Marks. (line 42) * gnus-summary-check-current: Summary Maneuvering. (line 57) * gnus-summary-clear-above: Setting Marks. (line 72) * gnus-summary-clear-mark-forward: Setting Marks. (line 55) * gnus-summary-copy-article: Mail Group Commands. (line 32) * gnus-summary-crosspost-article: Mail Group Commands. (line 36) * gnus-summary-current-score: Summary Score Commands. (line 23) * gnus-summary-default-score: Score Variables. (line 51) * gnus-summary-delete-article: Mail Group Commands. (line 23) * gnus-summary-describe-briefly: Summary Group Information. (line 21) * gnus-summary-describe-group: Summary Group Information. (line 16) * gnus-summary-down-thread: Thread Commands. (line 65) * gnus-summary-dummy-line-format: Customizing Threading. (line 134) * gnus-summary-edit-article: Mail Group Commands. (line 51) * gnus-summary-edit-global-kill: Kill Files. (line 38) * gnus-summary-edit-local-kill: Kill Files. (line 35) * gnus-summary-end-of-article: Paging the Article. (line 33) * gnus-summary-enter-digest-group: Really Various Summary Commands. (line 7) * gnus-summary-execute-command: Searching for Articles. (line 15) * gnus-summary-exit: Exiting the Summary Buffer. (line 11) * gnus-summary-exit-hook: Exiting the Summary Buffer. (line 11) * gnus-summary-exit-no-update: Exiting the Summary Buffer. (line 20) * gnus-summary-expand-window: Really Various Summary Commands. (line 21) * gnus-summary-expire-articles: Mail Group Commands. (line 13) * gnus-summary-expire-articles-now: Mail Group Commands. (line 17) * gnus-summary-fetch-faq: Summary Group Information. (line 7) * gnus-summary-first-unread-article: Choosing Articles. (line 39) * gnus-summary-followup: Summary Post Commands. (line 14) * gnus-summary-followup-with-original: Summary Post Commands. (line 18) * gnus-summary-gather-exclude-subject: Customizing Threading. (line 86) * gnus-summary-gather-subject-limit: Customizing Threading. (line 40) * gnus-summary-generate-hook: Various Summary Stuff. (line 15) * gnus-summary-goto-article: Summary Maneuvering. (line 23) * gnus-summary-goto-last-article: Choosing Articles. (line 49) * gnus-summary-goto-subject: Summary Maneuvering. (line 27) * gnus-summary-goto-unread <1>: Setting Marks. (line 84) * gnus-summary-goto-unread: Process/Prefix. (line 32) * gnus-summary-hide-all-threads: Thread Commands. (line 43) * gnus-summary-hide-thread: Thread Commands. (line 37) * gnus-summary-highlight: Summary Highlighting. (line 20) * gnus-summary-import-article: Mail Group Commands. (line 42) * gnus-summary-isearch-article: Paging the Article. (line 36) * gnus-summary-kill-below: Setting Marks. (line 50) * gnus-summary-kill-same-subject: Setting Marks. (line 30) * gnus-summary-kill-same-subject-and-select: Setting Marks. (line 24) * gnus-summary-kill-thread: Thread Commands. (line 8) * gnus-summary-limit-exclude-childless-dormant: Limiting. (line 58) * gnus-summary-limit-exclude-dormant: Limiting. (line 55) * gnus-summary-limit-include-dormant: Limiting. (line 51) * gnus-summary-limit-include-expunged: Limiting. (line 47) * gnus-summary-limit-mark-excluded-as-read: Limiting. (line 62) * gnus-summary-limit-to-articles: Limiting. (line 32) * gnus-summary-limit-to-author: Limiting. (line 17) * gnus-summary-limit-to-marks: Limiting. (line 28) * gnus-summary-limit-to-score: Limiting. (line 42) * gnus-summary-limit-to-subject: Limiting. (line 13) * gnus-summary-limit-to-unread: Limiting. (line 22) * gnus-summary-line-format: Summary Buffer Lines. (line 6) * gnus-summary-lower-score: Summary Score Commands. (line 66) * gnus-summary-lower-thread: Thread Commands. (line 15) * gnus-summary-mail-forward: Summary Mail Commands. (line 20) * gnus-summary-mail-other-window: Summary Mail Commands. (line 29) * gnus-summary-make-false-root: Customizing Threading. (line 117) * gnus-summary-mark-above: Setting Marks. (line 80) * gnus-summary-mark-as-dormant: Setting Marks. (line 14) * gnus-summary-mark-as-expirable: Setting Marks. (line 60) * gnus-summary-mark-as-processable <1>: Setting Process Marks. (line 8) * gnus-summary-mark-as-processable: Pick and Read. (line 20) * gnus-summary-mark-as-read-forward: Setting Marks. (line 19) * gnus-summary-mark-below: Scoring. (line 11) * gnus-summary-mark-read-and-unread-as-read: Choosing Articles. (line 70) * gnus-summary-mark-region-as-read: Setting Marks. (line 46) * gnus-summary-mark-unread-as-read: Choosing Articles. (line 70) * gnus-summary-menu-hook: Highlighting and Menus. (line 89) * gnus-summary-mode-hook: Various Summary Stuff. (line 12) * gnus-summary-mode-line-format: Summary Buffer Mode Line. (line 6) * gnus-summary-move-article: Mail Group Commands. (line 28) * gnus-summary-next-article: Choosing Articles. (line 23) * gnus-summary-next-group: Exiting the Summary Buffer. (line 48) * gnus-summary-next-page <1>: Choosing Articles. (line 10) * gnus-summary-next-page: Paging the Article. (line 7) * gnus-summary-next-same-subject: Choosing Articles. (line 30) * gnus-summary-next-thread: Thread Commands. (line 59) * gnus-summary-next-unread-article: Choosing Articles. (line 15) * gnus-summary-next-unread-subject: Summary Maneuvering. (line 13) * gnus-summary-pipe-output: Saving Articles. (line 49) * gnus-summary-pop-article: Choosing Articles. (line 52) * gnus-summary-pop-limit: Limiting. (line 37) * gnus-summary-post-forward: Summary Mail Commands. (line 24) * gnus-summary-post-news: Summary Post Commands. (line 10) * gnus-summary-prepare-exit-hook: Exiting the Summary Buffer. (line 11) * gnus-summary-prepare-hook: Various Summary Stuff. (line 22) * gnus-summary-prev-article: Choosing Articles. (line 27) * gnus-summary-prev-group: Exiting the Summary Buffer. (line 52) * gnus-summary-prev-page: Paging the Article. (line 12) * gnus-summary-prev-same-subject: Choosing Articles. (line 34) * gnus-summary-prev-thread: Thread Commands. (line 62) * gnus-summary-prev-unread-article: Choosing Articles. (line 19) * gnus-summary-prev-unread-subject: Summary Maneuvering. (line 18) * gnus-summary-raise-score: Summary Score Commands. (line 62) * gnus-summary-raise-thread: Thread Commands. (line 19) * gnus-summary-refer-article: Finding the Parent. (line 18) * gnus-summary-refer-parent-article: Finding the Parent. (line 6) * gnus-summary-refer-references: Finding the Parent. (line 14) * gnus-summary-remove-bookmark: Setting Marks. (line 68) * gnus-summary-reparent-thread: Thread Commands. (line 51) * gnus-summary-reply: Summary Mail Commands. (line 10) * gnus-summary-reply-with-original: Summary Mail Commands. (line 15) * gnus-summary-rescan-group: Exiting the Summary Buffer. (line 43) * gnus-summary-rescore: Summary Score Commands. (line 31) * gnus-summary-reselect-current-group: Exiting the Summary Buffer. (line 37) * gnus-summary-resend-bounced-mail: Summary Mail Commands. (line 33) * gnus-summary-resend-message: Summary Mail Commands. (line 44) * gnus-summary-respool-article: Mail Group Commands. (line 47) * gnus-summary-respool-query: Mail Group Commands. (line 56) * gnus-summary-rethread-current: Thread Commands. (line 46) * gnus-summary-same-subject: Summary Buffer Format. (line 21) * gnus-summary-save-article: Saving Articles. (line 21) * gnus-summary-save-article-body-file: Saving Articles. (line 37) * gnus-summary-save-article-file: Saving Articles. (line 33) * gnus-summary-save-article-folder: Saving Articles. (line 41) * gnus-summary-save-article-mail: Saving Articles. (line 25) * gnus-summary-save-article-rmail: Saving Articles. (line 29) * gnus-summary-save-article-vm: Saving Articles. (line 45) * gnus-summary-save-body-in-file: Saving Articles. (line 85) * gnus-summary-save-in-file: Saving Articles. (line 80) * gnus-summary-save-in-folder: Saving Articles. (line 90) * gnus-summary-save-in-mail: Saving Articles. (line 75) * gnus-summary-save-in-rmail: Saving Articles. (line 70) * gnus-summary-save-in-vm: Saving Articles. (line 98) * gnus-summary-score-entry: Summary Score Commands. (line 37) * gnus-summary-scroll-up: Paging the Article. (line 16) * gnus-summary-search-article-backward: Searching for Articles. (line 11) * gnus-summary-search-article-forward: Searching for Articles. (line 7) * gnus-summary-selected-face: Summary Highlighting. (line 16) * gnus-summary-set-bookmark: Setting Marks. (line 64) * gnus-summary-set-score: Summary Score Commands. (line 20) * gnus-summary-show-all-threads: Thread Commands. (line 40) * gnus-summary-show-article: Paging the Article. (line 21) * gnus-summary-show-thread: Thread Commands. (line 33) * gnus-summary-sort-by-author: Summary Sorting. (line 13) * gnus-summary-sort-by-date: Summary Sorting. (line 19) * gnus-summary-sort-by-number: Summary Sorting. (line 10) * gnus-summary-sort-by-score: Summary Sorting. (line 22) * gnus-summary-sort-by-subject: Summary Sorting. (line 16) * gnus-summary-stop-page-breaking: Article Washing. (line 14) * gnus-summary-supersede-article: Canceling and Superseding. (line 24) * gnus-summary-thread-gathering-function: Customizing Threading. (line 94) * gnus-summary-tick-above: Setting Marks. (line 76) * gnus-summary-tick-article-forward: Setting Marks. (line 10) * gnus-summary-toggle-header: Article Washing. (line 22) * gnus-summary-toggle-mime: Article Washing. (line 30) * gnus-summary-toggle-threads: Thread Commands. (line 30) * gnus-summary-toggle-truncation: Really Various Summary Commands. (line 17) * gnus-summary-top-thread: Thread Commands. (line 71) * gnus-summary-universal-argument: Searching for Articles. (line 20) * gnus-summary-unmark-all-processable <1>: Pick and Read. (line 26) * gnus-summary-unmark-all-processable: Setting Process Marks. (line 17) * gnus-summary-unmark-as-processable <1>: Setting Process Marks. (line 9) * gnus-summary-unmark-as-processable: Pick and Read. (line 23) * gnus-summary-up-thread: Thread Commands. (line 68) * gnus-summary-update-hook: Summary Highlighting. (line 12) * gnus-summary-verbose-header: Article Washing. (line 26) * gnus-summary-wake-up-the-dead: Exiting the Summary Buffer. (line 57) * gnus-summary-zcore-fuzz: Summary Buffer Lines. (line 76) * gnus-supercite-regexp: Article Highlighting. (line 45) * gnus-supercite-secondary-regexp: Article Highlighting. (line 48) * gnus-suspend-gnus-hook: Exiting Gnus. (line 19) * gnus-thread-hide-killed: Customizing Threading. (line 161) * gnus-thread-hide-subtree: Customizing Threading. (line 157) * gnus-thread-ignore-subject: Customizing Threading. (line 165) * gnus-thread-indent-level: Customizing Threading. (line 171) * gnus-thread-operation-ignore-subject: Thread Commands. (line 73) * gnus-thread-score-function: Sorting. (line 46) * gnus-thread-sort-by-author: Sorting. (line 6) * gnus-thread-sort-by-date: Sorting. (line 6) * gnus-thread-sort-by-number: Sorting. (line 6) * gnus-thread-sort-by-score: Sorting. (line 6) * gnus-thread-sort-by-subject: Sorting. (line 6) * gnus-thread-sort-by-total-score: Sorting. (line 6) * gnus-thread-sort-functions: Sorting. (line 6) * gnus-ticked-mark: Unread Articles. (line 8) * gnus-topic-copy-group: Topic Commands. (line 20) * gnus-topic-copy-matching: Topic Commands. (line 34) * gnus-topic-create-topic: Topic Commands. (line 11) * gnus-topic-delete: Topic Commands. (line 72) * gnus-topic-indent: Topic Commands. (line 56) * gnus-topic-indent-level: Topic Variables. (line 34) * gnus-topic-kill-group: Topic Commands. (line 61) * gnus-topic-line-format: Topic Variables. (line 9) * gnus-topic-list-active: Topic Commands. (line 75) * gnus-topic-mark-topic: Topic Commands. (line 38) * gnus-topic-mode: Group Topics. (line 13) * gnus-topic-mode-hook: Topic Variables. (line 38) * gnus-topic-move-group: Topic Commands. (line 15) * gnus-topic-move-matching: Topic Commands. (line 30) * gnus-topic-remove-group: Topic Commands. (line 25) * gnus-topic-rename: Topic Commands. (line 69) * gnus-topic-select-group: Topic Commands. (line 46) * gnus-topic-topology: Topic Topology. (line 28) * gnus-topic-unmark-topic: Topic Commands. (line 42) * gnus-topic-yank-group: Topic Commands. (line 64) * gnus-total-expirable-newsgroups: Expiring Mail. (line 76) * gnus-tree-brackets: Tree Display. (line 58) * gnus-tree-line-format: Tree Display. (line 26) * gnus-tree-minimize-window: Tree Display. (line 70) * gnus-tree-mode-hook: Tree Display. (line 14) * gnus-tree-mode-line-format: Tree Display. (line 17) * gnus-tree-parent-child-edges: Tree Display. (line 64) * gnus-uncacheable-groups: Article Caching. (line 44) * gnus-unload: Exiting Gnus. (line 24) * gnus-unread-mark <1>: Choosing Articles. (line 70) * gnus-unread-mark: Unread Articles. (line 22) * gnus-update-format: Formatting Variables. (line 71) * gnus-update-score-entry-dates: Score Variables. (line 101) * gnus-updated-mode-lines: Mode Lines. (line 6) * gnus-use-adaptive-scoring: Adaptive Scoring. (line 10) * gnus-use-cache: Article Caching. (line 15) * gnus-use-cross-reference: Exiting the Summary Buffer. (line 70) * gnus-use-demon: Daemons. (line 50) * gnus-use-dribble-file: Auto Save. (line 16) * gnus-use-full-window: Windows Configuration. (line 8) * gnus-use-grouplens: Using GroupLens. (line 13) * gnus-use-long-file-name <1>: Article Caching. (line 15) * gnus-use-long-file-name: Saving Articles. (line 151) * gnus-use-nocem: NoCeM. (line 27) * gnus-use-scoring: Score Variables. (line 7) * gnus-use-trees: Tree Display. (line 6) * gnus-uu-correct-stripped-uucode: Other Decode Variables. (line 56) * gnus-uu-decode-postscript: PostScript Files. (line 7) * gnus-uu-decode-postscript-and-save: PostScript Files. (line 10) * gnus-uu-decode-postscript-and-save-view: PostScript Files. (line 18) * gnus-uu-decode-postscript-view: PostScript Files. (line 14) * gnus-uu-decode-unshar: Shared Articles. (line 7) * gnus-uu-decode-unshar-and-save: Shared Articles. (line 10) * gnus-uu-decode-unshar-and-save-view: Shared Articles. (line 18) * gnus-uu-decode-unshar-view: Shared Articles. (line 14) * gnus-uu-decode-uu: Uuencoded Articles. (line 7) * gnus-uu-decode-uu-and-save: Uuencoded Articles. (line 10) * gnus-uu-decode-uu-and-save-view: Uuencoded Articles. (line 17) * gnus-uu-decode-uu-view: Uuencoded Articles. (line 14) * gnus-uu-digest-headers: Mail. (line 9) * gnus-uu-digest-mail-forward: Summary Mail Commands. (line 60) * gnus-uu-digest-post-forward: Summary Mail Commands. (line 65) * gnus-uu-do-not-unpack-archives: Other Decode Variables. (line 32) * gnus-uu-grab-move: Other Decode Variables. (line 17) * gnus-uu-grab-view: Other Decode Variables. (line 14) * gnus-uu-grabbed-file-functions: Other Decode Variables. (line 6) * gnus-uu-ignore-default-archive-rules: Other Decode Variables. (line 44) * gnus-uu-ignore-default-view-rules: Other Decode Variables. (line 40) * gnus-uu-ignore-files-by-name: Other Decode Variables. (line 20) * gnus-uu-ignore-files-by-type: Other Decode Variables. (line 23) * gnus-uu-kill-carriage-return: Other Decode Variables. (line 48) * gnus-uu-mark-all: Setting Process Marks. (line 46) * gnus-uu-mark-buffer <1>: Pick and Read. (line 47) * gnus-uu-mark-buffer: Setting Process Marks. (line 49) * gnus-uu-mark-by-regexp <1>: Setting Process Marks. (line 21) * gnus-uu-mark-by-regexp: Pick and Read. (line 41) * gnus-uu-mark-over: Setting Process Marks. (line 35) * gnus-uu-mark-region <1>: Pick and Read. (line 35) * gnus-uu-mark-region: Setting Process Marks. (line 24) * gnus-uu-mark-series: Setting Process Marks. (line 39) * gnus-uu-mark-sparse: Setting Process Marks. (line 42) * gnus-uu-mark-thread <1>: Pick and Read. (line 29) * gnus-uu-mark-thread <2>: Setting Process Marks. (line 27) * gnus-uu-mark-thread: Thread Commands. (line 23) * gnus-uu-notify-files: Uuencoded Articles. (line 30) * gnus-uu-post-include-before-composing: Uuencoding and Posting. (line 7) * gnus-uu-post-length: Uuencoding and Posting. (line 13) * gnus-uu-post-news: Summary Post Commands. (line 23) * gnus-uu-post-separate-description: Uuencoding and Posting. (line 24) * gnus-uu-post-threaded: Uuencoding and Posting. (line 17) * gnus-uu-save-in-digest: Other Decode Variables. (line 66) * gnus-uu-tmp-dir: Other Decode Variables. (line 29) * gnus-uu-unmark-articles-not-decoded: Other Decode Variables. (line 52) * gnus-uu-unmark-buffer: Pick and Read. (line 50) * gnus-uu-unmark-by-regexp: Pick and Read. (line 44) * gnus-uu-unmark-region: Pick and Read. (line 38) * gnus-uu-unmark-thread <1>: Setting Process Marks. (line 31) * gnus-uu-unmark-thread <2>: Thread Commands. (line 26) * gnus-uu-unmark-thread: Pick and Read. (line 32) * gnus-uu-user-archive-rules: Rule Variables. (line 25) * gnus-uu-user-view-rules: Rule Variables. (line 14) * gnus-uu-user-view-rules-end: Rule Variables. (line 21) * gnus-uu-view-and-save: Other Decode Variables. (line 36) * gnus-uu-view-with-metamail: Other Decode Variables. (line 60) * gnus-verbose: Various Various. (line 7) * gnus-verbose-backends: Various Various. (line 15) * gnus-version: Group Information. (line 21) * gnus-view-pseudo-asynchronously: Viewing Files. (line 19) * gnus-view-pseudos: Viewing Files. (line 22) * gnus-view-pseudos-separately: Viewing Files. (line 27) * gnus-visible-headers: Hiding Headers. (line 21) * gnus-visual: Highlighting and Menus. (line 6) * gnus-visual-mark-article-hook: Summary Highlighting. (line 7) * gnus-window-min-height: Windows Configuration. (line 100) * gnus-window-min-width: Windows Configuration. (line 100) * group buffer: The Group Buffer. (line 6) * group buffer format: Group Buffer Format. (line 6) * group description: Group Information. (line 13) * group information: Group Information. (line 6) * group level: Group Levels. (line 6) * group listing: Listing Groups. (line 6) * group movement: Group Maneuvering. (line 6) * group parameters: Group Parameters. (line 6) * group score: Group Score. (line 6) * group score commands: Group Score Commands. (line 6) * group selection: Selecting a Group. (line 6) * GroupLens: GroupLens. (line 6) * grouplens-best-unread-article: Rating Articles. (line 31) * grouplens-newsgroups: Using GroupLens. (line 21) * grouplens-next-unread-article: Rating Articles. (line 28) * grouplens-prediction-display: Displaying Predictions. (line 24) * grouplens-pseudonym: Using GroupLens. (line 17) * grouplens-score-thread: Rating Articles. (line 19) * head: Terminology. (line 54) * header: Terminology. (line 62) * headers: Terminology. (line 65) * help group: Document Groups. (line 6) * hiding headers: Hiding Headers. (line 6) * highlight: Article Highlighting. (line 6) * highlighting <1>: Compatibility. (line 34) * highlighting: Highlighting and Menus. (line 6) * highlights: Various Various. (line 6) * hilit19: Compatibility. (line 34) * history: History. (line 6) * ignored groups: The Active File. (line 6) * illegal characters in file names: Various Various. (line 29) * incoming mail files: Mail Backend Variables. (line 80) * info: Group Information. (line 27) * information on groups: Group Information. (line 6) * interaction: Interactive. (line 6) * ispell: Mail and Post. (line 25) * ispell-message: Mail and Post. (line 25) * Jem: NoCeM. (line 53) * kibozing: Kibozed Groups. (line 6) * kill files: Kill Files. (line 6) * killed groups: Terminology. (line 83) * levels: Terminology. (line 75) * limiting: Limiting. (line 6) * links: Splitting Mail. (line 45) * LIST overview.fmt: Exiting the Summary Buffer. (line 100) * local variables: Score File Format. (line 202) * mail <1>: Summary Mail Commands. (line 6) * mail <2>: Terminology. (line 14) * mail: Getting Mail. (line 6) * mail folders: Mail Folders. (line 6) * mail group commands: Mail Group Commands. (line 6) * mail message: Terminology. (line 48) * mail NOV spool: Mail Spool. (line 6) * mail splitting <1>: Splitting Mail. (line 6) * mail splitting: Fancy Mail Splitting. (line 6) * mail-extract-address-components: Summary Buffer Format. (line 12) * MAILHOST: Mail Backend Variables. (line 15) * mailing lists: Mail and Post. (line 10) * manual: Group Information. (line 27) * marking groups: Marking Groups. (line 6) * marks: Marking Articles. (line 6) * mbox: Document Groups. (line 10) * mbox folders: Mail Folders. (line 6) * menus: Highlighting and Menus. (line 6) * message: Terminology. (line 51) * metamail: Other Decode Variables. (line 60) * metamail-buffer: Using MIME. (line 16) * MH folders: Saving Articles. (line 90) * mh-e mail spool: MH Spool. (line 6) * MIME: Using MIME. (line 6) * MIME digest: Document Groups. (line 28) * MMDF mail box: Document Groups. (line 15) * mode lines <1>: Mode Lines. (line 6) * mode lines: Various Various. (line 6) * MODE READER: NNTP. (line 23) * mouse: Buttons. (line 6) * move mail: Mail Group Commands. (line 28) * movemail: Mail Backend Variables. (line 15) * moving articles: Mail Group Commands. (line 61) * Mule: Emacsen. (line 6) * native: Terminology. (line 32) * new features: New Features. (line 6) * new groups: New Groups. (line 6) * new messages: Scanning New Messages. (line 6) * news: Terminology. (line 7) * news backends: Getting News. (line 6) * news spool: News Spool. (line 6) * nnbabyl: Rmail Babyl. (line 6) * nnbabyl-active-file: Rmail Babyl. (line 16) * nnbabyl-get-new-mail <1>: Rmail Babyl. (line 19) * nnbabyl-get-new-mail: Not Reading Mail. (line 13) * nnbabyl-mbox-file: Rmail Babyl. (line 6) * nnchoke: Backend Interface. (line 52) * nndir: Directory Groups. (line 6) * nndoc: Document Groups. (line 6) * nndoc-article-type: Document Groups. (line 57) * nndoc-post-type: Document Groups. (line 62) * nneething: Anything Groups. (line 6) * nneething-exclude-files: Anything Groups. (line 47) * nneething-map-file: Anything Groups. (line 52) * nneething-map-file-directory: Anything Groups. (line 43) * nnfolder: Mail Folders. (line 6) * nnfolder-active-file: Mail Folders. (line 16) * nnfolder-directory: Mail Folders. (line 13) * nnfolder-generate-active-file: Mail Folders. (line 25) * nnfolder-get-new-mail <1>: Mail Folders. (line 23) * nnfolder-get-new-mail: Not Reading Mail. (line 13) * nnfolder-newsgroups-file: Mail Folders. (line 19) * nnheader-file-name-translation-alist: Various Various. (line 29) * nnheader-max-head-length: Various Various. (line 19) * nnkiboze: Kibozed Groups. (line 6) * nnkiboze-directory: Kibozed Groups. (line 36) * nnkiboze-generate-groups: Kibozed Groups. (line 21) * nnmail-crash-box: Mail Backend Variables. (line 44) * nnmail-crosspost: Splitting Mail. (line 40) * nnmail-crosspost-link-function: Splitting Mail. (line 45) * nnmail-delete-file-function: Mail Backend Variables. (line 91) * nnmail-delete-incoming: Mail Backend Variables. (line 80) * nnmail-expiry-wait: Expiring Mail. (line 42) * nnmail-expiry-wait-function <1>: Group Parameters. (line 73) * nnmail-expiry-wait-function: Expiring Mail. (line 51) * nnmail-keep-last-article <1>: Mail and Procmail. (line 50) * nnmail-keep-last-article: Expiring Mail. (line 72) * nnmail-message-id-cache-file: Duplicates. (line 6) * nnmail-message-id-cache-length: Duplicates. (line 6) * nnmail-movemail-program: Mail Backend Variables. (line 76) * nnmail-pop-password: Mail Backend Variables. (line 15) * nnmail-pop-password-required: Mail Backend Variables. (line 15) * nnmail-post-get-new-mail-hook: Mail Backend Variables. (line 54) * nnmail-pre-get-new-mail-hook: Mail Backend Variables. (line 54) * nnmail-prepare-incoming-hook: Mail Backend Variables. (line 50) * nnmail-procmail-directory: Mail and Procmail. (line 38) * nnmail-procmail-suffix <1>: Mail Backend Variables. (line 37) * nnmail-procmail-suffix: Mail and Procmail. (line 38) * nnmail-read-incoming-hook: Mail Backend Variables. (line 9) * nnmail-resplit-incoming: Mail and Procmail. (line 45) * nnmail-split-abbrev-alist: Fancy Mail Splitting. (line 57) * nnmail-split-fancy: Fancy Mail Splitting. (line 6) * nnmail-split-fancy-syntax-table: Fancy Mail Splitting. (line 62) * nnmail-split-methods: Splitting Mail. (line 6) * nnmail-spool-file: Mail Backend Variables. (line 14) * nnmail-tmp-directory: Mail Backend Variables. (line 70) * nnmail-treat-duplicates: Duplicates. (line 6) * nnmail-use-long-file-names: Mail Backend Variables. (line 85) * nnmail-use-procmail: Mail Backend Variables. (line 37) * nnmbox: Unix Mail Box. (line 6) * nnmbox-active-file: Unix Mail Box. (line 16) * nnmbox-get-new-mail <1>: Not Reading Mail. (line 13) * nnmbox-get-new-mail: Unix Mail Box. (line 19) * nnmbox-mbox-file: Unix Mail Box. (line 6) * nnmh: MH Spool. (line 6) * nnmh-be-safe: MH Spool. (line 20) * nnmh-directory: MH Spool. (line 14) * nnmh-get-new-mail <1>: MH Spool. (line 17) * nnmh-get-new-mail: Not Reading Mail. (line 13) * nnml: Mail Spool. (line 6) * nnml-active-file: Mail Spool. (line 38) * nnml-directory: Mail Spool. (line 35) * nnml-generate-nov-databases: Mail Spool. (line 57) * nnml-get-new-mail <1>: Mail Spool. (line 45) * nnml-get-new-mail: Not Reading Mail. (line 13) * nnml-newsgroups-file: Mail Spool. (line 41) * nnml-nov-file-name: Mail Spool. (line 51) * nnml-nov-is-evil: Mail Spool. (line 48) * nnml-prepare-save-mail-hook: Mail Spool. (line 54) * nnsoup: SOUP Groups. (line 6) * nnsoup-active-file: SOUP Groups. (line 34) * nnsoup-directory: SOUP Groups. (line 17) * nnsoup-pack-replies: SOUP Commands. (line 22) * nnsoup-packer: SOUP Groups. (line 40) * nnsoup-packet-directory: SOUP Groups. (line 48) * nnsoup-packet-regexp: SOUP Groups. (line 52) * nnsoup-replies-directory: SOUP Groups. (line 21) * nnsoup-replies-format-type: SOUP Groups. (line 25) * nnsoup-replies-index-type: SOUP Groups. (line 30) * nnsoup-set-variables: SOUP Replies. (line 10) * nnsoup-tmp-directory: SOUP Groups. (line 13) * nnsoup-unpacker: SOUP Groups. (line 44) * nnspool: News Spool. (line 6) * nnspool-active-file: News Spool. (line 36) * nnspool-active-times-file: News Spool. (line 45) * nnspool-history-file: News Spool. (line 42) * nnspool-inews-program: News Spool. (line 19) * nnspool-inews-switches: News Spool. (line 22) * nnspool-lib-dir: News Spool. (line 33) * nnspool-newsgroups-file: News Spool. (line 39) * nnspool-nov-directory: News Spool. (line 29) * nnspool-nov-is-evil: News Spool. (line 48) * nnspool-sift-nov-with-sed: News Spool. (line 52) * nnspool-spool-directory: News Spool. (line 25) * nntp: NNTP. (line 6) * nntp authentification: NNTP. (line 23) * NNTP server: Finding the News. (line 23) * nntp-address: NNTP. (line 109) * nntp-async-number <1>: Asynchronous Fetching. (line 38) * nntp-async-number: NNTP. (line 144) * nntp-buggy-select: NNTP. (line 116) * nntp-command-timeout: NNTP. (line 68) * nntp-connection-timeout: NNTP. (line 58) * nntp-end-of-line: NNTP. (line 100) * nntp-maximum-request: NNTP. (line 50) * nntp-nov-gap: NNTP. (line 129) * nntp-nov-is-evil: NNTP. (line 119) * nntp-open-network-stream: NNTP. (line 87) * nntp-open-rlogin: NNTP. (line 87) * nntp-open-server-function: NNTP. (line 88) * nntp-port-number: NNTP. (line 112) * nntp-prepare-server-hook: NNTP. (line 141) * nntp-retry-on-break: NNTP. (line 79) * nntp-rlogin-parameters: NNTP. (line 96) * nntp-rlogin-user-name: NNTP. (line 105) * nntp-send-authinfo: NNTP. (line 23) * nntp-send-mode-reader: NNTP. (line 23) * nntp-server-action-alist: NNTP. (line 31) * nntp-server-hook: NNTP. (line 84) * nntp-server-opened-hook: NNTP. (line 23) * nntp-warn-about-losing-connection: NNTP. (line 150) * nntp-xover-commands: NNTP. (line 124) * NNTPSERVER: Finding the News. (line 23) * nnvirtual: Virtual Groups. (line 6) * nnvirtual-always-rescan: Virtual Groups. (line 48) * nocem: NoCeM. (line 6) * nov <1>: Terminology. (line 69) * nov: NNTP. (line 124) * NOV: Exiting the Summary Buffer. (line 90) * offline: SOUP. (line 6) * overview.fmt: Exiting the Summary Buffer. (line 100) * parent articles: Finding the Parent. (line 6) * persistent articles: Persistent Articles. (line 6) * pick and read: Pick and Read. (line 6) * POP mail: Mail Backend Variables. (line 15) * post <1>: Composing Messages. (line 6) * post: Summary Post Commands. (line 6) * PostScript: PostScript Files. (line 6) * PPP connections: NNTP. (line 68) * process mark: Other Marks. (line 6) * process/prefix convention: Process/Prefix. (line 6) * procmail: Mail and Procmail. (line 6) * pseudo-articles: Viewing Files. (line 6) * rcvstore: Saving Articles. (line 90) * reading init file: File Commands. (line 7) * reading mail: Getting Mail. (line 6) * reading news: Getting News. (line 6) * referring articles: Finding the Parent. (line 6) * reply <1>: Terminology. (line 20) * reply: Composing Messages. (line 6) * reporting bugs <1>: Troubleshooting. (line 27) * reporting bugs: Compatibility. (line 53) * restarting: Scanning New Messages. (line 24) * reverse scoring: Reverse Scoring. (line 6) * RFC 1036: Conformity. (line 14) * RFC 1153 digest: Document Groups. (line 28) * RFC 341 digest: Document Groups. (line 28) * RFC 822: Conformity. (line 11) * rmail mbox <1>: Document Groups. (line 9) * rmail mbox: Rmail Babyl. (line 6) * rnews batch files: Document Groups. (line 22) * rule variables: Rule Variables. (line 6) * saving .newsrc: File Commands. (line 11) * saving articles: Saving Articles. (line 6) * scanning new news: Scanning New Messages. (line 6) * score cache: Score Variables. (line 29) * score commands: Summary Score Commands. (line 6) * score file format: Score File Format. (line 6) * score variables: Score Variables. (line 6) * scoring: Scoring. (line 6) * scoring crossposts: Scoring Tips. (line 7) * scoring tips: Scoring Tips. (line 6) * secondary: Terminology. (line 41) * sed: News Spool. (line 52) * select method: Terminology. (line 103) * select methods: Select Methods. (line 6) * selecting articles: Choosing Articles. (line 6) * sent messages: Archived Messages. (line 6) * server: Terminology. (line 100) * server buffer format: Server Buffer Format. (line 6) * server commands: Server Commands. (line 6) * server errors: The Server is Down. (line 6) * setting marks: Setting Marks. (line 6) * setting process marks: Setting Process Marks. (line 6) * shared articles: Shared Articles. (line 6) * slave: Slave Gnusii. (line 6) * slocal: Mail and Procmail. (line 6) * slow machine: Slow Machine. (line 6) * Son-of-RFC 1036: Conformity. (line 21) * sorting groups: Sorting Groups. (line 6) * SOUP: SOUP. (line 6) * sox: Rule Variables. (line 14) * spam: NoCeM. (line 6) * spamming: Exiting the Summary Buffer. (line 79) * splitting mail: Splitting Mail. (line 6) * starting up: Starting Up. (line 6) * startup files: Startup Files. (line 6) * subscribing: Subscription Commands. (line 6) * summary buffer: The Summary Buffer. (line 6) * summary buffer format: Summary Buffer Format. (line 6) * summary exit: Exiting the Summary Buffer. (line 6) * summary movement: Summary Maneuvering. (line 6) * summary sorting: Summary Sorting. (line 6) * superseding articles: Canceling and Superseding. (line 6) * terminology: Terminology. (line 6) * thread commands: Thread Commands. (line 6) * threading: Threading. (line 6) * to-address: Group Parameters. (line 28) * to-group: Group Parameters. (line 59) * to-list: Group Parameters. (line 45) * todo: Newest Features. (line 6) * topic commands: Topic Commands. (line 6) * topic topology: Topic Topology. (line 6) * topic variables: Topic Variables. (line 6) * topics: Group Topics. (line 6) * topology: Topic Topology. (line 6) * total-expire: Group Parameters. (line 68) * transient-mark-mode: Process/Prefix. (line 19) * trees: Tree Display. (line 6) * troubleshooting: Troubleshooting. (line 6) * unix mail box: Unix Mail Box. (line 6) * Unix mbox: Document Groups. (line 10) * unloading: Exiting Gnus. (line 24) * unshar: Shared Articles. (line 6) * Usenet Seal of Approval: Conformity. (line 17) * uudecode: Uuencoded Articles. (line 6) * uuencoded articles: Uuencoded Articles. (line 6) * V R (Summary): Summary Score Commands. (line 31) * velveeta: Exiting the Summary Buffer. (line 79) * version: Group Information. (line 21) * viewing files: Viewing Files. (line 6) * virtual groups: Virtual Groups. (line 6) * virtual server: Terminology. (line 107) * visible group parameter: Listing Groups. (line 61) * visual: Highlighting and Menus. (line 6) * washing: Article Washing. (line 6) * window height: Windows Configuration. (line 100) * window width: Windows Configuration. (line 100) * windows configuration: Windows Configuration. (line 6) * x-face: Article Washing. (line 50) * XEmacs <1>: Emacsen. (line 6) * XEmacs: Emacs/XEmacs Code. (line 6) * XOVER: NNTP. (line 124) * Xref: Exiting the Summary Buffer. (line 90) * zombie groups: Terminology. (line 87)  File: gnus, Node: Key Index, Prev: Index, Up: Top 12 Key Index ************ [index] * Menu: * ! (Summary): Setting Marks. (line 10) * # (Group): Marking Groups. (line 16) * # (Summary): Setting Process Marks. (line 8) * & (Summary): Searching for Articles. (line 15) * * (Summary): Persistent Articles. (line 22) * , (Group): Group Maneuvering. (line 40) * , (GroupLens): Rating Articles. (line 31) * , (Summary): Choosing Articles. (line 44) * . (Summary): Choosing Articles. (line 39) * . (Group): Group Maneuvering. (line 44) * / / (Summary): Limiting. (line 13) * / a (Summary): Limiting. (line 17) * / C (Summary): Limiting. (line 62) * / c (Summary): Limiting. (line 58) * / d (Summary): Limiting. (line 55) * / D (Summary): Limiting. (line 51) * / E (Summary): Limiting. (line 47) * / m (Summary): Limiting. (line 28) * / n (Summary): Limiting. (line 32) * / u (Summary): Limiting. (line 22) * / v (Summary): Limiting. (line 42) * / w (Summary): Limiting. (line 37) * < (Summary): Paging the Article. (line 28) * = (Summary): Really Various Summary Commands. (line 21) * > (Summary): Paging the Article. (line 33) * ? (Article): Article Keymap. (line 34) * ? (Browse): Browse Foreign Server. (line 47) * ? (Group): Group Information. (line 24) * ? (Summary): Setting Marks. (line 14) * ^ (Group): Misc Group Stuff. (line 13) * ^ (Summary): Finding the Parent. (line 6) * a (Group): Misc Group Stuff. (line 17) * a (Server): Server Commands. (line 7) * a (Summary): Summary Post Commands. (line 10) * A < (Summary): Paging the Article. (line 28) * A > (Summary): Paging the Article. (line 33) * A a (Group): Listing Groups. (line 53) * A A (Group): Listing Groups. (line 46) * A d (Group): Listing Groups. (line 57) * A D (Summary): Really Various Summary Commands. (line 7) * A g (Summary): Paging the Article. (line 21) * A k (Group): Listing Groups. (line 30) * A l (Group): Listing Groups. (line 25) * A M (Group): Listing Groups. (line 43) * A m (Group): Listing Groups. (line 39) * A R (Summary): Finding the Parent. (line 14) * A s (Group): Listing Groups. (line 10) * A s (Summary): Paging the Article. (line 36) * A T (Group): Topic Commands. (line 75) * A u (Group): Listing Groups. (line 18) * A z (Group): Listing Groups. (line 36) * b (Group): Group Maintenance. (line 7) * B (Group) <1>: Finding the News. (line 40) * B (Group): Browse Foreign Server. (line 7) * B (Pick): Pick and Read. (line 50) * b (Pick): Pick and Read. (line 47) * B c (Summary): Mail Group Commands. (line 32) * B C (Summary): Mail Group Commands. (line 36) * B DEL (Summary): Mail Group Commands. (line 23) * B e (Summary): Mail Group Commands. (line 13) * B i (Summary): Mail Group Commands. (line 42) * B m (Summary): Mail Group Commands. (line 28) * B M-C-e (Summary): Mail Group Commands. (line 17) * B q (Summary): Mail Group Commands. (line 56) * B r (Summary): Mail Group Commands. (line 47) * B w (Summary): Mail Group Commands. (line 51) * c (Group): Selecting a Group. (line 36) * C (Group): Selecting a Group. (line 41) * c (Server): Server Commands. (line 25) * C (Server): Unavailable Servers. (line 32) * c (Summary): Exiting the Summary Buffer. (line 25) * C (Summary): Canceling and Superseding. (line 11) * C-c ^ (Article): Article Keymap. (line 21) * C-c C-c (Article): Mail Group Commands. (line 51) * C-c C-c (Post): Composing Messages. (line 6) * C-c C-c (Score): Score File Editing. (line 14) * C-c C-d (Score): Score File Editing. (line 18) * C-c C-i (Group): Group Information. (line 27) * C-c C-m (Article): Article Keymap. (line 26) * C-c C-p (Score): Score File Editing. (line 23) * C-c C-s (Group): Sorting Groups. (line 6) * C-c C-s C-a (Summary): Summary Sorting. (line 13) * C-c C-s C-d (Summary): Summary Sorting. (line 19) * C-c C-s C-i (Summary): Summary Sorting. (line 22) * C-c C-s C-n (Summary): Summary Sorting. (line 10) * C-c C-s C-s (Summary): Summary Sorting. (line 16) * C-c C-x (Group): Group Maintenance. (line 16) * C-c M-C-x (Group): Group Maintenance. (line 20) * C-c M-g (Group): Scanning New Messages. (line 21) * C-k (Group) <1>: Topic Commands. (line 61) * C-k (Group): Subscription Commands. (line 19) * C-k (Summary): Setting Marks. (line 30) * C-t (Summary): Really Various Summary Commands. (line 17) * C-w (Group): Subscription Commands. (line 32) * C-w (Summary): Setting Marks. (line 46) * C-x C-t (Group): Subscription Commands. (line 26) * C-y (Group) <1>: Subscription Commands. (line 23) * C-y (Group): Topic Commands. (line 64) * D (Group): Group Information. (line 13) * D (Server): Unavailable Servers. (line 36) * d (Summary): Setting Marks. (line 19) * DEL (Article): Article Keymap. (line 18) * DEL (Group): Group Maneuvering. (line 15) * DEL (Summary): Paging the Article. (line 12) * e (Pick): Pick and Read. (line 41) * E (Pick): Pick and Read. (line 44) * e (Server): Server Commands. (line 10) * e (Summary): Mail Group Commands. (line 51) * E (Summary): Setting Marks. (line 60) * F (Group): Group Maintenance. (line 11) * f (Summary): Summary Post Commands. (line 14) * F (Summary): Summary Post Commands. (line 18) * g (Binary): Binary Groups. (line 12) * g (Group): Scanning New Messages. (line 7) * g (Summary): Paging the Article. (line 21) * G a (Group): Foreign Groups. (line 41) * G b (Summary): Choosing Articles. (line 44) * G C-n (Summary): Choosing Articles. (line 30) * G C-p (Summary): Choosing Articles. (line 34) * G D (Group): Foreign Groups. (line 54) * G d (Group): Foreign Groups. (line 34) * G DEL (Group): Foreign Groups. (line 66) * G E (Group): Foreign Groups. (line 30) * G e (Group): Foreign Groups. (line 22) * G f (Summary): Choosing Articles. (line 39) * G f (Group): Foreign Groups. (line 58) * G g (Summary): Summary Maneuvering. (line 27) * G h (Group): Foreign Groups. (line 38) * G j (Summary): Summary Maneuvering. (line 23) * G k (Group) <1>: Foreign Groups. (line 48) * G k (Group): Kibozed Groups. (line 11) * G l (Summary): Choosing Articles. (line 49) * G m (Group): Foreign Groups. (line 11) * G M-n (Summary): Summary Maneuvering. (line 13) * G M-p (Summary): Summary Maneuvering. (line 18) * G n (Summary): Choosing Articles. (line 15) * G N (Summary): Choosing Articles. (line 23) * G p (Group): Foreign Groups. (line 26) * G P (Summary): Choosing Articles. (line 27) * G p (Summary): Choosing Articles. (line 52) * G r (Group): Foreign Groups. (line 16) * G S a (Group): Sorting Groups. (line 38) * G s b (Group): SOUP Commands. (line 7) * G S l (Group): Sorting Groups. (line 46) * G S m (Group): Sorting Groups. (line 58) * G s p (Group): SOUP Commands. (line 19) * G s r (Group): SOUP Commands. (line 22) * G S r (Group): Sorting Groups. (line 54) * G s s (Group): SOUP Commands. (line 15) * G S u (Group): Sorting Groups. (line 42) * G S v (Group): Sorting Groups. (line 50) * G s w (Group): SOUP Commands. (line 12) * G V (Group): Foreign Groups. (line 73) * G v (Group): Foreign Groups. (line 77) * H d (Summary): Summary Group Information. (line 16) * H f (Summary): Summary Group Information. (line 7) * H h (Summary): Summary Group Information. (line 21) * H i (Summary): Summary Group Information. (line 25) * I C-i (Summary): Summary Score Commands. (line 62) * j (Group): Group Maneuvering. (line 35) * j (Summary): Summary Maneuvering. (line 23) * k (GroupLens): Rating Articles. (line 19) * k (Server): Server Commands. (line 19) * k (Summary): Setting Marks. (line 24) * l (Browse): Browse Foreign Server. (line 44) * l (Group): Listing Groups. (line 10) * L (Group): Listing Groups. (line 18) * l (Server): Server Commands. (line 28) * l (Summary): Choosing Articles. (line 49) * L C-l (Summary): Summary Score Commands. (line 66) * m (Group): Misc Group Stuff. (line 21) * m (Summary): Summary Mail Commands. (line 29) * M ? (Summary): Setting Marks. (line 14) * M b (Group): Marking Groups. (line 30) * M b (Summary): Setting Marks. (line 64) * M B (Summary): Setting Marks. (line 68) * M C (Summary): Setting Marks. (line 34) * M c (Summary): Setting Marks. (line 55) * M C-c (Summary): Setting Marks. (line 38) * M d (Summary): Setting Marks. (line 19) * M e (Summary): Setting Marks. (line 60) * M H (Summary): Setting Marks. (line 42) * M K (Summary): Setting Marks. (line 30) * M k (Summary): Setting Marks. (line 24) * M m (Group): Marking Groups. (line 17) * M P a (Summary): Setting Process Marks. (line 46) * M P b (Summary): Setting Process Marks. (line 49) * M P p (Summary): Setting Process Marks. (line 8) * M P r (Summary): Setting Process Marks. (line 24) * M P R (Summary): Setting Process Marks. (line 21) * M P S (Summary): Setting Process Marks. (line 42) * M P s (Summary): Setting Process Marks. (line 39) * M P t (Summary): Setting Process Marks. (line 27) * M P T (Summary): Setting Process Marks. (line 31) * M P u (Summary): Setting Process Marks. (line 13) * M P U (Summary): Setting Process Marks. (line 17) * M P v (Summary): Setting Process Marks. (line 35) * M r (Group): Marking Groups. (line 33) * M S (Summary): Limiting. (line 47) * M t (Summary): Setting Marks. (line 10) * M u (Group): Marking Groups. (line 21) * M U (Group): Marking Groups. (line 24) * M V c (Summary): Setting Marks. (line 72) * M V k (Summary): Setting Marks. (line 50) * M V m (Summary): Setting Marks. (line 80) * M V u (Summary): Setting Marks. (line 76) * M w (Group): Marking Groups. (line 27) * M-# (Group): Marking Groups. (line 20) * M-# (Summary): Setting Process Marks. (line 13) * M-& (Summary): Searching for Articles. (line 20) * M-* (Summary): Persistent Articles. (line 25) * M-^ (Summary): Finding the Parent. (line 18) * M-C-k (Summary): Thread Commands. (line 8) * M-C-l (Summary): Thread Commands. (line 15) * M-d (Group): Group Information. (line 17) * M-f (Group): Group Information. (line 7) * M-g (Group): Scanning New Messages. (line 14) * M-g (Summary): Exiting the Summary Buffer. (line 43) * M-k (Group): Kill Files. (line 43) * M-K (Group): Kill Files. (line 46) * M-k (Summary): Kill Files. (line 35) * M-K (Summary): Kill Files. (line 38) * M-n (Group): Group Maneuvering. (line 29) * M-n (Summary): Summary Maneuvering. (line 13) * M-p (Group): Group Maneuvering. (line 25) * M-p (Summary): Summary Maneuvering. (line 18) * M-r (Summary): Searching for Articles. (line 11) * M-RET (Group): Selecting a Group. (line 31) * M-s (Summary): Searching for Articles. (line 7) * M-TAB (Article): Article Keymap. (line 42) * M-u (Summary): Setting Marks. (line 55) * M-x gnus: Starting Up. (line 6) * M-x gnus-binary-mode: Binary Groups. (line 6) * M-x gnus-bug <1>: Compatibility. (line 53) * M-x gnus-bug: Troubleshooting. (line 27) * M-x gnus-other-frame: Starting Up. (line 10) * M-x gnus-pick-mode: Pick and Read. (line 11) * M-x gnus-update-format: Formatting Variables. (line 71) * M-x nnfolder-generate-active-file: Mail Folders. (line 25) * M-x nnkiboze-generate-groups: Kibozed Groups. (line 21) * n (Browse): Browse Foreign Server. (line 26) * n (Group): Group Maneuvering. (line 10) * N (Group): Group Maneuvering. (line 19) * n (GroupLens): Rating Articles. (line 28) * N (Summary): Choosing Articles. (line 23) * n (Summary): Choosing Articles. (line 15) * O (Server): Unavailable Servers. (line 28) * o (Summary): Saving Articles. (line 21) * O b (Summary): Saving Articles. (line 37) * O f (Summary): Saving Articles. (line 33) * O h (Summary): Saving Articles. (line 41) * O m (Summary): Saving Articles. (line 25) * O o (Summary): Saving Articles. (line 21) * O p (Summary): Saving Articles. (line 49) * O r (Summary): Saving Articles. (line 29) * O s (Summary): SOUP Commands. (line 25) * O v (Summary): Saving Articles. (line 45) * p (Browse): Browse Foreign Server. (line 29) * P (Group): Group Maneuvering. (line 22) * p (Group): Group Maneuvering. (line 15) * P (Summary): Choosing Articles. (line 27) * p (Summary): Choosing Articles. (line 19) * q (Browse): Browse Foreign Server. (line 44) * Q (Group): Exiting Gnus. (line 17) * q (Group): Exiting Gnus. (line 14) * q (Server): Server Commands. (line 16) * q (Summary): Exiting the Summary Buffer. (line 11) * Q (Summary): Exiting the Summary Buffer. (line 20) * r (Group): File Commands. (line 7) * R (Group): Scanning New Messages. (line 24) * r (GroupLens): Rating Articles. (line 15) * r (Pick): Pick and Read. (line 35) * R (Pick): Pick and Read. (line 38) * R (Server): Unavailable Servers. (line 39) * R (Summary): Summary Mail Commands. (line 15) * r (Summary): Summary Mail Commands. (line 10) * RET (Browse): Browse Foreign Server. (line 36) * RET (Group) <1>: Selecting a Group. (line 17) * RET (Group): Topic Commands. (line 46) * RET (Pick): Pick and Read. (line 53) * RET (Summary): Paging the Article. (line 16) * s (Article): Article Keymap. (line 30) * s (Group): File Commands. (line 11) * S (Summary): Canceling and Superseding. (line 24) * S C-k (Group): Subscription Commands. (line 38) * S D b (Summary): Summary Mail Commands. (line 33) * S D r (Summary): Summary Mail Commands. (line 44) * S f (Summary): Summary Post Commands. (line 14) * S F (Summary): Summary Post Commands. (line 18) * S k (Group): Subscription Commands. (line 19) * S l (Group): Group Levels. (line 16) * S m (Summary): Summary Mail Commands. (line 29) * S o m (Summary): Summary Mail Commands. (line 20) * S O m (Summary): Summary Mail Commands. (line 60) * S o p (Summary): Summary Mail Commands. (line 24) * S O p (Summary): Summary Mail Commands. (line 65) * S p (Summary): Summary Post Commands. (line 10) * S R (Summary): Summary Mail Commands. (line 15) * S r (Summary): Summary Mail Commands. (line 10) * S s (Group): Subscription Commands. (line 13) * S t (Group): Subscription Commands. (line 8) * S u (Summary): Summary Post Commands. (line 23) * S w (Group): Subscription Commands. (line 32) * S y (Group): Subscription Commands. (line 23) * S z (Group): Subscription Commands. (line 35) * SPACE (Article): Article Keymap. (line 15) * SPACE (Browse): Browse Foreign Server. (line 32) * SPACE (Group): Selecting a Group. (line 7) * SPACE (Pick): Pick and Read. (line 20) * SPACE (Server): Server Commands. (line 13) * SPACE (Summary) <1>: Choosing Articles. (line 10) * SPACE (Summary): Paging the Article. (line 7) * T # (Group): Topic Commands. (line 38) * T # (Summary): Thread Commands. (line 23) * t (Group): Group Topics. (line 13) * t (Pick): Pick and Read. (line 29) * T (Pick): Pick and Read. (line 32) * T ^ (Summary): Thread Commands. (line 51) * T c (Group): Topic Commands. (line 20) * T C (Group): Topic Commands. (line 34) * T D (Group): Topic Commands. (line 25) * T d (Summary): Thread Commands. (line 65) * T DEL (Group): Topic Commands. (line 72) * T H (Summary): Thread Commands. (line 43) * T h (Summary): Thread Commands. (line 37) * T i (Summary): Thread Commands. (line 19) * T k (Summary): Thread Commands. (line 8) * T l (Summary): Thread Commands. (line 15) * T m (Group): Topic Commands. (line 15) * T M (Group): Topic Commands. (line 30) * T M-# (Group): Topic Commands. (line 42) * T M-# (Summary): Thread Commands. (line 26) * T n (Group): Topic Commands. (line 11) * T n (Summary): Thread Commands. (line 59) * T o (Summary): Thread Commands. (line 71) * T p (Summary): Thread Commands. (line 62) * T r (Group): Topic Commands. (line 69) * T S (Summary): Thread Commands. (line 40) * T s (Summary): Thread Commands. (line 33) * T t (Summary): Thread Commands. (line 46) * T T (Summary): Thread Commands. (line 30) * T TAB (Group): Topic Commands. (line 56) * T u (Summary): Thread Commands. (line 68) * TAB (Article): Article Keymap. (line 38) * u (Browse): Browse Foreign Server. (line 39) * u (Group): Subscription Commands. (line 8) * U (Group): Subscription Commands. (line 13) * u (Pick): Pick and Read. (line 23) * U (Pick): Pick and Read. (line 26) * V (Group): Group Information. (line 21) * V a (Summary): Summary Score Commands. (line 37) * V C (Summary): Summary Score Commands. (line 58) * V c (Summary): Summary Score Commands. (line 41) * V e (Summary): Summary Score Commands. (line 45) * V E (Summary): Summary Score Commands. (line 76) * V F (Summary): Summary Score Commands. (line 54) * V f (Summary): Summary Score Commands. (line 50) * V m (Summary): Summary Score Commands. (line 72) * V s (Summary): Summary Score Commands. (line 20) * V S (Summary): Summary Score Commands. (line 23) * V t (Summary): Summary Score Commands. (line 27) * W B (Summary): Article Washing. (line 70) * W b (Summary): Article Washing. (line 67) * W c (Summary): Article Washing. (line 40) * W f (Group): Group Score Commands. (line 9) * W f (Summary): Article Washing. (line 50) * W H a (Summary): Article Highlighting. (line 10) * W H c (Summary): Article Highlighting. (line 23) * W H h (Summary): Article Highlighting. (line 13) * W H s (Summary): Article Highlighting. (line 66) * W l (Summary): Article Washing. (line 14) * W L (Summary): Article Washing. (line 43) * W m (Summary): Article Washing. (line 30) * W o (Summary): Article Washing. (line 34) * W q (Summary): Article Washing. (line 47) * W r (Summary): Article Washing. (line 18) * W t (Summary): Article Washing. (line 22) * W T e (Summary): Article Date. (line 18) * W T l (Summary): Article Date. (line 15) * W T o (Summary): Article Date. (line 22) * W T u (Summary): Article Date. (line 11) * W v (Summary): Article Washing. (line 26) * W w (Summary): Article Washing. (line 37) * W W a (Summary): Article Hiding. (line 10) * W W b (Summary): Article Hiding. (line 17) * W W C (Summary): Article Hiding. (line 59) * W W c (Summary): Article Hiding. (line 27) * W W h (Summary): Article Hiding. (line 13) * W W p (Summary): Article Hiding. (line 24) * W W s (Summary): Article Hiding. (line 21) * x (Summary): Limiting. (line 22) * X p (Summary): PostScript Files. (line 7) * X P (Summary): PostScript Files. (line 10) * X s (Summary): Shared Articles. (line 7) * X S (Summary): Shared Articles. (line 10) * X u (Summary): Uuencoded Articles. (line 7) * X U (Summary): Uuencoded Articles. (line 10) * X v p (Summary): PostScript Files. (line 14) * X v P (Summary): PostScript Files. (line 18) * X v S (Summary): Shared Articles. (line 18) * X v s (Summary): Shared Articles. (line 14) * X v u (Summary): Uuencoded Articles. (line 14) * X v U (Summary): Uuencoded Articles. (line 17) * y (Server): Server Commands. (line 22) * z (Group): Exiting Gnus. (line 9) * Z C (Summary): Exiting the Summary Buffer. (line 29) * Z c (Summary): Exiting the Summary Buffer. (line 25) * Z E (Summary): Exiting the Summary Buffer. (line 20) * Z G (Summary): Exiting the Summary Buffer. (line 43) * Z n (Summary): Exiting the Summary Buffer. (line 33) * Z N (Summary): Exiting the Summary Buffer. (line 48) * Z P (Summary): Exiting the Summary Buffer. (line 52) * Z R (Summary): Exiting the Summary Buffer. (line 37) * Z Z (Summary): Exiting the Summary Buffer. (line 11)