Gnus -- Minor tweak define #'time-to-seconds

[packages] / xemacs-packages / edit-utils / edit-utils.texi

@c -*-texinfo-*-
@c
@c Copyright (C) 2002, 2003 Free Software Foundation, Inc.
@c Copyright (C) 2003 Jake Colman
@c
@c @setfilename edit-utils.info
@settitle Editing Utilities for XEmacs
@ifinfo
@dircategory XEmacs Editor
@direntry
* Edit Utilities: (edit-utils). Editing Utilities for XEmacs.
@end direntry
@end ifinfo

@c @copying
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.
@c @end copying

@node Top, Copying, (dir), (dir)
@chapter The Editing Utilities Package

@ifinfo
This Info file contains the manual for the Editing Utilities package.
@end ifinfo

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 @code{C-x 4 l <filename> RET} where <filename> is the name of the
elisp file to be loaded.

@menu
* Copying::                     Why this manual is GPL, and what that means

Buffer and Window Management
* compare-w::                   Comparing Windows
* detached-minibuf::            Detached Minibuffers
* iswitchb::                    Convenient Buffer Switching
* permanent-buffers::           Permanent Buffers
* rsz-minibuf::                 Self-Resizing Minibuffer
* search-buffers::              Searching Many Buffers
* uniquify::                    Meaningful Unique Names
* winring::                     Window Configuration Rings
* autorevert::                  Reverting Buffers

Editing Help
* foldout::                     Folding Extensions for Outline-Mode
* func-menu::                   Jump to a Function Within a Buffer.
* id-select::                   Select Syntax-Driven Regions in a Buffer
* outl-mouse::                  Outline-Mode Mouse Commands
* page-ext::                    Extended Page Handling Commands
* power-macros::                Power Macros - Keyboard Macros Made Easy
* redo::                        Redo/Undo System
* scroll-in-place::             Scrolling In Place
* setnu::                       VI-style Line Number Mode
* vertical-mode::               Vertical Mode - Editing of Vertical Text
* align::                       Align Text to a Specific Column, By Regexp
* allout::                      Extensive Outline Mode
* narrow-stack::                Extending the built-in narrowing functions
* register-menu::               Menu for easier register interaction
* register-toolbar::            Toolbar for easier register interaction

File Management
* backup-dir::                  Specify Directories to be Used for Backup Files

Session Management
* bookmark::                    Create annotated bookmarks
* desktop::                     Save Partial Status of Emacs When Killed
* recent-files::                Recent File Navigation
* resume::                      Resuming a Suspended Emacs Job
* saveconf::                    Save Buffer/Window Configuration Between Sessions
* savehist::                    Save Minibuffer History
* saveplace::                   Automatically Save Place in Files
* where-was-i-db::              Keep Persistent State in Visited Files

Abbreviations
* completion::                  Completion
* dabbrev::                     Dynamic Abbreviations
* hippie-exp::                  Hippie Expand
* icomplete::                   Interactive Minibuffer Completion
* tempo::                       Flexible Template Insertion

Display, Faces, and Highlighting:
* avoid::                       Move Mouse Pointer Out of the Way of Editing
* blink-cursor::                Blinking Cursor
* fast-lock::                   Speeding Up Font Lock Mode
* lazy-lock::                   Lazy Demand-Driven Fontification
* lazy-shot::                   Another Lazy Demand-Driven Fontification
* mic-paren::                   Advanced Highlighting of Matching Parentheses
* paren::                       Highlight (Un)matching Parens and Whole Expressions
* shell-font::                  Decorate a Shell Buffer With Fonts
* highline::                    Highlight the Current Line in the Buffer
* buffer-colors::               System for Buffer-Local Color Schemes

Low-Level Editing Hacks:
* after-save-commands::         Hooks Invoked After Saving a File
* atomic-extents::              Indivisible Blocks of Text
* array::                       Table and Array Editor

Menu and Toolbar Support:
* floating-toolbar::            Floating Toolbar
* The Toolbar Utilities::       Creating and Managing Toolbars and Buttons.

Miscellaneous:
* flow-ctrl::                   Flow Control
* makesum::                     Generate Summary of All Key Binding
* man::                         Browse UNIX manual pages

Undocumented:
* abbrevlist::                  Abbreviation List
* file-part::                   Treat a Section of a Buffer as a Separate File
* info-look::                   Major-Mode-Sensitive Info Index Lookup Facility
* live-icon::                   Make Frame Icons Represent Current Frame Contents
* mode-motion+::                Per Mode/Buffer Mouse Tracking With Highlighting
* popper::                      Shrink-Wrapped Temporary Windows
* reportmail::                  Display Time and Load in Mode Line
* balloon-help::                Balloon Help and Tooltips
* blink-paren::                 Blinking Parentheses
* edit-faces::                  Face Editor
* lispm-fonts::                 lispm-fonts
* big-menubar::                 Big Menubar
* tree-menu::                   tree-menu.el

Appendices:
* XEmacs License::              The GNU General Public License
@end menu

