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: Group Buffer Format,  Next: Group Maneuvering,  Up: The Group Buffer

Group Buffer Format
===================

* Menu:

* Group Line Specification::       Deciding how the group buffer is to look.
* Group Modeline Specification::   The group buffer modeline.
* Group Highlighting::             Having nice colors in the group buffer.


File: gnus,  Node: Group Line Specification,  Next: Group Modeline Specification,  Up: Group Buffer Format

Group Line Specification
------------------------

   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:

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

   Quite simple, huh?

   You can see that there are 25 unread articles in
`news.announce.newusers'.  There are no unread articles, but some
ticked articles, in `alt.fan.andrea-dworkin' (see that little asterisk
at the beginning of the line?).

   You can change that format to whatever you want by fiddling with the
`gnus-group-line-format' variable.  This variable works along the lines
of a `format' specification, which is pretty much the same as a
`printf' specifications, for those of you who use (feh!) C.  *Note
Formatting Variables::.

   `%M%S%5y: %(%g%)\n' is the value that produced those lines above.

   There should always be a colon on the line; the cursor always moves
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, spreadsheet-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:

`M'
     An asterisk if the group only has marked articles.

`S'
     Whether the group is subscribed.

`L'
     Level of subscribedness.

`N'
     Number of unread articles.

`I'
     Number of dormant articles.

`T'
     Number of ticked articles.

`R'
     Number of read articles.

`t'
     Estimated total number of articles.  (This is really MAX-NUMBER
     minus MIN-NUMBER plus 1.)

`y'
     Number of unread, unticked, non-dormant articles.

`i'
     Number of ticked and dormant articles.

`g'
     Full group name.

`G'
     Group name.

`D'
     Newsgroup description.

`o'
     `m' if moderated.

`O'
     `(m)' if moderated.

`s'
     Select method.

`n'
     Select from where.

`z'
     A string that looks like `<%s:%n>' if a foreign select method is
     used.

`P'
     Indentation based on the level of the topic (*note Group Topics::).

`c'
     Short (collapsed) group name.  The `gnus-group-uncollapsed-levels'
     variable says how many levels to leave at the end of the group
     name.  The default is 1--this will mean that group names like
     `gnu.emacs.gnus' will be shortened to `g.e.gnus'.

`m'
     `%' (`gnus-new-mail-mark') if there has arrived new mail to the
     group lately.

