]> code.delx.au - gnu-emacs/blobdiff - lisp/custom.el
(eshell-windows-shell-file): Look for command.com, not command.exe.
[gnu-emacs] / lisp / custom.el
index a0aeeca659df7c965a1fda48ca8f72754ccc5c92..0831535f181f56206931674a21d849fee89a5514 100644 (file)
@@ -1,7 +1,7 @@
 ;;; custom.el --- tools for declaring and initializing options
 ;;
 ;;; custom.el --- tools for declaring and initializing options
 ;;
-;; Copyright (C) 1996, 1997, 1999, 2001, 2002, 2004
-;;  Free Software Foundation, Inc.
+;; Copyright (C) 1996, 1997, 1999, 2001, 2002, 2003, 2004,
+;;   2005 Free Software Foundation, Inc.
 ;;
 ;; Author: Per Abrahamsen <abraham@dina.kvl.dk>
 ;; Maintainer: FSF
 ;;
 ;; Author: Per Abrahamsen <abraham@dina.kvl.dk>
 ;; Maintainer: FSF
@@ -21,8 +21,8 @@
 
 ;; You should have received a copy of the GNU General Public License
 ;; along with GNU Emacs; see the file COPYING.  If not, write to the
 
 ;; You should have received a copy of the GNU General Public License
 ;; along with GNU Emacs; see the file COPYING.  If not, write to the
-;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
-;; Boston, MA 02111-1307, USA.
+;; Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+;; Boston, MA 02110-1301, USA.
 
 ;;; Commentary:
 ;;
 
 ;;; Commentary:
 ;;
@@ -76,6 +76,28 @@ if any, or VALUE."
                 (eval (car (get symbol 'saved-value)))
               (eval value)))))
 
                 (eval (car (get symbol 'saved-value)))
               (eval value)))))
 
