This is ../info/gnus, produced by makeinfo version 4.0 from gnus.texi.
INFO-DIR-SECTION Emacs
START-INFO-DIR-ENTRY
* Gnus: (gnus). The newsreader Gnus.
END-INFO-DIR-ENTRY
This file documents Gnus, the GNU Emacs newsreader.
Copyright (C) 1995,96,97,98,99,2000,2001 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.
`p'
`#' (`gnus-process-mark') if the group is process marked.
`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
=================
`<SPC>'
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-<SPC>'
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 <SPC> 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 back ends.
`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' back end (`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.
Some parameters have corresponding customizable variables, each of
which is an alist of regexps and values.
`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.
See also `gnus-parameter-to-list-alist'.
`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.
See also `gnus-total-expirable-newsgroups'.
`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.
See also `gnus-group-charset-alist'.
`ignored-charsets'
Elements that look like `(ignored-charsets x-known iso-8859-1)'
will make `iso-8859-1' and `x-unknown' ignored; that is, the
default charset will be used for decoding articles.
See also `gnus-group-ignored-charsets-alist'.
`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"))
`banner'
An item like `(banner . "regex")' causes any part of an article
that matches the regular expression "regex" to be stripped.
Instead of "regex", you can also use the symbol `signature' which
strips the last signature or any of the elements of the alist
`gnus-article-banner-alist'.
`(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
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?
Use the `G p' or the `G c' command to edit group parameters of a
group. (`G p' presents you with a Lisp-based interface, `G c' presents
you with a Customize-like interface. The latter helps avoid silly Lisp
errors.) 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 back end 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 back end 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').
`<SPC>'
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>'
`<SPC>'
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 back end name
(`gnus-topic-sort-groups-by-method').
*Note Sorting Groups::, for more information about group sorting.