This manual is part of XEmacs.

XEmacs is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2, or (at your option) any later version.

XEmacs is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with XEmacs; see the file COPYING.  If not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

The Editing Utilities Package
*****************************

This Info file contains the manual for the Editing Utilities package.

The node name for each entry in the menu is the name of the elisp file containing the code that implements the functionality described.  It is highly recommended that you briefly peruse the elisp source code since it can provide valuable information on usage and technique.  This can easily be done by typing C-x 4 l <filename> RET where <filename> is the name of the elisp file to be loaded.

Copying
*******

This document may be redistributed, verbatim or in modified form, under the terms of the GNU General Public License, version 2 or any later version.  The same terms apply to the libraries it documents.  A copy of the General Public License is provided as an Appendix.

Most XEmacs documentation has its own license, which is an ancestor of the GNU Free Documentation License (FDL), and whose terms are quite similar to those imposed by GNU on Emacs documentation.  Why is this manual licensed differently (under the GNU General Public License, or GPL), and why does it have to be distributed separately from the XEmacs User's Guide and the XEmacs Lisp Reference Manual?

Taking the second question first, XEmacs is community-owned software.  That is, unlike GNU Emacs, there is no monopoly copyright holder.  Many of us, including the original Lucid authors, have contributed our copyrights to the Free Software Foundation (FSF), and of course much content is derived from GNU Emacs, and therefore is held by the FSF.  Another large chunk is held by Sun Microsystems, and a few individual authors hold copyright to thousands of lines each.  But many individuals hold copyright to only a few dozen lines.  Like the Linux kernel, copyright ownership is distributed throughout a community.

However, its license is ``copyleft,'' i.e., it requires that you redistribute it under terms identical to those under which you received it, unless you have explicit permission of the copyright holder.  Because of the multiple owners, determining the ownership of any given part of XEmacs is tedious, and perhaps impossible.  For practical purposes, then, the license of any substantial chunk of existing XEmacs content cannot be changed, except to a later version of the GPL, for those parts under GPL.  (That is due to the explicit permission to change to a later version of the GPL, present in every file of XEmacs.)

Unfortunately, this severe restriction means that the GPL, FDL, and the XEmacs documentation license (XDL) are mutually incompatible.  That is, content licensed under any of the GPL, FDL, or XDL may not be mixed with content licensed under either of the other two without changing the license of some of the content.  But this requires permission of the copyright holder, which is often difficult or impossible to get.

For example, you may not take comments or docstrings from XEmacs code and add them to the Lispref to mend a gap in the latter's coverage. You may not copy text from the Lispref into docstrings in the code.  And you may not copy text from the GNU Emacs Lisp Reference to the XEmacs Lisp Reference Manual.  (In this case it is at least trivial to ask permission, although it is rather unclear whether it would be granted.)

In fact, parts of this document were derived by copying from XEmacs code under the GPL, without any further permission from the authors.  Thus, this document must be distributed under the GPL, as a ``volume'' separate from the XEmacs documentation under the XDL.  Note that the ``mere aggregation'' clauses allow us to distribute in the same tarball.  But incorporating it as a node in the Lispref is prohibited, even if done by inclusion.

A bit of advocacy:

If you look carefully at the additional restrictions imposed by the soi-disant "free" documentation licenses, you discover that they are simply proprietary restrictions guaranteeing a certain amount of unpaid political advertising to the Free Software Foundation and GNU Project (and in the case of the FDL, this is extended to commercial advertising by authors of original or derived works).  Whether this is ``ethically justified'' or not is a difficult question.  What is certain is that there is little social benefit to these terms (since the license documents themselves contain the advocacy and must be included with any distribution).

I conclude it makes sense for XEmacs to reduce its restrictions, where possible, to the ``least common denominator,'' the GNU General Public License.

Comparing Windows
*****************

This package provides one entry point, compare-windows.  It compares text starting from point in two adjacent windows, advancing point until it finds a difference.  There are variables to permit ignoring of whitespace differences, or case differences, or both.

Detached Minibuffers
********************

This package creates a standalone minibuffer in its own frame.

To configure this package, type:

       M-x customize-group RET detached-minibuf RET

Convenient Buffer Switching
***************************

With this package installed, as you type in a substring, the list of buffers currently matching the substring are displayed as you type.  The list is ordered so that the most recent buffers visited come at the start of the list.  The buffer at the start of the list will be the one visited when you press return.  By typing more of the substring, the list is narrowed down so that gradually the buffer you want will be at the top of the list. Alternatively, you can use C-s and C-r to rotate buffer names in the list until the one you want is at the top of the list.  Completion is also available so that you can see what is common to all of the matching buffers as you type.

For example, let's say we have two buffers called "123456" and "123", with "123456" the most recent. When I use iswitchb, I first of all get presented with the list of all the buffers

iswitch {123456,123}

If I then press 2:

iswitch 2[3]{123456,123}

The list in {} are the matching buffers, most recent first (buffers visible in the current frame are put at the end of the list by default).  At any time I can select the item at the head of the list by pressing RET.  I can also bring the put the first element at the end of the list by pressing C-s, or put the last element at the head of the list by pressing C-r.  The item in [] indicates what can be added to my input by pressing TAB.  In this case, I will get 3 added to my input. So, press TAB:

iswitch 23{123456,123}

At this point, I still have two matching buffers.  If I want the first buffer in the list, I simply press RET.  If I wanted the second in the list, I could press C-s to move it to the top of the list and then RET to select it.

However, If I type 4, I only have one match left:

iswitch 234[123456] [Matched]

Since there is only one matching buffer left, it is given in [] and we see the text [Matched] afterwards.  I can now press TAB or RET to go to that buffer.

If however, I now type a:

iswitch 234a [No match]

There are no matching buffers.  If I press RET or TAB, I can be prompted to create a new buffer called "234a".

