Commits

Anonymous committed c9fe270

Import from CVS: tag r21-0b43

Comments (0)

Files changed (90)

 							-*- indented-text -*-
+to 21.0 beta43 "Spanish"
+-- texinfo documentation synched from GNU texinfo-3.12
+-- Manual cleanup from Adrian Aichner
+-- Miscellaneous fixes from Rick Rankin
+-- D'n'D fixes from Oliver Graf
+-- startup changes from Stephen Turnbull
+-- Miscellaneous fixes from Kirill Katsnelson
+-- PNG Graphics fix from Gunnar Evermann
+-- Miscellaneous MS windows patches from Andy Piper
+-- Graphics update from Hrvoje Niksic
+-- Miscellaneous patches from Hrvoje Niksic
+-- NEWS updates from Hrvoje Niksic
+-- Grayscale JPEG fix from Jareth Hein
+-- Miscellaneous patches from Didier Verna
+-- Miscellaneous patches from Altrasoft
+
 to 21.0 beta42 "Somali"
 -- Sounds are no longer included in the core distribution
 -- Unexec fix for SGI from Olivier Galibert
+1998-06-11  SL Baur  <steve@altair.xemacs.org>
+
+	* XEmacs 21.0-beta 43 is released.
+
+1998-06-04  Oliver Graf <ograf@fga.de>
+
+	* tests/Dnd/README: a step-by-step test run
+	* tests/Dnd/droptest.el: some clarifications
+	* tests/Dnd/droptest.sh: created, creates test files
+
+1998-06-01  Oliver Graf <ograf@fga.de>
+
+	* configure.in (summary): added experimental to dragndrop option
+	* configure.usage: added experimental note to --with-dragndrop
+	* tests/Dnd/droptest.el: extra start-drag-region function
+	changed the experimental- stuff
+
+1998-06-02  Andy Piper  <andyp@parallax.co.uk>
+
+	* etc/check_cygwin_setup.sh: set more intelligent defaults for
+	windows 95.
+
+1998-06-07  SL Baur  <steve@altair.xemacs.org>
+
+	* lwlib/xlwmenu.c: Add room for the 0 byte sentinel.
+
+1998-06-05  Colin Rafferty   <colin@xemacs.org>
+
+	* lwlib/xlwmenu.c: Made newchars be as large as it needs to be.
+
 1998-06-01  SL Baur  <steve@altair.xemacs.org>
 
 	* XEmacs 21.0-beta42 is released.
 	* configure.in: Switch from giflib to gifreader for
 	our GIF image support (no other mods needed)
 
-1998-05-28  Oliver Graf <ograf@fga.de>
+1998-05-28  Oliver Graf  <ograf@fga.de>
 
 	* configure.in: only one DnD protocol, CDE has priority over OffiX
 
 	* tests/Dnd/dragtest.el: removed
 	* tests/Dnd/droptest.el: cosmetics and comments
 
-1998-05-26  Oliver Graf <ograf@fga.de>
+1998-05-26  Oliver Graf  <ograf@fga.de>
 
 	* tests/Dnd/droptest.el: adapted to CDE extensions
 
+1998-05-25  Hans Guenter Weigand  <hgweigand@wiesbaden.netsurf.de>
+
+	* configure.in:
+	* config.sub: add initial OpenBSD support
+
 1998-05-21  Andy Piper  <andyp@parallax.co.uk>
 
 	* configure.in: check for msw dialogs.
 test "$with_cde"      = yes && echo "  Compiling in support for CDE."
 test "$with_tooltalk" = yes && echo "  Compiling in support for ToolTalk."
 test "$with_offix"    = yes && echo "  Compiling in support for OffiX."
-test "$with_dragndrop" = yes && echo "  Compiling in support for Drag'n'Drop ($dragndrop_proto )."
+test "$with_dragndrop" = yes && echo "  Compiling in EXPERIMENTAL support for Drag'n'Drop ($dragndrop_proto )."
 test "$with_workshop" = yes && echo "  Compiling in support for Sun WorkShop."
 test "$with_session"  != no && echo "  Compiling in support for proper session-management."
 case "$with_menubars" in
 test "$with_cde"      = yes && echo "  Compiling in support for CDE."
 test "$with_tooltalk" = yes && echo "  Compiling in support for ToolTalk."
 test "$with_offix"    = yes && echo "  Compiling in support for OffiX."
-test "$with_dragndrop" = yes && echo "  Compiling in support for Drag'n'Drop ($dragndrop_proto )."
+test "$with_dragndrop" = yes && echo "  Compiling in EXPERIMENTAL support for Drag'n'Drop ($dragndrop_proto )."
 test "$with_workshop" = yes && echo "  Compiling in support for Sun WorkShop."
 test "$with_session"  != no && echo "  Compiling in support for proper session-management."
 case "$with_menubars" in
 --with-dragndrop (*)	Compile in the generic drag and drop API. This is
 			automatically added if one of the drag and drop
 			protocols is found (currently CDE, OffiX, MSWindows).
+			*WARNING*  The Drag'n'drop support is under development
+				   and is considered experimental.
 --with-cde (*)		Compile in support for CDE drag and drop.
 --with-offix (*)	Compile in support for OffiX drag and drop.
 --without-xmu (*)	For those unfortunates whose vendors don't ship Xmu.
 See the file `etc/PACKAGES' in the distribution for a full
 description.
 
+** XEmacs is now supported under Microsoft Windows 95/98 and Windows
+NT operating systems.  For starters, look at the XEmacs on Windows FAQ
+at <URL:http://jagor.srce.hr/~hniksic/xemacs-on-windows.txt>.  To
+discuss Windows-specific issues, subscribe to the mailing list at
+<xemacs-nt-request@xemacs.org>.
+
+** XEmacs will now use `XEmacs' as its application class if it finds
+any `XEmacs' resources in the resource database.  Otherwise, it will
+continue to use the `Emacs' class.
+
 ** When the Zmacs region is active, `M-x query-replace' and the other
 replace commands now operate on the region contents only.
 
 or the native C libraries support Japanese localization.  This has
 been available since 20.3, only it hasn't been announced before.
 
-** Jamie Zawinski's `gdb-highlight' program is now distributed with
+** Jamie Zawinski's `gdb-highlight' extension is now distributed with
 the `debug' package.  gdb-highlight makes most objects printed in a
 gdb buffer be mouse-sensitive: as text shows up in the buffer, it is
 parsed, and objects which are recognized have context-sensitive
 
   (add-hook 'gdb-mode-hook (lambda () (require 'gdb-highlight)))
 
+** The package popper.el is now included in the edit-utils package.
+It has been greatly enhanced with respect to the one once included
+with the ilisp package and should work well under XEmacs 21.0.
+
 ** C mode changes
 
 *** Multiline macros are now handled, both as they affect indentation,
 If you want spaces at the beginning of a line to start a paragraph,
 use the new mode, Paragraph Indent Text mode.
 
-** In Info mode, dir files can be automatically rebuilt  
-when they do not exist or get out of date with respect to the info files
-in the same directory.
-
-The default behaviour is to ask the user if he wants to rebuild an
-outdated info file when doing so would overwrite the file.  When the
-user has no write access to an outdated info file or to an info
-directory containing no dir file, a temporary dir file is built and used
-instead without asking the user but issuing a warning.
+** The `dir' files are no longer essential for functioning of the Info
+subsystem.  If the `dir' file does not exist in an Info directory, the
+relevant information will be generated on-the-fly.
 
 This behaviour can be customized, look for `Info-rebuild-outdated-dir'
-in the `info' customization group.
+in the `info' customization group. #### Mention other variables!
 
 
 * Lisp and internal changes in XEmacs 21.0
 precedence than the buffer locale.  This is because the window locale
 is more specific than the buffer locale.
 
+*** The new macro `let-specifier' can be used to temporarily add
+specifications to specifiers.  See the documentation for details.
+
 *** The new specifiers `vertical-scrollbar-visible-p' and
 `horizontal-scrollbar-visible-p' may be used to control scrollbar
-visibility.  Previously, the only way to toggle scrollbar visibility
-was to set a scrollbar's size to 0.  This method is still supported
-for backward compatibility.
+visibility.  Previously, the only way to remove a scrollbar was to set
+its size to 0.  This method is still supported for backward
+compatibility.
 
 *** The new specifiers `scrollbar-on-left-p' and `scrollbar-on-top-p'
 may be used to control the position of the vertical and horizontal
 *** The behavior of `other-frame' command (`C-x 5 o') is unaffected by
 these changes.
 
+** The function `select-window' now has an optional second argument
+NORECORD which if non-nil inhibits the recording of a buffer change.
+
+** The function `vertical-motion' now correctly handles the second,
+optional WINDOW argument.  A new third argument PIXELS, if non-nil,
+indicates that the returned motion should be in pixels.
+
+** The new function `vertical-motion-pixels' is similar to
+vertical-motion but takes as input a vertical motion in pixels.
+
+** The new functions window-text-area-pixel-{width,height,edges} can
+be used to obtain information about the text-displaying area of a
+window.
+
+** The new functions `shrink-window-pixels' and `enlarge-window-pixels'
+can be used to adjust the size of a window by a pixel amount.
+
+** The new function `window-displayed-text-pixel-height' can be used
+to determine the height of the text actually displayed in a window.
+
 ** The arithmetic comparison functions <, >, =, /= now accept a
 variable number of arguments.
 
 and returns the resulting string.  This is consistent with other
 functions, like `list', `vector', etc.
 
+** The function `temp-directory' is now available to return the
+directory to store temporary files.  On Unix this will be obtained
+from TMPDIR, defaulting to `/tmp'.
+
 ** The function load-average now accepts an optional argument
 USE-FLOATS.  If it is non-nil, the load average values are returned as
 floating point numbers, rather than as integers to be divided by 100.

etc/check_cygwin_setup.sh

 if [ "$HOME" = "" ]; then
     echo -n "HOME is not set, rectify?"
     if yorn; then