@node Copying, compare-w, Top, Top
@chapter 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 (@dfn{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 @dfn{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 @dfn{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,'' @emph{i.e.}, it @emph{requires}
that you redistribute it under terms @emph{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 @emph{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 (@dfn{XDL}) are @emph{mutually
incompatible}.  That is, content licensed under any of the GPL, FDL, or
XDL @emph{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 @emph{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 @emph{may not} copy text from the Lispref into docstrings in the
code.  And you @emph{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
@emph{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.

@node compare-w, detached-minibuf, Copying, Top
@chapter 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.

@node detached-minibuf, iswitchb, compare-w, Top
@chapter Detached Minibuffers

This package creates a standalone minibuffer in its own frame.

To configure this package, type:

@example
  M-x customize-group RET detached-minibuf RET
@end example

@node iswitchb, permanent-buffers, detached-minibuf, Top
@chapter 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 @kbd{C-s} and @kbd{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 @samp{iswitchb}, I first of all get
presented with the list of all the buffers

@samp{iswitch @{123456,123@}}

If I then press @kbd{2}:

@samp{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 @kbd{RET}.  I can
also bring the put the first element at the end of the list by pressing
@kbd{C-s}, or put the last element at the head of the list by pressing
@kbd{C-r}.  The item in [] indicates what can be added to my input by
pressing @kbd{TAB}.  In this case, I will get @samp{3} added to my input.
So, press @kbd{TAB}:

@samp{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 @kbd{RET}.  If I wanted the second in the list, I
could press @kbd{C-s} to move it to the top of the list and then @kbd{RET} to
select it.

However, If I type @kbd{4}, I only have one match left:

@samp{iswitch 234[123456] [Matched]}

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

If however, I now type @kbd{a}:

@samp{iswitch 234a [No match]}

There are no matching buffers.  If I press @kbd{RET} or @kbd{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 @kbd{4} and then
@kbd{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 @kbd{?}
or press @kbd{TAB} when there are no further completions to the substring.
Repeated @kbd{TAB} presses will scroll you through this separate buffer.

The buffer at the head of the list can be killed by pressing @kbd{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
@kbd{C-x C-f} to immediately drop into find-file.

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

@example
  M-x describe-function RET iswitchb
@end example

@menu
* Customization: iswitchb-cust.
* Changing the Display::
* Regexp Matching::
* Replacement for read-buffer::
@end menu

@node iswitchb-cust, Changing the Display, iswitchb, iswitchb
@section Customization

To configure the package, type:

@example
  M-x customize-group RET iswitchb RET
@end example

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

@example
  M-x iswitchb-default-keybindings RET
@end example

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

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

@node Changing the Display, Regexp Matching, iswitchb-cust, iswitchb
@section 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 @code{(resize-minibuffer-mode)}
@xref{rsz-minibuf}.  You can also limit iswitchb so that it only shows a
certain number of lines.  To do this, see the documentation for
@code{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:

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

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 @code{(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)

@node Regexp Matching, Replacement for read-buffer, Changing the Display, iswitchb
@section Regexp Matching

There is limited provision for regexp matching within @code{iswitchb},
enabled through @code{iswitchb-regexp}.  This allows you to type @kbd{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
@code{iswitchb-regexp} is @code{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 @kbd{C-g} and try
again.  Secondly, no completion mechanism is currently offered when regexp
searching.

@node Replacement for read-buffer,  , Regexp Matching, iswitchb
@section Replacement for read-buffer

iswitchb-read-buffer has been written to be a drop in replacement for the
normal buffer selection routine @code{read-buffer}.  To use iswitch for all
buffer selections in Emacs, add: @code{(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: @code{(defalias
'read-buffer 'iswitchb-read-buffer)} since @code{read-buffer} is defined in
lisp.

@node permanent-buffers, rsz-minibuf, iswitchb, Top
@chapter 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 @code{permanent-buffers-mode} or use
@code{turn-on-permanent-buffers} at startup. Within an XEmacs session, use
@code{permanent-buffers-mode} or @code{turn-o[n|ff]-permanent-buffers}. You
might also want to customize @code{permanent-buffers-alist}.

To configure this package, type:

@example
  M-x customize-group RET permanent-buffers RET
@end example

@node rsz-minibuf, search-buffers, permanent-buffers, Top
@chapter 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:

@example
  M-x resize-minibuffer-mode RET
@end example

To configure this package, type:

@example
  M-x customize-group RET resize-minibuffer RET
@end example

@node search-buffers, uniquify, rsz-minibuf, Top
@chapter 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:

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

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 (@kbd{n}) or
previous (@kbd{p}) match.

@node uniquify, winring, search-buffers, Top
@chapter 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 @file{/u/mernst/tmp/Makefile} and
@file{/usr/projects/zaphod/Makefile} would be named @samp{Makefile|tmp} and
@samp{Makefile|zaphod}, respectively (instead of @samp{Makefile} and
@samp{Makefile<2>}).  Other buffer name styles are also available.

To configure this package, type:

@example
  M-x customize-group RET uniquify RET
@end example

@node winring, autorevert, uniquify, Top
@chapter 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 @kbd{C-x 4 b},
@kbd{C-x 2}, and @kbd{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
@code{current-window-configuration}, however winring also saves point for the
current buffer.

To use, add the following to your initialization file:

@example
  (winring-initialize)
@end example

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

The following commands are defined:

@table @kbd

@item C-x 7 n 

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

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

@item C-x 7 2 

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

@item C-x 7 j 

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

@item 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
@kbd{C-u}, prompts for the name of the configuration to kill.

@item C-x 7 o

Go to the next configuration on the ring.

@item 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.

@item C-x 7 r

Rename the current window configuration.

@item C-x 7 b

Submit a bug report on winring.

@item C-x 7 v

Echo the winring version.

@end table

As mentioned, window configuration names can be displayed in the modeline.
The default value of @code{winring-show-names} is currently @code{nil} by
default. Set it to @code{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 @code{winring-initialize}.

@menu
* History::
* Related Packages::
@end menu

@node History, Related Packages, winring, winring
@section 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.

@node Related Packages,  , History, winring
@section Related Packages

I know of a few other related packages:

@itemize @bullet

@item

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

@item 

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

@item

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

@item

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.

@end itemize

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

@node autorevert, backup-dir, winring, Top
@chapter 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).

@menu
* Auto-Revert Usage::           How to use the package.
@end menu

@node Auto-Revert Usage,  , autorevert, autorevert
@section Auto-Revert Usage

To configure the package, type:

@example
  M-x customize-group RET auto-revert RET
@end example

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

@example
  M-x auto-revert-mode RET
@end example

To activate Global Auto-Revert Mode, type:

@example
  M-x global-auto-revert-mode RET
@end example

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:

@example
  (global-auto-revert-mode 1)
@end example

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:

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

@node backup-dir, bookmark, autorevert, Top
@chapter 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, @code{bkup-backup-directory-info}.  This variable is a
list of lists of the form @code{(FILE-REGEXP BACKUP-DIR OPTIONS ...)}.  If
the filename to be backed up matches @code{FILE-REGEXP}, or
@code{FILE-REGEXP} is @code{t}, then @code{BACKUP-DIR} is used as the path
for its backups.  Directories may begin with "/" to specify an absolute
pathname.

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

If @code{OPTIONS} contains the symbol @code{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 @code{OPTIONS} contains @code{prepend-name} in addition to
@code{full-path}, then the file name is prepended rather than appended to the
path component when forming the backup name.

If @code{OPTIONS} contains the symbol @code{search-upward} and the backup
directory @code{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 @code{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:

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

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

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

@node bookmark, desktop, backup-dir, Top
@chapter 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:

@example
  M-x customize-group RET bookmark RET
@end example

@node desktop, recent-files, bookmark, Top
@chapter Save Partial Status of Emacs When Killed

Save the Desktop, i.e.,

@itemize @bullet

@item 
some global variables

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

@itemize @bullet

@item 
the major mode

@item 
the default directory

@item 
the point

@item 
the mark & mark-active

@item 
buffer-read-only

@item 
some local variables

@end itemize

@end itemize

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

@example
  (desktop-load-default)
  (desktop-read)
@end example

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

@example
  (setq desktop-locals-to-save (cons 'foobar desktop-locals-to-save))
@end example

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

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

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

Start Emacs in the root directory of your "project". The desktop saver is
inactive by default.  You activate it by typing @code{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 @code{minor-mode-alist} is also a function; and (2) use translation
table @code{desktop-minor-mode-table} in the case where the two names are not
the same.

By the way: don't use @file{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
@code{desktop-globals-to-save} (by default it isn't).  This may result in saving
things you did not mean to keep.  Use @code{M-x desktop-clear RET}.

To configure this package, type:

@example
  M-x customize-group RET desktop RET
@end example

@node recent-files, resume, desktop, Top
@chapter Recent File Navigation

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

@example
  (recent-files-initialize)
@end example

@file{recent-files} adds the menu "Recent Files" (or whatever name you
choose, (@pxref{recentf-cust,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 @code{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 @code{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.

@menu
* Customization: recentf-cust.
@end menu

@node recentf-cust,  , recent-files, recent-files
@section 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.

@table @code

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

@item 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.

@item 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.

@item 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:

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

The default is empty.

@item 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.

@item 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

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

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 "~".

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

@item 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.

@item 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 @code{recent-files-permanent-submenu} and
@code{recent-files-non-permanent-submenu} to t to have both lists in
separate submenus.)

@item 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.

@item 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...".

@item 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.

@item 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.

@item 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 @code{find-file},
which is the default.

@end table

@node resume, saveconf, recent-files, Top
@chapter Resuming a Suspended Emacs Job

This library not documented.  Please contribute!

@node saveconf, savehist, resume, Top
@chapter 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 @code{save-context} and @code{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 @code{M-x
save-context} at each emacs exit, put the line:

@example
  (setq auto-save-and-recover-context t)
@end example

in your initialization file or in @file{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

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

at the end of your initialization file or the @file{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.

@node savehist, saveplace, saveconf, Top
@chapter 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, @code{savehist-save} will dump the contents of
various minibuffer histories (as determined by
@code{savehist-history-variables}) to a save file (@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:

@example
  (savehist-load)
@end example

To configure this package, type:

@example
  M-x customize-group RET savehist RET
@end example

@node saveplace, where-was-i-db, savehist, Top
@chapter 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
@code{save-place} to determine whether to save position or not.

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

@example
  (require 'saveplace)
@end example

To configure this package, type:

@example
  M-x customize-group RET saveplace RET
@end example

@node where-was-i-db, completion, saveplace, Top
@chapter 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 @code{find-file-hooks} and on the
buffer-local @code{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 @code{point}.  When you visit a file, the
database is queried, keyed on @code{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:

@example
  M-x toggle-where-was-i 
@end example

which, using auto-completion, can be entered as 

@example
  M-x tog TAB w TAB
@end example

that will turn place saving on and off on a per-file, buffer- local basis.
If @code{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 @code{where-was-i-db} feature to be autoloaded, as
@code{toggle-where-was-i} will call on @code{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 @code{wwi-auto-install-on-startup-flag}.  There is
more information about this in its docstring.

This feature can be unloaded with:

@example
  C-u M-x install-where-was-i
@end example

which will call @code{unload-feature}, as well as traverse the
@code{buffer-list} removing the buffer-local @code{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 @code{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 @kbd{C-u M-x
install-where-was-i}, no @code{where-was-i-db} database update will happen
for them, since their buffer-local @code{kill-buffer-hook} will have been
cleaned of the member @code{wwi-save-where-i-am}, the function that writes
the @code{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 @code{where-was-i-db} installed.

To remove a file from the place saving database, simply visit it, @kbd{M-x
toggle-where-was-i} to switch @code{where-was-i-db} off, then kill that
buffer.  You can see how this works by looking at the definition of
@code{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:

@example
  M-x wwi-vacume-where-was-i-db
@end example

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 @code{(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 @code{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 @code{wwi-vacume-where-was-i-db}.  Of course,
you might not want to do that, for obvious reasons.

To configure this package, type:

@example
  M-x customize-group RET where-was-i RET
@end example


@node completion, dabbrev, where-was-i-db, Top
@chapter Completion

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

@example
  (require 'completion)
@end example

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" (@kbd{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
@kbd{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 @xref{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:

@example
  M-x customize-group RET completion RET
@end example

@node dabbrev, hippie-exp, completion, Top
@chapter 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 @kbd{M-/}
(@code{dabbrev-expand}) or @kbd{M-C-/} (@code{dabbrev-completion}).

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

To configure this package, type:

@example
  M-x customize-group RET dabbrev RET
@end example

@node hippie-exp, icomplete, dabbrev, Top
@chapter Hippie Expand

@code{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
@code{hippie-expand-try-functions-list}.  Much customization of
@code{hippie-expand} can be made by changing the order of, removing, or
inserting new functions in this list.  Given a positive numeric argument,
@code{hippie-expand} jumps directly ARG functions forward in this list.
Given some other argument (a negative argument or just @kbd{C-u}) it undoes
the tried completion.

If the variable @code{hippie-expand-verbose} is non-nil, @code{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 @code{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
@code{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
@code{make-hippie-expand-function} below.

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

@table @code

@item 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.

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

@item 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.

@item 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.

@item try-expand-line-all-buffers
Like @code{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
@code{hippie-expand}.)

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

@item try-expand-list-all-buffers
Like @code{try-expand-list} but searches in all buffers (except the current).

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

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

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

@item 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.

@item 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".

@item try-complete-lisp-symbol
Like @code{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 @code{lisp-complete-symbol},
which already has a key of its own, you might want to remove this.

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

@end table

Not all of the above functions are by default in
@code{hippie-expand-try-functions-list}.  This variable is better set in your
initialization file to make @code{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
@code{make-hippie-expand-function} to construct different
@code{hippie-expand}-like functions, with different try-lists and bound to
different keys. It is also possible to make
@code{hippie-expand-try-functions-list} a buffer local variable, and let it
depend on the mode (by setting it in the mode-hooks).

@node icomplete, tempo, hippie-exp, Top
@chapter 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 @code{icomplete-completions} docstring for a description of the icomplete
display format.

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

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

To configure this package, type:

@example
  M-x customize-group RET icomplete RET
@end example

@node tempo, avoid, icomplete, Top
@chapter 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 @file{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 @code{tempo-backward-mark} and @code{tempo-forward-mark}. If the
template definer provides a prompt for the point, and the variable
@code{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 @code{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 @code{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 @code{foo}, a symbol named
@code{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:

@example
  M-x customize-group RET tempo RET
@end example

@node avoid, blink-cursor, tempo, Top
@chapter 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 @code{M-x mouse-avoidance-mode}.
To set up permanently, add the following to your initialization file:

@example
  (if window-system (mouse-avoidance-mode 'animate))
@end example

The @code{'animate} can be @code{'jump} or @code{'banish} or @code{'exile} or
@code{'protean} if you prefer.  See the documentation for function
@code{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:

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

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

To configure this package, type:

@example
  M-x customize-group RET avoid RET
@end example

@node blink-cursor, fast-lock, avoid, Top
@chapter Blinking Cursor

To activate this package, type:

@example
  M-x blink-cursor-mode RET
@end example

To configure this package, type:

@example
  M-x customize-group RET blink-cursor RET
@end example

@node fast-lock, lazy-lock, blink-cursor, Top
@chapter 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:

@example
  (setq font-lock-support-mode 'fast-lock-mode)
@end example

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

@example
  M-x customize-group RET fast-lock RET
@end example

@node lazy-lock, lazy-shot, fast-lock, Top
@chapter Lazy Demand-Driven Fontification

The purpose of this library is to make visiting buffers in
@code{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:

@example
  (setq font-lock-support-mode 'lazy-lock-mode)
@end example

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 @code{font-lock-mode} enabled) which is at least
@code{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 @code{lazy-lock-stealth-time} seconds of idle time.

To configure this package, type:

@example
  M-x customize-group RET lazy-lock RET
@end example

@node lazy-shot, mic-paren, lazy-lock, Top
@chapter 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:

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

Do not use in combination with @code{lazy-lock}.

@example
  M-x customize-group RET lazy-shot RET
@end example

@node mic-paren, paren, lazy-shot, Top
@chapter 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:

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

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

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

@file{mic-paren.el} is an extension and replacement to the packages
@file{paren.el} and @file{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:

@itemize @bullet

@item

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

@item

Indication of mismatched parentheses.

@item

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

@item

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

@item

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

@item

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

@item

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

@item

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.

@item

Optional delayed highlighting (useful on slow systems),

@item

Functions to activate/deactivate @file{mic-paren.el} are provided.

@item

Numerous options to control the behaviour and appearance of
@file{mic-paren.el}.

@end itemize

To configure this package, type:

@example
  M-x customize-group RET mic-paren-matching RET
@end example

@node paren, shell-font, mic-paren, Top
@chapter 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 @code{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 @code{forward-sexp}
(@kbd{M-C-f}) and @code{backward-sexp} (@kbd{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 @code{paren-mode} is @code{sexp}, entire S-expressions are highlighted
instead of just matching parens.

To configure this package, type:

@example
  M-x customize-group RET paren-matching RET
@end example

@node shell-font, highline, paren, Top
@chapter Decorate a Shell Buffer With Fonts

Do this: @code{(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 @code{shell-prompt}, @code{shell-input} and @code{shell-output} can
be modified as desired, for example, @code{(copy-face 'italic
'shell-prompt)}.

@node highline, highline-keys, shell-font, Top
@chapter 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:

@itemize @bullet

@item LOCAL highline
@item GLOBAL highline
@item INDIRECT highline

@end itemize

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

Indirect highline (@code{highline-view-on}, @code{highline-view-off} and
@code{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.

@menu
* Key Bindings and Example Usage: highline-keys.
* Hooks: highline-hooks.
* Options: highline-options.
@end menu

@node highline-keys, highline-hooks, highline, highline
@section Key Bindings and Example Usage

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

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

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

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

@node highline-hooks, highline-options, highline-keys, highline
@section Hooks

highline has the following hook variables:

@table @code

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

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

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

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

@end table

@node highline-options, buffer-colors, highline-hooks, highline
@section Options

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

@table @code

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

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

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

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

@item highline-verbose
Non-nil means generate messages.

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

@item highline-priority
Specify highline overlay priority.

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

@end table

To configure this package, type:

@example
  M-x highline-customize RET
@end example

@node buffer-colors, after-save-commands, highline-options, Top

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.
 

@node after-save-commands, atomic-extents, buffer-colors, Top
@chapter 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 @code{newaliases(1)} on
@file{/etc/aliases}, @code{xrdb(1)} on @file{~/.Xresources}, installing a new
@file{~/.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 @code{After-save-alist} for more information.

@node atomic-extents, array, after-save-commands, Top
@chapter 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
@code{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:

@example
  (require 'atomic-extents)
@end example

To make an extent atomic use the command:

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

@node array, floating-toolbar, atomic-extents, Top
@chapter 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.

@node floating-toolbar, The Toolbar Utilities, array, Top
@chapter Floating Toolbar

The command @code{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 @code{'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
@code{floating-toolbar}.  This variable can be made buffer local to produce
buffer local floating toolbars.

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

@code{floating-toolbar-from-extent-or-popup-mode-menu} works like
@code{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:

@example
  (require 'floating-toolbar)
@end example

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

@node The Toolbar Utilities, foldout, floating-toolbar, Top
@chapter The Toolbar Utilities
@cindex toolbar

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:

@table @file
@item toolbar-utils.el

The toolbar utility APIs and user commands.

@item edit-toolbar.el

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

@item xemacs-toolbar.el

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

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.

@menu
* Adding Buttons on the Fly::           Quick and convenient.
* The Toolbar Editor::                  Power tools for customization.
* APIs for Adding and Killing::         For Lisp programmers.
* APIs for Search::                     Button, button, who's got the button?
* Toolbar Portability::                 The @file{xemacs-toolbar.el} library.
@end menu

@node Adding Buttons on the Fly, The Toolbar Editor, The Toolbar Utilities, The Toolbar Utilities
@section Adding Buttons on the Fly

@defvr Group edit-toolbar

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

@defvar 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 @code{left}, @code{right}, or
@code{extreme-right}.  @code{left} is synonymous with 0, and
@code{extreme-right} is synonymous with @code{(length toolbar)}.
@code{right} specifies placing a new item at the right end of the
flush-left group of buttons.

Default value: @code{right}.  Customize type: sexp.

See also @samp{toolbar-add-button}, @ref{APIs for Adding and Killing}.
@end defvar

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

Add an button at @var{position} to the default toolbar of the selected
window.  Returns @code{t}.

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

@table @var
@item description
A string describing the action, and displayed as help.

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

@item label
A string used to label the button.

@item position
Optional.  A position (a non-negative integer, or one of the
symbols @code{left}, @code{right}, or @code{extreme-right}.

Default: @code{right}.

@item 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 @code{global}.  It's safe and probably does what
you want.
@end table
@end deffn

@deffn 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.

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

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

@item is-file
Determines the treatment of @var{icon} (q.v.).
@end table

Used interactively, prompts for the macro name @var{mac} and an
@var{icon}.  @var{is-file} is non-@code{nil} if a prefix argument was
used.
@end deffn

@defun toolbar-add-execute-macro-button

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

Unlike @code{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.
@end defun

@defun toolbar-execute-last-kbd-macro
Toolbar thunk which executes the most recently defined keyboard macro.
@end defun

@deffn Command restore-initial-toolbar
Restores the default toolbar defined by @code{initial-toolbar-spec}.

There is also a cache of killed buttons in @code{button-palette}.
@end deffn

@node The Toolbar Editor, APIs for Adding and Killing, Adding Buttons on the Fly, The Toolbar Utilities
@section The Toolbar Editor

To use @file{edit-toolbar.el}, simply type @kbd{M-x edit-toolbar RET}.

For help on the various commands you can type @key{?} in a
@samp{edit-toolbar} buffer.  To save a modified toolbar type @kbd{C-x
C-s} in an @samp{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:

@example
  (load "~/.xemacs/.toolbar")
@end example

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

@table @kbd
@item q

@samp{edit-toolbar-quit}:  Bury the @samp{edit-toolbar} buffer.

@item p
@itemx DEL

@samp{edit-toolbar-previous}:  Select the previous item (line).

@item n
@itemx SPC
@itemx RET

@samp{edit-toolbar-next}:    Select the next item (line).

@item ?

@samp{describe-mode}:  Help.

@item f

@samp{edit-toolbar-set-function}:  Set the command for the current button.

@item h

@samp{edit-toolbar-set-help}:  Set the help string for the current button.

@item a

@samp{edit-toolbar-add-button}:  Add a new empty button.

@item 2

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

@item @@

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

@item 3

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

@item #

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

@item R

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

@item c

@samp{edit-toolbar-copy}:  Copy the selected button.

@item d

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

@item u

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

@item k

@samp{edit-toolbar-kill}:  Kill the selected button.

@item s
@itemx C-x C-s

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

@item r

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

@end table

@node APIs for Adding and Killing, APIs for Search, The Toolbar Editor, The Toolbar Utilities
@section APIs for Adding and Killing

@defvar button-palette
List of buttons cut from toolbars.

Note this is actually a toolbar descriptor.
@end defvar

@defun toolbar-add-item toolbar-spec item &optional position
Add @var{item} to @var{toolbar-spec} at @var{position}, and return
@var{toolbar-spec}.  Uses functions that alter list structure.

@table @var
@item item
A toolbar button or spacer specification (eg, from
@code{toolbar-new-button} or @code{toolbar-new-spacer}).
@item toolbar-spec
A toolbar descriptor (eg, from @code{toolbar-new-toolbar}).
@item position
Optional.  A non-negative integer, with 0 being the extreme left and
\(length @var{toolbar-spec}) the extreme right.  The symbols
@code{left}, @code{right}, and @code{extreme-right} are also accepted.
@code{left} is synonymous with 0.  @code{right} places @var{item} at the
right end of the left group of buttons.  @code{extreme-right} places
@var{item} at the extreme right of the toolbar, creating a right group
if one does not exist.
@end table

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

@var{position} may be greater than (length @var{toolbar-spec}), in which
case it is truncated to (length @var{toolbar-spec}).  Note that
@code{(length @var{toolbar-spec})} is not synonymous with @code{right}
or @code{extreme-right} (@code{extreme-right} will create a right group
if it doesn't already exist).
@end defun

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

@table @var
@item icon-spec
A list of glyphs (from @code{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.)

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

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

@item initially-disabled
Optional.  If non-@code{nil}, specifies that the button should initially
be disabled.

See @code{default-toolbar} or the Lispref (@pxref{Toolbars, , ,
lispref}) for more information.
@end table
@end defun

@defun toolbar-new-spacer style &optional size
Returns a checked toolbar spacer ``button''.

@table @var
@item style
One of the symbols @code{2d} or @code{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.

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

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

@table @var
@item toolbar-spec
May be a list of buttons (ie, a toolbar descriptor, see
@code{default-toolbar}), a toolbar specifier object, a symbol whose
value is a toolbar specifier object, or @code{nil}.  If @code{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 @code{specifier-instance}).  The list thus generated is checked and
returned.

If @var{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 @code{default-toolbar} or the Lispref (@pxref{Toolbars, , ,
lispref}) for more information.
@end table
@end defun

@defun toolbar-kill-item-pos pos &optional toolbar locale
Kill the item at position @var{pos} of @var{toolbar} in @var{locale}.
Killed buttons are prepended to @code{button-palette}.

@var{locale} defaults to @code{global}.  If there are multiple specs for
@var{locale}, take the first one.

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

@node APIs for Search, Toolbar Portability, APIs for Adding and Killing, The Toolbar Utilities
@section APIs for Search

@defun toolbar-find-button item &optional toolbar locale
Return the position of a button containing @var{item} in its
specification. 

@table @var
@item item
May specify a button, spacer, icon, command, help string, or nil.  If
@var{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.)

@item toolbar
If non-@code{nil}, search it; otherwise search the default toolbar.

@item locale
If non-@code{nil}, get @var{toolbar}'s descriptor in that locale,
otherwise use the @code{global} locale.
@end table
@end defun

@defun toolbar-find-item item &optional toolbar locale
Return the position of @var{item}, a button, spacer, or nil.
@var{toolbar} and @var{locale} determine the descriptor to be searched.

If @var{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.
@end defun

@defun toolbar-find-button-by-icon icon &optional toolbar locale
Return the position of a button with icon @var{icon}.
@var{icon} must be a list of glyphs or a symbols whose value is a list
of glyphs.
@var{toolbar} and @var{locale} determine the descriptor to be searched.

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

@defun toolbar-find-button-by-command cmd &optional toolbar locale
Return the position of a button invoking command CMD.  @var{toolbar} and
@var{locale} determine the descriptor to be searched.

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

@defun toolbar-find-button-by-help-string str &optional toolbar locale

Return the position of a button with help-string @var{str}.
@var{toolbar} and @var{locale} determine the descriptor to be searched.

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

@defun toolbar-find-button-by-element object index toolbar locale &optional thunk
Return the position of a button containing @var{object} in element
@var{index}.  @var{toolbar} and @var{locale} determine the descriptor to
be searched.

Optional argument @var{thunk} is a function of one argument which is
used to normalize @var{object} for comparison.

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

@node Toolbar Portability,  , APIs for Search, The Toolbar Utilities
@section Toolbar API Portability to GNU Emacs
@cindex GNU Emacs compatibility
@cindex compatibility libraries, GNU Emacs

The @file{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:

@example
  (if (featurep 'xemacs)
      (require 'toolbar-utils)
    (require 'toolbar-utils "xemacs-toolbar"))
@end example

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 @code{toolbar-add-kbd-macro} and advanced features
such as the toolbar editor and the button cache are not presently
provided.

@node foldout, func-menu, The Toolbar Utilities, Top
@chapter Folding Extensions for Outline-Mode

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

Imagine you're in an @code{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 @kbd{C-c
C-e} @code{(show-entry)} to expose the body or @kbd{C-c C-i} to expose the
child (level-2) headings.

With foldout, you do @kbd{C-c C-z} (@code{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 @kbd{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: @kbd{C-u C-c C-z}.
You can specify the number of levels of children too (c.f. @code{show-children}):
e.g. @kbd{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: @kbd{M-- C-c C-z}.  You can also cause the whole subtree
to be expanded, similar to @kbd{C-c C-s} (@code{show-subtree}), by specifying
a zero argument: @kbd{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 @kbd{C-c C-x} (@code{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, @kbd{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:-

@itemize @bullet

@item mouse-1 (@code{foldout-mouse-zoom}) zooms in on the heading clicked on:

@itemize @minus

@item single click -- expose body

@item double click -- expose subheadings

@item triple click -- expose body and subheadings

@item quad click -- expose entire subtree

@end itemize

@item mouse-2 (@code{foldout-mouse-show}) exposes text under the heading clicked on:

@itemize @minus

@item single click -- expose body

@item double click -- expose subheadings

@item triple click -- expose body and subheadings

@item quad click -- expose entire subtree

@end itemize

@item mouse-3 (@code{foldout-mouse-hide-or-exit}) hides text under the
heading clicked on or exits the fold:

@itemize @minus

@item single click -- hide subtree

@item double click -- exit fold and hide text

@item triple click -- exit fold without hiding text

@item quad click -- exit all folds and hide text

@end itemize

@end itemize

You can change the modifier keys used by setting
@code{foldout-mouse-modifiers}.

To use foldout, put this in your initialization file:

@example
  (require 'foldout)
@end example

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

@example
  (eval-after-load "outline" '(require 'foldout))
@end example

@node func-menu, id-select, foldout, Top
@chapter 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:

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

@node id-select, outl-mouse, func-menu, Top
@chapter 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
@file{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, @code{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,
@code{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, @code{id-select-thing}, may be bound to a key to provide the
same syntax-driven region selection functionality. @kbd{C-c C-m} is a
reasonable site-wide choice since this key is seldom used and it mnemonically
indicates marking something.  @kbd{C-c s} may be preferred as a personal
binding.

Use @kbd{C-g} to unmark the region when done.  Use,
@code{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:

@table @code

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

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

@item 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.

@end table

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

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

To configure this package, type:

@example
  M-x customize-group RET id-select RET
@end example

@node outl-mouse, page-ext, id-select, Top
@chapter Outline-Mode Mouse Commands

Defines @kbd{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 @code{outline-minor-mode} or @code{outline-mode}
are turned on. There is also a menu for each glyph on @kbd{mouse button 3}.

To use, add the following to your initialization file:

@example
  (require 'outl-mouse)
@end example

If you use func-menu all the time and want outl-mouse on all the time as well
then specify @code{(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 @code{outline-mac-style} to t.  If
you want the outline arrows on the left then set
@code{outline-glyphs-on-left} to t. If you have xpm then arrows are much
better defined.

To configure this package, type:

@example
  M-x customize-group RET outl-mouse RET
@end example

@node page-ext, power-macros, outl-mouse, Top
@chapter Extended Page Handling Commands

The page commands are helpful in several different contexts.  For example,
programmers often divide source files into sections using the
@code{page-delimiter}; you can use the @code{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 @code{pages-directory} or
@code{pages-directory-for-addresses} command.

@menu
* Key Assignments: page-ext-keys.
* Using the Page Commands: page-ext-using.
* Address List or Small Database: page-ext-addr.
@end menu

@node page-ext-keys, page-ext-using, page-ext, page-ext
@section Key Assignments

The current page commands are:

@multitable {pages-directory-for-addresses} {C-x C-p  (change this to C-x C-p C-m)}

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

@end multitable

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

The extended page handling commands are:

@multitable {pages-directory-for-addresses} {C-x C-p  (change this to C-x C-p C-m)}

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

@end multitable

@node page-ext-using, page-ext-addr, page-ext-keys, page-ext
@section Using the Page Commands

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

You may change the buffer local value of the @code{page-delimiter} with the
@code{set-page-delimiter} command.  This command is bound to @kbd{C-x C-p
C-l}. The command prompts you for a new value for the @code{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:

@table @code

@item pages-directory-buffer-narrowing-p 
Causes the @code{pages-directory-goto} command to narrow to the destination
page.

@item pages-directory-for-adding-page-narrowing-p 
Causes the @code{add-new-page} command to narrow to the new entry.

@item pages-directory-for-adding-new-page-before-current-page-p
Causes the @code{add-new-page} command to insert a new page before current
page.

@end table

These variables are all true by default.

@node page-ext-addr,  , page-ext-using, page-ext
@section 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 @code{pages-directory} or
@code{pages-directory-for-addresses} command.

Specifically:

@enumerate

@item

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

@item

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 @kbd{C-x C-p C-d}
(@code{pages-directory}) command or the @kbd{C-x C-p d}
(@code{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.

@item

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.

@end enumerate

For example, a file might look like this:

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

    \f
    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.

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

    About philosophy, Whorfian effects, and linguistics.

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

In this example, the heading lines are:

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

The @kbd{C-x C-p s} (@code{sort-pages-buffer}) command sorts the entries in
the buffer alphabetically.

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

You may use either the @kbd{C-x C-p d} (@code{pages-directory-for-addresses})
or the @kbd{C-x C-p C-d} (@code{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
@kbd{C-c C-c} (@code{pages-directory-goto}) to go to the entry to which it
refers in the pages buffer.

You can type @kbd{C-c C-p C-a} (@code{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.

@code{`pages-directory-for-addresses} assumes a default addresses file.  You
do not need to specify the addresses file but merely type @kbd{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, @kbd{C-u C-x C-p d}, it prompts you for a file name.

You may customize the addresses commands:

@table @code

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

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

@item pages-directory-for-addresses-buffer-keep-windows-p
Determines whether @code{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.

@item pages-directory-for-adding-addresses-narrowing-p
Determines whether @code{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.

@end table

Call the @code{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 @code{pages-directory} command has several options:

@enumerate

@item

Called with a prefix arg, @kbd{C-u C-x C-p C-d}, the @code{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, @kbd{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.

@item

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

@item

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

@end enumerate

To configure this package, type:

@example
  M-x customize-group RET pages RET
@end example

@node power-macros, redo, page-ext, Top
@chapter 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:

@example
  M-x pm-manage-macros RET
@end example

To configure the package, type:

@example
  M-x customize-group RET power-macros RET
@end example

@node redo, scroll-in-place, power-macros, Top
@chapter 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:

@enumerate

@item

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.

@item

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

@end enumerate

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

@example
  (require 'redo)
@end example

@node scroll-in-place, setnu, redo, Top
@chapter Scrolling In Place

This library provides improved vertical scrolling commands for GNU Emacs.

@menu
* Features: sip-features.
* Commands and Functions: sip-commands.
* Installation: sip-install.
* Advanced Customization: sip-customize
@end menu

@node sip-features, sip-commands, scroll-in-place, scroll-in-place
@section Features

The new vertical scrolling commands offer the following features:

@itemize @bullet

@item

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 @code{scroll-in-place}, which is true by default, determines
whether or not the standard GNU Emacs scrolling commands (@code{scroll-down},
@code{scroll-up}, @code{scroll-other-window-down}, and
@code{scroll-other-window}) use the "in place" features listed here.  When
@code{scroll-in-place} is nil the standard GNU Emacs scrolling commands
essentially just call the original versions of themselves.  (Note that even
when @code{scroll-in-place} is nil the new versions of @code{scroll-down} and
@code{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
@code{scroll-in-place} for those buffers.  The variable
@code{scroll-in-place} is not usually buffer-local, but you can make it so if
you desire.

@item

Because the improved scrolling commands keep point at its original window
position, these scrolling commands are "reversible."  The @code{scroll-up}
command undoes the effect of the immediately previous @code{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.

@item

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 @code{scroll-up} (@kbd{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, @code{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 @emph{before} any "in place" commands are invoked.  For more
information about grouping commands, see the documentation for the variables
@code{scroll-command-groups} and @code{scroll-default-command-group}.

@item

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

@item

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.

@item

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.

@item

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

@item

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

@end itemize

@node sip-commands, sip-install, sip-features, scroll-in-place
@section Command and Functions

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

@itemize @bullet
@item scroll-down-in-place
@item scroll-up-in-place
@item scroll-other-window-down-in-place
@item scroll-other-window-in-place
@end itemize

The variable @code{scroll-in-place}, which is true by default, determines
whether or not the new versions of the standard GNU Emacs scrolling commands
(@code{scroll-down}, @code{scroll-up}, @code{scroll-other-window-down}, and
@code{scroll-other-window}) use the "in place" features listed above.  When
@code{scroll-in-place} is nil the standard GNU Emacs scrolling commands
essentially just call the original versions of themselves.  (Note that even
when @code{scroll-in-place} is nil the new versions of @code{scroll-down} and
@code{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
@code{scroll-down}, @code{scroll-up}, @code{scroll-other-window-down}, and
@code{scroll-other-window} (in order to check the variable
@code{scroll-in-place}, as described above).  The command
@code{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:

@itemize @bullet
@item scroll-window
@item scroll-window-in-place
@item scroll-window-in-place-continue-sequence
@item scroll-default-lines (variable)
@item scroll-command-groups (variable)
@end itemize

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

The variable @code{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 @code{next-screen-context-lines}.  The variable
@code{scroll-command-groups} contains the explicit groups of "in place"
scrolling commands; for more information read the variable documentation.

@node sip-install, sip-customize, sip-commands, scroll-in-place
@section Installation

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

@example
  (require 'scroll-in-place)
@end example

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

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

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

@node sip-customize,  , sip-install, scroll-in-place
@section Advanced Customization

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

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

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

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

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
@code{scroll-in-place} a buffer-local variable for that buffer and then bind
that local copy of @code{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:

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

The variable @code{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?)

@node setnu, vertical-mode, scroll-in-place, Top
@chapter VI-style Line Number Mode

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

@code{M-x setnu-mode} toggles the line number mode on and off.

@code{turn-on-setnu-mode} is useful for adding to a major-mode hook variable.

@example
  (add-hook 'text-mode-hook 'turn-on-setnu-mode)
@end example

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

@node vertical-mode, align, setnu, Top
@chapter 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 @kbd{spacebar}, waiting for autorepeat to do the
job for you.

@node align, allout, vertical-mode, Top
@chapter 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:

@example
  int a = 1;
  short foo = 2;
  double blah = 4;
@end example

becomes

@example
  int    a    = 1;
  short  foo  = 2;
  double blah = 4;
@end example

@menu
* Align Usage::         How to use the package.
@end menu

@node Align Usage,  , align, align
@section Align Usage

To configure the package, type:

@example
  M-x customize-group RET align RET
@end example

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:

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

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.

@node allout, narrow-stack, align, Top
@chapter Extensive Outline Mode

Allout outline mode provides extensive outline formatting and manipulation
beyond standard emacs outline mode (@pxref{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:

@itemize @bullet

@item topic-oriented repositioning, cut, and paste

@item integral outline exposure-layout

@item incremental search with dynamic exposure and reconcealment of hidden
text

@item automatic topic-number maintenance

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

@end itemize 
 
and many other features.
 
To configure the package, type:

@example
  M-x customize-group RET allout RET
@end example

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

@lisp 
(require 'outline "allout") 
@end lisp 

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):

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

@node narrow-stack, register-menu, allout, Top
@chapter 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 @code{M-x narrow-stack-mode} or add
@code{(narrow-stack-mode)} to your initialization file.

@node register-menu, register-toolbar, narrow-stack, Top

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 @code{M-x 
customize-group RET register-menu RET}

@node register-toolbar, flow-ctrl, register-menu, Top

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: @code{M-x register-toolbar-mode}.
 
@node flow-ctrl, makesum, register-toolbar, Top
@chapter 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
@code{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:

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

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

@node makesum, man, flow-ctrl, Top
@chapter 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:

@example
  M-x make-command-summary RET
@end example

@node man, abbrevlist, makesum, Top
@chapter Browse UNIX manual pages

This library defines the command @code{manual-entry} to browse Unix manual
pages.

To invoke this command, type:

@example
  M-x manual-entry RET
@end example

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

To configure this package, type:

@example
  M-x customize-group RET man RET
@end example

@node abbrevlist, file-part, man, Top
@chapter Abbreviation List

This library not documented.  Please contribute!

@node file-part, info-look, abbrevlist, Top
@chapter Treat a Section of a Buffer as a Separate File

This library not documented.  Please contribute!

@node info-look, live-icon, file-part, Top
@chapter Major-Mode-Sensitive Info Index Lookup Facility

This library not documented.  Please contribute!

@node live-icon, mode-motion+, info-look, Top
@chapter Make Frame Icons Represent Current Frame Contents

This library not documented.  Please contribute!

@node mode-motion+, popper, live-icon, Top
@chapter Per Mode/Buffer Mouse Tracking With Highlighting

This library not documented.  Please contribute!

@node popper, reportmail, mode-motion+, Top
@chapter Shrink-Wrapped Temporary Windows

This library not documented.  Please contribute!

@node reportmail, balloon-help, popper, Top
@chapter Display Time and Load in Mode Line

This library not documented.  Please contribute!

@node balloon-help, blink-paren, reportmail, Top
@chapter Balloon Help and Tooltips

This library not documented.  Please contribute!

@node blink-paren, edit-faces, balloon-help, Top
@chapter Blinking Parentheses

This library not documented.  Please contribute!

@node edit-faces, lispm-fonts, blink-paren, Top
@chapter Face Editor

This library not documented.  Please contribute!

@node lispm-fonts, big-menubar, edit-faces, Top
@chapter lispm-fonts

This library not documented.  Please contribute!

@node big-menubar, tree-menu, lispm-fonts, Top
@chapter Big Menubar

This library not documented.  Please contribute!

@node tree-menu, XEmacs License, big-menubar, Top
@chapter tree-menu

This library not documented.  Please contribute!

@node XEmacs License,  , tree-menu, Top
@chapter XEmacs License
@unnumbered GNU GENERAL PUBLIC LICENSE
@center Version 2, June 1991

@display
Copyright @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.
@end display

@unnumberedsec 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.

@iftex
@unnumberedsec TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
@end iftex
@ifnottex
@center TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
@end ifnottex

@enumerate 0
@item
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.

@item
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.

@item
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:

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

@item
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.

@item
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.)
@end enumerate

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.

@item
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:

@enumerate a
@item
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,

@item
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,

@item
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.)
@end enumerate

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.

@item
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.

@item
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.

@item
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.

@item
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.

@item
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.

@item
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.

@item
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.

@iftex
@heading NO WARRANTY
@end iftex
@ifnottex
@center NO WARRANTY
@end ifnottex

@item
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.

@item
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 enumerate

@iftex
@heading END OF TERMS AND CONDITIONS
@end iftex
@ifnottex
@center END OF TERMS AND CONDITIONS
@end ifnottex

@page
@unnumberedsec 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.

@smallexample
@var{one line to give the program's name and an idea of what it does.}
Copyright (C) 19@var{yy}  @var{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.
@end smallexample

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:

@smallexample
Gnomovision version 69, Copyright (C) 19@var{yy} @var{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.
@end smallexample

The hypothetical commands @samp{show w} and @samp{show c} should show
the appropriate parts of the General Public License.  Of course, the
commands you use may be called something other than @samp{show w} and
@samp{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:

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

@var{signature of Ty Coon}, 1 April 1989
Ty Coon, President of Vice
@end group
@end smallexample

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.