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

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

   This file documents Gnus, the GNU Emacs newsreader.

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

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

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

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


File: gnus,  Node: Uuencoding and Posting,  Prev: Other Decode Variables,  Up: Decoding Variables

Uuencoding and Posting
......................

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

`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.

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

`gnus-uu-post-separate-description'
     Non-`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 `nil', the description the user enters will be
     included at the beginning of the first article, which will be
     numbered (1/x).  Default is `t'.


File: gnus,  Node: Viewing Files,  Prev: Decoding Variables,  Up: Decoding Articles

Viewing Files
-------------

   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
`pics.tar.gz' containing the files `pic1.jpg' and `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 "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.

   If `gnus-view-pseudo-asynchronously' is `nil', Emacs will wait until
the viewing is done before proceeding.

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

   If `gnus-view-pseudos-separately' is non-`nil', one pseudo-article
will be created for each file to be viewed.  If `nil', all files that
use the same viewing command will be given as a list of parameters to
that command.

   If `gnus-insert-pseudo-articles' is non-`nil', insert
pseudo-articles when decoding.  It is `t' by default.

   So; there you are, reading your _pseudo-articles_ in your _virtual
newsgroup_ from the _virtual server_; and you think: Why isn't anything
real anymore? How did we get here?


File: gnus,  Node: Article Treatment,  Next: MIME Commands,  Prev: Decoding Articles,  Up: The Summary Buffer

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 Buttons::         Click on URLs, Message-IDs, addresses and the like.
* Article Date::            Grumble, UT!
* Article Signature::       What is a signature?
* Article Miscellania::     Various other stuff.


File: gnus,  Node: Article Highlighting,  Next: Article Fontisizing,  Up: Article Treatment

Article Highlighting
--------------------

   Not only do you want your article buffer to look like fruit salad,
but you want it to look like technicolor fruit salad.

`W H a'
     Do much highlighting of the current article
     (`gnus-article-highlight').  This function highlights header, cited
     text, the signature, and adds buttons to the body and the head.

`W H h'
     Highlight the headers (`gnus-article-highlight-headers').  The
     highlighting will be done according to the `gnus-header-face-alist'
     variable, which is a list where each element has the form `(REGEXP
     NAME CONTENT)'.  REGEXP is a regular expression for matching the
     header, NAME is the face used for highlighting the header name
     (*note Faces and Fonts::) and CONTENT is the face for highlighting
     the header value.  The first match made will be used.  Note that
     REGEXP shouldn't have `^' prepended--Gnus will add one.

`W H c'
     Highlight cited text (`gnus-article-highlight-citation').

     Some variables to customize the citation highlights:

    `gnus-cite-parse-max-size'
          If the article size if bigger than this variable (which is
          25000 by default), no citation highlighting will be performed.

    `gnus-cite-prefix-regexp'
          Regexp matching the longest possible citation prefix on a
          line.

    `gnus-cite-max-prefix'
          Maximum possible length for a citation prefix (default 20).

    `gnus-cite-face-list'
          List of faces used for highlighting citations (*note 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.

    `gnus-supercite-regexp'
          Regexp matching normal Supercite attribution lines.

    `gnus-supercite-secondary-regexp'
          Regexp matching mangled Supercite attribution lines.

    `gnus-cite-minimum-match-count'
          Minimum number of identical prefixes we have to see before we
          believe that it's a citation.

    `gnus-cite-attribution-prefix'
          Regexp matching the beginning of an attribution line.

    `gnus-cite-attribution-suffix'
          Regexp matching the end of an attribution line.

    `gnus-cite-attribution-face'
          Face used for attribution lines.  It is merged with the face
          for the cited text belonging to the attribution.

`W H s'
     Highlight the signature (`gnus-article-highlight-signature').
     Everything after `gnus-signature-separator' (*note Article
     Signature::) in an article will be considered a signature and will
     be highlighted with `gnus-signature-face', which is `italic' by
     default.

   *Note Customizing Articles::, for how to highlight articles
automatically.


File: gnus,  Node: Article Fontisizing,  Next: Article Hiding,  Prev: Article Highlighting,  Up: Article Treatment

Article Fontisizing
-------------------

   People commonly add emphasis to words in news articles by writing
things like `_this_' or `*this*' or `/this/'.  Gnus can make this look
nicer by running the article through the `W e'
(`gnus-article-emphasize') command.

   How the emphasis is computed is controlled by the
`gnus-emphasis-alist' variable.  This is an alist where the first
element is a regular expression to be matched.  The second is a number
that says what regular expression grouping is used to find the entire
emphasized word.  The third is a number that says what regexp grouping
should be displayed and highlighted.  (The text between these two
groupings will be hidden.)  The fourth is the face used for
highlighting.

     (setq gnus-article-emphasis
           '(("_\\(\\w+\\)_" 0 1 gnus-emphasis-underline)
             ("\\*\\(\\w+\\)\\*" 0 1 gnus-emphasis-bold)))

   By default, there are seven rules, and they use the following faces:
`gnus-emphasis-bold', `gnus-emphasis-italic',
`gnus-emphasis-underline', `gnus-emphasis-bold-italic',
`gnus-emphasis-underline-italic', `gnus-emphasis-underline-bold', and
`gnus-emphasis-underline-bold-italic'.

   If you want to change these faces, you can either use `M-x
customize', or you can use `copy-face'.  For instance, if you want to
make `gnus-emphasis-italic' use a red face instead, you could say
something like:

     (copy-face 'red 'gnus-emphasis-italic)

   If you want to highlight arbitrary words, you can use the
`gnus-group-highlight-words-alist' variable, which uses the same syntax
as `gnus-emphasis-alist'.  The `highlight-words' group parameter (*note
Group Parameters::) can also be used.

   *Note Customizing Articles::, for how to fontize articles
automatically.


File: gnus,  Node: Article Hiding,  Next: Article Washing,  Prev: Article Fontisizing,  Up: Article Treatment

Article Hiding
--------------

   Or rather, hiding certain things in each article.  There usually is
much too much cruft in most articles.

`W W a'
     Do quite a lot of hiding on the article buffer
     (`gnus-article-hide').  In particular, this function will hide
     headers, PGP, cited text and the signature.

`W W h'
     Hide headers (`gnus-article-hide-headers').  *Note Hiding
     Headers::.

`W W b'
     Hide headers that aren't particularly interesting
     (`gnus-article-hide-boring-headers').  *Note Hiding Headers::.

`W W s'
     Hide signature (`gnus-article-hide-signature').  *Note Article
     Signature::.

`W W l'
     Strip list identifiers specified in `gnus-list-identifiers'.  These
     are strings some mailing list servers add to the beginning of all
     `Subject' headers--for example, `[zebra 4711]'.  Any leading `Re:
     ' is skipped before stripping. `gnus-list-identifiers' may not
     contain `\\(..\\)'.

    `gnus-list-identifiers'
          A regular expression that matches list identifiers to be
          removed from subject.  This can also be a list of regular
          expressions.

`W W p'
     Hide PGP signatures (`gnus-article-hide-pgp').  The
     `gnus-article-hide-pgp-hook' hook will be run after a PGP
     signature has been hidden.  For example, to automatically verify
     articles that have signatures in them do:
          ;;; Hide pgp cruft if any.
          
          (setq gnus-treat-strip-pgp t)
          
          ;;; After hiding pgp, verify the message;
          ;;; only happens if pgp signature is found.
          
          (add-hook 'gnus-article-hide-pgp-hook
                    (lambda ()
                      (save-excursion
                        (set-buffer gnus-original-article-buffer)
                        (mc-verify))))

`W W P'
     Hide PEM (privacy enhanced messages) cruft
     (`gnus-article-hide-pem').

`W W B'
     Strip the banner specified by the `banner' group parameter
     (`gnus-article-strip-banner').  This is mainly used to hide those
     annoying banners and/or signatures that some mailing lists and
     moderated groups adds to all the messages.  The way to use this
     function is to add the `banner' group parameter (*note Group
     Parameters::) to the group you want banners stripped from.  The
     parameter either be a string, which will be interpreted as a
     regular expression matching text to be removed, or the symbol
     `signature', meaning that the (last) signature should be removed,
     or other symbol, meaning that the corresponding regular expression
     in `gnus-article-banner-alist' is used.

`W W c'
     Hide citation (`gnus-article-hide-citation').  Some variables for
     customizing the hiding:

    `gnus-cited-opened-text-button-line-format'
    `gnus-cited-closed-text-button-line-format'
          Gnus adds buttons to show where the cited text has been
          hidden, and to allow toggle hiding the text.  The format of
          the variable is specified by these format-like variable
          (*note Formatting Variables::).  These specs are valid:

         `b'
               Starting point of the hidden text.

         `e'
               Ending point of the hidden text.

         `l'
               Number of characters in the hidden region.

         `n'
               Number of lines of hidden text.

    `gnus-cited-lines-visible'
          The number of lines at the beginning of the cited text to
          leave shown. This can also be a cons cell with the number of
          lines at the top and bottom of the text, respectively, to
          remain visible.

`W W C-c'
     Hide citation (`gnus-article-hide-citation-maybe') depending on the
     following two variables:

    `gnus-cite-hide-percentage'
          If the cited text is of a bigger percentage than this
          variable (default 50), hide the cited text.

    `gnus-cite-hide-absolute'
          The cited text must have at least this length (default 10)
          before it is hidden.

`W W C'
     Hide cited text in articles that aren't roots
     (`gnus-article-hide-citation-in-followups').  This isn't very
     useful as an interactive command, but might be a handy function to
     stick have happen automatically (*note Customizing Articles::).

   All these "hiding" commands are toggles, but if you give a negative
prefix to these commands, they will show what they have previously
hidden.  If you give a positive prefix, they will always hide.

   Also *note Article Highlighting:: for further variables for citation
customization.

   *Note Customizing Articles::, for how to hide article elements
automatically.


File: gnus,  Node: Article Washing,  Next: Article Buttons,  Prev: Article Hiding,  Up: Article Treatment

Article Washing
---------------

   We call this "article washing" for a really good reason.  Namely, the
`A' key was taken, so we had to use the `W' key instead.

   "Washing" is defined by us as "changing something from something to
something else", but normally results in something looking better.
Cleaner, perhaps.

`W l'
     Remove page breaks from the current article
     (`gnus-summary-stop-page-breaking').  *Note Misc Article::, for
     page delimiters.

`W r'
     Do a Caesar rotate (rot13) on the article buffer
     (`gnus-summary-caesar-message').  Unreadable articles that tell
     you to read them with Caesar rotate or rot13.  (Typically
     offensive jokes and such.)

     It's commonly called "rot13" because each letter is rotated 13
     positions in the alphabet, e. g. `B' (letter #2) -> `O' (letter
     #15).  It is sometimes referred to as "Caesar rotate" because
     Caesar is rumored to have employed this form of, uh, somewhat weak
     encryption.

`W t'

`t'
     Toggle whether to display all headers in the article buffer
     (`gnus-summary-toggle-header').

`W v'
     Toggle whether to display all headers in the article buffer
     permanently (`gnus-summary-verbose-header').

`W o'
     Treat overstrike (`gnus-article-treat-overstrike').

`W d'
     Treat M****s*** sm*rtq**t*s according to
     `gnus-article-dumbquotes-map' (`gnus-article-treat-dumbquotes').
     Note that this function guesses whether a character is a
     sm*rtq**t* or not, so it should only be used interactively.

     Sm*rtq**t*s are M****s***'s unilateral extension to the character
     map in an attempt to provide more quoting characters.  If you see
     something like `\222' or `\264' where you're expecting some kind of
     apostrophe or quotation mark, then try this wash.

`W w'
     Do word wrap (`gnus-article-fill-cited-article').

     You can give the command a numerical prefix to specify the width
     to use when filling.

`W Q'
     Fill long lines (`gnus-article-fill-long-lines').

`W C'
     Capitalize the first word in each sentence
     (`gnus-article-capitalize-sentences').

`W c'
     Translate CRLF pairs (i. e., `^M's on the end of the lines) into LF
     (this takes care of DOS line endings), and then translate any
     remaining CRs into LF (this takes care of Mac line endings)
     (`gnus-article-remove-cr').

`W q'
     Treat quoted-printable (`gnus-article-de-quoted-unreadable').
     Quoted-Printable is one common MIME encoding employed when sending
     non-ASCII (i. e., 8-bit) articles.  It typically makes strings like
     `déjà vu' look like `d=E9j=E0 vu', which doesn't look very
     readable to me.  Note that the this is usually done automatically
     by Gnus if the message in question has a
     `Content-Transfer-Encoding' header that says that this encoding
     has been done.

`W 6'
     Treat base64 (`gnus-article-de-base64-unreadable').  Base64 is one
     common MIME encoding employed when sending non-ASCII (i. e.,
     8-bit) articles.  Note that the this is usually done automatically
     by Gnus if the message in question has a
     `Content-Transfer-Encoding' header that says that this encoding has
     been done.

`W Z'
     Treat HZ or HZP (`gnus-article-decode-HZ').  HZ (or HZP) is one
     common encoding employed when sending Chinese articles.  It
     typically makes strings look like `~{<:Ky2;S{#,NpJ)l6HK!#~}'.

`W h'
     Treat HTML (`gnus-article-wash-html').  Note that the this is
     usually done automatically by Gnus if the message in question has
     a `Content-Type' header that says that this type has been done.

`W f'
     Look for and display any X-Face headers
     (`gnus-article-display-x-face').  The command executed by this
     function is given by the `gnus-article-x-face-command' variable.
     If this variable is a string, this string will be executed in a
     sub-shell.  If it is a function, this function will be called with
     the face as the argument.  If the `gnus-article-x-face-too-ugly'
     (which is a regexp) matches the `From' header, the face will not
     be shown.  The default action under Emacs is to fork off the
     `display' program(1) to view the face.  Under XEmacs or Emacs 21+
     with suitable image support, the default action is to display the
     face before the `From' header.  (It's nicer if XEmacs has been
     compiled with X-Face support--that will make display somewhat
     faster.  If there's no native X-Face support, Gnus will try to
     convert the `X-Face' header using external programs from the
     `pbmplus' package and friends.(2))  If you want to have this
     function in the display hook, it should probably come last.

`W b'
     Add clickable buttons to the article (`gnus-article-add-buttons').
     *Note Article Buttons::.

`W B'
     Add clickable buttons to the article headers
     (`gnus-article-add-buttons-to-head').

`W W H'
     Strip headers like the `X-No-Archive' header from the beginning of
     article bodies (`gnus-article-strip-headers-from-body').

`W E l'
     Remove all blank lines from the beginning of the article
     (`gnus-article-strip-leading-blank-lines').

`W E m'
     Replace all blank lines with empty lines and then all multiple
     empty lines with a single empty line.
     (`gnus-article-strip-multiple-blank-lines').

`W E t'
     Remove all blank lines at the end of the article
     (`gnus-article-remove-trailing-blank-lines').

`W E a'
     Do all the three commands above (`gnus-article-strip-blank-lines').

`W E A'
     Remove all blank lines (`gnus-article-strip-all-blank-lines').

`W E s'
     Remove all white space from the beginning of all lines of the
     article body (`gnus-article-strip-leading-space').

`W E e'
     Remove all white space from the end of all lines of the article
     body (`gnus-article-strip-trailing-space').

   *Note Customizing Articles::, for how to wash articles automatically.

   ---------- Footnotes ----------

   (1) `display' is from the ImageMagick package.  For the `uncompface'
and `icontopbm' programs look for a package like `compface' or
`faces-xface' on a GNU/Linux system.

   (2) On a GNU/Linux system look for packages with names like `netpbm'
or `libgr-progs'.


File: gnus,  Node: Article Buttons,  Next: Article Date,  Prev: Article Washing,  Up: Article Treatment

Article Buttons
---------------

   People often include references to other stuff in articles, and it
would be nice if Gnus could just fetch whatever it is that people talk
about with the minimum of fuzz when you hit `RET' or use the middle
mouse button on these references.

   Gnus adds "buttons" to certain standard references by default:
Well-formed URLs, mail addresses and Message-IDs.  This is controlled by
two variables, one that handles article bodies and one that handles
article heads:

`gnus-button-alist'
     This is an alist where each entry has this form:

          (REGEXP BUTTON-PAR USE-P FUNCTION DATA-PAR)

    REGEXP
          All text that match this regular expression will be
          considered an external reference.  Here's a typical regexp
          that matches embedded URLs: `<URL:\\([^\n\r>]*\\)>'.

    BUTTON-PAR
          Gnus has to know which parts of the matches is to be
          highlighted.  This is a number that says what sub-expression
          of the regexp is to be highlighted.  If you want it all
          highlighted, you use 0 here.

    USE-P
          This form will be `eval'ed, and if the result is non-`nil',
          this is considered a match.  This is useful if you want extra
          sifting to avoid false matches.

    FUNCTION
          This function will be called when you click on this button.

    DATA-PAR
          As with BUTTON-PAR, this is a sub-expression number, but this
          one says which part of the match is to be sent as data to
          FUNCTION.

     So the full entry for buttonizing URLs is then

          ("<URL:\\([^\n\r>]*\\)>" 0 t gnus-button-url 1)

`gnus-header-button-alist'
     This is just like the other alist, except that it is applied to the
     article head only, and that each entry has an additional element
     that is used to say what headers to apply the buttonize coding to:

          (HEADER REGEXP BUTTON-PAR USE-P FUNCTION DATA-PAR)

     HEADER is a regular expression.

`gnus-button-url-regexp'
     A regular expression that matches embedded URLs.  It is used in the
     default values of the variables above.

`gnus-article-button-face'
     Face used on buttons.

`gnus-article-mouse-face'
     Face used when the mouse cursor is over a button.

   *Note Customizing Articles::, for how to buttonize articles
automatically.


File: gnus,  Node: Article Date,  Next: Article Signature,  Prev: Article Buttons,  Up: Article Treatment

Article Date
------------

   The date is most likely generated in some obscure timezone you've
never heard of, so it's quite nice to be able to find out what the time
was when the article was sent.

`W T u'
     Display the date in UT (aka. GMT, aka ZULU)
     (`gnus-article-date-ut').

`W T i'
     Display the date in international format, aka. ISO 8601
     (`gnus-article-date-iso8601').

`W T l'
     Display the date in the local timezone (`gnus-article-date-local').

`W T s'
     Display the date using a user-defined format
     (`gnus-article-date-user').  The format is specified by the
     `gnus-article-time-format' variable, and is a string that's passed
     to `format-time-string'.  See the documentation of that variable
     for a list of possible format specs.

`W T e'
     Say how much time has elapsed between the article was posted and
     now (`gnus-article-date-lapsed').  It looks something like:

          X-Sent: 9 years, 6 weeks, 4 days, 9 hours, 3 minutes, 28 seconds ago

     The value of `gnus-article-date-lapsed-new-header' determines
     whether this header will just be added below the old Date one, or
     will replace it.

     An advantage of using Gnus to read mail is that it converts simple
     bugs into wonderful absurdities.

     If you want to have this line updated continually, you can put

          (gnus-start-date-timer)

     in your `.gnus.el' file, or you can run it off of some hook.  If
     you want to stop the timer, you can use the `gnus-stop-date-timer'
     command.

`W T o'
     Display the original date (`gnus-article-date-original').  This can
     be useful if you normally use some other conversion function and
     are worried that it might be doing something totally wrong.  Say,
     claiming that the article was posted in 1854.  Although something
     like that is _totally_ impossible.  Don't you trust me? *titter*

   *Note Customizing Articles::, for how to display the date in your
preferred format automatically.


File: gnus,  Node: Article Signature,  Next: Article Miscellania,  Prev: Article Date,  Up: Article Treatment

Article Signature
-----------------

   Each article is divided into two parts--the head and the body.  The
body can be divided into a signature part and a text part.  The variable
that says what is to be considered a signature is
`gnus-signature-separator'.  This is normally the standard `^-- $' as
mandated by son-of-RFC 1036.  However, many people use non-standard
signature separators, so this variable can also be a list of regular
expressions to be tested, one by one.  (Searches are done from the end
of the body towards the beginning.)  One likely value is:

     (setq gnus-signature-separator
           '("^-- $"         ; The standard
             "^-- *$"        ; A common mangling
             "^-------*$"    ; Many people just use a looong
                             ; line of dashes.  Shame!
             "^ *--------*$" ; Double-shame!
             "^________*$"   ; Underscores are also popular
             "^========*$")) ; Pervert!

   The more permissive you are, the more likely it is that you'll get
false positives.

   `gnus-signature-limit' provides a limit to what is considered a
signature when displaying articles.

  1. If it is an integer, no signature may be longer (in characters)
     than that integer.

  2. If it is a floating point number, no signature may be longer (in
     lines) than that number.

  3. If it is a function, the function will be called without any
     parameters, and if it returns `nil', there is no signature in the
     buffer.

  4. If it is a string, it will be used as a regexp.  If it matches,
     the text in question is not a signature.

   This variable can also be a list where the elements may be of the
types listed above.  Here's an example:

     (setq gnus-signature-limit
           '(200.0 "^---*Forwarded article"))

   This means that if there are more than 200 lines after the signature
separator, or the text after the signature separator is matched by the
regular expression `^---*Forwarded article', then it isn't a signature
after all.


File: gnus,  Node: Article Miscellania,  Prev: Article Signature,  Up: Article Treatment

Article Miscellania
-------------------

`A t'
     Translate the article from one language to another
     (`gnus-article-babel').


File: gnus,  Node: MIME Commands,  Next: Charsets,  Prev: Article Treatment,  Up: The Summary Buffer

MIME Commands
=============

   The following commands all understand the numerical prefix.  For
instance, `3 b' means "view the third MIME part".

`b'
`K v'
     View the MIME part.

`K o'
     Save the MIME part.

`K c'
     Copy the MIME part.

`K e'
     View the MIME part externally.

`K i'
     View the MIME part internally.

`K |'
     Pipe the MIME part to an external command.

   The rest of these MIME commands do not use the numerical prefix in
the same manner:

`K b'
     Make all the MIME parts have buttons in front of them.  This is
     mostly useful if you wish to save (or perform other actions) on
     inlined parts.

`K m'
     Some multipart messages are transmitted with missing or faulty
     headers.  This command will attempt to "repair" these messages so
     that they can be viewed in a more pleasant manner
     (`gnus-summary-repair-multipart').

`X m'
     Save all parts matching a MIME type to a directory
     (`gnus-summary-save-parts').  Understands the process/prefix
     convention (*note Process/Prefix::).

`M-t'
     Toggle the buttonized display of the article buffer
     (`gnus-summary-toggle-display-buttonized').

`W M w'
     Decode RFC 2047-encoded words in the article headers
     (`gnus-article-decode-mime-words').

`W M c'
     Decode encoded article bodies as well as charsets
     (`gnus-article-decode-charset').

     This command looks in the `Content-Type' header to determine the
     charset.  If there is no such header in the article, you can give
     it a prefix, which will prompt for the charset to decode as.  In
     regional groups where people post using some common encoding (but
     do not include MIME headers), you can set the `charset'
     group/topic parameter to the required charset (*note Group
     Parameters::).

`W M v'
     View all the MIME parts in the current article
     (`gnus-mime-view-all-parts').

   Relevant variables:

`gnus-ignored-mime-types'
     This is a list of regexps.  MIME types that match a regexp from
     this list will be completely ignored by Gnus.  The default value is
     `nil'.

     To have all Vcards be ignored, you'd say something like this:

          (setq gnus-ignored-mime-types
                '("text/x-vcard"))

`gnus-unbuttonized-mime-types'
     This is a list of regexps.  MIME types that match a regexp from
     this list won't have MIME buttons inserted unless they aren't
     displayed.  The default value is `(".*/.*")'.

`gnus-article-mime-part-function'
     For each MIME part, this function will be called with the MIME
     handle as the parameter.  The function is meant to be used to allow
     users to gather information from the article (e. g., add Vcard
     info to the bbdb database) or to do actions based on parts (e. g.,
     automatically save all jpegs into some directory).

     Here's an example function the does the latter:

          (defun my-save-all-jpeg-parts (handle)
            (when (equal (car (mm-handle-type handle)) "image/jpeg")
              (with-temp-buffer
                (insert (mm-get-part handle))
                (write-region (point-min) (point-max)
                              (read-file-name "Save jpeg to: ")))))
          (setq gnus-article-mime-part-function
                'my-save-all-jpeg-parts)

`gnus-mime-multipart-functions'
     Alist of MIME multipart types and functions to handle them.


File: gnus,  Node: Charsets,  Next: Article Commands,  Prev: MIME Commands,  Up: The Summary Buffer

Charsets
========

   People use different charsets, and we have MIME to let us know what
charsets they use.  Or rather, we wish we had.  Many people use
newsreaders and mailers that do not understand or use MIME, and just
send out messages without saying what character sets they use.  To help
a bit with this, some local news hierarchies have policies that say
what character set is the default.  For instance, the `fj' hierarchy
uses `iso-2022-jp-2'.

   This knowledge is encoded in the `gnus-group-charset-alist'
variable, which is an alist of regexps (to match group names) and
default charsets to be used when reading these groups.

   In addition, some people do use soi-disant MIME-aware agents that
aren't.  These blitely mark messages as being in `iso-8859-1' even if
they really are in `koi-8'.  To help here, the
`gnus-newsgroup-ignored-charsets' variable can be used.  The charsets
that are listed here will be ignored.  The variable can be set on a
group-by-group basis using the group parameters (*note Group
Parameters::).  The default value is `(unknown-8bit)', which is
something some agents insist on having in there.

   When posting, `gnus-group-posting-charset-alist' is used to
determine which charsets should not be encoded using the MIME
encodings.  For instance, some hierarchies discourage using
quoted-printable header encoding.

   This variable is an alist of regexps and permitted unencoded charsets
for posting.  Each element of the alist has the form `('TEST HEADER
BODY-LIST`)', where:

TEST
     is either a regular expression matching the newsgroup header or a
     variable to query,

HEADER
     is the charset which may be left unencoded in the header (`nil'
     means encode all charsets),

BODY-LIST
     is a list of charsets which may be encoded using 8bit
     content-transfer encoding in the body, or one of the special
     values `nil' (always encode using quoted-printable) or `t' (always
     use 8bit).

   Other charset tricks that may be useful, although not Gnus-specific:

   If there are several MIME charsets that encode the same Emacs
charset, you can choose what charset to use by saying the following:

     (put-charset-property 'cyrillic-iso8859-5
                           'preferred-coding-system 'koi8-r)

   This means that Russian will be encoded using `koi8-r' instead of
the default `iso-8859-5' MIME charset.

   If you want to read messages in `koi8-u', you can cheat and say

     (define-coding-system-alias 'koi8-u 'koi8-r)

   This will almost do the right thing.

   And finally, to read charsets like `windows-1251', you can say
something like

     (codepage-setup 1251)
     (define-coding-system-alias 'windows-1251 'cp1251)


File: gnus,  Node: Article Commands,  Next: Summary Sorting,  Prev: Charsets,  Up: The Summary Buffer

Article Commands
================

`A P'
     Generate and print a PostScript image of the article buffer
     (`gnus-summary-print-article').  `gnus-ps-print-hook' will be run
     just before printing the buffer.


File: gnus,  Node: Summary Sorting,  Next: Finding the Parent,  Prev: Article Commands,  Up: The Summary Buffer

Summary Sorting
===============

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

`C-c C-s C-n'
     Sort by article number (`gnus-summary-sort-by-number').

`C-c C-s C-a'
     Sort by author (`gnus-summary-sort-by-author').

`C-c C-s C-s'
     Sort by subject (`gnus-summary-sort-by-subject').

`C-c C-s C-d'
     Sort by date (`gnus-summary-sort-by-date').

`C-c C-s C-l'
     Sort by lines (`gnus-summary-sort-by-lines').

`C-c C-s C-c'
     Sort by article length (`gnus-summary-sort-by-chars').

`C-c C-s C-i'
     Sort by score (`gnus-summary-sort-by-score').

   These functions will work both when you use threading and when you
don't use threading.  In the latter case, all summary lines will be
sorted, line by line.  In the former case, sorting will be done on a
root-by-root basis, which might not be what you were looking for.  To
toggle whether to use threading, type `T T' (*note Thread Commands::).


File: gnus,  Node: Finding the Parent,  Next: Alternative Approaches,  Prev: Summary Sorting,  Up: The Summary Buffer

Finding the Parent
==================

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

     If given a positive numerical prefix, fetch that many articles
     back into the ancestry.  If given a negative numerical prefix,
     fetch just that ancestor.  So if you say `3 ^', Gnus will fetch
     the parent, the grandparent and the grandgrandparent of the
     current article.  If you say `-3 ^', Gnus will only fetch the
     grandgrandparent of the current article.

`A R (Summary)'
     Fetch all articles mentioned in the `References' header of the
     article (`gnus-summary-refer-references').

`A T (Summary)'
     Display the full thread where the current article appears
     (`gnus-summary-refer-thread').  This command has to fetch all the
     headers in the current group to work, so it usually takes a while.
     If you do it often, you may consider setting
     `gnus-fetch-old-headers' to `invisible' (*note Filling In
     Threads::).  This won't have any visible effects normally, but
     it'll make this command work a whole lot faster.  Of course, it'll
     make group entry somewhat slow.

     The `gnus-refer-thread-limit' variable says how many old (i. e.,
     articles before the first displayed in the current group) headers
     to fetch when doing this command.  The default is 200.  If `t', all
     the available headers will be fetched.  This variable can be
     overridden by giving the `A T' command a numerical prefix.

`M-^ (Summary)'
     You can also ask the NNTP server for an arbitrary article, no
     matter what group it belongs to.  `M-^'
     (`gnus-summary-refer-article') will ask you for a `Message-ID',
     which is one of those long, hard-to-read thingies that look
     something like `<38o6up$6f2@hymir.ifi.uio.no>'.  You have to get
     it all exactly right.  No fuzzy searches, I'm afraid.

   The current select method will be used when fetching by `Message-ID'
from non-news select method, but you can override this by giving this
command a prefix.

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

   It can also be a list of select methods, as well as the special
symbol `current', which means to use the current select method.  If it
is a list, Gnus will try all the methods in the list until it finds a
match.

   Here's an example setting that will first try the current method, and
then ask Deja if that fails:

     (setq gnus-refer-article-method
           '(current
             (nnweb "refer" (nnweb-type dejanews))))

   Most of the mail backends support fetching by `Message-ID', but do
not do a particularly excellent job at it.  That is, `nnmbox' and
`nnbabyl' are able to locate articles from any groups, while `nnml' and
`nnfolder' are only able to locate articles that have been posted to
the current group.  (Anything else would be too time consuming.)
`nnmh' does not support this at all.


File: gnus,  Node: Alternative Approaches,  Next: Tree Display,  Prev: Finding the Parent,  Up: The Summary Buffer

Alternative Approaches
======================

   Different people like to read news using different methods.  This
being Gnus, we offer a small selection of minor modes for the summary
buffers.

* Menu:

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


File: gnus,  Node: Pick and Read,  Next: Binary Groups,  Up: Alternative Approaches

Pick and Read
-------------

   Some newsreaders (like `nn' and, uhm, `Netnews' on VM/CMS) use a
two-phased reading interface.  The user first marks in a summary buffer
the articles she wants to read.  Then she starts reading the articles
with just an article buffer displayed.

   Gnus provides a summary buffer minor mode that allows
this--`gnus-pick-mode'.  This basically means that a few process mark
commands become one-keystroke commands to allow easy marking, and it
provides one additional command for switching to the summary buffer.

   Here are the available keystrokes when using pick mode:

`.'
     Pick the article or thread on the current line
     (`gnus-pick-article-or-thread').  If the variable
     `gnus-thread-hide-subtree' is true, then this key selects the
     entire thread when used at the first article of the thread.
     Otherwise, it selects just the article.  If given a numerical
     prefix, go to that thread or article and pick it.  (The line
     number is normally displayed at the beginning of the summary pick
     lines.)

`SPACE'
     Scroll the summary buffer up one page (`gnus-pick-next-page').  If
     at the end of the buffer, start reading the picked articles.

`u'
     Unpick the thread or article
     (`gnus-pick-unmark-article-or-thread').  If the variable
     `gnus-thread-hide-subtree' is true, then this key unpicks the
     thread if used at the first article of the thread.  Otherwise it
     unpicks just the article.  You can give this key a numerical
     prefix to unpick the thread or article at that line.

`RET'
     Start reading the picked articles (`gnus-pick-start-reading').  If
     given a prefix, mark all unpicked articles as read first.  If
     `gnus-pick-display-summary' is non-`nil', the summary buffer will
     still be visible when you are reading.

   All the normal summary mode commands are still available in the
pick-mode, with the exception of `u'.  However `!' is available which
is mapped to the same function `gnus-summary-tick-article-forward'.

   If this sounds like a good idea to you, you could say:

     (add-hook 'gnus-summary-mode-hook 'gnus-pick-mode)

   `gnus-pick-mode-hook' is run in pick minor mode buffers.

   If `gnus-mark-unpicked-articles-as-read' is non-`nil', mark all
unpicked articles as read.  The default is `nil'.

   The summary line format in pick mode is slightly different from the
standard format.  At the beginning of each line the line number is
displayed.  The pick mode line format is controlled by the
`gnus-summary-pick-line-format' variable (*note Formatting
Variables::).  It accepts the same format specs that
`gnus-summary-line-format' does (*note Summary Buffer Lines::).


File: gnus,  Node: Binary Groups,  Prev: Pick and Read,  Up: Alternative Approaches

Binary Groups
-------------

   If you spend much time in binary groups, you may grow tired of
hitting `X u', `n', `RET' all the time.  `M-x gnus-binary-mode' is a
minor mode for summary buffers that makes all ordinary Gnus article
selection functions uudecode series of articles and display the result
instead of just displaying the articles the normal way.

   The only way, in fact, to see the actual articles is the `g'
command, when you have turned on this mode (`gnus-binary-show-article').

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


File: gnus,  Node: Tree Display,  Next: Mail Group Commands,  Prev: Alternative Approaches,  Up: The Summary Buffer

Tree Display
============

   If you don't like the normal Gnus summary display, you might try
setting `gnus-use-trees' to `t'.  This will create (by default) an
additional "tree buffer".  You can execute all summary mode commands in
the tree buffer.

   There are a few variables to customize the tree display, of course:

`gnus-tree-mode-hook'
     A hook called in all tree mode buffers.

`gnus-tree-mode-line-format'
     A format string for the mode bar in the tree mode buffers (*note
     Mode Line Formatting::).  The default is `Gnus: %%b %S %Z'.  For a
     list of valid specs, *note Summary Buffer Mode Line::.

`gnus-selected-tree-face'
     Face used for highlighting the selected article in the tree
     buffer.  The default is `modeline'.

`gnus-tree-line-format'
     A format string for the tree nodes.  The name is a bit of a
     misnomer, though--it doesn't define a line, but just the node.
     The default value is `%(%[%3,3n%]%)', which displays the first
     three characters of the name of the poster.  It is vital that all
     nodes are of the same length, so you _must_ use `%4,4n'-like
     specifiers.

     Valid specs are:

    `n'
          The name of the poster.

    `f'
          The `From' header.

    `N'
          The number of the article.

    `['
          The opening bracket.

    `]'
          The closing bracket.

    `s'
          The subject.

     *Note Formatting Variables::.

     Variables related to the display are:

    `gnus-tree-brackets'
          This is used for differentiating between "real" articles and
          "sparse" articles.  The format is `((REAL-OPEN . REAL-CLOSE)
          (SPARSE-OPEN . SPARSE-CLOSE) (DUMMY-OPEN . DUMMY-CLOSE))',
          and the default is `((?[ . ?]) (?( . ?)) (?{ . ?}) (?< .
          ?>))'.

    `gnus-tree-parent-child-edges'
          This is a list that contains the characters used for
          connecting parent nodes to their children.  The default is
          `(?- ?\\ ?|)'.

`gnus-tree-minimize-window'
     If this variable is non-`nil', Gnus will try to keep the tree
     buffer as small as possible to allow more room for the other Gnus
     windows.  If this variable is a number, the tree buffer will never
     be higher than that number.  The default is `t'.  Note that if you
     have several windows displayed side-by-side in a frame and the tree
     buffer is one of these, minimizing the tree window will also
     resize all other windows displayed next to it.

`gnus-generate-tree-function'
     The function that actually generates the thread tree.  Two
     predefined functions are available:
     `gnus-generate-horizontal-tree' and `gnus-generate-vertical-tree'
     (which is the default).

   Here's an example from a horizontal tree buffer:

     {***}-(***)-[odd]-[Gun]
          |      \[Jan]
          |      \[odd]-[Eri]
          |      \(***)-[Eri]
          |            \[odd]-[Paa]
          \[Bjo]
          \[Gun]
          \[Gun]-[Jor]

   Here's the same thread displayed in a vertical tree buffer:

     {***}
       |--------------------------\-----\-----\
     (***)                         [Bjo] [Gun] [Gun]
       |--\-----\-----\                          |
     [odd] [Jan] [odd] (***)                   [Jor]
       |           |     |--\
     [Gun]       [Eri] [Eri] [odd]
                               |
                             [Paa]

   If you're using horizontal trees, it might be nice to display the
trees side-by-side with the summary buffer.  You could add something
like the following to your `.gnus.el' file:

     (setq gnus-use-trees t
           gnus-generate-tree-function 'gnus-generate-horizontal-tree
           gnus-tree-minimize-window nil)
     (gnus-add-configuration
      '(article
        (vertical 1.0
                  (horizontal 0.25
                              (summary 0.75 point)
                              (tree 1.0))
                  (article 1.0))))

   *Note Windows Configuration::.