-	echo "please enter your home path [/winnt/profiles/$userid]"
-	read HOME junk
-	if [ "$HOME" = "" ]; then
-	    HOME="/winnt/profiles/$userid"
+	if [ "$OS" = "Windows_NT" ]
+	then
+	    echo "please enter your home path [/winnt/profiles/$userid]"
+	    read HOME junk
+	    if [ "$HOME" = "" ]; then
+		HOME="/winnt/profiles/$userid"
+	    fi
+	else
+	    echo "please enter your home path [/]"
+	    read HOME junk
+	    if [ "$HOME" = "" ]; then
+		HOME="/"
+	    fi
 	fi
+
 	echo "HOME=$HOME; export HOME" >> $HOME/.bashrc
     fi
 else 
     echo "TERM is $TERM"
 fi
 
-if echo $CYGWIN32 | grep tty; then
+if echo $CYGWIN32 | grep -w tty; then
     echo "CYGWIN32 is $CYGWIN32"
 else 
     echo "CYGWIN32 does not contain \"tty\" terminal may be deficient"

lib-src/ChangeLog

+1998-06-04  Andy Piper  <andyp@parallax.co.uk>
+
+	* Makefile.in.in (runemacs): add runemacs as a build target if
+	HAVE_MS_WINDOWS is defined. move cpp stuff up slightly so that
+	build targets can benefit from it.
+
 1998-05-31  Kirill M. Katsnelson  <kkm@kis.ru>
 
 	* wakeup.c (sleep): Added NT preprocessor quirkfest.

lib-src/Makefile.in.in

 
 ## ========================== Lists of Files ===========================
 
+#define NO_SHORTNAMES
+#define NOT_C_CODE
+#include "../src/config.h"
+
 ## Things that a user might actually run,
 ## which should be installed in bindir.
-INSTALLABLES = etags ctags b2m gnuclient ootags
+INSTALLABLES_BASE = etags ctags b2m gnuclient ootags
 INSTALLABLE_SCRIPTS = rcs-checkin pstogif install-sid send-pr gnudoit gnuattach
+#ifdef HAVE_MS_WINDOWS
+INSTALLABLES = $(INSTALLABLES_BASE) runemacs
+#else
+INSTALLABLES = $(INSTALLABLES_BASE) 
+#endif
+
 
 ## Things that Emacs runs internally, or during the build process,
 ## which should not be installed in bindir.
 
 ## ========================== start of cpp stuff =======================
 
-#define NO_SHORTNAMES
-#define NOT_C_CODE
-#include "../src/config.h"
-
 #ifdef USE_GNU_MAKE
 vpath %.c @srcdir@
 vpath %.h @srcdir@
 etags: ${etags_deps}
 	$(CC) ${etags_args} -o $@
 
+runemacs_args = -I. $(cflags) -I${srcdir} -I${srcdir}/../src \
+	-DVERSION='"${version}"' ${srcdir}/../nt/runemacs.c \
+	$(ldflags) -Wl,--subsystem,windows
+runemacs_deps   = ${srcdir}/../nt/runemacs.c ../src/config.h
+
+runemacs: ${runemacs_deps}
+	$(CC) ${runemacs_args} -o $@
+
 ootags_args = -I. $(cflags) -I${srcdir} -I${srcdir}/../src \
 	-DVERSION='"${version}"' ${srcdir}/ootags.c \
 	$(GETOPTOBJS) regex.o $(ldflags)
+1998-06-10  Hrvoje Niksic  <hniksic@srce.hr>
+
+	* specifier.el (let-specifier): Tiny docfixes.
+
+1998-06-12  Andy Piper  <andyp@parallax.co.uk>
+
+	* msw-mouse.el: set selection-pointer-glyph to Normal.
+
+1998-06-09  Per Abrahamsen  <abraham@dina.kvl.dk>
+
+	* wid-edit.el (widget-specify-secret): New function.
+	(widget-after-change): Use it.
+	(widget-specify-field): Use it.
+
+1998-06-08  Hrvoje Niksic  <hniksic@srce.hr>
+
+	* mouse.el (drag-window-divider): Use `(not done)' instead of
+	`doit'; reuse result of `window-pixel-edges'.
+
+	* modeline.el (drag-modeline-event-lag): Rename to
+	drag-divider-event-lag.
+
+1998-06-07  Hrvoje Niksic  <hniksic@srce.hr>
+
+	* specifier.el (let-specifier): Rewritten not to generate needless
+	`let's; clarified documentation; support TAG-SET and HOW-TO-ADD
+	arguments.
+
+1998-05-28  Hrvoje Niksic  <hniksic@srce.hr>
+
+	* minibuf.el (read-file-name-1): Setup buffer-local value of
+	`completion-ignore-case' in completions buffer under Windows.
+
+1998-06-06  Kirill M. Katsnelson  <kkm@kis.ru>
+
+	* about.el (about-maintainer-glyph): Fix support for not
+	compressed images.
+
+1998-06-04  Kirill M. Katsnelson  <kkm@kis.ru>
+
+	* cmdloop.el (cancel-mode-internal): Defined this do-nothing function.
+
+	* mouse.el (mouse-track): Cancel selection if misc-user event with
+	`cancel-mode-internal' function is fetched.
+
+1998-06-03  Hrvoje Niksic  <hniksic@srce.hr>
+
+	* files.el (save-some-buffers-1): Fixed return value.
+
+1998-06-01  Oliver Graf <ograf@fga.de>
+
+	* dragdrop.el: added experimental
+
+1998-05-26  Stephen J. Turnbull  <turnbull@sk.tsukuba.ac.jp>
+
+	* startup.el (after-init-hook, init-file-user,
+	user-init-directory, load-user-init-file):  Purge references
+	to "~/.xemacs/init.el" from docstrings.
+
+	(load-user-init-file) Use paths-construct-path to construct
+	paths to user init files.  Go directly to ~/.emacs, do not
+	search ~/.xemacs/, do not load `default-custom-file'.
+
+1998-06-03  Hrvoje Niksic  <hniksic@srce.hr>
+
+	* files.el (interpreter-mode-alist): Catch wish and tclsh before
+	general	*sh.
+	(inhibit-first-line-modes-regexps): Added `.tar.gz'.
+
+1998-06-03  Andy Piper  <andyp@parallax.co.uk>
+
+	* menubar-items.el (default-menubar): add Update Packages to customize
+	menu.
+
+1998-06-02  Andy Piper  <andyp@parallax.co.uk>
+
+	* faces.el: use toolbar face as a fallback for toolbar properties
+	in xpm-color-symbols instead of default.
+
+	* msw-faces.el: rename 3d-object -> gui-element face.
+
+1998-06-06  SL Baur  <steve@altair.xemacs.org>
+
+	* startup.el (xemacs-startup-logo-function): New variable.
+	(startup-splash-frame): Use it.
+
+1998-06-02  Hrvoje Niksic  <hniksic@srce.hr>
+
+	* files.el (save-some-buffers): Would wait 1 second.
+	(save-some-buffers-1): Delete other windows here instead of in
+	`save-some-buffers'.
+	(save-some-buffers): Force redisplay only if windows were deleted.
+
+1998-06-02  Didier Verna  <verna@inf.enst.fr>
+
+	* cus-face.el (custom-face-attributes): generalized the use of
+	toggle buttons for boolean attributes. 
+	Re-ordered the items a bit.
+
 1998-06-01  SL Baur  <steve@altair.xemacs.org>
 
 	* sound.el (default-sound-directory): Use `locate-data-directory'
 		     (make-glyph [string :data "[Error]"]))
 		    (file
 		     (make-glyph
-		      (if (featurep 'xbm)
-			  `([xbm :data ,data]
+		      (if (featurep 'xpm)
+			  `([xpm :file ,file]
 			    [string :data "[Image]"])
 			`([string :data "[Image]"]))))
 		    (t
 	 (delete-other-windows))
 	((string-match "^ \\*" (buffer-name (current-buffer)))
 	 (bury-buffer))))
