This is edit-utils.info, produced by makeinfo version 4.6 from
edit-utils.texi.

INFO-DIR-SECTION XEmacs Editor
START-INFO-DIR-ENTRY
* Edit Utilities: (edit-utils).	Editing utilities for XEmacs.
END-INFO-DIR-ENTRY

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.

File: edit-utils.info,  Node: Top,  Next: Copying,  Prev: (dir),  Up: (dir)

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

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

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

* 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 Apecific Column, By Regexp
* allout::                      Extensive Outline Mode

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

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


File: edit-utils.info,  Node: Copying,  Next: compare-w,  Prev: Top,  Up: Top

Copying
*******

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

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

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

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

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

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

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

   A bit of advocacy:

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

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


File: edit-utils.info,  Node: compare-w,  Next: detached-minibuf,  Prev: Copying,  Up: Top

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.


File: edit-utils.info,  Node: detached-minibuf,  Next: iswitchb,  Prev: compare-w,  Up: Top

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

This package creates a standalone minibuffer in its own frame.

   To configure this package, type:

       M-x customize-group RET detached-minibuf RET


File: edit-utils.info,  Node: iswitchb,  Next: permanent-buffers,  Prev: detached-minibuf,  Up: Top

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

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

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

   `iswitch {123456,123}'

   If I then press `2':

   `iswitch 2[3]{123456,123}'

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

   `iswitch 23{123456,123}'

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

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

   `iswitch 234[123456] [Matched]'

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

   If however, I now type `a':

   `iswitch 234a [No match]'

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

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

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

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

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

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

       M-x describe-function RET iswitchb

* Menu:

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


File: edit-utils.info,  Node: iswitchb-cust,  Next: Changing the Display,  Prev: iswitchb,  Up: iswitchb

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

To configure the package, type:

       M-x customize-group RET iswitchb RET

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

       M-x iswitchb-default-keybindings RET

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

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


File: edit-utils.info,  Node: Changing the Display,  Next: Regexp Matching,  Prev: iswitchb-cust,  Up: iswitchb

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

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

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

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

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

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


File: edit-utils.info,  Node: Regexp Matching,  Next: Replacement for read-buffer,  Prev: Changing the Display,  Up: iswitchb

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

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


File: edit-utils.info,  Node: Replacement for read-buffer,  Prev: Regexp Matching,  Up: iswitchb

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

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


File: edit-utils.info,  Node: permanent-buffers,  Next: rsz-minibuf,  Prev: iswitchb,  Up: Top

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

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

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

   To configure this package, type:

       M-x customize-group RET permanent-buffers RET


File: edit-utils.info,  Node: rsz-minibuf,  Next: search-buffers,  Prev: permanent-buffers,  Up: Top

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

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

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

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

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

   To invoke this mode, type:

       M-x resize-minibuffer-mode RET

   To configure this package, type:

       M-x customize-group RET resize-minibuffer RET


File: edit-utils.info,  Node: search-buffers,  Next: uniquify,  Prev: rsz-minibuf,  Up: Top

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

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

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

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

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


File: edit-utils.info,  Node: uniquify,  Next: winring,  Prev: search-buffers,  Up: Top

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

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

   To configure this package, type:

       M-x customize-group RET uniquify RET


File: edit-utils.info,  Node: winring,  Next: autorevert,  Prev: uniquify,  Up: Top

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

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

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

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

   To use, add the following to your initialization file:

       (winring-initialize)

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

   The following commands are defined:

`C-x 7 n'
     Create a new window configuration.  The new configuration will
     contain a single buffer, the one named in the variable
     `winring-new-config-buffer-name'.

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

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

`C-x 7 j'
     Jump to a named configuration (prompts for the name).

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

`C-x 7 o'
     Go to the next configuration on the ring.

`C-x 7 p'
     Go to the previous configuration on the ring.

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

`C-x 7 r'
     Rename the current window configuration.

`C-x 7 b'
     Submit a bug report on winring.

