Initial revision

[gnu-emacs] / lisp / cus-edit.el

diff --git a/lisp/cus-edit.el b/lisp/cus-edit.el
index de806bdea8c6ddd752f3bf48ecebe4169ecb7a67..4d4fc083553f137261f3128a9e7215444b33b440 100644 (file)
--- a/lisp/cus-edit.el
+++ b/lisp/cus-edit.el
@@ -1,10 +1,10 @@
-;;; cus-edit.el --- Tools for customization Emacs.
+;;; cus-edit.el --- Tools for customizating Emacs and Lisp packages.

 ;;
 ;; Copyright (C) 1996, 1997 Free Software Foundation, Inc.
 ;;
 ;; Author: Per Abrahamsen <abraham@dina.kvl.dk>
 ;; Keywords: help, faces
 ;;
 ;; Copyright (C) 1996, 1997 Free Software Foundation, Inc.
 ;;
 ;; Author: Per Abrahamsen <abraham@dina.kvl.dk>
 ;; Keywords: help, faces

-;; Version: 1.9904
+;; Version: 1.9954

 ;; X-URL: http://www.dina.kvl.dk/~abraham/custom/
 
 ;; This file is part of GNU Emacs.
 ;; X-URL: http://www.dina.kvl.dk/~abraham/custom/
 
 ;; This file is part of GNU Emacs.


@@ -30,6 +30,10 @@
 ;; 
 ;; See `custom.el'.
 
 ;; 
 ;; See `custom.el'.
 

