This is ../info/gnus, produced by makeinfo version 4.8 from gnus.texi. This file documents Gnus, the GNU Emacs newsreader. Copyright (C) 1995,96 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: Top, Next: Starting Up, Up: (dir) The Gnus Newsreader ******************* You can read news (and mail) from within Emacs by using Gnus. The news can be gotten by any nefarious means you can think of--NNTP, local spool or your mbox file. All at the same time, if you want to push your luck. * Menu: * Starting Up:: Finding news can be a pain. * The Group Buffer:: Selecting, subscribing and killing groups. * The Summary Buffer:: Reading, saving and posting articles. * The Article Buffer:: Displaying and handling articles. * Composing Messages:: Information on sending mail and news. * Select Methods:: Gnus reads all messages from various select methods. * Scoring:: Assigning values to articles. * Various:: General purpose settings. * The End:: Farewell and goodbye. * Appendices:: Terminology, Emacs intro, FAQ, History, Internals. * Index:: Variable, function and concept index. * Key Index:: Key Index.  File: gnus, Node: Starting Up, Next: The Group Buffer, Prev: Top, Up: Top 1 Starting Gnus *************** If your system administrator has set things up properly, starting Gnus and reading news is extremely easy--you just type `M-x gnus' in your Emacs. If you want to start Gnus in a different frame, you can use the command `M-x gnus-other-frame' instead. If things do not go smoothly at startup, you have to twiddle some variables. * Menu: * Finding the News:: Choosing a method for getting news. * The First Time:: What does Gnus do the first time you start it? * The Server is Down:: How can I read my mail then? * Slave Gnusii:: You can have more than one Gnus active at a time. * Fetching a Group:: Starting Gnus just to read a group. * New Groups:: What is Gnus supposed to do with new groups? * Startup Files:: Those pesky startup files---`.newsrc'. * Auto Save:: Recovering from a crash. * The Active File:: Reading the active file over a slow line Takes Time. * Startup Variables:: Other variables you might change.  File: gnus, Node: Finding the News, Next: The First Time, Up: Starting Up 1.1 Finding the News ==================== The `gnus-select-method' variable says where Gnus should look for news. This variable should be a list where the first element says "how" and the second element says "where". This method is your native method. All groups that are not fetched with this method are foreign groups. For instance, if the `news.somewhere.edu' NNTP server is where you want to get your daily dosage of news from, you'd say: (setq gnus-select-method '(nntp "news.somewhere.edu")) If you want to read directly from the local spool, say: (setq gnus-select-method '(nnspool "")) If you can use a local spool, you probably should, as it will almost certainly be much faster. If this variable is not set, Gnus will take a look at the `NNTPSERVER' environment variable. If that variable isn't set, Gnus will see whether `gnus-nntpserver-file' (`/etc/nntpserver' by default) has any opinions on the matter. If that fails as well, Gnus will will try to use the machine that is running Emacs as an NNTP server. That's a long-shot, though. If `gnus-nntp-server' is set, this variable will override `gnus-select-method'. You should therefore set `gnus-nntp-server' to `nil', which is what it is by default. You can also make Gnus prompt you interactively for the name of an NNTP server. If you give a non-numerical prefix to `gnus' (i.e., `C-u M-x gnus'), Gnus will let you choose between the servers in the `gnus-secondary-servers' list (if any). You can also just type in the name of any server you feel like visiting. However, if you use one NNTP server regularly and are just interested in a couple of groups from a different server, you would be better served by using the `B' command in the group buffer. It will let you have a look at what groups are available, and you can subscribe to any of the groups you want to. This also makes `.newsrc' maintenance much tidier. *Note Foreign Groups::. A slightly different approach to foreign groups is to set the `gnus-secondary-select-methods' variable. The select methods listed in this variable are in many ways just as native as the `gnus-select-method' server. They will also be queried for active files during startup (if that's required), and new newsgroups that appear on these servers will be subscribed (or not) just as native groups are. For instance, if you use the `nnmbox' backend to read your mail, you would typically set this variable to (setq gnus-secondary-select-methods '((nnmbox "")))  File: gnus, Node: The First Time, Next: The Server is Down, Prev: Finding the News, Up: Starting Up 1.2 The First Time ================== If no startup files exist, Gnus will try to determine what groups should be subscribed by default. If the variable `gnus-default-subscribed-newsgroups' is set, Gnus will subscribe you to just those groups in that list, leaving the rest killed. Your system administrator should have set this variable to something useful. Since she hasn't, Gnus will just subscribe you to a few arbitrarily picked groups (i.e., `*.newusers'). ("Arbitrary" is here defined as "whatever Lars thinks you should read".) You'll also be subscribed to the Gnus documentation group, which should help you with most common problems. If `gnus-default-subscribed-newsgroups' is `t', Gnus will just use the normal functions for handling new groups, and not do anything special.  File: gnus, Node: The Server is Down, Next: Slave Gnusii, Prev: The First Time, Up: Starting Up 1.3 The Server is Down ====================== If the default server is down, Gnus will understandably have some problems starting. However, if you have some mail groups in addition to the news groups, you may want to start Gnus anyway. Gnus, being the trusting sort of program, will ask whether to proceed without a native select method if that server can't be contacted. This will happen whether the server doesn't actually exist (i.e., you have given the wrong address) or the server has just momentarily taken ill for some reason or other. If you decide to continue and have no foreign groups, you'll find it difficult to actually do anything in the group buffer. But, hey, that's your problem. Blllrph! If you know that the server is definitely down, or you just want to read your mail without bothering with the server at all, you can use the `gnus-no-server' command to start Gnus. That might come in handy if you're in a hurry as well.  File: gnus, Node: Slave Gnusii, Next: Fetching a Group, Prev: The Server is Down, Up: Starting Up 1.4 Slave Gnusiï ================ You might want to run more than one Emacs with more than one Gnus at the same time. If you are using different `.newsrc' files (eg., if you are using the two different Gnusiï to read from two different servers), that is no problem whatsoever. You just do it. The problem appears when you want to run two Gnusiï that use the same `.newsrc' file. To work around that problem some, we here at the Think-Tank at the Gnus Towers have come up with a new concept: "Masters" and "servants". (We have applied for a patent on this concept, and have taken out a copyright on those words. If you wish to use those words in conjunction with each other, you have to send $1 per usage instance to me. Usage of the patent ("Master/Slave Relationships In Computer Applications") will be much more expensive, of course.) Anyways, you start one Gnus up the normal way with `M-x gnus' (or however you do it). Each subsequent slave Gnusiï should be started with `M-x gnus-slave'. These slaves won't save normal `.newsrc' files, but instead save "slave files" that contains information only on what groups have been read in the slave session. When a master Gnus starts, it will read (and delete) these slave files, incorporating all information from them. (The slave files will be read in the sequence they were created, so the latest changes will have precedence.) Information from the slave files has, of course, precedence over the information in the normal (i. e., master) `.newsrc' file.  File: gnus, Node: Fetching a Group, Next: New Groups, Prev: Slave Gnusii, Up: Starting Up 1.5 Fetching a Group ==================== It it sometime convenient to be able to just say "I want to read this group and I don't care whether Gnus has been started or not". This is perhaps more useful for people who write code than for users, but the command `gnus-fetch-group' provides this functionality in any case. It takes the group name as a parameter.  File: gnus, Node: New Groups, Next: Startup Files, Prev: Fetching a Group, Up: Starting Up 1.6 New Groups ============== What Gnus does when it encounters a new group is determined by the `gnus-subscribe-newsgroup-method' variable. This variable should contain a function. Some handy pre-fab values are: `gnus-subscribe-zombies' Make all new groups zombies. You can browse the zombies later (with `A z') and either kill them all off properly, or subscribe to them. This is the default. `gnus-subscribe-randomly' Subscribe all new groups randomly. `gnus-subscribe-alphabetically' Subscribe all new groups alphabetically. `gnus-subscribe-hierarchically' Subscribe all new groups hierarchically. `gnus-subscribe-interactively' Subscribe new groups interactively. This means that Gnus will ask you about *all* new groups. `gnus-subscribe-killed' Kill all new groups. A closely related variable is `gnus-subscribe-hierarchical-interactive'. (That's quite a mouthful.) If this variable is non-`nil', Gnus will ask you in a hierarchical fashion whether to subscribe to new groups or not. Gnus will ask you for each sub-hierarchy whether you want to descend the hierarchy or not. One common mistake is to set the variable a few paragraphs above to `gnus-subscribe-hierarchical-interactive'. This is an error. This will not work. This is ga-ga. So don't do it. A nice and portable way to control which new newsgroups should be subscribed (or ignored) is to put an "options" line at the start of the `.newsrc' file. Here's an example: options -n !alt.all !rec.all sci.all This line obviously belongs to a serious-minded intellectual scientific person (or she may just be plain old boring), because it says that all groups that have names beginning with `alt' and `rec' should be ignored, and all groups with names beginning with `sci' should be subscribed. Gnus will not use the normal subscription method for subscribing these groups. `gnus-subscribe-options-newsgroup-method' is used instead. This variable defaults to `gnus-subscribe-alphabetically'. If you don't want to mess with your `.newsrc' file, you can just set the two variables `gnus-options-subscribe' and `gnus-options-not-subscribe'. These two variables do exactly the same as the `.newsrc' `options -n' trick. Both are regexps, and if the the new group matches the former, it will be unconditionally subscribed, and if it matches the latter, it will be ignored. Yet another variable that meddles here is `gnus-auto-subscribed-groups'. It works exactly like `gnus-options-subscribe', and is therefore really superfluous, but I thought it would be nice to have two of these. This variable is more meant for setting some ground rules, while the other variable is used more for user fiddling. By default this variable makes all new groups that come from mail backends (`nnml', `nnbabyl', `nnfolder', `nnmbox', and `nnmh') subscribed. If you don't like that, just set this variable to `nil'. If you are satisfied that you really never want to see any new groups, you could set `gnus-check-new-newsgroups' to `nil'. This will also save you some time at startup. Even if this variable is `nil', you can always subscribe to the new groups just by pressing `U' in the group buffer (*note Group Maintenance::). This variable is `t' by default. Gnus normally determines whether a group is new or not by comparing the list of groups from the active file(s) with the lists of subscribed and dead groups. This isn't a particularly fast method. If `gnus-check-new-newsgroups' is `ask-server', Gnus will ask the server for new groups since the last time. This is both faster & cheaper. This also means that you can get rid of the list of killed groups altogether, so you may set `gnus-save-killed-list' to `nil', which will save time both at startup, at exit, and all over. Saves disk space, too. Why isn't this the default, then? Unfortunately, not all servers support this command. I bet I know what you're thinking now: How do I find out whether my server supports `ask-server'? No? Good, because I don't have a fail-safe answer. I would suggest just setting this variable to `ask-server' and see whether any new groups appear within the next few days. If any do, then it works. If any don't, then it doesn't work. I could write a function to make Gnus guess whether the server supports `ask-server', but it would just be a guess. So I won't. You could `telnet' to the server and say `HELP' and see whether it lists `NEWGROUPS' among the commands it understands. If it does, then it might work. (But there are servers that lists `NEWGROUPS' without supporting the function properly.) This variable can also be a list of select methods. If so, Gnus will issue an `ask-server' command to each of the select methods, and subscribe them (or not) using the normal methods. This might be handy if you are monitoring a few servers for new groups. A side effect is that startup will take much longer, so you can meditate while waiting. Use the mantra "dingnusdingnusdingnus" to achieve permanent bliss.  File: gnus, Node: Startup Files, Next: Auto Save, Prev: New Groups, Up: Starting Up 1.7 Startup Files ================= Now, you all know about the `.newsrc' file. All subscription information is traditionally stored in this file. Things got a bit more complicated with GNUS. In addition to keeping the `.newsrc' file updated, it also used a file called `.newsrc.el' for storing all the information that didn't fit into the `.newsrc' file. (Actually, it also duplicated everything in the `.newsrc' file.) GNUS would read whichever one of these files was the most recently saved, which enabled people to swap between GNUS and other newsreaders. That was kinda silly, so Gnus went one better: In addition to the `.newsrc' and `.newsrc.el' files, Gnus also has a file called `.newsrc.eld'. It will read whichever of these files that are most recent, but it will never write a `.newsrc.el' file. You can turn off writing the `.newsrc' file by setting `gnus-save-newsrc-file' to `nil', which means you can delete the file and save some space, as well as making exit from Gnus faster. However, this will make it impossible to use other newsreaders than Gnus. But hey, who would want to, right? If `gnus-save-killed-list' (default `t') is `nil', Gnus will not save the list of killed groups to the startup file. This will save both time (when starting and quitting) and space (on disk). It will also means that Gnus has no record of what groups are new or old, so the automatic new groups subscription methods become meaningless. You should always set `gnus-check-new-newsgroups' to `nil' or `ask-server' if you set this variable to `nil' (*note New Groups::). The `gnus-startup-file' variable says where the startup files are. The default value is `~/.newsrc', with the Gnus (El Dingo) startup file being whatever that one is with a `.eld' appended. `gnus-save-newsrc-hook' is called before saving any of the newsrc files, while `gnus-save-quick-newsrc-hook' is called just before saving the `.newsrc.eld' file, and `gnus-save-standard-newsrc-hook' is called just before saving the `.newsrc' file. The latter two are commonly used to turn version control on or off. Version control is off by default when saving the startup files.  File: gnus, Node: Auto Save, Next: The Active File, Prev: Startup Files, Up: Starting Up 1.8 Auto Save ============= Whenever you do something that changes the Gnus data (reading articles, catching up, killing/subscribing groups), the change is added to a special "dribble buffer". This buffer is auto-saved the normal Emacs way. If your Emacs should crash before you have saved the `.newsrc' files, all changes you have made can be recovered from this file. If Gnus detects this file at startup, it will ask the user whether to read it. The auto save file is deleted whenever the real startup file is saved. If `gnus-use-dribble-file' is `nil', Gnus won't create and maintain a dribble buffer. The default is `t'. Gnus will put the dribble file(s) in `gnus-dribble-directory'. If this variable is `nil', which it is by default, Gnus will dribble into the directory where the `.newsrc' file is located. (This is normally the user's home directory.) The dribble file will get the same file permissions as the `.newsrc' file.  File: gnus, Node: The Active File, Next: Startup Variables, Prev: Auto Save, Up: Starting Up 1.9 The Active File =================== When Gnus starts, or indeed whenever it tries to determine whether new articles have arrived, it reads the active file. This is a very large file that lists all the active groups and articles on the server. Before examining the active file, Gnus deletes all lines that match the regexp `gnus-ignored-newsgroups'. This is done primarily to reject any groups with bogus names, but you can use this variable to make Gnus ignore hierarchies you aren't ever interested in. However, this is not recommended. In fact, it's highly discouraged. Instead, *note New Groups:: for an overview of other variables that can be used instead. The active file can be rather Huge, so if you have a slow network, you can set `gnus-read-active-file' to `nil' to prevent Gnus from reading the active file. This variable is `t' by default. Gnus will try to make do by getting information just on the groups that you actually subscribe to. Note that if you subscribe to lots and lots of groups, setting this variable to `nil' will probably make Gnus slower, not faster. At present, having this variable `nil' will slow Gnus down considerably, unless you read news over a 2400 baud modem. This variable can also have the value `some'. Gnus will then attempt to read active info only on the subscribed groups. On some servers this is quite fast (on sparkling, brand new INN servers that support the `LIST ACTIVE group' command), on others this isn't fast at all. In any case, `some' should be faster than `nil', and is certainly faster than `t' over slow lines. If this variable is `nil', Gnus will ask for group info in total lock-step, which isn't very fast. If it is `some' and you use an NNTP server, Gnus will pump out commands as fast as it can, and read all the replies in one swoop. This will normally result in better performance, but if the server does not support the aforementioned `LIST ACTIVE group' command, this isn't very nice to the server. In any case, if you use `some' or `nil', you should definitely kill all groups that you aren't interested in to speed things up.  File: gnus, Node: Startup Variables, Prev: The Active File, Up: Starting Up 1.10 Startup Variables ====================== `gnus-load-hook' A hook that is run while Gnus is being loaded. Note that this hook will normally be run just once in each Emacs session, no matter how many times you start Gnus. `gnus-startup-hook' A hook that is run after starting up Gnus successfully. `gnus-check-bogus-newsgroups' If non-`nil', Gnus will check for and delete all bogus groups at startup. A "bogus group" is a group that you have in your `.newsrc' file, but doesn't exist on the news server. Checking for bogus groups can take quite a while, so to save time and resources it's best to leave this option off, and do the checking for bogus groups once in a while from the group buffer instead (*note Group Maintenance::). `gnus-inhibit-startup-message' If non-`nil', the startup message won't be displayed. That way, your boss might not notice that you are reading news instead of doing your job as easily. `gnus-no-groups-message' Message displayed by Gnus when no groups are available.  File: gnus, Node: The Group Buffer, Next: The Summary Buffer, Prev: Starting Up, Up: Top 2 The Group Buffer ****************** The "group buffer" lists all (or parts) of the available groups. It is the first buffer shown when Gnus starts, and will never be killed as long as Gnus is active. * Menu: * Group Buffer Format:: Information listed and how you can change it. * Group Maneuvering:: Commands for moving in the group buffer. * Selecting a Group:: Actually reading news. * Subscription Commands:: Unsubscribing, killing, subscribing. * Group Levels:: Levels? What are those, then? * Group Score:: A mechanism for finding out what groups you like. * Marking Groups:: You can mark groups for later processing. * Foreign Groups:: Creating and editing groups. * Group Parameters:: Each group may have different parameters set. * Listing Groups:: Gnus can list various subsets of the groups. * Sorting Groups:: Re-arrange the group order. * Group Maintenance:: Maintaining a tidy `.newsrc' file. * Browse Foreign Server:: You can browse a server. See what it has to offer. * Exiting Gnus:: Stop reading news and get some work done. * Group Topics:: A folding group mode divided into topics. * Misc Group Stuff:: Other stuff that you can to do.  File: gnus, Node: Group Buffer Format, Next: Group Maneuvering, Up: The Group Buffer 2.1 Group Buffer Format ======================= * Menu: * Group Line Specification:: Deciding how the group buffer is to look. * Group Modeline Specification:: The group buffer modeline. * Group Highlighting:: Having nice colors in the group buffer.  File: gnus, Node: Group Line Specification, Next: Group Modeline Specification, Up: Group Buffer Format 2.1.1 Group Line Specification ------------------------------ The default format of the group buffer is nice and dull, but you can make it as exciting and ugly as you feel like. Here's a couple of example group lines: 25: news.announce.newusers * 0: alt.fan.andrea-dworkin Quite simple, huh? You can see that there are 25 unread articles in `news.announce.newusers'. There are no unread articles, but some ticked articles, in `alt.fan.andrea-dworkin' (see that little asterisk at the beginning of the line?) You can change that format to whatever you want by fiddling with the `gnus-group-line-format' variable. This variable works along the lines of a `format' specification, which is pretty much the same as a `printf' specifications, for those of you who use (feh!) C. *Note Formatting Variables::. The default value that produced those lines above is `%M%S%5y: %(%g%)\n'. There should always be a colon on the line; the cursor always moves to the colon after performing an operation. Nothing else is required--not even the group name. All displayed text is just window dressing, and is never examined by Gnus. Gnus stores all real information it needs using text properties. (Note that if you make a really strange, wonderful, spreadsheet-like layout, everybody will believe you are hard at work with the accounting instead of wasting time reading news.) Here's a list of all available format characters: `M' Only marked articles. `S' Whether the group is subscribed. `L' Level of subscribedness. `N' Number of unread articles. `I' Number of dormant articles. `T' Number of ticked articles. `R' Number of read articles. `t' Total number of articles. `y' Number of unread, unticked, non-dormant articles. `i' Number of ticked and dormant articles. `g' Full group name. `G' Group name. `D' Newsgroup description. `o' `m' if moderated. `O' `(m)' if moderated. `s' Select method. `n' Select from where. `z' A string that looks like `<%s:%n>' if a foreign select method is used. `P' Indentation based on the level of the topic (*note Group Topics::). `c' Short (collapsed) group name. The `gnus-group-uncollapsed-levels' variable says how many levels to leave at the end of the group name. The default is `1'. `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 headers as argument. The function should return a string, which will be inserted into the buffer just like information from any other specifier. All the "number-of" specs will be filled with an asterisk (`*') if no info is available--for instance, if it is a non-activated foreign group, or a bogus (or semi-bogus) native group.  File: gnus, Node: Group Modeline Specification, Next: Group Highlighting, Prev: Group Line Specification, Up: Group Buffer Format 2.1.2 Group Modeline Specification ---------------------------------- The mode line can be changed by setting (`gnus-group-mode-line-format'). It doesn't understand that many format specifiers: `S' The native news server. `M' The native select method.  File: gnus, Node: Group Highlighting, Prev: Group Modeline Specification, Up: Group Buffer Format 2.1.3 Group Highlighting ------------------------ Highlighting in the group buffer is controlled by the `gnus-group-highlight' variable. This is an alist with elements that look like (FORM . FACE). If FORM evaluates to something non-`nil', the FACE will be used on the line. Here's an example value for this variable that might look nice if the background is dark: (setq gnus-group-highlight `(((> unread 200) . ,(custom-face-lookup "Red" nil nil t nil nil)) ((and (< level 3) (zerop unread)) . ,(custom-face-lookup "SeaGreen" nil nil t nil nil)) ((< level 3) . ,(custom-face-lookup "SpringGreen" nil nil t nil nil)) ((zerop unread) . ,(custom-face-lookup "SteelBlue" nil nil t nil nil)) (t . ,(custom-face-lookup "SkyBlue" nil nil t nil nil)) )) Variables that are dynamically bound when the forms are evaluated include: `group' The group name. `unread' The number of unread articles in the group. `method' The select method. `mailp' Whether the group is a mail group. `level' The level of the group. `score' The score of the group. `ticked' The number of ticked articles in the group. `topic' When using the topic minor mode, this variable is bound to the current topic being inserted. When the forms are `eval'ed, point is at the beginning of the line of the group in question, so you can use many of the normal Gnus functions for snarfing info on the group. `gnus-group-update-hook' is called when a group line is changed. It will not be called when `gnus-visual' is `nil'. This hook calls `gnus-group-highlight-line' by default.  File: gnus, Node: Group Maneuvering, Next: Selecting a Group, Prev: Group Buffer Format, Up: The Group Buffer 2.2 Group Maneuvering ===================== All movement commands understand the numeric prefix and will behave as expected, hopefully. `n' Go to the next group that has unread articles (`gnus-group-next-unread-group'). `p' `DEL' Go to the previous group group that has unread articles (`gnus-group-prev-unread-group'). `N' Go to the next group (`gnus-group-next-group'). `P' Go to the previous group (`gnus-group-prev-group'). `M-p' Go to the next unread group on the same level (or lower) (`gnus-group-next-unread-group-same-level'). `M-n' Go to the previous unread group on the same level (or lower) (`gnus-group-prev-unread-group-same-level'). Three commands for jumping to groups: `j' Jump to a group (and make it visible if it isn't already) (`gnus-group-jump-to-group'). Killed groups can be jumped to, just like living groups. `,' Jump to the unread group with the lowest level (`gnus-group-best-unread-group'). `.' Jump to the first group with unread articles (`gnus-group-first-unread-group'). If `gnus-group-goto-unread' is `nil', all the movement commands will move to the next group, not the next unread group. Even the commands that say they move to the next unread group. The default is `t'.  File: gnus, Node: Selecting a Group, Next: Subscription Commands, Prev: Group Maneuvering, Up: The Group Buffer 2.3 Selecting a Group ===================== `SPACE' Select the current group, switch to the summary buffer and display the first unread article (`gnus-group-read-group'). If there are no unread articles in the group, or if you give a non-numerical prefix to this command, Gnus will offer to fetch all the old articles in this group from the server. If you give a numerical prefix N, Gnus will fetch N number of articles. If N is positive, fetch the N newest articles, if N is negative, fetch the ABS(N) oldest articles. `RET' Select the current group and switch to the summary buffer (`gnus-group-select-group'). Takes the same arguments as `gnus-group-read-group'--the only difference is that this command does not display the first unread article automatically upon group entry. `M-RET' This does the same as the command above, but tries to do it with the minimum amount off fuzz (`gnus-group-quick-select-group'). No scoring/killing will be performed, there will be no highlights and no expunging. This might be useful if you're in a real hurry and have to enter some humongous group. `M-SPACE' This is yet one more command that does the same as the one above, but this one does it without expunging and hiding dormants (`gnus-group-visible-select-group'). `c' Mark all unticked articles in this group as read (`gnus-group-catchup-current'). `gnus-group-catchup-group-hook' is when catching up a group from the group buffer. `C' Mark all articles in this group, even the ticked ones, as read (`gnus-group-catchup-current-all'). The `gnus-large-newsgroup' variable says what Gnus should consider to be a big group. This is 200 by default. If the group has more unread articles than this, Gnus will query the user before entering the group. The user can then specify how many articles should be fetched from the server. If the user specifies a negative number (`-n'), the `n' oldest articles will be fetched. If it is positive, the `n' articles that have arrived most recently will be fetched. `gnus-auto-select-first' control whether any articles are selected automatically when entering a group. `nil' Don't select any articles when entering the group. Just display the full summary buffer. `t' Select the first unread article when entering the group. `best' Select the most high-scored article in the group when entering the group. If you want to prevent automatic selection in some group (say, in a binary group with Huge articles) you can set this variable to `nil' in `gnus-select-group-hook', which is called when a group is selected.  File: gnus, Node: Subscription Commands, Next: Group Levels, Prev: Selecting a Group, Up: The Group Buffer 2.4 Subscription Commands ========================= `S t' `u' Toggle subscription to the current group (`gnus-group-unsubscribe-current-group'). `S s' `U' Prompt for a group to subscribe, and then subscribe it. If it was subscribed already, unsubscribe it instead (`gnus-group-unsubscribe-group'). `S k' `C-k' Kill the current group (`gnus-group-kill-group'). `S y' `C-y' Yank the last killed group (`gnus-group-yank-group'). `C-x C-t' Transpose two groups (`gnus-group-transpose-groups'). This isn't really a subscription command, but you can use it instead of a kill-and-yank sequence sometimes. `S w' `C-w' Kill all groups in the region (`gnus-group-kill-region'). `S z' Kill all zombie groups (`gnus-group-kill-all-zombies'). `S C-k' Kill all groups on a certain level (`gnus-group-kill-level'). These groups can't be yanked back after killing, so this command should be used with some caution. The only thing where this command comes in really handy is when you have a `.newsrc' with lots of unsubscribed groups that you want to get rid off. `S C-k' on level `7' will kill off all unsubscribed groups that do not have message numbers in the `.newsrc' file. Also *note Group Levels::.  File: gnus, Node: Group Levels, Next: Group Score, Prev: Subscription Commands, Up: The Group Buffer 2.5 Group Levels ================ All groups have a level of "subscribedness". For instance, if a group is on level 2, it is more subscribed than a group on level 5. You can ask Gnus to just list groups on a given level or lower (*note Listing Groups::), or to just check for new articles in groups on a given level or lower (*note Scanning New Messages::). Remember: The higher the level of the group, the less important it is. `S l' Set the level of the current group. If a numeric prefix is given, the next N groups will have their levels set. The user will be prompted for a level. Gnus considers groups on between levels 1 and `gnus-level-subscribed' (inclusive) (default 5) to be subscribed, `gnus-level-subscribed' (exclusive) and `gnus-level-unsubscribed' (inclusive) (default 7) to be unsubscribed, `gnus-level-zombie' to be zombies (walking dead) (default 8) and `gnus-level-killed' to be killed (default 9), completely dead. Gnus treats subscribed and unsubscribed groups exactly the same, but zombie and killed groups have no information on what articles you have read, etc, stored. This distinction between dead and living groups isn't done because it is nice or clever, it is done purely for reasons of efficiency. It is recommended that you keep all your mail groups (if any) on quite low levels (eg. 1 or 2). If you want to play with the level variables, you should show some care. Set them once, and don't touch them ever again. Better yet, don't touch them at all unless you know exactly what you're doing. Two closely related variables are `gnus-level-default-subscribed' (default 3) and `gnus-level-default-unsubscribed' (default 6), which are the levels that new groups will be put on if they are (un)subscribed. These two variables should, of course, be inside the relevant legal ranges. If `gnus-keep-same-level' is non-`nil', some movement commands will only move to groups that are of the same level (or lower). In particular, going from the last article in one group to the next group will go to the next group of the same level (or lower). This might be handy if you want to read the most important groups before you read the rest. All groups with a level less than or equal to `gnus-group-default-list-level' will be listed in the group buffer by default. If `gnus-group-list-inactive-groups' is non-`nil', non-active groups will be listed along with the unread groups. This variable is `t' by default. If it is `nil', inactive groups won't be listed. If `gnus-group-use-permanent-levels' is non-`nil', once you give a level prefix to `g' or `l', all subsequent commands will use this level as the "work" level. Gnus will normally just activate groups that are on level `gnus-activate-level' or less. If you don't want to activate unsubscribed groups, for instance, you might set this variable to `5'.  File: gnus, Node: Group Score, Next: Marking Groups, Prev: Group Levels, Up: The Group Buffer 2.6 Group Score =============== You would normally keep important groups on high levels, but that scheme is somewhat restrictive. Don't you wish you could have Gnus sort the group buffer according to how often you read groups, perhaps? Within reason? This is what "group score" is for. You can assign a score to each group. You can then sort the group buffer based on this score. Alternatively, you can sort on score and then level. (Taken together, the level and the score is called the "rank" of the group. A group that is on level 4 and has a score of 1 has a higher rank than a group on level 5 that has a score of 300. (The level is the most significant part and the score is the least significant part.) If you want groups you read often to get higher scores than groups you read seldom you can add the `gnus-summary-bubble-group' function to the `gnus-summary-exit-hook' hook. This will result (after sorting) in a bubbling sort of action. If you want to see that in action after each summary exit, you can add `gnus-group-sort-groups-by-rank' or `gnus-group-sort-groups-by-score' to the same hook, but that will slow things down somewhat.  File: gnus, Node: Marking Groups, Next: Foreign Groups, Prev: Group Score, Up: The Group Buffer 2.7 Marking Groups ================== If you want to perform some command on several groups, and they appear subsequently in the group buffer, you would normally just give a numerical prefix to the command. Most group commands will then do your bidding on those groups. However, if the groups are not in sequential order, you can still perform a command on several groups. You simply mark the groups first with the process mark and then execute the command. `#' `M m' Set the mark on the current group (`gnus-group-mark-group'). `M-#' `M u' Remove the mark from the current group (`gnus-group-unmark-group'). `M U' Remove the mark from all groups (`gnus-group-unmark-all-groups'). `M w' Mark all groups between point and mark (`gnus-group-mark-region'). `M b' Mark all groups in the buffer (`gnus-group-mark-buffer'). `M r' Mark all groups that match some regular expression (`gnus-group-mark-regexp'). Also *note Process/Prefix::. If you want to execute some command on all groups that have been marked with the process mark, you can use the `M-&' (`gnus-group-universal-argument') command. It will prompt you for the command to be executed.  File: gnus, Node: Foreign Groups, Next: Group Parameters, Prev: Marking Groups, Up: The Group Buffer 2.8 Foreign Groups ================== Here are some group mode commands for making and editing general foreign groups, as well as commands to ease the creation of a few special-purpose groups: `G m' Make a new group (`gnus-group-make-group'). Gnus will prompt you for a name, a method and possibly an "address". For an easier way to subscribe to NNTP groups, *note Browse Foreign Server::. `G r' Rename the current group to something else (`gnus-group-rename-group'). This is legal only on some groups - mail groups mostly. This command might very well be quite slow on some backends. `G e' Enter a buffer where you can edit the select method of the current group (`gnus-group-edit-group-method'). `G p' Enter a buffer where you can edit the group parameters (`gnus-group-edit-group-parameters'). `G E' Enter a buffer where you can edit the group info (`gnus-group-edit-group'). `G d' Make a directory group. You will be prompted for a directory name (`gnus-group-make-directory-group'). `G h' Make the Gnus help group (`gnus-group-make-help-group'). `G a' Make a Gnus archive group (`gnus-group-make-archive-group'). By default a group pointing to the most recent articles will be created (`gnus-group-recent-archive-directory'), but given a prefix, a full group will be created from from `gnus-group-archive-directory'. `G k' Make a kiboze group. You will be prompted for a name, for a regexp to match groups to be "included" in the kiboze group, and a series of strings to match on headers (`gnus-group-make-kiboze-group'). *Note Kibozed Groups:: `G D' Read an arbitrary directory as if with were a newsgroup with the `nneething' backend (`gnus-group-enter-directory'). `G f' Make a group based on some file or other (`gnus-group-make-doc-group'). If you give a prefix to this command, you will be prompted for a file name and a file type. Currently supported types are `babyl', `mbox', `digest', `mmdf', `news', `rnews', `clari-briefs', and `forward'. If you run this command without a prefix, Gnus will guess at the file type. `G DEL' This function will delete the current group (`gnus-group-delete-group'). If given a prefix, this function will actually delete all the articles in the group, and forcibly remove the group itself from the face of the Earth. Use a prefix only if you are absolutely sure of what you are doing. `G V' Make a new, fresh, empty `nnvirtual' group (`gnus-group-make-empty-virtual'). `G v' Add the current group to an `nnvirtual' group (`gnus-group-add-to-virtual'). Uses the process/prefix convention. *Note Select Methods:: for more information on the various select methods. If the `gnus-activate-foreign-newsgroups' is a positive number, Gnus will check all foreign groups with this level or lower at startup. This might take quite a while, especially if you subscribe to lots of groups from different NNTP servers.  File: gnus, Node: Group Parameters, Next: Listing Groups, Prev: Foreign Groups, Up: The Group Buffer 2.9 Group Parameters ==================== Gnus stores all information on a group in a list that is usually known as the "group info". This list has from three to six elements. Here's an example info. ("nnml:mail.ding" 3 ((1 . 232) 244 (256 . 270)) ((tick 246 249)) (nnml "private") ((to-address . "ding@ifi.uio.no"))) The first element is the "group name", as Gnus knows the group, anyway. The second element is the "subscription level", which normally is a small integer. The third element is a list of ranges of read articles. The fourth element is a list of lists of article marks of various kinds. The fifth element is the select method (or virtual server, if you like). The sixth element is a list of "group parameters", which is what this section is about. Any of the last three elements may be missing if they are not required. In fact, the vast majority of groups will normally only have the first three elements, which saves quite a lot of cons cells. The group parameters store information local to a particular group: `to-address' If the group parameter list contains an element that looks like `(to-address . "some@where.com")', that address will be used by the backend when doing followups and posts. This is primarily useful in mail groups that represent closed mailing lists--mailing lists where it's expected that everybody that writes to the mailing list is subscribed to it. Since using this parameter ensures that the mail only goes to the mailing list itself, it means that members won't receive two copies of your followups. Using `to-address' will actually work whether the group is foreign or not. Let's say there's a group on the server that is called `fa.4ad-l'. This is a real newsgroup, but the server has gotten the articles from a mail-to-news gateway. Posting directly to this group is therefore impossible--you have to send mail to the mailing list address instead. `to-list' If the group parameter list has an element that looks like `(to-list . "some@where.com")', that address will be used when doing a `a' in any group. It is totally ignored when doing a followup--except that if it is present in a news group, you'll get mail group semantics when doing `f'. `broken-reply-to' Elements like `(broken-reply-to . t)' signals that `Reply-To' headers in this group are to be ignored. This can be useful if you're reading a mailing list group where the listserv has inserted `Reply-To' headers that point back to the listserv itself. This is broken behavior. So there! `to-group' If the group parameter list contains an element like `(to-group . "some.group.name")', all posts will be sent to that group. `auto-expire' If this symbol is present in the group parameter list, all articles that are read will be marked as expirable. For an alternative approach, *note Expiring Mail::. `total-expire' If this symbol is present, all read articles will be put through the expiry process, even if they are not marked as expirable. Use with caution. `expiry-wait' If the group parameter has an element that looks like `(expiry-wait . 10)', this value will override any `nnmail-expiry-wait' and `nnmail-expiry-wait-function' when expiring expirable messages. The value can either be a number of days (not necessarily an integer) or the symbols `never' or `immediate'. `score-file' Elements that look like `(score-file . "file")' will make `file' into the current score file for the group in question. This means that all score commands you issue will end up in that file. `admin-address' When unsubscribing to a mailing list you should never send the unsubscription notice to the mailing list itself. Instead, you'd send messages to the administrative address. This parameter allows you to put the admin address somewhere convenient. `comment' This parameter allows you to enter a arbitrary comment on the group. `(VARIABLE FORM)' You can use the group parameters to set variables local to the group you are entering. Say you want to turn threading off in `news.answers'. You'd then put `(gnus-show-threads nil)' in the group parameters of that group. `gnus-show-threads' will be made into a local variable in the summary buffer you enter, and the form `nil' will be `eval'ed there. This can also be used as a group-specific hook function, if you'd like. If you want to hear a beep when you enter the group `alt.binaries.pictures.furniture', you could put something like `(dummy-variable (ding))' in the parameters of that group. `dummy-variable' will be set to the result of the `(ding)' form, but who cares? If you want to change the group info you can use the `G E' command to enter a buffer where you can edit it. You usually don't want to edit the entire group info, so you'd be better off using the `G p' command to just edit the group parameters.  File: gnus, Node: Listing Groups, Next: Sorting Groups, Prev: Group Parameters, Up: The Group Buffer 2.10 Listing Groups =================== These commands all list various slices of the groups that are available. `l' `A s' List all groups that have unread articles (`gnus-group-list-groups'). If the numeric prefix is used, this command will list only groups of level ARG and lower. By default, it only lists groups of level five or lower (i.e., just subscribed groups). `L' `A u' List all groups, whether they have unread articles or not (`gnus-group-list-all-groups'). If the numeric prefix is used, this command will list only groups of level ARG and lower. By default, it lists groups of level seven or lower (i.e., just subscribed and unsubscribed groups). `A l' List all unread groups on a specific level (`gnus-group-list-level'). If given a prefix, also list the groups with no unread articles. `A k' List all killed groups (`gnus-group-list-killed'). If given a prefix argument, really list all groups that are available, but aren't currently (un)subscribed. This could entail reading the active file from the server. `A z' List all zombie groups (`gnus-group-list-zombies'). `A m' List all subscribed groups with unread articles that match a regexp (`gnus-group-list-matching'). `A M' List groups that match a regexp (`gnus-group-list-all-matching'). `A A' List absolutely all groups that are in the active file(s) of the server(s) you are connected to (`gnus-group-list-active'). This might very well take quite a while. It might actually be a better idea to do a `A m' to list all matching, and just give `.' as the thing to match on. `A a' List all groups that have names that match a regexp (`gnus-group-apropos'). `A d' List all groups that have names or descriptions that match a regexp (`gnus-group-description-apropos'). Groups that match the `gnus-permanently-visible-groups' regexp will always be shown, whether they have unread articles or not. You can also add the `visible' element to the group parameters in question to get the same effect. Groups that have just ticked articles in it are normally listed in the group buffer. If `gnus-list-groups-with-ticked-articles' is `nil', these groups will be treated just like totally empty groups. It is `t' by default.  File: gnus, Node: Sorting Groups, Next: Group Maintenance, Prev: Listing Groups, Up: The Group Buffer 2.11 Sorting Groups =================== The `C-c C-s' (`gnus-group-sort-groups') command sorts the group buffer according to the function(s) given by the `gnus-group-sort-function' variable. Available sorting functions include: `gnus-group-sort-by-alphabet' Sort the group names alphabetically. This is the default. `gnus-group-sort-by-level' Sort by group level. `gnus-group-sort-by-score' Sort by group score. `gnus-group-sort-by-rank' Sort by group score and then the group level. The level and the score are, when taken together, the group's "rank". `gnus-group-sort-by-unread' Sort by number of unread articles. `gnus-group-sort-by-method' Sort by alphabetically on the select method. `gnus-group-sort-function' can also be a list of sorting functions. In that case, the most significant sort key function must be the last one. There are also a number of commands for sorting directly according to some sorting criteria: `G S a' Sort the group buffer alphabetically by group name (`gnus-group-sort-groups-by-alphabet'). `G S u' Sort the group buffer by the number of unread articles (`gnus-group-sort-groups-by-unread'). `G S l' Sort the group buffer by group level (`gnus-group-sort-groups-by-level'). `G S v' Sort the group buffer by group score (`gnus-group-sort-groups-by-score'). `G S r' Sort the group buffer by group level (`gnus-group-sort-groups-by-rank'). `G S m' Sort the group buffer alphabetically by backend name (`gnus-group-sort-groups-by-method'). When given a prefix, all these commands will sort in reverse order.  File: gnus, Node: Group Maintenance, Next: Browse Foreign Server, Prev: Sorting Groups, Up: The Group Buffer 2.12 Group Maintenance ====================== `b' Find bogus groups and delete them (`gnus-group-check-bogus-groups'). `F' Find new groups and process them (`gnus-find-new-newsgroups'). If given a prefix, use the `ask-server' method to query the server for new groups. `C-c C-x' Run all expirable articles in the current group through the expiry process (if any) (`gnus-group-expire-articles'). `C-c M-C-x' Run all articles in all groups through the expiry process (`gnus-group-expire-all-groups').  File: gnus, Node: Browse Foreign Server, Next: Exiting Gnus, Prev: Group Maintenance, Up: The Group Buffer 2.13 Browse Foreign Server ========================== `B' You will be queried for a select method and a server name. Gnus will then attempt to contact this server and let you browse the groups there (`gnus-group-browse-foreign-server'). A new buffer with a list of available groups will appear. This buffer will be use the `gnus-browse-mode'. This buffer looks a bit (well, a lot) like a normal group buffer, but with one major difference - you can't enter any of the groups. If you want to read any of the news available on that server, you have to subscribe to the groups you think may be interesting, and then you have to exit this buffer. The new groups will be added to the group buffer, and then you can read them as you would any other group. Future versions of Gnus may possibly permit reading groups straight from the browse buffer. Here's a list of keystrokes available in the browse mode: `n' Go to the next group (`gnus-group-next-group'). `p' Go to the previous group (`gnus-group-prev-group'). `SPACE' Enter the current group and display the first article (`gnus-browse-read-group'). `RET' Enter the current group (`gnus-browse-select-group'). `u' Unsubscribe to the current group, or, as will be the case here, subscribe to it (`gnus-browse-unsubscribe-current-group'). `l' `q' Exit browse mode (`gnus-browse-exit'). `?' Describe browse mode briefly (well, there's not much to describe, is there) (`gnus-browse-describe-briefly').  File: gnus, Node: Exiting Gnus, Next: Group Topics, Prev: Browse Foreign Server, Up: The Group Buffer 2.14 Exiting Gnus ================= Yes, Gnus is ex(c)iting. `z' Suspend Gnus (`gnus-group-suspend'). This doesn't really exit Gnus, but it kills all buffers except the Group buffer. I'm not sure why this is a gain, but then who am I to judge? `q' Quit Gnus (`gnus-group-exit'). `Q' Quit Gnus without saving any startup files (`gnus-group-quit'). `gnus-suspend-gnus-hook' is called when you suspend Gnus and `gnus-exit-gnus-hook' is called when you quit Gnus, while `gnus-after-exiting-gnus-hook' is called as the final item when exiting Gnus. If you wish to completely unload Gnus and all its adherents, you can use the `gnus-unload' command. This command is also very handy when trying to customize meta-variables. Note: Miss Lisa Cannifax, while sitting in English class, feels her feet go numbly heavy and herself fall into a hazy trance as the boy sitting behind her drew repeated lines with his pencil across the back of her plastic chair.  File: gnus, Node: Group Topics, Next: Misc Group Stuff, Prev: Exiting Gnus, Up: The Group Buffer 2.15 Group Topics ================= If you read lots and lots of groups, it might be convenient to group them hierarchically according to topics. You put your Emacs groups over here, your sex groups over there, and the rest (what, two groups or so?) you put in some misc section that you never bother with anyway. You can even group the Emacs sex groups as a sub-topic to either the Emacs groups or the sex groups--or both! Go wild! To get this _fab_ functionality you simply turn on (ooh!) the `gnus-topic' minor mode--type `t' in the group buffer. (This is a toggling command.) Go ahead, just try it. I'll still be here when you get back. La de dum... Nice tune, that... la la la... What, you're back? Yes, and now press `l'. There. All your groups are now listed under `misc'. Doesn't that make you feel all warm and fuzzy? Hot and bothered? If you want this permanently enabled, you should add that minor mode to the hook for the group mode: (add-hook 'gnus-group-mode-hook 'gnus-topic-mode) * Menu: * Topic Variables:: How to customize the topics the Lisp Way. * Topic Commands:: Interactive E-Z commands. * Topic Topology:: A map of the world.  File: gnus, Node: Topic Variables, Next: Topic Commands, Up: Group Topics 2.15.1 Topic Variables ---------------------- Now, if you select a topic, if will fold/unfold that topic, which is really neat, I think. The topic lines themselves are created according to the `gnus-topic-line-format' variable. *Note Formatting Variables::. Elements allowed are: `i' Indentation. `n' Topic name. `v' Visibility. `l' Level. `g' Number of groups in the topic. `a' Number of unread articles in the topic. `A' Number of unread articles in the topic and all its subtopics. Each sub-topic (and the groups in the sub-topics) will be indented with `gnus-topic-indent-level' times the topic level number of spaces. The default is `2'. `gnus-topic-mode-hook' is called in topic minor mode buffers.  File: gnus, Node: Topic Commands, Next: Topic Topology, Prev: Topic Variables, Up: Group Topics 2.15.2 Topic Commands --------------------- When the topic minor mode is turned on, a new `T' submap will be available. In addition, a few of the standard keys change their definitions slightly. `T n' Prompt for a new topic name and create it (`gnus-topic-create-topic'). `T m' Move the current group to some other topic (`gnus-topic-move-group'). This command understands the process/prefix convention (*note Process/Prefix::). `T c' Copy the current group to some other topic (`gnus-topic-copy-group'). This command understands the process/prefix convention (*note Process/Prefix::). `T D' Remove a group from the current topic (`gnus-topic-remove-group'). This command understands the process/prefix convention (*note Process/Prefix::). `T M' Move all groups that match some regular expression to a topic (`gnus-topic-move-matching'). `T C' Copy all groups that match some regular expression to a topic (`gnus-topic-copy-matching'). `T #' Mark all groups in the current topic with the process mark (`gnus-topic-mark-topic'). `T M-#' Remove the process mark from all groups in the current topic (`gnus-topic-unmark-topic'). `RET' `SPACE' Either select a group or fold a topic (`gnus-topic-select-group'). When you perform this command on a group, you'll enter the group, as usual. When done on a topic line, the topic will be folded (if it was visible) or unfolded (if it was folded already). So it's basically a toggling command on topics. In addition, if you give a numerical prefix, group on that level (and lower) will be displayed. `T TAB' "Indent" the current topic so that it becomes a sub-topic of the previous topic (`gnus-topic-indent'). If given a prefix, "un-indent" the topic instead. `C-k' Kill a group or topic (`gnus-topic-kill-group'). `C-y' Yank the previously killed group or topic (`gnus-topic-yank-group'). Note that all topics will be yanked before all groups. `T r' Rename a topic (`gnus-topic-rename'). `T DEL' Delete an empty topic (`gnus-topic-delete'). `A T' List all groups that Gnus knows about in a topics-ified way (`gnus-topic-list-active').  File: gnus, Node: Topic Topology, Prev: Topic Commands, Up: Group Topics 2.15.3 Topic Topology --------------------- So, let's have a look at an example group buffer: Gnus Emacs -- I wuw it! 3: comp.emacs 2: alt.religion.emacs Naughty Emacs 452: alt.sex.emacs 0: comp.talk.emacs.recovery Misc 8: comp.binaries.fractals 13: comp.sources.unix So, here we have one top-level topic, two topics under that, and one sub-topic under one of the sub-topics. (There is always just one (1) top-level topic). This topology can be expressed as follows: (("Gnus" visible) (("Emacs -- I wuw it!" visible) (("Naughty Emacs" visible))) (("Misc" visible))) This is in fact how the variable `gnus-topic-topology' would look for the display above. That variable is saved in the `.newsrc.eld' file, and shouldn't be messed with manually--unless you really want to. Since this variable is read from the `.newsrc.eld' file, setting it in any other startup files will have no effect. This topology shows what topics are sub-topics of what topics (right), and which topics are visible. Two settings are currently allowed--`visible' and `invisible'.  File: gnus, Node: Misc Group Stuff, Prev: Group Topics, Up: The Group Buffer 2.16 Misc Group Stuff ===================== * Menu: * Scanning New Messages:: Asking Gnus to see whether new messages have arrived. * Group Information:: Information and help on groups and Gnus. * File Commands:: Reading and writing the Gnus files. `^' Enter the server buffer (`gnus-group-enter-server-mode'). *Note The Server Buffer::. `a' Post an article to a group (`gnus-group-post-news'). The current group name will be used as the default. `m' Mail a message somewhere (`gnus-group-mail'). Variables for the group buffer: `gnus-group-mode-hook' `gnus-group-mode-hook' is called after the group buffer has been created. `gnus-group-prepare-hook' `gnus-group-prepare-hook' is called after the group buffer is generated. It may be used to modify the buffer in some strange, unnatural way. `gnus-permanently-visible-groups' Groups matching this regexp will always be listed in the group buffer, whether they are empty or not.  File: gnus, Node: Scanning New Messages, Next: Group Information, Up: Misc Group Stuff 2.16.1 Scanning New Messages ---------------------------- `g' Check the server(s) for new articles. If the numerical prefix is used, this command will check only groups of level ARG and lower (`gnus-group-get-new-news'). If given a non-numerical prefix, this command will force a total rereading of the active file(s) from the backend(s). `M-g' Check whether new articles have arrived in the current group (`gnus-group-get-new-news-this-group'). The `gnus-goto-next-group-when-activating' variable controls whether this command is to move point to the next group or not. It is `t' by default. `C-c M-g' Activate absolutely all groups (`gnus-activate-all-groups'). `R' Restart Gnus (`gnus-group-restart'). `gnus-get-new-news-hook' is run just before checking for new news. `gnus-after-getting-new-news-hook' is run after checking for new news.  File: gnus, Node: Group Information, Next: File Commands, Prev: Scanning New Messages, Up: Misc Group Stuff 2.16.2 Group Information ------------------------ `M-f' Try to fetch the FAQ for the current group (`gnus-group-fetch-faq'). Gnus will try to get the FAQ from `gnus-group-faq-directory', which is usually a directory on a remote machine. `ange-ftp' will be used for fetching the file. `D' Describe the current group (`gnus-group-describe-group'). If given a prefix, force Gnus to re-read the description from the server. `M-d' Describe all groups (`gnus-group-describe-all-groups'). If given a prefix, force Gnus to re-read the description file from the server. `V' Display current Gnus version numbers (`gnus-version'). `?' Give a very short help message (`gnus-group-describe-briefly'). `C-c C-i' Go to the Gnus info node (`gnus-info-find-node').  File: gnus, Node: File Commands, Prev: Group Information, Up: Misc Group Stuff 2.16.3 File Commands -------------------- `r' Read the init file (`gnus-init-file', which defaults to `~/.gnus') (`gnus-group-read-init-file'). `s' Save the `.newsrc.eld' file (and `.newsrc' if wanted) (`gnus-group-save-newsrc'). If given a prefix, force saving the file(s) whether Gnus thinks it is necessary or not.  File: gnus, Node: The Summary Buffer, Next: The Article Buffer, Prev: The Group Buffer, Up: Top 3 The Summary Buffer ******************** A line for each article is displayed in the summary buffer. You can move around, read articles, post articles and reply to articles. * Menu: * Summary Buffer Format:: Deciding how the summary buffer is to look. * Summary Maneuvering:: Moving around the summary buffer. * Choosing Articles:: Reading articles. * Paging the Article:: Scrolling the current article. * Reply Followup and Post:: Posting articles. * Canceling and Superseding:: ``Whoops, I shouldn't have called him that.'' * Marking Articles:: Marking articles as read, expirable, etc. * Limiting:: You can limit the summary buffer. * Threading:: How threads are made. * Sorting:: How articles and threads are sorted. * Asynchronous Fetching:: Gnus might be able to pre-fetch articles. * Article Caching:: You may store articles in a cache. * Persistent Articles:: Making articles expiry-resistant. * Article Backlog:: Having already read articles hang around. * Saving Articles:: Ways of customizing article saving. * Decoding Articles:: Gnus can treat series of (uu)encoded articles. * Article Treatment:: The article buffer can be mangled at will. * Summary Sorting:: Sorting the summary buffer in various ways. * Finding the Parent:: No child support? Get the parent. * Alternative Approaches:: Reading using non-default summaries. * Tree Display:: A more visual display of threads. * Mail Group Commands:: Some commands can only be used in mail groups. * Various Summary Stuff:: What didn't fit anywhere else. * Exiting the Summary Buffer:: Returning to the Group buffer.  File: gnus, Node: Summary Buffer Format, Next: Summary Maneuvering, Up: The Summary Buffer 3.1 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. * Summary Highlighting:: Making the summary buffer all pretty and nice. 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. The default function will return the wrong answer in 5% of the cases. If this is unacceptable to you, use the other function instead. `gnus-summary-same-subject' is a string indicating that the current article has the same subject as the previous. This string will be used with those specs that require it. The default is `'.  File: gnus, Node: Summary Buffer Lines, Next: Summary Buffer Mode Line, Up: Summary Buffer Format 3.1.1 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. `V' Total thread score. `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. 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, Next: Summary Highlighting, Prev: Summary Buffer Lines, Up: Summary Buffer Format 3.1.2 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. `p' Unprefixed 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. `d' Number of dormant articles. `t' Number of ticked articles. `r' Number of articles that have been marked as read in this session. `E' Number of articles expunged by the score files.  File: gnus, Node: Summary Highlighting, Prev: Summary Buffer Mode Line, Up: Summary Buffer Format 3.1.3 Summary Highlighting -------------------------- `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: Summary Maneuvering, Next: Choosing Articles, Prev: Summary Buffer Format, Up: The Summary Buffer 3.2 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 j' `j' Ask for an article number and then go that article (`gnus-summary-goto-article'). `G g' Ask for an article number and then go the summary line of that article (`gnus-summary-goto-subject'). 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. Variables related to summary movement: `gnus-auto-select-next' 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 this variable 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. If this variable is `almost-quietly', the same will happen only if you are located on the last article in the group. Finally, if this variable is `slightly-quietly', the `Z n' command will go to the next group without confirmation. Also *note Group Levels::. `gnus-auto-select-same' If 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. `gnus-summary-check-current' If 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. `gnus-auto-center-summary' If 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. This will also inhibit horizontal re-centering of the summary buffer, which might make it more inconvenient to read extremely long threads.  File: gnus, Node: Choosing Articles, Next: Paging the Article, Prev: Summary Maneuvering, Up: The Summary Buffer 3.3 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. The default value is `gnus-summary-mark-read-and-unread-as-read', and will change the mark of almost any article you read to `gnus-unread-mark'. The only articles not affected by this function are ticked, dormant, and expirable articles. If you'd instead like to just have unread articles marked as read, you can use `gnus-summary-mark-unread-as-read' instead. It will leave marks like `gnus-low-score-mark', `gnus-del-mark' (and so on) alone.  File: gnus, Node: Paging the Article, Next: Reply Followup and Post, Prev: Choosing Articles, Up: The Summary Buffer 3.4 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 g' `g' (Re)fetch the current article (`gnus-summary-show-article'). If given a prefix, fetch the current article, but don't run any of the article treatment functions. This will give you a "raw" article, just the way it came from the server. `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'). `A s' Perform an isearch in the article buffer (`gnus-summary-isearch-article').  File: gnus, Node: Reply Followup and Post, Next: Canceling and Superseding, Prev: Paging the Article, Up: The Summary Buffer 3.5 Reply, Followup and Post ============================ * Menu: * Summary Mail Commands:: Sending mail. * Summary Post Commands:: Sending news.  File: gnus, Node: Summary Mail Commands, Next: Summary Post Commands, Up: Reply Followup and Post 3.5.1 Summary Mail Commands --------------------------- 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 D b' If you have sent a mail, but the mail was bounced back to you for some reason (wrong address, transient failure), you can use this command to resend that bounced mail (`gnus-summary-resend-bounced-mail'). You will be popped into a mail buffer where you can edit the headers before sending the mail off again. If you give a prefix to this command, and the bounced mail is a reply to some other mail, Gnus will try to fetch that mail and display it for easy perusal of its headers. This might very well fail, though. `S D r' Not to be confused with the previous command, `gnus-summary-resend-message' will prompt you for an address to send the current message off to, and then send it to that place. The headers of the message won't be altered--but lots of headers that say `Resent-To', `Resent-From' and so on will be added. This means that you actually send a mail to someone that has a `To' header that (probably) points to yourself. This will confuse people. So, natcherly you'll only do that if you're really eVIl. This command is mainly used if you have several accounts and want to ship a mail to a different account of yours. (If you're both `root' and `postmaster' and get a mail for `postmaster' to the `root' account, you may want to resend it to `postmaster'. Ordnung muss sein! `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').  File: gnus, Node: Summary Post Commands, Prev: Summary Mail Commands, Up: Reply Followup and Post 3.5.2 Summary Post Commands --------------------------- 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'). (*note Uuencoding and Posting::).  File: gnus, Node: Canceling and Superseding, Next: Marking Articles, Prev: Reply Followup and Post, Up: The Summary Buffer 3.6 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. 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: Limiting, Prev: Canceling and Superseding, Up: The Summary Buffer 3.7 Marking Articles ==================== There are several marks you can set on an article. You have marks that decide the "readedness" (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 3.7.1 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. `SPACE' An "unread" article is marked with a `SPACE' (`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 3.7.2 Read Articles ------------------- All the following marks mark articles as read. `r' 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. `R' Articles that are actually read are marked with `R' (`gnus-read-mark'). `O' 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-canceled-mark') `F' SOUPed article (`gnus-souped-mark'). `Q' Sparsely reffed article (`gnus-sparse-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 3.7.3 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 cats' urinary tracts, and have to go home for dinner before you've finished reading the thesis. You can then set a bookmark in the article, and Gnus will jump to this bookmark the next time it encounters the article. * 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'). * Articles that are stored in the article cache will be marked with an `*' in the second column (`gnus-cached-mark'). * Articles that are "saved" (in some manner or other; not necessarily religiously) are marked with an `S' in the second column (`gnus-saved-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' in the third column, 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. You might have noticed that most of these "non-readedness" marks appear in the second column by default. So if you have a cached, saved, replied article that you have process-marked, what will that look like? Nothing much. The precedence rules go as follows: process -> cache -> replied -> saved. So if the article is in the cache and is replied, you'll only see the cache mark and not the replied mark.  File: gnus, Node: Setting Marks, Next: Setting Process Marks, Prev: Other Marks, Up: Marking Articles 3.7.4 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' Mark all unread articles in the group as read (`gnus-summary-catchup'). `M C-c' Mark all articles in the group as read--even the ticked and dormant articles (`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 V k' Kill all articles with scores below the default score (or below the numeric prefix) (`gnus-summary-kill-below'). `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 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'). 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. As a special case, if this variable is `never', all the marking commands as well as other commands (like `SPACE') will move to the next article, whether it is unread or not. The default is `t'.  File: gnus, Node: Setting Process Marks, Prev: Setting Marks, Up: Marking Articles 3.7.5 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 T' Unmark all articles in the current (sub)thread (`gnus-uu-unmark-thread'). `M P v' Mark all articles that have a score above the prefix argument (`gnus-uu-mark-over'). `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'). `M P b' Mark all articles in the buffer in the order they appear (`gnus-uu-mark-buffer').  File: gnus, Node: Limiting, Next: Threading, Prev: Marking Articles, Up: The Summary Buffer 3.8 Limiting ============ It can be convenient to limit the summary buffer to just show some subset of the articles currently in the group. The effect most limit commands have is to remove a few (or many) articles from the summary buffer. `/ /' `/ s' Limit the summary buffer to articles that match some subject (`gnus-summary-limit-to-subject'). `/ a' Limit the summary buffer to articles that match some author (`gnus-summary-limit-to-author'). `/ u' `x' Limit the summary buffer to articles that are not marked as read (`gnus-summary-limit-to-unread'). If given a prefix, limit the buffer to articles that are strictly unread. This means that ticked and dormant articles will also be excluded. `/ m' Ask for a mark and then limit to all articles that have not been marked with that mark (`gnus-summary-limit-to-marks'). `/ n' Limit the summary buffer to the current article (`gnus-summary-limit-to-articles'). Uses the process/prefix convention (*note Process/Prefix::). `/ w' Pop the previous limit off the stack and restore it (`gnus-summary-pop-limit'). If given a prefix, pop all limits off the stack. `/ v' Limit the summary buffer to articles that have a score at or above some score (`gnus-summary-limit-to-score'). `/ E' `M S' Display all expunged articles (`gnus-summary-limit-include-expunged'). `/ D' Display all dormant articles (`gnus-summary-limit-include-dormant'). `/ d' Hide all dormant articles (`gnus-summary-limit-exclude-dormant'). `/ c' Hide all dormant articles that have no children (`gnus-summary-limit-exclude-childless-dormant'). `/ C' Mark all excluded unread articles as read (`gnus-summary-limit-mark-excluded-as-read'). If given a prefix, also mark excluded ticked and dormant articles as read.  File: gnus, Node: Threading, Next: Sorting, Prev: Limiting, Up: The Summary Buffer 3.9 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 3.9.1 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' or a number. If you set it to a number, no more than that number of extra old headers will be fetched. In either case, fetching old headers only works if the 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-build-sparse-threads' Fetching old headers can be slow. A low-rent similar effect can be gotten by setting this variable to `some'. Gnus will then look at the complete `References' headers of all articles and try to string articles that belong in the same thread together. This will leave "gaps" in the threading display where Gnus guesses that an article is missing from the thread. (These gaps appear like normal summary lines. If you select a gap, Gnus will try to fetch the article in question.) If this variable is `t', Gnus will display all these "gaps" without regard for whether they are useful for completing the thread or not. Finally, if this variable is `more', Gnus won't cut off sparse leaf nodes that don't lead anywhere. This variable is `nil' by default. `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 really 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-simplify-subject-fuzzy-regexp' This can either be a regular expression or list of regular expressions that match strings that will be removed from subjects if fuzzy subject simplification is used. `gnus-simplify-ignored-prefixes' If you set `gnus-summary-gather-subject-limit' to something as low as 10, you might consider setting this variable to something sensible: (setq gnus-simplify-ignored-prefixes (concat "\\`\\[?\\(" (mapconcat 'identity '("looking" "wanted" "followup" "summary\\( of\\)?" "help" "query" "problem" "question" "answer" "reference" "announce" "How can I" "How to" "Comparison of" ;; ... ) "\\|") "\\)\\s *\\(" (mapconcat 'identity '("for" "for reference" "with" "about") "\\|") "\\)?\\]?:?[ \t]*")) All words that match this regexp will be removed before comparing two subjects. `gnus-summary-gather-exclude-subject' Since loose thread gathering is done on subjects only, that might lead to many false hits, especially with certain common subjects like `' and `(none)'. To make the situation slightly better, you can use the regexp `gnus-summary-gather-exclude-subject' to say what subjects should be excluded from the gathering process. The default is `^ *$\\|^(none)$'. `gnus-summary-thread-gathering-function' Gnus gathers threads by looking at `Subject' headers. This means that totally unrelated articles may end up in the same "thread", which is confusing. An alternate approach is to look at all the `Message-ID's in all the `References' headers to find matches. This will ensure that no gathered threads ever includes unrelated articles, but it's also means that people who have posted with broken newsreaders won't be gathered properly. The choice is yours--plague or cholera: `gnus-gather-threads-by-subject' This function is the default gathering function and looks at `Subject's exclusively. `gnus-gather-threads-by-references' This function looks at `References' headers exclusively. If you want to test gathering by `References', you could say something like: (setq gnus-summary-thread-gathering-function 'gnus-gather-threads-by-references) `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. `gnus-summary-dummy-line-format' is used to specify the format of the dummy roots. It accepts only one format spec: `S', which is the subject of the article. *Note Formatting Variables::. `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 3.9.2 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 #' Set the process mark on the current thread (`gnus-uu-mark-thread'). `T M-#' Remove the process mark from the current thread (`gnus-uu-unmark-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'). `T t' Re-thread the thread the current article is part of (`gnus-summary-rethread-current'). This works even when the summary buffer is otherwise unthreaded. `T ^' Make the current article the child of the marked (or previous) article (`gnus-summary-reparent-thread'. 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'). `T o' Go to the top of the thread (`gnus-summary-top-thread'). If you ignore subject while threading, you'll naturally end up with threads that have several different subjects in them. If you then issue a command like `T k' (`gnus-summary-kill-thread') you might not wish to kill the entire thread, but just those parts of the thread that have the same subject as the current article. If you like this idea, you can fiddle with `gnus-thread-operation-ignore-subject'. If is is non-`nil' (which it is by default), subjects will be ignored when doing thread commands. If this variable is `nil', articles in the same thread with different subjects will not be included in the operation in question. If this variable is `fuzzy', only articles that have subjects that are fuzzily equal will be included.  File: gnus, Node: Sorting, Next: Asynchronous Fetching, Prev: Threading, Up: The Summary Buffer 3.10 Sorting ============ If you are using a threaded summary display, you can sort the threads by setting `gnus-thread-sort-functions', which is a list of functions. By default, sorting is done on article numbers. Ready-made sorting predicate functions include `gnus-thread-sort-by-number', `gnus-thread-sort-by-author', `gnus-thread-sort-by-subject', `gnus-thread-sort-by-date', `gnus-thread-sort-by-score', and `gnus-thread-sort-by-total-score'. Each function takes two threads and return non-`nil' if the first thread should be sorted before the other. Note that sorting really is normally done by looking only at the roots of each thread. If you use more than one function, the primary sort key should be the last function in the list. You should probably always include `gnus-thread-sort-by-number' in the list of sorting functions--preferably first. This will ensure that threads that are equal with respect to the other sort criteria will be displayed in ascending article order. If you would like to sort by score, then by subject, and finally by number, you could do something like: (setq gnus-thread-sort-functions '(gnus-thread-sort-by-number gnus-thread-sort-by-subject gnus-thread-sort-by-score)) The threads that have highest score will be displayed first in the summary buffer. When threads have the same score, they will be sorted alphabetically. The threads that have the same score and the same subject will be sorted by number, which is (normally) the sequence in which the articles arrived. If you want to sort by score and then reverse arrival order, you could say something like: (setq gnus-thread-sort-functions '((lambda (t1 t2) (not (gnus-thread-sort-by-number t1 t2))) gnus-thread-sort-by-score)) The function in the `gnus-thread-score-function' variable (default `+') is used for calculating the total score of a thread. Useful functions might be `max', `min', or squared means, or whatever tickles your fancy. If you are using an unthreaded display for some strange reason or other, you have to fiddle with the `gnus-article-sort-functions' variable. It is very similar to the `gnus-thread-sort-functions', except that is uses slightly different functions for article comparison. Available sorting predicate functions are `gnus-article-sort-by-number', `gnus-article-sort-by-author', `gnus-article-sort-by-subject', `gnus-article-sort-by-date', and `gnus-article-sort-by-score'. If you want to sort an unthreaded summary display by subject, you could say something like: (setq gnus-article-sort-functions '(gnus-article-sort-by-number gnus-article-sort-by-subject))  File: gnus, Node: Asynchronous Fetching, Next: Article Caching, Prev: Sorting, Up: The Summary Buffer 3.11 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: Persistent Articles, Prev: Asynchronous Fetching, Up: The Summary Buffer 3.12 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. It is likely that you do not want caching on some groups. For instance, if your `nnml' mail is located under your home directory, it makes no sense to cache it somewhere else under your home directory. Unless you feel that it's neat to use twice as much space. To limit the caching, you could set the `gnus-uncacheable-groups' regexp to `^nnml', for instance. This variable is `nil' by default. The cache stores information on what articles it contains in its active file (`gnus-cache-active-file'). If this file (or any other parts of the cache) becomes all messed up for some reason or other, Gnus offers two functions that will try to set things right. `M-x gnus-cache-generate-nov-databases' will (re)build all the NOV files, and `gnus-cache-generate-active' will (re)generate the active file.  File: gnus, Node: Persistent Articles, Next: Article Backlog, Prev: Article Caching, Up: The Summary Buffer 3.13 Persistent Articles ======================== Closely related to article caching, we have "persistent articles". In fact, it's just a different way of looking at caching, and much more useful in my opinion. Say you're reading a newsgroup, and you happen on to some valuable gem that you want to keep and treasure forever. You'd normally just save it (using one of the many saving commands) in some file. The problem with that is that it's just, well, yucky. Ideally you'd prefer just having the article remain in the group where you found it forever; untouched by the expiry going on at the news server. This is what a "persistent article" is--an article that just won't be deleted. It's implemented using the normal cache functions, but you use two explicit commands for managing persistent articles: `*' Make the current article persistent (`gnus-cache-enter-article'). `M-*' Remove the current article from the persistent articles (`gnus-cache-remove-article'). This will normally delete the article. Both these commands understand the process/prefix convention. To avoid having all ticked articles (and stuff) entered into the cache, you should set `gnus-use-cache' to `passive' if you're just interested in persistent articles: (setq gnus-use-cache 'passive)  File: gnus, Node: Article Backlog, Next: Saving Articles, Prev: Persistent Articles, Up: The Summary Buffer 3.14 Article Backlog ==================== If you have a slow connection, but the idea of using caching seems unappealing to you (and it is, really), you can help the situation some by switching on the "backlog". This is where Gnus will buffer already read articles so that it doesn't have to re-fetch articles you've already read. This only helps if you are in the habit of re-selecting articles you've recently read, of course. If you never do that, turning the backlog on will slow Gnus down a little bit, and increase memory usage some. If you set `gnus-keep-backlog' to a number N, Gnus will store at most N old articles in a buffer for later re-fetching. If this variable is non-`nil' and is not a number, Gnus will store _all_ read articles, which means that your Emacs will grow without bound before exploding and taking your machine down with you. I put that in there just to keep y'all on your toes. This variable is `nil' by default.  File: gnus, Node: Saving Articles, Next: Decoding Articles, Prev: Article Backlog, Up: The Summary Buffer 3.15 Saving Articles ==================== Gnus can save articles in a number of ways. Below is the documentation for saving articles in a fairly straight-forward fashion (i.e., little processing of the article is done before it is saved). For a different approach (uudecoding, unsharing) you should use `gnus-uu' (*note Decoding Articles::). If `gnus-save-all-headers' is non-`nil', Gnus will not delete unwanted headers before saving the article. If the preceding variable is `nil', all headers that match the `gnus-saved-headers' regexp will be kept, while the rest will be deleted before saving. `O o' `o' Save the current article using the default article saver (`gnus-summary-save-article'). `O m' Save the current article in mail format (`gnus-summary-save-article-mail'). `O r' Save the current article in rmail format (`gnus-summary-save-article-rmail'). `O f' Save the current article in plain file format (`gnus-summary-save-article-file'). `O b' Save the current article body in plain file format (`gnus-summary-save-article-body-file'). `O h' Save the current article in mh folder format (`gnus-summary-save-article-folder'). `O v' Save the current article in a VM folder (`gnus-summary-save-article-vm'). `O p' Save the current article in a pipe. Uhm, like, what I mean is--Pipe the current article to a process (`gnus-summary-pipe-output'). All these commands use the process/prefix convention (*note Process/Prefix::). If you save bunches of articles using these functions, you might get tired of being prompted for files to save each and every article in. The prompting action is controlled by the `gnus-prompt-before-saving' variable, which is `always' by default, giving you that excessive prompting action you know and loathe. If you set this variable to `t' instead, you'll be prompted just once for each series of articles you save. If you like to really have Gnus do all your thinking for you, you can even set this variable to `nil', which means that you will never be prompted for files to save articles in. Gnus will simply save all the articles in the default files. You can customize the `gnus-default-article-saver' variable to make Gnus do what you want it to. You can use any of the four ready-made functions below, or you can create your own. `gnus-summary-save-in-rmail' This is the default format, "babyl". Uses the function in the `gnus-rmail-save-name' variable to get a file name to save the article in. The default is `gnus-plain-save-name'. `gnus-summary-save-in-mail' Save in a Unix mail (mbox) file. Uses the function in the `gnus-mail-save-name' variable to get a file name to save the article in. The default is `gnus-plain-save-name'. `gnus-summary-save-in-file' Append the article straight to an ordinary file. Uses the function in the `gnus-file-save-name' variable to get a file name to save the article in. The default is `gnus-numeric-save-name'. `gnus-summary-save-body-in-file' Append the article body to an ordinary file. Uses the function in the `gnus-file-save-name' variable to get a file name to save the article in. The default is `gnus-numeric-save-name'. `gnus-summary-save-in-folder' Save the article to an MH folder using `rcvstore' from the MH library. Uses the function in the `gnus-folder-save-name' variable to get a file name to save the article in. The default is `gnus-folder-save-name', but you can also use `gnus-Folder-save-name'. The former creates capitalized names, and the latter does not. `gnus-summary-save-in-vm' Save the article in a VM folder. You have to have the VM mail reader to use this setting. All of these functions, except for the last one, will save the article in the `gnus-article-save-directory', which is initialized from the `SAVEDIR' environment variable. This is `~/News/' by default. As you can see above, the functions use different functions to find a suitable name of a file to save the article in. Below is a list of available functions that generate names: `gnus-Numeric-save-name' Generates file names that look like `~/News/Alt.andrea-dworkin/45'. `gnus-numeric-save-name' Generates file names that look like `~/News/alt.andrea-dworkin/45'. `gnus-Plain-save-name' Generates file names that look like `~/News/Alt.andrea-dworkin'. `gnus-plain-save-name' Generates file names that look like `~/News/alt.andrea-dworkin'. You can have Gnus suggest where to save articles by plonking a regexp into the `gnus-split-methods' alist. For instance, if you would like to save articles related to Gnus in the file `gnus-stuff', and articles related to VM in `vm-stuff', you could set this variable to something like: (("^Subject:.*gnus\\|^Newsgroups:.*gnus" "gnus-stuff") ("^Subject:.*vm\\|^Xref:.*vm" "vm-stuff") (my-choosing-function "../other-dir/my-stuff") ((equal gnus-newsgroup-name "mail.misc") "mail-stuff")) We see that this is a list where each element is a list that has two elements--the "match" and the "file". The match can either be a string (in which case it is used as a regexp to match on the article head); it can be a symbol (which will be called as a function with the group name as a parameter); or it can be a list (which will be `eval'ed). If any of these actions have a non-`nil' result, the "file" will be used as a default prompt. In addition, the result of the operation itself will be used if the function or form called returns a string or a list of strings. You basically end up with a list of file names that might be used when saving the current article. (All "matches" will be used.) You will then be prompted for what you really want to use as a name, with file name completion over the results from applying this variable. This variable is `((gnus-article-archive-name))' by default, which means that Gnus will look at the articles it saves for an `Archive-name' line and use that as a suggestion for the file name. Finally, you have the `gnus-use-long-file-name' variable. If it is `nil', all the preceding functions will replace all periods (`.') in the group names with slashes (`/')--which means that the functions will generate hierarchies of directories instead of having all the files in the toplevel directory (`~/News/alt/andrea-dworkin' instead of `~/News/alt.andrea-dworkin'.) This variable is `t' by default on most systems. However, for historical reasons, this is `nil' on Xenix and usg-unix-v machines by default. This function also affects kill and score file names. If this variable is a list, and the list contains the element `not-score', long file names will not be used for score files, if it contains the element `not-save', long file names will not be used for saving, and if it contains the element `not-kill', long file names will not be used for kill files. If you'd like to save articles in a hierarchy that looks something like a spool, you could (setq gnus-use-long-file-name '(not-save)) ; to get a hierarchy (setq gnus-default-article-save 'gnus-summary-save-in-file) ; no encoding Then just save with `o'. You'd then read this hierarchy with ephemeral `nneething' groups--`G D' in the group buffer, and the toplevel directory as the argument (`~/News/'). Then just walk around to the groups/directories with `nneething'.  File: gnus, Node: Decoding Articles, Next: Article Treatment, Prev: Saving Articles, Up: The Summary Buffer 3.16 Decoding Articles ====================== Sometime users post articles (or series of articles) that have been encoded in some way or other. Gnus can decode them for you. * Menu: * Uuencoded Articles:: Uudecode articles. * Shared Articles:: Unshar articles. * PostScript Files:: Split PostScript. * Decoding Variables:: Variables for a happy decoding. * Viewing Files:: You want to look at the result of the decoding? All these functions use the process/prefix convention (*note Process/Prefix::) for finding out what articles to work on, with the extension that a "single article" means "a single series". Gnus can find out by itself what articles belong to a series, decode all the articles and unpack/view/save the resulting file(s). Gnus guesses what articles are in the series according to the following simplish rule: The subjects must be (nearly) identical, except for the last two numbers of the line. (Spaces are largely ignored, however.) For example: If you choose a subject called `cat.gif (2/3)', Gnus will find all the articles that match the regexp `^cat.gif ([0-9]+/[0-9]+).*$'. Subjects that are nonstandard, like `cat.gif (2/3) Part 6 of a series', will not be properly recognized by any of the automatic viewing commands, and you have to mark the articles manually with `#'.  File: gnus, Node: Uuencoded Articles, Next: Shared Articles, Up: Decoding Articles 3.16.1 Uuencoded Articles ------------------------- `X u' Uudecodes the current series (`gnus-uu-decode-uu'). `X U' Uudecodes and saves the current series (`gnus-uu-decode-uu-and-save'). `X v u' Uudecodes and views the current series (`gnus-uu-decode-uu-view'). `X v U' Uudecodes, views and saves the current series (`gnus-uu-decode-uu-and-save-view'). Remember that these all react to the presence of articles marked with the process mark. If, for instance, you'd like to decode and save an entire newsgroup, you'd typically do `M P a' (`gnus-uu-mark-all') and then `X U' (`gnus-uu-decode-uu-and-save'). All this is very much different from how `gnus-uu' worked with GNUS 4.1, where you had explicit keystrokes for everything under the sun. This version of `gnus-uu' generally assumes that you mark articles in some way (*note Setting Process Marks::) and then press `X u'. Note: When trying to decode articles that have names matching `gnus-uu-notify-files', which is hard-coded to `[Cc][Ii][Nn][Dd][Yy][0-9]+.\\(gif\\|jpg\\)', `gnus-uu' will automatically post an article on `comp.unix.wizards' saying that you have just viewed the file in question. This feature can't be turned off.  File: gnus, Node: Shared Articles, Next: PostScript Files, Prev: Uuencoded Articles, Up: Decoding Articles 3.16.2 Shared Articles ---------------------- `X s' Unshars the current series (`gnus-uu-decode-unshar'). `X S' Unshars and saves the current series (`gnus-uu-decode-unshar-and-save'). `X v s' Unshars and views the current series (`gnus-uu-decode-unshar-view'). `X v S' Unshars, views and saves the current series (`gnus-uu-decode-unshar-and-save-view').  File: gnus, Node: PostScript Files, Next: Decoding Variables, Prev: Shared Articles, Up: Decoding Articles 3.16.3 PostScript Files ----------------------- `X p' Unpack the current PostScript series (`gnus-uu-decode-postscript'). `X P' Unpack and save the current PostScript series (`gnus-uu-decode-postscript-and-save'). `X v p' View the current PostScript series (`gnus-uu-decode-postscript-view'). `X v P' View and save the current PostScript series (`gnus-uu-decode-postscript-and-save-view').  File: gnus, Node: Decoding Variables, Next: Viewing Files, Prev: PostScript Files, Up: Decoding Articles 3.16.4 Decoding Variables ------------------------- Adjective, not verb. * Menu: * Rule Variables:: Variables that say how a file is to be viewed. * Other Decode Variables:: Other decode variables. * Uuencoding and Posting:: Variables for customizing uuencoding.  File: gnus, Node: Rule Variables, Next: Other Decode Variables, Up: Decoding Variables 3.16.4.1 Rule Variables ....................... Gnus uses "rule variables" to decide how to view a file. All these variables are on the form (list '(regexp1 command2) '(regexp2 command2) ...) `gnus-uu-user-view-rules' This variable is consulted first when viewing files. If you wish to use, for instance, `sox' to convert an `.au' sound file, you could say something like: (setq gnus-uu-user-view-rules (list '(\"\\\\.au$\" \"sox %s -t .aiff > /dev/audio\"))) `gnus-uu-user-view-rules-end' This variable is consulted if Gnus couldn't make any matches from the user and default view rules. `gnus-uu-user-archive-rules' This variable can be used to say what commands should be used to unpack archives.  File: gnus, Node: Other Decode Variables, Next: Uuencoding and Posting, Prev: Rule Variables, Up: Decoding Variables 3.16.4.2 Other Decode Variables ............................... `gnus-uu-grabbed-file-functions' All functions in this list will be called right each file has been successfully decoded--so that you can move or view files right away, and don't have to wait for all files to be decoded before you can do anything. Ready-made functions you can put in this list are: `gnus-uu-grab-view' View the file. `gnus-uu-grab-move' Move the file (if you're using a saving function.) `gnus-uu-ignore-files-by-name' Files with name matching this regular expression won't be viewed. `gnus-uu-ignore-files-by-type' Files with a MIME type matching this variable won't be viewed. Note that Gnus tries to guess what type the file is based on the name. `gnus-uu' is not a MIME package (yet), so this is slightly kludgey. `gnus-uu-tmp-dir' Where `gnus-uu' does its work. `gnus-uu-do-not-unpack-archives' Non-`nil' means that `gnus-uu' won't peek inside archives looking for files to display. `gnus-uu-view-and-save' Non-`nil' means that the user will always be asked to save a file after viewing it. `gnus-uu-ignore-default-view-rules' Non-`nil' means that `gnus-uu' will ignore the default viewing rules. `gnus-uu-ignore-default-archive-rules' Non-`nil' means that `gnus-uu' will ignore the default archive unpacking commands. `gnus-uu-kill-carriage-return' Non-`nil' means that `gnus-uu' will strip all carriage returns from articles. `gnus-uu-unmark-articles-not-decoded' Non-`nil' means that `gnus-uu' will mark articles that were unsuccessfully decoded as unread. `gnus-uu-correct-stripped-uucode' Non-`nil' means that `gnus-uu' will _try_ to fix uuencoded files that have had trailing spaces deleted. `gnus-uu-view-with-metamail' Non-`nil' means that `gnus-uu' will ignore the viewing commands defined by the rule variables and just fudge a MIME content type based on the file name. The result will be fed to `metamail' for viewing. `gnus-uu-save-in-digest' Non-`nil' means that `gnus-uu', when asked to save without decoding, will save in digests. If this variable is `nil', `gnus-uu' will just save everything in a file without any embellishments. The digesting almost conforms to RFC1153--no easy way to specify any meaningful volume and issue numbers were found, so I simply dropped them.  File: gnus, Node: Uuencoding and Posting, Prev: Other Decode Variables, Up: Decoding Variables 3.16.4.3 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 are 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 3.16.5 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: Summary Sorting, Prev: Decoding Articles, Up: The Summary Buffer 3.17 Article Treatment ====================== Reading through this huge manual, you may have quite forgotten that the object of newsreaders are 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 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!  File: gnus, Node: Article Highlighting, Next: Article Hiding, Up: Article Treatment 3.17.1 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' Highlight the current article (`gnus-article-highlight'). `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 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. 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' in an article will be considered a signature and will be highlighted with `gnus-signature-face', which is `italic' by default.  File: gnus, Node: Article Hiding, Next: Article Washing, Prev: Article Highlighting, Up: Article Treatment 3.17.2 Article Hiding --------------------- Or rather, hiding certain things in each article. There usually is much too much cruft in most articles. `W W a' Do maximum hiding on the summary buffer (`gnus-article-hide'). `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'). `W W p' Hide PGP signatures (`gnus-article-hide-pgp'). `W W c' Hide citation (`gnus-article-hide-citation'). Some variables for customizing the hiding: `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 be have at least this length (default 10) before it is hidden. `gnus-cited-text-button-line-format' Gnus adds buttons show where the cited text has been hidden, and to allow toggle hiding the text. The format of the variable is specified by this format-like variable. These specs are legal: `b' Start point of the hidden text. `e' End point of the hidden text. `l' Length of the hidden text. `gnus-cited-lines-visible' The number of lines at the beginning of the cited text to leave shown. `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 in `gnus-article-display-hook' (*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. `gnus-signature-limit' provides a limit to what is considered a signature. If it is a number, no signature may not be longer (in characters) than that number. 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. If it is a string, it will be used as a regexp. If it matches, the text in question is not a signature.  File: gnus, Node: Article Washing, Next: Article Buttons, Prev: Article Hiding, Up: Article Treatment 3.17.3 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'). `W r' Do a Caesar rotate (rot13) on the article buffer (`gnus-summary-caesar-message'). `W 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 m' Toggle whether to run the article through MIME before displaying (`gnus-summary-toggle-mime'). `W o' Treat overstrike (`gnus-article-treat-overstrike'). `W w' Do word wrap (`gnus-article-fill-cited-article'). `W c' Remove CR (`gnus-article-remove-cr'). `W L' Remove all blank lines at the end of the article (`gnus-article-remove-trailing-blank-lines'). `W q' Treat quoted-printable (`gnus-article-de-quoted-unreadable'). `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 an `xv' to view the face; under XEmacs 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.) 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'). `W B' Add clickable buttons to the article headers (`gnus-article-add-buttons-to-head').  File: gnus, Node: Article Buttons, Next: Article Date, Prev: Article Washing, Up: Article Treatment 3.17.4 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. 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 match embedded URLs: `]*\\)>'. BUTTON-PAR Gnus has to know which parts of the match is to be highlighted. This is a number that says what sub-expression of the regexp that 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 ("]*\\)>" 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 bottons. `gnus-article-mouse-face' Face is used when the mouse cursor is over a button.  File: gnus, Node: Article Date, Prev: Article Buttons, Up: Article Treatment 3.17.5 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 l' Display the date in the local timezone (`gnus-article-date-local'). `W T e' Say how much time has (e)lapsed between the article was posted and now (`gnus-article-date-lapsed'). `W T o' Display the original date (`gnus-article-date-original'). This can be useful if you normally use some other conversion function and is 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*  File: gnus, Node: Summary Sorting, Next: Finding the Parent, Prev: Article Treatment, Up: The Summary Buffer 3.18 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-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 3.19 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. You can have Gnus fetch all articles mentioned in the `References' header of the article by pushing `A R' (`gnus-summary-refer-references'). 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 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. 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 same as the one that keeps the spool you are reading from updated, but that's not really necessary. Most of the mail backends support fetching by `Message-ID', but do not do a particularly excellent job of 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 3.20 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 3.20.1 Pick and Read -------------------- Some newsreaders (like `nn' and, uhm, `nn') use a two-phased reading interface. The user first marks the articles she wants to read from a summary buffer. 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 makes one additional command for switching to the summary buffer available. Here are the available keystrokes when using pick mode: `SPACE' Pick the article (`gnus-summary-mark-as-processable'). `u' Unpick the article (`gnus-summary-unmark-as-processable'). `U' Unpick all articles (`gnus-summary-unmark-all-processable'). `t' Pick the thread (`gnus-uu-mark-thread'). `T' Unpick the thread (`gnus-uu-unmark-thread'). `r' Pick the region (`gnus-uu-mark-region'). `R' Unpick the region (`gnus-uu-unmark-region'). `e' Pick articles that match a regexp (`gnus-uu-mark-by-regexp'). `E' Unpick articles that match a regexp (`gnus-uu-unmark-by-regexp'). `b' Pick the buffer (`gnus-uu-mark-buffer'). `B' Unpick the buffer (`gnus-uu-unmark-buffer'). `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. 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.  File: gnus, Node: Binary Groups, Prev: Pick and Read, Up: Alternative Approaches 3.20.2 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. In fact, the only way to see the actual articles if you have turned this mode on is the `g' command (`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 3.21 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. The default is `Gnus: %%b [%A] %Z'. For a list of legal 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. Legal 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'. `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 and 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]  File: gnus, Node: Mail Group Commands, Next: Various Summary Stuff, Prev: Tree Display, Up: The Summary Buffer 3.22 Mail Group Commands ======================== Some commands only make sense in mail groups. If these commands are illegal in the current group, they will raise a hell and let you know. All these commands (except the expiry and edit commands) use the process/prefix convention (*note Process/Prefix::). `B e' Expire all expirable articles in the group (`gnus-summary-expire-articles'). `B M-C-e' Expunge all the expirable articles in the group (`gnus-summary-expire-articles-now'). This means that *all* articles that are eligible for expiry in the current group will disappear forever into that big `/dev/null' in the sky. `B DEL' Delete the mail article. This is "delete" as in "delete it from your disk forever and ever, never to return again." Use with caution. (`gnus-summary-delete-article'). `B m' Move the article from one mail group to another (`gnus-summary-move-article'). `B c' Copy the article from one group (mail group or not) to a mail group (`gnus-summary-copy-article'). `B C' Crosspost the current article to some other group (`gnus-summary-crosspost-article'). This will create a new copy of the article in the other group, and the Xref headers of the article will be properly updated. `B i' Import an arbitrary file into the current mail newsgroup (`gnus-summary-import-article'). You will be prompted for a file name, a `From' header and a `Subject' header. `B r' Respool the mail article (`gnus-summary-move-article'). `B w' `e' Edit the current article (`gnus-summary-edit-article'). To finish editing and make the changes permanent, type `C-c C-c' (`gnus-summary-edit-article-done'). `B q' If you want to re-spool an article, you might be curious as to what group the article will end up in before you do the re-spooling. This command will tell you (`gnus-summary-respool-query'). If you move (or copy) articles regularly, you might wish to have Gnus suggest where to put the articles. `gnus-move-split-methods' is a variable that uses the same syntax as `gnus-split-methods' (*note Saving Articles::). You may customize that variable to create suggestions you find reasonable.  File: gnus, Node: Various Summary Stuff, Next: Exiting the Summary Buffer, Prev: Mail Group Commands, Up: The Summary Buffer 3.23 Various Summary Stuff ========================== * Menu: * Summary Group Information:: Information oriented commands. * Searching for Articles:: Multiple article commands. * Really Various Summary Commands:: Those pesky non-conformant commands. `gnus-summary-mode-hook' This hook is called when creating a summary mode buffer. `gnus-summary-generate-hook' This is called as the last thing before doing the threading and the generation of the summary buffer. It's quite convenient for customizing the threading variables based on what data the newsgroup has. This hook is called from the summary buffer after most summary buffer variables has been set. `gnus-summary-prepare-hook' Is is called after the summary buffer has been generated. You might use it to, for instance, highlight lines or modify the look of the buffer in some other ungodly manner. I don't care.  File: gnus, Node: Summary Group Information, Next: Searching for Articles, Up: Various Summary Stuff 3.23.1 Summary Group Information -------------------------------- `H f' Try to fetch the FAQ (list of frequently asked questions) for the current group (`gnus-summary-fetch-faq'). Gnus will try to get the FAQ from `gnus-group-faq-directory', which is usually a directory on a remote machine. This variable can also be a list of directories. In that case, giving a prefix to this command will allow you to choose between the various sites. `ange-ftp' probably will be used for fetching the file. `H d' Give a brief description of the current group (`gnus-summary-describe-group'). If given a prefix, force rereading the description from the server. `H h' Give a very brief description of the most important summary keystrokes (`gnus-summary-describe-briefly'). `H i' Go to the Gnus info node (`gnus-info-find-node').  File: gnus, Node: Searching for Articles, Next: Really Various Summary Commands, Prev: Summary Group Information, Up: Various Summary Stuff 3.23.2 Searching for Articles ----------------------------- `M-s' Search through all subsequent articles for a regexp (`gnus-summary-search-article-forward'). `M-r' Search through all previous articles for a regexp (`gnus-summary-search-article-backward'). `&' This command will prompt you for a header field, a regular expression to match on this field, and a command to be executed if the match is made (`gnus-summary-execute-command'). `M-&' Perform any operation on all articles that have been marked with the process mark (`gnus-summary-universal-argument').  File: gnus, Node: Really Various Summary Commands, Prev: Searching for Articles, Up: Various Summary Stuff 3.23.3 Really Various Summary Commands -------------------------------------- `A D' If the current article is a collection of other articles (for instance, a digest), you might use this command to enter a group based on the that article (`gnus-summary-enter-digest-group'). Gnus will try to guess what article type is currently displayed unless you give a prefix to this command, which forces a "digest" interpretation. Basically, whenever you see a message that is a collection of other messages on some format, you `A D' and read these messages in a more convenient fashion. `C-t' Toggle truncation of summary lines (`gnus-summary-toggle-truncation'). `=' Expand the summary buffer window (`gnus-summary-expand-window'). If given a prefix, force an `article' window configuration.  File: gnus, Node: Exiting the Summary Buffer, Prev: Various Summary Stuff, Up: The Summary Buffer 3.24 Exiting the Summary Buffer =============================== Exiting from the summary buffer will normally update all info on the group and return you to the group buffer. `Z Z' `q' Exit the current group and update all information on the group (`gnus-summary-exit'). `gnus-summary-prepare-exit-hook' is called before doing much of the exiting, and calls `gnus-summary-expire-articles' by default. `gnus-summary-exit-hook' is called after finishing the exiting process. `Z E' `Q' Exit the current group without updating any information on the group (`gnus-summary-exit-no-update'). `Z c' `c' Mark all unticked articles in the group as read and then exit (`gnus-summary-catchup-and-exit'). `Z C' Mark all articles, even the ticked ones, as read and then exit (`gnus-summary-catchup-all-and-exit'). `Z n' Mark all articles as read and go to the next group (`gnus-summary-catchup-and-goto-next-group'). `Z R' Exit this group, and then enter it again (`gnus-summary-reselect-current-group'). If given a prefix, select all articles, both read and unread. `Z G' `M-g' Exit the group, check for new articles in the group, and select the group (`gnus-summary-rescan-group'). If given a prefix, select all articles, both read and unread. `Z N' Exit the group and go to the next group (`gnus-summary-next-group'). `Z P' Exit the group and go to the previous group (`gnus-summary-prev-group'). `gnus-exit-group-hook' is called when you exit the current group. If you're in the habit of exiting groups, and then changing your mind about it, you might set `gnus-kill-summary-on-exit' to `nil'. If you do that, Gnus won't kill the summary buffer when you exit it. (Quelle surprise!) Instead it will change the name of the buffer to something like `*Dead Summary ... *' and install a minor mode called `gnus-dead-summary-mode'. Now, if you switch back to this buffer, you'll find that all keys are mapped to a function called `gnus-summary-wake-up-the-dead'. So tapping any keys in a dead summary buffer will result in a live, normal summary buffer. There will never be more than one dead summary buffer at any one time. The data on the current group will be updated (which articles you have read, which articles you have replied to, etc.) when you exit the summary buffer. If the `gnus-use-cross-reference' variable is `t' (which is the default), articles that are cross-referenced to this group and are marked as read, will also be marked as read in the other subscribed groups they were cross-posted to. If this variable is neither `nil' nor `t', the article will be marked as read in both subscribed and unsubscribed groups. Marking cross-posted articles as read ensures that you'll never have to read the same article more than once. Unless, of course, somebody has posted it to several groups separately. Posting the same article to several groups (not cross-posting) is called "spamming", and you are by law required to send nasty-grams to anyone who perpetrates such a heinous crime. Remember: Cross-posting is kinda ok, but posting the same article separately to several groups is not. Massive cross-posting (aka. "velveeta") is to be avoided. One thing that may cause Gnus to not do the cross-posting thing correctly is if you use an NNTP server that supports XOVER (which is very nice, because it speeds things up considerably) which does not include the `Xref' header in its NOV lines. This is Evil, but all too common, alas, alack. Gnus tries to Do The Right Thing even with XOVER by registering the `Xref' lines of all articles you actually read, but if you kill the articles, or just mark them as read without reading them, Gnus will not get a chance to snoop the `Xref' lines out of these articles, and will be unable to use the cross reference mechanism. To check whether your NNTP server includes the `Xref' header in its overview files, try `telnet your.nntp.server nntp', `MODE READER' on `inn' servers, and then say `LIST overview.fmt'. This may not work, but if it does, and the last line you get does not read `Xref:full', then you should shout and whine at your news admin until she includes the `Xref' header in the overview files. If you want Gnus to get the `Xref's right all the time, you have to set `gnus-nov-is-evil' to `t', which slows things down considerably. C'est la vie.  File: gnus, Node: The Article Buffer, Next: Composing Messages, Prev: The Summary Buffer, Up: Top 4 The Article Buffer ******************** The articles are displayed in the article buffer, of which there is only one. All the summary buffers share the same article buffer unless you tell Gnus otherwise. * Menu: * Hiding Headers:: Deciding what headers should be displayed. * Using MIME:: Pushing articles through MIME before reading them. * Customizing Articles:: Tailoring the look of the articles. * Article Keymap:: Keystrokes available in the article buffer * Misc Article:: Other stuff.  File: gnus, Node: Hiding Headers, Next: Using MIME, Up: The Article Buffer 4.1 Hiding Headers ================== The top section of each article is the "head". (The rest is the "body", but you may have guessed that already.) There is a lot of useful information in the head: the name of the person who wrote the article, the date it was written and the subject of the article. That's well and nice, but there's also lots of information most people do not want to see--what systems the article has passed through before reaching you, the `Message-ID', the `References', etc. ad nauseum--and you'll probably want to get rid of some of those lines. If you want to keep all those lines in the article buffer, you can set `gnus-show-all-headers' to `t'. Gnus provides you with two variables for sifting headers: `gnus-visible-headers' If this variable is non-`nil', it should be a regular expression that says what headers you wish to keep in the article buffer. All headers that do not match this variable will be hidden. For instance, if you only want to see the name of the person who wrote the article and the subject, you'd say: (setq gnus-visible-headers "^From:\\|^Subject:") This variable can also be a list of regexps to match headers that are to remain visible. `gnus-ignored-headers' This variable is the reverse of `gnus-visible-headers'. If this variable is set (and `gnus-visible-headers' is `nil'), it should be a regular expression that matches all lines that you want to hide. All lines that do not match this variable will remain visible. For instance, if you just want to get rid of the `References' line and the `Xref' line, you might say: (setq gnus-ignored-headers "^References:\\|^Xref:") This variable can also be a list of regexps to match headers that are to be removed. Note that if `gnus-visible-headers' is non-`nil', this variable will have no effect. Gnus can also sort the headers for you. (It does this by default.) You can control the sorting by setting the `gnus-sorted-header-list' variable. It is a list of regular expressions that says in what order the headers are to be displayed. For instance, if you want the name of the author of the article first, and then the subject, you might say something like: (setq gnus-sorted-header-list '("^From:" "^Subject:")) Any headers that are to remain visible, but are not listed in this variable, will be displayed in random order after all the headers that are listed in this variable. You can hide further boring headers by entering `gnus-article-hide-boring-headers' into `gnus-article-display-hook'. What this function does depends on the `gnus-boring-article-headers' variable. It's a list, but this list doesn't actually contain header names. Instead is lists various "boring conditions" that Gnus can check and remove from sight. These conditions are: `empty' Remove all empty headers. `newsgroups' Remove the `Newsgroups' header if it only contains the current group name. `followup-to' Remove the `Followup-To' header if it is identical to the `Newsgroups' header. `reply-to' Remove the `Reply-To' header if it lists the same address as the `From' header. `date' Remove the `Date' header if the article is less than three days old. To include the four first elements, you could say something like; (setq gnus-boring-article-headers '(empty newsgroups followup-to reply-to)) This is also the default value for this variable.  File: gnus, Node: Using MIME, Next: Customizing Articles, Prev: Hiding Headers, Up: The Article Buffer 4.2 Using MIME ============== Mime is a standard for waving your hands through the air, aimlessly, while people stand around yawning. MIME, however, is a standard for encoding your articles, aimlessly, while all newsreaders die of fear. MIME may specify what character set the article uses, the encoding of the characters, and it also makes it possible to embed pictures and other naughty stuff in innocent-looking articles. Gnus handles MIME by shoving the articles through `gnus-show-mime-method', which is `metamail-buffer' by default. Set `gnus-show-mime' to `t' if you want to use MIME all the time. However, if `gnus-strict-mime' is non-`nil', the MIME method will only be used if there are MIME headers in the article. It might be best to just use the toggling functions from the summary buffer to avoid getting nasty surprises. (For instance, you enter the group `alt.sing-a-long' and, before you know it, MIME has decoded the sound file in the article and some horrible sing-a-long song comes streaming out out your speakers, and you can't find the volume button, because there isn't one, and people are starting to look at you, and you try to stop the program, but you can't, and you can't find the program to control the volume, and everybody else in the room suddenly decides to look at you disdainfully, and you'll feel rather stupid.) Any similarity to real events and people is purely coincidental. Ahem.  File: gnus, Node: Customizing Articles, Next: Article Keymap, Prev: Using MIME, Up: The Article Buffer 4.3 Customizing Articles ======================== The `gnus-article-display-hook' is called after the article has been inserted into the article buffer. It is meant to handle all treatment of the article before it is displayed. By default it contains `gnus-article-hide-headers', `gnus-article-treat-overstrike', and `gnus-article-maybe-highlight', but there are thousands, nay millions, of functions you can put in this hook. For an overview of functions *note Article Highlighting::, *note Article Hiding::, *note Article Washing::, *note Article Buttons:: and *note Article Date::. You can, of course, write your own functions. The functions are called from the article buffer, and you can do anything you like, pretty much. There is no information that you have to keep in the buffer--you can change everything. However, you shouldn't delete any headers. Instead make them invisible if you want to make them go away.  File: gnus, Node: Article Keymap, Next: Misc Article, Prev: Customizing Articles, Up: The Article Buffer 4.4 Article Keymap ================== Most of the keystrokes in the summary buffer can also be used in the article buffer. They should behave as if you typed them in the summary buffer, which means that you don't actually have to have a summary buffer displayed while reading. You can do it all from the article buffer. A few additional keystrokes are available: `SPACE' Scroll forwards one page (`gnus-article-next-page'). `DEL' Scroll backwards one page (`gnus-article-prev-page'). `C-c ^' If point is in the neighborhood of a `Message-ID' and you press `r', Gnus will try to get that article from the server (`gnus-article-refer-article'). `C-c C-m' Send a reply to the address near point (`gnus-article-mail'). If given a prefix, include the mail. `s' Reconfigure the buffers so that the summary buffer becomes visible (`gnus-article-show-summary'). `?' Give a very brief description of the available keystrokes (`gnus-article-describe-briefly'). `TAB' Go to the next button, if any (`gnus-article-next-button'. This only makes sense if you have buttonizing turned on. `M-TAB' Go to the previous button, if any (`gnus-article-prev-button'.  File: gnus, Node: Misc Article, Prev: Article Keymap, Up: The Article Buffer 4.5 Misc Article ================ `gnus-single-article-buffer' If non-`nil', use the same article buffer for all the groups. (This is the default.) If `nil', each group will have its own article buffer. `gnus-article-prepare-hook' This hook is called right after the article has been inserted into the article buffer. It is mainly intended for functions that do something depending on the contents; it should probably not be used for changing the contents of the article buffer. `gnus-article-display-hook' This hook is called as the last thing when displaying an article, and is intended for modifying the contents of the buffer, doing highlights, hiding headers, and the like. `gnus-article-mode-hook' Hook called in article mode buffers. `gnus-article-mode-line-format' This variable is a format string along the same lines as `gnus-summary-mode-line-format'. It accepts exactly the same format specifications as that variable. `gnus-break-pages' Controls whether "page breaking" is to take place. If this variable is non-`nil', the articles will be divided into pages whenever a page delimiter appears in the article. If this variable is `nil', paging will not be done. `gnus-page-delimiter' This is the delimiter mentioned above. By default, it is `^L' (form linefeed).  File: gnus, Node: Composing Messages, Next: Select Methods, Prev: The Article Buffer, Up: Top 5 Composing Messages ******************** All commands for posting and mailing will put you in a message buffer where you can edit the article all you like, before you send the article by pressing `C-c C-c'. *Note Top: (message)Top. 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 and replying. * Post:: Posting and following up. * Posting Server:: What server should you post via? * Mail and Post:: Mailing and posting at the same time. * Archived Messages:: Where Gnus stores the messages you've sent. Also see *note Canceling and Superseding:: for information on how to remove articles you shouldn't have posted.  File: gnus, Node: Mail, Next: Post, Up: Composing Messages 5.1 Mail ======== Variables for customizing outgoing mail: `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.  File: gnus, Node: Post, Next: Posting Server, Prev: Mail, Up: Composing Messages 5.2 Post ======== Variables for composing news articles: `gnus-sent-message-ids-file' Gnus will keep a `Message-ID' history file of all the mails it has sent. If it discovers that it has already sent a mail, it will ask the user whether to re-send the mail. (This is primarily useful when dealing with SOUP packets and the like where one is apt to sent the same packet multiple times.) This variable says what the name of this history file is. It is `~/News/Sent-Message-IDs' by default. Set this variable to `nil' if you don't want Gnus to keep a history file. `gnus-sent-message-ids-length' This variable says how many `Message-ID's to keep in the history file. It is 1000 by default.  File: gnus, Node: Posting Server, Next: Mail and Post, Prev: Post, Up: Composing Messages 5.3 Posting Server ================== When you press those magical `C-c C-c' keys to ship off your latest (extremely intelligent, of course) article, where does it go? Thank you for asking. I hate you. It can be quite complicated. Normally, Gnus will use the same native server. However. If your native server doesn't allow posting, just reading, you probably want to use some other server to post your (extremely intelligent and fabulously interesting) articles. You can then set the `gnus-post-method' to some other method: (setq gnus-post-method '(nnspool "")) Now, if you've done this, and then this server rejects your article, or this server is down, what do you do then? To override this variable you can use a non-zero prefix to the `C-c C-c' command to force using the "current" server for posting. If you give a zero prefix (i. e., `C-u 0 C-c C-c') to that command, Gnus will prompt you for what method to use for posting. You can also set `gnus-post-method' to a list of select methods. If that's the case, Gnus will always prompt you for what method to use for posting.  File: gnus, Node: Mail and Post, Next: Archived Messages, Prev: Posting Server, Up: Composing Messages 5.4 Mail and Post ================= Here's a list of variables that are relevant to both mailing and posting: `gnus-mailing-list-groups' If your news server offers groups that are really mailing lists that are gatewayed to the NNTP server, you can read those groups without problems, but you can't post/followup to them without some difficulty. One solution is to add a `to-address' to the group parameters (*note Group Parameters::). An easier thing to do is set the `gnus-mailing-list-groups' to a regexp that match the groups that really are mailing lists. Then, at least, followups to the mailing lists will work most of the time. Posting to these groups (`a') is still a pain, though. 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 'message-send-hook 'ispell-message)  File: gnus, Node: Archived Messages, Prev: Mail and Post, Up: Composing Messages 5.5 Archived Messages ===================== Gnus provides a few different methods for storing the mail you send. The default method is to use the "archive virtual server" to store the mail. If you want to disable this completely, you should set `gnus-message-archive-group' to `nil'. `gnus-message-archive-method' says what virtual server Gnus is to use to store sent messages. It is `(nnfolder "archive" (nnfolder-directory "~/Mail/archive/"))' by default, but you can use any mail select method (`nnml', `nnmbox', etc.). However, `nnfolder' is a quite likeable select method for doing this sort of thing. If you don't like the default directory chosen, you could say something like: (setq gnus-message-archive-method '(nnfolder "archive" (nnfolder-inhibit-expiry t) (nnfolder-active-file "~/News/sent-mail/active") (nnfolder-directory "~/News/sent-mail/"))) Gnus will insert `Gcc' headers in all outgoing messages that point to one or more group(s) on that server. Which group to use is determined by the `gnus-message-archive-group' variable. This variable can be: * a string Messages will be saved in that group. * a list of strings Messages will be saved in all those groups. * an alist of regexps, functions and forms When a key "matches", the result is used. Let's illustrate: Just saving to a single group called `MisK': (setq gnus-message-archive-group "MisK") Saving to two groups, `MisK' and `safe': (setq gnus-message-archive-group '("MisK" "safe")) Save to different groups based on what group you are in: (setq gnus-message-archive-group '(("^alt" "sent-to-alt") ("mail" "sent-to-mail") (".*" "sent-to-misc"))) More complex stuff: (setq gnus-message-archive-group '((if (message-news-p) "misc-news" "misc-mail"))) This is the default. How about storing all news messages in one file, but storing all mail messages in one file per month: (setq gnus-message-archive-group '((if (message-news-p) "misc-news" (concat "mail." (format-time-string "%Y-%m" (current-time)))))) Now, when you send a message off, it will be stored in the appropriate group. (If you want to disable storing for just one particular message, you can just remove the `Gcc' header that has been inserted.) The archive group will appear in the group buffer the next time you start Gnus, or the next time you press `F' in the group buffer. You can enter it and read the articles in it just like you'd read any other group. If the group gets really big and annoying, you can simply rename if (using `G r' in the group buffer) to something nice - `misc-mail-september-1995', or whatever. New messages will continue to be stored in the old (now empty) group. That's the default method of archiving sent mail. Gnus also offers two other variables for the people who don't like the default method. In that case you should set `gnus-message-archive-group' to `nil'; this will disable archiving. XEmacs 19.13 doesn't have `format-time-string', so you'll have to use a different value for `gnus-message-archive-group' there. `gnus-outgoing-message-group' All outgoing messages will be put in this group. If you want to store all your outgoing mail and articles in the group `nnml:archive', you set this variable to that value. This variable can also be a list of group names. If you want to have greater control over what group to put each message in, you can set this variable to a function that checks the current newsgroup name and then returns a suitable group name (or list of names).  File: gnus, Node: Select Methods, Next: Scoring, Prev: Composing Messages, Up: Top 6 Select Methods **************** A "foreign group" is a group that is not read by the usual (or default) means. It could be, for instance, a group from a different NNTP server, it could be a virtual group, or it could be your own personal mail group. A foreign group (or any group, really) is specified by a "name" and a "select method". To take the latter first, a select method is a list where the first element says what backend to use (eg. `nntp', `nnspool', `nnml') and the second element is the "server name". There may be additional elements in the select method, where the value may have special meaning for the backend in question. One could say that a select method defines a "virtual server"--so we do just that (*note The Server Buffer::). The "name" of the group is the name the backend will recognize the group as. For instance, the group `soc.motss' on the NNTP server `some.where.edu' will have the name `soc.motss' and select method `(nntp "some.where.edu")'. Gnus will call this group, in all circumstances, `nntp+some.where.edu:soc.motss', even though the `nntp' backend just knows this group as `soc.motss'. The different methods all have their peculiarities, of course. * Menu: * The Server Buffer:: Making and editing virtual servers. * Getting News:: Reading USENET news with Gnus. * Getting Mail:: Reading your personal mail with Gnus. * Other Sources:: Reading directories, files, SOUP packets. * Combined Groups:: Combining groups into one group.  File: gnus, Node: The Server Buffer, Next: Getting News, Up: Select Methods 6.1 The Server Buffer ===================== Traditionally, a "server" is a machine or a piece of software that one connects to, and then requests information from. Gnus does not connect directly to any real servers, but does all transactions through one backend or other. But that's just putting one layer more between the actual media and Gnus, so we might just as well say that each backend represents a virtual server. For instance, the `nntp' backend may be used to connect to several different actual NNTP servers, or, perhaps, to many different ports on the same actual NNTP server. You tell Gnus which backend to use, and what parameters to set by specifying a "select method". These select methods specifications can sometimes become quite complicated--say, for instance, that you want to read from the NNTP server `news.funet.fi' on port number `13', which hangs if queried for NOV headers and has a buggy select. Ahem. Anyways, if you had to specify that for each group that used this server, that would be too much work, so Gnus offers a way of naming select methods, which is what you do in the server buffer. To enter the server buffer, user the `^' (`gnus-group-enter-server-mode') command in the group buffer. * Menu: * Server Buffer Format:: You can customize the look of this buffer. * Server Commands:: Commands to manipulate servers. * Example Methods:: Examples server specifications. * Creating a Virtual Server:: An example session. * Servers and Methods:: You can use server names as select methods. * Unavailable Servers:: Some servers you try to contact may be down. `gnus-server-mode-hook' is run when creating the server buffer.  File: gnus, Node: Server Buffer Format, Next: Server Commands, Up: The Server Buffer 6.1.1 Server Buffer Format -------------------------- You can change the look of the server buffer lines by changing the `gnus-server-line-format' variable. This is a `format'-like variable, with some simple extensions: `h' How the news is fetched--the backend name. `n' The name of this server. `w' Where the news is to be fetched from--the address. `s' The opened/closed/denied status of the server. The mode line can also be customized by using the `gnus-server-mode-line-format' variable. The following specs are understood: `S' Server name. `M' Server method. Also *note Formatting Variables::.  File: gnus, Node: Server Commands, Next: Example Methods, Prev: Server Buffer Format, Up: The Server Buffer 6.1.2 Server Commands --------------------- `a' Add a new server (`gnus-server-add-server'). `e' Edit a server (`gnus-server-edit-server'). `SPACE' Browse the current server (`gnus-server-read-server'). `q' Return to the group buffer (`gnus-server-exit'). `k' Kill the current server (`gnus-server-kill-server'). `y' Yank the previously killed server (`gnus-server-yank-server'). `c' Copy the current server (`gnus-server-copy-server'). `l' List all servers (`gnus-server-list-servers').  File: gnus, Node: Example Methods, Next: Creating a Virtual Server, Prev: Server Commands, Up: The Server Buffer 6.1.3 Example Methods --------------------- Most select methods are pretty simple and self-explanatory: (nntp "news.funet.fi") Reading directly from the spool is even simpler: (nnspool "") As you can see, the first element in a select method is the name of the backend, and the second is the "address", or "name", if you will. After these two elements, there may be a arbitrary number of (VARIABLE FORM) pairs. To go back to the first example--imagine that you want to read from port `15' from that machine. This is what the select method should look like then: (nntp "news.funet.fi" (nntp-port-number 15)) You should read the documentation to each backend to find out what variables are relevant, but here's an `nnmh' example. `nnmh' is a mail backend that reads a spool-like structure. Say you have two structures that you wish to access: One is your private mail spool, and the other is a public one. Here's the possible spec for you private mail: (nnmh "private" (nnmh-directory "~/private/mail/")) (This server is then called `private', but you may have guessed that.) Here's the method for a public spool: (nnmh "public" (nnmh-directory "/usr/information/spool/") (nnmh-get-new-mail nil))  File: gnus, Node: Creating a Virtual Server, Next: Servers and Methods, Prev: Example Methods, Up: The Server Buffer 6.1.4 Creating a Virtual Server ------------------------------- If you're saving lots of articles in the cache by using persistent articles, you may want to create a virtual server to read the cache. First you need to add a new server. The `a' command does that. It would probably be best to use `nnspool' to read the cache. You could also use `nnml' or `nnmh', though. Type `a nnspool RET cache RET'. You should now have a brand new `nnspool' virtual server called `cache'. You now need to edit it to have the right definitions. Type `e' to edit the server. You'll be entered into a buffer that will contain the following: (nnspool "cache") Change that to: (nnspool "cache" (nnspool-spool-directory "~/News/cache/") (nnspool-nov-directory "~/News/cache/") (nnspool-active-file "~/News/cache/active")) Type `C-c C-c' to return to the server buffer. If you now press `RET' over this virtual server, you should be entered into a browse buffer, and you should be able to enter any of the groups displayed.  File: gnus, Node: Servers and Methods, Next: Unavailable Servers, Prev: Creating a Virtual Server, Up: The Server Buffer 6.1.5 Servers and Methods ------------------------- Wherever you would normally use a select method (eg. `gnus-secondary-select-method', in the group select method, when browsing a foreign server) you can use a virtual server name instead. This could potentially save lots of typing. And it's nice all over.  File: gnus, Node: Unavailable Servers, Prev: Servers and Methods, Up: The Server Buffer 6.1.6 Unavailable Servers ------------------------- If a server seems to be unreachable, Gnus will mark that server as `denied'. That means that any subsequent attempt to make contact with that server will just be ignored. "It can't be opened," Gnus will tell you, without making the least effort to see whether that is actually the case or not. That might seem quite naughty, but it does make sense most of the time. Let's say you have 10 groups subscribed to the server `nepholococcygia.com'. This server is located somewhere quite far away from you, the machine is quite, so it takes 1 minute just to find out that it refuses connection from you today. If Gnus were to attempt to do that 10 times, you'd be quite annoyed, so Gnus won't attempt to do that. Once it has gotten a single "connection refused", it will regard that server as "down". So, what happens if the machine was only feeling unwell temporarily? How do you test to see whether the machine has come up again? You jump to the server buffer (*note The Server Buffer::) and poke it with the following commands: `O' Try to establish connection to the server on the current line (`gnus-server-open-server'). `C' Close the connection (if any) to the server (`gnus-server-close-server'). `D' Mark the current server as unreachable (`gnus-server-deny-server'). `R' Remove all marks to whether Gnus was denied connection from all servers (`gnus-server-remove-denials').  File: gnus, Node: Getting News, Next: Getting Mail, Prev: The Server Buffer, Up: Select Methods 6.2 Getting News ================ A newsreader is normally used for reading news. Gnus currently provides only two methods of getting news - it can read from an NNTP server, or it can read from a local spool. * Menu: * NNTP:: Reading news from an NNTP server. * News Spool:: Reading news from the local spool.  File: gnus, Node: NNTP, Next: News Spool, Up: Getting News 6.2.1 NNTP ---------- Subscribing to a foreign group from an NNTP server is rather easy. You just specify `nntp' as method and the address of the NNTP server as the, uhm, address. If the NNTP server is located at a non-standard port, setting the third element of the select method to this port number should allow you to connect to the right port. You'll have to edit the group info for that (*note Foreign Groups::). The name of the foreign group can be the same as a native group. In fact, you can subscribe to the same group from as many different servers you feel like. There will be no name collisions. The following variables can be used to create a virtual `nntp' server: `nntp-server-opened-hook' `nntp-server-opened-hook' is run after a connection has been made. It can be used to send commands to the NNTP server after it has been contacted. By default is sends the command `MODE READER' to the server with the `nntp-send-mode-reader' function. Another popular function is `nntp-send-authinfo', which will prompt you for an NNTP password and stuff. `nntp-server-action-alist' This is an list of regexps to match on server types and actions to be taken when matches are made. For instance, if you want Gnus to beep every time you connect to innd, you could say something like: (setq nntp-server-action-alist '(("innd" (ding)))) You probably don't want to do that, though. The default value is '(("nntpd 1\\.5\\.11t" (remove-hook 'nntp-server-opened-hook nntp-send-mode-reader))) This ensures that Gnus doesn't send the `MODE READER' command to nntpd 1.5.11t, since that command chokes that server, I've been told. `nntp-maximum-request' If the NNTP server doesn't support NOV headers, this backend will collect headers by sending a series of `head' commands. To speed things up, the backend sends lots of these commands without waiting for reply, and then reads all the replies. This is controlled by the `nntp-maximum-request' variable, and is 400 by default. If your network is buggy, you should set this to 1. `nntp-connection-timeout' If you have lots of foreign `nntp' groups that you connect to regularly, you're sure to have problems with NNTP servers not responding properly, or being too loaded to reply within reasonable time. This is can lead to awkward problems, which can be helped somewhat by setting `nntp-connection-timeout'. This is an integer that says how many seconds the `nntp' backend should wait for a connection before giving up. If it is `nil', which is the default, no timeouts are done. `nntp-command-timeout' If you're running Gnus on a machine that has a dynamically assigned address, Gnus may become confused. If the address of your machine changes after connecting to the NNTP server, Gnus will simply sit waiting forever for replies from the server. To help with this unfortunate problem, you can set this command to a number. Gnus will then, if it sits waiting longer than that number of seconds for a reply from the server, shut down the connection, start a new one, and resend the command. This should hopefully be transparent to the user. A likely number is 30 seconds. `nntp-retry-on-break' If this variable is non-`nil', you can also `C-g' if Gnus hangs. This will have much the same effect as the command timeout described above. `nntp-server-hook' This hook is run as the last step when connecting to an NNTP server. `nntp-open-server-function' This function is used to connect to the remote system. Two pre-made functions are `nntp-open-network-stream', which is the default, and simply connects to some port or other on the remote system. The other is `nntp-open-rlogin', which does an rlogin on the remote system, and then does a telnet to the NNTP server available there. `nntp-rlogin-parameters' If you use `nntp-open-rlogin' as the `nntp-open-server-function', this list will be used as the parameter list given to `rsh'. `nntp-end-of-line' String to use as end-of-line markers when talking to the NNTP server. This is `\r\n' by default, but should be `\n' when using `rlogin' to talk to the server. `nntp-rlogin-user-name' User name on the remote system when using the `rlogin' connect function. `nntp-address' The address of the remote system running the NNTP server. `nntp-port-number' Port number to connect to when using the `nntp-open-network-stream' connect function. `nntp-buggy-select' Set this to non-`nil' if your select routine is buggy. `nntp-nov-is-evil' If the NNTP server does not support NOV, you could set this variable to `t', but `nntp' usually checks whether NOV can be used automatically. `nntp-xover-commands' List of strings that are used as commands to fetch NOV lines from a server. The default value of this variable is `("XOVER" "XOVERVIEW")'. `nntp-nov-gap' `nntp' normally sends just one big request for NOV lines to the server. The server responds with one huge list of lines. However, if you have read articles 2-5000 in the group, and only want to read article 1 and 5001, that means that `nntp' will fetch 4999 NOV lines that you do not want, and will not use. This variable says how big a gap between two consecutive articles is allowed to be before the `XOVER' request is split into several request. Note that if your network is fast, setting this variable to a really small number means that fetching will probably be slower. If this variable is `nil', `nntp' will never split requests. `nntp-prepare-server-hook' A hook run before attempting to connect to an NNTP server. `nntp-async-number' How many articles should be pre-fetched when in asynchronous mode. 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. `nntp-warn-about-losing-connection' If this variable is non-`nil', some noise will be made when a server closes connection.  File: gnus, Node: News Spool, Prev: NNTP, Up: Getting News 6.2.2 News Spool ---------------- Subscribing to a foreign group from the local spool is extremely easy, and might be useful, for instance, to speed up reading groups like `alt.binaries.pictures.furniture'. Anyways, you just specify `nnspool' as the method and `' (or anything else) as the address. If you have access to a local spool, you should probably use that as the native select method (*note Finding the News::). It is normally faster than using an `nntp' select method, but might not be. It depends. You just have to try to find out what's best at your site. `nnspool-inews-program' Program used to post an article. `nnspool-inews-switches' Parameters given to the inews program when posting an article. `nnspool-spool-directory' Where `nnspool' looks for the articles. This is normally `/usr/spool/news/'. `nnspool-nov-directory' Where `nnspool' will look for NOV files. This is normally `/usr/spool/news/over.view/'. `nnspool-lib-dir' Where the news lib dir is (`/usr/lib/news/' by default). `nnspool-active-file' The path of the active file. `nnspool-newsgroups-file' The path of the group descriptions file. `nnspool-history-file' The path of the news history file. `nnspool-active-times-file' The path of the active date file. `nnspool-nov-is-evil' If non-`nil', `nnspool' won't try to use any NOV files that it finds. `nnspool-sift-nov-with-sed' If non-`nil', which is the default, use `sed' to get the relevant portion from the overview file. If nil, `nnspool' will load the entire file into a buffer and process it there.  File: gnus, Node: Getting Mail, Next: Other Sources, Prev: Getting News, Up: Select Methods 6.3 Getting Mail ================ Reading mail with a newsreader--isn't that just plain WeIrD? But of course. * Menu: * Getting Started Reading Mail:: A simple cookbook example. * Splitting Mail:: How to create mail groups. * Mail Backend Variables:: Variables for customizing mail handling. * Fancy Mail Splitting:: Gnus can do hairy splitting of incoming mail. * Mail and Procmail:: Reading mail groups that procmail create. * Incorporating Old Mail:: What about the old mail you have? * Expiring Mail:: Getting rid of unwanted mail. * Duplicates:: Dealing with duplicated mail. * Not Reading Mail:: Using mail backends for reading other files. * Choosing a Mail Backend:: Gnus can read a variety of mail formats.  File: gnus, Node: Getting Started Reading Mail, Next: Splitting Mail, Up: Getting Mail 6.3.1 Getting Started Reading Mail ---------------------------------- It's quite easy to use Gnus to read your new mail. You just plonk the mail backend of your choice into `gnus-secondary-select-methods', and things will happen automatically. For instance, if you want to use `nnml' (which is a one file per mail backend), you could put the following in your `.gnus' file: (setq gnus-secondary-select-methods '((nnml "private"))) Now, the next time you start Gnus, this backend will be queried for new articles, and it will move all the messages in your spool file to its directory, which is `~/Mail/' by default. The new group that will be created (`mail.misc') will be subscribed, and you can read it like any other group. You will probably want to split the mail into several groups, though: (setq nnmail-split-methods '(("junk" "^From:.*Lars Ingebrigtsen") ("crazy" "^Subject:.*die\\|^Organization:.*flabby") ("other" ""))) This will result in three new mail groups being created: `nnml:junk', `nnml:crazy', and `nnml:other'. All the mail that doesn't fit into the first two groups will be placed in the latter group. This should be sufficient for reading mail with Gnus. You might want to give the other sections in this part of the manual a perusal, though, especially *note Choosing a Mail Backend:: and *note Expiring Mail::.  File: gnus, Node: Splitting Mail, Next: Mail Backend Variables, Prev: Getting Started Reading Mail, Up: Getting Mail 6.3.2 Splitting Mail -------------------- The `nnmail-split-methods' variable says how the incoming mail is to be split into groups. (setq nnmail-split-methods '(("mail.junk" "^From:.*Lars Ingebrigtsen") ("mail.crazy" "^Subject:.*die\\|^Organization:.*flabby") ("mail.other" ""))) This variable is a list of lists, where the first element of each of these lists is the name of the mail group (they do not have to be called something beginning with `mail', by the way), and the second element is a regular expression used on the header of each mail to determine if it belongs in this mail group. The second element can also be a function. In that case, it will be called narrowed to the headers with the first element of the rule as the argument. It should return a non-`nil' value if it thinks that the mail belongs in that group. The last of these groups should always be a general one, and the regular expression should _always_ be `' so that it matches any mails that haven't been matched by any of the other regexps. If you like to tinker with this yourself, you can set this variable to a function of your choice. This function will be called without any arguments in a buffer narrowed to the headers of an incoming mail message. The function should return a list of groups names that it thinks should carry this mail message. Note that the mail backends are free to maul the poor, innocent incoming headers all they want to. They all add `Lines' headers; some add `X-Gnus-Group' headers; most rename the Unix mbox `From' line to something else. The mail backends all support cross-posting. If several regexps match, the mail will be "cross-posted" to all those groups. `nnmail-crosspost' says whether to use this mechanism or not. Note that no articles are crossposted to the general (`') group. `nnmh' and `nnml' makes crossposts by creating hard links to the crossposted articles. However, not all files systems support hard links. If that's the case for you, set `nnmail-crosspost-link-function' to `copy-file'. (This variable is `add-name-to-file' by default.) Gnus gives you all the opportunity you could possibly want for shooting yourself in the foot. Let's say you create a group that will contain all the mail you get from your boss. And then you accidentally unsubscribe from the group. Gnus will still put all the mail from your boss in the unsubscribed group, and so, when your boss mails you "Have that report ready by Monday or you're fired!", you'll never see it and, come Tuesday, you'll still believe that you're gainfully employed while you really should be out collecting empty bottles to save up for next month's rent money.  File: gnus, Node: Mail Backend Variables, Next: Fancy Mail Splitting, Prev: Splitting Mail, Up: Getting Mail 6.3.3 Mail Backend Variables ---------------------------- These variables are (for the most part) pertinent to all the various mail backends. `nnmail-read-incoming-hook' The mail backends all call this hook after reading new mail. You can use this hook to notify any mail watch programs, if you want to. `nnmail-spool-file' The backends will look for new mail in this file. If this variable is `nil', the mail backends will never attempt to fetch mail by themselves. If you are using a POP mail server and your name is `larsi', you should set this variable to `po:larsi'. If your name is not `larsi', you should probably modify that slightly, but you may have guessed that already, you smart & handsome devil! You can also set this variable to `pop', and Gnus will try to figure out the POP mail string by itself. In any case, Gnus will call `movemail' which will contact the POP server named in the `MAILHOST' environment variable. If the POP server needs a password, you can either set `nnmail-pop-password-required' to `t' and be prompted for the password, or set `nnmail-pop-password' to the password itself. When you use a mail backend, Gnus will slurp all your mail from your inbox and plonk it down in your home directory. Gnus doesn't move any mail if you're not using a mail backend--you have to do a lot of magic invocations first. At the time when you have finished drawing the pentagram, lightened the candles, and sacrificed the goat, you really shouldn't be too surprised when Gnus moves your mail. `nnmail-use-procmail' If non-`nil', the mail backends will look in `nnmail-procmail-directory' for incoming mail. All the files in that directory that have names ending in `nnmail-procmail-suffix' will be considered incoming mailboxes, and will be searched for new mail. `nnmail-crash-box' When the mail backends read a spool file, it is first moved to this file, which is `~/.gnus-crash-box' by default. If this file already exists, it will always be read (and incorporated) before any other spool files. `nnmail-prepare-incoming-hook' This is run in a buffer that holds all the new incoming mail, and can be used for, well, anything, really. `nnmail-pre-get-new-mail-hook' `nnmail-post-get-new-mail-hook' These are two useful hooks executed when treating new incoming mail--`nnmail-pre-get-new-mail-hook' (is called just before starting to handle the new mail) and `nnmail-post-get-new-mail-hook' (is called when the mail handling is done). Here's and example of using these two hooks to change the default file modes the new mail files get: (add-hook 'gnus-pre-get-new-mail-hook (lambda () (set-default-file-modes 511))) (add-hook 'gnus-post-get-new-mail-hook (lambda () (set-default-file-modes 551))) `nnmail-tmp-directory' This variable says where to move the incoming mail to while processing it. This is usually done in the same directory that the mail backend inhabits (i.e., `~/Mail/'), but if this variable is non-`nil', it will be used instead. `nnmail-movemail-program' This program is executed to move mail from the user's inbox to her home directory. The default is `movemail'. `nnmail-delete-incoming' If non-`nil', the mail backends will delete the temporary incoming file after splitting mail into the proper groups. This is `nil' by default for reasons of security. `nnmail-use-long-file-names' If non-`nil', the mail backends will use long file and directory names. Groups like `mail.misc' will end up in directories like `mail.misc/'. If it is `nil', the same group will end up in `mail/misc/'. `nnmail-delete-file-function' Function called to delete files. It is `delete-file' by default.  File: gnus, Node: Fancy Mail Splitting, Next: Mail and Procmail, Prev: Mail Backend Variables, Up: Getting Mail 6.3.4 Fancy Mail Splitting -------------------------- If the rather simple, standard method for specifying how to split mail doesn't allow you to do what you want, you can set `nnmail-split-methods' to `nnmail-split-fancy'. Then you can play with the `nnmail-split-fancy' variable. Let's look at an example value of this variable first: ;; Messages from the mailer daemon are not crossposted to any of ;; the ordinary groups. Warnings are put in a separate group ;; from real errors. (| ("from" mail (| ("subject" "warn.*" "mail.warning") "mail.misc")) ;; Non-error messages are crossposted to all relevant ;; groups, but we don't crosspost between the group for the ;; (ding) list and the group for other (ding) related mail. (& (| (any "ding@ifi\\.uio\\.no" "ding.list") ("subject" "ding" "ding.misc")) ;; Other mailing lists... (any "procmail@informatik\\.rwth-aachen\\.de" "procmail.list") (any "SmartList@informatik\\.rwth-aachen\\.de" "SmartList.list") ;; People... (any "larsi@ifi\\.uio\\.no" "people.Lars Magne Ingebrigtsen")) ;; Unmatched mail goes to the catch all group. "misc.misc"))") This variable has the format of a "split". A split is a (possibly) recursive structure where each split may contain other splits. Here are the four possible split syntaxes: "GROUP" If the split is a string, that will be taken as a group name. "(FIELD VALUE SPLIT)" If the split is a list, and the first element is a string, then that means that if header FIELD (a regexp) contains VALUE (also a regexp), then store the message as specified by SPLIT. "(| SPLIT...)" If the split is a list, and the first element is `|' (vertical bar), then process each SPLIT until one of them matches. A SPLIT is said to match if it will cause the mail message to be stored in one or more groups. "(& SPLIT...)" If the split is a list, and the first element is `&', then process all SPLITs in the list. In these splits, FIELD must match a complete field name. VALUE must match a complete word according to the fundamental mode syntax table. You can use `.*' in the regexps to match partial field names or words. FIELD and VALUE can also be lisp symbols, in that case they are expanded as specified by the variable `nnmail-split-abbrev-alist'. This is an alist of cons cells, where the car of the cells contains the key, and the cdr contains a string. `nnmail-split-fancy-syntax-table' is the syntax table in effect when all this splitting is performed.  File: gnus, Node: Mail and Procmail, Next: Incorporating Old Mail, Prev: Fancy Mail Splitting, Up: Getting Mail 6.3.5 Mail and Procmail ----------------------- Many people use `procmail' (or some other mail filter program or external delivery agent--`slocal', `elm', etc) to split incoming mail into groups. If you do that, you should set `nnmail-spool-file' to `procmail' to ensure that the mail backends never ever try to fetch mail by themselves. This also means that you probably don't want to set `nnmail-split-methods' either, which has some, perhaps, unexpected side effects. When a mail backend is queried for what groups it carries, it replies with the contents of that variable, along with any groups it has figured out that it carries by other means. None of the backends (except `nnmh') actually go out to the disk and check what groups actually exist. (It's not trivial to distinguish between what the user thinks is a basis for a newsgroup and what is just a plain old file or directory.) This means that you have to tell Gnus (and the backends) what groups exist by hand. Let's take the `nnmh' backend as an example. The folders are located in `nnmh-directory', say, `~/Mail/'. There are three folders, `foo', `bar' and `mail.baz'. Go to the group buffer and type `G m'. When prompted, answer `foo' for the name and `nnmh' for the method. Repeat twice for the two other groups, `bar' and `mail.baz'. Be sure to include all your mail groups. That's it. You are now set to read your mail. An active file for this method will be created automatically. If you use `nnfolder' or any other backend that store more than a single article in each file, you should never have procmail add mails to the file that Gnus sees. Instead, procmail should put all incoming mail in `nnmail-procmail-directory'. To arrive at the file name to put the incoming mail in, append `nnmail-procmail-suffix' to the group name. The mail backends will read the mail from these files. When Gnus reads a file called `mail.misc.spool', this mail will be put in the `mail.misc', as one would expect. However, if you want Gnus to split the mail the normal way, you could set `nnmail-resplit-incoming' to `t'. If you use `procmail' to split things directory into an `nnmh' directory (which you shouldn't do), you should set `nnmail-keep-last-article' to non-`nil' to prevent Gnus from ever expiring the final article in a mail newsgroup. This is quite, quite important.  File: gnus, Node: Incorporating Old Mail, Next: Expiring Mail, Prev: Mail and Procmail, Up: Getting Mail 6.3.6 Incorporating Old Mail ---------------------------- Most people have lots of old mail stored in various file formats. If you have set up Gnus to read mail using one of the spiffy Gnus mail backends, you'll probably wish to have that old mail incorporated into your mail groups. Doing so can be quite easy. To take an example: You're reading mail using `nnml' (*note Mail Spool::), and have set `nnmail-split-methods' to a satisfactory value (*note Splitting Mail::). You have an old Unix mbox file filled with important, but old, mail. You want to move it into your `nnml' groups. Here's how: 1. Go to the group buffer. 2. Type `G f' and give the path of the mbox file when prompted to create an `nndoc' group from the mbox file (*note Foreign Groups::). 3. Type `SPACE' to enter the newly created group. 4. Type `M P b' to process-mark all articles in this group (*note Setting Process Marks::). 5. Type `B r' to respool all the process-marked articles, and answer `nnml' when prompted (*note Mail Group Commands::). All the mail messages in the mbox file will now also be spread out over all your `nnml' groups. Try entering them and check whether things have gone without a glitch. If things look ok, you may consider deleting the mbox file, but I wouldn't do that unless I was absolutely sure that all the mail has ended up where it should be. Respooling is also a handy thing to do if you're switching from one mail backend to another. Just respool all the mail in the old mail groups using the new mail backend.  File: gnus, Node: Expiring Mail, Next: Duplicates, Prev: Incorporating Old Mail, Up: Getting Mail 6.3.7 Expiring Mail ------------------- Traditional mail readers have a tendency to remove mail articles when you mark them as read, in some way. Gnus takes a fundamentally different approach to mail reading. Gnus basically considers mail just to be news that has been received in a rather peculiar manner. It does not think that it has the power to actually change the mail, or delete any mail messages. If you enter a mail group, and mark articles as "read", or kill them in some other fashion, the mail articles will still exist on the system. I repeat: Gnus will not delete your old, read mail. Unless you ask it to, of course. To make Gnus get rid of your unwanted mail, you have to mark the articles as "expirable". This does not mean that the articles will disappear right away, however. In general, a mail article will be deleted from your system if, 1) it is marked as expirable, AND 2) it is more than one week old. If you do not mark an article as expirable, it will remain on your system until hell freezes over. This bears repeating one more time, with some spurious capitalizations: IF you do NOT mark articles as EXPIRABLE, Gnus will NEVER delete those ARTICLES. You do not have to mark articles as expirable by hand. Groups that match the regular expression `gnus-auto-expirable-newsgroups' will have all articles that you read marked as expirable automatically. All articles that are marked as expirable have an `E' in the first column in the summary buffer. Let's say you subscribe to a couple of mailing lists, and you want the articles you have read to disappear after a while: (setq gnus-auto-expirable-newsgroups "mail.nonsense-list\\|mail.nice-list") Another way to have auto-expiry happen is to have the element `auto-expire' in the group parameters of the group. The `nnmail-expiry-wait' variable supplies the default time an expirable article has to live. The default is seven days. Gnus also supplies a function that lets you fine-tune how long articles are to live, based on what group they are in. Let's say you want to have one month expiry period in the `mail.private' group, a one day expiry period in the `mail.junk' group, and a six day expiry period everywhere else: (setq nnmail-expiry-wait-function (lambda (group) (cond ((string= group "mail.private") 31) ((string= group "mail.junk") 1) ((string= group "important") 'never) (t 6)))) The group names that this function is fed are "unadorned" group names--no `nnml:' prefixes and the like. The `nnmail-expiry-wait' variable and `nnmail-expiry-wait-function' function can be either a number (not necessarily an integer) or the symbols `immediate' or `never'. You can also use the `expiry-wait' group parameter to selectively change the expiry period (*note Group Parameters::). If `nnmail-keep-last-article' is non-`nil', Gnus will never expire the final article in a mail newsgroup. This is to make life easier for procmail users. By the way, that line up there about Gnus never expiring non-expirable articles is a lie. If you put `total-expire' in the group parameters, articles will not be marked as expirable, but all read articles will be put through the expiry process. Use with extreme caution. Even more dangerous is the `gnus-total-expirable-newsgroups' variable. All groups that match this regexp will have all read articles put through the expiry process, which means that _all_ old mail articles in the groups in question will be deleted after a while. Use with extreme caution, and don't come crying to me when you discover that the regexp you used matched the wrong group and all your important mail has disappeared. Be a _man_! Or a _woman_! Whatever you feel more comfortable with! So there!  File: gnus, Node: Duplicates, Next: Not Reading Mail, Prev: Expiring Mail, Up: Getting Mail 6.3.8 Duplicates ---------------- If you are a member of a couple of mailing list, you will sometime receive two copies of the same mail. This can be quite annoying, so `nnmail' checks for and treats any duplicates it might find. To do this, it keeps a cache of old `Message-ID's - `nnmail-message-id-cache-file', which is `~/.nnmail-cache' by default. The approximate maximum number of `Message-ID's stored there is controlled by the `nnmail-message-id-cache-length' variable, which is 1000 by default. (So 1000 `Message-ID's will be stored.) If all this sounds scary to you, you can set `nnmail-treat-duplicates' to `warn' (which is what it is by default), and `nnmail' won't delete duplicate mails. Instead it will generate a brand new `Message-ID' for the mail and insert a warning into the head of the mail saying that it thinks that this is a duplicate of a different message. This variable can also be a function. If that's the case, the function will be called from a buffer narrowed to the message in question with the `Message-ID' as a parameter. The function must return either `nil', `warn', or `delete'. You can turn this feature off completely by setting the variable to `nil'. If you want all the duplicate mails to be put into a special "duplicates" group, you could do that using the normal mail split methods: (setq nnmail-split-fancy '(| ;; Messages duplicates go to a separate group. ("gnus-warning" "duplication of message" "duplicate") ;; Message from daemons, postmaster, and the like to another. (any mail "mail.misc") ;; Other rules. [ ... ] )) Or something like: (setq nnmail-split-methods '(("duplicates" "^Gnus-Warning:") ;; Other rules. [...])) Here's a neat feature: If you know that the recipient reads her mail with Gnus, and that she has `nnmail-treat-duplicates' set to `delete', you can send her as many insults as you like, just by using a `Message-ID' of a mail that you know that she's already received. Think of all the fun! She'll never see any of it! Whee!  File: gnus, Node: Not Reading Mail, Next: Choosing a Mail Backend, Prev: Duplicates, Up: Getting Mail 6.3.9 Not Reading Mail ---------------------- If you start using any of the mail backends, they have the annoying habit of assuming that you want to read mail with them. This might not be unreasonable, but it might not be what you want. If you set `nnmail-spool-file' to `nil', none of the backends will ever attempt to read incoming mail, which should help. This might be too much, if, for instance, you are reading mail quite happily with `nnml' and just want to peek at some old RMAIL file you have stashed away with `nnbabyl'. All backends have variables called backend-`get-new-mail'. If you want to disable the `nnbabyl' mail reading, you edit the virtual server for the group to have a setting where `nnbabyl-get-new-mail' to `nil'. All the mail backends will call `nn'*`-prepare-save-mail-hook' narrowed to the article to be saved before saving it when reading incoming mail.  File: gnus, Node: Choosing a Mail Backend, Prev: Not Reading Mail, Up: Getting Mail 6.3.10 Choosing a Mail Backend ------------------------------ Gnus will read the mail spool when you activate a mail group. The mail file is first copied to your home directory. What happens after that depends on what format you want to store your mail in. * Menu: * Unix Mail Box:: Using the (quite) standard Un*x mbox. * Rmail Babyl:: Emacs programs use the rmail babyl format. * Mail Spool:: Store your mail in a private spool? * MH Spool:: An mhspool-like backend. * Mail Folders:: Having one file for each group.  File: gnus, Node: Unix Mail Box, Next: Rmail Babyl, Up: Choosing a Mail Backend 6.3.10.1 Unix Mail Box ...................... The "nnmbox" backend will use the standard Un*x mbox file to store mail. `nnmbox' will add extra headers to each mail article to say which group it belongs in. Virtual server settings: `nnmbox-mbox-file' The name of the mail box in the user's home directory. `nnmbox-active-file' The name of the active file for the mail box. `nnmbox-get-new-mail' If non-`nil', `nnmbox' will read incoming mail and split it into groups.  File: gnus, Node: Rmail Babyl, Next: Mail Spool, Prev: Unix Mail Box, Up: Choosing a Mail Backend 6.3.10.2 Rmail Babyl .................... The "nnbabyl" backend will use a babyl mail box (aka. "rmail mbox") to store mail. `nnbabyl' will add extra headers to each mail article to say which group it belongs in. Virtual server settings: `nnbabyl-mbox-file' The name of the rmail mbox file. `nnbabyl-active-file' The name of the active file for the rmail box. `nnbabyl-get-new-mail' If non-`nil', `nnbabyl' will read incoming mail.  File: gnus, Node: Mail Spool, Next: MH Spool, Prev: Rmail Babyl, Up: Choosing a Mail Backend 6.3.10.3 Mail Spool ................... The "nnml" spool mail format isn't compatible with any other known format. It should be used with some caution. If you use this backend, Gnus will split all incoming mail into files; one file for each mail, and put the articles into the correct directories under the directory specified by the `nnml-directory' variable. The default value is `~/Mail/'. You do not have to create any directories beforehand; Gnus will take care of all that. If you have a strict limit as to how many files you are allowed to store in your account, you should not use this backend. As each mail gets its own file, you might very well occupy thousands of inodes within a few weeks. If this is no problem for you, and it isn't a problem for you having your friendly systems administrator walking around, madly, shouting "Who is eating all my inodes?! Who? Who!?!", then you should know that this is probably the fastest format to use. You do not have to trudge through a big mbox file just to read your new mail. `nnml' is probably the slowest backend when it comes to article splitting. It has to create lots of files, and it also generates NOV databases for the incoming mails. This makes is the fastest backend when it comes to reading mail. Virtual server settings: `nnml-directory' All `nnml' directories will be placed under this directory. `nnml-active-file' The active file for the `nnml' server. `nnml-newsgroups-file' The `nnml' group descriptions file. *Note Newsgroups File Format::. `nnml-get-new-mail' If non-`nil', `nnml' will read incoming mail. `nnml-nov-is-evil' If non-`nil', this backend will ignore any NOV files. `nnml-nov-file-name' The name of the NOV files. The default is `.overview'. `nnml-prepare-save-mail-hook' Hook run narrowed to an article before saving. If your `nnml' groups and NOV files get totally out of whack, you can do a complete update by typing `M-x nnml-generate-nov-databases'. This command will trawl through the entire `nnml' hierarchy, looking at each and every article, so it might take a while to complete.  File: gnus, Node: MH Spool, Next: Mail Folders, Prev: Mail Spool, Up: Choosing a Mail Backend 6.3.10.4 MH Spool ................. `nnmh' is just like `nnml', except that is doesn't generate NOV databases and it doesn't keep an active file. This makes `nnmh' a _much_ slower backend than `nnml', but it also makes it easier to write procmail scripts for. Virtual server settings: `nnmh-directory' All `nnmh' directories will be located under this directory. `nnmh-get-new-mail' If non-`nil', `nnmh' will read incoming mail. `nnmh-be-safe' If non-`nil', `nnmh' will go to ridiculous lengths to make sure that the articles in the folder are actually what Gnus thinks they are. It will check date stamps and stat everything in sight, so setting this to `t' will mean a serious slow-down. If you never use anything but Gnus to read the `nnmh' articles, you do not have to set this variable to `t'.  File: gnus, Node: Mail Folders, Prev: MH Spool, Up: Choosing a Mail Backend 6.3.10.5 Mail Folders ..................... `nnfolder' is a backend for storing each mail group in a separate file. Each file is in the standard Un*x mbox format. `nnfolder' will add extra headers to keep track of article numbers and arrival dates. Virtual server settings: `nnfolder-directory' All the `nnfolder' mail boxes will be stored under this directory. `nnfolder-active-file' The name of the active file. `nnfolder-newsgroups-file' The name of the group descriptions file. *Note Newsgroups File Format::. `nnfolder-get-new-mail' If non-`nil', `nnfolder' will read incoming mail. If you have lots of `nnfolder'-like files you'd like to read with `nnfolder', you can use the `M-x nnfolder-generate-active-file' command to make `nnfolder' aware of all likely files in `nnfolder-directory'.  File: gnus, Node: Other Sources, Next: Combined Groups, Prev: Getting Mail, Up: Select Methods 6.4 Other Sources ================= Gnus can do more than just read news or mail. The methods described below allow Gnus to view directories and files as if they were newsgroups. * Menu: * Directory Groups:: You can read a directory as if it was a newsgroup. * Anything Groups:: Dired? Who needs dired? * Document Groups:: Single files can be the basis of a group. * SOUP:: Reading SOUP packets ``offline''.  File: gnus, Node: Directory Groups, Next: Anything Groups, Up: Other Sources 6.4.1 Directory Groups ---------------------- If you have a directory that has lots of articles in separate files in it, you might treat it as a newsgroup. The files have to have numerical names, of course. This might be an opportune moment to mention `ange-ftp', that most wonderful of all wonderful Emacs packages. When I wrote `nndir', I didn't think much about it--a backend to read directories. Big deal. `ange-ftp' changes that picture dramatically. For instance, if you enter `"/ftp.hpc.uh.edu:/pub/emacs/ding-list/"' as the the directory name, ange-ftp will actually allow you to read this directory over at `sina' as a newsgroup. Distributed news ahoy! `nndir' will use NOV files if they are present. `nndir' is a "read-only" backend--you can't delete or expire articles with this method. You can use `nnmh' or `nnml' for whatever you use `nndir' for, so you could switch to any of those methods if you feel the need to have a non-read-only `nndir'.  File: gnus, Node: Anything Groups, Next: Document Groups, Prev: Directory Groups, Up: Other Sources 6.4.2 Anything Groups --------------------- From the `nndir' backend (which reads a single spool-like directory), it's just a hop and a skip to `nneething', which pretends that any arbitrary directory is a newsgroup. Strange, but true. When `nneething' is presented with a directory, it will scan this directory and assign article numbers to each file. When you enter such a group, `nneething' must create "headers" that Gnus can use. After all, Gnus is a newsreader, in case you're forgetting. `nneething' does this in a two-step process. First, it snoops each file in question. If the file looks like an article (i.e., the first few lines look like headers), it will use this as the head. If this is just some arbitrary file without a head (eg. a C source file), `nneething' will cobble up a header out of thin air. It will use file ownership, name and date and do whatever it can with these elements. All this should happen automatically for you, and you will be presented with something that looks very much like a newsgroup. Totally like a newsgroup, to be precise. If you select an article, it will be displayed in the article buffer, just as usual. If you select a line that represents a directory, Gnus will pop you into a new summary buffer for this `nneething' group. And so on. You can traverse the entire disk this way, if you feel like, but remember that Gnus is not dired, really, and does not intend to be, either. There are two overall modes to this action--ephemeral or solid. When doing the ephemeral thing (i.e., `G D' from the group buffer), Gnus will not store information on what files you have read, and what files are new, and so on. If you create a solid `nneething' group the normal way with `G m', Gnus will store a mapping table between article numbers and file names, and you can treat this group like any other groups. When you activate a solid `nneething' group, you will be told how many unread articles it contains, etc., etc. Some variables: `nneething-map-file-directory' All the mapping files for solid `nneething' groups will be stored in this directory, which defaults to `~/.nneething/'. `nneething-exclude-files' All files that match this regexp will be ignored. Nice to use to exclude auto-save files and the like, which is what it does by default. `nneething-map-file' Name of the map files.  File: gnus, Node: Document Groups, Next: SOUP, Prev: Anything Groups, Up: Other Sources 6.4.3 Document Groups --------------------- `nndoc' is a cute little thing that will let you read a single file as a newsgroup. Several files types are supported: `babyl' The babyl (rmail) mail box. `mbox' The standard Unix mbox file. `mmdf' The MMDF mail box format. `news' Several news articles appended into a file. `rnews' The rnews batch transport format. `forward' Forwarded articles. `mime-digest' MIME (RFC 1341) digest format. `standard-digest' The standard (RFC 1153) digest format. `slack-digest' Non-standard digest format--matches most things, but does it badly. You can also use the special "file type" `guess', which means that `nndoc' will try to guess what file type it is looking at. `digest' means that `nndoc' should guess what digest type the file is. `nndoc' will not try to change the file or insert any extra headers into it--it will simply, like, let you use the file as the basis for a group. And that's it. If you have some old archived articles that you want to insert into your new & spiffy Gnus mail backend, `nndoc' can probably help you with that. Say you have an old `RMAIL' file with mail that you now want to split into your new `nnml' groups. You look at that file using `nndoc', set the process mark on all the articles in the buffer (`M P b', for instance), and then re-spool (`B r') using `nnml'. If all goes well, all the mail in the `RMAIL' file is now also stored in lots of `nnml' directories, and you can delete that pesky `RMAIL' file. If you have the guts! Virtual server variables: `nndoc-article-type' This should be one of `mbox', `babyl', `digest', `mmdf', `forward', `news', `rnews', `mime-digest', `clari-briefs', or `guess'. `nndoc-post-type' This variable says whether Gnus is to consider the group a news group or a mail group. There are two legal values: `mail' (the default) and `news'.  File: gnus, Node: SOUP, Prev: Document Groups, Up: Other Sources 6.4.4 SOUP ---------- In the PC world people often talk about "offline" newsreaders. These are thingies that are combined reader/news transport monstrosities. With built-in modem programs. Yecchh! Of course, us Unix Weenie types of human beans use things like `uucp' and, like, `nntpd' and set up proper news and mail transport things like Ghod intended. And then we just use normal newsreaders. However, it can sometimes be convenient to do something a that's a bit easier on the brain if you have a very slow modem, and you're not really that interested in doing things properly. A file format called SOUP has been developed for transporting news and mail from servers to home machines and back again. It can be a bit fiddly. 1. You log in on the server and create a SOUP packet. You can either use a dedicated SOUP thingie, or you can use Gnus to create the packet with the `O s' command. 2. You transfer the packet home. Rail, boat, car or modem will do fine. 3. You put the packet in your home directory. 4. You fire up Gnus using the `nnsoup' backend as the native server. 5. You read articles and mail and answer and followup to the things you want. 6. You do the `G s r' command to pack these replies into a SOUP packet. 7. You transfer this packet to the server. 8. You use Gnus to mail this packet out with the `G s s' command. 9. You then repeat until you die. So you basically have a bipartite system--you use `nnsoup' for reading and Gnus for packing/sending these SOUP packets. * Menu: * SOUP Commands:: Commands for creating and sending SOUP packets * SOUP Groups:: A backend for reading SOUP packets. * SOUP Replies:: How to enable `nnsoup' to take over mail and news.  File: gnus, Node: SOUP Commands, Next: SOUP Groups, Up: SOUP 6.4.4.1 SOUP Commands ..................... `G s b' Pack all unread articles in the current group (`gnus-group-brew-soup'). This command understands the process/prefix convention. `G s w' Save all data files (`gnus-soup-save-areas'). `G s s' Send all replies from the replies packet (`gnus-soup-send-replies'). `G s p' Pack all files into a SOUP packet (`gnus-soup-pack-packet'). `G s r' Pack all replies into a replies packet (`nnsoup-pack-replies'). `O s' This summary-mode command adds the current article to a SOUP packet (`gnus-soup-add-article'). It understands the process/prefix convention. There are a few variables to customize where Gnus will put all these thingies: `gnus-soup-directory' Directory where Gnus will save intermediate files while composing SOUP packets. The default is `~/SoupBrew/'. `gnus-soup-replies-directory' This is what Gnus will use as a temporary directory while sending our reply packets. The default is `~/SoupBrew/SoupReplies/'. `gnus-soup-prefix-file' Name of the file where Gnus stores the last used prefix. The default is `gnus-prefix'. `gnus-soup-packer' A format string command for packing a SOUP packet. The default is `tar cf - %s | gzip > $HOME/Soupout%d.tgz'. `gnus-soup-unpacker' Format string command for unpacking a SOUP packet. The default is `gunzip -c %s | tar xvf -'. `gnus-soup-packet-directory' Where Gnus will look for reply packets. The default is `~/'. `gnus-soup-packet-regexp' Regular expression matching SOUP reply packets in `gnus-soup-packet-directory'.  File: gnus, Node: SOUP Groups, Next: SOUP Replies, Prev: SOUP Commands, Up: SOUP 6.4.4.2 SOUP Groups ................... `nnsoup' is the backend for reading SOUP packets. It will read incoming packets, unpack them, and put them in a directory where you can read them at leisure. These are the variables you can use to customize its behavior: `nnsoup-tmp-directory' When `nnsoup' unpacks a SOUP packet, it does it in this directory. (`/tmp/' by default.) `nnsoup-directory' `nnsoup' then moves each message and index file to this directory. The default is `~/SOUP/'. `nnsoup-replies-directory' All replies will stored in this directory before being packed into a reply packet. The default is `~/SOUP/replies/"'. `nnsoup-replies-format-type' The SOUP format of the replies packets. The default is `?n' (rnews), and I don't think you should touch that variable. I probably shouldn't even have documented it. Drats! Too late! `nnsoup-replies-index-type' The index type of the replies packet. The is `?n', which means "none". Don't fiddle with this one either! `nnsoup-active-file' Where `nnsoup' stores lots of information. This is not an "active file" in the `nntp' sense; it's an Emacs Lisp file. If you lose this file or mess it up in any way, you're dead. The default is `~/SOUP/active'. `nnsoup-packer' Format string command for packing a reply SOUP packet. The default is `tar cf - %s | gzip > $HOME/Soupin%d.tgz'. `nnsoup-unpacker' Format string command for unpacking incoming SOUP packets. The default is `gunzip -c %s | tar xvf -'. `nnsoup-packet-directory' Where `nnsoup' will look for incoming packets. The default is `~/'. `nnsoup-packet-regexp' Regular expression matching incoming SOUP packets. The default is `Soupout'.  File: gnus, Node: SOUP Replies, Prev: SOUP Groups, Up: SOUP 6.4.4.3 SOUP Replies .................... Just using `nnsoup' won't mean that your postings and mailings end up in SOUP reply packets automagically. You have to work a bit more for that to happen. The `nnsoup-set-variables' command will set the appropriate variables to ensure that all your followups and replies end up in the SOUP system. In specific, this is what it does: (setq gnus-inews-article-function 'nnsoup-request-post) (setq send-mail-function 'nnsoup-request-mail) And that's it, really. If you only want news to go into the SOUP system you just use the first line. If you only want mail to be SOUPed you use the second.  File: gnus, Node: Combined Groups, Prev: Other Sources, Up: Select Methods 6.5 Combined Groups =================== Gnus allows combining a mixture of all the other group types into bigger groups. * Menu: * Virtual Groups:: Combining articles from many groups. * Kibozed Groups:: Looking through parts of the newsfeed for articles.  File: gnus, Node: Virtual Groups, Next: Kibozed Groups, Up: Combined Groups 6.5.1 Virtual Groups -------------------- An "nnvirtual group" is really nothing more than a collection of other groups. For instance, if you are tired of reading many small group, you can put them all in one big group, and then grow tired of reading one big, unwieldy group. The joys of computing! You specify `nnvirtual' as the method. The address should be a regexp to match component groups. All marks in the virtual group will stick to the articles in the component groups. So if you tick an article in a virtual group, the article will also be ticked in the component group from whence it came. (And vice versa--marks from the component groups will also be shown in the virtual group.) Here's an example `nnvirtual' method that collects all Andrea Dworkin newsgroups into one, big, happy newsgroup: (nnvirtual "^alt\\.fan\\.andrea-dworkin$\\|^rec\\.dworkin.*") The component groups can be native or foreign; everything should work smoothly, but if your computer explodes, it was probably my fault. Collecting the same group from several servers might actually be a good idea if users have set the Distribution header to limit distribution. If you would like to read `soc.motss' both from a server in Japan and a server in Norway, you could use the following as the group regexp: "^nntp+some.server.jp:soc.motss$\\|^nntp+some.server.no:soc.motss$" This should work kinda smoothly--all articles from both groups should end up in this one, and there should be no duplicates. Threading (and the rest) will still work as usual, but there might be problems with the sequence of articles. Sorting on date might be an option here (*note Selecting a Group::. One limitation, however--all groups that are included in a virtual group has to be alive (i.e., subscribed or unsubscribed). Killed or zombie groups can't be component groups for `nnvirtual' groups. If the `nnvirtual-always-rescan' is non-`nil', `nnvirtual' will always scan groups for unread articles when entering a virtual group. If this variable is `nil' (which is the default) and you read articles in a component group after the virtual group has been activated, the read articles from the component group will show up when you enter the virtual group. You'll also see this effect if you have two virtual groups that contain the same component group. If that's the case, you should set this variable to `t'. Or you can just tap `M-g' on the virtual group every time before you enter it--it'll have much the same effect.  File: gnus, Node: Kibozed Groups, Prev: Virtual Groups, Up: Combined Groups 6.5.2 Kibozed Groups -------------------- "Kibozing" is defined by OED as "grepping through (parts of) the news feed". `nnkiboze' is a backend that will do this for you. Oh joy! Now you can grind any NNTP server down to a halt with useless requests! Oh happiness! To create a kibozed group, use the `G k' command in the group buffer. The address field of the `nnkiboze' method is, as with `nnvirtual', a regexp to match groups to be "included" in the `nnkiboze' group. There most similarities between `nnkiboze' and `nnvirtual' ends. In addition to this regexp detailing component groups, an `nnkiboze' group must have a score file to say what articles that are to be included in the group (*note Scoring::). You must run `M-x nnkiboze-generate-groups' after creating the `nnkiboze' groups you want to have. This command will take time. Lots of time. Oodles and oodles of time. Gnus has to fetch the headers from all the articles in all the components groups and run them through the scoring process to determine if there are any articles in the groups that are to be part of the `nnkiboze' groups. Please limit the number of component groups by using restrictive regexps. Otherwise your sysadmin may become annoyed with you, and the NNTP site may throw you off and never let you back in again. Stranger things have happened. `nnkiboze' component groups do not have to be alive--they can be dead, and they can be foreign. No restrictions. The generation of an `nnkiboze' group means writing two files in `nnkiboze-directory', which is `~/News/' by default. One contains the NOV header lines for all the articles in the group, and the other is an additional `.newsrc' file to store information on what groups that have been searched through to find component articles. Articles that are marked as read in the `nnkiboze' group will have their NOV lines removed from the NOV file.  File: gnus, Node: Scoring, Next: Various, Prev: Select Methods, Up: Top 7 Scoring ********* Other people use "kill files", but we here at Gnus Towers like scoring better than killing, so we'd rather switch than fight. They do something completely different as well, so sit up straight and pay attention! All articles have a default score (`gnus-summary-default-score'), which is 0 by default. This score may be raised or lowered either interactively or by score files. Articles that have a score lower than `gnus-summary-mark-below' are marked as read. Gnus will read any "score files" that apply to the current group before generating the summary buffer. There are several commands in the summary buffer that insert score entries based on the current article. You can, for instance, ask Gnus to lower or increase the score of all articles with a certain subject. There are two sorts of scoring entries: Permanent and temporary. Temporary score entries are self-expiring entries. Any entries that are temporary and have not been used for, say, a week, will be removed silently to help keep the sizes of the score files down. * Menu: * Summary Score Commands:: Adding score entries for the current group. * Group Score Commands:: General score commands. * Score Variables:: Customize your scoring. (My, what terminology). * Score File Format:: What a score file may contain. * Score File Editing:: You can edit score files by hand as well. * Adaptive Scoring:: Big Sister Gnus *knows* what you read. * Followups To Yourself:: Having Gnus notice when people answer you. * Scoring Tips:: How to score effectively. * Reverse Scoring:: That problem child of old is not problem. * Global Score Files:: Earth-spanning, ear-splitting score files. * Kill Files:: They are still here, but they can be ignored. * GroupLens:: Getting predictions on what you like to read.  File: gnus, Node: Summary Score Commands, Next: Group Score Commands, Up: Scoring 7.1 Summary Score Commands ========================== The score commands that alter score entries do not actually modify real score files. That would be too inefficient. Gnus maintains a cache of previously loaded score files, one of which is considered the "current score file alist". The score commands simply insert entries into this list, and upon group exit, this list is saved. The current score file is by default the group's local score file, even if no such score file actually exists. To insert score commands into some other score file (eg. `all.SCORE'), you must first make this score file the current one. General score commands that don't actually change the score file: `V s' Set the score of the current article (`gnus-summary-set-score'). `V S' Display the score of the current article (`gnus-summary-current-score'). `V t' Display all score rules that have been used on the current article (`gnus-score-find-trace'). `V R' Run the current summary through the scoring process (`gnus-summary-rescore'). This might be useful if you're playing around with your score files behind Gnus' back and want to see the effect you're having. `V a' Add a new score entry, and allow specifying all elements (`gnus-summary-score-entry'). `V c' Make a different score file the current (`gnus-score-change-score-file'). `V e' Edit the current score file (`gnus-score-edit-current-scores'). You will be popped into a `gnus-score-mode' buffer (*note Score File Editing::). `V f' Edit a score file and make this score file the current one (`gnus-score-edit-file'). `V F' Flush the score cahe (`gnus-score-flush-cache'). This is useful after editing score files. `V C' Customize a score file in a visually pleasing manner (`gnus-score-customize'). `I C-i' Increase the score of the current article (`gnus-summary-raise-score'). `L C-l' Lower the score of the current article (`gnus-summary-lower-score'). The rest of these commands modify the local score file. `V m' Prompt for a score, and mark all articles with a score below this as read (`gnus-score-set-mark-below'). `V E' Expunge all articles with a score below the default score (or the numeric prefix) (`gnus-score-set-expunge-below'). The keystrokes for actually making score entries follow a very regular pattern, so there's no need to list all the commands. (Hundreds of them.) 1. The first key is either `I' (upper case i) for increasing the score or `L' for lowering the score. 2. The second key says what header you want to score on. The following keys are available: `a' Score on the author name. `s' Score on the subject line. `x' Score on the Xref line--i.e., the cross-posting line. `t' Score on thread--the References line. `d' Score on the date. `l' Score on the number of lines. `i' Score on the Message-ID. `f' Score on followups. `b' Score on the body. `h' Score on the head. 3. The third key is the match type. Which match types are legal depends on what headers you are scoring on. `strings' `e' Exact matching. `s' Substring matching. `f' Fuzzy matching. `r' Regexp matching `date' `b' Before date. `a' At date. `n' This date. `number' `<' Less than number. `=' Equal to number. `>' Greater than number. 4. The fourth and final key says whether this is a temporary (i.e., expiring) score entry, or a permanent (i.e., non-expiring) score entry, or whether it is to be done immediately, without adding to the score file. `t' Temporary score entry. `p' Permanent score entry. `i' Immediately scoring. So, let's say you want to increase the score on the current author with exact matching permanently: `I a e p'. If you want to lower the score based on the subject line, using substring matching, and make a temporary score entry: `L s s t'. Pretty easy. To make things a bit more complicated, there are shortcuts. If you use a capital letter on either the second or third keys, Gnus will use defaults for the remaining one or two keystrokes. The defaults are "substring" and "temporary". So `I A' is the same as `I a s t', and `I a R' is the same as `I a r t'. The `gnus-score-mimic-keymap' says whether these commands will pretend they are keymaps or not.  File: gnus, Node: Group Score Commands, Next: Score Variables, Prev: Summary Score Commands, Up: Scoring 7.2 Group Score Commands ======================== There aren't many of these as yet, I'm afraid. `W f' Gnus maintains a cache of score alists to avoid having to reload them all the time. This command will flush the cache (`gnus-score-flush-cache').  File: gnus, Node: Score Variables, Next: Score File Format, Prev: Group Score Commands, Up: Scoring 7.3 Score Variables =================== `gnus-use-scoring' If `nil', Gnus will not check for score files, and will not, in general, do any score-related work. This is `t' by default. `gnus-kill-killed' If this variable is `nil', Gnus will never apply score files to articles that have already been through the kill process. While this may save you lots of time, it also means that if you apply a kill file to a group, and then change the kill file and want to run it over you group again to kill more articles, it won't work. You have to set this variable to `t' to do that. (It is `t' by default.) `gnus-kill-files-directory' All kill and score files will be stored in this directory, which is initialized from the `SAVEDIR' environment variable by default. This is `~/News/' by default. `gnus-score-file-suffix' Suffix to add to the group name to arrive at the score file name (`SCORE' by default.) `gnus-score-uncacheable-files' All score files are normally cached to avoid excessive re-loading of score files. However, if this might make you Emacs grow big and bloated, so this regexp can be used to weed out score files that are unlikely to be needed again. It would be a bad idea to deny caching of `all.SCORE', while it might be a good idea to not cache `comp.infosystems.www.authoring.misc.ADAPT'. In fact, this variable is `ADAPT$' by default, so no adaptive score files will be cached. `gnus-save-score' If you have really complicated score files, and do lots of batch scoring, then you might set this variable to `t'. This will make Gnus save the scores into the `.newsrc.eld' file. `gnus-score-interactive-default-score' Score used by all the interactive raise/lower commands to raise/lower score with. Default is 1000, which may seem excessive, but this is to ensure that the adaptive scoring scheme gets enough room to play with. We don't want the small changes from the adaptive scoring to overwrite manually entered data. `gnus-summary-default-score' Default score of an article, which is 0 by default. `gnus-score-over-mark' Mark (in the third column) used for articles with a score over the default. Default is `+'. `gnus-score-below-mark' Mark (in the third column) used for articles with a score below the default. Default is `-'. `gnus-score-find-score-files-function' Function used to find score files for the current group. This function is called with the name of the group as the argument. Predefined functions available are: `gnus-score-find-single' Only apply the group's own score file. `gnus-score-find-bnews' Apply all score files that match, using bnews syntax. This is the default. For instance, if the current group is `gnu.emacs.gnus', `all.emacs.all.SCORE', `not.alt.all.SCORE' and `gnu.all.SCORE' would all apply. In short, the instances of `all' in the score file names are translated into `.*', and then a regexp match is done. This means that if you have some score entries that you want to apply to all groups, then you put those entries in the `all.SCORE' file. `gnus-score-find-hierarchical' Apply all score files from all the parent groups. This means that you can't have score files like `all.SCORE' or `all.emacs.SCORE', but you can have `SCORE', `comp.SCORE' and `comp.emacs.SCORE'. This variable can also be a list of functions. In that case, all these functions will be called, and all the returned lists of score files will be applied. These functions can also return lists of score alists directly. In that case, the functions that return these non-file score alists should probably be placed before the "real" score file functions, to ensure that the last score file returned is the local score file. Phu. `gnus-score-expiry-days' This variable says how many days should pass before an unused score file entry is expired. If this variable is `nil', no score file entries are expired. It's 7 by default. `gnus-update-score-entry-dates' If this variable is non-`nil', matching score entries will have their dates updated. (This is how Gnus controls expiry--all non-matching entries will become too old while matching entries will stay fresh and young.) However, if you set this variable to `nil', even matching entries will grow old and will have to face that oh-so grim reaper. `gnus-score-after-write-file-function' Function called with the name of the score file just written.  File: gnus, Node: Score File Format, Next: Score File Editing, Prev: Score Variables, Up: Scoring 7.4 Score File Format ===================== A score file is an `emacs-lisp' file that normally contains just a single form. Casual users are not expected to edit these files; everything can be changed from the summary buffer. Anyway, if you'd like to dig into it yourself, here's an example: (("from" ("Lars Ingebrigtsen" -10000) ("Per Abrahamsen") ("larsi\\|lmi" -50000 nil R)) ("subject" ("Ding is Badd" nil 728373)) ("xref" ("alt.politics" -1000 728372 s)) ("lines" (2 -100 nil <)) (mark 0) (expunge -1000) (mark-and-expunge -10) (read-only nil) (orphan -10) (adapt t) (files "/hom/larsi/News/gnu.SCORE") (exclude-files "all.SCORE") (local (gnus-newsgroup-auto-expire t) (gnus-summary-make-false-root 'empty)) (eval (ding))) This example demonstrates absolutely everything about a score file. Even though this looks much like lisp code, nothing here is actually `eval'ed. The lisp reader is used to read this form, though, so it has to be legal syntactically, if not semantically. Six keys are supported by this alist: `STRING' If the key is a string, it is the name of the header to perform the match on. Scoring can only be performed on these eight headers: `From', `Subject', `References', `Message-ID', `Xref', `Lines', `Chars' and `Date'. In addition to these headers, there are three strings to tell Gnus to fetch the entire article and do the match on larger parts of the article: `Body' will perform the match on the body of the article, `Head' will perform the match on the head of the article, and `All' will perform the match on the entire article. Note that using any of these last three keys will slow down group entry _considerably_. The final "header" you can score on is `Followup'. These score entries will result in new score entries being added for all follow-ups to articles that matches these score entries. Following this key is a arbitrary number of score entries, where each score entry has one to four elements. 1. The first element is the "match element". On most headers this will be a string, but on the Lines and Chars headers, this must be an integer. 2. If the second element is present, it should be a number--the "score element". This number should be an integer in the neginf to posinf interval. This number is added to the score of the article if the match is successful. If this element is not present, the `gnus-score-interactive-default-score' number will be used instead. This is 1000 by default. 3. If the third element is present, it should be a number--the "date element". This date says when the last time this score entry matched, which provides a mechanism for expiring the score entries. It this element is not present, the score entry is permanent. The date is represented by the number of days since December 31, 1 ce. 4. If the fourth element is present, it should be a symbol--the "type element". This element specifies what function should be used to see whether this score entry matches the article. What match types that can be used depends on what header you wish to perform the match on. "From, Subject, References, Xref, Message-ID" For most header types, there are the `r' and `R' (regexp) as well as `s' and `S' (substring) types and `e' and `E' (exact match) types. If this element is not present, Gnus will assume that substring matching should be used. `R' and `S' differ from the other two in that the matches will be done in a case-sensitive manner. All these one-letter types are really just abbreviations for the `regexp', `string' and `exact' types, which you can use instead, if you feel like. "Lines, Chars" These two headers use different match types: `<', `>', `=', `>=' and `<='. "Date" For the Date header we have three match types: `before', `at' and `after'. I can't really imagine this ever being useful, but, like, it would feel kinda silly not to provide this function. Just in case. You never know. Better safe than sorry. Once burnt, twice shy. Don't judge a book by its cover. Never not have sex on a first date. "Head, Body, All" These three match keys use the same match types as the `From' (etc) header uses. "Followup" This match key will add a score entry on all articles that followup to some author. Uses the same match types as the `From' header uses. "Thread" This match key will add a score entry on all articles that are part of a thread. Uses the same match types as the `References' header uses. `mark' The value of this entry should be a number. Any articles with a score lower than this number will be marked as read. `expunge' The value of this entry should be a number. Any articles with a score lower than this number will be removed from the summary buffer. `mark-and-expunge' The value of this entry should be a number. Any articles with a score lower than this number will be marked as read and removed from the summary buffer. `thread-mark-and-expunge' The value of this entry should be a number. All articles that belong to a thread that has a total score below this number will be marked as read and removed from the summary buffer. `gnus-thread-score-function' says how to compute the total score for a thread. `files' The value of this entry should be any number of file names. These files are assumed to be score files as well, and will be loaded the same way this one was. `exclude-files' The clue of this entry should be any number of files. This files will not be loaded, even though they would normally be so, for some reason or other. `eval' The value of this entry will be `eval'el. This element will be ignored when handling global score files. `read-only' Read-only score files will not be updated or saved. Global score files should feature this atom (*note Global Score Files::). `orphan' The value of this entry should be a number. Articles that do not have parents will get this number added to their scores. Imagine you follow some high-volume newsgroup, like `comp.lang.c'. Most likely you will only follow a few of the threads, also want to see any new threads. You can do this with the following two score file entries: (orphan -500) (mark-and-expunge -100) When you enter the group the first time, you will only see the new threads. You then raise the score of the threads that you find interesting (with `I T' or `I S'), and ignore (`C y') the rest. Next time you enter the group, you will see new articles in the interesting threads, plus any new threads. I.e. - the orphan score atom is for high-volume groups where there exist a few interesting threads which can't be found automatically by ordinary scoring rules. `adapt' This entry controls the adaptive scoring. If it is `t', the default adaptive scoring rules will be used. If it is `ignore', no adaptive scoring will be performed on this group. If it is a list, this list will be used as the adaptive scoring rules. If it isn't present, or is something other than `t' or `ignore', the default adaptive scoring rules will be used. If you want to use adaptive scoring on most groups, you'd set `gnus-use-adaptive-scoring' to `t', and insert an `(adapt ignore)' in the groups where you do not want adaptive scoring. If you only want adaptive scoring in a few groups, you'd set `gnus-use-adaptive-scoring' to `nil', and insert `(adapt t)' in the score files of the groups where you want it. `adapt-file' All adaptive score entries will go to the file named by this entry. It will also be applied when entering the group. This atom might be handy if you want to adapt on several groups at once, using the same adaptive file for a number of groups. `local' The value of this entry should be a list of `(VAR VALUE)' pairs. Each VAR will be made buffer-local to the current summary buffer, and set to the value specified. This is a convenient, if somewhat strange, way of setting variables in some groups if you don't like hooks much.  File: gnus, Node: Score File Editing, Next: Adaptive Scoring, Prev: Score File Format, Up: Scoring 7.5 Score File Editing ====================== You normally enter all scoring commands from the summary buffer, but you might feel the urge to edit them by hand as well, so we've supplied you with a mode for that. It's simply a slightly customized `emacs-lisp' mode, with these additional commands: `C-c C-c' Save the changes you have made and return to the summary buffer (`gnus-score-edit-done'). `C-c C-d' Insert the current date in numerical format (`gnus-score-edit-insert-date'). This is really the day number, if you were wondering. `C-c C-p' The adaptive score files are saved in an unformatted fashion. If you intend to read one of these files, you want to "pretty print" it first. This command (`gnus-score-pretty-print') does that for you. Type `M-x gnus-score-mode' to use this mode. `gnus-score-menu-hook' is run in score mode buffers. In the summary buffer you can use commands like `V f' and `V e' to begin editing score files.  File: gnus, Node: Adaptive Scoring, Next: Followups To Yourself, Prev: Score File Editing, Up: Scoring 7.6 Adaptive Scoring ==================== If all this scoring is getting you down, Gnus has a way of making it all happen automatically--as if by magic. Or rather, as if by artificial stupidity, to be precise. When you read an article, or mark an article as read, or kill an article, you leave marks behind. On exit from the group, Gnus can sniff these marks and add score elements depending on what marks it finds. You turn on this ability by setting `gnus-use-adaptive-scoring' to `t'. To give you complete control over the scoring process, you can customize the `gnus-default-adaptive-score-alist' variable. For instance, it might look something like this: (defvar gnus-default-adaptive-score-alist '((gnus-unread-mark) (gnus-ticked-mark (from 4)) (gnus-dormant-mark (from 5)) (gnus-del-mark (from -4) (subject -1)) (gnus-read-mark (from 4) (subject 2)) (gnus-expirable-mark (from -1) (subject -1)) (gnus-killed-mark (from -1) (subject -3)) (gnus-kill-file-mark) (gnus-ancient-mark) (gnus-low-score-mark) (gnus-catchup-mark (from -1) (subject -1)))) As you see, each element in this alist has a mark as a key (either a variable name or a "real" mark--a character). Following this key is a arbitrary number of header/score pairs. If there are no header/score pairs following the key, no adaptive scoring will be done on articles that have that key as the article mark. For instance, articles with `gnus-unread-mark' in the example above will not get adaptive score entries. Each article can have only one mark, so just a single of these rules will be applied to each article. To take `gnus-del-mark' as an example--this alist says that all articles that have that mark (i.e., are marked with `D') will have a score entry added to lower based on the `From' header by -4, and lowered by `Subject' by -1. Change this to fit your prejudices. If you have marked 10 articles with the same subject with `gnus-del-mark', the rule for that mark will be applied ten times. That means that that subject will get a score of ten times -1, which should be, unless I'm much mistaken, -10. The headers you can score on are `from', `subject', `message-id', `references', `xref', `lines', `chars' and `date'. In addition, you can score on `followup', which will create an adaptive score entry that matches on the `References' header using the `Message-ID' of the current article, thereby matching the following thread. You can also score on `thread', which will try to score all articles that appear in a thread. `thread' matches uses a `Message-ID' to match on the `References' header of the article. If the match is made, the `Message-ID' of the article is added to the `thread' rule. (Think about it. I'd recommend two aspirins afterwards.) If you use this scheme, you should set the score file atom `mark' to something small--like -300, perhaps, to avoid having small random changes result in articles getting marked as read. After using adaptive scoring for a week or so, Gnus should start to become properly trained and enhance the authors you like best, and kill the authors you like least, without you having to say so explicitly. You can control what groups the adaptive scoring is to be performed on by using the score files (*note Score File Format::). This will also let you use different rules in different groups. The adaptive score entries will be put into a file where the name is the group name with `gnus-adaptive-file-suffix' appended. The default is `ADAPT'. When doing adaptive scoring, substring or fuzzy matching would probably give you the best results in most cases. However, if the header one matches is short, the possibility for false positives is great, so if the length of the match is less than `gnus-score-exact-adapt-limit', exact matching will be used. If this variable is `nil', exact matching will always be used to avoid this problem.  File: gnus, Node: Followups To Yourself, Next: Scoring Tips, Prev: Adaptive Scoring, Up: Scoring 7.7 Followups To Yourself ========================= Gnus offers two commands for picking out the `Message-ID' header in the current buffer. Gnus will then add a score rule that scores using this `Message-ID' on the `References' header of other articles. This will, in effect, increase the score of all articles that respond to the article in the current buffer. Quite useful if you want to easily note when people answer what you've said. `gnus-score-followup-article' This will add a score to articles that directly follow up your own article. `gnus-score-followup-thread' This will add a score to all articles that appear in a thread "below" your own article. These two functions are both primarily meant to be used in hooks like `gnus-inews-article-hook'.  File: gnus, Node: Scoring Tips, Next: Reverse Scoring, Prev: Followups To Yourself, Up: Scoring 7.8 Scoring Tips ================ "Crossposts" If you want to lower the score of crossposts, the line to match on is the `Xref' header. ("xref" (" talk.politics.misc:" -1000)) "Multiple crossposts" If you want to lower the score of articles that have been crossposted to more than, say, 3 groups: ("xref" ("[^:\n]+:[0-9]+ +[^:\n]+:[0-9]+ +[^:\n]+:[0-9]+" -1000 nil r)) "Matching on the body" This is generally not a very good idea--it takes a very long time. Gnus actually has to fetch each individual article from the server. But you might want to anyway, I guess. Even though there are three match keys (`Head', `Body' and `All'), you should choose one and stick with it in each score file. If you use any two, each article will be fetched _twice_. If you want to match a bit on the `Head' and a bit on the `Body', just use `All' for all the matches. "Marking as read" You will probably want to mark articles that has a score below a certain number as read. This is most easily achieved by putting the following in your `all.SCORE' file: ((mark -100)) You may also consider doing something similar with `expunge'. "Negated character classes" If you say stuff like `[^abcd]*', you may get unexpected results. That will match newlines, which might lead to, well, The Unknown. Say `[^abcd\n]*' instead.  File: gnus, Node: Reverse Scoring, Next: Global Score Files, Prev: Scoring Tips, Up: Scoring 7.9 Reverse Scoring =================== If you want to keep just articles that have `Sex with Emacs' in the subject header, and expunge all other articles, you could put something like this in your score file: (("subject" ("Sex with Emacs" 2)) (mark 1) (expunge 1)) So, you raise all articles that match `Sex with Emacs' and mark the rest as read, and expunge them to boot.  File: gnus, Node: Global Score Files, Next: Kill Files, Prev: Reverse Scoring, Up: Scoring 7.10 Global Score Files ======================= Sure, other newsreaders have "global kill files". These are usually nothing more than a single kill file that applies to all groups, stored in the user's home directory. Bah! Puny, weak newsreaders! What I'm talking about here are Global Score Files. Score files from all over the world, from users everywhere, uniting all nations in one big, happy score file union! Ange-score! New and untested! All you have to do to use other people's score files is to set the `gnus-global-score-files' variable. One entry for each score file, or each score file directory. Gnus will decide by itself what score files are applicable to which group. Say you want to use all score files in the `/ftp@ftp.some-where:/pub/score' directory and the single score file `/ftp@ftp.ifi.uio.no:/pub/larsi/ding/score/soc.motss.SCORE': (setq gnus-global-score-files '("/ftp@ftp.ifi.uio.no:/pub/larsi/ding/score/soc.motss.SCORE" "/ftp@ftp.some-where:/pub/score/")) Simple, eh? Directory names must end with a `/'. These directories are typically scanned only once during each Gnus session. If you feel the need to manually re-scan the remote directories, you can use the `gnus-score-search-global-directories' command. Note that, at present, using this option will slow down group entry somewhat. (That is--a lot.) If you want to start maintaining score files for other people to use, just put your score file up for anonymous ftp and announce it to the world. Become a retro-moderator! Participate in the retro-moderator wars sure to ensue, where retro-moderators battle it out for the sympathy of the people, luring them to use their score files on false premises! Yay! The net is saved! Here are some tips for the would-be retro-moderator, off the top of my head: * Articles that are heavily crossposted are probably junk. * To lower a single inappropriate article, lower by `Message-ID'. * Particularly brilliant authors can be raised on a permanent basis. * Authors that repeatedly post off-charter for the group can safely be lowered out of existence. * Set the `mark' and `expunge' atoms to obliterate the nastiest articles completely. * Use expiring score entries to keep the size of the file down. You should probably have a long expiry period, though, as some sites keep old articles for a long time. ... I wonder whether other newsreaders will support global score files in the future. _Snicker_. Yup, any day now, newsreaders like Blue Wave, xrn and 1stReader are bound to implement scoring. Should we start holding our breath yet?  File: gnus, Node: Kill Files, Next: GroupLens, Prev: Global Score Files, Up: Scoring 7.11 Kill Files =============== Gnus still supports those pesky old kill files. In fact, the kill file entries can now be expiring, which is something I wrote before Daniel Quinlan thought of doing score files, so I've left the code in there. In short, kill processing is a lot slower (and I do mean _a lot_) than score processing, so it might be a good idea to rewrite your kill files into score files. Anyway, a kill file is a normal `emacs-lisp' file. You can put any forms into this file, which means that you can use kill files as some sort of primitive hook function to be run on group entry, even though that isn't a very good idea. XCNormal kill files look like this: (gnus-kill "From" "Lars Ingebrigtsen") (gnus-kill "Subject" "ding") (gnus-expunge "X") This will mark every article written by me as read, and remove them from the summary buffer. Very useful, you'll agree. Other programs use a totally different kill file syntax. If Gnus encounters what looks like a `rn' kill file, it will take a stab at interpreting it. Two summary functions for editing a GNUS kill file: `M-k' Edit this group's kill file (`gnus-summary-edit-local-kill'). `M-K' Edit the general kill file (`gnus-summary-edit-global-kill'). Two group mode functions for editing the kill files: `M-k' Edit this group's kill file (`gnus-group-edit-local-kill'). `M-K' Edit the general kill file (`gnus-group-edit-global-kill'). Kill file variables: `gnus-kill-file-name' A kill file for the group `soc.motss' is normally called `soc.motss.KILL'. The suffix appended to the group name to get this file name is detailed by the `gnus-kill-file-name' variable. The "global" kill file (not in the score file sense of "global", of course) is called just `KILL'. `gnus-kill-save-kill-file' If this variable is non-`nil', Gnus will save the kill file after processing, which is necessary if you use expiring kills. `gnus-apply-kill-hook' A hook called to apply kill files to a group. It is `(gnus-apply-kill-file)' by default. If you want to ignore the kill file if you have a score file for the same group, you can set this hook to `(gnus-apply-kill-file-unless-scored)'. If you don't want kill files to be processed, you should set this variable to `nil'. `gnus-kill-file-mode-hook' A hook called in kill-file mode buffers.  File: gnus, Node: GroupLens, Prev: Kill Files, Up: Scoring 7.12 GroupLens ============== GroupLens is a collaborative filtering system that helps you work together with other people to find the quality news articles out of the huge volume of news articles generated every day. To accomplish this the GroupLens system combines your opinions about articles you have already read with the opinions of others who have done likewise and gives you a personalized prediction for each unread news article. Think of GroupLens as a matchmaker. GroupLens watches how you rate articles, and finds other people that rate articles the same way. Once it has found for you some people you agree with it tells you, in the form of a prediction, what they thought of the article. You can use this prediction to help you decide whether or not you want to read the article. * Menu: * Using GroupLens:: How to make Gnus use GroupLens. * Rating Articles:: Letting GroupLens know how you rate articles. * Displaying Predictions:: Displaying predictions given by GroupLens. * GroupLens Variables:: Customizing GroupLens.  File: gnus, Node: Using GroupLens, Next: Rating Articles, Up: GroupLens 7.12.1 Using GroupLens ---------------------- To use GroupLens you must register a pseudonym with your local Better Bit Bureau (BBB). At the moment the only better bit in town is at `http://www.cs.umn.edu/Research/GroupLens/bbb.html'. Once you have registered you'll need to set a couple of variables. `gnus-use-grouplens' Setting this variable to a non-`nil' value will make Gnus hook into all the relevant GroupLens functions. `grouplens-pseudonym' This variable should be set to the pseudonum you got when registering with the Better Bit Bureau. `grouplens-newsgroups' A list of groups that you want to get GroupLens predictions for. Thats the minimum of what you need to get up and running with GroupLens. Once you've registered, GroupLens will start giving you scores for articles based on the average of what other people think. But, to get the real benefit of GroupLens you need to start rating articles yourself. Then the scores GroupLens gives you will be personalized for you, based on how the people you usually agree with have already rated.  File: gnus, Node: Rating Articles, Next: Displaying Predictions, Prev: Using GroupLens, Up: GroupLens 7.12.2 Rating Articles ---------------------- In GroupLens, an article is rated on a scale from 1 to 5, inclusive. Where 1 means something like this article is a waste of bandwidth and 5 means that the article was really good. The basic question to ask yourself is, "on a scale from 1 to 5 would I like to see more articles like this one?" There are four ways to enter a rating for an article in GroupLens. `r' This function will prompt you for a rating on a scale of one to five. `k' This function will prompt you for a rating, and rate all the articles in the thread. This is really useful for some of those long running giant threads in rec.humor. The next two commands, `n' and `,' take a numerical prefix to be the score of the article you're reading. `1-5 n' Rate the article and go to the next unread article. `1-5 ,' Rate the article and go to the next unread article with the highest score. If you want to give the current article a score of 4 and then go to the next article, just type `4 n'.  File: gnus, Node: Displaying Predictions, Next: GroupLens Variables, Prev: Rating Articles, Up: GroupLens 7.12.3 Displaying Predictions ----------------------------- GroupLens makes a prediction for you about how much you will like a news article. The predictions from GroupLens are on a scale from 1 to 5, where 1 is the worst and 5 is the best. You can use the predictions from GroupLens in one of three ways controlled by the variable `gnus-grouplens-override-scoring'. There are three ways to display predictions in grouplens. You may choose to have the GroupLens scores contribute to, or override the regular gnus scoring mechanism. override is the default; however, some people prefer to see the Gnus scores plus the grouplens scores. To get the separate scoring behavior you need to set `gnus-grouplens-override-scoring' to `'separate'. To have the GroupLens predictions combined with the grouplens scores set it to `'override' and to combine the scores set `gnus-grouplens-override-scoring' to `'combine'. When you use the combine option you will also want to set the values for `grouplens-prediction-offset' and `grouplens-score-scale-factor'. In either case, GroupLens gives you a few choices for how you would like to see your predictions displayed. The display of predictions is controlled by the `grouplens-prediction-display' variable. The following are legal values for that variable. `prediction-spot' The higher the prediction, the further to the right an `*' is displayed. `confidence-interval' A numeric confidence interval. `prediction-bar' The higher the prediction, the longer the bar. `confidence-bar' Numerical confidence. `confidence-spot' The spot gets bigger with more confidence. `prediction-num' Plain-old numeric value. `confidence-plus-minus' Prediction +/i confidence.  File: gnus, Node: GroupLens Variables, Prev: Displaying Predictions, Up: GroupLens 7.12.4 GroupLens Variables -------------------------- `gnus-summary-grouplens-line-format' The summary line format used in summary buffers that are GroupLens enhanced. It accepts the same specs as the normal summary line format (*note Summary Buffer Lines::). The default is `%U%R%z%l%I%(%[%4L: %-20,20n%]%) %s\n'. `grouplens-bbb-host' Host running the bbbd server. The default is `grouplens.cs.umn.edu'. `grouplens-bbb-port' Port of the host running the bbbd server. The default is 9000. `grouplens-score-offset' Offset the prediction by this value. In other words, subtract the prediction value by this number to arrive at the effective score. The default is 0. `grouplens-score-scale-factor' This variable allows the user to magnify the effect of GroupLens scores. The scale factor is applied after the offset. The default is 1.  File: gnus, Node: Various, Next: The End, Prev: Scoring, Up: Top 8 Various ********* * Menu: * Process/Prefix:: A convention used by many treatment commands. * Interactive:: Making Gnus ask you many questions. * Formatting Variables:: You can specify what buffers should look like. * Windows Configuration:: Configuring the Gnus buffer windows. * Compilation:: How to speed Gnus up. * Mode Lines:: Displaying information in the mode lines. * Highlighting and Menus:: Making buffers look all nice and cozy. * Buttons:: Get tendonitis in ten easy steps! * Daemons:: Gnus can do things behind your back. * NoCeM:: How to avoid spam and other fatty foods. * Picons:: How to display pictures of what your reading. * Various Various:: Things that are really various.  File: gnus, Node: Process/Prefix, Next: Interactive, Up: Various 8.1 Process/Prefix ================== Many functions, among them functions for moving, decoding and saving articles, use what is known as the "Process/Prefix convention". This is a method for figuring out what articles that the user wants the command to be performed on. It goes like this: If the numeric prefix is N, perform the operation on the next N articles, starting with the current one. If the numeric prefix is negative, perform the operation on the previous N articles, starting with the current one. If `transient-mark-mode' in non-`nil' and the region is active, all articles in the region will be worked upon. If there is no numeric prefix, but some articles are marked with the process mark, perform the operation on the articles that are marked with the process mark. If there is neither a numeric prefix nor any articles marked with the process mark, just perform the operation on the current article. Quite simple, really, but it needs to be made clear so that surprises are avoided. One thing that seems to shock & horrify lots of people is that, for instance, `3 d' does exactly the same as `d' `d' `d'. Since each `d' (which marks the current article as read) by default goes to the next unread article after marking, this means that `3 d' will mark the next three unread articles as read, no matter what the summary buffer looks like. Set `gnus-summary-goto-unread' to `nil' for a more straightforward action.  File: gnus, Node: Interactive, Next: Formatting Variables, Prev: Process/Prefix, Up: Various 8.2 Interactive =============== `gnus-novice-user' If this variable is non-`nil', you are either a newcomer to the World of Usenet, or you are very cautious, which is a nice thing to be, really. You will be given questions of the type "Are you sure you want to do this?" before doing anything dangerous. This is `t' by default. `gnus-expert-user' If this variable is non-`nil', you will never ever be asked any questions by Gnus. It will simply assume you know what you're doing, no matter how strange. `gnus-interactive-catchup' Require confirmation before catching up a group if non-`nil'. It is `t' by default. `gnus-interactive-exit' Require confirmation before exiting Gnus. This variable is `t' by default.  File: gnus, Node: Formatting Variables, Next: Windows Configuration, Prev: Interactive, Up: Various 8.3 Formatting Variables ======================== Throughout this manual you've probably noticed lots of variables that are called things like `gnus-group-line-format' and `gnus-summary-mode-line-format'. These control how Gnus is to output lines in the various buffers. There's quite a lot of them. Fortunately, they all use the same syntax, so there's not that much to be annoyed by. Here's an example format spec (from the group buffer): `%M%S%5y: %(%g%)\n'. We see that it is indeed extremely ugly, and that there are lots of percentages everywhere. Each `%' element will be replaced by some string or other when the buffer in question is generated. `%5y' means "insert the `y' spec, and pad with spaces to get a 5-character field". Just like a normal format spec, almost. You can also say `%6,4y', which means that the field will never be more than 6 characters wide and never less than 4 characters wide. There are also specs for highlighting, and these are shared by all the format variables. Text inside the `%(' and `%)' specifiers will get the special `mouse-face' property set, which means that it will be highlighted (with `gnus-mouse-face') when you put the mouse pointer over it. Text inside the `%[' and `%]' specifiers will have their normal faces set using `gnus-face-0', which is `bold' by default. If you say `%1[' instead, you'll get `gnus-face-1' instead, and so on. Create as many faces as you wish. The same goes for the `mouse-face' specs--you can say `%3(hello%)' to have `hello' mouse-highlighted with `gnus-mouse-face-3'. Here's an alternative recipe for the group buffer: ;; Create three face types. (setq gnus-face-1 'bold) (setq gnus-face-3 'italic) ;; We want the article count to be in ;; a bold and green face. So we create ;; a new face called `my-green-bold'. (copy-face 'bold 'my-green-bold) ;; Set the color. (set-face-foreground 'my-green-bold "ForestGreen") (setq gnus-face-2 'my-green-bold) ;; Set the new & fancy format. (setq gnus-group-line-format "%M%S%3{%5y%}%2[:%] %(%1{%g%}%)\n") I'm sure you'll be able to use this scheme to create totally unreadable and extremely vulgar displays. Have fun! Currently Gnus uses the following formatting variables: `gnus-group-line-format', `gnus-summary-line-format', `gnus-server-line-format', `gnus-topic-line-format', `gnus-group-mode-line-format', `gnus-summary-mode-line-format', `gnus-article-mode-line-format', `gnus-server-mode-line-format'. Note that the `%(' specs (and friends) do not make any sense on the mode-line variables. All these format variables can also be arbitrary elisp forms. In that case, they will be `eval'ed to insert the required lines. Gnus includes a command to help you while creating your own format specs. `M-x gnus-update-format' will `eval' the current form, update the spec in question and pop you to a buffer where you can examine the resulting lisp code to be run to generate the line.