Anonymous avatar Anonymous committed b980b62

Import from CVS: tag r20-2b2

Comments (0)

Files changed (110)

 							-*- indented-text -*-
+to 20.2 beta2
+-- sundry psgml fixes
+-- VM-6.29
+-- Gnus-5.4.46
+-- W3-3.0.84
+-- miscellaneous bug fixes
+-- edmacro.el-3.10
+-- Reverted to custom-1.84
+-- Make use of DECnet support a configure time option.
+
 to 20.2 beta1
 -- W3-3.0.83 courtesy of William Perry
 -- edmacro.el-3.09 courtesy of Hrvoje Niksic
+Wed Apr 23 10:33:58 1997  Steven L Baur  <steve@altair.xemacs.org>
+
+	* XEmacs 20.2-b2 is released.
+
+	* configure.in (beta): OPENWINHOME misspelled.
+
+Mon Apr 21 14:48:29 1997  Steven L Baur  <steve@altair.xemacs.org>
+
+	* etc/BETA (writing): Update with information about how to create
+	patches.
+
 Sat Apr 19 16:13:16 1997  Steven L Baur  <steve@altair.xemacs.org>
 
 	* XEmacs 20.2-b1 is released.
 Remember, you can't compile lwlib for r4 and emacs for r5, or vice versa.
 They must be in sync.
 
+** Problems finding X11 libraries on Solaris with Openwindows
+
+Some users have reported problems in this area.  The reported solution
+is to define the environment variable OPENWINHOME, even if you must set
+it to `/usr/openwin'.
+
 * Problems with running XEmacs
 
 ** You type Control-H (Backspace) expecting to delete characters.
 with_toolbars=''
 with_tty='yes'
 use_union_type='no'
+with_dnet=''
 
 # # gnu echo silently eats `--help', `--version', `-n', `-e', `-E', `-n'.
 # # other versions of echo eat any strings beginning with `-n'.
 --with-pop		support POP for mail retrieval
 --with-kerberos		support Kerberos-authenticated POP
 --with-hesiod		support Hesiod to get the POP server host
+--with-dnet (*)		Compile with support for DECnet.
 
 Internationalization options:
 
 	with_pop	| \
 	with_kerberos	| \
 	with_hesiod	| \
+	with_dnet	| \
 	external_widget | \
 	verbose		| \
 	extra_verbose	| \
 DEFS="${C_SWITCH_SITE} $c_switch_system $c_switch_machine $c_switch_x_system $DEFS"
 LIBS="${LD_SWITCH_SITE} $ld_switch_x_system $libsrc_libs $LIBS"
 
-ac_save_LIBS="${LIBS}"
+test "${with_dnet}"      != "no"   -a \
+     "${with_dnet}"      != "yes" && { ac_save_LIBS="${LIBS}"
 LIBS="${LIBS} -ldnet"
 ac_have_lib=""
 test -n "$silent" || echo "checking for -ldnet"
 rm -f conftest*
 LIBS="${ac_save_LIBS}"
 if test -n "${ac_have_lib}"; then
-   
+   :; with_dnet="yes"
+else
+   :; 
+fi
+ }
+test "${with_dnet}" = yes && 
 {
 test -n "$verbose" && \
 echo "	defining HAVE_LIBDNET"
 "
 }
 
-   LIBS="${LIBS} -ldnet"
-fi
 
 
 ac_save_LIBS="${LIBS}"
       C_SWITCH_X_SITE="${C_SWITCH_X_SITE} ${arg}"
     fi
   done
-  for arg in "-L/usr/lib" "-L${OPENWINHHOME-/usr/openwin}/lib" "-L/usr/dt/lib"
+  for arg in "-L/usr/lib" "-L${OPENWINHOME-/usr/openwin}/lib" "-L/usr/dt/lib"
   do
     case "${arg}" in
 	-L*) if test -f `echo "${arg}/libtt.a" | sed 's/^\-L//'` ; then
 
 
 (
-echo "uname -a: `uname -a`" 
+if test -f /etc/osversion; then
+	# SONY NEWS-OS
+	echo "osversion: `cat /etc/osversion`"
+eles
+	echo "uname -a: `uname -a`" 
+fi
 echo "" 
 echo "$0 $quoted_arguments" 
 ) >> Installation
 elif test -n "$site_runtime_libraries"; then
   echo "  Additional libraries:                                   ${site_runtime_libraries}"
 fi
+test "$with_dnet"  = yes && echo "  Compiling in support for DNET."
 test "$with_socks" = yes && echo "  Compiling in support for SOCKS."
 test "$with_term"  = yes && echo "  Compiling in support for TERM."
 test "$with_xauth" = yes && echo "  Compiling in support for XAUTH."
 with_toolbars=''
 with_tty='yes'
 use_union_type='no'
+with_dnet=''
 
 # # gnu echo silently eats `--help', `--version', `-n', `-e', `-E', `-n'.
 # # other versions of echo eat any strings beginning with `-n'.
 --with-pop		support POP for mail retrieval
 --with-kerberos		support Kerberos-authenticated POP
 --with-hesiod		support Hesiod to get the POP server host
+--with-dnet (*)		Compile with support for DECnet.
 
 Internationalization options:
 
 	with_pop	| \
 	with_kerberos	| \
 	with_hesiod	| \
+	with_dnet	| \
 	external_widget | \
 	verbose		| \
 	extra_verbose	| \
 dnl If found, this defines HAVE_LIBDNET, which m/pmax.h checks,
 dnl and also adds -ldnet to LIBS, which Autoconf uses for checks.
 dnl FSF 19.29 also checks for function dnet_ntoa.
-AC_HAVE_LIBRARY(-ldnet)
+test "${with_dnet}"      != "no"   -a \
+     "${with_dnet}"      != "yes" && { AC_HAVE_LIBRARY(-ldnet, with_dnet="yes") }
+IF_YES_AC_DEFINE(with_dnet, HAVE_LIBDNET)
+
 dnl This causes -lresolv to get used in subsequent tests,
 dnl which causes failures on some systems such as HPUX 9.
 dnl FSF 19.29 also checks for function gethostbyname.
       C_SWITCH_X_SITE="${C_SWITCH_X_SITE} ${arg}"
     fi
   done
-  for arg in "-L/usr/lib" "-L${OPENWINHHOME-/usr/openwin}/lib" "-L/usr/dt/lib"
+  for arg in "-L/usr/lib" "-L${OPENWINHOME-/usr/openwin}/lib" "-L/usr/dt/lib"
   do
     case "${arg}" in
 	-L*) if test -f `echo "${arg}/libtt.a" | sed 's/^\-L//'` ; then
 elif test -n "$site_runtime_libraries"; then
   echo "  Additional libraries:                                   ${site_runtime_libraries}"
 fi
+test "$with_dnet"  = yes && echo "  Compiling in support for DNET."
 test "$with_socks" = yes && echo "  Compiling in support for SOCKS."
 test "$with_term"  = yes && echo "  Compiling in support for TERM."
 test "$with_xauth" = yes && echo "  Compiling in support for XAUTH."
 
 5. Any other unusual items you feel should be brought to the attention
    of the developers.
