803 lines
32 KiB
EmacsLisp
803 lines
32 KiB
EmacsLisp
;;; cus-new-user.el --- Customize some important options
|
|
;;
|
|
;; Author: Lennart Borgman (lennart O borgman A gmail O com)
|
|
;; Created: 2009-07-10 Fri
|
|
;; Version: 0.2
|
|
;; Last-Updated: 2009-07-10 Fri
|
|
;; URL:
|
|
;; Keywords:
|
|
;; Compatibility:
|
|
;;
|
|
;; Features that might be required by this library:
|
|
;;
|
|
;; None
|
|
;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;;
|
|
;;; Commentary:
|
|
;;
|
|
;; Customize significant options for which different user
|
|
;; environment expectations might dictate different defaults.
|
|
;;
|
|
;; After an idea of Scot Becker on Emacs Devel.
|
|
;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;;
|
|
;;; Change log:
|
|
;;
|
|
;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;;
|
|
;; This program is free software; you can redistribute it and/or
|
|
;; modify it under the terms of the GNU General Public License as
|
|
;; published by the Free Software Foundation; either version 3, or
|
|
;; (at your option) any later version.
|
|
;;
|
|
;; This program is distributed in the hope that it will be useful,
|
|
;; but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
;; General Public License for more details.
|
|
;;
|
|
;; You should have received a copy of the GNU General Public License
|
|
;; along with this program; see the file COPYING. If not, write to
|
|
;; the Free Software Foundation, Inc., 51 Franklin Street, Fifth
|
|
;; Floor, Boston, MA 02110-1301, USA.
|
|
;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;;
|
|
;;; Code:
|
|
|
|
(defvar cusnu-my-skin-widget nil)
|
|
|
|
(defvar cusnu-insert-os-spec-fun nil)
|
|
|
|
;;(customize-for-new-user)
|
|
;;;###autoload
|
|
(defun customize-for-new-user (&optional name)
|
|
"Show special customization page for new user.
|
|
"
|
|
(interactive)
|
|
;;(setq debug-on-error t)
|
|
;;(setq buffer-read-only t)
|
|
(require 'cus-edit)
|
|
(let ((inhibit-read-only t)
|
|
fill-pos)
|
|
(pop-to-buffer (custom-get-fresh-buffer (or name "*Customizations for New Users*")))
|
|
(buffer-disable-undo)
|
|
(Custom-mode)
|
|
(erase-buffer)
|
|
(widget-insert (propertize "Easy Customization for New Users\n" 'face '(:weight bold :height 1.5)))
|
|
(setq fill-pos (point))
|
|
(widget-insert
|
|
"Below are some custom options that new users often may want to
|
|
tweak since they may make Emacs a bit more like what they expect from
|
|
using other software in their environment.
|
|
|
|
After this, at the bottom of this page, is a tool for exporting your own specific options.
|
|
You choose which to export, make a description and give the group of options a new and click a button.
|
|
Then you just mail it or put it on the web for others to use.
|
|
|
|
Since Emacs runs in many environment and an Emacs user may use
|
|
several of them it is hard to decide by default what a user
|
|
wants/expects. Therefor you are given the possibility to easily
|
|
do those changes here.
|
|
|
|
Note that this is just a collection of normal custom options.
|
|
There are no new options here.
|
|
|
|
|
|
")
|
|
(fill-region fill-pos (point))
|
|
|
|
;; Normal custom buffer header
|
|
(let ((init-file (or custom-file user-init-file)))
|
|
;; Insert verbose help at the top of the custom buffer.
|
|
(when custom-buffer-verbose-help
|
|
(widget-insert "Editing a setting changes only the text in this buffer."
|
|
(if init-file
|
|
"
|
|
To apply your changes, use the Save or Set buttons.
|
|
Saving a change normally works by editing your init file."
|
|
"
|
|
Currently, these settings cannot be saved for future Emacs sessions,
|
|
possibly because you started Emacs with `-q'.")
|
|
"\nFor details, see ")
|
|
(widget-create 'custom-manual
|
|
:tag "Saving Customizations"
|
|
"(emacs)Saving Customizations")
|
|
(widget-insert " in the ")
|
|
(widget-create 'custom-manual
|
|
:tag "Emacs manual"
|
|
:help-echo "Read the Emacs manual."
|
|
"(emacs)Top")
|
|
(widget-insert "."))
|
|
(widget-insert "\n")
|
|
;; The custom command buttons are also in the toolbar, so for a
|
|
;; time they were not inserted in the buffer if the toolbar was in use.
|
|
;; But it can be a little confusing for the buffer layout to
|
|
;; change according to whether or nor the toolbar is on, not to
|
|
;; mention that a custom buffer can in theory be created in a
|
|
;; frame with a toolbar, then later viewed in one without.
|
|
;; So now the buttons are always inserted in the buffer. (Bug#1326)
|
|
;;; (when (not (and (bound-and-true-p tool-bar-mode) (display-graphic-p)))
|
|
(if custom-buffer-verbose-help
|
|
(widget-insert "\n
|
|
Operate on all settings in this buffer that are not marked HIDDEN:\n"))
|
|
(let ((button (lambda (tag action active help icon)
|
|
(widget-insert " ")
|
|
(if (eval active)
|
|
(widget-create 'push-button :tag tag
|
|
:help-echo help :action action))))
|
|
(commands custom-commands))
|
|
(apply button (pop commands)) ; Set for current session
|
|
(apply button (pop commands)) ; Save for future sessions
|
|
(if custom-reset-button-menu
|
|
(progn
|
|
(widget-insert " ")
|
|
(widget-create 'push-button
|
|
:tag "Reset buffer"
|
|
:help-echo "Show a menu with reset operations."
|
|
:mouse-down-action 'ignore
|
|
:action 'custom-reset))
|
|
(widget-insert "\n")
|
|
(apply button (pop commands)) ; Undo edits
|
|
(apply button (pop commands)) ; Reset to saved
|
|
(apply button (pop commands)) ; Erase customization
|
|
(widget-insert " ")
|
|
(pop commands) ; Help (omitted)
|
|
(apply button (pop commands)))) ; Exit
|
|
(widget-insert "\n\n")
|
|
|
|
(widget-insert (propertize "\nThis part is for your own use\n" 'face '(:weight bold :height 1.5)))
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; Editor emulator level
|
|
|
|
(widget-insert "\n")
|
|
(setq fill-pos (point))
|
|
(widget-insert
|
|
"Emacs can emulate some common editing behaviours (and some uncommon too).
|
|
For the most common ones you can decide if you want to use them here:
|
|
")
|
|
(fill-region fill-pos (point))
|
|
(cusnu-mark-part-desc fill-pos (point))
|
|
|
|
;; CUA Mode
|
|
(cusnu-insert-options '((cua-mode custom-variable)))
|
|
|
|
;; Viper Mode
|
|
(widget-insert "\n")
|
|
(widget-insert (propertize "Viper" 'face 'custom-variable-tag))
|
|
(widget-insert ":")
|
|
(setq fill-pos (point))
|
|
(widget-insert "
|
|
Viper is currently set up in a special way, please see the
|
|
command `viper-mode'. You can use custom to set up most of
|
|
it. However if you want to load Viper at startup you must
|
|
explicitly include \(require 'viper) in your .emacs.
|
|
")
|
|
(fill-region fill-pos (point))
|
|
|
|
;; Viper Mode
|
|
(backward-delete-char 1)
|
|
(cusnu-insert-options '((viper-mode custom-variable)))
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; OS specific
|
|
|
|
(widget-insert "\n")
|
|
(setq fill-pos (point))
|
|
(widget-insert (format "OS specific options (%s): \n" system-type))
|
|
(fill-region fill-pos (point))
|
|
(cusnu-mark-part-desc fill-pos (point))
|
|
|
|
(if cusnu-insert-os-spec-fun
|
|
(funcall cusnu-insert-os-spec-fun)
|
|
(widget-insert "No OS specific customizations.\n"))
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; Disputed settings
|
|
|
|
(widget-insert "\n")
|
|
(setq fill-pos (point))
|
|
(widget-insert
|
|
"Some old time Emacs users want to change the options below:
|
|
")
|
|
(fill-region fill-pos (point))
|
|
(cusnu-mark-part-desc fill-pos (point))
|
|
|
|
(cusnu-insert-options '((global-visual-line-mode custom-variable)))
|
|
(cusnu-insert-options '((word-wrap custom-variable)))
|
|
(cusnu-insert-options '((blink-cursor-mode custom-variable)))
|
|
(cusnu-insert-options '((tool-bar-mode custom-variable)))
|
|
(cusnu-insert-options '((tooltip-mode custom-variable)))
|
|
;;(cusnu-insert-options '((initial-scratch-message custom-variable)))
|
|
|
|
(widget-insert "\n")
|
|
(widget-insert (propertize "\n\nThis part is for exporting to others\n\n" 'face '(:weight bold :height 1.5)))
|
|
(setq fill-pos (point))
|
|
(widget-insert
|
|
"My skin options - This is for exporting custom options to other users
|
|
\(or maybe yourself on another computer).
|
|
This works the following way:
|
|
|
|
- You add a description of your options and the options you want to export below.
|
|
Then you click on `Export my skin options'.
|
|
This creates a file that you can send to other Emacs users.
|
|
They simply open that file in Emacs and follow the instructions there to test your options
|
|
and maybe save them for later use if they like them.
|
|
\(You can follow the instructions yourself to see how it works.)
|
|
|
|
Please change the group symbol name to something specific for you.
|
|
")
|
|
(fill-region fill-pos (point))
|
|
(cusnu-mark-part-desc fill-pos (point))
|
|
|
|
(widget-insert "\n")
|
|
(set (make-local-variable 'cusnu-my-skin-widget)
|
|
(car
|
|
(cusnu-insert-options '((cusnu-my-skin-options custom-variable)))))
|
|
(widget-insert "\n")
|
|
(widget-create 'push-button
|
|
:tag "Export my skin options "
|
|
:action (lambda (&rest ignore)
|
|
(let ((use-dialog-box nil))
|
|
(call-interactively 'cusnu-export-my-skin-options))))
|
|
(widget-insert "\n")
|
|
(widget-create 'push-button
|
|
:tag "Customize my skin options "
|
|
:action (lambda (&rest ignore)
|
|
(let ((use-dialog-box nil))
|
|
(call-interactively 'cusnu-customize-my-skin-options))))
|
|
(widget-insert "\n")
|
|
(widget-create 'push-button
|
|
:tag "Reset those options to saved values"
|
|
:action (lambda (&rest ignore)
|
|
(let ((use-dialog-box nil))
|
|
(call-interactively 'cusnu-reset-my-skin-options))))
|
|
|
|
;; Finish setup buffer
|
|
(mapc 'custom-magic-reset custom-options)
|
|
(cusnu-make-xrefs)
|
|
(widget-setup)
|
|
(buffer-enable-undo)
|
|
(goto-char (point-min)))))
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; Example on Emacs+Emacw32
|
|
(eval-when-compile (require 'emacsw32 nil t))
|
|
(when (fboundp 'emacsw32-version)
|
|
(defun cusnu-emacsw32-show-custstart (&rest args)
|
|
(emacsw32-show-custstart))
|
|
(setq cusnu-insert-os-spec-fun 'cusnu-insert-emacsw32-specific-part)
|
|
(defun cusnu-insert-emacsw32-specific-part ()
|
|
(cusnu-insert-options '((w32-meta-style custom-variable)))
|
|
(widget-insert "\n")
|
|
(widget-insert (propertize "EmacsW32" 'face 'custom-variable-tag))
|
|
(widget-insert "
|
|
Easy setup for Emacs+EmacsW32.")
|
|
(widget-insert "\n ")
|
|
(widget-create 'push-button :tag "Customize EmacsW32"
|
|
;;:help-echo help
|
|
:action 'cusnu-emacsw32-show-custstart)
|
|
(widget-insert "\n")))
|
|
;; End example
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
(defun cusnu-mark-part-desc (beg end)
|
|
(let ((ovl (make-overlay beg end)))
|
|
(overlay-put ovl 'face 'highlight)))
|
|
|
|
(defun cusnu-make-xrefs (&optional beg end)
|
|
(save-restriction
|
|
(when (or beg end)
|
|
(unless beg (setq beg (point-min)))
|
|
(unless end (setq end (point-max)))
|
|
(narrow-to-region beg end))
|
|
(let ((here (point)))
|
|
(goto-char (point-min))
|
|
(cusnu-help-insert-xrefs 'cusnu-help-xref-button)
|
|
(goto-char here))))
|
|
|
|
(defun widget-info-link-action (widget &optional event)
|
|
"Open the info node specified by WIDGET."
|
|
(info-other-window (widget-value widget)))
|
|
|
|
(defun widget-documentation-string-value-create (widget)
|
|
;; Insert documentation string.
|
|
(let ((doc (widget-value widget))
|
|
(indent (widget-get widget :indent))
|
|
(shown (widget-get (widget-get widget :parent) :documentation-shown))
|
|
(start (point)))
|
|
(if (string-match "\n" doc)
|
|
(let ((before (substring doc 0 (match-beginning 0)))
|
|
(after (substring doc (match-beginning 0)))
|
|
button)
|
|
(when (and indent (not (zerop indent)))
|
|
(insert-char ?\s indent))
|
|
(insert before ?\s)
|
|
(widget-documentation-link-add widget start (point))
|
|
(setq button
|
|
(widget-create-child-and-convert
|
|
widget (widget-get widget :visibility-widget)
|
|
:help-echo "Show or hide rest of the documentation."
|
|
:on "Hide Rest"
|
|
:off "More"
|
|
:always-active t
|
|
:action 'widget-parent-action
|
|
shown))
|
|
(when shown
|
|
(setq start (point))
|
|
(when (and indent (not (zerop indent)))
|
|
(insert-char ?\s indent))
|
|
(insert after)
|
|
(widget-documentation-link-add widget start (point))
|
|
(cusnu-make-xrefs start (point))
|
|
)
|
|
(widget-put widget :buttons (list button)))
|
|
(when (and indent (not (zerop indent)))
|
|
(insert-char ?\s indent))
|
|
(insert doc)
|
|
(widget-documentation-link-add widget start (point))))
|
|
(insert ?\n))
|
|
(defun cusnu-help-xref-button (match-number type what &rest args)
|
|
(let ((beg (match-beginning match-number))
|
|
(end (match-end match-number)))
|
|
(if nil
|
|
(let ((ovl (make-overlay beg end)))
|
|
(overlay-put ovl 'face 'highlight))
|
|
(let* ((tag (match-string match-number))
|
|
(value what)
|
|
(wid-type (cond
|
|
((eq type 'help-variable)
|
|
'variable-link)
|
|
((eq type 'help-function)
|
|
'function-link)
|
|
((eq type 'help-info)
|
|
'custom-manual)
|
|
(t nil)))
|
|
)
|
|
(when wid-type
|
|
(delete-region beg end)
|
|
(backward-char)
|
|
;;(tag action active help icon)
|
|
(widget-create wid-type
|
|
;;tag
|
|
:value value
|
|
:tag tag
|
|
:keymap custom-mode-link-map
|
|
:follow-link 'mouse-face
|
|
:button-face 'custom-link
|
|
:mouse-face 'highlight
|
|
:pressed-face 'highlight
|
|
;;:help-echo help
|
|
)))))
|
|
)
|
|
|
|
;; Override default ... ;-)
|
|
(define-widget 'documentation-link 'link
|
|
"Link type used in documentation strings."
|
|
;;:tab-order -1
|
|
:help-echo "Describe this symbol"
|
|
:button-face 'custom-link
|
|
:action 'widget-documentation-link-action)
|
|
|
|
(defun cusnu-xref-niy (&rest ignore)
|
|
(message "Not implemented yet"))
|
|
|
|
(defun cusnu-describe-function (wid &rest ignore)
|
|
(let ((fun (widget-get wid :what))
|
|
)
|
|
(describe-function fun)))
|
|
|
|
(defun cusnu-help-insert-xrefs (help-xref-button)
|
|
;; The following should probably be abstracted out.
|
|
(unwind-protect
|
|
(progn
|
|
;; Info references
|
|
(save-excursion
|
|
(while (re-search-forward help-xref-info-regexp nil t)
|
|
(let ((data (match-string 2)))
|
|
(save-match-data
|
|
(unless (string-match "^([^)]+)" data)
|
|
(setq data (concat "(emacs)" data))))
|
|
(funcall help-xref-button 2 'help-info data))))
|
|
;; URLs
|
|
(save-excursion
|
|
(while (re-search-forward help-xref-url-regexp nil t)
|
|
(let ((data (match-string 1)))
|
|
(funcall help-xref-button 1 'help-url data))))
|
|
;; Mule related keywords. Do this before trying
|
|
;; `help-xref-symbol-regexp' because some of Mule
|
|
;; keywords have variable or function definitions.
|
|
(if help-xref-mule-regexp
|
|
(save-excursion
|
|
(while (re-search-forward help-xref-mule-regexp nil t)
|
|
(let* ((data (match-string 7))
|
|
(sym (intern-soft data)))
|
|
(cond
|
|
((match-string 3) ; coding system
|
|
(and sym (coding-system-p sym)
|
|
(funcall help-xref-button 6 'help-coding-system sym)))
|
|
((match-string 4) ; input method
|
|
(and (assoc data input-method-alist)
|
|
(funcall help-xref-button 7 'help-input-method data)))
|
|
((or (match-string 5) (match-string 6)) ; charset
|
|
(and sym (charsetp sym)
|
|
(funcall help-xref-button 7 'help-character-set sym)))
|
|
((assoc data input-method-alist)
|
|
(funcall help-xref-button 7 'help-character-set data))
|
|
((and sym (coding-system-p sym))
|
|
(funcall help-xref-button 7 'help-coding-system sym))
|
|
((and sym (charsetp sym))
|
|
(funcall help-xref-button 7 'help-character-set sym)))))))
|
|
;; Quoted symbols
|
|
(save-excursion
|
|
(while (re-search-forward help-xref-symbol-regexp nil t)
|
|
(let* ((data (match-string 8))
|
|
(sym (intern-soft data)))
|
|
(if sym
|
|
(cond
|
|
((match-string 3) ; `variable' &c
|
|
(and (or (boundp sym) ; `variable' doesn't ensure
|
|
; it's actually bound
|
|
(get sym 'variable-documentation))
|
|
(funcall help-xref-button 8 'help-variable sym)))
|
|
((match-string 4) ; `function' &c
|
|
(and (fboundp sym) ; similarly
|
|
(funcall help-xref-button 8 'help-function sym)))
|
|
((match-string 5) ; `face'
|
|
(and (facep sym)
|
|
(funcall help-xref-button 8 'help-face sym)))
|
|
((match-string 6)) ; nothing for `symbol'
|
|
((match-string 7)
|
|
;;; this used:
|
|
;;; #'(lambda (arg)
|
|
;;; (let ((location
|
|
;;; (find-function-noselect arg)))
|
|
;;; (pop-to-buffer (car location))
|
|
;;; (goto-char (cdr location))))
|
|
(funcall help-xref-button 8 'help-function-def sym))
|
|
((and
|
|
(facep sym)
|
|
(save-match-data (looking-at "[ \t\n]+face\\W")))
|
|
(funcall help-xref-button 8 'help-face sym))
|
|
((and (or (boundp sym)
|
|
(get sym 'variable-documentation))
|
|
(fboundp sym))
|
|
;; We can't intuit whether to use the
|
|
;; variable or function doc -- supply both.
|
|
(funcall help-xref-button 8 'help-symbol sym))
|
|
((and
|
|
(or (boundp sym)
|
|
(get sym 'variable-documentation))
|
|
(or
|
|
(documentation-property
|
|
sym 'variable-documentation)
|
|
(condition-case nil
|
|
(documentation-property
|
|
(indirect-variable sym)
|
|
'variable-documentation)
|
|
(cyclic-variable-indirection nil))))
|
|
(funcall help-xref-button 8 'help-variable sym))
|
|
((fboundp sym)
|
|
(funcall help-xref-button 8 'help-function sym)))))))
|
|
;; An obvious case of a key substitution:
|
|
(save-excursion
|
|
(while (re-search-forward
|
|
;; Assume command name is only word and symbol
|
|
;; characters to get things like `use M-x foo->bar'.
|
|
;; Command required to end with word constituent
|
|
;; to avoid `.' at end of a sentence.
|
|
"\\<M-x\\s-+\\(\\sw\\(\\sw\\|\\s_\\)*\\sw\\)" nil t)
|
|
(let ((sym (intern-soft (match-string 1))))
|
|
(if (fboundp sym)
|
|
(funcall help-xref-button 1 'help-function sym)))))
|
|
;; Look for commands in whole keymap substitutions:
|
|
(save-excursion
|
|
;; Make sure to find the first keymap.
|
|
(goto-char (point-min))
|
|
;; Find a header and the column at which the command
|
|
;; name will be found.
|
|
|
|
;; If the keymap substitution isn't the last thing in
|
|
;; the doc string, and if there is anything on the
|
|
;; same line after it, this code won't recognize the end of it.
|
|
(while (re-search-forward "^key +binding\n\\(-+ +\\)-+\n\n"
|
|
nil t)
|
|
(let ((col (- (match-end 1) (match-beginning 1))))
|
|
(while
|
|
(and (not (eobp))
|
|
;; Stop at a pair of blank lines.
|
|
(not (looking-at "\n\\s-*\n")))
|
|
;; Skip a single blank line.
|
|
(and (eolp) (forward-line))
|
|
(end-of-line)
|
|
(skip-chars-backward "^ \t\n")
|
|
(if (and (>= (current-column) col)
|
|
(looking-at "\\(\\sw\\|\\s_\\)+$"))
|
|
(let ((sym (intern-soft (match-string 0))))
|
|
(if (fboundp sym)
|
|
(funcall help-xref-button 0 'help-function sym))))
|
|
(forward-line))))))
|
|
;;(set-syntax-table stab)
|
|
))
|
|
|
|
(defun cusnu-insert-options (options)
|
|
(widget-insert "\n")
|
|
(setq custom-options
|
|
(append
|
|
(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))
|
|
:value (nth 0 entry)))
|
|
options)
|
|
(let ((count 0)
|
|
(length (length options)))
|
|
(mapcar (lambda (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)))
|
|
custom-options))
|
|
(unless (eq (preceding-char) ?\n)
|
|
(widget-insert "\n"))
|
|
custom-options
|
|
)
|
|
|
|
(defun cusnu-is-custom-obj (sym)
|
|
"Return non-nil if symbol SYM is customizable."
|
|
(or (get sym 'custom-type)
|
|
(get sym 'face)
|
|
(get sym 'custom-group)
|
|
))
|
|
|
|
(define-widget 'custom-symbol 'symbol
|
|
"A customizable symbol."
|
|
:prompt-match 'cusnu-is-custom-obj
|
|
:prompt-history 'widget-variable-prompt-value-history
|
|
:complete-function (lambda ()
|
|
(interactive)
|
|
(lisp-complete-symbol 'cusnu-is-custom-obj))
|
|
:tag "Custom option")
|
|
|
|
(defun cusnu-set-my-skin-options (sym val)
|
|
(set-default sym val)
|
|
(let ((group (nth 0 val))
|
|
(doc (nth 1 val))
|
|
(members (nth 2 val)))
|
|
(custom-declare-group group nil doc)
|
|
(put group 'custom-group nil)
|
|
(dolist (opt members)
|
|
(let ((type (cusnu-get-opt-main-type opt)))
|
|
(when type
|
|
(custom-add-to-group group opt type))))))
|
|
|
|
(defun cusnu-get-opt-main-type (opt)
|
|
(when opt
|
|
(cond ((get opt 'face) 'custom-face)
|
|
((get opt 'custom-type) 'custom-variable)
|
|
((get opt 'custom-group) 'custom-group))))
|
|
|
|
(defgroup all-my-loaded-skin-groups nil
|
|
"All your loaded skin groups."
|
|
:group 'environment
|
|
:group 'convenience)
|
|
|
|
(defun cusnu-custom-group-p (symbol)
|
|
(and (intern-soft symbol)
|
|
(or (and (get symbol 'custom-loads)
|
|
(not (get symbol 'custom-autoload)))
|
|
(get symbol 'custom-group))))
|
|
|
|
(defcustom cusnu-my-skin-options '(my-skin-group "My skin group.\n\n\n\n\n" nil)
|
|
"Your custom skin-like options.
|
|
The purpose of this variable is to provide for easy export a
|
|
selection of variables you choose to set to other users.
|
|
|
|
To send these values to other users you export them to a file
|
|
with `cusnu-export-my-skin-options'."
|
|
:type '(list (symbol :tag "My custom group symbol name (should be specific to you)")
|
|
(string :tag "My custom group description")
|
|
(repeat :tag "Add your custom options below"
|
|
(custom-symbol :tag "My custom option")))
|
|
:set 'cusnu-set-my-skin-options
|
|
:group 'all-my-loaded-skin-groups)
|
|
|
|
;;(cusnu-ring-bell "bell")
|
|
(defun cusnu-ring-bell (format-string &rest args)
|
|
(message "%s" (propertize (apply
|
|
'format format-string args) 'face 'secondary-selection))
|
|
(ding)
|
|
(throw 'bell nil))
|
|
|
|
;;;###autoload
|
|
(defun cusnu-export-my-skin-options (file)
|
|
"Export to file FILE custom options in `cusnu-my-skin-options'.
|
|
The options is exported to elisp code that other users can run to
|
|
set the options that you have added to `cusnu-my-skin-options'.
|
|
|
|
For more information about this see `cusnu-export-cust-group'."
|
|
(interactive '(nil))
|
|
(catch 'bell
|
|
(let ((grp (nth 0 cusnu-my-skin-options))
|
|
buf)
|
|
(let ((state (plist-get (cdr cusnu-my-skin-widget) :custom-state)))
|
|
(case state
|
|
((set saved) nil) ;;(error "test, state=%s" state))
|
|
(standard (cusnu-ring-bell "Please enter your options first"))
|
|
(t (cusnu-ring-bell "My Skin Options must be saved or set, use the State button, %s" state))))
|
|
(unless (nth 2 cusnu-my-skin-options)
|
|
(cusnu-ring-bell "You have not added any of your options"))
|
|
(unless file
|
|
(setq file (read-file-name "Save to file: ")))
|
|
(when (file-exists-p file)
|
|
(cusnu-ring-bell "File %s already exists, choose another file name" file))
|
|
(setq buf (find-file-other-window file))
|
|
(with-current-buffer buf
|
|
(unless (eq major-mode 'emacs-lisp-mode) (emacs-lisp-mode))
|
|
(unless (file-exists-p (buffer-file-name))
|
|
(erase-buffer)))
|
|
(cusnu-export-cust-group grp buf))))
|
|
|
|
(defun cusnu-customize-my-skin-options ()
|
|
(interactive)
|
|
(customize-group-other-window (nth 0 cusnu-my-skin-options)))
|
|
|
|
(defun cusnu-reset-my-skin-options ()
|
|
"Reset to my defaults for those options.
|
|
"
|
|
(interactive)
|
|
(cusnu-reset-group-options-to-my-defaults (nth 0 cusnu-my-skin-options)))
|
|
|
|
(defun cusnu-reset-group-options-to-my-defaults (group)
|
|
(dolist (sym-typ (get group 'custom-group))
|
|
(let ((symbol (nth 0 sym-typ))
|
|
;;(type (cusnu-get-opt-main-type symbol))
|
|
(type (nth 1 sym-typ))
|
|
defval)
|
|
(cond
|
|
((eq type 'custom-variable)
|
|
;; First try reset to saved.
|
|
(let* ((set (or (get symbol 'custom-set) 'set-default))
|
|
(value (get symbol 'saved-value))
|
|
(comment (get symbol 'saved-variable-comment)))
|
|
(cond ((or comment value)
|
|
(put symbol 'variable-comment comment)
|
|
(custom-push-theme 'theme-value symbol 'user 'set (car-safe value))
|
|
(condition-case err
|
|
(funcall set symbol (eval (car value)))
|
|
(error (message "%s" err))))
|
|
;; If symbol was not saved then reset to standard.
|
|
(t
|
|
(unless (get symbol 'standard-value)
|
|
(error "No standard setting known for %S" symbol))
|
|
(put symbol 'variable-comment nil)
|
|
(put symbol 'customized-value nil)
|
|
(put symbol 'customized-variable-comment nil)
|
|
(custom-push-theme 'theme-value symbol 'user 'reset)
|
|
(custom-theme-recalc-variable symbol)
|
|
(put symbol 'saved-value nil)
|
|
(put symbol 'saved-variable-comment nil)
|
|
))))
|
|
((eq type 'custom-face)
|
|
;; First try reset to saved
|
|
(let* ((value (get symbol 'saved-face))
|
|
(comment (get symbol 'saved-face-comment)))
|
|
(cond ((or value comment)
|
|
(put symbol 'customized-face nil)
|
|
(put symbol 'customized-face-comment nil)
|
|
(custom-push-theme 'theme-face symbol 'user 'set value)
|
|
(face-spec-set symbol value t)
|
|
(put symbol 'face-comment comment))
|
|
;; If symbol was not saved then reset to standard.
|
|
(t
|
|
(setq value (get symbol 'face-defface-spec))
|
|
(unless value
|
|
(error "No standard setting for this face"))
|
|
(put symbol 'customized-face nil)
|
|
(put symbol 'customized-face-comment nil)
|
|
(custom-push-theme 'theme-face symbol 'user 'reset)
|
|
(face-spec-set symbol value t)
|
|
(custom-theme-recalc-face symbol)
|
|
;; Do this later.
|
|
(put symbol 'saved-face nil)
|
|
(put symbol 'saved-face-comment nil)
|
|
))))
|
|
(t (error "not iy"))))))
|
|
|
|
(defun cusnu-export-cust-group (group buf)
|
|
"Export custom group GROUP to end of buffer BUF.
|
|
Only the options that has been customized will be exported.
|
|
|
|
The group is exported as elisp code. Running the code will
|
|
create a group with just those members. After this it opens a
|
|
customization buffer with the new group.
|
|
|
|
The code will also set the options to the customized values, but
|
|
it will not save them in the users init file.
|
|
|
|
See also the comment in the exported file."
|
|
(let (start
|
|
(doc (get group 'group-documentation))
|
|
groups options faces
|
|
(members (mapcar (lambda (rec)
|
|
(car rec))
|
|
(get group 'custom-group))))
|
|
(with-current-buffer buf
|
|
(insert (format-time-string ";; Here is my skin custom group %Y-%m-%d.\n"))
|
|
(font-lock-mode 1)
|
|
(insert (format ";;;;;; Customization group name: %s\n" group))
|
|
(insert ";;\n")
|
|
(let ((here (point)))
|
|
(insert doc "\n")
|
|
(comment-region here (point))
|
|
(fill-region here (point)))
|
|
(cusnu-get-options-and-faces members 'groups 'options 'faces)
|
|
(unless (or options faces)
|
|
(cusnu-ring-bell "There are no options or faces in %s customized by you" group))
|
|
(insert "
|
|
;; This file defines the group and sets the options in it, but does
|
|
;; not save the values to your init file.
|
|
;;
|
|
;; To set the values evaluate this file. To do that open this file in Emacs and to
|
|
;;
|
|
;; M-x eval-buffer
|
|
;;
|
|
;; To go back to your default evaluate next line (place point at the end and to C-x C-e):
|
|
")
|
|
(insert (format ";; (cusnu-reset-group-options-to-my-defaults '%s)\n\n" group))
|
|
(insert (format "(let ((grp '%s))\n" group))
|
|
(insert (format " (custom-declare-group grp nil %S)\n" doc))
|
|
(insert " (put grp 'custom-group nil)\n")
|
|
(insert (format " (custom-add-to-group 'all-my-loaded-skin-groups '%s 'custom-group)\n" group))
|
|
(dolist (opt members)
|
|
(let ((type (cusnu-get-opt-main-type opt)))
|
|
(when type
|
|
(insert (format " (custom-add-to-group grp '%s '%s)\n"
|
|
opt type)))))
|
|
(insert " (custom-set-variables\n")
|
|
(dolist (opt options)
|
|
(let ((my-val (or (get opt 'saved-value)
|
|
(get opt 'customized-value))))
|
|
(when my-val
|
|
(insert (format " '(%s %S)\n" opt (custom-quote (symbol-value opt)))))))
|
|
(insert " )\n")
|
|
(insert " (custom-set-faces\n")
|
|
(dolist (opt faces)
|
|
(let ((my-val (get opt 'customized-face)))
|
|
(when my-val
|
|
(insert (format " '(%s %S)\n" opt my-val)))))
|
|
(insert " ))\n")
|
|
(insert (format "\n(customize-group '%s)\n" group))
|
|
)))
|
|
|
|
(defun cusnu-get-options-and-faces (members groups-par options-par faces-par)
|
|
(dolist (sym members)
|
|
(insert (format ";; sym=%s\n" sym))
|
|
(cond ((and (get sym 'custom-type)
|
|
(or (get sym 'saved-value)
|
|
(get sym 'customize-value)))
|
|
(add-to-list options-par sym))
|
|
((and (get sym 'face)
|
|
(get sym 'customized-face))
|
|
(add-to-list faces-par sym))
|
|
((get sym 'custom-group)
|
|
(unless (memq sym groups-par) ;; Don't loop
|
|
(cusnu-get-options-and-faces groups-par options-par faces-par)))
|
|
(t (insert ";; Not a custom variable or face: %s\n" sym)))))
|
|
|
|
(provide 'cus-new-user)
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;;; cus-new-user.el ends here
|