Copyright © 2000–2023 Free Software Foundation, Inc.
Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.3 or any later version published by the Free Software Foundation; with no Invariant Sections, with the Front-Cover Texts being “A GNU Manual”, and with the Back-Cover Texts as in (a) below. A copy of the license is included in the section entitled “GNU Free Documentation License”.
(a) The FSF’s Back-Cover Text is: “You have the freedom to copy and modify this GNU manual.”
link Widgeturl-link Widgetinfo-link Widgetpush-button Widgeteditable-field Widgettext Widgetmenu-choice Widgetradio-button-choice Widgetitem Widgetchoice-item Widgettoggle Widgetcheckbox Widgetchecklist Widgeteditable-list Widgetgroup WidgetMost graphical user interface toolkits provide a number of standard
user interface controls (sometimes known as “widgets” or “gadgets”).
Emacs doesn’t really support anything like this, except for an
incredibly powerful text “widget.” On the other hand, Emacs does
provide the necessary primitives to implement many other widgets
within a text buffer. The widget package simplifies this task.
The basic widgets are:
linkAreas of text with an associated action. Intended for hypertext links embedded in text.
push-buttonLike link, but intended for stand-alone buttons.
editable-fieldAn editable text field. It can be either variable or fixed length.
menu-choiceAllows the user to choose one of multiple options from a menu, each option is itself a widget. Only the selected option will be visible in the buffer.
radio-button-choiceAllows the user to choose one of multiple options by activating radio buttons. The options are implemented as widgets. All options will be visible in the buffer.
itemA simple constant widget intended to be used in the menu-choice and
radio-button-choice widgets.
choice-itemA button item only intended for use in choices. When invoked, the user will be asked to select another option from the choice widget.
toggleA simple ‘on’/‘off’ switch.
checkboxA checkbox (‘[ ]’/‘[X]’).
editable-listCreate an editable list. The user can insert or delete items in the list. Each list item is itself a widget.
Now, of what possible use can support for widgets be in a text editor? I’m glad you asked. The answer is that widgets are useful for implementing forms. A form in Emacs is a buffer where the user is supposed to fill out a number of fields, each of which has a specific meaning. The user is not supposed to change or delete any of the text between the fields. Examples of forms in Emacs are the forms package (of course), the customize buffers, the mail and news compose modes, and the HTML form support in the w3 browser.
The advantages for a programmer of using the widget package to
implement forms are:
A form consists of read only text for documentation and some fields, where each field contains two parts, a tag and a value. The tags are used to identify the fields, so the documentation can refer to the ‘foo field’, meaning the field tagged with ‘Foo’. Here is an example form:
Here is some documentation. Name: My Name Choose: This option Address: Some Place In some City Some country. See also _other work_ for more information. Numbers: count to three below [INS] [DEL] One [INS] [DEL] Eh, two? [INS] [DEL] Five! [INS] Select multiple: [X] This [ ] That [X] Thus Select one: (*) One ( ) Another One. ( ) A Final One. [Apply Form] [Reset Form]
The top level widgets in this example are tagged ‘Name’, ‘Choose’, ‘Address’, ‘_other work_’, ‘Numbers’, ‘Select multiple’, ‘Select one’, ‘[Apply Form]’, and ‘[Reset Form]’. There are basically two things the user can do within a form, namely editing the editable text fields and activating the buttons.
In the example, the value for the ‘Name’ is most likely displayed in an editable text field, and so are values for each of the members of the ‘Numbers’ list. All the normal Emacs editing operations are available for editing these fields. The only restriction is that each change you make must be contained within a single editable text field. For example, capitalizing all text from the middle of one field to the middle of another field is prohibited.
Editable text fields are created by the editable-field widget.
Warning: In an editable-field widget, the editable
field must not be adjacent to another widget—that won’t work.
You must put some text in between. Either make this text part of
the editable-field widget itself, or insert it with
widget-insert.
The :format keyword is useful for generating the necessary
text; for instance, if you give it a value of "Name: %v ",
the ‘Name: ’ part will provide the necessary separating text
before the field and the trailing space will provide the
separating text after the field. If you don’t include the
:size keyword, the field will extend to the end of the
line, and the terminating newline will provide separation after.
Warning: In an editable-field widget, the ‘%v’ escape
must be preceded by some other text in the :format string
(if specified).
The editing text fields are highlighted with the
widget-field-face face, making them easy to find.
Face used for other editing fields.
Some portions of the buffer have an associated action, which can be invoked by a standard key or mouse command. These portions are called buttons. The default commands for activating a button are:
Invoke the button at pos, defaulting to point.
If point is not located on a button, invoke the binding in
widget-global-map (by default the global map).
Invoke the button at the location of the mouse pointer. If the mouse
pointer is located in an editable text field, invoke the binding in
widget-global-map (by default the global map).
There are several different kind of buttons, all of which are present in the example:
When you invoke one of these buttons, you will be asked to choose
between a number of different options. This is how you edit an option
field. Option fields are created by the menu-choice widget. In
the example, ‘Choose’ is an option field tag.
Activating these will insert or delete elements from an editable list.
The list is created by the editable-list widget.
The ‘_other work_’ is an example of an embedded
button. Embedded buttons are not associated with any fields, but can serve
any purpose, such as implementing hypertext references. They are
usually created by the link widget.
Activating one of these will convert it to the other. This is useful
for implementing multiple-choice fields. You can create them with the
checkbox widget.
Only one radio button in a radio-button-choice widget can be
selected at any time. When you invoke one of the unselected radio
buttons, it will be selected and the previous selected radio button will
become unselected.
These are explicit buttons made with the push-button widget. The
main difference from the link widget is that the buttons will be
displayed as GUI buttons when possible.
To make them easier to locate, buttons are emphasized in the buffer.
Face used for buttons.
Face used for highlighting a button when the mouse pointer moves across it.
Here is the code to implement the user interface example (see User Interface).
(require 'widget)
(eval-when-compile
(require 'wid-edit))
(defvar widget-example-repeat)
(defun widget-example ()
"Create the widgets from the Widget manual."
(interactive)
(switch-to-buffer "*Widget Example*")
(kill-all-local-variables)
(make-local-variable 'widget-example-repeat)
(let ((inhibit-read-only t))
(erase-buffer))
(remove-overlays)
(widget-insert "Here is some documentation.\n\n")
(widget-create 'editable-field
:size 13
:format "Name: %v " ; Text after the field!
"My Name")
(widget-create 'menu-choice
:tag "Choose"
:value "This"
:help-echo "Choose me, please!"
:notify (lambda (widget &rest ignore)
(message "%s is a good choice!"
(widget-value widget)))
'(item :tag "This option" :value "This")
'(choice-item "That option")
'(editable-field :menu-tag "No option" "Thus option"))
(widget-create 'editable-field
:format "Address: %v"
"Some Place\nIn some City\nSome country.")
(widget-insert "\nSee also ")
(widget-create 'link
:notify (lambda (&rest ignore)
(widget-value-set widget-example-repeat
'("En" "To" "Tre"))
(widget-setup))
"other work")
(widget-insert
" for more information.\n\nNumbers: count to three below\n")
(setq widget-example-repeat
(widget-create 'editable-list
:entry-format "%i %d %v"
:notify
(lambda (widget &rest ignore)
(let ((old (widget-get widget
':example-length))
(new (length (widget-value widget))))
(unless (eq old new)
(widget-put widget ':example-length new)
(message "You can count to %d." new))))
:value '("One" "Eh, two?" "Five!")
'(editable-field :value "three")))
(widget-insert "\n\nSelect multiple:\n\n")
(widget-create 'checkbox t)
(widget-insert " This\n")
(widget-create 'checkbox nil)
(widget-insert " That\n")
(widget-create 'checkbox
:notify (lambda (&rest ignore) (message "Tickle"))
t)
(widget-insert " Thus\n\nSelect one:\n\n")
(widget-create 'radio-button-choice
:value "One"
:notify (lambda (widget &rest ignore)
(message "You selected %s"
(widget-value widget)))
'(item "One") '(item "Another One.")
'(item "A Final One."))
(widget-insert "\n")
(widget-create 'push-button
:notify (lambda (&rest ignore)
(if (= (length
(widget-value widget-example-repeat))
3)
(message "Congratulation!")
(error "Three was the count!")))
"Apply Form")
(widget-insert " ")
(widget-create 'push-button
:notify (lambda (&rest ignore)
(widget-example))
"Reset Form")
(widget-insert "\n")
(use-local-map widget-keymap)
(widget-setup))
Widgets are created with widget-create, which returns a
widget object. This object can be queried and manipulated by
other widget functions, until it is deleted with widget-delete.
After the widgets have been created, widget-setup must be called
to enable them.
Create and return a widget of type type. The syntax for the type argument is described in Basic Types.
The keyword arguments can be used to overwrite the keyword arguments that are part of type.
Delete widget and remove it from the buffer.
Set up a buffer to support widgets.
This should be called after creating all the widgets and before allowing the user to edit them.
If you want to insert text outside the widgets in the form, the
recommended way to do that is with widget-insert.
Insert the arguments, either strings or characters, at point. The inserted text will be read-only.
There is a standard widget keymap which you might find useful.
TAB and C-TAB are bound to widget-forward and
widget-backward, respectively. RET and mouse-2
are bound to widget-button-press and
widget-button-click.
Keymap used by widget-button-press and widget-button-click
when not on a button. By default this is global-map.
This is the general syntax of a type specification:
name ::= (name [keyword argument]... args)
| name
Where, name is a widget name, keyword is the name of a property, argument is the value of the property, and args are interpreted in a widget specific way.
The following keyword arguments apply to all widgets:
:valueThe initial value for widgets of this type. Typically, a widget represents its value in two formats: external and internal. The external format is the value as the rest of Emacs sees it, and the internal format is a representation that the widget defines and uses in a widget specific way.
Both formats might be the same for certain widgets and might differ
for others, and there is no guarantee about which format the value
stored in the :value property has. However, when creating a
widget or defining a new one (see Defining New Widgets), the
:value should be in the external format.
:formatThis string will be inserted in the buffer when you create a widget. The following ‘%’ escapes are available:
The text inside will be marked as a button.
By default, the text will be shown in widget-button-face, and
surrounded by brackets.
String to prefix buttons.
String to suffix buttons.
The text inside will be displayed with the face specified by
:sample-face.
This will be replaced with the buffer representation of the widget’s value. What this is depends on the widget type.
Warning: In an editable-field widget, the ‘%v’ escape
must be preceded by some other text in the format string (if specified).
Insert the string specified by :doc here.
Like ‘%d’, with the following modifications: If the documentation
string is more than one line, it will add a button which will toggle
between showing only the first line, and showing the full text.
Furthermore, if there is no :doc property in the widget, it will
instead examine the :documentation-property property. If it is a
lambda expression, it will be called with the widget’s value as an
argument, and the result will be used as the documentation text.
Insert the string specified by :tag here, or the princ
representation of the value if there is no tag.
Insert a literal ‘%’.
:button-faceFace used to highlight text inside %[ %] in the format.
:button-prefix:button-suffixText around %[ %] in the format.
These can be
No text is inserted.
The string is inserted literally.
The value of the symbol is expanded according to this table.
:docThe string inserted by the ‘%d’ escape in the format string.
:tagThe string inserted by the ‘%t’ escape in the format string.
:tag-glyphName of image to use instead of the string specified by :tag on
Emacsen that supports it.
:help-echoSpecifies how to display a message whenever you move to the widget with
either widget-forward or widget-backward or move the mouse
over it (using the standard help-echo mechanism). The argument
is either a string to display, a function of one argument, the widget,
which should return a string to display, or a form that evaluates to
such a string.
:follow-linkSpecifies how to interpret a mouse-1 click on the widget. See Defining Clickable Text in the Emacs Lisp Reference Manual.
:indentAn integer indicating the absolute number of spaces to indent children of this widget.
:offsetAn integer indicating how many extra spaces to add to the widget’s grandchildren compared to this widget.
:extra-offsetAn integer indicating how many extra spaces to add to the widget’s children compared to this widget.
:notifyA function called each time the widget or a nested widget is changed. The function is called with two or three arguments. The first argument is the widget itself, the second argument is the widget that was changed, and the third argument is the event leading to the change, if any.
:menu-tagTag used in the menu when the widget is used as an option in a
menu-choice widget.
:menu-tag-getFunction used for finding the tag when the widget is used as an option
in a menu-choice widget. By default, the tag used will be either the
:menu-tag or :tag property if present, or the princ
representation of the :value property if not.
:matchShould be a function called with two arguments, the widget and an
external value, and should return non-nil if the widget can
represent the specified value.
:validateA function which takes a widget as an argument, and returns nil
if the widget’s current value is valid for the widget. Otherwise it
should return the widget containing the invalid data, and set that
widget’s :error property to a string explaining the error.
The following predefined function can be used:
All the :children of widget must be valid.
:tab-orderSpecify the order in which widgets are traversed with
widget-forward or widget-backward. This is only partially
implemented.
-1 are ignored.
nil,
whichever comes first.
nil
:parentThe parent of a nested widget (e.g., a menu-choice item or an
element of a editable-list widget).
:sibling-argsThis keyword is only used for members of a radio-button-choice or
checklist. The value should be a list of extra keyword
arguments, which will be used when creating the radio-button or
checkbox associated with this item.
Directory where Widget should look for images. Widget will look here for a file with the same name as specified for the image, with either a .xpm (if supported) or .xbm extension.
If non-nil, allow images to appear on displays where they are supported.
link Widgeturl-link Widgetinfo-link Widgetpush-button Widgeteditable-field Widgettext Widgetmenu-choice Widgetradio-button-choice Widgetitem Widgetchoice-item Widgettoggle Widgetcheckbox Widgetchecklist Widgeteditable-list Widgetgroup Widgetlink WidgetSyntax:
type ::= (link [keyword argument]... [ value ])
The value, if present, is used to initialize the :value
property. The value should be a string, which will be inserted in the
buffer.
By default the link will be shown in brackets.
String to prefix links.
String to suffix links.
url-link WidgetSyntax:
type ::= (url-link [keyword argument]... url)
When this link is invoked, the WWW browser specified by
browse-url-browser-function will be called with url.
info-link WidgetSyntax:
type ::= (info-link [keyword argument]... address)
When this link is invoked, the built-in Info reader is started on address.
push-button WidgetSyntax:
type ::= (push-button [keyword argument]... [ value ])
The value, if present, is used to initialize the :value
property. The value should be a string, which will be inserted in the
buffer.
By default the tag will be shown in brackets.
String to prefix push buttons.
String to suffix push buttons.
editable-field WidgetSyntax:
type ::= (editable-field [keyword argument]... [ value ])
The value, if present, is used to initialize the :value
property. The value should be a string, which will be inserted in the
field. This widget will match all string values.
The following extra properties are recognized:
:sizeThe width of the editable field.
By default the field will reach to the end of the line.
:value-faceFace used for highlighting the editable field. Default is
widget-field-face, see User Interface.
:secretCharacter used to display the value. You can set this to, e.g., ?*
if the field contains a password or other secret information. By
default, this is nil, and the value is not secret.
:valid-regexpBy default the :validate function will match the content of the
field with the value of this attribute. The default value is ""
which matches everything.
:keymapKeymap used in the editable field. The default value is
widget-field-keymap, which allows you to use all the normal
editing commands, even if the buffer’s major mode suppresses some of
them. Pressing RET invokes the function specified by
:action.
text WidgetThis is just like editable-field, but intended for multiline text
fields. The default :keymap is widget-text-keymap, which
does not rebind the RET key.
radio-button-choice WidgetSyntax:
type ::= (radio-button-choice [keyword argument]... type ... )
The component types specify the choices, with one radio button for each. The widget’s value will be that of the chosen type argument. This widget matches any value that matches at least one of the specified type arguments.
The following extra properties are recognized.
:entry-formatThis string will be inserted for each entry in the list. The following ‘%’ escapes are available:
Replace with the buffer representation of the type widget.
Replace with the radio button.
Insert a literal ‘%’.
:button-argsA list of keywords to pass to the radio buttons. Useful for setting, e.g., the ‘:help-echo’ for each button.
:buttonsThe widgets representing the radio buttons.
:childrenThe widgets representing each type.
:choiceThe current chosen type
:argsThe list of types.
You can add extra radio button items to a radio-button-choice
widget after it has been created with the function
widget-radio-add-item.
Add to radio-button-choice widget widget a new radio button
item of type type.
Please note that such items added after the radio-button-choice
widget has been created will not be properly destructed when
you call widget-delete.
item WidgetSyntax:
item ::= (item [keyword argument]... value)
The value, if present, is used to initialize the :value
property. The value should be a string, which will be inserted in the
buffer. This widget will only match the specified value.
choice-item WidgetSyntax:
item ::= (choice-item [keyword argument]... value)
The value, if present, is used to initialize the :value
property. The value should be a string, which will be inserted in the
buffer as a button. Activating the button of a choice-item is
equivalent to activating the parent widget. This widget will only match
the specified value.
toggle WidgetSyntax:
type ::= (toggle [keyword argument]...)
The widget has two possible states, ‘on’ and ‘off’, which
correspond to a t or nil value, respectively.
The following extra properties are recognized:
:onA string representing the ‘on’ state. By default the string ‘on’.
:offA string representing the ‘off’ state. By default the string ‘off’.
:on-glyphName of a glyph to be used instead of the ‘:on’ text string, on emacsen that supports this.
:off-glyphName of a glyph to be used instead of the ‘:off’ text string, on emacsen that supports this.
checkbox WidgetThis widget has two possible states, ‘selected’ and
‘unselected’, which corresponds to a t or nil value.
Syntax:
type ::= (checkbox [keyword argument]...)
checklist WidgetSyntax:
type ::= (checklist [keyword argument]... type ... )
The type arguments represent each checklist item. The widget’s value will be a list containing the values of all checked type arguments. The checklist widget will match a list whose elements all match at least one of the specified type arguments.
The following extra properties are recognized:
:entry-formatThis string will be inserted for each entry in the list. The following ‘%’ escapes are available:
Replaced with the buffer representation of the type widget.
Replace with the checkbox.
Insert a literal ‘%’.
:greedyUsually a checklist will only match if the items are in the exact
sequence given in the specification. By setting :greedy to
non-nil, it will allow the items to come in any sequence.
However, if you extract the value they will be in the sequence given
in the checklist, i.e., the original sequence is forgotten.
:button-argsA list of keywords to pass to the checkboxes. Useful for setting, e.g., the ‘:help-echo’ for each checkbox.
:buttonsThe widgets representing the checkboxes.
:childrenThe widgets representing each type.
:argsThe list of types.
editable-list WidgetSyntax:
type ::= (editable-list [keyword argument]... type)
The value is a list, where each member represents one widget of type type.
The following extra properties are recognized:
:entry-formatThis string will be inserted for each entry in the list. The following ‘%’ escapes are available:
This will be replaced with the buffer representation of the type widget.
Insert the [INS] button.
Insert the [DEL] button.
Insert a literal ‘%’.
:insert-button-argsA list of keyword arguments to pass to the insert buttons.
:delete-button-argsA list of keyword arguments to pass to the delete buttons.
:append-button-argsA list of keyword arguments to pass to the trailing insert button.
:buttonsThe widgets representing the insert and delete buttons.
:childrenThe widgets representing the elements of the list.
:argsList whose CAR is the type of the list elements.
A number of widgets for editing s-expressions (Lisp types), sexp for short, are also available. These basically fall in several categories described in this section.
The const widget can contain any Lisp expression, but the user is
prohibited from editing it, which is mainly useful as a component of one
of the composite widgets.
The syntax for the const widget is:
type ::= (const [keyword argument]... [ value ])
The value, if present, is used to initialize the :value
property and can be any s-expression.
This will display any valid s-expression in an immutable part of the buffer.
There are two variations of the const widget, namely
variable-item and function-item. These should contain a
symbol with a variable or function binding. The major difference from
the const widget is that they will allow the user to see the
variable or function documentation for the symbol.
An immutable symbol that is bound as a variable.
An immutable symbol that is bound as a function.
The sexp widget can contain any Lisp expression, and allows the
user to edit it inline in the buffer.
The syntax for the sexp widget is:
type ::= (sexp [keyword argument]... [ value ])
This will allow you to edit any valid s-expression in an editable buffer field.
The sexp widget takes the same keyword arguments as the
editable-field widget. See The editable-field Widget.
The atoms are s-expressions that do not consist of other s-expressions. For example, a string, a file name, or a symbol are atoms, while a list is a composite type. You can edit the value of an atom with the following widgets.
The syntax for all the atoms are:
type ::= (construct [keyword argument]... [ value ])
The value, if present, is used to initialize the :value
property and must be an expression of the same type as the widget.
That is, the string widget can only be initialized with a string.
All the atom widgets take the same keyword arguments as the
editable-field widget. See The editable-field Widget.
Allows you to edit a string in an editable field.
Allows you to edit a regular expression in an editable field.
Allows you to enter a character in an editable field.
Allows you to edit a file name in an editable field.
Keywords:
Allows you to edit a directory name in an editable field.
Similar to the file widget.
Allows you to edit a Lisp symbol in an editable field.
Allows you to edit a lambda expression, or a function name with completion.
Allows you to edit a variable name, with completion.
Allows you to edit an integer in an editable field.
Allows you to edit a number in an editable field.
Allows you to edit a boolean. In Lisp this means a variable which is
either nil meaning false, or non-nil meaning true.
The syntax for the composite widget construct is:
type ::= (construct [keyword argument]... component...)
where each component must be a widget type. Each component widget will be displayed in the buffer, and will be editable by the user.
The value of a cons widget must be a cons-cell whose CAR
and CDR have two specified types. It uses this syntax:
type ::= (cons [keyword argument]... car-type cdr-type)
The value matched by a choice widget must have one of a fixed
set of types. The widget’s syntax is as follows:
type ::= (choice [keyword argument]... type ... )
The value of a choice widget can be anything that matches any of the
types.
The value of a list widget must be a list whose element types
match the specified component types:
type ::= (list [keyword argument]... component-type...)
Thus, (list string number) matches lists of two elements,
the first being a string and the second being a number.
The vector widget is like the list widget but matches
vectors instead of lists. Thus, (vector string number) matches
vectors of two elements, the first being a string and the second being
a number.
The above suffice for specifying fixed size lists and vectors. To get
variable length lists and vectors, you can use a choice,
set, or repeat widget together with the :inline
keyword. If any component of a composite widget has the
:inline keyword set, its value must be a list which will then
be spliced into the composite. For example, to specify a list whose
first element must be a file name, and whose remaining elements should
either be the symbol t or two strings (file names), you can use
the following widget specification:
(list file
(choice (const t)
(list :inline t
:value ("foo" "bar")
string string)))
The value of a widget of this type will either have the form
(file t) or (file string string).
This concept of :inline may be hard to understand. It was
certainly hard to implement, so instead of confusing you more by
trying to explain it here, I’ll just suggest you meditate over it for
a while.
Specifies a type whose values are the lists whose elements all belong to a given set. The order of elements of the list is not significant. Here’s the syntax:
type ::= (set [keyword argument]... permitted-element ... )
Use const to specify each permitted element, like this:
(set (const a) (const b)).
Specifies a list of any number of elements that fit a certain type.
type ::= (repeat [keyword argument]... type)
You can examine or set the value of a widget by using the widget object
that was returned by widget-create.
Return the current value contained in widget. It is an error to call this function on an uninitialized widget.
Set the value contained in widget to value. It is an error to call this function with an invalid value.
Important: You must call widget-setup after
modifying the value of a widget before the user is allowed to edit the
widget again. It is enough to call widget-setup once if you
modify multiple widgets. This is currently only necessary if the widget
contains an editing field, but may be necessary for other widgets in the
future.
If your application needs to associate some information with the widget
objects, for example a reference to the item being edited, it can be
done with widget-put and widget-get. The property names
must begin with a ‘:’.
In widget set property to value. property should be a symbol, while value can be anything.
In widget return the value for property.
property should be a symbol, the value is what was last set by
widget-put for property.
Non-nil if widget has a value (even nil) for
property property.
Apply the value of property to widget, passing args as additional arguments to the function. Return the result of that function call.
Occasionally it can be useful to know which kind of widget you have, i.e., the name of the widget type you gave when the widget was created.
Return the name of widget, a symbol.
Widgets can be in two states: active, which means they are modifiable by the user, or inactive, which means they cannot be modified by the user. You can query or set the state with the following code:
;; Examine if widget is active or not.
(if (widget-apply widget :active)
(message "Widget is active.")
(message "Widget is inactive.")
;; Make widget inactive.
(widget-apply widget :deactivate)
;; Make widget active.
(widget-apply widget :activate)
A widget is inactive if it, or any of its ancestors (found by
following the :parent link), have been deactivated. To make sure
a widget is really active, you must therefore activate both it and
all its ancestors.
(while widget (widget-apply widget :activate) (setq widget (widget-get widget :parent)))
You can check if a widget has been made inactive by examining the value
of the :inactive keyword. If this is non-nil, the widget itself
has been deactivated. This is different from using the :active
keyword, in that the latter tells you if the widget or any of
its ancestors have been deactivated. Do not attempt to set the
:inactive keyword directly. Use the :activate
:deactivate keywords instead.
You can define specialized widgets with define-widget. It allows
you to create a shorthand for more complex widgets, including specifying
component widgets and new default values for the keyword
arguments.
Define a new widget type named name from class.
name and class should both be symbols, class should be one
of the existing widget types.
The third argument doc is a documentation string for the widget.
After the new widget has been defined, the following two calls will create identical widgets:
(widget-create name)
(apply widget-create class args)
Using define-widget just stores the definition of the widget type
in the widget-type property of name, which is what
widget-create uses.
If you only want to specify defaults for keywords with no complex
conversions, you can use identity as your conversion function.
The following additional keyword arguments are useful when defining new widgets:
:convert-widgetFunction to convert a widget type before creating a widget of that type. It takes a widget type as an argument, and returns the converted widget type. When a widget is created, this function is called for the widget type and all the widget’s parent types, most derived first.
The following predefined functions can be used here:
Convert :args as widget types in widget.
Initialize :value from :args in widget.
:copyFunction to deep copy a widget type. It takes a shallow copy of the
widget type as an argument (made by copy-sequence), and returns a
deep copy. The purpose of this is to avoid having different instances
of combined widgets share nested attributes.
The following predefined functions can be used here:
Copy :args as widget types in widget.
:value-to-internalFunction to convert the value to the internal format. The function
takes two arguments, a widget and an external value, and returns the
internal value. The function is called on the present :value
when the widget is created, and on any value set later with
widget-value-set.
:value-to-externalFunction to convert the value to the external format. The function takes two arguments, a widget and an internal value, and returns the external value.
:createFunction to create a widget from scratch. The function takes one argument, a widget type, and creates a widget of that type, inserts it in the buffer, and returns a widget object.
:deleteFunction to delete a widget. The function takes one argument, a widget, and should remove all traces of the widget from the buffer.
The default value is:
Remove widget from the buffer.
Delete all :children and :buttons in widget.
In most cases you should not change this value, but instead use
:value-delete to make any additional cleanup.
:value-createFunction to expand the ‘%v’ escape in the format string. It will be called with the widget as its argument and should insert a representation of the widget’s value in the buffer.
Nested widgets should be listed in :children or :buttons
to make sure they are automatically deleted.
:value-deleteShould remove the representation of the widget’s value from the buffer.
It will be called with the widget as its argument. It doesn’t have to
remove the text, but it should release markers and delete nested widgets
if these are not listed in :children or :buttons.
:value-getFunction to extract the value of a widget, as it is displayed in the buffer.
The following predefined function can be used here:
Return the :value property of widget.
:format-handlerFunction to handle unknown ‘%’ escapes in the format string. It will be called with the widget and the character that follows the ‘%’ as arguments. You can set this to allow your widget to handle non-standard escapes.
You should end up calling widget-default-format-handler to handle
unknown escape sequences, which will handle the ‘%h’ and any future
escape sequences, as well as give an error for unknown escapes.
:actionFunction to handle user initiated events. By default, :notify
the parent.
The following predefined function can be used here:
Tell :parent of widget to handle the :action.
Optional event is the event that triggered the action.
:prompt-valueFunction to prompt for a value in the minibuffer. The function should
take four arguments, widget, prompt, value, and
unbound and should return a value for widget entered by the user.
prompt is the prompt to use. value is the default value to
use, unless unbound is non-nil, in which case there is no default
value. The function should read the value using the method most natural
for this widget, and does not have to check that it matches.
If you want to define a new widget from scratch, use the default
widget as its base.
Widget used as a base for other widgets.
It provides most of the functionality that is referred to as “by default” in this text.
There is a separate package to browse widgets. This is intended to help programmers who want to examine the content of a widget. The browser shows the value of each keyword, but uses links for certain keywords such as ‘:parent’, which avoids printing cyclic structures.
Create a widget browser for widget. When called interactively, prompt for widget.
Create a widget browser for widget and show it in another window. When called interactively, prompt for widget.
Create a widget browser for the widget at pos. When called interactively, use the position of point.
There is a minor mode for manipulating widgets in major modes that don’t provide any support for widgets themselves. This is mostly intended to be useful for programmers doing experiments.
Toggle minor mode for traversing widgets. With arg, turn widget mode on if and only if arg is positive.
Keymap used in widget-minor-mode.
Prompt for a value matching widget, using prompt.
The current value is assumed to be value, unless unbound is
non-nil.
Get the item which widget is assumed to toggle. This is only meaningful for radio buttons or checkboxes in a list.
Prompt the user to choose an item from a list of options.
title is the name of the list of options. items should be
a menu, with its items in the simple format or in the extended format.
See Defining Menus in the Emacs Lisp Reference
Manual. Independently of the format, you don’t have to provide a
title for the menu, just pass the desired title in title. The
optional event is an input event. If event is a mouse
event and the number of elements in items is less than the user
option widget-menu-max-size, then widget-choose uses a
popup menu to prompt the user. Otherwise, widget-choose uses
the minibuffer.
When items is a keymap menu, the returned value is the symbol in
the key vector, as in the argument of define-key
(see Changing Key Bindings in the Emacs Lisp Reference
Manual). When items is a list whose selectable items are of
the form (name . value) (i.e., the simplified format),
then the return value is the value of the chosen element.
menu-choice tag should be prettier, something like the abbreviated
menus in Open Look.
:tab-order.
property-list widget.
association-list widget.
key-binding widget.
widget widget for editing widget specifications.
TeX-printer-list for an explanation.
widget-prompt-value should give type specific help.
mailto widget.
Copyright © 2000, 2001, 2002, 2007, 2008 Free Software Foundation, Inc. https://fsf.org/ Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed.
The purpose of this License is to make a manual, textbook, or other functional and useful document free in the sense of freedom: to assure everyone the effective freedom to copy and redistribute it, with or without modifying it, either commercially or noncommercially. Secondarily, this License preserves for the author and publisher a way to get credit for their work, while not being considered responsible for modifications made by others.
This License is a kind of “copyleft”, which means that derivative works of the document must themselves be free in the same sense. It complements the GNU General Public License, which is a copyleft license designed for free software.
We have designed this License in order to use it for manuals for free software, because free software needs free documentation: a free program should come with manuals providing the same freedoms that the software does. But this License is not limited to software manuals; it can be used for any textual work, regardless of subject matter or whether it is published as a printed book. We recommend this License principally for works whose purpose is instruction or reference.
This License applies to any manual or other work, in any medium, that contains a notice placed by the copyright holder saying it can be distributed under the terms of this License. Such a notice grants a world-wide, royalty-free license, unlimited in duration, to use that work under the conditions stated herein. The “Document”, below, refers to any such manual or work. Any member of the public is a licensee, and is addressed as “you”. You accept the license if you copy, modify or distribute the work in a way requiring permission under copyright law.
A “Modified Version” of the Document means any work containing the Document or a portion of it, either copied verbatim, or with modifications and/or translated into another language.
A “Secondary Section” is a named appendix or a front-matter section of the Document that deals exclusively with the relationship of the publishers or authors of the Document to the Document’s overall subject (or to related matters) and contains nothing that could fall directly within that overall subject. (Thus, if the Document is in part a textbook of mathematics, a Secondary Section may not explain any mathematics.) The relationship could be a matter of historical connection with the subject or with related matters, or of legal, commercial, philosophical, ethical or political position regarding them.
The “Invariant Sections” are certain Secondary Sections whose titles are designated, as being those of Invariant Sections, in the notice that says that the Document is released under this License. If a section does not fit the above definition of Secondary then it is not allowed to be designated as Invariant. The Document may contain zero Invariant Sections. If the Document does not identify any Invariant Sections then there are none.
The “Cover Texts” are certain short passages of text that are listed, as Front-Cover Texts or Back-Cover Texts, in the notice that says that the Document is released under this License. A Front-Cover Text may be at most 5 words, and a Back-Cover Text may be at most 25 words.
A “Transparent” copy of the Document means a machine-readable copy, represented in a format whose specification is available to the general public, that is suitable for revising the document straightforwardly with generic text editors or (for images composed of pixels) generic paint programs or (for drawings) some widely available drawing editor, and that is suitable for input to text formatters or for automatic translation to a variety of formats suitable for input to text formatters. A copy made in an otherwise Transparent file format whose markup, or absence of markup, has been arranged to thwart or discourage subsequent modification by readers is not Transparent. An image format is not Transparent if used for any substantial amount of text. A copy that is not “Transparent” is called “Opaque”.
Examples of suitable formats for Transparent copies include plain ASCII without markup, Texinfo input format, LaTeX input format, SGML or XML using a publicly available DTD, and standard-conforming simple HTML, PostScript or PDF designed for human modification. Examples of transparent image formats include PNG, XCF and JPG. Opaque formats include proprietary formats that can be read and edited only by proprietary word processors, SGML or XML for which the DTD and/or processing tools are not generally available, and the machine-generated HTML, PostScript or PDF produced by some word processors for output purposes only.
The “Title Page” means, for a printed book, the title page itself, plus such following pages as are needed to hold, legibly, the material this License requires to appear in the title page. For works in formats which do not have any title page as such, “Title Page” means the text near the most prominent appearance of the work’s title, preceding the beginning of the body of the text.
The “publisher” means any person or entity that distributes copies of the Document to the public.
A section “Entitled XYZ” means a named subunit of the Document whose title either is precisely XYZ or contains XYZ in parentheses following text that translates XYZ in another language. (Here XYZ stands for a specific section name mentioned below, such as “Acknowledgements”, “Dedications”, “Endorsements”, or “History”.) To “Preserve the Title” of such a section when you modify the Document means that it remains a section “Entitled XYZ” according to this definition.
The Document may include Warranty Disclaimers next to the notice which states that this License applies to the Document. These Warranty Disclaimers are considered to be included by reference in this License, but only as regards disclaiming warranties: any other implication that these Warranty Disclaimers may have is void and has no effect on the meaning of this License.
You may copy and distribute the Document in any medium, either commercially or noncommercially, provided that this License, the copyright notices, and the license notice saying this License applies to the Document are reproduced in all copies, and that you add no other conditions whatsoever to those of this License. You may not use technical measures to obstruct or control the reading or further copying of the copies you make or distribute. However, you may accept compensation in exchange for copies. If you distribute a large enough number of copies you must also follow the conditions in section 3.
You may also lend copies, under the same conditions stated above, and you may publicly display copies.
If you publish printed copies (or copies in media that commonly have printed covers) of the Document, numbering more than 100, and the Document’s license notice requires Cover Texts, you must enclose the copies in covers that carry, clearly and legibly, all these Cover Texts: Front-Cover Texts on the front cover, and Back-Cover Texts on the back cover. Both covers must also clearly and legibly identify you as the publisher of these copies. The front cover must present the full title with all words of the title equally prominent and visible. You may add other material on the covers in addition. Copying with changes limited to the covers, as long as they preserve the title of the Document and satisfy these conditions, can be treated as verbatim copying in other respects.
If the required texts for either cover are too voluminous to fit legibly, you should put the first ones listed (as many as fit reasonably) on the actual cover, and continue the rest onto adjacent pages.
If you publish or distribute Opaque copies of the Document numbering more than 100, you must either include a machine-readable Transparent copy along with each Opaque copy, or state in or with each Opaque copy a computer-network location from which the general network-using public has access to download using public-standard network protocols a complete Transparent copy of the Document, free of added material. If you use the latter option, you must take reasonably prudent steps, when you begin distribution of Opaque copies in quantity, to ensure that this Transparent copy will remain thus accessible at the stated location until at least one year after the last time you distribute an Opaque copy (directly or through your agents or retailers) of that edition to the public.
It is requested, but not required, that you contact the authors of the Document well before redistributing any large number of copies, to give them a chance to provide you with an updated version of the Document.
You may copy and distribute a Modified Version of the Document under the conditions of sections 2 and 3 above, provided that you release the Modified Version under precisely this License, with the Modified Version filling the role of the Document, thus licensing distribution and modification of the Modified Version to whoever possesses a copy of it. In addition, you must do these things in the Modified Version:
If the Modified Version includes new front-matter sections or appendices that qualify as Secondary Sections and contain no material copied from the Document, you may at your option designate some or all of these sections as invariant. To do this, add their titles to the list of Invariant Sections in the Modified Version’s license notice. These titles must be distinct from any other section titles.
You may add a section Entitled “Endorsements”, provided it contains nothing but endorsements of your Modified Version by various parties—for example, statements of peer review or that the text has been approved by an organization as the authoritative definition of a standard.
You may add a passage of up to five words as a Front-Cover Text, and a passage of up to 25 words as a Back-Cover Text, to the end of the list of Cover Texts in the Modified Version. Only one passage of Front-Cover Text and one of Back-Cover Text may be added by (or through arrangements made by) any one entity. If the Document already includes a cover text for the same cover, previously added by you or by arrangement made by the same entity you are acting on behalf of, you may not add another; but you may replace the old one, on explicit permission from the previous publisher that added the old one.
The author(s) and publisher(s) of the Document do not by this License give permission to use their names for publicity for or to assert or imply endorsement of any Modified Version.
You may combine the Document with other documents released under this License, under the terms defined in section 4 above for modified versions, provided that you include in the combination all of the Invariant Sections of all of the original documents, unmodified, and list them all as Invariant Sections of your combined work in its license notice, and that you preserve all their Warranty Disclaimers.
The combined work need only contain one copy of this License, and multiple identical Invariant Sections may be replaced with a single copy. If there are multiple Invariant Sections with the same name but different contents, make the title of each such section unique by adding at the end of it, in parentheses, the name of the original author or publisher of that section if known, or else a unique number. Make the same adjustment to the section titles in the list of Invariant Sections in the license notice of the combined work.
In the combination, you must combine any sections Entitled “History” in the various original documents, forming one section Entitled “History”; likewise combine any sections Entitled “Acknowledgements”, and any sections Entitled “Dedications”. You must delete all sections Entitled “Endorsements.”
You may make a collection consisting of the Document and other documents released under this License, and replace the individual copies of this License in the various documents with a single copy that is included in the collection, provided that you follow the rules of this License for verbatim copying of each of the documents in all other respects.
You may extract a single document from such a collection, and distribute it individually under this License, provided you insert a copy of this License into the extracted document, and follow this License in all other respects regarding verbatim copying of that document.
A compilation of the Document or its derivatives with other separate and independent documents or works, in or on a volume of a storage or distribution medium, is called an “aggregate” if the copyright resulting from the compilation is not used to limit the legal rights of the compilation’s users beyond what the individual works permit. When the Document is included in an aggregate, this License does not apply to the other works in the aggregate which are not themselves derivative works of the Document.
If the Cover Text requirement of section 3 is applicable to these copies of the Document, then if the Document is less than one half of the entire aggregate, the Document’s Cover Texts may be placed on covers that bracket the Document within the aggregate, or the electronic equivalent of covers if the Document is in electronic form. Otherwise they must appear on printed covers that bracket the whole aggregate.
Translation is considered a kind of modification, so you may distribute translations of the Document under the terms of section 4. Replacing Invariant Sections with translations requires special permission from their copyright holders, but you may include translations of some or all Invariant Sections in addition to the original versions of these Invariant Sections. You may include a translation of this License, and all the license notices in the Document, and any Warranty Disclaimers, provided that you also include the original English version of this License and the original versions of those notices and disclaimers. In case of a disagreement between the translation and the original version of this License or a notice or disclaimer, the original version will prevail.
If a section in the Document is Entitled “Acknowledgements”, “Dedications”, or “History”, the requirement (section 4) to Preserve its Title (section 1) will typically require changing the actual title.
You may not copy, modify, sublicense, or distribute the Document except as expressly provided under this License. Any attempt otherwise to copy, modify, sublicense, or distribute it is void, and will automatically terminate your rights under this License.
However, if you cease all violation of this License, then your license from a particular copyright holder is reinstated (a) provisionally, unless and until the copyright holder explicitly and finally terminates your license, and (b) permanently, if the copyright holder fails to notify you of the violation by some reasonable means prior to 60 days after the cessation.
Moreover, your license from a particular copyright holder is reinstated permanently if the copyright holder notifies you of the violation by some reasonable means, this is the first time you have received notice of violation of this License (for any work) from that copyright holder, and you cure the violation prior to 30 days after your receipt of the notice.
Termination of your rights under this section does not terminate the licenses of parties who have received copies or rights from you under this License. If your rights have been terminated and not permanently reinstated, receipt of a copy of some or all of the same material does not give you any rights to use it.
The Free Software Foundation may publish new, revised versions of the GNU Free Documentation License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns. See https://www.gnu.org/licenses/.
Each version of the License is given a distinguishing version number. If the Document specifies that a particular numbered version of this License “or any later version” applies to it, you have the option of following the terms and conditions either of that specified version or of any later version that has been published (not as a draft) by the Free Software Foundation. If the Document does not specify a version number of this License, you may choose any version ever published (not as a draft) by the Free Software Foundation. If the Document specifies that a proxy can decide which future versions of this License can be used, that proxy’s public statement of acceptance of a version permanently authorizes you to choose that version for the Document.
“Massive Multiauthor Collaboration Site” (or “MMC Site”) means any World Wide Web server that publishes copyrightable works and also provides prominent facilities for anybody to edit those works. A public wiki that anybody can edit is an example of such a server. A “Massive Multiauthor Collaboration” (or “MMC”) contained in the site means any set of copyrightable works thus published on the MMC site.
“CC-BY-SA” means the Creative Commons Attribution-Share Alike 3.0 license published by Creative Commons Corporation, a not-for-profit corporation with a principal place of business in San Francisco, California, as well as future copyleft versions of that license published by that same organization.
“Incorporate” means to publish or republish a Document, in whole or in part, as part of another Document.
An MMC is “eligible for relicensing” if it is licensed under this License, and if all works that were first published under this License somewhere other than this MMC, and subsequently incorporated in whole or in part into the MMC, (1) had no cover texts or invariant sections, and (2) were thus incorporated prior to November 1, 2008.
The operator of an MMC Site may republish an MMC contained in the site under CC-BY-SA on the same site at any time before August 1, 2009, provided the MMC is eligible for relicensing.
To use this License in a document you have written, include a copy of the License in the document and put the following copyright and license notices just after the title page:
Copyright (C) year your name. Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.3 or any later version published by the Free Software Foundation; with no Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts. A copy of the license is included in the section entitled ``GNU Free Documentation License''.
If you have Invariant Sections, Front-Cover Texts and Back-Cover Texts, replace the “with…Texts.” line with this:
with the Invariant Sections being list their titles, with
the Front-Cover Texts being list, and with the Back-Cover Texts
being list.
If you have Invariant Sections without Cover Texts, or some other combination of the three, merge those two alternatives to suit the situation.
If your document contains nontrivial examples of program code, we recommend releasing these examples in parallel under your choice of free software license, such as the GNU General Public License, to permit their use in free software.
This is an alphabetical listing of all concepts, functions, commands, variables, and widgets described in this manual.
| Jump to: | A B C D E F G H I K L M N O P R S T U V W |
|---|
| Jump to: | A B C D E F G H I K L M N O P R S T U V W |
|---|