This is gnus, produced by makeinfo version 4.5 from gnus.texi.

INFO-DIR-SECTION The Emacs editor and associated tools
START-INFO-DIR-ENTRY
* Gnus: (gnus.info).			The newsreader Gnus.
END-INFO-DIR-ENTRY

   This file documents Gnus, the GNU Emacs newsreader.

   Copyright (C) 1995,96,97,98,99,2000 Free Software Foundation, Inc.

   Permission is granted to copy, distribute and/or modify this document
under the terms of the GNU Free Documentation License, Version 1.1 or
any later version published by the Free Software Foundation; with the
Invariant Sections being none, with the Front-Cover texts being "A GNU
Manual", and with the Back-Cover Texts as in (a) below.  A copy of the
license is included in the section entitled "GNU Free Documentation
License" in the Emacs manual.

   (a) The FSF's Back-Cover Text is: "You have freedom to copy and
modify this GNU Manual, like GNU software.  Copies published by the Free
Software Foundation raise funds for GNU development."

   This document is part of a collection distributed under the GNU Free
Documentation License.  If you want to distribute this document
separately from the collection, you can do so by adding a copy of the
license to the document, as described in section 6 of the license.


File: gnus,  Node: Topic Topology,  Next: Topic Parameters,  Prev: Topic Sorting,  Up: Group Topics

Topic Topology
--------------

   So, let's have a look at an example group buffer:

     Gnus
       Emacs -- I wuw it!
          3: comp.emacs
          2: alt.religion.emacs
         Naughty Emacs
          452: alt.sex.emacs
            0: comp.talk.emacs.recovery
       Misc
          8: comp.binaries.fractals
         13: comp.sources.unix

   So, here we have one top-level topic (`Gnus'), two topics under
that, and one sub-topic under one of the sub-topics.  (There is always
just one (1) top-level topic).  This topology can be expressed as
follows:

     (("Gnus" visible)
      (("Emacs -- I wuw it!" visible)
       (("Naughty Emacs" visible)))
      (("Misc" visible)))

   This is in fact how the variable `gnus-topic-topology' would look
for the display above.  That variable is saved in the `.newsrc.eld'
file, and shouldn't be messed with manually--unless you really want to.
Since this variable is read from the `.newsrc.eld' file, setting it in
any other startup files will have no effect.

   This topology shows what topics are sub-topics of what topics
(right), and which topics are visible.  Two settings are currently
allowed--`visible' and `invisible'.


File: gnus,  Node: Topic Parameters,  Prev: Topic Topology,  Up: Group Topics

Topic Parameters
----------------

   All groups in a topic will inherit group parameters from the parent
(and ancestor) topic parameters.  All valid group parameters are valid
topic parameters (*note Group Parameters::).

   In addition, the following parameters are only valid as topic
parameters:

`subscribe'
     When subscribing new groups by topic (*note Subscription
     Methods::), the `subscribe' topic parameter says what groups go in
     what topic.  Its value should be a regexp to match the groups that
     should go in that topic.


   Group parameters (of course) override topic parameters, and topic
parameters in sub-topics override topic parameters in super-topics.  You
know.  Normal inheritance rules.  ("Rules" is here a noun, not a verb,
although you may feel free to disagree with me here.)

     Gnus
       Emacs
          3: comp.emacs
          2: alt.religion.emacs
        452: alt.sex.emacs
         Relief
          452: alt.sex.emacs
            0: comp.talk.emacs.recovery
       Misc
          8: comp.binaries.fractals
         13: comp.sources.unix
        452: alt.sex.emacs

   The `Emacs' topic has the topic parameter `(score-file .
"emacs.SCORE")'; the `Relief' topic has the topic parameter
`(score-file . "relief.SCORE")'; and the `Misc' topic has the topic
parameter `(score-file . "emacs.SCORE")'.  In addition,
`alt.religion.emacs' has the group parameter `(score-file .
"religion.SCORE")'.

   Now, when you enter `alt.sex.emacs' in the `Relief' topic, you will
get the `relief.SCORE' home score file.  If you enter the same group in
the `Emacs' topic, you'll get the `emacs.SCORE' home score file.  If
you enter the group `alt.religion.emacs', you'll get the
`religion.SCORE' home score file.

   This seems rather simple and self-evident, doesn't it?  Well, yes.
But there are some problems, especially with the `total-expiry'
parameter.  Say you have a mail group in two topics; one with
`total-expiry' and one without.  What happens when you do `M-x
gnus-expire-all-expirable-groups'?  Gnus has no way of telling which one
of these topics you mean to expire articles from, so anything may
happen.  In fact, I hereby declare that it is "undefined" what happens.
You just have to be careful if you do stuff like that.


File: gnus,  Node: Misc Group Stuff,  Prev: Group Topics,  Up: The Group Buffer

Misc Group Stuff
================

* Menu:

* Scanning New Messages:: Asking Gnus to see whether new messages have arrived.
* Group Information::     Information and help on groups and Gnus.
* Group Timestamp::       Making Gnus keep track of when you last read a group.
* File Commands::         Reading and writing the Gnus files.

`^'
     Enter the server buffer (`gnus-group-enter-server-mode').  *Note
     The Server Buffer::.

