*** empty log message ***

[gnus] / texi / gnus.texi

\input texinfo                  @c -*-texinfo-*-
@comment %**start of header (This is for running Texinfo on a region.)
@setfilename gnus
@settitle (ding) Gnus 0.1 Manual
@synindex fn cp
@synindex vr cp
@synindex pg cp
@iftex
@finalout
@end iftex
@setchapternewpage odd
@c      @smallbook
@comment %**end of header (This is for running Texinfo on a region.)
@tex
\overfullrule=0pt
%\global\baselineskip 30pt      % For printing in double spaces
@end tex

@ifinfo

This file documents (ding) Gnus, the GNU Emacs newsreader.

Copyright (C) 1989, 1990, 1993, 1995 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.

@ignore
Permission is granted to process this file through Tex and print the
results, provided the printed document carries copying permission
notice identical to this one except for the removal of this paragraph
(this paragraph not being relevant to the printed manual).

@end ignore
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.
@end ifinfo

@titlepage
@title (ding) Gnus Manual

@author by Lars Magne Ingebrigtsen
@page
@vskip 0pt plus 1filll
Copyright @copyright{} 1989, 1990, 1993 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 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.

Cover art by Etienne Suvasa.
@end titlepage
@page

@node Top
@top The Gnus Newsreader

You can read news (and mail) from within Emacs by using (ding) Gnus.
The news can be gotten by any nefarious means you can think of - NNTP,
local spool or your mbox file.  All at the same time, if you want to
push your luck.

@menu
* History::                 How Gnus got where it is today.
* Terminology::             We use really difficult, like, words here.
* Starting Up::             Finding news can be a pain.
* The Group Buffer::        Selecting, subscribing and killing groups.
* The Summary Buffer::      Reading, saving and posting articles.
* The Article Buffer::      Displaying and handling articles.
* Various::                 General purpose settings.
* Customization::           Tailoring Gnus to your needs.
* Troubleshooting::         What you might try if things do not work.
* Reporting Bugs::          Bugs? What bugs?!
* Index::                   Variable, function and concept index.
* Key Index::               Key Index.
@end menu

Note: This is a work of fiction.  Any similarity between this manual and
real programs is purely coincidental.

@node History
@chapter History

@cindex history
@sc{GNUS} was written by Masanobu UMEDA.  When autumn crept up in '94,
Lars Magne Ingebrigtsen grew bored and decided to write (ding) Gnus.

(ding) Gnus is based on @sc{GNUS 4.1} and includes excellent functions
from Per Abrahamsen, lots of fixes by Sudish Joseph, as well as bits and
pieces from the XGnus distribution by Felix Lee and JWZ.

The recommended pronounciation of the name this program is "ding
guh-noose", with "ding" being half-sung in a loud, high-pitched voice,
and "guh-noose" being grumbled and a disaffected fashion.  Any
irritation and/or damage this name may cause you is not the
responsibility of the author, even though you might like to strangle him
for the stupid idea.