+(defun custom-initialize-safe-set (symbol value)
+  "Like `custom-initialize-set', but catches errors.
+If an error occurs during initialization, SYMBOL is set to nil
+and no error is thrown.  This is meant for use in pre-loaded files
+where some variables or functions used to compute VALUE may not yet
+be defined.  You can then re-evaluate VALUE in startup.el, for instance
+using `custom-reevaluate-setting'."
+  (condition-case nil
+      (custom-initialize-set symbol value)
+    (error (set-default symbol nil))))
+
+(defun custom-initialize-safe-default (symbol value)
+  "Like `custom-initialize-default', but catches errors.
+If an error occurs during initialization, SYMBOL is set to nil
+and no error is thrown.  This is meant for use in pre-loaded files
+where some variables or functions used to compute VALUE may not yet
+be defined.  You can then re-evaluate VALUE in startup.el, for instance
+using `custom-reevaluate-setting'."
+  (condition-case nil
+      (custom-initialize-default symbol value)
+    (error (set-default symbol nil))))
+
 (defun custom-initialize-reset (symbol value)
   "Initialize SYMBOL based on VALUE.
 Set the symbol, using its `:set' function (or `set-default' if it has none).
 (defun custom-initialize-reset (symbol value)
   "Initialize SYMBOL based on VALUE.
 Set the symbol, using its `:set' function (or `set-default' if it has none).
@@ -115,14 +137,9 @@ For the standard setting, use `set-default'."
 DEFAULT should be an expression to evaluate to compute the default value,
 not the default value itself.
 
 DEFAULT should be an expression to evaluate to compute the default value,
 not the default value itself.
 
-DEFAULT is stored as SYMBOL's value in the standard theme.  See
-`custom-known-themes' for a list of known themes.  For backwards
-compatibility, DEFAULT is also stored in SYMBOL's property
+DEFAULT is stored as SYMBOL's standard value, in SYMBOL's property
 `standard-value'.  At the same time, SYMBOL's property `force-value' is
 set to nil, as the value is no longer rogue."
 `standard-value'.  At the same time, SYMBOL's property `force-value' is
 set to nil, as the value is no longer rogue."
-  ;; Remember the standard setting.  The value should be in the standard
-  ;; theme, not in this property.  However, his would require changeing
-  ;; the C source of defvar and others as well...
   (put symbol 'standard-value (list default))
   ;; Maybe this option was rogue in an earlier version.  It no longer is.
   (when (get symbol 'force-value)
   (put symbol 'standard-value (list default))
   ;; Maybe this option was rogue in an earlier version.  It no longer is.
   (when (get symbol 'force-value)
@@ -168,7 +185,7 @@ set to nil, as the value is no longer rogue."
     ;; Do the actual initialization.
     (unless custom-dont-initialize
       (funcall initialize symbol default)))
     ;; Do the actual initialization.
     (unless custom-dont-initialize
       (funcall initialize symbol default)))
-  (push (cons 'defvar symbol) current-load-list)
+  (push symbol current-load-list)
   (run-hooks 'custom-define-hook)
   symbol)
 
   (run-hooks 'custom-define-hook)
   symbol)
 
@@ -246,6 +263,13 @@ The following keywords are meaningful:
        Specifies that SYMBOL should be set after the list of variables
         VARIABLES when both have been customized.
 
        Specifies that SYMBOL should be set after the list of variables
         VARIABLES when both have been customized.
 
+If SYMBOL has a local binding, then this form affects the local
+binding.  This is normally not what you want.  Thus, if you need
+to load a file defining variables with this form, or with
+`defvar' or `defconst', you should always load that file
+_outside_ any bindings for these variables.  \(`defvar' and
+`defconst' behave similarly in this respect.)
+
 Read the section about customization in the Emacs Lisp manual for more
 information."
   ;; It is better not to use backquote in this file,
 Read the section about customization in the Emacs Lisp manual for more
 information."
   ;; It is better not to use backquote in this file,
@@ -280,9 +304,18 @@ The following KEYWORDs are defined:
 
 SPEC should be an alist of the form ((DISPLAY ATTS)...).
 
 
 SPEC should be an alist of the form ((DISPLAY ATTS)...).
 
-The first element of SPEC where the DISPLAY matches the frame
-is the one that takes effect in that frame.  The ATTRs in this
-element take effect; the other elements are ignored, on that frame.
+In the first element, DISPLAY can be :default.  The ATTS in that
+element then act as defaults for all the following elements.
+
+Aside from that, DISPLAY specifies conditions to match some or
+all frames.  For each frame, the first element of SPEC where the
+DISPLAY conditions are satisfied is the one that applies to that
+frame.  The ATTRs in this element take effect, and the following
+elements are ignored, on that frame.
+
+In the last element, DISPLAY can be t.  That element applies to a
+frame if none of the previous elements (except the :default if
+any) did.
 
 ATTS is a list of face attributes followed by their values:
   (ATTR VALUE ATTR VALUE...)
 
 ATTS is a list of face attributes followed by their values:
   (ATTR VALUE ATTR VALUE...)
@@ -291,15 +324,17 @@ The possible attributes are `:family', `:width', `:height', `:weight',
 `:slant', `:underline', `:overline', `:strike-through', `:box',
 `:foreground', `:background', `:stipple', `:inverse-video', and `:inherit'.
 
 `:slant', `:underline', `:overline', `:strike-through', `:box',
 `:foreground', `:background', `:stipple', `:inverse-video', and `:inherit'.
 
-DISPLAY can either be the symbol t, which will match all frames, or an
-alist of the form \((REQ ITEM...)...).  For the DISPLAY to match a
-FRAME, the REQ property of the frame must match one of the ITEM.  The
-following REQ are defined:
+DISPLAY can be `:default' (only in the first element), the symbol
+t (only in the last element) to match all frames, or an alist of
+conditions of the form \(REQ ITEM...).  For such an alist to
+match a frame, each of the conditions must be satisfied, meaning
+that the REQ property of the frame must match one of the
+corresponding ITEMs.  These are the defined REQ values:
 
 `type' (the value of `window-system')
   Under X, in addition to the values `window-system' can take,
 
 `type' (the value of `window-system')
   Under X, in addition to the values `window-system' can take,
-  `motif', `lucid' and `x-toolkit' are allowed, and match when
-  the Motif toolkit, Lucid toolkit, or any X toolkit is in use.
+  `motif', `lucid', `gtk' and `x-toolkit' are allowed, and match when
+  the Motif toolkit, Lucid toolkit, GTK toolkit or any X toolkit is in use.
 
 `class' (the frame's color support)
   Should be one of `color', `grayscale', or `mono'.
 
 `class' (the frame's color support)
   Should be one of `color', `grayscale', or `mono'.
@@ -311,6 +346,11 @@ following REQ are defined:
   Should be an integer, it is compared with the result of
   `display-color-cells'.
 
   Should be an integer, it is compared with the result of
   `display-color-cells'.
 
+`supports' (only match frames that support the specified face attributes)
+  Should be a list of face attributes.  See the documentation for
+  the function `display-supports-face-attributes-p' for more
+  information on exactly how testing is done.
+
 Read the section about customization in the Emacs Lisp manual for more
 information."
   ;; It is better not to use backquote in this file,
 Read the section about customization in the Emacs Lisp manual for more
 information."
   ;; It is better not to use backquote in this file,
@@ -463,8 +503,10 @@ both appear in constructs like `custom-set-variables'."
 (defun custom-add-option (symbol option)
   "To the variable SYMBOL add OPTION.
 
 (defun custom-add-option (symbol option)
   "To the variable SYMBOL add OPTION.
 
-If SYMBOL is a hook variable, OPTION should be a hook member.
-For other types variables, the effect is undefined."
+If SYMBOL's custom type is a hook, OPTION should be a hook member.
+If SYMBOL's custom type is an alist, OPTION specifies a symbol
+to offer to the user as a possible key in the alist.
+For other custom types, this has no effect."
   (let ((options (get symbol 'custom-options)))
     (unless (member option options)
       (put symbol 'custom-options (cons option options)))))
   (let ((options (get symbol 'custom-options)))
     (unless (member option options)
       (put symbol 'custom-options (cons option options)))))
@@ -493,7 +535,9 @@ LOAD should be either a library file name, or a feature name."
 
 ;; This test is also in the C code of `user-variable-p'.
 (defun custom-variable-p (variable)
 
 ;; This test is also in the C code of `user-variable-p'.
 (defun custom-variable-p (variable)
-  "Return non-nil if VARIABLE is a custom variable."
+  "Return non-nil if VARIABLE is a custom variable.
+This recursively follows aliases."
+  (setq variable (indirect-variable variable))
   (or (get variable 'standard-value)
       (get variable 'custom-autoload)))
 
   (or (get variable 'standard-value)
       (get variable 'custom-autoload)))
 
@@ -535,104 +579,15 @@ LOAD should be either a library file name, or a feature name."
              ;; and it is not in load-history yet.
              ((equal load "cus-edit"))
              (t (condition-case nil (load load) (error nil))))))))
              ;; and it is not in load-history yet.
              ((equal load "cus-edit"))
              (t (condition-case nil (load load) (error nil))))))))
-
+\f
 (defvar custom-known-themes '(user standard)
 (defvar custom-known-themes '(user standard)
-   "Themes that have been define with `deftheme'.
+   "Themes that have been defined with `deftheme'.
 The default value is the list (user standard).  The theme `standard'
 contains the Emacs standard settings from the original Lisp files.  The
 The default value is the list (user standard).  The theme `standard'
 contains the Emacs standard settings from the original Lisp files.  The
-theme `user' contains all the the settings the user customized and saved.
+theme `user' contains all the settings the user customized and saved.
 Additional themes declared with the `deftheme' macro will be added to
 the front of this list.")
 
 Additional themes declared with the `deftheme' macro will be added to
 the front of this list.")
 
-(defun custom-declare-theme (theme feature &optional doc &rest args)
-  "Like `deftheme', but THEME is evaluated as a normal argument.
-FEATURE is the feature this theme provides.  This symbol is created
-from THEME by `custom-make-theme-feature'."
-  (add-to-list 'custom-known-themes theme)
-  (put theme 'theme-feature feature)
-  (when doc
-    (put theme 'theme-documentation doc))
-  (while args
-    (let ((arg (car args)))
-      (setq args (cdr args))
-      (unless (symbolp arg)
-       (error "Junk in args %S" args))
-      (let ((keyword arg)
-           (value (car args)))
-       (unless args
-         (error "Keyword %s is missing an argument" keyword))
-       (setq args (cdr args))
-       (cond ((eq keyword :short-description)
-              (put theme 'theme-short-description value))
-             ((eq keyword :immediate)
-              (put theme 'theme-immediate value))
-             ((eq keyword :variable-set-string)
-              (put theme 'theme-variable-set-string value))
-             ((eq keyword :variable-reset-string)
-              (put theme 'theme-variable-reset-string value))
-             ((eq keyword :face-set-string)
-              (put theme 'theme-face-set-string value))
-             ((eq keyword :face-reset-string)
-              (put theme 'theme-face-reset-string value)))))))
-
-(defmacro deftheme (theme &optional doc &rest args)
-  "Declare custom theme THEME.
-The optional argument DOC is a doc string describing the theme.
-The remaining arguments should have the form
-
-   [KEYWORD VALUE]...
-
-The following KEYWORD's are defined:
-
-:short-description
-       VALUE is a short (one line) description of the theme.  If not
-       given, DOC is used.
-:immediate
-       If VALUE is non-nil, variables specified in this theme are set
-       immediately when loading the theme.
-:variable-set-string
-       VALUE is a string used to indicate that a variable takes its
-       setting from this theme.  It is passed to FORMAT with the name
-       of the theme as an additional argument.  If not given, a
-       generic description is used.
-:variable-reset-string
-       VALUE is a string used in the case a variable has been forced
-       to its value in this theme.  It is passed to FORMAT with the
-       name of the theme as an additional argument.  If not given, a
-       generic description is used.
-:face-set-string
-       VALUE is a string used to indicate that a face takes its
-       setting from this theme.  It is passed to FORMAT with the name
-       of the theme as an additional argument.  If not given, a
-       generic description is used.
-:face-reset-string
-       VALUE is a string used in the case a face has been forced to
-       its value in this theme.  It is passed to FORMAT with the name
-       of the theme as an additional argument.  If not given, a
-       generic description is used.
-
-Any theme `foo' should be defined in a file called `foo-theme.el';
-see `custom-make-theme-feature' for more information."
-  (let ((feature (custom-make-theme-feature theme)))
-    ;; It is better not to use backquote in this file,
-    ;; because that makes a bootstrapping problem
-    ;; if you need to recompile all the Lisp files using interpreted code.
-    (nconc (list 'custom-declare-theme
-                (list 'quote theme)
-                (list 'quote feature)
-                doc) args)))
-
-(defun custom-make-theme-feature (theme)
-  "Given a symbol THEME, create a new symbol by appending \"-theme\".
-Store this symbol in the `theme-feature' property of THEME.
-Calling `provide-theme' to provide THEME actually puts `THEME-theme'
-into `features'.
-
-This allows for a file-name convention for autoloading themes:
-Every theme X has a property `provide-theme' whose value is \"X-theme\".
-\(require-theme X) then attempts to load the file `X-theme.el'."
-  (intern (concat (symbol-name theme) "-theme")))
-
 (defsubst custom-theme-p (theme)
   "Non-nil when THEME has been defined."
   (memq theme custom-known-themes))
 (defsubst custom-theme-p (theme)
   "Non-nil when THEME has been defined."
   (memq theme custom-known-themes))
@@ -645,13 +600,15 @@ Every theme X has a property `provide-theme' whose value is \"X-theme\".
 ;;; Initializing.
 
 (defun custom-push-theme (prop symbol theme mode value)
 ;;; Initializing.
 
 (defun custom-push-theme (prop symbol theme mode value)
-  "Add (THEME MODE VALUE) to the list in property PROP of SYMBOL.
-If the first element in that list is already (THEME ...),
-discard it first.
+  "Record a value for face or variable SYMBOL in custom theme THEME.
+PROP is`theme-face' for a face, `theme-value' for a variable.
+The value is specified by (THEME MODE VALUE), which is interpreted
+by `custom-theme-value'.
 
 MODE can be either the symbol `set' or the symbol `reset'.  If it is the
 symbol `set', then VALUE is the value to use.  If it is the symbol
 
 MODE can be either the symbol `set' or the symbol `reset'.  If it is the
 symbol `set', then VALUE is the value to use.  If it is the symbol
-`reset', then VALUE is the mode to query instead.
+`reset', then VALUE is another theme, whose value for this face or
+variable should be used.
 
 In the following example for the variable `goto-address-url-face', the
 theme `subtle-hacker' uses the same value for the variable as the theme
 
 In the following example for the variable `goto-address-url-face', the
 theme `subtle-hacker' uses the same value for the variable as the theme
@@ -684,11 +641,20 @@ This records values for the `standard' and the `gnome2' themes.
 The user has not customized the face; had he done that,
 the list would contain an entry for the `user' theme, too.
 See `custom-known-themes' for a list of known themes."
 The user has not customized the face; had he done that,
 the list would contain an entry for the `user' theme, too.
 See `custom-known-themes' for a list of known themes."
-  (let ((old (get symbol prop)))
-    (if (eq (car-safe (car-safe old)) theme)
-        (setq old (cdr old)))
-    (put symbol prop (cons (list theme mode value) old))))
-
+  (let* ((old (get symbol prop))
+        (setting (assq theme old)))
+    ;; Alter an existing theme-setting for the symbol,
+    ;; or add a new one.
+    (if setting
+       (progn
+         (setcar (cdr setting) mode)
+         (setcar (cddr setting) value))
+      (put symbol prop (cons (list theme mode value) old)))
+    ;; Record, for each theme, all its settings.
+    (put theme 'theme-settings
+        (cons (list prop symbol theme mode value)
+              (get theme 'theme-settings)))))
+\f
 (defvar custom-local-buffer nil
   "Non-nil, in a Customization buffer, means customize a specific buffer.
 If this variable is non-nil, it should be a buffer,
 (defvar custom-local-buffer nil
   "Non-nil, in a Customization buffer, means customize a specific buffer.
 If this variable is non-nil, it should be a buffer,
@@ -698,84 +664,92 @@ in every Customization buffer.")
 (put 'custom-local-buffer 'permanent-local t)
 
 (defun custom-set-variables (&rest args)
 (put 'custom-local-buffer 'permanent-local t)
 
 (defun custom-set-variables (&rest args)
-  "Initialize variables according to user preferences.
-The settings are registered as theme `user'.
+  "Install user customizations of variable values specified in ARGS.
+These settings are registered as theme `user'.
 The arguments should each be a list of the form:
 
 The arguments should each be a list of the form:
 
-  (SYMBOL VALUE [NOW [REQUEST [COMMENT]]])
+  (SYMBOL EXP [NOW [REQUEST [COMMENT]]])
 
 
-The unevaluated VALUE is stored as the saved value for SYMBOL.
-If NOW is present and non-nil, VALUE is also evaluated and bound as
-the default value for the SYMBOL.
+This stores EXP (without evaluating it) as the saved value for SYMBOL.
+If NOW is present and non-nil, then also evaluate EXP and set
+the default value for the SYMBOL to the value of EXP.
 
 
-REQUEST is a list of features we must 'require for SYMBOL.
+REQUEST is a list of features we must require in order to
+handle SYMBOL properly.
 COMMENT is a comment string about SYMBOL."
   (apply 'custom-theme-set-variables 'user args))
 
 COMMENT is a comment string about SYMBOL."
   (apply 'custom-theme-set-variables 'user args))
 
+(defun custom-reevaluate-setting (symbol)
+  "Reset the value of SYMBOL by re-evaluating its saved or standard value.
+Use the :set function to do so.  This is useful for customizable options
+that are defined before their standard value can really be computed.
+E.g. dumped variables whose default depends on run-time information."
+  (funcall (or (get symbol 'custom-set) 'set-default)
+          symbol
+          (eval (car (or (get symbol 'saved-value) (get symbol 'standard-value))))))
+
 (defun custom-theme-set-variables (theme &rest args)
 (defun custom-theme-set-variables (theme &rest args)
-  "Initialize variables according to settings specified by args.
-Records the settings as belonging to THEME.
+  "Initialize variables for theme THEME according to settings in ARGS.
+Each of the arguments in ARGS should be a list of this form:
 
 
-The arguments should be a list where each entry has the form:
+  (SYMBOL EXP [NOW [REQUEST [COMMENT]]])
 
 
-  (SYMBOL VALUE [NOW [REQUEST [COMMENT]]])
+This stores EXP (without evaluating it) as the saved value for SYMBOL.
+If NOW is present and non-nil, then also evaluate EXP and set
+the default value for the SYMBOL to the value of EXP.
 
 
-The unevaluated VALUE is stored as the saved value for SYMBOL.
-If NOW is present and non-nil, VALUE is also evaluated and bound as
-the default value for the SYMBOL.
-REQUEST is a list of features we must 'require for SYMBOL.
+REQUEST is a list of features we must require in order to
+handle SYMBOL properly.
 COMMENT is a comment string about SYMBOL.
 
 Several properties of THEME and SYMBOL are used in the process:
 
 COMMENT is a comment string about SYMBOL.
 
 Several properties of THEME and SYMBOL are used in the process:
 
-If THEME property `theme-immediate' is non-nil, this is equivalent of
-providing the NOW argument to all symbols in the argument list: SYMBOL
-is bound to the evaluated VALUE.  The only difference is SYMBOL property
+If THEME's property `theme-immediate' is non-nil, this is equivalent of
+providing the NOW argument to all symbols in the argument list:
+evaluate each EXP and set the corresponding SYMBOL.  However,
+there's a difference in the handling of SYMBOL's property
 `force-value': if NOW is non-nil, SYMBOL's property `force-value' is set to
 the symbol `rogue', else if THEME's property `theme-immediate' is non-nil,
 `force-value': if NOW is non-nil, SYMBOL's property `force-value' is set to
 the symbol `rogue', else if THEME's property `theme-immediate' is non-nil,
-FACE's property `force-face' is set to the symbol `immediate'.
+SYMBOL's property `force-value' is set to the symbol `immediate'.
 
 
-VALUE itself is saved unevaluated as SYMBOL property `saved-value' and
+EXP itself is saved unevaluated as SYMBOL property `saved-value' and
 in SYMBOL's list property `theme-value' \(using `custom-push-theme')."
   (custom-check-theme theme)
 in SYMBOL's list property `theme-value' \(using `custom-push-theme')."
   (custom-check-theme theme)
-  (let ((immediate (get theme 'theme-immediate)))
-    (setq args
-         (sort args
-               (lambda (a1 a2)
-                 (let* ((sym1 (car a1))
-                        (sym2 (car a2))
-                        (1-then-2 (memq sym1 (get sym2 'custom-dependencies)))
-                        (2-then-1 (memq sym2 (get sym1 'custom-dependencies))))
-                   (cond ((and 1-then-2 2-then-1)
-                          (error "Circular custom dependency between `%s' and `%s'"
-                                 sym1 sym2))
-                         (2-then-1 nil)
-                         ;; Put symbols with :require last.  The macro
-                         ;; define-minor-mode generates a defcustom
-                         ;; with a :require and a :set, where the
-                         ;; setter function calls the mode function.
-                         ;; Putting symbols with :require last ensures
-                         ;; that the mode function will see other
-                         ;; customized values rather than default
-                         ;; values.
-                         (t (nth 3 a2)))))))
-    (while args
-      (let ((entry (car args)))
-       (if (listp entry)
-           (let* ((symbol (nth 0 entry))
-                  (value (nth 1 entry))
-                  (now (nth 2 entry))
-                  (requests (nth 3 entry))
-                  (comment (nth 4 entry))
-                   set)
-             (when requests
-               (put symbol 'custom-requests requests)
-               (mapc 'require requests))
-             (setq set (or (get symbol 'custom-set) 'custom-set-default))
-             (put symbol 'saved-value (list value))
-             (put symbol 'saved-variable-comment comment)
-              (custom-push-theme 'theme-value symbol theme 'set value)
-             ;; Allow for errors in the case where the setter has
+  (setq args
+       (sort args
+             (lambda (a1 a2)
+               (let* ((sym1 (car a1))
+                      (sym2 (car a2))
+                      (1-then-2 (memq sym1 (get sym2 'custom-dependencies)))
+                      (2-then-1 (memq sym2 (get sym1 'custom-dependencies))))
+                 (cond ((and 1-then-2 2-then-1)
+                        (error "Circular custom dependency between `%s' and `%s'"
+                               sym1 sym2))
+                       (2-then-1 nil)
+                       ;; Put minor modes and symbols with :require last.
+                       ;; Putting minor modes last ensures that the mode
+                       ;; function will see other customized values rather
+                       ;; than default values.
+                       (t (or (nth 3 a2)
+                               (eq (get sym2 'custom-set)
+                                   'custom-set-minor-mode))))))))
+  (while args
+    (let ((entry (car args)))
+      (if (listp entry)
+         (let* ((symbol (indirect-variable (nth 0 entry)))
+                (value (nth 1 entry))
+                (now (nth 2 entry))
+                (requests (nth 3 entry))
+                (comment (nth 4 entry))
+                set)
+           (when requests
+             (put symbol 'custom-requests requests)
+             (mapc 'require requests))
+           (setq set (or (get symbol 'custom-set) 'custom-set-default))
+           (put symbol 'saved-value (list value))
+           (put symbol 'saved-variable-comment comment)
+           (custom-push-theme 'theme-value symbol theme 'set value)
+           ;; Allow for errors in the case where the setter has
            ;; changed between versions, say, but let the user know.
            (condition-case data
                (cond (now
            ;; changed between versions, say, but let the user know.
            (condition-case data
                (cond (now
@@ -787,18 +761,18 @@ in SYMBOL's list property `theme-value' \(using `custom-push-theme')."
                       (funcall set symbol (eval value))))
              (error
               (message "Error setting %s: %s" symbol data)))
                       (funcall set symbol (eval value))))
              (error
               (message "Error setting %s: %s" symbol data)))
-             (setq args (cdr args))
-             (and (or now (default-boundp symbol))
-                  (put symbol 'variable-comment comment)))
-         ;; Old format, a plist of SYMBOL VALUE pairs.
-         (message "Warning: old format `custom-set-variables'")
-         (ding)
-         (sit-for 2)
-         (let ((symbol (nth 0 args))
-               (value (nth 1 args)))
-           (put symbol 'saved-value (list value))
-            (custom-push-theme 'theme-value symbol theme 'set value))
-         (setq args (cdr (cdr args))))))))
+           (setq args (cdr args))
+           (and (or now (default-boundp symbol))
+                (put symbol 'variable-comment comment)))
+       ;; Old format, a plist of SYMBOL VALUE pairs.
+       (message "Warning: old format `custom-set-variables'")
+       (ding)
+       (sit-for 2)
+       (let ((symbol (indirect-variable (nth 0 args)))
+             (value (nth 1 args)))
+         (put symbol 'saved-value (list value))
+         (custom-push-theme 'theme-value symbol theme 'set value))
+       (setq args (cdr (cdr args)))))))
 
 (defun custom-set-default (variable value)
   "Default :set function for a customizable variable.
 
 (defun custom-set-default (variable value)
   "Default :set function for a customizable variable.
@@ -818,8 +792,8 @@ but if `custom-local-buffer' is non-nil,
 this sets the local binding in that buffer instead."
   (if custom-local-buffer
       (with-current-buffer custom-local-buffer
 this sets the local binding in that buffer instead."
   (if custom-local-buffer
       (with-current-buffer custom-local-buffer
-       (funcall variable (or value 0)))
-    (funcall variable (or value 0))))
+       (funcall variable (if value 1 0)))
+    (funcall variable (if value 1 0))))
 
 (defun custom-quote (sexp)
   "Quote SEXP iff it is not self quoting."
 
 (defun custom-quote (sexp)
   "Quote SEXP iff it is not self quoting."
@@ -887,101 +861,222 @@ Return non-nil iff the `customized-value' property actually changed."
       (put symbol 'customized-value nil))
     ;; Changed?
     (not (equal customized (get symbol 'customized-value)))))
       (put symbol 'customized-value nil))
     ;; Changed?
     (not (equal customized (get symbol 'customized-value)))))
+\f
+;;; Defining themes.
 
 
-;;; Theme Manipulation
+;; deftheme is used at the beginning of the file that records a theme.
+
+(defmacro deftheme (theme &optional doc &rest args)
+  "Declare custom theme THEME.
+The optional argument DOC is a doc string describing the theme.
+The remaining arguments should have the form
+
+   [KEYWORD VALUE]...
+
+The following KEYWORD's are defined:
+
+:short-description
+       VALUE is a short (one line) description of the theme.  If not
+       given, DOC is used.
+:immediate
+       If VALUE is non-nil, variables specified in this theme are set
+       immediately when loading the theme.
+:variable-set-string
+       VALUE is a string used to indicate that a variable takes its
+       setting from this theme.  It is passed to FORMAT with the name
+       of the theme as an additional argument.  If not given, a
+       generic description is used.
+:variable-reset-string
+       VALUE is a string used in the case a variable has been forced
+       to its value in this theme.  It is passed to FORMAT with the
+       name of the theme as an additional argument.  If not given, a
+       generic description is used.
+:face-set-string
+       VALUE is a string used to indicate that a face takes its
+       setting from this theme.  It is passed to FORMAT with the name
+       of the theme as an additional argument.  If not given, a
+       generic description is used.
+:face-reset-string
+       VALUE is a string used in the case a face has been forced to
+       its value in this theme.  It is passed to FORMAT with the name
+       of the theme as an additional argument.  If not given, a
+       generic description is used.
+
+Any theme `foo' should be defined in a file called `foo-theme.el';
+see `custom-make-theme-feature' for more information."
+  (let ((feature (custom-make-theme-feature theme)))
+    ;; It is better not to use backquote in this file,
+    ;; because that makes a bootstrapping problem
+    ;; if you need to recompile all the Lisp files using interpreted code.
+    (nconc (list 'custom-declare-theme
+                (list 'quote theme)
+                (list 'quote feature)
+                doc)
+          args)))
+
+(defun custom-declare-theme (theme feature &optional doc &rest args)
+  "Like `deftheme', but THEME is evaluated as a normal argument.
+FEATURE is the feature this theme provides.  This symbol is created
+from THEME by `custom-make-theme-feature'."
+  (add-to-list 'custom-known-themes theme)
+  (put theme 'theme-feature feature)
+  (when doc
+    (put theme 'theme-documentation doc))
+  (while args
+    (let ((arg (car args)))
+      (setq args (cdr args))
+      (unless (symbolp arg)
+       (error "Junk in args %S" args))
+      (let ((keyword arg)
+           (value (car args)))
+       (unless args
+         (error "Keyword %s is missing an argument" keyword))
+       (setq args (cdr args))
+       (cond ((eq keyword :short-description)
+              (put theme 'theme-short-description value))
+             ((eq keyword :immediate)
+              (put theme 'theme-immediate value))
+             ((eq keyword :variable-set-string)
+              (put theme 'theme-variable-set-string value))
+             ((eq keyword :variable-reset-string)
+              (put theme 'theme-variable-reset-string value))
+             ((eq keyword :face-set-string)
+              (put theme 'theme-face-set-string value))
+             ((eq keyword :face-reset-string)
+              (put theme 'theme-face-reset-string value)))))))
+
+(defun custom-make-theme-feature (theme)
+  "Given a symbol THEME, create a new symbol by appending \"-theme\".
+Store this symbol in the `theme-feature' property of THEME.
+Calling `provide-theme' to provide THEME actually puts `THEME-theme'
+into `features'.
+
+This allows for a file-name convention for autoloading themes:
+Every theme X has a property `provide-theme' whose value is \"X-theme\".
+\(require-theme X) then attempts to load the file `X-theme.el'."
+  (intern (concat (symbol-name theme) "-theme")))
+\f
+;;; Loading themes.
+
+;; The variable and face settings of a theme are recorded in
+;; the `theme-settings' property of the theme name.
+;; This property's value is a list of elements, each of the form
+;; (PROP SYMBOL THEME MODE VALUE), where PROP is `theme-value' or `theme-face'
+;; and SYMBOL is the face or variable name.
+;; THEME is the theme name itself; that's redundant, but simplifies things.
+;; MODE is `set' or `reset'.
+;; If MODE is `set', then VALUE is an expression that specifies the
+;; theme's setting for SYMBOL.
+;; If MODE is `reset', then VALUE is another theme,
+;; and it means to use the value from that theme.
+
+;; Each variable has a `theme-value' property that describes all the
+;; settings of enabled themes that apply to it.
+;; Each face name has a `theme-face' property that describes all the
+;; settings of enabled themes that apply to it.
+;; The property value is a list of settings, each with the form
+;; (THEME MODE VALUE).  THEME, MODE and VALUE are as above.
+;; Each of these lists is ordered by decreasing theme precedence.
+;; Thus, the first element is always the one that is in effect.
+
+;; Disabling a theme removes its settings from the `theme-value' and
+;; `theme-face' properties, but the theme's own `theme-settings'
+;; property remains unchanged.
+
+;; Loading a theme implicitly enables it.  Enabling a theme adds its
+;; settings to the symbols' `theme-value' and `theme-face' properties,
+;; or moves them to the front of those lists if they're already present.
 
 (defvar custom-loaded-themes nil
 
 (defvar custom-loaded-themes nil
-  "Themes in the order they are loaded.")
+  "Custom themes that have been loaded.")
+
+(defcustom custom-theme-directory
+  (if (eq system-type 'ms-dos)
+        ;; MS-DOS cannot have initial dot.
+        "~/_emacs.d/"
+      "~/.emacs.d/")
+  "Directory in which Custom theme files should be written.
+`require-theme' searches this directory in addition to load-path.
+The command `customize-create-theme' writes the files it produces
+into this directory."
+  :type 'string
+  :group 'customize
+  :version "22.1")
 
 (defun custom-theme-loaded-p (theme)
 
 (defun custom-theme-loaded-p (theme)
-  "Return non-nil when THEME has been loaded."
+  "Return non-nil if THEME has been loaded."
   (memq theme custom-loaded-themes))
 
   (memq theme custom-loaded-themes))
 
+(defvar custom-enabled-themes '(user)
+  "Custom themes currently enabled, highest precedence first.
+The first one is always `user'.")
+
+(defun custom-theme-enabled-p (theme)
+  "Return non-nil if THEME is enabled."
+  (memq theme custom-enabled-themes))
+
 (defun provide-theme (theme)
   "Indicate that this file provides THEME.
 (defun provide-theme (theme)
   "Indicate that this file provides THEME.
-Add THEME to `custom-loaded-themes' and `provide' whatever
-is stored in THEME's property `theme-feature'.
+Add THEME to `custom-loaded-themes', and `provide' whatever
+feature name is stored in THEME's property `theme-feature'.
 
 
-Usually the theme-feature property contains a symbol created
+Usually the `theme-feature' property contains a symbol created
 by `custom-make-theme-feature'."
   (custom-check-theme theme)
   (provide (get theme 'theme-feature))
 by `custom-make-theme-feature'."
   (custom-check-theme theme)
   (provide (get theme 'theme-feature))
-  (setq custom-loaded-themes (nconc (list theme) custom-loaded-themes)))
+  (push theme custom-loaded-themes)
+  ;; Loading a theme also installs its settings,
+  ;; so mark it as "enabled".
+  (push theme custom-enabled-themes)
+  ;; `user' must always be the highest-precedence enabled theme.
+  ;; Make that remain true.  (This has the effect of making user settings
+  ;; override the ones just loaded, too.)
+  (custom-enable-theme 'user))
 
 (defun require-theme (theme)
 
 (defun require-theme (theme)
-  "Try to load a theme by requiring its feature.
-THEME's feature is stored in THEME's `theme-feature' property.
+  "Try to load a theme's settings from its file.
+This also enables the theme; use `custom-disable-theme' to disable it."
+
+  ;; THEME's feature is stored in THEME's `theme-feature' property.
+  ;; Usually the `theme-feature' property contains a symbol created
+  ;; by `custom-make-theme-feature'.
 
 
-Usually the `theme-feature' property contains a symbol created
-by `custom-make-theme-feature'."
   ;; Note we do no check for validity of the theme here.
   ;; This allows to pull in themes by a file-name convention
   ;; Note we do no check for validity of the theme here.
   ;; This allows to pull in themes by a file-name convention
-  (require (or (get theme 'theme-feature)
-              (custom-make-theme-feature theme))))
-
-(defun custom-remove-theme (spec-alist theme)
-  "Delete all elements from SPEC-ALIST whose car is THEME."
-  (let ((elt (assoc theme spec-alist)))
-    (while elt
-       (setq spec-alist (delete elt spec-alist)
-             elt (assoc theme spec-alist))))
-  spec-alist)
-
-(defun custom-do-theme-reset (theme)
-  "Undo all settings defined by THEME.
-
-A variable remains unchanged if its property `theme-value' does not
-contain a value for THEME.  A face remains unchanged if its property
-`theme-face' does not contain a value for THEME.  In either case, all
-settings for THEME are removed from the property and the variable or
-face is set to the `user' theme.
-
-See `custom-known-themes' for a list of known themes."
-  (let (spec-list)
-    (mapatoms (lambda (symbol)
-               ;; This works even if symbol is both a variable and a
-               ;; face.
-                (setq spec-list (get symbol 'theme-value))
-                (when spec-list
-                  (put symbol 'theme-value (custom-remove-theme spec-list theme))
-                  (custom-theme-reset-internal symbol 'user))
-                (setq spec-list (get symbol 'theme-face))
-                (when spec-list
-                  (put symbol 'theme-face (custom-remove-theme spec-list theme))
-                  (custom-theme-reset-internal-face symbol 'user))))))
+  (let ((load-path (if (file-directory-p custom-theme-directory)
+                      (cons custom-theme-directory load-path)
+                    load-path)))
+    (require (or (get theme 'theme-feature)
+                (custom-make-theme-feature theme)))))
+\f
+;;; How to load and enable various themes as part of `user'.
 
 (defun custom-theme-load-themes (by-theme &rest body)
   "Load the themes specified by BODY.
 
 (defun custom-theme-load-themes (by-theme &rest body)
   "Load the themes specified by BODY.
-Record them as required by theme BY-THEME.  BODY is a sequence of either
+Record them as required by theme BY-THEME.
+
+BODY is a sequence of either
 
 THEME
 
 THEME
-       BY-THEME requires THEME
+        Load THEME and enable it.
 \(reset THEME)
        Undo all the settings made by THEME
 \(hidden THEME)
 \(reset THEME)
        Undo all the settings made by THEME
 \(hidden THEME)
-       Require THEME but hide it from the user
+       Load THEME but do not enable it.
 
 All the themes loaded for BY-THEME are recorded in BY-THEME's property
 
 All the themes loaded for BY-THEME are recorded in BY-THEME's property
-`theme-loads-themes'.  Any theme loaded with the hidden predicate will
-be given the property `theme-hidden' unless it has been loaded before.
-Whether a theme has been loaded before is determined by the function
-`custom-theme-loaded-p'."
+`theme-loads-themes'."
   (custom-check-theme by-theme)
   (custom-check-theme by-theme)
-  (let ((theme)
-       (themes-loaded (get by-theme 'theme-loads-themes)))
-    (while theme
-      (setq theme (car body)
-           body (cdr body))
+  (let ((themes-loaded (get by-theme 'theme-loads-themes)))
+    (dolist (theme body)
       (cond ((and (consp theme) (eq (car theme) 'reset))
       (cond ((and (consp theme) (eq (car theme) 'reset))
-            (custom-do-theme-reset (cadr theme)))
+            (custom-disable-theme (cadr theme)))
            ((and (consp theme) (eq (car theme) 'hidden))
             (require-theme (cadr theme))
            ((and (consp theme) (eq (car theme) 'hidden))
             (require-theme (cadr theme))
-            (unless (custom-theme-loaded-p (cadr theme))
-              (put (cadr theme) 'theme-hidden t)))
+            (custom-disable-theme (cadr theme)))
            (t
            (t
-            (require-theme theme)
-            (put theme 'theme-hidden nil)))
-      (setq themes-loaded (nconc (list theme) themes-loaded)))
+            (require-theme theme)))
+      (push theme themes-loaded))
     (put by-theme 'theme-loads-themes themes-loaded)))
 
 (defun custom-load-themes (&rest body)
     (put by-theme 'theme-loads-themes themes-loaded)))
 
 (defun custom-load-themes (&rest body)
@@ -989,82 +1084,127 @@ Whether a theme has been loaded before is determined by the function
 
 See `custom-theme-load-themes' for more information on BODY."
   (apply 'custom-theme-load-themes 'user body))
 
 See `custom-theme-load-themes' for more information on BODY."
   (apply 'custom-theme-load-themes 'user body))
-
-; (defsubst copy-upto-last (elt list)
-;   "Copy all the elements of the list upto the last occurence of elt"
-;   ;; Is it faster to do more work in C than to do less in elisp?
-;   (nreverse (cdr (member elt (reverse list)))))
-
-(defun custom-theme-value (theme theme-spec-list)
-  "Determine the value for THEME defined by THEME-SPEC-LIST.
-Returns a list with the original value if found; nil otherwise.
-
-THEME-SPEC-LIST is an alist with themes as its key.  As new themes are
-installed, these are added to the front of THEME-SPEC-LIST.
-Each element has the form
+\f
+;;; Enabling and disabling loaded themes.
+
+(defun custom-enable-theme (theme)
+  "Reenable all variable and face settings defined by THEME.
+The newly enabled theme gets the highest precedence (after `user').
+If it is already enabled, just give it highest precedence (after `user')."
+  (let ((settings (get theme 'theme-settings)))
+    (dolist (s settings)
+      (let* ((prop (car s))
+            (symbol (cadr s))
+            (spec-list (get symbol prop)))
+       (put symbol prop (cons (cddr s) (assq-delete-all theme spec-list)))
+       (if (eq prop 'theme-value)
+           (custom-theme-recalc-variable symbol)
+         (custom-theme-recalc-face symbol)))))
+  (setq custom-enabled-themes
+        (cons theme (delq theme custom-enabled-themes)))
+  ;; `user' must always be the highest-precedence enabled theme.
+  (unless (eq theme 'user)
+    (custom-enable-theme 'user)))
+
+(defun custom-disable-theme (theme)
+  "Disable all variable and face settings defined by THEME.
+See `custom-known-themes' for a list of known themes."
+  (let ((settings (get theme 'theme-settings)))
+    (dolist (s settings)
+      (let* ((prop (car s))
+            (symbol (cadr s))
+            (spec-list (get symbol prop)))
+       (put symbol 'theme-value (assq-delete-all theme spec-list))
+       (if (eq prop 'theme-value)
+           (custom-theme-recalc-variable symbol)
+         (custom-theme-recalc-face symbol)))))
+  (setq custom-enabled-themes
+       (delq theme custom-enabled-themes)))
+
+(defun custom-theme-value (theme setting-list)
+  "Determine the value specified for THEME according to SETTING-LIST.
+Returns a list whose car is the specified value, if we
+find one; nil otherwise.
+
+SETTING-LIST is an alist with themes as its key.
+Each element has the form:
 
   \(THEME MODE VALUE)
 
 MODE is either the symbol `set' or the symbol `reset'.  See
 `custom-push-theme' for more information on the format of
 
   \(THEME MODE VALUE)
 
 MODE is either the symbol `set' or the symbol `reset'.  See
 `custom-push-theme' for more information on the format of
-THEME-SPEC-LIST."
+SETTING-LIST."
   ;; Note we do _NOT_ signal an error if the theme is unknown
   ;; it might have gone away without the user knowing.
   ;; Note we do _NOT_ signal an error if the theme is unknown
   ;; it might have gone away without the user knowing.
-  (let ((value (cdr (assoc theme theme-spec-list))))
-    (if value
-        (if (eq (car value) 'set)
-            (cdr value)
-          (custom-theme-value (cadr value) theme-spec-list)))))
-
-(defun custom-theme-variable-value (variable theme)
-  "Return (list value) indicating value of VARIABLE in THEME.
-If THEME does not define a value for VARIABLE, return nil.  The value
-definitions per theme are stored in VARIABLE's property `theme-value'.
-The actual work is done by function `custom-theme-value', which see.
-See `custom-push-theme' for more information on how these definitions
-are stored."
-  (custom-theme-value theme (get variable 'theme-value)))
-
-(defun custom-theme-reset-internal (symbol to-theme)
-  "Reset SYMBOL to the value defined by TO-THEME.
-If SYMBOL is not defined in TO-THEME, reset SYMBOL to the standard
-value.  See `custom-theme-variable-value'.  The standard value is
-stored in SYMBOL's property `standard-value'."
-  (let ((value (custom-theme-variable-value symbol to-theme))
-        was-in-theme)
-    (setq was-in-theme value)
-    (setq value (or value (get symbol 'standard-value)))
-    (when value
-      (put symbol 'saved-value was-in-theme)
-      (if (or (get 'force-value symbol) (default-boundp symbol))
-          (funcall (or (get symbol 'custom-set) 'set-default) symbol
-                   (eval (car value)))))
-    value))
-
+  (let ((elt (cdr (assoc theme setting-list))))
+    (if elt
+        (if (eq (car elt) 'set)
+            (cdr elt)
+         ;; `reset' means refer to another theme's value in the same alist.
+          (custom-theme-value (cadr elt) setting-list)))))
+
+(defun custom-variable-theme-value (variable)
+  "Return (list VALUE) indicating the custom theme value of VARIABLE.
+That is to say, it specifies what the value should be according to
+currently enabled custom themes.
+
+This function returns nil if no custom theme specifies a value for VARIABLE."
+  (let* ((theme-value (get variable 'theme-value)))
+    (if theme-value
+       (custom-theme-value (car (car theme-value)) theme-value))))
+
+(defun custom-face-theme-value (face)
+  "Return the face spec of FACE according to currently enabled custom themes.
+This function returns nil if no custom theme specifies anything for FACE."
+  (let* ((theme-value (get face 'theme-face)))
+    (if theme-value
+       (custom-theme-value (car (car theme-value)) theme-value))))
+
+(defun custom-theme-recalc-variable (variable)
+  "Set VARIABLE according to currently enabled custom themes."
+  (let ((valspec (custom-variable-theme-value variable)))
+    (when valspec
+      (put variable 'saved-value valspec))
+    (unless valspec
+      (setq valspec (get variable 'standard-value)))
+    (when valspec
+      (if (or (get 'force-value variable) (default-boundp variable))
+          (funcall (or (get variable 'custom-set) 'set-default) variable
+                   (eval (car valspec)))))))
+
+(defun custom-theme-recalc-face (face)
+  "Set FACE according to currently enabled custom themes."
+  (let ((spec (custom-face-theme-value face)))
+    (when spec
+      (put face 'save-face spec))
+    (unless spec
+      (setq spec (get face 'face-defface-spec)))
+    (when spec
+      (when (or (get face 'force-face) (facep face))
+       (unless (facep face)
+         (make-empty-face face))
+       (face-spec-set face spec)))))
+\f
 (defun custom-theme-reset-variables (theme &rest args)
 (defun custom-theme-reset-variables (theme &rest args)
-  "Reset the value of the variables to values previously defined.
-Associate this setting with THEME.
-
-ARGS is a list of lists of the form
+  "Reset the specs in THEME of some variables to their values in other themes.
+Each of the arguments ARGS has this form:
 
 
-    (VARIABLE TO-THEME)
+    (VARIABLE FROM-THEME)
 
 
-This means reset VARIABLE to its value in TO-THEME."
+This means reset VARIABLE to its value in FROM-THEME."
   (custom-check-theme theme)
   (custom-check-theme theme)
-  (mapcar '(lambda (arg)
-            (apply 'custom-theme-reset-internal arg)
-            (custom-push-theme 'theme-value (car arg) theme 'reset (cadr arg)))
-         args))
+  (dolist (arg args)
+    (custom-push-theme 'theme-value (car arg) theme 'reset (cadr arg))))
 
 (defun custom-reset-variables (&rest args)
 
 (defun custom-reset-variables (&rest args)
-    "Reset the value of the variables to values previously saved.
-This is the setting associated the `user' theme.
+  "Reset the specs of some variables to their values in certain themes.
+This creates settings in the `user' theme.
 
 
-ARGS is a list of lists of the form
+Each of the arguments ARGS has this form:
 
 
-    (VARIABLE TO-THEME)
+    (VARIABLE FROM-THEME)
 
 
-This means reset VARIABLE to its value in TO-THEME."
+This means reset VARIABLE to its value in FROM-THEME."
     (apply 'custom-theme-reset-variables 'user args))
 
 ;;; The End.
     (apply 'custom-theme-reset-variables 'user args))
 
 ;;; The End.
@@ -1076,5 +1216,5 @@ This means reset VARIABLE to its value in TO-THEME."
 
 (provide 'custom)
 
 
 (provide 'custom)
 
-;;; arch-tag: 041b6116-aabe-4f9a-902d-74092bc3dab2
+;; arch-tag: 041b6116-aabe-4f9a-902d-74092bc3dab2
 ;;; custom.el ends here
 ;;; custom.el ends here