+
+;; `cancel-mode-internal' is a function of a misc-user event, which is
+;; queued when window system directs XEmacs frame to cancel any modal
+;; behavior it exposes, like mouse pointer grabbing.
+;;
+;; This function does nothing at the top level, but the code which
+;; runs modal event loops, such as selection drag loop in `mouse-track',
+;; check if misc-user function symbol is `cancel-mode-internal', and
+;; takes necessary cleanup actions.
+(defun cancel-mode-internal (object)
+  (setq zmacs-region-stays t))
 
 ;; Someone wrote: "This should really be a ring of last errors."
 ;;
 ;;; Font Attributes.
 
 (defconst custom-face-attributes
-  '((:bold (boolean :tag "Bold"
-		    :help-echo "Control whether a bold font should be used.")
-	   custom-set-face-bold custom-face-bold)
-    (:italic (boolean :tag "Italic"
-		      :help-echo "\
-Control whether an italic font should be used.")
-	     custom-set-face-italic custom-face-italic)
-    (:underline (boolean :tag "Underline"
-			 :help-echo "\
-Control whether the text should be underlined.")
-		set-face-underline-p face-underline-p)
-    (:foreground (color :tag "Foreground"
+  '((:foreground (color :tag "Foreground"
 			:value ""
 			:help-echo "Set foreground color.")
 		 set-face-foreground face-foreground-name)
 			:value ""
 			:help-echo "Set background color.")
 		 set-face-background face-background-name)
-    ;; #### Should make it work on X
-    (:inverse-video (boolean :tag "Inverse"
-			     :help-echo "\
-Control whether the text should be inverted.  Works only on TTY-s")
-		    set-face-reverse-p face-reverse-p)
+    (:size (editable-field :format "Size: %v"
+			   :help-echo "\
+Text size (e.g. 9pt or 2mm).")
+	   custom-set-face-font-size custom-face-font-size)
     (:stipple (editable-field :format "Stipple: %v"
 			      :help-echo "Name of background bitmap file.")
 	      set-face-stipple custom-face-stipple)
 			     :help-echo "\
 Name of font family to use (e.g. times).") 
 	     custom-set-face-font-family custom-face-font-family)
-    (:size (editable-field :format "Size: %v"
-			   :help-echo "\
-Text size (e.g. 9pt or 2mm).")
-	   custom-set-face-font-size custom-face-font-size)
+    (:bold (toggle :format "%[Bold%]: %v\n"
+		   :help-echo "Control whether a bold font should be used.")
+	   custom-set-face-bold custom-face-bold)
+    (:italic (toggle :format "%[Italic%]: %v\n"
+		     :help-echo "\
+Control whether an italic font should be used.")
+	     custom-set-face-italic custom-face-italic)
+    (:underline (toggle :format "%[Underline%]: %v\n"
+			:help-echo "\
+Control whether the text should be underlined.")
+		set-face-underline-p face-underline-p)
+    ;; #### Should make it work on X
     (:strikethru (toggle :format "%[Strikethru%]: %v\n"
 			 :help-echo "\
 Control whether the text should be strikethru.")
-		 set-face-strikethru-p face-strikethru-p))
+		 set-face-strikethru-p face-strikethru-p)
+    (:inverse-video (toggle :format "%[Inverse Video%]: %v\n"
+			    :help-echo "\
+Control whether the text should be inverted.  Works only on TTY-s")
+		    set-face-reverse-p face-reverse-p))
   "Alist of face attributes. 
 
 The elements are of the form (KEY TYPE SET GET) where KEY is a symbol
 ;; Anyway: is dragdrop- a good prefix for all this?
 ;; What if someone trys drop<TAB> in the minibuffer?
 (defgroup drag-n-drop nil
-  "Window system-independent drag'n'drop support."
+  "*{EXPERIMENTAL} Window system-independent drag'n'drop support."
   :group 'editing)
 
 (defcustom dragdrop-drop-at-point nil
-  "*If non-nil, the drop handler functions will drop text at the cursor location.
+  "*{EXPERIMENTAL} If non-nil, drop text at the cursor location.
 Otherwise, the cursor will be moved to the location of the pointer drop before
 text is inserted."
   :type 'boolean
   :group 'drag-n-drop)
 
 (defcustom dragdrop-autoload-tm-view nil
-  "*If non-nil, autoload tm-view if a MIME buffer needs to be decoded.
+  "*{EXPERIMENTAL} If non-nil, autoload tm-view to decode MIME data.
 Otherwise, the buffer is only decoded if tm-view is already avaiable."
   :type 'boolean
   :group 'drag-n-drop)
 
 ;; the widget for editing the drop-functions
 (define-widget 'dragdrop-function-widget 'list
-  "Widget for editing drop dispatch functions."
+  "*{EXPERIMENTAL} Widget for editing drop dispatch functions."
   :args `((choice :tag "Function"
-		  (function-item dragdrop-drop-url-default)
-		  (function-item dragdrop-drop-mime-default)
-		  (function-item dragdrop-drop-log-function)
+		  (function-item experimental-dragdrop-drop-url-default)
+		  (function-item experimental-dragdrop-drop-mime-default)
+		  (function-item experimental-dragdrop-drop-log-function)
 		  (function :tag "Other" nil))
 	  (choice :tag "Button" :value t
 		  (choice-item :tag "Ignore" t)
 		  (sexp :tag "Arg" :value nil)))
   :value '(nil t t))
 