`C-x 7 v'
     Echo the winring version.


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

* Menu:

* History::
* Related Packages::


File: edit-utils.info,  Node: History,  Next: Related Packages,  Prev: winring,  Up: winring

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.


File: edit-utils.info,  Node: Related Packages,  Prev: History,  Up: winring

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

I know of a few other related packages:

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

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

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

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


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


File: edit-utils.info,  Node: autorevert,  Next: backup-dir,  Prev: winring,  Up: Top

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.


File: edit-utils.info,  Node: Auto-Revert Usage,  Prev: autorevert,  Up: autorevert

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

To configure the package, type:

       M-x customize-group RET auto-revert RET

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

       M-x auto-revert-mode RET

   To activate Global Auto-Revert Mode, type:

       M-x global-auto-revert-mode RET

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

       (global-auto-revert-mode 1)

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

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


File: edit-utils.info,  Node: backup-dir,  Next: bookmark,  Prev: autorevert,  Up: Top

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

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

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

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

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

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

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

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

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

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


File: edit-utils.info,  Node: bookmark,  Next: desktop,  Prev: backup-dir,  Up: Top

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

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

   To configure this package, type:

       M-x customize-group RET bookmark RET


File: edit-utils.info,  Node: desktop,  Next: recent-files,  Prev: bookmark,  Up: Top

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

Save the Desktop, i.e.,

   * some global variables

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

        * the major mode

        * the default directory

        * the point

        * the mark & mark-active

        * buffer-read-only

        * some local variables



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

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

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

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

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

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

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

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

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

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

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

   To configure this package, type:

       M-x customize-group RET desktop RET


File: edit-utils.info,  Node: recent-files,  Next: resume,  Prev: desktop,  Up: Top

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

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

       (recent-files-initialize)

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

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

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

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

   The command "Kill buffer <buffer> and delete entry" is handy when
you have accidently 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.


File: edit-utils.info,  Node: recentf-cust,  Prev: recent-files,  Up: recent-files

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

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

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

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

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

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

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

     The default is empty.

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

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

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

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

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

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

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

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

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

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

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

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



File: edit-utils.info,  Node: resume,  Next: saveconf,  Prev: recent-files,  Up: Top

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

This library not documented.  Please contribute!


File: edit-utils.info,  Node: saveconf,  Next: savehist,  Prev: resume,  Up: Top

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

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

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

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

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

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

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

   To use the package put these lines

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

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


File: edit-utils.info,  Node: savehist,  Next: saveplace,  Prev: saveconf,  Up: Top

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

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

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

       (savehist-load)

   To configure this package, type:

       M-x customize-group RET savehist RET


File: edit-utils.info,  Node: saveplace,  Next: where-was-i-db,  Prev: savehist,  Up: Top

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

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

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

       (require 'saveplace)

   To configure this package, type:

       M-x customize-group RET saveplace RET


File: edit-utils.info,  Node: where-was-i-db,  Next: completion,  Prev: saveplace,  Up: Top

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

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

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

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

       M-x toggle-where-was-i

   which, using auto-completion, can be entered as

       M-x tog TAB w TAB

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

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

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

   This feature can be unloaded with:

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

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

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

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

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

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

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

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

   To configure this package, type:

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


File: edit-utils.info,  Node: completion,  Next: dabbrev,  Prev: where-was-i-db,  Up: Top

Completion
**********

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

       (require 'completion)

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

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

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

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

   Completions are automatically saved to a file between sessions.

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

   To configure this package, type:

       M-x customize-group RET completion RET


File: edit-utils.info,  Node: dabbrev,  Next: hippie-exp,  Prev: completion,  Up: Top

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

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

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

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

   To configure this package, type:

       M-x customize-group RET dabbrev RET


File: edit-utils.info,  Node: hippie-exp,  Next: icomplete,  Prev: dabbrev,  Up: Top

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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


File: edit-utils.info,  Node: icomplete,  Next: tempo,  Prev: hippie-exp,  Up: Top

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

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

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

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

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

   To configure this package, type:

       M-x customize-group RET icomplete RET


File: edit-utils.info,  Node: tempo,  Next: avoid,  Prev: icomplete,  Up: Top

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

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

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

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

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

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

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

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

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

   To configure this package, type:

       M-x customize-group RET tempo RET


File: edit-utils.info,  Node: avoid,  Next: blink-cursor,  Prev: tempo,  Up: Top

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

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

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

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

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

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

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

   To configure this package, type:

       M-x customize-group RET avoid RET


File: edit-utils.info,  Node: blink-cursor,  Next: fast-lock,  Prev: avoid,  Up: Top

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

To activate this package, type:

       M-x blink-cursor-mode RET

   To configure this package, type:

       M-x customize-group RET blink-cursor RET


File: edit-utils.info,  Node: fast-lock,  Next: lazy-lock,  Prev: blink-cursor,  Up: Top

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

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

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

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

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

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

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

   To configure this package, type:

       M-x customize-group RET fast-lock RET


File: edit-utils.info,  Node: lazy-lock,  Next: lazy-shot,  Prev: fast-lock,  Up: Top

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

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

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

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

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

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

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

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

   To configure this package, type:

       M-x customize-group RET lazy-lock RET


File: edit-utils.info,  Node: lazy-shot,  Next: mic-paren,  Prev: lazy-lock,  Up: Top

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

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

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

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

   Do not use in combination with `lazy-lock'.

       M-x customize-group RET lazy-shot RET


