[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [Search] [Page Top / Page Bottom] [?]

14. Writing Customization Definitions

comment(none) to "lispref/WritingCustomizationDefinitions"

This chapter describes how to declare user options for customization, and also customization groups for classifying them. We use the term customization item to include both kinds of customization definitions--as well as face definitions (see section 38.12.1 Defining Faces).

[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [Search] [Page Top / Page Bottom] [?]

14.1 Common Item Keywords

comment(none) to "lispref/CommonItemKeywords"

All kinds of customization declarations (for variables and groups, and for faces) accept keyword arguments for specifying various information. This section describes some keywords that apply to all kinds.

All of these keywords, except :tag, can be used more than once in a given item. Each use of the keyword has an independent effect. The keyword :tag is an exception because any given item can only display one name.

:tag label
Use label, a string, instead of the item's name, to label the item in customization menus and buffers. Don't use a tag which is substantially different from the item's real name; that would cause confusion. One legitimate case for use of :tag is to specify a dash where normally a hyphen would be converted to a space:

(defcustom cursor-in-non-selected-windows ...
  :tag "Cursor In Non-selected Windows"

:group group
Put this customization item in group group. When you use :group in a defgroup, it makes the new group a subgroup of group.

If you use this keyword more than once, you can put a single item into more than one group. Displaying any of those groups will show this item. Please don't overdo this, since the result would be annoying.

:link link-data
Include an external link after the documentation string for this item. This is a sentence containing an active field which references some other documentation.

There are several alternatives you can use for link-data:

(custom-manual info-node)
Link to an Info node; info-node is a string which specifies the node name, as in "(emacs)Top". The link appears as `[Manual]' in the customization buffer and enters the built-in Info reader on info-node.

(info-link info-node)
Like custom-manual except that the link appears in the customization buffer with the Info node name.

(url-link url)
Link to a web page; url is a string which specifies the URL. The link appears in the customization buffer as url and invokes the WWW browser specified by browse-url-browser-function.

(emacs-commentary-link library)
Link to the commentary section of a library; library is a string which specifies the library name.

(emacs-library-link library)
Link to an Emacs Lisp library file; library is a string which specifies the library name.

(file-link file)
Link to a file; file is a string which specifies the name of the file to visit with find-file when the user invokes this link.

(function-link function)
Link to the documentation of a function; function is a string which specifies the name of the function to describe with describe-function when the user invokes this link.

(variable-link variable)
Link to the documentation of a variable; variable is a string which specifies the name of the variable to describe with describe-variable when the user invokes this link.

(custom-group-link group)
Link to another customization group. Invoking it creates a new customization buffer for group.

You can specify the text to use in the customization buffer by adding :tag name after the first element of the link-data; for example, (info-link :tag "foo" "(emacs)Top") makes a link to the Emacs manual which appears in the buffer as `foo'.

An item can have more than one external link; however, most items have none at all.

:load file
Load file file (a string) before displaying this customization item. Loading is done with load-library, and only if the file is not already loaded.

:require feature
Execute (require 'feature) when your saved customizations set the value of this item. feature should be a symbol.

The most common reason to use :require is when a variable enables a feature such as a minor mode, and just setting the variable won't have any effect unless the code which implements the mode is loaded.

:version version
This keyword specifies that the item was first introduced in Emacs version version, or that its default value was changed in that version. The value version must be a string.

:package-version '(package . version)
This keyword specifies that the item was first introduced in package version version, or that its meaning or default value was changed in that version. The value of package is a symbol and version is a string.

This keyword takes priority over :version.

package should be the official name of the package, such as MH-E or Gnus. If the package package is released as part of Emacs, package and version should appear in the value of customize-package-emacs-version-alist.

Packages distributed as part of Emacs that use the :package-version keyword must also update the customize-package-emacs-version-alist variable.

Variable: customize-package-emacs-version-alist
This alist provides a mapping for the versions of Emacs that are associated with versions of a package listed in the :package-version keyword. Its elements look like this:

(package (pversion . eversion)...)

For each package, which is a symbol, there are one or more elements that contain a package version pversion with an associated Emacs version eversion. These versions are strings. For example, the MH-E package updates this alist with the following:

(add-to-list 'customize-package-emacs-version-alist
             '(MH-E ("6.0" . "22.1") ("6.1" . "22.1") ("7.0" . "22.1")
                    ("7.1" . "22.1") ("7.2" . "22.1") ("7.3" . "22.1")
                    ("7.4" . "22.1") ("8.0" . "22.1")))

The value of package needs to be unique and it needs to match the package value appearing in the :package-version keyword. Since the user might see the value in a error message, a good choice is the official name of the package, such as MH-E or Gnus.

[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [Search] [Page Top / Page Bottom] [?]

14.2 Defining Customization Groups

comment(none) to "lispref/DefiningCustomizationGroups"

Each Emacs Lisp package should have one main customization group which contains all the options, faces and other groups in the package. If the package has a small number of options and faces, use just one group and put everything in it. When there are more than twelve or so options and faces, then you should structure them into subgroups, and put the subgroups under the package's main customization group. It is OK to put some of the options and faces in the package's main group alongside the subgroups.

The package's main or only group should be a member of one or more of the standard customization groups. (To display the full list of them, use M-x customize.) Choose one or more of them (but not too many), and add your group to each of them using the :group keyword.

The way to declare new customization groups is with defgroup.

Macro: defgroup group members doc [keyword value]...
Declare group as a customization group containing members. Do not quote the symbol group. The argument doc specifies the documentation string for the group.

The argument members is a list specifying an initial set of customization items to be members of the group. However, most often members is nil, and you specify the group's members by using the :group keyword when defining those members.

If you want to specify group members through members, each element should have the form (name widget). Here name is a symbol, and widget is a widget type for editing that symbol. Useful widgets are custom-variable for a variable, custom-face for a face, and custom-group for a group.

When you introduce a new group into Emacs, use the :version keyword in the defgroup; then you need not use it for the individual members of the group.

In addition to the common keywords (see section 14.1 Common Item Keywords), you can also use this keyword in defgroup:

:prefix prefix
If the name of an item in the group starts with prefix, then the tag for that item is constructed (by default) by omitting prefix.

One group can have any number of prefixes.

The prefix-discarding feature is currently turned off, which means that :prefix currently has no effect. We did this because we found that discarding the specified prefixes often led to confusing names for options. This happened because the people who wrote the defgroup definitions for various groups added :prefix keywords whenever they make logical sense--that is, whenever the variables in the library have a common prefix.

In order to obtain good results with :prefix, it would be necessary to check the specific effects of discarding a particular prefix, given the specific items in a group and their names and documentation. If the resulting text is not clear, then :prefix should not be used in that case.

It should be possible to recheck all the customization groups, delete the :prefix specifications which give unclear results, and then turn this feature back on, if someone would like to do the work.

[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [Search] [Page Top / Page Bottom] [?]

14.3 Defining Customization Variables

comment(none) to "lispref/DefiningCustomizationVariables"

Use defcustom to declare user-customizable variables.

Macro: defcustom option standard doc [keyword value]...
This construct declares option as a customizable user option variable. You should not quote option. The argument doc specifies the documentation string for the variable. There is no need to start it with a `*', because defcustom automatically marks option as a user option (see section 11.5 Defining Global Variables).

The argument standard is an expression that specifies the standard value for option. Evaluating the defcustom form evaluates standard, but does not necessarily install the standard value. If option already has a default value, defcustom does not change it. If the user has saved a customization for option, defcustom installs the user's customized value as option's default value. If neither of those cases applies, defcustom installs the result of evaluating standard as the default value.

The expression standard can be evaluated at various other times, too--whenever the customization facility needs to know option's standard value. So be sure to use an expression which is harmless to evaluate at any time. We recommend avoiding backquotes in standard, because they are not expanded when editing the value, so list values will appear to have the wrong structure.

Every defcustom should specify :group at least once.

If you specify the :set keyword, to make the variable take other special actions when set through the customization buffer, the variable's documentation string should tell the user specifically how to do the same job in hand-written Lisp code.

When you evaluate a defcustom form with C-M-x in Emacs Lisp mode (eval-defun), a special feature of eval-defun arranges to set the variable unconditionally, without testing whether its value is void. (The same feature applies to defvar.) See section 11.5 Defining Global Variables.

defcustom accepts the following additional keywords:

:type type
Use type as the data type for this option. It specifies which values are legitimate, and how to display the value. See section 14.4 Customization Types, for more information.

:options value-list
Specify the list of reasonable values for use in this option. The user is not restricted to using only these values, but they are offered as convenient alternatives.

This is meaningful only for certain types, currently including hook, plist and alist. See the definition of the individual types for a description of how to use :options.

:set setfunction
Specify setfunction as the way to change the value of this option. The function setfunction should take two arguments, a symbol (the option name) and the new value, and should do whatever is necessary to update the value properly for this option (which may not mean simply setting the option as a Lisp variable). The default for setfunction is set-default.

:get getfunction
Specify getfunction as the way to extract the value of this option. The function getfunction should take one argument, a symbol, and should return whatever customize should use as the "current value" for that symbol (which need not be the symbol's Lisp value). The default is default-value.

You have to really understand the workings of Custom to use :get correctly. It is meant for values that are treated in Custom as variables but are not actually stored in Lisp variables. It is almost surely a mistake to specify getfunction for a value that really is stored in a Lisp variable.

:initialize function
function should be a function used to initialize the variable when the defcustom is evaluated. It should take two arguments, the option name (a symbol) and the value. Here are some predefined functions meant for use in this way:

Use the variable's :set function to initialize the variable, but do not reinitialize it if it is already non-void.

Like custom-initialize-set, but use the function set-default to set the variable, instead of the variable's :set function. This is the usual choice for a variable whose :set function enables or disables a minor mode; with this choice, defining the variable will not call the minor mode function, but customizing the variable will do so.

Always use the :set function to initialize the variable. If the variable is already non-void, reset it by calling the :set function using the current value (returned by the :get method). This is the default :initialize function.

Use the :set function to initialize the variable, if it is already set or has been customized; otherwise, just use set-default.

These functions behave like custom-initialize-set (custom-initialize-default, respectively), but catch errors. If an error occurs during initialization, they set the variable to nil using set-default, and throw no error.

These two functions are only meant for options defined in pre-loaded files, where some variables or functions used to compute the option's value may not yet be defined. The option normally gets updated in `startup.el', ignoring the previously computed value. Because of this typical usage, the value which these two functions compute normally only matters when, after startup, one unsets the option's value and then reevaluates the defcustom. By that time, the necessary variables and functions will be defined, so there will not be an error.

:risky value
Set this variable's risky-local-variable property to value.

:safe function
Set this variable's safe-local-variable property to function.

:set-after variables
When setting variables according to saved customizations, make sure to set the variables variables before this one; in other words, delay setting this variable until after those others have been handled. Use :set-after if setting this variable won't work properly unless those other variables already have their intended values.

The :require keyword is useful for an option that turns on the operation of a certain feature. Assuming that the package is coded to check the value of the option, you still need to arrange for the package to be loaded. You can do that with :require. See section 14.1 Common Item Keywords. Here is an example, from the library `saveplace.el':

(defcustom save-place nil
  "Non-nil means automatically save place in each file..."
  :type 'boolean
  :require 'saveplace
  :group 'save-place)

If a customization item has a type such as hook or alist, which supports :options, you can add additional values to the list from outside the defcustom declaration by calling custom-add-frequent-value. For example, if you define a function my-lisp-mode-initialization intended to be called from emacs-lisp-mode-hook, you might want to add that to the list of reasonable values for emacs-lisp-mode-hook, but not by editing its definition. You can do it thus:

(custom-add-frequent-value 'emacs-lisp-mode-hook

Function: custom-add-frequent-value symbol value
For the customization option symbol, add value to the list of reasonable values.

The precise effect of adding a value depends on the customization type of symbol.

Internally, defcustom uses the symbol property standard-value to record the expression for the standard value, and saved-value to record the value saved by the user with the customization buffer. Both properties are actually lists whose car is an expression which evaluates to the value.

[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [Search] [Page Top / Page Bottom] [?]

14.4 Customization Types

comment(none) to "lispref/CustomizationTypes"

When you define a user option with defcustom, you must specify its customization type. That is a Lisp object which describes (1) which values are legitimate and (2) how to display the value in the customization buffer for editing.

You specify the customization type in defcustom with the :type keyword. The argument of :type is evaluated, but only once when the defcustom is executed, so it isn't useful for the value to vary. Normally we use a quoted constant. For example:

(defcustom diff-command "diff"
  "The command to use to run diff."
  :type '(string)
  :group 'diff)

In general, a customization type is a list whose first element is a symbol, one of the customization type names defined in the following sections. After this symbol come a number of arguments, depending on the symbol. Between the type symbol and its arguments, you can optionally write keyword-value pairs (see section 14.4.4 Type Keywords).

Some of the type symbols do not use any arguments; those are called simple types. For a simple type, if you do not use any keyword-value pairs, you can omit the parentheses around the type symbol. For example just string as a customization type is equivalent to (string).

14.4.1 Simple Types   
14.4.2 Composite Types   
14.4.3 Splicing into Lists   
14.4.4 Type Keywords   
14.4.5 Defining New Types   

All customization types are implemented as widgets; see section `Introduction' in

The Emacs Widget Library
, for details.

[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [Search] [Page Top / Page Bottom] [?]

14.4.1 Simple Types

comment(none) to "lispref/SimpleTypes"

This section describes all the simple customization types.

The value may be any Lisp object that can be printed and read back. You can use sexp as a fall-back for any option, if you don't want to take the time to work out a more specific type to use.

The value must be an integer, and is represented textually in the customization buffer.

The value must be a number (floating point or integer), and is represented textually in the customization buffer.

The value must be a floating point number, and is represented textually in the customization buffer.

The value must be a string, and the customization buffer shows just the contents, with no delimiting `"' characters and no quoting with `\'.

Like string except that the string must be a valid regular expression.

The value must be a character code. A character code is actually an integer, but this type shows the value by inserting the character in the buffer, rather than by showing the number.

The value must be a file name, and you can do completion with M-TAB.

(file :must-match t)
The value must be a file name for an existing file, and you can do completion with M-TAB.

The value must be a directory name, and you can do completion with M-TAB.

The value must be a list of functions (or a single function, but that is obsolete usage). This customization type is used for hook variables. You can use the :options keyword in a hook variable's defcustom to specify a list of functions recommended for use in the hook; see 14.3 Defining Customization Variables.

The value must be a list of cons-cells, the CAR of each cell representing a key, and the CDR of the same cell representing an associated value. The user can add and delete key/value pairs, and edit both the key and the value of each pair.

You can specify the key and value types like this:

(alist :key-type key-type :value-type value-type)

where key-type and value-type are customization type specifications. The default key type is sexp, and the default value type is sexp.

The user can add any key matching the specified key type, but you can give some keys a preferential treatment by specifying them with the :options (see 14.3 Defining Customization Variables). The specified keys will always be shown in the customize buffer (together with a suitable value), with a checkbox to include or exclude or disable the key/value pair from the alist. The user will not be able to edit the keys specified by the :options keyword argument.

The argument to the :options keywords should be a list of specifications for reasonable keys in the alist. Ordinarily, they are simply atoms, which stand for themselves as. For example:

:options '("foo" "bar" "baz")

specifies that there are three "known" keys, namely "foo", "bar" and "baz", which will always be shown first.

You may want to restrict the value type for specific keys, for example, the value associated with the "bar" key can only be an integer. You can specify this by using a list instead of an atom in the list. The first element will specify the key, like before, while the second element will specify the value type. For example:

:options '("foo" ("bar" integer) "baz")

Finally, you may want to change how the key is presented. By default, the key is simply shown as a const, since the user cannot change the special keys specified with the :options keyword. However, you may want to use a more specialized type for presenting the key, like function-item if you know it is a symbol with a function binding. This is done by using a customization type specification instead of a symbol for the key.

:options '("foo" ((function-item some-function) integer)

Many alists use lists with two elements, instead of cons cells. For example,

(defcustom list-alist '(("foo" 1) ("bar" 2) ("baz" 3))
  "Each element is a list of the form (KEY VALUE).")

instead of

(defcustom cons-alist '(("foo" . 1) ("bar" . 2) ("baz" . 3))
  "Each element is a cons-cell (KEY . VALUE).")

Because of the way lists are implemented on top of cons cells, you can treat list-alist in the example above as a cons cell alist, where the value type is a list with a single element containing the real value.

(defcustom list-alist '(("foo" 1) ("bar" 2) ("baz" 3))
  "Each element is a list of the form (KEY VALUE)."
  :type '(alist :value-type (group integer)))

The group widget is used here instead of list only because the formatting is better suited for the purpose.

Similarly, you can have alists with more values associated with each key, using variations of this trick:

(defcustom person-data '(("brian"  50 t)
                         ("dorith" 55 nil)
                         ("ken"    52 t))
  "Alist of basic info about people.
Each element has the form (NAME AGE MALE-FLAG)."
  :type '(alist :value-type (group integer boolean)))

(defcustom pets '(("brian")
                  ("dorith" "dog" "guppy")
                  ("ken" "cat"))
  "Alist of people's pets.
In an element (KEY . VALUE), KEY is the person's name,
and the VALUE is a list of that person's pets."
  :type '(alist :value-type (repeat string)))

The plist custom type is similar to the alist (see above), except that the information is stored as a property list, i.e. a list of this form:

(key value key value key value ...)

The default :key-type for plist is symbol, rather than sexp.

The value must be a symbol. It appears in the customization buffer as the name of the symbol.

The value must be either a lambda expression or a function name. When it is a function name, you can do completion with M-TAB.

The value must be a variable name, and you can do completion with M-TAB.

The value must be a symbol which is a face name, and you can do completion with M-TAB.

The value is boolean--either nil or t. Note that by using choice and const together (see the next section), you can specify that the value must be nil or t, but also specify the text to describe each value in a way that fits the specific meaning of the alternative.

The value must be a coding-system name, and you can do completion with M-TAB.

The value must be a valid color name, and you can do completion with M-TAB. A sample is provided.

[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [Search] [Page Top / Page Bottom] [?]

14.4.2 Composite Types

comment(none) to "lispref/CompositeTypes"

When none of the simple types is appropriate, you can use composite types, which build new types from other types or from specified data. The specified types or data are called the arguments of the composite type. The composite type normally looks like this:

(constructor arguments...)

but you can also add keyword-value pairs before the arguments, like this:

(constructor {keyword value}... arguments...)

Here is a table of constructors and how to use them to write composite types:

(cons car-type cdr-type)
The value must be a cons cell, its CAR must fit car-type, and its CDR must fit cdr-type. For example, (cons string symbol) is a customization type which matches values such as ("foo" . foo).

In the customization buffer, the CAR and the CDR are displayed and edited separately, each according to the type that you specify for it.

(list element-types...)
The value must be a list with exactly as many elements as the element-types given; and each element must fit the corresponding element-type.

For example, (list integer string function) describes a list of three elements; the first element must be an integer, the second a string, and the third a function.

In the customization buffer, each element is displayed and edited separately, according to the type specified for it.

(vector element-types...)
Like list except that the value must be a vector instead of a list. The elements work the same as in list.

(choice alternative-types...)
The value must fit at least one of alternative-types. For example, (choice integer string) allows either an integer or a string.

In the customization buffer, the user selects an alternative using a menu, and can then edit the value in the usual way for that alternative.

Normally the strings in this menu are determined automatically from the choices; however, you can specify different strings for the menu by including the :tag keyword in the alternatives. For example, if an integer stands for a number of spaces, while a string is text to use verbatim, you might write the customization type this way,

(choice (integer :tag "Number of spaces")
        (string :tag "Literal text"))

so that the menu offers `Number of spaces' and `Literal text'.

In any alternative for which nil is not a valid value, other than a const, you should specify a valid default for that alternative using the :value keyword. See section 14.4.4 Type Keywords.

If some values are covered by more than one of the alternatives, customize will choose the first alternative that the value fits. This means you should always list the most specific types first, and the most general last. Here's an example of proper usage:

(choice (const :tag "Off" nil)
        symbol (sexp :tag "Other"))

This way, the special value nil is not treated like other symbols, and symbols are not treated like other Lisp expressions.

(radio element-types...)
This is similar to choice, except that the choices are displayed using `radio buttons' rather than a menu. This has the advantage of displaying documentation for the choices when applicable and so is often a good choice for a choice between constant functions (function-item customization types).

(const value)
The value must be value---nothing else is allowed.

The main use of const is inside of choice. For example, (choice integer (const nil)) allows either an integer or nil.

:tag is often used with const, inside of choice. For example,

(choice (const :tag "Yes" t)
        (const :tag "No" nil)
        (const :tag "Ask" foo))

describes a variable for which t means yes, nil means no, and foo means "ask."

(other value)
This alternative can match any Lisp value, but if the user chooses this alternative, that selects the value value.

The main use of other is as the last element of choice. For example,

(choice (const :tag "Yes" t)
        (const :tag "No" nil)
        (other :tag "Ask" foo))

describes a variable for which t means yes, nil means no, and anything else means "ask." If the user chooses `Ask' from the menu of alternatives, that specifies the value foo; but any other value (not t, nil or foo) displays as `Ask', just like foo.

(function-item function)
Like const, but used for values which are functions. This displays the documentation string as well as the function name. The documentation string is either the one you specify with :doc, or function's own documentation string.

(variable-item variable)
Like const, but used for values which are variable names. This displays the documentation string as well as the variable name. The documentation string is either the one you specify with :doc, or variable's own documentation string.

(set types...)
The value must be a list, and each element of the list must match one of the types specified.

This appears in the customization buffer as a checklist, so that each of types may have either one corresponding element or none. It is not possible to specify two different elements that match the same one of types. For example, (set integer symbol) allows one integer and/or one symbol in the list; it does not allow multiple integers or multiple symbols. As a result, it is rare to use nonspecific types such as integer in a set.

Most often, the types in a set are const types, as shown here:

(set (const :bold) (const :italic))

Sometimes they describe possible elements in an alist:

(set (cons :tag "Height" (const height) integer)
     (cons :tag "Width" (const width) integer))

That lets the user specify a height value optionally and a width value optionally.

(repeat element-type)
The value must be a list and each element of the list must fit the type element-type. This appears in the customization buffer as a list of elements, with `[INS]' and `[DEL]' buttons for adding more elements or removing elements.

(restricted-sexp :match-alternatives criteria)
This is the most general composite type construct. The value may be any Lisp object that satisfies one of criteria. criteria should be a list, and each element should be one of these possibilities:

For example,

(restricted-sexp :match-alternatives
                 (integerp 't 'nil))

allows integers, t and nil as legitimate values.

The customization buffer shows all legitimate values using their read syntax, and the user edits them textually.

Here is a table of the keywords you can use in keyword-value pairs in a composite type:

:tag tag
Use tag as the name of this alternative, for user communication purposes. This is useful for a type that appears inside of a choice.

:match-alternatives criteria
Use criteria to match possible values. This is used only in restricted-sexp.

:args argument-list
Use the elements of argument-list as the arguments of the type construct. For instance, (const :args (foo)) is equivalent to (const foo). You rarely need to write :args explicitly, because normally the arguments are recognized automatically as whatever follows the last keyword-value pair.

[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [Search] [Page Top / Page Bottom] [?]

14.4.3 Splicing into Lists

comment(none) to "lispref/SplicingintoLists"

The :inline feature lets you splice a variable number of elements into the middle of a list or vector. You use it in a set, choice or repeat type which appears among the element-types of a list or vector.

Normally, each of the element-types in a list or vector describes one and only one element of the list or vector. Thus, if an element-type is a repeat, that specifies a list of unspecified length which appears as one element.

But when the element-type uses :inline, the value it matches is merged directly into the containing sequence. For example, if it matches a list with three elements, those become three elements of the overall sequence. This is analogous to using `,@' in the backquote construct.

For example, to specify a list whose first element must be baz and whose remaining arguments should be zero or more of foo and bar, use this customization type:

(list (const baz) (set :inline t (const foo) (const bar)))

This matches values such as (baz), (baz foo), (baz bar) and (baz foo bar).

When the element-type is a choice, you use :inline not in the choice itself, but in (some of) the alternatives of the choice. For example, to match a list which must start with a file name, followed either by the symbol t or two strings, use this customization type:

(list file
      (choice (const t)
              (list :inline t string string)))

If the user chooses the first alternative in the choice, then the overall list has two elements and the second element is t. If the user chooses the second alternative, then the overall list has three elements and the second and third must be strings.

[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [Search] [Page Top / Page Bottom] [?]

14.4.4 Type Keywords

comment(none) to "lispref/TypeKeywords"

You can specify keyword-argument pairs in a customization type after the type name symbol. Here are the keywords you can use, and their meanings:

:value default
This is used for a type that appears as an alternative inside of choice; it specifies the default value to use, at first, if and when the user selects this alternative with the menu in the customization buffer.

Of course, if the actual value of the option fits this alternative, it will appear showing the actual value, not default.

If nil is not a valid value for the alternative, then it is essential to specify a valid default with :value.

:format format-string
This string will be inserted in the buffer to represent the value corresponding to the type. The following `%' escapes are available for use in format-string:

Display the text button marked as a button. The :action attribute specifies what the button will do if the user invokes it; its value is a function which takes two arguments--the widget which the button appears in, and the event.

There is no way to specify two different buttons with different actions.

Show sample in a special face specified by :sample-face.

Substitute the item's value. How the value is represented depends on the kind of item, and (for variables) on the customization type.

Substitute the item's documentation string.

Like `%d', but if the documentation string is more than one line, add an active field to control whether to show all of it or just the first line.

Substitute the tag here. You specify the tag with the :tag keyword.

Display a literal `%'.

:action action
Perform action if the user clicks on a button.

:button-face face
Use the face face (a face name or a list of face names) for button text displayed with `%[...%]'.

:button-prefix prefix
:button-suffix suffix
These specify the text to display before and after a button. Each can be:

No text is inserted.

a string
The string is inserted literally.

a symbol
The symbol's value is used.

:tag tag
Use tag (a string) as the tag for the value (or part of the value) that corresponds to this type.

:doc doc
Use doc as the documentation string for this value (or part of the value) that corresponds to this type. In order for this to work, you must specify a value for :format, and use `%d' or `%h' in that value.

The usual reason to specify a documentation string for a type is to provide more information about the meanings of alternatives inside a :choice type or the parts of some other composite type.

:help-echo motion-doc
When you move to this item with widget-forward or widget-backward, it will display the string motion-doc in the echo area. In addition, motion-doc is used as the mouse help-echo string and may actually be a function or form evaluated to yield a help string. If it is a function, it is called with one argument, the widget.

:match function
Specify how to decide whether a value matches the type. The corresponding value, function, should be a function that accepts two arguments, a widget and a value; it should return non-nil if the value is acceptable.

[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [Search] [Page Top / Page Bottom] [?]

14.4.5 Defining New Types

comment(none) to "lispref/DefiningNewTypes"

In the previous sections we have described how to construct elaborate type specifications for defcustom. In some cases you may want to give such a type specification a name. The obvious case is when you are using the same type for many user options: rather than repeat the specification for each option, you can give the type specification a name, and use that name each defcustom. The other case is when a user option's value is a recursive data structure. To make it possible for a datatype to refer to itself, it needs to have a name.

Since custom types are implemented as widgets, the way to define a new customize type is to define a new widget. We are not going to describe the widget interface here in details, see section `Introduction' in

The Emacs Widget Library
, for that. Instead we are going to demonstrate the minimal functionality needed for defining new customize types by a simple example.

(define-widget 'binary-tree-of-string 'lazy
  "A binary tree made of cons-cells and strings."
  :offset 4
  :tag "Node"
  :type '(choice (string :tag "Leaf" :value "")
                 (cons :tag "Interior"
                       :value ("" . "")

(defcustom foo-bar ""
  "Sample variable holding a binary tree of strings."
  :type 'binary-tree-of-string)

The function to define a new widget is called define-widget. The first argument is the symbol we want to make a new widget type. The second argument is a symbol representing an existing widget, the new widget is going to be defined in terms of difference from the existing widget. For the purpose of defining new customization types, the lazy widget is perfect, because it accepts a :type keyword argument with the same syntax as the keyword argument to defcustom with the same name. The third argument is a documentation string for the new widget. You will be able to see that string with the M-x widget-browse RET binary-tree-of-string RET command.

After these mandatory arguments follow the keyword arguments. The most important is :type, which describes the data type we want to match with this widget. Here a binary-tree-of-string is described as being either a string, or a cons-cell whose car and cdr are themselves both binary-tree-of-string. Note the reference to the widget type we are currently in the process of defining. The :tag attribute is a string to name the widget in the user interface, and the :offset argument is there to ensure that child nodes are indented four spaces relative to the parent node, making the tree structure apparent in the customization buffer.

The defcustom shows how the new widget can be used as an ordinary customization type.

The reason for the name lazy is that the other composite widgets convert their inferior widgets to internal form when the widget is instantiated in a buffer. This conversion is recursive, so the inferior widgets will convert their inferior widgets. If the data structure is itself recursive, this conversion is an infinite recursion. The lazy widget prevents the recursion: it convert its :type argument only when needed.

[ << ] [ >> ]           [Top] [Contents] [Index] [Search] [Page Top / Page Bottom] [?]