@c This is part of the Emacs manual.
-@c Copyright (C) 1985,86,87,93,94,95,97,2000,2001,2002,2004
-@c Free Software Foundation, Inc.
+@c Copyright (C) 1985, 1986, 1987, 1993, 1994, 1995, 1997, 2000, 2001,
+@c 2002, 2003, 2004, 2005, 2006 Free Software Foundation, Inc.
@c See file emacs.texi for copying conditions.
@node Customization, Quitting, Amusements, Top
@chapter Customization
@cindex customization
This chapter talks about various topics relevant to adapting the
-behavior of Emacs in minor ways. See @cite{The Emacs Lisp Reference
-Manual} for how to make more far-reaching changes. @xref{X Resources},
+behavior of Emacs in minor ways.
+@iftex
+See @cite{The Emacs Lisp Reference Manual}
+@end iftex
+@ifnottex
+@xref{Top, Emacs Lisp, Emacs Lisp, elisp, The Emacs Lisp
+Reference Manual},
+@end ifnottex
+for how to make more far-reaching changes. @xref{X Resources},
for information on using X resources to customize Emacs.
Customization that you do within Emacs normally affects only the
@menu
* Minor Modes:: Each minor mode is one feature you can turn on
independently of any others.
-* Easy Customization::
- Convenient way to browse and change user options.
+* Easy Customization:: Convenient way to browse and change settings.
* Variables:: Many Emacs commands examine Emacs variables
to decide what to do; by setting variables,
you can control their functioning.
* Key Bindings:: The keymaps say what command each key runs.
By changing them, you can "redefine keys".
-* Keyboard Translations::
- If your keyboard passes an undesired code
- for a key, you can tell Emacs to
- substitute another code.
* Syntax:: The syntax table controls how words and
- expressions are parsed.
+ expressions are parsed.
* Init File:: How to write common customizations in the
@file{.emacs} file.
@end menu
that Auto Fill mode is on.
Append @code{-mode} to the name of a minor mode to get the name of a
-command function that turns the mode on or off. Thus, the command to
-enable or disable Auto Fill mode is called @kbd{M-x auto-fill-mode}. These
+command that turns the mode on or off. Thus, the command to
+enable or disable Auto Fill mode is called @code{auto-fill-mode}. These
commands are usually invoked with @kbd{M-x}, but you can bind keys to them
if you wish. With no argument, the function turns the mode on if it was
off and off if it was on. This is known as @dfn{toggling}. A positive
the mode in certain buffers and not others.
For most minor modes, the command name is also the name of a
-variable which directly controls the mode. The mode is enabled
-whenever this variable's value is non-@code{nil}, and the minor-mode
-command works by setting the variable. For example, the command
-@code{outline-minor-mode} works by setting the value of
-@code{outline-minor-mode} as a variable; it is this variable that
-directly turns Outline minor mode on and off. To check whether a
-given minor mode works this way, use @kbd{C-h v} to ask for
-documentation on the variable name.
-
- These minor-mode variables provide a good way for Lisp programs to turn
-minor modes on and off; they are also useful in a file's local variables
-list. But please think twice before setting minor modes with a local
-variables list, because most minor modes are a matter of user
-preference---other users editing the same file might not want the same
-minor modes you prefer.
-
- The buffer-local minor modes include Abbrev mode, Auto Fill mode,
-Auto Save mode, Font-Lock mode, Glasses mode, ISO Accents mode,
-Outline minor mode, Overwrite mode, and Binary Overwrite mode.
+variable. The variable's value is non-@code{nil} if the mode is
+enabled and @code{nil} if it is disabled. Some minor-mode commands
+work by just setting the variable. For example, the command
+@code{abbrev-mode} works by setting the value of @code{abbrev-mode} as
+a variable; it is this variable that directly turns Abbrev mode on and
+off. You can directly set the variable's value instead of calling the
+mode function. For other minor modes, you need to either set the
+variable through the Customize interface or call the mode function to
+correctly enable or disable the mode. To check which of these two
+possibilities applies to a given minor mode, use @kbd{C-h v} to ask
+for documentation on the variable name.
+
+ For minor mode commands that work by just setting the minor mode
+variable, that variable provides a good way for Lisp programs to turn
+minor modes on and off; it is also useful in a file's local variables
+list (@pxref{File Variables}). But please think twice before setting
+minor modes with a local variables list, because most minor modes are
+a matter of user preference---other users editing the same file might
+not want the same minor modes you prefer.
+
+ The most useful buffer-local minor modes include Abbrev mode, Auto
+Fill mode, Auto Save mode, Font-Lock mode, Glasses mode, ISO Accents
+mode, Outline minor mode, Overwrite mode, and Binary Overwrite mode.
Abbrev mode allows you to define abbreviations that automatically expand
as you type them. For example, @samp{amd} might expand to @samp{abbrev
Font-Lock mode automatically highlights certain textual units found in
programs, such as comments, strings, and function names being defined.
-This requires a window system that can display multiple fonts.
+This requires a graphical display that can show multiple fonts.
@xref{Faces}.
ISO Accents mode makes the characters @samp{`}, @samp{'}, @samp{"},
@samp{^}, @samp{/} and @samp{~} combine with the following letter, to
produce an accented letter in the ISO Latin-1 character set. The
newer and more general feature of input methods more or less
-supersedes ISO Accents mode. @xref{Single-Byte Character Support}.
+supersedes ISO Accents mode. @xref{Unibyte Mode}.
Outline minor mode provides the same facilities as the major mode
called Outline mode; but since it is a minor mode instead, you can
In Binary Overwrite mode, digits after @kbd{C-q} specify an
octal character code, as usual.
- The following minor modes normally apply to all buffers at once.
-Since each is enabled or disabled by the value of a variable, you
-@emph{can} set them differently for particular buffers, by explicitly
-making the corresponding variables local in those buffers.
-@xref{Locals}.
+ Here are some useful minor modes that normally apply to all buffers
+at once. Since Line Number mode and Transient Mark mode can be
+enabled or disabled just by setting the value of the minor mode
+variable, you @emph{can} set them differently for particular buffers,
+by explicitly making the corresponding variable local in those
+buffers. @xref{Locals}.
Icomplete mode displays an indication of available completions when
you are in the minibuffer and completion is active. @xref{Completion
will get an error. This means you must either set the mark, or
explicitly ``reactivate'' it, before each command that uses the region.
The advantage of Transient Mark mode is that Emacs can display the
-region highlighted (currently only when using X). @xref{Mark}.
+region highlighted. @xref{Mark}.
@node Easy Customization
@section Easy Customization Interface
-@cindex user option
- Emacs has many @dfn{user options} which have values that you can set
-in order to customize various commands. Many user options are
-documented in this manual. Most user options are actually Lisp
-variables (@pxref{Variables}), so their names appear in the Variable
-Index (@pxref{Variable Index}). The rest are faces and their
-attributes (@pxref{Faces}).
+@cindex settings
+ Emacs has many @dfn{settings} which have values that you can specify
+in order to customize various commands. Many are documented in this
+manual. Most settings are @dfn{user options}---that is to say, Lisp
+variables (@pxref{Variables})---so their names appear in the Variable
+Index (@pxref{Variable Index}). The other settings are faces and
+their attributes (@pxref{Faces}).
@findex customize
@cindex customization buffer
- You can browse interactively through the the user options and change
-some of them using @kbd{M-x customize}. This command creates a
-@dfn{customization buffer}, which offers commands to navigate through
-a logically organized structure of the Emacs user options; you can
-also use it to edit and set their values, and to save settings
-permanently in your @file{~/.emacs} file (@pxref{Init File}).
+ You can browse interactively through settings and change them using
+@kbd{M-x customize}. This command creates a @dfn{customization
+buffer}, which offers commands to navigate through a logically
+organized structure of the Emacs settings; you can also use it to edit
+and set their values, and to save settings permanently in your
+@file{~/.emacs} file (@pxref{Init File}).
The appearance of the example buffers in this section is typically
-different under a window system, since faces are then used to indicate
-the active fields and other features.
+different under a graphical display, since faces are then used to indicate
+buttons, links and editable fields.
@menu
-* Groups: Customization Groups. How options are classified in a structure.
-* Changing a Variable:: How to edit a value and set an option.
-* Saving Customizations:: Details of saving customizations.
+* Groups: Customization Groups. How settings are classified in a structure.
+* Browsing: Browsing Custom. Browsing and searching for settings.
+* Changing a Variable:: How to edit an option's value and set the option.
+* Saving Customizations:: Specifying the file for saving customizations.
* Face Customization:: How to edit the attributes of a face.
* Specific Customization:: Making a customization buffer for specific
variables, faces, or groups.
+* Custom Themes:: How to define collections of customized options
+ that can be loaded and unloaded together.
@end menu
@node Customization Groups
@subsection Customization Groups
@cindex customization groups
- For customization purposes, user options are organized into
-@dfn{groups} to help you find them. Groups are collected into bigger
-groups, all the way up to a master group called @code{Emacs}.
+ For customization purposes, settings are organized into @dfn{groups}
+to help you find them. Groups are collected into bigger groups, all
+the way up to a master group called @code{Emacs}.
@kbd{M-x customize} creates a customization buffer that shows the
top-level @code{Emacs} group and the second-level groups immediately
@smallexample
/- Emacs group: ---------------------------------------------------\
- [State]: visible group members are all at standard settings.
+ [State]: visible group members are all at standard values.
Customization of the One True Editor.
See also [Manual].
-Confirm Kill Emacs: [Hide] [Value Menu] Don't confirm
- [State]: this option is unchanged from its standard setting.
-How to ask for confirmation when leaving Emacs. [More]
-
Editing group: [Go to Group]
Basic text editing facilities.
line.
@cindex editable fields (customization buffer)
-@cindex active fields (customization buffer)
+@cindex buttons (customization buffer)
+@cindex links (customization buffer)
Most of the text in the customization buffer is read-only, but it
-typically includes some @dfn{editable fields} that you can edit. There
-are also @dfn{active fields}; this means a field that does something
-when you @dfn{invoke} it. To invoke an active field, either click on it
-with @kbd{Mouse-1}, or move point to it and type @key{RET}.
-
- For example, the phrase @samp{[Go to Group]} that appears in a
-second-level group is an active field. Invoking the @samp{[Go to
-Group]} field for a group creates a new customization buffer, which
-shows that group and its contents. This field is a kind of hypertext
-link to another group.
-
- The @code{Emacs} group includes a few user options itself, but
-mainly it contains other groups, which contain more groups, which
-contain the user options. By browsing the hierarchy of groups, you
-will eventually find the feature you are interested in customizing.
-Then you can use the customization buffer to set the options
-pertaining to that feature. You can also go straight to a particular
-group by name, using the command @kbd{M-x customize-group}.
-
+typically includes some @dfn{editable fields} that you can edit.
+There are also @dfn{buttons} and @dfn{links}, which do something when
+you @dfn{invoke} them. To invoke a button or a link, either click on
+it with @kbd{Mouse-1}, or move point to it and type @key{RET}.
+
+ For example, the phrase @samp{[State]} that appears in
+a second-level group is a button. It operates on the same
+customization buffer. The phrase @samp{[Go to Group]} is a kind
+of hypertext link to another group. Invoking it creates a new
+customization buffer, which shows that group and its contents.
+
+ The @code{Emacs} group includes a few settings, but mainly it
+contains other groups, which contain more groups, which contain the
+settings. By browsing the hierarchy of groups, you will eventually
+find the feature you are interested in customizing. Then you can use
+the customization buffer to set that feature's settings. You can also
+go straight to a particular group by name, using the command @kbd{M-x
+customize-group}.
+
+@node Browsing Custom
+@subsection Browsing and Searching for Options and Faces
@findex customize-browse
- You can view the structure of customization groups on a larger scale
-with @kbd{M-x customize-browse}. This command creates a special kind of
-customization buffer which shows only the names of the groups (and
-variables and faces), and their structure.
+
+ @kbd{M-x customize-browse} is another way to browse the available
+settings. This command creates a special customization buffer which
+shows only the names of groups and settings, and puts them in a
+structure.
In this buffer, you can show the contents of a group by invoking
@samp{[+]}. When the group contents are visible, this button changes to
@samp{[-]}; invoking that hides the group contents.
- Each group, variable, or face name in this buffer has an active field
-which says @samp{[Group]}, @samp{[Variable]} or @samp{[Face]}. Invoking
-that active field creates an ordinary customization buffer showing just
-that group and its contents, just that variable, or just that face.
-This is the way to set values in it.
+ Each setting in this buffer has a link which says @samp{[Group]},
+@samp{[Option]} or @samp{[Face]}. Invoking this link creates an
+ordinary customization buffer showing just that group and its
+contents, just that user option, or just that face. This is the way
+to change settings that you find with @kbd{M-x customize-browse}.
+
+ If you can guess part of the name of the settings you are interested
+in, @kbd{M-x customize-apropos} is another way to search for settings.
+However, unlike @code{customize} and @code{customize-browse},
+@code{customize-apropos} can only find groups and settings that are
+loaded in the current Emacs session. @xref{Specific Customization,,
+Customizing Specific Items}.
@node Changing a Variable
@subsection Changing a Variable
- Here is an example of what a variable looks like in the
-customization buffer:
+ Here is an example of what a variable (a user option) looks like in
+the customization buffer:
@smallexample
-Kill Ring Max: [Hide] 60
- [State]: this variable is unchanged from its standard setting.
+Kill Ring Max: [Hide Value] 60
+ [State]: STANDARD.
Maximum length of kill ring before oldest elements are thrown away.
@end smallexample
- The text following @samp{[Hide]}, @samp{60} in this case, indicates
-the current value of the variable. If you see @samp{[Show]} instead of
-@samp{[Hide]}, it means that the value is hidden; the customization
+ The text following @samp{[Hide Value]}, @samp{60} in this case, indicates
+the current value of the variable. If you see @samp{[Show Value]} instead of
+@samp{[Hide Value]}, it means that the value is hidden; the customization
buffer initially hides values that take up several lines. Invoke
-@samp{[Show]} to show the value.
+@samp{[Show Value]} to show the value.
- The line after the option name indicates the @dfn{customization state}
-of the variable: in the example above, it says you have not changed the
-option yet. The word @samp{[State]} at the beginning of this line is
-active; you can get a menu of various operations by invoking it with
-@kbd{Mouse-1} or @key{RET}. These operations are essential for
-customizing the variable.
+ The line after the variable name indicates the @dfn{customization
+state} of the variable: in the example above, it says you have not
+changed the option yet. The @samp{[State]} button at the beginning of
+this line gives you a menu of various operations for customizing the
+variable.
The line after the @samp{[State]} line displays the beginning of the
variable's documentation string. If there are more lines of
-documentation, this line ends with @samp{[More]}; invoke this to show
-the full documentation string.
+documentation, this line ends with a @samp{[More]} button; invoke that
+to show the full documentation string.
- To enter a new value for @samp{Kill Ring Max}, move point to the value
-and edit it textually. For example, you can type @kbd{M-d}, then insert
-another number.
-
- When you begin to alter the text, you will see the @samp{[State]} line
-change to say that you have edited the value:
+ To enter a new value for @samp{Kill Ring Max}, move point to the
+value and edit it textually. For example, you can type @kbd{M-d},
+then insert another number. As you begin to alter the text, you will
+see the @samp{[State]} line change to say that you have edited the
+value:
@smallexample
-[State]: you have edited the value as text, but not set the variable.
+[State]: EDITED, shown value does not take effect until you set or @r{@dots{}}
+ save it.
@end smallexample
-@cindex setting option value
- Editing the value does not actually set the variable. To do
-that, you must @dfn{set} it. To do this, invoke the word
-@samp{[State]} and choose @samp{Set for Current Session}.
+@cindex settings, how to set
+ Editing the value does not actually set the variable. To do that,
+you must @dfn{set} the variable. To do this, invoke the
+@samp{[State]} button and choose @samp{Set for Current Session}.
The state of the variable changes visibly when you set it:
@smallexample
-[State]: you have set this variable, but not saved it for future sessions.
+[State]: SET for current session only.
@end smallexample
You don't have to worry about specifying a value that is not valid;
-setting the variable checks for validity and will not really install an
-unacceptable value.
+the @samp{Set for Current Session} operation checks for validity and
+will not install an unacceptable value.
@kindex M-TAB @r{(customization buffer)}
@findex widget-complete
- While editing a value or field that is a file name, directory name,
-command name, or anything else for which completion is defined, you can
-type @kbd{M-@key{TAB}} (@code{widget-complete}) to do completion.
+ While editing a field that is a file name, directory name,
+command name, or anything else for which completion is defined, you
+can type @kbd{M-@key{TAB}} (@code{widget-complete}) to do completion.
+(@kbd{@key{ESC} @key{TAB}} and @kbd{C-M-i} do the same thing.)
Some variables have a small fixed set of possible legitimate values.
-These variables don't let you edit the value textually. Instead, an
-active field @samp{[Value Menu]} appears before the value; invoke this
-field to edit the value. For a boolean ``on or off'' value, the active
-field says @samp{[Toggle]}, and it changes to the other value.
-@samp{[Value Menu]} and @samp{[Toggle]} edit the buffer; the changes
-take effect when you use the @samp{Set for Current Session} operation.
+These variables don't let you edit the value textually. Instead, a
+@samp{[Value Menu]} button appears before the value; invoke this
+button to change the value. For a boolean ``on or off'' value, the
+button says @samp{[Toggle]}, and it changes to the other value.
+@samp{[Value Menu]} and @samp{[Toggle]} simply edit the buffer; the
+changes take real effect when you use the @samp{Set for Current
+Session} operation.
Some variables have values with complex structure. For example, the
value of @code{file-coding-system-alist} is an association list. Here
is how it appears in the customization buffer:
@smallexample
-File Coding System Alist: [Hide]
+File Coding System Alist: [Hide Value]
[INS] [DEL] File regexp: \.elc\'
Choice: [Value Menu] Encoding/decoding pair:
Decoding: emacs-mule
Decoding: undecided
Encoding: nil
[INS]
- [State]: this variable is unchanged from its standard setting.
-Alist to decide a coding system to use for a file I/O operation. [Hide]
+ [State]: STANDARD.
+Alist to decide a coding system to use for a file I/O @r{@dots{}}
+ operation. [Hide Rest]
The format is ((PATTERN . VAL) ...),
where PATTERN is a regular expression matching a file name,
@r{[@dots{}more lines of documentation@dots{}]}
@noindent
Each association in the list appears on four lines, with several
-editable or ``active'' fields. You can edit the regexps and coding
+editable fields and/or buttons. You can edit the regexps and coding
systems using ordinary editing commands. You can also invoke
-@samp{[Value Menu]} to switch to a kind of value---for instance, to
-specify a function instead of a pair of coding systems.
+@samp{[Value Menu]} to switch to a different kind of value---for
+instance, to specify a function instead of a pair of coding systems.
To delete an association from the list, invoke the @samp{[DEL]} button
for that item. To add an association, invoke @samp{[INS]} at the
@kindex S-TAB @r{(customization buffer)}
@findex widget-forward
@findex widget-backward
- Two special commands, @key{TAB} and @kbd{S-@key{TAB}}, are useful for
-moving through the customization buffer. @key{TAB}
-(@code{widget-forward}) moves forward to the next active or editable
-field; @kbd{S-@key{TAB}} (@code{widget-backward}) moves backward to the
-previous active or editable field.
+ Two special commands, @key{TAB} and @kbd{S-@key{TAB}}, are useful
+for moving through the customization buffer. @key{TAB}
+(@code{widget-forward}) moves forward to the next button or editable
+field; @kbd{S-@key{TAB}} (@code{widget-backward}) moves backward to
+the previous button or editable field.
Typing @key{RET} on an editable field also moves forward, just like
@key{TAB}. We set it up this way because people often type @key{RET}
when they are finished editing a field. To insert a newline within an
editable field, use @kbd{C-o} or @kbd{C-q C-j}.
-@cindex saving variable value
-@cindex customized variables, saving
+@cindex saving a setting
+@cindex settings, how to save
Setting the variable changes its value in the current Emacs session;
@dfn{saving} the value changes it for future sessions as well. To
save the variable, invoke @samp{[State]} and select the @samp{Save for
You can also restore the variable to its standard value by invoking
@samp{[State]} and selecting the @samp{Erase Customization} operation.
-There are actually three reset operations:
+There are actually four reset operations:
@table @samp
-@item Reset
+@item Undo Edits
If you have made some modifications and not yet set the variable,
this restores the text in the customization buffer to match
the actual value.
@item Erase Customization
This sets the variable to its standard value, and updates the text
-accordingly. This also eliminates any saved value for the option,
+accordingly. This also eliminates any saved value for the variable,
so that you will get the standard value in future Emacs sessions.
-@item Use Backup Value
+@item Set to Backup Value
This sets the variable to a previous value that was set in the
customization buffer in this session. If you customize a variable
and then reset it, which discards the customized value,
the same variable in a customization buffer, even in another session.
The state of a group indicates whether anything in that group has been
-edited, set or saved. You can select @samp{Set for Current Session},
-@samp{Save for Future Sessions} and the various kinds of @samp{Reset}
-operation for the group; these operations on the group apply to all
-options in the group and its subgroups.
+edited, set or saved.
- Near the top of the customization buffer there are two lines
-containing several active fields:
+ Near the top of the customization buffer there are two lines of buttons:
@smallexample
[Set for Current Session] [Save for Future Sessions]
- [Reset] [Reset to Saved] [Erase Customization] [Finish]
+ [Undo Edits] [Reset to Saved] [Erase Customization] [Finish]
@end smallexample
@vindex custom-buffer-done-function
@noindent
Invoking @samp{[Finish]} either buries or kills this customization
buffer according to the setting of the option
-@code{custom-buffer-done-function}; the default is to bury the buffer.
-Each of the other fields performs an operation---set, save or
-reset---on each of the options in the buffer that could meaningfully
-be set, saved or reset. They do not operate on options whose values
-are hidden.
+@code{custom-buffer-done-kill}; the default is to bury the buffer.
+Each of the other buttons performs an operation---set, save or
+reset---on each of the settings in the buffer that could meaningfully
+be set, saved or reset. They do not operate on settings whose values
+are hidden, nor on subgroups not visible in the buffer.
@node Saving Customizations
@subsection Saving Customizations
example of how a face looks:
@smallexample
-Custom Changed Face:(sample) [Hide]
- [State]: this face is unchanged from its standard setting.
+Custom Changed Face:(sample) [Hide Face]
+ [State]: STANDARD.
Face used when the customize item has been changed.
-Parent groups: => Custom Magic Faces
+Parent groups: [Custom Magic Faces]
Attributes: [ ] Font Family: *
[ ] Width: *
[ ] Height: *
[ ] Inherit: *
@end smallexample
- Each face attribute has its own line. The @samp{[@var{x}]} field
+ Each face attribute has its own line. The @samp{[@var{x}]} button
before the attribute name indicates whether the attribute is
-@dfn{enabled}; @samp{X} means that it is. You can enable or disable the
-attribute by invoking that field. When the attribute is enabled, you
-can change the attribute value in the usual ways.
+@dfn{enabled}; @samp{[X]} means that it's enabled, and @samp{[ ]}
+means that it's disabled. You can enable or disable the attribute by
+clicking that button. When the attribute is enabled, you can change
+the attribute value in the usual ways.
For the colors, you can specify a color name (use @kbd{M-x
-list-colors-display}) for a list of them) or a hexadecimal color
+list-colors-display} for a list of them) or a hexadecimal color
specification of the form @samp{#@var{rr}@var{gg}@var{bb}}.
(@samp{#000000} is black, @samp{#ff0000} is red, @samp{#00ff00} is
green, @samp{#0000ff} is blue, and @samp{#ffffff} is white.) On a
A face can specify different appearances for different types of
display. For example, a face can make text red on a color display, but
use a bold font on a monochrome display. To specify multiple
-appearances for a face, select @samp{Show all display specs} in the menu you
-get from invoking @samp{[State]}.
+appearances for a face, select @samp{For All Kinds of Displays} in the
+menu you get from invoking @samp{[State]}.
@findex modify-face
Another more basic way to set the attributes of a specific face is
@node Specific Customization
@subsection Customizing Specific Items
- Instead of finding the options you want to change by moving down
-through the structure of groups, you can specify the particular variable,
-face, or group that you want to customize.
+ Instead of finding the setting you want to change by navigating the
+structure of groups, here are other ways to specify the settings that
+you want to customize.
@table @kbd
@item M-x customize-variable @key{RET} @var{variable} @key{RET}
@item M-x customize-group @key{RET} @var{group} @key{RET}
Set up a customization buffer with just one group, @var{group}.
@item M-x customize-apropos @key{RET} @var{regexp} @key{RET}
-Set up a customization buffer with all the variables, faces and groups
-that match @var{regexp}.
+Set up a customization buffer with all the settings and groups that
+match @var{regexp}.
@item M-x customize-changed-options @key{RET} @var{version} @key{RET}
-Set up a customization buffer with all the variables, faces and groups
+Set up a customization buffer with all the settings and groups
whose meaning has changed since Emacs version @var{version}.
@item M-x customize-saved
-Set up a customization buffer containing all variables and faces that you
+Set up a customization buffer containing all settings that you
have saved with customization buffers.
@item M-x customize-customized
-Set up a customization buffer containing all variables and faces that you
-have customized but not saved.
+Set up a customization buffer containing all settings that you have
+customized but not saved.
@end table
@findex customize-variable
customize-variable} and specify the variable name. This sets up the
customization buffer with just one variable---the one that you asked
for. Editing, setting and saving the value work as described above,
-but only for the specified variable.
+but only for the specified variable. Minibuffer completion is handy
+if you only know part of the name. However, this command can only see
+options that have been loaded in the current Emacs session.
@findex customize-face
Likewise, you can modify a specific face, chosen by name, using
@findex customize-group
You can also set up the customization buffer with a specific group,
using @kbd{M-x customize-group}. The immediate contents of the chosen
-group, including user options, faces, and other groups, all appear
-as well. However, these subgroups' own contents start out hidden. You
-can show their contents in the usual way, by invoking @samp{[Show]}.
+group, including variables, faces, and other groups, all appear
+as well (even if not already loaded). However, the subgroups' own
+contents are not included.
@findex customize-apropos
To control more precisely what to customize, you can use @kbd{M-x
-customize-apropos}. You specify a regular expression as argument; then
-all options, faces and groups whose names match this regular expression
-are set up in the customization buffer. If you specify an empty regular
-expression, this includes @emph{all} groups, options and faces in the
-customization buffer (but that takes a long time).
+customize-apropos}. You specify a regular expression as argument;
+then all @emph{loaded} settings and groups whose names match this
+regular expression are set up in the customization buffer. If you
+specify an empty regular expression, this includes @emph{all} loaded
+groups and settings---which takes a long time to set up.
-@findex customize-changed-options
+@findex customize-changed
When you upgrade to a new Emacs version, you might want to customize
-new options and options whose meanings or default values have changed.
-To do this, use @kbd{M-x customize-changed-options} and specify a
-previous Emacs version number using the minibuffer. It creates a
-customization buffer which shows all the options (and groups) whose
-definitions have been changed since the specified version.
+new settings and settings whose meanings or default values have
+changed. To do this, use @kbd{M-x customize-changed} and
+specify a previous Emacs version number using the minibuffer. It
+creates a customization buffer which shows all the settings and groups
+whose definitions have been changed since the specified version, loading
+them if necessary.
@findex customize-saved
@findex customize-customized
- If you change option values and then decide the change was a
-mistake, you can use two special commands to revisit your previous
-changes. Use @kbd{M-x customize-saved} to look at the options that
-you have saved. Use @kbd{M-x customize-customized} to look at the
-options that you have set but not saved.
+ If you change settings and then decide the change was a mistake, you
+can use two special commands to revisit your previous changes. Use
+@kbd{M-x customize-saved} to look at the settings that you have saved.
+Use @kbd{M-x customize-customized} to look at the settings that you
+have set but not saved.
+
+@node Custom Themes
+@subsection Customization Themes
+@cindex custom themes
+
+ @dfn{Custom themes} are collections of settings that can be enabled
+or disabled as a unit. You can use Custom themes to switch quickly
+and easily between various collections of settings, and to transfer
+such collections from one computer to another.
+
+@findex customize-create-theme
+ To define a Custom theme, use @kbd{M-x customize-create-theme},
+which brings up a buffer named @samp{*New Custom Theme*}. At the top
+of the buffer is an editable field where you can specify the name of
+the theme. Click on the button labelled @samp{Insert Variable} to add
+a variable to the theme, and click on @samp{Insert Face} to add a
+face. You can edit these values in the @samp{*New Custom Theme*}
+buffer like in an ordinary Customize buffer. To remove an option from
+the theme, click on its @samp{State} button and select @samp{Delete}.
+
+@vindex custom-theme-directory
+ After adding the desired options, click on @samp{Save Theme} to save
+the Custom theme. This writes the theme definition to a file
+@file{@var{foo}-theme.el} (where @var{foo} is the theme name you
+supplied), in the directory @file{~/.emacs.d/}. You can specify the
+directory by setting @code{custom-theme-directory}.
+
+ You can view and edit the settings of a previously-defined theme by
+clicking on @samp{Visit Theme} and specifying the theme name. You can
+also import the variables and faces that you have set using Customize
+by visiting the ``special'' theme named @samp{user}. This theme, which
+records all the options that you set in the ordinary customization
+buffer, is always enabled, and always takes precedence over all other
+enabled Custom themes. Additionally, the @samp{user} theme is
+recorded in your @file{.emacs} file, rather than a
+@file{user-theme.el} file.
+
+@vindex custom-enabled-themes
+ Once you have defined a Custom theme, you can use it by customizing
+the variable @code{custom-enabled-themes}. This is a list of Custom
+themes that are @dfn{enabled}, or put into effect. If you set
+@code{custom-enabled-themes} using the Customize interface, the theme
+definitions are automatically loaded from the theme files, if they
+aren't already. If you save the value of @code{custom-enabled-themes}
+for future Emacs sessions, those Custom themes will be enabled
+whenever Emacs is started up.
+
+ If two enabled themes specify different values for an option, the
+theme occurring earlier in @code{custom-enabled-themes} takes effect.
+
+@findex load-theme
+@findex enable-theme
+@findex disable-theme
+ You can temporarily enable a Custom theme with @kbd{M-x
+enable-theme}. This prompts for a theme name in the minibuffer, loads
+the theme from the theme file if necessary, and enables the theme.
+You can @dfn{disabled} any enabled theme with the command @kbd{M-x
+disable-theme}; this returns the options specified in the theme to
+their original values. To re-enable the theme, type @kbd{M-x
+enable-theme} again. If a theme file is changed during your Emacs
+session, you can reload it by typing @kbd{M-x load-theme}. (This also
+enables the theme.)
@node Variables
@section Variables
have a documentation string which describes what kind of value it should
have and how the value will be used.
- Lisp allows any variable to have any kind of value, but most variables
-that Emacs uses need a value of a certain type. Often the value should
-always be a string, or should always be a number. Sometimes we say that a
-certain feature is turned on if a variable is ``non-@code{nil},'' meaning
-that if the variable's value is @code{nil}, the feature is off, but the
-feature is on for @emph{any} other value. The conventional value to use to
-turn on the feature---since you have to pick one particular value when you
-set the variable---is @code{t}.
+ Emacs Lisp allows any variable (with a few exceptions) to have any
+kind of value, but most variables that Emacs uses need a value of a
+certain type. Often the value should always be a string, or should
+always be a number. Sometimes we say that a certain feature is turned
+on if a variable is ``non-@code{nil},'' meaning that if the variable's
+value is @code{nil}, the feature is off, but the feature is on for
+@emph{any} other value. The conventional value to use to turn on the
+feature---since you have to pick one particular value when you set the
+variable---is @code{t}.
Emacs uses many Lisp variables for internal record keeping, but the
-most interesting variables for a non-programmer user are those that
-are also @dfn{user options}, the variables that are meant for users to
-change. Each user option that you can set with the customization
-buffer is (if it is not a face) in fact a Lisp variable. Emacs does
-not (usually) change the values of these variables; instead, you set
-the values, and thereby alter and control the behavior of certain
-Emacs commands. Use of the customization buffer is explained above
-(@pxref{Easy Customization}); here we describe other aspects of Emacs
-variables.
+most interesting variables for a non-programmer user are those meant
+for users to change---the @dfn{user options}.
+
+ Each user option that you can set with the customization buffer is
+in fact a Lisp variable. Emacs does not (usually) change the values
+of these variables; instead, you set the values, and thereby alter and
+control the behavior of certain Emacs commands. Use of the
+customization buffer is explained above (@pxref{Easy Customization});
+here we describe other aspects of Emacs variables.
@menu
* Examining:: Examining or setting one variable's value.
The most convenient way to set a specific user option variable is
with @kbd{M-x set-variable}. This reads the variable name with the
minibuffer (with completion), and then reads a Lisp expression for the
-new value using the minibuffer a second time. For example,
+new value using the minibuffer a second time (you can insert the old
+value into the minibuffer for editing via @kbd{M-n}). For example,
@example
M-x set-variable @key{RET} fill-column @key{RET} 75 @key{RET}
If you play with adding various different versions of a hook
function by calling @code{add-hook} over and over, remember that all
-the versions you added will remain in the hook variable together.
-To clear them out, you can do @code{(setq @var{hook-variable} nil)}.
+the versions you added will remain in the hook variable together. You
+can clear out individual functions with @code{remove-hook}, or do
+@code{(setq @var{hook-variable} nil)} to remove everything.
@node Locals
@subsection Local Variables
specifications; it automatically makes these variables local to the
buffer, and sets them to the values specified in the file.
- There are two ways to specify local variable values: in the first
+@menu
+* Specifying File Variables:: Specifying file local variables.
+* Safe File Variables:: Making sure file local variables are safe.
+@end menu
+
+@node Specifying File Variables
+@subsubsection Specifying File Variables
+
+ There are two ways to specify file local variable values: in the first
line, or with a local variables list. Here's how to specify them in the
first line:
in the @samp{-*-} line first, and @emph{everything} in the local
variables list afterward.
-Here is an example of a local variables list:
+ Here is an example of a local variables list:
@example
;;; Local Variables: ***
major mode of a buffer according to the file name and contents,
including the local variables list if any. @xref{Choosing Modes}.
-@findex enable-local-variables
- The variable @code{enable-local-variables} controls whether to process
-local variables in files, and thus gives you a chance to override them.
-Its default value is @code{t}, which means do process local variables in
-files. If you set the value to @code{nil}, Emacs simply ignores local
-variables in files. Any other value says to query you about each file
-that has local variables, showing you the local variable specifications
-so you can judge.
-
-@findex enable-local-eval
- The @code{eval} ``variable,'' and certain actual variables, create a
-special risk; when you visit someone else's file, local variable
-specifications for these could affect your Emacs in arbitrary ways.
-Therefore, the variable @code{enable-local-eval} controls whether Emacs
-processes @code{eval} variables, as well variables with names that end
-in @samp{-hook}, @samp{-hooks}, @samp{-function} or @samp{-functions},
-and certain other variables. The three possibilities for the variable's
-value are @code{t}, @code{nil}, and anything else, just as for
-@code{enable-local-variables}. The default is @code{maybe}, which is
-neither @code{t} nor @code{nil}, so normally Emacs does ask for
-confirmation about file settings for these variables.
-
-@findex safe-local-eval-forms
+@node Safe File Variables
+@subsubsection Safety of File Variables
+
+ File-local variables can be dangerous; when you visit someone else's
+file, there's no telling what its local variables list could do to
+your Emacs. Improper values of the @code{eval} ``variable,'' and
+other variables such as @code{load-path}, could execute Lisp code you
+didn't intend to run.
+
+ Therefore, whenever Emacs encounters file local variable values that
+are not known to be safe, it displays the file's entire local
+variables list, and asks you for confirmation before setting them.
+You can type @kbd{y} or @key{SPC} to put the local variables list into
+effect, or @kbd{n} to ignore it. When Emacs is run in batch mode
+(@pxref{Initial Options}), it can't really ask you, so it assumes the
+answer @samp{n}.
+
+ Emacs normally recognizes certain variables/value pairs as safe.
+For instance, it is safe to give @code{comment-column} or
+@code{fill-column} any integer value. If a file specifies only safe
+variable/value pairs, Emacs does not ask for confirmation before
+setting them. Otherwise, you can tell Emacs to record that all the
+variable/value pairs in the file are safe, by typing @kbd{!} at the
+confirmation prompt. When Emacs encounters these variable/value pairs
+subsequently, in the same file or others, it will assume they are
+safe.
+
+@vindex safe-local-variable-values
+@cindex risky variable
+ Some variables, such as @code{load-path}, are considered
+particularly @dfn{risky}: there is seldom any reason to specify them
+as local variables, and changing them can be dangerous. Even if you
+enter @kbd{!} at the confirmation prompt, Emacs will not record any
+values as safe for these variables. If you really want to record safe
+values for these variables, do it directly by customizing
+@samp{safe-local-variable-values} (@pxref{Easy Customization}).
+
+@vindex enable-local-variables
+ The variable @code{enable-local-variables} allows you to change the
+way Emacs processes local variables. Its default value is @code{t},
+which specifies the behavior described above. If it is @code{nil},
+Emacs simply ignores all file local variables. Any other value says
+to query you about each file that has local variables, without trying
+to determine whether the values are known to be safe.
+
+@vindex enable-local-eval
+ The variable @code{enable-local-eval} controls whether Emacs
+processes @code{eval} variables. The three possibilities for the
+variable's value are @code{t}, @code{nil}, and anything else, just as
+for @code{enable-local-variables}. The default is @code{maybe}, which
+is neither @code{t} nor @code{nil}, so normally Emacs does ask for
+confirmation about processes @code{eval} variables.
+
+@vindex safe-local-eval-forms
The @code{safe-local-eval-forms} is a customizable list of eval
forms which are safe to eval, so Emacs should not ask for
-confirmation to evaluate these forms, even if
-@code{enable-local-variables} says to ask for confirmation in general.
+confirmation to evaluate these forms.
@node Key Bindings
@section Customizing Key Bindings
symbol whose function definition is the following keymap; the effect is
the same, but it provides a command name for the prefix key that can be
used as a description of what the prefix key is for. Thus, the binding
-of @kbd{C-x} is the symbol @code{Ctl-X-Prefix}, whose function
+of @kbd{C-x} is the symbol @code{Control-X-prefix}, whose function
definition is the keymap for @kbd{C-x} commands. The definitions of
@kbd{C-c}, @kbd{C-x}, @kbd{C-h} and @key{ESC} as prefix keys appear in
the global map, so these prefix keys are always available.
@vindex minibuffer-local-ns-map
@vindex minibuffer-local-completion-map
@vindex minibuffer-local-must-match-map
+@vindex minibuffer-local-filename-completion-map
+@vindex minibuffer-local-must-match-filename-map
The minibuffer has its own set of local keymaps; they contain various
completion and exit commands.
@item
@code{minibuffer-local-must-match-map} is for strict completion and
for cautious completion.
+@item
+@code{minibuffer-local-filename-completion-map} and
+@code{minibuffer-local-must-match-filename-map} are like the two
+previous ones, but they are specifically for file name completion.
+They do not bind @key{SPC}.
@end itemize
@node Rebinding
(global-set-key [H-M-right] 'forward-word)
@end example
+@cindex keypad
+ Many keyboards have a ``numeric keypad'' on the right hand side.
+The numeric keys in the keypad double up as cursor motion keys,
+toggled by a key labeled @samp{Num Lock}. By default, Emacs
+translates these keys to the corresponding keys in the main keyboard.
+For example, when @samp{Num Lock} is on, the key labeled @samp{8} on
+the numeric keypad produces @code{kp-8}, which is translated to
+@kbd{8}; when @samp{Num Lock} is off, the same key produces
+@code{kp-up}, which is translated to @key{UP}. If you rebind a key
+such as @kbd{8} or @key{UP}, it affects the equivalent keypad key too.
+However, if you rebind a @samp{kp-} key directly, that won't affect
+its non-keypad equivalent.
+
+ Emacs provides a convenient method for binding the numeric keypad
+keys, using the variables @code{keypad-setup},
+@code{keypad-numlock-setup}, @code{keypad-shifted-setup}, and
+@code{keypad-numlock-shifted-setup}. These can be found in the
+@samp{keyboard} customization group (@pxref{Easy Customization}). You
+can rebind the keys to perform other tasks, such as issuing numeric
+prefix arguments.
+
@node Named ASCII Chars
@subsection Named @acronym{ASCII} Control Characters
Emacs also supports triple-click events whose names start with
@samp{triple-}. Emacs does not distinguish quadruple clicks as event
types; clicks beyond the third generate additional triple-click events.
-However, the full number of clicks is recorded in the event list, so you
-can distinguish if you really want to. We don't recommend distinct
-meanings for more than three clicks, but sometimes it is useful for
-subsequent clicks to cycle through the same set of three meanings, so
-that four clicks are equivalent to one click, five are equivalent to
-two, and six are equivalent to three.
+However, the full number of clicks is recorded in the event list, so
+if you know Emacs Lisp you can distinguish if you really want to
+(@pxref{Accessing Events,,, elisp, The Emacs Lisp Reference Manual}).
+We don't recommend distinct meanings for more than three clicks, but
+sometimes it is useful for subsequent clicks to cycle through the same
+set of three meanings, so that four clicks are equivalent to one
+click, five are equivalent to two, and six are equivalent to three.
Emacs also records multiple presses in drag and button-down events.
For example, when you press a button twice, then move the mouse while
@vindex double-click-fuzz
The variable @code{double-click-fuzz} specifies how much the mouse
-can move between clicks still allow them to be grouped as a multiple
+can move between clicks and still allow them to be grouped as a multiple
click. Its value is in units of pixels on windowed displays and in
units of 1/8 of a character cell on text-mode terminals; the default is
3.
@item vertical-scroll-bar
The mouse was in a vertical scroll bar. (This is the only kind of
scroll bar Emacs currently supports.)
+@item menu-bar
+The mouse was in the menu bar.
+@item header-line
+The mouse was in a header line.
@ignore
@item horizontal-scroll-bar
The mouse was in a horizontal scroll bar. Horizontal scroll bars do
@kbd{M-x}. Disabling a command has no effect on calling it as a
function from Lisp programs.
-@node Keyboard Translations
-@section Keyboard Translations
-
- Some keyboards do not make it convenient to send all the special
-characters that Emacs uses. The most common problem case is the
-@key{DEL} character. Some keyboards provide no convenient way to type
-this very important character---usually because they were designed to
-expect the character @kbd{C-h} to be used for deletion. On these
-keyboards, if you press the key normally used for deletion, Emacs handles
-the @kbd{C-h} as a prefix character and offers you a list of help
-options, which is not what you want.
-
-@cindex keyboard translations
-@findex keyboard-translate
- You can work around this problem within Emacs by setting up keyboard
-translations to turn @kbd{C-h} into @key{DEL} and @key{DEL} into
-@kbd{C-h}, as follows:
-
-@example
-;; @r{Translate @kbd{C-h} to @key{DEL}.}
-(keyboard-translate ?\C-h ?\C-?)
-
-;; @r{Translate @key{DEL} to @kbd{C-h}.}
-(keyboard-translate ?\C-? ?\C-h)
-@end example
-
- Keyboard translations are not the same as key bindings in keymaps
-(@pxref{Keymaps}). Emacs contains numerous keymaps that apply in
-different situations, but there is only one set of keyboard
-translations, and it applies to every character that Emacs reads from
-the terminal. Keyboard translations take place at the lowest level of
-input processing; the keys that are looked up in keymaps contain the
-characters that result from keyboard translation.
-
- On a window system, the keyboard key named @key{DELETE} is a function
-key and is distinct from the @acronym{ASCII} character named @key{DEL}.
-@xref{Named ASCII Chars}. Keyboard translations affect only @acronym{ASCII}
-character input, not function keys; thus, the above example used on a
-window system does not affect the @key{DELETE} key. However, the
-translation above isn't necessary on window systems, because Emacs can
-also distinguish between the @key{BACKSPACE} key and @kbd{C-h}; and it
-normally treats @key{BACKSPACE} as @key{DEL}.
-
- For full information about how to use keyboard translations, see
-@ref{Translating Input,,,elisp, The Emacs Lisp Reference Manual}.
-
@node Syntax
@section The Syntax Table
@cindex syntax table
@cindex startup (init file)
When Emacs is started, it normally loads a Lisp program from the
-file @file{.emacs} or @file{.emacs.el} in your home directory. (You
-can also put it in a subdirectory @file{~/.emacs.d} and Emacs will
-still find it.) We call this file your @dfn{init file} because it
-specifies how to initialize Emacs for you. You can use the command
-line switch @samp{-q} to prevent loading your init file, and @samp{-u}
-(or @samp{--user}) to specify a different user's init file
-(@pxref{Initial Options}).
+file @file{.emacs} or @file{.emacs.el} in your home directory
+(see @ref{General Variables, HOME}, if you don't know where that is).
+We call this file your @dfn{init file} because it specifies how to
+initialize Emacs for you. You can use the command line switch
+@samp{-q} to prevent loading your init file, and @samp{-u} (or
+@samp{--user}) to specify a different user's init file (@pxref{Initial
+Options}).
+
+ You can also use @file{~/.emacs.d/init.el} as the init file. Emacs
+tries this if it cannot find @file{~/.emacs} or @file{~/.emacs.el}.
@cindex @file{default.el}, the default init file
There can also be a @dfn{default init file}, which is the library
finds this file via the standard search path for Lisp libraries.
Emacs loads this library before it loads your init file. To inhibit
loading of this library, use the option @samp{--no-site-file}.
-@xref{Initial Options}.
+@xref{Initial Options}. We recommend against using
+@file{site-start.el} for changes that some users may not like. It is
+better to put them in @file{default.el}, so that users can more easily
+override them.
You can place @file{default.el} and @file{site-start.el} in any of
the directories which Emacs searches for Lisp libraries. The variable
@example
(put 'narrow-to-region 'disabled nil)
@end example
+
+@item
+Adjusting the configuration to various platforms and Emacs versions.
+
+Users typically want Emacs to behave the same on all systems, so the
+same init file is right for all platforms. However, sometimes it
+happens that a function you use for customizing Emacs is not available
+on some platforms or in older Emacs versions. To deal with that
+situation, put the customization inside a conditional that tests whether
+the function or facility is available, like this:
+
+@example
+(if (fboundp 'blink-cursor-mode)
+ (blink-cursor-mode 0))
+
+(if (boundp 'coding-category-utf-8)
+ (set-coding-priority '(coding-category-utf-8)))
+@end example
+
+@noindent
+You can also simply disregard the errors that occur if the
+function is not defined.
+
+@example
+(condition case ()
+ (set-face-background 'region "grey75")
+ (error nil))
+@end example
+
+A @code{setq} on a variable which does not exist is generally
+harmless, so those do not need a conditional.
@end itemize
@node Terminal Init
@node Find Init
@subsection How Emacs Finds Your Init File
- Normally Emacs uses the environment variable @env{HOME} to find
-@file{.emacs}; that's what @samp{~} means in a file name. If @file{.emacs}
-is not found directly inside @file{~/}, Emacs looks for it in
-@file{~/.emacs.d/}.
+ Normally Emacs uses the environment variable @env{HOME}
+(@pxref{General Variables, HOME}) to find @file{.emacs}; that's what
+@samp{~} means in a file name. If @file{.emacs} is not found inside
+@file{~/} (nor @file{.emacs.el}), Emacs looks for
+@file{~/.emacs.d/init.el} (which, like @file{~/.emacs.el}, can be
+byte-compiled).
However, if you run Emacs from a shell started by @code{su}, Emacs
tries to find your own @file{.emacs}, not that of the user you are
editor customizations even if you are running as the super user.
More precisely, Emacs first determines which user's init file to use.
-It gets the user name from the environment variables @env{LOGNAME} and
+It gets your user name from the environment variables @env{LOGNAME} and
@env{USER}; if neither of those exists, it uses effective user-ID.
If that user name matches the real user-ID, then Emacs uses @env{HOME};
otherwise, it looks up the home directory corresponding to that user