This is Info file ../info/gnus, produced by Makeinfo-1.55 from the input file gnus.texi. This file documents Gnus, the GNU Emacs newsreader. Copyright (C) 1995 Free Software Foundation, Inc. Permission is granted to make and distribute verbatim copies of this manual provided the copyright notice and this permission notice are preserved on all copies. Permission is granted to copy and distribute modified versions of this manual under the conditions for verbatim copying, provided also that the entire resulting derived work is distributed under the terms of a permission notice identical to this one. Permission is granted to copy and distribute translations of this manual into another language, under the above conditions for modified versions.  File: gnus, Node: Summary Buffer Format, Next: Summary Maneuvering, Up: The Summary Buffer Summary Buffer Format ===================== * Menu: * Summary Buffer Lines:: You can specify how summary lines should look. * Summary Buffer Mode Line:: You can say how the mode line should look. Gnus will use the value of the `gnus-extract-address-components' variable as a function for getting the name and address parts of a `From' header. Two pre-defined function exist: `gnus-extract-address-components', which is the default, quite fast, and too simplistic solution, and `mail-extract-address-components', which works very nicely, but is slower. `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.  File: gnus, Node: Summary Buffer Lines, Next: Summary Buffer Mode Line, Up: Summary Buffer Format Summary Buffer Lines -------------------- You can change the format of the lines in the summary buffer by changing the `gnus-summary-line-format' variable. It works along the same lines a a normal `format' string, with some extensions. The default string is `"%U%R%z%I%(%[%4L: %-20,20n%]%) %s\n"'. The following format specification characters are understood: `N' Article number. `S' Subject string. `s' Subject if the article is the root, `gnus-summary-same-subject' otherwise. `F' Full `From' line. `n' The name (from the `From' header). `a' The name (from the `From' header). This differs from the `n' spec in that it uses `gnus-extract-address-components', which is slower, but may be more thorough. `A' The address (from the `From' header). This works the same way as the `a' spec. `L' Number of lines in the article. `c' Number of characters in the article. `I' Indentation based on thread level (*note Customizing Threading::.). `T' Nothing if the article is a root and lots of spaces if it isn't (it pushes everything after it off the screen). `\[' Opening bracket, which is normally `\[', but can also be `<' for adopted articles. `\]' Closing bracket, which is normally `\]', but can also be `>' for adopted articles. `<' One space for each thread level. `>' Twenty minus thread level spaces. `U' Unread. `R' Replied. `i' Score as a number. `z' Zcore, `+' if above the default level and `-' if below the default level. If the difference between `gnus-summary-default-level' and the score is less than `gnus-summary-zcore-fuzz', this spec will not be used. `x' `Xref'. `D' `Date'. `M' `Message-Id'. `r' `References'. `t' Number of articles in the current sub-thread. Using this spec will slow down summary buffer generation somewhat. `e' A single character will be displayed if the article has any children. `u' User defined specifier. The next character in the format string should be a letter. GNUS will call the function `gnus-user-format-function-'`X', where `X' is the letter following `%u'. The function will be passed the current header as argument. The function should return a string, which will be inserted into the summary just like information from any other summary specifier. Text between `%(' and `%)' will be highlighted with `gnus-mouse-face' when the mouse point is placed inside the area. There can only be one such area. The `%U' (status), `%R' (replied) and `%z' (zcore) specs have to be handled with care. For reasons of efficiency, Gnus will compute what column these characters will end up in, and "hard-code" that. This means that it is illegal to have these specs after a variable-length spec. Well, you might not be arrested, but your summary buffer will look strange, which is bad enough. The smart choice is to have these specs as far to the left as possible. (Isn't that the case with everything, though? But I digress.) This restriction may disappear in later versions of Gnus.  File: gnus, Node: Summary Buffer Mode Line, Prev: Summary Buffer Lines, Up: Summary Buffer Format Summary Buffer Mode Line ------------------------ You can also change the format of the summary mode bar. Set `gnus-summary-mode-line-format' to whatever you like. Here are the elements you can play with: `G' Group name. `A' Current article number. `V' Gnus version. `U' Number of unread articles in this group. `e' Number of unselected articles in this group. `Z' A string with the number of unread and unselected articles represented either as `<%U(+%u) more>' if there are both unread and unselected articles, and just as `<%U more>' if there are just unread articles and no unselected ones. `g' Shortish group name. For instance, `rec.arts.anime' will be shortened to `r.a.anime'. `S' Subject of the current article. `u' Used-defined spec. `s' Name of the current score file.  File: gnus, Node: Summary Maneuvering, Next: Choosing Articles, Prev: Summary Buffer Format, Up: The Summary Buffer Summary Maneuvering =================== All the straight movement commands understand the numeric prefix and behave pretty much as you'd expect. None of these commands select articles. `G M-n' `M-n' Go to the next summary line of an unread article (`gnus-summary-next-unread-subject'). `G M-p' `M-p' Go to the previous summary line of an unread article (`gnus-summary-prev-unread-subject'). `G g' `j' Ask for an article number and then go to this summary line (`gnus-summary-goto-subject'). If you are at the end of the group and issue one of the movement commands, Gnus will offer to go to the next group. If `gnus-auto-select-next' is `t' and the next group is empty, Gnus will exit summary mode and return to the group buffer. If this variable is neither `t' nor `nil', Gnus will select the next group, no matter whether it has any unread articles or not. As a special case, if this variable is `quietly', Gnus will select the next group without asking for confirmation. Also *Note Group Levels::. If Gnus asks you to press a key to confirm going to the next group, you can use the `C-n' and `C-p' keys to move around the group buffer, searching for the next group to read without actually returning to the group buffer. If `gnus-auto-select-same' is non-`nil', all the movement commands will try to go to the next article with the same subject as the current. This variable is not particularly useful if you use a threaded display. If `gnus-summary-check-current' is non-`nil', all the "unread" movement commands will not proceed to the next (or previous) article if the current article is unread. Instead, they will choose the current article. If `gnus-auto-center-summary' is non-`nil', Gnus will keep the point in the summary buffer centered at all times. This makes things quite tidy, but if you have a slow network connection, or simply do not like this un-Emacsism, you can set this variable to `nil' to get the normal Emacs scrolling action.  File: gnus, Node: Choosing Articles, Next: Paging the Article, Prev: Summary Maneuvering, Up: The Summary Buffer Choosing Articles ================= None of the following movement commands understand the numeric prefix, and they all select and display an article. `SPACE' Select the current article, or, if that one's read already, the next unread article (`gnus-summary-next-page'). `G n' `n' Go to next unread article (`gnus-summary-next-unread-article'). `G p' `p' Go to previous unread article (`gnus-summary-prev-unread-article'). `G N' `N' Go to the next article (`gnus-summary-next-article'). `G P' `P' Go to the previous article (`gnus-summary-prev-article'). `G C-n' Go to the next article with the same subject (`gnus-summary-next-same-subject'). `G C-p' Go to the previous article with the same subject (`gnus-summary-prev-same-subject'). `G f' `.' Go to the first unread article (`gnus-summary-first-unread-article'). `G b' `,' Go to the article with the highest score (`gnus-summary-best-unread-article'). `G l' `l' Go to the previous article read (`gnus-summary-goto-last-article'). `G p' Pop an article off the summary history and go to this article (`gnus-summary-pop-article'). This command differs from the command above in that you can pop as many previous articles off the history as you like. Some variables that are relevant for moving and selecting articles: `gnus-auto-extend-newsgroup' All the movement commands will try to go to the previous (or next) article, even if that article isn't displayed in the Summary buffer if this variable is non-`nil'. Gnus will then fetch the article from the server and display it in the article buffer. `gnus-select-article-hook' This hook is called whenever an article is selected. By default it exposes any threads hidden under the selected article. `gnus-mark-article-hook' This hook is called whenever an article is selected. It is intended to be used for marking articles as read. `gnus-visual-mark-article-hook' This hook is run after selecting an article. It is meant to be used for highlighting the article in some way. It is not run if `gnus-visual' is `nil'. `gnus-summary-update-hook' This hook is called when a summary line is changed. It is not run if `gnus-visual' is `nil'. `gnus-summary-selected-face' This is the face (or "font" as some people call it) that is used to highlight the current article in the summary buffer. `gnus-summary-highlight' Summary lines are highlighted according to this variable, which is a list where the elements are on the format `(FORM . FACE)'. If you would, for instance, like ticked articles to be italic and high-scored articles to be bold, you could set this variable to something like (((eq mark gnus-ticked-mark) . italic) ((> score default) . bold)) As you may have guessed, if FORM returns a non-`nil' value, FACE will be applied to the line.  File: gnus, Node: Paging the Article, Next: Reply Followup and Post, Prev: Choosing Articles, Up: The Summary Buffer Scrolling the Article ===================== `SPACE' Pressing `SPACE' will scroll the current article forward one page, or, if you have come to the end of the current article, will choose the next article (`gnus-summary-next-page'). `DEL' Scroll the current article back one page (`gnus-summary-prev-page'). `RET' Scroll the current article one line forward (`gnus-summary-scroll-up'). `A <' `<' Scroll to the beginning of the article (`gnus-summary-beginning-of-article'). `A >' `>' Scroll to the end of the article (`gnus-summary-end-of-article').  File: gnus, Node: Reply Followup and Post, Next: Canceling and Superseding, Prev: Paging the Article, Up: The Summary Buffer Reply, Followup and Post ======================== All the commands for posting and mailing will put you in a post or mail buffer where you can edit the article all you like, before you send the article by pressing `C-c C-c'. If you are in a foreign news group, and you wish to post the article using the foreign server, you can give a prefix to `C-c C-c' to make Gnus try to post using the foreign server. * Menu: * Mail:: Mailing & replying. * Post:: Posting and following up. * Mail & Post:: Mailing and posting at the same time.  File: gnus, Node: Mail, Next: Post, Up: Reply Followup and Post Mail ---- Commands for composing a mail message: `S r' `r' Mail a reply to the author of the current article (`gnus-summary-reply'). `S R' `R' Mail a reply to the author of the current article and include the original message (`gnus-summary-reply-with-original'). This command uses the process/prefix convention. `S o m' Forward the current article to some other person (`gnus-summary-mail-forward'). `S o p' Forward the current article to a newsgroup (`gnus-summary-post-forward'). `S m' `m' Send a mail to some other person (`gnus-summary-mail-other-window'). `S O m' Digest the current series and forward the result using mail (`gnus-uu-digest-mail-forward'). This command uses the process/prefix convention (*note Process/Prefix::.). `S O p' Digest the current series and forward the result to a newsgroup (`gnus-uu-digest-mail-forward'). Variables for customizing outgoing mail: `gnus-reply-to-function' Gnus uses the normal methods to determine where replies are to go, but you can change the behavior to suit your needs by fiddling with this variable. If you want the replies to go to the `Sender' instead of the `From' in the group `mail.stupid-list', you could do something like this: (setq gnus-reply-to-function (lambda (group) (cond ((string= group "mail.stupid-list") (mail-fetch-field "sender")) (t nil)))) This function will be called narrowed to the head of the article that is being replied to. As you can see, this function should return a string if it has an opinion as to what the To header should be. If it does not, it should just return `nil', and the normal methods for determining the To header will be used. This function can also return a list. In that case, each list element should be a cons, where the car should be the name of an header (eg. `Cc') and the cdr should be the header value (eg. `larsi@ifi.uio.no'). All these headers will be inserted into the head of the outgoing mail. `gnus-mail-send-method' This variable says how a mail should be mailed. It uses the function in the `send-mail-function' variable as the default. `gnus-uu-digest-headers' List of regexps to match headers included in digested messages. The headers will be included in the sequence they are matched. `gnus-mail-hook' Hook called as the last thing after setting up a mail buffer. There are three "methods" for handling all mail. The default is `sendmail'. Some people like what `mh' does better, and some people prefer `vm'. Three variables for customizing what to use when: `gnus-mail-reply-method' This function is used to compose replies. The three functions avaibale are: * `gnus-mail-reply-using-mail' (sendmail) * `gnus-mail-reply-using-mhe' (mh) * `gnus-mail-reply-using-vm' (vm) `gnus-mail-forward-method' This function is used to forward messages. The three functions avaibale are: * `gnus-mail-forward-using-mail' (sendmail) * `gnus-mail-forward-using-mhe' (mh) * `gnus-mail-forward-using-vm' (vm) `gnus-mail-other-window-method' This function is used to send mails. The three functions avaibale are: * `gnus-mail-other-window-using-mail' (sendmail) * `gnus-mail-other-window-using-mhe' (mh) * `gnus-mail-other-window-using-vm' (vm)  File: gnus, Node: Post, Next: Mail & Post, Prev: Mail, Up: Reply Followup and Post Post ---- Commands for posting an article: `S p' `a' Post an article to the current group (`gnus-summary-post-news'). `S f' `f' Post a followup to the current article (`gnus-summary-followup'). `S F' `F' Post a followup to the current article and include the original message (`gnus-summary-followup-with-original'). This command uses the process/prefix convention. `S u' Uuencode a file, split it into parts, and post it as a series (`gnus-uu-post-news'). `gnus-required-headers' a list of header symbols. These headers will either be automatically generated, or, if that's impossible, they will be prompted for. The following symbols are legal: `From' This required header will be filled out with the result of the `gnus-inews-user-name' function, which depends on the `gnus-user-from-line', `gnus-user-login-name', `gnus-local-domain' and `user-mail-address' variables. `Subject' This required header will be prompted for if not present already. `Newsgroups' This required header says which newsgroups the article is to be posted to. If it isn't present already, it will be prompted for. `Organization' This optional header will be filled out depending on the `gnus-local-organization' variable. `gnus-organization-file' will be used if that variable is nil. `Lines' This optional header will be computed by Gnus. `Message-ID' This required header will be generated by Gnus. A unique ID will be created based on date, time, user name and system name. `X-Newsreader' This optional header will be filled out with the Gnus version numbers. In addition, you can enter conses into this list. The car of this cons should be a symbol who's name is the name of the header, and the cdr can either a string to be entered verbatim as the value of this header, or it can be a function to be called. This function should return a string to be inserted. For instance, if you want to insert `Mime-Version: 1.0', you should enter `(Mime-Version . "1.0")' into the list. If you want to insert a funny quote, you could enter something like `(X-Yow . yow)' into the list. The function `yow' will then be called without any arguments. Other variables for customizing outgoing articles: `gnus-post-method' If non-`nil', Gnus will use this method instead of the default select method when posting. `nntp-news-default-headers' If non-`nil', this variable will override `mail-default-headers' when posting. This variable should then be a string. This string will be inserted, as is, in the head of all outgoing articles. `gnus-use-followup-to' If `nil', always ignore the Followup-To header. If it is `t', use its value, but ignore the special value `poster', which will send the followup as a reply mail to the person you are responding to. If it is the symbol `ask', query the user before posting. If it is the symbol `use', always use the value. `gnus-followup-to-function' This variable is most useful in mail groups, where "following up" really means sending a mail to a list address. Gnus uses the normal methods to determine where follow-ups are to go, but you can change the behavior to suit your needs by fiddling with this variable. If you want the followups to go to the `Sender' instead of the `From' in the group `mail.stupid-list', you could do something like this: (setq gnus-followup-to-function (lambda (group) (cond ((string= group "mail.stupid-list") (mail-fetch-field "sender")) (t nil)))) This function will be called narrowed to header of the article that is being followed up. `gnus-removable-headers' Some headers that are generated are toxic to the NNTP server. These include the `NNTP-Posting-Host', `Bcc' and `Xref', so these headers are deleted if they are present in this list of symbols. `gnus-deletable-headers' Headers in this list that were previously generated by Gnus will be deleted before posting. Let's say you post an article. Then you decide to post it again to some other group, you naughty boy, so you jump back to the `*post-buf*' buffer, edit the `Newsgroups' line, and ship it off again. By default, this variable makes sure that the old generated `Message-ID' is deleted, and a new one generated. If this isn't done, the entire empire would probably crumble, anarchy would prevail, and cats would start walking on two legs and rule the world. Allegedly. `gnus-signature-function' If non-`nil', this variable should be a function that returns a signature file name. The function will be called with the name of the group being posted to. If the function returns a string that doesn't correspond to a file, the string itself is inserted. If the function returns `nil', the `gnus-signature-file' variable will be used instead. `gnus-post-prepare-function' This function is called with the name of the current group after the post buffer has been initialized, and can be used for inserting a signature. Nice if you use different signatures in different groups. `gnus-post-prepapare-hook' This hook is called after a post buffer has been prepared. If you want to insert a signature at this point, you could put `gnus-inews-insert-signature' into this hook. `news-reply-header-hook' A related variable when following up and replying is this variable, which inserts the "quote line". The default value is: (defvar news-reply-header-hook (lambda () (insert "In article " news-reply-yank-message-id " " news-reply-yank-from " writes:\n\n"))) This will create lines like: In article Lars Mars writes: Having the `Message-Id' in this line is probably overkill, so I would suggest this hook instead: (setq news-reply-header-hook (lambda () (insert news-reply-yank-from " writes:\n\n"))) `gnus-prepare-article-hook' This hook is called before the headers have been prepared. By default it inserts the signature specified by `gnus-signature-file'. `gnus-inews-article-function' This function is used to do the actual article processing and header checking/generation. `gnus-inews-article-hook' This hook is called right before the article is posted. By default it handles FCC processing (i.e., saving the article to a file.) `gnus-inews-article-header-hook' This hook is called after inserting the required headers in an article to be posted. The hook is called from the `*post-news*' buffer, narrowed to the head, and is intended for people who would like to insert additional headers, or just change headers in some way or other. `gnus-check-before-posting' If non-`nil', Gnus will attempt to check the legality of the headers, as well as some other stuff, before posting. You can control the granularity of the check by adding or removing elements from this list. Legal elemetents are: `subject-cmsg' Check the subject for commands. `multiple-headers' Check for the existence of multiple equal headers. `sendsys' Check for the existence of version and sendsys commands. `message-id' Check whether the `Message-ID' looks ok. `from' Check whether the `From' header seems nice. `long-lines' Check for too long lines. `control-chars' Check for illegal characters. `size' Check for excessive size. `new-text' Check whether there is any new text in the messages. `signature' Check the length of the signature  File: gnus, Node: Mail & Post, Prev: Post, Up: Reply Followup and Post Mail & Post ----------- Commands for sending mail and post at the same time: `S b' Post a followup and send a reply to the current article (`gnus-summary-followup-and-reply'). `S B' Post a followup and send a reply to the current article and include the original message (`gnus-summary-followup-and-reply-with-original'). This command uses the process/prefix convention. Here's a list of variables that are relevant to both mailing and posting: `gnus-signature-file' `mail-signature' If `gnus-signature-file' is non-`nil', it should be the name of a file containing a signature (`~/.signature' by default). This signature will be appended to all outgoing post. Most people find it more convenient to use `mail-signature', which (sort of) does the same, but inserts the signature into the buffer before you start editing the post (or mail). So - if you have both of these variables set, you will get two signatures. Note that `mail-signature' does not work the same way as `gnus-signature-file', which is a bit confusing. If `mail-signature' is `t', it will insert `~/.signature'. If it is a string, this string will be inserted. Note that RFC1036 says that a signature should be preceded by the three characters `-- ' on a line by themselves. This is to make it easier for the recipient to automatically recognize and process the signature. So don't remove those characters, even though you might feel that they ruin you beautiful design, like, totally. Also note that no signature should be more than four lines long. Including ASCII graphics is an efficient way to get everybody to believe that you are silly and have nothing important to say. `mail-yank-prefix' When you are replying to or following up an article, you normally want to quote the person you are answering. Inserting quoted text is done by "yanking", and each quoted line you yank will have `mail-yank-prefix' prepended to it. This is ` ' by default, which isn't very pretty. Most everybody prefers that lines are prepended with `> ', so `(setq mail-yank-prefix "> ")' in your `.emacs' file. `mail-yank-ignored-headers' When you yank a message, you do not want to quote any headers, so `(setq mail-yank-ignored-headers ":")'. `user-mail-address' If all of `gnus-user-login-name', `gnus-use-generic-from' and `gnus-local-domain' are `nil', Gnus will use `user-mail-address' as the address part of the `From' header. `gnus-user-from-line' Your full, complete e-mail address. This variable overrides the other Gnus variables if it is non-`nil'. Here are two example values of this variable: `"larsi@ifi.uio.no (Lars Magne Ingebrigtsen)"' and `"Lars Magne Ingebrigtsen "'. The latter version is recommended, but the name has to be quoted if it contains non-alpha-numerical characters - `"\"Lars M. Ingebrigtsen\" "'. `mail-default-headers' This is a string that will be inserted into the header of all outgoing mail messages and news articles. Convenient to use to insert standard headers. If `nntp-news-default-headers' is non-`nil', that variable will override this one when posting articles. `gnus-auto-mail-to-author' If `ask', you will be prompted for whether you want to send a mail copy to the author of the article you are following up. If non-`nil' and not `ask', Gnus will send a mail with a copy of all follow-ups to the authors of the articles you follow up. It's nice in one way - you make sure that the person you are responding to gets your response. Other people loathe this method and will hate you dearly for it, because it means that they will first get a mail, and then have to read the same article later when they read the news. It is `nil' by default. `gnus-mail-courtesy-message' This is a string that will be prepended to all mails that are the result of using the variable described above. You may want to do spell-checking on messages that you send out. Or, if you don't want to spell-check by hand, you could add automatic spell-checking via the `ispell' package: (add-hook 'news-inews-hook 'ispell-message) ;For news posts (add-hook 'mail-send-hook 'ispell-message) ;for mail posts via sendmail If you want to insert some MIME headers into the articles you post, without doing any actual encoding, you could add `gnus-inews-insert-mime-headers' to `gnus-inews-article-hook'.  File: gnus, Node: Canceling and Superseding, Next: Marking Articles, Prev: Reply Followup and Post, Up: The Summary Buffer Canceling Articles ================== Have you ever written something, and then decided that you really, really, really wish you hadn't posted that? Well, you can't cancel mail, but you can cancel posts. Find the article you wish to cancel (you can only cancel your own articles, so don't try any funny stuff). Then press `C' or `S c' (`gnus-summary-cancel-article'). Your article will be canceled - machines all over the world will be deleting your article. 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. If you discover that you have made some mistakes and want to do some corrections, you can post a "superseding" article that will replace your original article. Go to the original article and press `S s' (`gnus-summary-supersede-article'). You will be put in a buffer where you can edit the article all you want before sending it off the usual way. You probably want to delete some of the old headers before sending the superseding article - `Path' and `Date' are probably incorrect. Set `gnus-delete-supersedes-headers' to a regexp to match the lines you want removed. The default is `"^Path:\\|^Date"'. 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 `*post-buf*'). There you will find the article you just posted, with all the headers intact. Change the `Message-ID' header to a `Cancel' or `Supersedes' header by substituting one of those words for `Message-ID'. Then just press `C-c C-c' to send the article as you would do normally. The previous article will be canceled/superseded. Just remember, kids: There is no 'c' in 'supersede'.  File: gnus, Node: Marking Articles, Next: Threading, Prev: Canceling and Superseding, Up: The Summary Buffer Marking Articles ================ There are several marks you can set on an article. You have marks that decide the "readed-ness" (whoo, neato-keano neologism ohoy!) of the article. Alphabetic marks generally mean "read", while non-alphabetic characters generally mean "unread". In addition, you also have marks that do not affect readedness. * Menu: * Unread Articles:: Marks for unread articles. * Read Articles:: Marks for read articles. * Other Marks:: Marks that do not affect readedness. There's a plethora of commands for manipulating these marks: * Menu: * Setting Marks:: How to set and remove marks. * Setting Process Marks:: How to mark articles for later processing.  File: gnus, Node: Unread Articles, Next: Read Articles, Up: Marking Articles Unread Articles --------------- The following marks mark articles as unread, in one form or other. `!' "Ticked articles" are articles that will remain visible always. If you see an article that you find interesting, or you want to put off reading it, or replying to it, until sometime later, you'd typically tick it. However, articles can be expired, so if you want to keep an article forever, you'll have to save it. Ticked articles have a `!' (`gnus-ticked-mark') in the first column. `?' A "dormant" article is marked with a `?' (`gnus-dormant-mark'), and will only appear in the summary buffer if there are followups to it. `SPC' An "unread" article is marked with a `SPC' (`gnus-unread-mark'). These are articles that haven't been read at all yet.  File: gnus, Node: Read Articles, Next: Other Marks, Prev: Unread Articles, Up: Marking Articles Read Articles ------------- All the following marks mark articles as read. `D' Articles that are marked as read. They have a `r' (`gnus-del-mark') in the first column. These are articles that the user has marked as read more or less manually. `d' Articles that are actually read are marked with `R' (`gnus-read-mark'). `A' Articles that were marked as read in previous sessions are now "old" and marked with `O' (`gnus-ancient-mark'). `K' Marked as killed (`gnus-killed-mark'). `X' Marked as killed by kill files (`gnus-kill-file-mark'). `Y' Marked as read by having a too low score (`gnus-low-score-mark'). `C' Marked as read by a catchup (`gnus-catchup-mark'). `G' Canceled article (`gnus-cancelled-mark') All these marks just mean that the article is marked as read, really. They are interpreted differently by the adaptive scoring scheme, however. One more special mark, though: `E' You can also mark articles as "expirable" (or have them marked as such automatically). That doesn't make much sense in normal groups, because a user does not control the expiring of news articles, but in mail groups, for instance, articles that are marked as "expirable" can be deleted by Gnus at any time. Expirable articles are marked with `E' (`gnus-expirable-mark').  File: gnus, Node: Other Marks, Next: Setting Marks, Prev: Read Articles, Up: Marking Articles Other Marks ----------- There are some marks that have nothing to do with whether the article is read or not. You can set a bookmark in the current article. Say you are reading a long thesis on cat's 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. All articles that you have replied to or made a followup to (i.e., have answered) will be marked with an `A' in the second column (`gnus-replied-mark'). It the `%e' spec is used, the presence of threads or not will be marked with `gnus-not-empty-thread-mark' and `gnus-empty-thread-mark', respectively. Finally we have the "process mark" (`gnus-process-mark'. A variety of commands react to the presence of the process mark. For instance, `X u' (`gnus-uu-decode-uu') will uudecode and view all articles that have been marked with the process mark. Articles marked with the process mark have a `#' in the second column.  File: gnus, Node: Setting Marks, Next: Setting Process Marks, Prev: Other Marks, Up: Marking Articles Setting Marks ------------- All the marking commands understand the numeric prefix. `M t' `!' Tick the current article (`gnus-summary-tick-article-forward'). `M ?' `?' Mark the current article as dormant (`gnus-summary-mark-as-dormant'). `M d' `d' Mark the current article as read (`gnus-summary-mark-as-read-forward'). `M k' `k' Mark all articles that have the same subject as the current one as read, and then select the next unread article (`gnus-summary-kill-same-subject-and-select'). `M K' `C-k' Mark all articles that have the same subject as the current one as read (`gnus-summary-kill-same-subject'). `M C' Catchup the current group (`gnus-summary-catchup'). `M C-c' Catchup all articles in the current group (`gnus-summary-catchup-all'). `M H' Catchup the current group to point (`gnus-summary-catchup-to-here'). `C-w' Mark all articles between point and mark as read (`gnus-summary-mark-region-as-read'). `M c' `M-u' Clear all readedness-marks from the current article (`gnus-summary-clear-mark-forward'). `M e' `E' Mark the current article as expirable (`gnus-summary-mark-as-expirable'). `M b' Set a bookmark in the current article (`gnus-summary-set-bookmark'). `M B' Remove the bookmark from the current article (`gnus-summary-remove-bookmark'). `M M-r' `x' Expunge all deleted articles from the summary buffer (`gnus-summary-remove-lines-marked-as-read'). `M M-C-r' Ask for a mark and then expunge all articles that have been marked with that mark (`gnus-summary-remove-lines-marked-with'). `M S' Display all expunged articles (`gnus-summary-show-all-expunged'). `M D' Display all dormant articles (`gnus-summary-show-all-dormant'). `M M-D' Hide all dormant articles (`gnus-summary-hide-all-dormant'). `M V k' Kill all articles with scores below the default score (or below the numeric prefix) (`gnus-summary-kill-below'). `M V c' Clear all marks from articles with scores over the default score (or over the numeric prefix) (`gnus-summary-clear-above'). `M V u' Tick all articles with scores over the default score (or over the numeric prefix) (`gnus-summary-tick-above'). `M V m' Prompt for a mark, and mark all articles with scores over the default score (or over the numeric prefix) with this mark (`gnus-summary-clear-above'). `gnus-summary-goto-unread' The `gnus-summary-goto-unread' variable controls what action should be taken after setting a mark. If non-`nil', point will move to the next/previous unread article. If `nil', point will just move one line up or down.  File: gnus, Node: Setting Process Marks, Prev: Setting Marks, Up: Marking Articles Setting Process Marks --------------------- `M P p' `#' Mark the current article with the process mark (`gnus-summary-mark-as-processable'). `M P u' `M-#' Remove the process mark, if any, from the current article (`gnus-summary-unmark-as-processable'). `M P U' Remove the process mark from all articles (`gnus-summary-unmark-all-processable'). `M P R' Mark articles by a regular expression (`gnus-uu-mark-by-regexp'). `M P r' Mark articles in region (`gnus-uu-mark-region'). `M P t' Mark all articles in the current (sub)thread (`gnus-uu-mark-thread'). `M P s' Mark all articles in the current series (`gnus-uu-mark-series'). `M P S' Mark all series that have already had some articles marked (`gnus-uu-mark-sparse'). `M P a' Mark all articles in series order (`gnus-uu-mark-series').  File: gnus, Node: Threading, Next: Asynchronous Fetching, Prev: Marking Articles, Up: The Summary Buffer Threading ========= Gnus threads articles by default. "To thread" is to put replies to articles directly after the articles they reply to - in a hierarchical fashion. * Menu: * Customizing Threading:: Variables you can change to affect the threading. * Thread Commands:: Thread based commands in the summary buffer.  File: gnus, Node: Customizing Threading, Next: Thread Commands, Up: Threading Customizing Threading --------------------- `gnus-show-threads' If this variable is `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. `gnus-fetch-old-headers' If non-`nil', Gnus will attempt to build old threads by fetching more old headers - headers to articles that are 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 `some'. In either case, fetching old headers only works if the backend you are using carries overview files - this would normally be `nntp', `nnspool' and `nnml'. Also remember that if the root of the thread has been expired by the server, there's not much Gnus can do about that. `gnus-summary-gather-subject-limit' Loose threads are gathered by comparing subjects of articles. If this variable is `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 subjects 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 real low number, you'll find that Gnus will gather everything in sight into one thread, which isn't very helpful. If you set this variable to the special value `fuzzy', Gnus will use a fuzzy string comparison algorithm on the subjects. `gnus-summary-make-false-root' If non-`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: `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 (`<>') instead of the standard square brackets (`[]'). This is the default method. `dummy' 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. `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 `gnus-summary-same-subject' as the subject (*note Summary Buffer Format::.).) `none' Don't make any article parent at all. Just gather the threads and display them after one another. `nil' Don't gather loose threads. `gnus-thread-hide-subtree' If non-`nil', all threads will be hidden when the summary buffer is generated. `gnus-thread-hide-killed' if you kill a thread and this variable is non-`nil', the subtree will be hidden. `gnus-thread-ignore-subject' Sometimes somebody changes the subject in the middle of a thread. If this variable is non-`nil', the subject change is ignored. If it is `nil', which is the default, a change in the subject will result in a new thread. `gnus-thread-indent-level' This is a number that says how much each sub-thread should be indented. The default is `4'.  File: gnus, Node: Thread Commands, Prev: Customizing Threading, Up: Threading Thread Commands --------------- `T k' `M-C-k' Mark all articles in the current sub-thread as read (`gnus-summary-kill-thread'). If the prefix argument is positive, remove all marks instead. If the prefix argument is negative, tick articles instead. `T l' `M-C-l' Lower the score of the current thread (`gnus-summary-lower-thread'). `T i' Increase the score of the current thread (`gnus-summary-raise-thread'). `T #' Mark the current thread with the process mark (`gnus-uu-mark-thread'). `T T' Toggle threading (`gnus-summary-toggle-threads'). `T s' Expose the thread hidden under the current article, if any (`gnus-summary-show-thread'). `T h' Hide the current (sub)thread (`gnus-summary-hide-thread'). `T S' Expose all hidden threads (`gnus-summary-show-all-threads'). `T H' Hide all threads (`gnus-summary-hide-all-threads'). The following commands are thread movement commands. They all understand the numeric prefix. `T n' Go to the next thread (`gnus-summary-next-thread'). `T p' Go to the previous thread (`gnus-summary-prev-thread'). `T d' Descend the thread (`gnus-summary-down-thread'). `T u' Ascend the thread (`gnus-summary-up-thread').  File: gnus, Node: Asynchronous Fetching, Next: Article Caching, Prev: Threading, Up: The Summary Buffer Asynchronous Article Fetching ============================= If you read your news from an NNTP server that's far away, the network latencies may make reading articles a chore. You have to wait for a while after pressing `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 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... unless you really want to. Here's how: Set `gnus-asynchronous' to `t'. The rest should happen automatically. You can control how many articles that are to be pre-fetched by setting `nntp-async-number'. This is five by default, which means that when you read an article in the group, `nntp' will pre-fetch the next five articles. If this variable is `t', `nntp' will pre-fetch all the articles that it can without bound. If it is `nil', no pre-fetching will be made. You may wish to create some sort of scheme for choosing which articles that `nntp' should consider as candidates for pre-fetching. For instance, you may wish to pre-fetch all articles with high scores, and not pre-fetch low-scored articles. You can do that by setting the `gnus-asynchronous-article-function', which will be called with an alist where the keys are the article numbers. Your function should return an alist where the articles you are not interested in have been removed. You could also do sorting on article score and the like.  File: gnus, Node: Article Caching, Next: Exiting the Summary Buffer, Prev: Asynchronous Fetching, Up: The Summary Buffer Article Caching =============== If you have an *extremely* slow 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 *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. To turn caching on, set `gnus-use-cache' to `t'. By default, all articles that are ticked or marked as dormant will then be copied over to your local cache (`gnus-cache-directory'). Whether this cache is flat or hierarchal is controlled by the `gnus-use-long-file-name' variable, as usual. When re-select 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. The entering/removal of articles from the cache is controlled by the `gnus-cache-enter-articles' and `gnus-cache-remove-articles' variables. Both are lists of symbols. The first is `(ticked dormant)' by default, meaning that ticked and dormant articles will be put in the cache. The latter is `(read)' by default, meaning that articles that are marked as read are removed from the cache. Possibly symbols in these two lists are `ticked', `dormant', `unread' and `read'. So where does the massive article-fetching and storing come into the picture? The `gnus-jog-cache' command will go through all subscribed newsgroups, request all unread articles, and store them in the cache. You should only ever, ever ever ever, use this command if 1) your connection to the NNTP server is really, really, really slow and 2) you have a really, really, really huge disk. Seriously.