+
+** Creating patches for submission
+==================================
+
+When making patches you should use the `-c', or preferably if your
+diff supports it, `-u'.  Using ordinary diffs like this are
+notoriously prone to error (and this one won't in fact work, since
+I've already applied a patch to this file so the line numbers probably
+don't match up any more).
+
+$ diff -u old-file.c new-file.c
+
+-or-
+
+$ diff -c old-file.c new-file.c
+
+Also, it is helpful for me if you create the patch in the top level of
+the XEmacs source directory:
+
+$ diff -u lwlib/xlwmenu.c~ lwlib/xlwmenu.c
+
+I prefer patches to be accompanied by an update (either a raw entry or
+a patch) to the appropriate ChangeLog file, but it is not required.
+
+Also note that if you cut & paste from an xterm to an XEmacs mail buffer
+you will probably lose due to tab expansion.  The best thing to do is to
+M-x cd to the appropriate directory, and issue the command `C-u M-!' from
+within XEmacs.
 *** More user-level documentation on using Mule.
 
 
-* Changes in XEmacs 20.1
+* Changes in XEmacs 20.2
 ========================
 
 ** The logo has been changed, and the default background color is
 eval-expression (`M-:') and upcase-region (`C-x C-u')/downcase-region
 (`C-x C-l').
 
+** The `C-z' key now iconifies only the current X frame.  You can use
+`C-x C-z' to get the old behavior.
+
+On the tty frames `C-z' behaves as before.
+
 ** Numerous causes of crashes have been fixed.  XEmacs should now be
 even more stable than before.
 
 
 *** The nnml mail backend now understands compressed article files.
 
-** Custom 1.84, courtesy of Per Abrahamsen
+** Custom 1.86, courtesy of Per Abrahamsen
 
 The Customize library enables Emacs Lisp programmers to specify types
 of their variables, so that the users can customize them.
 the chain of buffer modification records shorter by one, to counteract
 the effect of the undo command making the record list longer by one.
 
-** edmacro.el-3.09, courtesy of Dave Gillespie, ported to XEmacs by
+** edmacro.el-3.10, courtesy of Dave Gillespie, ported to XEmacs by
 Hrvoje Niksic.
 
 Edmacro is a utility that provides easy editing of keyboard macros.
 ** overlay.el, courtesy of Joseph Nuspl
 
 
-* Lisp and internal changes in XEmacs 20.1
+* Lisp and internal changes in XEmacs 20.2
 ==========================================
 
 ** `defcustom' and `defgroup' can now be used to specify types and
 
 ** The `read-kbd-macro' function is now available.
 
-The `read-kbd-macro' function (and its shorter-named equivalent `kbd')
-from the edmacro package is now available in XEmacs.  For example:
+The `read-kbd-macro' function (as well as the read-time evaluated
+`kbd' macro) from the edmacro package is now available in XEmacs.  For
+example:
 
 (define-key foo-mode-map (kbd "C-c <up>") 'foo-up)
 
-is the equivalent of
+is completely equivalent to
 
 (define-key foo-mode-map [(control ?c) up] 'foo-up)
 
-Using `read-kbd-macro' and `kbd' is not necessary for GNU Emacs
-compatibility (GNU Emacs supports the XEmacs-style keysyms), but adds
-to clarity.
-
-For example, (kbd "C-?") is easier to read than [(control ??)].  The
-full description of the syntax of keybindings accepted by
-`read-kbd-macro' is documented in the docstring of `edmacro-mode'.
+The `kbd' macro is preferred over `read-kbd-macro' function , as it
+evaluates before compiling, thus having no loading overhead.
+
+Using `kbd' is not necessary for GNU Emacs compatibility (GNU Emacs
+supports the XEmacs-style keysyms), but adds to clarity.  For example,
+(kbd "C-?") is usually easier to read than [(control ??)].  The full
+description of the syntax of keybindings accepted by `read-kbd-macro'
+is documented in the docstring of `edmacro-mode'.
 
 ** Overlay compatibility is implemented.
 
 Emacs-compatible way of changing display properties.
 
 ** You should use keysyms kp-* (kp-1, kp-2, ..., kp-enter etc.)
-rather than the old form kp_*.  The old form is retained for
-backwards compatibility, but is obsolete.  The new form is also
-compatible with GNU Emacs.
+rather than the old form kp_*.  The new form is also compatible with
+GNU Emacs.
 
 ** The keysyms mouse-1, mouse-2, mouse-3 and down-mouse-1,
 down-mouse-2, and down-mouse-3 have been added for GNU Emacs
 distribution.
 
 
+* Changes in XEmacs 20.1
+========================
+
+XEmacs 20.1 has not been released to the net.  Please consult the 20.2
+entries instead.
+
+
 * Major Differences Between 19.14 and 20.0
 ===========================================
 

etc/app-defaults/ja/Emacs

 !! Fonts for the window frame and menus
 Emacs*fontList: \
 -*-gothic-medium-r-normal--14-120-75-75-c-*-*-*:
+!! FontSet for the window frame and menus when you use USE_XFONTSET
+Emacs*fontSet: -*-fixed-medium-r-normal--14-*
 
 !!!! Default Menubar Top Level
 
 performance:Performance Issues:dmoore:
 redisplay:Redisplay Issues:gnats-admin:cthomp@xemacs.org
 scrollbars:X11 scrollbars:gnats-amdin:mrb@eng.sun.com
+subprocesses:All Subprocess stuff:dmoore:
 toolbars:X11 toolbars:gnats-admin:
 gnus:Gnus newsreader:larsi:
 vm:VM Mailreader:kyle:

etc/gnats/xemacs.org

 performance
 redisplay
 scrollbars
-tooblbars
+subprocesses
+toolbars
 gnus
 vm
 w3

etc/sgml/iso88591.map

+160 [nbsp  ]
+161 [iexcl ]
+162 [cent  ]
+163 [pound ]
+164 [curren]
+165 [yen   ]
+166 [brvbar]
+167 [sect  ]
+168 [uml   ]
+169 [copy  ]
+170 [ordf  ]
+171 [laquo ]
+172 [not   ]
+173 [shy   ]
+174 [reg   ]
+175 [macr  ]
+176 [deg   ]
+177 [plusmn]
+178 [sup2  ]
+179 [sup3  ]
+180 [acute ]
+181 [micro ]
+182 [para  ]
+183 [middot]
+184 [cedil ]
+185 [sup1  ]
+186 [ordm  ]
+187 [raquo ]
+188 [frac14]
+189 [frac12]
+190 [frac34]
+191 [iquest]
+192 [Agrave]
+193 [Aacute]
+194 [Acirc ]
+195 [Atilde]
+196 [Auml  ]
+197 [Aring ]
+198 [AElig ]
+199 [Ccedil]
+200 [Egrave]
+201 [Eacute]
+202 [Ecirc ]
+203 [Euml  ]
+204 [Igrave]
+205 [Iacute]
+206 [Icirc ]
+207 [Iuml  ]
+208 [ETH   ]
+209 [Ntilde]
+210 [Ograve]
+211 [Oacute]
+212 [Ocirc ]
+213 [Otilde]
+214 [Ouml  ]
+216 [Oslash]
+217 [Ugrave]
+218 [Uacute]
+219 [Ucirc ]
+220 [Uuml  ]
+221 [Yacute]
+222 [THORN ]
+223 [szlig ]
+224 [agrave]
+225 [aacute]
+226 [acirc ]
+227 [atilde]
+228 [auml  ]
+229 [aring ]
+230 [aelig ]
+231 [ccedil]
+232 [egrave]
+233 [eacute]
+234 [ecirc ]
+235 [euml  ]
+236 [igrave]
+237 [iacute]
+238 [icirc ]
+239 [iuml  ]
+240 [eth   ]
+241 [ntilde]
+242 [ograve]
+243 [oacute]
+244 [ocirc ]
+245 [otilde]
+246 [ouml  ]
+248 [oslash]
+249 [ugrave]
+250 [uacute]
+251 [ucirc ]
+252 [uuml  ]
+253 [yacute]
+254 [thorn ]
+255 [yuml  ]
+192 �
+193 �
+194 �
+195 �
+196 �
+197 �
+198 �
+199 �
+200 �
+201 �
+202 �
+203 �
+204 �
+205 �
+206 �
+207 �
+208 �
+209 �
+210 �
+211 �
+212 �
+213 �
+214 �
+216 �
+217 �
+218 �
+219 �
+220 �
+221 �
+222 �
+223 �
+224 �
+225 �
+226 �
+227 �
+228 �
+229 �
+230 �
+231 �
+232 �
+233 �
+234 �
+235 �
+236 �
+237 �
+238 �
+239 �
+240 �
+241 �
+242 �
+243 �
+244 �
+245 �
+246 �
+248 �
+249 �
+250 �
+251 �
+252 �
+253 �
+254 �
+255 �

etc/w3/stylesheet

 **
 **  This contains the top level fallback default styles for Emacs-w3
 **
-******************************************************************************
+*******************************************************************************
 **
 ** To specify device-dependent styles, you must mark a section with
 ** @media devicetype { ... }
 ** xemacs - only include this chunk if you are using XEmacs
 **  light - only include this chunk if you are using a light background
 **   dark - only include this chunk if you are using a dark background
+**    tty - only include this chunk if you are using a TTY
+** ansi-tty - "  include this chunk if you are using an ANSI-capable TTY 
+*******************************************************************************
+**
+** There are some things this stylesheet cannot really specify, that we 
+** must rely on the browser to explicitly handle correctly:
+**
+** o table formatting
+** o actually creating a hyperlink from an <a> tag and its attributes
+** o specifying which tags open lists
+** o inlined images
+** o frames (perhaps with positioning)
+** o applet/script/embed/object
+** o horizontal rules
 ******************************************************************************/
 
-/*
-** Headers
-*/
+/* Headers */
 
 h1,h2,h3,
 h4,h5,h6  {
             font-weight : bold;
           }
 
-/*
-** Since Emacs-19 doesn't handle mixed-sized fonts very well just yet,
-** we only use them under XEmacs.  Hopefully, this will change soon.
-*/
-@media xemacs {
       h1  { font-size : +12pt }
       h2  { font-size : +6pt  }
       h3  { font-size : +4pt  }
       h5  { font-size : -2pt  }
       h6  { font-size : -4pt  }
-/*
-** Emacs-19 also doesn't handle how Emacs-W3 changes this type of font
-** very well, so lets only do it under XEmacs for now.  Emacs-19 can only
-** do monospaced fonts anyway, so its redundant.
-*/
+
+/* Used to cause problems under Emacs 19, lets try once more, with feeling! */
    pre,xmp,
   plaintext { font-family: monospace }
 key,code,tt { font-family: monospace }
-} // @media xemacs
 
 /*
 ** Best we can do under Emacs-19 is use the default font and try to make
 ** the standard way to do this, perhaps in CSS level 2.
 */
 input:text,
-input:integer,
+input:int,
 input:float,
 input:url,
 input:text    { text-decoration: underline; }
          }
 
 input:text,
-input:integer,
+input:int,
 input:float,
 input:url,
+input:file,
+input:password,
 input:text    { insert-before: "[{"; insert-after: "}]"; }
 select { insert-before: "[{"; insert-after: "}]"; }
 
  a:active { color : yellow   }
 } // @media ansi-tty
 
+/*
+** Secial styles for the Emacspeak subsystem of emacs - an incredibly cool
+** speech synthesizer.  This was contributed by T.V. Raman (raman@adobe.com)
+*/
 @media speech {
 h1,h2,h3,
 h4,h5,h6 { voice-family: paul; stress: 2; richness: 9; }
+Wed Apr 23 10:56:05 1997  Steven L Baur  <steve@altair.xemacs.org>
+
+	* prim/files.el (hack-local-variables-prop-line): Mistakenly
+	returned t when enable-local-variables was nil.
+
+	* psgml/psgml-charent.el (sgml-display-char-list-filename): Move
+	iso88591.map to a proper location.
+
+	* prim/sound.el (load-sound-file): Make sure sound files are read
+	as binary files.
+
+Tue Apr 22 02:05:38 1997  Steven L Baur  <steve@altair.xemacs.org>
+
+	* packages/vc.el (vc-directory): Set text properties.
+
+	* psgml/psgml-xemacs.el (sgml-xemacs-get-popup-value): Allow for
+	interactive commands.
+
+Mon Apr 21 15:15:12 1997  Steven L Baur  <steve@altair.xemacs.org>
+
+	* prim/minibuf.el (input-error): New error type.
+	(read-from-minibuffer): Use it.
+
+	* comint/comint.el (comint-exec-hook): Do not Customize due to
+	interactions with setting language environment in MULE.
+
+Sun Apr 20 09:36:19 1997  Steven L Baur  <steve@altair.xemacs.org>
+
+	* packages/info.el (Info-footnote-tag): Changing the footnote tag
+	from the default "Note" is broken.
+
+Tue Apr 22 07:01:20 1997  Hrvoje Niksic  <hniksic@srce.hr>
+
+	* prim/keydefs.el (global-map): Bind it to `C-z'.
+
+	* prim/frame.el (suspend-emacs-or-iconify-frame): New function.
+
 Fri Apr 18 16:45:07 1997  Steven L Baur  <steve@altair.xemacs.org>
 
 	* utils/skeleton.el (skeleton-pair-insert-maybe): Guard test with

lisp/comint/comint.el

   :type 'hook
   :group 'comint)
 
-(defcustom comint-exec-hook '()
+;; This is initialized by the various language environments, do not
+;; Custom-ize it.
+(defvar comint-exec-hook '()
   "Called each time a process is exec'd by `comint-exec'.
 This is called after the process is cranked up.  It is useful for things that
 must be done each time a process is executed in a comint mode buffer (e.g.,
 `(process-kill-without-query)').  In contrast, the `comint-mode-hook' is only
-executed once when the buffer is created."
-  :type 'hook
-  :group 'comint)
+executed once when the buffer is created.")
 
 (defvar comint-mode-map nil)
 

lisp/comint/gdbsrc.el

       (and (eq major-mode 'gdb-mode)	; doesn't work w/ energize yet
 	   (setq current-gdb-buffer (current-buffer))
 	   ;; XEmacs change:
-	   (make-local-hook 'kill-buffer-hook)
-	   (add-hook 'kill-buffer-hook 'gdbsrc-reset nil t))
+	   (progn
+	     (make-local-hook 'kill-buffer-hook)
+	     (add-hook 'kill-buffer-hook 'gdbsrc-reset nil t)))
       (error "Cannot determine current-gdb-buffer"))
 ;;;   (set-process-filter 
 ;;;    (get-buffer-process current-gdb-buffer) 'gdbsrc-mode-filter)
 	 epnt
 	 extent
 	 (eq (window-buffer ewin)
-	     (extent-buffer extent))
+	     (extent-object extent))
 	 (extent-start-position extent)
 	 (> epnt (extent-start-position extent))
 	 (> (extent-end-position extent) epnt))))
   ;; stig@hackvan.com
   (and extent		; FIXME - I'm such a sinner...
        (eq (current-buffer) 
-	   (extent-buffer extent))
+	   (extent-object extent))
        (> (point) (extent-start-position extent))
        (>= (extent-end-position extent) (point))))
 
   (let ((gbuf (or gdbsrc-associated-buffer current-gdb-buffer)))
     (cond ((eq (current-buffer) gbuf)
 	   (and gdb-arrow-extent
-		(extent-buffer gdb-arrow-extent)
-		(progn (pop-to-buffer (extent-buffer gdb-arrow-extent))
+		(extent-object gdb-arrow-extent)
+		(progn (pop-to-buffer (extent-object gdb-arrow-extent))
 		       (goto-char (extent-start-position gdb-arrow-extent)))))
 	  ((buffer-name gbuf) (pop-to-buffer gbuf))
 	  ((y-or-n-p "No debugger.  Start a new one? ")
   (ad-set-arg 2 'source) ; tell it not to select the gdb window
   ad-do-it
   (save-excursion
-    (let* ((buf (extent-buffer gdb-arrow-extent))
+    (let* ((buf (extent-object gdb-arrow-extent))
 	   (win (get-buffer-window buf)))
       (setq gdbsrc-last-src-buffer buf)
       (select-window win)

lisp/custom/ChangeLog

-Thu Apr 17 18:55:15 1997  Per Abrahamsen  <abraham@dina.kvl.dk>
-
-	* Version 1.89 released.
-
-Thu Apr 17 11:23:20 1997  Per Abrahamsen  <abraham@dina.kvl.dk>
-
-	* cus-edit.el (custom-toggle-hide): New function.
-	(custom-level-action): Use it.
-	(custom-group-menu): Ditto.
-	(custom-face-menu): Ditto.
-	(custom-variable-menu): Ditto.
-
-	* cus-edit.el (custom-redraw): Goto old line and column instead of
-	old character position.  This is more tolerant for changes.
-
-	* wid-edit.el (widget-choice-action): Only notify parent if
-	something was chosen.
-
-	* widget.texi (Sexp Types): Documented `function-item' and
-	`variable-item'. 
-	(group): New subsection.
-	(Widget Browser): New section.
-	(Widget Minor Mode): New sextion.
-
-	* wid-edit.el: Moved widget minor mode support to
-	`wid-browse.el'. 
-
-	* custom.el (custom-declare-group): Make sure initial members
-	aren't duplicated even if the `defgroup' is evaluated twice. 
-
-	* custom.el (custom-declare-variable): Use `append' instead of
-	`copy-list'.
-
-	* widget.texi (checklist): Documented `:greedy'.
-
-Wed Apr 16 19:24:47 1997  Per Abrahamsen  <abraham@dina.kvl.dk>
-
-	* Version 1.88 released.
-
-Wed Apr 16 13:28:37 1997  Per Abrahamsen  <abraham@dina.kvl.dk>
-
-	* wid-edit.el (widget-minor-mode): New variable and command.
-	(widget-minor-mode-map): New variable.
-	Add to `'minor-mode-alist' and `minor-mode-map-alist'.
-	* widget.el: Added autoload.
-
-	* wid-edit.el (widget-specify-inactive): Set priority.
-
-	* wid-edit.el (widget-move): Skip inactive widgets.
-
-	* cus-edit.el (custom-display-unselected-match): Matched too many 
-        displays.  
-
-	* Version 1.87 released.
-
-Wed Apr 16 00:15:26 1997  Per Abrahamsen  <abraham@dina.kvl.dk>
-
-	* wid-edit.el (widget-field-face): Changed default background
-	color. 
-
-	* custom.el (custom-declare-variable): Set `custom-get' the right
-	place.
-
-	* cus-edit.el (custom-magic): Don't notify the parent.
-
-	* cus-edit.el (custom-variable-menu): Allow more actions on
-	`changed' and `rogue' states.
-
-	* custom.el (custom-initialize-set): New function.
-	(custom-initialize-reset): New function.
-	(custom-initialize-changed): New function.
-	(custom-declare-variable): Use `custom-initialize-set' as
-	default for `:initialize'.
-
-	* Version 1.86 released.
-
-Wed Apr 16 00:02:19 1997  Per Abrahamsen  <abraham@dina.kvl.dk>
-
-	* cus-edit.el (custom-save-variables): Save :require symbols.
-
-	* Version 1.85 released.
-
-Tue Apr 15 11:56:16 1997  Per Abrahamsen  <abraham@dina.kvl.dk>
-
-	* custom.el (:initialize, :set, :get, :request): New keywords. 
-	(custom-declare-variable): Support them.
-	(custom-set-variables): Ditto.
-	(defcustom): Document them.
-	(custom-initialize-default): New function.
-	* custom.texi (Declaring Variables): Documented them.
-	* cus-edit.el (custom-variable-value-create): Support them.
-	(custom-variable-set): Ditto.
-	(custom-variable-save): Ditto.
-	(custom-variable-reset-saved): Ditto.
-	(custom-variable-reset-factory): Ditto.
-	(custom-variable-state-set): Ditto.
-
-	* cus-edit.el (custom-menu-filter): New function.
-	(custom-variable-menu): New format.
-	(custom-variable-action): Use it.
-	(custom-face-menu): New format.
-	(custom-face-action): Use it.
-	(custom-group-menu): New format.
-	(custom-group-action): Use it.
-
-	* wid-edit.el (widget-choose): Accept unselectable items.
-
-	* wid-edit.el (widget-default-create): Clear undo buffer.
-	(widget-default-delete): Ditto.
-
-	* cus-edit.el (customize-other-window): New function.
-
-	* cus-face.el (custom-frame-parameter): Replace
-	`frame-parameter'. 
-	(custom-background-mode, custom-extract-frame-properties,
-	custom-get-frame-properties): Updated callers.
-
-	* custom.el: Minor doc fixes from RMS.
-
-	* cus-face.el (custom-declare-face): Protest when dumping defface
-	in Emacs.
-
-	* wid-edit.el (widget-info-link-action): Steal mouse up event.
-
-	* wid-edit.el (widget-specify-insert): Use old style backquote.
-	Patch by "William M. Perry" <wmperry@aventail.com>.
-	
-Sun Apr 13 19:19:33 1997  Per Abrahamsen  <abraham@dina.kvl.dk>
-
-	* custom.texi (Declaring Faces): Documentation property symbol is 
-	`face-documentation'. 
-
 Sat Apr 12 18:31:22 1997  Per Abrahamsen  <abraham@dina.kvl.dk>
 
 	* Version 1.84 released.

lisp/custom/cus-edit.el

 ;;
 ;; Author: Per Abrahamsen <abraham@dina.kvl.dk>
 ;; Keywords: help, faces
-;; Version: 1.89
+;; Version: 1.84
 ;; X-URL: http://www.dina.kvl.dk/~abraham/custom/
 
 ;;; Commentary:
 ;;
-;; This file implements the code to create and edit customize buffers.
-;; 
 ;; See `custom.el'.
 
 ;;; Code:
 (require 'wid-edit)
 (require 'easymenu)
 
-(condition-case nil
-    (require 'cus-load)
-  (error nil))
-
 (define-widget-keywords :custom-prefixes :custom-menu :custom-show
   :custom-magic :custom-state :custom-level :custom-form
   :custom-set :custom-save :custom-reset-current :custom-reset-saved 
      (list (if (equal val "")
 	       v (intern val)))))
 
-(defun custom-menu-filter (menu widget)
-  "Convert MENU to the form used by `widget-choose'.
-MENU should be in the same format as `custom-variable-menu'.
-WIDGET is the widget to apply the filter entries of MENU on."
-  (let ((result nil)
-	current name action filter)
-    (while menu 
-      (setq current (car menu)
-	    name (nth 0 current)
-	    action (nth 1 current)
-	    filter (nth 2 current)
-	    menu (cdr menu))
-      (if (or (null filter) (funcall filter widget))
-	  (push (cons name action) result)
-	(push name result)))
-    (nreverse result)))
-
 ;;; Unlispify.
 
 (defvar custom-prefix-list nil
   (custom-buffer-create (list (list symbol 'custom-group))))
 
 ;;;###autoload
-(defun customize-other-window (symbol)
-  "Customize SYMBOL, which must be a customization group."
-  (interactive (list (completing-read "Customize group: (default emacs) "
-				      obarray 
-				      (lambda (symbol)
-					(get symbol 'custom-group))
-				      t)))
-
-  (when (stringp symbol)
-    (if (string-equal "" symbol)
-	(setq symbol 'emacs)
-      (setq symbol (intern symbol))))
-  (custom-buffer-create-other-window (list (list symbol 'custom-group))))
-
-;;;###autoload
 (defun customize-variable (symbol)
   "Customize SYMBOL, which must be a variable."
   (interactive (custom-variable-prompt))
   "Show and manipulate state for a customization option."
   :format "%v"
   :action 'widget-choice-item-action
-  :notify 'ignore
   :value-get 'ignore
   :value-create 'custom-magic-value-create
   :value-delete 'widget-children-value-delete)
 
 (defun custom-level-action (widget &optional event)
   "Toggle visibility for parent to WIDGET."
-  (custom-toggle-hide (widget-get widget :parent)))
+  (let* ((parent (widget-get widget :parent))
+	 (state (widget-get parent :custom-state)))
+    (cond ((memq state '(invalid modified))
+	   (error "There are unset changes"))
+	  ((eq state 'hidden)
+	   (widget-put parent :custom-state 'unknown))
+	  (t
+	   (widget-put parent :custom-state 'hidden)))
+    (custom-redraw parent)))
 
 ;;; The `custom' Widget.
 
 
 (defun custom-redraw (widget)
   "Redraw WIDGET with current settings."
-  (let ((line (count-lines (point-min) (point)))
-	(column (current-column))
-	(pos (point))
+  (let ((pos (point))
 	(from (marker-position (widget-get widget :from)))
 	(to (marker-position (widget-get widget :to))))
     (save-excursion
       (widget-value-set widget (widget-value widget))
       (custom-redraw-magic widget))
     (when (and (>= pos from) (<= pos to))
-      (condition-case nil
-	  (progn 
-	    (goto-line line)
-	    (move-to-column column))
-	(error nil)))))
+      (goto-char pos))))
 
 (defun custom-redraw-magic (widget)
   "Redraw WIDGET state with current settings."
   "Load all dependencies for WIDGET."
   (custom-load-symbol (widget-value widget)))
 
-(defun custom-toggle-hide (widget)
-  "Toggle visibility of WIDGET."
-  (let ((state (widget-get widget :custom-state)))
-    (cond ((memq state '(invalid modified))
-	   (error "There are unset changes"))
-	  ((eq state 'hidden)
-	   (widget-put widget :custom-state 'unknown))
-	  (t 
-	   (widget-put widget :custom-state 'hidden)))
-    (custom-redraw widget)))
-
 ;;; The `custom-variable' Widget.
 
 (defface custom-variable-sample-face '((t (:underline t)))
 	 (tag (widget-get widget :tag))
 	 (type (custom-variable-type symbol))
 	 (conv (widget-convert type))
-	 (get (or (get symbol 'custom-get) 'default-value))
-	 (set (or (get symbol 'custom-set) 'set-default))
 	 (value (if (default-boundp symbol)
-		    (funcall get symbol)
+		    (default-value symbol)
 		  (widget-get conv :value))))
     ;; If the widget is new, the child determine whether it is hidden.
     (cond (state)
 			       ((get symbol 'factory-value)
 				(car (get symbol 'factory-value)))
 			       ((default-boundp symbol)
-				(custom-quote (funcall get symbol)))
+				(custom-quote (default-value symbol)))
 			       (t
 				(custom-quote (widget-get conv :value))))))
 	     (push (widget-create-child-and-convert 
 (defun custom-variable-state-set (widget)
   "Set the state of WIDGET."
   (let* ((symbol (widget-value widget))
-	 (get (or (get symbol 'custom-get) 'default-value))
 	 (value (if (default-boundp symbol)
-		    (funcall get symbol)
+		    (default-value symbol)
 		  (widget-get widget :value)))
 	 tmp
 	 (state (cond ((setq tmp (get symbol 'customized-value))
     (widget-put widget :custom-state state)))
 
 (defvar custom-variable-menu 
-  '(("Hide" custom-toggle-hide
-     (lambda (widget)
-       (not (memq (widget-get widget :custom-state) '(modified invalid)))))
-     ("Edit" custom-variable-edit 
-     (lambda (widget)
-       (not (eq (widget-get widget :custom-form) 'edit))))
-    ("Edit Lisp" custom-variable-edit-lisp
-     (lambda (widget)
-       (not (eq (widget-get widget :custom-form) 'lisp))))
-    ("Set" custom-variable-set
-     (lambda (widget)
-       (eq (widget-get widget :custom-state) 'modified)))
-    ("Save" custom-variable-save
-     (lambda (widget)
-       (memq (widget-get widget :custom-state) '(modified set changed rogue))))
-    ("Reset to Current" custom-redraw
-     (lambda (widget)
-       (and (default-boundp (widget-value widget))
-	    (memq (widget-get widget :custom-state) '(modified)))))
-    ("Reset to Saved" custom-variable-reset-saved
-     (lambda (widget)
-       (and (get (widget-value widget) 'saved-value)
-	    (memq (widget-get widget :custom-state)
-		  '(modified set changed rogue)))))
-    ("Reset to Factory Settings" custom-variable-reset-factory
-     (lambda (widget)
-       (and (get (widget-value widget) 'factory-value)
-	    (memq (widget-get widget :custom-state)
-		  '(modified set changed saved rogue))))))
+  '(("Edit" . custom-variable-edit)
+    ("Edit Lisp" . custom-variable-edit-lisp)
+    ("Set" . custom-variable-set)
+    ("Save" . custom-variable-save)
+    ("Reset to Current" . custom-redraw)
+    ("Reset to Saved" . custom-variable-reset-saved)
+    ("Reset to Factory Settings" . custom-variable-reset-factory))
   "Alist of actions for the `custom-variable' widget.
-Each entry has the form (NAME ACTION FILTER) where NAME is the name of
-the menu entry, ACTION is the function to call on the widget when the
-menu is selected, and FILTER is a predicate which takes a `custom-variable'
-widget as an argument, and returns non-nil if ACTION is valid on that
-widget. If FILTER is nil, ACTION is always valid.")
+The key is a string containing the name of the action, the value is a
+lisp function taking the widget as an element which will be called
+when the action is chosen.")
 
 (defun custom-variable-action (widget &optional event)
   "Show the menu for `custom-variable' WIDGET.
     (let* ((completion-ignore-case t)
 	   (answer (widget-choose (custom-unlispify-tag-name
 				   (widget-get widget :value))
-				  (custom-menu-filter custom-variable-menu
-						      widget)
+				  custom-variable-menu
 				  event)))
       (if answer
 	  (funcall answer widget)))))
 
 (defun custom-variable-set (widget)
   "Set the current value for the variable being edited by WIDGET."
-  (let* ((form (widget-get widget :custom-form))
-	 (state (widget-get widget :custom-state))
-	 (child (car (widget-get widget :children)))
-	 (symbol (widget-value widget))
-	 (set (or (get symbol 'custom-set) 'set-default))
-	  val)
+  (let ((form (widget-get widget :custom-form))
+	(state (widget-get widget :custom-state))
+	(child (car (widget-get widget :children)))
+	(symbol (widget-value widget))
+	val)
     (cond ((eq state 'hidden)
 	   (error "Cannot set hidden variable."))
 	  ((setq val (widget-apply child :validate))
 	   (goto-char (widget-get val :from))
 	   (error "%s" (widget-get val :error)))
 	  ((eq form 'lisp)
-	   (funcall set symbol (eval (setq val (widget-value child))))
+	   (set-default symbol (eval (setq val (widget-value child))))
 	   (put symbol 'customized-value (list val)))
 	  (t
-	   (funcall set symbol (setq val (widget-value child)))
+	   (set-default symbol (setq val (widget-value child)))
 	   (put symbol 'customized-value (list (custom-quote val)))))
     (custom-variable-state-set widget)
     (custom-redraw-magic widget)))
 
 (defun custom-variable-save (widget)
   "Set the default value for the variable being edited by WIDGET."
-  (let* ((form (widget-get widget :custom-form))
-	 (state (widget-get widget :custom-state))
-	 (child (car (widget-get widget :children)))
-	 (symbol (widget-value widget))
-	 (set (or (get symbol 'custom-set) 'set-default))
-	 val)
+  (let ((form (widget-get widget :custom-form))
+	(state (widget-get widget :custom-state))
+	(child (car (widget-get widget :children)))
+	(symbol (widget-value widget))
+	val)
     (cond ((eq state 'hidden)
 	   (error "Cannot set hidden variable."))
 	  ((setq val (widget-apply child :validate))
 	   (error "%s" (widget-get val :error)))
 	  ((eq form 'lisp)
 	   (put symbol 'saved-value (list (widget-value child)))
-	   (funcall set symbol (eval (widget-value child))))
+	   (set-default symbol (eval (widget-value child))))
 	  (t
 	   (put symbol
 		'saved-value (list (custom-quote (widget-value
 						  child))))
-	   (funcall set symbol (widget-value child))))
+	   (set-default symbol (widget-value child))))
     (put symbol 'customized-value nil)
     (custom-save-all)
     (custom-variable-state-set widget)
 
 (defun custom-variable-reset-saved (widget)
   "Restore the saved value for the variable being edited by WIDGET."
-  (let* ((symbol (widget-value widget))
-	 (set (or (get symbol 'custom-set) 'set-default)))
+  (let ((symbol (widget-value widget)))
     (if (get symbol 'saved-value)
 	(condition-case nil
-	    (funcall set symbol (eval (car (get symbol 'saved-value))))
+	    (set-default symbol (eval (car (get symbol 'saved-value))))
 	  (error nil))
       (error "No saved value for %s" symbol))
     (put symbol 'customized-value nil)
 
 (defun custom-variable-reset-factory (widget)
   "Restore the factory setting for the variable being edited by WIDGET."
-  (let* ((symbol (widget-value widget))
-	 (set (or (get symbol 'custom-set) 'set-default)))
+  (let ((symbol (widget-value widget)))
     (if (get symbol 'factory-value)
-	(funcall set symbol (eval (car (get symbol 'factory-value))))
+	(set-default symbol (eval (car (get symbol 'factory-value))))
       (error "No factory default for %S" symbol))
     (put symbol 'customized-value nil)
     (when (get symbol 'saved-value)
 
 (defun custom-display-unselected-match (widget value)
   "Non-nil if VALUE is an unselected display specification."
-  (not (custom-display-match-frame value (selected-frame))))
+  (and (listp value)
+       (eq (length value) 2)
+       (not (custom-display-match-frame value (selected-frame)))))
 
 (define-widget 'custom-face-selected 'group 
   "Edit the attributes of the selected display in a face specification."
     (message "Creating face editor...done")))
 
 (defvar custom-face-menu 
-  '(("Hide" custom-toggle-hide
-     (lambda (widget)
-       (not (memq (widget-get widget :custom-state) '(modified invalid)))))
-    ("Edit Selected" custom-face-edit-selected
-     (lambda (widget)
-       (not (eq (widget-get widget :custom-form) 'selected))))
-    ("Edit All" custom-face-edit-all
-     (lambda (widget)
-       (not (eq (widget-get widget :custom-form) 'all))))
-    ("Edit Lisp" custom-face-edit-lisp
-     (lambda (widget)
-       (not (eq (widget-get widget :custom-form) 'lisp))))
-    ("Set" custom-face-set)
-    ("Save" custom-face-save)
-    ("Reset to Saved" custom-face-reset-saved
-     (lambda (widget)
-       (get (widget-value widget) 'saved-face)))
-    ("Reset to Factory Setting" custom-face-reset-factory
-     (lambda (widget)
-       (get (widget-value widget) 'factory-face))))
+  '(("Edit Selected" . custom-face-edit-selected)
+    ("Edit All" . custom-face-edit-all)
+    ("Edit Lisp" . custom-face-edit-lisp)
+    ("Set" . custom-face-set)
+    ("Save" . custom-face-save)
+    ("Reset to Saved" . custom-face-reset-saved)
+    ("Reset to Factory Setting" . custom-face-reset-factory))
   "Alist of actions for the `custom-face' widget.
-Each entry has the form (NAME ACTION FILTER) where NAME is the name of
-the menu entry, ACTION is the function to call on the widget when the
-menu is selected, and FILTER is a predicate which takes a `custom-face'
-widget as an argument, and returns non-nil if ACTION is valid on that
-widget. If FILTER is nil, ACTION is always valid.")
+The key is a string containing the name of the action, the value is a
+lisp function taking the widget as an element which will be called
+when the action is chosen.")
 
 (defun custom-face-edit-selected (widget)
   "Edit selected attributes of the value of WIDGET."
     (let* ((completion-ignore-case t)
 	   (symbol (widget-get widget :value))
 	   (answer (widget-choose (custom-unlispify-tag-name symbol)
-				  (custom-menu-filter custom-face-menu
-						      widget)
-				  event)))
+				  custom-face-menu event)))
       (if answer
 	  (funcall answer widget)))))
 
 	(message "Creating group... done")))))
 
 (defvar custom-group-menu 
-  '(("Hide" custom-toggle-hide
-     (lambda (widget)
-       (not (memq (widget-get widget :custom-state) '(modified invalid)))))
-    ("Set" custom-group-set
-     (lambda (widget)
-       (eq (widget-get widget :custom-state) 'modified)))
-    ("Save" custom-group-save
-     (lambda (widget)
-       (memq (widget-get widget :custom-state) '(modified set))))
-    ("Reset to Current" custom-group-reset-current
-     (lambda (widget)
-       (and (default-boundp (widget-value widget))
-	    (memq (widget-get widget :custom-state) '(modified)))))
-    ("Reset to Saved" custom-group-reset-saved
-     (lambda (widget)
-       (and (get (widget-value widget) 'saved-value)
-	    (memq (widget-get widget :custom-state) '(modified set)))))
-    ("Reset to Factory" custom-group-reset-factory
-     (lambda (widget)
-       (and (get (widget-value widget) 'factory-value)
-	    (memq (widget-get widget :custom-state) '(modified set saved))))))
+  '(("Set" . custom-group-set)
+    ("Save" . custom-group-save)
+    ("Reset to Current" . custom-group-reset-current)
+    ("Reset to Saved" . custom-group-reset-saved)
+    ("Reset to Factory" . custom-group-reset-factory))
   "Alist of actions for the `custom-group' widget.
-Each entry has the form (NAME ACTION FILTER) where NAME is the name of
-the menu entry, ACTION is the function to call on the widget when the
-menu is selected, and FILTER is a predicate which takes a `custom-group'
-widget as an argument, and returns non-nil if ACTION is valid on that
-widget. If FILTER is nil, ACTION is always valid.")
+The key is a string containing the name of the action, the value is a
+lisp function taking the widget as an element which will be called
+when the action is chosen.")
 
 (defun custom-group-action (widget &optional event)
   "Show the menu for `custom-group' WIDGET.
     (let* ((completion-ignore-case t)
 	   (answer (widget-choose (custom-unlispify-tag-name
 				   (widget-get widget :value))
-				  (custom-menu-filter custom-group-menu
-						      widget)
+				  custom-group-menu
 				  event)))
       (if answer
 	  (funcall answer widget)))))
 	(princ "\n"))
       (princ "(custom-set-variables")
       (mapatoms (lambda (symbol)
-		  (let ((value (get symbol 'saved-value))
-			(requests (get symbol 'custom-requests))
-			(now (not (or (get symbol 'factory-value)
-				      (and (not (boundp symbol))
-					   (not (get symbol 'force-value)))))))
+		  (let ((value (get symbol 'saved-value)))
 		    (when value
 		      (princ "\n '(")
 		      (princ symbol)
 		      (princ " ")
 		      (prin1 (car value))
-		      (cond (requests
-			     (if now
-				 (princ " t ")
-			       (princ " nil "))
-			     (prin1 requests)
-			     (princ ")"))
-			    (now
-			     (princ " t)"))
-			    (t
-			     (princ ")")))))))
+		      (if (or (get symbol 'factory-value)
+			      (and (not (boundp symbol))
+				   (not (get symbol 'force-value))))
+			  (princ ")")
+			(princ " t)"))))))
       (princ ")")
       (unless (looking-at "\n")
 	(princ "\n")))))
 
 (easy-menu-define custom-mode-customize-menu 
     custom-mode-map
-  "Menu used to customize customization buffers."
+  "Menu used in customization buffers."
   (customize-menu-create 'customize))
 
 (easy-menu-define custom-mode-menu 

lisp/custom/cus-face.el

 ;;
 ;; Author: Per Abrahamsen <abraham@dina.kvl.dk>
 ;; Keywords: help, faces
-;; Version: 1.89
+;; Version: 1.84
 ;; X-URL: http://www.dina.kvl.dk/~abraham/custom/
 
 ;;; Commentary:
 				     'face-font-name
 				   'face-font))
 
-
 (eval-and-compile
-  (cond ((fboundp 'frame-property)
-	 ;; XEmacs.
-	 (defalias 'custom-frame-parameter 'frame-property))
-	((fboundp 'frame-parameter)
-	 ;; Emacs 19.35.
-	 (defalias 'custom-frame-parameter 'frame-parameter))
-	(t
-	 ;; Old emacsen.
-	 (defun custom-frame-parameter (frame property &optional default)
-	   "Return FRAME's value for property PROPERTY."
-	   (or (cdr (assq property (frame-parameters frame)))
-	       default))))
+  (unless (fboundp 'frame-property)
+    ;; XEmacs function missing in Emacs.
+    (defun frame-property (frame property &optional default)
+      "Return FRAME's value for property PROPERTY."
+      (or (cdr (assq property (frame-parameters frame)))
+	  default)))
 
   (unless (fboundp 'face-doc-string)
     ;; XEmacs function missing in Emacs.
 ;;    (interactive (list (read-face-name "Reverse face: ")))
 ;;    (let ((fg (or (face-foreground face frame)
 ;;		  (face-foreground 'default frame)
-;;		  (custom-frame-parameter (or frame (selected-frame))
+;;		  (frame-property (or frame (selected-frame))
 ;;				  'foreground-color)
 ;;		  "black"))
 ;;	  (bg (or (face-background face frame)
 ;;		  (face-background 'default frame)
-;;		  (custom-frame-parameter (or frame (selected-frame))
+;;		  (frame-property (or frame (selected-frame))
 ;;				  'background-color)
 ;;		  "white")))
 ;;      (set-face-foreground face bg frame)
 	 (mode (cond (bg-resource
 		      (intern (downcase bg-resource)))
 		     ((and (setq color (condition-case ()
-					   (or (custom-frame-parameter
+					   (or (frame-property
 						frame
 						'background-color)
 					       (custom-face-background
 	(list 'type (device-type (frame-device frame))
 	      'class (device-class (frame-device frame))
 	      'background (or custom-background-mode
-			      (custom-frame-parameter frame
+			      (frame-property frame
 					      'background-mode)
 			      (custom-background-mode frame))))
     ;; Emacs.
     (defun custom-extract-frame-properties (frame)
       "Return a plist with the frame properties of FRAME used by custom."
       (list 'type window-system
-	    'class (custom-frame-parameter frame 'display-type)
+	    'class (frame-property frame 'display-type)
 	    'background (or custom-background-mode
-			    (custom-frame-parameter frame 'background-mode)
+			    (frame-property frame 'background-mode)
 			    (custom-background-mode frame))))))  
 
 ;;; Declaring a face.
 ;;;###autoload
 (defun custom-declare-face (face spec doc &rest args)
   "Like `defface', but FACE is evaluated as a normal argument."
-  (when (or (fboundp 'load-gc)		;XEmacs.
-	    ;; Emacs.
-	    (and (boundp purify-flag) purify-flag))
+  (when (fboundp 'load-gc)
     ;; This should be allowed, somehow.
     (error "Attempt to declare a face during dump"))
   (unless (get face 'factory-face)
 If FRAME is nil, return the default frame properties."
   (cond (frame
 	 ;; Try to get from cache.
-	 (let ((cache (custom-frame-parameter frame 'custom-properties)))
+	 (let ((cache (frame-property frame 'custom-properties)))
 	   (unless cache
 	     ;; Oh well, get it then.
 	     (setq cache (custom-extract-frame-properties frame))

lisp/custom/custom.el

 ;;
 ;; Author: Per Abrahamsen <abraham@dina.kvl.dk>
 ;; Keywords: help, faces
-;; Version: 1.89
+;; Version: 1.84
 ;; X-URL: http://www.dina.kvl.dk/~abraham/custom/
 
 ;;; Commentary:
 
 (require 'widget)
 
-(define-widget-keywords :initialize :set :get :require :prefix :tag
-  :load :link :options :type :group) 
+(define-widget-keywords :prefix :tag :load :link :options :type :group)
 
 ;; These autoloads should be deleted eventually. 
 (unless (fboundp 'load-gc)
   ;; From cus-edit.el
   (autoload 'customize "cus-edit" nil t)
-  (autoload 'customize-other-window "cus-edit" nil t)
   (autoload 'customize-variable "cus-edit" nil t)
   (autoload 'customize-variable-other-window "cus-edit" nil t)
   (autoload 'customize-face "cus-edit" nil t)
 
 ;;; The `defcustom' Macro.
 
-(defun custom-initialize-default (symbol value)
-  "Initialize SYMBOL with VALUE.
-This will do nothing if symbol already has a default binding.
-Otherwise, if symbol has a `saved-value' property, it will evaluate
-the car of that and used as the default binding for symbol.
-Otherwise, VALUE will be evaluated and used as the default binding for
-symbol."
+(defun custom-declare-variable (symbol value doc &rest args)
+  "Like `defcustom', but SYMBOL and VALUE are evaluated as normal arguments."
+  ;; Bind this variable unless it already is bound.
   (unless (default-boundp symbol)
     ;; Use the saved value if it exists, otherwise the factory setting.
     (set-default symbol (if (get symbol 'saved-value)
 			    (eval (car (get symbol 'saved-value)))
-			  (eval value)))))
-
-(defun custom-initialize-set (symbol value)
-  "Initialize SYMBOL with VALUE.
-Like `custom-initialize-default', but use the function specified by
-`:set' to initialize SYMBOL."
-  (unless (default-boundp symbol)
-    (funcall (or (get symbol 'custom-set) 'set-default)
-	     symbol 
-	     (if (get symbol 'saved-value)
-		 (eval (car (get symbol 'saved-value)))
-	       (eval value)))))
-
-(defun custom-initialize-reset (symbol value)
-  "Initialize SYMBOL with VALUE.
-Like `custom-initialize-set', but use the function specified by
-`:get' to reinitialize SYMBOL if it is already bound."
-    (funcall (or (get symbol 'custom-set) 'set-default)
-	     symbol 
-	     (cond ((default-boundp symbol)
-		    (funcall (or (get symbol 'custom-get) 'default-value)
-			     symbol))
-		   ((get symbol 'saved-value)
-		    (eval (car (get symbol 'saved-value))))
-		   (t
-		    (eval value)))))
-
-(defun custom-initialize-changed (symbol value)
-  "Initialize SYMBOL with VALUE.
-Like `custom-initialize-reset', but only use the `:set' function if the 
-not using the factory setting.  Otherwise, use the `set-default'."
-  (cond ((default-boundp symbol)
-	 (funcall (or (get symbol 'custom-set) 'set-default)
-		  symbol
-		  (funcall (or (get symbol 'custom-get) 'default-value)
-			   symbol)))
-	((get symbol 'saved-value)
-	 (funcall (or (get symbol 'custom-set) 'set-default)
-		  symbol
-		  (eval (car (get symbol 'saved-value)))))
-	(t
-	 (set-default symbol (eval value)))))
-
-(defun custom-declare-variable (symbol value doc &rest args)
-  "Like `defcustom', but SYMBOL and VALUE are evaluated as normal arguments."
+			  (eval value))))
   ;; Remember the factory setting.
   (put symbol 'factory-value (list value))
   ;; Maybe this option was rogue in an earlier version.  It no longer is.
     (put symbol 'force-value nil))
   (when doc
     (put symbol 'variable-documentation doc))
-  (let ((initialize 'custom-initialize-set)
-	(requests nil))
-    (while args 
-      (let ((arg (car args)))
+  (while args 
+    (let ((arg (car args)))
+      (setq args (cdr args))
+      (unless (symbolp arg)
+	(error "Junk in args %S" args))
+      (let ((keyword arg)
+	    (value (car args)))
+	(unless args
+	  (error "Keyword %s is missing an argument" keyword))
 	(setq args (cdr args))
-	(unless (symbolp arg)
-	  (error "Junk in args %S" args))
-	(let ((keyword arg)
-	      (value (car args)))
-	  (unless args
-	    (error "Keyword %s is missing an argument" keyword))
-	  (setq args (cdr args))
-	  (cond ((eq keyword :initialize)
-		 (setq initialize value))
-		((eq keyword :set)
-		 (put symbol 'custom-set value))
-		((eq keyword :get)
-		 (put symbol 'custom-get value))
-		((eq keyword :require)
-		 (push value requests))
-		((eq keyword :type)
-		 (put symbol 'custom-type value))
-		((eq keyword :options)
-		 (if (get symbol 'custom-options)
-		     ;; Slow safe code to avoid duplicates.
-		     (mapcar (lambda (option)
-			       (custom-add-option symbol option))
-			     value)
-		   ;; Fast code for the common case.
-		   (put symbol 'custom-options (append value nil))))
-		(t
-		 (custom-handle-keyword symbol keyword value
-					'custom-variable))))))
-    (put symbol 'custom-requests requests)
-    ;; Do the actual initialization.
-    (funcall initialize symbol value))
+	(cond ((eq keyword :type)
+	       (put symbol 'custom-type value))
+	      ((eq keyword :options)
+	       (if (get symbol 'custom-options)
+		   ;; Slow safe code to avoid duplicates.
+		   (mapcar (lambda (option)
+			     (custom-add-option symbol option))
+			   value)
+		 ;; Fast code for the common case.
+		 (put symbol 'custom-options (copy-list value))))
+	      (t
+	       (custom-handle-keyword symbol keyword value
+				      'custom-variable))))))
   (run-hooks 'custom-define-hook)
   symbol)
 
 
 The following KEYWORD's are defined:
 
-:type	VALUE should be a widget type for editing the symbols value.
-	The default is `sexp'.
+:type	VALUE should be a widget type.
 :options VALUE should be a list of valid members of the widget type.
 :group  VALUE should be a customization group.  
         Add SYMBOL to that group.
-:initialize VALUE should be a function used to initialize the
-	variable.  It takes two arguments, the symbol and value
-	given in the `defcustom' call.  The default is
-	`custom-initialize-default' 
-:set	VALUE should be a function to set the value of the symbol. 
-	It takes two arguments, the symbol to set and the value to
-	give it.  The default is `set-default'.
-:get	VALUE should be a function to extract the value of symbol.
-	The function takes one argument, a symbol, and should return
-	the current value for that symbol.  The default is
-	`default-value'. 
-:require VALUE should be a feature symbol.  Each feature will be
-	required after initialization, of the the user have saved this
-	option.
 
-Read the section about customization in the Emacs Lisp manual for more
+Read the section about customization in the emacs lisp manual for more
 information."
   `(eval-and-compile
      (custom-declare-variable (quote ,symbol) (quote ,value) ,doc ,@args)))
 `background' (what color is used for the background text)
   Should be one of `light' or `dark'.
 
-Read the section about customization in the Emacs Lisp manual for more
+Read the section about customization in the emacs lisp manual for more
 information."
   `(custom-declare-face (quote ,face) ,spec ,doc ,@args))
 
 
 (defun custom-declare-group (symbol members doc &rest args)
   "Like `defgroup', but SYMBOL is evaluated as a normal argument."
-  (while members 
-    (apply 'custom-add-to-group symbol (car members))
-    (setq members (cdr members)))
   (put symbol 'custom-group (nconc members (get symbol 'custom-group)))
   (when doc
     (put symbol 'group-documentation doc))
 :group  VALUE should be a customization group.
         Add SYMBOL to that group.
 
-Read the section about customization in the Emacs Lisp manual for more
+Read the section about customization in the emacs lisp manual for more
 information."
   `(custom-declare-group (quote ,symbol) ,members ,doc ,@args))
 
   (while args 
     (let ((entry (car args)))
       (if (listp entry)
-	  (let* ((symbol (nth 0 entry))
-		 (value (nth 1 entry))
-		 (now (nth 2 entry))
-		 (requests (nth 3 entry))
-		 (set (or (get symbol 'custom-set) 'set-default)))
+	  (let ((symbol (nth 0 entry))
+		(value (nth 1 entry))
+		(now (nth 2 entry)))
 	    (put symbol 'saved-value (list value))
 	    (cond (now 
 		   ;; Rogue variable, set it now.
 		   (put symbol 'force-value t)
-		   (funcall set symbol (eval value)))
+		   (set-default symbol (eval value)))
 		  ((default-boundp symbol)
 		   ;; Something already set this, overwrite it.
-		   (funcall set symbol (eval value))))
-	    (when requests
-	      (put symbol 'custom-requests requests)
-	      (mapcar 'require requests))
+		   (set-default symbol (eval value))))
 	    (setq args (cdr args)))
 	;; Old format, a plist of SYMBOL VALUE pairs.
 	(message "Warning: old format `custom-set-variables'")

lisp/custom/wid-browse.el

 ;;
 ;; Author: Per Abrahamsen <abraham@dina.kvl.dk>
 ;; Keywords: extensions
-;; Version: 1.89
+;; Version: 1.84
 ;; X-URL: http://www.dina.kvl.dk/~abraham/custom/
 
 ;;; Commentary:
 (put :button 'widget-keyword-printer 'widget-browse-widget)
 (put :args 'widget-keyword-printer 'widget-browse-sexps)
 
-;;; Widget Minor Mode.
-
-(defvar widget-minor-mode nil
-  "I non-nil, we are in Widget Minor Mode.")
-  (make-variable-buffer-local 'widget-minor-mode)
-
-(defvar widget-minor-mode-map nil
-  "Keymap used in Widget Minor Mode.")
-
-(unless widget-minor-mode-map
-  (setq widget-minor-mode-map (make-sparse-keymap))
-  (set-keymap-parent widget-minor-mode-map widget-keymap))
-
-;;;###autoload
-(defun widget-minor-mode (&optional arg)
-  "Togle minor mode for traversing widgets.
-With arg, turn widget mode on if and only if arg is positive."
-  (interactive "P")
-  (cond ((null arg)
-	 (setq widget-minor-mode (not widget-minor-mode)))
-	((<= 0 arg)
-	 (setq widget-minor-mode nil))
-	(t
-	 (setq widget-minor-mode t)))
-  (force-mode-line-update))
-
-(add-to-list 'minor-mode-alist '(widget-minor-mode " Widget"))
-
-(add-to-list 'minor-mode-map-alist 
-	     (cons 'widget-minor-mode widget-minor-mode-map))
-
 ;;; The End:
 
 (provide 'wid-browse)

lisp/custom/wid-edit.el

 ;;
 ;; Author: Per Abrahamsen <abraham@dina.kvl.dk>
 ;; Keywords: extensions
-;; Version: 1.89
+;; Version: 1.84
 ;; X-URL: http://www.dina.kvl.dk/~abraham/custom/
 
 ;;; Commentary:
     ;; We have the old custom-library, hack around it!
     (defmacro defgroup (&rest args) nil)
     (defmacro defcustom (var value doc &rest args) 
-      (` (defvar (, var) (, value) (, doc))))
+      `(defvar ,var ,value ,doc))
     (defmacro defface (&rest args) nil)
     (define-widget-keywords :prefix :tag :load :link :options :type :group)
     (when (fboundp 'copy-face)
 
 (defface widget-field-face '((((class grayscale color)
 			       (background light))
-			      (:background "gray85"))
+			      (:background "light gray"))
 			     (((class grayscale color)
 			       (background dark))
 			      (:background "dark gray"))
   "Choose an item from a list.
 
 First argument TITLE is the name of the list.
-Second argument ITEMS is an list whose members are either
- (NAME . VALUE), to indicate selectable items, or just strings to
- indicate unselectable items.
+Second argument ITEMS is an alist (NAME . VALUE).
 Optional third argument EVENT is an input event.
 
 The user is asked to choose between each NAME from the items alist,
 			   (mapcar
 			    (function
 			     (lambda (x)
-			       (if (stringp x)
-				   (vector x nil nil) 
-				 (vector (car x) (list (car x)) t))))
+			       (vector (car x) (list (car x)) t)))
 			    items)))))
 	   (setq val (and val
 			  (listp (event-object val))
 			  (car (event-object val))))
 	   (cdr (assoc val items))))
 	(t
-	 (setq items (remove-if 'stringp items))
 	 (let ((val (completing-read (concat title ": ") items nil t)))
 	   (if (stringp val)
 	       (let ((try (try-completion val items)))
 
 (defmacro widget-specify-insert (&rest form)
   ;; Execute FORM without inheriting any text properties.
-  (`
-   (save-restriction
+  `(save-restriction
      (let ((inhibit-read-only t)
 	   result
 	   after-change-functions)
        (narrow-to-region (- (point) 2) (point))
        (widget-specify-none (point-min) (point-max))
        (goto-char (1+ (point-min)))
-       (setq result (progn (,@ form)))
+       (setq result (progn ,@form))
        (delete-region (point-min) (1+ (point-min)))
        (delete-region (1- (point-max)) (point-max))
        (goto-char (point-max))
-       result))))
+       result)))
 
 (defface widget-inactive-face '((((class grayscale color)
 				  (background dark))
   (unless (widget-get widget :inactive)
     (let ((overlay (make-overlay from to nil t nil)))
       (overlay-put overlay 'face 'widget-inactive-face)
-      (overlay-put overlay 'evaporate t)
-      (overlay-put overlay 'priority 100)
+      (overlay-put overlay 'evaporate 't)
       (overlay-put overlay (if (string-match "XEmacs" emacs-version)
 			       'read-only
 			     'modification-hooks) '(widget-overlay-inactive))
 		       (t
 			(error "No buttons or fields found"))))))
 	(setq button (widget-at (point)))
-	(if (or (and button (widget-get button :tab-order)
-		     (< (widget-get button :tab-order) 0))
-		(and button (not (widget-apply button :active))))
+	(if (and button (widget-get button :tab-order)
+		 (< (widget-get button :tab-order) 0))
 	    (setq arg (1+ arg))))))
   (while (< arg 0)
     (if (= (point-min) (point))
 	    (button (goto-char button))
 	    (field (goto-char field)))
       (setq button (widget-at (point)))
-      (if (or (and button (widget-get button :tab-order)
-		   (< (widget-get button :tab-order) 0))
-	      (and button (not (widget-apply button :active))))
+      (if (and button (widget-get button :tab-order)
+	       (< (widget-get button :tab-order) 0))
 	  (setq arg (1- arg)))))
   (widget-echo-help (point))
   (run-hooks 'widget-move-hook))
      (set-marker-insertion-type from t)
      (set-marker-insertion-type to nil)
      (widget-put widget :from from)
-     (widget-put widget :to to)))
-  (widget-clear-undo))
+     (widget-put widget :to to))))
 
 (defun widget-default-format-handler (widget escape)
   ;; We recognize the %h escape by default.
       ;; Kludge: this doesn't need to be true for empty formats.
       (delete-region from to))
     (set-marker from nil)
-    (set-marker to nil))
-  (widget-clear-undo))
+    (set-marker to nil)))
 
 (defun widget-default-value-set (widget value)
   ;; Recreate widget with new value.
 
 (defun widget-info-link-action (widget &optional event)
   "Open the info node specified by WIDGET."
-  (Info-goto-node (widget-value widget))
-  ;; Steal button release event.
-  (if (and (fboundp 'button-press-event-p)
-	   (fboundp 'next-command-event))
-      ;; XEmacs
-      (and event
-	   (button-press-event-p event)
-	   (next-command-event))
-    ;; Emacs
-    (when (memq 'down (event-modifiers event))
-      (read-event))))
+  (Info-goto-node (widget-value widget)))
 
 ;;; The `url-link' Widget.
 
       (widget-value-set widget 
 			(widget-apply current :value-to-external
 				      (widget-get current :value)))
-      (widget-apply widget :notify widget event)
-      (widget-setup))))
+    (widget-apply widget :notify widget event)
+    (widget-setup)))
+  ;; Notify parent.
+  (widget-apply widget :notify widget event)
+  (widget-clear-undo))
 
 (defun widget-choice-validate (widget)
   ;; Valid if we have made a valid choice.
   ;; Toggle value.
   (widget-value-set widget (not (widget-value widget)))
   (widget-apply widget :notify widget event))
-
+  
 ;;; The `checkbox' Widget.
 
 (define-widget 'checkbox 'toggle

lisp/custom/widget-example.el

 ;;
 ;; Author: Per Abrahamsen <abraham@dina.kvl.dk>
 ;; Keywords: help, extensions, faces, hypermedia
-;; Version: 1.89
+;; Version: 1.84
 ;; X-URL: http://www.dina.kvl.dk/~abraham/custom/
 
 (require 'widget)

lisp/custom/widget.el

 ;;
 ;; Author: Per Abrahamsen <abraham@dina.kvl.dk>
 ;; Keywords: help, extensions, faces, hypermedia
-;; Version: 1.89
+;; Version: 1.84
 ;; X-URL: http://www.dina.kvl.dk/~abraham/custom/
 
 ;;; Commentary:
   (autoload 'widget-insert "wid-edit")
   (autoload 'widget-browse "wid-browse" nil t)
   (autoload 'widget-browse-other-window "wid-browse" nil t)
-  (autoload 'widget-browse-at "wid-browse" nil t)
-  (autoload 'widget-minor-mode "wid-browse" nil t))
+  (autoload 'widget-browse-at "wid-browse" nil t))
 
 (defun define-widget (name class doc &rest args)
   "Define a new widget type named NAME from CLASS.

lisp/edebug/edebug.el

 ;; LCD Archive Entry:
 ;; edebug|Daniel LaLiberte|liberte@cs.uiuc.edu
 ;; |A source level debugger for Emacs Lisp.
-;; |$Date: 1997/04/13 03:13:54 $|$Revision: 1.4 $|~/modes/edebug.el|
+;; |$Date: 1997/04/24 03:59:43 $|$Revision: 1.5 $|~/modes/edebug.el|
 
 ;; This minor mode allows programmers to step through Emacs Lisp
 ;; source code while executing functions.  You can also set
 ;;; Code:
 
 (defconst edebug-version
-  (let ((raw-version "$Revision: 1.4 $"))
+  (let ((raw-version "$Revision: 1.5 $"))
     (substring raw-version (string-match "[0-9.]*" raw-version)
 	       (match-end 0))))
      
 
 ;;; Options
 
+(defgroup edebug nil
+  "A source-level debugger for Emacs Lisp"
+  :group 'lisp)
+
+
 (defvar edebug-setup-hook nil
   "*Functions to call before edebug is used.
 Each time it is set to a new value, Edebug will call those functions
 to load up Edebug specifications associated with a package you are
 using but only when you also use Edebug.")
 
-(defvar edebug-all-defs nil
+(defcustom edebug-all-defs nil
   "*If non-nil, evaluation of any defining forms will instrument for Edebug.
 This applies to `eval-defun', `eval-region', `eval-buffer', and
 `eval-current-buffer'.  `eval-region' is also called by
 You can use the command `edebug-all-defs' to toggle the value of this
 variable.  You may wish to make it local to each buffer with
 \(make-local-variable 'edebug-all-defs) in your
-`emacs-lisp-mode-hook'.")
-
-(defvar edebug-all-forms nil
+`emacs-lisp-mode-hook'."
+  :type 'boolean
+  :group 'edebug)
+
+(defcustom edebug-all-forms nil
   "*Non-nil evaluation of all forms will instrument for Edebug.
 This doesn't apply to loading or evaluations in the minibuffer.
-Use the command `edebug-all-forms' to toggle the value of this option.")
-
-(defvar edebug-eval-macro-args nil
+Use the command `edebug-all-forms' to toggle the value of this option."
+  :type 'boolean
+  :group 'edebug)
+
+(defcustom edebug-eval-macro-args nil
   "*Non-nil means all macro call arguments may be evaluated.  
 If this variable is nil, the default, Edebug will *not* wrap
 macro call arguments as if they will be evaluated.  
 So to specify exceptions for macros that have some arguments evaluated
 and some not, you should specify an `edebug-form-spec'.
 
-This option is going away soon.")
-
-(defvar edebug-stop-before-symbols nil
+This option is going away soon."
+  :type 'boolean
+  :group 'edebug)
+
+(defcustom edebug-stop-before-symbols nil
   "*Non-nil causes Edebug to stop before symbols as well as after.  
 In any case, a breakpoint or interrupt may stop before a symbol.
 
-This option is going away soon.")
-
-(defvar edebug-save-windows t
+This option is going away soon."
+  :type 'boolean
+  :group 'edebug)
+
+(defcustom edebug-save-windows t
   "*If non-nil, Edebug saves and restores the window configuration.
 That takes some time, so if your program does not care what happens to
 the window configurations, it is better to set this variable to nil.
 If the value is a list, only the listed windows are saved and
 restored.  
 
-`edebug-toggle-save-windows' may be used to change this variable.")
-
-(defvar edebug-save-displayed-buffer-points nil
+`edebug-toggle-save-windows' may be used to change this variable."
+  :type '(choice boolean (repeat string))
+  :group 'edebug)
+
+(defcustom edebug-save-displayed-buffer-points nil
   "*If non-nil, save and restore point in all displayed buffers.
 
 Saving and restoring point in other buffers is necessary if you are
 
 Saving and restoring point in all buffers is expensive, since it
 requires selecting each window twice, so enable this only if you need
-it.")
-
-(defvar edebug-initial-mode 'step
+it."
+  :type 'boolean
+  :group 'edebug)
+