-;;; cus-edit.el --- Tools for customizating Emacs and Lisp packages.
+;;; cus-edit.el --- tools for customizing Emacs and Lisp packages
;;
-;; Copyright (C) 1996, 1997, 1999 Free Software Foundation, Inc.
+;; Copyright (C) 1996, 1997, 1999, 2000, 2001 Free Software Foundation, Inc.
;;
;; Author: Per Abrahamsen <abraham@dina.kvl.dk>
;; Keywords: help, faces
-;; X-URL: http://www.dina.kvl.dk/~abraham/custom/ (probably obsolete)
;; This file is part of GNU Emacs.
(require 'cus-face)
(require 'wid-edit)
-(require 'easymenu)
(eval-when-compile
- (require 'cl)
(defvar custom-versions-load-alist)) ; from cus-load
(condition-case nil
(defun custom-quote (sexp)
"Quote SEXP iff it is not self quoting."
(if (or (memq sexp '(t nil))
- (and (symbolp sexp)
- (eq (aref (symbol-name sexp) 0) ?:))
+ (keywordp sexp)
(and (listp sexp)
(memq (car sexp) '(lambda)))
(stringp sexp)
regexp))
(defun custom-variable-prompt ()
- ;; Code stolen from `help.el'.
"Prompt for a variable, defaulting to the variable at point.
Return a list suitable for use in `interactive'."
(let ((v (variable-at-point))
(and (boundp symbol)
(or (get symbol 'custom-type)
(get symbol 'custom-loads)
- (user-variable-p symbol)))) t))
+ (get symbol 'standard-value)))) t))
(list (if (equal val "")
(if (symbolp v) v nil)
(intern val)))))
;;; Unlispify.
(defvar custom-prefix-list nil
- "List of prefixes that should be ignored by `custom-unlispify'")
+ "List of prefixes that should be ignored by `custom-unlispify'.")
(defcustom custom-unlispify-menu-entries t
"Display menu entries as words instead of symbols if non nil."
:type 'boolean)
(defun custom-unlispify-menu-entry (symbol &optional no-suffix)
- "Convert symbol into a menu entry."
+ "Convert SYMBOL into a menu entry."
(cond ((not custom-unlispify-menu-entries)
(symbol-name symbol))
((get symbol 'custom-tag)
:type 'boolean)
(defun custom-unlispify-tag-name (symbol)
- "Convert symbol into a menu entry."
+ "Convert SYMBOL into a menu entry."
(let ((custom-unlispify-menu-entries custom-unlispify-tag-names))
(custom-unlispify-menu-entry symbol t)))
(defun custom-prefix-add (symbol prefixes)
- ;; Addd SYMBOL to list of ignored PREFIXES.
+ "Add SYMBOL to list of ignored PREFIXES."
(cons (or (get symbol 'custom-prefix)
(concat (symbol-name symbol) "-"))
prefixes))
(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))))
+ (namea (nth 0 a)) (nameb (nth 0 b)))
(cond ((not order-groups)
;; Since we don't care about A and B order, maybe sort.
(when sort-alphabetically
"Set changes in all modified options."
(interactive)
(let ((children custom-options))
- (mapcar (lambda (child)
- (when (eq (widget-get child :custom-state) 'modified)
- (widget-apply child :custom-set)))
+ (mapc (lambda (child)
+ (when (eq (widget-get child :custom-state) 'modified)
+ (widget-apply child :custom-set)))
children)))
(defun Custom-save ()
"Set all modified group members and save them."
(interactive)
(let ((children custom-options))
- (mapcar (lambda (child)
- (when (memq (widget-get child :custom-state)
- '(modified set changed rogue))
- (widget-apply child :custom-save)))
+ (mapc (lambda (child)
+ (when (memq (widget-get child :custom-state)
+ '(modified set changed rogue))
+ (widget-apply child :custom-save)))
children))
(custom-save-all))
(defvar custom-reset-menu
'(("Current" . Custom-reset-current)
("Saved" . Custom-reset-saved)
- ("Standard Settings" . Custom-reset-standard))
+ ("Erase Customization (use 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
+Lisp function taking the widget as an element which will be called
when the action is chosen.")
(defun custom-reset (event)
"Reset all modified group members to their current value."
(interactive)
(let ((children custom-options))
- (mapcar (lambda (widget)
- (and (default-boundp (widget-value widget))
- (if (memq (widget-get widget :custom-state)
- '(modified changed))
- (widget-apply widget :custom-reset-current))))
+ (mapc (lambda (widget)
+ (and (default-boundp (widget-value widget))
+ (if (memq (widget-get widget :custom-state)
+ '(modified changed))
+ (widget-apply widget :custom-reset-current))))
children)))
(defun Custom-reset-saved (&rest ignore)
"Reset all modified or set group members to their saved value."
(interactive)
(let ((children custom-options))
- (mapcar (lambda (widget)
- (and (get (widget-value widget) 'saved-value)
- (if (memq (widget-get widget :custom-state)
- '(modified set changed rogue))
- (widget-apply widget :custom-reset-saved))))
+ (mapc (lambda (widget)
+ (and (get (widget-value widget) 'saved-value)
+ (if (memq (widget-get widget :custom-state)
+ '(modified set changed rogue))
+ (widget-apply widget :custom-reset-saved))))
children)))
(defun Custom-reset-standard (&rest ignore)
- "Reset all modified, set, or saved group members to their standard settings."
+ "Erase all customization (either current or saved) for the group members.
+The immediate result is to restore them to their standard settings.
+This operation eliminates any saved settings for the group members,
+making them as if they had never been customized at all."
(interactive)
(let ((children custom-options))
- (mapcar (lambda (widget)
- (and (get (widget-value widget) 'standard-value)
- (if (memq (widget-get widget :custom-state)
- '(modified set changed saved rogue))
- (widget-apply widget :custom-reset-standard))))
+ (mapc (lambda (widget)
+ (and (get (widget-value widget) 'standard-value)
+ (if (memq (widget-get widget :custom-state)
+ '(modified set changed saved rogue))
+ (widget-apply widget :custom-reset-standard))))
children)))
;;; The Customize Commands
(put var 'variable-comment comment))))
;;;###autoload
-(defun customize-set-variable (var val &optional comment)
+(defun customize-set-variable (variable value &optional comment)
"Set the default for VARIABLE to VALUE. VALUE is a Lisp object.
If VARIABLE has a `custom-set' property, that is used for setting
(interactive (custom-prompt-variable "Set variable: "
"Set customized value for %s to: "
current-prefix-arg))
- (funcall (or (get var 'custom-set) 'set-default) var val)
- (put var 'customized-value (list (custom-quote val)))
+ (funcall (or (get variable 'custom-set) 'set-default) variable value)
+ (put variable 'customized-value (list (custom-quote value)))
(cond ((string= comment "")
- (put var 'variable-comment nil)
- (put var 'customized-variable-comment nil))
+ (put variable 'variable-comment nil)
+ (put variable 'customized-variable-comment nil))
(comment
- (put var 'variable-comment comment)
- (put var 'customized-variable-comment comment))))
+ (put variable 'variable-comment comment)
+ (put variable 'customized-variable-comment comment))))
;;;###autoload
-(defun customize-save-variable (var val &optional comment)
+(defun customize-save-variable (var value &optional comment)
"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.
(interactive (custom-prompt-variable "Set and ave variable: "
"Set and save value for %s as: "
current-prefix-arg))
- (funcall (or (get var 'custom-set) 'set-default) var val)
- (put var 'saved-value (list (custom-quote val)))
+ (funcall (or (get var 'custom-set) 'set-default) var value)
+ (put var 'saved-value (list (custom-quote value)))
(cond ((string= comment "")
(put var 'variable-comment nil)
(put var 'saved-variable-comment nil))
(interactive "sCustomize options changed, since version (default all versions): ")
(if (equal since-version "")
- (setq since-version nil))
+ (setq since-version nil)
+ (unless (condition-case nil
+ (numberp (read since-version))
+ (error nil))
+ (signal 'wrong-type-argument (list 'numberp since-version))))
(unless since-version
(setq since-version customize-changed-options-previous-release))
(let ((found nil)
"*Customize Changed Options*"))))
(defun customize-version-lessp (version1 version2)
+ ;; Why are the versions strings, and given that they are, why aren't
+ ;; they converted to numbers and compared as such here? -- fx
+
;; 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)))
+ (string-match "\\([0-9]+\\)\\(\\.\\([0-9]+\\)\\)?" version1)
+ (setq major1 (read (or (match-string 1 version1)
+ "0")))
+ (setq minor1 (read (or (match-string 3 version1)
+ "0")))
+ (string-match "\\([0-9]+\\)\\(\\.\\([0-9]+\\)\\)?" version2)
+ (setq major2 (read (or (match-string 1 version2)
+ "0")))
+ (setq minor2 (read (or (match-string 3 version2)
+ "0")))
(or (< major1 major2)
(and (= major1 major2)
(< minor1 minor2)))))
"Customize SYMBOL, which should be a face name or nil.
If SYMBOL is nil, customize all faces."
(interactive (list (completing-read "Customize face: (default all) "
- obarray 'custom-facep)))
+ obarray 'custom-facep t)))
(if (or (null symbol) (and (stringp symbol) (zerop (length symbol))))
(custom-buffer-create (custom-sort-items
(mapcar (lambda (symbol)
;;;###autoload
(defun customize-face-other-window (&optional symbol)
- "Show customization buffer for FACE in other window."
+ "Show customization buffer for face SYMBOL in other window."
(interactive (list (completing-read "Customize face: "
- obarray 'custom-facep)))
+ obarray 'custom-facep t)))
(if (or (null symbol) (and (stringp symbol) (zerop (length symbol))))
()
(if (stringp symbol)
(const links))
:group 'custom-buffer)
-(defcustom custom-buffer-done-function 'bury-buffer
+;; If we pass BUFFER to `bury-buffer', the buffer isn't removed from
+;; the window.
+(defun custom-bury-buffer (buffer)
+ (bury-buffer))
+
+(defcustom custom-buffer-done-function 'custom-bury-buffer
"*Function called to remove a Custom buffer when the user is done with it.
Called with one argument, the buffer to remove."
- :type '(choice (function-item bury-buffer)
- (function-item kill-buffer)
+ :type '(choice (function-item :tag "Bury buffer" custom-bury-buffer)
+ (function-item :tag "Kill buffer" kill-buffer)
(function :tag "Other"))
:version "21.1"
:group 'custom-buffer)
:action 'Custom-reset-saved)
(widget-insert " ")
(widget-create 'push-button
- :tag "Reset to Standard"
+ :tag "Erase Customization"
:help-echo "\
-Reset all values in this buffer to their standard settings."
+Un-customize all values in this buffer. They get their standard settings."
:action 'Custom-reset-standard))
(widget-insert " ")
(widget-create 'push-button
:tag "Finish"
- :help-echo "Bury or kill the buffer."
+ :help-echo
+ (lambda (&rest ignore)
+ (cond
+ ((eq custom-buffer-done-function
+ 'custom-bury-buffer)
+ "Bury this buffer")
+ ((eq custom-buffer-done-function 'kill-buffer)
+ "Kill this buffer")
+ (t "Finish with this buffer")))
:action #'Custom-buffer-done)
(widget-insert "\n\n")
(message "Creating customization items...")
+ (buffer-disable-undo)
(setq custom-options
(if (= (length options) 1)
(mapcar (lambda (entry)
(let ((count 0)
(length (length options)))
(mapcar (lambda (entry)
- (prog2
- (message "Creating customization items ...%2d%%"
- (/ (* 100.0 count) length))
- (widget-create (nth 1 entry)
+ (prog2
+ (message "Creating customization items ...%2d%%"
+ (/ (* 100.0 count) length))
+ (widget-create (nth 1 entry)
:tag (custom-unlispify-tag-name
(nth 0 entry))
:value (nth 0 entry))
- (setq count (1+ count))
- (unless (eq (preceding-char) ?\n)
- (widget-insert "\n"))
- (widget-insert "\n")))
- options))))
+ (setq count (1+ count))
+ (unless (eq (preceding-char) ?\n)
+ (widget-insert "\n"))
+ (widget-insert "\n")))
+ options))))
(unless (eq (preceding-char) ?\n)
(widget-insert "\n"))
- (message "Creating customization items ...%2d%%done" 100)
+ (message "Creating customization items ...done")
(unless (eq custom-buffer-style 'tree)
- (mapcar 'custom-magic-reset custom-options))
+ (mapc 'custom-magic-reset custom-options))
(message "Creating customization setup...")
(widget-setup)
+ (buffer-enable-undo)
(goto-char (point-min))
(message "Creating customization buffer...done"))
'hidden)))
(defun custom-magic-value-create (widget)
- ;; Create compact status report for WIDGET.
+ "Create compact status report for WIDGET."
(let* ((parent (widget-get widget :parent))
(state (widget-get parent :custom-state))
(hidden (eq state 'hidden))
;;; The `custom' Widget.
(defface custom-button-face
- '((((type x) (class color)) ; Like default modeline
- (:box (:line-width 2 :style released-button) :background "lightgrey"))
+ '((((type x w32 mac) (class color)) ; Like default modeline
+ (:box (:line-width 2 :style released-button)
+ :background "lightgrey" :foreground "black"))
(t
nil))
"Face used for buttons in customization buffers."
:group 'custom-faces)
(defface custom-button-pressed-face
- '((((type x) (class color))
- (:box (:line-width 2 :style pressed-button) :background "lightgrey"))
+ '((((type x w32 mac) (class color))
+ (:box (:line-width 2 :style pressed-button)
+ :background "lightgrey" :foreground "black"))
(t
(:inverse-video t)))
"Face used for buttons in customization buffers."
:match (lambda (widget value) (symbolp value)))
(defun custom-convert-widget (widget)
- ;; Initialize :value and :tag from :args in WIDGET.
+ "Initialize :value and :tag from :args in WIDGET."
(let ((args (widget-get widget :args)))
(when args
(widget-put widget :value (widget-apply widget
((and (boundp 'preloaded-file-list)
(member load preloaded-file-list)))
((assoc load load-history))
- ((assoc (locate-library load) load-history))
+ ;; This was just (assoc (locate-library load) load-history)
+ ;; but has been optimized not to load locate-library
+ ;; if not necessary.
+ ((let (found (regexp (regexp-quote load)))
+ (dolist (loaded load-history)
+ (and (string-match regexp (car loaded))
+ (eq (locate-library load) (car loaded))
+ (setq found t)))
+ found))
+ ;; Without this, we would load cus-edit recursively.
+ ;; We are still loading it when we call this,
+ ;; and it is not in load-history yet.
+ ((equal load "cus-edit"))
(t
(condition-case nil
- ;; Without this, we would load cus-edit recursively.
- ;; We are still loading it when we call this,
- ;; and it is not in load-history yet.
- (or (equal load "cus-edit")
- (load-library load))
+ (load-library load)
(error nil))))))))
(defun custom-load-widget (widget)
(defun custom-comment-create (widget)
(let* ((null-comment (equal "" (widget-value widget))))
- (when (or (widget-get (widget-get widget :parent) :comment-shown)
- (not null-comment))
- (widget-default-create widget))))
+ (if (or (widget-get (widget-get widget :parent) :comment-shown)
+ (not null-comment))
+ (widget-default-create widget)
+ ;; `widget-default-delete' expects markers in these slots --
+ ;; maybe it shouldn't.
+ (widget-put widget :from (point-marker))
+ (widget-put widget :to (point-marker)))))
(defun custom-comment-hide (widget)
(widget-put (widget-get widget :parent) :comment-shown nil))
;;; The `custom-variable' Widget.
-(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)))
+;; When this was underlined blue, users confused it with a
+;; Mosaic-style hyperlink...
+(defface custom-variable-tag-face
+ `((((class color)
+ (background dark))
+ (:foreground "light blue" :bold t :height 1.2 :inherit variable-pitch))
+ (((class color)
+ (background light))
+ (:foreground "blue" :bold t :height 1.2 :inherit variable-pitch))
+ (t (:bold t)))
"Face used for unpushable variable tags."
:group 'custom-faces)
(get (widget-value widget) 'saved-variable-comment))
(memq (widget-get widget :custom-state)
'(modified set changed rogue)))))
- ("Reset to Standard Settings" custom-variable-reset-standard
+ ("Erase Customization" custom-variable-reset-standard
(lambda (widget)
(and (get (widget-value widget) 'standard-value)
(memq (widget-get widget :custom-state)
the menu entry, ACTION is the function to call on the widget when the
menu is selected, and FILTER is a predicate which takes a `custom-variable'
widget as an argument, and returns non-nil if ACTION is valid on that
-widget. If FILTER is nil, ACTION is always valid.")
+widget. If FILTER is nil, ACTION is always valid.")
(defun custom-variable-action (widget &optional event)
"Show the menu for `custom-variable' WIDGET.
(custom-redraw widget))
(defun custom-variable-edit-lisp (widget)
- "Edit the lisp representation of the value of WIDGET."
+ "Edit the Lisp representation of the value of WIDGET."
(widget-put widget :custom-state 'unknown)
(widget-put widget :custom-form 'lisp)
(custom-redraw widget))
(error "Cannot set hidden variable"))
((setq val (widget-apply child :validate))
(goto-char (widget-get val :from))
- (error "%s" (widget-get val :error)))
+ (error "Saving %s: %s" symbol (widget-get val :error)))
((memq form '(lisp mismatch))
(when (equal comment "")
(setq comment nil)
"Restore the saved value for the variable being edited by WIDGET."
(let* ((symbol (widget-value widget))
(set (or (get symbol 'custom-set) 'set-default))
- (comment-widget (widget-get widget :comment-widget))
(value (get symbol 'saved-value))
(comment (get symbol 'saved-variable-comment)))
(cond ((or value comment)
(custom-redraw widget)))
(defun custom-variable-reset-standard (widget)
- "Restore the standard setting for the variable being edited by WIDGET."
+ "Restore the standard setting for the variable being edited by WIDGET.
+This operation eliminates any saved setting for the variable,
+restoring it to the state of a variable that has never been customized."
(let* ((symbol (widget-value widget))
- (set (or (get symbol 'custom-set) 'set-default))
- (comment-widget (widget-get widget :comment-widget)))
+ (set (or (get symbol 'custom-set) 'set-default)))
(if (get symbol 'standard-value)
(funcall set symbol (eval (car (get symbol 'standard-value))))
(error "No standard setting known for %S" symbol))
:tag "Attributes"
:extra-offset 12
:button-args '(:help-echo "Control whether this attribute has any effect.")
+ :convert-widget 'custom-face-edit-convert-widget
:args (mapcar (lambda (att)
(list 'group
:inline t
(nth 1 att)))
custom-face-attributes))
+(defun custom-face-edit-convert-widget (widget)
+ "Convert :args as widget types in WIDGET."
+ (widget-put
+ widget
+ :args (mapcar (lambda (arg)
+ (widget-convert arg
+ :deactivate 'custom-face-edit-deactivate
+ :activate 'custom-face-edit-activate
+ :delete 'custom-face-edit-delete))
+ (widget-get widget :args)))
+ widget)
+
+(defun custom-face-edit-deactivate (widget)
+ "Make face widget WIDGET inactive for user modifications."
+ (unless (widget-get widget :inactive)
+ (let ((tag (custom-face-edit-attribute-tag widget))
+ (from (copy-marker (widget-get widget :from)))
+ (to (widget-get widget :to))
+ (value (widget-value widget))
+ (inhibit-read-only t)
+ (inhibit-modification-hooks t))
+ (save-excursion
+ (goto-char from)
+ (widget-default-delete widget)
+ (insert tag ": *\n")
+ (widget-put widget :inactive
+ (cons value (cons from (- (point) from))))))))
+
+(defun custom-face-edit-activate (widget)
+ "Make face widget WIDGET inactive for user modifications."
+ (let ((inactive (widget-get widget :inactive))
+ (inhibit-read-only t)
+ (inhibit-modification-hooks t))
+ (when (consp inactive)
+ (save-excursion
+ (goto-char (car (cdr inactive)))
+ (delete-region (point) (+ (point) (cdr (cdr inactive))))
+ (widget-put widget :inactive nil)
+ (widget-apply widget :create)
+ (widget-value-set widget (car inactive))
+ (widget-setup)))))
+
+(defun custom-face-edit-delete (widget)
+ "Remove widget from the buffer."
+ (let ((inactive (widget-get widget :inactive))
+ (inhibit-read-only t)
+ (inhibit-modification-hooks t))
+ (if (not inactive)
+ ;; Widget is alive, we don't have to do anything special
+ (widget-default-delete widget)
+ ;; WIDGET is already deleted because we did so to inactivate it;
+ ;; now just get rid of the label we put in its place.
+ (delete-region (car (cdr inactive))
+ (+ (car (cdr inactive)) (cdr (cdr inactive))))
+ (widget-put widget :inactive nil))))
+
+
+(defun custom-face-edit-attribute-tag (widget)
+ "Returns the first :tag property in WIDGET or one of its children."
+ (let ((tag (widget-get widget :tag)))
+ (or (and (not (equal tag "")) tag)
+ (let ((children (widget-get widget :children)))
+ (while (and (null tag) children)
+ (setq tag (custom-face-edit-attribute-tag (pop children))))
+ tag))))
+
;;; The `custom-display' Widget.
(define-widget 'custom-display 'menu-choice
;;; The `custom-face' Widget.
-(defface custom-face-tag-face '((t (:underline t)))
+(defface custom-face-tag-face
+ `((t (:bold t :height 1.2 :inherit variable-pitch)))
"Face used for face tags."
:group 'custom-faces)
"Customize face."
:sample-face 'custom-face-tag-face
:help-echo "Set or reset this face."
- :documentation-property '(lambda (face)
- (face-doc-string face))
+ :documentation-property #'face-doc-string
:value-create 'custom-face-value-create
:action 'custom-face-action
:custom-category 'face
(defconst custom-face-selected (widget-convert 'custom-face-selected)
"Converted version of the `custom-face-selected' widget.")
+(defun custom-filter-face-spec (spec filter-index &optional default-filter)
+ "Return a canonicalized version of SPEC using.
+FILTER-INDEX is the index in the entry for each attribute in
+`custom-face-attributes' at which the appropriate filter function can be
+found, and DEFAULT-FILTER is the filter to apply for attributes that
+don't specify one."
+ (mapcar (lambda (entry)
+ ;; Filter a single face-spec entry
+ (let ((tests (car entry))
+ (unfiltered-attrs
+ ;; Handle both old- and new-style attribute syntax
+ (if (listp (car (cdr entry)))
+ (car (cdr entry))
+ (cdr entry)))
+ (filtered-attrs nil))
+ ;; Filter each face attribute
+ (while unfiltered-attrs
+ (let* ((attr (pop unfiltered-attrs))
+ (pre-filtered-value (pop unfiltered-attrs))
+ (filter
+ (or (nth filter-index (assq attr custom-face-attributes))
+ default-filter))
+ (filtered-value
+ (if filter
+ (funcall filter pre-filtered-value)
+ pre-filtered-value)))
+ (push filtered-value filtered-attrs)
+ (push attr filtered-attrs)))
+ ;;
+ (list tests filtered-attrs)))
+ spec))
+
+(defun custom-pre-filter-face-spec (spec)
+ "Return SPEC changed as necessary for editing by the face customization widget.
+SPEC must be a full face spec."
+ (custom-filter-face-spec spec 2))
+
+(defun custom-post-filter-face-spec (spec)
+ "Return the customized SPEC in a form suitable for setting the face."
+ (custom-filter-face-spec spec 3))
+
(defun custom-face-value-create (widget)
"Create a list of the display specifications for WIDGET."
(let ((buttons (widget-get widget :buttons))
(t
;; Create tag.
(insert tag)
+ (widget-specify-sample widget begin (point))
(if (eq custom-buffer-style 'face)
(insert " ")
- (widget-specify-sample widget begin (point))
- (insert ": "))
+ (if (string-match "face\\'" tag)
+ (insert ":")
+ (insert " face: ")))
;; Sample.
(push (widget-create-child-and-convert widget 'item
:format "(%{%t%})"
(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)
+ (spec (or (get symbol 'customized-face)
+ (get symbol 'saved-face)
(get symbol 'face-defface-spec)
;; Attempt to construct it.
(list (list t (custom-face-attributes-get
;; 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 spec (custom-pre-filter-face-spec spec))
(setq edit (widget-create-child-and-convert
widget
(cond ((and (eq form 'selected)
(lambda (widget)
(or (get (widget-value widget) 'saved-face)
(get (widget-value widget) 'saved-face-comment))))
- ("Reset to Standard Setting" custom-face-reset-standard
+ ("Erase Customization" custom-face-reset-standard
(lambda (widget)
(get (widget-value widget) 'face-defface-spec)))
("---" ignore ignore)
the menu entry, ACTION is the function to call on the widget when the
menu is selected, and FILTER is a predicate which takes a `custom-face'
widget as an argument, and returns non-nil if ACTION is valid on that
-widget. If FILTER is nil, ACTION is always valid.")
+widget. If FILTER is nil, ACTION is always valid.")
(defun custom-face-edit-selected (widget)
"Edit selected attributes of the value of WIDGET."
(custom-redraw widget))
(defun custom-face-edit-lisp (widget)
- "Edit the lisp representation of the value of WIDGET."
+ "Edit the Lisp representation of the value of WIDGET."
(widget-put widget :custom-state 'unknown)
(widget-put widget :custom-form 'lisp)
(custom-redraw widget))
"Make the face attributes in WIDGET take effect."
(let* ((symbol (widget-value widget))
(child (car (widget-get widget :children)))
- (value (widget-value child))
+ (value (custom-post-filter-face-spec (widget-value child)))
(comment-widget (widget-get widget :comment-widget))
(comment (widget-value comment-widget)))
(when (equal comment "")
;; Make the comment invisible by hand if it's empty
(custom-comment-hide comment-widget))
(put symbol 'customized-face value)
- (face-spec-set symbol value)
+ (if (face-spec-choose value)
+ (face-spec-set symbol value)
+ ;; face-set-spec ignores empty attribute lists, so just give it
+ ;; something harmless instead.
+ (face-spec-set symbol '((t :foreground unspecified))))
(put symbol 'customized-face-comment comment)
(put symbol 'face-comment comment)
(custom-face-state-set widget)
"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))
+ (value (custom-post-filter-face-spec (widget-value child)))
(comment-widget (widget-get widget :comment-widget))
(comment (widget-value comment-widget)))
(when (equal comment "")
(setq comment nil)
;; Make the comment invisible by hand if it's empty
(custom-comment-hide comment-widget))
- (face-spec-set symbol value)
+ (if (face-spec-choose value)
+ (face-spec-set symbol value)
+ ;; face-set-spec ignores empty attribute lists, so just give it
+ ;; something harmless instead.
+ (face-spec-set symbol '((t :foreground unspecified))))
(put symbol 'saved-face value)
(put symbol 'customized-face nil)
(put symbol 'face-comment comment)
(custom-redraw-magic widget)))
(defun custom-face-reset-standard (widget)
- "Restore WIDGET to the face's standard settings."
+ "Restore WIDGET to the face's standard settings.
+This operation eliminates any saved setting for the face,
+restoring it to the state of a face that has never been customized."
(let* ((symbol (widget-value widget))
(child (car (widget-get widget :children)))
(value (get symbol 'face-defface-spec))
:convert-widget 'widget-value-convert-widget
:button-prefix 'widget-push-button-prefix
:button-suffix 'widget-push-button-suffix
- :format "%t: %[select face%] %v"
+ :format "%{%t%}: %[select face%] %v"
:tag "Face"
:value 'default
:value-create 'widget-face-value-create
:value-get 'widget-value-value-get
:validate 'widget-children-validate
:action 'widget-face-action
- :match '(lambda (widget value) (symbolp value)))
+ :match (lambda (widget value) (symbolp value)))
(defun widget-face-value-create (widget)
- ;; Create a `custom-face' child.
+ "Create a `custom-face' child."
(let* ((symbol (widget-value widget))
(custom-buffer-style 'face)
(child (widget-create-child-and-convert
(widget-put widget :children (list child))))
(defun widget-face-value-delete (widget)
- ;; Remove the child from the options.
+ "Remove the child from the options."
(let ((child (car (widget-get widget :children))))
(setq custom-options (delq child custom-options))
(widget-children-value-delete widget)))
:match (lambda (widget value)
(or (symbolp value)
(widget-group-match widget value)))
+ ;; Avoid adding undefined functions to the hook, especially for
+ ;; things like `find-file-hook' or even more basic ones, to avoid
+ ;; chaos.
+ :set (lambda (symbol value)
+ (dolist (elt value)
+ (if (fboundp elt)
+ (add-hook symbol elt))))
:convert-widget 'custom-hook-convert-widget
:tag "Hook")
(defun custom-hook-convert-widget (widget)
- ;; Handle `:custom-options'.
+ ;; Handle `:options'.
(let* ((options (widget-get widget :options))
(other `(editable-list :inline t
:entry-format "%i %d%v"
:type '(repeat face)
:group 'custom-faces)
-(defface custom-group-tag-face-1 '((((class color)
- (background dark))
- (:foreground "pink" :underline t))
- (((class color)
- (background light))
- (:foreground "red" :underline t))
- (t (:underline t)))
- "Face used for group tags.")
-
-(defface custom-group-tag-face '((((class color)
- (background dark))
- (:foreground "light blue" :underline t))
- (((class color)
- (background light))
- (:foreground "blue" :underline t))
- (t (:underline t)))
+(defface custom-group-tag-face-1
+ `((((class color)
+ (background dark))
+ (:foreground "pink" :bold t :height 1.2 :inherit variable-pitch))
+ (((class color)
+ (background light))
+ (:foreground "red" :bold t :height 1.2 :inherit variable-pitch))
+ (t (:bold t)))
+ "Face used for group tags."
+ :group 'custom-faces)
+
+(defface custom-group-tag-face
+ `((((class color)
+ (background dark))
+ (:foreground "light blue" :bold t :height 1.2))
+ (((class color)
+ (background light))
+ (:foreground "blue" :bold t :height 1.2))
+ (t (:bold t)))
"Face used for low level group tags."
:group 'custom-faces)
(widget-insert "\n"))))
members)))
(message "Creating group magic...")
- (mapcar 'custom-magic-reset children)
+ (mapc 'custom-magic-reset children)
(message "Creating group state...")
(widget-put widget :children children)
(custom-group-state-update widget)
(defun custom-group-set (widget)
"Set changes in all modified group members."
(let ((children (widget-get widget :children)))
- (mapcar (lambda (child)
- (when (eq (widget-get child :custom-state) 'modified)
- (widget-apply child :custom-set)))
+ (mapc (lambda (child)
+ (when (eq (widget-get child :custom-state) 'modified)
+ (widget-apply child :custom-set)))
children )))
(defun custom-group-save (widget)
"Save all modified group members."
(let ((children (widget-get widget :children)))
- (mapcar (lambda (child)
- (when (memq (widget-get child :custom-state) '(modified set))
- (widget-apply child :custom-save)))
+ (mapc (lambda (child)
+ (when (memq (widget-get child :custom-state) '(modified set))
+ (widget-apply child :custom-save)))
children )))
(defun custom-group-reset-current (widget)
"Reset all modified group members."
(let ((children (widget-get widget :children)))
- (mapcar (lambda (child)
- (when (eq (widget-get child :custom-state) 'modified)
- (widget-apply child :custom-reset-current)))
+ (mapc (lambda (child)
+ (when (eq (widget-get child :custom-state) 'modified)
+ (widget-apply child :custom-reset-current)))
children )))
(defun custom-group-reset-saved (widget)
"Reset all modified or set group members."
(let ((children (widget-get widget :children)))
- (mapcar (lambda (child)
- (when (memq (widget-get child :custom-state) '(modified set))
- (widget-apply child :custom-reset-saved)))
+ (mapc (lambda (child)
+ (when (memq (widget-get child :custom-state) '(modified set))
+ (widget-apply child :custom-reset-saved)))
children )))
(defun custom-group-reset-standard (widget)
"Reset all modified, set, or saved group members."
(let ((children (widget-get widget :children)))
- (mapcar (lambda (child)
- (when (memq (widget-get child :custom-state)
- '(modified set saved))
- (widget-apply child :custom-reset-standard)))
+ (mapc (lambda (child)
+ (when (memq (widget-get child :custom-state)
+ '(modified set saved))
+ (widget-apply child :custom-reset-standard)))
children )))
(defun custom-group-state-update (widget)
"File used for storing customization information.
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."
+you need to explicitly load that file for the settings to take effect.
+
+When you change this variable, look in the previous custom file
+\(usually your init file) for the forms `(custom-set-variables ...)'
+and `(custom-set-faces ...)', and copy them (whichever ones you find)
+to the new custom file. This will preserve your existing customizations."
:type '(choice (const :tag "Your Emacs init file" nil) file)
:group 'customize)
"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"))))
+ (let ((user-init-file user-init-file)
+ (default-init-file
+ (if (eq system-type 'ms-dos) "~/_emacs" "~/.emacs")))
+ (when (null user-init-file)
+ (if (or (file-exists-p default-init-file)
+ (and (eq system-type 'windows-nt)
+ (file-exists-p "~/_emacs")))
+ ;; Started with -q, i.e. the file containing
+ ;; Custom settings hasn't been read. Saving
+ ;; settings there would overwrite other settings.
+ (error "Saving settings from \"emacs -q\" would overwrite existing customizations"))
+ (setq user-init-file default-init-file))
+ user-init-file))))
(defun custom-save-delete (symbol)
- "Delete the call to SYMBOL from `custom-file'.
-Leave point at the location of the call, or after the last expression."
+ "Visit `custom-file' and delete all calls to SYMBOL from it.
+Leave point at the old location of the first such call,
+or (if there were none) at the end of the buffer."
(let ((default-major-mode))
(set-buffer (find-file-noselect (custom-file))))
(goto-char (point-min))
(while (forward-comment 1))
(or (eobp)
(save-excursion (forward-sexp (buffer-size)))) ; Test for scan errors.
- (catch 'found
- (while t
- ;; Skip all whitespace and comments.
- (while (forward-comment 1))
- (let ((start (point))
- (sexp (condition-case nil
- (read (current-buffer))
- (end-of-file (throw 'found nil)))))
- (when (and (listp sexp)
- (eq (car sexp) symbol))
- (delete-region start (point))
- (throw 'found nil))))))
+ (let (first)
+ (catch 'found
+ (while t ;; We exit this loop only via throw.
+ ;; Skip all whitespace and comments.
+ (while (forward-comment 1))
+ (let ((start (point))
+ (sexp (condition-case nil
+ (read (current-buffer))
+ (end-of-file (throw 'found nil)))))
+ (when (and (listp sexp)
+ (eq (car sexp) symbol))
+ (delete-region start (point))
+ (unless first
+ (setq first (point)))))))
+ (if first
+ (goto-char first)
+ ;; Move in front of local variables, otherwise long Custom
+ ;; entries would make them ineffective.
+ (let ((pos (point-max))
+ (case-fold-search t))
+ (save-excursion
+ (goto-char (point-max))
+ (search-backward "\n\^L" (max (- (point-max) 3000) (point-min))
+ 'move)
+ (when (search-forward "Local Variables:" nil t)
+ (setq pos (line-beginning-position))))
+ (goto-char pos)))))
(defun custom-save-variables ()
"Save all customized variables in `custom-file'."
(setq saved-list (sort (cdr saved-list) 'string<))
(unless (bolp)
(princ "\n"))
- (princ "(custom-set-variables")
+ (princ "(custom-set-variables
+ ;; custom-set-variables was added by Custom -- don't edit or cut/paste it!
+ ;; Your init file should contain only one such instance.\n")
(mapcar
(lambda (symbol)
(let ((value (get symbol 'saved-value))
(comment (get symbol 'saved-variable-comment))
sep)
(when (or value comment)
- (princ "\n '(")
+ (unless (bolp)
+ (princ "\n"))
+ (princ " '(")
(prin1 symbol)
(princ " ")
(prin1 (car value))
(t
(princ ")"))))))
saved-list)
+ (if (bolp)
+ (princ " "))
(princ ")")
(unless (looking-at "\n")
(princ "\n")))))
(setq saved-list (cons 'default (delq 'default saved-list))))
(unless (bolp)
(princ "\n"))
- (princ "(custom-set-faces")
+ (princ "(custom-set-faces
+ ;; custom-set-faces was added by Custom -- don't edit or cut/paste it!
+ ;; Your init file should contain only one such instance.\n")
(mapcar
(lambda (symbol)
(let ((value (get symbol 'saved-face))
(comment (get 'default 'saved-face-comment)))
(unless (eq symbol 'default))
;; Don't print default face here.
- (princ "\n '(")
+ (unless (bolp)
+ (princ "\n"))
+ (princ " '(")
(prin1 symbol)
(princ " ")
(prin1 value)
(t
(princ ")")))))
saved-list)
+ (if (bolp)
+ (princ " "))
(princ ")")
(unless (looking-at "\n")
(princ "\n")))))
':style 'toggle
':selected symbol)))
-;; Fixme: sort out use of :filter in Emacs
-(if nil ; (string-match "XEmacs" emacs-version)
- ;; XEmacs can create menus dynamically.
- (defun custom-group-menu-create (widget symbol)
- "Ignoring WIDGET, create a menu entry for customization group SYMBOL."
- `( ,(custom-unlispify-menu-entry symbol t)
- :filter (lambda (&rest junk)
- (cdr (custom-menu-create ',symbol)))))
- ;; But emacs can't.
- (defun custom-group-menu-create (widget symbol)
- "Ignoring WIDGET, create a menu entry for customization group SYMBOL."
- ;; Limit the nesting.
- (let ((custom-menu-nesting (1- custom-menu-nesting)))
- (custom-menu-create symbol))))
+(defun custom-group-menu-create (widget symbol)
+ "Ignoring WIDGET, create a menu entry for customization group SYMBOL."
+ `( ,(custom-unlispify-menu-entry symbol t)
+ :filter (lambda (&rest junk)
+ (cdr (custom-menu-create ',symbol)))))
;;;###autoload
(defun custom-menu-create (symbol)
The format is suitable for use with `easy-menu-define'."
(unless name
(setq name "Customize"))
- ;; Fixme: sort out use of :filter in Emacs
- (if nil ;(string-match "XEmacs" emacs-version)
- ;; We can delay it under XEmacs.
- `(,name
- :filter (lambda (&rest junk)
- (cdr (custom-menu-create ',symbol))))
- ;; But we must create it now under Emacs.
- (cons name (cdr (custom-menu-create symbol)))))
+ `(,name
+ :filter (lambda (&rest junk)
+ (custom-menu-create ',symbol))))
;;; The Custom Mode.
"Keymap for `custom-mode'.")
(unless custom-mode-map
+ ;; This keymap should be dense, but a dense keymap would prevent inheriting
+ ;; "\r" bindings from the parent map.
(setq custom-mode-map (make-sparse-keymap))
(set-keymap-parent custom-mode-map widget-keymap)
(suppress-keymap custom-mode-map)
(set (make-local-variable 'widget-push-button-suffix) "")
(set (make-local-variable 'widget-link-prefix) "")
(set (make-local-variable 'widget-link-suffix) ""))
- (make-local-hook 'widget-edit-functions)
(add-hook 'widget-edit-functions 'custom-state-buffer-message nil t)
(run-hooks 'custom-mode-hook))
+(put 'custom-mode 'mode-class 'special)
+
+(add-to-list
+ 'debug-ignored-errors
+ "^No user options have changed defaults in recent Emacs versions$")
+
;;; The End.
(provide 'cus-edit)