If you want to take a look at the person responsible for this outrage,
you can point your (feh!) web browser to
@file{http://www.ifi.uio.no/~larsi/}.  This is also the primary
distribution point for the new and spiffy versions of Gnus, also know as
The Site That Destroys Newsrcs And Drives People Mad.

@dfn{(ding)}, is, of course, short for @dfn{ding is not Gnus}, which is
a total and utter lie, but who cares? (Besides, the "Gnus" in this
abbreviation should probably be pronounced "news" as UMEDA intended,
which makes it a more appropriate name, don't you think?)

@menu
* Compatibility::          Just how compatible is (ding) Gnus with @sc{GNUS}?
* New Features::           A short description of all the new stuff in Gnus.
@end menu

@node Compatibility
@section Compatibility

@cindex compatability
(ding) Gnus was designed to be fully compatible with @sc{GNUS}.  Almost
all key binding have been kept.  More key binding have been added, of
course, but only in one or two obscure cases have key bindings been
changed.

Our motto is:
@quotation
@cartouche
In a cloud bones of steel.
@end cartouche
@end quotation

All commands have kept their names.  Some internal functions have changed
their names.

The @code{gnus-uu} package has changed drastically. @xref{Decoding
Articles}. 

One major compatability question if the presence of several summary
buffers.  The variables that are relevant while reading a group are
buffer-local to the summary buffer they belong in.  Although most
important variables have their values copied into their global
counterparts whenever a command is executed in the summary buffer, this
might lead to incorrect values being used if one is not careful.

All code that relies on knowledge of @sc{GNUS} internals will probably
fail.  To take two examples: Sorting @code{gnus-newsrc-assoc} (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 assoc (which
speeds up many functions), and changing the assoc directly will lead to
peculiar results.

@cindex hilit19
@cindex highlighting
Old hilit19 code does not work at all.  In fact, you should probably
remove all hihit code from all the Gnus hooks
(@code{gnus-group-prepare-hook}, @code{gnus-summary-prepare-hook} and
@code{gnus-summary-article-hook}).  (Well, at the very least the first
two.)  Gnus provides various integrated functions for highlighting,
which are both faster and more accurated. 

Packages like @code{expire-kill} will no longer work.  As a matter of
fact, you should probably remove all old @sc{GNUS} packages (and other
code) when you start using (ding) Gnus.  More likely than not, (ding)
Gnus already do what you have written code to make @sc{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.

(ding) Gnus understands all @sc{GNUS} startup files.

@kindex M-x gnus-bug
Overall, a casual user who hasn't written much code that depends on
@sc{GNUS} internals should suffer no problems.  If problems occur,
please let me know (@kbd{M-x gnus-bug}).

@node New Features
@section New Features
@cindex new features

The look of all buffers can be changed by setting format-like variables.
 
Local spool and several NNTP servers can be used at once.  Virtual
groups and private mail groups are featured.

Gnus can use various strategies for gathering threads that have lost
their roots (thereby gathering loose sub-threads in one thread) or it
can go back and retrieve enough headers to build a complete thread.

Killed groups can be displayed in the group buffer, and you can read
them as well.

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.

Gnus implements a sliding scale of subscribedness to groups.

The approach to killing has been changed.  Instead of simply killing or
not, you can score articles for easier reading.

@node Terminology
@chapter Terminology

@cindex terminology
@table @samp
@item 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.
@item 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.
@item reply
Send a mail to the person who has written what you are reading.
@item follow up
Post an article to the current newsgroup responding to the article you
are reading.
@item 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.
@item native
Gnus will always use one method (and backend) as the @dfn{native}, or
default, way of getting news.
@item foreign
You can also have any number of foreign groups at the same time.  These
are groups that use different backends for getting news.
@item header
A line from the head of an article. 
@item headers
A collection of such lines, or a collection of heads.  Or even a
collection of NOV lines.
@item NOV
When Gnus enters a group, it asks the backend for the headers for all
the unread articles in the group.  Most servers support the News OverView
format, which is much smaller and much faster to read than the normal
HEAD format. 
@end table

@node Starting Up
@chapter Starting Gnus
@cindex starting up

@kindex M-x gnus
If your system administrator has set thing up properly, starting Gnus
and reading news is extremely easy - you just type @kbd{M-x gnus}.

If things do not go smoothly at startup, you have to twiddle some
variables. 

@menu
* Finding the News::    Choosing a method for getting news.
* The First Time::      What does Gnus do the first time you start it?
* The Server is Down::  How can I read my mail then?
* New Groups::          What is Gnus supposed to do with new groups?
* Startup Files::       Those pesky startup files - @file{.newsrc}.
* Auto Save::           Recovering from a crash.
* The Active File::     Reading the active file over a slow line Takes Time.
* Startup Variables::   Other variables you might change.
@end menu

@node Finding the News
@section Finding the News

@vindex gnus-select-method
The @code{gnus-select-method} variable controls how Gnus finds news.
This variable should be a list where the first element says "how" and
the second element says "where".  This method is is your native method.
All groups that are not fetched with this method are foreign groups.

For instance, if you want to get your daily dosage of news from the NNTP
server "news.friendly.server", you'd say:

@lisp
(setq gnus-select-method '(nntp "news.friendly.server"))
@end lisp

If you want to use a local spool, say:

@lisp
(setq gnus-select-method '(nnspool ""))
@end lisp

If you can use the local spool, you probably should, as it will almost
certainly be much faster.

If this variable is not set, Gnus will take a look at the
@code{NNTPSERVER} environment variable.  If that isn't set either, it
will try to use the machine that is running Emacs as an NNTP server.

@vindex gnus-nntp-server
If @code{gnus-nntp-server} is set, this variable will override
@code{gnus-select-method}.  You should therefore set
@code{gnus-nntp-server} to @code{nil}, which is what it is by default.

@vindex gnus-secondary-servers
You can also make Gnus prompt you interactively for the name of an NNTP
server.  If you give a non-numerical prefix to @code{gnus} (ie. @kbd{C-u
M-x gnus}), Gnus will let you choose between the servers in the
@code{gnus-secondary-servers} list (if any).  You can also just type in
the name of any server you feel like visiting.

However, if you use one NNTP server regularly, and is just interested in
a couple of groups from a different server, you would be better served
by using the @code{gnus-group-browse-foreign-server} command from the
group buffer.  It will let you have a look at what groups are available,
and you can subscribe to any of the groups you want to.  This also makes
@file{.newsrc} maintenance much tidier.  @xref{Foreign Groups}.

@vindex gnus-secondary-select-methods
A slightly different approach to foreign groups is to set the
@code{gnus-secondary-select-methods} variable.  The select methods
listed in this variable are in many ways just as native as the
@code{gnus-select-method} server.  They will also be asked for active
files during startup (if that's required), and new newsgroups that
appear on these servers will be subscribed (or not) just as native
groups are.

For instance, if you use the @code{nnmbox} backend to read you mail, you
would typically set this variable to

@lisp
(setq gnus-secondary-select-methods 
  '((nnmbox "")))
@end lisp

@node The First Time
@section The First Time
@cindex first time usage

If no startup files exist, Gnus will try to determine what groups should
be subscribed by default.

@vindex gnus-default-subscribed-newsgroups
If the variable @code{gnus-default-subscribed-newsgroups} is set, Gnus
will subscribe you to just those groups in that list, leaving the rest
killed.  Your system administrator should have set this variable to
something useful.

Since she hasn't, Gnus will just subscribe you to a few randomly picked
groups (ie. @samp{*.newusers}).  (@dfn{Random} is here defined as
"whatever Lars thinks you should read".)

You'll also be subscribed to the Gnus documentation group, which should
help you with most common problems.  

If @code{gnus-default-subscribed-newsgroups} is @code{t}, Gnus will just use
the normal functions for handling new groups, and not do anything
special.

@node The Server is Down
@section The Server is Down
@cindex server errors

If the default server is down, Gnus will understandably have some
problems starting.  However, if you have some mail groups in addition to
the news groups, you may want to start Gnus anyway.

@findex gnus-no-server
You can do that by @kbd{M-x gnus-no-server}.  This will start Gnus
without attempting to contact the default server.  Gnus will be started
on level two, so you shouldn't have any groups from the native server on
level one or two, but only have mail groups and other foreign groups on
these two levels.

@node New Groups
@section New Groups
@cindex new groups

@vindex gnus-subscribe-newsgroup-method
What Gnus does when it encounters a new group is determined by the
@code{gnus-subscribe-newsgroup-method} variable.

This variable should contain a function.  Some handy pre-fab values
are:

@table @code
@item gnus-subscribe-randomly
@vindex gnus-subscribe-randomly
Subscribe all new groups randomly.
@item gnus-subscribe-alphabetically
@vindex gnus-subscribe-alphabetically
Subscribe all new groups alphabetically.
@item gnus-subscribe-hierarchically
@vindex gnus-subscribe-hierarchically
Subscribe all new groups hierarchially.
@item gnus-subscribe-interactively
@vindex gnus-subscribe-interactively
Subscribe new groups interactively.  This means that Gnus will ask
you about @strong{all} new groups.
@item gnus-subscribe-zombies
@vindex gnus-subscribe-zombies
Make all new groups zombies.  You can browse the zombies later and
either kill them all off properly, or subscribe to them.  This is the
default.
@end table

@vindex gnus-subscribe-hierarchical-interactive
A closely related variable is
@code{gnus-subscribe-hierarchical-interactive}.  (That's quite a
mouthful.)  If this variable is non-@code{nil}, Gnus will ask you in a
hierarchial fashion whether to subscribe to new groups or not.  Gnus
will ask you for each sub-hierarchy whether you want to descend the
hierarchy or not.

One common way to control which new newsgroups should be subscribed or
ignored is to put an @dfn{options} line at the start of the
@file{.newsrc} file.  Here's an example:

@example
options -n !alt.all !rec.all sci.all
@end example

@vindex gnus-subscribe-options-newsgroup-method
This line obviously belongs to a serious-minded intellectual scientific
person (or she may just be plain old boring), because it says that all
groups that have names beginning with @samp{alt} and @samp{rec} should
be ignored, and all groups with names beginning with @samp{sci} should
be subscribed.  Gnus will not use the normal subscription method for
subscribing these groups.
@code{gnus-subscribe-options-newsgroup-method} is used instead.  This
variable defaults to @code{gnus-subscribe-alphabetically}.

@vindex gnus-options-not-subscribe
@vindex gnus-options-subscribe
If you don't want to mess with your @file{.newsrc} file, you can just
set the two variables @code{gnus-options-subscribe} and
@code{gnus-options-not-subscribe}.  These two variables do exactly the
same as the @file{.newsrc} options -n trick.  Both are regexps, and if
the the new group matches the first, it will be unconditionally
subscribed, and if it matches the latter, it will be ignored.

@vindex gnus-check-new-newsgroups
If you are satisfied that you really never want to see any new groups,
you could set @code{gnus-check-new-newsgroups} to @code{nil}.  This will
also save you some time at startup.  Even if this variable is
@code{nil}, you can always subscribe to the new groups just by pressing
@kbd{U} in the group buffer (@pxref{Group Maintenance}).

Gnus normally determine whether a group is new or not by comparing the
list of groups from the active file(s) with the lists of subscribed and
dead groups.  This isn't a particularly fast method.  If
@code{gnus-check-new-newsgroups} is @code{ask-server}, Gnus will ask the
server for new groups since the last time.  This is both faster &
cheaper.  This also means that you can get rid of the list of killed
groups altogether, so you may set @code{gnus-save-killed-list} to
@code{nil}, which will save time both at startup, at exit, and all over.
Saves disk space, too.  Why isn't this the default, then?
Unfortunately, not all servers support this function.

This variable can also be a list of select methods.  If so, Gnus will
issue an @code{ask-server} command to each of the select methods, and
subscribe them (or not) using the normal methods.  This might be handy
if you are monitoring a few servers for new groups.  A side effect is
that startup will take much longer, so you can meditate while waiting.
Use the mantra "dingnusdingnusdingnus" to achieve permanent happiness.

@node Startup Files
@section Startup Files
@cindex startup files
@cindex .newsrc

Now, you all know about the @file{.newsrc} files.  All information about
what groups you read is traditionally stored in this file, which has a
rather rigid structure.

Things got a bit more complicated with @sc{GNUS}.  In addition to
keeping the @file{.newsrc} file updated, it also used a file called
@file{.newsrc.el} for storing all the information that didn't fit into
the @file{.newsrc} file.  (Actually, it duplicated everything in the
@file{.newsrc} file.)  @sc{GNUS} would read whichever one of these files
that were the most recently saved, which enabled people to swap between
@sc{GNUS} and other newsreaders.

That was kinda silly, so (ding) Gnus went one better: In addition to the
@file{.newsrc} and @file{.newsrc.el} files, (ding) Gnus also has a file
called @file{.newsrc.eld}.  It will read whichever of these files that
are most recent, but it will never write a @file{.newsrc.el} file.

@vindex gnus-save-newsrc-file
You can also turn off writing @file{.newsrc} by setting
@code{gnus-save-newsrc-file} to @code{nil}, which means you can delete
the file and save some space, as well as some time when quitting Gnus.
However, that will make it impossible to use other newsreaders than
(ding) Gnus.  But hey, who would want to, right?

@vindex gnus-save-killed-list
If @code{gnus-save-killed-list} is @code{nil}, Gnus will not save the
list of killed groups to the startup file.  This will save both time
(when starting and quitting) and space (on disk).  It will also means
that Gnus has no record of what groups are new or old, so the automatic
new groups subscription methods become meaningless.  You should always
set @code{gnus-check-new-newsgroups} to @code{nil} if you set this
variable to @code{nil}.

@vindex gnus-startup-file
The @code{gnus-startup-file} variable says where the startup files are.
The default value is @file{"~/.newsrc"}, with the Gnus (El Dingo)
startup file being whatever that one is with a @samp{".eld"} appended.

@vindex gnus-save-newsrc-hook
@code{gnus-save-newsrc-hook} is called before saving the @file{.newsrc}
file.

@node Auto Save
@section Auto Save
@cindex dribble file
@cindex auto-save

Whenever you do something that changes the Gnus data (reading articles,
cathing up, killing/subscribing to groups,) the change is added to a
special @dfn{dribble} buffer.  This buffer is auto-saved the normal
Emacs way.  If your Emacs should crash before you have saved the
@file{.newsrc} files, all changes you have made can be recovered from
this file. 

If Gnus detects this file at startup, it will ask the user whether to
read it.

The auto save file is deleted whenever the real startup file is saved. 

@vindex gnus-use-dribble-file
If @code{gnus-use-dribble-file} is @code{nil}, Gnus won't create and
maintain a dribble buffer.

@node The Active File
@section The Active File
@cindex active file
@cindex ignored groups

When Gnus starts, or indeed whenever it tries to determine whether new
articles have arrived, it reads the active file.  This is a large file
that the NNTP server maintains to keep track of what groups it carries.

@vindex gnus-ignored-newsgroups
Before examining the active file to see what groups are available, Gnus
deletes all lines in this file that match the regexp
@code{gnus-ignored-newsgroups}.  This is done primarily to reject any
groups with bogus names (eg. groups containing characters like
@samp{'[]"} and so on), but you can use this variable to make Gnus
ignore hierarchies you aren't ever interested in.

@vindex gnus-read-active-file
The active file can be rather Huge, so if you have a slow network, you
can set @code{gnus-read-active-file} to @code{nil} to prevent Gnus from
reading the active file.

Gnus will try to make do by just getting information on the groups
that you actually subscribe to.

Note that if you subscribe to lots and lots of groups, setting this
variable to @code{nil} will probabaly make Gnus slower, not faster.  At
present, having this variable @code{nil} will slow Gnus down
considerably, unless you read news over a 2400 baud modem.  Gnus does
the group info fetching in total lock-step, so if you have this variable
@code{nil}, you should kill all groups that you aren't interested in to
speed things up.

There are plans for doing lots of Gnus stuff asynchronously, which
should make this option more useful, but that's probably some ways off
in the future.

@node Startup Variables
@section Startup Variables

@table @code
@item gnus-check-bogus-newsgroups
@vindex gnus-check-bogus-newsgroups
If non-@code{nil}, Gnus will check for and delete all bogus groups at
startup.  A @dfn{bogus group} is a group that you have in your
@file{.newsrc} file, but doesn't exist on the news server.  Checking for
bogus groups isn't very quick, so to save time and resources, it's best
to leave this option off, and instead do the checking for bogus groups
once in a while from the group buffer (@pxref{Group Maintenance}).
@item gnus-inhibit-startup-message
@vindex gnus-inhibit-startup-message
If non-@code{nil}, the startup message won't be displayed.  That way,
your boss might not notice thay you are reading news instead of doing
your job.
@end table

@node The Group Buffer
@chapter The Group Buffer
@cindex group buffer

The @dfn{group buffer} lists all (or parts) of the available groups.  It
is the first buffer shown when Gnus starts, and will never be killed as
long as Gnus is active.

@menu
* Group Buffer Format::    Information listed and how you can change it.
* Group Manouvering::      Commands for moving in the group buffer.
* Selecting a Group::      Actually reading news.
* Group Subscribing::      Unsubscribing, killing, subscribing.
* Group Levels::           Levels? What are those, then?
* Foreign Groups::         How to create foreign groups.
* Listing Groups::         Gnus can list various subsets of the groups.
* Group Maintenance::      Maintaining a tidy @file{.newsrc} file.
* Browse Foreign Server::  You can browse a server.  See what if has to offer.
* Exiting Gnus::           Stop reading news and get some work done.
* Misc Group Stuff::       Other stuff that you can to do.
@end menu

@node Group Buffer Format
@section Group Buffer Format
@cindex group buffer format

The default format of the group buffer is nice and dull, but you can
make it as exciting and ugly as you feel like.

Here's a couple of example group lines:

@example
     25: news.announce.newusers
 *    0: alt.fan.andrea-dworkin
@end example

Quite simple, huh?

Those lines mean that there are 25 unread articles in
@samp{news.announce.newusers} and no unread articles, but some ticked
articles in @samp{alt.fan.andrea-dworkin} (see that little asterisk at
the beginning of the line?)

@vindex gnus-group-line-format
You can fuck that up to your heart's delight by fiddling with the
@code{gnus-group-line-format} variable.  This variable works along the
lines of a @code{format} specification, which is pretty much the same as
a @code{printf} specifications, for those of you who use (feh!) C.

In addition to the normal "padding" specs that @code{format} supports
(eg. @samp{%7d}), specifications like @samp{%7,12s} are allowed.  A spec
of this type means that the field will be at least 7 characters long,
and never more that 12 characters long.

The default value that produced those lines above is 
@samp{"%M%S%5y: %(%g%)\n"}.

There should always be a colon on the line; the cursor always move to
the colon after performing an operation.  Nothing else is required - not
even the group name.  All displayed text is just window dressing, and is
never examined by Gnus.  Gnus stores all real information it needs using
text properties.

(Note that if you make a really strange, wonderful, spreadsheat-like
layout, everybody will believe you are hard at work with the accounting
instead of wasting time reading news.)

Here's a list of all available format characters:

@table @samp
@item M    
Only marked articles
@item S
Whether the group is subscribed 
@item L    
Level of subscribedness 
@item N
Number of unread articles
@item I
Number of dormant articles
@item T
Number of ticked articles
@item R
Number of read articles
@item t
Total number of articles
@item y
Number of unread, unticked, non-dormant articles
@item i
Number of ticked and dormant articles
@item g
Full group name
@item G
Group name 
@item D
Newsgroup description
@item o
Moderated
@item O
Moderated
@item s
Select method 
@item n
Select from where
@item z
A string that look like @samp{<%s:%n>} if a foreign select method is
used. 
@item u
User defined specifier.  The next character in the format string should
be a letter.  @sc{GNUS} will call the function gnus-user-format-function-X,
where X is the letter following %u.  The function will be passed the
current headers as argument.  The function should return a string, which
will be inserted into the buffer just like information from any other
specifier.
@end table

@vindex gnus-group-mode-line-format
The mode line can be changed by setting
(@code{gnus-group-mode-line-format}).  It doesn't understand that many
format specifiers:

@table @samp
@item S
Default news server
@item M
Default select method
@end table

@node Group Manouvering
@section Group Manouvering
@cindex group movement

All movement commands understand the numeric prefix and will behave as
expected, hopefully. 

@table @kbd
@item n
@kindex n (Group)
@findex gnus-group-next-unread-group
Go to the next group with unread articles
(@code{gnus-group-next-unread-group}). 
@item p
@item DEL
@kindex DEL (Group)
@kindex p (Group)
@findex gnus-group-prev-unread-group
Go to the previous group group with unread articles
(@code{gnus-group-prev-unread-group}). 
@item N
@kindex N (Group)
@findex gnus-group-next-group
Go to the next group (@code{gnus-group-next-group}).
@item P
@kindex P (Group)
@findex gnus-group-prev-group
Go to the previous group (@code{gnus-group-prev-group}).
@item M-p
@kindex M-p (Group)
@findex gnus-group-next-unread-group-same-level
Go to the next unread group on the same level (or lower)
(@code{gnus-group-next-unread-group-same-level}). 
@item M-n
@kindex M-n (Group)
@findex gnus-group-prev-unread-group-same-level
Go to the previous unread group on the same level (or lower)
(@code{gnus-group-prev-unread-group-same-level}). 
@end table

Two commands for jumping to groups:

@table @kbd
@item j
@kindex j (Group)
@findex gnus-group-jump-to-group
Jump to a group (and make it visible if it isn't already)
(@code{gnus-group-jump-to-group}).  Killed groups can be jumped to, just
like living groups.
@item ,
@kindex , (Group)
@findex gnus-group-best-unread-group
Jump to the unread group with the lowest level
(@code{gnus-group-best-unread-group}). 
@end table

@node Selecting a Group
@section Selecting a Group
@cindex group selection

@table @kbd
@item SPACE
@kindex SPACE (Group)
@findex gnus-group-read-group
Select the current group, switch to the summary buffer and display
the first unread article in the group
(@code{gnus-group-read-group}).  If there are no unread articles in the
group, or if you give a prefix to this command, Gnus will offer to
fetch all the old articles in this group from the server.
server. 
@item RET
@kindex RET (Group)
@findex gnus-group-select-group
Select the current group and switch to the summary buffer
(@code{gnus-group-select-group}).  If you give a prefix to this command,
Gnus will fetch all available articles in this group.
@item c
@kindex c (Group)
@findex gnus-group-catchup-current
Mark all unticked articles in this group as read
(@code{gnus-group-catchup-current}). 
@item C
@kindex C (Group)
@findex gnus-group-catchup-current-all
Mark all articles in this group, even the ticked ones, as read
(@code{gnus-group-catchup-current-all}). 
@end table

@vindex gnus-large-newsgroup
The @code{gnus-large-newsgroup} variable says what Gnus should consider
to be a big group.  If the group has more unread articles than this
variable, Gnus will query the user before entering the group.  The user
can then specify how many articles should be fetched from the server.
If the user specifies a negative number (@samp{-n}), the @samp{n} oldest
articles will be fetched.  If it is positive, the @samp{n} articles that
have arrived most recently will be fetched.

@vindex gnus-select-group-hook
@vindex gnus-auto-select-newsgroup
If @code{gnus-auto-select-newsgroup} is non-@code{nil}, the first unread
article in the group will be displayed when you enter the group.  If you
want to prevent automatic selection in some group (say, in a binary
group with Huge articles) you can set this variable to @code{nil} in
@code{gnus-select-group-hook}, which is called when a group is selected.

@findex gnus-thread-sort-by-total-score
@findex gnus-thread-sort-by-date
@findex gnus-thread-sort-by-score
@findex gnus-thread-sort-by-subject
@findex gnus-thread-sort-by-author
@findex gnus-thread-sort-by-number
@vindex gnus-thread-sort-functions
If you are using threaded summary display, you can sort the threads by
setting @code{gnus-thread-sort-functions}, which is a list of functions.
By default, sorting is done on article numbers.  Ready-made sorting
functions include @code{gnus-thread-sort-by-number},
@code{gnus-thread-sort-by-author}, @code{gnus-thread-sort-by-subject},
@code{gnus-thread-sort-by-date}, @code{gnus-thread-sort-by-score},
@code{gnus-thread-sort-by-total-score}. 

Each function takes two threads and return non-@code{nil} if the first
thread should be sorted before the other.  If you use more than one
function, the primary sort key should be the last function in the list.

If you would like to sort by score, then by subject, and finally by
date, you could do something like:

@lisp
(setq gnus-thread-sort-functions 
      '(gnus-thread-sort-by-date
        gnus-thread-sort-by-subject
        gnus-thread-sort-by-score))
@end lisp

@vindex gnus-thread-score-function
The function in the @code{gnus-thread-score-function} variable (default
@code{+}) is used for calculating the total score of a thread.  Useful
functions might be @code{max}, @code{min}, or squared means, or whatever
tickles you fancy.

@node Group Subscribing
@section Group Subscribing
@cindex subscribing

@table @kbd
@item u
@kindex u (Group)
@findex gnus-group-unsubscribe-current-group
Unsubscribe the current group, or, if it was unsubscribed already,
subscribe it (@code{gnus-group-unsubscribe-current-group}). 
@item U
@kindex U (Group)
@findex gnus-group-unsubscribe-group
Ask the user for a group to unsubscribe, and then unsubscribe it.  If
it was unsubscribed already, subscribe it instead
(@code{gnus-group-unsubscribe-group}). 
@item C-k
@kindex C-k (Group)
@findex gnus-group-kill-group
Kill the current group (@code{gnus-group-kill-group}).
@item C-y
@kindex C-y (Group)
@findex gnus-group-yank-group
Yank the last killed group (@code{gnus-group-yank-group}).
@item C-w
@kindex C-w (Group)
@findex gnus-group-kill-region
Kill all groups in the region (@code{gnus-group-kill-region}). 
@item M-z
@kindex M-z (Group)
@findex gnus-group-kill-all-zombies
Kill all zombie groups (@code{gnus-group-kill-all-zombies}).
@end table

@node Group Levels
@section Group Levels
@cindex group level

All groups have a level of @dfn{subscribedness}.  For instance, if a
group is on level 2, it is more subscribed than a group on level 5.  You
can ask Gnus to just list groups on a given level and lower
(@pxref{Listing Groups}), or to just check for new articles in groups on
a given level and lower (@pxref{Misc Group Stuff}).

@table @kbd
@item S
@kindex S (Group)
@findex gnus-group-set-current-level
Set the level of the current group depending on the numeric
prefix.  For instance, @kbd{3 s} will set the level of the current
group to three (@code{gnus-group-set-current-level}).  If no numeric
prefix is given, this command will prompt the user for a level.
@end table

Gnus considers groups on levels 1-5 to be subscribed, 6-7 to be
unsubscribed, 8 to be zombies (walking dead) and 9 to be killed,
completely dead.  Gnus treats subscribed and unsubscribed groups exactly
the same, but zombie and killed groups have no information on what
articles you have read, etc, stored.  This distinction between dead and
living groups isn't done because it is nice or clever, it is done purely
for reasons of efficiency. 

It is recommended that you keep all regular groups on level 3 or higher,
and keep your mail groups (if any) on level 1 or 2.

@vindex gnus-keep-same-level
If @code{gnus-keep-same-level} is non-@code{nil}, some movement commands
will only move to groups that are of the same level (or lower).  In
particular, going from the last article in one group to the next group
will go to the next group of the same level (or lower).  This might be
handy if you want to read the most important groups before you read the
rest.

@node Foreign Groups
@section Foreign Groups
@cindex foreign groups

A @dfn{foreign group} is a group that is not read by the usual (or
default) means.  It could be, for instance, a group from a different
NNTP server, it could be a virtual group, or it could be your own
personal mail group.

A foreign group (or any group, really) is specified by a @dfn{name} and
a @dfn{select method}.  To take the latter first, a select method is a
list where the first element says what backend to use (eg. nntp,
nnspool, nnml) and the second element is the "address", in some meaning of
the word.  There may be additional elements in the select method, where
the value may have special meaning for the backends.

The @dfn{name} of the group is the name the backend will recognize the
group as.

For instance, the group @samp{soc.motss} on the NNTP server
@samp{some.where.edu} will have the name @samp{soc.motss} and select
method @samp{(nntp "some.where.edu")}.  Gnus will call this group, in
all circumstances @samp{nntp+some.where.edu:soc.motss}, even though the
nntp backend just knows this group as @samp{soc.motss}.

Here are some commands for making and editing general foreign groups,
and some commands to ease the creation of some special-purpose groups:

@table @kbd
@item M m
@kindex M m (Group)
@findex gnus-group-make-group
Make a new group.  Gnus will prompt you for a name, a method and an
"address" (@code{gnus-group-make-group}).
@item M e
@kindex M e (Group)
@findex gnus-group-edit-group
Edit a group entry.  Gnus will pop up a new buffer where you can edit
the entry (@code{gnus-group-edit-group}).
@item M d
@kindex M d (Group)
@findex gnus-group-make-directory-group
Make a directory group.  You will be prompted for a directory name
(@code{gnus-group-make-directory-group}).  
@item M h 
@kindex M h (Group)
@findex gnus-group-make-help-group
Make the (ding) Gnus help group (@code{gnus-group-make-help-group}).
@item M k
@kindex M k (Group)
@findex gnus-group-make-kiboze-group
Make a kiboze group.  You will be prompted for a name, for a regexp to
match groups to be "included" in the kiboze group, and a series of
strings to match on headers (@code{gnus-group-make-kiboze-group}).
@end table

The different methods all have their peculiarities, of course.

@menu
* nntp::           Reading news from a different NNTP server.
* nnspool::        Reading news from the local spool.
* nnvirtual::      Combining articles from many groups.
* nnkiboze::       Looking through parts of the newsfeed for articles.
* nndir::          You can read a directory as if it was a newsgroup.
* nndoc::          Single files can be the basis of a group.
* nndigest::       Digests can be undigested and treated as a group.
* Mail::           Reading your personal mail with Gnus.
@end menu

@vindex gnus-activate-foreign-newsgroups
If the @code{gnus-activate-foreign-newsgroups} is a positive number,
Gnus will check all foreign groups with this level or lower at startup.
This might take quite a while, especially if you subscribe to lots of
groups from different NNTP servers.  It is @code{nil} by default, which
means that you won't be told whether there are new articles in these
groups.  How many unread articles there are will be determined when, or
if, you decide to enter them.  You can also activate any group with
@kbd{M-g} to see how many unread articles there are.

@cindex to-address
If the select method contains an element that looks like
@samp{(to-address .  "some@@where.com")}, that address will be used by
the backend when doing followups and posts.  This is primarily useful in
mail groups that represent mailing lists.  You'd then just set this
address to whatever the list address is.

This trick will actually work whether the group is foreign or not.
Let's say there's a group on the server that is called @samp{fa.4ad-l}.
This is a real group, but the server has gotten the articles from a
mail-to-news gateway.  Posting directly to this group is therefore
impossible - you have to send mail to the mailing list address instead. 

To achieve this, go to the group in question in the group buffer and
type @kbd{M e} to edit the group entry.  You'll then be put in a buffer
where you can edit the group entry.

@lisp
(gnus-group-set-info
 '("ifi.fritt-forum" 3
   ((1 . 3321)
    (3325 . 3325))
   ((score
     (3322 . 1000)
     (3324 . 1000)))))
@end lisp

A fifth entry has to be added. (In case there isn't a fourth one, you
have to add a fourth one yourself - @code{nil}.)  The fifth entry should
look like this:

@lisp
(nntp "your.host" (to-address . "4ad-l@@jhuvm.hcf.jhu.edu"))
@end lisp

The two first entries in this method should, of course, be the same as
@code{gnus-select-method}. 

Quite simple, eh? <duck> *Ouch*.

Let's take time out for a poem by Reznikoff:

@quotation
Te Deum
@sp 2
Not because of victories @*
I sing,@*
having none,@*
but for the common sunshine,@*
the breeze,@*
the largess of the spring.
@sp 2
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.@*
@end quotation

@node nntp
@subsection nntp
@cindex nntp

Subscribing to a foreign group from an NNTP server is rather easy.  You
just specify @code{nntp} as method and the address of the NNTP server as
the, uhm, address.

If the NNTP server is located at a non-standard port number, setting the
third element of the select method to this port number should allow you
to connect to the right port.  You'll have to edit the group info for
that (@pxref{Foreign Groups}).

The name of the foreign group can be the same as a native group.  In
fact, you can subscribe to the same group from as many different servers
you feel like.  There will be no name collisions.

@vindex nntp-server-opened-hook
@code{nntp-server-opened-hook} is run after a connection has been made.
It can be used to send initial commands to the NNTP server, like
@samp{(nntp-send-command "MODE" "READER")} (which is what this hook does
by default) or to send the @code{AUTHINFO} command, if the server
requires that.

@vindex nntp-maximum-request
If the NNTP server doesn't support NOV headers, this backend will
collect headers by sending a series of @code{HEAD} commands.  To speed
things up, the backend sends lots of these commands, without waiting for
reply, and then reads all the replies.  This is controlled by the
@code{nntp-maximum-request} variable, and is 400 by default.  If your
network is buggy, you should set this to 1.

@vindex nntp-connection-timeout
If you have lots of foreign nntp groups that you connect to regularly,
you're sure to have problems with nntp servers not responding properly,
or being too loaded to reply within reasonable time.  This is can lead
to awkward problems, which can be helped somewhat by setting
@code{nntp-connection-timeout}.  This is an integer that says how many
seconds the nntp backend should wait for a connection before giving up.
If it is @code{nil}, which is the default, no timeouts are done.

@node nnspool
@subsection nnspool
@cindex nnspool
@cindex news spool

Subscribing to a foreign group from the local spool is extremely easy,
and might be useful, for instance, to speed up reading groups like
@samp{alt.binaries.pictures.furniture}.

Anyways, you just specify @code{nnspool} as the method and @samp{""} (or
anything else) as the address.

If you have access to a local spool, you should probably use that as the
native select method (@pxref{Finding the News}).

@table @code
@item nnspool-inews-program
Program used to post an article.
@item nnspool-spool-directory
Where nnspool looks for the articles.  This is normally
@file{/usr/spool/news/}.
@item nnspool-nov-directory 
Where nnspool will look for NOV files.  This is normally 
@file{/usr/spool/news/over.view/}.
@item nnspool-lib-dir
Where the news lib dir is (@file{/usr/lib/news/} by default).
@end table

@node nnvirtual
@subsection nnvirtual
@cindex nnvirtual
@cindex virtual groups

A @dfn{virtual group} is really nothing more than a collection of
other groups. 

You specify @code{nnvirtual} as the method and a regular expression that
says which groups that you wish to have in this one as the address. 

For instance, if you are tired of reading many small group, you can
put them all in one big group, and then grow tired of reading one
big, unwieldy group.  The joys of computing!

All marks, read status, etc., in the nnvirtual group will stick to the
articles in the component groups.  So if you tick an article in an
nnvirtual group, the article will also be ticked in the component group
from whence it it.  (And vice versa - marks from the component groups
will also be shown in the nnvirtual group.)

@example
"^alt\\.fan\\.andrea-dworkin$\\|^rec\\.dworkin.*"
@end example

These groups can be native or foreign; everything should work smoothly,
but if your computer explodes, it was probably my fault.  

Collecting the same group from several servers might actually be a good
idea if users have set the Distribution headers to limit distribution. 
If you would like to read @samp{soc.motss} both from a server in Japan
and a server in Norway, you could use the following as the group regexp:

@example
"^nntp+some.server.jp:soc.motss\\|^nntp+some.server.no:soc.motss"
@end example

This should work kinda smoothly - all articles from both groups should
end up in this one, and there should be no duplicates.  Threading (and
the rest) will still work as usual, but there might be problems with the
sequence of articles.  Sorting on date might be an option here.

One limitation, however - all groups that are included in a virtual
group has to be alive (ie. subscribed or unsubscribed).  Killed or
zombie groups can't be component groups for nnvirtual groups.

@node nnkiboze
@subsection nnkiboze
@cindex nnkiboze
@cindex kibozing

@dfn{kibozing} is defined by OED as "grepping through (parts of) the
news feed".  nnkiboze is a backend that will do this for you.  Oh joy!
Now you can grind any NNTP server down to a halt with useless requests!
Oh happiness!

The address field of the nnkiboze method is, as with nnvirtual, a regexp
to match groups to be "included" in the nnkiboze group.  There most
similarities between nnkiboze and nnvirtual ends.

In addition to this regexp detailing component groups, an nnkiboze group
must have a score file to say what articles that are to be included in
the group.

@kindex M-x nnkiboze-generate-groups
@findex nnkiboze-generate-groups
After creating the nnkiboze groups you feel like having, you must run
@kbd{M-x nnkiboze-generate-groups}.  (This can also be reached from one
of the menus.) This will take time.  Lots of time.  Oodles ond oodles of
time.  Gnus has to fetch the headers from all the articles on all the
components groups and run them through the scoring process to determine
if there are any articles in the groups that are to be part of the
nnkiboze groups.

Please limit the number of component groups by using restrictive
regexps.  Or your sysadm may become annoyed with you, and the NNTP site
may throw you off and never let you back in again.  Stranger things have
happened.

nnkiboze component groups do not have to be alive - they can be dead,
and they can be foreign.  No restrictions.

@vindex nnkiboze-directory
The generation of an nnkiboze group means writing two files in
@code{nnkiboze-directory}, which is @file{~/News/} by default.  One
contains the NOV header lines for all the articles in the group, and the
other is an additional @file{.newsrc} to store information on what
groups that have been searched through to find component articles.

Articles that are marked as read in the nnkiboze group will have their
NOV lines removed from the NOV file.

@node nndir
@subsection nndir
@cindex nndir
@cindex directory groups

If you have a directory that has lots of articles in separate files in
it, you might treat it as a newsgroup.  The files have to have numerical
names, of course.

This might be an opportune moment to mention ange-ftp, that most
wonderful of all wonderful Emacs packages.  When I wrote nndir, I didn't
think much about it - a backend to read directories.  Big deal.

ange-ftp changes that picture dramatically.  For instance, if you enter
@file{/ftp/amanda} as the the directory name, ange-ftp will actually
allow you to read this directory over at amanda as a newsgroup.
Distributed news ahoy!

nndir supports, and will use, NOV files if they are present.

@node nndoc
@subsection nndoc
@cindex nndoc
@cindex documentation group
@cindex help group

nndoc is a cute little thing that will let you read a single file as a
newsgroup.  The file has to be divided into articles by the use of Unix
mbox "From " lines.  nndoc will not try to change the file or insert any
extra headers into it - it will simply, like, let you use the file as
the basis for a group.  And that's it.

@node nndigest
@subsection nndigest
@cindex nndigest
@cindex digest groups

nndigest is a bit odd.  It will use a buffer containing a valid digest
as the basis of the group.

These nndigest groups are rather ephemeral.  They will never store
information on what articles you have read, and you can't really use
them as foreign groups at all.  The only way to reach an nndigest group
is to type @kbd{V D} on a digest in the summary buffer.

When you have finished reading the digest and press @kbd{q}, you will be
returned to the group from whence you came instead of going to the group
buffer.

Odd all over, as you can see, but somewhat useful.

@node Mail
@subsection Mail
@cindex reading mail
@cindex mail

Reading mail with a newsreader - isn't that just plain WeIrD? But of
course.

@menu
* Creating Mail Groups::         How to create mail groups.
* Mail & Procmail::              Reading mail groups that procmail create.
* Expiring Old Mail Articles::   Getting rid of unwanted mail.
@end menu

Gnus will read the mail spool when you activate a mail group.  The mail
file is first copied to your home directory.  What happens after that
depends on what format you want to store your mail in.

@menu
* nnmbox::    Using the (quite) standard Un*x mbox.
* nnbabyl::   Many Emacs programs use the rmail babyl format.
* nnml::      Store your mail in a private spool?
* nnmh::      An mhspool-like backend useful for procmail people.
* nnfolder::  Having one file for each group.
@end menu

@vindex nnmail-read-incoming-hook
The mail backends all call @code{nnmail-read-incoming-hook} after
reading new mail.  You can use this hook to notify any mail watch
programs, if you want to.

@vindex nnmail-spool-file
@code{nnmail-spool-file} says where to look for new mail.  If this
variable is @code{nil}, the mail backends will never attempt to fetch
mail by themselves.

Gnus gives you all the opportunity you want for shooting yourself in
your foot.  Let's say you create a group that will contain all the mail
you get from your boss.  And then you accidentally unsubscribe from the
group.  Gnus will still put all the mail from your boss in the
unsubscribed group, and so, when your boss mails you "Have that report
ready by Monday or you're fired!", you'll never see it and, come
Tuesday, you'll still believe that you're gainfully unemplyed while you
really should be out collecting empty bottles to save up for next
month's rent money.

@node Creating Mail Groups
@subsubsection Creating Mail Groups
@cindex creating mail groups

You can make Gnus read your personal, private, secret mail.

You should first set @code{gnus-secondary-select-methods} to, for
instance, @code{((nnmbox ""))}.  When you start up Gnus, Gnus will ask
this backend for what groups it carries (@samp{mail.misc} by default)
and subscribe it the normal way.  (Which means you may have to look for
it among the zombie groups, I guess, all depending on your
@code{gnus-subscribe-newsgroup-method} variable.)

@vindex nnmail-split-methods
The you should set the variable @code{nnmail-split-methods} to specify
how the incoming mail is to be split into groups.

@lisp
(setq nnmail-split-methods
  '(("mail.junk" "^From:.*Lars Ingebrigtsen")
    ("mail.crazzy" "^Subject:.*die\\|^Organization:.*flabby")
    ("mail.other" "")))
@end lisp

This variable is a list of lists, where the first element of each of
these lists contain the name of the mail group (they do not have to be
called something beginning with @samp{"mail"}, by the way), and the
second element is a regular expression used on the header of each mail
to determine if it belongs in this mail group.

The second element can also be a function.  In that case, it will be
called narrowed to the headers with the first element of the rule as the
argument.  It should return a non-@code{nil} value if it thinks that the
mail belongs in that group.

The last of these groups should always be a general one, and the regular
expression should *always* be @samp{""} so that it matches any mails
that haven't been matched by any of the other regexps.

@vindex nnmail-crosspost
The mail backends all support cross-posting.  If several regexps match,
the mail will be "cross-posted" to all those groups.
@code{nnmail-crosspost} says whether to use this mechanism or not.

@node Mail & Procmail
@subsubsection Mail & Procmail
@cindex procmail

Many people use @code{procmail} to split incoming mail into groups.  If
you do that, you should set @code{nnmail-spool-file} to @code{nil} to
make sure that the mail backends never ever try to fetch mail by
themselves.

This also means that you probably don't want to set
@code{nnmail-split-methods} either, which has some, perhaps, unexpected
side effects.

When a mail backend is queried for what groups it carries, it replies
with the contents of that variable, along with any groups it has figured
out that it carries by other means.  None of the backends (except
@code{nnmh}) actually go out to the disk and check what groups that
actually exists.  (It's not trivial to distinguish between what the user
thinks is a basis for a newsgroup and what is just a plain old file or
directory.)

This means that you have to tell Gnus (and the backends) what groups
exist by hand.

Let's take the @code{nnfolder} backend as an example.  (This backend
features one file as the basis of each group.)  

The folders are located in @code{nnfolder-directory}, say,
@file{~/Mail/}.  There are three folders, @file{foo}, @file{bar} and
@file{mail.baz}.

Go to the group buffer and type @kbd{M m}.  When prompted, answer
@samp{foo} for the name, @samp{nnfolder} for the method and @samp{""}
for the address.  Repeat twice for the two other groups, @samp{bar} and
@code{mail.baz}.  Be sure to include all your mail groups.

That's it.  You are now set to read your mail.

@node Expiring Old Mail Articles
@subsubsection Expiring Old Mail Articles
@cindex article expiry

Traditional mail readers have a tendency to remove mail articles when
you mark them as read, in some way.  Gnus takes a fundamentally
different approach to mail reading.

Gnus basically considers mail just to be news that has been received in
a rather peculiar manner.  It does not think that it has the power to
actually change the mail, or delete any mail messages.  If you enter a
mail group, and mark articles as "read", or kill them in some other
fashion, the mail articles will still exist on the system.  I repeat:
Gnus will not delete your old, read mail.  Unless you ask it to, of
course.

To make Gnus get rid of your unwanted mail, you have to mark the
articles as @dfn{expirable}.  This does not mean that the articles will
disappear right away, however.  In general, a mail article will be
deleted from your system if, 1) it is marked as expirable, AND 2) it is
more than one week old.  If you do not mark an article as expirable, it
will remain on your system until hell freezes over.  This bears
repeating one more time, with some spurious capitalization: IF you do
NOT mark articles as EXPIRABLE, Gnus will NEVER delete those ARTICLES.

@vindex gnus-auto-expirable-newsgroups
You do not have to mark articles as expirable by hand.  Groups that
match the regular expression @code{gnus-auto-expirable-newsgroups} will
have all articles that you read marked as expirable automatically.  All
articles that are marked as expirable have an @samp{X} in the third
column in the summary buffer.

Let's say you subscribe to a couple of mailing lists, and you want the
articles you have read to disappear after a while:

@lisp
(setq gnus-auto-expirable-newsgroups 
      "^mail.nonsense-list\\|^mail.nice-list")
@end lisp

@vindex nnmail-expiry-wait
The @code{nnmail-expiry-wait} variable supplies the default time an
expirable article has to live.  The default is seven days.

Gnus also supplies a function that lets you fine-tune how long articles
are to live, based on what group they are in.  Let's say you want to
have one month expiry period in the @samp{mail.private} group, a one day
expiry period in the @samp{mail.junk} group, and a six day expiry period
everywhere else:

@lisp
(setq nnmail-expiry-wait-function
      '(lambda (group)
        (cond ((string= group "mail.private")
                31)
              ((string= group "mail.junk")
                1)
              (t
                6))))
@end lisp

@vindex nnmail-keep-last-article
If @code{nnmail-keep-last-article} is non-@code{nil}, Gnus will never
expire the final article in a mail newsgroup.  This is to make life
easier for procmail users.

@node nnmbox
@subsubsection nnmbox
@cindex nnmbox
@cindex unix mail box

@vindex nnmbox-active-file
@vindex nnmbox-mbox-file
The @dfn{nnmbox} backend will use the standard Un*x mbox file to store
mail.  The path of the mbox file is given by the @code{nnmbox-mbox-file}
variable.  In addition, Gnus needs to store information about active
articles.  The file specified by @code{nnmbox-active-file} will be used
for that.

nnmbox will add extra headers to each mail article to say which
group it belongs in.

@node nnbabyl
@subsubsection nnbabyl
@cindex nnbabyl
@cindex rmail mbox

@vindex nnbabyl-active-file
@vindex nnbabyl-mbox-file
The @dfn{nnbabyl} backend will use a babyl mail box to store mail.  The
path of the rmail mail box file is given by the @code{nnbabyl-mbox-file}
variable.  In addition, Gnus needs to store information about active
articles.  The file specified by @code{nnbabyl-active-file} will be used
for that.

nnbabyl will add extra headers to each mail article to say which
group it belongs in.

@node nnml
@subsubsection nnml
@cindex nnml
@cindex mail nov spool

The spool mail format (@code{nnml}) isn't compatible with any other
known format.  It should be used with some caution.

@vindex nnml-directory
If you use this backend, Gnus will split all incoming mail into files;
one file for each mail, and put the articles into the correct
directories under the directory specified by the @code{nnml-directory}
variable.  The default value is @samp{"~/Mail/"}.

You do not have to create any directories beforehand; Gnus will take
care of all that.

If you have a strict limit as to how many files you are allowed to store
in your account, you should not use this backend.  As each mail gets its
own file, you might very well occupy thousands of inodes within a few
weeks.  If this is no problem for you, and it isn't a problem for you
having your friendly systems administrator walking around, madly,
shouting "Who is eating all my inodes?! Who? Who!?!", then you should
know that this is probably the fastest format to use.  You do not have
to trudge through a big mbox file just to read your new mail.

@code{nnml} is probably the slowest backend when it comes to article
splitting.  It has to create lots of files, and it also generates NOV
databases for the incoming mails.  This makes is the fastest backend
when it comes to reading mail.

@findex nnml-generate-nov-databases
If your @code{nnml} groups and nov files get totally out of whack, you
can do a complete update by typing @kbd{M-x
nnml-generate-nov-databases}.  This command will trawl through the
entire @code{nnml} hierarchy, looking at each and every article, so it
might take a while to finish.

@node nnmh
@subsubsection nnmh
@cindex nnmh
@cindex mh-e mail spool

@code{nnmh} is just like @code{nnml}, except that is doesn't generate
NOV databases and it doesn't keep an active file.  This makes
@code{nnmh} a *much* slower backend than @code{nnml}, but it also makes
it easier to write procmail scripts for.

@node nnfolder
@subsubsection nnfolder
@cindex nnfolder
@cindex mbox folders

@code{nnfolder} is a backend for storing each mail group in a separate
file.  Each file is in the standard Un*x mbox format.  @code{nnfolder}
will add extra headers to keep track of article numbers and arrival
dates.

@vindex nnfolder-active-file
@vindex nnfolder-directory
@code{nnfolder-directory} says where to store these files, and
@code{nnfolder-active-file} says where to store the @dfn{active}
information.

@node Listing Groups
@section Listing Groups
@cindex group listing

These commands all list various slices of the groups that are available.

@table @kbd
@item l
@item G s
@kindex G s (Group)
@kindex l (Group)
@findex gnus-group-list-groups
List all subscribed groups that have unread articles
(@code{gnus-group-list-groups}).  If the numeric prefix is used, this
command will list only groups of level ARG and lower.  By default, it
only lists groups of level five or lower (ie. just subscribed groups).
@item L
@item G u
@kindex G u
@kindex L (Group)
@findex gnus-group-list-all-groups
List all subscribed and unsubscribed groups, whether they have unread
articles or not (@code{gnus-group-list-all-groups}).  If the numeric
prefix is used, this command will list only groups of level ARG and
lower.  By default, it lists groups of level seven or lower (ie. just
subscribed and unsubscribed groups).
@item G k
@kindex G k (Group)
@findex gnus-group-list-killed
List all killed groups (@code{gnus-group-list-killed}).
@item G z
@kindex G z (Group)
@findex gnus-group-list-zombies
List all zombie groups (@code{gnus-group-list-zombies}).
@item G m
@kindex G m (Group)
@findex gnus-group-list-matching
List all subscribed groups with unread articles that match a regexp
(@code{gnus-group-list-matching}). 
@item G M
@kindex G M (Group)
@findex gnus-group-list-all-matching
List groups that match a regexp (@code{gnus-group-list-all-matching}).
@end table

@node Group Maintenance
@section Group Maintenance
@cindex bogus groups

@table @kbd
@item b
@kindex b (Group)
@findex gnus-group-check-bogus-groups
Check bogus groups and delete them
(@code{gnus-group-check-bogus-groups}).
@item F
@kindex F (Group)
@findex gnus-find-new-newsgroups
Find new groups (@code{gnus-find-new-newsgroups}).
@item C-c C-x
@kindex C-c C-x (Group)
@findex gnus-group-expire-articles
Run all expirable articles in the current group through the expiry
process (if any) (@code{gnus-group-expire-articles}).
@item C-c M-C-x
@kindex C-c M-C-x (Group)
@findex gnus-group-expire-all-groups
Run all articles in all groups through the expiry process
(@code{gnus-group-expire-all-groups}).
@item C-c C-s
@kindex C-c C-s (Group)
@findex gnus-group-sort-groups
@findex gnus-group-sort-by-level
@findex gnus-group-sort-by-unread
@findex gnus-group-sort-by-alphabet
@vindex gnus-group-sort-function
Sort the groups according to the function given by the
@code{gnus-group-sort-function} variable
(@code{gnus-group-sort-groups}).  Available sorting functions include
@code{gnus-group-sort-by-alphabet} (the default),
@code{gnus-group-sort-by-unread} and @code{gnus-group-sort-by-level}. 
@end table

@node Browse Foreign Server
@section Browse Foreign Server
@cindex foreign servers
@cindex browsing servers

@table @kbd
@item B
@kindex B (Group)
@findex gnus-group-browse-foreign-server
You will be queried for a select method and a server name.  Gnus will
then attempt to contact this server and let you browse the groups there
(@code{gnus-group-browse-foreign-server}).
@end table

@findex gnus-browse-server-mode
A new buffer with a list of available groups will appear.  This buffer
will be use the @code{gnus-browse-server-mode}.  This buffer looks a bit
(well, a lot) like a normal group buffer, but with one major difference
- you can't enter any of the groups.  If you want to read any of the
news available on that server, you have to subscribe to the groups you
think may be interesting, and then you have to exit this buffer.  The
new groups will be added to the group buffer, and then you can read them
as you would any other group.

Future versions of Gnus may possibly permit reading groups straight from
the browse buffer.

Here's a list of keystrokes available in the browse mode:

@table @kbd
@item n
@kindex n (Browse)
@findex gnus-group-next-group
Go to the next group (@code{gnus-group-next-group}).
@item p
@kindex p (Browse)
@findex gnus-group-prev-group
Go to the previous group (@code{gnus-group-prev-group}).
@item u
@kindex u (Browse)
@findex gnus-browse-unsubscribe-current-group
Unsubscribe to the current group, or, as will be the case here,
subscribe to it (@code{gnus-browse-unsubscribe-current-group}). 
@item q
@kindex q (Browse)
@findex gnus-browse-exit
Exit browse mode (@code{gnus-browse-exit}).
@item ?
@kindex ? (Browse)
@findex gnus-browse-describe-briefly
Describe browse mode briefly (well, there's not much to describe, is
there) (@code{gnus-browse-describe-briefly}).
@end table

@node Exiting Gnus
@section Exiting Gnus
@cindex exiting Gnus

Yes, Gnus is ex(c)iting.

@table @kbd
@item z
@kindex z (Group)
@findex gnus-group-suspend
Suspend Gnus (@code{gnus-group-suspend}).  This doesn't really exit Gnus,
but it kills all buffers exept the Group buffer.  I'm not sure why this
is a gain, but then who am I to judge.
@item q
@kindex q (Group)
@findex gnus-group-exit
Quit Gnus (@code{gnus-group-exit}).
@item Q
@kindex Q (Group)
@findex gnus-group-quit
Quit Gnus without saving any startup files (@code{gnus-group-quit}).
@end table

@vindex gnus-exit-gnus-hook
@vindex gnus-suspend-gnus-hook
@code{gnus-suspend-gnus-hook} is called when you suspend Gnus and
@code{gnus-exit-gnus-hook} is called when you quit Gnus.

Note:

@quotation
Miss Lisa Cannifax, while sitting in English class, feels her feet go
numbly heavy and herself fall into a hazy trance as the boy sitting
behind her drew repeated lines with his pencil across the back of her
plastic chair.
@end quotation

@node Misc Group Stuff
@section Misc Group Stuff

@table @kbd
@item g
@kindex g (Group)
@findex gnus-group-get-new-news
Check server for new articles. 
If the numeric prefix is used, this command will check only groups of
level ARG and lower (@code{gnus-group-get-new-news}).
@item M-g
@kindex M-g (Group)
@findex gnus-group-get-new-news-this-group
Check whether new articles have arrived in the current group
(@code{gnus-group-get-new-news-this-group}).
@item M-f
@kindex M-f (Group)
@findex gnus-group-fetch-faq
Try to fetch the FAQ for the current group
(@code{gnus-group-fetch-faq}).
@item R
@kindex R (Group)
@findex gnus-group-restart
Restart Gnus (@code{gnus-group-restart}).
@item r
@kindex r (Group)
@findex gnus-group-read-init-file
Read the init file (@code{gnus-init-file}, which defaults to
@file{~/.gnus}) (@code{gnus-group-read-init-file}).
@item s
@kindex s (Group)
@findex gnus-group-save-newsrc
Save the @file{.newsrc.eld} file (and @file{.newsrc} if wanted)
(@code{gnus-group-save-newsrc}).
@item Z
@kindex Z (Group)
@findex gnus-group-clear-dribble
Clear the dribble buffer (@code{gnus-group-clear-dribble}).
@item D
@kindex D (Group)
@findex gnus-group-describe-group
Describe the current group (@code{gnus-group-describe-group}).  If given
a prefix, force Gnus to re-read the description from the server.
@item C-c C-a
@kindex C-c C-a (Group)
@findex gnus-group-apropos
List all groups that have names that match a regexp
(@code{gnus-group-apropos}).
@item C-c M-C-a 
@kindex C-c M-C-a (Group)
@findex gnus-group-description-apropos
List all groups that have names or descriptions that match a regexp
(@code{gnus-group-description-apropos}).
@item a
@kindex a (Group)
@findex gnus-group-post-news
Post an article to a group (@code{gnus-group-post-news}).
@item m
@kindex m (Group)
@findex gnus-group-mail
Mail a message somewhere (@code{gnus-group-mail}).
@item C-x C-t
@kindex C-x C-t (Group)
@findex gnus-group-transpose-groups
Transpose two groups (@code{gnus-group-transpose-groups}).
@item V
@kindex V (Group)
@findex gnus-version
Display current Gnus version numbers (@code{gnus-version}).
@item M-d
@kindex M-d (Group)
@findex gnus-group-describe-all-groups
Describe all groups (@code{gnus-group-describe-all-groups}).  If given a
prefix, force Gnus to re-read the descriptoion file from the server.
@item ?
@kindex ? (Group)
@findex gnus-group-describe-briefly
Give a very short help message (@code{gnus-group-describe-briefly}).
@item C-c C-i
@kindex C-c C-i (Group)
@findex gnus-info-find-node
Go to the Gnus info node (@code{gnus-info-find-node}).
@end table

@vindex gnus-group-prepare-hook
@code{gnus-group-prepare-hook} is called after the group list is
created in the Group buffer.  It may be used to modify the group
buffer in some strange, unnatural way.

@node The Summary Buffer
@chapter The Summary Buffer
@cindex summary buffer

A line for each article is displayed in the Summay buffer.  You can move
around, read articles, post articles and reply to them.

@menu
* Summary Buffer Format::       Deciding how the summar buffer is to look.
* Summary Manouvering::         Moving around the summary buffer.
* Choosing Articles::           Reading articles.
* Paging the Article::          Scrolling the current article.
* Reply Followup and Post::     Posting articles.
* Cancelling and Superseding::  "Whoops, I shouldn't have called him that."
* Ticking and Marking::         Marking articles as read, expirable, etc.
* Threading::                   How threads are made.
* Exiting the Summary Buffer::  Returning to the Group buffer.
* Process/Prefix::              A convention used by many treatment commands.
* Saving Articles::             Ways of customizing article saving.
* Decoding Articles::           Gnus can treat series of (uu)encoded articles.
* Various Article Stuff::       Various stuff dealing with articles.
* Summary Sorting::             You can sort the summary buffer four ways.
* Finding the Parent::          No child support? Get the parent.
* Score Files::                 Maintaining a score file.
* Mail Group Commands::         Some commands can only be used in mail groups.
* Various Summary Stuff::       What didn't fit anywhere else.
@end menu

@node Summary Buffer Format
@section Summary Buffer Format
@cindex summary buffer format

@menu
* Summary Buffer Lines::     You can specify how summary lines should look.
* Summary Buffer Mode Line:: You can say how the mode line should look.
@end menu

@findex mail-extract-address-components
@findex gnus-extract-address-components
@vindex gnus-extract-address-components
Gnus will use the value of the @code{gnus-extract-address-components}
variable as a function for getting the name and address parts of a From
header.  Two pre-defined function exist:
@code{gnus-extract-address-components}, which is the default, quite fast, and
too simplistic solution, and @code{mail-extract-address-components}, which
works very nicely, but is slower.

@vindex gnus-summary-same-subject
@code{gnus-summary-same-subject} is a string indicating that the current
article has the same subject as the previous.  This string will be used
with those specs that require it.

@node Summary Buffer Lines
@subsection Summary Buffer Lines

@vindex gnus-summary-line-format
You can change the format of the lines in the summary buffer by changing
the @code{gnus-summary-line-format} variable.  It works along the same
lines a a normal @code{format} string, with some extensions.

The default string is @samp{"%U%R%z%I%(%[%4L: %-20,20n%]%) %s\n"}.

The following format specification characters are understood:

@table @samp
@item N 
Article number
@item S
Subject string
@item s
Subject if the article is the root, @code{gnus-summary-same-subject}
otherwise. 
@item F
Full From line
@item n
The name (from the @code{From} header field)
@item A
The address (from the @code{From} header field)
@item L
Number of lines in the article
@item c
Number of characters in the article
@item I
Indentation based on thread level
@item T
Nothing if the article is a root and lots of spaces if it isn't (it
pushes everything after it off the screen)
@item \[
Opening bracket, which is normally @samp{\[}, but can also be @samp{<}
for adopted articles.
@item \]
Closing bracked, which is normally @samp{\]}, but can also be @samp{<}
for adopted articles.
@item <
One space for each thread level.
@item >
Twenty minus thread level spaces.
@item U
Unread
@item X
Expirable
@item R
Replied
@item i
Score
@item z
Zcore
@item x
Xref
@item D
Date
@item M
Message-ID
@item r
References
@item x
Xref
@item u
User defined specifier.  The next character in the format string should
be a letter.  @sc{GNUS} will call the function gnus-user-format-function-X,
where X is the letter following %u.  The function will be passed the
current header as argument.  The function should return a string, which
will be inserted into the summary just like information from any other
summary specifier.
@end table

Text between %( and %) will be highlighted with `gnus-mouse-face'
when the mouse point is placed inside the area.  There can only be one
such area.

The %U (status), %R (replied) and %z (zcore) specs have to be handled
with care.  For reasons of efficiency, Gnus will compute what column
these characters will end up in, and "hard-code" that.  This means that
it is illegal to have these specs after a variable-length spec.  Well,
you might not be arrested, but your summary buffer will look strange,
which is bad enough.

The smart choice is to have these specs as far to the left as possible.
(Isn't that the case with everything, though?  But I digress.)

This restriction may disappear in later versions of Gnus.

@node Summary Buffer Mode Line
@subsection Summary Buffer Mode Line

@vindex gnus-summary-mode-line-format
You can also change the format of the summary mode bar.  Set
@code{gnus-summary-mode-line-format} to whatever you like.  Here's what
elements you have to play with:

@table @samp
@item G
Group name
@item A
Current article number
@item V
Gnus version
@item U
Number of unread articles in this group
@item u
Number of unselected articles in this group
@item Z
A string with the number of unread and unselected articles represented
either as @samp{<%U(+%u) more>} if there are both unselected articles,
and just as @samp{<%U more>} if there are just unread articles and no
unselected ones.
@end table


@node Summary Manouvering
@section Summary Manouvering
@cindex summary movement

All the straight movement commands understand the numeric prefix and
behave pretty much as you'd expect. 

None of these commands select articles.

@table @kbd
@item G M-n
@item M-n
@kindex M-n (Summary)
@kindex G M-n (Summary)
@findex gnus-summary-next-unread-subject
Go to the next summary line of an unread article
(@code{gnus-summary-next-unread-subject}). 
@item G M-p
@item M-p
@kindex M-p (Summary)
@kindex G M-p (Summary)
@findex gnus-summary-prev-unread-subject
Go to the previous summary line of an unread article
(@code{gnus-summary-prev-unread-subject}). 
@item G g
@item j
@kindex j (Summary)
@kindex G g (Summary)
@findex gnus-summary-goto-subject
Ask for an article number and then go to this summary line
(@code{gnus-summary-goto-subject}). 
@end table

@vindex gnus-auto-select-next
If you are at the end of the group and issue one of the movement
commands, Gnus will offer to go to the next group.  If
@code{gnus-auto-select-next} is @code{t} and the next group is empty,
Gnus will exit summary mode and return to the group buffer.  If this
variable is neither @code{t} nor @code{nil}, Gnus will select the next
group, no matter if it has any unread articles or not.  As a special
case, if this variable equals @code{quietly}, Gnus will select the next
group without asking for confirmation.  Also see
@code{gnus-keep-same-level}.

If Gnus asks you to press a key to confirm going to the next group, you
can use the @kbd{C-n} and @kbd{C-p} keys to move around the group
buffer, searching for the next group to read without actually returning
to the group buffer.

@vindex gnus-auto-center-summary
If @code{gnus-auto-center-summary} is non-@code{nil}, Gnus will keep the
point in the summary buffer centered at all times.  This makes things
quite tidy, but if you have a slow network connection, or do simply not
like this un-Emacsism, you can set this variable to @code{nil} to get
the normal Emacs scrolling action.

@node Choosing Articles
@section Choosing Articles
@cindex selecting articles

None of the following movement commands understand the numeric prefix,
and they all select and display an article.

@table @kbd
@item SPACE
@kindex SPACE (Summary)
@findex gnus-summary-next-page
Select the current article, or, if that one's read already, the next
unread article (@code{gnus-summary-next-page}).
@item G n
@item n
@kindex n (Summary)
@kindex G n (Summary)
@findex gnus-summary-next-unread-article
Go to next unread article (@code{gnus-summary-next-unread-article}).
@item G p
@item p
@kindex p (Summary)
@findex gnus-summary-prev-unread-article
Go to previous unread article (@code{gnus-summary-prev-unread-article}).
@item G N
@item N
@kindex N (Summary)
@kindex G N (Summary)
@findex gnus-summary-next-article
Go to the next article (@code{gnus-summary-next-article}).
@item G P
@item P
@kindex P (Summary)
@kindex G P (Summary)
@findex gnus-summary-prev-article
Go to the previous article (@code{gnus-summary-prev-article}).
@item G C-n
@kindex G C-n (Summary)
@findex gnus-summary-next-same-subject
Go to the next article with the same subject
(@code{gnus-summary-next-same-subject}). 
@item G C-p
@kindex G C-p (Summary)
@findex gnus-summary-prev-same-subject
Go to the previous article with the same subject
(@code{gnus-summary-prev-same-subject}). 
@item G f
@item .
@kindex G f  (Summary)
@kindex .  (Summary)
@findex gnus-summary-first-unread-article
Go to the first unread article
(@code{gnus-summary-first-unread-article}).
@item G b
@item ,
@kindex G b (Summary)
@kindex , (Summary)
Go to the article with the highest score
(@code{gnus-summary-best-unread-article}). 
@item G l
@item l
@kindex l (Summary)
@kindex G l (Summary)
@findex gnus-summary-goto-last-article
Go to the summary line of the previous article
(@code{gnus-summary-goto-last-article}).
@item G p
@kindex G p
@findex gnus-summary-pop-article
Pop an article off the summary history and go to the previous article
(@code{gnus-summary-pop-article}).  This command differs from the
command above in that you can pop as many previous articles off the
history as you like.
@end table

Some variables that are relevant for moving and selecting articles:

@table @code
@item gnus-auto-extend-newsgroup
@vindex gnus-auto-extend-newsgroup
All the movement commands will try to go to the previous (or next)
article, even if that article isn't displayed in the Summary buffer if
this variable is non-@code{nil}.  Gnus will then fetch the article from
the server and display it in the article buffer.
@item gnus-select-article-hook
@vindex gnus-select-article-hook
This hook is called whenever an article is selected.  By default it
exposes any threads hidden under the selected article.
@item gnus-mark-article-hook
@vindex gnus-mark-article-hook
This hook is called when an article is selected for the first time.  It
is intended to be used for marking articles as read automatically when
articles are selected.
@item gnus-visual-mark-article-hook
@vindex gnus-visual-mark-article-hook
This hook is run after selecting an article.  It is meant to be used for
highlighting the article in some way.  It is not run if
@code{gnus-visual} is @code{nil}.
@item gnus-visual-summary-update-hook
@vindex gnus-visual-summary-update-hook
This hook is called when a summary line is changed.  It is not run if
@code{gnus-visual} is @code{nil}.
@end table

@node Paging the Article
@section Scrolling the Article
@cindex article scrolling

@table @kbd
@item SPACE
@kindex SPACE (Summary)
@findex gnus-summary-next-page
Pressing @kbd{SPACE} will scroll the current article forward one page,
or, if you have come to the end of the current article, will choose the
next article (@code{gnus-summary-next-page}).
@item DEL
@kindex DEL (Summary)
@findex gnus-summary-prev-page
Scoll the current article back one page (@code{gnus-summary-prev-page}). 
@item RET
@kindex RET (Summary)
@findex gnus-summary-scroll-up
Scroll the current article one line forward
(@code{gnus-summary-scroll-up}).
@item <
@item A <
@kindex < (Summary)
@kindex A < (Summary)
@findex gnus-summary-beginning-of-article
Scroll to the beginning of the article
(@code{gnus-summary-beginning-of-article}).
@item >
@item A >
@kindex > (Summary)
@kindex A > (Summary)
@findex gnus-summary-end-of-article
Scroll to the end of the article (@code{gnus-summary-end-of-article}).
@end table

@node Reply Followup and Post
@section Reply Followup and Post
@cindex reply
@cindex followup
@cindex post

@kindex C-c C-c (Post)
All the commands for posting and mailing will put you in a post or mail
buffer where you can edit the article all you like, before you send the
article by pressing @kbd{C-c C-c}.  If you are in a foreign news group,
and you wish to post the article using the foreign server, you can give
a prefix to @kbd{C-c C-c} to make Gnus try to post using the foreign
server. 

@table @kbd
@item a
@kindex a (Summary)
@findex gnus-summary-post-news
Post an article to the current group
(@code{gnus-summary-post-news}).
@item f
@kindex f (Summary)
@findex gnus-summary-followup
Post a followup to the current article (@code{gnus-summary-followup}).
@item F
@kindex F (Summary)
@findex gnus-summary-followup-with-original
Post a followup to the current article and include the original message
(@code{gnus-summary-followup-with-original}). 
@item r
@kindex r (Summary)
@findex gnus-summary-reply
Mail a reply to the author of the current article
(@code{gnus-summary-reply}). 
@item R
@kindex R (Summary)
@findex gnus-summary-reply-with-original
Mail a reply to the author of the current article and include the
original message (@code{gnus-summary-reply-with-original}).
@item b
@kindex b (Summary)
@findex gnus-summary-followup-and-reply
Post a followup and send a reply to the current article
(@code{gnus-summary-followup-and-reply}).
@item B
@kindex N (Summary)
@findex gnus-summary-followup-and-reply-with-original
Post a followup and send a reply to the current article and include the
original message (@code{gnus-summary-followup-and-reply-with-original}).
@item C-c C-f
@kindex C-c C-f (Summary)
@findex gnus-summary-mail-forward
Forward the current article to some other person
(@code{gnus-summary-mail-forward}). 
@item m
@kindex m (Summary)
@findex gnus-summary-mail-other-window
Send a mail to some other person
(@code{gnus-summary-mail-other-window}). 
@item S M-f
@kindex S M-f (Summary)
@findex gnus-uu-digest-and-forward
Digest the current series and forward the result using mail
(@code{gnus-uu-digest-and-forward}). 
@item S u
@kindex S u (Summary)
@findex gnus-uu-post-news
Uuencode a file, split it up into parts, and post it as a series
(@code{gnus-uu-post-news}). 
@end table

@table @code
@item gnus-required-headers
@vindex gnus-required-headers
Gnus determines which headers it should generate in outgoing posts by
consulting the this variable.  All headers mentioned in this list will
either be generated automatically or prompted for before an article is
posted. 
@item gnus-post-method
@vindex gnus-post-method
If non-@code{nil}, Gnus will use this method instead of the default
select method when posting.
@item gnus-use-followup-to
@vindex gnus-use-followup-to
If @code{nil}, always ignore the Followup-To header.  If it is @code{t},
use its value, but ignore the special value @samp{poster}, which will
send the followup as a reply mail to the person you are responding to.
If it is neither @code{nil} nor @code{t}, always use the Followup-To
value.
@item gnus-followup-to-function
@item gnus-reply-to-function
@vindex gnus-reply-to-function
@vindex gnus-followup-to-function
Gnus uses the normal methods to determine where replys and follow-ups
are to go, but you can change the behaviour to suit your need by
fiddling with the @code{gnus-reply-to-function} and
@code{gnus-followup-to-function} variables.

To take "reply" as an example: If you want the replies to go to the
"sender" instead of the "from" in the group "mail.stupid-list", you
could do something like this:

@lisp
(setq gnus-reply-to-function
      '(lambda (group)
        (cond ((string= group "mail.stupid-list")
                (mail-fetch-field "sender"))
              (t
               nil))))
@end lisp

These functions will be called with point in the buffer of the article
that is being replied to (or followed up).
@item gnus-signature-function
@vindex gnus-signature-function
If non-@code{nil}, this variable should be a function that returns a
signature file name.  The function will be called with the name of the
group being posted to.  If the function returns a string that doesn't
correspond to a file, the string itself is inserted.  If the function
returns @code{nil}, the @code{gnus-signature-file} variable will be used
instead.
@item gnus-signature-file
@item mail-signature
@vindex mail-signature
@vindex gnus-signature-file
If non-@code{nil}, this variable should be the name of a file containing
a signature (@samp{~/.signature} by default).  This signature will be
appended to all outgoing post.  Most people find it more convenient to
use @code{mail-signature}, which does the same, but inserts the
signature into the buffer before you start editing the post (or mail).
So - if you have both of these variables set, you will get two
signatures.

Note that RFC1036 says that a signature should be preceded by the three
characters @samp{-- } on a line by themselves.  This is to make it
easier for the recipient to automatically filter the signature away.  So
don't remove those characters, even though you might feel that they ruin
you beautiful design, like, totally.

Also note that no signature should be more than four lines long.
Including ASCII graphics is an efficient way to get everybody to believe
that you are silly and have nothing important to say.
@item gnus-post-prepare-function
@vindex gnus-post-prepare-function
This function is called with the name of the current group after the
post buffer has been initialized, and can be used for inserting a
signature.  Nice if you use different signatures in different groups.
@item gnus-auto-mail-to-author
@vindex gnus-auto-mail-to-author
If non-@code{nil}, Gnus will send a mail with a copy of all follow-ups
to the authors of the articles you follow up.  It's nice in one way -
you make sure that the person you are responding to gets your response.
Other people loathe this method and will hate you dearly for it, because
it means that they will first get a mail, and then have to read the same
article later when they read the news.  It is @code{nil} by default.
@item gnus-mail-send-method
@vindex gnus-mail-send-method
This variable says how a mail should be mailed.  It uses the function in
the @code{send-mail-function} variable as the default.
@item gnus-prepare-article-hook
@vindex gnus-prepare-article-hook
This hook is called before the headers have been prepared.  By default
it inserts the signature specified by @code{gnus-signature-file}.
@item gnus-inews-article-hook
@vindex gnus-inews-article-hook
This hook is called right before the article is posted.  By default it
handles FCC processing (ie. saving the article to a file.)
@item gnus-inews-article-header-hook
@vindex gnus-inews-article-header-hook
This hook is called after inserting the required headers in an article
to be posted.  The hook is called from the @code{*post-news*} buffer,
narrowed to the headers, and is intended for people who would like to
insert additional headers, or just change headers in some way.
@end table

@node Cancelling and Superseding
@section Cancelling Articles
@cindex cancelling articles
@cindex superseding articles

Have you ever written something, and then decided that you really,
really, really hadn't posted that? 

Well, you can't cancel mail, but you can cancel posts.

@findex gnus-summary-cancel-article
@kindex C (Summary)
Find the article you wish to cancel (you can only cancel your own
articles, so don't try any funny stuff).  Then press @kbd{C}
(@code{gnus-summary-cancel-article}).  Your article will be cancelled.

Be aware, however, that not all sites honor cancels, so your article may
live on in some parts of the world, while most sites will delete the
cancelled article.

If you discover that you have made some mistakes and want to do some
corrections, you can post a @dfn{superseding} article that will replace
your original article.

@findex gnus-summary-supersede-article
@kindex S (Summary)
Go to the original article and press @kbd{S}
(@code{gnus-summary-supersede-article}).  You will be put in a buffer
where you can edit the article all you want before sending it off the
usual way.

The same goes for superseding as for cancelling, only more so: Some
sites do not honor superseding.  On those sites, it will appear that you
have posted almost the same article twice.

If you have just posted the article, and change your mind right away,
there is a trick you can use to cancel/supersede the article without
waiting for the article to appear on your site first.  You simply return
to the post buffer (which is called @code{*post-buf*}).  There you will
find the article you just posted, with all the headers intact.  Change
the @samp{Message-ID} header to a @samp{Cancel} or @samp{Supersedes}
header by substituting one of those words for @samp{Message-ID}.  Then
just press @kbd{C-c C-c} to send the article as you would do normally.
The previous article will be cancelled/superseded.

Just remember, kids: There is no 'c' in 'supersede'.

@node Ticking and Marking
@section Ticking and Marking
@cindex article marking
@cindex article ticking

There are several marks you can set on an article. 

You have marks that decide the "readed-ness" (whoo, neato-keano
neologism ohoy!) of the article.  Alphabetic marks generally mean
@dfn{read}, while non-alphabetic characters generally mean @dfn{unread}.

In addition, you also have marks that do not affect readedness.

@menu
* Unread Articles::      Marks for unread articles.
* Read Articles::        Marks for read articles.
* Other Marks::          Marks that do not affect readedness.
@end menu

There's a plethora of commands for manipulating these marks:

@menu
* Setting Marks::           How to set and remove marks.
* Setting Process Marks::   How to mark articles for later processing.
@end menu

@node Unread Articles
@subsection Unread Articles

The following marks mark articles as unread, in one form or other.

@vindex gnus-dormant-mark
@vindex gnus-ticked-mark
@table @samp
@item !
@dfn{Ticked articles} are articles that will remain visible always.  If
you see an article that you find interesting, or you want to put off
reading it, or replying to it, until sometime later, you'd typically
tick it.  However, articles can be expired, so if you want to keep an
article forever, you'll have to save it.  Ticked articles have a
@samp{!} (@code{gnus-ticked-mark}) in the first column.
@item ?
A @dfn{dormant} article is marked with a @samp{?}
(@code{gnus-dormant-mark}), and will only appear in the summary buffer
if there are followups to it.
@item SPC
An @dfn{unread} article is marked with a @samp{SPC}
(@code{gnus-unread-mark}).  These are articles that haven't been read at
all yet.
@end table

@node Read Articles
@subsection Read Articles
@cindex expirable mark

All the following marks mark articles as read.

@table @samp
@item D
Articles that are marked as read.  They have a @samp{D}
(@code{gnus-dread-mark}) in the first column.  These are articles that the
user has marked as read more or less manually.
@item d
Articles that are actually read are marked with @samp{d}
(@code{gnus-read-mark}). 
@item A
Articles that were marked as read in previous sessions are now
@dfn{ancient} and marked with @samp{A} (@code{gnus-ancient-mark}). 
@item K
Marked as killed ((@code{gnus-killed-mark})).
@item X
Marked as killed by kill files (@code{gnus-kill-file-mark}).
@item Y
Marked as read by having a too low score (@code{gnus-low-score-mark}).
@item C
Marked as read by a catch-up (@code{gnus-catchup-mark}).
@item G
Cancelled article (@code{gnus-cancelled-mark})
@end table

All these mark just mean that the article is marked as read,
really.  They are interpreted differently by the adaptive scoring scheme,
however. 

One more special mark, though:

@table @samp
@item E
You can also mark articles as @dfn{expirable} (or have them marked as
such automatically).  That doesn't make much sense in normal groups,
because a user does not control the expiring of news articles, but in
mail groups, for instance, articles that are marked as @dfn{expirable}
can be deleted by Gnus at any time.  Expirable articles are marked with
@samp{E} (@code{gnus-expirable-mark}).
@end table

@node Other Marks
@subsection Other Marks
@cindex process mark
@cindex bookmarks

There are some marks that have nothing to do with whether the article is
read or not.

You can set a bookmark in the current article.  Say you are reading a
long thesis on cat's urinary tracts, and have to go home for dinner
before you've finished reading the thesis.  You can then set a bookmark
in the article, and Gnus will jump to this bookmark the next time it
encounters the article.

Finally we have the @dfn{process mark}.  A variety of commands react to
the presence of the process mark.  For instance, @kbd{X u}
(@code{gnus-uu-decode-uu}) will uudecode and view all articles that have
been marked with the process mark.  Articles marked with the process
mark have a @samp{#} in the second column.

@node Setting Marks
@subsection Setting Marks
@cindex setting marks

All the marking commands understand the numeric prefix.

@table @kbd
@item M t
@item !
@kindex ! (Summary)
@kindex M t (Summary)
@findex gnus-summary-tick-article-forward
Tick the current article (@code{gnus-summary-tick-article-forward}).
@item M ?
@item ?
@kindex ? (Summary)
@kindex M ? (Summary)
@findex gnus-summary-mark-as-dormant
Mark the current article as dormant
(@code{gnus-summary-mark-as-dormant}).
@item M d
@item d
@kindex M d (Summary)
@kindex d (Summary)
@findex gnus-summary-mark-as-read-forward
Mark the current article as read
(@code{gnus-summary-mark-as-read-forward}).
@item k
@kindex k (Summary)
@findex gnus-summary-kill-same-subject-and-select
Mark all articles that have the same subject as the current one as read,
and then select the next unread article
(@code{gnus-summary-kill-same-subject-and-select}).
@item C-k
@kindex C-k (Summary)
@findex gnus-summary-kill-same-subject
Mark all articles that have the same subject as the current one as read
(@code{gnus-summary-kill-same-subject}).  
@item M C
@kindex M C (Summary)
@findex gnus-summary-catchup
Catchup the current group (@code{gnus-summary-catchup}).
@item M C-c
@kindex M C-c (Summary)
@findex gnus-summary-catchup-all
Catchup all articles in the current group (@code{gnus-summary-catchup-all}).
@item M H
@kindex M H (Summary)
@findex gnus-summary-catchup-to-here
Catchup the current group to point (@code{gnus-summary-catchup-to-here}).
@item M c
@item M-u
@kindex M c (Summary)
@kindex M-u (Summary)
@findex gnus-summary-clear-mark-forward
Clear tick and read marks from the current article
(@code{gnus-summary-clear-mark-forward}).
@item M e
@item E
@kindex M e (Summary)
@kindex E (Summary)
@findex gnus-summary-mark-as-expirable
Mark the current article as expirable
(@code{gnus-summary-mark-as-expirable}).
@item M b
@kindex M b (Summary)
@findex gnus-summary-set-bookmark
Set a bookmark in the current article
(@code{gnus-summary-set-bookmark}).
@item M B
@kindex M B (Summary)
@findex gnus-summary-remove-bookmark
Remove the bookmark from the current article
(@code{gnus-summary-remove-bookmark}).
@item M M-r
@item M-d
@kindex M M-r (Summary)
@kindex M-d (Summary)
@findex gnus-summary-remove-lines-marked-as-read
Expunge all deleted articles from the summary buffer
(@code{gnus-summary-remove-lines-marked-as-read}). 
@item M M-C-r
@item M-C-d
@kindex M M-C-r (Summary)
@kindex M-C-d (Summary)
@findex gnus-summary-remove-lines-marked-with
Ask for a mark and then expunge all articles that have been marked with
that mark (@code{gnus-summary-remove-lines-marked-with}).
@item M S
@kindex M S (Summary)
@findex gnus-summary-show-all-expunged
Display all expunged articles (@code{gnus-summary-show-all-expunged}).
@item M D
@kindex M D (Summary)
@findex gnus-summary-show-all-dormant
Display all dormant articles (@code{gnus-summary-show-all-dormant}).
@item M M-D
@kindex M M-D (Summary)
@findex gnus-summary-hide-all-dormant
Hide all dormant articles (@code{gnus-summary-hide-all-dormant}).
@item M s k
@kindex M s k (Summary)
@findex gnus-summary-kill-below
Kill all articles with scores below the default score (or below the
numeric prefix) (@code{gnus-summary-kill-below}).
@item M s c
@kindex M s c (Summary)
@findex gnus-summary-clear-above
Clear all marks from articles with scores over the default score (or
over the numeric prefix) (@code{gnus-summary-clear-above}).
@item M s u
@kindex M s u (Summary)
@findex gnus-summary-tick-above
Tick all articles with scores over the default score (or over the
numeric prefix) (@code{gnus-summary-clear-above}).
@item M s m
@kindex M s m (Summary)
@findex gnus-summary-mark-above
Prompt for a mark, and mark all articles with scores over the default
score (or over the numeric prefix) with this mark
(@code{gnus-summary-clear-above}).
@end table

The @code{gnus-summary-goto-unread} variable controls what action should
be taken after setting a mark.  If non-@code{nil}, point will move to
the next/previous unread article.  If @code{nil}, point will just move
one line up or down.

@node Setting Process Marks
@subsection Setting Process Marks
@cindex setting process marks

@table @kbd
@item #
@item M p
@kindex # (Summary)
@kindex M p p (Summary)
@findex gnus-summary-mark-as-processable
Mark the current article with the process mark
(@code{gnus-summary-mark-as-processable}). 
@findex gnus-summary-unmark-as-processable
@item M-#
@item M p u 
@kindex M-# (Summary)
@kindex M p u (Summary)
Remove the process mark from the current article
(@code{gnus-summary-unmark-as-processable}). 
@item C-c M-#
@item M p U
@kindex C-c M-# (Summary)
@kindex M p U (Summary)
@findex gnus-summary-unmark-all-processable
Remove the process mark from all articles
(@code{gnus-summary-unmark-all-processable}). 
@item M p R
@kindex M p R (Summary)
@findex gnus-uu-mark-by-regexp
Mark articles by a regular expression (@code{gnus-uu-mark-by-regexp}). 
@item M p r
@kindex M p r (Summary)
@findex gnus-uu-mark-region
Mark articles in region (@code{gnus-uu-mark-region}).
@item M p t
@kindex M p t (Summary)
@findex gnus-uu-mark-thread
Mark all articles in the current (sub)thread
(@code{gnus-uu-mark-thread}).
@item M p s
@kindex M p s (Summary)
@findex gnus-uu-mark-series
Mark all articles in the current series (@code{gnus-uu-mark-series}).
@item M p S
@kindex M p S (Summary)
@findex gnus-uu-mark-sparse
Mark all series that have already had some articles marked
(@code{gnus-uu-mark-sparse}).
@item M p a
@kindex M p a (Summary)
@findex gnus-uu-mark-all
Mark all articles in series order (@code{gnus-uu-mark-series}).
@end table

@findex gnus-summary-universal-argument
@kindex V u (Summary)
Finally, we have @kbd{V u} (@code{gnus-summary-universal-argument}) that
will perform any operation on all articles that have been marked with
the process mark.

@node Threading
@section Threading
@cindex threading
@cindex article threading

Gnus threads articles by default.  @dfn{To thread} is to put replies to
articles directly after the articles they reply to - in a hierarchical
fashion.

@menu
* Customizing Threading::     Variables you can change to affect the threading.
* Thread Commands::           Thread based commands in the summary buffer.
@end menu

@node Customizing Threading
@subsection Customizing Threading
@cindex customizing threading

@table @code
@item gnus-show-threads
@vindex gnus-show-threads
If this variable is @code{nil}, no threading will be done, and all of
the rest of the variables here will have no effect.  Turning threading
off will speed group selection up a bit, but it is sure to make reading
slower and more awkward.
@item gnus-fetch-old-headers
@vindex gnus-fetch-old-headers
If non-@code{nil}, Gnus will attempt to build old threads by fetching
more old headers - headers to articles that are marked as read.  If it
has the value `some', only enough headers to connect otherwise loose
threads will be displayed.  Fetching old headers only works if the
select method you are using supports XOVER.  Also remember that if the
root of the thread has been expired by the server, there's not much Gnus
can do about that.
@item gnus-gather-loose-threads
@vindex gnus-gather-loose-threads
If non-@code{nil}, Gnus will gather all loose subtrees into one big tree
and create a dummy root at the top.  (Wait a minute.  Root at the top?
Yup.)  Loose subtrees occur when the real root has expired, or you've
read it or marked it as read in a previous session.
@item gnus-summary-gather-subject-limit
If this variable is @code{nil}, the entire subject line will be used to
gather loose threads.  If you would limit this to the 20 first
characters of the subjects, set this variable to 20.
@item gnus-summary-make-false-root
@vindex gnus-summary-make-false-root
When there is no real root of a thread, Gnus will have to fudge
something.  This variable says what method Gnus should use while
fudging.  There are four possible value:

@table @code
@item adopt
Gnus will make the first of the orphaned articles the parent.  This
parent will adopt all the other articles.  The adopted articles will be
marked as such by pointy brackeds instead of square brackets.  This is
the default value.
@item dummy
Gnus will create a dummy that will stand in as the parent.  This dummy
will be displayed on a line of its own, but it does not correspond to
any real article.
@item empty
Gnus won't actually make any article the parent, but simply leave the
subject field of all orphans except the first empty.  (It will use
@code{gnus-summary-same-subject} as the subject.)
@item nil
Don't make any article parent at all.  Just gather the threads and
display them after one another.
@end table

@item gnus-thread-hide-subtree
@vindex gnus-thread-hide-subtree
If non-@code{nil}, all subtrees will be hidden when the summary buffer
is generated.
@item gnus-thread-hide-killed
@vindex gnus-thread-hide-killed
if you kill a thread and this variable is non-@code{nil}, the subtree
will be hidden.
@item gnus-thread-ignore-subject
@vindex gnus-thread-ignore-subject
Sometimes somebody changes the subject in the middle of a thread.  If
this variable is non-@code{nil}, the change in subject is ignored.  If
it is @code{nil}, which is the default, a change in the subject will
result in a new thread.
@item gnus-thread-indent-level
@vindex gnus-thread-indent-level
This is a number that how much each subthread should be indented.  The
default is @samp{4}.
@end table

@node Thread Commands
@subsection Thread Commands
@cindex thread commands

@table @kbd
@item T k
@item M-C-k
@kindex T k (Summary)
@kindex M-C-k (Summary)
@findex gnus-summary-kill-thread
Mark all articles under the current one as read
(@code{gnus-summary-kill-thread}).  If the prefix argument is positive,
remove all marks.  If the prefix argument is negative, tick articles.
@item T l
@item M-C-l
@kindex T l (Summary)
@kindex M-C-l (Summary)
@findex gnus-summary-lower-thread
Lower the score of the current thread
(@code{gnus-summary-lower-thread}). 
@item T i
@kindex T i (Summary)
@findex gnus-summary-raise-thread
Increase the score of the current thread
(@code{gnus-summary-raise-thread}).
@item T #
@kindex T # (Summary)
@findex gnus-uu-mark-thread
Mark the current thread with the process mark
(@code{gnus-uu-mark-thread}).
@item T T
@kindex T T (Summary)
@findex gnus-summary-toggle-threads
Toggle showing threads (@code{gnus-summary-toggle-threads}).
@item T s
@kindex T s (Summary)
@findex gnus-summary-show-thread
Show the thread hidden under the current article, if any
(@code{gnus-summary-show-thread}). 
@item T h
@kindex T h (Summary)
@findex gnus-summary-hide-thread
Hide the current (sub)thread (@code{gnus-summary-hide-thread}).
@item T S
@kindex T S (Summary)
@findex gnus-summary-show-all-threads
Show all hidden threads (@code{gnus-summary-show-all-threads}).
@item T H
@kindex T H (Summary)
@findex gnus-summary-hide-all-threads
Hide all threads (@code{gnus-summary-hide-all-threads}).
@end table

The following commands are all thread movement commands.  They all
understand the numeric prefix.

@table @kbd
@item T n
@kindex T n (Summary)
@findex gnus-summary-next-thread
Go to the next thread (@code{gnus-summary-next-thread}).
@item T p
@kindex T p (Summary)
@findex gnus-summary-prev-thread
Go to the previous thread (@code{gnus-summary-prev-thread}).
@item T d
@kindex T d (Summary)
@findex gnus-summary-down-thread
Descend the thread (@code{gnus-summary-down-thread}).
@item T u
@kindex T u (Summary)
@findex gnus-summary-up-thread
Ascend the thread (@code{gnus-summary-up-thread}).
@end table

@node Exiting the Summary Buffer
@section Exiting the Summary Buffer
@cindex summary exit

Exiting from the summary buffer will normally update all info on the
group and return you to the group buffer. 

@table @kbd
@item q
@kindex q (Summary)
@findex gnus-summary-exit
Exit the current group and update all the information
(@code{gnus-summary-exit}). 
@item Q
@kindex Q (Summary)
@findex gnus-summary-quit
Exit the current group without updating any information
(@code{gnus-summary-quit}). 
@item c
@kindex c (Summary)
@findex gnus-summary-catchup-and-exit
Mark all articles in the group as read and exit
(@code{gnus-summary-catchup-and-exit}). 
@end table

@vindex gnus-exit-group-hook
@code{gnus-exit-group-hook} is called when you exit the current
group.  

@vindex gnus-use-cross-reference
When you exit the summary buffer, the data on the current group will be
updated (which articles you have read, which articles you have replied
to, etc.) If the @code{gnus-use-cross-reference} variable is @code{t}, articles
that are cross-referenced to this group, and are marked as read, will
also be marked as read in the other subscribed groups they were
cross-posted to.   If this variable is neither @code{nil} nor @code{t}, the
article will be marked as read in both subscribed and unsubscribed
groups. 

Marking cross-posted articles as read ensures that you'll never have to
read the same article more than once.  Unless, of course, somebody has
posted it to several groups separately.  Posting the same article to
several groups (not cross-posting) is called @dfn{spamming}, and you are
by law required to send nasty-grams to anyone who perpetrates such a
heinous crime.

Remember: Cross-posting is kinda ok, but posting the same article
separately to several groups is not.

One thing that may cause Gnus to not do the cross-posting thing
correctly is if you use an NNTP server that supports xover (which is
very nice, because it speeds things up considerably) which does not
include the Xref header in its NOV lines.  This is Evil, but it's
common.  Gnus tries to Do The Right Thing even with xover by registering
the Xref lines of all articles you actually read, but if you kill the
articles, or just mark them as read without reading them, Gnus will not
get a chance to snoop the Xref lines out of these articles, and will be
unable to use the cross reference mechanism.

@vindex gnus-nov-is-evil
If you want Gnus to get the Xrefs right all the time, you have to set
@code{gnus-nov-is-evil} to @code{t}, which slows things down considerably. 

C'est la vie.

@node Process/Prefix
@section Process/Prefix
@cindex process/prefix convention

Many functions, among them functions for moving articles, decoding
articles and saving articles use what is known as the
@dfn{Process/Prefix convention}.

This is a method for figuring out what articles that the user wants the
command to be performed on.

It goes like this:

If the numeric prefix is N, perform the operation on the next N
articles, starting with the current one.  If the numeric prefix is
negative, perform the operation on the previous N articles, starting
with the current one.

If there is no numeric prefix, but some articles are marked with the
process mark, perform the operation on the articles that are marked with
the process mark.

If there is neither a numeric prefix nor any articles marked with the
process mark, just perform the operation on the current article.

Quite simple, really, but it needs to be made clear so that surprises
are avoided.

@node Saving Articles
@section Saving Articles
@cindex saving articles

Gnus can save articles in a number of ways.  Below is the documentation
for saving articles in a fairly straight-forward fashion (ie. little
processing of the article is done before it is saved).  For a different
approach (uudecoding, unsharing) see gnus-uu.  @xref{Decoding Articles}.

@vindex gnus-save-all-headers
If @code{gnus-save-all-headers} is non-@code{nil}, Gnus will not delete
unwanted headers before saving the article.

@table @kbd
@item o
@kindex o (Summary)
@findex gnus-summary-save-article
Save the current article (@code{gnus-summary-save-article}).
@item C-o
@kindex C-o (Summary)
@findex gnus-summary-save-article-mail
Save the current article in mail format
(@code{gnus-summary-save-article-mail}). 
@end table

Both these command use the process/prefix convention
(@pxref{Process/Prefix}). 

@vindex gnus-default-article-saver
You can customize the @code{gnus-default-article-saver} variable to make
Gnus what you want it to.  You can use any of the four ready-made
functions below, or you can create your own. 

@table @code
@item gnus-summary-save-in-rmail
@vindex gnus-summary-save-in-rmail
This is the default format, @dfn{babyl}.  Uses the function in the
@code{gnus-rmail-save-name} variable to get a file name to save the
article in.  The default is @code{gnus-plain-save-name}.
@item gnus-summary-save-in-mail
@vindex gnus-summary-save-in-mail
Save in a Unix mail (mbox) file.  Uses the function in the
@code{gnus-mail-save-name} variable to get a file name to save the
article in.  The default is @code{gnus-plain-save-name}.
@item gnus-summary-save-in-file
@vindex gnus-summary-save-in-file
Append the article straight to an ordinary file.  Uses the function in
the @code{gnus-file-save-name} variable to get a file name to save the
article in.  The default is @code{gnus-numeric-save-name}.
@item gnus-summary-save-in-folder
@vindex gnus-summary-save-in-folder
Save the article to an MH folder using @code{rcvstore} from the MH
library.
@end table

All of these functions, except for the last one, will save the article
in the @code{gnus-article-save-directory}, which is initialized from the
@samp{SAVEDIR} environment variable.

As you can see above, the functions use different functions to find a
suitable name of a file to save the article in.  Below is a list of
available functions that generate names:

@table @code
@item gnus-Numeric-save-name
@findex gnus-Numeric-save-name
Generates file names that look like @samp{~/News/Alt.andrea-dworkin/45}.
@item gnus-numeric-save-name
@findex gnus-numeric-save-name
Generates file names that look like @samp{~/News/alt.andrea-dworkin/45}.
@item gnus-Plain-save-name
@findex gnus-Plain-save-name
Generates file names that look like @samp{~/News/Alt.andrea-dworkin}.
@item gnus-plain-save-name
@findex gnus-plain-save-name
Generates file names that look like @samp{~/News/alt.andrea-dworkin}.
@end table

@vindex gnus-use-long-file-name
Finally, you have the @code{gnus-use-long-file-name} variable.  If it is
@code{nil}, all the preceding functions will replace all periods
(@samp{.}) in the group names with slashes (@samp{/}) - which means that
the functions will generate hierarchies of directories instead of having
all the files in the toplevel directory
(@samp{~/News/alt/andrea-dworkin} instead of
@samp{~/News/alt.andrea-dworkin}.)

@node Decoding Articles
@section Decoding Articles
@cindex decoding articles

Sometime users post articles (or series of articles) that have been
encoded in some way or other.  Gnus can decode them for you.

@menu 
* Uuencoded Articles::    Uudecode articles.
* Shared Articles::       Unshar articles.
@end menu

All these functions use the process/prefix convention
(@pxref{Process/Prefix}) for finding out what articles to work on, with
the extension that a "single article" means "a single series".  Gnus can
find out by itself what articles belong to one series, decode all the
articles and unpack/view/save the resulting file(s).

Gnus guesses what articles are in the series according to the following
simplish rule: The subjects must be (nearly) identical, except for the
last two numbers of the line.  (Spaces are largely ignored, however.)

For example: If you choose a subject called @samp{cat.gif (2/3)}, Gnus
will find all the articles that match the regexp @samp{^cat.gif
([0-9]+/[0-9]+).*$}.  

Subjects that are nonstandard, like @samp{cat.gif (2/3) Part 6 of a
series}, will not be properly recognized by any of the automatic viewing
commands, and you have to mark the articles manually with @key{#}.

@menu 
* Decoding Variables::     Variables for a happy decoding.
* Viewing Files::          You want to look at the result of the decoding?
@end menu

@node Uuencoded Articles
@subsection Uuencoded Articles
@cindex uudecode
@cindex uuencoded articles

@table @kbd
@item X u
@kindex X u (Summary)
@findex gnus-uu-decode-uu
Uudecodes the current series (@code{gnus-uu-decode-uu}).
@item X U
@kindex X U (Summary)
@findex gnus-uu-decode-and-save
Uudecodes and saves the current series (@code{gnus-uu-decode-and-save}).
@item X v u
@kindex X v u (Summary)
@findex gnus-uu-decode-uu-view
Uudecodes and views the current series (@code{gnus-uu-decode-uu-view}).
@item X v U
@kindex X v U (Summary)
@findex gnus-uu-decode-uu-and-save-view
Uudecodes, views and saves the current series
(@code{gnus-uu-decode-uu-and-save-view}). 
@end table

Remember that these all react to the presence of articles marked with
the process mark.  If, for instance, you'd like to uncode and save an
entire newsgroup, you'd typically do @kbd{M p a}
(@code{gnus-uu-mark-all}) and then @kbd{X U} (@code{gnus-uu-decode-uu}).

All this is very much different from how gnus-uu worked with @sc{GNUS
4.1}, where you had explicit keystrokes for everything under the sun.
This version of gnus-uu generally assumes that you either mark articles
in some way (@pxref{Setting Process Marks}) and then press @kbd{X u}.

Note: When trying to decode articles that have names matching
@samp{[Cc][Ii][Nn][Dd][Yy][0-9]+.\\(gif\\|jpg\\)}
(@code{gnus-uu-notify-files}), gnus-uu will automatically post an
article on @samp{comp.unix.wizards} saying that you have just viewed the
file in question.  This feature can't be turned off.

@node Shared Articles
@subsection Shared Articles
@cindex unshar
@cindex shared articles

@table @kbd
@item X s
@kindex X s (Summary)
@findex gnus-uu-decode-unshar
Unshars the current series (@code{gnus-uu-decode-unshar}).
@item X S
@kindex X S (Summary)
@findex gnus-uu-decode-unshar-and-save
Unshars and saves the current series (@code{gnus-uu-decode-unshar-and-save}).
@item X v s
@kindex X v s (Summary)
@findex gnus-uu-decode-unshar-view
Unshars and views the current series (@code{gnus-uu-decode-unshar-view}).
@item X v S
@kindex X v S (Summary)
@findex gnus-uu-decode-unshar-and-save-view
Unshars, views and saves the current series
(@code{gnus-uu-decode-unshar-and-save-view}). 
@end table

@node Decoding Variables
@subsection Decoding Variables

Adjective, not verb.

@menu 
* Rule Variables::          Variables that say how a file is to be viewed.
* Other Decode Variables::  Other decode variables.
@end menu

@node Rule Variables
@subsubsection Rule Variables
@cindex rule variables

Gnus uses @dfn{rule} variables to decide how to view a file.  All these
variables are on the form
  
@lisp
      (list '(regexp1 command2)
            '(regexp2 command2)
            ...)
@end lisp

@table @code
@item gnus-uu-user-view-rules
@vindex gnus-uu-user-view-rules
This variable is consulted first when viewing files.  If you wish to use,
for instance, @code{sox} to convert an @samp{.au} sound file, you could
say something like:
@lisp
       (setq gnus-uu-user-view-rules
         (list '(\"\\\\.au$\" \"sox %s -t .aiff > /dev/audio\")))
@end lisp
@item gnus-uu-user-view-rules-end
@vindex gnus-uu-user-view-rules-end
This variable is consulted if Gnus couldn't make any matches from the
user and default view rules.
@item gnus-uu-user-archive-rules
@vindex gnus-uu-user-archive-rules
This variable can be used to say what comamnds should be used to unpack
archives.
@end table

@node Other Decode Variables
@subsubsection Other Decode Variables

@table @code
@item gnus-uu-ignore-files-by-name
@vindex gnus-uu-ignore-files-by-name
Files with name matching this regular expression won't be viewed.

@item gnus-uu-ignore-files-by-type
@vindex gnus-uu-ignore-files-by-type
Files with a MIME type matching this variable won't be viewed.  Note
that Gnus tries to guess what type the file is based on the
name.  gnus-uu is not a MIME package, so this is slightly kludgy.

@item gnus-uu-tmp-dir
@vindex gnus-uu-tmp-dir
Where gnus-uu does its work.

@item gnus-uu-do-not-unpack-archives
@vindex gnus-uu-do-not-unpack-archives
Non-@code{nil} means that gnus-uu won't peek inside archives looking for
files to dispay.

@item gnus-uu-view-and-save
@vindex gnus-uu-view-and-save
Non-@code{nil} means that the user will always be asked to save a file
after viewing it.

@item gnus-uu-ignore-default-view-rules
@vindex gnus-uu-ignore-default-view-rules
Non-@code{nil} means that gnus-uu will ignore the default viewing rules.

@item gnus-uu-ignore-default-archive-rules
@vindex gnus-uu-ignore-default-archive-rules
Non-@code{nil} means that gnus-uu will ignore the default archive
unpacking commands.

@item gnus-uu-kill-carriage-return
@vindex gnus-uu-kill-carriage-return
Non-@code{nil} means that gnus-uu will strip all carriage returns from
articles.

@item gnus-uu-unmark-articles-not-decoded
@vindex gnus-uu-unmark-articles-not-decoded
Non-@code{nil} means that gnus-uu will mark articles that were
unsuccessfully decoded as unread.

@item gnus-uu-correct-stripped-uucode
@vindex gnus-uu-correct-stripped-uucode
Non-@code{nil} means that gnus-uu will *try* to fix uuencoded files that
have had traling spaces deleted.

@item gnus-uu-view-with-metamail
@vindex gnus-uu-view-with-metamail
Non-@code{nil} means that gnus-uu will ignore the viewing commands
defined by the rule variables and just fudge a MIME content type based
on the file name.  The result will be fed to metamail for viewing.

@item gnus-uu-save-in-digest
@vindex gnus-uu-save-in-digest
Non-@code{nil} means that gnus-uu, when asked to save without decoding,
will save in digests.  If this variable is @code{nil}, gnus-uu will just
save everything in a file without any embellishments.  The digesting
almost conforms to RFC1153 - no easy way to specify any meaningful
volume and issue numbers were found, so I simply dropped them.

@item gnus-uu-post-include-before-composing
@vindex gnus-uu-post-include-before-composing
Non-@code{nil} means that gnus-uu will ask for a file to encode before
you compose the article.  If this variable is @code{t}, you can either
include an encoded file with @key{C-c C-i} or have one included for you
when you post the article.

@item gnus-uu-post-length
@vindex gnus-uu-post-length
Maximum length of an article.  The encoded file will be split into how
many articles it takes to post the entire file.

@item gnus-uu-post-threaded
@vindex gnus-uu-post-threaded
Non-@code{nil} means that gnus-uu will post the encoded file in a
thread.  This may not be smart, as no other decoder I have seen are able
to follow threads when collecting uuencoded articles.  (Well, I have
seen one package that does that - gnus-uu, but somehow, I don't think
that counts...) Default is @code{nil}.

@item gnus-uu-post-separate-description
@vindex gnus-uu-post-separate-description
Non-@code{nil} means that the description will be posted in a separate
article.  The first article will typically be numbered (0/x).  If this
variable is @code{nil}, the description the user enters will be included
at the beginning of the first article, which will be numbered (1/x).
Default is @code{t}.

@end table

@node Viewing Files
@subsection Viewing Files
@cindex vieving files
@cindex pseudo-articles

After decoding, if the file is some sort of archive, Gnus will attempt
to unpack the archive and see if any of the files in the archive can be
viewed.  For instance, if you have a gzipped tar file @file{pics.tar.gz}
containing the files @file{pic1.jpg} and @file{pic2.gif}, Gnus will
uncompress and detar the main file, and then view the two pictures.
This unpacking process is recursive, so if the archive contains archives
of archives, it'll all be unpacked.

Finally, Gnus will normally insert a @dfn{pseudo-article} for each
extracted file into the summary buffer.  If you go to these "articles",
the user will be prompted for a command to run (usually Gnus will make a
suggestion), and then the command will be run.

@vindex gnus-view-pseudo-asynchronously
If @code{gnus-view-pseudo-asynchronously} is @code{nil}, Emacs will wait
until the viewing is done before proceeding.

@vindex gnus-view-pseudos
If @code{gnus-view-pseudos} is @code{automatic}, Gnus will not insert
the pseudo-articles into the summary buffer, but view them
immediately.  If this variable is @code{not-confirm}, the user won't even
be asked for a confirmation before viewing is done.


@node Various Article Stuff 
@section Various Article Stuff 

@table @kbd
@item A w
@kindex A w (Summary)
@findex gnus-summary-stop-page-breaking
Remove page breaking from the current article
(@code{gnus-summary-stop-page-breaking}). 
@item A s 
@item A s (Summary)
@findex gnus-summary-isearch-article
Perform an isearch in the article buffer
(@code{gnus-summary-isearch-article}). 
@item A c
@kindex A c (Summary)
@findex gnus-summary-caesar-message
Do a Caesar rotate (rot13) on the article buffer
(@code{gnus-summary-caesar-message}). 
@item A g
@kindex A g (Summary)
@findex gnus-summary-show-article
Select the current article (@code{gnus-summary-show-article}).
@item A t
@kindex A t (Summary)
@findex gnus-summary-toggle-header
Toggle whether to display all headers in the article buffer
(@code{gnus-summary-toggle-header}). 
@item A m
@kindex A m (Summary)
@findex gnus-summary-toggle-mime
Toggle whether to run the article through MIME before displaying
(@code{gnus-summary-toggle-mime}). 
@item V |
@kindex V | (Summary)
@findex gnus-summary-pipe-output
Pipe the current article to a process
(@code{gnus-summary-pipe-output}). 
@end table

There's a battery of commands for washing the article buffer:

@table @kbd
@item A h h
@kindex A h h (Summary)
@findex gnus-article-hide-headers
Hide headers (@code{gnus-article-hide-headers}).
@item A h s
@kindex A h s (Summary)
@findex gnus-article-hide-signature
Hide signature (@code{gnus-article-hide-signature}).
@item A h c
@kindex A h c (Summary)
@findex gnus-article-hide-citation
Hide citation (@code{gnus-article-hide-citation}).
@item A h o
@kindex A h o (Summary)
@findex gnus-article-treat-overstrike
Treat overstrike (@code{gnus-article-treat-overstrike}).
@item A h w
@kindex A h w (Summary)
@findex gnus-article-word-wrap
Do word wrap (@code{gnus-article-word-wrap}).
@item A h d
@kindex A h d (Summary)
@findex gnus-article-remove-cr
Remove CR (@code{gnus-article-remove-cr}).
@item A h q
@kindex A h q (Summary)
@findex gnus-article-de-quoted-unreadable
Treat quoted-printable (@code{gnus-article-de-quoted-unreadable}).
@end table


@node Summary Sorting
@section Summary Sorting
@cindex summary sorting

You can have the summary buffer sorted in various ways, even though I
can't really se why you'd want that.

@table @kbd
@item V s n
@kindex V s n (Summary)
@findex gnus-summary-sort-by-number
Sort by article number (@code{gnus-summary-sort-by-number}).
@item V s a
@kindex V s a (Summary)
@findex gnus-summary-sort-by-author
Sort by author (@code{gnus-summary-sort-by-author}).
@item V s s
@kindex V s s (Summary)
@findex gnus-summary-sort-by-subject
Sort by subject (@code{gnus-summary-sort-by-subject}).
@item V s d
@kindex V s d (Summary)
@findex gnus-summary-sort-by-date
Sort by date (@code{gnus-summary-sort-by-date}).
@end table

@node Finding the Parent
@section Finding the Parent
@cindex parent articles
@cindex refering articles

@findex gnus-summary-refer-parent-article
@kindex ^ (Summary)
If you'd like to read the parent of the current article, and it is not
displayed in the article buffer, you might still be able to.  That is,
if the current group is fetched by NNTP, the parent hasn't expired and
the References in the current article are not mangled, you can just
press @kbd{^} (@code{gnus-summary-refer-parent-article}).  If everything
goes well, you'll get the parent.  If the parent is already displayed in
the summary buffer, point will just move to this article.

@findex gnus-summary-refer-article
@kindex M-^ (Summary)
You can also ask the NNTP server for an arbitrary article, no matter
what group it belongs to.  @kbd{M-^} (@code{gnus-summary-refer-article})
will ask you for a message-id, which is one of those long thingies that
look something like @samp{<38o6up$6f2@@hymir.ifi.uio.no>}.  You have to
get it all exactly right.

@vindex gnus-refer-article-method
If the group you are reading is located on a backend that does not
support fetching by Message-ID very well (like @code{nnspool}), you can
set @code{gnus-refer-article-method} to an NNTP method.  It would,
perhaps, be best if the NNTP server you consult is the same as the one
that keeps the spool you are erading from updated, but that's not really
necessary. 

@node Score Files
@section Score Files
@cindex score files

Other people use @dfn{kill files}, but we here at (ding) Gnus Towers
like scoring better than killing, so we'd rather switch than fight.  They
do something completely different as well, so sit up straight and pay
attention!

@vindex gnus-summary-mark-below
All articles have a default score (@code{gnus-summary-default-score}).
This score may be raised or lowered either interactively or by score
files.  Articles that have a score lower than
@code{gnus-summary-mark-below} are marked as read.

Gnus will read any @dfn{score files} that apply to the current group
before generating the summary buffer.

There are several commands reachable from the summary buffer that
inserts commands for scoring articles based on the current article.  You
can, for instance, ask Gnus to lower or increase the score of all
articles with a certain subject.

There are two sorts of scoring entries: Permanent and temporary.
Temporary score entries are self-expiring entries.  Any entries that are
temporary and have not been used for, say, a week, will be removed
silently to help keep the sizes of the score files down.

@menu 
* Summary Score Commands::   Adding score commands to the score file.
* Score Variables::          Customize your scoring.  (My, what terminology).
* Score File Format::        What a score file may contain.
* Score File Editing::       You can edit score files by hand as well.
* Scoring Tips::             How to score effectively.
* Global Score Files::       Earth-spanning, ear-splitting score files.
@end menu

@node Summary Score Commands
@subsection Summary Score Commands
@cindex score commands

General score commands don't actually change score files: 

@table @kbd
@item V S s
@kindex V S s (Summary)
@findex gnus-summary-set-score
Set the score of the current article (@code{gnus-summary-set-score}).  
@item I C-i
@kindex I C-i (Summary)
@findex gnus-summary-raise-score
Increase the score of the current article
(@code{gnus-summary-raise-score}).
@item L C-l
@kindex L C-l (Summary)
@findex gnus-summary-lower-score
Lower the score of the current article
(@code{gnus-summary-lower-score}). 
@item V S c
@kindex V S c (Summary)
@findex gnus-score-change-score-file
Make a different score file the current
(@code{gnus-score-change-score-file}). 
@item V S e
@kindex V S e (Summary)
@findex gnus-score-edit-file
Edit the current score file (@code{gnus-score-edit-file}).  You will be
popped into a @code{gnus-score-mode} buffer (@pxref{Score File
Editing}). 
@end table

The rest of these commands modify the local score file.

@table @kbd
@item V S m
@kindex V S m (Summary)
@findex gnus-score-set-mark-below
Prompt for a score, and mark all articles with a score below this as
read (@code{gnus-score-set-mark-below}).
@item V S E
@kindex V S E (Summary)
@findex gnus-score-set-expunge-below
Expunge all articles with a score below the default score (or the
numeric prefix) (@code{gnus-score-set-expunge-below}).
@end table

Commands for increasing score:

@table @kbd
@item I s t
@kindex I s t (Summary)
@findex gnus-summary-temporarily-raise-by-subject
Increase the current subject temporarily
(@code{gnus-summary-temporarily-raise-by-subject}).
@item I s p
@kindex I s p (Summary)
@findex gnus-summary-raise-by-subject
Increase the current subject permanently
(@code{gnus-summary-raise-by-subject}).
@item I a t
@kindex I a t (Summary)
@findex gnus-summary-temporarily-raise-by-author
Increase the current author temporarily
(@code{gnus-summary-temporarily-raise-by-author}).
@item I a p
@kindex I a p (Summary)
@findex gnus-summary-raise-by-author
Increase the current author permanently
(@code{gnus-summary-raise-by-author}).
@item I i t
@kindex I i t (Summary)
@findex gnus-summary-temporarily-raise-by-id
Increase the current message-id temporarily
(@code{gnus-summary-temporarily-raise-by-id}).
@item I i p
@kindex I i p (Summary)
@findex gnus-summary-raise-by-id
Increase the current message-id permanently
(@code{gnus-summary-raise-by-id}).
@item I t t
@kindex I t t (Summary)
@findex gnus-summary-temporarily-raise-by-thread
Increase the current thread temporarily
(@code{gnus-summary-temporarily-raise-by-thread}).
@item I t p
@kindex I t p (Summary)
@findex gnus-summary-raise-by-subject
Increase the current thread permanently
(@code{gnus-summary-raise-by-subject}).
@item I x t
@kindex I x t (Summary)
@findex gnus-summary-temporarily-raise-by-xref
Increase the current xref temporarily
(@code{gnus-summary-temporarily-raise-by-xref}).
@item I x p
@kindex I x p (Summary)
@findex gnus-summary-raise-by-xref
Increase the current xref permanently
(@code{gnus-summary-raise-by-xref}).
@item I f t
@kindex I f t (Summary)
@findex gnus-summary-temporarily-raise-followups-to-author
Increase followups to the current author temporarily
(@code{gnus-summary-temporarily-raise-followups-to-author}).
@item I f p
@kindex I f p (Summary)
@findex gnus-summary-raise-followups-to-author
Increase followups to the current author permanently
(@code{gnus-summary-raise-followups-to-author}).
@end table

Commands for lowering score:

@table @kbd
@item L s t
@kindex L s t (Summary)
@findex gnus-summary-temporarily-lower-by-subject
Lower the current subject temporarily
(@code{gnus-summary-temporarily-lower-by-subject}).
@item L s p
@kindex L s p (Summary)
@findex gnus-summary-lower-by-subject
Lower the current subject permanently
(@code{gnus-summary-lower-by-subject}).
@item L a t
@kindex L a t (Summary)
@findex gnus-summary-temporarily-lower-by-author
Lower the current author temporarily
(@code{gnus-summary-temporarily-lower-by-author}).
@item L a p
@kindex L a p (Summary)
@findex gnus-summary-lower-by-author
Lower the current author permanently
(@code{gnus-summary-lower-by-author}).
@item L i t
@kindex L i t (Summary)
@findex gnus-summary-temporarily-lower-by-id
Lower the current message-id temporarily
(@code{gnus-summary-temporarily-lower-by-id}).
@item L a p
@kindex L a p (Summary)
@findex gnus-summary-lower-by-id
Lower the current message-id permanently
(@code{gnus-summary-lower-by-id}).
@item L t t
@kindex L t t (Summary)
@findex gnus-summary-temporarily-lower-by-thread
Lower the current thread temporarily
(@code{gnus-summary-temporarily-lower-by-thread}).
@item L t p
@kindex L t p (Summary)
@findex gnus-summary-lower-by-subject
Lower the current thread permanently
(@code{gnus-summary-lower-by-subject}).
@item L x t
@kindex L x t (Summary)
@findex gnus-summary-temporarily-lower-by-xref
Lower the current xref temporarily
(@code{gnus-summary-temporarily-lower-by-xref}).
@item L x p
@kindex L x p (Summary)
@findex gnus-summary-lower-by-xref
Lower the current xref permanently
(@code{gnus-summary-lower-by-xref}).
@item L f t
@kindex L f t (Summary)
@findex gnus-summary-temporarily-lower-followups-to-author
Lower followups to the current author temporarily
(@code{gnus-summary-temporarily-lower-followups-to-author}).
@item L f p
@kindex L f p (Summary)
@findex gnus-summary-lower-followups-to-author
Lower followups to the current author permanently
(@code{gnus-summary-lower-followups-to-author}).
@end table

@node Score Variables
@subsection Score Variables
@cindex score variables

@table @code
@item gnus-kill-killed
@vindex gnus-kill-killed
If this variable is @code{nil}, Gnus will never apply score files to
articles that have already been through the kill process.  While this
may save you lots of time, it also means that if you apply a kill file
to a group, and then change the kill file and want to run it over you
group again to kill more articles, it won't work.  You have to set this
variable to @code{t} to do that.
@item gnus-kill-files-directory
@vindex gnus-kill-files-directory
All kill files will be stored in this directory, which is initialized
from the @samp{SAVEDIR} environment variable by default.
@item gnus-score-file-suffix
@vindex gnus-score-file-suffix
Suffix to add to the group name to arrive at the score file name
(@samp{SCORE} by default.)
@item gnus-score-interactive-default-score
@vindex gnus-score-interactive-default-score
Score used by all the interactive raise/lower commands to raise/lower
score with.  Default is 1000, which may seem excessive, but this is to
ensure that the adaptive scoring scheme gets enough room to play
with.  We don't want the small changes that successive adaptive changes
to overwrite manually entered data.
@item gnus-summary-default-score
@vindex gnus-summary-default-score
Default score of an article, which is 0 by default.
@item gnus-score-over-mark
@vindex gnus-score-over-mark
Mark (in the third column) used for articles with a score over the
default.  Default is @samp{+}.
@item gnus-score-below-mark
@vindex gnus-score-below-mark
Mark (in the third column) used for articles with a score below the
default.  Default is @samp{-}.
@item gnus-score-find-score-files-function
@vindex gnus-score-find-score-files-function
Function used to find score files for the current group.  This function
is called with the name of the group as the argument. 

Predefined functions available are:
@table @code
@item gnus-score-find-single
@findex gnus-score-find-single
Only apply the group's own score file.
@item gnus-score-find-bnews
@findex gnus-score-find-bnews
Apply all score files that match, using bnews syntax.  For instance, if
the current group is @samp{gnu.emacs.gnus}, @samp{gnu.all.SCORE},
@samp{all.emacs.all.SCORE} and @samp{not.alt.all.SCORE} would all
apply.  In short, the instances of @samp{all} in the score file names are
translated into @samp{.*}, and then a regexp match is done.
@item gnus-score-find-hierarchical
@findex gnus-score-find-hierarchical
Apply all score files from all the parent groups.
@end table
@item gnus-kill-expiry-days
@vindex gnus-kill-expiry-days
This variable says how many days should pass before an unused score file
entry should be expired.  The default is 7.
@end table

@node Score File Format
@subsection Score File Format
@cindex score file format

A score file is an emacs-lisp file that normally contains just a single
form.  Casual users are not expected to edit these files, everthing can
be changed from the summary buffer.

Anyway, if you'd like to dig into it yourself, here's an example:

@lisp
(("from"
  ("Lars Ingebrigtsen" -10000)
  ("Per Abrahamsen")
  ("larsi\\|lmi" -50000 nil r))
 ("subject"
  ("Ding is Badd" nil 728373))
 ("xref"
  ("alt.politics" -1000 728372 s))
 (mark 0)
 (expunge -1000)
 (mark-and-expunge -10)
 (read-only t)
 (files "/hom/larsi/News/gnu.SCORE")
 (eval (ding)))
@end lisp

This example demonstrates absolutely everything about a score file. 

Even though this looks much like lisp code, nothing here is actually
@code{eval}ed.  The lisp reader is used to read this form, though, so it
has to be legal syntactically, if not semantically.

Six keys are supported by this alist:

@table @code
@item STRING
If the key is a string, it is a header name to perform the scoring on.
Following this key is a random number of element score entries, where
each score entry have one to four elements.  
@enumerate
@item 
The first element is always a string - the @dfn{match element}.
@item 
If the second element is present, it should be a number - the @dfn{score
element}.  This number should be an integer in the neginf to posinf
interval.  If this element is not present, the
@code{gnus-score-interactive-default-score} number will be used instead.
@item 
If the third element is present, it should be a number - the @dfn{date
element}.  This date says when the last time this score entry provided a
match, which provides a mechanism for expiring the score entries.  It
this element is not present, the score entry is premanent.  The date is
represented by the number of days since December 31, 1 CE.
@item 
If the fourth element is present, it should be a symbol - the @dfn{type
element}.  Currently supported are the @code{r} (regexp) and @code{s}
(substring) types.  If this element is not present, Gnus will assume
that substring matching should be used.
@end enumerate

@item mark
The value of this entry should be a number.  Any articles with a score
lower than this number will be marked as read.
@item expunge
The value of this entry should be a number.  Any articles with a score
lower than this number will be removed from the summary buffer.
@item mark-and-expunge
The value of this entry should be a number.  Any articles with a score
lower than this number will be marked as read and removed from the
summary buffer.
@item files
The value of this entry should any number of file names.  These files
are assumed to be score files as well, and will be loaded the same way
this one was.
@item eval
The value of this entry will be @code{eval}el.  This element will be
ignored when handling global score files. 
@item read-only
Read-only score files will not be updated or saved.  Global score files
should feature this atom (@pxref{Global Score Files}).
@end table

@node Score File Editing
@subsection Score File Editing

You normally enter all scoring commands from the summary buffer, but you
might feel the urge to edit them by hand as well, so we've supplied you
with a mode for that.  

It's simply a slightly customized emacs-lisp mode, with these additional
commands:

@table @kbd
@item C-c C-c
@kindex C-c C-c (Score)
@findex gnus-score-edit-done
Save the changes you have made and return to the summary buffer
(@code{gnus-score-edit-done}). 
@item C-c C-d
@kindex C-c C-d (Score)
@findex gnus-score-edit-insert-date
Insert the current date in numerical format
(@code{gnus-score-edit-insert-date}).  This is really the day number, if
you were wondering.
@end table

@node Scoring Tips
@subsection Scoring Tips
@cindex scoring tips

@table . 
@item Crossposts
If you want to lower the score of crossposts, the line to match on is
the Xref header.  
@lisp
("xref" (" talk.politics.misc:" -1000))
@end lisp
@item Multiple crossposts
If you want to lower the score of articles that have been crossposted to
more than, say, 3 groups:
@lisp
("xref" (" +[^ ]+:[0-9]+ +[^ ]+:[0-9]+ +[^ ]+:[0-9]+" -1000 nil r))
@end lisp
@end table

@node Global Score Files
@subsection Global Score Files
@cindex global score files

Sure, other newsreaders have "global kill files".  These are usually
nothing more than a single kill file that applies to all groups, stored
under the user's home directory.  Bah!  Puny, weak newsreaders!

What I'm talking about here are Global Score Files.  Score files from
all over the world, from users everywhere, uniting all nations in one
big, happy score file union!  Ange-score!  New and untested!

@vindex gnus-global-score-files
All you have to do to use other people's score files is to set the
@code{gnus-global-score-files}.  One entry for each score file, or each
score file directory.  Gnus will decide by itself what score files are
applicable to which group.

Say you want to use the single score file
@file{/ftp@@ftp.ifi.uio.no:/pub/larsi/ding/score/soc.motss.SCORE} and all
score files in the @file{/ftp@@ftp.some-where:/pub/score} directory.  

@lisp
(setq gnus-global-score-files
      '("/ftp@@ftp.ifi.uio.no:/pub/larsi/ding/score/soc.motss.SCORE"
        "/ftp@@ftp.some-where:/pub/score/"))
@end lisp

@findex gnus-score-search-global-directories
Simple, eh?  Directory names must end with a @samp{/}.  These
directories are typically scanned only once during each Gnus session.
If you feel the need to manually re-scan the remote directories, you can
use the @code{gnus-score-search-global-directories} command.

Note that, at present, using this option will slow down group entry
somewhat.  (That is - a lot.)

If you want to start maintaining score files for other people to use,
just put your score file up for anonymous ftp and announce it to the
world.  Become a retro-moderator!  Participate in the retro-moderator
wars sure to ensue, where retro-moderators battle it out for the
sympathy of the people, luring them to use their score files on false
premises!  Yay!  The net is saved!

Here are some tips for the would-be retro-moderator, off the top of my
head: 

@itemize @bullet
@item 
Articles that are heavily crossposted are probably junk. 
@item
To lower a single inappropriate article, lower by message-id. 
@item
Particularly brilliant authors can be raised on a permanent basis. 
@item
Authors that repeatedly post off-charter for the group can safely be
lowered out of existance.
@item
Set the @code{mark} and @code{expunge} atoms to obliterate the nastiest
articles completely.
@item 
Use expiring score entries to keep the size of the file down.  You
should probably have a long expiry period, though, as some sites keep
old articles for a long time.
@end itemize

... I wonder whether other newsreaders will support global score files
in the future.  *Snicker*.  Yup, any day now, newsreaders like Blue
Wave, xrn and 1stReader are bound to implement scoring.  Should we start
holding our breath yet?

@node Mail Group Commands
@section Mail Group Commands
@cindex mail group commands

Some commands only make sense in mail groups.  If these commands are
illegal in the current group, they will raise a hell and let you know.

All these commands (except the expiry and edit commands) use the
process/prefix convention (@pxref{Process/Prefix}).

@table @kbd
@item V m e
@kindex V m e (Summary)
@findex gnus-summary-expire-articles
Expire all expirable articles in the group
(@code{gnus-summary-expire-articles}).
@item V m DEL
@kindex V m DEL (Summary)
@findex gnus-summary-delete-articles
Delete the mail article.  This is "delete" as in "delete it from your
disk forever and ever, never to return again." Use with caution.
(@code{gnus-summary-delete-article}).
@item V m m
@kindex V m m (Summary)
@findex gnus-summary-move-article
Move the article from one mail group to another
(@code{gnus-summary-move-article}). 
@item V m c
@kindex V m c (Summary)
@findex gnus-summary-copy-article
Copy the article from one group (mail group or not) to a mail group
(@code{gnus-summary-copy-article}).
@item V m r
@kindex V m r (Summary)
@findex gnus-summary-respool-article
Respool the mail article (@code{gnus-summary-move-article}).
@item V m w
@item e
@kindex V m w (Summary)
@kindex e (Summary)
@findex gnus-summary-edit-article
@kindex C-c C-c (Article)
Edit the current article (@code{gnus-summary-edit-article}).  Type
@kbd{C-c C-c} (@kbd{gnus-summary-edit-article-done}) to finish editing
and make the changes permanent.
@end table

@node Various Summary Stuff
@section Various Summary Stuff

@table @kbd
@item V D
@kindex V D (Summary)
@findex gnus-summary-enter-digest-group
If the current article is a digest, you might use this command to enter
you into a group based onthe current digest to ease reading
(@code{gnus-summary-enter-digest-group}).  @xref{nndigest}.
@item V f
@kindex V f (Summary)
@findex gnus-summary-fetch-faq
@vindex gnus-group-faq-directory
Try to fetch the FAQ (list of frequently asked questions) for the
current group (@code{gnus-summary-fetch-faq}).  Gnus will try to get the
FAQ from @code{gnus-group-faq-directory}, which is usually a directory
on a remote machine. ange-ftp will be used for fetching the file.
@item &
@kindex & (Summary)
@findex gnus-summary-expand-window
This command will prompt you for a header field, a regular expression to
be matched this field, and a command to be executed if the match is
made. 
@item V C-s
@kindex V C-s (Summary)
@findex gnus-summary-search-article-forward
Search through all subsequent articles for a regexp
(@code{gnus-summary-search-article-forward}). 
@item V C-r
@kindex V C-r (Summary)
@findex gnus-summary-search-article-backward
Search through all previous articles for a regexp
(@code{gnus-summary-search-article-backward}). 
@item V T
@kindex V T (Summary)
@findex gnus-summary-toggle-truncation
Toggle truncation of summary lines (@code{gnus-summary-toggle-truncation}).
@item V e
@kindex V e (Summary)
@findex gnus-summary-expand-window
Expand the summary buffer window (@code{gnus-summary-expand-window}).
@item V S
@kindex V S (Summary)
@findex gnus-summary-reselect-current-group
Exit this group, and then enter it again
(@code{gnus-summary-reselect-current-group}).
@item V d
@kindex V d (Summary)
@findex gnus-summary-describe-group
Give a brief description of the current group
(@code{gnus-summary-describe-group}).  If given a prefix, force reading
new description from the server. 
@item V g
@item M-g
@kindex V g (Summary)
@kindex M-g (Summary)
@findex gnus-summary-rescan-group
Exit group, check for new articles in the group, and select the group
(@code{gnus-summary-rescan-group}).
@item V
@kindex V (Summary)
@findex gnus-version
Display the Gnus version numbers (@code{gnus-version}).
@item V ?
@kindex V ? (Summary)
@findex gnus-summary-describe-briefly
Give a very brief description of the most important summary keystrokes
(@code{gnus-summary-describe-briefly}). 
@item V i
@kindex V i (Summary)
@findex gnus-info-find-node
Go to the Gnus info node (@code{gnus-info-find-node}).
@end table

@vindex gnus-summary-prepare-hook
@code{gnus-summary-prepare-hook} is called after the summary buffer has
been generated.  You might use it to, for instance, hilight lines, modify
the look, or anything else you feel like.  I don't care.

@node The Article Buffer
@chapter The Article Buffer
@cindex article buffer

The articles are displayed in the article buffer, of which there is only
one.  All the summary buffer share the same article buffer.

@menu
* Hiding Headers::        Deciding what headers should be displayed.
* Using Mime::            Pushing articles through MIME before reading them.
* Customizing Articles::  Tailoring the look of the articles.
* Article Keymap::        Keystrokes available in the article buffer
* Misc Article::          Other stuff.
@end menu

@node Hiding Headers
@section Hiding Headers
@cindex hiding headers
@cindex deleting headers

The top section of each article is the @dfn{header}.  (The rest is the
@dfn{body}, but you may have guessed that already.) 

@vindex gnus-show-all-headers
There is a lot of useful information in the header: the name of the
person who wrote the article, the date and the subject of the article.
That well and nice, but there's also lots of information most people do
not want to see - what systems the article has passed through before
reaching you, the message id, the references, etc. ad nauseum - and
you'll probably want to get rid of some of those lines.  If you want to
keep all those lines in the article buffer, you can set
@code{gnus-show-all-headers} to @code{t}.

Gnus provides you with two variables for sifting header lines:

@table @code
@item gnus-visible-headers
@vindex gnus-visible-headers
If this variable is non-@code{nil}, it should be a regular expression
that says what header lines you wish to keep in the article buffer.  All
header lines that does not match this variable will be hidden.

For instance, if you only want to see the name of the person who wrote
the article and the subject, you'd say:

@lisp
(setq gnus-visible-headers "^From:\\|^Subject:")
@end lisp

@item gnus-ignored-headers
@vindex gnus-ignored-headers
This variable is the reverse of @code{gnus-visible-headers}.  If this
variable is set (and @code{gnus-visible-headers} is @code{nil}), it
should be a regular expression that matches all lines that you want to
hide.  All lines that does not match this variable will remain visible.

For instance, if you just want to get rid of the references line and the
xref line, you might say:

@lisp
(setq gnus-ignored-headers "^References:\\|^Xref:")
@end lisp

Note that if @code{gnus-visible-headers} is non-@code{nil}, this
variable will have no effect.
@end table

@vindex gnus-sorted-header-list
Gnus can also sort the headers for you.  (It does this by default.)  You
can control the sorting by setting the @code{gnus-sorted-header-list}
variable.  It is a list of regular expressions that says in what order
the header lines are to be displayed.

For instance, if you want the name of the author of the article first,
and then the subject, you might say something like:

@lisp
(setq gnus-sorted-header-list '("^From:" "^Subject:"))
@end lisp

Any headers that are to remain visible, but are not listed in this
variable, will be displayed in random order after all the headers that
are listed in this variable.

@node Using Mime
@section Using Mime
@cindex MIME

Mime is a standard for waving your hands through the air, aimlessly,
while people stand around yawning.

MIME, however, is a standard for encoding your articles, aimlessly,
while all newsreaders die of fear.

MIME may specify what character set the article uses, the encoding of
the characters, and it also makes it possible to embed pictures and
other naughty stuff in innocent-looking articles.

@vindex gnus-show-mime
@vindex gnus-show-mime-method
Gnus handles MIME by shoving the articles through
@code{gnus-show-mime-method}, which is @code{metamail-buffer} by
default.  Set @code{gnus-show-mime} to @code{t} if you want to use MIME all the
time; it might be best just use the toggling functions from the summary
buffer to avoid getting nasty surprises (for instance, you enter the
group @samp{alt.sing-a-long} and, before you know it, MIME has decoded
the sounds file in the article and some horrible sing-a-long song comes
streaming out out your speakers, and you can't find the volume button,
because there isn't one, and people are starting to look at you, and you
try to stop the program, but you can't, and you can't find the program
to control the volume, and everybody else in the room suddenly decides
to look at you disdainfully, and you'll feel rather stupid.)

Any similarity to real events and people is purely coincidental.  Ahem.

@node Customizing Articles
@section Customizing Articles
@cindex article customization

@vindex gnus-article-display-hook
The @code{gnus-article-display-hook} is called after the article has
been inserted into the article buffer.  It is meant to handle all
treatment of the article before it is displayed.  By default it contains
@code{gnus-article-hide-headers}, which hides unwanted headers.

@findex gnus-article-subcite
@findex gnus-article-hide-signature
@findex gnus-article-hide-citation
Other useful functions you might add to this hook is
@code{gnus-article-hide-citation} (which hides all cited text);
@code{gnus-article-hide-signature} (which, umn, hides the signature);
@code{gnus-article-subcite} (which tries to clean up the mess supercite
makes in The Hands Of The Mad; @code{gnus-article-treat-overstrike}
(which treats @samp{^H_} in a reasonable manner); and
@code{gnus-article-remove-cr} (which removes trailing carriage returns).

You can, of course, write your own functions.  The functions are called
in the article buffer, and you can do anything you like, pretty much.
There is no information that you have to keep in the buffer - you can
change everything.

@node Article Keymap
@section Article Keymap

Most of the keystrokes in the summary buffer can also be used in the
article buffer.  They should behave as if you typed them in the summary
buffer, which means that you don't actually have to have a summary
buffer displayed when you're reading.  You can do it all from the
article buffer.

A few additional keystrokes are available:

@table @kbd
@item SPACE
@kindex SPACE (Article)
@findex gnus-article-next-page
Scroll forwards one page (@code{gnus-article-next-page}).
@item DEL
@kindex DEL (Article)
@findex gnus-article-prev-page
Scroll backwards one page (@code{gnus-article-prev-page}).
@item C-c ^
@kindex C-c ^ (Article)
@findex gnus-article-refer-article
If point is in the neighborhood of a message-id and you press @kbd{r},
Gnus will try to get that article from the server.  (Only available with
nntp).  (@code{gnus-article-refer-article}).
@item C-c C-m
@kindex C-c C-m (Article)
@findex gnus-article-mail
Send a reply to the address near point (@code{gnus-article-mail}). 
@item C-c C-M
@kindex C-c C-M (Article)
@findex gnus-article-mail-with-original
Send a reply to the address near point and include the original article
(@code{gnus-article-mail-with-original}). 
@item s
@kindex s (Article)
@findex gnus-article-show-summary
Reconfigure the buffers so that the summary buffer becomes visible
(@code{gnus-article-show-summary}).
@item ?
@kindex ? (Article)
@findex gnus-article-describe-briefly
Give a very brief description of the available keystrokes
(@code{gnus-article-describe-briefly}). 
@end table

@node Misc Article
@section Misc Article

@table @code
@vindex gnus-article-prepare-hook
@item gnus-article-prepare-hook
This hook is called right after the article has been inserted into the
article buffer.  It is mainly intended for functions that do something
depending on the contents; it should probably not be used for changing
the contents of the article buffer.
@vindex gnus-article-display-hook
@item gnus-article-display-hook
This hook is called as the last thing when displaying an article, and is
intended for modifying the contents of the buffer, highlight, hiding
headers, and the like.
@vindex gnus-article-mode-line-format
@item gnus-article-mode-line-format
This variable is a format string along the same lines as
@code{gnus-summary-mode-line-format}.  It accepts exactly the same
format specifications as that variable.
@vindex gnus-break-pages
@item gnus-break-pages
Controls whether @dfn{page breaking} is to take place.  If this variable
is non-@code{nil}, the articles will be divided into pages whenever a
page delimeter appears in the article.  If this variable is @code{nil},
paging will not be done.
@item gnus-page-delimeter
@vindex gnus-page-delimiter
This is the delimeter mentioned above.  By default, it is @samp{^L}
(form linefeed).
@end table

@node Various
@chapter Various

@menu
* Interactive::                Making Gnus ask you many questions.
* Windows Configuration::      Configuring the Gnus buffer windows.
* Various Various::            Things that are really various.
@end menu

@node Interactive
@section Interactive
@cindex interaction

@table @code
@item gnus-novice-user
@vindex gnus-novice-user
If this variable is non-@code{nil}, you are either a newcomer to the
usenet world, or you are very cautious, which is a nice thing to be,
really.  You will be given questions of the type "Are you sure you want
to do this?" before doing anything dangerous.
@item gnus-expert-user
@vindex gnus-expert-user
If this variable is non-@code{nil}, you will never ever be asked any
questions by Gnus.  It will simply assume you know what your are doing,
no matter how strange.
@item gnus-interactive-catchup
@vindex gnus-interactive-catchup
Require confirmation before catching up a group if non-@code{nil}.
@item gnus-interactive-post
@vindex gnus-interactive-post
If non-@code{nil}, the user will be prompted for a group name when
posting an article.
@item gnus-interactive-exit
@vindex gnus-interactive-exit
Require confirmation before exiting Gnus.
@end table

@node Windows Configuration
@section Windows Configuration
@cindex windows configuration

No, there's nothing here about X, so be quiet.

@table @code
@item gnus-use-full-window
@vindex gnus-use-full-window
If non-@code{nil}, Gnus will delete all other windows and occupy the
entire Emacs screen by itself.  It is @code{t} by default.
@item gnus-window-configuration
@vindex gnus-window-configuration
This variable describes how much space each Gnus buffer should be given,
compared to the other Gnus buffers.  Here's an example:

@lisp
(setq gnus-window-configuration
  '((summary (0 1 0))
    (groups (1 0 0))
    (article (0 3 10))))
@end lisp

This variable is a list of lists, where each of these small lists is on
the form @var{(action (g s a))}.  As you can see, there are three
possible @var{action}s - @code{group} (which is what happens when
you first start Gnus, or returns from the summary buffer),
@code{summary} (which is what happens when there are no unread articles
in the group, and @code{article} (which is what happens when there
is an unread article in the group). 

We see that in the first two actions, the respective buffers will fill
the screen, and in the last, the article buffer will take ten lines for
each three the summary buffer gets.

@findex gnus-window-configuration-split
This variable can also have a function as its value.  In that case,
whenever Gnus tries to configure the Gnus buffers, that function will be
called with the @var{action} as its parameter.  There is one pre-made
function supplied, @code{gnus-window-configuration-split}, which may be
suitable if you have a very wide Emacs window, and want to have the
summary buffer and the article buffer side by side.
@end table

@node Various Various
@section Various Various
@cindex mode lines
@cindex highlights

@table @code
@item gnus-updated-mode-lines
@vindex gnus-updated-mode-lines
This is a list of buffers that should keep their mode lines updated.
The list may contain the symbols `group', `article' and `summary'.  If
the corresponding symbol is present, Gnus will keep that mode line
updated with information that may be pertinent.  If this variable is
@code{nil}, screen refresh may be quicker.

@item gnus-mode-non-string-length
@vindex gnus-mode-non-string-length
By default, Gnus displays information of 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.  This variable says how
long the other info on the line is (ie. the non-info part).  If you put
additional elements on the mode line (eg. a clock), you should modify
this variable:
@c Hook written by Keinonen Kari <kk85613@cs.tut.fi>.
@lisp
(add-hook 'display-time-hook
          (lambda ()
            (setq gnus-mode-non-string-length
                  (+ 21 (length display-time-string)))))
@end lisp

@item gnus-visual
@vindex gnus-visual
If @code{nil}, Gnus won't attempt to create menus or use fancy colours
or fonts.  This will also inhibit loading the @file{gnus-visual.el}
file.
@item gnus-mouse-face
@vindex gnus-mouse-face
This is the face (ie. font) used for mouse highlighting in Gnus.  No
mouse highlights will be done if @code{gnus-visual} is @code{nil}.
@end table

@node Customization
@chapter Customization
@cindex general 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 NNTP 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.
@end menu

@node Slow NNTP Connection
@section Slow 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.

@table @code
@item gnus-read-active-file
Set this to @code{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 @code{gnus-check-new-news} and
@code{gnus-check-bogus-newsgroups} to @code{nil} to make sure that Gnus
doesn't suddenly decide to fetch the active file anyway.  Note that this
will make it difficult for you to get hold of new groups.
@item gnus-nov-is-evil
This one has to be @code{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.
@end table

@node Slow Terminal Connection
@section Slow Terminal Connection

Let's say you use your home computer for dialling 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.

@table @code
@item gnus-auto-center-summary
Set this to @code{nil} to inhibit Gnus from recentering the summary
buffer all the time.
@item 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
@samp{"^NEVVVVER"} or @samp{"From:"}, or whatever you feel you need.
@item gnus-article-display-hook
Set this hook to all the available hiding commands:
@lisp
(setq gnus-article-display-hook 
      '(gnus-article-hide-headers gnus-article-hide-signature
        gnus-article-hide-citation))
@end lisp
@item gnus-use-full-window
By setting this to @code{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.
@item gnus-thread-hide-subtree
If this is non-@code{nil}, all threads in the summary buffer will be
hidden initially.
@item gnus-updated-mode-lines
If this is @code{nil}, Gnus will not put information in the buffer mode
lines, which might save some time.
@end table

@node Little Disk Space
@section Little Disk Space

The startup files can get rather large, so you may want to keep their
sizes down a bit if you are running out of space.

@table @code
@item gnus-save-newsrc-file
If this is @code{nil}, Gnus will never save @file{.newsrc} - it will
only save @file{.newsrc.eld}.  This means that you will not be able to
use any other newsreaders than Gnus.
@item gnus-save-killed-list
If this is @code{nil}, Gnus will not save the list of dead groups.  That
means that Gnus will not know whether groups are new or old, which makes
automatic handling of new groups impossible.  You should also set
@code{gnus-check-new-newsgroups} and @code{gnus-check-bogus-newsgroups}
to @code{nil} if you set this variable to @code{nil}.
@end table

@node Slow Machine
@section 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 @code{gnus-read-active-file}, @code{gnus-check-new-newsgroups},
@code{gnus-check-bogus-newsgroups} to @code{nil} to make startup faster.

Set @code{gnus-show-threads}, @code{gnus-use-cross-reference} and
@code{nntp-xover-is-evil} to @code{nil} to make entering and exiting the
summary buffer faster.

Set @code{gnus-article-display-hook} to @code{nil} to make article
processing a bit faster.

@node Troubleshooting
@chapter Troubleshooting
@cindex troubleshooting

(ding) Gnus work so well straight out of the box, so I can't imagine any
problems, really.  

Ahem.

Make sure your computer is switched on.

Make sure that you really load the current Gnus version.  If you have
been running @sc{GNUS}, you need to exit Emacs and start it up again before
Gnus will work.

Read the help group (@kbd{M h} in the group buffer) for a FAQ and a
how-to. 

If all else fails, report the problem as a bug (@pxref{Reporting
Bugs}). 

@node Reporting Bugs
@chapter Reporting Bugs
@cindex bugs
@cindex reporting bugs

@kindex M-x gnus-bug
@findex gnus-bug
If you find a bug in (ding) Gnus, you can report it with the @kbd{M-x
gnus-bug} command.  @code{(setq debug-on-error t)}, 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.

If you just need help, you are better off asking on
@samp{gnu.emacs.gnus}.

@node Index
@chapter Index
@printindex cp

@node Key Index
@chapter Key Index
@printindex ky

@summarycontents
@contents
@bye

\f
@c Local Variables:
@c outline-regexp: "@chap\\|@\\(sub\\)*section\\|@appendix \\|@appendix\\(sub\\)*sec\\|\^L"
@c End: