Several miscellaneous doc changes

[gnus] / texi / gnus.texi

\input texinfo

@include gnus-overrides.texi

@setfilename gnus
@settitle Gnus Manual
@syncodeindex fn cp
@syncodeindex vr cp
@syncodeindex pg cp

@documentencoding ISO-8859-1

@copying
Copyright @copyright{} 1995-2012 Free Software Foundation, Inc.

@quotation
Permission is granted to copy, distribute and/or modify this document
under the terms of the GNU Free Documentation License, Version 1.3 or
any later version published by the Free Software Foundation; with no
Invariant Sections, 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''.

(a) The FSF's Back-Cover Text is: ``You have the freedom to copy and
modify this GNU manual.  Buying copies from the FSF supports it in
developing GNU and promoting software freedom.''
@end quotation
@end copying

@iftex
@iflatex
\documentclass[twoside,a4paper,openright,11pt]{book}
\usepackage[latin1]{inputenc}
\usepackage{pagestyle}
\usepackage{epsfig}
\usepackage{pixidx}
\input{gnusconfig.tex}

\ifx\pdfoutput\undefined
\else
\usepackage[pdftex,bookmarks,colorlinks=true]{hyperref}
\usepackage{thumbpdf}
\pdfcompresslevel=9
\fi

\makeindex
\begin{document}

% Adjust ../Makefile.in if you change the following line:
\newcommand{\gnusversionname}{No Gnus v0.20}
\newcommand{\gnuschaptername}{}
\newcommand{\gnussectionname}{}

\newcommand{\gnusbackslash}{/}