`d'
     A string that says when you last read the group (*note Group
     Timestamp::).

`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 a single dummy parameter as
     argument.  The function should return a string, which will be
     inserted into the buffer just like information from any other
     specifier.

   All the "number-of" specs will be filled with an asterisk (`*') if
no info is available--for instance, if it is a non-activated foreign
group, or a bogus native group.


File: gnus,  Node: Group Modeline Specification,  Next: Group Highlighting,  Prev: Group Line Specification,  Up: Group Buffer Format

Group Modeline Specification
----------------------------

   The mode line can be changed by setting
`gnus-group-mode-line-format' (*note Mode Line Formatting::).  It
doesn't understand that many format specifiers:

`S'
     The native news server.

`M'
     The native select method.


File: gnus,  Node: Group Highlighting,  Prev: Group Modeline Specification,  Up: Group Buffer Format

Group Highlighting
------------------

   Highlighting in the group buffer is controlled by the
`gnus-group-highlight' variable.  This is an alist with elements that
look like `(FORM . FACE)'.  If FORM evaluates to something non-`nil',
the FACE will be used on the line.

   Here's an example value for this variable that might look nice if the
background is dark:

     (cond (window-system
            (setq custom-background-mode 'light)
            (defface my-group-face-1
     	 '((t (:foreground "Red" :bold t))) "First group face")
            (defface my-group-face-2
     	 '((t (:foreground "DarkSeaGreen4" :bold t))) "Second group face")
            (defface my-group-face-3
     	 '((t (:foreground "Green4" :bold t))) "Third group face")
            (defface my-group-face-4
     	 '((t (:foreground "SteelBlue" :bold t))) "Fourth group face")
            (defface my-group-face-5
     	 '((t (:foreground "Blue" :bold t))) "Fifth group face")))
     
     (setq gnus-group-highlight
           '(((> unread 200) . my-group-face-1)
             ((and (< level 3) (zerop unread)) . my-group-face-2)
             ((< level 3) . my-group-face-3)
             ((zerop unread) . my-group-face-4)
             (t . my-group-face-5)))

   Also *note Faces and Fonts::.

   Variables that are dynamically bound when the forms are evaluated
include:

`group'
     The group name.

`unread'
     The number of unread articles in the group.

`method'
     The select method.

`mailp'
     Whether the group is a mail group.

`level'
     The level of the group.

`score'
     The score of the group.

`ticked'
     The number of ticked articles in the group.

`total'
     The total number of articles in the group.  Or rather, MAX-NUMBER
     minus MIN-NUMBER plus one.

`topic'
     When using the topic minor mode, this variable is bound to the
     current topic being inserted.

   When the forms are `eval'ed, point is at the beginning of the line
of the group in question, so you can use many of the normal Gnus
functions for snarfing info on the group.

   `gnus-group-update-hook' is called when a group line is changed.  It
will not be called when `gnus-visual' is `nil'.  This hook calls
`gnus-group-highlight-line' by default.


File: gnus,  Node: Group Maneuvering,  Next: Selecting a Group,  Prev: Group Buffer Format,  Up: The Group Buffer

Group Maneuvering
=================

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

`n'
     Go to the next group that has unread articles
     (`gnus-group-next-unread-group').

`p'
`DEL'
     Go to the previous group that has unread articles
     (`gnus-group-prev-unread-group').

`N'
     Go to the next group (`gnus-group-next-group').

`P'
     Go to the previous group (`gnus-group-prev-group').

`M-n'
     Go to the next unread group on the same (or lower) level
     (`gnus-group-next-unread-group-same-level').

`M-p'
     Go to the previous unread group on the same (or lower) level
     (`gnus-group-prev-unread-group-same-level').

   Three commands for jumping to groups:

`j'
     Jump to a group (and make it visible if it isn't already)
     (`gnus-group-jump-to-group').  Killed groups can be jumped to, just
     like living groups.

`,'
     Jump to the unread group with the lowest level
     (`gnus-group-best-unread-group').

`.'
     Jump to the first group with unread articles
     (`gnus-group-first-unread-group').

   If `gnus-group-goto-unread' is `nil', all the movement commands will
move to the next group, not the next unread group.  Even the commands
that say they move to the next unread group.  The default is `t'.


File: gnus,  Node: Selecting a Group,  Next: Group Data,  Prev: Group Maneuvering,  Up: The Group Buffer

Selecting a Group
=================

`SPACE'
     Select the current group, switch to the summary buffer and display
     the first unread article (`gnus-group-read-group').  If there are
     no unread articles in the group, or if you give a non-numerical
     prefix to this command, Gnus will offer to fetch all the old
     articles in this group from the server.  If you give a numerical
     prefix N, N determines the number of articles Gnus will fetch.  If
     N is positive, Gnus fetches the N newest articles, if N is
     negative, Gnus fetches the `abs(N)' oldest articles.

     Thus, `SPC' enters the group normally, `C-u SPC' offers old
     articles, `C-u 4 2 SPC' fetches the 42 newest articles, and `C-u -
     4 2 SPC' fetches the 42 oldest ones.

     When you are in the group (in the Summary buffer), you can type
     `M-g' to fetch new articles, or `C-u M-g' to also show the old
     ones.

`RET'
     Select the current group and switch to the summary buffer
     (`gnus-group-select-group').  Takes the same arguments as
     `gnus-group-read-group'--the only difference is that this command
     does not display the first unread article automatically upon group
     entry.

`M-RET'
     This does the same as the command above, but tries to do it with
     the minimum amount of fuzz (`gnus-group-quick-select-group').  No
     scoring/killing will be performed, there will be no highlights and
     no expunging.  This might be useful if you're in a real hurry and
     have to enter some humongous group.  If you give a 0 prefix to
     this command (i.e., `0 M-RET'), Gnus won't even generate the
     summary buffer, which is useful if you want to toggle threading
     before generating the summary buffer (*note Summary Generation
     Commands::).

`M-SPACE'
     This is yet one more command that does the same as the `RET'
     command, but this one does it without expunging and hiding dormants
     (`gnus-group-visible-select-group').

`M-C-RET'
     Finally, this command selects the current group ephemerally without
     doing any processing of its contents
     (`gnus-group-select-group-ephemerally').  Even threading has been
     turned off.  Everything you do in the group after selecting it in
     this manner will have no permanent effects.


   The `gnus-large-newsgroup' variable says what Gnus should consider
to be a big group.  This is 200 by default.  If the group has more
(unread and/or ticked) articles than this, 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 (`-n'), the `n' oldest articles will be fetched.  If it is
positive, the `n' articles that have arrived most recently will be
fetched.

   `gnus-auto-select-first' control whether any articles are selected
automatically when entering a group with the `SPACE' command.

`nil'
     Don't select any articles when entering the group.  Just display
     the full summary buffer.

`t'
     Select the first unread article when entering the group.

`best'
     Select the highest scored article in the group when entering the
     group.


   This variable can also be a function.  In that case, that function
will be called to place point on a subject line, and/or select some
article.  Useful functions include:

`gnus-summary-first-unread-subject'
     Place point on the subject line of the first unread article, but
     don't select the article.

`gnus-summary-first-unread-article'
     Select the first unread article.

`gnus-summary-best-unread-article'
     Select the highest-scored unread article.

   If you want to prevent automatic selection in some group (say, in a
binary group with Huge articles) you can set this variable to `nil' in
`gnus-select-group-hook', which is called when a group is selected.


File: gnus,  Node: Subscription Commands,  Next: Group Levels,  Prev: Group Data,  Up: The Group Buffer

Subscription Commands
=====================

`S t'
`u'
     Toggle subscription to the current group
     (`gnus-group-unsubscribe-current-group').

`S s'
`U'
     Prompt for a group to subscribe, and then subscribe it.  If it was
     subscribed already, unsubscribe it instead
     (`gnus-group-unsubscribe-group').

`S k'
`C-k'
     Kill the current group (`gnus-group-kill-group').

`S y'
`C-y'
     Yank the last killed group (`gnus-group-yank-group').

`C-x C-t'
     Transpose two groups (`gnus-group-transpose-groups').  This isn't
     really a subscription command, but you can use it instead of a
     kill-and-yank sequence sometimes.

`S w'
`C-w'
     Kill all groups in the region (`gnus-group-kill-region').

`S z'
     Kill all zombie groups (`gnus-group-kill-all-zombies').

`S C-k'
     Kill all groups on a certain level (`gnus-group-kill-level').
     These groups can't be yanked back after killing, so this command
     should be used with some caution.  The only time where this
     command comes in really handy is when you have a `.newsrc' with
     lots of unsubscribed groups that you want to get rid off.  `S C-k'
     on level 7 will kill off all unsubscribed groups that do not have
     message numbers in the `.newsrc' file.


   Also *note Group Levels::.


File: gnus,  Node: Group Data,  Next: Subscription Commands,  Prev: Selecting a Group,  Up: The Group Buffer

Group Data
==========

`c'
     Mark all unticked articles in this group as read
     (`gnus-group-catchup-current').  `gnus-group-catchup-group-hook'
     is called when catching up a group from the group buffer.

`C'
     Mark all articles in this group, even the ticked ones, as read
     (`gnus-group-catchup-current-all').

`M-c'
     Clear the data from the current group--nix out marks and the list
     of read articles (`gnus-group-clear-data').

`M-x gnus-group-clear-data-on-native-groups'
     If you have switched from one NNTP server to another, all your
     marks and read ranges have become worthless.  You can use this
     command to clear out all data that you have on your native groups.
     Use with caution.



File: gnus,  Node: Group Levels,  Next: Group Score,  Prev: Subscription Commands,  Up: The Group Buffer

Group Levels
============

   All groups have a level of "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 or lower (*note
Listing Groups::), or to just check for new articles in groups on a
given level or lower (*note Scanning New Messages::).

   Remember:  The higher the level of the group, the less important it
is.

`S l'
     Set the level of the current group.  If a numeric prefix is given,
     the next N groups will have their levels set.  The user will be
     prompted for a level.

   Gnus considers groups from levels 1 to `gnus-level-subscribed'
(inclusive) (default 5) to be subscribed, `gnus-level-subscribed'
(exclusive) and `gnus-level-unsubscribed' (inclusive) (default 7) to be
unsubscribed, `gnus-level-zombie' to be zombies (walking dead) (default
8) and `gnus-level-killed' to be killed (completely dead) (default 9).
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 your mail groups (if any) on
quite low levels (e.g. 1 or 2).

   Maybe the following description of the default behavior of Gnus
helps to understand what these levels are all about.  By default, Gnus
shows you subscribed nonempty groups, but by hitting `L' you can have
it show empty subscribed groups and unsubscribed groups, too.  Type `l'
to go back to showing nonempty subscribed groups again.  Thus,
unsubscribed groups are hidden, in a way.

   Zombie and killed groups are similar to unsubscribed groups in that
they are hidden by default.  But they are different from subscribed and
unsubscribed groups in that Gnus doesn't ask the news server for
information (number of messages, number of unread messages) on zombie
and killed groups.  Normally, you use `C-k' to kill the groups you
aren't interested in.  If most groups are killed, Gnus is faster.

   Why does Gnus distinguish between zombie and killed groups?  Well,
when a new group arrives on the server, Gnus by default makes it a
zombie group.  This means that you are normally not bothered with new
groups, but you can type `A z' to get a list of all new groups.
Subscribe the ones you like and kill the ones you don't want.  (`A k'
shows a list of killed groups.)

   If you want to play with the level variables, you should show some
care.  Set them once, and don't touch them ever again.  Better yet,
don't touch them at all unless you know exactly what you're doing.

   Two closely related variables are `gnus-level-default-subscribed'
(default 3) and `gnus-level-default-unsubscribed' (default 6), which
are the levels that new groups will be put on if they are
(un)subscribed.  These two variables should, of course, be inside the
relevant valid ranges.

   If `gnus-keep-same-level' is non-`nil', some movement commands will
only move to groups 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.

   If this variable is `best', Gnus will make the next newsgroup the
one with the best level.

   All groups with a level less than or equal to
`gnus-group-default-list-level' will be listed in the group buffer by
default.

   If `gnus-group-list-inactive-groups' is non-`nil', non-active groups
will be listed along with the unread groups.  This variable is `t' by
default.  If it is `nil', inactive groups won't be listed.

   If `gnus-group-use-permanent-levels' is non-`nil', once you give a
level prefix to `g' or `l', all subsequent commands will use this level
as the "work" level.

   Gnus will normally just activate (i. e., query the server about)
groups on level `gnus-activate-level' or less.  If you don't want to
activate unsubscribed groups, for instance, you might set this variable
to 5.  The default is 6.


File: gnus,  Node: Group Score,  Next: Marking Groups,  Prev: Group Levels,  Up: The Group Buffer

Group Score
===========

   You would normally keep important groups on high levels, but that
scheme is somewhat restrictive.  Don't you wish you could have Gnus
sort the group buffer according to how often you read groups, perhaps?
Within reason?

   This is what "group score" is for.  You can have Gnus assign a score
to each group through the mechanism described below.  You can then sort
the group buffer based on this score.  Alternatively, you can sort on
score and then level.  (Taken together, the level and the score is
called the "rank" of the group.  A group that is on level 4 and has a
score of 1 has a higher rank than a group on level 5 that has a score
of 300.  (The level is the most significant part and the score is the
least significant part.))

   If you want groups you read often to get higher scores than groups
you read seldom you can add the `gnus-summary-bubble-group' function to
the `gnus-summary-exit-hook' hook.  This will result (after sorting) in
a bubbling sort of action.  If you want to see that in action after
each summary exit, you can add `gnus-group-sort-groups-by-rank' or
`gnus-group-sort-groups-by-score' to the same hook, but that will slow
things down somewhat.


File: gnus,  Node: Marking Groups,  Next: Foreign Groups,  Prev: Group Score,  Up: The Group Buffer

Marking Groups
==============

   If you want to perform some command on several groups, and they
appear subsequently in the group buffer, you would normally just give a
numerical prefix to the command.  Most group commands will then do your
bidding on those groups.

   However, if the groups are not in sequential order, you can still
perform a command on several groups.  You simply mark the groups first
with the process mark and then execute the command.

`#'
`M m'
     Set the mark on the current group (`gnus-group-mark-group').

`M-#'
`M u'
     Remove the mark from the current group (`gnus-group-unmark-group').

`M U'
     Remove the mark from all groups (`gnus-group-unmark-all-groups').

`M w'
     Mark all groups between point and mark (`gnus-group-mark-region').

`M b'
     Mark all groups in the buffer (`gnus-group-mark-buffer').

`M r'
     Mark all groups that match some regular expression
     (`gnus-group-mark-regexp').

   Also *note Process/Prefix::.

   If you want to execute some command on all groups that have been
marked with the process mark, you can use the `M-&'
(`gnus-group-universal-argument') command.  It will prompt you for the
command to be executed.


File: gnus,  Node: Foreign Groups,  Next: Group Parameters,  Prev: Marking Groups,  Up: The Group Buffer

Foreign Groups
==============

   Below are some group mode commands for making and editing general
foreign groups, as well as commands to ease the creation of a few
special-purpose groups.  All these commands insert the newly created
groups under point--`gnus-subscribe-newsgroup-method' is not consulted.

`G m'
     Make a new group (`gnus-group-make-group').  Gnus will prompt you
     for a name, a method and possibly an "address".  For an easier way
     to subscribe to NNTP groups, *note Browse Foreign Server::.

`G r'
     Rename the current group to something else
     (`gnus-group-rename-group').  This is valid only on some
     groups--mail groups mostly.  This command might very well be quite
     slow on some backends.

`G c'
     Customize the group parameters (`gnus-group-customize').

`G e'
     Enter a buffer where you can edit the select method of the current
     group (`gnus-group-edit-group-method').

`G p'
     Enter a buffer where you can edit the group parameters
     (`gnus-group-edit-group-parameters').

`G E'
     Enter a buffer where you can edit the group info
     (`gnus-group-edit-group').

`G d'
     Make a directory group (*note Directory Groups::).  You will be
     prompted for a directory name (`gnus-group-make-directory-group').

`G h'
     Make the Gnus help group (`gnus-group-make-help-group').

`G a'
     Make a Gnus archive group (`gnus-group-make-archive-group').  By
     default a group pointing to the most recent articles will be
     created (`gnus-group-recent-archive-directory'), but given a
     prefix, a full group will be created from
     `gnus-group-archive-directory'.

`G k'
     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
     (`gnus-group-make-kiboze-group').  *Note Kibozed Groups::.

`G D'
     Read an arbitrary directory as if it were a newsgroup with the
     `nneething' backend (`gnus-group-enter-directory').  *Note
     Anything Groups::.

`G f'
     Make a group based on some file or other
     (`gnus-group-make-doc-group').  If you give a prefix to this
     command, you will be prompted for a file name and a file type.
     Currently supported types are `babyl', `mbox', `digest', `mmdf',
     `news', `rnews', `clari-briefs', `rfc934', `rfc822-forward',
     `nsmail' and `forward'.  If you run this command without a prefix,
     Gnus will guess at the file type.  *Note Document Groups::.

`G u'
     Create one of the groups mentioned in `gnus-useful-groups'
     (`gnus-group-make-useful-group').

`G w'
     Make an ephemeral group based on a web search
     (`gnus-group-make-web-group').  If you give a prefix to this
     command, make a solid group instead.  You will be prompted for the
     search engine type and the search string.  Valid search engine
     types include `dejanews', `altavista' and `reference'.  *Note Web
     Searches::.

     If you use the `dejanews' search engine, you can limit the search
     to a particular group by using a match string like `~g
     alt.sysadmin.recovery shaving'.

`G DEL'
     This function will delete the current group
     (`gnus-group-delete-group').  If given a prefix, this function will
     actually delete all the articles in the group, and forcibly remove
     the group itself from the face of the Earth.  Use a prefix only if
     you are absolutely sure of what you are doing.  This command can't
     be used on read-only groups (like `nntp' group), though.

`G V'
     Make a new, fresh, empty `nnvirtual' group
     (`gnus-group-make-empty-virtual').  *Note Virtual Groups::.

`G v'
     Add the current group to an `nnvirtual' group
     (`gnus-group-add-to-virtual').  Uses the process/prefix convention.

   *Note Select Methods::, for more information on the various select
methods.

   If `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.  Also *note Group Levels::;
`gnus-activate-level' also affects activation of foreign newsgroups.


File: gnus,  Node: Group Parameters,  Next: Listing Groups,  Prev: Foreign Groups,  Up: The Group Buffer

Group Parameters
================

   The group parameters store information local to a particular group.
Here's an example group parameter list:

     ((to-address . "ding@gnus.org")
      (auto-expire . t))

   We see that each element consists of a "dotted pair"--the thing
before the dot is the key, while the thing after the dot is the value.
All the parameters have this form _except_ local variable specs, which
are not dotted pairs, but proper lists.

   The following group parameters can be used:

`to-address'
     Address used by when doing followups and new posts.

          (to-address . "some@where.com")

     This is primarily useful in mail groups that represent closed
     mailing lists--mailing lists where it's expected that everybody
     that writes to the mailing list is subscribed to it.  Since using
     this parameter ensures that the mail only goes to the mailing list
     itself, it means that members won't receive two copies of your
     followups.

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

`to-list'
     Address used when doing `a' in that group.

          (to-list . "some@where.com")

     It is totally ignored when doing a followup--except that if it is
     present in a news group, you'll get mail group semantics when
     doing `f'.

     If you do an `a' command in a mail group and you have neither a
     `to-list' group parameter nor a `to-address' group parameter, then
     a `to-list' group parameter will be added automatically upon
     sending the message if `gnus-add-to-list' is set to `t'.

     If you do an `a' command in a mail group and you don't have a
     `to-list' group parameter, one will be added automatically upon
     sending the message.

`visible'
     If the group parameter list has the element `(visible . t)', that
     group will always be visible in the Group buffer, regardless of
     whether it has any unread articles.

`broken-reply-to'
     Elements like `(broken-reply-to . t)' signals that `Reply-To'
     headers in this group are to be ignored.  This can be useful if
     you're reading a mailing list group where the listserv has inserted
     `Reply-To' headers that point back to the listserv itself.  This is
     broken behavior.  So there!

`to-group'
     Elements like `(to-group . "some.group.name")' means that all
     posts in that group will be sent to `some.group.name'.

`newsgroup'
     If you have `(newsgroup . t)' in the group parameter list, Gnus
     will treat all responses as if they were responses to news
     articles.  This can be useful if you have a mail group that's
     really a mirror of a news group.

`gcc-self'
     If `(gcc-self . t)' is present in the group parameter list, newly
     composed messages will be `Gcc''d to the current group.  If
     `(gcc-self . none)' is present, no `Gcc:' header will be
     generated, if `(gcc-self . "string")' is present, this string will
     be inserted literally as a `gcc' header.  This parameter takes
     precedence over any default `Gcc' rules as described later (*note
     Archived Messages::).

`auto-expire'
     If the group parameter has an element that looks like `(auto-expire
     . t)', all articles read will be marked as expirable.  For an
     alternative approach, *note Expiring Mail::.

`total-expire'
     If the group parameter has an element that looks like
     `(total-expire . t)', all read articles will be put through the
     expiry process, even if they are not marked as expirable.  Use with
     caution.  Unread, ticked and dormant articles are not eligible for
     expiry.

`expiry-wait'
     If the group parameter has an element that looks like `(expiry-wait
     . 10)', this value will override any `nnmail-expiry-wait' and
     `nnmail-expiry-wait-function' when expiring expirable messages.
     The value can either be a number of days (not necessarily an
     integer) or the symbols `never' or `immediate'.

`score-file'
     Elements that look like `(score-file . "file")' will make `file'
     into the current score file for the group in question.  All
     interactive score entries will be put into this file.

`adapt-file'
     Elements that look like `(adapt-file . "file")' will make `file'
     into the current adaptive file for the group in question.  All
     adaptive score entries will be put into this file.

`admin-address'
     When unsubscribing from a mailing list you should never send the
     unsubscription notice to the mailing list itself.  Instead, you'd
     send messages to the administrative address.  This parameter
     allows you to put the admin address somewhere convenient.

`display'
     Elements that look like `(display . MODE)' say which articles to
     display on entering the group.  Valid values are:

    `all'
          Display all articles, both read and unread.

    `default'
          Display the default visible articles, which normally includes
          unread and ticked articles.

`comment'
     Elements that look like `(comment . "This is a comment")' are
     arbitrary comments on the group.  They are currently ignored by
     Gnus, but provide a place for you to store information on
     particular groups.

`charset'
     Elements that look like `(charset . iso-8859-1)' will make
     `iso-8859-1' the default charset; that is, the charset that will be
     used for all articles that do not specify a charset.

`(VARIABLE FORM)'
     You can use the group parameters to set variables local to the
     group you are entering.  If you want to turn threading off in
     `news.answers', you could put `(gnus-show-threads nil)' in the
     group parameters of that group.  `gnus-show-threads' will be made
     into a local variable in the summary buffer you enter, and the
     form `nil' will be `eval'ed there.

     This can also be used as a group-specific hook function, if you'd
     like.  If you want to hear a beep when you enter a group, you
     could put something like `(dummy-variable (ding))' in the
     parameters of that group.  `dummy-variable' will be set to the
     result of the `(ding)' form, but who cares?

`posting-style'
     You can store additional posting style information for this group
     only here (*note Posting Styles::).  The format is that of an
     entry in the `gnus-posting-styles' alist, except that there's no
     regexp matching the group name (of course).  Style elements in
     this group parameter will take precedence over the ones found in
     `gnus-posting-styles'.

     For instance, if you want a funky name and signature in this group
     only, instead of hacking `gnus-posting-styles', you could put
     something like this in the group parameters:

          (posting-style
            (name "Funky Name")
            (signature "Funky Signature"))


   Use the `G p' command to edit group parameters of a group.  You
might also be interested in reading about topic parameters (*note Topic
Parameters::).


File: gnus,  Node: Listing Groups,  Next: Sorting Groups,  Prev: Group Parameters,  Up: The Group Buffer

Listing Groups
==============

   These commands all list various slices of the groups available.

`l'
`A s'
     List all groups that have unread articles
     (`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 (i. e.,
     `gnus-group-default-list-level') or lower (i.e., just subscribed
     groups).

`L'
`A u'
     List all groups, whether they have unread articles or not
     (`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 (i.e., just
     subscribed and unsubscribed groups).

`A l'
     List all unread groups on a specific level
     (`gnus-group-list-level').  If given a prefix, also list the groups
     with no unread articles.

`A k'
     List all killed groups (`gnus-group-list-killed').  If given a
     prefix argument, really list all groups that are available, but
     aren't currently (un)subscribed.  This could entail reading the
     active file from the server.

`A z'
     List all zombie groups (`gnus-group-list-zombies').

`A m'
     List all unread, subscribed groups with names that match a regexp
     (`gnus-group-list-matching').

`A M'
     List groups that match a regexp (`gnus-group-list-all-matching').

`A A'
     List absolutely all groups in the active file(s) of the server(s)
     you are connected to (`gnus-group-list-active').  This might very
     well take quite a while.  It might actually be a better idea to do
     a `A M' to list all matching, and just give `.' as the thing to
     match on.  Also note that this command may list groups that don't
     exist (yet)--these will be listed as if they were killed groups.
     Take the output with some grains of salt.

`A a'
     List all groups that have names that match a regexp
     (`gnus-group-apropos').

`A d'
     List all groups that have names or descriptions that match a regexp
     (`gnus-group-description-apropos').

`A c'
     List all groups with cached articles (`gnus-group-list-cached').

`A ?'
     List all groups with dormant articles (`gnus-group-list-dormant').


   Groups that match the `gnus-permanently-visible-groups' regexp will
always be shown, whether they have unread articles or not.  You can also
add the `visible' element to the group parameters in question to get
the same effect.

   Groups that have just ticked articles in it are normally listed in
the group buffer.  If `gnus-list-groups-with-ticked-articles' is `nil',
these groups will be treated just like totally empty groups.  It is `t'
by default.


File: gnus,  Node: Sorting Groups,  Next: Group Maintenance,  Prev: Listing Groups,  Up: The Group Buffer

Sorting Groups
==============

   The `C-c C-s' (`gnus-group-sort-groups') command sorts the group
buffer according to the function(s) given by the
`gnus-group-sort-function' variable.  Available sorting functions
include:

`gnus-group-sort-by-alphabet'
     Sort the group names alphabetically.  This is the default.

`gnus-group-sort-by-real-name'
     Sort the group alphabetically on the real (unprefixed) group names.

`gnus-group-sort-by-level'
     Sort by group level.

`gnus-group-sort-by-score'
     Sort by group score.  *Note Group Score::.

`gnus-group-sort-by-rank'
     Sort by group score and then the group level.  The level and the
     score are, when taken together, the group's "rank".  *Note Group
     Score::.

`gnus-group-sort-by-unread'
     Sort by number of unread articles.

`gnus-group-sort-by-method'
     Sort alphabetically on the select method.


   `gnus-group-sort-function' can also be a list of sorting functions.
In that case, the most significant sort key function must be the last
one.

   There are also a number of commands for sorting directly according to
some sorting criteria:

`G S a'
     Sort the group buffer alphabetically by group name
     (`gnus-group-sort-groups-by-alphabet').

`G S u'
     Sort the group buffer by the number of unread articles
     (`gnus-group-sort-groups-by-unread').

`G S l'
     Sort the group buffer by group level
     (`gnus-group-sort-groups-by-level').

`G S v'
     Sort the group buffer by group score
     (`gnus-group-sort-groups-by-score').  *Note Group Score::.

`G S r'
     Sort the group buffer by group rank
     (`gnus-group-sort-groups-by-rank').  *Note Group Score::.

`G S m'
     Sort the group buffer alphabetically by backend name
     (`gnus-group-sort-groups-by-method').


   All the commands below obey the process/prefix convention (*note
Process/Prefix::).

   When given a symbolic prefix (*note Symbolic Prefixes::), all these
commands will sort in reverse order.

   You can also sort a subset of the groups:

`G P a'
     Sort the groups alphabetically by group name
     (`gnus-group-sort-selected-groups-by-alphabet').

`G P u'
     Sort the groups by the number of unread articles
     (`gnus-group-sort-selected-groups-by-unread').

`G P l'
     Sort the groups by group level
     (`gnus-group-sort-selected-groups-by-level').

`G P v'
     Sort the groups by group score
     (`gnus-group-sort-selected-groups-by-score').  *Note Group Score::.

`G P r'
     Sort the groups by group rank
     (`gnus-group-sort-selected-groups-by-rank').  *Note Group Score::.

`G P m'
     Sort the groups alphabetically by backend name
     (`gnus-group-sort-selected-groups-by-method').



File: gnus,  Node: Group Maintenance,  Next: Browse Foreign Server,  Prev: Sorting Groups,  Up: The Group Buffer

Group Maintenance
=================

`b'
     Find bogus groups and delete them
     (`gnus-group-check-bogus-groups').

`F'
     Find new groups and process them (`gnus-group-find-new-groups').
     With 1 `C-u', use the `ask-server' method to query the server for
     new groups.  With 2 `C-u''s, use most complete method possible to
     query the server for new groups, and subscribe the new groups as
     zombies.

`C-c C-x'
     Run all expirable articles in the current group through the expiry
     process (if any) (`gnus-group-expire-articles').

`C-c M-C-x'
     Run all articles in all groups through the expiry process
     (`gnus-group-expire-all-groups').



File: gnus,  Node: Browse Foreign Server,  Next: Exiting Gnus,  Prev: Group Maintenance,  Up: The Group Buffer

Browse Foreign Server
=====================

`B'
     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 (`gnus-group-browse-foreign-server').

   A new buffer with a list of available groups will appear.  This
buffer will use the `gnus-browse-mode'.  This buffer looks a bit (well,
a lot) like a normal group buffer.

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

`n'
     Go to the next group (`gnus-group-next-group').

`p'
     Go to the previous group (`gnus-group-prev-group').

`SPACE'
     Enter the current group and display the first article
     (`gnus-browse-read-group').

`RET'
     Enter the current group (`gnus-browse-select-group').

`u'
     Unsubscribe to the current group, or, as will be the case here,
     subscribe to it (`gnus-browse-unsubscribe-current-group').

`l'
`q'
     Exit browse mode (`gnus-browse-exit').

`?'
     Describe browse mode briefly (well, there's not much to describe,
     is there) (`gnus-browse-describe-briefly').


File: gnus,  Node: Exiting Gnus,  Next: Group Topics,  Prev: Browse Foreign Server,  Up: The Group Buffer

Exiting Gnus
============

   Yes, Gnus is ex(c)iting.

`z'
     Suspend Gnus (`gnus-group-suspend').  This doesn't really exit
     Gnus, but it kills all buffers except the Group buffer.  I'm not
     sure why this is a gain, but then who am I to judge?

`q'
     Quit Gnus (`gnus-group-exit').

`Q'
     Quit Gnus without saving the `.newsrc' files (`gnus-group-quit').
     The dribble file will be saved, though (*note Auto Save::).

   `gnus-suspend-gnus-hook' is called when you suspend Gnus and
`gnus-exit-gnus-hook' is called when you quit Gnus, while
`gnus-after-exiting-gnus-hook' is called as the final item when exiting
Gnus.

   If you wish to completely unload Gnus and all its adherents, you can
use the `gnus-unload' command.  This command is also very handy when
trying to customize meta-variables.

   Note:

     Miss Lisa Cannifax, while sitting in English class, felt 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.


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

Group Topics
============

   If you read lots and lots of groups, it might be convenient to group
them hierarchically according to topics.  You put your Emacs groups over
here, your sex groups over there, and the rest (what, two groups or so?)
you put in some misc section that you never bother with anyway.  You can
even group the Emacs sex groups as a sub-topic to either the Emacs
groups or the sex groups--or both!  Go wild!

   Here's an example:

     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

   To get this _fab_ functionality you simply turn on (ooh!) the
`gnus-topic' minor mode--type `t' in the group buffer.  (This is a
toggling command.)

   Go ahead, just try it.  I'll still be here when you get back.  La de
dum...  Nice tune, that...  la la la...  What, you're back? Yes, and now
press `l'.  There.  All your groups are now listed under `misc'.
Doesn't that make you feel all warm and fuzzy?  Hot and bothered?

   If you want this permanently enabled, you should add that minor mode
to the hook for the group mode:

     (add-hook 'gnus-group-mode-hook 'gnus-topic-mode)

* Menu:

* Topic Variables::    How to customize the topics the Lisp Way.
* Topic Commands::     Interactive E-Z commands.
* Topic Sorting::      Sorting each topic individually.
* Topic Topology::     A map of the world.
* Topic Parameters::   Parameters that apply to all groups in a topic.


File: gnus,  Node: Topic Variables,  Next: Topic Commands,  Up: Group Topics

Topic Variables
---------------

   Now, if you select a topic, it will fold/unfold that topic, which is
really neat, I think.

   The topic lines themselves are created according to the
`gnus-topic-line-format' variable (*note Formatting Variables::).
Valid elements are:

`i'
     Indentation.

`n'
     Topic name.

`v'
     Visibility.

`l'
     Level.

`g'
     Number of groups in the topic.

`a'
     Number of unread articles in the topic.

`A'
     Number of unread articles in the topic and all its subtopics.

   Each sub-topic (and the groups in the sub-topics) will be indented
with `gnus-topic-indent-level' times the topic level number of spaces.
The default is 2.

   `gnus-topic-mode-hook' is called in topic minor mode buffers.

   The `gnus-topic-display-empty-topics' says whether to display even
topics that have no unread articles in them.  The default is `t'.


File: gnus,  Node: Topic Commands,  Next: Topic Sorting,  Prev: Topic Variables,  Up: Group Topics

Topic Commands
--------------

   When the topic minor mode is turned on, a new `T' submap will be
available.  In addition, a few of the standard keys change their
definitions slightly.

`T n'
     Prompt for a new topic name and create it
     (`gnus-topic-create-topic').

`T m'
     Move the current group to some other topic
     (`gnus-topic-move-group').  This command uses the process/prefix
     convention (*note Process/Prefix::).

`T j'
     Go to a topic (`gnus-topic-jump-to-topic').

`T c'
     Copy the current group to some other topic
     (`gnus-topic-copy-group').  This command uses the process/prefix
     convention (*note Process/Prefix::).

`T h'
     Hide the current topic (`gnus-topic-hide-topic').  If given a
     prefix, hide the topic permanently.

`T s'
     Show the current topic (`gnus-topic-show-topic').  If given a
     prefix, show the topic permanently.

`T D'
     Remove a group from the current topic (`gnus-topic-remove-group').
     This command is mainly useful if you have the same group in several
     topics and wish to remove it from one of the topics.  You may also
     remove a group from all topics, but in that case, Gnus will add it
     to the root topic the next time you start Gnus.  In fact, all new
     groups (which, naturally, don't belong to any topic) will show up
     in the root topic.

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

`T M'
     Move all groups that match some regular expression to a topic
     (`gnus-topic-move-matching').

`T C'
     Copy all groups that match some regular expression to a topic
     (`gnus-topic-copy-matching').

`T H'
     Toggle hiding empty topics
     (`gnus-topic-toggle-display-empty-topics').

`T #'
     Mark all groups in the current topic with the process mark
     (`gnus-topic-mark-topic').

`T M-#'
     Remove the process mark from all groups in the current topic
     (`gnus-topic-unmark-topic').

`T TAB'
`TAB'
     "Indent" the current topic so that it becomes a sub-topic of the
     previous topic (`gnus-topic-indent').  If given a prefix,
     "un-indent" the topic instead.

`M-TAB'
     "Un-indent" the current topic so that it becomes a sub-topic of the
     parent of its current parent (`gnus-topic-unindent').

`RET'
`SPACE'
     Either select a group or fold a topic (`gnus-topic-select-group').
     When you perform this command on a group, you'll enter the group,
     as usual.  When done on a topic line, the topic will be folded (if
     it was visible) or unfolded (if it was folded already).  So it's
     basically a toggling command on topics.  In addition, if you give
     a numerical prefix, group on that level (and lower) will be
     displayed.

`C-c C-x'
     Run all expirable articles in the current group or topic through
     the expiry process (if any) (`gnus-topic-expire-articles').

`C-k'
     Kill a group or topic (`gnus-topic-kill-group').  All groups in the
     topic will be removed along with the topic.

`C-y'
     Yank the previously killed group or topic
     (`gnus-topic-yank-group').  Note that all topics will be yanked
     before all groups.

`T r'
     Rename a topic (`gnus-topic-rename').

`T DEL'
     Delete an empty topic (`gnus-topic-delete').

`A T'
     List all groups that Gnus knows about in a topics-ified way
     (`gnus-topic-list-active').

`G p'
     Edit the topic parameters (`gnus-topic-edit-parameters').  *Note
     Topic Parameters::.



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

Topic Sorting
-------------

   You can sort the groups in each topic individually with the following
commands:

`T S a'
     Sort the current topic alphabetically by group name
     (`gnus-topic-sort-groups-by-alphabet').

`T S u'
     Sort the current topic by the number of unread articles
     (`gnus-topic-sort-groups-by-unread').

`T S l'
     Sort the current topic by group level
     (`gnus-topic-sort-groups-by-level').

`T S v'
     Sort the current topic by group score
     (`gnus-topic-sort-groups-by-score').  *Note Group Score::.

`T S r'
     Sort the current topic by group rank
     (`gnus-topic-sort-groups-by-rank').  *Note Group Score::.

`T S m'
     Sort the current topic alphabetically by backend name
     (`gnus-topic-sort-groups-by-method').


   *Note Sorting Groups::, for more information about group sorting.