File: edit-utils.info,  Node: mic-paren,  Next: paren,  Prev: lazy-shot,  Up: Top

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

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

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

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

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

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

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

   Features include:

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

   *  Indication of mismatched parentheses.

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

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

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

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

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

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

   *  Optional delayed highlighting (useful on slow systems),

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

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


   To configure this package, type:

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


File: edit-utils.info,  Node: paren,  Next: shell-font,  Prev: mic-paren,  Up: Top

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

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

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

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

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

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

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

   To configure this package, type:

       M-x customize-group RET paren-matching RET


File: edit-utils.info,  Node: shell-font,  Next: after-save-commands,  Prev: paren,  Up: Top

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

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

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


File: edit-utils.info,  Node: after-save-commands,  Next: atomic-extents,  Prev: shell-font,  Up: Top

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

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

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

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

   See variable `After-save-alist' for more information.


File: edit-utils.info,  Node: atomic-extents,  Next: array,  Prev: after-save-commands,  Up: Top

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

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

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

       (require 'atomic-extents)

   To make an extent atomic use the command:

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


File: edit-utils.info,  Node: array,  Next: floating-toolbar,  Prev: atomic-extents,  Up: Top

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.


File: edit-utils.info,  Node: floating-toolbar,  Next: The Toolbar Utilities,  Prev: array,  Up: Top

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

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

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

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

   Add the following line to your initialization file:

       (require 'floating-toolbar)

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


File: edit-utils.info,  Node: The Toolbar Utilities,  Next: foldout,  Prev: floating-toolbar,  Up: Top

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

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

   The toolbar utilities are implemented in three files:

`toolbar-utils.el'
     The toolbar utility APIs and user commands.

`edit-toolbar.el'
     The near-WYSIWYG toolbar editor by Peter D. Pezaris.

`xemacs-toolbar.el'
     The XEmacs compatibility API for programs that should also run
     under GNU Emacs.

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

* 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 `xemacs-toolbar.el' library.


File: edit-utils.info,  Node: Adding Buttons on the Fly,  Next: The Toolbar Editor,  Prev: The Toolbar Utilities,  Up: The Toolbar Utilities

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

 - Group: edit-toolbar
     Customize group of tools for interactive editing and
     non-interactive management of toolbars.

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

     Default value: `right'.  Customize type: sexp.

     See also `toolbar-add-button', *Note APIs for Adding and Killing::.

 - Command: toolbar-add-button-on-the-fly description command label
          &optional position locale
     Add an button at POSITION to the default toolbar of the selected
     window.  Returns `t'.

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

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

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

    LABEL
          A string used to label the button.

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

          Default: `right'.

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

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

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

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

    IS-FILE
          Determines the treatment of ICON (q.v.).

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

 - Function: toolbar-add-execute-macro-button
     Add a button to the global toolbar to execute the last keyboard
     macro.

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

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

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

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

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


File: edit-utils.info,  Node: The Toolbar Editor,  Next: APIs for Adding and Killing,  Prev: Adding Buttons on the Fly,  Up: The Toolbar Utilities

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

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

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

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

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

`q'
     `edit-toolbar-quit':  Bury the `edit-toolbar' buffer.

`p'
`DEL'
     `edit-toolbar-previous':  Select the previous item (line).

`n'
`SPC'
`RET'
     `edit-toolbar-next':    Select the next item (line).

`?'
     `describe-mode':  Help.

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

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

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

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

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

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

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

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

`c'
     `edit-toolbar-copy':  Copy the selected button.

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

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

`k'
     `edit-toolbar-kill':  Kill the selected button.

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

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



File: edit-utils.info,  Node: APIs for Adding and Killing,  Next: APIs for Search,  Prev: The Toolbar Editor,  Up: The Toolbar Utilities

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

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

     Note this is actually a toolbar descriptor.

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

    ITEM
          A toolbar button or spacer specification (eg, from
          `toolbar-new-button' or `toolbar-new-spacer').

    TOOLBAR-SPEC
          A toolbar descriptor (eg, from `toolbar-new-toolbar').

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

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

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

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

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

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

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

    INITIALLY-DISABLED
          Optional.  If non-`nil', specifies that the button should
          initially be disabled.

          See `default-toolbar' or the Lispref (*note Toolbars:
          (lispref)Toolbars.) for more information.

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

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

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

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

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

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

          See `default-toolbar' or the Lispref (*note Toolbars:
          (lispref)Toolbars.) for more information.

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

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

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