Of course, where this function comes in really useful is when you can specify the buffer using only a few keystrokes.  In the above example, the quickest way to get to the "123456" buffer would be just to type 4 and then RET (assuming there isn't any newer buffer with "4" in its name).

To see a full list of all matching buffers in a separate buffer, hit ? or press TAB when there are no further completions to the substring. Repeated TAB presses will scroll you through this separate buffer.

The buffer at the head of the list can be killed by pressing C-k.  If the buffer needs saving, you will be queried before the buffer is killed.

If you find that the file you are after is not in a buffer, you can press C-x C-f to immediately drop into find-file.

To see the doc string of iswitchb for full keybindings and features, type:

       M-x describe-function RET iswitchb

Customization
=============

To configure the package, type:

       M-x customize-group RET iswitchb RET

To install this package on the default keys used for buffer switching, type:

       M-x iswitchb-default-keybindings RET

To modify the default keybindings, use the hook provided.  For example, the following code can be added to your initialization file:

       (add-hook 'iswitchb-define-mode-map-hook 'iswitchb-my-keys)

       (defun iswitchb-my-keys ()
         "Add my keybindings for iswitchb."
         (define-key iswitchb-mode-map " " 'iswitchb-next-match)
         )

Changing the Display
====================

If you have many matching buffers, they may not all fit onto one line of the minibuffer.  In this case, you should use (resize-minibuffer-mode) see rsz-minibuf.  You can also limit iswitchb so that it only shows a certain number of lines.  To do this, see the documentation for iswitchb-minibuffer-setup-hook.

By default, the list of current buffers is most recent first, oldest last, with the exception that the buffers visible in the current frame are put at the end of the list.  A hook exists to allow other functions to order the list.  For example, if you add:

       (add-hook 'iswitchb-make-buflist-hook 'iswitchb-summaries-to-end)

then all buffers matching "Summary" are moved to the end of the list.  (I find this handy for keeping the INBOX Summary and so on out of the way.)  It also moves buffers matching "output\*$" to the end of the list (these are created by AUC TeX when compiling.)  Other functions could be made available which alter the list of matching buffers (either deleting or rearranging elements.)

If you have font-lock loaded, the first matching buffer is highlighted.  To switch this off, set (setq iswitchb-use-fonts nil). I don't use font-lock that much, so I've hardcoded the faces.  If this is too harsh, let me know.  Colouring of the matching buffer name was suggested by Carsten Dominik (dominik@strw.leidenuniv.nl)

Regexp Matching
===============

There is limited provision for regexp matching within iswitchb, enabled through iswitchb-regexp.  This allows you to type c$ for example and see all buffer names ending in `c'.  This facility is quite limited though in two respects.  First, you can't currently type in expressions like `[0-9]' directly -- you have to type them in when iswitchb-regexp is nil and then toggle on the regexp functionality.  Likewise, don't enter an expression containing `\' in regexp mode.  If you try, iswitchb gets confused, so just hit C-g and try again.  Secondly, no completion mechanism is currently offered when regexp searching.

Replacement for read-buffer
===========================

iswitchb-read-buffer has been written to be a drop in replacement for the normal buffer selection routine read-buffer.  To use iswitch for all buffer selections in Emacs, add: (setq read-buffer-function 'iswitchb-read-buffer) (This variable should be present in Emacs 20.3+) XEmacs users can get the same behaviour by doing: (defalias 'read-buffer 'iswitchb-read-buffer) since read-buffer is defined in lisp.

Permanent Buffers
*****************

A permanent buffer is a buffer that you don't want to kill, mainly used for testing or temporary stuff. The *scratch* buffer is the most famous example of what could be a permanent buffer. This package allows you to define several permanent buffers (the scratch buffer can be one of them) that will never disappear. If you kill them or save their contents, they will be regenerated. You can also specify a set of lisp forms to eval in the buffer when it is (re)generated.

This package is implemented in a minor-mode fashion. You can customize the default value of permanent-buffers-mode or use turn-on-permanent-buffers at startup. Within an XEmacs session, use permanent-buffers-mode or turn-o[n|ff]-permanent-buffers. You might also want to customize permanent-buffers-alist.

To configure this package, type:

       M-x customize-group RET permanent-buffers RET

Self-Resizing Minibuffer
************************

This package allows the entire contents (or as much as possible) of the minibuffer to be visible at once when typing.  As the end of a line is reached, the minibuffer will resize itself.  When the user is done typing, the minibuffer will return to its original size.

In window systems where it is possible to have a frame in which the minibuffer is the only window, the frame itself can be resized.

Note that the minibuffer and echo area are not the same!  They simply happen to occupy roughly the same place on the frame.  Messages put in the echo area will not cause any resizing by this package.

This package is considered a minor mode but it doesn't put anything in minor-mode-alist because this mode is specific to the minibuffer, which has no modeline.

To invoke this mode, type:

       M-x resize-minibuffer-mode RET

To configure this package, type:

       M-x customize-group RET resize-minibuffer RET

Searching Many Buffers
**********************

This package searches all live buffers for REGEXP and presents matching lines in a separate buffer with hyperlinks to their occurrences.

After creating countless buffers in an XEmacs session, the user can execute the following:

       M-x list-matches-in-buffers RET \<problem\> RET .* RET

to find all matches of the single word "problem" in any of them.  The result is presented in a buffer named "*Matches for "\<problem\>" in buffers*" with hyperlinks to any occurrence.  User may navigate to the next (n) or previous (p) match.

Meaningful Unique Names
***********************

Emacs' standard method for making buffer names unique adds <2>, <3>, etc. to the end of (all but one of) the buffers.  This file replaces that behavior, for buffers visiting files and dired buffers, with a uniquification that adds parts of the file name until the buffer names are unique.  For instance, buffers visiting /u/mernst/tmp/Makefile and /usr/projects/zaphod/Makefile would be named Makefile|tmp and Makefile|zaphod, respectively (instead of Makefile and Makefile<2>).  Other buffer name styles are also available.

To configure this package, type:

       M-x customize-group RET uniquify RET

Window Configuration Rings
**************************

This package provides lightweight support for circular rings of window configurations.  A window configuration is the layout of windows and associated buffers within a frame.  There is always at least one configuration on the ring, the current configuration.  You can create new configurations and cycle through the layouts in either direction.  You can also delete configurations from the ring (except the last one of course!). Window configurations are named, and you can jump to and delete named configurations.

Window configuration rings are frame specific.  That is, each frame has its own ring which can be cycled through independently of other frames.

You are always looking at the current window configuration for each frame, which consists of the windows in the frame, the buffers in those windows, and point in the current buffer.  As you run commands such as C-x 4 b, C-x 2, and C-x 0 you are modifying the current window configuration.  When you jump to a new configuration, the layout that existed before the jump is captured, and the ring is rotated to the selected configuration.  Window configurations are captured with current-window-configuration, however winring also saves point for the current buffer.

To use, add the following to your initialization file:

       (winring-initialize)

Note that by default, this binds the winring keymap to the C-x 7 prefix, but you can change this by setting the value of winring-keymap-prefix, before you call winring-initialize.

The following commands are defined:

C-x 7 n

     Create a new window configuration.  The new configuration will contain a single buffer, the one named in the variable winring-new-config-buffer-name.

     With C-u, winring prompts for the name of the new configuration.  If you don't use C-u the function in winring-name-generator will be called to get the new configuration's name.

C-x 7 2

     Create a duplicate of the current window configuration.  C-u has the same semantics as with C-x 7 c.

C-x 7 j

     Jump to a named configuration (prompts for the name).

C-x 7 0

     Kill the current window configuration and rotate to the previous layout on the ring.  You cannot delete the last configuration in the ring.  With C-u, prompts for the name of the configuration to kill.

C-x 7 o

     Go to the next configuration on the ring.

C-x 7 p

     Go to the previous configuration on the ring.

     Note that the sequence `C-x 7 o C-x 7 p' is a no-op; it leaves you in the same configuration you were in before the sequence.

C-x 7 r

     Rename the current window configuration.

C-x 7 b

     Submit a bug report on winring.

C-x 7 v

     Echo the winring version.

As mentioned, window configuration names can be displayed in the modeline. The default value of winring-show-names is currently nil by default. Set it to t to activate.  If you don't like the position in the modeline where winring names are shown, you can change this by passing in your own modeline hacker function to winring-initialize.

History
=======

A long long time ago there was a package called `wicos' written by Heikki Suopanki, which was based on yet another earlier package called `screens' also written by Suopanki.  This in turn was based on the Unix tty session manager `screen' (unrelated to Emacs) by Oliver Laumann, Juergen Weigert, and Michael Schroeder.

Wicos essentially provided fancy handling for window configurations.  I liked the basic ideas, but wicos broke with later versions of Emacs and XEmacs.  I re-implemented just the functionality I wanted, simplifying things in the process, and porting the code to run with XEmacs 19 and 20, and Emacs 20 (I don't know if winring works in Emacs 19.34).

Wicos used the M-o prefix which I've recently changed to C-x 7 as the default, by suggestion of RMS.  Wicos also had some support for multiple frames, and saving configurations on all visible frames, but it didn't work too well, and I like frame independent rings better.

Related Packages
================

I know of a few other related packages:

  * `escreen' by Noah Friedman.  A much more ambitious package that does Emacs window session management.  Very cool, but I wanted something more lightweight.

  * `wconfig' by Bob Weiner as part of Hyperbole.  I think wconfig is similar in spirit to winring; it seems to have also have named window configurations, but not frame-specific window rings.

  * `winner' by Ivar Rummelhoff.  This package comes with Emacs 20, and appears to differ from winring by providing undo/redo semantics to window configuration changes.  winner is a minor mode and does seem to support frame-specific window rings.

  * window-xemacs' by the XEmacs Development Team.  It appears that this package, which is specific to XEmacs (and perhaps just XEmacs 20) implements stacks of window configurations which are frame independent.

Please feel free to email me if my rendition of history, or my explanation of the related packages, is inaccurate.

Reverting Buffers
*****************

Whenever a file that Emacs is editing has been changed by another program the user normally has to execute the command `revert-buffer' to load the new content of the file into Emacs.

This package is defined in autorevert.el and contains two minor modes: Global Auto-Revert Mode and Auto-Revert Mode.  Both modes automatically revert buffers whenever the corresponding files have been changed on disk.

Auto-Revert Mode can be activated for individual buffers.  Global Auto-Revert Mode applies to all file buffers.

Both modes operate by checking the time stamp of all files at intervals of `auto-revert-interval'.  The default is every five seconds.  The check is aborted whenever the user actually uses Emacs.  You should never even notice that this package is active (except that your buffers will be reverted, of course).

Auto-Revert Usage
=================

To configure the package, type:

       M-x customize-group RET auto-revert RET

To activate Auto-Revert for a specific buffer, go to the buffer and type:

       M-x auto-revert-mode RET

To activate Global Auto-Revert Mode, type:

       M-x global-auto-revert-mode RET

To activate Global Auto-Revert Mode every time Emacs is started customize the option `global-auto-revert-mode' or the following line could be added to your initialization file:

       (global-auto-revert-mode 1)

The function `turn-on-auto-revert-mode' could be added to any major mode hook to activate Auto-Revert Mode for all buffers in that mode.  For example, the following line will activate Auto-Revert Mode in all C mode buffers:

       (add-hook 'c-mode-hook 'turn-on-auto-revert-mode)

Specify Directories to be Used for Backup Files
***********************************************

Allows backup files to be optionally stored in some directories, based on the value of the alist, bkup-backup-directory-info.  This variable is a list of lists of the form (FILE-REGEXP BACKUP-DIR OPTIONS ...).  If the filename to be backed up matches FILE-REGEXP, or FILE-REGEXP is t, then BACKUP-DIR is used as the path for its backups.  Directories may begin with "/" to specify an absolute pathname.

If BACKUP-DIR does not exist and OPTIONS contains the symbol ok-create, then it is created if possible.  Otherwise the usual behavior (backup in the same directory as the file) results.

If OPTIONS contains the symbol full-path, then the full path of the file being backed up is prepended to the backup file name, with each "/" replaced by a "!".  This is intended for cases where an absolute backup path is used.  If OPTIONS contains prepend-name in addition to full-path, then the file name is prepended rather than appended to the path component when forming the backup name.

If OPTIONS contains the symbol search-upward and the backup directory BACKUP-DIR is a relative path, then a directory with that name is searched for starting at the current directory and proceeding upward (.., ../.., etc) until one is found of that name or the root is reached, and if one is found it is used as the backup directory.

Finally, if no FILE-REGEXP matches the file name being backed up, then the usual behavior results.

These lines from my initialization file load this library and set the values I like:

       (require 'backup-dir)
       (setq bkup-backup-directory-info
             '(("/home/greg/.*" "/~/.backups/" ok-create full-path prepend-name)
               ("^/[^/:]+:"     ".backups/") ; handle EFS files specially: don't
               ("^/[^/:]+:"     "./")        ; search-upward... its very slow
               (t               ".backups/"
                                full-path prepend-name search-upward)))

The package also provides a new function, find-file-latest-backup to find the latest backup file for the current buffer's file.

This package is based on files.el from XEmacs 20.3 and overrides functions defined there.

Create annotated bookmarks
**************************

This package is for setting "bookmarks" in files.  A bookmark associates a string with a location in a certain file.  Thus, you can navigate your way to that location by providing the string.

To configure this package, type:

       M-x customize-group RET bookmark RET

Save Partial Status of Emacs When Killed
****************************************

Save the Desktop, i.e.,

  * some global variables

  * the list of buffers with associated files.  For each buffer also

       * the major mode

       * the default directory

       * the point

       * the mark & mark-active

       * buffer-read-only

       * some local variables

To use this, first put these two lines at the bottom of your initialization file (the later the better):

       (desktop-load-default)
       (desktop-read)

Between these two lines you may wish to add something that updates the variables desktop-globals-to-save and/or desktop-locals-to-save.  If for instance you want to save the local variable foobar for every buffer in which it is local, you could add the line

       (setq desktop-locals-to-save (cons 'foobar desktop-locals-to-save))

To avoid saving excessive amounts of data you may also wish to add something like the following

       (add-hook 'kill-emacs-hook
                 '(lambda ()
                    (desktop-truncate search-ring 3)
                    (desktop-truncate regexp-search-ring 3)))

which will make sure that no more than three search items are saved.  You must place this line after the (desktop-load-default) line. See also the variable desktop-save-hook.

Start Emacs in the root directory of your "project". The desktop saver is inactive by default.  You activate it by typing M-x desktop-save RET. When you exit the next time the above data will be saved.  This ensures that all the files you were editing will be reloaded the next time you start Emacs from the same directory and that points will be set where you left them.  If you save a desktop file in your home directory it will act as a default desktop when you start Emacs from a directory that doesn't have its own.  I never do this, but you may want to.

Some words on minor modes: Most minor modes are controlled by buffer-local variables, which have a standard save / restore mechanism.  To handle all minor modes, we take the following approach: (1) check whether the variable name from minor-mode-alist is also a function; and (2) use translation table desktop-minor-mode-table in the case where the two names are not the same.

By the way: don't use desktop.el to customize Emacs -- the standard XEmacs initialization file is used for that.  Saving global default values for buffers is an example of misuse.

PLEASE NOTE: The kill ring can be saved as specified by the variable desktop-globals-to-save (by default it isn't).  This may result in saving things you did not mean to keep.  Use M-x desktop-clear RET.

To configure this package, type:

       M-x customize-group RET desktop RET

Recent File Navigation
**********************

To install recent-files, put the following statements into your initialization file

       (recent-files-initialize)

recent-files adds the menu "Recent Files" (or whatever name you choose, (see Customization) to Emacs's menubar. Its entries are the files (and directories) that have recently been opened by Emacs. You can open one of these files again by selecting its entry in the "Recent Files" menu. The list of file entries in this menu is preserved from one Emacs session to another. You can prevent Emacs from saving this list by selecting "Don't save recent-files list on exit" from the menu. If you have disabled saving, you can re-enable it by selecting "Save recent-files list on exit".

The menu has permanent and non-permanent entries. Permanent entries are marked with an asterisk in front of the filename. The non-permanent entries are hidden in a submenu.

Each time you open a file in Emacs, it is added as a non-permanent entry to the menu. The value of recent-files-number-of-entries determines how many non-permanent entries are held in the menu. When the number of non-permanent entries reaches this value, the least recently added non-permanent entry is removed from the menu when another non-permanent entry is added. It is not removed from the list, though; it may reappear when entries are deleted from the list. The number of entries saved to disk is the value of the variable recent-files-number-of-saved-entries.

Permanent entries are not removed from the menu. You can make a file entry permanent by selecting "Make <buffer> permanent" (where <buffer> is the name of the current buffer) when the current buffer holds this file. "Make <buffer> non-permanent" makes the file entry of the current buffer non-permanent.

The command "Kill buffer <buffer> and delete entry" is handy when you have accidentally opened a file but want to keep neither the buffer nor the entry.

You can erase the list of non-permanent entries by selecting "Erase non-permanent entries" from the menu.

Customization
=============

There are lots of variables to control the behaviour of recent-files. You do not have to change any of them if you like it as it comes out of the box. However, you may want to look at these options to make it behave different.

recent-files-number-of-entries
     Controls how many non-permanent entries are shown in the recent-files list.  The default is 15.

recent-files-number-of-saved-entries
     Controls how many non-permanent entries are saved to disk when Emacs exits or recent-files-save-the-list is called. The default is 50.

recent-files-save-file
     The name of the file where the recent-files list is saved between Emacs session. You probably don't need to change this. The default is ".recent-files.el" in your home directory.

recent-files-dont-include
     A list of regular expressions for files that should not be included into the recent-files list. This list is empty by default. For instance, a list to exclude all .newsrc files, all auto-save-files, and all files in the /tmp directory (but not the /tmp directory itself) would look like this:

            (setq recent-files-dont-include
                  '("/\\.newsrc" "~$" "^/tmp/."))

     The default is empty.

recent-files-use-full-names
     If the value of this variable is non-nil, the full pathnames of the files are shown in the recent-files menu. Otherwise only the filename part (or the last name component if it is a directory) is shown in the menu. The default it t, i.e. show full names.

recent-files-filename-replacements
     This is a list of pairs of regular expressions and replacement strings. If a filename matches one of the regular expressions, the matching part is replaced by the replacement string for display in the recent-files menu. Example: My home directory is "/users/mmc/nickel/". I want to replace it with "~/". I also want to replace the directory "/imports/teleservices/mmc/avc2/", where I work a lot, with ".../avc2/". The list then looks like

            (setq recent-files-filename-replacements
                  '(("/users/mmc/nickel/" . "~/")
                    ("/imports/teleservices/mmc/avc2/" . ".../avc2/")))

     Only the first match is replaced. So, if you have several entries in this list that may match a filename simultaneously, put the one you want to match (usually the most special) in front of the others. The default is to replace the home directory with "~".

recent-files-sort-function
     Contains a function symbol to sort the display of filenames in the recent-files menu. Supplied are two functions, recent-files-dont-sort and recent-files-sort-alphabetically. The first, which is the default, preserves the order of "most recent on top".

recent-files-permanent-submenu
     If this variable is non-nil, the permanent entries are put into a separate submenu of the recent-files menu. The default is nil.

recent-files-non-permanent-submenu
     If this variable is non-nil, the non-permanent entries are put into a separate submenu of the recent-files menu. The default is currently t, but probably should be nil, and we may change it back. (You can set both recent-files-permanent-submenu and recent-files-non-permanent-submenu to t to have both lists in separate submenus.)

recent-files-commands-submenu
     If this variable is non-nil, the commands if recent-files are placed in a submenu of the recent-files menu. The default is nil.

recent-files-commands-submenu-title
     If the commands are placed in a submenu, this string is used as the title of the submenu. The default is "Commands...".

recent-files-actions-on-top
     If this variable is non-nil, the "action" menu entries ("Make <buffer> permanent" etc.) are put on top of the menu. Otherwise they appear below the file entries or submenus. The default is nil.

recent-files-permanent-first
     If this variable is t, the permanent entries are put first in the recent-files menu, i.e. above the non-permanent entries. If the value is nil, non-permanent entries appear first. If the value is neither t nor nil, the entries are sorted according to recent-files-sort-function. The default is 'sort.

recent-files-find-file-command
     This variable contains the command to execute when a file entry is selected from the menu. Usually this will be find-file, which is the default.

Resuming a Suspended Emacs Job
******************************

This library not documented.  Please contribute!

Save Buffer/Window Configuration Between Sessions
*************************************************

This package of functions gives Emacs the ability to remember which files were being visited, the windows that were on them, and the value of point in their buffers the last Emacs session in the same directory.  This is an emulation of an old Gosling Emacs feature.

The relevant commands are save-context and recover-context.

Most of the time you'll want an Emacs session's context saved even if you choose not to recover it later.  To avoid having to manually M-x save-context at each emacs exit, put the line:

       (setq auto-save-and-recover-context t)

in your initialization file or in default.el in the lisp directory of the Emacs distribution.  The context will then automatically be saved when Emacs exits.

By default only the contexts of visible buffers (buffers with windows on them) are saved.  Setting the variable save-buffer-context to t causes the contexts of all buffers to be saved.

To use the package put these lines

       (require 'saveconf)
       (if (null (cdr command-line-args))
           (setq inihibit-startup-message (recover-context)))

at the end of your initialization file or the default.el file in the lisp directory of the Emacs distribution.  This causes the context saved in the current directory to be recovered whenever Emacs is invoked without any arguments.

Save Minibuffer History
***********************

Many editors (e.g. Vim) have the feature of saving minibuffer history to an external file after exit.  This package provides the same feature in Emacs. When Emacs is about the exit, savehist-save will dump the contents of various minibuffer histories (as determined by savehist-history-variables) to a save file (~/.emacs-history by default).  Although the package was designed for saving the minibuffer histories, any variables can be saved that way.

To use savehist, put the following in your initialization file:

       (savehist-load)

To configure this package, type:

       M-x customize-group RET savehist RET

Automatically Save Place in Files
*********************************

Automatically save place in files, so that visiting them later (even during a different Emacs session) automatically moves point to the saved position, when the file is first found.  Uses the value of buffer-local variable save-place to determine whether to save position or not.

To use this package, put the following in your initialization file:

       (require 'saveplace)

To configure this package, type:

       M-x customize-group RET saveplace RET

Keep Persistent State in Visited Files
**************************************

This library will make XEmacs keep track of where you were last time you visited a file.  It hopes to become a standard and favored XEmacs feature on setups with Berkeley DB installed.

It works by installing functions on the find-file-hooks and on the buffer-local kill-buffer-hook.  When a buffer is killed, if it was visiting a file, and place saving has been enabled for it, a database entry is made, saving the location of point.  When you visit a file, the database is queried, keyed on buffer-file-name, and if an entry is found, point is set to the value retrieved, and place saving is enabled again for that buffer.

There is a command, which is initially not bound to a keystroke in this incarnation; and may never be, since I think completion works well enough:

       M-x toggle-where-was-i

which, using auto-completion, can be entered as

       M-x tog TAB w TAB

that will turn place saving on and off on a per-file, buffer- local basis. If where-was-i-db has been turned off in a buffer and then you kill it, or exit XEmacs, any record for that file will be purged from the database, and you'll start at the top of the file next time you open it, with place saving turned off there.

Place saving is automatically still `on' when you visit a file you'd toggled it on for in a previous session or visitation.  (That's the point of it, after all.)

Toggling place saving on in a buffer visiting a file is all that is required to cause the where-was-i-db feature to be autoloaded, as toggle-where-was-i will call on install-where-was-i if the `wwi-ffh' has not yet been installed.  That WILL NOT cause this feature to be automatically enabled in your next XEmacs invocation, however.  For that, you must customize and save wwi-auto-install-on-startup-flag.  There is more information about this in its docstring.

This feature can be unloaded with:

       C-u M-x install-where-was-i

which will call unload-feature, as well as traverse the buffer-list removing the buffer-local kill-buffer-hook installed by this program.  Note that any buffers that got place saving enabled by having had an entry in the database for them when they were first visited (thus restoring point to where it was the last time you had visited the file), will not have an updated entry made, nor the old entry removed (as would happen if you toggle-where-was-i to off in just that buffer), after you uninstall this feature like that.

If you toggle it on again in a buffer visiting a file, then kill that buffer, the point will be saved for it.  When you kill the other buffers that had place saving enabled before you uninstalled the feature with C-u M-x install-where-was-i, no where-was-i-db database update will happen for them, since their buffer-local kill-buffer-hook will have been cleaned of the member wwi-save-where-i-am, the function that writes the point entry to the database when a buffer is killed.  If you then re-visit one of those files, point will get restored to the location it did the last time you visited that file with where-was-i-db installed.

To remove a file from the place saving database, simply visit it, M-x toggle-where-was-i to switch where-was-i-db off, then kill that buffer.  You can see how this works by looking at the definition of wwi-save-where-i-am.

After a period of time, the database of saved file positions will become cluttered with the names of files that no longer exist.  You may vacume out the crumbs using:

       M-x wwi-vacume-where-was-i-db

which will prompt you for an optional regular expression to match files you want records removed for.  It will traverse the database and remove entries for file names that either match the regexp, or that are (not (file-exists-p file-name)). The main reason for this command is the removal of stale entries, for files that no longer exist on the filesystem.

Note also that running wwi-vacume-where-was-i-db will cause EFS traffic, if you've saved your place in any remote files.  Don't be surprised if your dialing daemon picks up the phone when you run the vacume function. You should be able to purge the database of all EFS entries with a simple regular expression passed to wwi-vacume-where-was-i-db.  Of course, you might not want to do that, for obvious reasons.

To configure this package, type:

       M-x customize-group RET where-was-i RET

Completion
**********

To load this package, add the following to your initialization file:

       (require 'completion)

After you type a few characters, pressing the "complete" key inserts the rest of the word you are likely to type.

This watches all the words that you type and remembers them.  When typing a new word, pressing "complete" (C-return) "completes" the word by inserting the most recently used word that begins with the same characters. If you press meta-return repeatedly, it cycles through all the words it knows about.

If you like the completion then just continue typing, it is as if you entered the text by hand.  If you want the inserted extra characters to go away, type C-w or delete.  More options are described below.

The guesses are made in the order of the most recently "used".  Typing in a word and then typing a separator character (such as a space) "uses" the word. So does moving a cursor over the word.  If no words are found, it uses an extended version of dynamic abbreviation see dabbrev.

Completions are automatically saved to a file between sessions.

Completion enables programmers to enter longer, more descriptive variable names while typing fewer keystrokes than they normally would.

To configure this package, type:

       M-x customize-group RET completion RET

Dynamic Abbreviations
*********************

The purpose with this package is to let you write just a few characters of words you've written earlier to be able to expand them.

To expand a word, just put the point right after the word and press M-/ (dabbrev-expand) or M-C-/ (dabbrev-completion).

Check out the customizable variables to learn about all the features of this package.

To configure this package, type:

       M-x customize-group RET dabbrev RET

Hippie Expand
*************

hippie-expand is a single function for a lot of different kinds of completions and expansions.  Called repeatedly it tries all possible completions in succession.  Which kinds of completions to try, and in which order, is determined by the contents of hippie-expand-try-functions-list.  Much customization of hippie-expand can be made by changing the order of, removing, or inserting new functions in this list.  Given a positive numeric argument, hippie-expand jumps directly ARG functions forward in this list. Given some other argument (a negative argument or just C-u) it undoes the tried completion.

If the variable hippie-expand-verbose is non-nil, hippie-expand outputs in a message which try-function in the list that is used currently (ie. was used currently and will be tried first the next time).

The variable hippie-expand-max-buffers determines in how many buffers, apart from the current, to search for expansions in.  It is used by the try-functions named "-all-buffers".  The variable hippie-expand-ignore-buffers is a list of regexps matching buffer names (as strings) or major modes (as atoms) of buffers that should not be searched by the try-functions named "-all-buffers".  See also the macro make-hippie-expand-function below.

A short description of the current try-functions in this file:

try-complete-file-name
     Very convenient to have in any buffer, and not just in the minibuffer or (some) shell-mode.  It goes through all possible completions instead of just completing as much as is unique.

try-complete-file-name-partially
     To insert in the list just before try-complete-file-name for those who want first to get a file name completed only as many characters as is unique.

try-expand-all-abbrevs
     Can be removed if you don't use abbrevs.  Otherwise it looks through all abbrev-tables, starting with the local followed by the global.

try-expand-line
     Searches the buffer for an entire line that begins exactly as the current line.  Convenient sometimes, for example as a substitute for (or complement to) the history list in shell-like buffers.  At other times, only confusing.

try-expand-line-all-buffers
     Like try-expand-line but searches in all buffers (except the current). (This may be a little slow, don't use it unless you are really fond of hippie-expand.)

`try-expand-list
     Tries to expand the text back to the nearest open delimiter, to a whole list from the buffer. Convenient for example when writing lisp or TeX.

try-expand-list-all-buffers
     Like try-expand-list but searches in all buffers (except the current).

try-expand-dabbrev
     Works exactly as dabbrev-expand (but of course in a way compatible with the other try-functions).

try-expand-dabbrev-all-buffers
     Perhaps the most useful of them, like dabbrev-expand but searches all Emacs buffers (except the current) for matching words.  (No, I don't find this one particularly slow.)

try-expand-dabbrev-visible
     Searches the currently visible parts of all windows.  Can be put before try-expand-dabbrev-all-buffers to first try the expansions you can see.

try-expand-dabbrev-from-kill
     Searches the kill ring for a suitable completion of the word.  Good to have, just in case the word was not found elsewhere.

try-expand-whole-kill
     Tries to complete text with a whole entry from the kill ring.  May be good if you don't know how far up in the kill-ring the required entry is, and don't want to mess with "Choose Next Paste".

try-complete-lisp-symbol
     Like lisp-complete-symbol, but goes through all possibilities instead of completing what is unique.  Might be tedious (usually a lot of possible completions) and since its function is much like lisp-complete-symbol, which already has a key of its own, you might want to remove this.

try-complete-lisp-symbol-partially
     To insert in the list just before try-complete-lisp-symbol for those who first want to get completion of what is unique in the name.

Not all of the above functions are by default in hippie-expand-try-functions-list.  This variable is better set in your initialization file to make hippie-expand behave maximally convenient according to personal taste.  Also, instead of loading the variable with all kinds of try-functions above, it might be an idea to use make-hippie-expand-function to construct different hippie-expand-like functions, with different try-lists and bound to different keys. It is also possible to make hippie-expand-try-functions-list a buffer local variable, and let it depend on the mode (by setting it in the mode-hooks).

Interactive Minibuffer Completion
*********************************

Loading this package implements a more fine-grained minibuffer completion feedback scheme.  Prospective completions are concisely indicated within the minibuffer itself, with each successive keystroke.

See icomplete-completions docstring for a description of the icomplete display format.

See the icomplete-minibuffer-setup-hook docstring for a means to customize icomplete setup for interoperation with other minibuffer-oriented packages.

To activate icomplete mode, load the package and use the icomplete-mode function.  You can subsequently deactivate it by invoking the function icomplete-mode with a negative prefix-arg (C-U -1 ESC-x icomplete-mode).  Also, you can prevent activation of the mode during package load by first setting the variable icomplete-mode to nil.  Icompletion can be enabled any time after the package is loaded by invoking icomplete-mode without a prefix arg.

To configure this package, type:

       M-x customize-group RET icomplete RET

Flexible Template Insertion
***************************

This file provides a simple way to define powerful templates, or macros, if you wish. It is mainly intended for, but not limited to, other programmers to be used for creating shortcuts for editing certain kind of documents. It was originally written to be used by a HTML editing mode written by Nelson Minar <nelson@santafe.edu>, and his html-helper-mode.el is probably the best example of how to use this program.

A template is defined as a list of items to be inserted in the current buffer at point. Some of the items can be simple strings, while other can control formatting or define special points of interest in the inserted text.

If a template defines a "point of interest" that point is inserted in a buffer-local list of "points of interest" that the user can jump between with the commands tempo-backward-mark and tempo-forward-mark. If the template definer provides a prompt for the point, and the variable tempo-interactive is non-nil, the user will be prompted for a string to be inserted in the buffer, using the minibuffer.

The template can also define one point to be replaced with the current region if the template command is called with a prefix (or a non-nil argument).

More flexible templates can be created by including lisp symbols, which will be evaluated as variables, or lists, which will be evaluated as lisp expressions.

See the documentation for tempo-define-template for the different items that can be used to define a tempo template.

One of the more powerful features of tempo templates are automatic completion. With every template can be assigned a special tag that should be recognized by tempo-complete-tag and expanded to the complete template. By default the tags are added to a global list of template tags, and are matched against the last word before point. But if you assign your tags to a specific list, you can also specify another method for matching text in the buffer against the tags. In the HTML mode, for instance, the tags are matched against the text between the last `<' and point.

When defining a template named foo, a symbol named tempo-template-foo will be created whose value as a variable will be the template definition, and its function value will be an interactive function that inserts the template at the point.

To configure this package, type:

       M-x customize-group RET tempo RET

Move Mouse Pointer Out of the Way of Editing
********************************************

For those who are annoyed by the mouse pointer obscuring text, this mode moves the mouse pointer - either just a little out of the way, or all the way to the corner of the frame.  To use, type M-x mouse-avoidance-mode. To set up permanently, add the following to your initialization file:

       (if window-system (mouse-avoidance-mode 'animate))

The 'animate can be 'jump or 'banish or 'exile or 'protean if you prefer.  See the documentation for function mouse-avoidance-mode for details of the different modes.

For added silliness, make the animatee animate by put something similar to the following into your initialization file:

       (if window-system
           (mouse-avoidance-set-pointer-shape
            (eval (nth (random 4)
                       '(x-pointer-man x-pointer-spider
                                       x-pointer-gobbler x-pointer-gumby)))))

For completely random pointer shape, replace the setq above with (setq x-pointer-shape (mouse-avoidance-random-shape)).

To configure this package, type:

       M-x customize-group RET avoid RET

Blinking Cursor
***************

To activate this package, type:

       M-x blink-cursor-mode RET

To configure this package, type:

       M-x customize-group RET blink-cursor RET

Speeding Up Font Lock Mode
**************************

Lazy Lock mode is a Font Lock support mode.  It makes visiting a file in Font Lock mode faster by restoring its face text properties from automatically saved associated Font Lock cache files.

See also the lazy-lock package.  (But don't use the two at the same time!)

To use this package, add the following to your initialization file:

       (setq font-lock-support-mode 'fast-lock-mode)

Start up a new Emacs and use font-lock as usual (except that you can use the so-called "gaudier" fontification regexps on big files without frustration).

When you visit a file (which has font-lock-mode enabled) that has a corresponding Font Lock cache file associated with it, the Font Lock cache will be loaded from that file instead of being generated by Font Lock code.

To configure this package, type:

       M-x customize-group RET fast-lock RET

Lazy Demand-Driven Fontification
********************************

The purpose of this library is to make visiting buffers in font-lock-mode faster by making fontification demand-driven and stealthy.  Fontification only occurs when, and where, necessary.

See also the fast-lock and lazy-shot packages.  (But don't use them at the same time as lazy-lock!)

To use this package, add the following to your initialization file:

       (setq font-lock-support-mode 'lazy-lock-mode)

Start up a new XEmacs and use font-lock as usual (except that you can use the so-called "gaudier" fontification regexps on big files without frustration).

In a buffer (which has font-lock-mode enabled) which is at least lazy-lock-minimum-size characters long, only the visible portion of the buffer will be fontified.  Motion around the buffer will fontify those visible portions that were not previous fontified.

If stealth fontification is enabled, fontification will occur in invisible parts of the buffer after lazy-lock-stealth-time seconds of idle time.

To configure this package, type:

       M-x customize-group RET lazy-lock RET

Another Lazy Demand-Driven Fontification
****************************************

This is an experimental demand based font-lock implementation.  It is experimental in the sense that it relies on C support from the redisplay engine, that is experimental.  The code in this file is more or less finished.  The C code support experimental because the current design is rumoured to be ugly.  Secondly because XEmacs does actually display the "un-font-locked" parts of the buffer first, the user notices flashing as the buffer is repainted with color/fonts.

To use this package, add the following to your initialization file:

       (add-hook 'font-lock-mode-hook 'turn-on-lazy-shot)

Do not use in combination with lazy-lock.

       M-x customize-group RET lazy-shot RET

Advanced Highlighting of Matching Parentheses
*********************************************

Load this file, activate it and Emacs will display highlighting on whatever parenthesis (and paired delimiter if you like this) matches the one before or after point. This is an extension to the paren.el file distributed with Emacs. The default behaviour is similar to paren.el but more sophisticated. Normally you can try all default settings to enjoy mic-paren.

Or - if you are a LaTeX writer like the current maintainer - try the following additional setup in your initialization file:

       ;; In LaTeX-mode we want this
       (add-hook 'LaTeX-mode-hook
                 (function (lambda ()
                             (paren-toggle-matching-quoted-paren 1)
                             (paren-toggle-matching-paired-delimiter 1))))

Or - if you are programming in C like languages - try also:

       (add-hook 'c-mode-common-hook
                 (function (lambda ()
                              (paren-toggle-open-paren-context 1))))

mic-paren.el is an extension and replacement to the packages paren.el and stig-paren.el for Emacs. When mic-paren is active Emacs normal parenthesis matching is deactivated. Instead parenthesis matching will be performed as soon as the cursor is positioned at a parenthesis. The matching parenthesis (or the entire expression between the parentheses) is highlighted until the cursor is moved away from the parenthesis.

Features include:

  * Both forward and backward parenthesis matching (simultaneously if cursor is between two expressions).

  * Indication of mismatched parentheses.

  * Recognition of "escaped" (also often called "quoted") parentheses.

  * Option to match "escaped" parens too, especially in (La)TeX-mode (e.g. matches expressions like "\(foo bar\)" properly).

  * Offers two functions as replacement for forward-sexp and backward-sexp which handle properly quoted parens (s.a.). These new functions can automatically be bounded to the original binding of the standard forward-sexp and backward-sexp functions.

  * Option to activate matching of paired delimiter (i.e. characters with syntax '$'). This is useful for writing in LaTeX-mode for example.

  * Option to select in which situations (always, never, if match, if mismatch) the entire expression should be highlighted or only the matching parenthesis.

  * Message describing the match when the matching parenthesis is off-screen (vertical and/or horizontal). Message contains either the linenumber or the number of lines between the two matching parens. Option to select in which cases this message should be displayed.

  * Optional delayed highlighting (useful on slow systems),

  * Functions to activate/deactivate mic-paren.el are provided.

  * Numerous options to control the behaviour and appearance of mic-paren.el.

To configure this package, type:

       M-x customize-group RET mic-paren-matching RET

Highlight (Un)matching Parens and Whole Expressions
***************************************************

This package highlights matching parens (or whole sexps) for easier editing of source code, particularly lisp source code.

The paren-highlight hook function runs after each command and checks to see if the cursor is at a parenthesis.  If so, then it highlights, in one of several ways, the matching parenthesis.

Priority is given to matching parentheses right before the cursor because that's what makes sense when you're typing a lot of closed parentheses.  This is especially intuitive if you frequently use forward-sexp (M-C-f) and backward-sexp (M-C-b) to maneuver around in source code.

Different faces are used for matching and mismatching parens so that it is easier to see mistakes as you type them.  Audible feedback is optional.

If a (mis)matching paren is offscreen, then a message is sent to the modeline.

If paren-mode is sexp, entire S-expressions are highlighted instead of just matching parens.

To configure this package, type:

       M-x customize-group RET paren-matching RET

Decorate a Shell Buffer With Fonts
**********************************

Do this: (add-hook 'shell-mode-hook 'install-shell-fonts) and the prompt in your shell-buffers will appear bold-italic, process output will appear in normal face, and typein will appear in bold.

The faces shell-prompt, shell-input and shell-output can be modified as desired, for example, (copy-face 'italic 'shell-prompt).

Highlight the Current Line in the Buffer
****************************************

This package is a minor mode to highlight the current line in buffer.

The mode supports the following modes of operation:

  * LOCAL highline

  * GLOBAL highline

  * INDIRECT highline

Both Local and Global minor modes may be in use at the same time.

Indirect highline (highline-view-on, highline-view-off and highline-view-mode) is useful when you wish to have various "visions" of the same buffer.  Indirect highline uses an indirect buffer to get the "vision" of the buffer.  So, if you kill an indirect buffer, the base buffer is not affected; if you kill the base buffer, all indirect buffer related with the base buffer is automagically killed.  Also, any text insertion/deletion in any indirect or base buffer is updated in all related buffers.

Key Bindings and Example Usage
==============================

It might be useful to set up some global key bindings as follows:

       (global-set-key "\C-c\C-a"     'highline-on)
       (global-set-key "\C-c\C-b"     'highline-off)
       (global-set-key "\C-c\C-l"     'highline-local-mode)
       (global-set-key "\C-c\C-d"     'highline-mode-on)
       (global-set-key "\C-c\C-e"     'highline-mode-off)
       (global-set-key "\C-c\C-g"     'highline-mode)
       (global-set-key "\C-c\C-c"     'highline-customize)
       (global-set-key "\C-c\C-v\C-n" 'highline-view-on)
       (global-set-key "\C-c\C-v\C-f" 'highline-view-off)
       (global-set-key "\C-c\C-v\C-t" 'highline-view-mode)

As an example, try to insert this in your .emacs file:

       (require 'highline)
       ;; Turn on local highlighting for Dired (C-x d)
       (add-hook 'dired-after-readin-hook 'highline-on)
       ;; Turn on local highlighting for list-buffers (C-x C-b)
       (defadvice list-buffers (after highlight-line activate)
         (save-excursion
           (set-buffer "*Buffer List*")
           (highline-on)))

Hooks
=====

highline has the following hook variables:

highline-hook
     It is evaluated always when highline is turned on globally.

highline-local-hook
     It is evaluated always when highline is turned on locally.

highline-view-hook
     It is evaluated always when indirect highline is turned on.

highline-load-hook
     It is evaluated after highline package is loaded.

Options
=======

This is a brief description of highline options.  Please see the options declarations in the code for more detail.

highline-face
     Specify face used to highlight the current line.

highline-vertical-face
     Specify face used to highlight other than current line.

highline-line
     Specify which part of line should be highlighted.

highline-vertical
     Specify how many vertical lines should be highlighted.

highline-verbose
     Non-nil means generate messages.

highline-ignore-regexp
     Specify regexp for buffers to ignore.

highline-priority
     Specify highline overlay priority.

highline-selected-window
     Non-nil means highlight current line on	current window.

To configure this package, type:

       M-x highline-customize RET

Buffer colors provides an easy interface to implementing buffer-local default color schemes. This can be used automatically based on mode or filename extension (for instance, all .c-files could be lime green on black, and all .h files could be amber on black) or manually settable. An option is provided for defining additional custom color schemes, and defining the buffer-colors by window instead of buffer. All configuration can be done through the buffer-colors customize group.

Hooks Invoked After Saving a File
*********************************

Set up a list of file-name matching regular expressions associated with shell commands or lisp forms to run after saving the file.

This is good for things like running newaliases(1) on /etc/aliases, xrdb(1) on ~/.Xresources, installing a new ~/.crontab, as well as for sending signals to daemons whose configuration files you've just finished editing.

It is much safer and more powerful than using exec statements in "Local Variables" sections, and can safely be used by root for system administration tasks.  The shell command can run about anything you can think of.

See variable After-save-alist for more information.

Indivisible Blocks of Text
**************************

Point is not allowed to fall inside of an atomic extent.  This has the effect of making all text covered by an atomic extent be treated as a single object. Normally point will be adjusted to an end of an atomic extent in the direction of motion.  If point appears inside of an atomic extent (via goto-char for example), point will be adjusted to the side closest to the entry point.

To make this feature available, add the following to your initialization file:

       (require 'atomic-extents)

To make an extent atomic use the command:

       (set-extent-property #<extent obj> 'atomic t)

Table and Array Editor
**********************

Commands for editing a buffer interpreted as a rectangular array or matrix of whitespace-separated strings.  You specify the array dimensions and some other parameters at startup time.

Floating Toolbar
****************

The command floating-toolbar pops up a small frame containing a toolbar.  The command should be bound to a button-press event.  If the mouse press happens over an extent that has a non-nil 'floating-toolbar property, the value of that property is the toolbar instantiator that will be displayed.  Otherwise the toolbar displayed is taken from the variable floating-toolbar.  This variable can be made buffer local to produce buffer local floating toolbars.

floating-toolbar-or-popup-mode-menu works like floating-toolbar except that if no toolbar is found, popup-mode-menu is called.

floating-toolbar-from-extent-or-popup-mode-menu works like floating-toolbar-or-popup-mode-menu except only extent local toolbars are used; the value of floating-toolbar is not used.

Add the following line to your initialization file:

       (require 'floating-toolbar)

You will also need to bind a mouse click to floating-toolbar or to floating-toolbar-or-popup-mode-menu.

The Toolbar Utilities
*********************

The toolbar utilities are a set of Emacs commands and Lisp functions for convenient creation and management of toolbars.  Common usages such as creating and adding toolbar buttons to invoke commands and keyboard macros are implemented as user commands.  Convenience APIs are provided to create buttons, add them to toolbars, kill them from toolbars, and finding a particular button, or a button with certain content, in a toolbar.

The toolbar utilities are implemented in three files:

toolbar-utils.el

     The toolbar utility APIs and user commands.

edit-toolbar.el

     The near-WYSIWYG toolbar editor by Peter D. Pezaris.

xemacs-toolbar.el

     The XEmacs compatibility API for programs that should also run under GNU Emacs.

The author would like to thank Jeff Miller and Peter D. Pezaris for the original API and the toolbar editor, respectively, and David Kastrup and Jamie Zawinski for the pedal-gluteal impetus that resulted in the recent revision of these libraries described in this manual.

Adding Buttons on the Fly
=========================

 -- Group: edit-toolbar

     Customize group of tools for interactive editing and non-interactive management of toolbars.

 -- Variable: toolbar-button-default-position
     Default position for adding toolbar buttons on the fly.  The value may be a non-negative integer (0 is leftmost), or one of the symbols left, right, or extreme-right.  left is synonymous with 0, and extreme-right is synonymous with (length toolbar). right specifies placing a new item at the right end of the flush-left group of buttons.

     Default value: right.  Customize type: sexp.

     See also toolbar-add-button, APIs for Adding and Killing.

 -- Command: toolbar-add-button-on-the-fly description command label &optional position locale

     Add an button at POSITION to the default toolbar of the selected window.  Returns t.

     The return value may change.  Tell stephen@xemacs.org what value you think would be (most) useful.

     description
          A string describing the action, and displayed as help.

     command
          An interactive command (ie, a symbol with an interactive function definition) implementing the action.

     label
          A string used to label the button.

     position
          Optional.  A position (a non-negative integer, or one of the symbols left, right, or extreme-right.

          Default: right.

     locale
          Optional.  A specifier locale, defaulting to the current buffer.  If current-buffer-only is not what you want, and you don't understand specifier locales, use global.  It's safe and probably does what you want.

 -- Command: toolbar-add-kbd-macro mac icon is-file
     Add a button invoking a keyboard macro to the toolbar. The button is added at the end of the left group.

     mac
          A keyboard macro name, or the empty string or nil to use a copy of the last keyboard macro defined.

     icon
          A string specifying the icon to be used.  If IS-FILE is non-nil, it is interpreted as the name of an image file, and searched for using locate-data-file.  Otherwise it is used verbatim as a label.

     is-file
          Determines the treatment of ICON (q.v.).

     Used interactively, prompts for the macro name MAC and an ICON.  IS-FILE is non-nil if a prefix argument was used.

 -- Function: toolbar-add-execute-macro-button

     Add a button to the global toolbar to execute the last keyboard macro.

     Unlike toolbar-add-kbd-macro, this does not copy the macro.  The macro executed will change with redefinitions.

     Due to a simple implementation, this button will not appear in buffers with local toolbars if invoked after the toolbar is installed.  If you like this button, it's probably best to invoke this function in your init file.

 -- Function: toolbar-execute-last-kbd-macro
     Toolbar thunk which executes the most recently defined keyboard macro.

 -- Command: restore-initial-toolbar
     Restores the default toolbar defined by initial-toolbar-spec.

     There is also a cache of killed buttons in button-palette.

The Toolbar Editor
==================

To use edit-toolbar.el, simply type M-x edit-toolbar RET.

For help on the various commands you can type ? in a edit-toolbar buffer.  To save a modified toolbar type C-x C-s in an edit-toolbar buffer.  If you want to use a saved toolbar in your future XEmacs sessions, add the following line of code to your init file:

       (load "~/.xemacs/.toolbar")

Here is a table of commands and bindings available in edit-toolbar-mode.  These commands are also available from the Edit Toolbar menu.

q

     edit-toolbar-quit:  Bury the edit-toolbar buffer.

p
DEL

     edit-toolbar-previous:  Select the previous item (line).

n
SPC
RET

     edit-toolbar-next:    Select the next item (line).

?

     describe-mode:  Help.

f

     edit-toolbar-set-function:  Set the command for the current button.

h

     edit-toolbar-set-help:  Set the help string for the current button.

a

     edit-toolbar-add-button:  Add a new empty button.

2

     edit-toolbar-add-separator-2D-narrow:  Add a new narrow 2D fixed-width spacer.

@

     edit-toolbar-add-separator-2D-wide:  Add a new wide 2D fixed-width spacer.

3

     edit-toolbar-add-separator-3D-narrow:  Add a new narrow 3D fixed-width spacer.

#

     edit-toolbar-add-separator-3D-wide:  Add a new wide 3D fixed-width spacer.

R

     edit-toolbar-add-separator-right-left:  Place the filler separator, which expands to create a flush-left group of buttons and spacers and a flush-right group.

c

     edit-toolbar-copy:  Copy the selected button.

d

     edit-toolbar-down:  Reorder the buttons by moving the selected button down (to the right on a horizontal toolbar).

u

     edit-toolbar-up:  Reorder the buttons by moving the selected button up (to the left on a horizontal toolbar).

k

     edit-toolbar-kill:  Kill the selected button.

s
C-x C-s

     edit-toolbar-save:  Save the current buffer to ~/.xemacs/.toolbar in a format that allows it to be reloaded.

r

     edit-toolbar-restore:  Restore the original toolbar (ie, before this editing session started).

APIs for Adding and Killing
===========================

 -- Variable: button-palette
     List of buttons cut from toolbars.

     Note this is actually a toolbar descriptor.

 -- Function: toolbar-add-item toolbar-spec item &optional position
     Add ITEM to TOOLBAR-SPEC at POSITION, and return TOOLBAR-SPEC.  Uses functions that alter list structure.

     item
          A toolbar button or spacer specification (eg, from toolbar-new-button or toolbar-new-spacer).

     toolbar-spec
          A toolbar descriptor (eg, from toolbar-new-toolbar).

     position
          Optional.  A non-negative integer, with 0 being the extreme left and \(length TOOLBAR-SPEC) the extreme right.  The symbols left, right, and extreme-right are also accepted. left is synonymous with 0.  right places ITEM at the right end of the left group of buttons.  extreme-right places ITEM at the extreme right of the toolbar, creating a right group if one does not exist.

     #### This function does not yet support inserting the group delimiter nil as an explicit item.

     POSITION may be greater than (length TOOLBAR-SPEC), in which case it is truncated to (length TOOLBAR-SPEC).  Note that (length TOOLBAR-SPEC) is not synonymous with right or extreme-right (extreme-right will create a right group if it doesn't already exist).

 -- Function: toolbar-new-button icon-spec command help-string &optional initially-disabled
     Return a checked toolbar button specification.

     icon-spec
          A list of glyphs (from make-glyph), a glyph, or a string to use as the button's icon.  If a string or single glyph, it will be used for the button-up glyph.  If a list, it may contain 1 to 6 glyphs, which XEmacs will use for button up, button down, button disabled, button up with caption, button down with caption, and button disabled with caption, in that order.  Missing or nil glyphs will be defaulted.  (#### Strings as list elements are not supported but could be.)

     command
          The (interactive) command to invoke when the button is pressed.

     help-string
          A string briefly describing the command, displayed in the echo area or as balloon help when the pointer enters the button.

     initially-disabled
          Optional.  If non-nil, specifies that the button should initially be disabled.

          See default-toolbar or the Lispref (see Toolbars (lispref)) for more information.

 -- Function: toolbar-new-spacer style &optional size
     Returns a checked toolbar spacer ``button''.

     style
          One of the symbols 2d or 3d, indicating whether the area is displayed without shadows (giving it a flat appearance), or with shadows (giving it a raised, 3-D appearance).  There is no default. #### We may set a default style.  Tell stephen@xemacs.org which you use.

     size
          Specifies the length, in pixels, of the blank area.  If omitted, it defaults to a device-specific value (8 pixels for X devices).

 -- Function: make-toolbar-instantiator &optional toolbar-spec domain
     Return a checked toolbar instantiator, a list of vectors.

     toolbar-spec
          May be a list of buttons (ie, a toolbar descriptor, see default-toolbar), a toolbar specifier object, a symbol whose value is a toolbar specifier object, or nil.  If nil, returns a null list.  If a toolbar specifier object or variable containing one, the specification for DOMAIN is used.  If non-nil, DOMAIN must be a window, a frame, or a device, otherwise it defaults to the selected window (see specifier-instance).  The list thus generated is checked and returned.

          If TOOLBAR-SPEC is a list, it is copied; it is safe to pass other packages' toolbar initializers to this function.  However, you probably do not want to change any of the objects in the returned specification. They are returned as is, not copied.

          See default-toolbar or the Lispref (see Toolbars (lispref)) for more information.

 -- Function: toolbar-kill-item-pos pos &optional toolbar locale
     Kill the item at position POS of TOOLBAR in LOCALE. Killed buttons are prepended to button-palette.

     LOCALE defaults to global.  If there are multiple specs for LOCALE, take the first one.

     This function currently does not accept symbolic positions a la toolbar-add-item.  Use toolbar-find-item to locate whole buttons and spacers, and toolbar-find-button to locate buttons by characteristics.  See also toolbar-find-button-by-icon, toolbar-find-button-by-command, and toolbar-find-button-by-help-string.

APIs for Search
===============

 -- Function: toolbar-find-button item &optional toolbar locale
     Return the position of a button containing ITEM in its specification.

     item
          May specify a button, spacer, icon, command, help string, or nil.  If ITEM is nil, find the separator between the group of buttons to be left justified, and the group to be right justified.  (Distinctions among the various ``search key types'' are somewhat heuristic but are probably reliable enough to use in library code.)

     toolbar
          If non-nil, search it; otherwise search the default toolbar.

     locale
          If non-nil, get TOOLBAR's descriptor in that locale, otherwise use the global locale.

 -- Function: toolbar-find-item item &optional toolbar locale
     Return the position of ITEM, a button, spacer, or nil. TOOLBAR and LOCALE determine the descriptor to be searched.

     If ITEM is nil, find the separator between the group of buttons to be left justified, and the group to be right justified.  If there are several matching items, the first is returned.  If none is found, return nil.

 -- Function: toolbar-find-button-by-icon icon &optional toolbar locale
     Return the position of a button with icon ICON. ICON must be a list of glyphs or a symbols whose value is a list of glyphs. TOOLBAR and LOCALE determine the descriptor to be searched.

     If there are several matching buttons, the first is returned.

 -- Function: toolbar-find-button-by-command cmd &optional toolbar locale
     Return the position of a button invoking command CMD.  TOOLBAR and LOCALE determine the descriptor to be searched.

     If there are several matching buttons, the first is returned.

 -- Function: toolbar-find-button-by-help-string str &optional toolbar locale

     Return the position of a button with help-string STR. TOOLBAR and LOCALE determine the descriptor to be searched.

     If there are several matching buttons, the first is returned. This function will not find spacers.

 -- Function: toolbar-find-button-by-element object index toolbar locale &optional thunk
     Return the position of a button containing OBJECT in element INDEX.  TOOLBAR and LOCALE determine the descriptor to be searched.

     Optional argument THUNK is a function of one argument which is used to normalize OBJECT for comparison.

     If there are several matching buttons, the first is returned. This function will not find spacers.

Toolbar API Portability to GNU Emacs
====================================

The xemacs-toolbar.el library provides XEmacs toolbar compatibility functions for GNU Emacs.

Third-party maintainers may use the same APIs in GNU Emacs as in XEmacs. Simply provide this library with your own code, and load it conditionally:

       (if (featurep 'xemacs)
           (require 'toolbar-utils)
         (require 'toolbar-utils "xemacs-toolbar"))

XEmacs features that are not present in GNU Emacs will be ignored, and various arguments with different semantics will be defaulted appropriately.

User commands such as toolbar-add-kbd-macro and advanced features such as the toolbar editor and the button cache are not presently provided.

Folding Extensions for Outline-Mode
***********************************

This file provides folding editor extensions for outline-mode and outline-minor-mode buffers.  What's a "folding editor"?  Read on...

Imagine you're in an outline-mode buffer and you've hidden all the text and subheadings under your level-1 headings.  You now want to look at the stuff hidden under one of these headings.  Normally you'd do C-c C-e (show-entry) to expose the body or C-c C-i to expose the child (level-2) headings.

With foldout, you do C-c C-z (foldout-zoom-subtree).  This exposes the body and child subheadings and narrows the buffer so that only the level-1 heading, the body and the level-2 headings are visible.  If you now want to look under one of the level-2 headings, position the cursor on it and do C-c C-z again.  This exposes the level-2 body and its level-3 child subheadings and narrows the buffer again.  You can keep on zooming in on successive subheadings as much as you like.  A string in the modeline tells you how deep you've gone.

When zooming in on a heading you might only want to see the child subheadings.  You do this by specifying a numeric argument: C-u C-c C-z. You can specify the number of levels of children too (c.f. show-children): e.g. M-2 C-c C-z exposes two levels of child subheadings.  Alternatively, you might only be interested in the body.  You do this by specifying a negative argument: M-- C-c C-z.  You can also cause the whole subtree to be expanded, similar to C-c C-s (show-subtree), by specifying a zero argument: M-0 C-c C-z.

While you're zoomed in you can still use outline-mode's exposure and hiding functions.  It won't upset foldout at all.  Also, since the buffer is narrowed, "global" editing actions will only affect the stuff under the zoomed-in heading.  This is useful for restricting changes to a particular chapter or section of your document.

You unzoom (exit) a fold by doing C-c C-x (foldout-exit-fold). This hides all the text and subheadings under the top-level heading and returns you to the previous view of the buffer.  Specifying a numeric argument exits that many folds.  Specifying a zero argument exits *all* folds.

You might want to exit a fold *without* hiding the text and subheadings.  You do this by specifying a negative argument.  For example, M--2 C-c C-x exits two folds and leaves the text and subheadings exposed.

Foldout also provides mouse bindings for entering and exiting folds and for showing and hiding text.  Hold down Meta and Control, then click a mouse button as follows:-

  * mouse-1 (foldout-mouse-zoom) zooms in on the heading clicked on:

       - single click -- expose body

       - double click -- expose subheadings

       - triple click -- expose body and subheadings

       - quad click -- expose entire subtree

  * mouse-2 (foldout-mouse-show) exposes text under the heading clicked on:

       - single click -- expose body

       - double click -- expose subheadings

       - triple click -- expose body and subheadings

       - quad click -- expose entire subtree

  * mouse-3 (foldout-mouse-hide-or-exit) hides text under the heading clicked on or exits the fold:

       - single click -- hide subtree

       - double click -- exit fold and hide text

       - triple click -- exit fold without hiding text

       - quad click -- exit all folds and hide text

You can change the modifier keys used by setting foldout-mouse-modifiers.

To use foldout, put this in your initialization file:

       (require 'foldout)

If you don't want it loaded until you need it, try this instead:

       (eval-after-load "outline" '(require 'foldout))

Jump to a Function Within a Buffer.
***********************************

Suppose you have a file with a lot of functions in it. Well, this package makes it easy to jump to any of those functions. The names of the functions in the current buffer are automatically put into a menubar menu, you select one of the function-names and the point is moved to that very function. The mark is pushed on the mark-ring, so you can easily go back to where you were. Alternatively, you can use enter the name of the desired function via the minibuffer which offers completing read input. In addition, the name of the function before point is optionally displayed in the modeline.

The following modes are supported:

Ada, Assembly, BibTex, C++, C, Dired, Ehdm, ELisp, FORTRAN, Ksh, Latex, Lelisp, Makefile, Maple, Modula2, Modula3, Outline, Objective-C, Pascal, Perl, Postscript, Prolog, PVS, Python, SGML, Scheme, Tcl, Verilog, Manual, Ruby, JavaScript

To install this package, add the following to your initialization file:

       (add-hook 'find-file-hooks 'fume-setup-buffer)
       (add-hook 'Manual-mode-hook 'turn-on-fume-mode)

Select Syntax-Driven Regions in a Buffer
****************************************

This is a radically cool, drop in mouse and keyboard-based library for selecting successively bigger syntactical regions within a buffer.  Simply load this library and you are ready to try it out by double-clicking on various kinds of characters in different buffer major modes.  You'll quickly get the hang of it.  (It also provides a command to jump between beginning and end tags within HTML and SGML buffers.)

A great deal of smarts are built-in so that it does the right thing almost all of the time; many other attempts at similar behavior such as thing.el fail to deal with many file format complexities.

Double clicks of the Selection Key (left mouse key) at the same point will select bigger and bigger regions with each successive use.  The first double click selects a region based upon the character at the point of the click. For example, with the point over an opening or closing grouping character, such as { or }, the whole grouping is selected, e.g. a C function.  When on an _ or - within a programming language variable name, the whole name is selected.  The type of selection is displayed in the minibuffer as feedback. When using a language based mainly on indenting, like Bourne shell, a double click on the first alpha character of a line, such as an if statement, selects the whole statement.

This whole package is driven by a single function, available in mouse and keyboard forms, that first marks a region based on the syntax category of the character following point.  Successive invocations mark larger and larger regions until the whole buffer is marked.  See the documentation for the function, id-select-syntactical-region, for the kinds of syntax categories handled.

Loading this package automatically installs its functionality on double-clicks (or higher) of the left mouse key.  (See the documentation for the variable, mouse-track-click-hook, for how this is done.)  A single click of the left button will remove the region and reset point.

The function, id-select-thing, may be bound to a key to provide the same syntax-driven region selection functionality. C-c C-m is a reasonable site-wide choice since this key is seldom used and it mnemonically indicates marking something.  C-c s may be preferred as a personal binding.

Use C-g to unmark the region when done.  Use, id-select-thing-with-mouse, if you want to bind this to a mouse key and thereby use single clicks instead of double clicks.

Three other commands are also provided:

id-select-and-copy-thing
     mark and copy the syntactical unit to the kill ring

id-select-and-kill-thing
     kill the syntactical unit at point

id-select-goto-matching-tag
     In HTML and SGML modes (actually any listed in the variable, `id-select-markup-modes'), moves point to the start of the tag paired with the closest tag that point is within or which it precedes, so you can quickly jump back and forth between open and close tags.

To autoload this package via mouse usage, add the following line to one of your initialization files:

       (add-hook 'mouse-track-click-hook 'id-select-double-click-hook)

To configure this package, type:

       M-x customize-group RET id-select RET

Outline-Mode Mouse Commands
***************************

Defines mouse button one to hide blocks when clicked on outline-up-arrow and expand blocks when clicked on outline-down-arrow. Features are activated when outline-minor-mode or outline-mode are turned on. There is also a menu for each glyph on mouse button 3.

To use, add the following to your initialization file:

       (require 'outl-mouse)

If you use func-menu all the time and want outl-mouse on all the time as well then specify (setq outline-sync-with-func-menu t).  Outlining will then be turned on when func-menu is activated.

If you want mac-style outlining then set outline-mac-style to t.  If you want the outline arrows on the left then set outline-glyphs-on-left to t. If you have xpm then arrows are much better defined.

To configure this package, type:

       M-x customize-group RET outl-mouse RET

Extended Page Handling Commands
*******************************

The page commands are helpful in several different contexts.  For example, programmers often divide source files into sections using the page-delimiter; you can use the pages-directory command to list the sections.

You may use the page commands to handle an address list or other small data base.  Put each address or entry on its own page.  The first line of text in each page is a `header line' and is listed by the pages-directory or pages-directory-for-addresses command.

Key Assignments
===============

The current page commands are:

forward-page         C-x ]
backward-page        C-x [
narrow-to-page       C-x p
count-lines-page     C-x l
mark-page            C-x C-p  (change this to C-x C-p C-m)
sort-pages           not bound
what-page            not bound

The new page handling commands all use C-x C-p as a prefix.  This means that the key binding for mark-page must be changed.  Otherwise, no other changes are made to the current commands or their bindings.

The extended page handling commands are:

next-page                         C-x C-p C-n
previous-page                     C-x C-p C-p
search-pages                      C-x C-p C-s
add-new-page                      C-x C-p C-a
sort-pages-buffer                 C-x C-p s
set-page-delimiter                C-x C-p C-l
pages-directory                   C-x C-p C-d
pages-directory-for-addresses     C-x C-p d
pages-directory-goto              C-c C-c

Using the Page Commands
=======================

The page commands are helpful in several different contexts.  For example, programmers often divide source files into sections using the page-delimiter; you can use the pages-directory command to list the sections.

You may change the buffer local value of the page-delimiter with the set-page-delimiter command.  This command is bound to C-x C-p C-l. The command prompts you for a new value for the page-delimiter. Called with a prefix-arg, the command resets the value of the page-delimiter to its original value.

You may set several user options:

pages-directory-buffer-narrowing-p
     Causes the pages-directory-goto command to narrow to the destination page.

pages-directory-for-adding-page-narrowing-p
     Causes the add-new-page command to narrow to the new entry.

pages-directory-for-adding-new-page-before-current-page-p
     Causes the add-new-page command to insert a new page before current page.

These variables are all true by default.

Address List or Small Database
==============================

You may use the page commands to handle an address list or other small data base.  Put each address or entry on its own page.  The first line of text in each page is a `header line' and is listed by the pages-directory or pages-directory-for-addresses command.

Specifically:

 1. Begin each entry with a `page-delimiter' (which is, by default, `^L' at the beginning of the line).

 2. The first line of text in each entry is the `heading line'; it will appear in the pages-directory-buffer which is constructed using the C-x C-p C-d (pages-directory) command or the C-x C-p d (pages-directory-for-addresses) command.

     The heading line may be on the same line as the page-delimiter or it may follow after.  It is the first non-blank line on the page.  Conventionally, the heading line is placed on the line immediately following the line containing page-delimiter.

 3. Follow the heading line with the body of the entry.  The body extends up to the next `page-delimiter'.  The body may be of any length.  It is conventional to place a blank line after the last line of the body.

For example, a file might look like this:

         FSF
         Free Software Foundation
         59 Temple Place - Suite 330
         Boston, MA 02111-1307  USA.
         (617) 542-5942
         gnu@prep.ai.mit.edu

         House Subcommittee on Intellectual Property,
         U.S. House of Representatives,
         Washington, DC  20515

         Congressional committee concerned with permitting or preventing
         monopolistic restrictions on the use of software technology.

         George Lakoff
         ``Women, Fire, and Dangerous Things:
         What Categories Reveal about the Mind''
         1987, Univ. of Chicago Press

         About philosophy, Whorfian effects, and linguistics.

         OBI   (On line text collection.)
         Open Book Initiative
         c/o Software Tool & Die
         1330 Beacon St, Brookline, MA 02146 USA
         (617) 739-0202
         obi@world.std.com

In this example, the heading lines are:

         FSF
         House Subcommittee on Intellectual Property
         George Lakoff
         OBI (On line text collection.)

The C-x C-p s (sort-pages-buffer) command sorts the entries in the buffer alphabetically.

You may use any of the page commands, including the next-page, previous-page, add-new-page, mark-page, and search-pages commands.

You may use either the C-x C-p d (pages-directory-for-addresses) or the C-x C-p C-d (pages-directory) command to construct and display a directory of all the heading lines.

In the directory, you may position the cursor over a heading line and type C-c C-c (pages-directory-goto) to go to the entry to which it refers in the pages buffer.

You can type C-c C-p C-a (add-new-page) to add a new entry in the pages buffer or address file.  This is the same command you use to add a new entry when you are in the pages buffer or address file.

If you wish, you may create several different directories, one for each different buffer.

`pages-directory-for-addresses assumes a default addresses file.  You do not need to specify the addresses file but merely type C-x C-p d from any buffer.  The command finds the file, constructs a directory for it, and switches you to the directory.  If you call the command with a prefix arg, C-u C-x C-p d, it prompts you for a file name.

You may customize the addresses commands:

pages-addresses-file-name
     Determines the name of the addresses file; by default it is "~/addresses".

pages-directory-for-addresses-goto-narrowing-p
     Determines whether pages-directory-goto narrows the addresses buffer to the entry, which it does by default.

pages-directory-for-addresses-buffer-keep-windows-p
     Determines whether pages-directory-for-addresses deletes other windows to show as many lines as possible on the screen or works in the usual Emacs manner and keeps other windows.  Default is to keep other windows.

pages-directory-for-adding-addresses-narrowing-p
     Determines whether pages-directory-for-addresses narrows the addresses buffer to a new entry when you are adding that entry.  Default is to narrow to new entry, which means you see a blank screen before you write the new entry.

Call the pages-directory command from the buffer for which you want a directory created; it creates a directory for the buffer and pops you to the directory.

The pages-directory command has several options:

 1. Called with a prefix arg, C-u C-x C-p C-d, the pages-directory prompts you for a regular expression and only lists only those header lines that are part of pages that contain matches to the regexp.  In the example above, C-u C-x C-p C-d 617 RET would match the telephone area code of the first and fourth entries, so only the header lines of those two entries would appear in the pages-directory-buffer.

 2. Called with a numeric argument, the pages-directory command lists the number of lines in each page.  This is helpful when you are printing hardcopy.

 3. Called with a negative numeric argument, the pages-directory command lists the lengths of pages whose contents match a regexp.

To configure this package, type:

       M-x customize-group RET pages RET

Power Macros - Keyboard Macros Made Easy
****************************************

Keyboard Macros are a very powerful tool, if you know how to use them the right way!  Without this extension it is, however, a bit difficult in Emacs to define and maintain several macros at a time. This problem is solved with this package.

When you have loaded this package Emacs will, upon completion of macro definition, ask you which key you want to assign this macro to and ask for a description of the macro. If something is already bound to this key, Emacs will ask you whether you want to override this binding. Furthermore, this package also takes care of saving the macro to your initialization file for later Emacs sessions.

The description for all the defined macros may be obtained with the function `pm-manage-macros'. Using this function you can also manage your power-macros.

To execute this function, type:

       M-x pm-manage-macros RET

To configure the package, type:

       M-x customize-group RET power-macros RET

Redo/Undo System
****************

Emacs' normal undo system allows you to undo an arbitrary number of buffer changes.  These undos are recorded as ordinary buffer changes themselves.  So when you break the chain of undos by issuing some other command, you can then undo all the undos.  The chain of recorded buffer modifications therefore grows without bound, truncated only at garbage collection time.

The redo/undo system is different in two ways:

 1. The undo/redo command chain is only broken by a buffer modification.  You can move around the buffer or switch buffers and still come back and do more undos or redos.

 2. The redo command rescinds the most recent undo without recording the change as a _new_ buffer change.  It completely reverses the effect of the undo, which includes making the chain of buffer modification records shorter by one, to counteract the effect of the undo command making the record list longer by one.

To use this package, add the following to your initialization file:

       (require 'redo)

Scrolling In Place
******************

This library provides improved vertical scrolling commands for GNU Emacs.

Features
========

The new vertical scrolling commands offer the following features:

  * When a scrolling command is executed, GNU Emacs tries to keep point as close as possible to its original window position (window line and column).  This is what "scroll in place" means: point stays "in place" within the window. (There are times when point must be moved from its original window position in order to execute the scroll; see below.)

     The variable scroll-in-place, which is true by default, determines whether or not the standard GNU Emacs scrolling commands (scroll-down, scroll-up, scroll-other-window-down, and scroll-other-window) use the "in place" features listed here.  When scroll-in-place is nil the standard GNU Emacs scrolling commands essentially just call the original versions of themselves.  (Note that even when scroll-in-place is nil the new versions of scroll-down and scroll-up have slightly different behavior when a minibuffer window is the selected window.  See below.)

     It is possible to turn off (or turn on) "in place" scrolling for certain buffers by making buffer-local bindings of the variable scroll-in-place for those buffers.  The variable scroll-in-place is not usually buffer-local, but you can make it so if you desire.

  * Because the improved scrolling commands keep point at its original window position, these scrolling commands are "reversible."  The scroll-up command undoes the effect of the immediately previous scroll-down command (if any) and vice versa.  In other words, if you scroll up and then immediately scroll back down, the window configuration is restored to its exact original state.  This allows you to browse through a buffer more easily, as you can always get back to the original configuration.

     Note, however, that the improved scrolling commands are guaranteed to be reversible only if there are no intervening non-scrolling commands.  Also, if you give a prefix argument to a scrolling command (in order to specify the number of lines to scroll by), previous scrolling commands may no longer be reversible.  More specifically, if the new prefix argument has a different magnitude than the previous scrolling distance, then any previous scrolling commands are not reversible.  The new prefix argument takes precedence.

     You might find it useful to think of the scrolling commands as forming "chains."  A scrolling command either starts or continues a chain.  By issuing a non-scrolling command or by changing the number of lines to be scrolled, you break the chain.  (Note that simply changing the scrolling direction won't break the chain; changing the absolute number of lines to be scrolled is what breaks the chain.)  Scrolling commands are guaranteed to be reversible only within the current chain.  Hopefully that's clear enough.

  * When a scrolling command is given a prefix argument (which specifies the number of lines to scroll by), then that argument becomes the default scrolling distance for all immediately subsequent scrolling commands.  This means that you can easily set the scrolling distance for a chain of scrolling commands.  Note that a new prefix argument or any non- scrolling command breaks the chain (as described above), and any further scrolling commands will use the usual defaults (or the prefix argument you specify at that time, of course).

     However, there are cases in which one doesn't want the current scrolling command to use the default scrolling distance that was set by the previous scrolling command.  For example, suppose that you had special commands that scrolled one line up and one line down.  When you invoke one of these commands, the "in place" scrolling routines set the default scrolling distance to be just one line.  Now suppose that you use one of your special commands and then immediately invoke scroll-up (C-v), expecting it to scroll by a near windowful of text.  You would be disappointed --- because the previous command set the default scrolling distance to be just one line, scroll-up just scrolls by one line.

     To solve this problem, "scroll-in-place" allows you to divide scrolling commands into separate "groups."  Commands in a group can only form chains with (and therefore, inherit defaults from) commands in the same group. (Note that no command can be in more than one group.)  If you invoke a scrolling command that is not in the same group as that of the immediately previous scrolling command, then the previous chain is broken and you start a new chain --- with a new set of defaults.

     So to solve the problem described above, you could put your one-line scrolling commands in their own group.  Once that is done, the standard scrolling commands will not form chains with your one-line scrolling commands, and therefore will not use the default scrolling distance set by those commands.  Problem solved!

     By default, all "in place" scrolling commands are in a single group.  If you want to partition some commands into separate groups, you must do that yourself before any "in place" commands are invoked.  For more information about grouping commands, see the documentation for the variables scroll-command-groups and scroll-default-command-group.

  * The improved scrolling commands will avoid displaying empty lines past the end of the buffer when possible.  In other words, just as you can't see "dead space" before the beginning of the buffer text, the new scrolling commands try to avoid displaying "dead space" past the end of the buffer text.  This behavior is somewhat configurable; see the documentation for the variable scroll-allow-blank-lines-past-eob.

     Dead space will be displayed if it is necessary in order to make a previous scrolling action reversible, however.

  * If the scrolling commands cannot keep point at its initial window position (because a buffer boundary is on screen and the window can't be scrolled as far as necessary to keep point at the right place), point is allowed to temporarily stray from its initial window position.  That is, point moves the correct number of window lines, even if it means that it has to stray from its desired window position.  This straying is undone when (and if) the scrolling action is reversed.

  * If a scrolling command tries to move point past a buffer boundary, point is instead moved to the boundary (the beginning or the end of the buffer as appropriate) and an appropriate message is displayed.  This motion is reversible, of course.

     However, if point was already at the buffer boundary when the scrolling command was invoked, the command signals an appropriate error instead.

  * When a minibuffer window is the selected window, the new versions of scroll-up and scroll-down either scroll the window in the variable minibuffer-scroll-window (which is usually the window of completions) or the next-window if there is no minibuffer-scroll-window.  This is usually much more useful than scrolling the minibuffer itself.  (Note that this feature is available even when the variable scroll-in-place is nil.)

  * When a scrolling command is scrolling a window other than the selected window, it will signal an appropriate buffer boundary error if the window cannot be scrolled (because the appropriate buffer boundary is already visible).  This means that an error is signalled even in cases that would be allowed (by "straying" point or by moving it to the buffer boundary) if the window were selected.

     (If an error were not signalled in these cases, then there would be many cases in which the last scroll in a particular direction would appear to do nothing because only the point position would change --- the displayed text would stay the same!  To avoid these cases the scrolling commands signal boundary errors "prematurely" when the window to be scrolled is not selected.)

Command and Functions
=====================

This library provides the following "in place" versions of GNU Emacs' standard vertical scrolling commands:

  * scroll-down-in-place

  * scroll-up-in-place

  * scroll-other-window-down-in-place

  * scroll-other-window-in-place

The variable scroll-in-place, which is true by default, determines whether or not the new versions of the standard GNU Emacs scrolling commands (scroll-down, scroll-up, scroll-other-window-down, and scroll-other-window) use the "in place" features listed above.  When scroll-in-place is nil the standard GNU Emacs scrolling commands essentially just call the original versions of themselves.  (Note that even when scroll-in-place is nil the new versions of scroll-down and scroll-up have slightly different behavior when a minibuffer window is the selected window.  See the feature list above.)

NOTE that this package redefines the standard GNU Emacs commands scroll-down, scroll-up, scroll-other-window-down, and scroll-other-window (in order to check the variable scroll-in-place, as described above).  The command scroll-other-window-down first appeared as a standard command in the FSF's GNU Emacs 19.26.

This package also provides the following functions and variables which are of use to programmers:

  * scroll-window

  * scroll-window-in-place

  * scroll-window-in-place-continue-sequence

  * scroll-default-lines (variable)

  * scroll-command-groups (variable)

The scroll-window-in-place function is the heart of the "in place" scrolling commands.  scroll-window is a function that checks the variable scroll-in-place and calls the appropriate scrolling function (either scroll-window-in-place or one of the original versions of scroll-down and scroll-up).  The function scroll-window-in-place-continue-sequence is provided in order to preserve running "chains" of scrolling commands as described above.

The variable scroll-default-lines determines the default scrolling distance when a new chain of "in place" scrolling commands begins.  If this variable is not a number, then the default distance is the height of the window to be scrolled minus next-screen-context-lines.  The variable scroll-command-groups contains the explicit groups of "in place" scrolling commands; for more information read the variable documentation.

Installation
============

To use this package, you simply need to load it from within your initialization file:

       (require 'scroll-in-place)

By default, this package provides for the standard GNU Emacs vertical scrolling commands (scroll-down, scroll-up, scroll-other-window-down, and scroll-other-window) to use the "in place" features.  If you would rather not have this, set the variable (setq scroll-in-place nil).

When scroll-in-place is nil you will have to bind keys in order to call the "in place" scrolling commands.  For example, you might want to do the following:

       (global-set-key "\M-v" 'scroll-down-in-place)
       (global-set-key "\C-v" 'scroll-up-in-place)

Advanced Customization
======================

If you want to partition certain "in place" scrolling commands into separate groups, you should do something like the following:

       ;; Make one group containing the commands `scroll-down-one-line' and
       ;; `scroll-up-one-line'.  (These are not standard GNU Emacs commands.)
       (setq scroll-command-groups
             (list '(scroll-down-one-line scroll-up-one-line)))

You could write the `scroll-down-one-line' command like this:

       (defun scroll-down-one-line (arg)
         "Scroll down one line, or number of lines specified by prefix arg."
         (interactive "P")
         (let ((scroll-default-lines 1))
           (scroll-down-in-place arg)))

If you want to disable "in place" scrolling for windows that display a particular buffer (while leaving it available in other windows), you can make scroll-in-place a buffer-local variable for that buffer and then bind that local copy of scroll-in-place to nil.  This is the kind of thing that one generally does in a major mode hook.  For example, you can disable "in place" scrolling of GNUS article windows with the following code:

       (setq gnus-article-mode-hook
             (function (lambda ()
                         (make-local-variable 'scroll-in-place)
                         (setq scroll-in-place nil))))
       ;; Set the variable `gnus-Article-mode-hook' instead if you are using
       ;; an old version of GNUS, say version 3.13 or 3.14.

The variable scroll-allow-blank-lines-past-eob can also be made local to particular buffers, if you desire.  (But why would you want to do that?)

VI-style Line Number Mode
*************************

This library activates VI-style line numbering for a buffer.

M-x setnu-mode toggles the line number mode on and off.

turn-on-setnu-mode is useful for adding to a major-mode hook variable.

       (add-hook 'text-mode-hook 'turn-on-setnu-mode)

to automatically turn on line numbering when entering text-mode.

Vertical Mode - Editing of Vertical Text
****************************************

This minor mode allows you to conveniently edit things that are oriented vertically (like tables in computer programs): after each action, cursor moves down. Therefore, to move block of text to the right, you simply enter vertical mode and then hold spacebar, waiting for autorepeat to do the job for you.

Align Text to a Specific Column, By Regexp
******************************************

This mode allows you to align regions in a context-sensitive fashion.  The classic use is to align assignments:

       int a = 1;
       short foo = 2;
       double blah = 4;

becomes

       int    a    = 1;
       short  foo  = 2;
       double blah = 4;

Align Usage
===========

To configure the package, type:

       M-x customize-group RET align RET

There are several variables which define how certain "categories" of syntax are to be treated.  These variables go by the name `align-CATEGORY-modes'. For example, "c++" is such a category.  There are several rules which apply to c++, but since several other languages have a syntax similar to c++ (e.g., c, java, etc), these modes are treated as belonging to the same category.

If you want to add a new mode under a certain category, just customize that list, or add the new mode manually.  For example, to make jde-mode a c++ category mode, use this code in your initialization file:

       (setq align-c++-modes (cons 'jde-mode align-c++-modes))

In some programming modes, it's useful to have the aligner run only after indentation is performed.  To achieve this, customize or set the variable `align-indent-before-aligning' to t.

Extensive Outline Mode
**********************

Allout outline mode provides extensive outline formatting and manipulation beyond standard emacs outline mode (see Outline Mode (xemacs)).  It provides for structured editing of outlines, as well as navigation and exposure.  It also provides for syntax-sensitive text like programming languages.  (For an example, see the allout code itself, which is organized in ;; an outline framework.)

In addition to outline navigation and exposure, allout includes:

  * topic-oriented repositioning, cut, and paste

  * integral outline exposure-layout

  * incremental search with dynamic exposure and reconcealment of hidden text

  * automatic topic-number maintenance

  * "Hot-spot" operation, for single-keystroke maneuvering and exposure control. (See the outline-mode docstring.)

and many other features.

To configure the package, type:

       M-x customize-group RET allout RET

To use the allout package in place of the standard outline package, add the following bit of code

     (require 'outline "allout")

to your initialization file.  This will ensure that all the functions provided by the outline package will be loaded from the new allout package instead.

The outline menubar additions provide quick reference to many of the features, and see the docstring of the variable `outline-init' for instructions on priming your emacs session for automatic activation of outline-mode.

See the docstring of the variables `outline-layout' and `outline-auto-activation' for details on automatic activation of allout outline-mode as a minor mode.

By default, allout mode does not fontify the buffer. To get Font Lock to work put the following into your initialization file (adapted from the standard outline mode):

       (defvar rf-allout-font-lock-keywords
         '(;;
           ;; Highlight headings according to the level.
           (eval . (list (concat "^\\(" outline-regexp "\\).+")
                         0 '(or (cdr (assq (outline-depth)
                                           '((1 . font-lock-function-name-face)
                                             (2 . font-lock-variable-name-face)
                                             (3 . font-lock-keyword-face)
                                             (4 . font-lock-builtin-face)
                                             (5 . font-lock-comment-face)
                                             (6 . font-lock-constant-face)
                                             (7 . font-lock-type-face)
                                             (8 . font-lock-string-face))))
                                font-lock-warning-face)
                         nil t)))
         "Additional expressions to highlight in Outline mode.")

       ;; add font-lock to allout mode
       (defun rf-allout-font-lock-hook ()
         (set (make-local-variable 'font-lock-defaults)
              '(rf-allout-font-lock-keywords t nil nil outline-back-to-current-heading)))

       (add-hook 'outline-mode-hook 'rf-allout-font-lock-hook)

Extending the built-in narrowing functions
******************************************

Narrowing, as implemented in Emacs has one limitation, namely that it is not possible to narrow within a narrowing, and then widen again to the previous narrowing.  This package implements an extension to narrowing, which makes this possible.

To activate this extension type M-x narrow-stack-mode or add (narrow-stack-mode) to your initialization file.

Registers in XEmacs are limited in easy accessibility to a handful of functions in the default keyboard layout. This menu provides a top-level menu interface to most of the functionality provided by registers, including columnar copying, bookmarking, and real-time in-menu previews of the contents of registers.

This menu can be configured through the register-menu configure group. Type M-x customize-group RET register-menu RET

The current XEmacs interface for registers is either deep in the menus, requiring multiple clicks for a single copy/paste command, or on a handful of keyboard bindings. The register toolbar minor mode provides a simple click interface for cut, copy and paste functionality to the digit registers (0-9). Modes are also available for columnar copy/cut operations.

This minor mode can be enabled through button 3 on the modeline or the command: M-x register-toolbar-mode.

Flow Control
************

Terminals that use XON/XOFF flow control can cause problems with GNU Emacs users.  This file contains Emacs Lisp code that makes it easy for a user to deal with this problem, when using such a terminal.

To invoke these adjustments, a user need only invoke the function enable-flow-control-on with a list of terminal types specified in the initialization file.  As arguments, give it the names of one or more terminal types in use by that user which require flow control adjustments.  Here's an example:

       (enable-flow-control-on "vt200" "vt300" "vt101" "vt131")

Portability note: This uses (getenv "TERM"), and therefore probably won't work outside of UNIX-like environments.

Generate Summary of All Key Binding
***********************************

Displays a nice human-readable summary of all keybindings in a two-column format.

To invoke this command, type:

       M-x make-command-summary RET

Browse UNIX manual pages
************************

This library defines the command manual-entry to browse Unix manual pages.

To invoke this command, type:

       M-x manual-entry RET

For ease of use, autocompletion on M-x man will work just fine.

To configure this package, type:

       M-x customize-group RET man RET

Abbreviation List
*****************

This library not documented.  Please contribute!

Treat a Section of a Buffer as a Separate File
**********************************************

This library not documented.  Please contribute!

Major-Mode-Sensitive Info Index Lookup Facility
***********************************************

This library not documented.  Please contribute!

Make Frame Icons Represent Current Frame Contents
*************************************************

This library not documented.  Please contribute!

Per Mode/Buffer Mouse Tracking With Highlighting
************************************************

This library not documented.  Please contribute!

Shrink-Wrapped Temporary Windows
********************************

This library not documented.  Please contribute!

Display Time and Load in Mode Line
**********************************

This library not documented.  Please contribute!

Balloon Help and Tooltips
*************************

This library not documented.  Please contribute!

Blinking Parentheses
********************

This library not documented.  Please contribute!

Face Editor
***********

This library not documented.  Please contribute!

lispm-fonts
***********

This library not documented.  Please contribute!

Big Menubar
***********

This library not documented.  Please contribute!

tree-menu
*********

This library not documented.  Please contribute!

XEmacs License
**************

GNU GENERAL PUBLIC LICENSE
**************************

Version 2, June 1991

     Copyright © 1989, 1991 Free Software Foundation, Inc.
     675 Mass Ave, Cambridge, MA 02139, USA

     Everyone is permitted to copy and distribute verbatim copies
     of this license document, but changing it is not allowed.

Preamble
========

The licenses for most software are designed to take away your freedom to share and change it.  By contrast, the GNU General Public License is intended to guarantee your freedom to share and change free software---to make sure the software is free for all its users.  This General Public License applies to most of the Free Software Foundation's software and to any other program whose authors commit to using it.  (Some other Free Software Foundation software is covered by the GNU Library General Public License instead.)  You can apply it to your programs, too.

When we speak of free software, we are referring to freedom, not price.  Our General Public Licenses are designed to make sure that you have the freedom to distribute copies of free software (and charge for this service if you wish), that you receive source code or can get it if you want it, that you can change the software or use pieces of it in new free programs; and that you know you can do these things.

To protect your rights, we need to make restrictions that forbid anyone to deny you these rights or to ask you to surrender the rights. These restrictions translate to certain responsibilities for you if you distribute copies of the software, or if you modify it.

For example, if you distribute copies of such a program, whether gratis or for a fee, you must give the recipients all the rights that you have.  You must make sure that they, too, receive or can get the source code.  And you must show them these terms so they know their rights.

We protect your rights with two steps: (1) copyright the software, and (2) offer you this license which gives you legal permission to copy, distribute and/or modify the software.

Also, for each author's protection and ours, we want to make certain that everyone understands that there is no warranty for this free software.  If the software is modified by someone else and passed on, we want its recipients to know that what they have is not the original, so that any problems introduced by others will not reflect on the original authors' reputations.

Finally, any free program is threatened constantly by software patents.  We wish to avoid the danger that redistributors of a free program will individually obtain patent licenses, in effect making the program proprietary.  To prevent this, we have made it clear that any patent must be licensed for everyone's free use or not licensed at all.

The precise terms and conditions for copying, distribution and modification follow.

TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION

 0. This License applies to any program or other work which contains a notice placed by the copyright holder saying it may be distributed under the terms of this General Public License.  The ``Program'', below, refers to any such program or work, and a ``work based on the Program'' means either the Program or any derivative work under copyright law: that is to say, a work containing the Program or a portion of it, either verbatim or with modifications and/or translated into another language.  (Hereinafter, translation is included without limitation in the term ``modification''.)  Each licensee is addressed as ``you''.

     Activities other than copying, distribution and modification are not covered by this License; they are outside its scope.  The act of running the Program is not restricted, and the output from the Program is covered only if its contents constitute a work based on the Program (independent of having been made by running the Program). Whether that is true depends on what the Program does.

 1. You may copy and distribute verbatim copies of the Program's source code as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice and disclaimer of warranty; keep intact all the notices that refer to this License and to the absence of any warranty; and give any other recipients of the Program a copy of this License along with the Program.

     You may charge a fee for the physical act of transferring a copy, and you may at your option offer warranty protection in exchange for a fee.

 2. You may modify your copy or copies of the Program or any portion of it, thus forming a work based on the Program, and copy and distribute such modifications or work under the terms of Section 1 above, provided that you also meet all of these conditions:

      a. You must cause the modified files to carry prominent notices stating that you changed the files and the date of any change.

      b. You must cause any work that you distribute or publish, that in whole or in part contains or is derived from the Program or any part thereof, to be licensed as a whole at no charge to all third parties under the terms of this License.

      c. If the modified program normally reads commands interactively when run, you must cause it, when started running for such interactive use in the most ordinary way, to print or display an announcement including an appropriate copyright notice and a notice that there is no warranty (or else, saying that you provide a warranty) and that users may redistribute the program under these conditions, and telling the user how to view a copy of this License.  (Exception: if the Program itself is interactive but does not normally print such an announcement, your work based on the Program is not required to print an announcement.)

     These requirements apply to the modified work as a whole.  If identifiable sections of that work are not derived from the Program, and can be reasonably considered independent and separate works in themselves, then this License, and its terms, do not apply to those sections when you distribute them as separate works.  But when you distribute the same sections as part of a whole which is a work based on the Program, the distribution of the whole must be on the terms of this License, whose permissions for other licensees extend to the entire whole, and thus to each and every part regardless of who wrote it.

     Thus, it is not the intent of this section to claim rights or contest your rights to work written entirely by you; rather, the intent is to exercise the right to control the distribution of derivative or collective works based on the Program.

     In addition, mere aggregation of another work not based on the Program with the Program (or with a work based on the Program) on a volume of a storage or distribution medium does not bring the other work under the scope of this License.

 3. You may copy and distribute the Program (or a work based on it, under Section 2) in object code or executable form under the terms of Sections 1 and 2 above provided that you also do one of the following:

      a. Accompany it with the complete corresponding machine-readable source code, which must be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange; or,

      b. Accompany it with a written offer, valid for at least three years, to give any third party, for a charge no more than your cost of physically performing source distribution, a complete machine-readable copy of the corresponding source code, to be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange; or,

      c. Accompany it with the information you received as to the offer to distribute corresponding source code.  (This alternative is allowed only for noncommercial distribution and only if you received the program in object code or executable form with such an offer, in accord with Subsection b above.)

     The source code for a work means the preferred form of the work for making modifications to it.  For an executable work, complete source code means all the source code for all modules it contains, plus any associated interface definition files, plus the scripts used to control compilation and installation of the executable.  However, as a special exception, the source code distributed need not include anything that is normally distributed (in either source or binary form) with the major components (compiler, kernel, and so on) of the operating system on which the executable runs, unless that component itself accompanies the executable.

     If distribution of executable or object code is made by offering access to copy from a designated place, then offering equivalent access to copy the source code from the same place counts as distribution of the source code, even though third parties are not compelled to copy the source along with the object code.

 4. You may not copy, modify, sublicense, or distribute the Program except as expressly provided under this License.  Any attempt otherwise to copy, modify, sublicense or distribute the Program is void, and will automatically terminate your rights under this License. However, parties who have received copies, or rights, from you under this License will not have their licenses terminated so long as such parties remain in full compliance.

 5. You are not required to accept this License, since you have not signed it.  However, nothing else grants you permission to modify or distribute the Program or its derivative works.  These actions are prohibited by law if you do not accept this License.  Therefore, by modifying or distributing the Program (or any work based on the Program), you indicate your acceptance of this License to do so, and all its terms and conditions for copying, distributing or modifying the Program or works based on it.

 6. Each time you redistribute the Program (or any work based on the Program), the recipient automatically receives a license from the original licensor to copy, distribute or modify the Program subject to these terms and conditions.  You may not impose any further restrictions on the recipients' exercise of the rights granted herein. You are not responsible for enforcing compliance by third parties to this License.

 7. If, as a consequence of a court judgment or allegation of patent infringement or for any other reason (not limited to patent issues), conditions are imposed on you (whether by court order, agreement or otherwise) that contradict the conditions of this License, they do not excuse you from the conditions of this License.  If you cannot distribute so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may not distribute the Program at all.  For example, if a patent license would not permit royalty-free redistribution of the Program by all those who receive copies directly or indirectly through you, then the only way you could satisfy both it and this License would be to refrain entirely from distribution of the Program.

     If any portion of this section is held invalid or unenforceable under any particular circumstance, the balance of the section is intended to apply and the section as a whole is intended to apply in other circumstances.

     It is not the purpose of this section to induce you to infringe any patents or other property right claims or to contest validity of any such claims; this section has the sole purpose of protecting the integrity of the free software distribution system, which is implemented by public license practices.  Many people have made generous contributions to the wide range of software distributed through that system in reliance on consistent application of that system; it is up to the author/donor to decide if he or she is willing to distribute software through any other system and a licensee cannot impose that choice.

     This section is intended to make thoroughly clear what is believed to be a consequence of the rest of this License.

 8. If the distribution and/or use of the Program is restricted in certain countries either by patents or by copyrighted interfaces, the original copyright holder who places the Program under this License may add an explicit geographical distribution limitation excluding those countries, so that distribution is permitted only in or among countries not thus excluded.  In such case, this License incorporates the limitation as if written in the body of this License.

 9. The Free Software Foundation may publish revised and/or new versions of the General Public License from time to time.  Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns.

     Each version is given a distinguishing version number.  If the Program specifies a version number of this License which applies to it and ``any later version'', you have the option of following the terms and conditions either of that version or of any later version published by the Free Software Foundation.  If the Program does not specify a version number of this License, you may choose any version ever published by the Free Software Foundation.

 10. If you wish to incorporate parts of the Program into other free programs whose distribution conditions are different, write to the author to ask for permission.  For software which is copyrighted by the Free Software Foundation, write to the Free Software Foundation; we sometimes make exceptions for this.  Our decision will be guided by the two goals of preserving the free status of all derivatives of our free software and of promoting the sharing and reuse of software generally.

     NO WARRANTY

 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM ``AS IS'' WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.

 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.

END OF TERMS AND CONDITIONS

How to Apply These Terms to Your New Programs
=============================================

If you develop a new program, and you want it to be of the greatest possible use to the public, the best way to achieve this is to make it free software which everyone can redistribute and change under these terms.

To do so, attach the following notices to the program.  It is safest to attach them to the start of each source file to most effectively convey the exclusion of warranty; and each file should have at least the ``copyright'' line and a pointer to where the full notice is found.

     ONE LINE TO GIVE THE PROGRAM'S NAME AND AN IDEA OF WHAT IT DOES.
     Copyright (C) 19YY  NAME OF AUTHOR

     This program is free software; you can redistribute it and/or
     modify it under the terms of the GNU General Public License
     as published by the Free Software Foundation; either version 2
     of the License, or (at your option) any later version.

     This program is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     GNU General Public License for more details.

     You should have received a copy of the GNU General Public License
     along with this program; if not, write to the Free Software
     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

Also add information on how to contact you by electronic and paper mail.

If the program is interactive, make it output a short notice like this when it starts in an interactive mode:

     Gnomovision version 69, Copyright (C) 19YY NAME OF AUTHOR
     Gnomovision comes with ABSOLUTELY NO WARRANTY; for details
     type `show w'.  This is free software, and you are welcome
     to redistribute it under certain conditions; type `show c'
     for details.

The hypothetical commands show w and show c should show the appropriate parts of the General Public License.  Of course, the commands you use may be called something other than show w and show c; they could even be mouse-clicks or menu items---whatever suits your program.

You should also get your employer (if you work as a programmer) or your school, if any, to sign a ``copyright disclaimer'' for the program, if necessary.  Here is a sample; alter the names:

     Yoyodyne, Inc., hereby disclaims all copyright
     interest in the program `Gnomovision'
     (which makes passes at compilers) written
     by James Hacker.

     SIGNATURE OF TY COON, 1 April 1989
     Ty Coon, President of Vice

This General Public License does not permit incorporating your program into proprietary programs.  If your program is a subroutine library, you may consider it more useful to permit linking proprietary applications with the library.  If this is what you want to do, use the GNU Library General Public License instead of this License.