-(defcustom dragdrop-drop-functions '((dragdrop-drop-url-default t t)
-				     (dragdrop-drop-mime-default t t))
-  "This is the standart drop function search list.
+(defcustom experimental-dragdrop-drop-functions '((experimental-dragdrop-drop-url-default t t)
+						  (experimental-dragdrop-drop-mime-default t t))
+  "*{EXPERIMENTAL} This is the standart drop function search list.
 Each element is a list of a function, a button selector, a modifier
 selector and optional argumets to the function call.
 The function must accept at least two arguments: first is the event
   :type '(repeat dragdrop-function-widget))
 
 (defgroup dnd-debug nil
-  "Drag'n'Drop debugging options."
+  "*{EXPERIMENTAL} Drag'n'Drop debugging options."
   :group 'drag-n-drop)
 
 (defcustom dragdrop-drop-log nil
-  "If non-nil, every drop is logged.
+  "*{EXPERIMENTAL} If non-nil, every drop is logged.
 The name of the buffer is set in the custom 'dragdrop-drop-log-name"
   :group 'dnd-debug
   :type 'boolean)
 
 (defcustom dragdrop-drop-log-name "*drop log buffer*"
-  "The name of the buffer used to log drops.
+  "*{EXPERIMENTAL} The name of the buffer used to log drops.
 Set dragdrop-drop-log to non-nil to enable this feature."
   :group 'dnd-debug
   :type 'string)
 
 (defvar dragdrop-drop-log-buffer nil
-  "Buffer to log drops in debug mode.")
+  "*{EXPERIMENTAL} Buffer to log drops in debug mode.")
 
 ;;
 ;; Drop API
 ;;
 (defun dragdrop-drop-dispatch (object)
-  "This function identifies DROP type misc-user-events.
+  "*{EXPERIMENTAL} This function identifies DROP type misc-user-events.
 It calls functions which will handle the drag."
   (let ((event current-mouse-event))
     (and dragdrop-drop-log
-	 (dragdrop-drop-log-function event object))
+	 (experimental-dragdrop-drop-log-function event object))
     (dragdrop-drop-find-functions event object)))
 
 (defun dragdrop-drop-find-functions (event object)
   "Finds valid drop-handle functions and executes them to dispose the drop.
-It does this by looking for extent-properties called 'dragdrop-drop-functions
-and for variables named like this."
+It does this by looking for extent-properties called
+'experimental-dragdrop-drop-functions and for variables named like this."
   (catch 'dragdrop-drop-is-done
     (and (event-over-text-area-p event)
 	 ;; let's search the extents
 	     (or pos (setq pos cpos))
 	     (select-window window)
 	     (setq buffer (window-buffer))
-	     (let ((ext (extent-at pos buffer 'dragdrop-drop-functions)))
+	     (let ((ext (extent-at pos buffer 'experimental-dragdrop-drop-functions)))
 	       (while (not (eq ext nil))
 		 (dragdrop-drop-do-functions
-		  (extent-property ext 'dragdrop-drop-functions)
+		  (extent-property ext 'experimental-dragdrop-drop-functions)
 		  event
 		  object)
-		 (setq ext (extent-at pos buffer 'dragdrop-drop-functions ext)))))))
-    ;; now look into the variable dragdrop-drop-functions
-    (dragdrop-drop-do-functions dragdrop-drop-functions event object)))
+		 (setq ext (extent-at pos buffer
+				      'experimental-dragdrop-drop-functions
+				      ext)))))))
+    ;; now look into the variable experimental-dragdrop-drop-functions
+    (dragdrop-drop-do-functions experimental-dragdrop-drop-functions event object)))
 
 (defun dragdrop-compare-mods (first-mods second-mods)
   "Returns t if both first-mods and second-mods contain the same elements.
       (setq drop-funs (cdr drop-funs))))
   nil)
 
-(defun dragdrop-drop-log-function (event object &optional message buffer)
-  "Logs any drops into a buffer.
+(defun experimental-dragdrop-drop-log-function (event object &optional message buffer)
+  "*{EXPERIMENTAL} Logs any drops into a buffer.
 If buffer is nil, it inserts the data into a buffer called after
 dragdrop-drop-log-name.
 If dragdrop-drop-log is non-nil, this is done automatically for each drop.
     (insert "----------\n"))
   nil)
 
-(defun dragdrop-drop-url-default (event object)
-  "Default handler for dropped URL data.
+(defun experimental-dragdrop-drop-url-default (event object)
+  "*{EXPERIMENTAL} Default handler for dropped URL data.
 Finds files and URLs. Returns nil if object does not contain URL data."
   (cond ((eq (car object) 'dragdrop-URL)
 	 (let ((data (cdr object))
 	   t))
 	(t nil)))
 
-(defun dragdrop-drop-mime-default (event object)
-  "Default handler for dropped MIME data.
+(defun experimental-dragdrop-drop-mime-default (event object)
+  "*{EXPERIMENTAL} Default handler for dropped MIME data.
 Inserts text into buffer, creates MIME buffers for other types.
 Returns nil if object does not contain MIME data."
   (cond ((eq (car object) 'dragdrop-MIME)
 ;;
 ;; Drag API
 ;;
-(defun dragdrop-drag (event object)
-  "The generic drag function.
+(defun experimental-dragdrop-drag (event object)
+  "*{EXPERIMENTAL} The generic drag function.
 Tries to do the best with object in the selected protocol.
 Object must comply to the standart drag'n'drop object 
 format."
   (error "Not implemented"))
 
-(defun dragdrop-drag-region (event begin end)
-  "Drag a region.
+(defun experimental-dragdrop-drag-region (event begin end)
+  "*{EXPERIMENTAL} Drag a region.
 This function uses special data types if the low-level
 protocol requires it. It does so by calling
 dragdrop-drag-pure-text."
   (dragdrop-drag-pure-text event
 			   (buffer-substring-no-properties begin end)))
 
-(defun dragdrop-drag-pure-text (event text)
-  "Drag text-only data.
+(defun experimental-dragdrop-drag-pure-text (event text)
+  "*{EXPERIMENTAL} Drag text-only data.
 Takes care of special low-level protocol data types.
 Text must be a list of strings."
   (error "Not implemented"))
 
-(defun dragdrop-drag-pure-file (event file)
-  "Drag filepath-only data.
+(defun experimental-dragdrop-drag-pure-file (event file)
+  "*{EXPERIMENTAL} Drag filepath-only data.
 Takes care of special low-level protocol data types.
 file must be a list of strings."
   (error "Not implemented"))
 		       (or
 			(and 
 			 (featurep 'x)
-			 (or 
-			  (x-get-resource "backgroundToolBarColor"
-					  "BackgroundToolBarColor" 'string)
-			  (x-get-resource "background" "Background" 'string)))
+			 (x-get-resource "backgroundToolBarColor"
+					 "BackgroundToolBarColor" 'string))
+
+			(face-background 'toolbar)
 			"Gray80")))
 	   (purecopy '("foregroundToolBarColor"
 		       (or
 			(and 
 			 (featurep 'x)
-			 (or
-			  (x-get-resource "foregroundToolBarColor"
-					  "ForegroundToolBarColor" 'string)
-			  (x-get-resource "foreground" "Foreground" 'string)))
+			 (x-get-resource "foregroundToolBarColor"
+					 "ForegroundToolBarColor" 'string))
+			(face-foreground 'toolbar)
 			"Black")))
 	   )))
 
 		  "File local-variables error: %s"
 		  (error-message-string err))))))
 
+;; #### This variable sucks in the package model.  There should be a
+;; way for new packages to add their entries to auto-mode-alist in a
+;; clean way.  Per Abrahamsen suggested splitting auto-mode-alist to
+;; several distinct variables such as, in order of precedence,
+;; `user-auto-mode-alist' for users, `package-auto-mode-alist' for
+;; packages and `auto-mode-alist' (which might also be called
+;; `default-auto-mode-alist') for default stuff, such as some of the
+;; entries below.
+
 (defvar auto-mode-alist
   '(("\\.te?xt\\'" . text-mode)
     ("\\.[ch]\\'" . c-mode)
     ("/\\.\\(bash_\\|z\\)?\\(profile\\|login\||logout\\)\\'" . sh-mode)
     ("/\\.\\([ckz]sh\\|bash\\|tcsh\\|es\\|xinit\\|startx\\)rc\\'" . sh-mode)
     ("/\\.\\([kz]shenv\\|xsession\\)\\'" . sh-mode)
-;;; The following should come after the ChangeLog pattern
-;;; for the sake of ChangeLog.1, etc.
-;;; and after the .scm.[0-9] pattern too.
+    ;; The following come after the ChangeLog pattern for the sake of
+    ;; ChangeLog.1, etc. and after the .scm.[0-9] pattern too.
     ("\\.[12345678]\\'" . nroff-mode)
     ("\\.[tT]e[xX]\\'" . tex-mode)
     ("\\.\\(sty\\|cls\\|bbl\\)\\'" . latex-mode)
 
 (defvar interpreter-mode-alist
   '(("^#!.*csh"	  . sh-mode)
+    ("^#!.*\\b\\(scope\\|wish\\|tcl\\|tclsh\\|expect\\)" . tcl-mode)
     ("^#!.*sh\\b" . sh-mode)
-    ("^#!.*\\b\\(scope\\|wish\\|tcl\\|expect\\)" . tcl-mode)
     ("perl"   . perl-mode)
     ("python" . python-mode)
     ("awk\\b" . awk-mode)
 with the name of the interpreter specified in the first line.
 If it matches, mode MODE is selected.")
 
-(defvar inhibit-first-line-modes-regexps (purecopy '("\\.tar\\'" "\\.tgz\\'"))
+(defvar inhibit-first-line-modes-regexps (purecopy '("\\.tar\\'" "\\.tgz\\'"
+						     "\\.tar\\.gz\\'"))
   "List of regexps; if one matches a file name, don't look for `-*-'.")
 
 (defvar inhibit-first-line-modes-suffixes nil
 	;; usual drill.
 	(save-some-buffers-1 arg exiting nil)
       ;; Else, protect the windows.
-      (delete-other-windows)
-      (save-window-excursion
-	(save-some-buffers-1 arg exiting t))
-      ;; Force redisplay.  #### Perhaps this should be handled
-      ;; automatically by `save-window-excursion'.
-      (sit-for 1))))
+      (when (save-window-excursion
+	      (save-some-buffers-1 arg exiting t))
+	;; Force redisplay.
+	(sit-for 0)))))
 
 ;; XEmacs - do not use queried flag
 (defun save-some-buffers-1 (arg exiting switch-buffer)
-  (let ((files-done
-	 (map-y-or-n-p
-	  (lambda (buffer)
-	    (and (buffer-modified-p buffer)
-		 (not (buffer-base-buffer buffer))
-		 ;; XEmacs addition:
-		 (not (symbol-value-in-buffer 'save-buffers-skip buffer))
-		 (or
-		  (buffer-file-name buffer)
-		  (and exiting
-		       (progn
-			 (set-buffer buffer)
-			 (and buffer-offer-save (> (buffer-size) 0)))))
-		 (if arg
-		     t
-		   ;; #### We should provide a per-buffer means to
-		   ;; disable the switching.
-		   (when switch-buffer
-		     ;; #### Consider using `display-buffer' here for 21.1!
-		     ;(display-buffer buffer nil (selected-frame)))
-		     (switch-to-buffer buffer t))
-		   (if (buffer-file-name buffer)
-		       (format "Save file %s? "
-			       (buffer-file-name buffer))
-		     (format "Save buffer %s? "
-			     (buffer-name buffer))))))
-	  (lambda (buffer)
-	    (set-buffer buffer)
-	    (condition-case ()
-		(save-buffer)
-	      (error nil)))
-	  (buffer-list)
-	  '("buffer" "buffers" "save")
-	  ;;instead of this we just say "yes all", "no all", etc.
-	  ;;"save all the rest"
-	  ;;"save only this buffer" "save no more buffers")
-	  ;; this is rather bogus. --ben
-	  ;; (it makes the dialog box too big, and you get an error
-	  ;; "wrong type argument: framep, nil" when you hit q after
-	  ;; choosing the option from the dialog box)
+  (let* ((switched nil)
+	 (files-done
+	  (map-y-or-n-p
+	   (lambda (buffer)
+	     (and (buffer-modified-p buffer)
+		  (not (buffer-base-buffer buffer))
+		  ;; XEmacs addition:
+		  (not (symbol-value-in-buffer 'save-buffers-skip buffer))
+		  (or
+		   (buffer-file-name buffer)
+		   (and exiting
+			(progn
+			  (set-buffer buffer)
+			  (and buffer-offer-save (> (buffer-size) 0)))))
+		  (if arg
+		      t
+		    ;; #### We should provide a per-buffer means to
+		    ;; disable the switching.  For instance, you might
+		    ;; want to turn it off for buffers the contents of
+		    ;; which is meaningless to humans, such as
+		    ;; `.newsrc.eld'.
+		    (when switch-buffer
+		      (unless (one-window-p)
+			(delete-other-windows))
+		      (setq switched t)
+		      ;; #### Consider using `display-buffer' here for 21.1!
+		      ;;(display-buffer buffer nil (selected-frame)))
+		      (switch-to-buffer buffer t))
+		    (if (buffer-file-name buffer)
+			(format "Save file %s? "
+				(buffer-file-name buffer))
+		      (format "Save buffer %s? "
+			      (buffer-name buffer))))))
+	   (lambda (buffer)
+	     (set-buffer buffer)
+	     (condition-case ()
+		 (save-buffer)
+	       (error nil)))
+	   (buffer-list)
+	   '("buffer" "buffers" "save")
+	   ;;instead of this we just say "yes all", "no all", etc.
+	   ;;"save all the rest"
+	   ;;"save only this buffer" "save no more buffers")
+	   ;; this is rather bogus. --ben
+	   ;; (it makes the dialog box too big, and you get an error
+	   ;; "wrong type argument: framep, nil" when you hit q after
+	   ;; choosing the option from the dialog box)
 
-	  ;; We should fix the dialog box rather than disabling
-	  ;; this!  --hniksic
-	  (list (list ?\C-r (lambda (buf)
-			      ;; #### FSF has an EXIT-ACTION argument
-			      ;; to `view-buffer'.
-			      (view-buffer buf)
-			      (setq view-exit-action
-				    (lambda (ignore)
-				      (exit-recursive-edit)))
-			      (recursive-edit)
-			      ;; Return nil to ask about BUF again.
-			      nil)
-		      "display the current buffer"))))
-	(abbrevs-done
-	 (and save-abbrevs abbrevs-changed
-	      (progn
-		(if (or arg
-			(y-or-n-p (format "Save abbrevs in %s? " abbrev-file-name)))
-		    (write-abbrev-file nil))
-		;; Don't keep bothering user if he says no.
-		(setq abbrevs-changed nil)
-		t))))
+	   ;; We should fix the dialog box rather than disabling
+	   ;; this!  --hniksic
+	   (list (list ?\C-r (lambda (buf)
+			       ;; #### FSF has an EXIT-ACTION argument
+			       ;; to `view-buffer'.
+			       (view-buffer buf)
+			       (setq view-exit-action
+				     (lambda (ignore)
+				       (exit-recursive-edit)))
+			       (recursive-edit)
+			       ;; Return nil to ask about BUF again.
+			       nil)
+		       "display the current buffer"))))
+	 (abbrevs-done
+	  (and save-abbrevs abbrevs-changed
+	       (progn
+		 (if (or arg
+			 (y-or-n-p (format "Save abbrevs in %s? " abbrev-file-name)))
+		     (write-abbrev-file nil))
+		 ;; Don't keep bothering user if he says no.
+		 (setq abbrevs-changed nil)
+		 t))))
     (or (> files-done 0) abbrevs-done
-	(display-message 'no-log "(No files need saving)"))))
+	(display-message 'no-log "(No files need saving)"))
+    switched))
 
 
 (defun not-modified (&optional arg)

lisp/menubar-items.el

        ["Saved..." customize-saved]
        ["Set..." customize-customized]
        ["Apropos..." customize-apropos]
-       ["Browse..." customize-browse])
+       ["Browse..." customize-browse]
+       ["Update Packages" package-get-custom])
       ("Editing Options"
        ["Overstrike"
 	(progn
 			      initial-contents completer)
     (let ((rfhookfun
 	   (lambda ()
+	     ;; #### SCREAM!  Create a `file-system-ignore-case'
+	     ;; function, so this kind of stuff is generalized!
+	     (and (eq system-type 'windows-nt)
+		  (set (make-local-variable 'completion-ignore-case) t))
 	     (set
 	      (make-local-variable
 	       'completion-display-completion-list-function)
   "Modeline customizations."
   :group 'environment)
 
-(defcustom drag-modeline-event-lag 150
-  "*The pause (in msecs) between drag modeline events before redisplaying.
+(defcustom drag-divider-event-lag 150
+  "*The pause (in msecs) between divider drag events before redisplaying.
 If this value is too small, dragging will be choppy because redisplay cannot
 keep up. If it is too large, dragging will be choppy because of the explicit
 redisplay delay specified."
   :type 'integer
+  ;; #### Fix group.
   :group 'modeline)
 
+(define-obsolete-variable-alias
+  'drag-modeline-event-lag
+  'drag-divider-event-lag)
+
 (defcustom modeline-click-swaps-buffers nil
   "*If non-nil, clicking on the modeline changes the current buffer.
 Click on the left half of the modeline cycles forward through the
 	;;   occurred in some other frame.
 	;; drag if this is a mouse motion event and the time
 	;;   between this event and the last event is greater than
-	;;   drag-modeline-event-lag.
+	;;   drag-divider-event-lag.
 	;; do nothing if this is any other kind of event.
 	(cond ((or (misc-user-event-p event)
 		   (key-press-event-p event))
 	      ((not (eq start-event-frame (event-frame event)))
 	       (setq done t))
 	      ((< (abs (- (event-timestamp event) last-timestamp))
-		  drag-modeline-event-lag)
+		  drag-divider-event-lag)
 	       nil)
 	      (t
 ;;		 (set-modeline-hscroll start-event-window
 		      event mouse-track-click-count)
 		   (mouse-track-run-hook 'mouse-track-click-hook
 		    event mouse-track-click-count)))
-		((key-press-event-p event)
+		((or (key-press-event-p event)
+		     (and (misc-user-event-p event)
+			  (eq (event-function event) 'cancel-mode-internal)))
 		 (error "Selection aborted"))
 		(t
 		 (dispatch-event event))))
     (let* ((window (event-window event))
 	   (frame (event-channel event))
 	   (last-timestamp (event-timestamp event))
-	   (doit t))
-      (while doit
-	(let ((old-right (caddr (window-pixel-edges window)))
-	      (old-left (car (window-pixel-edges window)))
-	      (backup-conf (current-window-configuration frame))
-	      (old-edges-all-windows (mapcar 'window-pixel-edges (window-list))))
+	   done)
+      (while (not done)
+	(let* ((edges (window-pixel-edges window))
+	       (old-right (caddr edges))
+	       (old-left (car edges))
+	       (backup-conf (current-window-configuration frame))
+	       (old-edges-all-windows (mapcar 'window-pixel-edges
+					      (window-list))))
 
 	  ;; This is borrowed from modeline.el:
 	  ;; requeue event and quit if this is a misc-user, eval or
 	  ;;   occurred in some other frame.
 	  ;; drag if this is a mouse motion event and the time
 	  ;;   between this event and the last event is greater than
-	  ;;   drag-modeline-event-lag.
+	  ;;   drag-divider-event-lag.
 	  ;; do nothing if this is any other kind of event.
 	  (setq event (next-event event))
 	  (cond ((or (misc-user-event-p event)
 		     (key-press-event-p event))
 		 (setq unread-command-events (nconc unread-command-events
 						    (list event))
-		       doit nil))
+		       done t))
 		((button-release-event-p event)
-		 (setq doit nil))
+		 (setq done t))
 		((button-event-p event)
-		 (setq doit nil))
+		 (setq done t))
 		((not (motion-event-p event))
 		 (dispatch-event event))
 		((not (eq frame (event-frame event)))
-		 (setq doit nil))
+		 (setq done t))
 		((< (abs (- (event-timestamp event) last-timestamp))
-		    drag-modeline-event-lag))
+		    drag-divider-event-lag))
 		(t
 		 (setq last-timestamp (event-timestamp event))
 		 ;; Enlarge the window, calculating change in characters

lisp/msw-faces.el

 (defun mswindows-init-device-faces (device)
   (set-face-font 'default 
 		 '((mswindows default) . "Courier New:Regular:10") 'global)
-  ;; 3d objects
-  (set-face-foreground '3d-object '((mswindows default) . "Black") 'global)
-  (set-face-background '3d-object '((mswindows default) . "Gray75") 'global)
+  ;; gui elements
+  (set-face-foreground 'gui-element '((mswindows default) . "Black") 'global)
+  (set-face-background 'gui-element '((mswindows default) . "Gray75") 'global)
   (set-face-foreground 'default '((mswindows default) . "black") 'global)
   (set-face-background 'default '((mswindows default) . "white") 'global)
   )

lisp/msw-mouse.el

 		 [resource :resource-type cursor :resource-id "Ibeam"])
 (set-glyph-image nontext-pointer-glyph
 		 [resource :resource-type cursor :resource-id "Normal"])
+(set-glyph-image selection-pointer-glyph
+		 [resource :resource-type cursor :resource-id "Normal"])
 (set-glyph-image modeline-pointer-glyph
 		 [resource :resource-type cursor :resource-id "SizeNS"])
 (set-glyph-image divider-pointer-glyph

lisp/specifier.el

 	    how-to-add))))
   value)
 
-;; Note: you cannot replace the following macro with `letf' because
-;; `specifier-instance' does not have a setf method defined.  (I tried
-;; to use `set-specifier' as the setf method for `specifier-instance',
-;; but it doesn't work for `letf' because set-specifier to the old
-;; value cannot be used to "undo" a previous set-specifier, as letf
-;; expects.)
-;;
-;; This macro might perhaps be made simpler, with an addition to
-;; `remove-specifier'.  Example (simplified for clarity):
-;;
-;; (defmacro let-specifier (specifier value domain &rest body)
-;;   `(unwind-protect
-;;        (progn
-;;	    (add-spec-to-specifier ,specifier ,value ,domain nil 'prepend)
-;;	    ,@body)
-;;      (remove-specifier ,specifier ,domain)))
-;;
-;; So, the idea is to unconditionally prepend a specification for
-;; DOMAIN, and unconditionally remove it.  This does not work because
-;; `remove-specifier' removes *all* the specifications of DOMAIN,
-;; nuking the old ones, in the process.  (for this purpose, it might
-;; make sense for `remove-specifier' to have a HOW-TO-REMOVE
-;; argument.)
-;;
-;; The following version remembers the old speclist and returns it
-;; later.  It's probably less error-prone anyway.
+(defmacro let-specifier (specifier-list &rest body)
+  "Add specifier specs, evaluate forms in BODY and restore the specifiers.
+\(let-specifier SPECIFIER-LIST BODY...)
 
-(defmacro let-specifier (specifier-list &rest body)
-  "(let-specifier SPECIFIER-LIST BODY): bind specifiers and evaluate BODY.
+Each element of SPECIFIER-LIST should look like this:
+\(SPECIFIER VALUE &optional LOCALE TAG-SET HOW-TO-ADD).
+
+SPECIFIER is the specifier to be temporarily modified.  VALUE is the
+instantiator to be temporarily added to SPECIFIER in LOCALE.  LOCALE,
+TAG-SET and HOW-TO-ADD have the same meaning as in
+`add-spec-to-specifier'.
+
+The code resulting from macro expansion will add specifications to
+specifiers using `add-spec-to-specifier'.  After BODY is finished, the
+temporary specifications are removed and old spec-lists are restored.
+
+LOCALE, TAG-SET and HOW-TO-ADD may be omitted, and default to nil.
 The value of the last form in BODY is returned.
-Each element of SPECIFIER-LIST should be a list of
-\(SPECIFIER VALUE DOMAIN).  VALUE and DOMAIN may be omitted, and default
-to nil.  The elements of SPECIFIER-LIST are evaluated sequentially.
 
-For meaning of DOMAIN, see `specifier-instance'."
-  ;; Error-checking
-  (dolist (listel specifier-list)
-    (or (and (consp listel)
-	     (<= (length listel) 3))
-	(signal 'error (list "Should be a 3-element list" listel))))
-  ;; Set up fresh symbols to avoid name clashes.
-  (let* ((specvarlist (mapcar #'(lambda (ignored) (gensym "specifier-"))
-			      specifier-list))
-	 (valvarlist (mapcar #'(lambda (ignored) (gensym "value-"))
-			     specifier-list))
-	 (domvarlist (mapcar #'(lambda (ignored) (gensym "domain-"))
-			     specifier-list))
-	 (oldvarlist (mapcar #'(lambda (ignored) (gensym "old-"))
-			     specifier-list)))
-    ;; Bind the appropriate variables.
-    `(let* (,@(mapcar* (lambda (symbol listel)
-			 (list symbol (nth 0 listel)))
-		       specvarlist specifier-list)
-	      ,@(mapcar* (lambda (symbol listel)
-			   (list symbol (nth 1 listel)))
-			 valvarlist specifier-list)
-	      ,@(mapcar* (lambda (symbol listel)
-			   (list symbol (nth 2 listel)))
-			 domvarlist specifier-list)
-	      ,@(mapcar* (lambda (symbol specifier domain)
-			   (list symbol `(specifier-spec-list
-					  ,specifier ,domain)))
-			 oldvarlist specvarlist domvarlist))
-       (unwind-protect
-	   (progn
-	     ,@(mapcar* (lambda (specifier value domain)
-			  `(add-spec-to-specifier
-			    ,specifier ,value ,domain
-			    nil 'prepend))
-			specvarlist valvarlist domvarlist)
-	     ,@body)
-	 ,@(apply
-	    #'nconc
-	    ;; Reverse the unwinding order for marginal safety gain.
-	    (nreverse
-	     (mapcar*
-	      (lambda (specifier domain oldvalue)
-		`((remove-specifier ,specifier ,domain)
-		  (add-spec-list-to-specifier ,specifier ,oldvalue)))
-	      specvarlist domvarlist oldvarlist)))))))
+NOTE: If you want the specifier's instance to change in all
+circumstances, use (selected-window) as the LOCALE.  If LOCALE is nil
+or omitted, it defaults to `global'.
 
-;; (cl-prettyexpand '(let-specifier ((modeline-shadow-thickness 0 (selected-window)) (fubar 0 baz)) (sit-for 1)))
+Example:
+    (let-specifier ((modeline-shadow-thickness 0 (selected-window)))
+      (sit-for 1))"
+  (check-argument-type 'listp specifier-list)
+  (flet ((gensym-frob (x name)
+	   (if (or (atom x) (eq (car x) 'quote))
+	       (list x)
+	     (list (gensym name) x))))
+    ;; VARLIST is a list of
+    ;; ((SPECIFIERSYM SPECIFIER) (VALUE) (LOCALESYM LOCALE)
+    ;;  (TAG-SET) (HOW-TO-ADD))
+    ;; If any of these is an atom, then a separate symbol is
+    ;; unnecessary, the CAR will contain the atom and CDR will be nil.
+    (let* ((varlist (mapcar #'(lambda (listel)
+				(or (and (consp listel)
+					 (<= (length listel) 5)
+					 (> (length listel) 1))
+				    (signal 'error
+					    (list
+					     "should be a list of 2-5 elements"
+					     listel)))
+				;; VALUE, TAG-SET and HOW-TO-ADD are
+				;; referenced only once, so we needn't
+				;; frob them with gensym.
+				(list (gensym-frob (nth 0 listel) "specifier-")
+				      (list (nth 1 listel))
+				      (gensym-frob (nth 2 listel) "locale-")
+				      (list (nth 3 listel))
+				      (list (nth 4 listel))))
+			    specifier-list))
+	   ;; OLDVALLIST is a list of (OLDVALSYM OLDVALFORM)
+	   (oldvallist (mapcar #'(lambda (varel)
+				   (list (gensym "old-")
+					 `(specifier-spec-list
+					   ,(car (nth 0 varel))
+					   ,(car (nth 2 varel)))))
+			       varlist)))
+      ;; Bind the appropriate variables.
+      `(let* (,@(mapcan #'(lambda (varel)
+			    (delq nil (mapcar
+				       #'(lambda (varcons)
+					   (and (cdr varcons) varcons))
+				       varel)))
+			varlist)
+		,@oldvallist)
+	 (unwind-protect
+	     (progn
+	       ,@(mapcar #'(lambda (varel)
+			     `(add-spec-to-specifier
+			       ,(car (nth 0 varel)) ,(car (nth 1 varel))
+			       ,(car (nth 2 varel)) ,(car (nth 3 varel))
+			       ,(car (nth 4 varel))))
+			 varlist)
+	       ,@body)
+	   ;; Reverse the unwinding order, so that using the same
+	   ;; specifier multiple times works.
+	   ,@(apply #'nconc (nreverse (mapcar*
+				       #'(lambda (oldval varel)
+					   `((remove-specifier
+					      ,(car (nth 0 varel))
+					      ,(car (nth 2 varel)))
+					     (add-spec-list-to-specifier
+					      ,(car (nth 0 varel))
+					      ,(car oldval))))
+				       oldvallist varlist))))))))
+
+;; Evaluate this for testing:
+; (cl-prettyexpand '(let-specifier ((modeline-shadow-thickness 0 (selected-window) 'x) (fubar (value) baz)) (sit-for 1)))
 
 (define-specifier-tag 'win 'device-on-window-system-p)
 
 (defvar after-init-hook nil
   "*Functions to call after loading the init file (`.emacs').
 The call is not protected by a condition-case, so you can set `debug-on-error'
-in `init.el', and put all the actual code on `after-init-hook'.")
+in `.emacs', and put all the actual code on `after-init-hook'.")
 
 (defvar term-setup-hook nil
   "*Functions to be called after loading terminal-specific Lisp code.
 originally logged in, or it may be a string containing a user's name.
 
 In either of the latter cases, `(concat \"~\" init-file-user \"/\")'
-evaluates to the name of the directory where the `init.el' file was
-looked for.
+evaluates to the name of the directory in which the `.emacs' file was
+searched for.
 
 Setting `init-file-user' does not prevent Emacs from loading
 `site-start.el'.  The only way to do that is to use `--no-site-file'.")
 	  (setq term nil))))))
 
 (defconst user-init-directory "/.xemacs/"
-  "Directory where user initialization and user-installed packages may go.")
+  "Directory where user-installed packages may go.")
 (define-obsolete-variable-alias
   'emacs-user-extension-dir
   'user-init-directory)
 
 (defun load-user-init-file (init-file-user)
-  "This function actually reads the init files.
-First try .xemacs/init, then try .emacs, but only load one of the two."
+  "This function actually reads the init file, .emacs."
   (when init-file-user
+;; purge references to init.el and options.el
+;; convert these to use paths-construct-path for eventual migration to init.el
+;; needs to be converted when idiom for constructing "~user" paths is created
+;    (setq user-init-file
+;	  (paths-construct-path (list (concat "~" init-file-user)
+;				      user-init-directory
+;				      "init.el")))
+;    (unless (file-exists-p (expand-file-name user-init-file))
     (setq user-init-file
-	  (cond
-	   ((eq system-type 'ms-dos)
-	    (concat "~" init-file-user user-init-directory "init.el"))
-	   (t
-	    (concat "~" init-file-user user-init-directory "init.el"))))
-    (unless (file-exists-p (expand-file-name user-init-file))
-      (setq user-init-file
-	    (cond
-	     ((eq system-type 'ms-dos)
-	      (concat "~" init-file-user "/_emacs"))
-	     (t
-	      (concat "~" init-file-user "/.emacs")))))
+	  (paths-construct-path (list (concat "~" init-file-user)
+				      (cond
+				       ((eq system-type 'ms-dos) "_emacs")
+				       (t ".emacs")))))
+;    )
     (load user-init-file t t t)
-    (let ((default-custom-file (concat "~"
-				       init-file-user
-				       user-init-directory
-				       "options.el")))
-      (when (string= custom-file default-custom-file)
-	(load default-custom-file t t)))
+;; This should not be loaded since custom stuff currently goes into .emacs
+;    (let ((default-custom-file
+;	    (paths-construct-path (list (concat "~" init-file-user)
+;				        user-init-directory
+;				        "options.el")))
+;      (when (string= custom-file default-custom-file)
+;	(load default-custom-file t t)))
     (unless inhibit-default-init
       (let ((inhibit-startup-message nil))
 	;; Users are supposed to be told their rights.
 For tips and answers to frequently asked questions, see the XEmacs FAQ.
 \(It's on the Help menu, or type " (key xemacs-local-faq) " [a capital F!].\)"))))
 
+(defvar xemacs-startup-logo-function nil
+  "If non-nil, function called to provide the startup logo.
+This function should return an initialized glyph if it is used.")
+
 (defun startup-splash-frame ()
   (let ((p (point))
-	(logo (cond ((featurep 'infodock)
-		     (make-glyph (locate-data-file "altrasoft-slogo.xpm")))
+	(logo (cond (xemacs-startup-logo-function
+		     (funcall xemacs-startup-logo-function))
 		    (t xemacs-logo)))
         (cramped-p (eq 'tty (console-type))))
     (unless cramped-p (insert "\n"))
     (set-extent-property extent 'button-or-field t)
     (set-extent-property extent 'keymap map)
     (set-extent-property extent 'face face)
-    (widget-handle-help-echo extent help-echo)))
+    (widget-handle-help-echo extent help-echo))
+  (widget-specify-secret widget))
+
+(defun widget-specify-secret (field)
+  "Replace text in FIELD with value of `:secret', if non-nil."
+  (let ((secret (widget-get field :secret))
+	(size (widget-get field :size)))
+    (when secret
+      (let ((begin (widget-field-start field))
+	    (end (widget-field-end field)))
+	(when size 
+	  (while (and (> end begin)
+		      (eq (char-after (1- end)) ?\ ))
+	    (setq end (1- end))))
+	(while (< begin end)
+	  (let ((old (char-after begin)))
+	    (unless (eq old secret)
+	      (subst-char-in-region begin (1+ begin) old secret)
+	      (put-text-property begin (1+ begin) 'secret old))
+	    (setq begin (1+ begin))))))))
 
 (defun widget-specify-button (widget from to)
   "Specify button for WIDGET between FROM and TO."
 	(when field
 	  (unless (eq field other)
 	    (debug "Change in different fields"))
-	  (let ((size (widget-get field :size))
-		(secret (widget-get field :secret)))
+	  (let ((size (widget-get field :size)))
 	    (when size
 	      (let ((begin (widget-field-start field))
 		    (end (widget-field-end field)))
 			 (while (and (eq (preceding-char) ?\ )
 				     (> (point) begin))
 			   (delete-backward-char 1)))))))
-	    (when secret
-	      (let ((begin (widget-field-start field))
-		    (end (widget-field-end field)))
-		(when size
-		  (while (and (> end begin)
-			      (eq (char-after (1- end)) ?\ ))
-		    (setq end (1- end))))
-		(while (< begin end)
-		  (let ((old (char-after begin)))
-		    (unless (eq old secret)
-		      (subst-char-in-region begin (1+ begin) old secret)
-		      (put-text-property begin (1+ begin) 'secret old))
-		    (incf begin))))))
+	    (widget-specify-secret field))
 	  (widget-apply field :notify field)))
     (error (debug "After Change"))))
 
   int drop;
 # endif
 #endif
-  char newchars[64];
+  char* newchars;
+  int charslength;
   char *chars;
   int i, j;
 
 #else
   chars = string;
 #endif
-
-  for (i = j = 0; chars[i] && (j < (int) sizeof (newchars)); i++)
+  charslength = strlen (chars);
+  newchars = (char *) alloca (charslength + 1);
+
+  for (i = j = 0; chars[i] && (j < charslength); i++)
     if (chars[i]=='%'&&chars[i+1]=='_')
 	    i++;
     else
+1998-06-10  Hrvoje Niksic  <hniksic@srce.hr>
+
+	* lispref/windows.texi (Resizing Windows): Document
+	`enlarge-window-pixels' and `shrink-window-pixels'.
+
+	* lispref/positions.texi (Screen Lines): Update documentation of
+	`vertical-motion'.
+	(Screen Lines): Document `vertical-motion-pixels'.
+
+	* lispref/frames.texi (Input Focus): Document `focus-frame',
+	`save-selected-frame' and `with-selected-frame'.
+
+1998-06-10  Hrvoje Niksic  <hniksic@srce.hr>
+
+	* lispref/searching.texi (Regexp Search): Document `split-path'.
+
+	* lispref/files.texi (Unique File Names): Update docs for
+	`make-temp-name'; document `temp-directory'.
+
+1998-06-10  Hrvoje Niksic  <hniksic@srce.hr>
+
+	* lispref/os.texi (Recording Input): Update docs for `recent-keys'.
+
+	* lispref/specifiers.texi (Specifier Instancing): Correct
+	instantiation order.
+	(Specifier Instancing Functions): Ditto.
+
+1998-06-11  Oliver Graf <ograf@fga.de>
+
+	* lispref/lispref.texi: references to Drag'n'Drop fixed
+	* lispref/modes.texi: references to Drag'n'Drop fixed
+	* lispref/scrollbars.texi: references to Drag'n'Drop fixed
+	* lispref/dragndrop.texi: naming changed to Drag and Drop
+	added some docu about the drop procedure
+
+1998-06-09  Adrian Aichner  <aichner@ecf.teradyne.com>
+
+	* info-stnd.texi: added ../info/ to @setfilename.
+	* info.texi: added ../info/ to @setfilename.
+	* lispref/commands.texi: see ALL.
+	* lispref/frames.texi: see ALL.
+	* lispref/os.texi: see ALL.
+	* lispref/text.texi: see ALL.
+	* new-users-guide/custom1.texi: broke line after enumerated @item.
+	* new-users-guide/custom2.texi: see ALL.
+	* new-users-guide/edit.texi: see ALL.
+	* new-users-guide/enter.texi: see ALL.
+	* new-users-guide/files.texi: see ALL.
+	* new-users-guide/help.texi
+	* new-users-guide/modes.texi: see ALL.
+	* new-users-guide/new-users-guide.texi: see ALL.
+	* new-users-guide/region.texi: see ALL.
+	* new-users-guide/search.texi: see ALL.
+	* new-users-guide/xmenu.texi: see ALL.
+	* standards.texi: added ../info/ to @setfilename.
+	* texinfo.texi: added ../info/ to @setfilename, broke line after
+	@noindent.  Changed @var{arg-not-used-by-@TeX{}} to
+	@var{arg-not-used-by-@@TeX{}} to make `texinfo-format-buffer'
+	happy.
+	* xemacs-faq.texi: added ../info/ to @setfilename.
+	* ALL: corrected INFO-FILE-NAME to lispref and xemacs in relevant
+	p?xefs (most were empty, some elisp and emacs), used
+	PRINTED-MANUAL-TITLE "XEmacs Lisp Reference Manual" and "XEmacs
+	User's Manual" respectively for all these.
+
+1998-06-01  Oliver Graf <ograf@fga.de>
+
+	* lispref/dragndrop.texi: added experimental
+
 1998-05-28  Oliver Graf <ograf@fga.de>
 
 	* lispref/dragndrop.texi: a warning, and a bit more text this time

man/lispref/commands.texi

      "Text deleted this way cannot be yanked back!\n")
 @end example
 
-  @xref{Disabling,,, emacs, The XEmacs Reference Manual}, for the details on
+  @xref{Disabling,,, xemacs, The XEmacs User's Manual}, for the details on
 what happens when a disabled command is invoked interactively.
 Disabling a command has no effect on calling it as a function from Lisp
 programs.
   There are a number of commands devoted to the editing and recall of
 previous commands.  The commands @code{repeat-complex-command}, and
 @code{list-command-history} are described in the user manual
-(@pxref{Repetition,,, emacs, The XEmacs Reference Manual}).  Within the
+(@pxref{Repetition,,, xemacs, The XEmacs User's Manual}).  Within the
 minibuffer, the history commands used are the same ones available in any
 minibuffer.
 
 
 @c Broke paragraph to prevent overfull hbox. --rjc 15mar92
   The commands are described in the user's manual (@pxref{Keyboard
-Macros,,, xemacs, The XEmacs Reference Manual}).
+Macros,,, xemacs, The XEmacs User's Manual}).

man/lispref/dragndrop.texi

 @c Original reference is (c) 1990, 1991, 1992, 1993, 1994 Free Software Foundation, Inc. 
 @c See the file lispref.texi for copying conditions.
 @setfilename ../../info/dragndrop.texi
-@node Drag'n'Drop, Modes, Scrollbars, Top
-@chapter Drag'n'Drop
-@cindex drag'n'drop
+@node Drag and Drop, Modes, Scrollbars, Top
+@chapter Drag and Drop
+@cindex drag and drop
 
 @emph{WARNING}: the Drag'n'Drop API is still under development and the
-interface may change!
+interface may change! The current implementation is considered experimental.
 
   Drag'n'drop is a way to transfer information between multiple applications.
 To do this serveral GUIs define their own protocols. Examples are OffiX, CDE,
 @subsection Loose ends
 
 The following protocols will be supported soon: Xdnd, Motif, Xde (if I
-get some specs).
+get some specs), KDE OffiX (if KDE can find XEmacs windows).
 
 In particular Xdnd will be one of the protocols that can benefit from
 the XEmacs API, cause it also uses MIME types to encode dragged data.
 misc-user-event.
 
 This misc-user-event has its function argument set to
-dragdrop-drop-dispatch and the object contains the data of the drop
-(converted to URL/MIME specific data).
+@code{dragdrop-drop-dispatch} and the object contains the data of the drop
+(converted to URL/MIME specific data). This function will search the variable
+@code{experimental-dragdrop-drop-functions} for a function that can handle the 
+dropped data.
+
+To modify the drop behaviour, the user can modify the variable
+@code{experimental-dragdrop-drop-functions}. Each element of this list
+specifies a possible handler for dropped data. The first one that can handle
+the data will return @code{t} and exit. Another possibility is to set a
+extent-property with the same name. Extents are checked prior to the
+variable.
+
+The customization group @code{drag-n-drop} shows all variables of user
+interest. 
 
 @node Drag Interface
 @section Drag Interface

man/lispref/files.texi

 construct a name for such a file:
 
 @example
-(make-temp-name (concat "/tmp/" @var{name-of-application}))
+(make-temp-name (expand-file-name @var{name-of-application} (temp-directory)))
 @end example
 
 @noindent
-Here we use the directory @file{/tmp/} because that is the standard
-place on Unix for temporary files.  The job of @code{make-temp-name} is
-to prevent two different users or two different processes from trying to
-use the same name.
+Here we use @code{(temp-directory)} to specify a directory for temporary
+files---under Unix, it will normally evaluate to @file{"/tmp/"}.  The
+job of @code{make-temp-name} is to prevent two different users or two
+different processes from trying to use the same name.
 
-@defun make-temp-name string
-This function generates a string that can be used as a unique name.  The
-name starts with @var{string}, and ends with a number that is different
-in each XEmacs process.
+@defun temp-directory
+This function returns the name of the directory to use for temporary
+files.  Under Unix, this will be the value of @code{TMPDIR}, defaulting
+to @file{/tmp}.  On Windows, this will be obtained from the @code{TEMP}
+or @code{TMP} environment variables, defaulting to @file{/}.
+
+Note that the @code{temp-directory} function does not exist under FSF
+Emacs.
+@end defun
+
+@defun make-temp-name prefix
+This function generates a temporary file name starting with
+@var{prefix}.  The Emacs process number forms part of the result, so
+there is no danger of generating a name being used by another process.
 
 @example
 @group
 (make-temp-name "/tmp/foo")
-     @result{} "/tmp/foo021304"
+     @result{} "/tmp/fooGaAQjC"
 @end group
 @end example
 
-To prevent conflicts among different libraries running in the same
-XEmacs, each Lisp program that uses @code{make-temp-name} should have its
-own @var{string}.  The number added to the end of the name distinguishes
-between the same application running in different XEmacs processes.
+In addition, this function makes an attempt to choose a name that does
+not specify an existing file.  To make this work, @var{prefix} should be 
+an absolute file name.
+
+To avoid confusion, each Lisp application should preferably use a unique
+@var{prefix} to @code{make-temp-name}.
 @end defun
 
 @node File Name Completion

man/lispref/frames.texi

 the frame appear with the wrong ones and then change to the specified
 ones.  If that bothers you, you can specify the same geometry and
 appearance with X resources; those do take affect before the frame is
-created.  @xref{Resources X,, X Resources, emacs, The XEmacs User's Manual}.
+created.  @xref{Resources X,, X Resources, xemacs, The XEmacs User's Manual}.
 
 X resource settings typically apply to all frames.  If you want to
 specify some X resources solely for the sake of the initial frame, and
 If you use options that specify window appearance when you invoke XEmacs,
 they take effect by adding elements to @code{default-frame-plist}.  One
 exception is @samp{-geometry}, which adds the specified position to
-@code{initial-frame-plist} instead.  @xref{Command Arguments,,, emacs,
+@code{initial-frame-plist} instead.  @xref{Command Arguments,,, xemacs,
 The XEmacs User's Manual}.
 
 @node X Frame Properties
 focus of the X server if any.  The selection of @var{frame} lasts until
 the next time the user does something to select a different frame, or
 until the next time this function is called.
-@end defun
 
-Note that this does not actually cause the window-system focus to be set
-to this frame, or the @code{select-frame-hook} or
+Note that @code{select-frame} does not actually cause the window-system
+focus to be set to this frame, or the @code{select-frame-hook} or
 @code{deselect-frame-hook} to be run, until the next time that XEmacs is
 waiting for an event.
 
-Also note that when the variable @code{focus-follows-mouse} is non-nil,
-the frame selection is temporary and is reverted when the current
-command terminates, much like the buffer selected by @code{set-buffer}.
-In order to effect a permanent focus change use @code{focus-frame}.
+Also note that when the variable @code{focus-follows-mouse} is
+non-@code{nil}, the frame selection is temporary and is reverted when
+the current command terminates, much like the buffer selected by
+@code{set-buffer}.  In order to effect a permanent focus change use
+@code{focus-frame}.
+@end defun
 
-@ignore (FSF Emacs)
+@defun focus-frame frame
+This function selects @var{frame} and gives it the window system focus.
+The operation of @code{focus-frame} is not affected by the value of
+@code{focus-follows-mouse}.
+@end defun
+
+@defmac save-selected-frame forms@dots{}
+This macro records the selected frame, executes @var{forms} in sequence,
+then restores the earlier selected frame.  The value returned is the
+value of the last form.
+@end defmac
+
+@defmac with-selected-frame frame forms@dots{}
+This macro records the selected frame, then selects @var{frame} and
+executes @var{forms} in sequence.  After the last form is finished, the
+earlier selected frame is restored.  The value returned is the value of
+the last form.
+@end defmac
+
+@ignore (FSF Emacs, continued from defun select-frame)
 XEmacs cooperates with the X server and the window managers by arranging
 to select frames according to what the server and window manager ask
 for.  It does so by generating a special kind of input event, called a

man/lispref/lispref.texi

 * Dialog Boxes::	    Creating dialog boxes.
 * Toolbar::		    Controlling the toolbar.
 * Scrollbars::		    Controlling the scrollbars.
-* Drag'n'Drop::		    Generic API to inter-application communication
+* Drag and Drop::	    Generic API to inter-application communication
                               via specific protocols.
 * Modes::                   Defining major and minor modes.
 * Documentation::           Writing and using documentation strings.

man/lispref/modes.texi

 @c Copyright (C) 1990, 1991, 1992, 1993, 1994 Free Software Foundation, Inc. 
 @c See the file lispref.texi for copying conditions.
 @setfilename ../../info/modes.info
-@node Modes, Documentation, Drag'n'Drop, Top
+@node Modes, Documentation, Drag and Drop, Top
 @chapter Major and Minor Modes
 @cindex mode
 

man/lispref/os.texi

 switches @samp{-q} and @samp{-u} affect the use of the init file;
 @samp{-q} says not to load an init file, and @samp{-u} says to load a
 specified user's init file instead of yours.  @xref{Entering XEmacs,,,
-emacs, The XEmacs Reference Manual}.
+xemacs, The XEmacs User's Manual}.
 
 @cindex default init file
   A site may have a @dfn{default init file}, which is the library named
 byte-compile it (@pxref{Byte Compilation}), and make your @file{.emacs}
 file load the other file using @code{load} (@pxref{Loading}).
 
-  @xref{Init File Examples,,, emacs, The XEmacs Reference Manual}, for
+  @xref{Init File Examples,,, xemacs, The XEmacs User's Manual}, for
 examples of how to make various commonly desired customizations in your
 @file{.emacs} file.
 
 
 The command line arguments are parsed by the @code{command-line-1}
 function in the @file{startup.el} file.  See also @ref{Command
-Switches, , Command Line Switches and Arguments, emacs, The XEmacs
-Reference Manual}.
+Switches, , Command Line Switches and Arguments, xemacs, The XEmacs
+User's Manual}.
 @end defvar
 
 @defvar command-line-args
 @node Recording Input
 @subsection Recording Input
 
-@defun recent-keys
-This function returns a vector containing the last 100 input events
-from the keyboard or mouse.  All input events are included, whether or
-not they were used as parts of key sequences.  Thus, you always get the
-last 100 inputs, not counting keyboard macros.  (Events from keyboard
-macros are excluded because they are less interesting for debugging; it
-should be enough to see the events that invoked the macros.)
+@defun recent-keys &optional number
+This function returns a vector containing recent input events from the
+keyboard or mouse.  By default, 100 events are recorded, which is how
+many @code{recent-keys} returns.
+
+All input events are included, whether or not they were used as parts of
+key sequences.  Thus, you always get the last 100 inputs, not counting
+keyboard macros.  (Events from keyboard macros are excluded because they
+are less interesting for debugging; it should be enough to see the
+events that invoked the macros.)
+
+If @var{number} is specified, not more than @var{number} events will be
+returned.  You may change the number of stored events using
+@code{set-recent-keys-ring-size}.
+@end defun
+
+@defun recent-keys-ring-size
+This function returns the number of recent events stored internally.
+This is also the maximum number of events @code{recent-keys} can
+return.  By default, 100 events are stored.
+@end defun
+
+@defun set-recent-keys-ring-size size
+This function changes the number of events stored by XEmacs and returned 
+by @code{recent-keys}.
+
+For example, @code{(set-recent-keys-ring-size 250)} will make XEmacs
+remember last 250 events and will make @code{recent-keys} return last
+250 events by default.
 @end defun
 
 @deffn Command open-dribble-file  filename

man/lispref/positions.texi

 
 
 @defun vertical-motion count &optional window
-This function moves point to the start of the screen line @var{count}
-screen lines down from the screen line containing point.  If @var{count}
+This function moves point to the start of the frame line @var{count}
+frame lines down from the frame line containing point.  If @var{count}
 is negative, it moves up instead.
 
 @code{vertical-motion} returns the number of lines moved.  The value may
 be less in absolute value than @var{count} if the beginning or end of
 the buffer was reached.
 
-The window @var{window} is used for obtaining parameters such as the
-width, the horizontal scrolling, and the display table.  But
-@code{vertical-motion} always operates on the current buffer, even if
-@var{window} currently displays some other buffer.
+Note that @code{vertical-motion} sets @var{window}'s buffer's point, not
+@var{window}'s point. (This differs from FSF Emacs, which buggily always
+sets current buffer's point, regardless of @var{window}.)
+@end defun
+
+@defun vertical-motion-pixels count &optional window
+This function is identical to @code{vertical-motion}, except that it
+returns the vertical pixel height of the motino which took place,
+instead of the actual number of lines moved.  A motion of zero lines
+returns the height of the current line.
 @end defun
 
 @deffn Command move-to-window-line count &optional window

man/lispref/scrollbars.texi

 @c Copyright (C) 1995 Ben Wing.
 @c See the file lispref.texi for copying conditions.
 @setfilename ../../info/glyphs.info
-@node Scrollbars, Drag'n'Drop, Toolbar, top
+@node Scrollbars, Drag and Drop, Toolbar, top
 @chapter scrollbars
 @cindex scrollbars
 

man/lispref/searching.texi

 @end example
 @end defun
 
+@defun split-path path
+This function splits a search path into a list of strings.  The path
+components are separated with the characters specified with
+@code{path-separator}.  Under Unix, @code{path-separator} will normally
+be @samp{:}, while under Windows, it will be @samp{;}.
+@end defun
+
 @defun looking-at regexp
 This function determines whether the text in the current buffer directly
 following point matches the regular expression @var{regexp}.  ``Directly

man/lispref/specifiers.texi

 this window?''.
 
 More specifically, a specifier contains a set of @dfn{specifications},
-each of which associates a @dfn{locale} (a buffer object, a window
+each of which associates a @dfn{locale} (a window object, a buffer
 object, a frame object, a device object, or the symbol @code{global})
 with an @dfn{inst-list}, which is a list of one or more
 @dfn{inst-pairs}. (For each possible locale, there can be at most one
 @itemize @bullet
 @item
 First, XEmacs searches for a specification whose locale is the same as
-the window's buffer.  If that fails, the search is repeated, looking for
-a locale that is the same as the window itself.  If that fails, the
-search is repeated using the window's frame, then using the device that
-frame is on.  Finally, the specification whose locale is the symbol
-@code{global} (if there is such a specification) is considered.
+the window.  If that fails, the search is repeated, looking for a locale
+that is the same as the window's buffer.  If that fails, the search is
+repeated using the window's frame, then using the device that frame is
+on.  Finally, the specification whose locale is the symbol @code{global}
+(if there is such a specification) is considered.
 @item
 The inst-pairs contained in the specification that was found are
 considered in their order in the inst-list, looking for one whose tag
-set matches the device that is derived from the window domain. (The
+set matches the device that is derived from the window domain.  (The
 tag set is an unordered list of zero or more tag symbols.  For all
 tags that have predicates associated with them, the predicate must
 match the device.)
 
 @defun add-spec-to-specifier specifier instantiator &optional locale tag-set how-to-add
 This function adds a specification to @var{specifier}.  The
-specification maps from @var{locale} (which should be a buffer, window,
+specification maps from @var{locale} (which should be a window, buffer,
 frame, device, or the symbol @code{global}, and defaults to
 @code{global}) to @var{instantiator}, whose allowed values depend on the
 type of the specifier.  Optional argument @var{tag-set} limits the
 
 @itemize @bullet
 @item
-@var{locale} := a buffer, a window, a frame, a device, or @code{global}
+@var{locale} := a window, a buffer, a frame, a device, or @code{global}
 @item
 @var{tag-set} := an unordered list of zero or more @var{tags}, each of
 which is a symbol
 more convenient and should be used instead.
 @end defun
 
+@deffn Macro let-specifier specifier-list &rest body
+This special form temporarily adds specifications to specifiers,
+evaluates forms in @var{body} and restores the specifiers to their
+previous states.  The specifiers and their temporary specifications are
+listed in @var{specifier-list}.
+
+The format of @var{specifier-list} is
+