+;; No commands should have names starting with `custom-' because
+;; that interferes with completion.  Use `customize-' for commands
+;; that the user will run with M-x, and `Custom-' for interactive commands.
+

 ;;; Code:
 
 (require 'cus-face)
 ;;; Code:
 
 (require 'cus-face)


@@ -45,7 +49,8 @@
     (require 'cus-start)
   (error nil))
 
     (require 'cus-start)
   (error nil))
 

-(define-widget-keywords :custom-category :custom-prefixes :custom-menu
+(define-widget-keywords :custom-last :custom-prefix :custom-category
+  :custom-prefixes :custom-menu  

   :custom-show  
   :custom-magic :custom-state :custom-level :custom-form
   :custom-set :custom-save :custom-reset-current :custom-reset-saved 
   :custom-show  
   :custom-magic :custom-state :custom-level :custom-form
   :custom-set :custom-save :custom-reset-current :custom-reset-saved 


@@ -101,6 +106,10 @@
   :group 'external
   :group 'development)
 
   :group 'external
   :group 'development)
 

+(defgroup convenience nil
+  "Convenience features for faster editing."
+  :group 'emacs)
+

 (defgroup programming nil
   "Support for programming in other languages."
   :group 'emacs)
 (defgroup programming nil
   "Support for programming in other languages."
   :group 'emacs)


@@ -209,6 +218,10 @@
   "Support editing files of data."
   :group 'emacs)
 
   "Support editing files of data."
   :group 'emacs)
 

+(defgroup files nil
+  "Support editing files."
+  :group 'emacs)
+

 (defgroup wp nil
   "Word processing."
   :group 'emacs)
 (defgroup wp nil
   "Word processing."
   :group 'emacs)


@@ -246,6 +259,21 @@
   :group 'customize
   :group 'faces)
 
   :group 'customize
   :group 'faces)
 

+(defgroup custom-browse nil
+  "Control customize browser."
+  :prefix "custom-"
+  :group 'customize)
+
+(defgroup custom-buffer nil
+  "Control customize buffers."
+  :prefix "custom-"
+  :group 'customize)
+
+(defgroup custom-menu nil
+  "Control customize menus."
+  :prefix "custom-"
+  :group 'customize)
+

 (defgroup abbrev-mode nil
   "Word abbreviations mode."
   :group 'abbrev)
 (defgroup abbrev-mode nil
   "Word abbreviations mode."
   :group 'abbrev)


@@ -313,7 +341,7 @@
 
 (defgroup auto-save nil
   "Preventing accidential loss of data."
 
 (defgroup auto-save nil
   "Preventing accidential loss of data."

-  :group 'data)
+  :group 'files)

 
 (defgroup processes-basics nil
   "Basic stuff dealing with processes."
 
 (defgroup processes-basics nil
   "Basic stuff dealing with processes."


@@ -329,6 +357,18 @@
 
 ;;; Utilities.
 
 
 ;;; Utilities.
 

+(defun custom-last (x &optional n)
+  ;; Stolen from `cl.el'.
+  "Returns the last link in the list LIST.
+With optional argument N, returns Nth-to-last link (default 1)."
+  (if n
+      (let ((m 0) (p x))
+       (while (consp p) (incf m) (pop p))
+       (if (<= n 0) p
+         (if (< n m) (nthcdr (- m n) x) x)))
+    (while (consp (cdr x)) (pop x))
+    x))
+

 (defun custom-quote (sexp)
   "Quote SEXP iff it is not self quoting."
   (if (or (memq sexp '(t nil))
 (defun custom-quote (sexp)
   "Quote SEXP iff it is not self quoting."
   (if (or (memq sexp '(t nil))


@@ -367,12 +407,12 @@ Return a list suitable for use in `interactive'."
         val)
      (setq val (completing-read 
                (if (symbolp v)
         val)
      (setq val (completing-read 
                (if (symbolp v)

-                   (format "Customize variable: (default %s) " v)
+                   (format "Customize option: (default %s) " v)

                  "Customize variable: ")
                obarray (lambda (symbol)
                          (and (boundp symbol)
                               (or (get symbol 'custom-type)
                  "Customize variable: ")
                obarray (lambda (symbol)
                          (and (boundp symbol)
                               (or (get symbol 'custom-type)

-                                  (user-variable-p symbol))))))
+                                  (user-variable-p symbol)))) t))

      (list (if (equal val "")
               (if (symbolp v) v nil)
             (intern val)))))
      (list (if (equal val "")
               (if (symbolp v) v nil)
             (intern val)))))


@@ -401,7 +441,12 @@ WIDGET is the widget to apply the filter entries of MENU on."
 
 (defcustom custom-unlispify-menu-entries t
   "Display menu entries as words instead of symbols if non nil."
 
 (defcustom custom-unlispify-menu-entries t
   "Display menu entries as words instead of symbols if non nil."

-  :group 'customize
+  :group 'custom-menu
+  :type 'boolean)
+
+(defcustom custom-unlispify-remove-prefixes nil
+  "Non-nil means remove group prefixes from option names in buffer."
+  :group 'custom-menu

   :type 'boolean)
 
 (defun custom-unlispify-menu-entry (symbol &optional no-suffix)
   :type 'boolean)
 
 (defun custom-unlispify-menu-entry (symbol &optional no-suffix)


@@ -422,15 +467,16 @@ WIDGET is the widget to apply the filter entries of MENU on."
                      (re-search-forward "-p\\'" nil t))
             (replace-match "" t t)
             (goto-char (point-min)))
                      (re-search-forward "-p\\'" nil t))
             (replace-match "" t t)
             (goto-char (point-min)))

-          (let ((prefixes custom-prefix-list)
-                prefix)
-            (while prefixes
-              (setq prefix (car prefixes))
-              (if (search-forward prefix (+ (point) (length prefix)) t)
-                  (progn 
-                    (setq prefixes nil)
-                    (delete-region (point-min) (point)))
-                (setq prefixes (cdr prefixes)))))
+          (if custom-unlispify-remove-prefixes
+              (let ((prefixes custom-prefix-list)
+                    prefix)
+                (while prefixes
+                  (setq prefix (car prefixes))
+                  (if (search-forward prefix (+ (point) (length prefix)) t)
+                      (progn 
+                        (setq prefixes nil)
+                        (delete-region (point-min) (point)))
+                    (setq prefixes (cdr prefixes))))))

           (subst-char-in-region (point-min) (point-max) ?- ?\  t)
           (capitalize-region (point-min) (point-max))
           (unless no-suffix 
           (subst-char-in-region (point-min) (point-max) ?- ?\  t)
           (capitalize-region (point-min) (point-max))
           (unless no-suffix 


@@ -440,7 +486,7 @@ WIDGET is the widget to apply the filter entries of MENU on."
 
 (defcustom custom-unlispify-tag-names t
   "Display tag names as words instead of symbols if non nil."
 
 (defcustom custom-unlispify-tag-names t
   "Display tag names as words instead of symbols if non nil."

-  :group 'customize
+  :group 'custom-buffer

   :type 'boolean)
 
 (defun custom-unlispify-tag-name (symbol)
   :type 'boolean)
 
 (defun custom-unlispify-tag-name (symbol)


@@ -518,56 +564,88 @@ if that fails, the doc string with `custom-guess-doc-alist'."
 
 ;;; Sorting.
 
 
 ;;; Sorting.
 

-(defcustom custom-buffer-sort-predicate 'custom-buffer-sort-alphabetically
-  "Function used for sorting group members in buffers.
-The value should be useful as a predicate for `sort'.  
-The list to be sorted is the value of the groups `custom-group' property."
-  :type '(radio (function-item custom-buffer-sort-alphabetically)
-               (function :tag "Other"))
-  :group 'customize)
-
-(defun custom-buffer-sort-alphabetically (a b)
-  "Return t iff is A should be before B.
-A and B should be members of a `custom-group' property. 
-The members are sorted alphabetically, except that all groups are
-sorted after all non-groups."
-  (cond ((and (eq (nth 1 a) 'custom-group) 
-             (not (eq (nth 1 b) 'custom-group)))
-        nil)
-       ((and (eq (nth 1 b) 'custom-group) 
-             (not (eq (nth 1 a) 'custom-group)))
-        t)
-       (t
-        (string-lessp (symbol-name (nth 0 a)) (symbol-name (nth 0 b))))))
-
-(defcustom custom-menu-sort-predicate 'custom-menu-sort-alphabetically
-  "Function used for sorting group members in menus.
-The value should be useful as a predicate for `sort'.  
-The list to be sorted is the value of the groups `custom-group' property."
-  :type '(radio (function-item custom-menu-sort-alphabetically)
-               (function :tag "Other"))
-  :group 'customize)
+(defcustom custom-browse-sort-alphabetically nil
+  "If non-nil, sort members of each customization group alphabetically."
+  :type 'boolean
+  :group 'custom-browse)
+
+(defcustom custom-browse-order-groups nil
+  "If non-nil, order group members within each customization group.
+If `first', order groups before non-groups.
+If `last', order groups after non-groups."
+  :type '(choice (const first)
+                (const last)
+                (const :tag "none" nil))
+  :group 'custom-browse)
+
+(defcustom custom-browse-only-groups nil
+  "If non-nil, show group members only within each customization group."
+  :type 'boolean
+  :group 'custom-browse)

 
 

-(defun custom-menu-sort-alphabetically (a b)
-  "Return t iff is A should be before B.
-A and B should be members of a `custom-group' property. 
-The members are sorted alphabetically, except that all groups are
-sorted before all non-groups."
-  (cond ((and (eq (nth 1 a) 'custom-group) 
-             (not (eq (nth 1 b) 'custom-group)))
-        t)
-       ((and (eq (nth 1 b) 'custom-group) 
-             (not (eq (nth 1 a) 'custom-group)))
-        nil)
-       (t
-        (string-lessp (symbol-name (nth 0 a)) (symbol-name (nth 0 b))))))
+(defcustom custom-buffer-sort-alphabetically nil
+  "If non-nil, sort members of each customization group alphabetically."
+  :type 'boolean
+  :group 'custom-buffer)
+
+(defcustom custom-buffer-order-groups 'last
+  "If non-nil, order group members within each customization group.
+If `first', order groups before non-groups.
+If `last', order groups after non-groups."
+  :type '(choice (const first)
+                (const last)
+                (const :tag "none" nil))
+  :group 'custom-buffer)
+
+(defcustom custom-menu-sort-alphabetically nil
+  "If non-nil, sort members of each customization group alphabetically."
+  :type 'boolean
+  :group 'custom-menu)
+
+(defcustom custom-menu-order-groups 'first
+  "If non-nil, order group members within each customization group.
+If `first', order groups before non-groups.
+If `last', order groups after non-groups."
+  :type '(choice (const first)
+                (const last)
+                (const :tag "none" nil))
+  :group 'custom-menu)
+
+;;;###autoload (add-hook 'same-window-regexps "\\`\\*Customiz.*\\*\\'")
+
+(defun custom-sort-items (items sort-alphabetically order-groups)
+  "Return a sorted copy of ITEMS.
+ITEMS should be a `custom-group' property.
+If SORT-ALPHABETICALLY non-nil, sort alphabetically.
+If ORDER-GROUPS is `first' order groups before non-groups, if `last' order
+groups after non-groups, if nil do not order groups at all."
+  (sort (copy-sequence items)
+   (lambda (a b)
+     (let ((typea (nth 1 a)) (typeb (nth 1 b))
+          (namea (symbol-name (nth 0 a))) (nameb (symbol-name (nth 0 b))))
+       (cond ((not order-groups)
+             ;; Since we don't care about A and B order, maybe sort.
+             (when sort-alphabetically
+               (string-lessp namea nameb)))
+            ((eq typea 'custom-group)
+             ;; If B is also a group, maybe sort.  Otherwise, order A and B.
+             (if (eq typeb 'custom-group)
+                 (when sort-alphabetically
+                   (string-lessp namea nameb))
+               (eq order-groups 'first)))
+            ((eq typeb 'custom-group)
+             ;; Since A cannot be a group, order A and B.
+             (eq order-groups 'last))
+            (sort-alphabetically
+             ;; Since A and B cannot be groups, sort.
+             (string-lessp namea nameb)))))))

 
 ;;; Custom Mode Commands.
 
 (defvar custom-options nil
   "Customization widgets in the current buffer.")
 
 
 ;;; Custom Mode Commands.
 
 (defvar custom-options nil
   "Customization widgets in the current buffer.")
 

-(defun custom-set ()
+(defun Custom-set ()

   "Set changes in all modified options."
   (interactive)
   (let ((children custom-options))
   "Set changes in all modified options."
   (interactive)
   (let ((children custom-options))


@@ -576,7 +654,7 @@ sorted before all non-groups."
                (widget-apply child :custom-set)))
            children)))
 
                (widget-apply child :custom-set)))
            children)))
 

-(defun custom-save ()
+(defun Custom-save ()

   "Set all modified group members and save them."
   (interactive)
   (let ((children custom-options))
   "Set all modified group members and save them."
   (interactive)
   (let ((children custom-options))


@@ -587,9 +665,9 @@ sorted before all non-groups."
   (custom-save-all))
 
 (defvar custom-reset-menu 
   (custom-save-all))
 
 (defvar custom-reset-menu 

-  '(("Current" . custom-reset-current)
-    ("Saved" . custom-reset-saved)
-    ("Standard Settings" . custom-reset-standard))
+  '(("Current" . Custom-reset-current)
+    ("Saved" . Custom-reset-saved)
+    ("Standard Settings" . Custom-reset-standard))

   "Alist of actions for the `Reset' button.
 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
   "Alist of actions for the `Reset' button.
 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


@@ -604,7 +682,7 @@ when the action is chosen.")
     (if answer
        (funcall answer))))
 
     (if answer
        (funcall answer))))
 

-(defun custom-reset-current (&rest ignore)
+(defun Custom-reset-current (&rest ignore)

   "Reset all modified group members to their current value."
   (interactive)
   (let ((children custom-options))
   "Reset all modified group members to their current value."
   (interactive)
   (let ((children custom-options))


@@ -613,22 +691,22 @@ when the action is chosen.")
                (widget-apply child :custom-reset-current)))
            children)))
 
                (widget-apply child :custom-reset-current)))
            children)))
 

-(defun custom-reset-saved (&rest ignore)
+(defun Custom-reset-saved (&rest ignore)

   "Reset all modified or set group members to their saved value."
   (interactive)
   (let ((children custom-options))
     (mapcar (lambda (child)
              (when (eq (widget-get child :custom-state) 'modified)
   "Reset all modified or set group members to their saved value."
   (interactive)
   (let ((children custom-options))
     (mapcar (lambda (child)
              (when (eq (widget-get child :custom-state) 'modified)

-               (widget-apply child :custom-reset-current)))
+               (widget-apply child :custom-reset-saved)))

            children)))
 
            children)))
 

-(defun custom-reset-standard (&rest ignore)
+(defun Custom-reset-standard (&rest ignore)

   "Reset all modified, set, or saved group members to their standard settings."
   (interactive)
   (let ((children custom-options))
     (mapcar (lambda (child)
              (when (eq (widget-get child :custom-state) 'modified)
   "Reset all modified, set, or saved group members to their standard settings."
   (interactive)
   (let ((children custom-options))
     (mapcar (lambda (child)
              (when (eq (widget-get child :custom-state) 'modified)

-               (widget-apply child :custom-reset-current)))
+               (widget-apply child :custom-reset-standard)))

            children)))
 
 ;;; The Customize Commands
            children)))
 
 ;;; The Customize Commands


@@ -668,7 +746,7 @@ If the variable has a `custom-type' property, it must be a widget and the
                   (eval-minibuffer prompt)))))))
 
 ;;;###autoload
                   (eval-minibuffer prompt)))))))
 
 ;;;###autoload

-(defun custom-set-value (var val)
+(defun customize-set-value (var val)

   "Set VARIABLE to VALUE.  VALUE is a Lisp object.
 
 If VARIABLE has a `variable-interactive' property, that is used as if
   "Set VARIABLE to VALUE.  VALUE is a Lisp object.
 
 If VARIABLE has a `variable-interactive' property, that is used as if


@@ -682,7 +760,7 @@ If VARIABLE has a `custom-type' property, it must be a widget and the
   (set var val))
 
 ;;;###autoload
   (set var val))
 
 ;;;###autoload

-(defun custom-set-variable (var val)
+(defun customize-set-variable (var val)

   "Set the default for VARIABLE to VALUE.  VALUE is a Lisp object.
 
 If VARIABLE has a `custom-set' property, that is used for setting
   "Set the default for VARIABLE to VALUE.  VALUE is a Lisp object.
 
 If VARIABLE has a `custom-set' property, that is used for setting


@@ -701,6 +779,26 @@ If VARIABLE has a `custom-type' property, it must be a widget and the
   (funcall (or (get var 'custom-set) 'set-default) var val)
   (put var 'customized-value (list (custom-quote val))))
 
   (funcall (or (get var 'custom-set) 'set-default) var val)
   (put var 'customized-value (list (custom-quote val))))
 

+;;;###autoload
+(defun customize-save-variable (var val)
+  "Set the default for VARIABLE to VALUE, and save it for future sessions.
+If VARIABLE has a `custom-set' property, that is used for setting
+VARIABLE, otherwise `set-default' is used.
+
+The `customized-value' property of the VARIABLE will be set to a list
+with a quoted VALUE as its sole list member.
+
+If VARIABLE has a `variable-interactive' property, that is used as if
+it were the arg to `interactive' (which see) to interactively read the value.
+
+If VARIABLE has a `custom-type' property, it must be a widget and the
+`:prompt-value' property of that widget will be used for reading the value. " 
+  (interactive (custom-prompt-variable "Set and ave variable: "
+                                      "Set and save value for %s as: "))
+  (funcall (or (get var 'custom-set) 'set-default) var val)
+  (put var 'saved-value (list (custom-quote val)))
+  (custom-save-all))
+

 ;;;###autoload
 (defun customize ()
   "Select a customization buffer which you can use to set user options.
 ;;;###autoload
 (defun customize ()
   "Select a customization buffer which you can use to set user options.


@@ -713,36 +811,55 @@ are shown; the contents of those subgroups are initially hidden."
 ;;;###autoload
 (defun customize-group (group)
   "Customize GROUP, which must be a customization group."
 ;;;###autoload
 (defun customize-group (group)
   "Customize GROUP, which must be a customization group."

-  (interactive (list (completing-read "Customize group: (default emacs) "
-                                     obarray 
-                                     (lambda (symbol)
-                                       (get symbol 'custom-group))
-                                     t)))
-
+  (interactive (list (let ((completion-ignore-case t))
+                      (completing-read "Customize group: (default emacs) "
+                                       obarray 
+                                       (lambda (symbol)
+                                         (or (get symbol 'custom-loads)
+                                             (get symbol 'custom-group)))
+                                       t))))

   (when (stringp group)
     (if (string-equal "" group)
        (setq group 'emacs)
       (setq group (intern group))))
   (when (stringp group)
     (if (string-equal "" group)
        (setq group 'emacs)
       (setq group (intern group))))

-  (custom-buffer-create (list (list group 'custom-group))
-                       (format "*Customize Group: %s*"
-                               (custom-unlispify-tag-name group))))
+  (or (get group 'custom-group)
+      (custom-load-symbol group))
+  (let ((name (format "*Customize Group: %s*"
+                     (custom-unlispify-tag-name group))))
+    (if (get-buffer name)
+       (pop-to-buffer name)
+      (custom-buffer-create (list (list group 'custom-group))
+                           name
+                           (concat " for group "
+                                   (custom-unlispify-tag-name group))))))

 
 ;;;###autoload
 
 ;;;###autoload

-(defun customize-group-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))
-   (format "*Customize Group: %s*" (custom-unlispify-tag-name symbol))))
+(defun customize-group-other-window (group)
+  "Customize GROUP, which must be a customization group."
+  (interactive (list (let ((completion-ignore-case t))
+                      (completing-read "Customize group: (default emacs) "
+                                       obarray 
+                                       (lambda (symbol)
+                                         (or (get symbol 'custom-loads)
+                                             (get symbol 'custom-group)))
+                                       t))))
+  (when (stringp group)
+    (if (string-equal "" group)
+       (setq group 'emacs)
+      (setq group (intern group))))
+  (or (get group 'custom-group)
+      (custom-load-symbol group))
+  (let ((name (format "*Customize Group: %s*"
+                     (custom-unlispify-tag-name group))))
+    (if (get-buffer name)
+       (let ((window (selected-window)))
+         (pop-to-buffer name)
+         (select-window window))
+      (custom-buffer-create-other-window
+       (list (list group 'custom-group))
+       name
+       (concat " for group "
+              (custom-unlispify-tag-name group))))))

 
 ;;;###autoload
 (defalias 'customize-variable 'customize-option)
 
 ;;;###autoload
 (defalias 'customize-variable 'customize-option)


@@ -755,6 +872,91 @@ are shown; the contents of those subgroups are initially hidden."
                        (format "*Customize Option: %s*"
                                (custom-unlispify-tag-name symbol))))
 
                        (format "*Customize Option: %s*"
                                (custom-unlispify-tag-name symbol))))
 

+(defvar customize-changed-options-previous-release "20.2"
+  "Version for `customize-changed-options' to refer back to by default.")
+
+;;;###autoload
+(defun customize-changed-options (since-version)
+  "Customize all user option variables changed in Emacs itself.
+This includes new user option variables and faces, and new
+customization groups, as well as older options and faces whose default
+values have changed since the previous major Emacs release.
+
+With argument SINCE-VERSION (a string), customize all user option
+variables that were added (or their meanings were changed) since that
+version."
+
+  (interactive "sCustomize options changed, since version (default all versions): ")
+  (if (equal since-version "")
+      (setq since-version nil))
+  (unless since-version
+    (setq since-version customize-changed-options-previous-release))
+  (let ((found nil)
+       (versions nil))
+    (mapatoms (lambda (symbol)
+               (and (or (boundp symbol)
+                        ;; For variables not yet loaded.
+                        (get symbol 'standard-value)
+                        ;; For groups the previous test fails, this one
+                        ;; could be used to determine if symbol is a
+                        ;; group. Is there a better way for this?
+                        (get symbol 'group-documentation))
+                    (let ((version (get symbol 'custom-version)))
+                      (and version
+                           (or (null since-version)
+                               (customize-version-lessp since-version version))
+                           (if (member version versions) 
+                               t
+                             ;;; Collect all versions that we use.
+                             (push version versions))))
+                    (setq found
+                          ;; We have to set the right thing here,
+                          ;; depending if we have a group or a
+                          ;; variable. 
+                          (if (get  symbol 'group-documentation)
+                              (cons (list symbol 'custom-group) found)
+                            (cons (list symbol 'custom-variable) found))))))
+    (if (not found)
+       (error "No user option defaults have been changed since Emacs %s"
+              since-version)
+      (let ((flist nil))
+       (while versions
+         (push (copy-sequence 
+                (cdr (assoc (car versions)  custom-versions-load-alist)))
+               flist)
+         (setq versions (cdr versions)))
+       (put 'custom-versions-load-alist 'custom-loads 
+            ;; Get all the files that correspond to element from the
+            ;; VERSIONS list. This could use some simplification.
+            (apply 'nconc flist)))
+      ;; Because we set all the files needed to be loaded as a
+      ;; `custom-loads' property to `custom-versions-load-alist' this
+      ;; call will actually load them.
+      (custom-load-symbol 'custom-versions-load-alist)
+      ;; Clean up
+      (put 'custom-versions-load-alist 'custom-loads nil)
+      (custom-buffer-create (custom-sort-items found t 'first)
+                           "*Customize Changed Options*"))))
+
+(defun customize-version-lessp (version1 version2)
+  ;; In case someone made a mistake and left out the quotes
+  ;; in the :version value.
+  (if (numberp version2)
+      (setq version2 (prin1-to-string version2)))
+  (let (major1 major2 minor1 minor2)
+    (string-match "\\([0-9]+\\)[.]\\([0-9]+\\)" version1)
+    (setq major1 (read (match-string 1 version1)))
+    (setq minor1 (read (match-string 2 version1)))
+    (string-match "\\([0-9]+\\)[.]\\([0-9]+\\)" version2)
+    (setq major2 (read (match-string 1 version2)))
+    (setq minor2 (read (match-string 2 version2)))
+    (or (< major1 major2)
+       (and (= major1 major2)
+            (< minor1 minor2)))))
+  
+;;;###autoload
+(defalias 'customize-variable-other-window 'customize-option-other-window)
+

 ;;;###autoload
 (defun customize-option-other-window (symbol)
   "Customize SYMBOL, which must be a user option variable.
 ;;;###autoload
 (defun customize-option-other-window (symbol)
   "Customize SYMBOL, which must be a user option variable.


@@ -771,17 +973,14 @@ If SYMBOL is nil, customize all faces."
   (interactive (list (completing-read "Customize face: (default all) " 
                                      obarray 'custom-facep)))
   (if (or (null symbol) (and (stringp symbol) (zerop (length symbol))))
   (interactive (list (completing-read "Customize face: (default all) " 
                                      obarray 'custom-facep)))
   (if (or (null symbol) (and (stringp symbol) (zerop (length symbol))))

-      (let ((found nil))
-       (message "Looking for faces...")
-       (mapcar (lambda (symbol)
-                 (setq found (cons (list symbol 'custom-face) found)))
-               (nreverse (mapcar 'intern 
-                                 (sort (mapcar 'symbol-name (face-list))
-                                       'string<))))
-                       
-       (custom-buffer-create found "*Customize Faces*"))
-    (if (stringp symbol)
-       (setq symbol (intern symbol)))
+      (custom-buffer-create (custom-sort-items
+                            (mapcar (lambda (symbol)
+                                      (list symbol 'custom-face))
+                                    (face-list))
+                            t nil)
+                           "*Customize Faces*")
+    (when (stringp symbol)
+      (setq symbol (intern symbol)))

     (unless (symbolp symbol)
       (error "Should be a symbol %S" symbol))
     (custom-buffer-create (list (list symbol 'custom-face))
     (unless (symbolp symbol)
       (error "Should be a symbol %S" symbol))
     (custom-buffer-create (list (list symbol 'custom-face))


@@ -811,14 +1010,14 @@ If SYMBOL is nil, customize all faces."
     (mapatoms (lambda (symbol)
                (and (get symbol 'customized-face)
                     (custom-facep symbol)
     (mapatoms (lambda (symbol)
                (and (get symbol 'customized-face)
                     (custom-facep symbol)

-                    (setq found (cons (list symbol 'custom-face) found)))
+                    (push (list symbol 'custom-face) found))

                (and (get symbol 'customized-value)
                     (boundp symbol)
                (and (get symbol 'customized-value)
                     (boundp symbol)

-                    (setq found
-                          (cons (list symbol 'custom-variable) found)))))
-    (if found 
-       (custom-buffer-create found "*Customize Customized*")
-      (error "No customized user options"))))
+                    (push (list symbol 'custom-variable) found))))
+    (if (not found)
+       (error "No customized user options")
+      (custom-buffer-create (custom-sort-items found t nil)
+                           "*Customize Customized*"))))

 
 ;;;###autoload
 (defun customize-saved ()
 
 ;;;###autoload
 (defun customize-saved ()


@@ -828,44 +1027,85 @@ If SYMBOL is nil, customize all faces."
     (mapatoms (lambda (symbol)
                (and (get symbol 'saved-face)
                     (custom-facep symbol)
     (mapatoms (lambda (symbol)
                (and (get symbol 'saved-face)
                     (custom-facep symbol)

-                    (setq found (cons (list symbol 'custom-face) found)))
+                    (push (list symbol 'custom-face) found))

                (and (get symbol 'saved-value)
                     (boundp symbol)
                (and (get symbol 'saved-value)
                     (boundp symbol)

-                    (setq found
-                          (cons (list symbol 'custom-variable) found)))))
-    (if found 
-       (custom-buffer-create found "*Customize Saved*")
-      (error "No saved user options"))))
+                    (push (list symbol 'custom-variable) found))))
+    (if (not found )
+       (error "No saved user options")
+      (custom-buffer-create (custom-sort-items found t nil)
+                           "*Customize Saved*"))))

 
 ;;;###autoload
 (defun customize-apropos (regexp &optional all)
   "Customize all user options matching REGEXP.
 
 ;;;###autoload
 (defun customize-apropos (regexp &optional all)
   "Customize all user options matching REGEXP.

-If ALL (e.g., started with a prefix key), include options which are not
-user-settable."
+If ALL is `options', include only options.
+If ALL is `faces', include only faces.
+If ALL is `groups', include only groups.
+If ALL is t (interactively, with prefix arg), include options which are not
+user-settable, as well as faces and groups."

   (interactive "sCustomize regexp: \nP")
   (let ((found nil))
     (mapatoms (lambda (symbol)
                (when (string-match regexp (symbol-name symbol))
   (interactive "sCustomize regexp: \nP")
   (let ((found nil))
     (mapatoms (lambda (symbol)
                (when (string-match regexp (symbol-name symbol))

-                 (when (get symbol 'custom-group)
-                   (setq found (cons (list symbol 'custom-group) found)))
-                 (when (custom-facep symbol)
-                   (setq found (cons (list symbol 'custom-face) found)))
-                 (when (and (boundp symbol)
+                 (when (and (not (memq all '(faces options)))
+                            (get symbol 'custom-group))
+                   (push (list symbol 'custom-group) found))
+                 (when (and (not (memq all '(options groups)))
+                            (custom-facep symbol))
+                   (push (list symbol 'custom-face) found))
+                 (when (and (not (memq all '(groups faces)))
+                            (boundp symbol)

                             (or (get symbol 'saved-value)
                                 (get symbol 'standard-value)
                             (or (get symbol 'saved-value)
                                 (get symbol 'standard-value)

-                                (if all
-                                    (get symbol 'variable-documentation)
-                                  (user-variable-p symbol))))
-                   (setq found
-                         (cons (list symbol 'custom-variable) found))))))
-    (if found 
-       (custom-buffer-create found "*Customize Apropos*")
-      (error "No matches"))))
+                                (if (memq all '(nil options))
+                                    (user-variable-p symbol)
+                                  (get symbol 'variable-documentation))))
+                   (push (list symbol 'custom-variable) found)))))
+    (if (not found)
+       (error "No matches")
+      (custom-buffer-create (custom-sort-items found t
+                                              custom-buffer-order-groups)
+                           "*Customize Apropos*"))))
+
+;;;###autoload
+(defun customize-apropos-options (regexp &optional arg)
+  "Customize all user options matching REGEXP.
+With prefix arg, include options which are not user-settable."
+  (interactive "sCustomize regexp: \nP")
+  (customize-apropos regexp (or arg 'options)))
+
+;;;###autoload
+(defun customize-apropos-faces (regexp)
+  "Customize all user faces matching REGEXP."
+  (interactive "sCustomize regexp: \n")
+  (customize-apropos regexp 'faces))
+
+;;;###autoload
+(defun customize-apropos-groups (regexp)
+  "Customize all user groups matching REGEXP."
+  (interactive "sCustomize regexp: \n")
+  (customize-apropos regexp 'groups))

 
 ;;; Buffer.
 
 
 ;;; Buffer.
 

+(defcustom custom-buffer-style 'links
+  "Control the presentation style for customization buffers.
+The value should be a symbol, one of:
+
+brackets: groups nest within each other with big horizontal brackets.
+links: groups have links to subgroups."
+  :type '(radio (const brackets)
+               (const links))
+  :group 'custom-buffer)
+
+(defcustom custom-buffer-indent 3
+  "Number of spaces to indent nested groups."
+  :type 'integer
+  :group 'custom-buffer)
+

 ;;;###autoload
 ;;;###autoload

-(defun custom-buffer-create (options &optional name)
+(defun custom-buffer-create (options &optional name description)

   "Create a buffer containing OPTIONS.
 Optional NAME is the name of the buffer.
 OPTIONS should be an alist of the form ((SYMBOL WIDGET)...), where
   "Create a buffer containing OPTIONS.
 Optional NAME is the name of the buffer.
 OPTIONS should be an alist of the form ((SYMBOL WIDGET)...), where


@@ -873,11 +1113,11 @@ SYMBOL is a customization option, and WIDGET is a widget for editing
 that option."
   (unless name (setq name "*Customization*"))
   (kill-buffer (get-buffer-create name))
 that option."
   (unless name (setq name "*Customization*"))
   (kill-buffer (get-buffer-create name))

-  (switch-to-buffer (get-buffer-create name))
-  (custom-buffer-create-internal options))
+  (pop-to-buffer (get-buffer-create name))
+  (custom-buffer-create-internal options description))

 
 ;;;###autoload
 
 ;;;###autoload

-(defun custom-buffer-create-other-window (options &optional name)
+(defun custom-buffer-create-other-window (options &optional name description)

   "Create a buffer containing OPTIONS.
 Optional NAME is the name of the buffer.
 OPTIONS should be an alist of the form ((SYMBOL WIDGET)...), where
   "Create a buffer containing OPTIONS.
 Optional NAME is the name of the buffer.
 OPTIONS should be an alist of the form ((SYMBOL WIDGET)...), where


@@ -885,66 +1125,84 @@ SYMBOL is a customization option, and WIDGET is a widget for editing
 that option."
   (unless name (setq name "*Customization*"))
   (kill-buffer (get-buffer-create name))
 that option."
   (unless name (setq name "*Customization*"))
   (kill-buffer (get-buffer-create name))

-  (let ((window (selected-window)))
-    (switch-to-buffer-other-window (get-buffer-create name))
-    (custom-buffer-create-internal options)
+  (let ((window (selected-window))
+       (pop-up-windows t)
+       (special-display-buffer-names nil)
+       (special-display-regexps nil)
+       (same-window-buffer-names nil)
+       (same-window-regexps nil))
+    (pop-to-buffer (get-buffer-create name))
+    (custom-buffer-create-internal options description)

     (select-window window)))
 
 (defcustom custom-reset-button-menu nil
   "If non-nil, only show a single reset button in customize buffers.
 This button will have a menu with all three reset operations."
   :type 'boolean
     (select-window window)))
 
 (defcustom custom-reset-button-menu nil
   "If non-nil, only show a single reset button in customize buffers.
 This button will have a menu with all three reset operations."
   :type 'boolean

-  :group 'customize)
+  :group 'custom-buffer)

 
 

-(defun custom-buffer-create-internal (options)
+(defun custom-buffer-create-internal (options &optional description)

   (message "Creating customization buffer...")
   (custom-mode)
   (message "Creating customization buffer...")
   (custom-mode)

-  (widget-insert "This is a customization buffer.
-Push RET or click mouse-2 on the word ")
-  ;; (put-text-property 1 2 'start-open nil)
+  (widget-insert "This is a customization buffer")
+  (if description
+      (widget-insert description))
+  (widget-insert ".
+Square brackets show active fields; type RET or click mouse-1
+on an active field to invoke its action.  Editing an option value
+changes the text in the buffer; invoke the State button and
+choose the Set operation to set the option value.
+Invoke ")

   (widget-create 'info-link 
   (widget-create 'info-link 

-                :tag "help"
+                :tag "Help"

                 :help-echo "Read the online help."
                 "(emacs)Easy Customization")
   (widget-insert " for more information.\n\n")
   (message "Creating customization buttons...")
                 :help-echo "Read the online help."
                 "(emacs)Easy Customization")
   (widget-insert " for more information.\n\n")
   (message "Creating customization buttons...")

+  (widget-insert "Operate on everything in this buffer:\n ")

   (widget-create 'push-button
   (widget-create 'push-button

-                :tag "Set"
-                :help-echo "Set all modifications for this session."
+                :tag "Set for Current Session"
+                :help-echo "\
+Make your editing in this buffer take effect for this session."

                 :action (lambda (widget &optional event)
                 :action (lambda (widget &optional event)

-                          (custom-set)))
+                          (Custom-set)))

   (widget-insert " ")
   (widget-create 'push-button
   (widget-insert " ")
   (widget-create 'push-button

-                :tag "Save"
+                :tag "Save for Future Sessions"

                 :help-echo "\
                 :help-echo "\

-Make the modifications default for future sessions."
+Make your editing in this buffer take effect for future Emacs sessions."

                 :action (lambda (widget &optional event)
                 :action (lambda (widget &optional event)

-                          (custom-save)))
-  (widget-insert " ")
+                          (Custom-save)))

   (if custom-reset-button-menu
   (if custom-reset-button-menu

-      (widget-create 'push-button
-                    :tag "Reset"
-                    :help-echo "Undo all modifications."
-                    :mouse-down-action (lambda (&rest junk) t)
-                    :action (lambda (widget &optional event)
-                              (custom-reset event)))
+      (progn
+       (widget-insert " ")
+       (widget-create 'push-button
+                      :tag "Reset"
+                      :help-echo "Show a menu with reset operations."
+                      :mouse-down-action (lambda (&rest junk) t)
+                      :action (lambda (widget &optional event)
+                                (custom-reset event))))
+    (widget-insert "\n ")

     (widget-create 'push-button
                   :tag "Reset"
     (widget-create 'push-button
                   :tag "Reset"

-                  :help-echo "Undo all modifications."
-                  :action 'custom-reset-current)
+                  :help-echo "\
+Reset all edited text in this buffer to reflect current values."
+                  :action 'Custom-reset-current)

     (widget-insert " ")
     (widget-create 'push-button
                   :tag "Reset to Saved"
     (widget-insert " ")
     (widget-create 'push-button
                   :tag "Reset to Saved"

-                  :help-echo "Undo all modifications."
-                  :action 'custom-reset-saved)
+                  :help-echo "\
+Reset all values in this buffer to their saved settings."
+                  :action 'Custom-reset-saved)

     (widget-insert " ")
     (widget-create 'push-button
                   :tag "Reset to Standard"
     (widget-insert " ")
     (widget-create 'push-button
                   :tag "Reset to Standard"

-                  :help-echo "Undo all modifications."
-                  :action 'custom-reset-standard))
-  (widget-insert " ")
+                  :help-echo "\
+Reset all values in this buffer to their standard settings."
+                  :action 'Custom-reset-standard))
+  (widget-insert "   ")

   (widget-create 'push-button
   (widget-create 'push-button

-                :tag "Done"
+                :tag "Bury Buffer"

                 :help-echo "Bury the buffer."
                 :action (lambda (widget &optional event)
                           (bury-buffer)))
                 :help-echo "Bury the buffer."
                 :action (lambda (widget &optional event)
                           (bury-buffer)))


@@ -954,6 +1212,7 @@ Make the modifications default for future sessions."
        (if (= (length options) 1)
            (mapcar (lambda (entry)
                      (widget-create (nth 1 entry)
        (if (= (length options) 1)
            (mapcar (lambda (entry)
                      (widget-create (nth 1 entry)

+                                    :documentation-shown t

                                     :custom-state 'unknown
                                     :tag (custom-unlispify-tag-name
                                           (nth 0 entry))
                                     :custom-state 'unknown
                                     :tag (custom-unlispify-tag-name
                                           (nth 0 entry))


@@ -963,7 +1222,7 @@ Make the modifications default for future sessions."
                (length (length options)))
            (mapcar (lambda (entry)
                        (prog2
                (length (length options)))
            (mapcar (lambda (entry)
                        (prog2

-                           (message "Creating customization items %2d%%..."
+                           (message "Creating customization items ...%2d%%"

                                     (/ (* 100.0 count) length))
                            (widget-create (nth 1 entry)
                                         :tag (custom-unlispify-tag-name
                                     (/ (* 100.0 count) length))
                            (widget-create (nth 1 entry)
                                         :tag (custom-unlispify-tag-name


@@ -976,21 +1235,118 @@ Make the modifications default for future sessions."
                      options))))
   (unless (eq (preceding-char) ?\n)
     (widget-insert "\n"))
                      options))))
   (unless (eq (preceding-char) ?\n)
     (widget-insert "\n"))

-  (message "Creating customization magic...")
-  (mapcar 'custom-magic-reset custom-options)
+  (message "Creating customization items ...%2d%%done" 100)
+  (unless (eq custom-buffer-style 'tree)
+    (mapcar 'custom-magic-reset custom-options))

   (message "Creating customization setup...")
   (widget-setup)
   (goto-char (point-min))
   (message "Creating customization setup...")
   (widget-setup)
   (goto-char (point-min))

-  (when (fboundp 'map-extents)  
-    ;; This horrible kludge should make bob and eob read-only in XEmacs.
-    (map-extents (lambda (extent &rest junk)
-                  (set-extent-property extent 'start-closed t))
-                nil (point-min) (1+ (point-min)))
-    (map-extents (lambda (extent &rest junk)
-                  (set-extent-property extent 'end-closed t))
-                nil (1- (point-max)) (point-max)))

   (message "Creating customization buffer...done"))
 
   (message "Creating customization buffer...done"))
 

+;;; The Tree Browser.
+
+;;;###autoload
+(defun customize-browse (&optional group)
+  "Create a tree browser for the customize hierarchy."
+  (interactive)
+  (unless group
+    (setq group 'emacs))
+  (let ((name "*Customize Browser*"))
+    (kill-buffer (get-buffer-create name))
+    (pop-to-buffer (get-buffer-create name)))
+  (custom-mode)
+  (widget-insert "\
+Square brackets show active fields; type RET or click mouse-1
+on an active field to invoke its action.
+Invoke [+] below to expand a group, and [-] to collapse an expanded group.\n")
+  (if custom-browse-only-groups
+      (widget-insert "\
+Invoke the [Group] button below to edit that item in another window.\n\n")
+    (widget-insert "Invoke the ") 
+    (widget-create 'item 
+                  :format "%t"
+                  :tag "[Group]"
+                  :tag-glyph "folder")
+    (widget-insert ", ")
+    (widget-create 'item 
+                  :format "%t"
+                  :tag "[Face]"
+                  :tag-glyph "face")
+    (widget-insert ", and ")
+    (widget-create 'item 
+                  :format "%t"
+                  :tag "[Option]"
+                  :tag-glyph "option")
+    (widget-insert " buttons below to edit that
+item in another window.\n\n"))
+  (let ((custom-buffer-style 'tree))
+    (widget-create 'custom-group 
+                  :custom-last t
+                  :custom-state 'unknown
+                  :tag (custom-unlispify-tag-name group)
+                  :value group))
+  (goto-char (point-min)))
+
+(define-widget 'custom-browse-visibility 'item
+  "Control visibility of items in the customize tree browser."
+  :format "%[[%t]%]"
+  :action 'custom-browse-visibility-action)
+
+(defun custom-browse-visibility-action (widget &rest ignore)
+  (let ((custom-buffer-style 'tree))
+    (custom-toggle-parent widget)))
+
+(define-widget 'custom-browse-group-tag 'push-button
+  "Show parent in other window when activated."
+  :tag "Group"
+  :tag-glyph "folder"
+  :action 'custom-browse-group-tag-action)
+
+(defun custom-browse-group-tag-action (widget &rest ignore)
+  (let ((parent (widget-get widget :parent)))
+    (customize-group-other-window (widget-value parent))))
+
+(define-widget 'custom-browse-variable-tag 'push-button
+  "Show parent in other window when activated."
+  :tag "Option"
+  :tag-glyph "option"
+  :action 'custom-browse-variable-tag-action)
+
+(defun custom-browse-variable-tag-action (widget &rest ignore)
+  (let ((parent (widget-get widget :parent)))
+    (customize-variable-other-window (widget-value parent))))
+
+(define-widget 'custom-browse-face-tag 'push-button
+  "Show parent in other window when activated."
+  :tag "Face"
+  :tag-glyph "face"
+  :action 'custom-browse-face-tag-action)
+
+(defun custom-browse-face-tag-action (widget &rest ignore)
+  (let ((parent (widget-get widget :parent)))
+    (customize-face-other-window (widget-value parent))))
+
+(defconst custom-browse-alist '(("   " "space")
+                             (" | " "vertical")
+                             ("-\\ " "top")
+                             (" |-" "middle")
+                             (" `-" "bottom")))
+
+(defun custom-browse-insert-prefix (prefix)
+  "Insert PREFIX.  On XEmacs convert it to line graphics."
+  (if nil ; (string-match "XEmacs" emacs-version)
+      (progn 
+       (insert "*")
+       (while (not (string-equal prefix ""))
+         (let ((entry (substring prefix 0 3)))
+           (setq prefix (substring prefix 3))
+           (let ((overlay (make-overlay (1- (point)) (point) nil t nil))
+                 (name (nth 1 (assoc entry custom-browse-alist))))
+             (overlay-put overlay 'end-glyph (widget-glyph-find name entry))
+             (overlay-put overlay 'start-open t)
+             (overlay-put overlay 'end-open t)))))
+    (insert prefix)))
+

 ;;; Modification of Basic Widgets.
 ;;
 ;; We add extra properties to the basic widgets needed here.  This is
 ;;; Modification of Basic Widgets.
 ;;
 ;; We add extra properties to the basic widgets needed here.  This is


@@ -1019,54 +1375,65 @@ Make the modifications default for future sessions."
 
 ;;; The `custom-magic' Widget.
 
 
 ;;; The `custom-magic' Widget.
 

+(defgroup custom-magic-faces nil
+  "Faces used by the magic button."
+  :group 'custom-faces
+  :group 'custom-buffer)
+

 (defface custom-invalid-face '((((class color))
                                (:foreground "yellow" :background "red"))
                               (t
                                (:bold t :italic t :underline t)))
 (defface custom-invalid-face '((((class color))
                                (:foreground "yellow" :background "red"))
                               (t
                                (:bold t :italic t :underline t)))

-  "Face used when the customize item is invalid.")
+  "Face used when the customize item is invalid."
+  :group 'custom-magic-faces)

 
 (defface custom-rogue-face '((((class color))
                              (:foreground "pink" :background "black"))
                             (t
                              (:underline t)))
 
 (defface custom-rogue-face '((((class color))
                              (:foreground "pink" :background "black"))
                             (t
                              (:underline t)))

-  "Face used when the customize item is not defined for customization.")
+  "Face used when the customize item is not defined for customization."
+  :group 'custom-magic-faces)

 
 (defface custom-modified-face '((((class color)) 
                                 (:foreground "white" :background "blue"))
                                (t
                                 (:italic t :bold)))
 
 (defface custom-modified-face '((((class color)) 
                                 (:foreground "white" :background "blue"))
                                (t
                                 (:italic t :bold)))

-  "Face used when the customize item has been modified.")
+  "Face used when the customize item has been modified."
+  :group 'custom-magic-faces)

 
 (defface custom-set-face '((((class color)) 
                                (:foreground "blue" :background "white"))
                               (t
                                (:italic t)))
 
 (defface custom-set-face '((((class color)) 
                                (:foreground "blue" :background "white"))
                               (t
                                (:italic t)))

-  "Face used when the customize item has been set.")
+  "Face used when the customize item has been set."
+  :group 'custom-magic-faces)

 
 (defface custom-changed-face '((((class color)) 
                                (:foreground "white" :background "blue"))
                               (t
                                (:italic t)))
 
 (defface custom-changed-face '((((class color)) 
                                (:foreground "white" :background "blue"))
                               (t
                                (:italic t)))

-  "Face used when the customize item has been changed.")
+  "Face used when the customize item has been changed."
+  :group 'custom-magic-faces)

 
 (defface custom-saved-face '((t (:underline t)))
 
 (defface custom-saved-face '((t (:underline t)))

-  "Face used when the customize item has been saved.")
+  "Face used when the customize item has been saved."
+  :group 'custom-magic-faces)

 
 (defconst custom-magic-alist '((nil "#" underline "\
 uninitialized, you should not see this.")
                               (unknown "?" italic "\
 unknown, you should not see this.")
                               (hidden "-" default "\
 
 (defconst custom-magic-alist '((nil "#" underline "\
 uninitialized, you should not see this.")
                               (unknown "?" italic "\
 unknown, you should not see this.")
                               (hidden "-" default "\

-hidden, invoke the dots above to show." "\
-group now hidden, invoke the dots above to show contents.")
+hidden, invoke \"Show\" in the previous line to show." "\
+group now hidden, invoke \"Show\", above, to show contents.")

                               (invalid "x" custom-invalid-face "\
 the value displayed for this %c is invalid and cannot be set.")
                               (modified "*" custom-modified-face "\
                               (invalid "x" custom-invalid-face "\
 the value displayed for this %c is invalid and cannot be set.")
                               (modified "*" custom-modified-face "\

-you have edited the value, and can now set the %c." "\
-you have edited something in this group, and can now set it.")
+you have edited the value as text, but you have not set the %c." "\
+you have edited something in this group, but not set it.")

                               (set "+" custom-set-face "\
                               (set "+" custom-set-face "\

-you have set this %c, but not saved it." "\
-something in this group has been set, but not yet saved.")
+you have set this %c, but not saved it for future sessions." "\
+something in this group has been set, but not saved.")

                               (changed ":" custom-changed-face "\
 this %c has been changed outside the customize buffer." "\
 something in this group has been changed outside customize.")
                               (changed ":" custom-changed-face "\
 this %c has been changed outside the customize buffer." "\
 something in this group has been changed outside customize.")


@@ -1078,7 +1445,7 @@ this %c has not been changed with customize." "\
 something in this group is not prepared for customization.")
                               (standard " " nil "\
 this %c is unchanged from its standard setting." "\
 something in this group is not prepared for customization.")
                               (standard " " nil "\
 this %c is unchanged from its standard setting." "\

-the visible members of this group are all at standard settings."))
+visible group members are all at standard settings."))

   "Alist of customize option states.
 Each entry is of the form (STATE MAGIC FACE ITEM-DESC [ GROUP-DESC ]), where 
 
   "Alist of customize option states.
 Each entry is of the form (STATE MAGIC FACE ITEM-DESC [ GROUP-DESC ]), where 
 


@@ -1121,24 +1488,24 @@ The list should be sorted most significant first.")
 
 (defcustom custom-magic-show 'long
   "If non-nil, show textual description of the state.
 
 (defcustom custom-magic-show 'long
   "If non-nil, show textual description of the state.

-If non-nil and not the symbol `long', only show first word."
+If `long', show a full-line description, not just one word."

   :type '(choice (const :tag "no" nil)
   :type '(choice (const :tag "no" nil)

-                (const short)
-                (const long))
-  :group 'customize)
+                (const long)
+                (other :tag "short" short))
+  :group 'custom-buffer)

 
 (defcustom custom-magic-show-hidden '(option face)
 
 (defcustom custom-magic-show-hidden '(option face)

-  "Control whether the state button is shown for hidden items.
-The value should be a list with the custom categories where the state
+  "Control whether the State button is shown for hidden items.
+The value should be a list with the custom categories where the State

 button should be visible.  Possible categories are `group', `option',
 and `face'."
   :type '(set (const group) (const option) (const face))
 button should be visible.  Possible categories are `group', `option',
 and `face'."
   :type '(set (const group) (const option) (const face))

-  :group 'customize)
+  :group 'custom-buffer)

 
 (defcustom custom-magic-show-button nil
 
 (defcustom custom-magic-show-button nil

-  "Show a magic button indicating the state of each customization option."
+  "Show a \"magic\" button indicating the state of each customization option."

   :type 'boolean
   :type 'boolean

-  :group 'customize)
+  :group 'custom-buffer)

 
 (define-widget 'custom-magic 'default
   "Show and manipulate state for a customization option."
 
 (define-widget 'custom-magic 'default
   "Show and manipulate state for a customization option."


@@ -1167,7 +1534,7 @@ and `face'."
         (text (or (and (eq category 'group)
                        (nth 4 entry))
                   (nth 3 entry)))
         (text (or (and (eq category 'group)
                        (nth 4 entry))
                   (nth 3 entry)))

-        (lisp (eq (widget-get parent :custom-form) 'lisp))
+        (form (widget-get parent :custom-form))

         children)
     (while (string-match "\\`\\(.*\\)%c\\(.*\\)\\'" text)
       (setq text (concat (match-string 1 text) 
         children)
     (while (string-match "\\`\\(.*\\)%c\\(.*\\)\\'" text)
       (setq text (concat (match-string 1 text) 


@@ -1177,6 +1544,11 @@ and `face'."
               (or (not hidden)
                   (memq category custom-magic-show-hidden)))
       (insert "   ")
               (or (not hidden)
                   (memq category custom-magic-show-hidden)))
       (insert "   ")

+      (when (and (eq category 'group)
+                (not (and (eq custom-buffer-style 'links)
+                          (> (widget-get parent :custom-level) 1))))
+       (insert-char ?\  (* custom-buffer-indent
+                           (widget-get parent :custom-level))))

       (push (widget-create-child-and-convert 
             widget 'choice-item 
             :help-echo "Change the state of this item."
       (push (widget-create-child-and-convert 
             widget 'choice-item 
             :help-echo "Change the state of this item."


@@ -1187,12 +1559,21 @@ and `face'."
             :tag "State")
            children)
       (insert ": ")
             :tag "State")
            children)
       (insert ": ")

-      (if (eq custom-magic-show 'long)
-         (insert text)
-       (insert (symbol-name state)))
-      (when lisp 
-       (insert " (lisp)"))
+      (let ((start (point)))
+       (if (eq custom-magic-show 'long)
+           (insert text)
+         (insert (symbol-name state)))
+       (cond ((eq form 'lisp)
+              (insert " (lisp)"))
+             ((eq form 'mismatch)
+              (insert " (mismatch)")))
+       (put-text-property start (point) 'face 'custom-state-face))

       (insert "\n"))
       (insert "\n"))

+    (when (and (eq category 'group)
+              (not (and (eq custom-buffer-style 'links)
+                        (> (widget-get parent :custom-level) 1))))
+      (insert-char ?\  (* custom-buffer-indent
+                         (widget-get parent :custom-level))))

     (when custom-magic-show-button
       (when custom-magic-show
        (let ((indent (widget-get parent :indent)))
     (when custom-magic-show-button
       (when custom-magic-show
        (let ((indent (widget-get parent :indent)))


@@ -1206,7 +1587,7 @@ and `face'."
             :button-suffix ""
             :help-echo "Change the state."
             :format (if hidden "%t" "%[%t%]")
             :button-suffix ""
             :help-echo "Change the state."
             :format (if hidden "%t" "%[%t%]")

-            :tag (if lisp 
+            :tag (if (memq form '(lisp mismatch))

                      (concat "(" magic ")")
                    (concat "[" magic "]")))
            children)
                      (concat "(" magic ")")
                    (concat "[" magic "]")))
            children)


@@ -1220,11 +1601,30 @@ and `face'."
 
 ;;; The `custom' Widget.
 
 
 ;;; The `custom' Widget.
 

+(defface custom-button-face nil
+  "Face used for buttons in customization buffers."
+  :group 'custom-faces)
+
+(defface custom-documentation-face nil
+  "Face used for documentation strings in customization buffers."
+  :group 'custom-faces)
+
+(defface custom-state-face '((((class color)
+                              (background dark))
+                             (:foreground "lime green"))
+                            (((class color)
+                              (background light))
+                             (:foreground "dark green"))
+                            (t nil))
+  "Face used for State descriptions in the customize buffer."
+  :group 'custom-faces)
+

 (define-widget 'custom 'default
   "Customize a user option."
 (define-widget 'custom 'default
   "Customize a user option."

+  :format "%v"

   :convert-widget 'custom-convert-widget
   :convert-widget 'custom-convert-widget

-  :format-handler 'custom-format-handler

   :notify 'custom-notify
   :notify 'custom-notify

+  :custom-prefix ""

   :custom-level 1
   :custom-state 'hidden
   :documentation-property 'widget-subclass-responsibility
   :custom-level 1
   :custom-state 'hidden
   :documentation-property 'widget-subclass-responsibility


@@ -1244,79 +1644,14 @@ and `face'."
       (widget-put widget :args nil)))
   widget)
 
       (widget-put widget :args nil)))
   widget)
 

-(defun custom-format-handler (widget escape)
-  ;; We recognize extra escape sequences.
-  (let* ((buttons (widget-get widget :buttons))
-        (state (widget-get widget :custom-state))
-        (level (widget-get widget :custom-level)))
-    (cond ((eq escape ?l)
-          (when level 
-            (insert-char ?\  (1- level))
-            (if (eq state 'hidden)
-                (insert-char ?- (1+ level))
-              (insert "/")
-              (insert-char ?- level))))
-         ((eq escape ?e)
-          (when (and level (not (eq state 'hidden)))
-            (insert "\n")
-            (insert-char ?\  (1- level))
-            (insert "\\")
-            (insert-char ?-  level)
-            (insert " " (widget-get widget :tag) " group end ")
-            (insert-char ?- (- 75 (current-column) level))
-            (insert "/\n")))
-         ((eq escape ?-)
-          (when (and level (not (eq state 'hidden)))
-            (insert-char ?- (- 76 (current-column) level))
-            (insert "\\")))
-         ((eq escape ?L)
-          (push (widget-create-child-and-convert
-                 widget 'visibility
-                 :action 'custom-toggle-parent
-                 (not (eq state 'hidden)))
-                buttons))
-         ((eq escape ?m)
-          (and (eq (preceding-char) ?\n)
-               (widget-get widget :indent)
-               (insert-char ?  (widget-get widget :indent)))
-          (let ((magic (widget-create-child-and-convert
-                        widget 'custom-magic nil)))
-            (widget-put widget :custom-magic magic)
-            (push magic buttons)
-            (widget-put widget :buttons buttons)))
-         ((eq escape ?a)
-          (unless (eq state 'hidden)
-            (let* ((symbol (widget-get widget :value))
-                   (links (get symbol 'custom-links))
-                   (many (> (length links) 2)))
-              (when links
-                (and (eq (preceding-char) ?\n)
-                     (widget-get widget :indent)
-                     (insert-char ?  (widget-get widget :indent)))
-                (insert "See also ")
-                (while links
-                  (push (widget-create-child-and-convert widget (car links))
-                        buttons)
-                  (setq links (cdr links))
-                  (cond ((null links)
-                         (insert ".\n"))
-                        ((null (cdr links))
-                         (if many
-                             (insert ", and ")
-                           (insert " and ")))
-                        (t 
-                         (insert ", "))))
-                (widget-put widget :buttons buttons)))))
-         (t 
-          (widget-default-format-handler widget escape)))))
-

 (defun custom-notify (widget &rest args)
   "Keep track of changes."
 (defun custom-notify (widget &rest args)
   "Keep track of changes."

-  (unless (memq (widget-get widget :custom-state) '(nil unknown hidden))
-    (widget-put widget :custom-state 'modified))
-  (let ((buffer-undo-list t))
-    (custom-magic-reset widget))
-  (apply 'widget-default-notify widget args))
+  (let ((state (widget-get widget :custom-state)))
+    (unless (eq state 'modified)
+      (unless (memq state '(nil unknown hidden))
+       (widget-put widget :custom-state 'modified))
+      (custom-magic-reset widget)
+      (apply 'widget-default-notify widget args))))

 
 (defun custom-redraw (widget)
   "Redraw WIDGET with current settings."
 
 (defun custom-redraw (widget)
   "Redraw WIDGET with current settings."


@@ -1341,11 +1676,12 @@ and `face'."
   "Redraw WIDGET state with current settings."
   (while widget 
     (let ((magic (widget-get widget :custom-magic)))
   "Redraw WIDGET state with current settings."
   (while widget 
     (let ((magic (widget-get widget :custom-magic)))

-      (unless magic 
-       (debug))
-      (widget-value-set magic (widget-value magic))
-      (when (setq widget (widget-get widget :group))
-       (custom-group-state-update widget))))
+      (cond (magic 
+            (widget-value-set magic (widget-value magic))
+            (when (setq widget (widget-get widget :group))
+              (custom-group-state-update widget)))
+           (t
+            (setq widget nil)))))

   (widget-setup))
 
 (defun custom-show (widget value)
   (widget-setup))
 
 (defun custom-show (widget value)


@@ -1375,6 +1711,8 @@ and `face'."
                   (require load)
                 (error nil)))
              ;; Don't reload a file already loaded.
                   (require load)
                 (error nil)))
              ;; Don't reload a file already loaded.

+             ((and (boundp 'preloaded-file-list)
+                   (member load preloaded-file-list)))

              ((assoc load load-history))
              ((assoc (locate-library load) load-history))
              (t
              ((assoc load load-history))
              ((assoc (locate-library load) load-history))
              (t


@@ -1390,8 +1728,31 @@ and `face'."
   "Load all dependencies for WIDGET."
   (custom-load-symbol (widget-value widget)))
 
   "Load all dependencies for WIDGET."
   (custom-load-symbol (widget-value widget)))
 

+(defun custom-unloaded-symbol-p (symbol)
+  "Return non-nil if the dependencies of SYMBOL has not yet been loaded."
+  (let ((found nil)
+       (loads (get symbol 'custom-loads))
+       load)
+    (while loads
+      (setq load (car loads)
+           loads (cdr loads))
+      (cond ((symbolp load)
+            (unless (featurep load)
+              (setq found t)))
+           ((assoc load load-history))
+           ((assoc (locate-library load) load-history)
+            (message nil))
+           (t
+            (setq found t))))
+    found))
+
+(defun custom-unloaded-widget-p (widget)
+  "Return non-nil if the dependencies of WIDGET has not yet been loaded."
+  (custom-unloaded-symbol-p (widget-value widget)))
+

 (defun custom-toggle-hide (widget)
   "Toggle visibility of WIDGET."
 (defun custom-toggle-hide (widget)
   "Toggle visibility of WIDGET."

+  (custom-load-widget widget)

   (let ((state (widget-get widget :custom-state)))
     (cond ((memq state '(invalid modified))
           (error "There are unset changes"))
   (let ((state (widget-get widget :custom-state)))
     (cond ((memq state '(invalid modified))
           (error "There are unset changes"))


@@ -1400,15 +1761,76 @@ and `face'."
          (t 
           (widget-put widget :documentation-shown nil)
           (widget-put widget :custom-state 'hidden)))
          (t 
           (widget-put widget :documentation-shown nil)
           (widget-put widget :custom-state 'hidden)))

-    (custom-redraw widget)))
+    (custom-redraw widget)
+    (widget-setup)))

 
 (defun custom-toggle-parent (widget &rest ignore)
 
 (defun custom-toggle-parent (widget &rest ignore)

-  "Toggle visibility of parent to WIDGET."
+  "Toggle visibility of parent of WIDGET."

   (custom-toggle-hide (widget-get widget :parent)))
 
   (custom-toggle-hide (widget-get widget :parent)))
 

+(defun custom-add-see-also (widget &optional prefix)
+  "Add `See also ...' to WIDGET if there are any links.
+Insert PREFIX first if non-nil."
+  (let* ((symbol (widget-get widget :value))
+        (links (get symbol 'custom-links))
+        (many (> (length links) 2))
+        (buttons (widget-get widget :buttons))
+        (indent (widget-get widget :indent)))
+    (when links
+      (when indent
+       (insert-char ?\  indent))
+      (when prefix
+       (insert prefix))
+      (insert "See also ")
+      (while links
+       (push (widget-create-child-and-convert widget (car links))
+             buttons)
+       (setq links (cdr links))
+       (cond ((null links)
+              (insert ".\n"))
+             ((null (cdr links))
+              (if many
+                  (insert ", and ")
+                (insert " and ")))
+             (t 
+              (insert ", "))))
+      (widget-put widget :buttons buttons))))
+
+(defun custom-add-parent-links (widget &optional initial-string)
+  "Add \"Parent groups: ...\" to WIDGET if the group has parents.
+The value if non-nil if any parents were found.
+If INITIAL-STRING is non-nil, use that rather than \"Parent groups:\"."
+  (let ((name (widget-value widget))
+       (type (widget-type widget))
+       (buttons (widget-get widget :buttons))
+       (start (point))
+       found)
+    (insert (or initial-string "Parent groups:"))
+    (mapatoms (lambda (symbol)
+               (let ((entry (assq name (get symbol 'custom-group))))
+                 (when (eq (nth 1 entry) type)
+                   (insert " ")
+                   (push (widget-create-child-and-convert 
+                          widget 'custom-group-link 
+                          :tag (custom-unlispify-tag-name symbol)
+                          symbol)
+                         buttons)
+                   (setq found t)))))
+    (widget-put widget :buttons buttons)
+    (if found
+       (insert "\n")
+      (delete-region start (point)))
+    found))
+

 ;;; The `custom-variable' Widget.
 
 ;;; The `custom-variable' Widget.
 

-(defface custom-variable-sample-face '((t (:underline t)))
+(defface custom-variable-tag-face '((((class color)
+                                     (background dark))
+                                    (:foreground "light blue" :underline t))
+                                   (((class color)
+                                     (background light))
+                                    (:foreground "blue" :underline t))
+                                   (t (:underline t)))

   "Face used for unpushable variable tags."
   :group 'custom-faces)
 
   "Face used for unpushable variable tags."
   :group 'custom-faces)
 


@@ -1416,15 +1838,22 @@ and `face'."
   "Face used for pushable variable tags."
   :group 'custom-faces)
 
   "Face used for pushable variable tags."
   :group 'custom-faces)
 

+(defcustom custom-variable-default-form 'edit
+  "Default form of displaying variable values."
+  :type '(choice (const edit)
+                (const lisp))
+  :group 'custom-buffer
+  :version "20.3")
+

 (define-widget 'custom-variable 'custom
   "Customize variable."
 (define-widget 'custom-variable 'custom
   "Customize variable."

-  :format "%v%m%h%a"
+  :format "%v"

   :help-echo "Set or reset this variable."
   :documentation-property 'variable-documentation
   :custom-category 'option
   :custom-state nil
   :custom-menu 'custom-variable-menu-create
   :help-echo "Set or reset this variable."
   :documentation-property 'variable-documentation
   :custom-category 'option
   :custom-state nil
   :custom-menu 'custom-variable-menu-create

-  :custom-form 'edit
+  :custom-form nil ; defaults to value of `custom-variable-default-form'

   :value-create 'custom-variable-value-create
   :action 'custom-variable-action
   :custom-set 'custom-variable-set
   :value-create 'custom-variable-value-create
   :action 'custom-variable-action
   :custom-set 'custom-variable-set


@@ -1452,6 +1881,8 @@ Otherwise, look up symbol in `custom-guess-type-alist'."
 (defun custom-variable-value-create (widget)
   "Here is where you edit the variables value."
   (custom-load-widget widget)
 (defun custom-variable-value-create (widget)
   "Here is where you edit the variables value."
   (custom-load-widget widget)

+  (unless (widget-get widget :custom-form)
+    (widget-put widget :custom-form custom-variable-default-form))

   (let* ((buttons (widget-get widget :buttons))
         (children (widget-get widget :children))
         (form (widget-get widget :custom-form))
   (let* ((buttons (widget-get widget :buttons))
         (children (widget-get widget :children))
         (form (widget-get widget :custom-form))


@@ -1461,6 +1892,8 @@ Otherwise, look up symbol in `custom-guess-type-alist'."
         (type (custom-variable-type symbol))
         (conv (widget-convert type))
         (get (or (get symbol 'custom-get) 'default-value))
         (type (custom-variable-type symbol))
         (conv (widget-convert type))
         (get (or (get symbol 'custom-get) 'default-value))

+        (prefix (widget-get widget :custom-prefix))
+        (last (widget-get widget :custom-last))

         (value (if (default-boundp symbol)
                    (funcall get symbol)
                  (widget-get conv :value))))
         (value (if (default-boundp symbol)
                    (funcall get symbol)
                  (widget-get conv :value))))


@@ -1474,23 +1907,31 @@ Otherwise, look up symbol in `custom-guess-type-alist'."
     (when (eq state 'unknown)
       (unless (widget-apply conv :match value)
        ;; (widget-apply (widget-convert type) :match value)
     (when (eq state 'unknown)
       (unless (widget-apply conv :match value)
        ;; (widget-apply (widget-convert type) :match value)

-       (setq form 'lisp)))
+       (setq form 'mismatch)))

     ;; Now we can create the child widget.
     ;; Now we can create the child widget.

-    (cond ((eq state 'hidden)
+    (cond ((eq custom-buffer-style 'tree)
+          (insert prefix (if last " `--- " " |--- "))
+          (push (widget-create-child-and-convert
+                 widget 'custom-browse-variable-tag)
+                buttons)
+          (insert " " tag "\n")
+          (widget-put widget :buttons buttons))
+         ((eq state 'hidden)

           ;; Indicate hidden value.
           (push (widget-create-child-and-convert 
                  widget 'item
                  :format "%{%t%}: "
           ;; Indicate hidden value.
           (push (widget-create-child-and-convert 
                  widget 'item
                  :format "%{%t%}: "

-                 :sample-face 'custom-variable-sample-face
+                 :sample-face 'custom-variable-tag-face

                  :tag tag
                  :parent widget)
                 buttons)
           (push (widget-create-child-and-convert 
                  widget 'visibility
                  :tag tag
                  :parent widget)
                 buttons)
           (push (widget-create-child-and-convert 
                  widget 'visibility

+                 :help-echo "Show the value of this option."

                  :action 'custom-toggle-parent
                  nil)
                 buttons))
                  :action 'custom-toggle-parent
                  nil)
                 buttons))

-         ((eq form 'lisp)
+         ((memq form '(lisp mismatch))

           ;; In lisp mode edit the saved value when possible.
           (let* ((value (cond ((get symbol 'saved-value)
                                (car (get symbol 'saved-value)))
           ;; In lisp mode edit the saved value when possible.
           (let* ((value (cond ((get symbol 'saved-value)
                                (car (get symbol 'saved-value)))


@@ -1502,10 +1943,11 @@ Otherwise, look up symbol in `custom-guess-type-alist'."
                                (custom-quote (widget-get conv :value))))))
             (insert (symbol-name symbol) ": ")
             (push (widget-create-child-and-convert 
                                (custom-quote (widget-get conv :value))))))
             (insert (symbol-name symbol) ": ")
             (push (widget-create-child-and-convert 

-                 widget 'visibility
-                 :action 'custom-toggle-parent
-                 t)
-                buttons)
+                   widget 'visibility
+                   :help-echo "Hide the value of this option."
+                   :action 'custom-toggle-parent
+                   t)
+                  buttons)

             (insert " ")
             (push (widget-create-child-and-convert 
                    widget 'sexp 
             (insert " ")
             (push (widget-create-child-and-convert 
                    widget 'sexp 


@@ -1520,21 +1962,23 @@ Otherwise, look up symbol in `custom-guess-type-alist'."
           (let* ((format (widget-get type :format))
                  tag-format value-format)
             (unless (string-match ":" format)
           (let* ((format (widget-get type :format))
                  tag-format value-format)
             (unless (string-match ":" format)

-              (error "Bad format."))
+              (error "Bad format"))

             (setq tag-format (substring format 0 (match-end 0)))
             (setq value-format (substring format (match-end 0)))
             (push (widget-create-child-and-convert
                    widget 'item 
                    :format tag-format
                    :action 'custom-tag-action
             (setq tag-format (substring format 0 (match-end 0)))
             (setq value-format (substring format (match-end 0)))
             (push (widget-create-child-and-convert
                    widget 'item 
                    :format tag-format
                    :action 'custom-tag-action

+                   :help-echo "Change value of this option."

                    :mouse-down-action 'custom-tag-mouse-down-action
                    :button-face 'custom-variable-button-face
                    :mouse-down-action 'custom-tag-mouse-down-action
                    :button-face 'custom-variable-button-face

-                   :sample-face 'custom-variable-sample-face
+                   :sample-face 'custom-variable-tag-face

                    tag)
                   buttons)
             (insert " ")
             (push (widget-create-child-and-convert 
                  widget 'visibility
                    tag)
                   buttons)
             (insert " ")
             (push (widget-create-child-and-convert 
                  widget 'visibility

+                 :help-echo "Hide the value of this option."

                  :action 'custom-toggle-parent
                  t)
                 buttons)            
                  :action 'custom-toggle-parent
                  t)
                 buttons)            


@@ -1543,15 +1987,29 @@ Otherwise, look up symbol in `custom-guess-type-alist'."
                    :format value-format
                    :value value)
                   children))))
                    :format value-format
                    :value value)
                   children))))

-    ;; Now update the state.
-    (unless (eq (preceding-char) ?\n)
-      (widget-insert "\n"))
-    (if (eq state 'hidden)
-       (widget-put widget :custom-state state)
-      (custom-variable-state-set widget))
-    (widget-put widget :custom-form form)           
-    (widget-put widget :buttons buttons)
-    (widget-put widget :children children)))
+    (unless (eq custom-buffer-style 'tree)
+      ;; Now update the state.
+      (unless (eq (preceding-char) ?\n)
+       (widget-insert "\n"))
+      (if (eq state 'hidden)
+         (widget-put widget :custom-state state)
+       (custom-variable-state-set widget))
+      ;; Create the magic button.
+      (let ((magic (widget-create-child-and-convert
+                   widget 'custom-magic nil)))
+       (widget-put widget :custom-magic magic)
+       (push magic buttons))
+      ;; Update properties.
+      (widget-put widget :custom-form form)         
+      (widget-put widget :buttons buttons)
+      (widget-put widget :children children)
+      ;; Insert documentation.
+      (widget-default-format-handler widget ?h)
+      ;; See also.
+      (unless (eq state 'hidden)
+       (when (eq (widget-get widget :custom-level) 1)
+         (custom-add-parent-links widget))
+       (custom-add-see-also widget)))))

 
 (defun custom-tag-action (widget &rest args)
   "Pass :action to first child of WIDGET's parent."
 
 (defun custom-tag-action (widget &rest args)
   "Pass :action to first child of WIDGET's parent."


@@ -1593,16 +2051,10 @@ Otherwise, look up symbol in `custom-guess-type-alist'."
     (widget-put widget :custom-state state)))
 
 (defvar custom-variable-menu 
     (widget-put widget :custom-state state)))
 
 (defvar custom-variable-menu 

-  '(("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
+  '(("Set for Current Session" custom-variable-set

      (lambda (widget)
        (eq (widget-get widget :custom-state) 'modified)))
      (lambda (widget)
        (eq (widget-get widget :custom-state) 'modified)))

-    ("Save" custom-variable-save
+    ("Save for Future Sessions" custom-variable-save

      (lambda (widget)
        (memq (widget-get widget :custom-state) '(modified set changed rogue))))
     ("Reset to Current" custom-redraw
      (lambda (widget)
        (memq (widget-get widget :custom-state) '(modified set changed rogue))))
     ("Reset to Current" custom-redraw


@@ -1618,7 +2070,14 @@ Otherwise, look up symbol in `custom-guess-type-alist'."
      (lambda (widget)
        (and (get (widget-value widget) 'standard-value)
            (memq (widget-get widget :custom-state)
      (lambda (widget)
        (and (get (widget-value widget) 'standard-value)
            (memq (widget-get widget :custom-state)

-                 '(modified set changed saved rogue))))))
+                 '(modified set changed saved rogue)))))
+    ("---" ignore ignore)
+    ("Don't show as Lisp expression" custom-variable-edit 
+     (lambda (widget)
+       (eq (widget-get widget :custom-form) 'lisp)))
+    ("Show initial Lisp expression" custom-variable-edit-lisp
+     (lambda (widget)
+       (eq (widget-get widget :custom-form) 'edit))))

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


@@ -1665,11 +2124,11 @@ Optional EVENT is the location for the menu."
         (set (or (get symbol 'custom-set) 'set-default))
          val)
     (cond ((eq state 'hidden)
         (set (or (get symbol 'custom-set) 'set-default))
          val)
     (cond ((eq state 'hidden)

-          (error "Cannot set hidden variable."))
+          (error "Cannot set hidden variable"))

          ((setq val (widget-apply child :validate))
           (goto-char (widget-get val :from))
           (error "%s" (widget-get val :error)))
          ((setq val (widget-apply child :validate))
           (goto-char (widget-get val :from))
           (error "%s" (widget-get val :error)))

-         ((eq form 'lisp)
+         ((memq form '(lisp mismatch))

           (funcall set symbol (eval (setq val (widget-value child))))
           (put symbol 'customized-value (list val)))
          (t
           (funcall set symbol (eval (setq val (widget-value child))))
           (put symbol 'customized-value (list val)))
          (t


@@ -1679,7 +2138,7 @@ Optional EVENT is the location for the menu."
     (custom-redraw-magic widget)))
 
 (defun custom-variable-save (widget)
     (custom-redraw-magic widget)))
 
 (defun custom-variable-save (widget)

-  "Set the default value for the variable being edited by WIDGET."
+  "Set and save the 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)))
   (let* ((form (widget-get widget :custom-form))
         (state (widget-get widget :custom-state))
         (child (car (widget-get widget :children)))


@@ -1687,11 +2146,11 @@ Optional EVENT is the location for the menu."
         (set (or (get symbol 'custom-set) 'set-default))
         val)
     (cond ((eq state 'hidden)
         (set (or (get symbol 'custom-set) 'set-default))
         val)
     (cond ((eq state 'hidden)

-          (error "Cannot set hidden variable."))
+          (error "Cannot set hidden variable"))

          ((setq val (widget-apply child :validate))
           (goto-char (widget-get val :from))
           (error "%s" (widget-get val :error)))
          ((setq val (widget-apply child :validate))
           (goto-char (widget-get val :from))
           (error "%s" (widget-get val :error)))

-         ((eq form 'lisp)
+         ((memq form '(lisp mismatch))

           (put symbol 'saved-value (list (widget-value child)))
           (funcall set symbol (eval (widget-value child))))
          (t
           (put symbol 'saved-value (list (widget-value child)))
           (funcall set symbol (eval (widget-value child))))
          (t


@@ -1772,10 +2231,10 @@ The X11 Window System.")
                                           :sibling-args (:help-echo "\
 OS/2 Presentation Manager.")
                                           pm)
                                           :sibling-args (:help-echo "\
 OS/2 Presentation Manager.")
                                           pm)

-                                   (const :format "Win32 "
+                                   (const :format "W32 "

                                           :sibling-args (:help-echo "\
                                           :sibling-args (:help-echo "\

-Windows NT/95/97.")
-                                          win32)
+Windows NT/9X.")
+                                          w32)

                                    (const :format "DOS "
                                           :sibling-args (:help-echo "\
 Plain MS-DOS.")
                                    (const :format "DOS "
                                           :sibling-args (:help-echo "\
 Plain MS-DOS.")


@@ -1824,10 +2283,16 @@ Match frames with dark backgrounds.")
   "Face used for face tags."
   :group 'custom-faces)
 
   "Face used for face tags."
   :group 'custom-faces)
 

+(defcustom custom-face-default-form 'selected
+  "Default form of displaying face definition."
+  :type '(choice (const all)
+                (const selected)
+                (const lisp))
+  :group 'custom-buffer
+  :version "20.3")
+

 (define-widget 'custom-face 'custom
   "Customize face."
 (define-widget 'custom-face 'custom
   "Customize face."

-  :format "%{%t%}: %s %L\n%m%h%a%v"
-  :format-handler 'custom-face-format-handler

   :sample-face 'custom-face-tag-face
   :help-echo "Set or reset this face."
   :documentation-property '(lambda (face)
   :sample-face 'custom-face-tag-face
   :help-echo "Set or reset this face."
   :documentation-property '(lambda (face)


@@ -1835,7 +2300,7 @@ Match frames with dark backgrounds.")
   :value-create 'custom-face-value-create
   :action 'custom-face-action
   :custom-category 'face
   :value-create 'custom-face-value-create
   :action 'custom-face-action
   :custom-category 'face

-  :custom-form 'selected
+  :custom-form nil ; defaults to value of `custom-face-default-form'

   :custom-set 'custom-face-set
   :custom-save 'custom-face-save
   :custom-reset-current 'custom-redraw
   :custom-set 'custom-face-set
   :custom-save 'custom-face-save
   :custom-reset-current 'custom-redraw


@@ -1843,26 +2308,6 @@ Match frames with dark backgrounds.")
   :custom-reset-standard 'custom-face-reset-standard
   :custom-menu 'custom-face-menu-create)
 
   :custom-reset-standard 'custom-face-reset-standard
   :custom-menu 'custom-face-menu-create)
 

-(defun custom-face-format-handler (widget escape)
-  ;; We recognize extra escape sequences.
-  (let (child
-       (symbol (widget-get widget :value)))
-    (cond ((eq escape ?s)
-          (and (string-match "XEmacs" emacs-version)
-               ;; XEmacs cannot display initialized faces.
-               (not (custom-facep symbol))
-               (copy-face 'custom-face-empty symbol))
-          (setq child (widget-create-child-and-convert 
-                       widget 'item
-                       :format "(%{%t%})"
-                       :sample-face symbol
-                       :tag "sample")))
-         (t 
-          (custom-format-handler widget escape)))
-    (when child
-      (widget-put widget
-                 :buttons (cons child (widget-get widget :buttons))))))
-

 (define-widget 'custom-face-all 'editable-list 
   "An editable list of display specifications and attributes."
   :entry-format "%i %d %v"
 (define-widget 'custom-face-all 'editable-list 
   "An editable list of display specifications and attributes."
   :entry-format "%i %d %v"


@@ -1896,55 +2341,122 @@ Match frames with dark backgrounds.")
   "Converted version of the `custom-face-selected' widget.")
 
 (defun custom-face-value-create (widget)
   "Converted version of the `custom-face-selected' widget.")
 
 (defun custom-face-value-create (widget)

-  ;; Create a list of the display specifications.
-  (unless (eq (preceding-char) ?\n)
-    (insert "\n"))
-  (when (not (eq (widget-get widget :custom-state) 'hidden))
-    (message "Creating face editor...")
-    (custom-load-widget widget)
-    (let* ((symbol (widget-value widget))
-          (spec (or (get symbol 'saved-face)
-                    (get symbol 'face-defface-spec)
-                    ;; Attempt to construct it.
-                    (list (list t (custom-face-attributes-get 
-                                   symbol (selected-frame))))))
-          (form (widget-get widget :custom-form))
-          (indent (widget-get widget :indent))
-          (edit (widget-create-child-and-convert
-                 widget
-                 (cond ((and (eq form 'selected)
-                             (widget-apply custom-face-selected :match spec))
-                        (when indent (insert-char ?\  indent))
-                        'custom-face-selected)
-                       ((and (not (eq form 'lisp))
-                             (widget-apply custom-face-all :match spec))
-                        'custom-face-all)
-                       (t 
-                        (when indent (insert-char ?\  indent))
-                        'sexp))
-                 :value spec)))
-      (custom-face-state-set widget)
-      (widget-put widget :children (list edit)))
-    (message "Creating face editor...done")))
+  "Create a list of the display specifications for WIDGET."
+  (let ((buttons (widget-get widget :buttons))
+       (symbol (widget-get widget :value))
+       (tag (widget-get widget :tag))
+       (state (widget-get widget :custom-state))
+       (begin (point))
+       (is-last (widget-get widget :custom-last))
+       (prefix (widget-get widget :custom-prefix)))
+    (unless tag
+      (setq tag (prin1-to-string symbol)))
+    (cond ((eq custom-buffer-style 'tree)
+          (insert prefix (if is-last " `--- " " |--- "))
+          (push (widget-create-child-and-convert
+                 widget 'custom-browse-face-tag)
+                buttons)
+          (insert " " tag "\n")
+          (widget-put widget :buttons buttons))
+         (t
+          ;; Create tag.
+          (insert tag)
+          (if (eq custom-buffer-style 'face)
+              (insert " ")
+            (widget-specify-sample widget begin (point))
+            (insert ": "))
+          ;; Sample.
+          (and (string-match "XEmacs" emacs-version)
+               ;; XEmacs cannot display uninitialized faces.
+               (not (custom-facep symbol))
+               (copy-face 'custom-face-empty symbol))
+          (push (widget-create-child-and-convert widget 'item
+                                                 :format "(%{%t%})"
+                                                 :sample-face symbol
+                                                 :tag "sample")
+                buttons)
+          ;; Visibility.
+          (insert " ")
+          (push (widget-create-child-and-convert 
+                 widget 'visibility
+                 :help-echo "Hide or show this face."
+                 :action 'custom-toggle-parent
+                 (not (eq state 'hidden)))
+                buttons)
+          ;; Magic.
+          (insert "\n")
+          (let ((magic (widget-create-child-and-convert
+                        widget 'custom-magic nil)))
+            (widget-put widget :custom-magic magic)
+            (push magic buttons))
+          ;; Update buttons.
+          (widget-put widget :buttons buttons)
+          ;; Insert documentation.
+          (widget-default-format-handler widget ?h)
+          ;; See also.
+          (unless (eq state 'hidden)
+            (when (eq (widget-get widget :custom-level) 1)
+              (custom-add-parent-links widget))
+            (custom-add-see-also widget))
+          ;; Editor.
+          (unless (eq (preceding-char) ?\n)
+            (insert "\n"))
+          (unless (eq state 'hidden)
+            (message "Creating face editor...")
+            (custom-load-widget widget)
+            (unless (widget-get widget :custom-form)
+                (widget-put widget :custom-form custom-face-default-form))
+            (let* ((symbol (widget-value widget))
+                   (spec (or (get symbol 'saved-face)
+                             (get symbol 'face-defface-spec)
+                             ;; Attempt to construct it.
+                             (list (list t (custom-face-attributes-get 
+                                            symbol (selected-frame))))))
+                   (form (widget-get widget :custom-form))
+                   (indent (widget-get widget :indent))
+                   edit)
+              ;; If the user has changed this face in some other way,
+              ;; edit it as the user has specified it.
+              (if (not (face-spec-match-p symbol spec (selected-frame)))
+                  (setq spec (list (list t (face-attr-construct symbol (selected-frame))))))
+              (setq edit (widget-create-child-and-convert
+                          widget
+                          (cond ((and (eq form 'selected)
+                                      (widget-apply custom-face-selected 
+                                                    :match spec))
+                                 (when indent (insert-char ?\  indent))
+                                 'custom-face-selected)
+                                ((and (not (eq form 'lisp))
+                                      (widget-apply custom-face-all
+                                                    :match spec))
+                                 'custom-face-all)
+                                (t 
+                                 (when indent (insert-char ?\  indent))
+                                 'sexp))
+                          :value spec))
+              (custom-face-state-set widget)
+              (widget-put widget :children (list edit)))
+            (message "Creating face editor...done"))))))

 
 (defvar custom-face-menu 
 
 (defvar custom-face-menu 

-  '(("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)
+  '(("Set for Current Session" custom-face-set)
+    ("Save for Future Sessions" custom-face-save-command)

     ("Reset to Saved" custom-face-reset-saved
      (lambda (widget)
        (get (widget-value widget) 'saved-face)))
     ("Reset to Standard Setting" custom-face-reset-standard
      (lambda (widget)
     ("Reset to Saved" custom-face-reset-saved
      (lambda (widget)
        (get (widget-value widget) 'saved-face)))
     ("Reset to Standard Setting" custom-face-reset-standard
      (lambda (widget)

-       (get (widget-value widget) 'face-defface-spec))))
+       (get (widget-value widget) 'face-defface-spec)))
+    ("---" ignore ignore)
+    ("Show all display specs" custom-face-edit-all
+     (lambda (widget)
+       (not (eq (widget-get widget :custom-form) 'all))))
+    ("Just current attributes" custom-face-edit-selected
+     (lambda (widget)
+       (not (eq (widget-get widget :custom-form) 'selected))))
+    ("Show as Lisp expression" custom-face-edit-lisp
+     (lambda (widget)
+       (not (eq (widget-get widget :custom-form) 'lisp)))))

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


@@ -2007,14 +2519,20 @@ Optional EVENT is the location for the menu."
     (custom-face-state-set widget)
     (custom-redraw-magic widget)))
 
     (custom-face-state-set widget)
     (custom-redraw-magic widget)))
 

+(defun custom-face-save-command (widget)
+  "Save in `.emacs' the face attributes in WIDGET."
+  (custom-face-save widget)
+  (custom-save-all))
+

 (defun custom-face-save (widget)
 (defun custom-face-save (widget)

-  "Make the face attributes in WIDGET default."
+  "Prepare for saving WIDGET's face attributes, but don't write `.emacs'."

   (let* ((symbol (widget-value widget))
         (child (car (widget-get widget :children)))
         (value (widget-value child)))
     (face-spec-set symbol value)
     (put symbol 'saved-face value)
     (put symbol 'customized-face nil)
   (let* ((symbol (widget-value widget))
         (child (car (widget-get widget :children)))
         (value (widget-value child)))
     (face-spec-set symbol value)
     (put symbol 'saved-face value)
     (put symbol 'customized-face nil)

+    (custom-save-all)

     (custom-face-state-set widget)
     (custom-redraw-magic widget)))
 
     (custom-face-state-set widget)
     (custom-redraw-magic widget)))
 


@@ -2052,7 +2570,9 @@ Optional EVENT is the location for the menu."
 (define-widget 'face 'default
   "Select and customize a face."
   :convert-widget 'widget-value-convert-widget
 (define-widget 'face 'default
   "Select and customize a face."
   :convert-widget 'widget-value-convert-widget

-  :format "%[%t%]: %v"
+  :button-prefix 'widget-push-button-prefix
+  :button-suffix 'widget-push-button-suffix
+  :format "%t: %[select face%] %v"

   :tag "Face"
   :value 'default
   :value-create 'widget-face-value-create
   :tag "Face"
   :value 'default
   :value-create 'widget-face-value-create


@@ -2065,9 +2585,9 @@ Optional EVENT is the location for the menu."
 (defun widget-face-value-create (widget)
   ;; Create a `custom-face' child.
   (let* ((symbol (widget-value widget))
 (defun widget-face-value-create (widget)
   ;; Create a `custom-face' child.
   (let* ((symbol (widget-value widget))

+        (custom-buffer-style 'face)

         (child (widget-create-child-and-convert
                 widget 'custom-face
         (child (widget-create-child-and-convert
                 widget 'custom-face

-                :format "%t %s %L\n%m%h%v"

                 :custom-level nil
                 :value symbol)))
     (custom-magic-reset child)
                 :custom-level nil
                 :value symbol)))
     (custom-magic-reset child)


@@ -2100,6 +2620,13 @@ Optional EVENT is the location for the menu."
 
 (define-widget 'hook 'list
   "A emacs lisp hook"
 
 (define-widget 'hook 'list
   "A emacs lisp hook"

+  :value-to-internal (lambda (widget value)
+                      (if (and value (symbolp value))
+                          (list value)
+                        value))
+  :match (lambda (widget value)
+          (or (symbolp value)
+              (widget-group-match widget value)))

   :convert-widget 'custom-hook-convert-widget
   :tag "Hook")
 
   :convert-widget 'custom-hook-convert-widget
   :tag "Hook")
 


@@ -2119,9 +2646,19 @@ Optional EVENT is the location for the menu."
     (widget-put widget :args args)
     widget))
 
     (widget-put widget :args args)
     widget))
 

+;;; The `custom-group-link' Widget.
+
+(define-widget 'custom-group-link 'link
+  "Show parent in other window when activated."
+  :help-echo "Create customization buffer for this group."
+  :action 'custom-group-link-action)
+
+(defun custom-group-link-action (widget &rest ignore)
+  (customize-group (widget-value widget)))
+

 ;;; The `custom-group' Widget.
 
 ;;; The `custom-group' Widget.
 

-(defcustom custom-group-tag-faces '(custom-group-tag-face-1)
+(defcustom custom-group-tag-faces nil

   ;; In XEmacs, this ought to play games with font size.
   "Face used for group tags.
 The first member is used for level 1 groups, the second for level 2,
   ;; In XEmacs, this ought to play games with font size.
   "Face used for group tags.
 The first member is used for level 1 groups, the second for level 2,


@@ -2151,7 +2688,7 @@ and so forth.  The remaining group tags are shown with
 
 (define-widget 'custom-group 'custom
   "Customize group."
 
 (define-widget 'custom-group 'custom
   "Customize group."

-  :format "%l %{%t%} group: %L %-\n%m%h%a%v%e"
+  :format "%v"

   :sample-face-get 'custom-group-sample-face-get
   :documentation-property 'group-documentation
   :help-echo "Set or reset all members of this group."
   :sample-face-get 'custom-group-sample-face-get
   :documentation-property 'group-documentation
   :help-echo "Set or reset all members of this group."


@@ -2170,49 +2707,253 @@ and so forth.  The remaining group tags are shown with
   (or (nth (1- (widget-get widget :custom-level)) custom-group-tag-faces)
       'custom-group-tag-face))
 
   (or (nth (1- (widget-get widget :custom-level)) custom-group-tag-faces)
       'custom-group-tag-face))
 

+(define-widget 'custom-group-visibility 'visibility
+  "An indicator and manipulator for hidden group contents."
+  :create 'custom-group-visibility-create)
+
+(defun custom-group-visibility-create (widget)
+  (let ((visible (widget-value widget)))
+    (if visible
+       (insert "--------")))
+  (widget-default-create widget))
+
+(defun custom-group-members (symbol groups-only)
+  "Return SYMBOL's custom group members.
+If GROUPS-ONLY non-nil, return only those members that are groups."
+  (if (not groups-only)
+      (get symbol 'custom-group)
+    (let (members)
+      (dolist (entry (get symbol 'custom-group))
+       (when (eq (nth 1 entry) 'custom-group)
+         (push entry members)))
+      (nreverse members))))
+

 (defun custom-group-value-create (widget)
 (defun custom-group-value-create (widget)

-  (let ((state (widget-get widget :custom-state)))
-    (unless (eq state 'hidden)
-      (message "Creating group...")
-      (custom-load-widget widget)
-      (let* ((level (widget-get widget :custom-level))
-            (symbol (widget-value widget))
-            (members (sort (get symbol 'custom-group) 
-                           custom-buffer-sort-predicate))
-            (prefixes (widget-get widget :custom-prefixes))
-            (custom-prefix-list (custom-prefix-add symbol prefixes))
-            (length (length members))
-            (count 0)
-            (children (mapcar (lambda (entry)
-                                (widget-insert "\n")
-                                (message "Creating group members... %2d%%"
-                                         (/ (* 100.0 count) length))
-                                (setq count (1+ count))
-                                (prog1
-                                    (widget-create-child-and-convert
-                                     widget (nth 1 entry)
-                                     :group widget
-                                     :tag (custom-unlispify-tag-name
-                                           (nth 0 entry))
-                                     :custom-prefixes custom-prefix-list
-                                     :custom-level (1+ level)
-                                     :value (nth 0 entry))
-                                  (unless (eq (preceding-char) ?\n)
-                                    (widget-insert "\n"))))
-                              members)))
-       (put symbol 'custom-group members)
-       (message "Creating group magic...")
-       (mapcar 'custom-magic-reset children)
-       (message "Creating group state...")
-       (widget-put widget :children children)
-       (custom-group-state-update widget)
-       (message "Creating group... done")))))
+  "Insert a customize group for WIDGET in the current buffer."
+  (let* ((state (widget-get widget :custom-state))
+        (level (widget-get widget :custom-level))
+        ;; (indent (widget-get widget :indent))
+        (prefix (widget-get widget :custom-prefix))
+        (buttons (widget-get widget :buttons))
+        (tag (widget-get widget :tag))
+        (symbol (widget-value widget))
+        (members (custom-group-members symbol
+                                       (and (eq custom-buffer-style 'tree)
+                                            custom-browse-only-groups))))
+    (cond ((and (eq custom-buffer-style 'tree)
+               (eq state 'hidden)
+               (or members (custom-unloaded-widget-p widget)))
+          (custom-browse-insert-prefix prefix)
+          (push (widget-create-child-and-convert
+                 widget 'custom-browse-visibility 
+                 ;; :tag-glyph "plus"
+                 :tag "+")
+                buttons)
+          (insert "-- ")
+          ;; (widget-glyph-insert nil "-- " "horizontal")
+          (push (widget-create-child-and-convert
+                 widget 'custom-browse-group-tag)
+                buttons)
+          (insert " " tag "\n")
+          (widget-put widget :buttons buttons))
+         ((and (eq custom-buffer-style 'tree)
+               (zerop (length members)))
+          (custom-browse-insert-prefix prefix)
+          (insert "[ ]-- ")
+          ;; (widget-glyph-insert nil "[ ]" "empty")
+          ;; (widget-glyph-insert nil "-- " "horizontal")
+          (push (widget-create-child-and-convert 
+                 widget 'custom-browse-group-tag)
+                buttons)
+          (insert " " tag "\n")
+          (widget-put widget :buttons buttons))
+         ((eq custom-buffer-style 'tree)
+          (custom-browse-insert-prefix prefix)
+          (custom-load-widget widget)
+          (if (zerop (length members))
+              (progn 
+                (custom-browse-insert-prefix prefix)
+                (insert "[ ]-- ")
+                ;; (widget-glyph-insert nil "[ ]" "empty")
+                ;; (widget-glyph-insert nil "-- " "horizontal")
+                (push (widget-create-child-and-convert 
+                       widget 'custom-browse-group-tag)
+                      buttons)
+                (insert " " tag "\n")
+                (widget-put widget :buttons buttons))
+            (push (widget-create-child-and-convert 
+                   widget 'custom-browse-visibility 
+                   ;; :tag-glyph "minus"
+                   :tag "-")
+                  buttons)
+            (insert "-\\ ")
+            ;; (widget-glyph-insert nil "-\\ " "top")
+            (push (widget-create-child-and-convert 
+                   widget 'custom-browse-group-tag)
+                  buttons)
+            (insert " " tag "\n")
+            (widget-put widget :buttons buttons)
+            (message "Creating group...")
+            (let* ((members (custom-sort-items members
+                             custom-browse-sort-alphabetically
+                             custom-browse-order-groups))
+                   (prefixes (widget-get widget :custom-prefixes))
+                   (custom-prefix-list (custom-prefix-add symbol prefixes))
+                   (extra-prefix (if (widget-get widget :custom-last)
+                                     "   "
+                                   " | "))
+                   (prefix (concat prefix extra-prefix))
+                   children entry)
+              (while members
+                (setq entry (car members)
+                      members (cdr members))
+                (push (widget-create-child-and-convert
+                       widget (nth 1 entry)
+                       :group widget
+                       :tag (custom-unlispify-tag-name (nth 0 entry))
+                       :custom-prefixes custom-prefix-list
+                       :custom-level (1+ level)
+                       :custom-last (null members)
+                       :value (nth 0 entry)
+                       :custom-prefix prefix)
+                      children))
+              (widget-put widget :children (reverse children)))
+            (message "Creating group...done")))
+         ;; Nested style.
+         ((eq state 'hidden)
+          ;; Create level indicator.
+          (unless (eq custom-buffer-style 'links)
+            (insert-char ?\  (* custom-buffer-indent (1- level)))
+            (insert "-- "))
+          ;; Create tag.
+          (let ((begin (point)))
+            (insert tag)
+            (widget-specify-sample widget begin (point)))
+          (insert " group: ")
+          ;; Create link/visibility indicator.
+          (if (eq custom-buffer-style 'links)
+              (push (widget-create-child-and-convert
+                     widget 'custom-group-link 
+                     :tag "Go to Group"
+                     symbol)
+                    buttons)
+            (push (widget-create-child-and-convert 
+                   widget 'custom-group-visibility
+                   :help-echo "Show members of this group."
+                   :action 'custom-toggle-parent
+                   (not (eq state 'hidden)))
+                  buttons))
+          (insert " \n")
+          ;; Create magic button.
+          (let ((magic (widget-create-child-and-convert
+                        widget 'custom-magic nil)))
+            (widget-put widget :custom-magic magic)
+            (push magic buttons))
+          ;; Update buttons.
+          (widget-put widget :buttons buttons)
+          ;; Insert documentation.
+          (if (and (eq custom-buffer-style 'links) (> level 1))
+              (widget-put widget :documentation-indent 0))
+          (widget-default-format-handler widget ?h))
+         ;; Nested style.
+         (t                            ;Visible.
+          ;; Add parent groups references above the group.
+          (if t    ;;; This should test that the buffer
+                   ;;; was made to display a group.
+              (when (eq level 1)
+                (if (custom-add-parent-links widget
+                                             "Go to parent group:")
+                    (insert "\n"))))
+          ;; Create level indicator.
+          (insert-char ?\  (* custom-buffer-indent (1- level)))
+          (insert "/- ")
+          ;; Create tag.
+          (let ((start (point)))
+            (insert tag)
+            (widget-specify-sample widget start (point)))
+          (insert " group: ")
+          ;; Create visibility indicator.
+          (unless (eq custom-buffer-style 'links)
+            (insert "--------")
+            (push (widget-create-child-and-convert 
+                   widget 'visibility
+                   :help-echo "Hide members of this group."
+                   :action 'custom-toggle-parent
+                   (not (eq state 'hidden)))
+                  buttons)
+            (insert " "))
+          ;; Create more dashes.
+          ;; Use 76 instead of 75 to compensate for the temporary "<"
+          ;; added by `widget-insert'.  
+          (insert-char ?- (- 76 (current-column)
+                             (* custom-buffer-indent level)))
+          (insert "\\\n")
+          ;; Create magic button.
+          (let ((magic (widget-create-child-and-convert
+                        widget 'custom-magic 
+                        :indent 0
+                        nil)))
+            (widget-put widget :custom-magic magic)
+            (push magic buttons))
+          ;; Update buttons.
+          (widget-put widget :buttons buttons)
+          ;; Insert documentation.
+          (widget-default-format-handler widget ?h)
+          ;; Parent groups.
+          (if nil  ;;; This should test that the buffer
+                   ;;; was not made to display a group.
+              (when (eq level 1)
+                (insert-char ?\  custom-buffer-indent)
+                (custom-add-parent-links widget)))
+          (custom-add-see-also widget 
+                               (make-string (* custom-buffer-indent level)
+                                            ?\ ))
+          ;; Members.
+          (message "Creating group...")
+          (custom-load-widget widget)
+          (let* ((members (custom-sort-items members
+                                             custom-buffer-sort-alphabetically
+                                             custom-buffer-order-groups))
+                 (prefixes (widget-get widget :custom-prefixes))
+                 (custom-prefix-list (custom-prefix-add symbol prefixes))
+                 (length (length members))
+                 (count 0)
+                 (children (mapcar (lambda (entry)
+                                     (widget-insert "\n")
+                                     (message "\
+Creating group members... %2d%%"
+                                              (/ (* 100.0 count) length))
+                                     (setq count (1+ count))
+                                     (prog1
+                                         (widget-create-child-and-convert
+                                          widget (nth 1 entry)
+                                          :group widget
+                                          :tag (custom-unlispify-tag-name
+                                                (nth 0 entry))
+                                          :custom-prefixes custom-prefix-list
+                                          :custom-level (1+ level)
+                                          :value (nth 0 entry))
+                                       (unless (eq (preceding-char) ?\n)
+                                         (widget-insert "\n"))))
+                                   members)))
+            (message "Creating group magic...")
+            (mapcar 'custom-magic-reset children)
+            (message "Creating group state...")
+            (widget-put widget :children children)
+            (custom-group-state-update widget)
+            (message "Creating group... done"))
+          ;; End line
+          (insert "\n")
+          (insert-char ?\  (* custom-buffer-indent (1- level)))
+          (insert "\\- " (widget-get widget :tag) " group end ")
+          (insert-char ?- (- 75 (current-column) (* custom-buffer-indent level)))
+          (insert "/\n")))))

 
 (defvar custom-group-menu 
 
 (defvar custom-group-menu 

-  '(("Set" custom-group-set
+  '(("Set for Current Session" custom-group-set

      (lambda (widget)
        (eq (widget-get widget :custom-state) 'modified)))
      (lambda (widget)
        (eq (widget-get widget :custom-state) 'modified)))

-    ("Save" custom-group-save
+    ("Save for Future Sessions" custom-group-save

      (lambda (widget)
        (memq (widget-get widget :custom-state) '(modified set))))
     ("Reset to Current" custom-group-reset-current
      (lambda (widget)
        (memq (widget-get widget :custom-state) '(modified set))))
     ("Reset to Current" custom-group-reset-current


@@ -2307,18 +3048,28 @@ Optional EVENT is the location for the menu."
   (custom-magic-reset widget))
 
 ;;; The `custom-save-all' Function.
   (custom-magic-reset widget))
 
 ;;; The `custom-save-all' Function.

-
-(defcustom custom-file "~/.emacs"
+;;;###autoload
+(defcustom custom-file nil

   "File used for storing customization information.
   "File used for storing customization information.

-If you change this from the default \"~/.emacs\" you need to
-explicitly load that file for the settings to take effect."
-  :type 'file
+The default is nil, which means to use your init file
+as specified by `user-init-file'.  If you specify some other file,
+you need to explicitly load that file for the settings to take effect."
+  :type '(choice (const :tag "Your Emacs init file" nil) file)

   :group 'customize)
 
   :group 'customize)
 

+(defun custom-file ()
+  "Return the file name for saving customizations."
+  (setq custom-file
+       (or custom-file
+           user-init-file
+           (read-file-name "File for customizations: "
+                           "~/" nil nil ".emacs"))))
+

 (defun custom-save-delete (symbol)
 (defun custom-save-delete (symbol)

-  "Delete the call to SYMBOL form `custom-file'.
+  "Delete the call to SYMBOL from `custom-file'.

 Leave point at the location of the call, or after the last expression."
 Leave point at the location of the call, or after the last expression."

-  (set-buffer (find-file-noselect custom-file))
+  (let ((default-major-mode))
+    (set-buffer (find-file-noselect (custom-file))))

   (goto-char (point-min))
   (catch 'found
     (while t
   (goto-char (point-min))
   (catch 'found
     (while t


@@ -2403,7 +3154,7 @@ Leave point at the location of the call, or after the last expression."
        (princ "\n")))))
 
 ;;;###autoload
        (princ "\n")))))
 
 ;;;###autoload

-(defun custom-save-customized ()
+(defun customize-save-customized ()

   "Save all user options which have been set in this session."
   (interactive)
   (mapatoms (lambda (symbol)
   "Save all user options which have been set in this session."
   (interactive)
   (mapatoms (lambda (symbol)


@@ -2421,52 +3172,22 @@ Leave point at the location of the call, or after the last expression."
 ;;;###autoload
 (defun custom-save-all ()
   "Save all customizations in `custom-file'."
 ;;;###autoload
 (defun custom-save-all ()
   "Save all customizations in `custom-file'."

-  (custom-save-variables)
-  (custom-save-faces)
-  (save-excursion
-    (set-buffer (find-file-noselect custom-file))
-    (save-buffer)))
+  (let ((inhibit-read-only t))
+    (custom-save-variables)
+    (custom-save-faces)
+    (save-excursion
+      (let ((default-major-mode nil))
+       (set-buffer (find-file-noselect (custom-file))))
+      (save-buffer))))

 
 ;;; The Customize Menu.
 
 ;;; Menu support
 
 
 ;;; The Customize Menu.
 
 ;;; Menu support
 

-(unless (string-match "XEmacs" emacs-version)
-  (defconst custom-help-menu '("Customize"
-                              ["Update menu..." custom-menu-update t]
-                              ["Group..." customize-group t]
-                              ["Variable..." customize-variable t]
-                              ["Face..." customize-face t]
-                              ["Saved..." customize-saved t]
-                              ["Set..." customize-customized t]
-                              ["Apropos..." customize-apropos t])
-    ;; This menu should be identical to the one defined in `menu-bar.el'. 
-    "Customize menu")
-
-  (defun custom-menu-reset ()
-    "Reset customize menu."
-    (remove-hook 'custom-define-hook 'custom-menu-reset)
-    (define-key global-map [menu-bar help-menu customize-menu]
-      (cons (car custom-help-menu)
-           (easy-menu-create-keymaps (car custom-help-menu)
-                                     (cdr custom-help-menu)))))
-
-  (defun custom-menu-update (event)
-    "Update customize menu."
-    (interactive "e")
-    (add-hook 'custom-define-hook 'custom-menu-reset)
-    (let* ((emacs (widget-apply '(custom-group) :custom-menu 'emacs))
-          (menu `(,(car custom-help-menu)
-                  ,emacs
-                  ,@(cdr (cdr custom-help-menu)))))
-      (let ((map (easy-menu-create-keymaps (car menu) (cdr menu))))
-       (define-key global-map [menu-bar help-menu customize-menu]
-         (cons (car menu) map))))))
-

 (defcustom custom-menu-nesting 2
   "Maximum nesting in custom menus."
   :type 'integer
 (defcustom custom-menu-nesting 2
   "Maximum nesting in custom menus."
   :type 'integer

-  :group 'customize)
+  :group 'custom-menu)

 
 (defun custom-face-menu-create (widget symbol)
   "Ignoring WIDGET, create a menu entry for customization face SYMBOL."
 
 (defun custom-face-menu-create (widget symbol)
   "Ignoring WIDGET, create a menu entry for customization face SYMBOL."


@@ -2519,9 +3240,9 @@ The menu is in a format applicable to `easy-menu-define'."
             (< (length (get symbol 'custom-group)) widget-menu-max-size))
        (let ((custom-prefix-list (custom-prefix-add symbol
                                                     custom-prefix-list))
             (< (length (get symbol 'custom-group)) widget-menu-max-size))
        (let ((custom-prefix-list (custom-prefix-add symbol
                                                     custom-prefix-list))

-             (members (sort (get symbol 'custom-group)
-                            custom-menu-sort-predicate)))
-         (put symbol 'custom-group members)
+             (members (custom-sort-items (get symbol 'custom-group)
+                                         custom-menu-sort-alphabetically
+                                         custom-menu-order-groups)))

          (custom-load-symbol symbol)
          `(,(custom-unlispify-menu-entry symbol t)
            ,item
          (custom-load-symbol symbol)
          `(,(custom-unlispify-menu-entry symbol t)
            ,item


@@ -2554,32 +3275,60 @@ The format is suitable for use with `easy-menu-define'."
 
 (defvar custom-mode-map nil
   "Keymap for `custom-mode'.")
 
 (defvar custom-mode-map nil
   "Keymap for `custom-mode'.")

-  
+

 (unless custom-mode-map
   (setq custom-mode-map (make-sparse-keymap))
   (set-keymap-parent custom-mode-map widget-keymap)
 (unless custom-mode-map
   (setq custom-mode-map (make-sparse-keymap))
   (set-keymap-parent custom-mode-map widget-keymap)

-  (define-key custom-mode-map "q" 'bury-buffer))
-
-(easy-menu-define custom-mode-customize-menu 
-    custom-mode-map
-  "Menu used to customize customization buffers."
-  (customize-menu-create 'customize))
-
-(easy-menu-define custom-mode-menu 
+  (suppress-keymap custom-mode-map)
+  (define-key custom-mode-map " " 'scroll-up)
+  (define-key custom-mode-map "\177" 'scroll-down)
+  (define-key custom-mode-map "q" 'bury-buffer)
+  (define-key custom-mode-map "u" 'Custom-goto-parent)
+  (define-key custom-mode-map "n" 'widget-forward)
+  (define-key custom-mode-map "p" 'widget-backward)
+  (define-key custom-mode-map [mouse-1] 'Custom-move-and-invoke))
+
+(defun Custom-move-and-invoke (event)
+  "Move to where you click, and if it is an active field, invoke it."
+  (interactive "e")
+  (mouse-set-point event)
+  (if (widget-event-point event)
+      (let* ((pos (widget-event-point event))
+            (button (get-char-property pos 'button)))
+       (if button
+           (widget-button-click event)))))
+
+(easy-menu-define Custom-mode-menu 

     custom-mode-map
   "Menu used in customization buffers."
   `("Custom"
     custom-mode-map
   "Menu used in customization buffers."
   `("Custom"

-    ["Set" custom-set t]
-    ["Save" custom-save t]
-    ["Reset to Current" custom-reset-current t]
-    ["Reset to Saved" custom-reset-saved t]
-    ["Reset to Standard Settings" custom-reset-standard t]
+    ,(customize-menu-create 'customize)
+    ["Set" Custom-set t]
+    ["Save" Custom-save t]
+    ["Reset to Current" Custom-reset-current t]
+    ["Reset to Saved" Custom-reset-saved t]
+    ["Reset to Standard Settings" Custom-reset-standard t]

     ["Info" (Info-goto-node "(custom)The Customization Buffer") t]))
 
     ["Info" (Info-goto-node "(custom)The Customization Buffer") t]))
 

+(defun Custom-goto-parent ()
+  "Go to the parent group listed at the top of this buffer.
+If several parents are listed, go to the first of them."
+  (interactive)
+  (save-excursion
+    (goto-char (point-min))
+    (if (search-forward "\nGo to parent group: " nil t)
+       (let* ((button (get-char-property (point) 'button))
+              (parent (downcase (widget-get  button :tag))))
+         (customize-group parent)))))
+

 (defcustom custom-mode-hook nil
   "Hook called when entering custom-mode."
   :type 'hook
 (defcustom custom-mode-hook nil
   "Hook called when entering custom-mode."
   :type 'hook

-  :group 'customize)
+  :group 'custom-buffer )
+
+(defun custom-state-buffer-message (widget)
+  (if (eq (widget-get (widget-get widget :parent) :custom-state) 'modified)
+      (message "To install your edits, invoke [State] and choose the Set operation")))

 
 (defun custom-mode ()
   "Major mode for editing customization buffers.
 
 (defun custom-mode ()
   "Major mode for editing customization buffers.


@@ -2588,13 +3337,16 @@ The following commands are available:
 
 Move to next button or editable field.     \\[widget-forward]
 Move to previous button or editable field. \\[widget-backward]
 
 Move to next button or editable field.     \\[widget-forward]
 Move to previous button or editable field. \\[widget-backward]

-Invoke button under the mouse pointer.     \\[widget-button-click]
+\\<widget-field-keymap>\
+Complete content of editable text field.   \\[widget-complete]
+\\<custom-mode-map>\
+Invoke button under the mouse pointer.     \\[Custom-move-and-invoke]

 Invoke button under point.                \\[widget-button-press]
 Invoke button under point.                \\[widget-button-press]

-Set all modifications.                    \\[custom-set]
-Make all modifications default.                   \\[custom-save]
-Reset all modified options.               \\[custom-reset-current]
-Reset all modified or set options.        \\[custom-reset-saved]
-Reset all options.                        \\[custom-reset-standard]
+Set all modifications.                    \\[Custom-set]
+Make all modifications default.                   \\[Custom-save]
+Reset all modified options.               \\[Custom-reset-current]
+Reset all modified or set options.        \\[Custom-reset-saved]
+Reset all options.                        \\[Custom-reset-standard]

 
 Entry to this mode calls the value of `custom-mode-hook'
 if that value is non-nil."
 
 Entry to this mode calls the value of `custom-mode-hook'
 if that value is non-nil."


@@ -2602,9 +3354,14 @@ if that value is non-nil."
   (setq major-mode 'custom-mode
        mode-name "Custom")
   (use-local-map custom-mode-map)
   (setq major-mode 'custom-mode
        mode-name "Custom")
   (use-local-map custom-mode-map)

-  (easy-menu-add custom-mode-customize-menu)
-  (easy-menu-add custom-mode-menu)
+  (easy-menu-add Custom-mode-menu)

   (make-local-variable 'custom-options)
   (make-local-variable 'custom-options)

+  (make-local-variable 'widget-documentation-face)
+  (setq widget-documentation-face 'custom-documentation-face)
+  (make-local-variable 'widget-button-face)
+  (setq widget-button-face 'custom-button-face)
+  (make-local-hook 'widget-edit-functions)
+  (add-hook 'widget-edit-functions 'custom-state-buffer-message nil t)

   (run-hooks 'custom-mode-hook))
 
 ;;; The End.
   (run-hooks 'custom-mode-hook))
 
 ;;; The End.