`a'
     Post an article to a group (`gnus-group-post-news').  If given a
     prefix, the current group name will be used as the default.

`m'
     Mail a message somewhere (`gnus-group-mail').


   Variables for the group buffer:

`gnus-group-mode-hook'
     is called after the group buffer has been created.

`gnus-group-prepare-hook'
     is called after the group buffer is generated.  It may be used to
     modify the buffer in some strange, unnatural way.

`gnus-group-prepared-hook'
     is called as the very last thing after the group buffer has been
     generated.  It may be used to move point around, for instance.

`gnus-permanently-visible-groups'
     Groups matching this regexp will always be listed in the group
     buffer, whether they are empty or not.

`gnus-group-name-charset-method-alist'
     An alist of method and the charset for group names. It is used to
     show non-ASCII group names.

     For example:
          (setq gnus-group-name-charset-method-alist
              '(((nntp "news.com.cn") . cn-gb-2312)))

`gnus-group-name-charset-group-alist'
     An alist of regexp of group name and the charset for group names.
     It is used to show non-ASCII group names.

     For example:
          (setq gnus-group-name-charset-group-alist
              '(("\\.com\\.cn:" . cn-gb-2312)))



File: gnus,  Node: Scanning New Messages,  Next: Group Information,  Up: Misc Group Stuff

Scanning New Messages
---------------------

`g'
     Check the server(s) for new articles.  If the numerical prefix is
     used, this command will check only groups of level ARG and lower
     (`gnus-group-get-new-news').  If given a non-numerical prefix, this
     command will force a total re-reading of the active file(s) from
     the backend(s).

`M-g'
     Check whether new articles have arrived in the current group
     (`gnus-group-get-new-news-this-group').
     `gnus-goto-next-group-when-activating' says whether this command is
     to move point to the next group or not.  It is `t' by default.

`C-c M-g'
     Activate absolutely all groups (`gnus-activate-all-groups').

`R'
     Restart Gnus (`gnus-group-restart').  This saves the `.newsrc'
     file(s), closes the connection to all servers, clears up all
     run-time Gnus variables, and then starts Gnus all over again.


   `gnus-get-new-news-hook' is run just before checking for new news.

   `gnus-after-getting-new-news-hook' is run after checking for new
news.


File: gnus,  Node: Group Information,  Next: Group Timestamp,  Prev: Scanning New Messages,  Up: Misc Group Stuff

Group Information
-----------------

`H f'
     Try to fetch the FAQ for the current group
     (`gnus-group-fetch-faq').  Gnus will try to get the FAQ from
     `gnus-group-faq-directory', which is usually a directory on a
     remote machine.  This variable can also be a list of directories.
     In that case, giving a prefix to this command will allow you to
     choose between the various sites.  `ange-ftp' (or `efs') will be
     used for fetching the file.

     If fetching from the first site is unsuccessful, Gnus will attempt
     to go through `gnus-group-faq-directory' and try to open them one
     by one.

`H d'
`C-c C-d'
     Describe the current group (`gnus-group-describe-group').  If given
     a prefix, force Gnus to re-read the description from the server.

`M-d'
     Describe all groups (`gnus-group-describe-all-groups').  If given a
     prefix, force Gnus to re-read the description file from the server.