File: edit-utils.info,  Node: APIs for Search,  Next: Toolbar Portability,  Prev: APIs for Adding and Killing,  Up: The Toolbar Utilities

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

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

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

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

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

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

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

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

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

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

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

 - Function: toolbar-find-button-by-help-string str &optional toolbar
          locale
     Return the position of a button with help-string STR.  TOOLBAR and
     LOCALE determine the descriptor to be searched.

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

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

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

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


File: edit-utils.info,  Node: Toolbar Portability,  Prev: APIs for Search,  Up: The Toolbar Utilities

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

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

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

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

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

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


File: edit-utils.info,  Node: foldout,  Next: func-menu,  Prev: The Toolbar Utilities,  Up: Top

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

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

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

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

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

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

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

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

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

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

        - single click - expose body

        - double click - expose subheadings

        - triple click - expose body and subheadings

        - quad click - expose entire subtree


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

        - single click - expose body

        - double click - expose subheadings

        - triple click - expose body and subheadings

        - quad click - expose entire subtree


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

        - single click - hide subtree

        - double click - exit fold and hide text

        - triple click - exit fold without hiding text

        - quad click - exit all folds and hide text



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

   To use foldout, put this in your initialization file:

       (require 'foldout)

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

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


File: edit-utils.info,  Node: func-menu,  Next: id-select,  Prev: foldout,  Up: Top

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

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

   The following modes are supported:

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

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

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


File: edit-utils.info,  Node: id-select,  Next: outl-mouse,  Prev: func-menu,  Up: Top

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

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

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

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

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

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

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

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

   Three other commands are also provided:

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

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

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


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

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

   To configure this package, type:

       M-x customize-group RET id-select RET


File: edit-utils.info,  Node: outl-mouse,  Next: page-ext,  Prev: id-select,  Up: Top

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

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

   To use, add the following to your initialization file:

       (require 'outl-mouse)

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

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

   To configure this package, type:

       M-x customize-group RET outl-mouse RET


File: edit-utils.info,  Node: page-ext,  Next: power-macros,  Prev: outl-mouse,  Up: Top

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

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

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

* Menu:

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


File: edit-utils.info,  Node: page-ext-keys,  Next: page-ext-using,  Prev: page-ext,  Up: page-ext

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

The current page commands are:

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

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

   The extended page handling commands are:

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


File: edit-utils.info,  Node: page-ext-using,  Next: page-ext-addr,  Prev: page-ext-keys,  Up: page-ext

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

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

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

   You may set several user options:

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

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

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


   These variables are all true by default.


File: edit-utils.info,  Node: page-ext-addr,  Prev: page-ext-using,  Up: page-ext

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

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

   Specifically:

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

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

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

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


   For example, a file might look like this:

         FSF
         Free Software Foundation
         59 Temple Place - Suite 330
         Boston, MA 02111-1307  USA.
         (617) 542-5942
         gnu@prep.ai.mit.edu
     
         
         House Subcommittee on Intellectual Property,
         U.S. House of Representatives,
         Washington, DC  20515
     
         Congressional committee concerned with permitting or preventing
         monopolistic restrictions on the use of software technology.
     
         
         George Lakoff
         ``Women, Fire, and Dangerous Things:
         What Categories Reveal about the Mind''
         1987, Univ. of Chicago Press
     
         About philosophy, Whorfian effects, and linguistics.
     
         
         OBI   (On line text collection.)
         Open Book Initiative
         c/o Software Tool & Die
         1330 Beacon St, Brookline, MA 02146 USA
         (617) 739-0202
         obi@world.std.com

   In this example, the heading lines are:

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

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

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

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

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

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

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

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

   You may customize the addresses commands:

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

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

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

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


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

   The `pages-directory' command has several options:

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

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

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


   To configure this package, type:

       M-x customize-group RET pages RET


File: edit-utils.info,  Node: power-macros,  Next: redo,  Prev: page-ext,  Up: Top

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

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

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

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

   To execute this function, type:

       M-x pm-manage-macros RET

   To configure the package, type:

       M-x customize-group RET power-macros RET


File: edit-utils.info,  Node: redo,  Next: scroll-in-place,  Prev: power-macros,  Up: Top

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

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

   The redo/undo system is different in two ways:

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

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


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

       (require 'redo)


File: edit-utils.info,  Node: scroll-in-place,  Next: setnu,  Prev: redo,  Up: Top

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


File: edit-utils.info,  Node: sip-features,  Next: sip-commands,  Prev: scroll-in-place,  Up: scroll-in-place

Features
========

The new vertical scrolling commands offer the following features:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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



File: edit-utils.info,  Node: sip-commands,  Next: sip-install,  Prev: sip-features,  Up: scroll-in-place

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

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

   * scroll-down-in-place

   * scroll-up-in-place

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

   * scroll-other-window-in-place

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

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

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

   * scroll-window

   * scroll-window-in-place

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

   * scroll-default-lines (variable)

   * scroll-command-groups (variable)

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

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


File: edit-utils.info,  Node: sip-install,  Next: sip-customize,  Prev: sip-commands,  Up: scroll-in-place

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

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

       (require 'scroll-in-place)

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

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

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


File: edit-utils.info,  Node: sip-customize,  Prev: sip-install,  Up: scroll-in-place

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

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

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

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

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

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

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

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


File: edit-utils.info,  Node: setnu,  Next: vertical-mode,  Prev: scroll-in-place,  Up: Top

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

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

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

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

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

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


File: edit-utils.info,  Node: vertical-mode,  Next: align,  Prev: setnu,  Up: Top

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

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


File: edit-utils.info,  Node: align,  Next: allout,  Prev: vertical-mode,  Up: Top

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

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

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

   becomes

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

* Menu:

* Align Usage::		How to use the package.


File: edit-utils.info,  Node: Align Usage,  Prev: align,  Up: align

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

To configure the package, type:

       M-x customize-group RET align RET

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

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

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

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


File: edit-utils.info,  Node: allout,  Next: flow-ctrl,  Prev: align,  Up: Top

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

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

   In addition to outline navigation and exposure, allout includes:

   * topic-oriented repositioning, cut, and paste

   * integral outline exposure-layout

   * incremental search with dynamic exposure and reconcealment of
     hidden text

   * automatic topic-number maintenance

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


   and many other features.

   To configure the package, type:

       M-x customize-group RET allout RET

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

     (require 'outline "allout")

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

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

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

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

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


File: edit-utils.info,  Node: flow-ctrl,  Next: makesum,  Prev: allout,  Up: Top

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

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

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

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

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


File: edit-utils.info,  Node: makesum,  Next: man,  Prev: flow-ctrl,  Up: Top

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

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

   To invoke this command, type:

       M-x make-command-summary RET


File: edit-utils.info,  Node: man,  Next: abbrevlist,  Prev: makesum,  Up: Top

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

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

   To invoke this command, type:

       M-x manual-entry RET

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

   To configure this package, type:

       M-x customize-group RET man RET


File: edit-utils.info,  Node: abbrevlist,  Next: file-part,  Prev: man,  Up: Top

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

This library not documented.  Please contribute!


File: edit-utils.info,  Node: file-part,  Next: info-look,  Prev: abbrevlist,  Up: Top

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

This library not documented.  Please contribute!


File: edit-utils.info,  Node: info-look,  Next: live-icon,  Prev: file-part,  Up: Top

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

This library not documented.  Please contribute!


File: edit-utils.info,  Node: live-icon,  Next: mode-motion+,  Prev: info-look,  Up: Top

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

This library not documented.  Please contribute!


File: edit-utils.info,  Node: mode-motion+,  Next: popper,  Prev: live-icon,  Up: Top

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

This library not documented.  Please contribute!


File: edit-utils.info,  Node: popper,  Next: reportmail,  Prev: mode-motion+,  Up: Top

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

This library not documented.  Please contribute!


File: edit-utils.info,  Node: reportmail,  Next: balloon-help,  Prev: popper,  Up: Top

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

This library not documented.  Please contribute!


File: edit-utils.info,  Node: balloon-help,  Next: blink-paren,  Prev: reportmail,  Up: Top

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

This library not documented.  Please contribute!


File: edit-utils.info,  Node: blink-paren,  Next: edit-faces,  Prev: balloon-help,  Up: Top

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

This library not documented.  Please contribute!


File: edit-utils.info,  Node: edit-faces,  Next: lispm-fonts,  Prev: blink-paren,  Up: Top

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

This library not documented.  Please contribute!


File: edit-utils.info,  Node: lispm-fonts,  Next: big-menubar,  Prev: edit-faces,  Up: Top

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

This library not documented.  Please contribute!


File: edit-utils.info,  Node: big-menubar,  Next: tree-menu,  Prev: lispm-fonts,  Up: Top

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

This library not documented.  Please contribute!


File: edit-utils.info,  Node: tree-menu,  Next: XEmacs License,  Prev: big-menubar,  Up: Top

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

This library not documented.  Please contribute!


File: edit-utils.info,  Node: XEmacs License,  Prev: tree-menu,  Up: Top

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

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

                         Version 2, June 1991
     Copyright (C) 1989, 1991 Free Software Foundation, Inc.
     675 Mass Ave, Cambridge, MA 02139, USA
     
     Everyone is permitted to copy and distribute verbatim copies
     of this license document, but changing it is not allowed.

Preamble
========

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

                                NO WARRANTY

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

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

                      END OF TERMS AND CONDITIONS

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

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

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

     ONE LINE TO GIVE THE PROGRAM'S NAME AND AN IDEA OF WHAT IT DOES.
     Copyright (C) 19YY  NAME OF AUTHOR
     
     This program is free software; you can redistribute it and/or
     modify it under the terms of the GNU General Public License
     as published by the Free Software Foundation; either version 2
     of the License, or (at your option) any later version.
     
     This program is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     GNU General Public License for more details.
     
     You should have received a copy of the GNU General Public License
     along with this program; if not, write to the Free Software
     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

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

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

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

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

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

     Yoyodyne, Inc., hereby disclaims all copyright
     interest in the program `Gnomovision'
     (which makes passes at compilers) written
     by James Hacker.
     
     SIGNATURE OF TY COON, 1 April 1989
     Ty Coon, President of Vice

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



Tag Table:
Node: Top923
Node: Copying5597
Node: compare-w9743
Node: detached-minibuf10136
Node: iswitchb10428
Node: iswitchb-cust13794
Node: Changing the Display14500
Node: Regexp Matching16035
Node: Replacement for read-buffer16826
Node: permanent-buffers17401
Node: rsz-minibuf18420
Node: search-buffers19508
Node: uniquify20192
Node: winring20952
Node: History24258
Node: Related Packages25320
Node: autorevert26468
Node: Auto-Revert Usage27486
Node: backup-dir28391
Node: bookmark30788
Node: desktop31205
Node: recent-files34075
Node: recentf-cust36300
Node: resume40958
Node: saveconf41159
Node: savehist42679
Node: saveplace43449
Node: where-was-i-db44078
Node: completion48693
Node: dabbrev50130
Node: hippie-exp50699
Node: icomplete55630
Node: tempo56786
Node: avoid59324
Node: blink-cursor60605
Node: fast-lock60879
Node: lazy-lock61890
Node: lazy-shot63128
Node: mic-paren63996
Node: paren67152
Node: shell-font68377
Node: after-save-commands68883
Node: atomic-extents69702
Node: array70461
Node: floating-toolbar70791
Node: The Toolbar Utilities71925
Node: Adding Buttons on the Fly73410
Node: The Toolbar Editor76843
Node: APIs for Adding and Killing79210
Node: APIs for Search84398
Node: Toolbar Portability87134
Node: foldout87981
Node: func-menu91831
Node: id-select93051
Node: outl-mouse96476
Node: page-ext97468
Node: page-ext-keys98250
Node: page-ext-using99371
Node: page-ext-addr100529
Node: power-macros106213
Node: redo107337
Node: scroll-in-place108508
Node: sip-features108853
Node: sip-commands117449
Node: sip-install119956
Node: sip-customize120775
Node: setnu122510
Node: vertical-mode122984
Node: align123459
Node: Align Usage123945
Node: allout124964
Node: flow-ctrl128169
Node: makesum128975
Node: man129283
Node: abbrevlist129704
Node: file-part129875
Node: info-look130110
Node: live-icon130346
Node: mode-motion+130589
Node: popper130827
Node: reportmail131034
Node: balloon-help131245
Node: blink-paren131443
Node: edit-faces131631
Node: lispm-fonts131800
Node: big-menubar131969
Node: tree-menu132137
Node: XEmacs License132304

End Tag Table