\newcommand{\gnusref}[1]{``#1'' on page \pageref{#1}}
\ifx\pdfoutput\undefined
\newcommand{\gnusuref}[1]{\gnustt{#1}}
\else
\newcommand{\gnusuref}[1]{\href{#1}{\gnustt{#1}}}
\fi
\newcommand{\gnusxref}[1]{See ``#1'' on page \pageref{#1}}
\newcommand{\gnuspxref}[1]{see ``#1'' on page \pageref{#1}}

\newcommand{\gnuskindex}[1]{\index{#1}}
\newcommand{\gnusindex}[1]{\index{#1}}

\newcommand{\gnustt}[1]{{\gnusselectttfont{}#1}}
\newcommand{\gnuscode}[1]{\gnustt{#1}}
\newcommand{\gnusasis}[1]{\gnustt{#1}}
\newcommand{\gnusurl}[1]{\gnustt{#1}}
\newcommand{\gnuscommand}[1]{\gnustt{#1}}
\newcommand{\gnusenv}[1]{\gnustt{#1}}
\newcommand{\gnussamp}[1]{``{\fontencoding{OT1}\gnusselectttfont{}#1}''}
\newcommand{\gnuslisp}[1]{\gnustt{#1}}
\newcommand{\gnuskbd}[1]{`\gnustt{#1}'}
\newcommand{\gnuskey}[1]{`\gnustt{#1}'}
\newcommand{\gnusfile}[1]{`\gnustt{#1}'}
\newcommand{\gnusdfn}[1]{\textit{#1}}
\newcommand{\gnusi}[1]{\textit{#1}}
\newcommand{\gnusr}[1]{\textrm{#1}}
\newcommand{\gnusstrong}[1]{\textbf{#1}}
\newcommand{\gnusemph}[1]{\textit{#1}}
\newcommand{\gnusvar}[1]{{\fontsize{10pt}{10}\selectfont\textsl{\textsf{#1}}}}
\newcommand{\gnussc}[1]{\textsc{#1}}
\newcommand{\gnustitle}[1]{{\huge\textbf{#1}}}
\newcommand{\gnusversion}[1]{{\small\textit{#1}}}
\newcommand{\gnusauthor}[1]{{\large\textbf{#1}}}
\newcommand{\gnusresult}[1]{\gnustt{=> #1}}
\newcommand{\gnusacronym}[1]{\textsc{#1}}
\newcommand{\gnusemail}[1]{\textit{#1}}

\newcommand{\gnusbullet}{{${\bullet}$}}
\newcommand{\gnusdollar}{\$}
\newcommand{\gnusampersand}{\&}
\newcommand{\gnuspercent}{\%}
\newcommand{\gnushash}{\#}
\newcommand{\gnushat}{\symbol{"5E}}
\newcommand{\gnusunderline}{\symbol{"5F}}
\newcommand{\gnusnot}{$\neg$}
\newcommand{\gnustilde}{\symbol{"7E}}
\newcommand{\gnusless}{{$<$}}
\newcommand{\gnusgreater}{{$>$}}
\newcommand{\gnusbraceleft}{{$>$}}
\newcommand{\gnusbraceright}{{$>$}}

\newcommand{\gnushead}{\raisebox{-1cm}{\epsfig{figure=ps/gnus-head,height=1cm}}}
\newcommand{\gnusinteresting}{
\marginpar[\mbox{}\hfill\gnushead]{\gnushead}
}

\newcommand{\gnuscleardoublepage}{\ifodd\count0\mbox{}\clearpage\thispagestyle{empty}\mbox{}\clearpage\else\clearpage\fi}

\newcommand{\gnuspagechapter}[1]{
{\mbox{}}
}

\newdimen{\gnusdimen}
\gnusdimen 0pt

\newcommand{\gnuschapter}[2]{
\gnuscleardoublepage
\ifdim \gnusdimen = 0pt\setcounter{page}{1}\pagestyle{gnus}\pagenumbering{arabic} \gnusdimen 1pt\fi
\chapter{#2}
\renewcommand{\gnussectionname}{}
\renewcommand{\gnuschaptername}{#2}
\thispagestyle{empty}
\hspace*{-2cm}
\begin{picture}(500,500)(0,0)
\put(480,350){\makebox(0,0)[tr]{#1}}
\put(40,300){\makebox(500,50)[bl]{{\Huge\bf{#2}}}}
\end{picture}
\clearpage
}

\newcommand{\gnusfigure}[3]{
\begin{figure}
\mbox{}\ifodd\count0\hspace*{-0.8cm}\else\hspace*{-3cm}\fi\begin{picture}(440,#2)
#3
\end{picture}
\caption{#1}
\end{figure}
}

\newcommand{\gnusicon}[1]{
\marginpar[\mbox{}\hfill\raisebox{-1.5cm}{\epsfig{figure=ps/#1-up,height=1.5cm}}]{\raisebox{-1cm}{\epsfig{figure=ps/#1-up,height=1cm}}}
}

\newcommand{\gnuspicon}[1]{
\margindex{\epsfig{figure=#1,width=2cm}}
}

\newcommand{\gnusxface}[2]{
\margindex{\epsfig{figure=#1,width=1cm}\epsfig{figure=#2,width=1cm}}
}

\newcommand{\gnussmiley}[2]{
\margindex{\makebox[2cm]{\hfill\epsfig{figure=#1,width=0.5cm}\hfill\epsfig{figure=#2,width=0.5cm}\hfill}}
}

\newcommand{\gnusitemx}[1]{\mbox{}\vspace*{-\itemsep}\vspace*{-\parsep}\item#1}

\newcommand{\gnussection}[1]{
\renewcommand{\gnussectionname}{#1}
\section{#1}
}

\newenvironment{codelist}%
{\begin{list}{}{
}
}{\end{list}}

\newenvironment{asislist}%
{\begin{list}{}{
}
}{\end{list}}

\newenvironment{kbdlist}%
{\begin{list}{}{
\labelwidth=0cm
}
}{\end{list}}

\newenvironment{dfnlist}%
{\begin{list}{}{
}
}{\end{list}}

\newenvironment{stronglist}%
{\begin{list}{}{
}
}{\end{list}}

\newenvironment{samplist}%
{\begin{list}{}{
}
}{\end{list}}

\newenvironment{varlist}%
{\begin{list}{}{
}
}{\end{list}}

\newenvironment{emphlist}%
{\begin{list}{}{
}
}{\end{list}}

\newlength\gnusheadtextwidth
\setlength{\gnusheadtextwidth}{\headtextwidth}
\addtolength{\gnusheadtextwidth}{1cm}

\newpagestyle{gnuspreamble}%
{
{
\ifodd\count0
{
\hspace*{-0.23cm}\underline{\makebox[\gnusheadtextwidth]{\mbox{}}\textbf{\hfill\roman{page}}}
}
\else
{
\hspace*{-3.25cm}\underline{\makebox[\gnusheadtextwidth]{\textbf{\roman{page}\hfill\mbox{}}}
}
}
\fi
}
}
{
\ifodd\count0
\mbox{} \hfill
\raisebox{-0.5cm}{\epsfig{figure=ps/gnus-big-logo,height=1cm}}
\else
\raisebox{-0.5cm}{\epsfig{figure=ps/gnus-big-logo,height=1cm}}
\hfill \mbox{}
\fi
}

\newpagestyle{gnusindex}%
{
{
\ifodd\count0
{
\hspace*{-0.23cm}\underline{\makebox[\gnusheadtextwidth]{\textbf{\gnuschaptername\hfill\arabic{page}}}}
}
\else
{
\hspace*{-3.25cm}\underline{\makebox[\gnusheadtextwidth]{\textbf{\arabic{page}\hfill\gnuschaptername}}}
}
\fi
}
}
{
\ifodd\count0
\mbox{} \hfill
\raisebox{-0.5cm}{\epsfig{figure=ps/gnus-big-logo,height=1cm}}
\else
\raisebox{-0.5cm}{\epsfig{figure=ps/gnus-big-logo,height=1cm}}
\hfill \mbox{}
\fi
}

\newpagestyle{gnus}%
{
{
\ifodd\count0
{
\makebox[12cm]{\hspace*{3.1cm}\underline{\makebox[\gnusheadtextwidth]{\textbf{\arabic{chapter}.\arabic{section}} \textbf{\gnussectionname\hfill\arabic{page}}}}}
}
\else
{
\makebox[12cm]{\hspace*{-2.95cm}\underline{\makebox[\gnusheadtextwidth]{\textbf{\arabic{page}\hfill\gnuschaptername}}}}
}
\fi
}
}
{
\ifodd\count0
\mbox{} \hfill
\raisebox{-0.5cm}{\epsfig{figure=ps/gnus-big-logo,height=1cm}}
\else
\raisebox{-0.5cm}{\epsfig{figure=ps/gnus-big-logo,height=1cm}}
\hfill \mbox{}
\fi
}

\pagenumbering{roman}
\pagestyle{gnuspreamble}

@end iflatex
@end iftex

@iftex
@iflatex

\begin{titlepage}
{

%\addtolength{\oddsidemargin}{-5cm}
%\addtolength{\evensidemargin}{-5cm}
\parindent=0cm
\addtolength{\textheight}{2cm}

\gnustitle{\gnustitlename}\hfill\gnusversion{\gnusversionname}\\
\rule{15cm}{1mm}\\
\vfill
\hspace*{0cm}\epsfig{figure=ps/gnus-big-logo,height=15cm}
\vfill
\rule{15cm}{1mm}\\
\gnusauthor{by Lars Magne Ingebrigtsen}
\newpage
}

\mbox{}
\vfill

\thispagestyle{empty}

@c @insertcopying
\newpage
\end{titlepage}
@end iflatex
@end iftex

@dircategory Emacs network features
@direntry
* Gnus: (gnus).                 The newsreader Gnus.
@end direntry
@iftex
@finalout
@end iftex


@titlepage
@ifset WEBHACKDEVEL
@title Gnus Manual (DEVELOPMENT VERSION)
@end ifset
@ifclear WEBHACKDEVEL
@title Gnus Manual
@end ifclear

@author by Lars Magne Ingebrigtsen
@page
@vskip 0pt plus 1filll
@insertcopying
@end titlepage

@summarycontents
@contents

@node Top
@top The Gnus Newsreader

@ifinfo

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

@c Adjust ../Makefile.in if you change the following line:
This manual corresponds to No Gnus v0.20

@ifnottex
@insertcopying
@end ifnottex

@end ifinfo

@iftex

@iflatex
\tableofcontents
\gnuscleardoublepage
@end iflatex

Gnus is the advanced, self-documenting, customizable, extensible
unreal-time newsreader for GNU Emacs.

Oops.  That sounds oddly familiar, so let's start over again to avoid
being accused of plagiarism:

Gnus is a message-reading laboratory.  It will let you look at just
about anything as if it were a newsgroup.  You can read mail with it,
you can browse directories with it, you can @code{ftp} with it---you
can even read news with it!

Gnus tries to empower people who read news the same way Emacs empowers
people who edit text.  Gnus sets no limits to what the user should be
allowed to do.  Users are encouraged to extend Gnus to make it behave
like they want it to behave.  A program should not control people;
people should be empowered to do what they want by using (or abusing)
the program.

@c Adjust ../Makefile.in if you change the following line:
This manual corresponds to No Gnus v0.20

@heading Other related manuals
@itemize
@item Message manual: Composing messages
@item Emacs-MIME:     Composing messages; @acronym{MIME}-specific parts.
@item Sieve:          Managing Sieve scripts in Emacs.
@item EasyPG:         @acronym{PGP/MIME} with Gnus.
@item SASL:           @acronym{SASL} authentication in Emacs.
@end itemize

@end iftex

@menu
* Starting Up::              Finding news can be a pain.
* Group Buffer::             Selecting, subscribing and killing groups.
* Summary Buffer::           Reading, saving and posting articles.
* Article Buffer::           Displaying and handling articles.
* Composing Messages::       Information on sending mail and news.
* Select Methods::           Gnus reads all messages from various select methods.
* Scoring::                  Assigning values to articles.
* Searching::                Mail and News search engines.
* Various::                  General purpose settings.
* The End::                  Farewell and goodbye.
* Appendices::               Terminology, Emacs intro, @acronym{FAQ}, History, Internals.
* GNU Free Documentation License:: The license for this documentation.
* Index::                    Variable, function and concept index.
* Key Index::                Key Index.

Other related manuals

* Message:(message).         Composing messages.
* Emacs-MIME:(emacs-mime).   Composing messages; @acronym{MIME}-specific parts.
* Sieve:(sieve).             Managing Sieve scripts in Emacs.
* EasyPG:(epa).              @acronym{PGP/MIME} with Gnus.
* SASL:(sasl).               @acronym{SASL} authentication in Emacs.

@detailmenu
 --- The Detailed Node Listing ---

Starting Gnus

* Finding the News::            Choosing a method for getting news.
* The Server is Down::          How can I read my mail then?
* Slave Gnusae::                You can have more than one Gnus active at a time.
* Fetching a Group::            Starting Gnus just to read a group.
* New Groups::                  What is Gnus supposed to do with new groups?
* Changing Servers::            You may want to move from one server to another.
* Startup Files::               Those pesky startup files---@file{.newsrc}.
* Auto Save::                   Recovering from a crash.
* The Active File::             Reading the active file over a slow line Takes Time.
* Startup Variables::           Other variables you might change.

New Groups

* Checking New Groups::         Determining what groups are new.
* Subscription Methods::        What Gnus should do with new groups.
* Filtering New Groups::        Making Gnus ignore certain new groups.

Group Buffer

* Group Buffer Format::         Information listed and how you can change it.
* Group Maneuvering::           Commands for moving in the group buffer.
* Selecting a Group::           Actually reading news.
* Subscription Commands::       Unsubscribing, killing, subscribing.
* Group Data::                  Changing the info for a group.
* Group Levels::                Levels? What are those, then?
* Group Score::                 A mechanism for finding out what groups you like.
* Marking Groups::              You can mark groups for later processing.
* Foreign Groups::              Creating and editing groups.
* Group Parameters::            Each group may have different parameters set.
* Listing Groups::              Gnus can list various subsets of the groups.
* Sorting Groups::              Re-arrange the group order.
* Group Maintenance::           Maintaining a tidy @file{.newsrc} file.
* Browse Foreign Server::       You can browse a server.  See what it has to offer.
* Exiting Gnus::                Stop reading news and get some work done.
* Group Topics::                A folding group mode divided into topics.
* Non-ASCII Group Names::       Accessing groups of non-English names.
* Misc Group Stuff::            Other stuff that you can to do.

Group Buffer Format

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

Group Topics

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

Misc Group Stuff

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

Summary Buffer

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

Summary Buffer Format

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

Choosing Articles

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

Reply, Followup and Post

* Summary Mail Commands::       Sending mail.
* Summary Post Commands::       Sending news.
* Summary Message Commands::    Other Message-related commands.
* Canceling and Superseding::

Marking Articles

* Unread Articles::             Marks for unread articles.
* Read Articles::               Marks for read articles.
* Other Marks::                 Marks that do not affect readedness.
* Setting Marks::               How to set and remove marks.
* Generic Marking Commands::    How to customize the marking.
* Setting Process Marks::       How to mark articles for later processing.

Threading

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

Customizing Threading

* Loose Threads::               How Gnus gathers loose threads into bigger threads.
* Filling In Threads::          Making the threads displayed look fuller.
* More Threading::              Even more variables for fiddling with threads.
* Low-Level Threading::         You thought it was over@dots{} but you were wrong!

Decoding Articles

* Uuencoded Articles::          Uudecode articles.
* Shell Archives::              Unshar articles.
* PostScript Files::            Split PostScript.
* Other Files::                 Plain save and binhex.
* Decoding Variables::          Variables for a happy decoding.
* Viewing Files::               You want to look at the result of the decoding?

Decoding Variables

* Rule Variables::              Variables that say how a file is to be viewed.
* Other Decode Variables::      Other decode variables.
* Uuencoding and Posting::      Variables for customizing uuencoding.

Article Treatment

* Article Highlighting::        You want to make the article look like fruit salad.
* Article Fontisizing::         Making emphasized text look nice.
* Article Hiding::              You also want to make certain info go away.
* Article Washing::             Lots of way-neat functions to make life better.
* Article Header::              Doing various header transformations.
* Article Buttons::             Click on URLs, Message-IDs, addresses and the like.
* Article Button Levels::       Controlling appearance of buttons.
* Article Date::                Grumble, UT!
* Article Display::             Display various stuff---X-Face, Picons, Smileys, Gravatars
* Article Signature::           What is a signature?
* Article Miscellanea::         Various other stuff.

Alternative Approaches

* Pick and Read::               First mark articles and then read them.
* Binary Groups::               Auto-decode all articles.

Various Summary Stuff

* Summary Group Information::   Information oriented commands.
* Searching for Articles::      Multiple article commands.
* Summary Generation Commands::
* Really Various Summary Commands::  Those pesky non-conformant commands.

Article Buffer

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

Composing Messages

* Mail::                        Mailing and replying.
* Posting Server::              What server should you post and mail via?
* POP before SMTP::             You cannot send a mail unless you read a mail.
* Mail and Post::               Mailing and posting at the same time.
* Archived Messages::           Where Gnus stores the messages you've sent.
* Posting Styles::              An easier way to specify who you are.
* Drafts::                      Postponing messages and rejected messages.
* Rejected Articles::           What happens if the server doesn't like your article?
* Signing and encrypting::      How to compose secure messages.

Select Methods

* Server Buffer::               Making and editing virtual servers.
* Getting News::                Reading USENET news with Gnus.
* Using IMAP::                  Reading mail from @acronym{IMAP}.
* Getting Mail::                Reading your personal mail with Gnus.
* Browsing the Web::            Getting messages from a plethora of Web sources.
* Other Sources::               Reading directories, files.
* Combined Groups::             Combining groups into one group.
* Email Based Diary::           Using mails to manage diary events in Gnus.
* Gnus Unplugged::              Reading news and mail offline.

Server Buffer

* Server Buffer Format::        You can customize the look of this buffer.
* Server Commands::             Commands to manipulate servers.
* Example Methods::             Examples server specifications.
* Creating a Virtual Server::   An example session.
* Server Variables::            Which variables to set.
* Servers and Methods::         You can use server names as select methods.
* Unavailable Servers::         Some servers you try to contact may be down.

Getting News

* NNTP::                        Reading news from an @acronym{NNTP} server.
* News Spool::                  Reading news from the local spool.

@acronym{NNTP}

* Direct Functions::            Connecting directly to the server.
* Indirect Functions::          Connecting indirectly to the server.
* Common Variables::            Understood by several connection functions.
* NNTP marks::                  Storing marks for @acronym{NNTP} servers.

Getting Mail

* Mail in a Newsreader::        Important introductory notes.
* Getting Started Reading Mail::  A simple cookbook example.
* Splitting Mail::              How to create mail groups.
* Mail Sources::                How to tell Gnus where to get mail from.
* Mail Back End Variables::     Variables for customizing mail handling.
* Fancy Mail Splitting::        Gnus can do hairy splitting of incoming mail.
* Group Mail Splitting::        Use group customize to drive mail splitting.
* Incorporating Old Mail::      What about the old mail you have?
* Expiring Mail::               Getting rid of unwanted mail.
* Washing Mail::                Removing cruft from the mail you get.
* Duplicates::                  Dealing with duplicated mail.
* Not Reading Mail::            Using mail back ends for reading other files.
* Choosing a Mail Back End::    Gnus can read a variety of mail formats.

Mail Sources

* Mail Source Specifiers::      How to specify what a mail source is.
* Mail Source Customization::   Some variables that influence things.
* Fetching Mail::               Using the mail source specifiers.

Choosing a Mail Back End

* Unix Mail Box::               Using the (quite) standard Un*x mbox.
* Babyl::                       Babyl was used by older versions of Rmail.
* Mail Spool::                  Store your mail in a private spool?
* MH Spool::                    An mhspool-like back end.
* Maildir::                     Another one-file-per-message format.
* Mail Folders::                Having one file for each group.
* Comparing Mail Back Ends::    An in-depth looks at pros and cons.

Browsing the Web

* Archiving Mail::
* Web Searches::                Creating groups from articles that match a string.
* RSS::                         Reading RDF site summary.
* Customizing W3::              Doing stuff to Emacs/W3 from Gnus.

Other Sources

* Directory Groups::            You can read a directory as if it was a newsgroup.
* Anything Groups::             Dired?  Who needs dired?
* Document Groups::             Single files can be the basis of a group.
* Mail-To-News Gateways::       Posting articles via mail-to-news gateways.
* The Empty Backend::           The backend that never has any news.

Document Groups

* Document Server Internals::   How to add your own document types.

Combined Groups

* Virtual Groups::              Combining articles from many groups.

Email Based Diary

* The NNDiary Back End::        Basic setup and usage.
* The Gnus Diary Library::      Utility toolkit on top of nndiary.
* Sending or Not Sending::      A final note on sending diary messages.

The NNDiary Back End

* Diary Messages::              What makes a message valid for nndiary.
* Running NNDiary::             NNDiary has two modes of operation.
* Customizing NNDiary::         Bells and whistles.

The Gnus Diary Library

* Diary Summary Line Format::           A nicer summary buffer line format.
* Diary Articles Sorting::              A nicer way to sort messages.
* Diary Headers Generation::            Not doing it manually.
* Diary Group Parameters::              Not handling them manually.

Gnus Unplugged

* Agent Basics::                How it all is supposed to work.
* Agent Categories::            How to tell the Gnus Agent what to download.
* Agent Commands::              New commands for all the buffers.
* Agent Visuals::               Ways that the agent may effect your summary buffer.
* Agent as Cache::              The Agent is a big cache too.
* Agent Expiry::                How to make old articles go away.
* Agent Regeneration::          How to recover from lost connections and other accidents.
* Agent and flags::             How the Agent maintains flags.
* Agent and IMAP::              How to use the Agent with @acronym{IMAP}.
* Outgoing Messages::           What happens when you post/mail something?
* Agent Variables::             Customizing is fun.
* Example Setup::               An example @file{~/.gnus.el} file for offline people.
* Batching Agents::             How to fetch news from a @code{cron} job.
* Agent Caveats::               What you think it'll do and what it does.

Agent Categories

* Category Syntax::             What a category looks like.
* Category Buffer::             A buffer for maintaining categories.
* Category Variables::          Customize'r'Us.

Agent Commands

* Group Agent Commands::        Configure groups and fetch their contents.
* Summary Agent Commands::      Manually select then fetch specific articles.
* Server Agent Commands::       Select the servers that are supported by the agent.

Scoring

* Summary Score Commands::      Adding score entries for the current group.
* Group Score Commands::        General score commands.
* Score Variables::             Customize your scoring.  (My, what terminology).
* Score File Format::           What a score file may contain.
* Score File Editing::          You can edit score files by hand as well.
* Adaptive Scoring::            Big Sister Gnus knows what you read.
* Home Score File::             How to say where new score entries are to go.
* Followups To Yourself::       Having Gnus notice when people answer you.
* Scoring On Other Headers::    Scoring on non-standard headers.
* Scoring Tips::                How to score effectively.
* Reverse Scoring::             That problem child of old is not problem.
* Global Score Files::          Earth-spanning, ear-splitting score files.
* Kill Files::                  They are still here, but they can be ignored.
* Converting Kill Files::       Translating kill files to score files.
* Advanced Scoring::            Using logical expressions to build score rules.
* Score Decays::                It can be useful to let scores wither away.

Advanced Scoring

* Advanced Scoring Syntax::     A definition.
* Advanced Scoring Examples::   What they look like.
* Advanced Scoring Tips::       Getting the most out of it.

Searching

* nnir::                        Searching with various engines.
* nnmairix::                    Searching with Mairix.

nnir

* What is nnir?::               What does nnir do.
* Basic Usage::                 How to perform simple searches.
* Setting up nnir::             How to set up nnir.

Setting up nnir

* Associating Engines::         How to associate engines.

Various

* Process/Prefix::              A convention used by many treatment commands.
* Interactive::                 Making Gnus ask you many questions.
* Symbolic Prefixes::           How to supply some Gnus functions with options.
* Formatting Variables::        You can specify what buffers should look like.
* Window Layout::               Configuring the Gnus buffer windows.
* Faces and Fonts::             How to change how faces look.
* Compilation::                 How to speed Gnus up.
* Mode Lines::                  Displaying information in the mode lines.
* Highlighting and Menus::      Making buffers look all nice and cozy.
* Daemons::                     Gnus can do things behind your back.
* Undo::                        Some actions can be undone.
* Predicate Specifiers::        Specifying predicates.
* Moderation::                  What to do if you're a moderator.
* Image Enhancements::          Modern versions of Emacs/XEmacs can display images.
* Fuzzy Matching::              What's the big fuzz?
* Thwarting Email Spam::        Simple ways to avoid unsolicited commercial email.
* Spam Package::                A package for filtering and processing spam.
* The Gnus Registry::           A package for tracking messages by Message-ID.
* Other modes::                 Interaction with other modes.
* Various Various::             Things that are really various.

Formatting Variables

* Formatting Basics::           A formatting variable is basically a format string.
* Mode Line Formatting::        Some rules about mode line formatting variables.
* Advanced Formatting::         Modifying output in various ways.
* User-Defined Specs::          Having Gnus call your own functions.
* Formatting Fonts::            Making the formatting look colorful and nice.
* Positioning Point::           Moving point to a position after an operation.
* Tabulation::                  Tabulating your output.
* Wide Characters::             Dealing with wide characters.

Image Enhancements

* X-Face::                      Display a funky, teensy black-and-white image.
* Face::                        Display a funkier, teensier colored image.
* Smileys::                     Show all those happy faces the way they were
                                  meant to be shown.
* Picons::                      How to display pictures of what you're reading.
* Gravatars::                   Display the avatar of people you read.
* XVarious::                    Other XEmacsy Gnusey variables.

Thwarting Email Spam

* The problem of spam::         Some background, and some solutions
* Anti-Spam Basics::            Simple steps to reduce the amount of spam.
* SpamAssassin::                How to use external anti-spam tools.
* Hashcash::                    Reduce spam by burning CPU time.

Spam Package

* Spam Package Introduction::
* Filtering Incoming Mail::
* Detecting Spam in Groups::
* Spam and Ham Processors::
* Spam Package Configuration Examples::
* Spam Back Ends::
* Extending the Spam package::
* Spam Statistics Package::

Spam Statistics Package

* Creating a spam-stat dictionary::
* Splitting mail using spam-stat::
* Low-level interface to the spam-stat dictionary::

Appendices

* XEmacs::                      Requirements for installing under XEmacs.
* History::                     How Gnus got where it is today.
* On Writing Manuals::          Why this is not a beginner's guide.
* Terminology::                 We use really difficult, like, words here.
* Customization::               Tailoring Gnus to your needs.
* Troubleshooting::             What you might try if things do not work.
* Gnus Reference Guide::        Rilly, rilly technical stuff.
* Emacs for Heathens::          A short introduction to Emacsian terms.
* Frequently Asked Questions::  The Gnus FAQ

History

* Gnus Versions::               What Gnus versions have been released.
* Why?::                        What's the point of Gnus?
* Compatibility::               Just how compatible is Gnus with @sc{gnus}?
* Conformity::                  Gnus tries to conform to all standards.
* Emacsen::                     Gnus can be run on a few modern Emacsen.
* Gnus Development::            How Gnus is developed.
* Contributors::                Oodles of people.
* New Features::                Pointers to some of the new stuff in Gnus.

New Features

* ding Gnus::                   New things in Gnus 5.0/5.1, the first new Gnus.
* September Gnus::              The Thing Formally Known As Gnus 5.2/5.3.
* Red Gnus::                    Third time best---Gnus 5.4/5.5.
* Quassia Gnus::                Two times two is four, or Gnus 5.6/5.7.
* Pterodactyl Gnus::            Pentad also starts with P, AKA Gnus 5.8/5.9.
* Oort Gnus::                   It's big.  It's far out.  Gnus 5.10/5.11.
* No Gnus::                     Very punny.

Customization

* Slow/Expensive Connection::   You run a local Emacs and get the news elsewhere.
* Slow Terminal Connection::    You run a remote Emacs.
* Little Disk Space::           You feel that having large setup files is icky.
* Slow Machine::                You feel like buying a faster machine.

Gnus Reference Guide

* Gnus Utility Functions::      Common functions and variable to use.
* Back End Interface::          How Gnus communicates with the servers.
* Score File Syntax::           A BNF definition of the score file standard.
* Headers::                     How Gnus stores headers internally.
* Ranges::                      A handy format for storing mucho numbers.
* Group Info::                  The group info format.
* Extended Interactive::        Symbolic prefixes and stuff.
* Emacs/XEmacs Code::           Gnus can be run under all modern Emacsen.
* Various File Formats::        Formats of files that Gnus use.

Back End Interface

* Required Back End Functions::  Functions that must be implemented.
* Optional Back End Functions::  Functions that need not be implemented.
* Error Messaging::             How to get messages and report errors.
* Writing New Back Ends::       Extending old back ends.
* Hooking New Back Ends Into Gnus::  What has to be done on the Gnus end.
* Mail-like Back Ends::         Some tips on mail back ends.

Various File Formats

* Active File Format::          Information on articles and groups available.
* Newsgroups File Format::      Group descriptions.

Emacs for Heathens

* Keystrokes::                  Entering text and executing commands.
* Emacs Lisp::                  The built-in Emacs programming language.

@end detailmenu
@end menu

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

If you haven't used Emacs much before using Gnus, read @ref{Emacs for
Heathens} first.

@kindex M-x gnus
@findex gnus
If your system administrator has set things up properly, starting Gnus
and reading news is extremely easy---you just type @kbd{M-x gnus} in
your Emacs.  If not, you should customize the variable
@code{gnus-select-method} as described in @ref{Finding the News}.  For a
minimal setup for posting should also customize the variables
@code{user-full-name} and @code{user-mail-address}.

@findex gnus-other-frame
@kindex M-x gnus-other-frame
If you want to start Gnus in a different frame, you can use the command
@kbd{M-x gnus-other-frame} instead.

If things do not go smoothly at startup, you have to twiddle some
variables in your @file{~/.gnus.el} file.  This file is similar to
@file{~/.emacs}, but is read when Gnus starts.

If you puzzle at any terms used in this manual, please refer to the
terminology section (@pxref{Terminology}).

@menu
* Finding the News::      Choosing a method for getting news.
* The Server is Down::    How can I read my mail then?
* Slave Gnusae::          You can have more than one Gnus active at a time.
* New Groups::            What is Gnus supposed to do with new groups?
* Changing Servers::      You may want to move from one server to another.
* Startup Files::         Those pesky startup files---@file{.newsrc}.
* Auto Save::             Recovering from a crash.
* The Active File::       Reading the active file over a slow line Takes Time.
* Startup Variables::     Other variables you might change.
@end menu


@node Finding the News
@section Finding the News
@cindex finding news

First of all, you should know that there is a special buffer called
@code{*Server*} that lists all the servers Gnus knows about.  You can
press @kbd{^} from the Group buffer to see it.  In the Server buffer,
you can press @kbd{RET} on a defined server to see all the groups it
serves (subscribed or not!).  You can also add or delete servers, edit
a foreign server's definition, agentize or de-agentize a server, and
do many other neat things.  @xref{Server Buffer}.
@xref{Foreign Groups}.  @xref{Agent Basics}.

@vindex gnus-select-method
@c @head
The @code{gnus-select-method} variable says where Gnus should look for
news.  This variable should be a list where the first element says
@dfn{how} and the second element says @dfn{where}.  This method is your
native method.  All groups not fetched with this method are
secondary or foreign groups.

For instance, if the @samp{news.somewhere.edu} @acronym{NNTP} server is where
you want to get your daily dosage of news from, you'd say:

@lisp
(setq gnus-select-method '(nntp "news.somewhere.edu"))
@end lisp

If you want to read directly from the local spool, say:

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

If you can use a local spool, you probably should, as it will almost
certainly be much faster.  But do not use the local spool if your
server is running Leafnode (which is a simple, standalone private news
server); in this case, use @code{(nntp "localhost")}.

@vindex gnus-nntpserver-file
@cindex NNTPSERVER
@cindex @acronym{NNTP} server
If this variable is not set, Gnus will take a look at the
@env{NNTPSERVER} environment variable.  If that variable isn't set,
Gnus will see whether @code{gnus-nntpserver-file}
(@file{/etc/nntpserver} by default) has any opinions on the matter.
If that fails as well, Gnus will try to use the machine running Emacs
as an @acronym{NNTP} server.  That's a long shot, though.

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

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

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

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

Note: the @acronym{NNTP} back end stores marks in marks files
(@pxref{NNTP marks}).  This feature makes it easy to share marks between
several Gnus installations, but may slow down things a bit when fetching
new articles.  @xref{NNTP marks}, for more information.


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

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

Gnus, being the trusting sort of program, will ask whether to proceed
without a native select method if that server can't be contacted.  This
will happen whether the server doesn't actually exist (i.e., you have
given the wrong address) or the server has just momentarily taken ill
for some reason or other.  If you decide to continue and have no foreign
groups, you'll find it difficult to actually do anything in the group
buffer.  But, hey, that's your problem.  Blllrph!

@findex gnus-no-server
@kindex M-x gnus-no-server
@c @head
If you know that the server is definitely down, or you just want to read
your mail without bothering with the server at all, you can use the
@code{gnus-no-server} command to start Gnus.  That might come in handy
if you're in a hurry as well.  This command will not attempt to contact
your primary server---instead, it will just activate all groups on level
1 and 2.  (You should preferably keep no native groups on those two
levels.) Also @pxref{Group Levels}.


@node Slave Gnusae
@section Slave Gnusae
@cindex slave

You might want to run more than one Emacs with more than one Gnus at the
same time.  If you are using different @file{.newsrc} files (e.g., if you
are using the two different Gnusae to read from two different servers),
that is no problem whatsoever.  You just do it.

The problem appears when you want to run two Gnusae that use the same
@file{.newsrc} file.

To work around that problem some, we here at the Think-Tank at the Gnus
Towers have come up with a new concept: @dfn{Masters} and
@dfn{slaves}.  (We have applied for a patent on this concept, and have
taken out a copyright on those words.  If you wish to use those words in
conjunction with each other, you have to send $1 per usage instance to
me.  Usage of the patent (@dfn{Master/Slave Relationships In Computer
Applications}) will be much more expensive, of course.)

@findex gnus-slave
Anyway, you start one Gnus up the normal way with @kbd{M-x gnus} (or
however you do it).  Each subsequent slave Gnusae should be started with
@kbd{M-x gnus-slave}.  These slaves won't save normal @file{.newsrc}
files, but instead save @dfn{slave files} that contain information only
on what groups have been read in the slave session.  When a master Gnus
starts, it will read (and delete) these slave files, incorporating all
information from them.  (The slave files will be read in the sequence
they were created, so the latest changes will have precedence.)

Information from the slave files has, of course, precedence over the
information in the normal (i.e., master) @file{.newsrc} file.

If the @file{.newsrc*} files have not been saved in the master when the
slave starts, you may be prompted as to whether to read an auto-save
file.  If you answer ``yes'', the unsaved changes to the master will be
incorporated into the slave.  If you answer ``no'', the slave may see some
messages as unread that have been read in the master.



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

@vindex gnus-check-new-newsgroups
If you are satisfied that you really never want to see any new groups,
you can set @code{gnus-check-new-newsgroups} to @code{nil}.  This will
also save you some time at startup.  Even if this variable is
@code{nil}, you can always subscribe to the new groups just by pressing
@kbd{U} in the group buffer (@pxref{Group Maintenance}).  This variable
is @code{ask-server} by default.  If you set this variable to
@code{always}, then Gnus will query the back ends for new groups even
when you do the @kbd{g} command (@pxref{Scanning New Messages}).

@menu
* Checking New Groups::         Determining what groups are new.
* Subscription Methods::        What Gnus should do with new groups.
* Filtering New Groups::        Making Gnus ignore certain new groups.
@end menu


@node Checking New Groups
@subsection Checking New Groups

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

I bet I know what you're thinking now: How do I find out whether my
server supports @code{ask-server}?  No?  Good, because I don't have a
fail-safe answer.  I would suggest just setting this variable to
@code{ask-server} and see whether any new groups appear within the next
few days.  If any do, then it works.  If none do, then it doesn't
work.  I could write a function to make Gnus guess whether the server
supports @code{ask-server}, but it would just be a guess.  So I won't.
You could @code{telnet} to the server and say @code{HELP} and see
whether it lists @samp{NEWGROUPS} among the commands it understands.  If
it does, then it might work.  (But there are servers that lists
@samp{NEWGROUPS} without supporting the function properly.)

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


@node Subscription Methods
@subsection Subscription Methods

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

This variable should contain a function.  This function will be called
with the name of the new group as the only parameter.

Some handy pre-fab functions are:

@table @code

@item gnus-subscribe-zombies
@vindex gnus-subscribe-zombies
Make all new groups zombies (@pxref{Group Levels}).  This is the
default.  You can browse the zombies later (with @kbd{A z}) and either
kill them all off properly (with @kbd{S z}), or subscribe to them
(with @kbd{u}).

@item gnus-subscribe-randomly
@vindex gnus-subscribe-randomly
Subscribe all new groups in arbitrary order.  This really means that all
new groups will be added at ``the top'' of the group buffer.

@item gnus-subscribe-alphabetically
@vindex gnus-subscribe-alphabetically
Subscribe all new groups in alphabetical order.

@item gnus-subscribe-hierarchically
@vindex gnus-subscribe-hierarchically
Subscribe all new groups hierarchically.  The difference between this
function and @code{gnus-subscribe-alphabetically} is slight.
@code{gnus-subscribe-alphabetically} will subscribe new groups in a strictly
alphabetical fashion, while this function will enter groups into its
hierarchy.  So if you want to have the @samp{rec} hierarchy before the
@samp{comp} hierarchy, this function will not mess that configuration
up.  Or something like that.

@item gnus-subscribe-interactively
@vindex gnus-subscribe-interactively
Subscribe new groups interactively.  This means that Gnus will ask
you about @strong{all} new groups.  The groups you choose to subscribe
to will be subscribed hierarchically.

@item gnus-subscribe-killed
@vindex gnus-subscribe-killed
Kill all new groups.

@item gnus-subscribe-topics
@vindex gnus-subscribe-topics
Put the groups into the topic that has a matching @code{subscribe} topic
parameter (@pxref{Topic Parameters}).  For instance, a @code{subscribe}
topic parameter that looks like

@example
"nnml"
@end example

will mean that all groups that match that regex will be subscribed under
that topic.

If no topics match the groups, the groups will be subscribed in the
top-level topic.

@end table

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

One common mistake is to set the variable a few paragraphs above
(@code{gnus-subscribe-newsgroup-method}) to
@code{gnus-subscribe-hierarchical-interactive}.  This is an error.  This
will not work.  This is ga-ga.  So don't do it.


@node Filtering New Groups
@subsection Filtering New Groups

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

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

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

The ``options -n'' format is very simplistic.  The syntax above is all
that is supports -- you can force-subscribe hierarchies, or you can
deny hierarchies, and that's it.

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

@vindex gnus-auto-subscribed-groups
Yet another variable that meddles here is
@code{gnus-auto-subscribed-groups}.  It works exactly like
@code{gnus-options-subscribe}, and is therefore really superfluous,
but I thought it would be nice to have two of these.  This variable is
more meant for setting some ground rules, while the other variable is
used more for user fiddling.  By default this variable makes all new
groups that come from mail back ends (@code{nnml}, @code{nnbabyl},
@code{nnfolder}, @code{nnmbox}, @code{nnmh}, @code{nnimap}, and
@code{nnmaildir}) subscribed.  If you don't like that, just set this
variable to @code{nil}.

@vindex gnus-auto-subscribed-categories
As if that wasn't enough, @code{gnus-auto-subscribed-categories} also
allows you to specify that new groups should be subscribed based on the
category their select methods belong to.  The default is @samp{(mail
post-mail)}, meaning that all new groups from mail-like backends
should be subscribed automatically.

New groups that match these variables are subscribed using
@code{gnus-subscribe-options-newsgroup-method}.


@node Changing Servers
@section Changing Servers
@cindex changing servers

Sometimes it is necessary to move from one @acronym{NNTP} server to another.
This happens very rarely, but perhaps you change jobs, or one server is
very flaky and you want to use another.

Changing the server is pretty easy, right?  You just change
@code{gnus-select-method} to point to the new server?

@emph{Wrong!}

Article numbers are not (in any way) kept synchronized between different
@acronym{NNTP} servers, and the only way Gnus keeps track of what articles
you have read is by keeping track of article numbers.  So when you
change @code{gnus-select-method}, your @file{.newsrc} file becomes
worthless.

@kindex M-x gnus-group-clear-data-on-native-groups
@findex gnus-group-clear-data-on-native-groups
You can use the @kbd{M-x gnus-group-clear-data-on-native-groups}
command to clear out all data that you have on your native groups.
Use with caution.

@kindex M-x gnus-group-clear-data
@findex gnus-group-clear-data
Clear the data from the current group only---nix out marks and the
list of read articles (@code{gnus-group-clear-data}).

After changing servers, you @strong{must} move the cache hierarchy away,
since the cached articles will have wrong article numbers, which will
affect which articles Gnus thinks are read.
@code{gnus-group-clear-data-on-native-groups} will ask you if you want
to have it done automatically; for @code{gnus-group-clear-data}, you
can use @kbd{M-x gnus-cache-move-cache} (but beware, it will move the
cache for all groups).


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

Most common Unix news readers use a shared startup file called
@file{.newsrc}.  This file contains all the information about what
groups are subscribed, and which articles in these groups have been
read.

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

That was kinda silly, so Gnus went one better: In addition to the
@file{.newsrc} and @file{.newsrc.el} files, Gnus also has a file called
@file{.newsrc.eld}.  It will read whichever of these files that are most
recent, but it will never write a @file{.newsrc.el} file.  You should
never delete the @file{.newsrc.eld} file---it contains much information
not stored in the @file{.newsrc} file.

@vindex gnus-save-newsrc-file
@vindex gnus-read-newsrc-file
You can turn off writing the @file{.newsrc} file by setting
@code{gnus-save-newsrc-file} to @code{nil}, which means you can delete
the file and save some space, as well as exiting from Gnus faster.
However, this will make it impossible to use other newsreaders than
Gnus.  But hey, who would want to, right?  Similarly, setting
@code{gnus-read-newsrc-file} to @code{nil} makes Gnus ignore the
@file{.newsrc} file and any @file{.newsrc-SERVER} files, which can be
convenient if you use a different news reader occasionally, and you
want to read a different subset of the available groups with that
news reader.

@vindex gnus-save-killed-list
If @code{gnus-save-killed-list} (default @code{t}) is @code{nil}, Gnus
will not save the list of killed groups to the startup file.  This will
save both time (when starting and quitting) and space (on disk).  It
will also mean that Gnus has no record of what groups are new or old,
so the automatic new groups subscription methods become meaningless.
You should always set @code{gnus-check-new-newsgroups} to @code{nil} or
@code{ask-server} if you set this variable to @code{nil} (@pxref{New
Groups}).  This variable can also be a regular expression.  If that's
the case, remove all groups that do not match this regexp before
saving.  This can be useful in certain obscure situations that involve
several servers where not all servers support @code{ask-server}.

@vindex gnus-startup-file
@vindex gnus-backup-startup-file
@vindex version-control
The @code{gnus-startup-file} variable says where the startup files are.
The default value is @file{~/.newsrc}, with the Gnus (El Dingo) startup
file being whatever that one is, with a @samp{.eld} appended.
If you want to keep multiple numbered backups of this file, set
@code{gnus-backup-startup-file}.  It respects the same values as the
@code{version-control} variable.

@vindex gnus-save-newsrc-hook
@vindex gnus-save-quick-newsrc-hook
@vindex gnus-save-standard-newsrc-hook
@code{gnus-save-newsrc-hook} is called before saving any of the newsrc
files, while @code{gnus-save-quick-newsrc-hook} is called just before
saving the @file{.newsrc.eld} file, and
@code{gnus-save-standard-newsrc-hook} is called just before saving the
@file{.newsrc} file.  The latter two are commonly used to turn version
control on or off.  Version control is on by default when saving the
startup files.  If you want to turn backup creation off, say something like:

@lisp
(defun turn-off-backup ()
  (set (make-local-variable 'backup-inhibited) t))

(add-hook 'gnus-save-quick-newsrc-hook 'turn-off-backup)
(add-hook 'gnus-save-standard-newsrc-hook 'turn-off-backup)
@end lisp

@vindex gnus-init-file
@vindex gnus-site-init-file
When Gnus starts, it will read the @code{gnus-site-init-file}
(@file{.../site-lisp/gnus-init} by default) and @code{gnus-init-file}
(@file{~/.gnus} by default) files.  These are normal Emacs Lisp files
and can be used to avoid cluttering your @file{~/.emacs} and
@file{site-init} files with Gnus stuff.  Gnus will also check for files
with the same names as these, but with @file{.elc} and @file{.el}
suffixes.  In other words, if you have set @code{gnus-init-file} to
@file{~/.gnus}, it will look for @file{~/.gnus.elc}, @file{~/.gnus.el},
and finally @file{~/.gnus} (in this order).  If Emacs was invoked with
the @option{-q} or @option{--no-init-file} options (@pxref{Initial
Options, ,Initial Options, emacs, The Emacs Manual}), Gnus doesn't read
@code{gnus-init-file}.


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

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

If Gnus detects this file at startup, it will ask the user whether to
read it.  The auto save file is deleted whenever the real startup file is
saved.

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

@vindex gnus-dribble-directory
Gnus will put the dribble file(s) in @code{gnus-dribble-directory}.  If
this variable is @code{nil}, which it is by default, Gnus will dribble
into the directory where the @file{.newsrc} file is located.  (This is
normally the user's home directory.)  The dribble file will get the same
file permissions as the @file{.newsrc} file.

@vindex gnus-always-read-dribble-file
If @code{gnus-always-read-dribble-file} is non-@code{nil}, Gnus will
read the dribble file on startup without querying the user.


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

When Gnus starts, or indeed whenever it tries to determine whether new
articles have arrived, it reads the active file.  This is a very large
file that lists all the active groups and articles on the server.

@vindex gnus-ignored-newsgroups
Before examining the active file, Gnus deletes all lines that match the
regexp @code{gnus-ignored-newsgroups}.  This is done primarily to reject
any groups with bogus names, but you can use this variable to make Gnus
ignore hierarchies you aren't ever interested in.  However, this is not
recommended.  In fact, it's highly discouraged.  Instead, @pxref{New
Groups} for an overview of other variables that can be used instead.

@c This variable is
@c @code{nil} by default, and will slow down active file handling somewhat
@c if you set it to anything else.

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

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

Note that if you subscribe to lots and lots of groups, setting this
variable to @code{nil} will probably make Gnus slower, not faster.  At
present, having this variable @code{nil} will slow Gnus down
considerably, unless you read news over a 2400 baud modem.

This variable can also have the value @code{some}.  Gnus will then
attempt to read active info only on the subscribed groups.  On some
servers this is quite fast (on sparkling, brand new INN servers that
support the @code{LIST ACTIVE group} command), on others this isn't fast
at all.  In any case, @code{some} should be faster than @code{nil}, and
is certainly faster than @code{t} over slow lines.

Some news servers (old versions of Leafnode and old versions of INN, for
instance) do not support the @code{LIST ACTIVE group}.  For these
servers, @code{nil} is probably the most efficient value for this
variable.

If this variable is @code{nil}, Gnus will ask for group info in total
lock-step, which isn't very fast.  If it is @code{some} and you use an
@acronym{NNTP} server, Gnus will pump out commands as fast as it can, and
read all the replies in one swoop.  This will normally result in better
performance, but if the server does not support the aforementioned
@code{LIST ACTIVE group} command, this isn't very nice to the server.

If you think that starting up Gnus takes too long, try all the three
different values for this variable and see what works best for you.

In any case, if you use @code{some} or @code{nil}, you should definitely
kill all groups that you aren't interested in to speed things up.

Note that this variable also affects active file retrieval from
secondary select methods.


@node Startup Variables
@section Startup Variables

@table @code

@item gnus-load-hook
@vindex gnus-load-hook
A hook run while Gnus is being loaded.  Note that this hook will
normally be run just once in each Emacs session, no matter how many
times you start Gnus.

@item gnus-before-startup-hook
@vindex gnus-before-startup-hook
A hook called as the first thing when Gnus is started.

@item gnus-startup-hook
@vindex gnus-startup-hook
A hook run as the very last thing after starting up Gnus

@item gnus-started-hook
@vindex gnus-started-hook
A hook that is run as the very last thing after starting up Gnus
successfully.

@item gnus-setup-news-hook
@vindex gnus-setup-news-hook
A hook that is run after reading the @file{.newsrc} file(s), but before
generating the group buffer.

@item gnus-check-bogus-newsgroups
@vindex gnus-check-bogus-newsgroups
If non-@code{nil}, Gnus will check for and delete all bogus groups at
startup.  A @dfn{bogus group} is a group that you have in your
@file{.newsrc} file, but doesn't exist on the news server.  Checking for
bogus groups can take quite a while, so to save time and resources it's
best to leave this option off, and do the checking for bogus groups once
in a while from the group buffer instead (@pxref{Group Maintenance}).

@item gnus-inhibit-startup-message
@vindex gnus-inhibit-startup-message
If non-@code{nil}, the startup message won't be displayed.  That way,
your boss might not notice as easily that you are reading news instead
of doing your job.  Note that this variable is used before
@file{~/.gnus.el} is loaded, so it should be set in @file{.emacs} instead.

@item gnus-no-groups-message
@vindex gnus-no-groups-message
Message displayed by Gnus when no groups are available.

@item gnus-use-backend-marks
@vindex gnus-use-backend-marks
If non-@code{nil}, Gnus will store article marks both in the
@file{.newsrc.eld} file and in the backends.  This will slow down
group operation some.

@end table


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

@c Alex Schroeder suggests to rearrange this as follows:
@c
@c <kensanata> ok, just save it for reference.  I'll go to bed in a minute.
@c   1. Selecting a Group, 2. (new) Finding a Group, 3. Group Levels,
@c   4. Subscription Commands, 5. Group Maneuvering, 6. Group Data,
@c   7. Group Score, 8. Group Buffer Format
@c <kensanata> Group Levels should have more information on levels 5 to 9.  I
@c   suggest to split the 4th paragraph ("Gnus considers groups...") as follows:
@c <kensanata> First, "Gnus considers groups... (default 9)."
@c <kensanata> New, a table summarizing what levels 1 to 9 mean.
@c <kensanata> Third, "Gnus treats subscribed ... reasons of efficiency"
@c <kensanata> Then expand the next paragraph or add some more to it.
@c    This short one sentence explains levels 1 and 2, therefore I understand
@c    that I should keep important news at 3 and boring news at 4.
@c    Say so!  Then go on to explain why I should bother with levels 6 to 9.
@c    Maybe keep those that you don't want to read temporarily at 6,
@c    those that you never want to read at 8, those that offend your
@c    human rights at 9...


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

@iftex
@iflatex
\gnusfigure{The Group Buffer}{320}{
\put(75,50){\epsfig{figure=ps/group,height=9cm}}
\put(120,37){\makebox(0,0)[t]{Buffer name}}
\put(120,38){\vector(1,2){10}}
\put(40,60){\makebox(0,0)[r]{Mode line}}
\put(40,58){\vector(1,0){30}}
\put(200,28){\makebox(0,0)[t]{Native select method}}
\put(200,26){\vector(-1,2){15}}
}
@end iflatex
@end iftex

@menu
* Group Buffer Format::         Information listed and how you can change it.
* Group Maneuvering::           Commands for moving in the group buffer.
* Selecting a Group::           Actually reading news.
* Subscription Commands::       Unsubscribing, killing, subscribing.
* Group Data::                  Changing the info for a group.
* Group Levels::                Levels? What are those, then?
* Group Score::                 A mechanism for finding out what groups you like.
* Marking Groups::              You can mark groups for later processing.
* Foreign Groups::              Creating and editing groups.
* Group Parameters::            Each group may have different parameters set.
* Listing Groups::              Gnus can list various subsets of the groups.
* Sorting Groups::              Re-arrange the group order.
* Group Maintenance::           Maintaining a tidy @file{.newsrc} file.
* Browse Foreign Server::       You can browse a server.  See what it has to offer.
* Exiting Gnus::                Stop reading news and get some work done.
* Group Topics::                A folding group mode divided into topics.
* Non-ASCII Group Names::       Accessing groups of non-English names.
* Misc Group Stuff::            Other stuff that you can to do.
@end menu


@node Group Buffer Format
@section Group Buffer Format

@menu
* Group Line Specification::    Deciding how the group buffer is to look.
* Group Mode Line Specification::  The group buffer mode line.
* Group Highlighting::          Having nice colors in the group buffer.
@end menu

You can customize the Group Mode tool bar, see @kbd{M-x
customize-apropos RET gnus-group-tool-bar}.  This feature is only
available in Emacs.

The tool bar icons are now (de)activated correctly depending on the
cursor position.  Therefore, moving around in the Group Buffer is
slower.  You can disable this via the variable
@code{gnus-group-update-tool-bar}.  Its default value depends on your
Emacs version.

@node Group Line Specification
@subsection Group Line Specification
@cindex group buffer format

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

Here's a couple of example group lines:

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

Quite simple, huh?

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

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

@samp{%M%S%5y:%B%(%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.  @xref{Positioning
Point}.  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:

@table @samp

@item M
An asterisk if the group only has marked articles.

@item S
Whether the group is subscribed.

@item L
Level of subscribedness.

@item N
Number of unread articles.

@item I
Number of dormant articles.

@item T
Number of ticked articles.

@item R
Number of read articles.

@item U
Number of unseen articles.

@item t
Estimated total number of articles.  (This is really @var{max-number}
minus @var{min-number} plus 1.)

Gnus uses this estimation because the @acronym{NNTP} protocol provides
efficient access to @var{max-number} and @var{min-number} but getting
the true unread message count is not possible efficiently.  For
hysterical raisins, even the mail back ends, where the true number of
unread messages might be available efficiently, use the same limited
interface.  To remove this restriction from Gnus means that the back
end interface has to be changed, which is not an easy job.

The nnml backend (@pxref{Mail Spool}) has a feature called ``group
compaction'' which circumvents this deficiency: the idea is to
renumber all articles from 1, removing all gaps between numbers, hence
getting a correct total count.  Other backends may support this in the
future.  In order to keep your total article count relatively up to
date, you might want to compact your groups (or even directly your
server) from time to time. @xref{Misc Group Stuff}, @xref{Server Commands}.

@item y
Number of unread, unticked, non-dormant articles.

@item i
Number of ticked and dormant articles.

@item g
Full group name.

@item G
Group name.

@item C
Group comment (@pxref{Group Parameters}) or group name if there is no
comment element in the group parameters.

@item D
Newsgroup description.  You need to read the group descriptions
before these will appear, and to do that, you either have to set
@code{gnus-read-active-file} or use the group buffer @kbd{M-d}
command.

@item o
@samp{m} if moderated.

@item O
@samp{(m)} if moderated.

@item s
Select method.

@item B
If the summary buffer for the group is open or not.

@item n
Select from where.

@item z
A string that looks like @samp{<%s:%n>} if a foreign select method is
used.

@item P
Indentation based on the level of the topic (@pxref{Group Topics}).

@item c
@vindex gnus-group-uncollapsed-levels
Short (collapsed) group name.  The @code{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
@samp{gnu.emacs.gnus} will be shortened to @samp{g.e.gnus}.

@item m
@vindex gnus-new-mail-mark
@cindex %
@samp{%} (@code{gnus-new-mail-mark}) if there has arrived new mail to
the group lately.

@item p
@samp{#} (@code{gnus-process-mark}) if the group is process marked.

@item d
A string that says when you last read the group (@pxref{Group
Timestamp}).

@item F
The disk space used by the articles fetched by both the cache and
agent.  The value is automatically scaled to bytes(B), kilobytes(K),
megabytes(M), or gigabytes(G) to minimize the column width.  A format
of %7F is sufficient for a fixed-width column.

@item u
User defined specifier.  The next character in the format string should
be a letter.  Gnus will call the function
@code{gnus-user-format-function-}@samp{X}, where @samp{X} is the letter
following @samp{%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.
@end table

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


@node Group Mode Line Specification
@subsection Group Mode Line Specification
@cindex group mode line

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

@table @samp
@item S
The native news server.
@item M
The native select method.
@end table


@node Group Highlighting
@subsection Group Highlighting
@cindex highlighting
@cindex group highlighting

@vindex gnus-group-highlight
Highlighting in the group buffer is controlled by the
@code{gnus-group-highlight} variable.  This is an alist with elements
that look like @code{(@var{form} . @var{face})}.  If @var{form} evaluates to
something non-@code{nil}, the @var{face} will be used on the line.

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

@lisp
(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)))
@end lisp

Also @pxref{Faces and Fonts}.

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

@table @code
@item group
The group name.
@item unread
The number of unread articles in the group.
@item method
The select method.
@item mailp
Whether the group is a mail group.
@item level
The level of the group.
@item score
The score of the group.
@item ticked
The number of ticked articles in the group.
@item total
The total number of articles in the group.  Or rather,
@var{max-number} minus @var{min-number} plus one.
@item topic
When using the topic minor mode, this variable is bound to the current
topic being inserted.
@end table

When the forms are @code{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.

@vindex gnus-group-update-hook
@findex gnus-group-highlight-line
@code{gnus-group-update-hook} is called when a group line is changed.
It will not be called when @code{gnus-visual} is @code{nil}.


@node Group Maneuvering
@section Group Maneuvering
@cindex group movement

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

@table @kbd

@item n
@kindex n (Group)
@findex gnus-group-next-unread-group
Go to the next group that has unread articles
(@code{gnus-group-next-unread-group}).

@item p
@itemx DEL
@kindex DEL (Group)
@kindex p (Group)
@findex gnus-group-prev-unread-group
Go to the previous group that has unread articles
(@code{gnus-group-prev-unread-group}).

@item N
@kindex N (Group)
@findex gnus-group-next-group
Go to the next group (@code{gnus-group-next-group}).

@item P
@kindex P (Group)
@findex gnus-group-prev-group
Go to the previous group (@code{gnus-group-prev-group}).

@item M-n
@kindex M-n (Group)
@findex gnus-group-next-unread-group-same-level
Go to the next unread group on the same (or lower) level
(@code{gnus-group-next-unread-group-same-level}).

@item M-p
@kindex M-p (Group)
@findex gnus-group-prev-unread-group-same-level
Go to the previous unread group on the same (or lower) level
(@code{gnus-group-prev-unread-group-same-level}).
@end table

Three commands for jumping to groups:

@table @kbd

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

@item ,
@kindex , (Group)
@findex gnus-group-best-unread-group
Jump to the unread group with the lowest level
(@code{gnus-group-best-unread-group}).

@item .
@kindex . (Group)
@findex gnus-group-first-unread-group
Jump to the first group with unread articles
(@code{gnus-group-first-unread-group}).
@end table

@vindex gnus-group-goto-unread
If @code{gnus-group-goto-unread} is @code{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 @code{t}.

@vindex gnus-summary-next-group-on-exit
If @code{gnus-summary-next-group-on-exit} is @code{t}, when a summary is
exited, the point in the group buffer is moved to the next unread group.
Otherwise, the point is set to the group just exited.  The default is
@code{t}.

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

@table @kbd

@item SPACE
@kindex SPACE (Group)
@findex gnus-group-read-group
Select the current group, switch to the summary buffer and display the
first unread article (@code{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 @var{n}, @var{n}
determines the number of articles Gnus will fetch.  If @var{n} is
positive, Gnus fetches the @var{n} newest articles, if @var{n} is
negative, Gnus fetches the @code{abs(@var{n})} oldest articles.

Thus, @kbd{SPC} enters the group normally, @kbd{C-u SPC} offers old
articles, @kbd{C-u 4 2 SPC} fetches the 42 newest articles, and @kbd{C-u
- 4 2 SPC} fetches the 42 oldest ones.

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

@item RET
@kindex RET (Group)
@findex gnus-group-select-group
Select the current group and switch to the summary buffer
(@code{gnus-group-select-group}).  Takes the same arguments as
@code{gnus-group-read-group}---the only difference is that this command
does not display the first unread article automatically upon group
entry.

@item M-RET
@kindex M-RET (Group)
@findex gnus-group-quick-select-group
This does the same as the command above, but tries to do it with the
minimum amount of fuzz (@code{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., @kbd{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 (@pxref{Summary Generation Commands}).

@item M-SPACE
@kindex M-SPACE (Group)
@findex gnus-group-visible-select-group
This is yet one more command that does the same as the @kbd{RET}
command, but this one does it without expunging and hiding dormants
(@code{gnus-group-visible-select-group}).

@item C-M-RET
@kindex C-M-RET (Group)
@findex gnus-group-select-group-ephemerally
Finally, this command selects the current group ephemerally without
doing any processing of its contents
(@code{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.

@end table

@vindex gnus-large-newsgroup
The @code{gnus-large-newsgroup} variable says what Gnus should
consider to be a big group.  If it is @code{nil}, no groups are
considered big.  The default value is 200.  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 (@var{-n}), the @var{n} oldest articles will be
fetched.  If it is positive, the @var{n} articles that have arrived
most recently will be fetched.

@vindex gnus-large-ephemeral-newsgroup
@code{gnus-large-ephemeral-newsgroup} is the same as
@code{gnus-large-newsgroup}, but is only used for ephemeral
newsgroups.

@vindex gnus-newsgroup-maximum-articles
In groups in some news servers, there might be a big gap between a few
very old articles that will never be expired and the recent ones.  In
such a case, the server will return the data like @code{(1 . 30000000)}
for the @code{LIST ACTIVE group} command, for example.  Even if there
are actually only the articles 1-10 and 29999900-30000000, Gnus doesn't
know it at first and prepares for getting 30000000 articles.  However,
it will consume hundreds megabytes of memories and might make Emacs get
stuck as the case may be.  If you use such news servers, set the
variable @code{gnus-newsgroup-maximum-articles} to a positive number.
The value means that Gnus ignores articles other than this number of the
latest ones in every group.  For instance, the value 10000 makes Gnus
get only the articles 29990001-30000000 (if the latest article number is
30000000 in a group).  Note that setting this variable to a number might
prevent you from reading very old articles.  The default value of the
variable @code{gnus-newsgroup-maximum-articles} is @code{nil}, which
means Gnus never ignores old articles.

@vindex gnus-select-group-hook
@vindex gnus-auto-select-first
@vindex gnus-auto-select-subject
If @code{gnus-auto-select-first} is non-@code{nil}, select an article
automatically when entering a group with the @kbd{SPACE} command.
Which article this is controlled by the
@code{gnus-auto-select-subject} variable.  Valid values for this
variable are:

@table @code

@item unread
Place point on the subject line of the first unread article.

@item first
Place point on the subject line of the first article.

@item unseen
Place point on the subject line of the first unseen article.

@item unseen-or-unread
Place point on the subject line of the first unseen article, and if
there is no such article, place point on the subject line of the first
unread article.

@item best
Place point on the subject line of the highest-scored unread article.

@end table

This variable can also be a function.  In that case, that function
will be called to place point on a subject line.

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


@node Subscription Commands
@section Subscription Commands
@cindex subscription

The following commands allow for managing your subscriptions in the
Group buffer.  If you want to subscribe to many groups, it's probably
more convenient to go to the @ref{Server Buffer}, and choose the
server there using @kbd{RET} or @kbd{SPC}.  Then you'll have the
commands listed in @ref{Browse Foreign Server} at hand.

@table @kbd

@item S t
@itemx u
@kindex S t (Group)
@kindex u (Group)
@findex gnus-group-unsubscribe-current-group
@c @icon{gnus-group-unsubscribe}
Toggle subscription to the current group
(@code{gnus-group-unsubscribe-current-group}).

@item S s
@itemx U
@kindex S s (Group)
@kindex U (Group)
@findex gnus-group-unsubscribe-group
Prompt for a group to subscribe, and then subscribe it.  If it was
subscribed already, unsubscribe it instead
(@code{gnus-group-unsubscribe-group}).

@item S k
@itemx C-k
@kindex S k (Group)
@kindex C-k (Group)
@findex gnus-group-kill-group
@c @icon{gnus-group-kill-group}
Kill the current group (@code{gnus-group-kill-group}).

@item S y
@itemx C-y
@kindex S y (Group)
@kindex C-y (Group)
@findex gnus-group-yank-group
Yank the last killed group (@code{gnus-group-yank-group}).

@item C-x C-t
@kindex C-x C-t (Group)
@findex gnus-group-transpose-groups
Transpose two groups (@code{gnus-group-transpose-groups}).  This isn't
really a subscription command, but you can use it instead of a
kill-and-yank sequence sometimes.

@item S w
@itemx C-w
@kindex S w (Group)
@kindex C-w (Group)
@findex gnus-group-kill-region
Kill all groups in the region (@code{gnus-group-kill-region}).

@item S z
@kindex S z (Group)
@findex gnus-group-kill-all-zombies
Kill all zombie groups (@code{gnus-group-kill-all-zombies}).

@item S C-k
@kindex S C-k (Group)
@findex gnus-group-kill-level
Kill all groups on a certain level (@code{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 @file{.newsrc} with lots of unsubscribed
groups that you want to get rid off.  @kbd{S C-k} on level 7 will
kill off all unsubscribed groups that do not have message numbers in the
@file{.newsrc} file.

@end table

Also @pxref{Group Levels}.


@node Group Data
@section Group Data

@table @kbd

@item c
@kindex c (Group)
@findex gnus-group-catchup-current
@vindex gnus-group-catchup-group-hook
@c @icon{gnus-group-catchup-current}
Mark all unticked articles in this group as read
(@code{gnus-group-catchup-current}).
@code{gnus-group-catchup-group-hook} is called when catching up a group from
the group buffer.

@item C
@kindex C (Group)
@findex gnus-group-catchup-current-all
Mark all articles in this group, even the ticked ones, as read
(@code{gnus-group-catchup-current-all}).

@item M-c
@kindex M-c (Group)
@findex gnus-group-clear-data
Clear the data from the current group---nix out marks and the list of
read articles (@code{gnus-group-clear-data}).

@item M-x gnus-group-clear-data-on-native-groups
@kindex M-x gnus-group-clear-data-on-native-groups
@findex gnus-group-clear-data-on-native-groups
If you have switched from one @acronym{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.

@end table


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

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

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

@table @kbd

@item S l
@kindex S l (Group)
@findex gnus-group-set-current-level
Set the level of the current group.  If a numeric prefix is given, the
next @var{n} groups will have their levels set.  The user will be
prompted for a level.
@end table

@vindex gnus-level-killed
@vindex gnus-level-zombie
@vindex gnus-level-unsubscribed
@vindex gnus-level-subscribed
Gnus considers groups from levels 1 to
@code{gnus-level-subscribed} (inclusive) (default 5) to be subscribed,
@code{gnus-level-subscribed} (exclusive) and
@code{gnus-level-unsubscribed} (inclusive) (default 7) to be
unsubscribed, @code{gnus-level-zombie} to be zombies (walking dead)
(default 8) and @code{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 @kbd{L} you can have it show
empty subscribed groups and unsubscribed groups, too.  Type @kbd{l} to
go back to showing nonempty subscribed groups again.  Thus, unsubscribed
groups are hidden, in a way.

@cindex zombie groups
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 @kbd{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 @kbd{A z} to get a list of all new groups.  Subscribe
the ones you like and kill the ones you don't want.  (@kbd{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.

@vindex gnus-level-default-unsubscribed
@vindex gnus-level-default-subscribed
Two closely related variables are @code{gnus-level-default-subscribed}
(default 3) and @code{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.

@vindex gnus-keep-same-level
If @code{gnus-keep-same-level} is non-@code{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 @code{best}, Gnus will make the next newsgroup the
one with the best level.

@vindex gnus-group-default-list-level
All groups with a level less than or equal to
@code{gnus-group-default-list-level} will be listed in the group buffer
by default.
This variable can also be a function.  In that case, that function will
be called and the result will be used as value.


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

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

@vindex gnus-activate-level
Gnus will normally just activate (i. e., query the server about) groups
on level @code{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.


@node Group Score
@section Group Score
@cindex group score
@cindex group rank
@cindex rank

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 @dfn{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 @dfn{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.))

@findex gnus-summary-bubble-group
If you want groups you read often to get higher scores than groups you
read seldom you can add the @code{gnus-summary-bubble-group} function to
the @code{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
@code{gnus-group-sort-groups-by-rank} or
@code{gnus-group-sort-groups-by-score} to the same hook, but that will
slow things down somewhat.


@node Marking Groups
@section Marking Groups
@cindex 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.

@table @kbd

@item #
@kindex # (Group)
@itemx M m
@kindex M m (Group)
@findex gnus-group-mark-group
Set the mark on the current group (@code{gnus-group-mark-group}).

@item M-#
@kindex M-# (Group)
@itemx M u
@kindex M u (Group)
@findex gnus-group-unmark-group
Remove the mark from the current group
(@code{gnus-group-unmark-group}).

@item M U
@kindex M U (Group)
@findex gnus-group-unmark-all-groups
Remove the mark from all groups (@code{gnus-group-unmark-all-groups}).

@item M w
@kindex M w (Group)
@findex gnus-group-mark-region
Mark all groups between point and mark (@code{gnus-group-mark-region}).

@item M b
@kindex M b (Group)
@findex gnus-group-mark-buffer
Mark all groups in the buffer (@code{gnus-group-mark-buffer}).

@item M r
@kindex M r (Group)
@findex gnus-group-mark-regexp
Mark all groups that match some regular expression
(@code{gnus-group-mark-regexp}).
@end table

Also @pxref{Process/Prefix}.

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


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

If you recall how to subscribe to servers (@pxref{Finding the News})
you will remember that @code{gnus-secondary-select-methods} and
@code{gnus-select-method} let you write a definition in Emacs Lisp of
what servers you want to see when you start up.  The alternate
approach is to use foreign servers and groups.  ``Foreign'' here means
they are not coming from the select methods.  All foreign server
configuration and subscriptions are stored only in the
@file{~/.newsrc.eld} file.

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---@code{gnus-subscribe-newsgroup-method} is not
consulted.

Changes from the group editing commands are stored in
@file{~/.newsrc.eld} (@code{gnus-startup-file}).  An alternative is the
variable @code{gnus-parameters}, @xref{Group Parameters}.

@table @kbd

@item G m
@kindex G m (Group)
@findex gnus-group-make-group
@cindex making groups
Make a new group (@code{gnus-group-make-group}).  Gnus will prompt you
for a name, a method and possibly an @dfn{address}.  For an easier way
to subscribe to @acronym{NNTP} groups (@pxref{Browse Foreign Server}).

@item G M
@kindex G M (Group)
@findex gnus-group-read-ephemeral-group
Make an ephemeral group (@code{gnus-group-read-ephemeral-group}).  Gnus
will prompt you for a name, a method and an @dfn{address}.

@item G r
@kindex G r (Group)
@findex gnus-group-rename-group
@cindex renaming groups
Rename the current group to something else
(@code{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.

@item G c
@kindex G c (Group)
@cindex customizing
@findex gnus-group-customize
Customize the group parameters (@code{gnus-group-customize}).

@item G e
@kindex G e (Group)
@findex gnus-group-edit-group-method
@cindex renaming groups
Enter a buffer where you can edit the select method of the current
group (@code{gnus-group-edit-group-method}).

@item G p
@kindex G p (Group)
@findex gnus-group-edit-group-parameters
Enter a buffer where you can edit the group parameters
(@code{gnus-group-edit-group-parameters}).

@item G E
@kindex G E (Group)
@findex gnus-group-edit-group
Enter a buffer where you can edit the group info
(@code{gnus-group-edit-group}).

@item G d
@kindex G d (Group)
@findex gnus-group-make-directory-group
@cindex nndir
Make a directory group (@pxref{Directory Groups}).  You will be prompted
for a directory name (@code{gnus-group-make-directory-group}).

@item G h
@kindex G h (Group)
@cindex help group
@findex gnus-group-make-help-group
Make the Gnus help group (@code{gnus-group-make-help-group}).

@item G D
@kindex G D (Group)
@findex gnus-group-enter-directory
@cindex nneething
Read an arbitrary directory as if it were a newsgroup with the
@code{nneething} back end (@code{gnus-group-enter-directory}).
@xref{Anything Groups}.

@item G f
@kindex G f (Group)
@findex gnus-group-make-doc-group
@cindex ClariNet Briefs
@cindex nndoc
Make a group based on some file or other
(@code{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 @code{mbox}, @code{babyl},
@code{digest}, @code{news}, @code{rnews}, @code{mmdf}, @code{forward},
@code{rfc934}, @code{rfc822-forward}, @code{mime-parts},
@code{standard-digest}, @code{slack-digest}, @code{clari-briefs},
@code{nsmail}, @code{outlook}, @code{oe-dbx}, and @code{mailman}.  If
you run this command without a prefix, Gnus will guess at the file
type.  @xref{Document Groups}.

@item G u
@kindex G u (Group)
@vindex gnus-useful-groups
@findex gnus-group-make-useful-group
Create one of the groups mentioned in @code{gnus-useful-groups}
(@code{gnus-group-make-useful-group}).

@item G w
@kindex G w (Group)
@findex gnus-group-make-web-group
@cindex Google
@cindex nnweb
@cindex gmane
Make an ephemeral group based on a web search
(@code{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 @code{google}, @code{dejanews}, and @code{gmane}.
@xref{Web Searches}.

If you use the @code{google} search engine, you can limit the search
to a particular group by using a match string like
@samp{shaving group:alt.sysadmin.recovery}.

@item G R
@kindex G R (Group)
@findex gnus-group-make-rss-group
Make a group based on an @acronym{RSS} feed
(@code{gnus-group-make-rss-group}).  You will be prompted for an URL.
@xref{RSS}.

@item G DEL
@kindex G DEL (Group)
@findex gnus-group-delete-group
This function will delete the current group
(@code{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 @code{nntp} groups), though.

@item G V
@kindex G V (Group)
@findex gnus-group-make-empty-virtual
Make a new, fresh, empty @code{nnvirtual} group
(@code{gnus-group-make-empty-virtual}).  @xref{Virtual Groups}.

@item G v
@kindex G v (Group)
@findex gnus-group-add-to-virtual
Add the current group to an @code{nnvirtual} group
(@code{gnus-group-add-to-virtual}).  Uses the process/prefix convention.
@end table

@xref{Select Methods}, for more information on the various select
methods.

@vindex gnus-activate-foreign-newsgroups
If @code{gnus-activate-foreign-newsgroups} is a positive number,
Gnus will check all foreign groups with this level or lower at startup.
This might take quite a while, especially if you subscribe to lots of
groups from different @acronym{NNTP} servers.  Also @pxref{Group Levels};
@code{gnus-activate-level} also affects activation of foreign
newsgroups.


The following commands create ephemeral groups.  They can be called not
only from the Group buffer, but in any Gnus buffer.

@table @code
@item gnus-read-ephemeral-gmane-group
@findex gnus-read-ephemeral-gmane-group
@vindex gnus-gmane-group-download-format
Read an ephemeral group on Gmane.org.  The articles are downloaded via
HTTP using the URL specified by @code{gnus-gmane-group-download-format}.
Gnus will prompt you for a group name, the start article number and an
the article range.

@item gnus-read-ephemeral-gmane-group-url
@findex gnus-read-ephemeral-gmane-group-url
This command is similar to @code{gnus-read-ephemeral-gmane-group}, but
the group name and the article number and range are constructed from a
given @acronym{URL}.  Supported @acronym{URL} formats include e.g.
@url{http://thread.gmane.org/gmane.foo.bar/12300/focus=12399},
@url{http://thread.gmane.org/gmane.foo.bar/12345/},
@url{http://article.gmane.org/gmane.foo.bar/12345/},
@url{http://permalink.gmane.org/gmane.foo.bar/12345/}, and
@url{http://news.gmane.org/group/gmane.foo.bar/thread=12345}.

@item gnus-read-ephemeral-emacs-bug-group
@findex gnus-read-ephemeral-emacs-bug-group
Read an Emacs bug report in an ephemeral group.  Gnus will prompt for a
bug number.  The default is the number at point.  The @acronym{URL} is
specified in @code{gnus-bug-group-download-format-alist}.

@item gnus-read-ephemeral-debian-bug-group
@findex gnus-read-ephemeral-debian-bug-group
Read a Debian bug report in an ephemeral group.  Analog to
@code{gnus-read-ephemeral-emacs-bug-group}.
@end table

Some of these command are also useful for article buttons, @xref{Article
Buttons}.

Here is an example:
@lisp
(require 'gnus-art)
(add-to-list
 'gnus-button-alist
 '("#\\([0-9]+\\)\\>" 1
   (string-match "\\<emacs\\>" (or gnus-newsgroup-name ""))
   gnus-read-ephemeral-emacs-bug-group 1))
@end lisp


@node Group Parameters
@section Group Parameters
@cindex group parameters

The group parameters store information local to a particular group.

Use the @kbd{G p} or the @kbd{G c} command to edit group parameters of a
group.  (@kbd{G p} presents you with a Lisp-based interface, @kbd{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 (@pxref{Topic Parameters}).
Additionally, you can set group parameters via the
@code{gnus-parameters} variable, see below.

Here's an example group parameter list:

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

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 @emph{except} local variable specs, which are
not dotted pairs, but proper lists.

Some parameters have correspondent customizable variables, each of which
is an alist of regexps and values.

The following group parameters can be used:

@table @code
@item to-address
@cindex to-address
Address used by when doing followups and new posts.

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

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 @code{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
@samp{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.

See also @code{gnus-parameter-to-address-alist}.

@item to-list
@cindex to-list
Address used when doing @kbd{a} in that group.

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

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 @kbd{f}.

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

@findex gnus-mailing-list-mode
@cindex mail list groups
If this variable is set, @code{gnus-mailing-list-mode} is turned on when
entering summary buffer.

See also @code{gnus-parameter-to-list-alist}.

@anchor{subscribed}
@item subscribed
@cindex subscribed
@cindex Mail-Followup-To
@findex gnus-find-subscribed-addresses
If this parameter is set to @code{t}, Gnus will consider the
to-address and to-list parameters for this group as addresses of
mailing lists you are subscribed to.  Giving Gnus this information is
(only) a first step in getting it to generate correct Mail-Followup-To
headers for your posts to these lists.  The second step is to put the
following in your @file{.gnus.el}

@lisp
(setq message-subscribed-address-functions
      '(gnus-find-subscribed-addresses))
@end lisp

@xref{Mailing Lists, ,Mailing Lists, message, The Message Manual}, for
a complete treatment of available MFT support.

@item visible
@cindex visible
If the group parameter list has the element @code{(visible . t)},
that group will always be visible in the Group buffer, regardless
of whether it has any unread articles.

This parameter cannot be set via @code{gnus-parameters}. See
@code{gnus-permanently-visible-groups} as an alternative.

@item broken-reply-to
@cindex broken-reply-to
Elements like @code{(broken-reply-to . t)} signals that @code{Reply-To}
headers in this group are to be ignored, and for the header to be hidden
if @code{reply-to} is part of @code{gnus-boring-article-headers}.  This
can be useful if you're reading a mailing list group where the listserv
has inserted @code{Reply-To} headers that point back to the listserv
itself.  That is broken behavior.  So there!

@item to-group
@cindex to-group
Elements like @code{(to-group . "some.group.name")} means that all
posts in that group will be sent to @code{some.group.name}.

@item newsgroup
@cindex newsgroup
If you have @code{(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.

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

@strong{Caveat}: Adding @code{(gcc-self . t)} to the parameter list of
@code{nntp} groups (or the like) isn't valid.  An @code{nntp} server
doesn't accept articles.

@item auto-expire
@cindex auto-expire
@cindex expiring mail
If the group parameter has an element that looks like @code{(auto-expire
. t)}, all articles read will be marked as expirable.  For an
alternative approach, @pxref{Expiring Mail}.

See also @code{gnus-auto-expirable-newsgroups}.

@item total-expire
@cindex total-expire
@cindex expiring mail
If the group parameter has an element that looks like
@code{(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 @code{gnus-total-expirable-newsgroups}.

@item expiry-wait
@cindex expiry-wait
@vindex nnmail-expiry-wait-function
If the group parameter has an element that looks like
@code{(expiry-wait . 10)}, this value will override any
@code{nnmail-expiry-wait} and @code{nnmail-expiry-wait-function}
(@pxref{Expiring Mail}) when expiring expirable messages.  The value
can either be a number of days (not necessarily an integer) or the
symbols @code{never} or @code{immediate}.

@item expiry-target
@cindex expiry-target
Where expired messages end up.  This parameter overrides
@code{nnmail-expiry-target}.

@item score-file
@cindex score file group parameter
Elements that look like @code{(score-file . "file")} will make
@file{file} into the current score file for the group in question.  All
interactive score entries will be put into this file.

@item adapt-file
@cindex adapt file group parameter
Elements that look like @code{(adapt-file . "file")} will make
@file{file} into the current adaptive file for the group in question.
All adaptive score entries will be put into this file.

@item admin-address
@cindex 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.

@item display
@cindex display
Elements that look like @code{(display . MODE)} say which articles to
display on entering the group.  Valid values are:

@table @code
@item all
Display all articles, both read and unread.

@item an integer
Display the last @var{integer} articles in the group.  This is the same as
entering the group with @kbd{C-u @var{integer}}.

@item default
Display the default visible articles, which normally includes unread and
ticked articles.

@item an array
Display articles that satisfy a predicate.

Here are some examples:

@table @code
@item [unread]
Display only unread articles.

@item [not expire]
Display everything except expirable articles.

@item [and (not reply) (not expire)]
Display everything except expirable and articles you've already
responded to.
@end table

The available operators are @code{not}, @code{and} and @code{or}.
Predicates include @code{tick}, @code{unsend}, @code{undownload},
@code{unread}, @code{dormant}, @code{expire}, @code{reply},
@code{killed}, @code{bookmark}, @code{score}, @code{save},
@code{cache}, @code{forward}, and @code{unseen}.

@end table

The @code{display} parameter works by limiting the summary buffer to
the subset specified.  You can pop the limit by using the @kbd{/ w}
command (@pxref{Limiting}).

@item comment
@cindex comment
Elements that look like @code{(comment . "This is a comment")} are
arbitrary comments on the group.  You can display comments in the
group line (@pxref{Group Line Specification}).

@item charset
@cindex charset
Elements that look like @code{(charset . iso-8859-1)} will make
@code{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 @code{gnus-group-charset-alist}.

@item ignored-charsets
@cindex ignored-charset
Elements that look like @code{(ignored-charsets x-unknown iso-8859-1)}
will make @code{iso-8859-1} and @code{x-unknown} ignored; that is, the
default charset will be used for decoding articles.

See also @code{gnus-group-ignored-charsets-alist}.

@item posting-style
@cindex posting-style
You can store additional posting style information for this group
here (@pxref{Posting Styles}).  The format is that of an entry in the
@code{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 @code{gnus-posting-styles}.

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

@example
(posting-style
  (name "Funky Name")
  ("X-My-Header" "Funky Value")
  (signature "Funky Signature"))
@end example

If you're using topics to organize your group buffer
(@pxref{Group Topics}), note that posting styles can also be set in
the topics parameters. Posting styles in topic parameters apply to all
groups in this topic. More precisely, the posting-style settings for a
group result from the hierarchical merging of all posting-style
entries in the parameters of this group and all the topics it belongs
to.


@item post-method
@cindex post-method
If it is set, the value is used as the method for posting message
instead of @code{gnus-post-method}.

@item mail-source
@cindex mail-source
If it is set, and the setting of @code{mail-sources} includes a
@code{group} mail source (@pxref{Mail Sources}), the value is a
mail source for this group.

@item banner
@cindex banner
An item like @code{(banner . @var{regexp})} causes any part of an article
that matches the regular expression @var{regexp} to be stripped.  Instead of
@var{regexp}, you can also use the symbol @code{signature} which strips the
last signature or any of the elements of the alist
@code{gnus-article-banner-alist}.

@item sieve
@cindex sieve
This parameter contains a Sieve test that should match incoming mail
that should be placed in this group.  From this group parameter, a
Sieve @samp{IF} control structure is generated, having the test as the
condition and @samp{fileinto "group.name";} as the body.

For example, if the @samp{INBOX.list.sieve} group has the @code{(sieve
address "sender" "sieve-admin@@extundo.com")} group parameter, when
translating the group parameter into a Sieve script (@pxref{Sieve
Commands}) the following Sieve code is generated:

@example
if address "sender" "sieve-admin@@extundo.com" @{
        fileinto "INBOX.list.sieve";
@}
@end example

To generate tests for multiple email-addresses use a group parameter
like @code{(sieve address "sender" ("name@@one.org" else@@two.org"))}.
When generating a sieve script (@pxref{Sieve Commands}) Sieve code
like the following is generated:

@example
if address "sender" ["name@@one.org", "else@@two.org"] @{
        fileinto "INBOX.list.sieve";
@}
@end example

See @pxref{Sieve Commands} for commands and variables that might be of
interest in relation to the sieve parameter.

The Sieve language is described in RFC 3028.  @xref{Top, Emacs Sieve,
Top, sieve, Emacs Sieve}.

@item (agent parameters)
If the agent has been enabled, you can set any of its parameters to
control the behavior of the agent in individual groups.  See Agent
Parameters in @ref{Category Syntax}.  Most users will choose to set
agent parameters in either an agent category or group topic to
minimize the configuration effort.

@item (@var{variable} @var{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 @samp{news.answers},
you could put @code{(gnus-show-threads nil)} in the group parameters of
that group.  @code{gnus-show-threads} will be made into a local variable
in the summary buffer you enter, and the form @code{nil} will be
@code{eval}ed there.

Note that this feature sets the variable locally to the summary buffer
if and only if @var{variable} has been bound as a variable.  Otherwise,
only evaluating the form will take place.  So, you may want to bind the
variable in advance using @code{defvar} or other if the result of the
form needs to be set to it.

But some variables are evaluated in the article buffer, or in the
message buffer (of a reply or followup or otherwise newly created
message).  As a workaround, it might help to add the variable in
question to @code{gnus-newsgroup-variables}.  @xref{Various Summary
Stuff}.  So if you want to set @code{message-from-style} via the group
parameters, then you may need the following statement elsewhere in your
@file{~/.gnus.el} file:

@lisp
(add-to-list 'gnus-newsgroup-variables 'message-from-style)
@end lisp

@vindex gnus-list-identifiers
A use for this feature is to remove a mailing list identifier tag in
the subject fields of articles.  E.g. if the news group

@example
nntp+news.gnus.org:gmane.text.docbook.apps
@end example

has the tag @samp{DOC-BOOK-APPS:} in the subject of all articles, this
tag can be removed from the article subjects in the summary buffer for
the group by putting @code{(gnus-list-identifiers "DOCBOOK-APPS:")}
into the group parameters for the group.

This can also be used as a group-specific hook function.  If you want to
hear a beep when you enter a group, you could put something like
@code{(dummy-variable (ding))} in the parameters of that group.  If
@code{dummy-variable} has been bound (see above), it will be set to the
(meaningless) result of the @code{(ding)} form.

Alternatively, since the VARIABLE becomes local to the group, this
pattern can be used to temporarily change a hook.  For example, if the
following is added to a group parameter

@lisp
(gnus-summary-prepared-hook
  '(lambda nil (local-set-key "d" (local-key-binding "n"))))
@end lisp

when the group is entered, the 'd' key will not mark the article as
expired.

@end table

@vindex gnus-parameters
Group parameters can be set via the @code{gnus-parameters} variable too.
But some variables, such as @code{visible}, have no effect (For this
case see @code{gnus-permanently-visible-groups} as an alternative.).
For example:

@lisp
(setq gnus-parameters
      '(("mail\\..*"
         (gnus-show-threads nil)
         (gnus-use-scoring nil)
         (gnus-summary-line-format
          "%U%R%z%I%(%[%d:%ub%-23,23f%]%) %s\n")
         (gcc-self . t)
         (display . all))

        ("^nnimap:\\(foo.bar\\)$"
         (to-group . "\\1"))

        ("mail\\.me"
         (gnus-use-scoring t))

        ("list\\..*"
         (total-expire . t)
         (broken-reply-to . t))))
@end lisp

All clauses that matches the group name will be used, but the last
setting ``wins''.  So if you have two clauses that both match the
group name, and both set, say @code{display}, the last setting will
override the first.

Parameters that are strings will be subjected to regexp substitution,
as the @code{to-group} example shows.

@vindex gnus-parameters-case-fold-search
By default, whether comparing the group name and one of those regexps
specified in @code{gnus-parameters} is done in a case-sensitive manner
or a case-insensitive manner depends on the value of
@code{case-fold-search} at the time when the comparison is done.  The
value of @code{case-fold-search} is typically @code{t}; it means, for
example, the element @code{("INBOX\\.FOO" (total-expire . t))} might be
applied to both the @samp{INBOX.FOO} group and the @samp{INBOX.foo}
group.  If you want to make those regexps always case-sensitive, set the
value of the @code{gnus-parameters-case-fold-search} variable to
@code{nil}.  Otherwise, set it to @code{t} if you want to compare them
always in a case-insensitive manner.

You can define different sorting to different groups via
@code{gnus-parameters}.  Here is an example to sort an @acronym{NNTP}
group by reverse date to see the latest news at the top and an
@acronym{RSS} group by subject.  In this example, the first group is the
Debian daily news group @code{gmane.linux.debian.user.news} from
news.gmane.org.  The @acronym{RSS} group corresponds to the Debian
weekly news RSS feed
@url{http://packages.debian.org/unstable/newpkg_main.en.rdf},
@xref{RSS}.

@lisp
(setq
 gnus-parameters
 '(("nntp.*gmane\\.debian\\.user\\.news"
    (gnus-show-threads nil)
    (gnus-article-sort-functions '((not gnus-article-sort-by-date)))
    (gnus-use-adaptive-scoring nil)
    (gnus-use-scoring nil))
   ("nnrss.*debian"
    (gnus-show-threads nil)
    (gnus-article-sort-functions 'gnus-article-sort-by-subject)
    (gnus-use-adaptive-scoring nil)
    (gnus-use-scoring t)
    (gnus-score-find-score-files-function 'gnus-score-find-single)
    (gnus-summary-line-format "%U%R%z%d %I%(%[ %s %]%)\n"))))
@end lisp


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

These commands all list various slices of the groups available.

@table @kbd

@item l
@itemx A s
@kindex A s (Group)
@kindex l (Group)
@findex gnus-group-list-groups
List all groups that have unread articles
(@code{gnus-group-list-groups}).  If the numeric prefix is used, this
command will list only groups of level ARG and lower.  By default, it
only lists groups of level five (i.e.,
@code{gnus-group-default-list-level}) or lower (i.e., just subscribed
groups).

@item L
@itemx A u
@kindex A u (Group)
@kindex L (Group)
@findex gnus-group-list-all-groups
List all groups, whether they have unread articles or not
(@code{gnus-group-list-all-groups}).  If the numeric prefix is used,
this command will list only groups of level ARG and lower.  By default,
it lists groups of level seven or lower (i.e., just subscribed and
unsubscribed groups).

@item A l
@kindex A l (Group)
@findex gnus-group-list-level
List all unread groups on a specific level
(@code{gnus-group-list-level}).  If given a prefix, also list the groups
with no unread articles.

@item A k
@kindex A k (Group)
@findex gnus-group-list-killed
List all killed groups (@code{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.

@item A z
@kindex A z (Group)
@findex gnus-group-list-zombies
List all zombie groups (@code{gnus-group-list-zombies}).

@item A m
@kindex A m (Group)
@findex gnus-group-list-matching
List all unread, subscribed groups with names that match a regexp
(@code{gnus-group-list-matching}).

@item A M
@kindex A M (Group)
@findex gnus-group-list-all-matching
List groups that match a regexp (@code{gnus-group-list-all-matching}).

@item A A
@kindex A A (Group)
@findex gnus-group-list-active
List absolutely all groups in the active file(s) of the
server(s) you are connected to (@code{gnus-group-list-active}).  This
might very well take quite a while.  It might actually be a better idea
to do a @kbd{A M} to list all matching, and just give @samp{.} 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.

@item A a
@kindex A a (Group)
@findex gnus-group-apropos
List all groups that have names that match a regexp
(@code{gnus-group-apropos}).

@item A d
@kindex A d (Group)
@findex gnus-group-description-apropos
List all groups that have names or descriptions that match a regexp
(@code{gnus-group-description-apropos}).

@item A c
@kindex A c (Group)
@findex gnus-group-list-cached
List all groups with cached articles (@code{gnus-group-list-cached}).

@item A ?
@kindex A ? (Group)
@findex gnus-group-list-dormant
List all groups with dormant articles (@code{gnus-group-list-dormant}).

@item A !
@kindex A ! (Group)
@findex gnus-group-list-ticked
List all groups with ticked articles (@code{gnus-group-list-ticked}).

@item A /
@kindex A / (Group)
@findex gnus-group-list-limit
Further limit groups within the current selection
(@code{gnus-group-list-limit}).  If you've first limited to groups
with dormant articles with @kbd{A ?}, you can then further limit with
@kbd{A / c}, which will then limit to groups with cached articles,
giving you the groups that have both dormant articles and cached
articles.

@item A f
@kindex A f (Group)
@findex gnus-group-list-flush
Flush groups from the current selection (@code{gnus-group-list-flush}).

@item A p
@kindex A p (Group)
@findex gnus-group-list-plus
List groups plus the current selection (@code{gnus-group-list-plus}).

@end table

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

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


@node Sorting Groups
@section Sorting Groups
@cindex sorting groups

@kindex C-c C-s (Group)
@findex gnus-group-sort-groups
@vindex gnus-group-sort-function
The @kbd{C-c C-s} (@code{gnus-group-sort-groups}) command sorts the
group buffer according to the function(s) given by the
@code{gnus-group-sort-function} variable.  Available sorting functions
include:

@table @code

@item gnus-group-sort-by-alphabet
@findex gnus-group-sort-by-alphabet
Sort the group names alphabetically.  This is the default.

@item gnus-group-sort-by-real-name
@findex gnus-group-sort-by-real-name
Sort the group alphabetically on the real (unprefixed) group names.

@item gnus-group-sort-by-level
@findex gnus-group-sort-by-level
Sort by group level.

@item gnus-group-sort-by-score
@findex gnus-group-sort-by-score
Sort by group score.  @xref{Group Score}.

@item gnus-group-sort-by-rank
@findex 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 @dfn{rank}.  @xref{Group Score}.

@item gnus-group-sort-by-unread
@findex gnus-group-sort-by-unread
Sort by number of unread articles.

@item gnus-group-sort-by-method
@findex gnus-group-sort-by-method
Sort alphabetically on the select method.

@item gnus-group-sort-by-server
@findex gnus-group-sort-by-server
Sort alphabetically on the Gnus server name.


@end table

@code{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:

@table @kbd
@item G S a
@kindex G S a (Group)
@findex gnus-group-sort-groups-by-alphabet
Sort the group buffer alphabetically by group name
(@code{gnus-group-sort-groups-by-alphabet}).

@item G S u
@kindex G S u (Group)
@findex gnus-group-sort-groups-by-unread
Sort the group buffer by the number of unread articles
(@code{gnus-group-sort-groups-by-unread}).

@item G S l
@kindex G S l (Group)
@findex gnus-group-sort-groups-by-level
Sort the group buffer by group level
(@code{gnus-group-sort-groups-by-level}).

@item G S v
@kindex G S v (Group)
@findex gnus-group-sort-groups-by-score
Sort the group buffer by group score
(@code{gnus-group-sort-groups-by-score}).  @xref{Group Score}.

@item G S r
@kindex G S r (Group)
@findex gnus-group-sort-groups-by-rank
Sort the group buffer by group rank
(@code{gnus-group-sort-groups-by-rank}).  @xref{Group Score}.

@item G S m
@kindex G S m (Group)
@findex gnus-group-sort-groups-by-method
Sort the group buffer alphabetically by back end name@*
(@code{gnus-group-sort-groups-by-method}).

@item G S n
@kindex G S n (Group)
@findex gnus-group-sort-groups-by-real-name
Sort the group buffer alphabetically by real (unprefixed) group name
(@code{gnus-group-sort-groups-by-real-name}).

@end table

All the commands below obey the process/prefix convention
(@pxref{Process/Prefix}).

When given a symbolic prefix (@pxref{Symbolic Prefixes}), all these
commands will sort in reverse order.

You can also sort a subset of the groups:

@table @kbd
@item G P a
@kindex G P a (Group)
@findex gnus-group-sort-selected-groups-by-alphabet
Sort the groups alphabetically by group name
(@code{gnus-group-sort-selected-groups-by-alphabet}).

@item G P u
@kindex G P u (Group)
@findex gnus-group-sort-selected-groups-by-unread
Sort the groups by the number of unread articles
(@code{gnus-group-sort-selected-groups-by-unread}).

@item G P l
@kindex G P l (Group)
@findex gnus-group-sort-selected-groups-by-level
Sort the groups by group level
(@code{gnus-group-sort-selected-groups-by-level}).

@item G P v
@kindex G P v (Group)
@findex gnus-group-sort-selected-groups-by-score
Sort the groups by group score
(@code{gnus-group-sort-selected-groups-by-score}).  @xref{Group Score}.

@item G P r
@kindex G P r (Group)
@findex gnus-group-sort-selected-groups-by-rank
Sort the groups by group rank
(@code{gnus-group-sort-selected-groups-by-rank}).  @xref{Group Score}.

@item G P m
@kindex G P m (Group)
@findex gnus-group-sort-selected-groups-by-method
Sort the groups alphabetically by back end name@*
(@code{gnus-group-sort-selected-groups-by-method}).

@item G P n
@kindex G P n (Group)
@findex gnus-group-sort-selected-groups-by-real-name
Sort the groups alphabetically by real (unprefixed) group name
(@code{gnus-group-sort-selected-groups-by-real-name}).

@item G P s
@kindex G P s (Group)
@findex gnus-group-sort-selected-groups
Sort the groups according to @code{gnus-group-sort-function}.

@end table

And finally, note that you can use @kbd{C-k} and @kbd{C-y} to manually
move groups around.


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

@table @kbd
@item b
@kindex b (Group)
@findex gnus-group-check-bogus-groups
Find bogus groups and delete them
(@code{gnus-group-check-bogus-groups}).

@item F
@kindex F (Group)
@findex gnus-group-find-new-groups
Find new groups and process them (@code{gnus-group-find-new-groups}).
With 1 @kbd{C-u}, use the @code{ask-server} method to query the server
for new groups.  With 2 @kbd{C-u}'s, use most complete method possible
to query the server for new groups, and subscribe the new groups as
zombies.

@item C-c C-x
@kindex C-c C-x (Group)
@findex gnus-group-expire-articles
@cindex expiring mail
Run all expirable articles in the current group through the expiry
process (if any) (@code{gnus-group-expire-articles}).  That is, delete
all expirable articles in the group that have been around for a while.
(@pxref{Expiring Mail}).

@item C-c C-M-x
@kindex C-c C-M-x (Group)
@findex gnus-group-expire-all-groups
@cindex expiring mail
Run all expirable articles in all groups through the expiry process
(@code{gnus-group-expire-all-groups}).

@end table


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

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

@findex gnus-browse-mode
A new buffer with a list of available groups will appear.  This buffer
will use the @code{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:

@table @kbd
@item n
@kindex n (Browse)
@findex gnus-group-next-group
Go to the next group (@code{gnus-group-next-group}).

@item p
@kindex p (Browse)
@findex gnus-group-prev-group
Go to the previous group (@code{gnus-group-prev-group}).

@item SPACE
@kindex SPACE (Browse)
@findex gnus-browse-read-group
Enter the current group and display the first article
(@code{gnus-browse-read-group}).

@item RET
@kindex RET (Browse)
@findex gnus-browse-select-group
Enter the current group (@code{gnus-browse-select-group}).

@item u
@kindex u (Browse)
@findex gnus-browse-unsubscribe-current-group
@vindex gnus-browse-subscribe-newsgroup-method
Unsubscribe to the current group, or, as will be the case here,
subscribe to it (@code{gnus-browse-unsubscribe-current-group}).  You
can affect the way the new group is entered into the Group buffer
using the variable @code{gnus-browse-subscribe-newsgroup-method}.  See
@pxref{Subscription Methods} for available options.

@item l
@itemx q
@kindex q (Browse)
@kindex l (Browse)
@findex gnus-browse-exit
Exit browse mode (@code{gnus-browse-exit}).

@item d
@kindex d (Browse)
@findex gnus-browse-describe-group
Describe the current group (@code{gnus-browse-describe-group}).

@item ?
@kindex ? (Browse)
@findex gnus-browse-describe-briefly
Describe browse mode briefly (well, there's not much to describe, is
there) (@code{gnus-browse-describe-briefly}).
@end table


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

Yes, Gnus is ex(c)iting.

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

@item q
@kindex q (Group)
@findex gnus-group-exit
@c @icon{gnus-group-exit}
Quit Gnus (@code{gnus-group-exit}).

@item Q
@kindex Q (Group)
@findex gnus-group-quit
Quit Gnus without saving the @file{.newsrc} files (@code{gnus-group-quit}).
The dribble file will be saved, though (@pxref{Auto Save}).
@end table

@vindex gnus-exit-gnus-hook
@vindex gnus-suspend-gnus-hook
@vindex gnus-after-exiting-gnus-hook
@code{gnus-suspend-gnus-hook} is called when you suspend Gnus and
@code{gnus-exit-gnus-hook} is called when you quit Gnus, while
@code{gnus-after-exiting-gnus-hook} is called as the final item when
exiting Gnus.

Note:

@quotation
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.
@end quotation


@node Group Topics
@section Group Topics
@cindex 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!

@iftex
@iflatex
\gnusfigure{Group Topics}{400}{
\put(75,50){\epsfig{figure=ps/group-topic,height=9cm}}
}
@end iflatex
@end iftex

Here's an example:

@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
@end example

@findex gnus-topic-mode
@kindex t (Group)
To get this @emph{fab} functionality you simply turn on (ooh!) the
@code{gnus-topic} minor mode---type @kbd{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@dots{} Nice tune, that@dots{} la la la@dots{} What, you're back?
Yes, and now press @kbd{l}.  There.  All your groups are now listed
under @samp{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.  Put the following line in your
@file{~/.gnus.el} file:

@lisp
(add-hook 'gnus-group-mode-hook 'gnus-topic-mode)
@end lisp

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


@node Topic Commands
@subsection Topic Commands
@cindex topic commands

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

In general, the following kinds of operations are possible on topics.
First of all, you want to create topics.  Secondly, you want to put
groups in topics and to move them around until you have an order you
like.  The third kind of operation is to show/hide parts of the whole
shebang.  You might want to hide a topic including its subtopics and
groups, to get a better overview of the other groups.

Here is a list of the basic keys that you might need to set up topics
the way you like.

@table @kbd

@item T n
@kindex T n (Topic)
@findex gnus-topic-create-topic
Prompt for a new topic name and create it
(@code{gnus-topic-create-topic}).

@item T TAB
@itemx TAB
@kindex T TAB (Topic)
@kindex TAB (Topic)
@findex gnus-topic-indent
``Indent'' the current topic so that it becomes a sub-topic of the
previous topic (@code{gnus-topic-indent}).  If given a prefix,
``un-indent'' the topic instead.

@item M-TAB
@kindex M-TAB (Topic)
@findex gnus-topic-unindent
``Un-indent'' the current topic so that it becomes a sub-topic of the
parent of its current parent (@code{gnus-topic-unindent}).

@end table

The following two keys can be used to move groups and topics around.
They work like the well-known cut and paste.  @kbd{C-k} is like cut and
@kbd{C-y} is like paste.  Of course, this being Emacs, we use the terms
kill and yank rather than cut and paste.

@table @kbd

@item C-k
@kindex C-k (Topic)
@findex gnus-topic-kill-group
Kill a group or topic (@code{gnus-topic-kill-group}).  All groups in the
topic will be removed along with the topic.

@item C-y
@kindex C-y (Topic)
@findex gnus-topic-yank-group
Yank the previously killed group or topic
(@code{gnus-topic-yank-group}).  Note that all topics will be yanked
before all groups.

So, to move a topic to the beginning of the list of topics, just hit
@kbd{C-k} on it.  This is like the ``cut'' part of cut and paste.  Then,
move the cursor to the beginning of the buffer (just below the ``Gnus''
topic) and hit @kbd{C-y}.  This is like the ``paste'' part of cut and
paste.  Like I said -- E-Z.

You can use @kbd{C-k} and @kbd{C-y} on groups as well as on topics.  So
you can move topics around as well as groups.

@end table

After setting up the topics the way you like them, you might wish to
hide a topic, or to show it again.  That's why we have the following
key.

@table @kbd

@item RET
@kindex RET (Topic)
@findex gnus-topic-select-group
@itemx SPACE
Either select a group or fold a topic (@code{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.

@end table

Now for a list of other commands, in no particular order.

@table @kbd

@item T m
@kindex T m (Topic)
@findex gnus-topic-move-group
Move the current group to some other topic
(@code{gnus-topic-move-group}).  This command uses the process/prefix
convention (@pxref{Process/Prefix}).

@item T j
@kindex T j (Topic)
@findex gnus-topic-jump-to-topic
Go to a topic (@code{gnus-topic-jump-to-topic}).

@item T c
@kindex T c (Topic)
@findex gnus-topic-copy-group
Copy the current group to some other topic
(@code{gnus-topic-copy-group}).  This command uses the process/prefix
convention (@pxref{Process/Prefix}).

@item T h
@kindex T h (Topic)
@findex gnus-topic-hide-topic
Hide the current topic (@code{gnus-topic-hide-topic}).  If given
a prefix, hide the topic permanently.

@item T s
@kindex T s (Topic)
@findex gnus-topic-show-topic
Show the current topic (@code{gnus-topic-show-topic}).  If given
a prefix, show the topic permanently.

@item T D
@kindex T D (Topic)
@findex gnus-topic-remove-group
Remove a group from the current topic (@code{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
(@pxref{Process/Prefix}).

@item T M
@kindex T M (Topic)
@findex gnus-topic-move-matching
Move all groups that match some regular expression to a topic
(@code{gnus-topic-move-matching}).

@item T C
@kindex T C (Topic)
@findex gnus-topic-copy-matching
Copy all groups that match some regular expression to a topic
(@code{gnus-topic-copy-matching}).

@item T H
@kindex T H (Topic)
@findex gnus-topic-toggle-display-empty-topics
Toggle hiding empty topics
(@code{gnus-topic-toggle-display-empty-topics}).

@item T #
@kindex T # (Topic)
@findex gnus-topic-mark-topic
Mark all groups in the current topic with the process mark
(@code{gnus-topic-mark-topic}).  This command works recursively on
sub-topics unless given a prefix.

@item T M-#
@kindex T M-# (Topic)
@findex gnus-topic-unmark-topic
Remove the process mark from all groups in the current topic
(@code{gnus-topic-unmark-topic}).  This command works recursively on
sub-topics unless given a prefix.

@item C-c C-x
@kindex C-c C-x (Topic)
@findex gnus-topic-expire-articles
@cindex expiring mail
Run all expirable articles in the current group or topic through the
expiry process (if any)
(@code{gnus-topic-expire-articles}).  (@pxref{Expiring Mail}).

@item T r
@kindex T r (Topic)
@findex gnus-topic-rename
Rename a topic (@code{gnus-topic-rename}).

@item T DEL
@kindex T DEL (Topic)
@findex gnus-topic-delete
Delete an empty topic (@code{gnus-topic-delete}).

@item A T
@kindex A T (Topic)
@findex gnus-topic-list-active
List all groups that Gnus knows about in a topics-ified way
(@code{gnus-topic-list-active}).

@item T M-n
@kindex T M-n (Topic)
@findex gnus-topic-goto-next-topic
Go to the next topic (@code{gnus-topic-goto-next-topic}).

@item T M-p
@kindex T M-p (Topic)
@findex gnus-topic-goto-previous-topic
Go to the previous topic (@code{gnus-topic-goto-previous-topic}).

@item G p
@kindex G p (Topic)
@findex gnus-topic-edit-parameters
@cindex group parameters
@cindex topic parameters
@cindex parameters
Edit the topic parameters (@code{gnus-topic-edit-parameters}).
@xref{Topic Parameters}.

@end table


@node Topic Variables
@subsection Topic Variables
@cindex topic variables

The previous section told you how to tell Gnus which topics to display.
This section explains how to tell Gnus what to display about each topic.

@vindex gnus-topic-line-format
The topic lines themselves are created according to the
@code{gnus-topic-line-format} variable (@pxref{Formatting Variables}).
Valid elements are:

@table @samp
@item i
Indentation.
@item n
Topic name.
@item v
Visibility.
@item l
Level.
@item g
Number of groups in the topic.
@item a
Number of unread articles in the topic.
@item A
Number of unread articles in the topic and all its subtopics.
@end table

@vindex gnus-topic-indent-level
Each sub-topic (and the groups in the sub-topics) will be indented with
@code{gnus-topic-indent-level} times the topic level number of spaces.
The default is 2.

@vindex gnus-topic-mode-hook
@code{gnus-topic-mode-hook} is called in topic minor mode buffers.

@vindex gnus-topic-display-empty-topics
The @code{gnus-topic-display-empty-topics} says whether to display even
topics that have no unread articles in them.  The default is @code{t}.


@node Topic Sorting
@subsection Topic Sorting
@cindex topic sorting

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


@table @kbd
@item T S a
@kindex T S a (Topic)
@findex gnus-topic-sort-groups-by-alphabet
Sort the current topic alphabetically by group name
(@code{gnus-topic-sort-groups-by-alphabet}).

@item T S u
@kindex T S u (Topic)
@findex gnus-topic-sort-groups-by-unread
Sort the current topic by the number of unread articles
(@code{gnus-topic-sort-groups-by-unread}).

@item T S l
@kindex T S l (Topic)
@findex gnus-topic-sort-groups-by-level
Sort the current topic by group level
(@code{gnus-topic-sort-groups-by-level}).

@item T S v
@kindex T S v (Topic)
@findex gnus-topic-sort-groups-by-score
Sort the current topic by group score
(@code{gnus-topic-sort-groups-by-score}).  @xref{Group Score}.

@item T S r
@kindex T S r (Topic)
@findex gnus-topic-sort-groups-by-rank
Sort the current topic by group rank
(@code{gnus-topic-sort-groups-by-rank}).  @xref{Group Score}.

@item T S m
@kindex T S m (Topic)
@findex gnus-topic-sort-groups-by-method
Sort the current topic alphabetically by back end name
(@code{gnus-topic-sort-groups-by-method}).

@item T S e
@kindex T S e (Topic)
@findex gnus-topic-sort-groups-by-server
Sort the current topic alphabetically by server name
(@code{gnus-topic-sort-groups-by-server}).

@item T S s
@kindex T S s (Topic)
@findex gnus-topic-sort-groups
Sort the current topic according to the function(s) given by the
@code{gnus-group-sort-function} variable
(@code{gnus-topic-sort-groups}).

@end table

When given a prefix argument, all these commands will sort in reverse
order.  @xref{Sorting Groups}, for more information about group
sorting.


@node Topic Topology
@subsection Topic Topology
@cindex topic topology
@cindex topology

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

@example
@group
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
@end group
@end example

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

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

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

This topology shows what topics are sub-topics of what topics (right),
and which topics are visible.  Two settings are currently
allowed---@code{visible} and @code{invisible}.


@node Topic Parameters
@subsection Topic Parameters
@cindex topic parameters

All groups in a topic will inherit group parameters from the parent
(and ancestor) topic parameters.  All valid group parameters are valid
topic parameters (@pxref{Group Parameters}).  When the agent is
enabled, all agent parameters (See Agent Parameters in @ref{Category
Syntax}) are also valid topic parameters.

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

@table @code
@item subscribe
When subscribing new groups by topic (@pxref{Subscription Methods}), the
@code{subscribe} topic parameter says what groups go in what topic.  Its
value should be a regexp to match the groups that should go in that
topic.

@item subscribe-level
When subscribing new groups by topic (see the @code{subscribe} parameter),
the group will be subscribed with the level specified in the
@code{subscribe-level} instead of @code{gnus-level-default-subscribed}.

@end table

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

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

The @samp{Emacs} topic has the topic parameter @code{(score-file
. "emacs.SCORE")}; the @samp{Relief} topic has the topic parameter
@code{(score-file . "relief.SCORE")}; and the @samp{Misc} topic has the
topic parameter @code{(score-file . "emacs.SCORE")}.  In addition,
@* @samp{alt.religion.emacs} has the group parameter @code{(score-file
. "religion.SCORE")}.

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

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


@node Non-ASCII Group Names
@section Accessing groups of non-English names
@cindex non-ascii group names

There are some news servers that provide groups of which the names are
expressed with their native languages in the world.  For instance, in a
certain news server there are some newsgroups of which the names are
spelled in Chinese, where people are talking in Chinese.  You can, of
course, subscribe to such news groups using Gnus.  Currently Gnus
supports non-@acronym{ASCII} group names not only with the @code{nntp}
back end but also with the @code{nnml} back end and the @code{nnrss}
back end.

Every such group name is encoded by a certain charset in the server
side (in an @acronym{NNTP} server its administrator determines the
charset, but for groups in the other back ends it is determined by you).
Gnus has to display the decoded ones for you in the group buffer and the
article buffer, and needs to use the encoded ones when communicating
with servers.  However, Gnus doesn't know what charset is used for each
non-@acronym{ASCII} group name.  The following two variables are just
the ones for telling Gnus what charset should be used for each group:

@table @code
@item gnus-group-name-charset-method-alist
@vindex gnus-group-name-charset-method-alist
An alist of select methods and charsets.  The default value is
@code{nil}.  The names of groups in the server specified by that select
method are all supposed to use the corresponding charset.  For example:

@lisp
(setq gnus-group-name-charset-method-alist
      '(((nntp "news.com.cn") . cn-gb-2312)))
@end lisp

Charsets specified for groups with this variable are preferred to the
ones specified for the same groups with the
@code{gnus-group-name-charset-group-alist} variable (see below).

A select method can be very long, like:

@lisp
(nntp "gmane"
      (nntp-address "news.gmane.org")
      (nntp-end-of-line "\n")
      (nntp-open-connection-function
       nntp-open-via-rlogin-and-telnet)
      (nntp-via-rlogin-command "ssh")
      (nntp-via-rlogin-command-switches
       ("-C" "-t" "-e" "none"))
      (nntp-via-address @dots{}))
@end lisp

In that case, you can truncate it into @code{(nntp "gmane")} in this
variable.  That is, it is enough to contain only the back end name and
the server name.

@item gnus-group-name-charset-group-alist
@cindex UTF-8 group names
@vindex gnus-group-name-charset-group-alist
An alist of regexp of group name and the charset for group names.
@code{((".*" . utf-8))} is the default value if UTF-8 is supported,
otherwise the default is @code{nil}.  For example:

@lisp
(setq gnus-group-name-charset-group-alist
      '(("\\.com\\.cn:" . cn-gb-2312)
        (".*" . utf-8)))
@end lisp

Note that this variable is ignored if the match is made with
@code{gnus-group-name-charset-method-alist}.
@end table

Those two variables are used also to determine the charset for encoding
and decoding non-@acronym{ASCII} group names that are in the back ends
other than @code{nntp}.  It means that it is you who determine it.  If
you do nothing, the charset used for group names in those back ends will
all be @code{utf-8} because of the last element of
@code{gnus-group-name-charset-group-alist}.

There is one more important variable for non-@acronym{ASCII} group
names:

@table @code
@item nnmail-pathname-coding-system
@vindex nnmail-pathname-coding-system
The value of this variable should be a coding system or @code{nil}.  The
default is @code{nil} in Emacs, or is the aliasee of the coding system
named @code{file-name} (a certain coding system of which an alias is
@code{file-name}) in XEmacs.

The @code{nnml} back end, the @code{nnrss} back end, the @acronym{NNTP}
marks feature (@pxref{NNTP marks}), the agent, and the cache use
non-@acronym{ASCII} group names in those files and directories.  This
variable overrides the value of @code{file-name-coding-system} which
specifies the coding system used when encoding and decoding those file
names and directory names.

In XEmacs (with the @code{mule} feature), @code{file-name-coding-system}
is the only means to specify the coding system used to encode and decode
file names.  On the other hand, Emacs uses the value of
@code{default-file-name-coding-system} if @code{file-name-coding-system}
is @code{nil} or it is bound to the value of
@code{nnmail-pathname-coding-system} which is @code{nil}.

Normally the value of @code{default-file-name-coding-system} in Emacs or
@code{nnmail-pathname-coding-system} in XEmacs is initialized according
to the locale, so you will need to do nothing if the value is suitable
to encode and decode non-@acronym{ASCII} group names.

The value of this variable (or @code{default-file-name-coding-system})
does not necessarily need to be the same value that is determined by
@code{gnus-group-name-charset-method-alist} and
@code{gnus-group-name-charset-group-alist}.

If @code{default-file-name-coding-system} or this variable is
initialized by default to @code{iso-latin-1} for example, although you
want to subscribe to the groups spelled in Chinese, that is the most
typical case where you have to customize
@code{nnmail-pathname-coding-system}.  The @code{utf-8} coding system is
a good candidate for it.  Otherwise, you may change the locale in your
system so that @code{default-file-name-coding-system} or this variable
may be initialized to an appropriate value.
@end table

Note that when you copy or move articles from a non-@acronym{ASCII}
group to another group, the charset used to encode and decode group
names should be the same in both groups.  Otherwise the Newsgroups
header will be displayed incorrectly in the article buffer.


@node Misc Group Stuff
@section Misc Group Stuff

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

@table @kbd

@item v
@kindex v (Group)
@cindex keys, reserved for users (Group)
The key @kbd{v} is reserved for users.  You can bind it to some
command or better use it as a prefix key.  For example:

@lisp
(define-key gnus-group-mode-map (kbd "v j d")
  (lambda ()
    (interactive)
    (gnus-group-jump-to-group "nndraft:drafts")))
@end lisp

On keys reserved for users in Emacs and on keybindings in general
@xref{Keymaps, Keymaps, , emacs, The Emacs Editor}.

@item ^
@kindex ^ (Group)
@findex gnus-group-enter-server-mode
Enter the server buffer (@code{gnus-group-enter-server-mode}).
@xref{Server Buffer}.

@item a
@kindex a (Group)
@findex gnus-group-post-news
Start composing a message (a news by default)
(@code{gnus-group-post-news}).  If given a prefix, post to the group
under the point.  If the prefix is 1, prompt for a group to post to.
Contrary to what the name of this function suggests, the prepared
article might be a mail instead of a news, if a mail group is specified
with the prefix argument.  @xref{Composing Messages}.

@item m
@kindex m (Group)
@findex gnus-group-mail
Mail a message somewhere (@code{gnus-group-mail}).  If given a prefix,
use the posting style of the group under the point.  If the prefix is 1,
prompt for a group name to find the posting style.
@xref{Composing Messages}.

@item i
@kindex i (Group)
@findex gnus-group-news
Start composing a news (@code{gnus-group-news}).  If given a prefix,
post to the group under the point.  If the prefix is 1, prompt
for group to post to.  @xref{Composing Messages}.

This function actually prepares a news even when using mail groups.
This is useful for ``posting'' messages to mail groups without actually
sending them over the network: they're just saved directly to the group
in question.  The corresponding back end must have a request-post method
for this to work though.

@item G z
@kindex G z (Group)
@findex gnus-group-compact-group

Compact the group under point (@code{gnus-group-compact-group}).
Currently implemented only in nnml (@pxref{Mail Spool}).  This removes
gaps between article numbers, hence getting a correct total article
count.

@end table

Variables for the group buffer:

@table @code

@item gnus-group-mode-hook
@vindex gnus-group-mode-hook
is called after the group buffer has been
created.

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

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

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

@end table

@node Scanning New Messages
@subsection Scanning New Messages
@cindex new messages
@cindex scanning new news

@table @kbd

@item g
@kindex g (Group)
@findex gnus-group-get-new-news
@c @icon{gnus-group-get-new-news}
Check the server(s) for new articles.  If the numerical prefix is used,
this command will check only groups of level @var{arg} and lower
(@code{gnus-group-get-new-news}).  If given a non-numerical prefix, this
command will force a total re-reading of the active file(s) from the
back end(s).

@item M-g
@kindex M-g (Group)
@findex gnus-group-get-new-news-this-group
@vindex gnus-goto-next-group-when-activating
@c @icon{gnus-group-get-new-news-this-group}
Check whether new articles have arrived in the current group
(@code{gnus-group-get-new-news-this-group}).
@code{gnus-goto-next-group-when-activating} says whether this command is
to move point to the next group or not.  It is @code{t} by default.

@findex gnus-activate-all-groups
@cindex activating groups
@item C-c M-g
@kindex C-c M-g (Group)
Activate absolutely all groups (@code{gnus-activate-all-groups}).

@item R
@kindex R (Group)
@cindex restarting
@findex gnus-group-restart
Restart Gnus (@code{gnus-group-restart}).  This saves the @file{.newsrc}
file(s), closes the connection to all servers, clears up all run-time
Gnus variables, and then starts Gnus all over again.

@end table

@vindex gnus-get-new-news-hook
@code{gnus-get-new-news-hook} is run just before checking for new news.

@vindex gnus-after-getting-new-news-hook
@code{gnus-after-getting-new-news-hook} is run after checking for new
news.


@node Group Information
@subsection Group Information
@cindex group information
@cindex information on groups

@table @kbd


@item H d
@itemx C-c C-d
@c @icon{gnus-group-describe-group}
@kindex H d (Group)
@kindex C-c C-d (Group)
@cindex describing groups
@cindex group description
@findex gnus-group-describe-group
Describe the current group (@code{gnus-group-describe-group}).  If given
a prefix, force Gnus to re-read the description from the server.

@item M-d
@kindex M-d (Group)
@findex gnus-group-describe-all-groups
Describe all groups (@code{gnus-group-describe-all-groups}).  If given a
prefix, force Gnus to re-read the description file from the server.

@item H v
@itemx V
@kindex V (Group)
@kindex H v (Group)
@cindex version
@findex gnus-version
Display current Gnus version numbers (@code{gnus-version}).

@item ?
@kindex ? (Group)
@findex gnus-group-describe-briefly
Give a very short help message (@code{gnus-group-describe-briefly}).

@item C-c C-i
@kindex C-c C-i (Group)
@cindex info
@cindex manual
@findex gnus-info-find-node
Go to the Gnus info node (@code{gnus-info-find-node}).
@end table


@node Group Timestamp
@subsection Group Timestamp
@cindex timestamps
@cindex group timestamps

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

@lisp
(add-hook 'gnus-select-group-hook 'gnus-group-set-timestamp)
@end lisp

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

This information can be displayed in various ways---the easiest is to
use the @samp{%d} spec in the group line format:

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

This will result in lines looking like:

@example
*        0: mail.ding                                19961002T012943
         0: custom                                   19961002T012713
@end example

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

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

If you would like greater control of the time format, you can use a
user-defined format spec.  Something like the following should do the
trick:

@lisp
(setq gnus-group-line-format
      "%M\%S\%p\%P\%5y: %(%-40,40g%) %ud\n")
(defun gnus-user-format-function-d (headers)
  (let ((time (gnus-group-timestamp gnus-tmp-group)))
    (if time
        (format-time-string "%b %d  %H:%M" time)
      "")))
@end lisp


@node File Commands
@subsection File Commands
@cindex file commands

@table @kbd

@item r
@kindex r (Group)
@findex gnus-group-read-init-file
@vindex gnus-init-file
@cindex reading init file
Re-read the init file (@code{gnus-init-file}, which defaults to
@file{~/.gnus.el}) (@code{gnus-group-read-init-file}).

@item s
@kindex s (Group)
@findex gnus-group-save-newsrc
@cindex saving .newsrc
Save the @file{.newsrc.eld} file (and @file{.newsrc} if wanted)
(@code{gnus-group-save-newsrc}).  If given a prefix, force saving the
file(s) whether Gnus thinks it is necessary or not.

@c @item Z
@c @kindex Z (Group)
@c @findex gnus-group-clear-dribble
@c Clear the dribble buffer (@code{gnus-group-clear-dribble}).

@end table


@node Sieve Commands
@subsection Sieve Commands
@cindex group sieve commands

Sieve is a server-side mail filtering language.  In Gnus you can use
the @code{sieve} group parameter (@pxref{Group Parameters}) to specify
sieve rules that should apply to each group.  Gnus provides two
commands to translate all these group parameters into a proper Sieve
script that can be transferred to the server somehow.

@vindex gnus-sieve-file
@vindex gnus-sieve-region-start
@vindex gnus-sieve-region-end
The generated Sieve script is placed in @code{gnus-sieve-file} (by
default @file{~/.sieve}).  The Sieve code that Gnus generate is placed
between two delimiters, @code{gnus-sieve-region-start} and
@code{gnus-sieve-region-end}, so you may write additional Sieve code
outside these delimiters that will not be removed the next time you
regenerate the Sieve script.

@vindex gnus-sieve-crosspost
The variable @code{gnus-sieve-crosspost} controls how the Sieve script
is generated.  If it is non-@code{nil} (the default) articles is
placed in all groups that have matching rules, otherwise the article
is only placed in the group with the first matching rule.  For
example, the group parameter @samp{(sieve address "sender"
"owner-ding@@hpc.uh.edu")} will generate the following piece of Sieve
code if @code{gnus-sieve-crosspost} is @code{nil}.  (When
@code{gnus-sieve-crosspost} is non-@code{nil}, it looks the same
except that the line containing the call to @code{stop} is removed.)

@example
if address "sender" "owner-ding@@hpc.uh.edu" @{
        fileinto "INBOX.ding";
        stop;
@}
@end example

@xref{Top, Emacs Sieve, Top, sieve, Emacs Sieve}.

@table @kbd

@item D g
@kindex D g (Group)
@findex gnus-sieve-generate
@vindex gnus-sieve-file
@cindex generating sieve script
Regenerate a Sieve script from the @code{sieve} group parameters and
put you into the @code{gnus-sieve-file} without saving it.

@item D u
@kindex D u (Group)
@findex gnus-sieve-update
@vindex gnus-sieve-file
@cindex updating sieve script
Regenerates the Gnus managed part of @code{gnus-sieve-file} using the
@code{sieve} group parameters, save the file and upload it to the
server using the @code{sieveshell} program.

@end table


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

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

The most common way to a summary buffer is to select a group from the
group buffer (@pxref{Selecting a Group}).

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

You can customize the Summary Mode tool bar, see @kbd{M-x
customize-apropos RET gnus-summary-tool-bar}.  This feature is only
available in Emacs.

@kindex v (Summary)
@cindex keys, reserved for users (Summary)
The key @kbd{v} is reserved for users.  You can bind it to some
command or better use it as a prefix key.  For example:
@lisp
(define-key gnus-summary-mode-map (kbd "v -") "LrS") ;; lower subthread
@end lisp

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


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

@iftex
@iflatex
\gnusfigure{The Summary Buffer}{180}{
\put(0,0){\epsfig{figure=ps/summary,width=7.5cm}}
\put(445,0){\makebox(0,0)[br]{\epsfig{figure=ps/summary-article,width=7.5cm}}}
}
@end iflatex
@end iftex

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

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

@lisp
(setq gnus-extract-address-components
      'mail-extract-address-components)
@end lisp

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


@node Summary Buffer Lines
@subsection Summary Buffer Lines

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

There should always be a colon or a point position marker on the line;
the cursor always moves to the point position marker or the colon after
performing an operation.  (Of course, Gnus wouldn't be Gnus if it wasn't
possible to change this.  Just write a new function
@code{gnus-goto-colon} which does whatever you like with the cursor.)
@xref{Positioning Point}.

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

The following format specification characters and extended format
specification(s) are understood:

@table @samp
@item N
Article number.
@item S
Subject string.  List identifiers stripped,
@code{gnus-list-identifiers}.  @xref{Article Hiding}.
@item s
Subject if the article is the root of the thread or the previous article
had a different subject, @code{gnus-summary-same-subject} otherwise.
(@code{gnus-summary-same-subject} defaults to @code{""}.)
@item F
Full @code{From} header.
@item n
The name (from the @code{From} header).
@item f
The name, @code{To} header or the @code{Newsgroups} header (@pxref{To
From Newsgroups}).
@item a
The name (from the @code{From} header).  This differs from the @code{n}
spec in that it uses the function designated by the
@code{gnus-extract-address-components} variable, which is slower, but
may be more thorough.
@item A
The address (from the @code{From} header).  This works the same way as
the @code{a} spec.
@item L
Number of lines in the article.
@item c
Number of characters in the article.  This specifier is not supported
in some methods (like nnfolder).
@item k
Pretty-printed version of the number of characters in the article;
for example, @samp{1.2k} or @samp{0.4M}.
@item I
Indentation based on thread level (@pxref{Customizing Threading}).
@item B
A complex trn-style thread tree, showing response-connecting trace
lines.  A thread could be drawn like this:

@example
>
+->
| +->
| | \->
| |   \->
| \->
+->
\->
@end example

You can customize the appearance with the following options.  Note
that it is possible to make the thread display look really neat by
replacing the default @acronym{ASCII} characters with graphic
line-drawing glyphs.
@table @code
@item gnus-sum-thread-tree-root
@vindex gnus-sum-thread-tree-root
Used for the root of a thread.  If @code{nil}, use subject
instead.  The default is @samp{> }.

@item gnus-sum-thread-tree-false-root
@vindex gnus-sum-thread-tree-false-root
Used for the false root of a thread (@pxref{Loose Threads}).  If
@code{nil}, use subject instead.  The default is @samp{> }.

@item gnus-sum-thread-tree-single-indent
@vindex gnus-sum-thread-tree-single-indent
Used for a thread with just one message.  If @code{nil}, use subject
instead.  The default is @samp{}.

@item gnus-sum-thread-tree-vertical
@vindex gnus-sum-thread-tree-vertical
Used for drawing a vertical line.  The default is @samp{| }.

@item gnus-sum-thread-tree-indent
@vindex gnus-sum-thread-tree-indent
Used for indenting.  The default is @samp{  }.

@item gnus-sum-thread-tree-leaf-with-other
@vindex gnus-sum-thread-tree-leaf-with-other
Used for a leaf with brothers.  The default is @samp{+-> }.

@item gnus-sum-thread-tree-single-leaf
@vindex gnus-sum-thread-tree-single-leaf
Used for a leaf without brothers.  The default is @samp{\-> }

@end table

@item T
Nothing if the article is a root and lots of spaces if it isn't (it
pushes everything after it off the screen).
@item [
Opening bracket, which is normally @samp{[}, but can also be @samp{<}
for adopted articles (@pxref{Customizing Threading}).
@item ]
Closing bracket, which is normally @samp{]}, but can also be @samp{>}
for adopted articles.
@item >
One space for each thread level.
@item <
Twenty minus thread level spaces.
@item U
Unread.  @xref{Read Articles}.

@item R
This misleadingly named specifier is the @dfn{secondary mark}.  This
mark will say whether the article has been replied to, has been cached,
or has been saved.  @xref{Other Marks}.

@item i
Score as a number (@pxref{Scoring}).
@item z
@vindex gnus-summary-zcore-fuzz
Zcore, @samp{+} if above the default level and @samp{-} if below the
default level.  If the difference between
@code{gnus-summary-default-score} and the score is less than
@code{gnus-summary-zcore-fuzz}, this spec will not be used.
@item V
Total thread score.
@item x
@code{Xref}.
@item D
@code{Date}.
@item d
The @code{Date} in @code{DD-MMM} format.
@item o
The @code{Date} in @var{YYYYMMDD}@code{T}@var{HHMMSS} format.
@item M
@code{Message-ID}.
@item r
@code{References}.
@item t
Number of articles in the current sub-thread.  Using this spec will slow
down summary buffer generation somewhat.
@item e
An @samp{=} (@code{gnus-not-empty-thread-mark}) will be displayed if the
article has any children.
@item P
The line number.
@item O
Download mark.
@item *
Desired cursor position (instead of after first colon).
@item &user-date;
Age sensitive date format.  Various date format is defined in
@code{gnus-user-date-format-alist}.
@item u
User defined specifier.  The next character in the format string should
be a letter.  Gnus will call the function
@code{gnus-user-format-function-@var{x}}, where @var{x} is the letter
following @samp{%u}.  The function will be passed the current header as
argument.  The function should return a string, which will be inserted
into the summary just like information from any other summary specifier.
@end table

Text between @samp{%(} and @samp{%)} will be highlighted with
@code{gnus-mouse-face} when the mouse point is placed inside the area.
There can only be one such area.

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

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

This restriction may disappear in later versions of Gnus.


@node To From Newsgroups
@subsection To From Newsgroups
@cindex To
@cindex Newsgroups

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

@enumerate
@item
@vindex gnus-extra-headers
The reading of extra header information is controlled by the
@code{gnus-extra-headers}.  This is a list of header symbols.  For
instance:

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

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

@item
@findex gnus-extra-header
The value of these extra headers can be accessed via the
@code{gnus-extra-header} function.  Here's a format line spec that will
access the @code{X-Newsreader} header:

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

@item
@vindex gnus-ignored-from-addresses
The @code{gnus-ignored-from-addresses} variable says when the @samp{%f}
summary line spec returns the @code{To}, @code{Newsreader} or
@code{From} header.  If this regexp matches the contents of the
@code{From} header, the value of the @code{To} or @code{Newsreader}
headers are used instead.

To distinguish regular articles from those where the @code{From} field
has been swapped, a string is prefixed to the @code{To} or
@code{Newsgroups} header in the summary line.  By default the string is
@samp{-> } for @code{To} and @samp{=> } for @code{Newsgroups}, you can
customize these strings with @code{gnus-summary-to-prefix} and
@code{gnus-summary-newsgroup-prefix}.

@end enumerate

@vindex nnmail-extra-headers
A related variable is @code{nnmail-extra-headers}, which controls when
to include extra headers when generating overview (@acronym{NOV}) files.
If you have old overview files, you should regenerate them after
changing this variable, by entering the server buffer using @kbd{^},
and then @kbd{g} on the appropriate mail server (e.g. nnml) to cause
regeneration.

@vindex gnus-summary-line-format
You also have to instruct Gnus to display the data by changing the
@code{%n} spec to the @code{%f} spec in the
@code{gnus-summary-line-format} variable.

In summary, you'd typically put something like the following in
@file{~/.gnus.el}:

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

(The values listed above are the default values in Gnus.  Alter them
to fit your needs.)

A note for news server administrators, or for users who wish to try to
convince their news server administrator to provide some additional
support:

The above is mostly useful for mail groups, where you have control over
the @acronym{NOV} files that are created.  However, if you can persuade your
nntp admin to add (in the usual implementation, notably INN):

@example
Newsgroups:full
@end example

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


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

@vindex gnus-summary-mode-line-format
You can also change the format of the summary mode bar (@pxref{Mode Line
Formatting}).  Set @code{gnus-summary-mode-line-format} to whatever you
like.  The default is @samp{Gnus: %%b [%A] %Z}.

Here are the elements you can play with:

@table @samp
@item G
Group name.
@item p
Unprefixed group name.
@item A
Current article number.
@item z
Current article score.
@item V
Gnus version.
@item U
Number of unread articles in this group.
@item e
Number of unread articles in this group that aren't displayed in the
summary buffer.
@item Z
A string with the number of unread and unselected articles represented
either as @samp{<%U(+%e) more>} if there are both unread and unselected
articles, and just as @samp{<%U more>} if there are just unread articles
and no unselected ones.
@item g
Shortish group name.  For instance, @samp{rec.arts.anime} will be
shortened to @samp{r.a.anime}.
@item S
Subject of the current article.
@item u
User-defined spec (@pxref{User-Defined Specs}).
@item s
Name of the current score file (@pxref{Scoring}).
@item d
Number of dormant articles (@pxref{Unread Articles}).
@item t
Number of ticked articles (@pxref{Unread Articles}).
@item r
Number of articles that have been marked as read in this session.
@item E
Number of articles expunged by the score files.
@end table


@node Summary Highlighting
@subsection Summary Highlighting

@table @code

@item gnus-visual-mark-article-hook
@vindex gnus-visual-mark-article-hook
This hook is run after selecting an article.  It is meant to be used for
highlighting the article in some way.  It is not run if
@code{gnus-visual} is @code{nil}.

@item gnus-summary-update-hook
@vindex gnus-summary-update-hook
This hook is called when a summary line is changed.  It is not run if
@code{gnus-visual} is @code{nil}.

@item gnus-summary-selected-face
@vindex gnus-summary-selected-face
This is the face (or @dfn{font} as some people call it) used to
highlight the current article in the summary buffer.

@item gnus-summary-highlight
@vindex gnus-summary-highlight
Summary lines are highlighted according to this variable, which is a
list where the elements are of the format @code{(@var{form}
. @var{face})}.  If you would, for instance, like ticked articles to be
italic and high-scored articles to be bold, you could set this variable
to something like
@lisp
(((eq mark gnus-ticked-mark) . italic)
 ((> score default) . bold))
@end lisp
As you may have guessed, if @var{form} returns a non-@code{nil} value,
@var{face} will be applied to the line.
@end table


@node Summary Maneuvering
@section Summary Maneuvering
@cindex summary movement

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

None of these commands select articles.

@table @kbd
@item G M-n
@itemx M-n
@kindex M-n (Summary)
@kindex G M-n (Summary)
@findex gnus-summary-next-unread-subject
Go to the next summary line of an unread article
(@code{gnus-summary-next-unread-subject}).

@item G M-p
@itemx M-p
@kindex M-p (Summary)
@kindex G M-p (Summary)
@findex gnus-summary-prev-unread-subject
Go to the previous summary line of an unread article
(@code{gnus-summary-prev-unread-subject}).

@item G g
@kindex G g (Summary)
@findex gnus-summary-goto-subject
Ask for an article number and then go to the summary line of that article
without displaying the article (@code{gnus-summary-goto-subject}).
@end table

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

Variables related to summary movement:

@table @code

@vindex gnus-auto-select-next
@item gnus-auto-select-next
If you issue one of the movement commands (like @kbd{n}) and there are
no more unread articles after the current one, Gnus will offer to go to
the next group.  If this variable is @code{t} and the next group is
empty, Gnus will exit summary mode and return to the group buffer.  If
this variable is neither @code{t} nor @code{nil}, Gnus will select the
next group with unread articles.  As a special case, if this variable
is @code{quietly}, Gnus will select the next group without asking for
confirmation.  If this variable is @code{almost-quietly}, the same
will happen only if you are located on the last article in the group.
Finally, if this variable is @code{slightly-quietly}, the @kbd{Z n}
command will go to the next group without confirmation.  Also
@pxref{Group Levels}.

@item gnus-auto-select-same
@vindex gnus-auto-select-same
If non-@code{nil}, all the movement commands will try to go to the next
article with the same subject as the current.  (@dfn{Same} here might
mean @dfn{roughly equal}.  See @code{gnus-summary-gather-subject-limit}
for details (@pxref{Customizing Threading}).)  If there are no more
articles with the same subject, go to the first unread article.

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

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

@item gnus-auto-center-summary
@vindex gnus-auto-center-summary
If non-@code{nil}, Gnus will keep the point in the summary buffer
centered at all times.  This makes things quite tidy, but if you have a
slow network connection, or simply do not like this un-Emacsism, you can
set this variable to @code{nil} to get the normal Emacs scrolling
action.  This will also inhibit horizontal re-centering of the summary
buffer, which might make it more inconvenient to read extremely long
threads.

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

@item gnus-summary-stop-at-end-of-message
@vindex gnus-summary-stop-at-end-of-message
If non-@code{nil}, don't go to the next article when hitting
@kbd{SPC}, and you're at the end of the article.

@end table


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

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


@node Choosing Commands
@subsection Choosing Commands

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

If you want to fetch new articles or redisplay the group, see
@ref{Exiting the Summary Buffer}.

@table @kbd
@item SPACE
@kindex SPACE (Summary)
@findex gnus-summary-next-page
Select the current article, or, if that one's read already, the next
unread article (@code{gnus-summary-next-page}).

If you have an article window open already and you press @kbd{SPACE}
again, the article will be scrolled.  This lets you conveniently
@kbd{SPACE} through an entire newsgroup.  @xref{Paging the Article}.

@item G n
@itemx n
@kindex n (Summary)
@kindex G n (Summary)
@findex gnus-summary-next-unread-article
@c @icon{gnus-summary-next-unread}
Go to next unread article (@code{gnus-summary-next-unread-article}).

@item G p
@itemx p
@kindex p (Summary)
@findex gnus-summary-prev-unread-article
@c @icon{gnus-summary-prev-unread}
Go to previous unread article (@code{gnus-summary-prev-unread-article}).

@item G N
@itemx N
@kindex N (Summary)
@kindex G N (Summary)
@findex gnus-summary-next-article
Go to the next article (@code{gnus-summary-next-article}).

@item G P
@itemx P
@kindex P (Summary)
@kindex G P (Summary)
@findex gnus-summary-prev-article
Go to the previous article (@code{gnus-summary-prev-article}).

@item G C-n
@kindex G C-n (Summary)
@findex gnus-summary-next-same-subject
Go to the next article with the same subject
(@code{gnus-summary-next-same-subject}).

@item G C-p
@kindex G C-p (Summary)
@findex gnus-summary-prev-same-subject
Go to the previous article with the same subject
(@code{gnus-summary-prev-same-subject}).

@item G f
@itemx .
@kindex G f  (Summary)
@kindex .  (Summary)
@findex gnus-summary-first-unread-article
Go to the first unread article
(@code{gnus-summary-first-unread-article}).

@item G b
@itemx ,
@kindex G b (Summary)
@kindex , (Summary)
@findex gnus-summary-best-unread-article
Go to the unread article with the highest score
(@code{gnus-summary-best-unread-article}).  If given a prefix argument,
go to the first unread article that has a score over the default score.

@item G l
@itemx l
@kindex l (Summary)
@kindex G l (Summary)
@findex gnus-summary-goto-last-article
Go to the previous article read (@code{gnus-summary-goto-last-article}).

@item G o
@kindex G o (Summary)
@findex gnus-summary-pop-article
@cindex history
@cindex article history
Pop an article off the summary history and go to this article
(@code{gnus-summary-pop-article}).  This command differs from the
command above in that you can pop as many previous articles off the
history as you like, while @kbd{l} toggles the two last read articles.
For a somewhat related issue (if you use these commands a lot),
@pxref{Article Backlog}.

@item G j
@itemx j
@kindex j (Summary)
@kindex G j (Summary)
@findex gnus-summary-goto-article
Ask for an article number or @code{Message-ID}, and then go to that
article (@code{gnus-summary-goto-article}).

@end table


@node Choosing Variables
@subsection Choosing Variables

Some variables relevant for moving and selecting articles:

@table @code
@item gnus-auto-extend-newsgroup
@vindex gnus-auto-extend-newsgroup
All the movement commands will try to go to the previous (or next)
article, even if that article isn't displayed in the Summary buffer if
this variable is non-@code{nil}.  Gnus will then fetch the article from
the server and display it in the article buffer.

@item gnus-select-article-hook
@vindex gnus-select-article-hook
This hook is called whenever an article is selected.  The default is
@code{nil}.  If you would like each article to be saved in the Agent as
you read it, putting @code{gnus-agent-fetch-selected-article} on this
hook will do so.

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

@end table


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

@table @kbd

@item SPACE
@kindex SPACE (Summary)
@findex gnus-summary-next-page
Pressing @kbd{SPACE} will scroll the current article forward one page,
or, if you have come to the end of the current article, will choose the
next article (@code{gnus-summary-next-page}).

@vindex gnus-article-boring-faces
@vindex gnus-article-skip-boring
If @code{gnus-article-skip-boring} is non-@code{nil} and the rest of
the article consists only of citations and signature, then it will be
skipped; the next article will be shown instead.  You can customize
what is considered uninteresting with
@code{gnus-article-boring-faces}.  You can manually view the article's
pages, no matter how boring, using @kbd{C-M-v}.

@item DEL
@kindex DEL (Summary)
@findex gnus-summary-prev-page
Scroll the current article back one page (@code{gnus-summary-prev-page}).

@item RET
@kindex RET (Summary)
@findex gnus-summary-scroll-up
Scroll the current article one line forward
(@code{gnus-summary-scroll-up}).

@item M-RET
@kindex M-RET (Summary)
@findex gnus-summary-scroll-down
Scroll the current article one line backward
(@code{gnus-summary-scroll-down}).

@item A g
@itemx g
@kindex A g (Summary)
@kindex g (Summary)
@findex gnus-summary-show-article
@vindex gnus-summary-show-article-charset-alist
(Re)fetch the current article (@code{gnus-summary-show-article}).  If
given a prefix, show a completely ``raw'' article, just the way it
came from the server.  If given a prefix twice (i.e., @kbd{C-u C-u
g'}), fetch the current article, but don't run any of the article
treatment functions.

@cindex charset, view article with different charset
If given a numerical prefix, you can do semi-manual charset stuff.
@kbd{C-u 0 g cn-gb-2312 RET} will decode the message as if it were
encoded in the @code{cn-gb-2312} charset.  If you have

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

then you can say @kbd{C-u 1 g} to get the same effect.

@item A <
@itemx <
@kindex < (Summary)
@kindex A < (Summary)
@findex gnus-summary-beginning-of-article
Scroll to the beginning of the article
(@code{gnus-summary-beginning-of-article}).

@item A >
@itemx >
@kindex > (Summary)
@kindex A > (Summary)
@findex gnus-summary-end-of-article
Scroll to the end of the article (@code{gnus-summary-end-of-article}).

@item A s
@itemx s
@kindex A s (Summary)
@kindex s (Summary)
@findex gnus-summary-isearch-article
Perform an isearch in the article buffer
(@code{gnus-summary-isearch-article}).

@item h
@kindex h (Summary)
@findex gnus-summary-select-article-buffer
Select the article buffer (@code{gnus-summary-select-article-buffer}).

@end table


@node Reply Followup and Post
@section Reply, Followup and Post

@menu
* Summary Mail Commands::       Sending mail.
* Summary Post Commands::       Sending news.
* Summary Message Commands::    Other Message-related commands.
* Canceling and Superseding::
@end menu


@node Summary Mail Commands
@subsection Summary Mail Commands
@cindex mail
@cindex composing mail

Commands for composing a mail message:

@table @kbd

@item S r
@itemx r
@kindex S r (Summary)
@kindex r (Summary)
@findex gnus-summary-reply
@c @icon{gnus-summary-mail-reply}
@c @icon{gnus-summary-reply}
Mail a reply to the author of the current article
(@code{gnus-summary-reply}).

@item S R
@itemx R
@kindex R (Summary)
@kindex S R (Summary)
@findex gnus-summary-reply-with-original
@c @icon{gnus-summary-reply-with-original}
Mail a reply to the author of the current article and include the
original message (@code{gnus-summary-reply-with-original}).  This
command uses the process/prefix convention.

@item S w
@kindex S w (Summary)
@findex gnus-summary-wide-reply
Mail a wide reply to the author of the current article
(@code{gnus-summary-wide-reply}).  A @dfn{wide reply} is a reply that
goes out to all people listed in the @code{To}, @code{From} (or
@code{Reply-to}) and @code{Cc} headers.  If @code{Mail-Followup-To} is
present, that's used instead.

@item S W
@kindex S W (Summary)
@findex gnus-summary-wide-reply-with-original
Mail a wide reply to the current article and include the original
message (@code{gnus-summary-wide-reply-with-original}).  This command uses
the process/prefix convention, but only uses the headers from the
first article to determine the recipients.

@item S L
@kindex S L (Summary)
@findex gnus-summary-reply-to-list-with-original
When replying to a message from a mailing list, send a reply to that
message to the mailing list, and include the original message
(@code{gnus-summary-reply-to-list-with-original}).

@item S v
@kindex S v (Summary)
@findex gnus-summary-very-wide-reply
Mail a very wide reply to the author of the current article
(@code{gnus-summary-wide-reply}).  A @dfn{very wide reply} is a reply
that goes out to all people listed in the @code{To}, @code{From} (or
@code{Reply-to}) and @code{Cc} headers in all the process/prefixed
articles.  This command uses the process/prefix convention.

@item S V
@kindex S V (Summary)
@findex gnus-summary-very-wide-reply-with-original
Mail a very wide reply to the author of the current article and include the
original message (@code{gnus-summary-very-wide-reply-with-original}).  This
command uses the process/prefix convention.

@item S B r
@kindex S B r (Summary)
@findex gnus-summary-reply-broken-reply-to
Mail a reply to the author of the current article but ignore the
@code{Reply-To} field (@code{gnus-summary-reply-broken-reply-to}).
If you need this because a mailing list incorrectly sets a
@code{Reply-To} header pointing to the list, you probably want to set
the @code{broken-reply-to} group parameter instead, so things will work
correctly.  @xref{Group Parameters}.

@item S B R
@kindex S B R (Summary)
@findex gnus-summary-reply-broken-reply-to-with-original
Mail a reply to the author of the current article and include the
original message but ignore the @code{Reply-To} field
(@code{gnus-summary-reply-broken-reply-to-with-original}).

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

@item S m
@itemx m
@kindex m (Summary)
@kindex S m (Summary)
@findex gnus-summary-mail-other-window
@c @icon{gnus-summary-mail-originate}
Prepare a mail (@code{gnus-summary-mail-other-window}).  By default, use
the posting style of the current group.  If given a prefix, disable that.
If the prefix is 1, prompt for a group name to find the posting style.

@item S i
@kindex S i (Summary)
@findex gnus-summary-news-other-window
Prepare a news (@code{gnus-summary-news-other-window}).  By default,
post to the current group.  If given a prefix, disable that.  If the
prefix is 1, prompt for a group to post to.

This function actually prepares a news even when using mail groups.
This is useful for ``posting'' messages to mail groups without actually
sending them over the network: they're just saved directly to the group
in question.  The corresponding back end must have a request-post method
for this to work though.

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

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

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

This command understands the process/prefix convention
(@pxref{Process/Prefix}).

@item S D e
@kindex S D e (Summary)
@findex gnus-summary-resend-message-edit

Like the previous command, but will allow you to edit the message as
if it were a new message before resending.

@item S O m
@kindex S O m (Summary)
@findex gnus-uu-digest-mail-forward
Digest the current series (@pxref{Decoding Articles}) and forward the
result using mail (@code{gnus-uu-digest-mail-forward}).  This command
uses the process/prefix convention (@pxref{Process/Prefix}).

@item S M-c
@kindex S M-c (Summary)
@findex gnus-summary-mail-crosspost-complaint
@cindex crossposting
@cindex excessive crossposting
Send a complaint about excessive crossposting to the author of the
current article (@code{gnus-summary-mail-crosspost-complaint}).

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

@end table

Also @xref{Header Commands, ,Header Commands, message, The Message
Manual}, for more information.


@node Summary Post Commands
@subsection Summary Post Commands
@cindex post
@cindex composing news

Commands for posting a news article:

@table @kbd
@item S p
@itemx a
@kindex a (Summary)
@kindex S p (Summary)
@findex gnus-summary-post-news
@c @icon{gnus-summary-post-news}
Prepare for posting an article (@code{gnus-summary-post-news}).  By
default, post to the current group.  If given a prefix, disable that.
If the prefix is 1, prompt for another group instead.

@item S f
@itemx f
@kindex f (Summary)
@kindex S f (Summary)
@findex gnus-summary-followup
@c @icon{gnus-summary-followup}
Post a followup to the current article (@code{gnus-summary-followup}).

@item S F
@itemx F
@kindex S F (Summary)
@kindex F (Summary)
@c @icon{gnus-summary-followup-with-original}
@findex gnus-summary-followup-with-original
Post a followup to the current article and include the original message
(@code{gnus-summary-followup-with-original}).  This command uses the
process/prefix convention.

@item S n
@kindex S n (Summary)
@findex gnus-summary-followup-to-mail
Post a followup to the current article via news, even if you got the
message through mail (@code{gnus-summary-followup-to-mail}).

@item S N
@kindex S N (Summary)
@findex gnus-summary-followup-to-mail-with-original
Post a followup to the current article via news, even if you got the
message through mail and include the original message
(@code{gnus-summary-followup-to-mail-with-original}).  This command uses
the process/prefix convention.

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

@item S O p
@kindex S O p (Summary)
@findex gnus-uu-digest-post-forward
@cindex digests
@cindex making digests
Digest the current series and forward the result to a newsgroup
(@code{gnus-uu-digest-post-forward}).  This command uses the
process/prefix convention.

@item S u
@kindex S u (Summary)
@findex gnus-uu-post-news
@c @icon{gnus-uu-post-news}
Uuencode a file, split it into parts, and post it as a series
(@code{gnus-uu-post-news}).  (@pxref{Uuencoding and Posting}).
@end table

Also @xref{Header Commands, ,Header Commands, message, The Message
Manual}, for more information.


@node Summary Message Commands
@subsection Summary Message Commands

@table @kbd
@item S y
@kindex S y (Summary)
@findex gnus-summary-yank-message
Yank the current article into an already existing Message composition
buffer (@code{gnus-summary-yank-message}).  This command prompts for
what message buffer you want to yank into, and understands the
process/prefix convention (@pxref{Process/Prefix}).

@end table


@node Canceling and Superseding
@subsection Canceling Articles
@cindex canceling articles
@cindex superseding articles

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

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

@findex gnus-summary-cancel-article
@kindex C (Summary)
@c @icon{gnus-summary-cancel-article}
Find the article you wish to cancel (you can only cancel your own
articles, so don't try any funny stuff).  Then press @kbd{C} or @kbd{S
c} (@code{gnus-summary-cancel-article}).  Your article will be
canceled---machines all over the world will be deleting your article.
This command uses the process/prefix convention (@pxref{Process/Prefix}).

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

Gnus will use the ``current'' select method when canceling.  If you
want to use the standard posting method, use the @samp{a} symbolic
prefix (@pxref{Symbolic Prefixes}).

Gnus ensures that only you can cancel your own messages using a
@code{Cancel-Lock} header (@pxref{Canceling News, Canceling News, ,
message, Message Manual}).

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

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

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

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

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

@node Delayed Articles
@section Delayed Articles
@cindex delayed sending
@cindex send delayed

Sometimes, you might wish to delay the sending of a message.  For
example, you might wish to arrange for a message to turn up just in time
to remind your about the birthday of your Significant Other.  For this,
there is the @code{gnus-delay} package.  Setup is simple:

@lisp
(gnus-delay-initialize)
@end lisp

@findex gnus-delay-article
Normally, to send a message you use the @kbd{C-c C-c} command from
Message mode.  To delay a message, use @kbd{C-c C-j}
(@code{gnus-delay-article}) instead.  This will ask you for how long the
message should be delayed.  Possible answers are:

@itemize @bullet
@item
A time span.  Consists of an integer and a letter.  For example,
@code{42d} means to delay for 42 days.  Available letters are @code{m}
(minutes), @code{h} (hours), @code{d} (days), @code{w} (weeks), @code{M}
(months) and @code{Y} (years).

@item
A specific date.  Looks like @code{YYYY-MM-DD}.  The message will be
delayed until that day, at a specific time (eight o'clock by default).
See also @code{gnus-delay-default-hour}.

@item
A specific time of day.  Given in @code{hh:mm} format, 24h, no am/pm
stuff.  The deadline will be at that time today, except if that time has
already passed, then it's at the given time tomorrow.  So if it's ten
o'clock in the morning and you specify @code{11:15}, then the deadline
is one hour and fifteen minutes hence.  But if you specify @code{9:20},
that means a time tomorrow.
@end itemize

The action of the @code{gnus-delay-article} command is influenced by a
couple of variables:

@table @code
@item gnus-delay-default-hour
@vindex gnus-delay-default-hour
When you specify a specific date, the message will be due on that hour
on the given date.  Possible values are integers 0 through 23.

@item gnus-delay-default-delay
@vindex gnus-delay-default-delay
This is a string and gives the default delay.  It can be of any of the
formats described above.

@item gnus-delay-group
@vindex gnus-delay-group
Delayed articles will be kept in this group on the drafts server until
they are due.  You probably don't need to change this.  The default
value is @code{"delayed"}.

@item gnus-delay-header
@vindex gnus-delay-header
The deadline for each article will be stored in a header.  This variable
is a string and gives the header name.  You probably don't need to
change this.  The default value is @code{"X-Gnus-Delayed"}.
@end table

The way delaying works is like this: when you use the
@code{gnus-delay-article} command, you give a certain delay.  Gnus
calculates the deadline of the message and stores it in the
@code{X-Gnus-Delayed} header and puts the message in the
@code{nndraft:delayed} group.

@findex gnus-delay-send-queue
And whenever you get new news, Gnus looks through the group for articles
which are due and sends them.  It uses the @code{gnus-delay-send-queue}
function for this.  By default, this function is added to the hook
@code{gnus-get-new-news-hook}.  But of course, you can change this.
Maybe you want to use the demon to send drafts?  Just tell the demon to
execute the @code{gnus-delay-send-queue} function.

@table @code
@item gnus-delay-initialize
@findex gnus-delay-initialize
By default, this function installs @code{gnus-delay-send-queue} in
@code{gnus-get-new-news-hook}.  But it accepts the optional second
argument @code{no-check}.  If it is non-@code{nil},
@code{gnus-get-new-news-hook} is not changed.  The optional first
argument is ignored.

For example, @code{(gnus-delay-initialize nil t)} means to do nothing.
Presumably, you want to use the demon for sending due delayed articles.
Just don't forget to set that up :-)
@end table

When delaying an article with @kbd{C-c C-j}, Message mode will
automatically add a @code{"Date"} header with the current time.  In
many cases you probably want the @code{"Date"} header to reflect the
time the message is sent instead.  To do this, you have to delete
@code{Date} from @code{message-draft-headers}.


@node Marking Articles
@section Marking Articles
@cindex article marking
@cindex article ticking
@cindex marks

There are several marks you can set on an article.

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

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

@ifinfo
There's a plethora of commands for manipulating these marks.
@end ifinfo

@menu
* Unread Articles::             Marks for unread articles.
* Read Articles::               Marks for read articles.
* Other Marks::                 Marks that do not affect readedness.
* Setting Marks::               How to set and remove marks.
* Generic Marking Commands::    How to customize the marking.
* Setting Process Marks::       How to mark articles for later processing.
@end menu


@node Unread Articles
@subsection Unread Articles

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

@table @samp
@item !
@vindex gnus-ticked-mark
Marked as ticked (@code{gnus-ticked-mark}).

@dfn{Ticked articles} are articles that will remain visible always.  If
you see an article that you find interesting, or you want to put off
reading it, or replying to it, until sometime later, you'd typically
tick it.  However, articles can be expired (from news servers by the
news server software, Gnus itself never expires ticked messages), so if
you want to keep an article forever, you'll have to make it persistent
(@pxref{Persistent Articles}).

@item ?
@vindex gnus-dormant-mark
Marked as dormant (@code{gnus-dormant-mark}).

@dfn{Dormant articles} will only appear in the summary buffer if there
are followups to it.  If you want to see them even if they don't have
followups, you can use the @kbd{/ D} command (@pxref{Limiting}).
Otherwise (except for the visibility issue), they are just like ticked
messages.

@item SPACE
@vindex gnus-unread-mark
Marked as unread (@code{gnus-unread-mark}).

@dfn{Unread articles} are articles that haven't been read at all yet.
@end table


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

All the following marks mark articles as read.

@table @samp

@item r
@vindex gnus-del-mark
These are articles that the user has marked as read with the @kbd{d}
command manually, more or less (@code{gnus-del-mark}).

@item R
@vindex gnus-read-mark
Articles that have actually been read (@code{gnus-read-mark}).

@item O
@vindex gnus-ancient-mark
Articles that were marked as read in previous sessions and are now
@dfn{old} (@code{gnus-ancient-mark}).

@item K
@vindex gnus-killed-mark
Marked as killed (@code{gnus-killed-mark}).

@item X
@vindex gnus-kill-file-mark
Marked as killed by kill files (@code{gnus-kill-file-mark}).

@item Y
@vindex gnus-low-score-mark
Marked as read by having too low a score (@code{gnus-low-score-mark}).

@item C
@vindex gnus-catchup-mark
Marked as read by a catchup (@code{gnus-catchup-mark}).

@item G
@vindex gnus-canceled-mark
Canceled article (@code{gnus-canceled-mark})

@item Q
@vindex gnus-sparse-mark
Sparsely reffed article (@code{gnus-sparse-mark}).  @xref{Customizing
Threading}.

@item M
@vindex gnus-duplicate-mark
Article marked as read by duplicate suppression
(@code{gnus-duplicate-mark}).  @xref{Duplicate Suppression}.

@end table

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

One more special mark, though:

@table @samp
@item E
@vindex gnus-expirable-mark
Marked as expirable (@code{gnus-expirable-mark}).

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


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

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

@itemize @bullet

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

@item
@vindex gnus-replied-mark
All articles that you have replied to or made a followup to (i.e., have
answered) will be marked with an @samp{A} in the second column
(@code{gnus-replied-mark}).

@item
@vindex gnus-forwarded-mark
All articles that you have forwarded will be marked with an @samp{F} in
the second column (@code{gnus-forwarded-mark}).

@item
@vindex gnus-cached-mark
Articles stored in the article cache will be marked with an @samp{*} in
the second column (@code{gnus-cached-mark}).  @xref{Article Caching}.

@item
@vindex gnus-saved-mark
Articles ``saved'' (in some manner or other; not necessarily
religiously) are marked with an @samp{S} in the second column
(@code{gnus-saved-mark}).

@item
@vindex gnus-unseen-mark
Articles that haven't been seen before in Gnus by the user are marked
with a @samp{.} in the second column (@code{gnus-unseen-mark}).

@item
@vindex gnus-downloaded-mark
When using the Gnus agent (@pxref{Agent Basics}), articles may be
downloaded for unplugged (offline) viewing.  If you are using the
@samp{%O} spec, these articles get the @samp{+} mark in that spec.
(The variable @code{gnus-downloaded-mark} controls which character to
use.)

@item
@vindex gnus-undownloaded-mark
When using the Gnus agent (@pxref{Agent Basics}), some articles might
not have been downloaded.  Such articles cannot be viewed while you
are unplugged (offline).  If you are using the @samp{%O} spec, these
articles get the @samp{-} mark in that spec.  (The variable
@code{gnus-undownloaded-mark} controls which character to use.)

@item
@vindex gnus-downloadable-mark
The Gnus agent (@pxref{Agent Basics}) downloads some articles
automatically, but it is also possible to explicitly mark articles for
download, even if they would not be downloaded automatically.  Such
explicitly-marked articles get the @samp{%} mark in the first column.
(The variable @code{gnus-downloadable-mark} controls which character to
use.)

@item
@vindex gnus-not-empty-thread-mark
@vindex gnus-empty-thread-mark
If the @samp{%e} spec is used, the presence of threads or not will be
marked with @code{gnus-not-empty-thread-mark} and
@code{gnus-empty-thread-mark} in the third column, respectively.

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

@end itemize

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

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


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

All the marking commands understand the numeric prefix.

@table @kbd
@item M c
@itemx M-u
@kindex M c (Summary)
@kindex M-u (Summary)
@findex gnus-summary-clear-mark-forward
@cindex mark as unread
Clear all readedness-marks from the current article
(@code{gnus-summary-clear-mark-forward}).  In other words, mark the
article as unread.

@item M t
@itemx !
@kindex ! (Summary)
@kindex M t (Summary)
@findex gnus-summary-tick-article-forward
Tick the current article (@code{gnus-summary-tick-article-forward}).
@xref{Article Caching}.

@item M ?
@itemx ?
@kindex ? (Summary)
@kindex M ? (Summary)
@findex gnus-summary-mark-as-dormant
Mark the current article as dormant
(@code{gnus-summary-mark-as-dormant}).  @xref{Article Caching}.

@item M d
@itemx d
@kindex M d (Summary)
@kindex d (Summary)
@findex gnus-summary-mark-as-read-forward
Mark the current article as read
(@code{gnus-summary-mark-as-read-forward}).

@item D
@kindex D (Summary)
@findex gnus-summary-mark-as-read-backward
Mark the current article as read and move point to the previous line
(@code{gnus-summary-mark-as-read-backward}).

@item M k
@itemx k
@kindex k (Summary)
@kindex M k (Summary)
@findex gnus-summary-kill-same-subject-and-select
Mark all articles that have the same subject as the current one as read,
and then select the next unread article
(@code{gnus-summary-kill-same-subject-and-select}).

@item M K
@itemx C-k
@kindex M K (Summary)
@kindex C-k (Summary)
@findex gnus-summary-kill-same-subject
Mark all articles that have the same subject as the current one as read
(@code{gnus-summary-kill-same-subject}).

@item M C
@kindex M C (Summary)
@findex gnus-summary-catchup
@c @icon{gnus-summary-catchup}
Mark all unread articles as read (@code{gnus-summary-catchup}).

@item M C-c
@kindex M C-c (Summary)
@findex gnus-summary-catchup-all
Mark all articles in the group as read---even the ticked and dormant
articles (@code{gnus-summary-catchup-all}).

@item M H
@kindex M H (Summary)
@findex gnus-summary-catchup-to-here
Catchup the current group to point (before the point)
(@code{gnus-summary-catchup-to-here}).

@item M h
@kindex M h (Summary)
@findex gnus-summary-catchup-from-here
Catchup the current group from point (after the point)
(@code{gnus-summary-catchup-from-here}).

@item C-w
@kindex C-w (Summary)
@findex gnus-summary-mark-region-as-read
Mark all articles between point and mark as read
(@code{gnus-summary-mark-region-as-read}).

@item M V k
@kindex M V k (Summary)
@findex gnus-summary-kill-below
Kill all articles with scores below the default score (or below the
numeric prefix) (@code{gnus-summary-kill-below}).

@item M e
@itemx E
@kindex M e (Summary)
@kindex E (Summary)
@findex gnus-summary-mark-as-expirable
Mark the current article as expirable
(@code{gnus-summary-mark-as-expirable}).

@item M b
@kindex M b (Summary)
@findex gnus-summary-set-bookmark
Set a bookmark in the current article
(@code{gnus-summary-set-bookmark}).

@item M B
@kindex M B (Summary)
@findex gnus-summary-remove-bookmark
Remove the bookmark from the current article
(@code{gnus-summary-remove-bookmark}).

@item M V c
@kindex M V c (Summary)
@findex gnus-summary-clear-above
Clear all marks from articles with scores over the default score (or
over the numeric prefix) (@code{gnus-summary-clear-above}).

@item M V u
@kindex M V u (Summary)
@findex gnus-summary-tick-above
Tick all articles with scores over the default score (or over the
numeric prefix) (@code{gnus-summary-tick-above}).

@item M V m
@kindex M V m (Summary)
@findex gnus-summary-mark-above
Prompt for a mark, and mark all articles with scores over the default
score (or over the numeric prefix) with this mark
(@code{gnus-summary-clear-above}).
@end table

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


@node Generic Marking Commands
@subsection Generic Marking Commands

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

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

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

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

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

@noindent
or

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


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

Process marks are displayed as @code{#} in the summary buffer, and are
used for marking articles in such a way that other commands will
process these articles.  For instance, if you process mark four
articles and then use the @kbd{*} command, Gnus will enter these four
articles into the cache.  For more information,
@pxref{Process/Prefix}.

@table @kbd

@item M P p
@itemx #
@kindex # (Summary)
@kindex M P p (Summary)
@findex gnus-summary-mark-as-processable
Mark the current article with the process mark
(@code{gnus-summary-mark-as-processable}).
@findex gnus-summary-unmark-as-processable

@item M P u
@itemx M-#
@kindex M P u (Summary)
@kindex M-# (Summary)
Remove the process mark, if any, from the current article
(@code{gnus-summary-unmark-as-processable}).

@item M P U
@kindex M P U (Summary)
@findex gnus-summary-unmark-all-processable
Remove the process mark from all articles
(@code{gnus-summary-unmark-all-processable}).

@item M P i
@kindex M P i (Summary)
@findex gnus-uu-invert-processable
Invert the list of process marked articles
(@code{gnus-uu-invert-processable}).

@item M P R
@kindex M P R (Summary)
@findex gnus-uu-mark-by-regexp
Mark articles that have a @code{Subject} header that matches a regular
expression (@code{gnus-uu-mark-by-regexp}).

@item M P G
@kindex M P G (Summary)
@findex gnus-uu-unmark-by-regexp
Unmark articles that have a @code{Subject} header that matches a regular
expression (@code{gnus-uu-unmark-by-regexp}).

@item M P r
@kindex M P r (Summary)
@findex gnus-uu-mark-region
Mark articles in region (@code{gnus-uu-mark-region}).

@item M P g
@kindex M P g (Summary)
@findex gnus-uu-unmark-region
Unmark articles in region (@code{gnus-uu-unmark-region}).

@item M P t
@kindex M P t (Summary)
@findex gnus-uu-mark-thread
Mark all articles in the current (sub)thread
(@code{gnus-uu-mark-thread}).

@item M P T
@kindex M P T (Summary)
@findex gnus-uu-unmark-thread
Unmark all articles in the current (sub)thread
(@code{gnus-uu-unmark-thread}).

@item M P v
@kindex M P v (Summary)
@findex gnus-uu-mark-over
Mark all articles that have a score above the prefix argument
(@code{gnus-uu-mark-over}).

@item M P s
@kindex M P s (Summary)
@findex gnus-uu-mark-series
Mark all articles in the current series (@code{gnus-uu-mark-series}).

@item M P S
@kindex M P S (Summary)
@findex gnus-uu-mark-sparse
Mark all series that have already had some articles marked
(@code{gnus-uu-mark-sparse}).

@item M P a
@kindex M P a (Summary)
@findex gnus-uu-mark-all
Mark all articles in series order (@code{gnus-uu-mark-all}).

@item M P b
@kindex M P b (Summary)
@findex gnus-uu-mark-buffer
Mark all articles in the buffer in the order they appear
(@code{gnus-uu-mark-buffer}).

@item M P k
@kindex M P k (Summary)
@findex gnus-summary-kill-process-mark
Push the current process mark set onto the stack and unmark all articles
(@code{gnus-summary-kill-process-mark}).

@item M P y
@kindex M P y (Summary)
@findex gnus-summary-yank-process-mark
Pop the previous process mark set from the stack and restore it
(@code{gnus-summary-yank-process-mark}).

@item M P w
@kindex M P w (Summary)
@findex gnus-summary-save-process-mark
Push the current process mark set onto the stack
(@code{gnus-summary-save-process-mark}).

@end table

Also see the @kbd{&} command in @ref{Searching for Articles}, for how to
set process marks based on article body contents.


@node Limiting
@section Limiting
@cindex limiting

It can be convenient to limit the summary buffer to just show some
subset of the articles currently in the group.  The effect most limit
commands have is to remove a few (or many) articles from the summary
buffer.

Limiting commands work on subsets of the articles already fetched from
the servers.  These commands don't query the server for additional
articles.

@table @kbd

@item / /
@itemx / s
@kindex / / (Summary)
@findex gnus-summary-limit-to-subject
Limit the summary buffer to articles that match some subject
(@code{gnus-summary-limit-to-subject}).  If given a prefix, exclude
matching articles.

@item / a
@kindex / a (Summary)
@findex gnus-summary-limit-to-author
Limit the summary buffer to articles that match some author
(@code{gnus-summary-limit-to-author}).  If given a prefix, exclude
matching articles.

@item / R
@kindex / R (Summary)
@findex gnus-summary-limit-to-recipient
Limit the summary buffer to articles that match some recipient
(@code{gnus-summary-limit-to-recipient}).  If given a prefix, exclude
matching articles.

@item / A
@kindex / A (Summary)
@findex gnus-summary-limit-to-address
Limit the summary buffer to articles in which contents of From, To or Cc
header match a given address (@code{gnus-summary-limit-to-address}).  If
given a prefix, exclude matching articles.

@item / S
@kindex / S (Summary)
@findex gnus-summary-limit-to-singletons
Limit the summary buffer to articles that aren't part of any displayed
threads (@code{gnus-summary-limit-to-singletons}).  If given a prefix,
limit to articles that are part of displayed threads.

@item / x
@kindex / x (Summary)
@findex gnus-summary-limit-to-extra
Limit the summary buffer to articles that match one of the ``extra''
headers (@pxref{To From Newsgroups})
(@code{gnus-summary-limit-to-extra}).  If given a prefix, exclude
matching articles.

@item / u
@itemx x
@kindex / u (Summary)
@kindex x (Summary)
@findex gnus-summary-limit-to-unread
Limit the summary buffer to articles not marked as read
(@code{gnus-summary-limit-to-unread}).  If given a prefix, limit the
buffer to articles strictly unread.  This means that ticked and
dormant articles will also be excluded.

@item / m
@kindex / m (Summary)
@findex gnus-summary-limit-to-marks
Ask for a mark and then limit to all articles that have been marked
with that mark (@code{gnus-summary-limit-to-marks}).

@item / t
@kindex / t (Summary)
@findex gnus-summary-limit-to-age
Ask for a number and then limit the summary buffer to articles older than (or equal to) that number of days
(@code{gnus-summary-limit-to-age}).  If given a prefix, limit to
articles younger than that number of days.

@item / n
@kindex / n (Summary)
@findex gnus-summary-limit-to-articles
With prefix @samp{n}, limit the summary buffer to the next @samp{n}
articles.  If not given a prefix, use the process marked articles
instead.  (@code{gnus-summary-limit-to-articles}).

@item / w
@kindex / w (Summary)
@findex gnus-summary-pop-limit
Pop the previous limit off the stack and restore it
(@code{gnus-summary-pop-limit}).  If given a prefix, pop all limits off
the stack.

@item / .
@kindex / . (Summary)
@findex gnus-summary-limit-to-unseen
Limit the summary buffer to the unseen articles
(@code{gnus-summary-limit-to-unseen}).

@item / v
@kindex / v (Summary)
@findex gnus-summary-limit-to-score
Limit the summary buffer to articles that have a score at or above some
score (@code{gnus-summary-limit-to-score}).

@item / p
@kindex / p (Summary)
@findex gnus-summary-limit-to-display-predicate
Limit the summary buffer to articles that satisfy the @code{display}
group parameter predicate
(@code{gnus-summary-limit-to-display-predicate}).  @xref{Group
Parameters}, for more on this predicate.

@item / r
@kindex / r (Summary)
@findex gnus-summary-limit-to-replied
Limit the summary buffer to replied articles
(@code{gnus-summary-limit-to-replied}).  If given a prefix, exclude
replied articles.

@item / E
@itemx M S
@kindex M S (Summary)
@kindex / E (Summary)
@findex gnus-summary-limit-include-expunged
Include all expunged articles in the limit
(@code{gnus-summary-limit-include-expunged}).

@item / D
@kindex / D (Summary)
@findex gnus-summary-limit-include-dormant
Include all dormant articles in the limit
(@code{gnus-summary-limit-include-dormant}).

@item / *
@kindex / * (Summary)
@findex gnus-summary-limit-include-cached
Include all cached articles in the limit
(@code{gnus-summary-limit-include-cached}).

@item / d
@kindex / d (Summary)
@findex gnus-summary-limit-exclude-dormant
Exclude all dormant articles from the limit
(@code{gnus-summary-limit-exclude-dormant}).

@item / M
@kindex / M (Summary)
@findex gnus-summary-limit-exclude-marks
Exclude all marked articles (@code{gnus-summary-limit-exclude-marks}).

@item / T
@kindex / T (Summary)
@findex gnus-summary-limit-include-thread
Include all the articles in the current thread in the limit.

@item / c
@kindex / c (Summary)
@findex gnus-summary-limit-exclude-childless-dormant
Exclude all dormant articles that have no children from the limit@*
(@code{gnus-summary-limit-exclude-childless-dormant}).

@item / C
@kindex / C (Summary)
@findex gnus-summary-limit-mark-excluded-as-read
Mark all excluded unread articles as read
(@code{gnus-summary-limit-mark-excluded-as-read}).  If given a prefix,
also mark excluded ticked and dormant articles as read.

@item / b
@kindex / b (Summary)
@findex gnus-summary-limit-to-bodies
Limit the summary buffer to articles that have bodies that match a
certain regexp (@code{gnus-summary-limit-to-bodies}).  If given a
prefix, reverse the limit.  This command is quite slow since it
requires selecting each article to find the matches.

@item / h
@kindex / h (Summary)
@findex gnus-summary-limit-to-headers
Like the previous command, only limit to headers instead
(@code{gnus-summary-limit-to-headers}).

@end table


The following commands aren't limiting commands, but use the @kbd{/}
prefix as well.

@table @kbd
@item / N
@kindex / N (Summary)
@findex gnus-summary-insert-new-articles
Insert all new articles in the summary buffer.  It scans for new emails
if @var{back-end}@code{-get-new-mail} is non-@code{nil}.

@item / o
@kindex / o (Summary)
@findex gnus-summary-insert-old-articles
Insert all old articles in the summary buffer.  If given a numbered
prefix, fetch this number of articles.

@end table


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

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

Threading is done by looking at the @code{References} headers of the
articles.  In a perfect world, this would be enough to build pretty
trees, but unfortunately, the @code{References} header is often broken
or simply missing.  Weird news propagation exacerbates the problem,
so one has to employ other heuristics to get pleasing results.  A
plethora of approaches exists, as detailed in horrible detail in
@ref{Customizing Threading}.

First, a quick overview of the concepts:

@table @dfn
@item root
The top-most article in a thread; the first article in the thread.

@item thread
A tree-like article structure.

@item sub-thread
A small(er) section of this tree-like structure.

@item loose threads
Threads often lose their roots due to article expiry, or due to the root
already having been read in a previous session, and not displayed in the
summary buffer.  We then typically have many sub-threads that really
belong to one thread, but are without connecting roots.  These are
called loose threads.

@item thread gathering
An attempt to gather loose threads into bigger threads.

@item sparse threads
A thread where the missing articles have been ``guessed'' at, and are
displayed as empty lines in the summary buffer.

@end table


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


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

@menu
* Loose Threads::               How Gnus gathers loose threads into bigger threads.
* Filling In Threads::          Making the threads displayed look fuller.
* More Threading::              Even more variables for fiddling with threads.
* Low-Level Threading::         You thought it was over@dots{} but you were wrong!
@end menu


@node Loose Threads
@subsubsection Loose Threads
@cindex <
@cindex >
@cindex loose threads

@table @code
@item gnus-summary-make-false-root
@vindex gnus-summary-make-false-root
If non-@code{nil}, Gnus will gather all loose subtrees into one big tree
and create a dummy root at the top.  (Wait a minute.  Root at the top?
Yup.)  Loose subtrees occur when the real root has expired, or you've
read or killed the root in a previous session.

When there is no real root of a thread, Gnus will have to fudge
something.  This variable says what fudging method Gnus should use.
There are four possible values:

@iftex
@iflatex
\gnusfigure{The Summary Buffer}{390}{
\put(0,0){\epsfig{figure=ps/summary-adopt,width=7.5cm}}
\put(445,0){\makebox(0,0)[br]{\epsfig{figure=ps/summary-empty,width=7.5cm}}}
\put(0,400){\makebox(0,0)[tl]{\epsfig{figure=ps/summary-none,width=7.5cm}}}
\put(445,400){\makebox(0,0)[tr]{\epsfig{figure=ps/summary-dummy,width=7.5cm}}}
}
@end iflatex
@end iftex

@cindex adopting articles

@table @code

@item adopt
Gnus will make the first of the orphaned articles the parent.  This
parent will adopt all the other articles.  The adopted articles will be
marked as such by pointy brackets (@samp{<>}) instead of the standard
square brackets (@samp{[]}).  This is the default method.

@item dummy
@vindex gnus-summary-dummy-line-format
@vindex gnus-summary-make-false-root-always
Gnus will create a dummy summary line that will pretend to be the
parent.  This dummy line does not correspond to any real article, so
selecting it will just select the first real article after the dummy
article.  @code{gnus-summary-dummy-line-format} is used to specify the
format of the dummy roots.  It accepts only one format spec:  @samp{S},
which is the subject of the article.  @xref{Formatting Variables}.
If you want all threads to have a dummy root, even the non-gathered
ones, set @code{gnus-summary-make-false-root-always} to @code{t}.

@item empty
Gnus won't actually make any article the parent, but simply leave the
subject field of all orphans except the first empty.  (Actually, it will
use @code{gnus-summary-same-subject} as the subject (@pxref{Summary
Buffer Format}).)

@item none
Don't make any article parent at all.  Just gather the threads and
display them after one another.

@item nil
Don't gather loose threads.
@end table

@item gnus-summary-gather-subject-limit
@vindex gnus-summary-gather-subject-limit
Loose threads are gathered by comparing subjects of articles.  If this
variable is @code{nil}, Gnus requires an exact match between the
subjects of the loose threads before gathering them into one big
super-thread.  This might be too strict a requirement, what with the
presence of stupid newsreaders that chop off long subject lines.  If
you think so, set this variable to, say, 20 to require that only the
first 20 characters of the subjects have to match.  If you set this
variable to a really low number, you'll find that Gnus will gather
everything in sight into one thread, which isn't very helpful.

@cindex fuzzy article gathering
If you set this variable to the special value @code{fuzzy}, Gnus will
use a fuzzy string comparison algorithm on the subjects (@pxref{Fuzzy
Matching}).

@item gnus-simplify-subject-fuzzy-regexp
@vindex gnus-simplify-subject-fuzzy-regexp
This can either be a regular expression or list of regular expressions
that match strings that will be removed from subjects if fuzzy subject
simplification is used.

@item gnus-simplify-ignored-prefixes
@vindex gnus-simplify-ignored-prefixes
If you set @code{gnus-summary-gather-subject-limit} to something as low
as 10, you might consider setting this variable to something sensible:

@c Written by Michael Ernst <mernst@cs.rice.edu>
@lisp
(setq gnus-simplify-ignored-prefixes
      (concat
       "\\`\\[?\\("
       (mapconcat
        'identity
        '("looking"
          "wanted" "followup" "summary\\( of\\)?"
          "help" "query" "problem" "question"
          "answer" "reference" "announce"
          "How can I" "How to" "Comparison of"
          ;; ...
          )
        "\\|")
       "\\)\\s *\\("
       (mapconcat 'identity
                  '("for" "for reference" "with" "about")
                  "\\|")
       "\\)?\\]?:?[ \t]*"))
@end lisp

All words that match this regexp will be removed before comparing two
subjects.

@item gnus-simplify-subject-functions
@vindex gnus-simplify-subject-functions
If non-@code{nil}, this variable overrides
@code{gnus-summary-gather-subject-limit}.  This variable should be a
list of functions to apply to the @code{Subject} string iteratively to
arrive at the simplified version of the string.

Useful functions to put in this list include:

@table @code
@item gnus-simplify-subject-re
@findex gnus-simplify-subject-re
Strip the leading @samp{Re:}.

@item gnus-simplify-subject-fuzzy
@findex gnus-simplify-subject-fuzzy
Simplify fuzzily.

@item gnus-simplify-whitespace
@findex gnus-simplify-whitespace
Remove excessive whitespace.

@item gnus-simplify-all-whitespace
@findex gnus-simplify-all-whitespace
Remove all whitespace.
@end table

You may also write your own functions, of course.


@item gnus-summary-gather-exclude-subject
@vindex gnus-summary-gather-exclude-subject
Since loose thread gathering is done on subjects only, that might lead
to many false hits, especially with certain common subjects like
@samp{} and @samp{(none)}.  To make the situation slightly better,
you can use the regexp @code{gnus-summary-gather-exclude-subject} to say
what subjects should be excluded from the gathering process.@*
The default is @samp{^ *$\\|^(none)$}.

@item gnus-summary-thread-gathering-function
@vindex gnus-summary-thread-gathering-function
Gnus gathers threads by looking at @code{Subject} headers.  This means
that totally unrelated articles may end up in the same ``thread'', which
is confusing.  An alternate approach is to look at all the
@code{Message-ID}s in all the @code{References} headers to find matches.
This will ensure that no gathered threads ever include unrelated
articles, but it also means that people who have posted with broken
newsreaders won't be gathered properly.  The choice is yours---plague or
cholera:

@table @code
@item gnus-gather-threads-by-subject
@findex gnus-gather-threads-by-subject
This function is the default gathering function and looks at
@code{Subject}s exclusively.

@item gnus-gather-threads-by-references
@findex gnus-gather-threads-by-references
This function looks at @code{References} headers exclusively.
@end table

If you want to test gathering by @code{References}, you could say
something like:

@lisp
(setq gnus-summary-thread-gathering-function
      'gnus-gather-threads-by-references)
@end lisp

@end table


@node Filling In Threads
@subsubsection Filling In Threads

@table @code
@item gnus-fetch-old-headers
@vindex gnus-fetch-old-headers
If non-@code{nil}, Gnus will attempt to build old threads by fetching
more old headers---headers to articles marked as read.  If you would
like to display as few summary lines as possible, but still connect as
many loose threads as possible, you should set this variable to
@code{some} or a number.  If you set it to a number, no more than that
number of extra old headers will be fetched.  In either case, fetching
old headers only works if the back end you are using carries overview
files---this would normally be @code{nntp}, @code{nnspool},
@code{nnml}, and @code{nnmaildir}.  Also remember that if the root of
the thread has been expired by the server, there's not much Gnus can
do about that.

This variable can also be set to @code{invisible}.  This won't have any
visible effects, but is useful if you use the @kbd{A T} command a lot
(@pxref{Finding the Parent}).

The server has to support @acronym{NOV} for any of this to work.

@cindex Gmane, gnus-fetch-old-headers
This feature can seriously impact performance it ignores all locally
cached header entries.  Setting it to @code{t} for groups for a server
that doesn't expire articles (such as news.gmane.org), leads to very
slow summary generation.

@item gnus-fetch-old-ephemeral-headers
@vindex gnus-fetch-old-ephemeral-headers
Same as @code{gnus-fetch-old-headers}, but only used for ephemeral
newsgroups.

@item gnus-build-sparse-threads
@vindex gnus-build-sparse-threads
Fetching old headers can be slow.  A low-rent similar effect can be
gotten by setting this variable to @code{some}.  Gnus will then look at
the complete @code{References} headers of all articles and try to string
together articles that belong in the same thread.  This will leave
@dfn{gaps} in the threading display where Gnus guesses that an article
is missing from the thread.  (These gaps appear like normal summary
lines.  If you select a gap, Gnus will try to fetch the article in
question.)  If this variable is @code{t}, Gnus will display all these
``gaps'' without regard for whether they are useful for completing the
thread or not.  Finally, if this variable is @code{more}, Gnus won't cut
off sparse leaf nodes that don't lead anywhere.  This variable is
@code{nil} by default.

@item gnus-read-all-available-headers
@vindex gnus-read-all-available-headers
This is a rather obscure variable that few will find useful.  It's
intended for those non-news newsgroups where the back end has to fetch
quite a lot to present the summary buffer, and where it's impossible to
go back to parents of articles.  This is mostly the case in the
web-based groups.

If you don't use those, then it's safe to leave this as the default
@code{nil}.  If you want to use this variable, it should be a regexp
that matches the group name, or @code{t} for all groups.

@end table


@node More Threading
@subsubsection More Threading

@table @code
@item gnus-show-threads
@vindex gnus-show-threads
If this variable is @code{nil}, no threading will be done, and all of
the rest of the variables here will have no effect.  Turning threading
off will speed group selection up a bit, but it is sure to make reading
slower and more awkward.

@item gnus-thread-hide-subtree
@vindex gnus-thread-hide-subtree
If non-@code{nil}, all threads will be hidden when the summary buffer is
generated.

This can also be a predicate specifier (@pxref{Predicate Specifiers}).
Available predicates are @code{gnus-article-unread-p} and
@code{gnus-article-unseen-p}.

Here's an example:

@lisp
(setq gnus-thread-hide-subtree
      '(or gnus-article-unread-p
           gnus-article-unseen-p))
@end lisp

(It's a pretty nonsensical example, since all unseen articles are also
unread, but you get my drift.)


@item gnus-thread-expunge-below
@vindex gnus-thread-expunge-below
All threads that have a total score (as defined by
@code{gnus-thread-score-function}) less than this number will be
expunged.  This variable is @code{nil} by default, which means that no
threads are expunged.

@item gnus-thread-hide-killed
@vindex gnus-thread-hide-killed
if you kill a thread and this variable is non-@code{nil}, the subtree
will be hidden.

@item gnus-thread-ignore-subject
@vindex gnus-thread-ignore-subject
Sometimes somebody changes the subject in the middle of a thread.  If
this variable is non-@code{nil}, which is the default, the subject
change is ignored.  If it is @code{nil}, a change in the subject will
result in a new thread.

@item gnus-thread-indent-level
@vindex gnus-thread-indent-level
This is a number that says how much each sub-thread should be indented.
The default is 4.

@item gnus-sort-gathered-threads-function
@vindex gnus-sort-gathered-threads-function
Sometimes, particularly with mailing lists, the order in which mails
arrive locally is not necessarily the same as the order in which they
arrived on the mailing list.  Consequently, when sorting sub-threads
using the default @code{gnus-thread-sort-by-number}, responses can end
up appearing before the article to which they are responding to.
Setting this variable to an alternate value
(e.g. @code{gnus-thread-sort-by-date}), in a group's parameters or in an
appropriate hook (e.g. @code{gnus-summary-generate-hook}) can produce a
more logical sub-thread ordering in such instances.

@end table


@node Low-Level Threading
@subsubsection Low-Level Threading

@table @code

@item gnus-parse-headers-hook
@vindex gnus-parse-headers-hook
Hook run before parsing any headers.

@item gnus-alter-header-function
@vindex gnus-alter-header-function
If non-@code{nil}, this function will be called to allow alteration of
article header structures.  The function is called with one parameter,
the article header vector, which it may alter in any way.  For instance,
if you have a mail-to-news gateway which alters the @code{Message-ID}s
in systematic ways (by adding prefixes and such), you can use this
variable to un-scramble the @code{Message-ID}s so that they are more
meaningful.  Here's one example:

@lisp
(setq gnus-alter-header-function 'my-alter-message-id)

(defun my-alter-message-id (header)
  (let ((id (mail-header-id header)))
    (when (string-match
           "\\(<[^<>@@]*\\)\\.?cygnus\\..*@@\\([^<>@@]*>\\)" id)
      (mail-header-set-id
       (concat (match-string 1 id) "@@" (match-string 2 id))
       header))))
@end lisp

@end table


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

@table @kbd

@item T k
@itemx C-M-k
@kindex T k (Summary)
@kindex C-M-k (Summary)
@findex gnus-summary-kill-thread
Mark all articles in the current (sub-)thread as read
(@code{gnus-summary-kill-thread}).  If the prefix argument is positive,
remove all marks instead.  If the prefix argument is negative, tick
articles instead.

@item T l
@itemx C-M-l
@kindex T l (Summary)
@kindex C-M-l (Summary)
@findex gnus-summary-lower-thread
Lower the score of the current (sub-)thread
(@code{gnus-summary-lower-thread}).

@item T i
@kindex T i (Summary)
@findex gnus-summary-raise-thread
Increase the score of the current (sub-)thread
(@code{gnus-summary-raise-thread}).

@item T #
@kindex T # (Summary)
@findex gnus-uu-mark-thread
Set the process mark on the current (sub-)thread
(@code{gnus-uu-mark-thread}).

@item T M-#
@kindex T M-# (Summary)
@findex gnus-uu-unmark-thread
Remove the process mark from the current (sub-)thread
(@code{gnus-uu-unmark-thread}).

@item T T
@kindex T T (Summary)
@findex gnus-summary-toggle-threads
Toggle threading (@code{gnus-summary-toggle-threads}).

@item T s
@kindex T s (Summary)
@findex gnus-summary-show-thread
Expose the (sub-)thread hidden under the current article, if any@*
(@code{gnus-summary-show-thread}).

@item T h
@kindex T h (Summary)
@findex gnus-summary-hide-thread
Hide the current (sub-)thread (@code{gnus-summary-hide-thread}).

@item T S
@kindex T S (Summary)
@findex gnus-summary-show-all-threads
Expose all hidden threads (@code{gnus-summary-show-all-threads}).

@item T H
@kindex T H (Summary)
@findex gnus-summary-hide-all-threads
Hide all threads (@code{gnus-summary-hide-all-threads}).

@item T t
@kindex T t (Summary)
@findex gnus-summary-rethread-current
Re-thread the current article's thread
(@code{gnus-summary-rethread-current}).  This works even when the
summary buffer is otherwise unthreaded.

@item T ^
@kindex T ^ (Summary)
@findex gnus-summary-reparent-thread
Make the current article the child of the marked (or previous) article
(@code{gnus-summary-reparent-thread}).

@item T M-^
@kindex T M-^ (Summary)
@findex gnus-summary-reparent-children
Make the current article the parent of the marked articles
(@code{gnus-summary-reparent-children}).

@end table

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

@table @kbd

@item T n
@kindex T n (Summary)
@itemx C-M-f
@kindex C-M-n (Summary)
@itemx M-down
@kindex M-down (Summary)
@findex gnus-summary-next-thread
Go to the next thread (@code{gnus-summary-next-thread}).

@item T p
@kindex T p (Summary)
@itemx C-M-b
@kindex C-M-p (Summary)
@itemx M-up
@kindex M-up (Summary)
@findex gnus-summary-prev-thread
Go to the previous thread (@code{gnus-summary-prev-thread}).

@item T d
@kindex T d (Summary)
@findex gnus-summary-down-thread
Descend the thread (@code{gnus-summary-down-thread}).

@item T u
@kindex T u (Summary)
@findex gnus-summary-up-thread
Ascend the thread (@code{gnus-summary-up-thread}).

@item T o
@kindex T o (Summary)
@findex gnus-summary-top-thread
Go to the top of the thread (@code{gnus-summary-top-thread}).
@end table

@vindex gnus-thread-operation-ignore-subject
If you ignore subject while threading, you'll naturally end up with
threads that have several different subjects in them.  If you then issue
a command like @kbd{T k} (@code{gnus-summary-kill-thread}) you might not
wish to kill the entire thread, but just those parts of the thread that
have the same subject as the current article.  If you like this idea,
you can fiddle with @code{gnus-thread-operation-ignore-subject}.  If it
is non-@code{nil} (which it is by default), subjects will be ignored
when doing thread commands.  If this variable is @code{nil}, articles in
the same thread with different subjects will not be included in the
operation in question.  If this variable is @code{fuzzy}, only articles
that have subjects fuzzily equal will be included (@pxref{Fuzzy
Matching}).


@node Sorting the Summary Buffer
@section Sorting the Summary Buffer

@findex gnus-thread-sort-by-total-score
@findex gnus-thread-sort-by-date
@findex gnus-thread-sort-by-score
@findex gnus-thread-sort-by-subject
@findex gnus-thread-sort-by-author
@findex gnus-thread-sort-by-recipient
@findex gnus-thread-sort-by-number
@findex gnus-thread-sort-by-random
@vindex gnus-thread-sort-functions
@findex gnus-thread-sort-by-most-recent-number
@findex gnus-thread-sort-by-most-recent-date
If you are using a threaded summary display, you can sort the threads by
setting @code{gnus-thread-sort-functions}, which can be either a single
function, a list of functions, or a list containing functions and
@code{(not some-function)} elements.

By default, sorting is done on article numbers.  Ready-made sorting
predicate functions include @code{gnus-thread-sort-by-number},
@code{gnus-thread-sort-by-author}, @code{gnus-thread-sort-by-recipient},
@code{gnus-thread-sort-by-subject},
@code{gnus-thread-sort-by-date},
@code{gnus-thread-sort-by-score},
@code{gnus-thread-sort-by-most-recent-number},
@code{gnus-thread-sort-by-most-recent-date},
@code{gnus-thread-sort-by-random} and
@code{gnus-thread-sort-by-total-score}.

Each function takes two threads and returns non-@code{nil} if the first
thread should be sorted before the other.  Note that sorting really is
normally done by looking only at the roots of each thread.  Exceptions
to this rule are @code{gnus-thread-sort-by-most-recent-number} and
@code{gnus-thread-sort-by-most-recent-date}.

If you use more than one function, the primary sort key should be the
last function in the list.  You should probably always include
@code{gnus-thread-sort-by-number} in the list of sorting
functions---preferably first.  This will ensure that threads that are
equal with respect to the other sort criteria will be displayed in
ascending article order.

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

@lisp
(setq gnus-thread-sort-functions
      '(gnus-thread-sort-by-number
        gnus-thread-sort-by-subject
        (not gnus-thread-sort-by-total-score)))
@end lisp

The threads that have highest score will be displayed first in the
summary buffer.  When threads have the same score, they will be sorted
alphabetically.  The threads that have the same score and the same
subject will be sorted by number, which is (normally) the sequence in
which the articles arrived.

If you want to sort by score and then reverse arrival order, you could
say something like:

@lisp
(setq gnus-thread-sort-functions
      '((not gnus-thread-sort-by-number)
        gnus-thread-sort-by-score))
@end lisp

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

@findex gnus-article-sort-functions
@findex gnus-article-sort-by-date
@findex gnus-article-sort-by-most-recent-date
@findex gnus-article-sort-by-score
@findex gnus-article-sort-by-subject
@findex gnus-article-sort-by-author
@findex gnus-article-sort-by-random
@findex gnus-article-sort-by-number
@findex gnus-article-sort-by-most-recent-number
If you are using an unthreaded display for some strange reason or
other, you have to fiddle with the @code{gnus-article-sort-functions}
variable.  It is very similar to the
@code{gnus-thread-sort-functions}, except that it uses slightly
different functions for article comparison.  Available sorting
predicate functions are @code{gnus-article-sort-by-number},
@code{gnus-article-sort-by-author},
@code{gnus-article-sort-by-subject}, @code{gnus-article-sort-by-date},
@code{gnus-article-sort-by-random}, and
@code{gnus-article-sort-by-score}.

If you want to sort an unthreaded summary display by subject, you could
say something like:

@lisp
(setq gnus-article-sort-functions
      '(gnus-article-sort-by-number
        gnus-article-sort-by-subject))
@end lisp

You can define group specific sorting via @code{gnus-parameters},
@xref{Group Parameters}.


@node Asynchronous Fetching
@section Asynchronous Article Fetching
@cindex asynchronous article fetching
@cindex article pre-fetch
@cindex pre-fetch

If you read your news from an @acronym{NNTP} server that's far away, the
network latencies may make reading articles a chore.  You have to wait
for a while after pressing @kbd{n} to go to the next article before the
article appears.  Why can't Gnus just go ahead and fetch the article
while you are reading the previous one?  Why not, indeed.

First, some caveats.  There are some pitfalls to using asynchronous
article fetching, especially the way Gnus does it.

Let's say you are reading article 1, which is short, and article 2 is
quite long, and you are not interested in reading that.  Gnus does not
know this, so it goes ahead and fetches article 2.  You decide to read
article 3, but since Gnus is in the process of fetching article 2, the
connection is blocked.

To avoid these situations, Gnus will open two (count 'em two)
connections to the server.  Some people may think this isn't a very nice
thing to do, but I don't see any real alternatives.  Setting up that
extra connection takes some time, so Gnus startup will be slower.

Gnus will fetch more articles than you will read.  This will mean that
the link between your machine and the @acronym{NNTP} server will become more
loaded than if you didn't use article pre-fetch.  The server itself will
also become more loaded---both with the extra article requests, and the
extra connection.

Ok, so now you know that you shouldn't really use this thing@dots{} unless
you really want to.

@vindex gnus-asynchronous
Here's how:  Set @code{gnus-asynchronous} to @code{t}.  The rest should
happen automatically.

@vindex gnus-use-article-prefetch
You can control how many articles are to be pre-fetched by setting
@code{gnus-use-article-prefetch}.  This is 30 by default, which means
that when you read an article in the group, the back end will pre-fetch
the next 30 articles.  If this variable is @code{t}, the back end will
pre-fetch all the articles it can without bound.  If it is
@code{nil}, no pre-fetching will be done.

@vindex gnus-async-prefetch-article-p
@findex gnus-async-unread-p
There are probably some articles that you don't want to pre-fetch---read
articles, for instance.  The @code{gnus-async-prefetch-article-p}
variable controls whether an article is to be pre-fetched.  This
function should return non-@code{nil} when the article in question is
to be pre-fetched.  The default is @code{gnus-async-unread-p}, which
returns @code{nil} on read articles.  The function is called with an
article data structure as the only parameter.

If, for instance, you wish to pre-fetch only unread articles shorter
than 100 lines, you could say something like:

@lisp
(defun my-async-short-unread-p (data)
  "Return non-nil for short, unread articles."
  (and (gnus-data-unread-p data)
       (< (mail-header-lines (gnus-data-header data))
          100)))

(setq gnus-async-prefetch-article-p 'my-async-short-unread-p)
@end lisp

These functions will be called many, many times, so they should
preferably be short and sweet to avoid slowing down Gnus too much.
It's probably a good idea to byte-compile things like this.

@vindex gnus-async-post-fetch-function
@findex gnus-html-prefetch-images
After an article has been prefetched, this
@code{gnus-async-post-fetch-function} will be called.  The buffer will
be narrowed to the region of the article that was fetched.  A useful
value would be @code{gnus-html-prefetch-images}, which will prefetch
and store images referenced in the article, so that you don't have to
wait for them to be fetched when you read the article.  This is useful
for @acronym{HTML} messages that have external images.

@vindex gnus-prefetched-article-deletion-strategy
Articles have to be removed from the asynch buffer sooner or later.  The
@code{gnus-prefetched-article-deletion-strategy} says when to remove
articles.  This is a list that may contain the following elements:

@table @code
@item read
Remove articles when they are read.

@item exit
Remove articles when exiting the group.
@end table

The default value is @code{(read exit)}.

@c @vindex gnus-use-header-prefetch
@c If @code{gnus-use-header-prefetch} is non-@code{nil}, prefetch articles
@c from the next group.


@node Article Caching
@section Article Caching
@cindex article caching
@cindex caching

If you have an @emph{extremely} slow @acronym{NNTP} connection, you may
consider turning article caching on.  Each article will then be stored
locally under your home directory.  As you may surmise, this could
potentially use @emph{huge} amounts of disk space, as well as eat up all
your inodes so fast it will make your head swim.  In vodka.

Used carefully, though, it could be just an easier way to save articles.

@vindex gnus-use-long-file-name
@vindex gnus-cache-directory
@vindex gnus-use-cache
To turn caching on, set @code{gnus-use-cache} to @code{t}.  By default,
all articles ticked or marked as dormant will then be copied
over to your local cache (@code{gnus-cache-directory}).  Whether this
cache is flat or hierarchical is controlled by the
@code{gnus-use-long-file-name} variable, as usual.

When re-selecting a ticked or dormant article, it will be fetched from the
cache instead of from the server.  As articles in your cache will never
expire, this might serve as a method of saving articles while still
keeping them where they belong.  Just mark all articles you want to save
as dormant, and don't worry.

When an article is marked as read, is it removed from the cache.

@vindex gnus-cache-remove-articles
@vindex gnus-cache-enter-articles
The entering/removal of articles from the cache is controlled by the
@code{gnus-cache-enter-articles} and @code{gnus-cache-remove-articles}
variables.  Both are lists of symbols.  The first is @code{(ticked
dormant)} by default, meaning that ticked and dormant articles will be
put in the cache.  The latter is @code{(read)} by default, meaning that
articles marked as read are removed from the cache.  Possibly
symbols in these two lists are @code{ticked}, @code{dormant},
@code{unread} and @code{read}.

@findex gnus-jog-cache
So where does the massive article-fetching and storing come into the
picture?  The @code{gnus-jog-cache} command will go through all
subscribed newsgroups, request all unread articles, score them, and
store them in the cache.  You should only ever, ever ever ever, use this
command if 1) your connection to the @acronym{NNTP} server is really, really,
really slow and 2) you have a really, really, really huge disk.
Seriously.  One way to cut down on the number of articles downloaded is
to score unwanted articles down and have them marked as read.  They will
not then be downloaded by this command.

@vindex gnus-uncacheable-groups
@vindex gnus-cacheable-groups
It is likely that you do not want caching on all groups.  For instance,
if your @code{nnml} mail is located under your home directory, it makes no
sense to cache it somewhere else under your home directory.  Unless you
feel that it's neat to use twice as much space.

To limit the caching, you could set @code{gnus-cacheable-groups} to a
regexp of groups to cache, @samp{^nntp} for instance, or set the
@code{gnus-uncacheable-groups} regexp to @samp{^nnml}, for instance.
Both variables are @code{nil} by default.  If a group matches both
variables, the group is not cached.

@findex gnus-cache-generate-nov-databases
@findex gnus-cache-generate-active
@vindex gnus-cache-active-file
The cache stores information on what articles it contains in its active
file (@code{gnus-cache-active-file}).  If this file (or any other parts
of the cache) becomes all messed up for some reason or other, Gnus
offers two functions that will try to set things right.  @kbd{M-x
gnus-cache-generate-nov-databases} will (re)build all the @acronym{NOV}
files, and @kbd{gnus-cache-generate-active} will (re)generate the active
file.

@findex gnus-cache-move-cache
@code{gnus-cache-move-cache} will move your whole
@code{gnus-cache-directory} to some other location.  You get asked to
where, isn't that cool?

@node Persistent Articles
@section Persistent Articles
@cindex persistent articles

Closely related to article caching, we have @dfn{persistent articles}.
In fact, it's just a different way of looking at caching, and much more
useful in my opinion.

Say you're reading a newsgroup, and you happen on to some valuable gem
that you want to keep and treasure forever.  You'd normally just save it
(using one of the many saving commands) in some file.  The problem with
that is that it's just, well, yucky.  Ideally you'd prefer just having
the article remain in the group where you found it forever; untouched by
the expiry going on at the news server.

This is what a @dfn{persistent article} is---an article that just won't
be deleted.  It's implemented using the normal cache functions, but
you use two explicit commands for managing persistent articles:

@table @kbd

@item *
@kindex * (Summary)
@findex gnus-cache-enter-article
Make the current article persistent (@code{gnus-cache-enter-article}).

@item M-*
@kindex M-* (Summary)
@findex gnus-cache-remove-article
Remove the current article from the persistent articles
(@code{gnus-cache-remove-article}).  This will normally delete the
article.
@end table

Both these commands understand the process/prefix convention.

To avoid having all ticked articles (and stuff) entered into the cache,
you should set @code{gnus-use-cache} to @code{passive} if you're just
interested in persistent articles:

@lisp
(setq gnus-use-cache 'passive)
@end lisp

@node Sticky Articles
@section Sticky Articles
@cindex sticky articles

When you select an article the current article buffer will be reused
according to the value of the variable
@code{gnus-single-article-buffer}.  If its value is non-@code{nil} (the
default) all articles reuse the same article buffer.  Else each group
has its own article buffer.

This implies that it's not possible to have more than one article buffer
in a group at a time.  But sometimes you might want to display all the
latest emails from your mother, your father, your aunt, your uncle and
your 17 cousins to coordinate the next Christmas party.

That's where sticky articles come in handy.  A sticky article buffer
basically is a normal article buffer, but it won't be reused when you
select another article.  You can make an article sticky with:

@table @kbd
@item A S
@kindex A S (Summary)
@findex gnus-sticky-article
Make the current article sticky.  If a prefix arg is given, ask for a
name for this sticky article buffer.
@end table

To close a sticky article buffer you can use these commands:

@table @kbd
@item q
@kindex q (Article)
@findex bury-buffer
Puts this sticky article buffer at the end of the list of all buffers.

@item k
@kindex k (Article)
@findex gnus-kill-sticky-article-buffer
Kills this sticky article buffer.
@end table

To kill all sticky article buffers you can use:

@defun gnus-kill-sticky-article-buffers ARG
Kill all sticky article buffers.
If a prefix ARG is given, ask for confirmation.
@end defun

@node Article Backlog
@section Article Backlog
@cindex backlog
@cindex article backlog

If you have a slow connection, but the idea of using caching seems
unappealing to you (and it is, really), you can help the situation some
by switching on the @dfn{backlog}.  This is where Gnus will buffer
already read articles so that it doesn't have to re-fetch articles
you've already read.  This only helps if you are in the habit of
re-selecting articles you've recently read, of course.  If you never do
that, turning the backlog on will slow Gnus down a little bit, and
increase memory usage some.

@vindex gnus-keep-backlog
If you set @code{gnus-keep-backlog} to a number @var{n}, Gnus will store
at most @var{n} old articles in a buffer for later re-fetching.  If this
variable is non-@code{nil} and is not a number, Gnus will store
@emph{all} read articles, which means that your Emacs will grow without
bound before exploding and taking your machine down with you.  I put
that in there just to keep y'all on your toes.

The default value is 20.


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

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

For the commands listed here, the target is a file.  If you want to
save to a group, see the @kbd{B c} (@code{gnus-summary-copy-article})
command (@pxref{Mail Group Commands}).

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

@vindex gnus-saved-headers
If the preceding variable is @code{nil}, all headers that match the
@code{gnus-saved-headers} regexp will be kept, while the rest will be
deleted before saving.

@table @kbd

@item O o
@itemx o
@kindex O o (Summary)
@kindex o (Summary)
@findex gnus-summary-save-article
@c @icon{gnus-summary-save-article}
Save the current article using the default article saver
(@code{gnus-summary-save-article}).

@item O m
@kindex O m (Summary)
@findex gnus-summary-save-article-mail
Save the current article in a Unix mail box (mbox) file
(@code{gnus-summary-save-article-mail}).

@item O r
@kindex O r (Summary)
@findex gnus-summary-save-article-rmail
Save the current article in Rmail format
(@code{gnus-summary-save-article-rmail}).  This is mbox since Emacs 23,
Babyl in older versions.

@item O f
@kindex O f (Summary)
@findex gnus-summary-save-article-file
@c @icon{gnus-summary-save-article-file}
Save the current article in plain file format
(@code{gnus-summary-save-article-file}).

@item O F
@kindex O F (Summary)
@findex gnus-summary-write-article-file
Write the current article in plain file format, overwriting any previous
file contents (@code{gnus-summary-write-article-file}).

@item O b
@kindex O b (Summary)
@findex gnus-summary-save-article-body-file
Save the current article body in plain file format
(@code{gnus-summary-save-article-body-file}).

@item O h
@kindex O h (Summary)
@findex gnus-summary-save-article-folder
Save the current article in mh folder format
(@code{gnus-summary-save-article-folder}).

@item O v
@kindex O v (Summary)
@findex gnus-summary-save-article-vm
Save the current article in a VM folder
(@code{gnus-summary-save-article-vm}).

@item O p
@itemx |
@kindex O p (Summary)
@kindex | (Summary)
@findex gnus-summary-pipe-output
@vindex gnus-summary-pipe-output-default-command
Save the current article in a pipe.  Uhm, like, what I mean is---Pipe
the current article to a process (@code{gnus-summary-pipe-output}).
If given a symbolic prefix (@pxref{Symbolic Prefixes}), include the
complete headers in the piped output.  The symbolic prefix @code{r} is
special; it lets this command pipe a raw article including all headers.
The @code{gnus-summary-pipe-output-default-command} variable can be set
to a string containing the default command and options (default
@code{nil}).

@item O P
@kindex O P (Summary)
@findex gnus-summary-muttprint
@vindex gnus-summary-muttprint-program
Save the current article into muttprint.  That is, print it using the
external program @uref{http://muttprint.sourceforge.net/,
Muttprint}.  The program name and options to use is controlled by the
variable @code{gnus-summary-muttprint-program}.
(@code{gnus-summary-muttprint}).

@end table

@vindex gnus-prompt-before-saving
All these commands use the process/prefix convention
(@pxref{Process/Prefix}).  If you save bunches of articles using these
functions, you might get tired of being prompted for files to save each
and every article in.  The prompting action is controlled by
the @code{gnus-prompt-before-saving} variable, which is @code{always} by
default, giving you that excessive prompting action you know and
loathe.  If you set this variable to @code{t} instead, you'll be prompted
just once for each series of articles you save.  If you like to really
have Gnus do all your thinking for you, you can even set this variable
to @code{nil}, which means that you will never be prompted for files to
save articles in.  Gnus will simply save all the articles in the default
files.


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

@table @code

@item gnus-summary-save-in-rmail
@findex gnus-summary-save-in-rmail
@vindex gnus-rmail-save-name
@findex gnus-plain-save-name
This is the default format, that used by the Rmail package.  Since Emacs
23, Rmail uses standard mbox format.  Before this, it used the
@dfn{Babyl} format.  Accordingly, this command writes mbox format since
Emacs 23, unless appending to an existing Babyl file.  In older versions
of Emacs, it always uses Babyl format.  Uses the function in the
@code{gnus-rmail-save-name} variable to get a file name to save the
article in.  The default is @code{gnus-plain-save-name}.

@item gnus-summary-save-in-mail
@findex gnus-summary-save-in-mail
@vindex gnus-mail-save-name
Save in a Unix mail (mbox) file.  Uses the function in the
@code{gnus-mail-save-name} variable to get a file name to save the
article in.  The default is @code{gnus-plain-save-name}.

@item gnus-summary-save-in-file
@findex gnus-summary-save-in-file
@vindex gnus-file-save-name
@findex gnus-numeric-save-name
Append the article straight to an ordinary file.  Uses the function in
the @code{gnus-file-save-name} variable to get a file name to save the
article in.  The default is @code{gnus-numeric-save-name}.

@item gnus-summary-write-to-file
@findex gnus-summary-write-to-file
Write the article straight to an ordinary file.  The file is
overwritten if it exists.  Uses the function in the
@code{gnus-file-save-name} variable to get a file name to save the
article in.  The default is @code{gnus-numeric-save-name}.

@item gnus-summary-save-body-in-file
@findex gnus-summary-save-body-in-file
Append the article body to an ordinary file.  Uses the function in the
@code{gnus-file-save-name} variable to get a file name to save the
article in.  The default is @code{gnus-numeric-save-name}.

@item gnus-summary-write-body-to-file
@findex gnus-summary-write-body-to-file
Write the article body straight to an ordinary file.  The file is
overwritten if it exists.  Uses the function in the
@code{gnus-file-save-name} variable to get a file name to save the
article in.  The default is @code{gnus-numeric-save-name}.

@item gnus-summary-save-in-folder
@findex gnus-summary-save-in-folder
@findex gnus-folder-save-name
@findex gnus-Folder-save-name
@vindex gnus-folder-save-name
@cindex rcvstore
@cindex MH folders
Save the article to an MH folder using @code{rcvstore} from the MH
library.  Uses the function in the @code{gnus-folder-save-name} variable
to get a file name to save the article in.  The default is
@code{gnus-folder-save-name}, but you can also use
@code{gnus-Folder-save-name}, which creates capitalized names.

@item gnus-summary-save-in-vm
@findex gnus-summary-save-in-vm
Save the article in a VM folder.  You have to have the VM mail
reader to use this setting.

@item gnus-summary-save-in-pipe
@findex gnus-summary-save-in-pipe
Pipe the article to a shell command.  This function takes optional two
arguments COMMAND and RAW.  Valid values for COMMAND include:

@itemize @bullet
@item a string@*
The executable command name and possibly arguments.
@item @code{nil}@*
You will be prompted for the command in the minibuffer.
@item the symbol @code{default}@*
It will be replaced with the command which the variable
@code{gnus-summary-pipe-output-default-command} holds or the command
last used for saving.
@end itemize

Non-@code{nil} value for RAW overrides @code{:decode} and
@code{:headers} properties (see below) and the raw article including all
headers will be piped.
@end table

The symbol of each function may have the following properties:

@table @code
@item :decode
The value non-@code{nil} means save decoded articles.  This is
meaningful only with @code{gnus-summary-save-in-file},
@code{gnus-summary-save-body-in-file},
@code{gnus-summary-write-to-file},
@code{gnus-summary-write-body-to-file}, and
@code{gnus-summary-save-in-pipe}.

@item :function
The value specifies an alternative function which appends, not
overwrites, articles to a file.  This implies that when saving many
articles at a time, @code{gnus-prompt-before-saving} is bound to
@code{t} and all articles are saved in a single file.  This is
meaningful only with @code{gnus-summary-write-to-file} and
@code{gnus-summary-write-body-to-file}.

@item :headers
The value specifies the symbol of a variable of which the value
specifies headers to be saved.  If it is omitted,
@code{gnus-save-all-headers} and @code{gnus-saved-headers} control what
headers should be saved.
@end table

@vindex gnus-article-save-directory
All of these functions, except for the last one, will save the article
in the @code{gnus-article-save-directory}, which is initialized from the
@env{SAVEDIR} environment variable.  This is @file{~/News/} by
default.

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

@table @code

@item gnus-Numeric-save-name
@findex gnus-Numeric-save-name
File names like @file{~/News/Alt.andrea-dworkin/45}.

@item gnus-numeric-save-name
@findex gnus-numeric-save-name
File names like @file{~/News/alt.andrea-dworkin/45}.

@item gnus-Plain-save-name
@findex gnus-Plain-save-name
File names like @file{~/News/Alt.andrea-dworkin}.

@item gnus-plain-save-name
@findex gnus-plain-save-name
File names like @file{~/News/alt.andrea-dworkin}.

@item gnus-sender-save-name
@findex gnus-sender-save-name
File names like @file{~/News/larsi}.
@end table

@vindex gnus-split-methods
You can have Gnus suggest where to save articles by plonking a regexp into
the @code{gnus-split-methods} alist.  For instance, if you would like to
save articles related to Gnus in the file @file{gnus-stuff}, and articles
related to VM in @file{vm-stuff}, you could set this variable to something
like:

@lisp
(("^Subject:.*gnus\\|^Newsgroups:.*gnus" "gnus-stuff")
 ("^Subject:.*vm\\|^Xref:.*vm" "vm-stuff")
 (my-choosing-function "../other-dir/my-stuff")
 ((equal gnus-newsgroup-name "mail.misc") "mail-stuff"))
@end lisp

We see that this is a list where each element is a list that has two
elements---the @dfn{match} and the @dfn{file}.  The match can either be
a string (in which case it is used as a regexp to match on the article
head); it can be a symbol (which will be called as a function with the
group name as a parameter); or it can be a list (which will be
@code{eval}ed).  If any of these actions have a non-@code{nil} result,
the @dfn{file} will be used as a default prompt.  In addition, the
result of the operation itself will be used if the function or form
called returns a string or a list of strings.

You basically end up with a list of file names that might be used when
saving the current article.  (All ``matches'' will be used.)  You will
then be prompted for what you really want to use as a name, with file
name completion over the results from applying this variable.

This variable is @code{((gnus-article-archive-name))} by default, which
means that Gnus will look at the articles it saves for an
@code{Archive-name} line and use that as a suggestion for the file
name.

Here's an example function to clean up file names somewhat.  If you have
lots of mail groups called things like
@samp{nnml:mail.whatever}, you may want to chop off the beginning of
these group names before creating the file name to save to.  The
following will do just that:

@lisp
(defun my-save-name (group)
  (when (string-match "^nnml:mail." group)
    (substring group (match-end 0))))

(setq gnus-split-methods
      '((gnus-article-archive-name)
        (my-save-name)))
@end lisp


@vindex gnus-use-long-file-name
Finally, you have the @code{gnus-use-long-file-name} variable.  If it is
@code{nil}, all the preceding functions will replace all periods
(@samp{.}) in the group names with slashes (@samp{/})---which means that
the functions will generate hierarchies of directories instead of having
all the files in the top level directory
(@file{~/News/alt/andrea-dworkin} instead of
@file{~/News/alt.andrea-dworkin}.)  This variable is @code{t} by default
on most systems.  However, for historical reasons, this is @code{nil} on
Xenix and usg-unix-v machines by default.

This function also affects kill and score file names.  If this variable
is a list, and the list contains the element @code{not-score}, long file
names will not be used for score files, if it contains the element
@code{not-save}, long file names will not be used for saving, and if it
contains the element @code{not-kill}, long file names will not be used
for kill files.

If you'd like to save articles in a hierarchy that looks something like
a spool, you could

@lisp
(setq gnus-use-long-file-name '(not-save)) ; @r{to get a hierarchy}
(setq gnus-default-article-saver
      'gnus-summary-save-in-file)          ; @r{no encoding}
@end lisp

Then just save with @kbd{o}.  You'd then read this hierarchy with
ephemeral @code{nneething} groups---@kbd{G D} in the group buffer, and
the top level directory as the argument (@file{~/News/}).  Then just walk
around to the groups/directories with @code{nneething}.


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

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

@menu
* Uuencoded Articles::          Uudecode articles.
* Shell Archives::              Unshar articles.
* PostScript Files::            Split PostScript.
* Other Files::                 Plain save and binhex.
* Decoding Variables::          Variables for a happy decoding.
* Viewing Files::               You want to look at the result of the decoding?
@end menu

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

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

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

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


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

@table @kbd

@item X u
@kindex X u (Summary)
@findex gnus-uu-decode-uu
@c @icon{gnus-uu-decode-uu}
Uudecodes the current series (@code{gnus-uu-decode-uu}).

@item X U
@kindex X U (Summary)
@findex gnus-uu-decode-uu-and-save
Uudecodes and saves the current series
(@code{gnus-uu-decode-uu-and-save}).

@item X v u
@kindex X v u (Summary)
@findex gnus-uu-decode-uu-view
Uudecodes and views the current series (@code{gnus-uu-decode-uu-view}).

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

@end table

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

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

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


@node Shell Archives
@subsection Shell Archives
@cindex unshar
@cindex shell archives
@cindex shared articles

Shell archives (``shar files'') used to be a popular way to distribute
sources, but it isn't used all that much today.  In any case, we have
some commands to deal with these:

@table @kbd

@item X s
@kindex X s (Summary)
@findex gnus-uu-decode-unshar
Unshars the current series (@code{gnus-uu-decode-unshar}).

@item X S
@kindex X S (Summary)
@findex gnus-uu-decode-unshar-and-save
Unshars and saves the current series (@code{gnus-uu-decode-unshar-and-save}).

@item X v s
@kindex X v s (Summary)
@findex gnus-uu-decode-unshar-view
Unshars and views the current series (@code{gnus-uu-decode-unshar-view}).

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


@node PostScript Files
@subsection PostScript Files
@cindex PostScript

@table @kbd

@item X p
@kindex X p (Summary)
@findex gnus-uu-decode-postscript
Unpack the current PostScript series (@code{gnus-uu-decode-postscript}).

@item X P
@kindex X P (Summary)
@findex gnus-uu-decode-postscript-and-save
Unpack and save the current PostScript series
(@code{gnus-uu-decode-postscript-and-save}).

@item X v p
@kindex X v p (Summary)
@findex gnus-uu-decode-postscript-view
View the current PostScript series
(@code{gnus-uu-decode-postscript-view}).

@item X v P
@kindex X v P (Summary)
@findex gnus-uu-decode-postscript-and-save-view
View and save the current PostScript series
(@code{gnus-uu-decode-postscript-and-save-view}).
@end table


@node Other Files
@subsection Other Files

@table @kbd
@item X o
@kindex X o (Summary)
@findex gnus-uu-decode-save
Save the current series
(@code{gnus-uu-decode-save}).

@item X b
@kindex X b (Summary)
@findex gnus-uu-decode-binhex
Unbinhex the current series (@code{gnus-uu-decode-binhex}).  This
doesn't really work yet.

@item X Y
@kindex X Y (Summary)
@findex gnus-uu-decode-yenc
yEnc-decode the current series and save it (@code{gnus-uu-decode-yenc}).
@end table


@node Decoding Variables
@subsection Decoding Variables

Adjective, not verb.

@menu
* Rule Variables::              Variables that say how a file is to be viewed.
* Other Decode Variables::      Other decode variables.
* Uuencoding and Posting::      Variables for customizing uuencoding.
@end menu


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

Gnus uses @dfn{rule variables} to decide how to view a file.  All these
variables are of the form

@lisp
      (list '(regexp1 command2)
            '(regexp2 command2)
            ...)
@end lisp

@table @code

@item gnus-uu-user-view-rules
@vindex gnus-uu-user-view-rules
@cindex sox
This variable is consulted first when viewing files.  If you wish to use,
for instance, @code{sox} to convert an @file{.au} sound file, you could
say something like:
@lisp
(setq gnus-uu-user-view-rules
      (list '("\\\\.au$" "sox %s -t .aiff > /dev/audio")))
@end lisp

@item gnus-uu-user-view-rules-end
@vindex gnus-uu-user-view-rules-end
This variable is consulted if Gnus couldn't make any matches from the
user and default view rules.

@item gnus-uu-user-archive-rules
@vindex gnus-uu-user-archive-rules
This variable can be used to say what commands should be used to unpack
archives.
@end table


@node Other Decode Variables
@subsubsection Other Decode Variables

@table @code
@vindex gnus-uu-grabbed-file-functions

@item gnus-uu-grabbed-file-functions
All functions in this list will be called right after each file has been
successfully decoded---so that you can move or view files right away,
and don't have to wait for all files to be decoded before you can do
anything.  Ready-made functions you can put in this list are:

@table @code

@item gnus-uu-grab-view
@findex gnus-uu-grab-view
View the file.

@item gnus-uu-grab-move
@findex gnus-uu-grab-move
Move the file (if you're using a saving function.)
@end table

@item gnus-uu-be-dangerous
@vindex gnus-uu-be-dangerous
Specifies what to do if unusual situations arise during decoding.  If
@code{nil}, be as conservative as possible.  If @code{t}, ignore things
that didn't work, and overwrite existing files.  Otherwise, ask each
time.

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

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

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

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

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

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

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

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

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

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

@item gnus-uu-pre-uudecode-hook
@vindex gnus-uu-pre-uudecode-hook
Hook run before sending a message to @code{uudecode}.

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

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

@end table


@node Uuencoding and Posting
@subsubsection Uuencoding and Posting

@table @code

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

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

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

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

@end table


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

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

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

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

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

@vindex gnus-view-pseudos-separately
If @code{gnus-view-pseudos-separately} is non-@code{nil}, one
pseudo-article will be created for each file to be viewed.  If
@code{nil}, all files that use the same viewing command will be given as
a list of parameters to that command.

@vindex gnus-insert-pseudo-articles
If @code{gnus-insert-pseudo-articles} is non-@code{nil}, insert
pseudo-articles when decoding.  It is @code{t} by default.

So; there you are, reading your @emph{pseudo-articles} in your
@emph{virtual newsgroup} from the @emph{virtual server}; and you think:
Why isn't anything real anymore? How did we get here?


@node Article Treatment
@section Article Treatment

Reading through this huge manual, you may have quite forgotten that the
object of newsreaders is to actually, like, read what people have
written.  Reading articles.  Unfortunately, people are quite bad at
writing, so there are tons of functions and variables to make reading
these articles easier.

@menu
* Article Highlighting::        You want to make the article look like fruit salad.
* Article Fontisizing::         Making emphasized text look nice.
* Article Hiding::              You also want to make certain info go away.
* Article Washing::             Lots of way-neat functions to make life better.
* Article Header::              Doing various header transformations.
* Article Buttons::             Click on URLs, Message-IDs, addresses and the like.
* Article Button Levels::       Controlling appearance of buttons.
* Article Date::                Grumble, UT!
* Article Display::             Display various stuff:
                                X-Face, Picons, Gravatars, Smileys.
* Article Signature::           What is a signature?
* Article Miscellanea::         Various other stuff.
@end menu


@node Article Highlighting
@subsection Article Highlighting
@cindex highlighting

Not only do you want your article buffer to look like fruit salad, but
you want it to look like technicolor fruit salad.

@table @kbd

@item W H a
@kindex W H a (Summary)
@findex gnus-article-highlight
@findex gnus-article-maybe-highlight
Do much highlighting of the current article
(@code{gnus-article-highlight}).  This function highlights header, cited
text, the signature, and adds buttons to the body and the head.

@item W H h
@kindex W H h (Summary)
@findex gnus-article-highlight-headers
@vindex gnus-header-face-alist
Highlight the headers (@code{gnus-article-highlight-headers}).  The
highlighting will be done according to the @code{gnus-header-face-alist}
variable, which is a list where each element has the form
@code{(@var{regexp} @var{name} @var{content})}.
@var{regexp} is a regular expression for matching the
header, @var{name} is the face used for highlighting the header name
(@pxref{Faces and Fonts}) and @var{content} is the face for highlighting
the header value.  The first match made will be used.  Note that
@var{regexp} shouldn't have @samp{^} prepended---Gnus will add one.

@item W H c
@kindex W H c (Summary)
@findex gnus-article-highlight-citation
Highlight cited text (@code{gnus-article-highlight-citation}).

Some variables to customize the citation highlights:

@table @code
@vindex gnus-cite-parse-max-size

@item gnus-cite-parse-max-size
If the article size in bytes is bigger than this variable (which is
25000 by default), no citation highlighting will be performed.

@item gnus-cite-max-prefix
@vindex gnus-cite-max-prefix
Maximum possible length for a citation prefix (default 20).

@item gnus-cite-face-list
@vindex gnus-cite-face-list
List of faces used for highlighting citations (@pxref{Faces and Fonts}).
When there are citations from multiple articles in the same message,
Gnus will try to give each citation from each article its own face.
This should make it easier to see who wrote what.

@item gnus-supercite-regexp
@vindex gnus-supercite-regexp
Regexp matching normal Supercite attribution lines.

@item gnus-supercite-secondary-regexp
@vindex gnus-supercite-secondary-regexp
Regexp matching mangled Supercite attribution lines.

@item gnus-cite-minimum-match-count
@vindex gnus-cite-minimum-match-count
Minimum number of identical prefixes we have to see before we believe
that it's a citation.

@item gnus-cite-attribution-prefix
@vindex gnus-cite-attribution-prefix
Regexp matching the beginning of an attribution line.

@item gnus-cite-attribution-suffix
@vindex gnus-cite-attribution-suffix
Regexp matching the end of an attribution line.

@item gnus-cite-attribution-face
@vindex gnus-cite-attribution-face
Face used for attribution lines.  It is merged with the face for the
cited text belonging to the attribution.

@item gnus-cite-ignore-quoted-from
@vindex gnus-cite-ignore-quoted-from
If non-@code{nil}, no citation highlighting will be performed on lines
beginning with @samp{>From }.  Those lines may have been quoted by MTAs
in order not to mix up with the envelope From line.  The default value
is @code{t}.

@end table


@item W H s
@kindex W H s (Summary)
@vindex gnus-signature-separator
@vindex gnus-signature-face
@findex gnus-article-highlight-signature
Highlight the signature (@code{gnus-article-highlight-signature}).
Everything after @code{gnus-signature-separator} (@pxref{Article
Signature}) in an article will be considered a signature and will be
highlighted with @code{gnus-signature-face}, which is @code{italic} by
default.

@end table

@xref{Custom