`H v'
`V'
     Display current Gnus version numbers (`gnus-version').

`?'
     Give a very short help message (`gnus-group-describe-briefly').

`C-c C-i'
     Go to the Gnus info node (`gnus-info-find-node').


File: gnus,  Node: Group Timestamp,  Next: File Commands,  Prev: Group Information,  Up: Misc Group Stuff

Group Timestamp
---------------

   It can be convenient to let Gnus keep track of when you last read a
group.  To set the ball rolling, you should add
`gnus-group-set-timestamp' to `gnus-select-group-hook':

     (add-hook 'gnus-select-group-hook 'gnus-group-set-timestamp)

   After doing this, each time you enter a group, it'll be recorded.

   This information can be displayed in various ways--the easiest is to
use the `%d' spec in the group line format:

     (setq gnus-group-line-format
           "%M\%S\%p\%P\%5y: %(%-40,40g%) %d\n")

   This will result in lines looking like:

     *        0: mail.ding                                19961002T012943
              0: custom                                   19961002T012713

   As you can see, the date is displayed in compact ISO 8601 format.
This may be a bit too much, so to just display the date, you could say
something like:

     (setq gnus-group-line-format
           "%M\%S\%p\%P\%5y: %(%-40,40g%) %6,6~(cut 2)d\n")


File: gnus,  Node: File Commands,  Prev: Group Timestamp,  Up: Misc Group Stuff

File Commands
-------------

`r'
     Re-read the init file (`gnus-init-file', which defaults to
     `~/.gnus') (`gnus-group-read-init-file').

`s'
     Save the `.newsrc.eld' file (and `.newsrc' if wanted)
     (`gnus-group-save-newsrc').  If given a prefix, force saving the
     file(s) whether Gnus thinks it is necessary or not.



File: gnus,  Node: The Summary Buffer,  Next: The Article Buffer,  Prev: The Group Buffer,  Up: Top

The Summary Buffer
******************

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

   The most common way to a summary buffer is to select a group from the
group buffer (*note Selecting a Group::).

   You can have as many summary buffers open as you wish.

* Menu:

* Summary Buffer Format::       Deciding how the summary buffer is to look.
* Summary Maneuvering::         Moving around the summary buffer.
* Choosing Articles::           Reading articles.
* Paging the Article::          Scrolling the current article.
* Reply Followup and Post::     Posting articles.
* Marking Articles::            Marking articles as read, expirable, etc.
* Limiting::                    You can limit the summary buffer.
* Threading::                   How threads are made.
* Sorting::                     How articles and threads are sorted.
* Asynchronous Fetching::       Gnus might be able to pre-fetch articles.
* Article Caching::             You may store articles in a cache.
* Persistent Articles::         Making articles expiry-resistant.
* Article Backlog::             Having already read articles hang around.
* Saving Articles::             Ways of customizing article saving.
* Decoding Articles::           Gnus can treat series of (uu)encoded articles.
* Article Treatment::           The article buffer can be mangled at will.
* MIME Commands::               Doing MIMEy things with the articles.
* Charsets::                    Character set issues.
* Article Commands::            Doing various things with the article buffer.
* Summary Sorting::             Sorting the summary buffer in various ways.
* Finding the Parent::          No child support? Get the parent.
* Alternative Approaches::      Reading using non-default summaries.
* Tree Display::                A more visual display of threads.
* Mail Group Commands::         Some commands can only be used in mail groups.
* Various Summary Stuff::       What didn't fit anywhere else.
* Exiting the Summary Buffer::  Returning to the Group buffer.
* Crosspost Handling::          How crossposted articles are dealt with.
* Duplicate Suppression::       An alternative when crosspost handling fails.


File: gnus,  Node: Summary Buffer Format,  Next: Summary Maneuvering,  Up: The Summary Buffer

Summary Buffer Format
=====================

* Menu:

* Summary Buffer Lines::     You can specify how summary lines should look.
* To From Newsgroups::       How to not display your own name.
* Summary Buffer Mode Line:: You can say how the mode line should look.
* Summary Highlighting::     Making the summary buffer all pretty and nice.

   Gnus will use the value of the `gnus-extract-address-components'
variable as a function for getting the name and address parts of a
`From' header.  Two pre-defined functions exist:
`gnus-extract-address-components', which is the default, quite fast,
and too simplistic solution; and `mail-extract-address-components',
which works very nicely, but is slower.  The default function will
return the wrong answer in 5% of the cases.  If this is unacceptable to
you, use the other function instead:

     (setq gnus-extract-address-components
           'mail-extract-address-components)

   `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.  The default is `""'.


File: gnus,  Node: Summary Buffer Lines,  Next: To From Newsgroups,  Up: Summary Buffer Format

Summary Buffer Lines
--------------------

   You can change the format of the lines in the summary buffer by
changing the `gnus-summary-line-format' variable.  It works along the
same lines as a normal `format' string, with some extensions (*note
Formatting Variables::).

   The default string is `%U%R%z%I%(%[%4L: %-20,20n%]%) %s\n'.

   The following format specification characters are understood:

`N'
     Article number.

`S'
     Subject string.  List identifiers stripped,
     `gnus-list-identifies'.  *Note Article Hiding::.

`s'
     Subject if the article is the root of the thread or the previous
     article had a different subject, `gnus-summary-same-subject'
     otherwise.  (`gnus-summary-same-subject' defaults to `""'.)

`F'
     Full `From' header.

`n'
     The name (from the `From' header).

`f'
     The name, code `To' header or the `Newsgroups' header (*note To
     From Newsgroups::).

`a'
     The name (from the `From' header).  This differs from the `n' spec
     in that it uses the function designated by the
     `gnus-extract-address-components' variable, which is slower, but
     may be more thorough.

`A'
     The address (from the `From' header).  This works the same way as
     the `a' spec.

`L'
     Number of lines in the article.

`c'
     Number of characters in the article. This specifier is not
     supported in some methods (like nnfolder).

`I'
     Indentation based on thread level (*note Customizing Threading::).

`T'
     Nothing if the article is a root and lots of spaces if it isn't (it
     pushes everything after it off the screen).

`['
     Opening bracket, which is normally `[', but can also be `<' for
     adopted articles (*note Customizing Threading::).

`]'
     Closing bracket, which is normally `]', but can also be `>' for
     adopted articles.

`>'
     One space for each thread level.

`<'
     Twenty minus thread level spaces.

`U'
     Unread.

`R'
     This misleadingly named specifier is the "secondary mark".  This
     mark will say whether the article has been replied to, has been
     cached, or has been saved.

`i'
     Score as a number (*note Scoring::).

`z'
     Zcore, `+' if above the default level and `-' if below the default
     level.  If the difference between `gnus-summary-default-score' and
     the score is less than `gnus-summary-zcore-fuzz', this spec will
     not be used.

`V'
     Total thread score.

`x'
     `Xref'.

`D'
     `Date'.

`d'
     The `Date' in `DD-MMM' format.

`o'
     The `Date' in YYYYMMDD`T'HHMMSS format.

`M'
     `Message-ID'.

`r'
     `References'.

`t'
     Number of articles in the current sub-thread.  Using this spec
     will slow down summary buffer generation somewhat.

`e'
     An `=' (`gnus-not-empty-thread-mark') will be displayed if the
     article has any children.

`P'
     The line number.

`O'
     Download mark.

`u'
     User defined specifier.  The next character in the format string
     should be a letter.  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.

   The `%U' (status), `%R' (replied) and `%z' (zcore) specs have to be
handled with care.  For reasons of efficiency, Gnus will compute what
column these characters will end up in, and "hard-code" that.  This
means that it is invalid to have these specs after a variable-length
spec.  Well, 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.


File: gnus,  Node: To From Newsgroups,  Next: Summary Buffer Mode Line,  Prev: Summary Buffer Lines,  Up: Summary Buffer Format

To From Newsgroups
------------------

   In some groups (particularly in archive groups), the `From' header
isn't very interesting, since all the articles there are written by
you.  To display the information in the `To' or `Newsgroups' headers
instead, you need to decide three things: What information to gather;
where to display it; and when to display it.

  1. The reading of extra header information is controlled by the
     `gnus-extra-headers'.  This is a list of header symbols.  For
     instance:

          (setq gnus-extra-headers
                '(To Newsgroups X-Newsreader))

     This will result in Gnus trying to obtain these three headers, and
     storing it in header structures for later easy retrieval.

  2. The value of these extra headers can be accessed via the
     `gnus-extra-header' function.  Here's a format line spec that will
     access the `X-Newsreader' header:

          "%~(form (gnus-extra-header 'X-Newsreader))@"

  3. The `gnus-ignored-from-addresses' variable says when the `%f'
     summary line spec returns the `To', `Newsreader' or `From' header.
     If this regexp matches the contents of the `From' header, the
     value of the `To' or `Newsreader' headers are used instead.


   A related variable is `nnmail-extra-headers', which controls when to
include extra headers when generating overview (NOV) files.  If you
have old overview files, you should regenerate them after changing this
variable.

   You also have to instruct Gnus to display the data by changing the
`%n' spec to the `%f' spec in the `gnus-summary-line-format' variable.

   In summary, you'd typically do something like the following:

     (setq gnus-extra-headers
           '(To Newsgroups))
     (setq nnmail-extra-headers gnus-extra-headers)
     (setq gnus-summary-line-format
           "%U%R%z%I%(%[%4L: %-20,20f%]%) %s\n")
     (setq gnus-ignored-from-addresses
           "Your Name Here")

   Now, this is mostly useful for mail groups, where you have control
over the NOV files that are created.  However, if you can persuade your
nntp admin to add:

     Newsgroups:full

   to the end of her `overview.fmt' file, then you can use that just as
you would the extra headers from the mail groups.


File: gnus,  Node: Summary Buffer Mode Line,  Next: Summary Highlighting,  Prev: To From Newsgroups,  Up: Summary Buffer Format

Summary Buffer Mode Line
------------------------

   You can also change the format of the summary mode bar (*note Mode
Line Formatting::).  Set `gnus-summary-mode-line-format' to whatever you
like.  The default is `Gnus: %%b [%A] %Z'.

   Here are the elements you can play with:

`G'
     Group name.

`p'
     Unprefixed group name.

`A'
     Current article number.

`z'
     Current article score.

`V'
     Gnus version.

`U'
     Number of unread articles in this group.

`e'
     Number of unread articles in this group that aren't displayed in
     the summary buffer.

`Z'
     A string with the number of unread and unselected articles
     represented either as `<%U(+%e) more>' if there are both unread
     and unselected articles, and just as `<%U more>' if there are just
     unread articles and no unselected ones.

`g'
     Shortish group name.  For instance, `rec.arts.anime' will be
     shortened to `r.a.anime'.

`S'
     Subject of the current article.

`u'
     User-defined spec (*note User-Defined Specs::).

`s'
     Name of the current score file (*note Scoring::).

`d'
     Number of dormant articles (*note Unread Articles::).

`t'
     Number of ticked articles (*note Unread Articles::).

`r'
     Number of articles that have been marked as read in this session.

`E'
     Number of articles expunged by the score files.


File: gnus,  Node: Summary Highlighting,  Prev: Summary Buffer Mode Line,  Up: Summary Buffer Format

Summary Highlighting
--------------------

`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
     `gnus-visual' is `nil'.

`gnus-summary-update-hook'
     This hook is called when a summary line is changed.  It is not run
     if `gnus-visual' is `nil'.

`gnus-summary-selected-face'
     This is the face (or "font" as some people call it) used to
     highlight the current article in the summary buffer.

`gnus-summary-highlight'
     Summary lines are highlighted according to this variable, which is
     a list where the elements are of the format `(FORM . FACE)'.  If
     you would, for instance, like ticked articles to be italic and
     high-scored articles to be bold, you could set this variable to
     something like
          (((eq mark gnus-ticked-mark) . italic)
           ((> score default) . bold))
     As you may have guessed, if FORM returns a non-`nil' value, FACE
     will be applied to the line.


File: gnus,  Node: Summary Maneuvering,  Next: Choosing Articles,  Prev: Summary Buffer Format,  Up: The Summary Buffer

Summary Maneuvering
===================

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

   None of these commands select articles.

`G M-n'
`M-n'
     Go to the next summary line of an unread article
     (`gnus-summary-next-unread-subject').

`G M-p'
`M-p'
     Go to the previous summary line of an unread article
     (`gnus-summary-prev-unread-subject').

`G j'
`j'
     Ask for an article number or `Message-ID', and then go to that
     article (`gnus-summary-goto-article').

`G g'
     Ask for an article number and then go to the summary line of that
     article without displaying the article
     (`gnus-summary-goto-subject').

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

   Variables related to summary movement:

`gnus-auto-select-next'
     If you issue one of the movement commands (like `n') and there are
     no more unread articles after the current one, Gnus will offer to
     go to the next group.  If this variable is `t' and the next group
     is empty, Gnus will exit summary mode and return to the group
     buffer.  If this variable is neither `t' nor `nil', Gnus will
     select the next group, no matter whether it has any unread
     articles or not.  As a special case, if this variable is
     `quietly', Gnus will select the next group without asking for
     confirmation.  If this variable is `almost-quietly', the same will
     happen only if you are located on the last article in the group.
     Finally, if this variable is `slightly-quietly', the `Z n' command
     will go to the next group without confirmation.  Also *note Group
     Levels::.

`gnus-auto-select-same'
     If non-`nil', all the movement commands will try to go to the next
     article with the same subject as the current.  ("Same" here might
     mean "roughly equal".  See `gnus-summary-gather-subject-limit' for
     details (*note Customizing Threading::).)  If there are no more
     articles with the same subject, go to the first unread article.

     This variable is not particularly useful if you use a threaded
     display.

`gnus-summary-check-current'
     If non-`nil', all the "unread" movement commands will not proceed
     to the next (or previous) article if the current article is unread.
     Instead, they will choose the current article.

`gnus-auto-center-summary'
     If non-`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 simply do not like this
     un-Emacsism, you can set this variable to `nil' to get the normal
     Emacs scrolling action.  This will also inhibit horizontal
     re-centering of the summary buffer, which might make it more
     inconvenient to read extremely long threads.

     This variable can also be a number.  In that case, center the
     window at the given number of lines from the top.



File: gnus,  Node: Choosing Articles,  Next: Paging the Article,  Prev: Summary Maneuvering,  Up: The Summary Buffer

Choosing Articles
=================

* Menu:

* Choosing Commands::        Commands for choosing articles.
* Choosing Variables::       Variables that influence these commands.


File: gnus,  Node: Choosing Commands,  Next: Choosing Variables,  Up: Choosing Articles

Choosing Commands
-----------------

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

`SPACE'
     Select the current article, or, if that one's read already, the
     next unread article (`gnus-summary-next-page').

`G n'
`n'
     Go to next unread article (`gnus-summary-next-unread-article').

`G p'
`p'
     Go to previous unread article (`gnus-summary-prev-unread-article').

`G N'
`N'
     Go to the next article (`gnus-summary-next-article').

`G P'
`P'
     Go to the previous article (`gnus-summary-prev-article').

`G C-n'
     Go to the next article with the same subject
     (`gnus-summary-next-same-subject').

`G C-p'
     Go to the previous article with the same subject
     (`gnus-summary-prev-same-subject').

`G f'
`.'
     Go to the first unread article
     (`gnus-summary-first-unread-article').

`G b'
`,'
     Go to the article with the highest score
     (`gnus-summary-best-unread-article').

`G l'
`l'
     Go to the previous article read (`gnus-summary-goto-last-article').

`G o'
     Pop an article off the summary history and go to this article
     (`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, while `l' toggles the two last read articles.
     For a somewhat related issue (if you use these commands a lot),
     *note Article Backlog::.


File: gnus,  Node: Choosing Variables,  Prev: Choosing Commands,  Up: Choosing Articles

Choosing Variables
------------------

   Some variables relevant for moving and selecting articles:

`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-`nil'.  Gnus will then fetch the
     article from the server and display it in the article buffer.

`gnus-select-article-hook'
     This hook is called whenever an article is selected.  By default it
     exposes any threads hidden under the selected article.

`gnus-mark-article-hook'
     This hook is called whenever an article is selected.  It is
     intended to be used for marking articles as read.  The default
     value is `gnus-summary-mark-read-and-unread-as-read', and will
     change the mark of almost any article you read to
     `gnus-unread-mark'.  The only articles not affected by this
     function are ticked, dormant, and expirable articles.  If you'd
     instead like to just have unread articles marked as read, you can
     use `gnus-summary-mark-unread-as-read' instead.  It will leave
     marks like `gnus-low-score-mark', `gnus-del-mark' (and so on)
     alone.



File: gnus,  Node: Paging the Article,  Next: Reply Followup and Post,  Prev: Choosing Articles,  Up: The Summary Buffer

Scrolling the Article
=====================

`SPACE'
     Pressing `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 (`gnus-summary-next-page').

`DEL'
     Scroll the current article back one page
     (`gnus-summary-prev-page').

`RET'
     Scroll the current article one line forward
     (`gnus-summary-scroll-up').

`M-RET'
     Scroll the current article one line backward
     (`gnus-summary-scroll-down').

`A g'
`g'
     (Re)fetch the current article (`gnus-summary-show-article').  If
     given a prefix, fetch the current article, but don't run any of the
     article treatment functions.  This will give you a "raw" article,
     just the way it came from the server.

     If given a numerical prefix, you can do semi-manual charset stuff.
     `C-u 0 g cn-gb-2312 RET' will decode the message as if it were
     encoded in the `cn-gb-2312' charset.  If you have

          (setq gnus-summary-show-article-charset-alist
                '((1 . cn-gb-2312)
                  (2 . big5)))

     then you can say `C-u 1 g' to get the same effect.

`A <'
`<'
     Scroll to the beginning of the article
     (`gnus-summary-beginning-of-article').

`A >'
`>'
     Scroll to the end of the article (`gnus-summary-end-of-article').

`A s'
`s'
     Perform an isearch in the article buffer
     (`gnus-summary-isearch-article').

`h'
     Select the article buffer (`gnus-summary-select-article-buffer').



File: gnus,  Node: Reply Followup and Post,  Next: Marking Articles,  Prev: Paging the Article,  Up: The Summary Buffer

Reply, Followup and Post
========================

* Menu:

* Summary Mail Commands::       Sending mail.
* Summary Post Commands::       Sending news.
* Summary Message Commands::    Other Message-related commands.
* Canceling and Superseding::   ``Whoops, I shouldn't have called him that.''


File: gnus,  Node: Summary Mail Commands,  Next: Summary Post Commands,  Up: Reply Followup and Post

Summary Mail Commands
---------------------

   Commands for composing a mail message:

`S r'
`r'
     Mail a reply to the author of the current article
     (`gnus-summary-reply').

`S R'
`R'
     Mail a reply to the author of the current article and include the
     original message (`gnus-summary-reply-with-original').  This
     command uses the process/prefix convention.

`S w'
     Mail a wide reply to the author of the current article
     (`gnus-summary-wide-reply').  A "wide reply" is a reply that goes
     out to all people listed in the `To', `From' (or `Reply-to') and
     `Cc' headers.

`S W'
     Mail a wide reply to the current article and include the original
     message (`gnus-summary-wide-reply-with-original').  This command
     uses the process/prefix convention.

`S o m'
`C-c C-f'
     Forward the current article to some other person
     (`gnus-summary-mail-forward').  If no prefix is given, the message
     is forwarded according to the value of (`message-forward-as-mime')
     and (`message-forward-show-mml'); if the prefix is 1, decode the
     message and forward directly inline; if the prefix is 2, foward
     message as an rfc822 MIME section; if the prefix is 3, decode
     message and forward as an rfc822 MIME section; if the prefix is 4,
     foward message directly inline; otherwise, the message is
     forwarded as no prefix given but use the flipped value of
     (`message-forward-as-mime').  By default, the message is decoded
     and forwarded as an rfc822 MIME section.

`S m'
`m'
     Send a mail to some other person
     (`gnus-summary-mail-other-window').

`S D b'
     If you have sent a mail, but the mail was bounced back to you for
     some reason (wrong address, transient failure), you can use this
     command to resend that bounced mail
     (`gnus-summary-resend-bounced-mail').  You will be popped into a
     mail buffer where you can edit the headers before sending the mail
     off again.  If you give a prefix to this command, and the bounced
     mail is a reply to some other mail, Gnus will try to fetch that
     mail and display it for easy perusal of its headers.  This might
     very well fail, though.

`S D r'
     Not to be confused with the previous command,
     `gnus-summary-resend-message' will prompt you for an address to
     send the current message off to, and then send it to that place.
     The headers of the message won't be altered--but lots of headers
     that say `Resent-To', `Resent-From' and so on will be added.  This
     means that you actually send a mail to someone that has a `To'
     header that (probably) points to yourself.  This will confuse
     people.  So, natcherly you'll only do that if you're really eVIl.

     This command is mainly used if you have several accounts and want
     to ship a mail to a different account of yours.  (If you're both
     `root' and `postmaster' and get a mail for `postmaster' to the
     `root' account, you may want to resend it to `postmaster'.
     Ordnung muß sein!

     This command understands the process/prefix convention (*note
     Process/Prefix::).

`S O m'
     Digest the current series (*note Decoding Articles::) and forward
     the result using mail (`gnus-uu-digest-mail-forward').  This
     command uses the process/prefix convention (*note
     Process/Prefix::).

`S M-c'
     Send a complaint about excessive crossposting to the author of the
     current article (`gnus-summary-mail-crosspost-complaint').

     This command is provided as a way to fight back against the current
     crossposting pandemic that's sweeping Usenet.  It will compose a
     reply using the `gnus-crosspost-complaint' variable as a preamble.
     This command understands the process/prefix convention (*note
     Process/Prefix::) and will prompt you before sending each mail.


   Also *note (message)Header Commands:: for more information.


File: gnus,  Node: Summary Post Commands,  Next: Summary Message Commands,  Prev: Summary Mail Commands,  Up: Reply Followup and Post

Summary Post Commands
---------------------

   Commands for posting a news article:

`S p'
`a'
     Post an article to the current group (`gnus-summary-post-news').

`S f'
`f'
     Post a followup to the current article (`gnus-summary-followup').

`S F'
`F'
     Post a followup to the current article and include the original
     message (`gnus-summary-followup-with-original').   This command
     uses the process/prefix convention.

`S n'
     Post a followup to the current article via news, even if you got
     the message through mail (`gnus-summary-followup-to-mail').

`S N'
     Post a followup to the current article via news, even if you got
     the message through mail and include the original message
     (`gnus-summary-followup-to-mail-with-original').  This command uses
     the process/prefix convention.

`S o p'
     Forward the current article to a newsgroup
     (`gnus-summary-post-forward').   If no prefix is given, the
     message is forwarded according to the value of
     (`message-forward-as-mime') and (`message-forward-show-mml'); if
     the prefix is 1, decode the message and forward directly inline;
     if the prefix is 2, foward message as an rfc822 MIME section; if
     the prefix is 3, decode message and forward as an rfc822 MIME
     section; if the prefix is 4, foward message directly inline;
     otherwise, the message is forwarded as no prefix given but use the
     flipped value of (`message-forward-as-mime').  By default, the
     message is decoded and forwarded as an rfc822 MIME section.

`S O p'
     Digest the current series and forward the result to a newsgroup
     (`gnus-uu-digest-mail-forward').  This command uses the
     process/prefix convention.

`S u'
     Uuencode a file, split it into parts, and post it as a series
     (`gnus-uu-post-news').  (*note Uuencoding and Posting::).

   Also *note (message)Header Commands:: for more information.


File: gnus,  Node: Summary Message Commands,  Next: Canceling and Superseding,  Prev: Summary Post Commands,  Up: Reply Followup and Post

Summary Message Commands
------------------------

`S y'
     Yank the current article into an already existing Message
     composition buffer (`gnus-summary-yank-message').  This command
     prompts for what message buffer you want to yank into, and
     understands the process/prefix convention (*note Process/Prefix::).



File: gnus,  Node: Canceling and Superseding,  Prev: Summary Message Commands,  Up: Reply Followup and Post

Canceling Articles
------------------

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

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

   Find the article you wish to cancel (you can only cancel your own
articles, so don't try any funny stuff).  Then press `C' or `S c'
(`gnus-summary-cancel-article').  Your article will be
canceled--machines all over the world will be deleting your article.
This command uses the process/prefix convention (*note
Process/Prefix::).

   Be aware, however, that not all sites honor cancels, so your article
may live on here and there, while most sites will delete the article in
question.

   Gnus will use the "current" select method when canceling.  If you
want to use the standard posting method, use the `a' symbolic prefix
(*note Symbolic Prefixes::).

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

   Go to the original article and press `S s'
(`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 canceling, 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 `*sent ...*').  There you will find
the article you just posted, with all the headers intact.  Change the
`Message-ID' header to a `Cancel' or `Supersedes' header by
substituting one of those words for the word `Message-ID'.  Then just
press `C-c C-c' to send the article as you would do normally.  The
previous article will be canceled/superseded.

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


File: gnus,  Node: Marking Articles,  Next: Limiting,  Prev: Reply Followup and Post,  Up: The Summary Buffer

Marking Articles
================

   There are several marks you can set on an article.

   You have marks that decide the "readedness" (whoo, neato-keano
neologism ohoy!) of the article.  Alphabetic marks generally mean
"read", while non-alphabetic characters generally mean "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.

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

* Menu:

* Setting Marks::             How to set and remove marks.
* Generic Marking Commands::  How to customize the marking.
* Setting Process Marks::     How to mark articles for later processing.


File: gnus,  Node: Unread Articles,  Next: Read Articles,  Up: Marking Articles

Unread Articles
---------------

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

`!'
     Marked as ticked (`gnus-ticked-mark').

     "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 make it persistent
     (*note Persistent Articles::).

`?'
     Marked as dormant (`gnus-dormant-mark').

     "Dormant articles" will only appear in the summary buffer if there
     are followups to it.  If you want to see them even if they don't
     have followups, you can use the `/ D' command (*note Limiting::).

`SPACE'
     Marked as unread (`gnus-unread-mark').

     "Unread articles" are articles that haven't been read at all yet.


File: gnus,  Node: Read Articles,  Next: Other Marks,  Prev: Unread Articles,  Up: Marking Articles

Read Articles
-------------

   All the following marks mark articles as read.

`r'
     These are articles that the user has marked as read with the `d'
     command manually, more or less (`gnus-del-mark').

`R'
     Articles that have actually been read (`gnus-read-mark').

`O'
     Articles that were marked as read in previous sessions and are now
     "old" (`gnus-ancient-mark').

`K'
     Marked as killed (`gnus-killed-mark').

`X'
     Marked as killed by kill files (`gnus-kill-file-mark').

`Y'
     Marked as read by having too low a score (`gnus-low-score-mark').

`C'
     Marked as read by a catchup (`gnus-catchup-mark').

`G'
     Canceled article (`gnus-canceled-mark')

`F'
     SOUPed article (`gnus-souped-mark').  *Note SOUP::.

`Q'
     Sparsely reffed article (`gnus-sparse-mark').  *Note Customizing
     Threading::.

`M'
     Article marked as read by duplicate suppression
     (`gnus-duplicated-mark').  *Note Duplicate Suppression::.


   All these marks just mean that the article is marked as read, really.
They are interpreted differently when doing adaptive scoring, though.

   One more special mark, though:

`E'
     Marked as expirable (`gnus-expirable-mark').

     Marking articles as "expirable" (or have them marked as such
     automatically) doesn't make much sense in normal groups--a user
     doesn't control expiring of news articles, but in mail groups, for
     instance, articles marked as "expirable" can be deleted by Gnus at
     any time.


File: gnus,  Node: Other Marks,  Next: Setting Marks,  Prev: Read Articles,  Up: Marking Articles

Other Marks
-----------

   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 cats' 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.  *Note Setting
     Marks::.

   * All articles that you have replied to or made a followup to (i.e.,
     have answered) will be marked with an `A' in the second column
     (`gnus-replied-mark').

   * Articles stored in the article cache will be marked with an `*' in
     the second column (`gnus-cached-mark').  *Note Article Caching::.

   * Articles "saved" (in some manner or other; not necessarily
     religiously) are marked with an `S' in the second column
     (`gnus-saved-mark').

   * If the `%e' spec is used, the presence of threads or not will be
     marked with `gnus-not-empty-thread-mark' and
     `gnus-empty-thread-mark' in the third column, respectively.

   * Finally we have the "process mark" (`gnus-process-mark').  A
     variety of commands react to the presence of the process mark.  For
     instance, `X u' (`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 `#' in the second column.


   You might have noticed that most of these "non-readedness" marks
appear in the second column by default.  So if you have a cached, saved,
replied article that you have process-marked, what will that look like?

   Nothing much.  The precedence rules go as follows: process -> cache
-> replied -> saved.  So if the article is in the cache and is replied,
you'll only see the cache mark and not the replied mark.


File: gnus,  Node: Setting Marks,  Next: Generic Marking Commands,  Prev: Other Marks,  Up: Marking Articles

Setting Marks
-------------

   All the marking commands understand the numeric prefix.

`M c'
`M-u'
     Clear all readedness-marks from the current article
     (`gnus-summary-clear-mark-forward').  In other words, mark the
     article as unread.

`M t'
`!'
     Tick the current article (`gnus-summary-tick-article-forward').
     *Note Article Caching::.

`M ?'
`?'
     Mark the current article as dormant
     (`gnus-summary-mark-as-dormant').  *Note Article Caching::.

`M d'
`d'
     Mark the current article as read
     (`gnus-summary-mark-as-read-forward').

`D'
     Mark the current article as read and move point to the previous
     line (`gnus-summary-mark-as-read-backward').

`M k'
`k'
     Mark all articles that have the same subject as the current one as
     read, and then select the next unread article
     (`gnus-summary-kill-same-subject-and-select').

`M K'
`C-k'
     Mark all articles that have the same subject as the current one as
     read (`gnus-summary-kill-same-subject').

`M C'
     Mark all unread articles as read (`gnus-summary-catchup').

`M C-c'
     Mark all articles in the group as read--even the ticked and dormant
     articles (`gnus-summary-catchup-all').

`M H'
     Catchup the current group to point
     (`gnus-summary-catchup-to-here').

`C-w'
     Mark all articles between point and mark as read
     (`gnus-summary-mark-region-as-read').

`M V k'
     Kill all articles with scores below the default score (or below the
     numeric prefix) (`gnus-summary-kill-below').

`M e'
`E'
     Mark the current article as expirable
     (`gnus-summary-mark-as-expirable').

`M b'
     Set a bookmark in the current article
     (`gnus-summary-set-bookmark').

`M B'
     Remove the bookmark from the current article
     (`gnus-summary-remove-bookmark').

`M V c'
     Clear all marks from articles with scores over the default score
     (or over the numeric prefix) (`gnus-summary-clear-above').

`M V u'
     Tick all articles with scores over the default score (or over the
     numeric prefix) (`gnus-summary-tick-above').

`M V m'
     Prompt for a mark, and mark all articles with scores over the
     default score (or over the numeric prefix) with this mark
     (`gnus-summary-clear-above').

   The `gnus-summary-goto-unread' variable controls what action should
be taken after setting a mark.  If non-`nil', point will move to the
next/previous unread article.  If `nil', point will just move one line
up or down.  As a special case, if this variable is `never', all the
marking commands as well as other commands (like `SPACE') will move to
the next article, whether it is unread or not.  The default is `t'.


File: gnus,  Node: Generic Marking Commands,  Next: Setting Process Marks,  Prev: Setting Marks,  Up: Marking Articles

Generic Marking Commands
------------------------

   Some people would like the command that ticks an article (`!') go to
the next article.  Others would like it to go to the next unread
article.  Yet others would like it to stay on the current article.  And
even though I haven't heard of anybody wanting it to go to the previous
(unread) article, I'm sure there are people that want that as well.

   Multiply these five behaviours with five different marking commands,
and you get a potentially complex set of variable to control what each
command should do.

   To sidestep that mess, Gnus provides commands that do all these
different things.  They can be found on the `M M' map in the summary
buffer.  Type `M M C-h' to see them all--there are too many of them to
list in this manual.

   While you can use these commands directly, most users would prefer
altering the summary mode keymap.  For instance, if you would like the
`!' command to go to the next article instead of the next unread
article, you could say something like:

     (add-hook 'gnus-summary-mode-hook 'my-alter-summary-map)
     (defun my-alter-summary-map ()
       (local-set-key "!" 'gnus-summary-put-mark-as-ticked-next))

   or

     (defun my-alter-summary-map ()
       (local-set-key "!" "MM!n"))

