(provide 'allout)
;;;_* USER CUSTOMIZATION VARIABLES:
+(defgroup allout nil
+ "Extensive outline mode for use alone and with other modes."
+ :prefix "outline-"
+ :group 'outlines)
;;;_ + Layout, Mode, and Topic Header Configuration
(make-variable-buffer-local 'outline-layout)
;;;_ = outline-header-prefix
-(defvar outline-header-prefix "."
+(defcustom outline-header-prefix "."
"*Leading string which helps distinguish topic headers.
Outline topic header lines are identified by a leading topic
header prefix, which mostly have the value of this var at their front.
\(Level 1 topics are exceptions. They consist of only a single
character, which is typically set to the outline-primary-bullet. Many
-outlines start at level 2 to avoid this discrepancy.")
+outlines start at level 2 to avoid this discrepancy."
+ :type 'string
+ :group 'allout)
(make-variable-buffer-local 'outline-header-prefix)
;;;_ = outline-primary-bullet
-(defvar outline-primary-bullet "*"
+(defcustom outline-primary-bullet "*"
"Bullet used for top-level outline topics.
Outline topic header lines are identified by a leading topic header
The value of an asterisk (`*') provides for backwards compatibility
with the original emacs outline mode. See outline-plain-bullets-string
and outline-distinctive-bullets-string for the range of available
-bullets.")
+bullets."
+ :type 'string
+ :group 'allout)
(make-variable-buffer-local 'outline-primary-bullet)
;;;_ = outline-plain-bullets-string
-(defvar outline-plain-bullets-string (concat outline-primary-bullet
+(defcustom outline-plain-bullets-string (concat outline-primary-bullet
"+-:.;,")
"*The bullets normally used in outline topic prefixes.
DO NOT include the close-square-bracket, `]', as a bullet.
Outline mode has to be reactivated in order for changes to the value
-of this var to take effect.")
+of this var to take effect."
+ :type 'string
+ :group 'allout)
(make-variable-buffer-local 'outline-plain-bullets-string)
;;;_ = outline-distinctive-bullets-string
-(defvar outline-distinctive-bullets-string "=>([{}&!?#%\"X@$~\\"
+(defcustom outline-distinctive-bullets-string "=>([{}&!?#%\"X@$~\\"
"*Persistent outline header bullets used to distinguish special topics.
These bullets are not offered among the regular, level-specific
to the value of this var to effect outline-mode operation.
DO NOT include the close-square-bracket, `]', on either of the bullet
-strings.")
+strings."
+ :type 'string
+ :group 'allout)
(make-variable-buffer-local 'outline-distinctive-bullets-string)
;;;_ = outline-use-mode-specific-leader
-(defvar outline-use-mode-specific-leader t
+(defcustom outline-use-mode-specific-leader t
"*When non-nil, use mode-specific topic-header prefixes.
Allout outline mode will use the mode-specific `outline-mode-leaders'
tripled, but an underscore is substituted for the space. [This
presumes that the space is for appearance, not comment syntax. You
can use `outline-mode-leaders' to override this behavior, when
-incorrect.]")
+incorrect.]"
+ :type '(choice (const t) (const nil) string
+ (const outline-mode-leaders)
+ (const comment-start))
+ :group 'allout)
;;;_ = outline-mode-leaders
(defvar outline-mode-leaders '()
"Specific outline-prefix leading strings per major modes.
from regular comments that start at bol.")
;;;_ = outline-old-style-prefixes
-(defvar outline-old-style-prefixes nil
+(defcustom outline-old-style-prefixes nil
"*When non-nil, use only old-and-crusty outline-mode `*' topic prefixes.
Non-nil restricts the topic creation and modification
like the original emacs-outline style prefixes.
Whatever the setting of this variable, both old and new style prefixes
-are always respected by the topic maneuvering functions.")
+are always respected by the topic maneuvering functions."
+ :type 'boolean
+ :group 'allout)
(make-variable-buffer-local 'outline-old-style-prefixes)
;;;_ = outline-stylish-prefixes - alternating bullets
-(defvar outline-stylish-prefixes t
+(defcustom outline-stylish-prefixes t
"*Do fancy stuff with topic prefix bullets according to level, etc.
Non-nil enables topic creation, modification, and repositioning
this variable setting.
The setting of this var is not relevant when outline-old-style-prefixes
-is non-nil.")
+is non-nil."
+ :type 'boolean
+ :group 'allout)
(make-variable-buffer-local 'outline-stylish-prefixes)
;;;_ = outline-numbered-bullet
-(defvar outline-numbered-bullet "#"
+(defcustom outline-numbered-bullet "#"
"*String designating bullet of topics that have auto-numbering; nil for none.
Topics having this bullet have automatic maintenance of a sibling
sequence-number tacked on, just after the bullet. Conventionally set
to \"#\", you can set it to a bullet of your choice. A nil value
-disables numbering maintenance.")
+disables numbering maintenance."
+ :type '(choice (const nil) string)
+ :group 'allout)
(make-variable-buffer-local 'outline-numbered-bullet)
;;;_ = outline-file-xref-bullet
-(defvar outline-file-xref-bullet "@"
+(defcustom outline-file-xref-bullet "@"
"*Bullet signifying file cross-references, for `outline-resolve-xref'.
Set this var to the bullet you want to use for file cross-references.
-Set it to nil if you want to inhibit this capability.")
+Set it to nil if you want to inhibit this capability."
+ :type '(choice (const nil) string)
+ :group 'allout)
;;;_ + LaTeX formatting
;;;_ - outline-number-pages
-(defvar outline-number-pages nil
- "*Non-nil turns on page numbering for LaTeX formatting of an outline.")
+(defcustom outline-number-pages nil
+ "*Non-nil turns on page numbering for LaTeX formatting of an outline."
+ :type 'boolean
+ :group 'allout)
;;;_ - outline-label-style
-(defvar outline-label-style "\\large\\bf"
- "*Font and size of labels for LaTeX formatting of an outline.")
+(defcustom outline-label-style "\\large\\bf"
+ "*Font and size of labels for LaTeX formatting of an outline."
+ :type 'string
+ :group 'allout)
;;;_ - outline-head-line-style
-(defvar outline-head-line-style "\\large\\sl "
- "*Font and size of entries for LaTeX formatting of an outline.")
+(defcustom outline-head-line-style "\\large\\sl "
+ "*Font and size of entries for LaTeX formatting of an outline."
+ :type 'string
+ :group 'allout)
;;;_ - outline-body-line-style
-(defvar outline-body-line-style " "
- "*Font and size of entries for LaTeX formatting of an outline.")
+(defcustom outline-body-line-style " "
+ "*Font and size of entries for LaTeX formatting of an outline."
+ :type 'string
+ :group 'allout)
;;;_ - outline-title-style
-(defvar outline-title-style "\\Large\\bf"
- "*Font and size of titles for LaTeX formatting of an outline.")
+(defcustom outline-title-style "\\Large\\bf"
+ "*Font and size of titles for LaTeX formatting of an outline."
+ :type 'string
+ :group 'allout)
;;;_ - outline-title
-(defvar outline-title '(or buffer-file-name (current-buffer-name))
+(defcustom outline-title '(or buffer-file-name (current-buffer-name))
"*Expression to be evaluated to determine the title for LaTeX
-formatted copy.")
+formatted copy."
+ :type 'sexp
+ :group 'allout)
;;;_ - outline-line-skip
-(defvar outline-line-skip ".05cm"
- "*Space between lines for LaTeX formatting of an outline.")
+(defcustom outline-line-skip ".05cm"
+ "*Space between lines for LaTeX formatting of an outline."
+ :type 'string
+ :group 'allout)
;;;_ - outline-indent
-(defvar outline-indent ".3cm"
- "*LaTeX formatted depth-indent spacing.")
+(defcustom outline-indent ".3cm"
+ "*LaTeX formatted depth-indent spacing."
+ :type 'string
+ :group 'allout)
;;;_ + Miscellaneous customization
("?c" outline-copy-exposed)))
;;;_ = outline-command-prefix
-(defvar outline-command-prefix "\C-c"
- "*Key sequence to be used as prefix for outline mode command key bindings.")
+(defcustom outline-command-prefix "\C-c"
+ "*Key sequence to be used as prefix for outline mode command key bindings."
+ :type 'string
+ :group 'allout)
;;;_ = outline-enwrap-isearch-mode
-(defvar outline-enwrap-isearch-mode t
+(defcustom outline-enwrap-isearch-mode t
"*Set non-nil to enable automatic exposure of concealed isearch targets.
If non-nil, isearch will expose hidden text encountered in the course
-of a search, and to reconceal it if the search is continued past it.")
+of a search, and to reconceal it if the search is continued past it."
+ :type 'boolean
+ :group 'allout)
;;;_ = outline-use-hanging-indents
-(defvar outline-use-hanging-indents t
+(defcustom outline-use-hanging-indents t
"*If non-nil, topic body text auto-indent defaults to indent of the header.
Ie, it is indented to be just past the header prefix. This is
relevant mostly for use with indented-text-mode, or other situations
where auto-fill occurs.
\[This feature no longer depends in any way on the `filladapt.el'
-lisp-archive package.\]")
+lisp-archive package.\]"
+ :type 'boolean
+ :group 'allout)
(make-variable-buffer-local 'outline-use-hanging-indents)
;;;_ = outline-reindent-bodies
-(defvar outline-reindent-bodies (if outline-use-hanging-indents
+(defcustom outline-reindent-bodies (if outline-use-hanging-indents
'text)
"*Non-nil enables auto-adjust of topic body hanging indent with depth shifts.
A value of `t' enables reindent in non-programming-code buffers, ie
those that do not have the variable `comment-start' set. A value of
-`force' enables reindent whether or not `comment-start' is set.")
+`force' enables reindent whether or not `comment-start' is set."
+ :type '(choice (const nil) (const t) (const text) (const force))
+ :group 'allout)
(make-variable-buffer-local 'outline-reindent-bodies)
;;;_ = outline-inhibit-protection
-(defvar outline-inhibit-protection nil
+(defcustom outline-inhibit-protection nil
"*Non-nil disables warnings and confirmation-checks for concealed-text edits.
Outline mode uses emacs change-triggered functions to detect unruly
This var takes effect at outline-mode activation, so you may have to
deactivate and then reactivate the mode if you want to toggle the
-behavior.")
+behavior."
+ :type 'boolean
+ :group 'allout)
;;;_* CODE - no user customizations below.
(require 'timer)
\f
-(defvar battery-status-function
+
+(defgroup battery nil
+ "Display battery status information."
+ :prefix "battery-"
+ :group 'hardware)
+
+(defcustom battery-status-function
(cond ((and (eq system-type 'gnu/linux)
(file-readable-p "/proc/apm"))
- 'battery-linux-proc-apm))
+ 'battery-linux-proc-apm))
"*Function for getting battery status information.
The function have to return an alist of conversion definitions.
Cons cells are of the form
(CONVERSION . REPLACEMENT-TEXT)
CONVERSION is the character code of a \"conversion specification\"
-introduced by a `%' character in a control string.")
+introduced by a `%' character in a control string."
+ :type 'function
+ :group 'battery)
-(defvar battery-echo-area-format
+(defcustom battery-echo-area-format
(cond ((eq battery-status-function 'battery-linux-proc-apm)
"Power %L, battery %B (%p%% load, remaining time %t)"))
"*Control string formatting the string to display in the echo area.
Ordinary characters in the control string are printed as-is, while
conversion specifications introduced by a `%' character in the control
string are substituted as defined by the current value of the variable
-`battery-status-function'.")
+`battery-status-function'."
+ :type '(choice string (const nil))
+ :group 'battery)
(defvar battery-mode-line-string nil
"String to display in the mode line.")
-(defvar battery-mode-line-format
+(defcustom battery-mode-line-format
(cond ((eq battery-status-function 'battery-linux-proc-apm)
" [%b%p%%]"))
"*Control string formatting the string to display in the mode line.
Ordinary characters in the control string are printed as-is, while
conversion specifications introduced by a `%' character in the control
string are substituted as defined by the current value of the variable
-`battery-status-function'.")
-
-(defvar battery-update-interval 60
- "*Seconds after which the battery status will be updated.")
+`battery-status-function'."
+ :type '(choice string (const nil))
+ :group 'battery)
+
+(defcustom battery-update-interval 60
+ "*Seconds after which the battery status will be updated."
+ :type 'integer
+ :group 'battery)
(defvar battery-update-timer nil
"Interval timer object.")
;;; Code:
+(defgroup chistory nil
+ "List command history."
+ :group 'keyboard)
+
;;;###autoload
(defun repeat-matching-complex-command (&optional pattern)
"Edit and re-evaluate complex command with name matching PATTERN.
(setq command-history (cdr command-history)))
(edit-and-eval-command "Redo: " what))))
-(defvar default-command-history-filter-garbage
+(defcustom default-command-history-filter-garbage
'(command-history-mode
list-command-history
electric-command-history)
"*A list of symbols to be ignored by `default-command-history-filter'.
-It that function is given a list whose car is an element of this list,
+If that function is given a list whose car is an element of this list,
then it will return non-nil (indicating the list should be discarded from
the history).
-Initially, all commands related to the command history are discarded.")
+Initially, all commands related to the command history are discarded."
+ :type '(repeat symbol)
+ :group 'chistory)
(defvar list-command-history-filter 'default-command-history-filter
"Predicate to test which commands should be excluded from the history listing.
(or (not (consp frob))
(memq (car frob) default-command-history-filter-garbage)))
-(defvar list-command-history-max 32
- "*If non-nil, maximum length of the listing produced by `list-command-history'.")
+(defcustom list-command-history-max 32
+ "*If non-nil, maximum length of the listing produced by `list-command-history'."
+ :type '(choice integer (const nil))
+ :group 'chistory)
;;;###autoload
(defun list-command-history ()
(setq major-mode (or majormode 'command-history-mode))
(setq mode-name (or modename "Command History")))
-(defvar command-history-hook nil
- "If non-nil, its value is called on entry to `command-history-mode'.")
+(defcustom command-history-hook nil
+ "If non-nil, its value is called on entry to `command-history-mode'."
+ :type 'hook
+ :group 'chistory)
(defvar command-history-map nil)
(if command-history-map
(require 'scheme)
(require 'comint)
+
+(defgroup cmuscheme nil
+ "Run a scheme process in a buffer."
+ :group 'lisp)
+
;;; INFERIOR SCHEME MODE STUFF
;;;============================================================================
-(defvar inferior-scheme-mode-hook nil
- "*Hook for customising inferior-scheme mode.")
+(defcustom inferior-scheme-mode-hook nil
+ "*Hook for customising inferior-scheme mode."
+ :type 'hook
+ :group 'cmuscheme)
+
(defvar inferior-scheme-mode-map nil)
(cond ((not inferior-scheme-mode-map)
(setq comint-get-old-input (function scheme-get-old-input))
(run-hooks 'inferior-scheme-mode-hook))
-(defvar inferior-scheme-filter-regexp "\\`\\s *\\S ?\\S ?\\s *\\'"
+(defcustom inferior-scheme-filter-regexp "\\`\\s *\\S ?\\S ?\\s *\\'"
"*Input matching this regexp are not saved on the history list.
-Defaults to a regexp ignoring all inputs of 0, 1, or 2 letters.")
+Defaults to a regexp ignoring all inputs of 0, 1, or 2 letters."
+ :type 'regexp
+ :group 'cmuscheme)
(defun scheme-input-filter (str)
"Don't save anything matching inferior-scheme-filter-regexp"
(scheme-args-to-list (substring string pos
(length string)))))))))
-(defvar scheme-program-name "scheme"
- "*Program invoked by the run-scheme command")
+(defcustom scheme-program-name "scheme"
+ "*Program invoked by the run-scheme command"
+ :type 'string
+ :group 'cmuscheme)
;;;###autoload
(defun run-scheme (cmd)
(interactive)
(scheme-send-region (save-excursion (backward-sexp) (point)) (point)))
-(defvar scheme-compile-exp-command "(compile '%s)"
- "*Template for issuing commands to compile arbitrary Scheme expressions.")
+(defcustom scheme-compile-exp-command "(compile '%s)"
+ "*Template for issuing commands to compile arbitrary Scheme expressions."
+ :type 'string
+ :group 'cmuscheme)
(defun scheme-compile-region (start end)
"Compile the current region in the inferior Scheme process.
(scheme-compile-region start end)
(switch-to-scheme t))
-(defvar scheme-source-modes '(scheme-mode)
+(defcustom scheme-source-modes '(scheme-mode)
"*Used to determine if a buffer contains Scheme source code.
If it's loaded into a buffer that is in one of these major modes, it's
considered a scheme source file by scheme-load-file and scheme-compile-file.
-Used by these commands to determine defaults.")
+Used by these commands to determine defaults."
+ :type '(repeat function)
+ :group 'cmuscheme)
(defvar scheme-prev-l/c-dir/file nil
"Caches the last (directory . file) pair.
;;; Do the user's customisation...
-(defvar cmuscheme-load-hook nil
+(defcustom cmuscheme-load-hook nil
"This hook is run when cmuscheme is loaded in.
-This is a good place to put keybindings.")
+This is a good place to put keybindings."
+ :type 'hook
+ :group 'cmuscheme)
(run-hooks 'cmuscheme-load-hook)
;;; Code:
-(defvar compare-windows-whitespace "[ \t\n]+"
+(defgroup compare-w nil
+ "Compare text between windows."
+ :prefix "compare-"
+ :group 'tools)
+
+(defcustom compare-windows-whitespace "[ \t\n]+"
"*Regexp that defines whitespace sequences for \\[compare-windows].
Changes in whitespace are optionally ignored.
The function is passed one argument, the point where `compare-windows'
was originally called; it should not consider any text before that point.
If the function returns the same value for both buffers, then the
-whitespace is considered to match, and is skipped.")
-
-(defvar compare-ignore-case nil
- "*Non-nil means \\[compare-windows] ignores case differences.")
+whitespace is considered to match, and is skipped."
+ :type '(choice regexp function)
+ :group 'compare-w)
+
+(defcustom compare-ignore-case nil
+ "*Non-nil means \\[compare-windows] ignores case differences."
+ :type 'boolean
+ :group 'compare-w)
;;;###autoload
(defun compare-windows (ignore-whitespace)
;;; Code:
;; User customizable variables
-
-(defvar docref-highlight-p t
+(defgroup docref nil
+ "Simple cross references for Elisp documentation strings."
+ :prefix "docref-"
+ :group 'help
+ :group 'lisp
+ :group 'docs)
+
+(defcustom docref-highlight-p t
"*If non-nil, \\(f@docref-subst) highlights cross-references.
Under window system it highlights them with face defined by
\\(v@docref-highlight-face), on character terminal highlighted references
-look like cross-references in info mode.")
+look like cross-references in info mode."
+ :type 'boolean
+ :group 'docref)
-(defvar docref-highlight-face 'highlight
- "*Face used to highlight cross-references (used by \\(f@docref-subst))")
+(defcustom docref-highlight-face 'highlight
+ "*Face used to highlight cross-references (used by \\(f@docref-subst))"
+ :type 'face
+ :group 'docref)
-(defvar docref-methods-alist
+(defcustom docref-methods-alist
'(("f" . docref-describe-function) ; reference to a function documentation
("v" . docref-describe-variable) ; reference to a variable documentation
("F" . docref-read-file) ; reference to a file contents
The car of each element is a string that serves as `type' in cross-references.
\(See \\(f@docref-subst)). The cdr is a function of one argument,
-to be called to find this reference.")
-
-(defvar docref-back-label "\nback"
- "Label to use by \\(f@docref-subst) for the go-back reference.")
+to be called to find this reference."
+ :type '(repeat (cons string function))
+ :group 'docref)
+
+(defcustom docref-back-label "\nback"
+ "Label to use by \\(f@docref-subst) for the go-back reference."
+ :type 'string
+ :group 'docref)
(defvar docref-back-reference nil
"If non-nil, this is a go-back reference to add to the current buffer.
;;; Code:
+(defgroup dos-fns nil
+ "MS-Dos specific functions."
+ :group 'environment)
+
;; This overrides a trivial definition in files.el.
(defun convert-standard-filename (filename)
"Convert a standard file's name to something suitable for the current OS.
(aset string (1- (length string)) lastchar))
(concat dir string))))
-(defvar msdos-shells '("command.com" "4dos.com" "ndos.com")
- "*List of shells that use `/c' instead of `-c' and a backslashed command.")
+(defcustom msdos-shells '("command.com" "4dos.com" "ndos.com")
+ "*List of shells that use `/c' instead of `-c' and a backslashed command."
+ :type '(repeat string)
+ :group 'dos-fns)
(defvar register-name-alist
'((ax . 0) (bx . 1) (cx . 2) (dx . 3) (si . 4) (di . 5)
(int86 33 regs))
;; Support for printing under MS-DOS, see lpr.el and ps-print.el.
-(defvar dos-printer "PRN"
+(defcustom dos-printer "PRN"
"*The name of a local MS-DOS device to which data is sent for printing.
\(Note that PostScript files are sent to `dos-ps-printer', which see.\)
parallel printers, or \"COM1\" to \"COM4\" or \"AUX\" for serial
printers. You can also set it to a name of a file, in which
case the output gets appended to that file.
-If you want to discard the printed output, set this to \"NUL\".")
+If you want to discard the printed output, set this to \"NUL\"."
+ :type 'file ; could use string but then we lose completion for files.
+ :group 'dos-fns)
(defun dos-print-region-function (start end
&optional lpr-prog
;; the same output as `lpr-buffer' and `lpr-region', accordingly.
(setq lpr-headers-switches "(page headers are not supported)")
-(defvar dos-ps-printer "PRN"
+(defcustom dos-ps-printer "PRN"
"*Method for printing PostScript files under MS-DOS.
If the value is a string, then it is taken as the name of the
If the value is anything but a string, PostScript files will be
piped to the program given by `ps-lpr-command', with switches
-given by `ps-lpr-switches', which see.")
+given by `ps-lpr-switches', which see."
+ :type '(choice file (const :tag "Pipe to ps-lpr-command" pipe))
+ :group 'dos-fns)
(setq ps-lpr-command "gs")
;;}}}
;;{{{ Variables
+(defgroup follow nil
+ "Synchronize windows showing the same buffer."
+ :prefix "follow-"
+ :group 'windows)
+
(defvar follow-mode nil
"Variable indicating if Follow mode is active.")
-(defvar follow-mode-hook nil
- "*Hooks to run when follow-mode is turned on.")
+(defcustom follow-mode-hook nil
+ "*Hooks to run when follow-mode is turned on."
+ :type 'hook
+ :group 'follow)
-(defvar follow-mode-off-hook nil
- "*Hooks to run when follow-mode is turned off.")
+(defcustom follow-mode-off-hook nil
+ "*Hooks to run when follow-mode is turned off."
+ :type 'hook
+ :group 'follow)
(defvar follow-mode-version "follow.el (Release 1.6)"
"The current version of Follow mode.")
(defvar follow-mode-map nil
"*Minor mode keymap for Follow mode.")
-(defvar follow-mode-line-text " Follow"
+(defcustom follow-mode-line-text " Follow"
"*Text shown in the mode line when Follow mode is active.
Defaults to \" Follow\". Examples of other values
-are \" Fw\", or simply \"\".")
+are \" Fw\", or simply \"\"."
+ :type 'string
+ :group 'follow)
-(defvar follow-auto nil
- "*Non-nil activates Follow mode whenever a file is loaded.")
+(defcustom follow-auto nil
+ "*Non-nil activates Follow mode whenever a file is loaded."
+ :type 'boolean
+ :group 'follow)
-(defvar follow-mode-prefix "\C-c."
+(defcustom follow-mode-prefix "\C-c."
"*Prefix key to use for follow commands in Follow mode.
The value of this variable is checked as part of loading Follow mode.
-After that, changing the prefix key requires manipulating keymaps.")
-
-(defvar follow-intercept-processes t
- "*When non-nil, Follow Mode will monitor process output.")
+After that, changing the prefix key requires manipulating keymaps."
+ :type 'string
+ :group 'follow)
+
+(defcustom follow-intercept-processes t
+ "*When non-nil, Follow Mode will monitor process output."
+ :type 'boolean
+ :group 'follow)
(defvar follow-emacs-version-xemacs-p
(string-match "XEmacs" emacs-version)
;;; Variables
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-(defvar shadow-noquery nil
+(defgroup shadow nil
+ "Automatic file copying when saving a file."
+ :prefix "shadow-"
+ :group 'files)
+
+(defcustom shadow-noquery nil
"*If t, always copy shadow files without asking.
If nil \(the default), always ask. If not nil and not t, ask only if there
-is no buffer currently visiting the file.")
+is no buffer currently visiting the file."
+ :type '(choice (const t) (const nil) (const :tag "Ask if no buffer" maybe))
+ :group 'shadow)
-(defvar shadow-inhibit-message nil
- "*If nonnil, do not display a message when a file needs copying.")
+(defcustom shadow-inhibit-message nil
+ "*If nonnil, do not display a message when a file needs copying."
+ :type 'boolean
+ :group 'shadow)
-(defvar shadow-inhibit-overload nil
+(defcustom shadow-inhibit-overload nil
"If nonnil, shadowfile won't redefine C-x C-c.
Normally it overloads the function `save-buffers-kill-emacs' to check
-for files have been changed and need to be copied to other systems.")
+for files have been changed and need to be copied to other systems."
+ :type 'boolean
+ :group 'shadow)
-(defvar shadow-info-file nil
+(defcustom shadow-info-file nil
"File to keep shadow information in.
The shadow-info-file should be shadowed to all your accounts to
-ensure consistency. Default: ~/.shadows")
+ensure consistency. Default: ~/.shadows"
+ :type '(choice (const nil) file)
+ :group 'shadow)
-(defvar shadow-todo-file nil
+(defcustom shadow-todo-file nil
"File to store the list of uncopied shadows in.
This means that if a remote system is down, or for any reason you cannot or
decide not to copy your shadow files at the end of one emacs session, it will
remember and ask you again in your next emacs session.
This file must NOT be shadowed to any other system, it is host-specific.
-Default: ~/.shadow_todo")
+Default: ~/.shadow_todo"
+ :type '(choice (const nil) file)
+ :group 'shadow)
+
;;; The following two variables should in most cases initialize themselves
;;; correctly. They are provided as variables in case the defaults are wrong
;;; User options
-(defvar tempo-interactive nil
+(defgroup tempo nil
+ "Flexible template insertion."
+ :prefix "tempo-"
+ :group 'tools)
+
+(defcustom tempo-interactive nil
"*Prompt user for strings in templates.
If this variable is non-nil, `tempo-insert' prompts the
-user for text to insert in the templates")
+user for text to insert in the templates"
+ :type 'boolean
+ :group 'tempo)
-(defvar tempo-insert-region nil
+(defcustom tempo-insert-region nil
"*Automatically insert current region when there is a `r' in the template
If this variable is NIL, `r' elements will be treated just like `p'
elements, unless the template function is given a prefix (or a non-nil
argument). If this variable is non-NIL, the behaviour is reversed.
-In Transient Mark mode, this option is unused.")
+In Transient Mark mode, this option is unused."
+ :type 'boolean
+ :group 'tempo)
-(defvar tempo-show-completion-buffer t
+(defcustom tempo-show-completion-buffer t
"*If non-NIL, show a buffer with possible completions, when only
-a partial completion can be found")
+a partial completion can be found"
+ :type 'boolean
+ :group 'tempo)
-(defvar tempo-leave-completion-buffer nil
+(defcustom tempo-leave-completion-buffer nil
"*If NIL, a completion buffer generated by \\[tempo-complete-tag]
-disappears at the next keypress; otherwise, it remains forever.")
+disappears at the next keypress; otherwise, it remains forever."
+ :type 'boolean
+ :group 'tempo)
;;; Internal variables
;;; Code:
-(defvar ispell-have-new-look t
- "Non-nil means use the `-r' option when running `look'.")
+(defgroup ispell4 nil
+ "Interface to GNU ISPELL version 4."
+ :prefix "ispell-"
+ :group 'applications)
+
+(defcustom ispell-have-new-look t
+ "Non-nil means use the `-r' option when running `look'."
+ :type 'boolean
+ :group 'ispell4)
(defvar ispell-enable-tex-parser nil
"Non-nil enables experimental TeX parser in Ispell for TeX-mode buffers.")
(defvar ispell-next-message nil
"An integer: where in `*ispell*' buffer to find next message from Ispell.")
-(defvar ispell-command "ispell"
- "Command for running Ispell.")
-(defvar ispell-command-options nil
+(defcustom ispell-command "ispell"
+ "Command for running Ispell."
+ :type 'string
+ :group 'ispell4)
+
+(defcustom ispell-command-options nil
"*String (or list of strings) to pass to Ispell as command arguments.
You can specify your private dictionary via the -p <filename> option.
The -S option is always passed to Ispell as the last parameter,
-and need not be mentioned here.")
+and need not be mentioned here."
+ :type '(repeat string)
+ :group 'ispell4)
-(defvar ispell-look-command "look"
- "*Command for running look.")
+(defcustom ispell-look-command "look"
+ "*Command for running look."
+ :type 'string
+ :group 'ispell4)
;Each marker in this list points to the start of a word that
;ispell thought was bad last time it did the :file command.
(kill-emacs 1))
(write-region (point-min) (point-max) "ispell.info"))
-(defvar ispell-highlight t
- "*Non-nil means to highlight ispell words.")
+(defcustom ispell-highlight t
+ "*Non-nil means to highlight ispell words."
+ :type 'boolean
+ :group 'ispell4)
(defvar ispell-overlay nil)
;;;; User-defined variables.
-(defvar ispell-look-dictionary nil
+(defcustom ispell-look-dictionary nil
"*If non-nil then spelling dictionary as string for `ispell-complete-word'.
Overrides default dictionary file such as \"/usr/dict/words\" or GNU look's
-\"${prefix}/lib/ispell/ispell.words\"")
+\"${prefix}/lib/ispell/ispell.words\""
+ :type '(choice (const nil) file)
+ :group 'ispell4)
+
-(defvar ispell-gnu-look-still-broken-p nil
+(defcustom ispell-gnu-look-still-broken-p nil
"*t if GNU look -r can give different results with and without trailing `.*'.
Example: `look -dfr \"^ya\" foo' returns nothing, while `look -dfr \"^ya.*\" foo'
returns `yacc', where `foo' is a dictionary file containing the three lines
Both commands should return `yacc'. If `ispell-complete-word' erroneously
states that no completions exist for a string, then setting this variable to t
-will help find those completions.")
+will help find those completions."
+ :type 'boolean
+ :group 'ispell4)
;;;; Internal variables.
"\\'\\`" ; An unmatchable string if string is null.
(regexp-quote string)))
-(defvar ispell-message-cite-regexp "^ \\|^\t"
- "*Regular expression to match lines cited from one message into another.")
+(defcustom ispell-message-cite-regexp "^ \\|^\t"
+ "*Regular expression to match lines cited from one message into another."
+ :type 'regexp
+ :group 'ispell4)
-(defvar ispell-message-text-end
+(defcustom ispell-message-text-end
(concat "^\\(" (mapconcat (function identity)
'(
;; Matches postscript files.
"\\)")
"*End of text which will be checked in ispell-message.
If it is a string, limit at first occurrence of that regular expression.
-Otherwise, it must be a function which is called to get the limit.")
+Otherwise, it must be a function which is called to get the limit."
+ :type '(choice string function)
+ :group 'ispell4)
-(defvar ispell-message-limit (* 100 80)
- "*Ispell-message will check no more than this number of characters.")
+(defcustom ispell-message-limit (* 100 80)
+ "*Ispell-message will check no more than this number of characters."
+ :type 'integer
+ :group 'ispell4)
;;;autoload
(defun ispell-message ()
(provide 'ispell)
-;;; ispell.el ends here
+;;; ispell4.el ends here
(require 'electric)
+(defgroup tmm nil
+ "Text mode access to menu-bar."
+ :prefix "tmm-"
+ :group 'menu)
+
;;; The following will be localized, added only to pacify the compiler.
(defvar tmm-short-cuts)
(defvar tmm-old-mb-map nil)
(interactive "e")
(tmm-menubar (car (posn-x-y (event-start event)))))
-(defvar tmm-mid-prompt "==>"
+(defcustom tmm-mid-prompt "==>"
"*String to insert between shortcut and menu item.
If nil, there will be no shortcuts. It should not consist only of spaces,
-or else the correct item might not be found in the `*Completions*' buffer.")
+or else the correct item might not be found in the `*Completions*' buffer."
+ :type 'string
+ :group 'tmm)
(defvar tmm-mb-map nil
"A place to store minibuffer map.")
-(defvar tmm-completion-prompt
+(defcustom tmm-completion-prompt
"Press PageUp Key to reach this buffer from the minibuffer.
Alternatively, you can use Up/Down keys (or your History keys) to change
the item in the minibuffer, and press RET when you are done, or press the
"
"*Help text to insert on the top of the completion buffer.
To save space, you can set this to nil,
-in which case the standard introduction text is deleted too.")
+in which case the standard introduction text is deleted too."
+ :type '(choice string (const nil))
+ :group 'tmm)
-(defvar tmm-shortcut-style '(downcase upcase)
+(defcustom tmm-shortcut-style '(downcase upcase)
"*What letters to use as menu shortcuts.
Must be either one of the symbols `downcase' or `upcase',
-or else a list of the two in the order you prefer.")
+or else a list of the two in the order you prefer."
+ :type '(choice (const downcase)
+ (const upcase)
+ (repeat (choice (const downcase) (const upcase))))
+ :group 'tmm)
-(defvar tmm-shortcut-words 2
+(defcustom tmm-shortcut-words 2
"*How many successive words to try for shortcuts, nil means all.
If you use only one of `downcase' or `upcase' for `tmm-shortcut-style',
-specify nil for this variable.")
+specify nil for this variable."
+ :type '(choice integer (const nil))
+ :group 'tmm)
;;;###autoload
(defun tmm-prompt (menu &optional in-popup default-item)
;;; Code:
+(defgroup vcursor nil
+ "Manipulate an alternative (\"virtual\") cursor."
+ :prefix "vcursor-"
+ :group 'display)
+
(or (memq 'vcursor (face-list))
(progn
(copy-face 'modeline 'vcursor)
(set-face-background 'vcursor "cyan")))
(set-face-underline-p 'vcursor t)))
-(defvar vcursor-auto-disable nil
+(defcustom vcursor-auto-disable nil
"*If non-nil, disable the virtual cursor after use.
-Any non-vcursor command will force `vcursor-disable' to be called.")
+Any non-vcursor command will force `vcursor-disable' to be called."
+ :type 'boolean
+ :group 'vcursor)
-(defvar vcursor-key-bindings t
+(defcustom vcursor-key-bindings t
"*How to bind keys when vcursor is loaded.
If t (the default), guess; if xterm, use bindings suitable for an
X terminal; if oemacs, use bindings which work on a PC with Oemacs.
-If nil, don't define any key bindings.")
+If nil, don't define any key bindings."
+ :type '(choice (const t) (const xterm) (const oemacs) (const nil))
+ :group 'vcursor)
-(defvar vcursor-interpret-input nil
+(defcustom vcursor-interpret-input nil
"*If non-nil, input from the vcursor is treated as interactive input.
This will cause text insertion to be much slower. Note that no special
interpretation of strings is done: \"\C-x\" is a string of four
-characters. The default is simply to copy strings.")
+characters. The default is simply to copy strings."
+ :type 'boolean
+ :group 'vcursor)
-(defvar vcursor-string "**>"
- "String used to show the vcursor position on dumb terminals.")
+(defcustom vcursor-string "**>"
+ "String used to show the vcursor position on dumb terminals."
+ :type 'string
+ :group 'vcursor)
(defvar vcursor-overlay nil
"Overlay for the virtual cursor.
;; could do some memq-ing with last-command instead, but this will
;; automatically handle any new commands using the primitives.
-(defvar vcursor-copy-flag nil
- "*Non-nil means moving vcursor should copy characters moved over to point.")
+(defcustom vcursor-copy-flag nil
+ "*Non-nil means moving vcursor should copy characters moved over to point."
+ :type 'boolean
+ :group 'vcursor)
(defvar vcursor-temp-goal-column nil
"Keeps track of temporary goal columns for the virtual cursor.")
(require 'scheme)
\f
-(defvar scheme-program-name "scheme"
- "*Program invoked by the `run-scheme' command.")
-
-(defvar scheme-band-name nil
- "*Band loaded by the `run-scheme' command.")
-
-(defvar scheme-program-arguments nil
- "*Arguments passed to the Scheme program by the `run-scheme' command.")
-
-(defvar xscheme-allow-pipelined-evaluation t
+(defgroup xscheme nil
+ "Major mode for editing Scheme and interacting with MIT's C-Scheme."
+ :group 'lisp)
+
+(defcustom scheme-program-name "scheme"
+ "*Program invoked by the `run-scheme' command."
+ :type 'string
+ :group 'xscheme)
+
+(defcustom scheme-band-name nil
+ "*Band loaded by the `run-scheme' command."
+ :type '(choice (const nil) string)
+ :group 'xscheme)
+
+(defcustom scheme-program-arguments nil
+ "*Arguments passed to the Scheme program by the `run-scheme' command."
+ :type '(choice (const nil) string)
+ :group 'xscheme)
+
+(defcustom xscheme-allow-pipelined-evaluation t
"If non-nil, an expression may be transmitted while another is evaluating.
Otherwise, attempting to evaluate an expression before the previous expression
-has finished evaluating will signal an error.")
+has finished evaluating will signal an error."
+ :type 'boolean
+ :group 'xscheme)
-(defvar xscheme-startup-message
+(defcustom xscheme-startup-message
"This is the Scheme process buffer.
Type \\[advertised-xscheme-send-previous-expression] to evaluate the expression before point.
Type \\[xscheme-send-control-g-interrupt] to abort evaluation.
"
"String to insert into Scheme process buffer first time it is started.
-Is processed with `substitute-command-keys' first.")
+Is processed with `substitute-command-keys' first."
+ :type 'string
+ :group 'xscheme)
-(defvar xscheme-signal-death-message nil
- "If non-nil, causes a message to be generated when the Scheme process dies.")
+(defcustom xscheme-signal-death-message nil
+ "If non-nil, causes a message to be generated when the Scheme process dies."
+ :type 'boolean
+ :group 'xscheme)
(defun xscheme-evaluation-commands (keymap)
(define-key keymap "\e\C-x" 'xscheme-send-definition)
(defvar xscheme-string-receiver nil
"Procedure to send the string argument from the scheme process.")
-(defvar xscheme-start-hook nil
+(defcustom xscheme-start-hook nil
"If non-nil, a procedure to call when the Scheme process is started.
-When called, the current buffer will be the Scheme process-buffer.")
+When called, the current buffer will be the Scheme process-buffer."
+ :type 'hook
+ :group 'xscheme)
(defvar xscheme-runlight-string nil)
(defvar xscheme-mode-string nil)
HCoop / bpt / emacs.git / commitdiff