Commit | Line | Data |
---|---|---|
6bf7aab6 | 1 | @c This is part of the Emacs manual. |
6ca0edfe DL |
2 | @c Copyright (C) 1985, 86, 87, 93, 94, 95, 97, 2000 |
3 | @c Free Software Foundation, Inc. | |
6bf7aab6 DL |
4 | @c See file emacs.texi for copying conditions. |
5 | @node Customization, Quitting, Amusements, Top | |
6 | @chapter Customization | |
7 | @cindex customization | |
8 | ||
9 | This chapter talks about various topics relevant to adapting the | |
10 | behavior of Emacs in minor ways. See @cite{The Emacs Lisp Reference | |
11 | Manual} for how to make more far-reaching changes. | |
12 | ||
13 | All kinds of customization affect only the particular Emacs session | |
14 | that you do them in. They are completely lost when you kill the Emacs | |
15 | session, and have no effect on other Emacs sessions you may run at the | |
16 | same time or later. The only way an Emacs session can affect anything | |
17 | outside of it is by writing a file; in particular, the only way to make | |
18 | a customization ``permanent'' is to put something in your @file{.emacs} | |
19 | file or other appropriate file to do the customization in each session. | |
20 | @xref{Init File}. | |
21 | ||
22 | @menu | |
23 | * Minor Modes:: Each minor mode is one feature you can turn on | |
24 | independently of any others. | |
25 | * Variables:: Many Emacs commands examine Emacs variables | |
26 | to decide what to do; by setting variables, | |
27 | you can control their functioning. | |
28 | * Keyboard Macros:: A keyboard macro records a sequence of | |
29 | keystrokes to be replayed with a single | |
30 | command. | |
31 | * Key Bindings:: The keymaps say what command each key runs. | |
32 | By changing them, you can "redefine keys". | |
33 | * Keyboard Translations:: | |
34 | If your keyboard passes an undesired code | |
35 | for a key, you can tell Emacs to | |
36 | substitute another code. | |
37 | * Syntax:: The syntax table controls how words and | |
38 | expressions are parsed. | |
39 | * Init File:: How to write common customizations in the | |
40 | @file{.emacs} file. | |
41 | @end menu | |
42 | ||
43 | @node Minor Modes | |
44 | @section Minor Modes | |
45 | @cindex minor modes | |
46 | @cindex mode, minor | |
47 | ||
48 | Minor modes are optional features which you can turn on or off. For | |
49 | example, Auto Fill mode is a minor mode in which @key{SPC} breaks lines | |
50 | between words as you type. All the minor modes are independent of each | |
51 | other and of the selected major mode. Most minor modes say in the mode | |
52 | line when they are on; for example, @samp{Fill} in the mode line means | |
53 | that Auto Fill mode is on. | |
54 | ||
55 | Append @code{-mode} to the name of a minor mode to get the name of a | |
56 | command function that turns the mode on or off. Thus, the command to | |
57 | enable or disable Auto Fill mode is called @kbd{M-x auto-fill-mode}. These | |
58 | commands are usually invoked with @kbd{M-x}, but you can bind keys to them | |
59 | if you wish. With no argument, the function turns the mode on if it was | |
60 | off and off if it was on. This is known as @dfn{toggling}. A positive | |
61 | argument always turns the mode on, and an explicit zero argument or a | |
62 | negative argument always turns it off. | |
63 | ||
64 | Enabling or disabling some minor modes applies only to the current | |
65 | buffer; each buffer is independent of the other buffers. Therefore, you | |
66 | can enable the mode in particular buffers and disable it in others. The | |
67 | per-buffer minor modes include Abbrev mode, Auto Fill mode, Auto Save | |
6ca0edfe | 68 | mode, Font-Lock mode, ISO Accents mode, Outline minor |
6bf7aab6 DL |
69 | mode, Overwrite mode, and Binary Overwrite mode. |
70 | ||
71 | Abbrev mode allows you to define abbreviations that automatically expand | |
72 | as you type them. For example, @samp{amd} might expand to @samp{abbrev | |
73 | mode}. @xref{Abbrevs}, for full information. | |
74 | ||
75 | Auto Fill mode allows you to enter filled text without breaking lines | |
76 | explicitly. Emacs inserts newlines as necessary to prevent lines from | |
77 | becoming too long. @xref{Filling}. | |
78 | ||
79 | Auto Save mode causes the contents of a buffer to be saved | |
80 | periodically to reduce the amount of work you can lose in case of a | |
81 | system crash. @xref{Auto Save}. | |
82 | ||
83 | Enriched mode enables editing and saving of formatted text. | |
84 | @xref{Formatted Text}. | |
85 | ||
86 | Flyspell mode automatically highlights misspelled words. | |
87 | @xref{Spelling}. | |
88 | ||
89 | Font-Lock mode automatically highlights certain textual units found in | |
90 | programs, such as comments, strings, and function names being defined. | |
91 | This requires a window system that can display multiple fonts. | |
92 | @xref{Faces}. | |
93 | ||
6bf7aab6 DL |
94 | ISO Accents mode makes the characters @samp{`}, @samp{'}, @samp{"}, |
95 | @samp{^}, @samp{/} and @samp{~} combine with the following letter, to | |
96 | produce an accented letter in the ISO Latin-1 character set. | |
0a7790e0 | 97 | @xref{Single-Byte Character Support}. |
6bf7aab6 DL |
98 | |
99 | Outline minor mode provides the same facilities as the major mode | |
100 | called Outline mode; but since it is a minor mode instead, you can | |
101 | combine it with any major mode. @xref{Outline Mode}. | |
102 | ||
103 | @cindex Overwrite mode | |
104 | @cindex mode, Overwrite | |
105 | @findex overwrite-mode | |
106 | @findex binary-overwrite-mode | |
107 | Overwrite mode causes ordinary printing characters to replace existing | |
108 | text instead of shoving it to the right. For example, if point is in | |
109 | front of the @samp{B} in @samp{FOOBAR}, then in Overwrite mode typing a | |
110 | @kbd{G} changes it to @samp{FOOGAR}, instead of producing @samp{FOOGBAR} | |
111 | as usual. In Overwrite mode, the command @kbd{C-q} inserts the next | |
112 | character whatever it may be, even if it is a digit---this gives you a | |
113 | way to insert a character instead of replacing an existing character. | |
114 | ||
115 | Binary Overwrite mode is a variant of Overwrite mode for editing | |
116 | binary files; it treats newlines and tabs like other characters, so that | |
117 | they overwrite other characters and can be overwritten by them. | |
118 | ||
119 | The following minor modes normally apply to all buffers at once. | |
120 | Since each is enabled or disabled by the value of a variable, you | |
121 | @emph{can} set them differently for particular buffers, by explicitly | |
122 | making the corresponding variables local in those buffers. | |
123 | @xref{Locals}. | |
124 | ||
125 | Icomplete mode displays an indication of available completions when | |
126 | you are in the minibuffer and completion is active. @xref{Completion | |
127 | Options}. | |
128 | ||
129 | Line Number mode enables continuous display in the mode line of the | |
6ca0edfe DL |
130 | line number of point and Column Number mode enables display of the |
131 | column number. @xref{Mode Line}. | |
6bf7aab6 DL |
132 | |
133 | Scroll Bar mode gives each window a scroll bar (@pxref{Scroll Bars}). | |
134 | Menu Bar mode gives each frame a menu bar (@pxref{Menu Bars}). Both of | |
135 | these modes are enabled by default when you use the X Window System. | |
136 | ||
137 | In Transient Mark mode, every change in the buffer contents | |
138 | ``deactivates'' the mark, so that commands that operate on the region | |
139 | will get an error. This means you must either set the mark, or | |
140 | explicitly ``reactivate'' it, before each command that uses the region. | |
141 | The advantage of Transient Mark mode is that Emacs can display the | |
6ca0edfe | 142 | region highlighted (currently only when using X). @xref{Mark}. |
6bf7aab6 DL |
143 | |
144 | For most minor modes, the command name is also the name of a variable | |
145 | which directly controls the mode. The mode is enabled whenever this | |
146 | variable's value is non-@code{nil}, and the minor-mode command works by | |
147 | setting the variable. For example, the command | |
148 | @code{outline-minor-mode} works by setting the value of | |
149 | @code{outline-minor-mode} as a variable; it is this variable that | |
150 | directly turns Outline minor mode on and off. To check whether a given | |
151 | minor mode works this way, use @kbd{C-h v} to ask for documentation on | |
152 | the variable name. | |
153 | ||
154 | These minor-mode variables provide a good way for Lisp programs to turn | |
155 | minor modes on and off; they are also useful in a file's local variables | |
156 | list. But please think twice before setting minor modes with a local | |
157 | variables list, because most minor modes are matter of user | |
158 | preference---other users editing the same file might not want the same | |
159 | minor modes you prefer. | |
160 | ||
161 | @node Variables | |
162 | @section Variables | |
163 | @cindex variable | |
164 | @cindex option, user | |
165 | @cindex user option | |
166 | ||
167 | A @dfn{variable} is a Lisp symbol which has a value. The symbol's | |
168 | name is also called the name of the variable. A variable name can | |
169 | contain any characters that can appear in a file, but conventionally | |
170 | variable names consist of words separated by hyphens. A variable can | |
171 | have a documentation string which describes what kind of value it should | |
172 | have and how the value will be used. | |
173 | ||
174 | Lisp allows any variable to have any kind of value, but most variables | |
175 | that Emacs uses require a value of a certain type. Often the value should | |
176 | always be a string, or should always be a number. Sometimes we say that a | |
177 | certain feature is turned on if a variable is ``non-@code{nil},'' meaning | |
178 | that if the variable's value is @code{nil}, the feature is off, but the | |
179 | feature is on for @emph{any} other value. The conventional value to use to | |
180 | turn on the feature---since you have to pick one particular value when you | |
181 | set the variable---is @code{t}. | |
182 | ||
183 | Emacs uses many Lisp variables for internal record keeping, as any | |
184 | Lisp program must, but the most interesting variables for you are the | |
185 | ones that exist for the sake of customization. Emacs does not (usually) | |
186 | change the values of these variables; instead, you set the values, and | |
187 | thereby alter and control the behavior of certain Emacs commands. These | |
188 | variables are called @dfn{user options}. Most user options are | |
189 | documented in this manual, and appear in the Variable Index | |
190 | (@pxref{Variable Index}). | |
191 | ||
192 | One example of a variable which is a user option is @code{fill-column}, which | |
193 | specifies the position of the right margin (as a number of characters from | |
194 | the left margin) to be used by the fill commands (@pxref{Filling}). | |
195 | ||
196 | @menu | |
197 | * Examining:: Examining or setting one variable's value. | |
198 | * Easy Customization:: | |
199 | Convenient and easy customization of variables. | |
200 | * Hooks:: Hook variables let you specify programs for parts | |
201 | of Emacs to run on particular occasions. | |
202 | * Locals:: Per-buffer values of variables. | |
203 | * File Variables:: How files can specify variable values. | |
204 | @end menu | |
205 | ||
206 | @node Examining | |
207 | @subsection Examining and Setting Variables | |
208 | @cindex setting variables | |
209 | ||
210 | @table @kbd | |
211 | @item C-h v @var{var} @key{RET} | |
212 | Display the value and documentation of variable @var{var} | |
213 | (@code{describe-variable}). | |
214 | @item M-x set-variable @key{RET} @var{var} @key{RET} @var{value} @key{RET} | |
215 | Change the value of variable @var{var} to @var{value}. | |
216 | @end table | |
217 | ||
218 | To examine the value of a single variable, use @kbd{C-h v} | |
219 | (@code{describe-variable}), which reads a variable name using the | |
220 | minibuffer, with completion. It displays both the value and the | |
221 | documentation of the variable. For example, | |
222 | ||
223 | @example | |
224 | C-h v fill-column @key{RET} | |
225 | @end example | |
226 | ||
227 | @noindent | |
228 | displays something like this: | |
229 | ||
230 | @smallexample | |
231 | fill-column's value is 75 | |
232 | ||
233 | Documentation: | |
234 | *Column beyond which automatic line-wrapping should happen. | |
235 | Automatically becomes buffer-local when set in any fashion. | |
236 | @end smallexample | |
237 | ||
238 | @noindent | |
239 | The star at the beginning of the documentation indicates that this | |
240 | variable is a user option. @kbd{C-h v} is not restricted to user | |
241 | options; it allows any variable name. | |
242 | ||
243 | @findex set-variable | |
244 | The most convenient way to set a specific user option is with @kbd{M-x | |
245 | set-variable}. This reads the variable name with the minibuffer (with | |
246 | completion), and then reads a Lisp expression for the new value using | |
247 | the minibuffer a second time. For example, | |
248 | ||
249 | @example | |
250 | M-x set-variable @key{RET} fill-column @key{RET} 75 @key{RET} | |
251 | @end example | |
252 | ||
253 | @noindent | |
254 | sets @code{fill-column} to 75. | |
255 | ||
256 | @kbd{M-x set-variable} is limited to user option variables, but you can | |
257 | set any variable with a Lisp expression, using the function @code{setq}. | |
258 | Here is a @code{setq} expression to set @code{fill-column}: | |
259 | ||
260 | @example | |
261 | (setq fill-column 75) | |
262 | @end example | |
263 | ||
264 | To execute an expression like this one, go to the @samp{*scratch*} | |
265 | buffer, type in the expression, and then type @kbd{C-j}. @xref{Lisp | |
266 | Interaction}. | |
267 | ||
268 | Setting variables, like all means of customizing Emacs except where | |
269 | otherwise stated, affects only the current Emacs session. | |
270 | ||
271 | @node Easy Customization | |
272 | @subsection Easy Customization Interface | |
273 | ||
274 | @findex customize | |
275 | @cindex customization buffer | |
276 | A convenient way to find the user option variables that you want to | |
277 | change, and then change them, is with @kbd{M-x customize}. This command | |
278 | creates a @dfn{customization buffer} with which you can browse through | |
279 | the Emacs user options in a logically organized structure, then edit and | |
280 | set their values. You can also use the customization buffer to save | |
281 | settings permanently. (Not all Emacs user options are included in this | |
282 | structure as of yet, but we are adding the rest.) | |
283 | ||
284 | @menu | |
285 | * Groups: Customization Groups. | |
286 | How options are classified in a structure. | |
287 | * Changing an Option:: How to edit a value and set an option. | |
288 | * Face Customization:: How to edit the attributes of a face. | |
289 | * Specific Customization:: Making a customization buffer for specific | |
290 | options, faces, or groups. | |
291 | @end menu | |
292 | ||
293 | @node Customization Groups | |
294 | @subsubsection Customization Groups | |
295 | @cindex customization groups | |
296 | ||
297 | For customization purposes, user options are organized into | |
298 | @dfn{groups} to help you find them. Groups are collected into bigger | |
299 | groups, all the way up to a master group called @code{Emacs}. | |
300 | ||
301 | @kbd{M-x customize} creates a customization buffer that shows the | |
302 | top-level @code{Emacs} group and the second-level groups immediately | |
303 | under it. It looks like this, in part: | |
304 | ||
305 | @smallexample | |
306 | /- Emacs group: ---------------------------------------------------\ | |
307 | [State]: visible group members are all at standard settings. | |
308 | Customization of the One True Editor. | |
309 | See also [Manual]. | |
310 | ||
311 | Editing group: [Go to Group] | |
312 | Basic text editing facilities. | |
313 | ||
314 | External group: [Go to Group] | |
315 | Interfacing to external utilities. | |
316 | ||
317 | @var{more second-level groups} | |
318 | ||
319 | \- Emacs group end ------------------------------------------------/ | |
320 | ||
321 | @end smallexample | |
322 | ||
323 | @noindent | |
324 | This says that the buffer displays the contents of the @code{Emacs} | |
325 | group. The other groups are listed because they are its contents. But | |
326 | they are listed differently, without indentation and dashes, because | |
327 | @emph{their} contents are not included. Each group has a single-line | |
328 | documentation string; the @code{Emacs} group also has a @samp{[State]} | |
329 | line. | |
330 | ||
331 | @cindex editable fields (customization buffer) | |
332 | @cindex active fields (customization buffer) | |
333 | Most of the text in the customization buffer is read-only, but it | |
334 | typically includes some @dfn{editable fields} that you can edit. There | |
335 | are also @dfn{active fields}; this means a field that does something | |
336 | when you @dfn{invoke} it. To invoke an active field, either click on it | |
337 | with @kbd{Mouse-1}, or move point to it and type @key{RET}. | |
338 | ||
339 | For example, the phrase @samp{[Go to Group]} that appears in a | |
340 | second-level group is an active field. Invoking the @samp{[Go to | |
341 | Group]} field for a group creates a new customization buffer, which | |
342 | shows that group and its contents. This field is a kind of hypertext | |
343 | link to another group. | |
344 | ||
345 | The @code{Emacs} group does not include any user options itself, but | |
346 | other groups do. By examining various groups, you will eventually find | |
347 | the options and faces that belong to the feature you are interested in | |
348 | customizing. Then you can use the customization buffer to set them. | |
349 | ||
350 | @findex customize-browse | |
351 | You can view the structure of customization groups on a larger scale | |
352 | with @kbd{M-x customize-browse}. This command creates a special kind of | |
353 | customization buffer which shows only the names of the groups (and | |
354 | options and faces), and their structure. | |
355 | ||
356 | In this buffer, you can show the contents of a group by invoking | |
357 | @samp{[+]}. When the group contents are visible, this button changes to | |
358 | @samp{[-]}; invoking that hides the group contents. | |
359 | ||
360 | Each group, option or face name in this buffer has an active field | |
361 | which says @samp{[Group]}, @samp{[Option]} or @samp{[Face]}. Invoking | |
362 | that active field creates an ordinary customization buffer showing just | |
363 | that group and its contents, just that option, or just that face. | |
364 | This is the way to set values in it. | |
365 | ||
366 | @node Changing an Option | |
367 | @subsubsection Changing an Option | |
368 | ||
369 | Here is an example of what a user option looks like in the | |
370 | customization buffer: | |
371 | ||
372 | @smallexample | |
373 | Kill Ring Max: [Hide] 30 | |
374 | [State]: this option is unchanged from its standard setting. | |
375 | Maximum length of kill ring before oldest elements are thrown away. | |
376 | @end smallexample | |
377 | ||
378 | The text following @samp{[Hide]}, @samp{30} in this case, indicates | |
379 | the current value of the option. If you see @samp{[Show]} instead of | |
380 | @samp{[Hide]}, it means that the value is hidden; the customization | |
381 | buffer initially hides values that take up several lines. Invoke | |
382 | @samp{[Show]} to show the value. | |
383 | ||
384 | The line after the option name indicates the @dfn{customization state} | |
385 | of the option: in the example above, it says you have not changed the | |
386 | option yet. The word @samp{[State]} at the beginning of this line is | |
387 | active; you can get a menu of various operations by invoking it with | |
388 | @kbd{Mouse-1} or @key{RET}. These operations are essential for | |
389 | customizing the variable. | |
390 | ||
391 | The line after the @samp{[State]} line displays the beginning of the | |
392 | option's documentation string. If there are more lines of | |
393 | documentation, this line ends with @samp{[More]}; invoke this to show | |
394 | the full documentation string. | |
395 | ||
396 | To enter a new value for @samp{Kill Ring Max}, move point to the value | |
397 | and edit it textually. For example, you can type @kbd{M-d}, then insert | |
398 | another number. | |
399 | ||
400 | When you begin to alter the text, you will see the @samp{[State]} line | |
401 | change to say that you have edited the value: | |
402 | ||
403 | @smallexample | |
404 | [State]: you have edited the value as text, but not set the option. | |
405 | @end smallexample | |
406 | ||
407 | @cindex setting option value | |
408 | Editing the value does not actually set the option variable. To do | |
409 | that, you must @dfn{set} the option. To do this, invoke the word | |
410 | @samp{[State]} and choose @samp{Set for Current Session}. | |
411 | ||
412 | The state of the option changes visibly when you set it: | |
413 | ||
414 | @smallexample | |
415 | [State]: you have set this option, but not saved it for future sessions. | |
416 | @end smallexample | |
417 | ||
418 | You don't have to worry about specifying a value that is not valid; | |
419 | setting the option checks for validity and will not really install an | |
420 | unacceptable value. | |
421 | ||
422 | @kindex M-TAB @r{(customization buffer)} | |
423 | @findex widget-complete | |
424 | While editing a value or field that is a file name, directory name, | |
425 | command name, or anything else for which completion is defined, you can | |
426 | type @kbd{M-@key{TAB}} (@code{widget-complete}) to do completion. | |
427 | ||
428 | Some options have a small fixed set of possible legitimate values. | |
429 | These options don't let you edit the value textually. Instead, an | |
430 | active field @samp{[Value Menu]} appears before the value; invoke this | |
431 | field to edit the value. For a boolean ``on or off'' value, the active | |
432 | field says @samp{[Toggle]}, and it changes to the other value. | |
433 | @samp{[Value Menu]} and @samp{[Toggle]} edit the buffer; the changes | |
434 | take effect when you use the @samp{Set for Current Session} operation. | |
435 | ||
436 | Some options have values with complex structure. For example, the | |
437 | value of @code{load-path} is a list of directories. Here is how it | |
438 | appears in the customization buffer: | |
439 | ||
440 | @smallexample | |
441 | Load Path: | |
442 | [INS] [DEL] [Current dir?]: /usr/local/share/emacs/20.3/site-lisp | |
443 | [INS] [DEL] [Current dir?]: /usr/local/share/emacs/site-lisp | |
444 | [INS] [DEL] [Current dir?]: /usr/local/share/emacs/20.3/leim | |
445 | [INS] [DEL] [Current dir?]: /usr/local/share/emacs/20.3/lisp | |
446 | [INS] [DEL] [Current dir?]: /build/emacs/e20/lisp | |
447 | [INS] [DEL] [Current dir?]: /build/emacs/e20/lisp/gnus | |
448 | [INS] | |
449 | [State]: this item has been changed outside the customization buffer. | |
450 | List of directories to search for files to load.... | |
451 | @end smallexample | |
452 | ||
453 | @noindent | |
454 | Each directory in the list appears on a separate line, and each line has | |
455 | several editable or active fields. | |
456 | ||
457 | You can edit any of the directory names. To delete a directory from | |
458 | the list, invoke @samp{[DEL]} on that line. To insert a new directory in | |
459 | the list, invoke @samp{[INS]} at the point where you want to insert it. | |
460 | ||
461 | You can also invoke @samp{[Current dir?]} to switch between including | |
462 | a specific named directory in the path, and including @code{nil} in the | |
463 | path. (@code{nil} in a search path means ``try the current | |
464 | directory.'') | |
465 | ||
466 | @kindex TAB @r{(customization buffer)} | |
467 | @kindex S-TAB @r{(customization buffer)} | |
468 | @findex widget-forward | |
469 | @findex widget-backward | |
470 | Two special commands, @key{TAB} and @kbd{S-@key{TAB}}, are useful for | |
471 | moving through the customization buffer. @key{TAB} | |
472 | (@code{widget-forward}) moves forward to the next active or editable | |
473 | field; @kbd{S-@key{TAB}} (@code{widget-backward}) moves backward to the | |
474 | previous active or editable field. | |
475 | ||
476 | Typing @key{RET} on an editable field also moves forward, just like | |
477 | @key{TAB}. The reason for this is that people have a tendency to type | |
478 | @key{RET} when they are finished editing a field. If you have occasion | |
479 | to insert a newline in an editable field, use @kbd{C-o} or @kbd{C-q | |
480 | C-j}. | |
481 | ||
482 | @cindex saving option value | |
483 | Setting the option changes its value in the current Emacs session; | |
484 | @dfn{saving} the value changes it for future sessions as well. This | |
485 | works by writing code into your @file{~/.emacs} file so as to set the | |
486 | option variable again each time you start Emacs. To save the option, | |
487 | invoke @samp{[State]} and select the @samp{Save for Future Sessions} | |
488 | operation. | |
489 | ||
490 | You can also restore the option to its standard value by invoking | |
0a7790e0 | 491 | @samp{[State]} and selecting the @samp{Erase Customization} |
6bf7aab6 DL |
492 | operation. There are actually three reset operations: |
493 | ||
494 | @table @samp | |
495 | @item Reset | |
496 | If you have made some modifications and not yet set the option, | |
497 | this restores the text in the customization buffer to match | |
498 | the actual value. | |
499 | ||
500 | @item Reset to Saved | |
501 | This restores the value of the option to the last saved value, | |
502 | and updates the text accordingly. | |
503 | ||
0a7790e0 | 504 | @item Erase Customization |
6bf7aab6 DL |
505 | This sets the option to its standard value, and updates the text |
506 | accordingly. This also eliminates any saved value for the option, | |
507 | so that you will get the standard value in future Emacs sessions. | |
508 | @end table | |
509 | ||
0a7790e0 DL |
510 | @cindex comments on customized options |
511 | Sometimes it is useful to record a comment on the value of an option | |
512 | which you have customized. Use the @samp{Add Comment} item from the | |
513 | @samp{[State]} menu to provide a field in which to edit a comment which | |
514 | will be saved and redisplayed if you re-customize the option later. | |
515 | ||
6bf7aab6 DL |
516 | The state of a group indicates whether anything in that group has been |
517 | edited, set or saved. You can select @samp{Set for Current Session}, | |
518 | @samp{Save for Future Sessions} and the various kinds of @samp{Reset} | |
519 | operation for the group; these operations on the group apply to all | |
520 | options in the group and its subgroups. | |
521 | ||
522 | Near the top of the customization buffer there are two lines | |
523 | containing several active fields: | |
524 | ||
525 | @smallexample | |
526 | [Set for Current Session] [Save for Future Sessions] | |
0a7790e0 | 527 | [Reset] [Reset to Saved] [Erase Customization] [Finish] |
6bf7aab6 DL |
528 | @end smallexample |
529 | ||
0a7790e0 | 530 | @vindex Custom-buffer-done |
6bf7aab6 | 531 | @noindent |
0a7790e0 DL |
532 | Invoking @samp{[Finish]} either buries or kills this customization |
533 | buffer according to the setting of the option @code{Custom-buffer-done}; | |
534 | the default is to bury the buffer. | |
535 | Each of the other fields performs an operation---set, save or reset---on | |
536 | each of the items in the buffer that could meaningfully be set, saved or | |
537 | reset. | |
6bf7aab6 DL |
538 | |
539 | @node Face Customization | |
540 | @subsubsection Customizing Faces | |
541 | @cindex customizing faces | |
542 | @cindex bold font | |
543 | @cindex italic font | |
544 | @cindex fonts and faces | |
545 | ||
546 | In addition to user options, some customization groups also include | |
547 | faces. When you show the contents of a group, both the user options and | |
548 | the faces in the group appear in the customization buffer. Here is an | |
549 | example of how a face looks: | |
550 | ||
551 | @smallexample | |
552 | Custom Changed Face: (sample) | |
553 | [State]: this face is unchanged from its standard setting. | |
554 | Face used when the customize item has been changed. | |
555 | Attributes: [ ] Bold: [toggle] off | |
556 | [X] Italic: [toggle] on | |
557 | [ ] Underline: [toggle] off | |
558 | [ ] Inverse-Video: [toggle] on | |
559 | [ ] Foreground: black (sample) | |
560 | [ ] Background: white (sample) | |
561 | [ ] Stipple: | |
562 | @end smallexample | |
563 | ||
564 | Each face attribute has its own line. The @samp{[@var{x}]} field | |
565 | before the attribute name indicates whether the attribute is | |
566 | @dfn{enabled}; @samp{X} means that it is. You can enable or disable the | |
567 | attribute by invoking that field. When the attribute is enabled, you | |
568 | can change the attribute value in the usual ways. | |
569 | ||
570 | On a black-and-white display, the colors you can use for the | |
571 | background are @samp{black}, @samp{white}, @samp{gray}, @samp{gray1}, | |
572 | and @samp{gray3}. Emacs supports these shades of gray by using | |
573 | background stipple patterns instead of a color. | |
574 | ||
575 | Setting, saving and resetting a face work like the same operations for | |
576 | options (@pxref{Changing an Option}). | |
577 | ||
578 | A face can specify different appearances for different types of | |
579 | display. For example, a face can make text red on a color display, but | |
580 | use a bold font on a monochrome display. To specify multiple | |
581 | appearances for a face, select @samp{Show Display Types} in the menu you | |
582 | get from invoking @samp{[State]}. | |
583 | ||
584 | @findex modify-face | |
585 | Another more basic way to set the attributes of a specific face is | |
586 | with @kbd{M-x modify-face}. This command reads the name of a face, then | |
587 | reads the attributes one by one. For the color and stipple attributes, | |
588 | the attribute's current value is the default---type just @key{RET} if | |
589 | you don't want to change that attribute. Type @samp{none} if you want | |
590 | to clear out the attribute. | |
591 | ||
592 | @node Specific Customization | |
593 | @subsubsection Customizing Specific Items | |
594 | ||
595 | Instead of finding the options you want to change by moving down | |
596 | through the structure of groups, you can specify the particular option, | |
597 | face or group that you want to customize. | |
598 | ||
599 | @table @kbd | |
600 | @item M-x customize-option @key{RET} @var{option} @key{RET} | |
601 | Set up a customization buffer with just one option, @var{option}. | |
602 | @item M-x customize-face @key{RET} @var{face} @key{RET} | |
603 | Set up a customization buffer with just one face, @var{face}. | |
604 | @item M-x customize-group @key{RET} @var{group} @key{RET} | |
605 | Set up a customization buffer with just one group, @var{group}. | |
606 | @item M-x customize-apropos @key{RET} @var{regexp} @key{RET} | |
607 | Set up a customization buffer with all the options, faces and groups | |
608 | that match @var{regexp}. | |
609 | @item M-x customize-changed-options @key{RET} @var{version} @key{RET} | |
610 | Set up a customization buffer with all the options, faces and groups | |
611 | whose meaning has changed since Emacs version @var{version}. | |
612 | @item M-x customize-saved | |
613 | Set up a customization buffer containing all options and faces that you | |
614 | have saved with customization buffers. | |
615 | @item M-x customize-customized | |
616 | Set up a customization buffer containing all options and faces that you | |
617 | have customized but not saved. | |
618 | @end table | |
619 | ||
620 | @findex customize-option | |
621 | If you want to alter a particular user option variable with the | |
622 | customization buffer, and you know its name, you can use the command | |
623 | @kbd{M-x customize-option} and specify the option name. This sets up | |
624 | the customization buffer with just one option---the one that you asked | |
625 | for. Editing, setting and saving the value work as described above, but | |
626 | only for the specified option. | |
627 | ||
628 | @findex customize-face | |
629 | Likewise, you can modify a specific face, chosen by name, using | |
630 | @kbd{M-x customize-face}. | |
631 | ||
632 | @findex customize-group | |
633 | You can also set up the customization buffer with a specific group, | |
634 | using @kbd{M-x customize-group}. The immediate contents of the chosen | |
635 | group, including option variables, faces, and other groups, all appear | |
636 | as well. However, these subgroups' own contents start out hidden. You | |
637 | can show their contents in the usual way, by invoking @samp{[Show]}. | |
638 | ||
639 | @findex customize-apropos | |
640 | To control more precisely what to customize, you can use @kbd{M-x | |
641 | customize-apropos}. You specify a regular expression as argument; then | |
642 | all options, faces and groups whose names match this regular expression | |
643 | are set up in the customization buffer. If you specify an empty regular | |
644 | expression, this includes @emph{all} groups, options and faces in the | |
645 | customization buffer (but that takes a long time). | |
646 | ||
647 | @findex customize-changed-options | |
648 | When you upgrade to a new Emacs version, you might want to customize | |
649 | new options and options whose meanings or default values have changed. | |
650 | To do this, use @kbd{M-x customize-changed-options} and specify a | |
651 | previous Emacs version number using the minibuffer. It creates a | |
652 | customization buffer which shows all the options (and groups) whose | |
653 | definitions have been changed since the specified version. | |
654 | ||
655 | @findex customize-saved | |
656 | @findex customize-customized | |
657 | If you change option values and then decide the change was a mistake, | |
658 | you can use two special commands to revisit your previous changes. Use | |
659 | @kbd{customize-saved} to look at the options and faces that you have | |
660 | saved. Use @kbd{M-x customize-customized} to look at the options and | |
661 | faces that you have set but not saved. | |
662 | ||
663 | @node Hooks | |
664 | @subsection Hooks | |
665 | @cindex hook | |
666 | @cindex hook function | |
667 | @cindex running a hook | |
668 | ||
669 | @dfn{Hooks} are an important mechanism for customization of Emacs. A | |
670 | hook is a Lisp variable which holds a list of functions, to be called on | |
671 | some well-defined occasion. (This is called @dfn{running the hook}.) | |
672 | The individual functions in the list are called the @dfn{hook functions} | |
673 | of the hook. With rare exceptions, hooks in Emacs are empty when Emacs | |
674 | starts up, so the only hook functions in any given hook are the ones you | |
675 | explicitly put there as customization. | |
676 | ||
677 | Most major modes run one or more @dfn{mode hooks} as the last step of | |
678 | initialization. This makes it easy for you to customize the behavior of | |
679 | the mode, by setting up a hook function to override the local variable | |
680 | assignments already made by the mode. But hooks are also used in other | |
681 | contexts. For example, the hook @code{suspend-hook} runs just before | |
682 | Emacs suspends itself (@pxref{Exiting}). | |
683 | ||
684 | @cindex normal hook | |
685 | Most Emacs hooks are @dfn{normal hooks}. This means that running the | |
686 | hook operates by calling all the hook functions, unconditionally, with | |
687 | no arguments. We have made an effort to keep most hooks normal so that | |
688 | you can use them in a uniform way. Every variable in Emacs whose name | |
689 | ends in @samp{-hook} is a normal hook. | |
690 | ||
691 | @cindex abnormal hook | |
692 | There are also a few @dfn{abnormal hooks}. These variables' names end | |
693 | in @samp{-hooks} or @samp{-functions}, instead of @samp{-hook}. What | |
694 | makes these hooks abnormal is that there is something peculiar about the | |
695 | way its functions are called---perhaps they are given arguments, or | |
696 | perhaps the values they return are used in some way. For example, | |
697 | @code{find-file-not-found-hooks} (@pxref{Visiting}) is abnormal because | |
698 | as soon as one hook function returns a non-@code{nil} value, the rest | |
699 | are not called at all. The documentation of each abnormal hook variable | |
700 | explains in detail what is peculiar about it. | |
701 | ||
702 | The recommended way to add a hook function to a hook (either normal or | |
703 | abnormal) is by calling @code{add-hook}. You can use any valid Lisp | |
704 | function as the hook function, provided it can handle the proper number | |
705 | of arguments (zero arguments, in the case of a normal hook). Of course, | |
706 | not every Lisp function is @emph{useful} in any particular hook. | |
707 | ||
708 | For example, here's how to set up a hook to turn on Auto Fill mode | |
709 | when entering Text mode and other modes based on Text mode: | |
710 | ||
711 | @example | |
712 | (add-hook 'text-mode-hook 'turn-on-auto-fill) | |
713 | @end example | |
714 | ||
715 | The next example shows how to use a hook to customize the indentation | |
716 | of C code. (People often have strong personal preferences for one | |
717 | format compared to another.) Here the hook function is an anonymous | |
718 | lambda expression. | |
719 | ||
720 | @example | |
721 | @group | |
722 | (setq my-c-style | |
723 | '((c-comment-only-line-offset . 4) | |
724 | @end group | |
725 | @group | |
726 | (c-cleanup-list . (scope-operator | |
727 | empty-defun-braces | |
728 | defun-close-semi)) | |
729 | @end group | |
730 | @group | |
731 | (c-offsets-alist . ((arglist-close . c-lineup-arglist) | |
732 | (substatement-open . 0))))) | |
733 | @end group | |
734 | ||
735 | @group | |
736 | (add-hook 'c-mode-common-hook | |
bed44076 SM |
737 | (lambda () |
738 | (c-add-style "my-style" my-c-style t))) | |
6bf7aab6 DL |
739 | @end group |
740 | @end example | |
741 | ||
742 | It is best to design your hook functions so that the order in which | |
743 | they are executed does not matter. Any dependence on the order is | |
744 | ``asking for trouble.'' However, the order is predictable: the most | |
745 | recently added hook functions are executed first. | |
746 | ||
747 | @node Locals | |
748 | @subsection Local Variables | |
749 | ||
750 | @table @kbd | |
751 | @item M-x make-local-variable @key{RET} @var{var} @key{RET} | |
752 | Make variable @var{var} have a local value in the current buffer. | |
753 | @item M-x kill-local-variable @key{RET} @var{var} @key{RET} | |
754 | Make variable @var{var} use its global value in the current buffer. | |
755 | @item M-x make-variable-buffer-local @key{RET} @var{var} @key{RET} | |
756 | Mark variable @var{var} so that setting it will make it local to the | |
757 | buffer that is current at that time. | |
758 | @end table | |
759 | ||
760 | @cindex local variables | |
761 | Almost any variable can be made @dfn{local} to a specific Emacs | |
762 | buffer. This means that its value in that buffer is independent of its | |
763 | value in other buffers. A few variables are always local in every | |
764 | buffer. Every other Emacs variable has a @dfn{global} value which is in | |
765 | effect in all buffers that have not made the variable local. | |
766 | ||
767 | @findex make-local-variable | |
768 | @kbd{M-x make-local-variable} reads the name of a variable and makes it | |
769 | local to the current buffer. Further changes in this buffer will not | |
770 | affect others, and further changes in the global value will not affect this | |
771 | buffer. | |
772 | ||
773 | @findex make-variable-buffer-local | |
774 | @cindex per-buffer variables | |
775 | @kbd{M-x make-variable-buffer-local} reads the name of a variable and | |
776 | changes the future behavior of the variable so that it will become local | |
777 | automatically when it is set. More precisely, once a variable has been | |
778 | marked in this way, the usual ways of setting the variable automatically | |
779 | do @code{make-local-variable} first. We call such variables | |
780 | @dfn{per-buffer} variables. | |
781 | ||
782 | Major modes (@pxref{Major Modes}) always make variables local to the | |
783 | buffer before setting the variables. This is why changing major modes | |
784 | in one buffer has no effect on other buffers. Minor modes also work by | |
785 | setting variables---normally, each minor mode has one controlling | |
786 | variable which is non-@code{nil} when the mode is enabled (@pxref{Minor | |
787 | Modes}). For most minor modes, the controlling variable is per buffer. | |
788 | ||
789 | Emacs contains a number of variables that are always per-buffer. | |
790 | These include @code{abbrev-mode}, @code{auto-fill-function}, | |
791 | @code{case-fold-search}, @code{comment-column}, @code{ctl-arrow}, | |
792 | @code{fill-column}, @code{fill-prefix}, @code{indent-tabs-mode}, | |
793 | @code{left-margin}, @code{mode-line-format}, @code{overwrite-mode}, | |
794 | @code{selective-display-ellipses}, @code{selective-display}, | |
795 | @code{tab-width}, and @code{truncate-lines}. Some other variables are | |
796 | always local in every buffer, but they are used for internal | |
797 | purposes.@refill | |
798 | ||
799 | A few variables cannot be local to a buffer because they are always | |
800 | local to each display instead (@pxref{Multiple Displays}). If you try to | |
801 | make one of these variables buffer-local, you'll get an error message. | |
802 | ||
803 | @findex kill-local-variable | |
804 | @kbd{M-x kill-local-variable} reads the name of a variable and makes | |
805 | it cease to be local to the current buffer. The global value of the | |
806 | variable henceforth is in effect in this buffer. Setting the major mode | |
807 | kills all the local variables of the buffer except for a few variables | |
808 | specially marked as @dfn{permanent locals}. | |
809 | ||
810 | @findex setq-default | |
811 | To set the global value of a variable, regardless of whether the | |
812 | variable has a local value in the current buffer, you can use the Lisp | |
813 | construct @code{setq-default}. This construct is used just like | |
814 | @code{setq}, but it sets variables' global values instead of their local | |
815 | values (if any). When the current buffer does have a local value, the | |
816 | new global value may not be visible until you switch to another buffer. | |
817 | Here is an example: | |
818 | ||
819 | @example | |
820 | (setq-default fill-column 75) | |
821 | @end example | |
822 | ||
823 | @noindent | |
824 | @code{setq-default} is the only way to set the global value of a variable | |
825 | that has been marked with @code{make-variable-buffer-local}. | |
826 | ||
827 | @findex default-value | |
828 | Lisp programs can use @code{default-value} to look at a variable's | |
829 | default value. This function takes a symbol as argument and returns its | |
830 | default value. The argument is evaluated; usually you must quote it | |
831 | explicitly. For example, here's how to obtain the default value of | |
832 | @code{fill-column}: | |
833 | ||
834 | @example | |
835 | (default-value 'fill-column) | |
836 | @end example | |
837 | ||
838 | @node File Variables | |
839 | @subsection Local Variables in Files | |
840 | @cindex local variables in files | |
841 | @cindex file local variables | |
842 | ||
843 | A file can specify local variable values for use when you edit the | |
844 | file with Emacs. Visiting the file checks for local variable | |
845 | specifications; it automatically makes these variables local to the | |
846 | buffer, and sets them to the values specified in the file. | |
847 | ||
848 | There are two ways to specify local variable values: in the first | |
849 | line, or with a local variables list. Here's how to specify them in the | |
850 | first line: | |
851 | ||
852 | @example | |
853 | -*- mode: @var{modename}; @var{var}: @var{value}; @dots{} -*- | |
854 | @end example | |
855 | ||
856 | @noindent | |
857 | You can specify any number of variables/value pairs in this way, each | |
858 | pair with a colon and semicolon as shown above. @code{mode: | |
859 | @var{modename};} specifies the major mode; this should come first in the | |
860 | line. The @var{value}s are not evaluated; they are used literally. | |
861 | Here is an example that specifies Lisp mode and sets two variables with | |
862 | numeric values: | |
863 | ||
864 | @smallexample | |
865 | ;; -*-mode: Lisp; fill-column: 75; comment-column: 50; -*- | |
866 | @end smallexample | |
867 | ||
868 | You can also specify the coding system for a file in this way: just | |
869 | specify a value for the ``variable'' named @code{coding}. The ``value'' | |
870 | must be a coding system name that Emacs recognizes. @xref{Coding | |
871 | Systems}. | |
872 | ||
873 | A @dfn{local variables list} goes near the end of the file, in the | |
874 | last page. (It is often best to put it on a page by itself.) The local | |
875 | variables list starts with a line containing the string @samp{Local | |
876 | Variables:}, and ends with a line containing the string @samp{End:}. In | |
877 | between come the variable names and values, one set per line, as | |
878 | @samp{@var{variable}:@: @var{value}}. The @var{value}s are not | |
879 | evaluated; they are used literally. If a file has both a local | |
880 | variables list and a @samp{-*-} line, Emacs processes @emph{everything} | |
881 | in the @samp{-*-} line first, and @emph{everything} in the local | |
882 | variables list afterward. | |
883 | ||
884 | Here is an example of a local variables list: | |
885 | ||
886 | @example | |
887 | ;;; Local Variables: *** | |
888 | ;;; mode:lisp *** | |
889 | ;;; comment-column:0 *** | |
890 | ;;; comment-start: ";;; " *** | |
891 | ;;; comment-end:"***" *** | |
892 | ;;; End: *** | |
893 | @end example | |
894 | ||
895 | As you see, each line starts with the prefix @samp{;;; } and each line | |
896 | ends with the suffix @samp{ ***}. Emacs recognizes these as the prefix | |
897 | and suffix based on the first line of the list, by finding them | |
898 | surrounding the magic string @samp{Local Variables:}; then it | |
899 | automatically discards them from the other lines of the list. | |
900 | ||
901 | The usual reason for using a prefix and/or suffix is to embed the | |
902 | local variables list in a comment, so it won't confuse other programs | |
903 | that the file is intended as input for. The example above is for a | |
904 | language where comment lines start with @samp{;;; } and end with | |
905 | @samp{***}; the local values for @code{comment-start} and | |
906 | @code{comment-end} customize the rest of Emacs for this unusual syntax. | |
907 | Don't use a prefix (or a suffix) if you don't need one. | |
908 | ||
909 | Two ``variable names'' have special meanings in a local variables | |
910 | list: a value for the variable @code{mode} really sets the major mode, | |
911 | and a value for the variable @code{eval} is simply evaluated as an | |
912 | expression and the value is ignored. @code{mode} and @code{eval} are | |
913 | not real variables; setting variables named @code{mode} and @code{eval} | |
914 | in any other context has no special meaning. If @code{mode} is used to | |
915 | set a major mode, it should be the first ``variable'' in the list. | |
916 | ||
917 | You can use the @code{mode} ``variable'' to set minor modes as well as | |
918 | major modes; in fact, you can use it more than once, first to set the | |
919 | major mode and then to set minor modes which are specific to particular | |
920 | buffers. But most minor modes should not be specified in the file in | |
921 | any fashion, because they represent user preferences. | |
922 | ||
923 | For example, you may be tempted to try to turn on Auto Fill mode with | |
924 | a local variable list. That is a mistake. The choice of Auto Fill mode | |
925 | or not is a matter of individual taste, not a matter of the contents of | |
926 | particular files. If you want to use Auto Fill, set up major mode hooks | |
927 | with your @file{.emacs} file to turn it on (when appropriate) for you | |
928 | alone (@pxref{Init File}). Don't use a local variable list to impose | |
929 | your taste on everyone. | |
930 | ||
931 | The start of the local variables list must be no more than 3000 | |
932 | characters from the end of the file, and must be in the last page if the | |
933 | file is divided into pages. Otherwise, Emacs will not notice it is | |
934 | there. The purpose of this rule is so that a stray @samp{Local | |
935 | Variables:}@: not in the last page does not confuse Emacs, and so that | |
936 | visiting a long file that is all one page and has no local variables | |
937 | list need not take the time to search the whole file. | |
938 | ||
939 | Use the command @code{normal-mode} to reset the local variables and | |
940 | major mode of a buffer according to the file name and contents, | |
941 | including the local variables list if any. @xref{Choosing Modes}. | |
942 | ||
943 | @findex enable-local-variables | |
944 | The variable @code{enable-local-variables} controls whether to process | |
945 | local variables in files, and thus gives you a chance to override them. | |
946 | Its default value is @code{t}, which means do process local variables in | |
947 | files. If you set the value to @code{nil}, Emacs simply ignores local | |
948 | variables in files. Any other value says to query you about each file | |
949 | that has local variables, showing you the local variable specifications | |
950 | so you can judge. | |
951 | ||
952 | @findex enable-local-eval | |
953 | The @code{eval} ``variable,'' and certain actual variables, create a | |
954 | special risk; when you visit someone else's file, local variable | |
955 | specifications for these could affect your Emacs in arbitrary ways. | |
956 | Therefore, the option @code{enable-local-eval} controls whether Emacs | |
957 | processes @code{eval} variables, as well variables with names that end | |
958 | in @samp{-hook}, @samp{-hooks}, @samp{-function} or @samp{-functions}, | |
959 | and certain other variables. The three possibilities for the option's | |
960 | value are @code{t}, @code{nil}, and anything else, just as for | |
961 | @code{enable-local-variables}. The default is @code{maybe}, which is | |
962 | neither @code{t} nor @code{nil}, so normally Emacs does ask for | |
963 | confirmation about file settings for these variables. | |
964 | ||
965 | @node Keyboard Macros | |
966 | @section Keyboard Macros | |
967 | ||
968 | @cindex defining keyboard macros | |
969 | @cindex keyboard macro | |
970 | A @dfn{keyboard macro} is a command defined by the user to stand for | |
971 | another sequence of keys. For example, if you discover that you are | |
972 | about to type @kbd{C-n C-d} forty times, you can speed your work by | |
973 | defining a keyboard macro to do @kbd{C-n C-d} and calling it with a | |
974 | repeat count of forty. | |
975 | ||
976 | @c widecommands | |
977 | @table @kbd | |
978 | @item C-x ( | |
979 | Start defining a keyboard macro (@code{start-kbd-macro}). | |
980 | @item C-x ) | |
981 | End the definition of a keyboard macro (@code{end-kbd-macro}). | |
982 | @item C-x e | |
983 | Execute the most recent keyboard macro (@code{call-last-kbd-macro}). | |
984 | @item C-u C-x ( | |
985 | Re-execute last keyboard macro, then add more keys to its definition. | |
986 | @item C-x q | |
987 | When this point is reached during macro execution, ask for confirmation | |
988 | (@code{kbd-macro-query}). | |
989 | @item M-x name-last-kbd-macro | |
990 | Give a command name (for the duration of the session) to the most | |
991 | recently defined keyboard macro. | |
992 | @item M-x insert-kbd-macro | |
993 | Insert in the buffer a keyboard macro's definition, as Lisp code. | |
994 | @item C-x C-k | |
995 | Edit a previously defined keyboard macro (@code{edit-kbd-macro}). | |
996 | @item M-x apply-macro-to-region-lines | |
997 | Run the last keyboard macro on each complete line in the region. | |
998 | @end table | |
999 | ||
1000 | Keyboard macros differ from ordinary Emacs commands in that they are | |
1001 | written in the Emacs command language rather than in Lisp. This makes it | |
1002 | easier for the novice to write them, and makes them more convenient as | |
1003 | temporary hacks. However, the Emacs command language is not powerful | |
1004 | enough as a programming language to be useful for writing anything | |
1005 | intelligent or general. For such things, Lisp must be used. | |
1006 | ||
1007 | You define a keyboard macro while executing the commands which are the | |
1008 | definition. Put differently, as you define a keyboard macro, the | |
1009 | definition is being executed for the first time. This way, you can see | |
1010 | what the effects of your commands are, so that you don't have to figure | |
1011 | them out in your head. When you are finished, the keyboard macro is | |
1012 | defined and also has been, in effect, executed once. You can then do the | |
1013 | whole thing over again by invoking the macro. | |
1014 | ||
1015 | @menu | |
1016 | * Basic Kbd Macro:: Defining and running keyboard macros. | |
1017 | * Save Kbd Macro:: Giving keyboard macros names; saving them in files. | |
1018 | * Kbd Macro Query:: Making keyboard macros do different things each time. | |
1019 | @end menu | |
1020 | ||
1021 | @node Basic Kbd Macro | |
1022 | @subsection Basic Use | |
1023 | ||
1024 | @kindex C-x ( | |
1025 | @kindex C-x ) | |
1026 | @kindex C-x e | |
1027 | @findex start-kbd-macro | |
1028 | @findex end-kbd-macro | |
1029 | @findex call-last-kbd-macro | |
1030 | To start defining a keyboard macro, type the @kbd{C-x (} command | |
1031 | (@code{start-kbd-macro}). From then on, your keys continue to be | |
1032 | executed, but also become part of the definition of the macro. @samp{Def} | |
1033 | appears in the mode line to remind you of what is going on. When you are | |
1034 | finished, the @kbd{C-x )} command (@code{end-kbd-macro}) terminates the | |
1035 | definition (without becoming part of it!). For example, | |
1036 | ||
1037 | @example | |
1038 | C-x ( M-f foo C-x ) | |
1039 | @end example | |
1040 | ||
1041 | @noindent | |
1042 | defines a macro to move forward a word and then insert @samp{foo}. | |
1043 | ||
1044 | The macro thus defined can be invoked again with the @kbd{C-x e} | |
1045 | command (@code{call-last-kbd-macro}), which may be given a repeat count | |
1046 | as a numeric argument to execute the macro many times. @kbd{C-x )} can | |
1047 | also be given a repeat count as an argument, in which case it repeats | |
1048 | the macro that many times right after defining it, but defining the | |
1049 | macro counts as the first repetition (since it is executed as you define | |
1050 | it). Therefore, giving @kbd{C-x )} an argument of 4 executes the macro | |
1051 | immediately 3 additional times. An argument of zero to @kbd{C-x e} or | |
1052 | @kbd{C-x )} means repeat the macro indefinitely (until it gets an error | |
1053 | or you type @kbd{C-g} or, on MS-DOS, @kbd{C-@key{BREAK}}). | |
1054 | ||
1055 | If you wish to repeat an operation at regularly spaced places in the | |
1056 | text, define a macro and include as part of the macro the commands to move | |
1057 | to the next place you want to use it. For example, if you want to change | |
1058 | each line, you should position point at the start of a line, and define a | |
1059 | macro to change that line and leave point at the start of the next line. | |
1060 | Then repeating the macro will operate on successive lines. | |
1061 | ||
1062 | After you have terminated the definition of a keyboard macro, you can add | |
1063 | to the end of its definition by typing @kbd{C-u C-x (}. This is equivalent | |
1064 | to plain @kbd{C-x (} followed by retyping the whole definition so far. As | |
1065 | a consequence it re-executes the macro as previously defined. | |
1066 | ||
1067 | You can use function keys in a keyboard macro, just like keyboard | |
1068 | keys. You can even use mouse events, but be careful about that: when | |
1069 | the macro replays the mouse event, it uses the original mouse position | |
1070 | of that event, the position that the mouse had while you were defining | |
1071 | the macro. The effect of this may be hard to predict. (Using the | |
1072 | current mouse position would be even less predictable.) | |
1073 | ||
1074 | One thing that doesn't always work well in a keyboard macro is the | |
1075 | command @kbd{C-M-c} (@code{exit-recursive-edit}). When this command | |
1076 | exits a recursive edit that started within the macro, it works as you'd | |
1077 | expect. But if it exits a recursive edit that started before you | |
1078 | invoked the keyboard macro, it also necessarily exits the keyboard macro | |
1079 | as part of the process. | |
1080 | ||
1081 | @findex edit-kbd-macro | |
1082 | @kindex C-x C-k | |
1083 | You can edit a keyboard macro already defined by typing @kbd{C-x C-k} | |
1084 | (@code{edit-kbd-macro}). Follow that with the keyboard input that you | |
1085 | would use to invoke the macro---@kbd{C-x e} or @kbd{M-x @var{name}} or | |
1086 | some other key sequence. This formats the macro definition in a buffer | |
1087 | and enters a specialized major mode for editing it. Type @kbd{C-h m} | |
1088 | once in that buffer to display details of how to edit the macro. When | |
1089 | you are finished editing, type @kbd{C-c C-c}. | |
1090 | ||
1091 | @findex apply-macro-to-region-lines | |
1092 | The command @kbd{M-x apply-macro-to-region-lines} repeats the last | |
1093 | defined keyboard macro on each complete line within the current region. | |
1094 | It does this line by line, by moving point to the beginning of the line | |
1095 | and then executing the macro. | |
1096 | ||
1097 | @node Save Kbd Macro | |
1098 | @subsection Naming and Saving Keyboard Macros | |
1099 | ||
1100 | @cindex saving keyboard macros | |
1101 | @findex name-last-kbd-macro | |
1102 | If you wish to save a keyboard macro for longer than until you define the | |
1103 | next one, you must give it a name using @kbd{M-x name-last-kbd-macro}. | |
1104 | This reads a name as an argument using the minibuffer and defines that name | |
1105 | to execute the macro. The macro name is a Lisp symbol, and defining it in | |
1106 | this way makes it a valid command name for calling with @kbd{M-x} or for | |
1107 | binding a key to with @code{global-set-key} (@pxref{Keymaps}). If you | |
1108 | specify a name that has a prior definition other than another keyboard | |
1109 | macro, an error message is printed and nothing is changed. | |
1110 | ||
1111 | @findex insert-kbd-macro | |
1112 | Once a macro has a command name, you can save its definition in a file. | |
1113 | Then it can be used in another editing session. First, visit the file | |
1114 | you want to save the definition in. Then use this command: | |
1115 | ||
1116 | @example | |
1117 | M-x insert-kbd-macro @key{RET} @var{macroname} @key{RET} | |
1118 | @end example | |
1119 | ||
1120 | @noindent | |
1121 | This inserts some Lisp code that, when executed later, will define the | |
1122 | same macro with the same definition it has now. (You need not | |
1123 | understand Lisp code to do this, because @code{insert-kbd-macro} writes | |
1124 | the Lisp code for you.) Then save the file. You can load the file | |
1125 | later with @code{load-file} (@pxref{Lisp Libraries}). If the file you | |
1126 | save in is your init file @file{~/.emacs} (@pxref{Init File}) then the | |
1127 | macro will be defined each time you run Emacs. | |
1128 | ||
1129 | If you give @code{insert-kbd-macro} a numeric argument, it makes | |
1130 | additional Lisp code to record the keys (if any) that you have bound to the | |
1131 | keyboard macro, so that the macro will be reassigned the same keys when you | |
1132 | load the file. | |
1133 | ||
1134 | @node Kbd Macro Query | |
1135 | @subsection Executing Macros with Variations | |
1136 | ||
1137 | @kindex C-x q | |
1138 | @findex kbd-macro-query | |
1139 | Using @kbd{C-x q} (@code{kbd-macro-query}), you can get an effect | |
1140 | similar to that of @code{query-replace}, where the macro asks you each | |
1141 | time around whether to make a change. While defining the macro, | |
1142 | type @kbd{C-x q} at the point where you want the query to occur. During | |
1143 | macro definition, the @kbd{C-x q} does nothing, but when you run the | |
1144 | macro later, @kbd{C-x q} asks you interactively whether to continue. | |
1145 | ||
1146 | The valid responses when @kbd{C-x q} asks are @key{SPC} (or @kbd{y}), | |
1147 | @key{DEL} (or @kbd{n}), @key{RET} (or @kbd{q}), @kbd{C-l} and @kbd{C-r}. | |
1148 | The answers are the same as in @code{query-replace}, though not all of | |
1149 | the @code{query-replace} options are meaningful. | |
1150 | ||
1151 | These responses include @key{SPC} to continue, and @key{DEL} to skip | |
1152 | the remainder of this repetition of the macro and start right away with | |
1153 | the next repetition. @key{RET} means to skip the remainder of this | |
1154 | repetition and cancel further repetitions. @kbd{C-l} redraws the screen | |
1155 | and asks you again for a character to say what to do. | |
1156 | ||
1157 | @kbd{C-r} enters a recursive editing level, in which you can perform | |
1158 | editing which is not part of the macro. When you exit the recursive | |
1159 | edit using @kbd{C-M-c}, you are asked again how to continue with the | |
1160 | keyboard macro. If you type a @key{SPC} at this time, the rest of the | |
1161 | macro definition is executed. It is up to you to leave point and the | |
1162 | text in a state such that the rest of the macro will do what you | |
1163 | want.@refill | |
1164 | ||
1165 | @kbd{C-u C-x q}, which is @kbd{C-x q} with a numeric argument, | |
1166 | performs a completely different function. It enters a recursive edit | |
1167 | reading input from the keyboard, both when you type it during the | |
1168 | definition of the macro, and when it is executed from the macro. During | |
1169 | definition, the editing you do inside the recursive edit does not become | |
1170 | part of the macro. During macro execution, the recursive edit gives you | |
1171 | a chance to do some particularized editing on each repetition. | |
1172 | @xref{Recursive Edit}. | |
1173 | ||
1174 | Another way to vary the behavior of a keyboard macro is to use a | |
1175 | register as a counter, incrementing it on each repetition of the macro. | |
1176 | @xref{RegNumbers}. | |
1177 | ||
1178 | @node Key Bindings | |
1179 | @section Customizing Key Bindings | |
1180 | @cindex key bindings | |
1181 | ||
1182 | This section describes @dfn{key bindings}, which map keys to commands, | |
1183 | and @dfn{keymaps}, which record key bindings. It also explains how | |
1184 | to customize key bindings. | |
1185 | ||
1186 | Recall that a command is a Lisp function whose definition provides for | |
1187 | interactive use. Like every Lisp function, a command has a function | |
1188 | name which usually consists of lower-case letters and hyphens. | |
1189 | ||
1190 | @menu | |
1191 | * Keymaps:: Generalities. The global keymap. | |
1192 | * Prefix Keymaps:: Keymaps for prefix keys. | |
1193 | * Local Keymaps:: Major and minor modes have their own keymaps. | |
1194 | * Minibuffer Maps:: The minibuffer uses its own local keymaps. | |
1195 | * Rebinding:: How to redefine one key's meaning conveniently. | |
1196 | * Init Rebinding:: Rebinding keys with your init file, @file{.emacs}. | |
1197 | * Function Keys:: Rebinding terminal function keys. | |
1198 | * Named ASCII Chars:: Distinguishing @key{TAB} from @kbd{C-i}, and so on. | |
1199 | * Non-ASCII Rebinding:: Rebinding non-ASCII characters such as Latin-1. | |
1200 | * Mouse Buttons:: Rebinding mouse buttons in Emacs. | |
1201 | * Disabling:: Disabling a command means confirmation is required | |
1202 | before it can be executed. This is done to protect | |
1203 | beginners from surprises. | |
1204 | @end menu | |
1205 | ||
1206 | @node Keymaps | |
1207 | @subsection Keymaps | |
1208 | @cindex keymap | |
1209 | ||
1210 | The bindings between key sequences and command functions are recorded | |
1211 | in data structures called @dfn{keymaps}. Emacs has many of these, each | |
1212 | used on particular occasions. | |
1213 | ||
1214 | Recall that a @dfn{key sequence} (@dfn{key}, for short) is a sequence | |
1215 | of @dfn{input events} that have a meaning as a unit. Input events | |
1216 | include characters, function keys and mouse buttons---all the inputs | |
1217 | that you can send to the computer with your terminal. A key sequence | |
1218 | gets its meaning from its @dfn{binding}, which says what command it | |
1219 | runs. The function of keymaps is to record these bindings. | |
1220 | ||
1221 | @cindex global keymap | |
1222 | The @dfn{global} keymap is the most important keymap because it is | |
1223 | always in effect. The global keymap defines keys for Fundamental mode; | |
1224 | most of these definitions are common to most or all major modes. Each | |
1225 | major or minor mode can have its own keymap which overrides the global | |
1226 | definitions of some keys. | |
1227 | ||
1228 | For example, a self-inserting character such as @kbd{g} is | |
1229 | self-inserting because the global keymap binds it to the command | |
1230 | @code{self-insert-command}. The standard Emacs editing characters such | |
1231 | as @kbd{C-a} also get their standard meanings from the global keymap. | |
1232 | Commands to rebind keys, such as @kbd{M-x global-set-key}, actually work | |
1233 | by storing the new binding in the proper place in the global map. | |
1234 | @xref{Rebinding}. | |
1235 | ||
1236 | Meta characters work differently; Emacs translates each Meta | |
1237 | character into a pair of characters starting with @key{ESC}. When you | |
1238 | type the character @kbd{M-a} in a key sequence, Emacs replaces it with | |
1239 | @kbd{@key{ESC} a}. A meta key comes in as a single input event, but | |
1240 | becomes two events for purposes of key bindings. The reason for this is | |
1241 | historical, and we might change it someday. | |
1242 | ||
1243 | @cindex function key | |
1244 | Most modern keyboards have function keys as well as character keys. | |
1245 | Function keys send input events just as character keys do, and keymaps | |
1246 | can have bindings for them. | |
1247 | ||
1248 | On many terminals, typing a function key actually sends the computer a | |
1249 | sequence of characters; the precise details of the sequence depends on | |
1250 | which function key and on the model of terminal you are using. (Often | |
1251 | the sequence starts with @kbd{@key{ESC} [}.) If Emacs understands your | |
1252 | terminal type properly, it recognizes the character sequences forming | |
1253 | function keys wherever they occur in a key sequence (not just at the | |
1254 | beginning). Thus, for most purposes, you can pretend the function keys | |
1255 | reach Emacs directly and ignore their encoding as character sequences. | |
1256 | ||
1257 | @cindex mouse | |
1258 | Mouse buttons also produce input events. These events come with other | |
1259 | data---the window and position where you pressed or released the button, | |
1260 | and a time stamp. But only the choice of button matters for key | |
1261 | bindings; the other data matters only if a command looks at it. | |
1262 | (Commands designed for mouse invocation usually do look at the other | |
1263 | data.) | |
1264 | ||
1265 | A keymap records definitions for single events. Interpreting a key | |
1266 | sequence of multiple events involves a chain of keymaps. The first | |
1267 | keymap gives a definition for the first event; this definition is | |
1268 | another keymap, which is used to look up the second event in the | |
1269 | sequence, and so on. | |
1270 | ||
1271 | Key sequences can mix function keys and characters. For example, | |
1272 | @kbd{C-x @key{SELECT}} is meaningful. If you make @key{SELECT} a prefix | |
1273 | key, then @kbd{@key{SELECT} C-n} makes sense. You can even mix mouse | |
1274 | events with keyboard events, but we recommend against it, because such | |
1275 | sequences are inconvenient to type in. | |
1276 | ||
1277 | As a user, you can redefine any key; but it might be best to stick to | |
1278 | key sequences that consist of @kbd{C-c} followed by a letter. These | |
1279 | keys are ``reserved for users,'' so they won't conflict with any | |
1280 | properly designed Emacs extension. The function keys @key{F5} through | |
1281 | @key{F9} are also reserved for users. If you redefine some other key, | |
1282 | your definition may be overridden by certain extensions or major modes | |
1283 | which redefine the same key. | |
1284 | ||
1285 | @node Prefix Keymaps | |
1286 | @subsection Prefix Keymaps | |
1287 | ||
1288 | A prefix key such as @kbd{C-x} or @key{ESC} has its own keymap, | |
1289 | which holds the definition for the event that immediately follows | |
1290 | that prefix. | |
1291 | ||
1292 | The definition of a prefix key is usually the keymap to use for | |
1293 | looking up the following event. The definition can also be a Lisp | |
1294 | symbol whose function definition is the following keymap; the effect is | |
1295 | the same, but it provides a command name for the prefix key that can be | |
1296 | used as a description of what the prefix key is for. Thus, the binding | |
1297 | of @kbd{C-x} is the symbol @code{Ctl-X-Prefix}, whose function | |
1298 | definition is the keymap for @kbd{C-x} commands. The definitions of | |
1299 | @kbd{C-c}, @kbd{C-x}, @kbd{C-h} and @key{ESC} as prefix keys appear in | |
1300 | the global map, so these prefix keys are always available. | |
1301 | ||
1302 | Aside from ordinary prefix keys, there is a fictitious ``prefix key'' | |
1303 | which represents the menu bar; see @ref{Menu Bar,,,elisp, The Emacs Lisp | |
1304 | Reference Manual}, for special information about menu bar key bindings. | |
1305 | Mouse button events that invoke pop-up menus are also prefix keys; see | |
1306 | @ref{Menu Keymaps,,,elisp, The Emacs Lisp Reference Manual}, for more | |
1307 | details. | |
1308 | ||
1309 | Some prefix keymaps are stored in variables with names: | |
1310 | ||
1311 | @itemize @bullet | |
1312 | @item | |
1313 | @vindex ctl-x-map | |
1314 | @code{ctl-x-map} is the variable name for the map used for characters that | |
1315 | follow @kbd{C-x}. | |
1316 | @item | |
1317 | @vindex help-map | |
1318 | @code{help-map} is for characters that follow @kbd{C-h}. | |
1319 | @item | |
1320 | @vindex esc-map | |
1321 | @code{esc-map} is for characters that follow @key{ESC}. Thus, all Meta | |
1322 | characters are actually defined by this map. | |
1323 | @item | |
1324 | @vindex ctl-x-4-map | |
1325 | @code{ctl-x-4-map} is for characters that follow @kbd{C-x 4}. | |
1326 | @item | |
1327 | @vindex mode-specific-map | |
1328 | @code{mode-specific-map} is for characters that follow @kbd{C-c}. | |
1329 | @end itemize | |
1330 | ||
1331 | @node Local Keymaps | |
1332 | @subsection Local Keymaps | |
1333 | ||
1334 | @cindex local keymap | |
1335 | So far we have explained the ins and outs of the global map. Major | |
1336 | modes customize Emacs by providing their own key bindings in @dfn{local | |
1337 | keymaps}. For example, C mode overrides @key{TAB} to make it indent the | |
1338 | current line for C code. Portions of text in the buffer can specify | |
1339 | their own keymaps to substitute for the keymap of the buffer's major | |
1340 | mode. | |
1341 | ||
1342 | @cindex minor mode keymap | |
1343 | Minor modes can also have local keymaps. Whenever a minor mode is | |
1344 | in effect, the definitions in its keymap override both the major | |
1345 | mode's local keymap and the global keymap. | |
1346 | ||
1347 | @vindex c-mode-map | |
1348 | @vindex lisp-mode-map | |
1349 | The local keymaps for Lisp mode and several other major modes always | |
1350 | exist even when not in use. These are kept in variables named | |
1351 | @code{lisp-mode-map} and so on. For major modes less often used, the | |
1352 | local keymap is normally constructed only when the mode is used for the | |
1353 | first time in a session. This is to save space. If you wish to change | |
1354 | one of these keymaps, you must use the major mode's @dfn{mode | |
1355 | hook}---see below. | |
1356 | ||
1357 | All minor mode keymaps are created in advance. There is no way to | |
1358 | defer their creation until the first time the minor mode is enabled. | |
1359 | ||
1360 | A local keymap can locally redefine a key as a prefix key by defining | |
1361 | it as a prefix keymap. If the key is also defined globally as a prefix, | |
1362 | then its local and global definitions (both keymaps) effectively | |
1363 | combine: both of them are used to look up the event that follows the | |
1364 | prefix key. Thus, if the mode's local keymap defines @kbd{C-c} as | |
1365 | another keymap, and that keymap defines @kbd{C-z} as a command, this | |
1366 | provides a local meaning for @kbd{C-c C-z}. This does not affect other | |
1367 | sequences that start with @kbd{C-c}; if those sequences don't have their | |
1368 | own local bindings, their global bindings remain in effect. | |
1369 | ||
1370 | Another way to think of this is that Emacs handles a multi-event key | |
1371 | sequence by looking in several keymaps, one by one, for a binding of the | |
1372 | whole key sequence. First it checks the minor mode keymaps for minor | |
1373 | modes that are enabled, then it checks the major mode's keymap, and then | |
1374 | it checks the global keymap. This is not precisely how key lookup | |
1375 | works, but it's good enough for understanding ordinary circumstances. | |
1376 | ||
1377 | @cindex rebinding major mode keys | |
4ea68fcc | 1378 | @findex define-key |
6bf7aab6 DL |
1379 | To change the local bindings of a major mode, you must change the |
1380 | mode's local keymap. Normally you must wait until the first time the | |
1381 | mode is used, because most major modes don't create their keymaps until | |
1382 | then. If you want to specify something in your @file{~/.emacs} file to | |
1383 | change a major mode's bindings, you must use the mode's mode hook to | |
1384 | delay the change until the mode is first used. | |
1385 | ||
1386 | For example, the command @code{texinfo-mode} to select Texinfo mode | |
1387 | runs the hook @code{texinfo-mode-hook}. Here's how you can use the hook | |
1388 | to add local bindings (not very useful, we admit) for @kbd{C-c n} and | |
1389 | @kbd{C-c p} in Texinfo mode: | |
1390 | ||
1391 | @example | |
1392 | (add-hook 'texinfo-mode-hook | |
1393 | '(lambda () | |
1394 | (define-key texinfo-mode-map | |
1395 | "\C-cp" | |
1396 | 'backward-paragraph) | |
1397 | (define-key texinfo-mode-map | |
1398 | "\C-cn" | |
1399 | 'forward-paragraph) | |
1400 | )) | |
1401 | @end example | |
1402 | ||
1403 | @xref{Hooks}. | |
1404 | ||
1405 | @node Minibuffer Maps | |
1406 | @subsection Minibuffer Keymaps | |
1407 | ||
1408 | @cindex minibuffer keymaps | |
1409 | @vindex minibuffer-local-map | |
1410 | @vindex minibuffer-local-ns-map | |
1411 | @vindex minibuffer-local-completion-map | |
1412 | @vindex minibuffer-local-must-match-map | |
1413 | The minibuffer has its own set of local keymaps; they contain various | |
1414 | completion and exit commands. | |
1415 | ||
1416 | @itemize @bullet | |
1417 | @item | |
1418 | @code{minibuffer-local-map} is used for ordinary input (no completion). | |
1419 | @item | |
1420 | @code{minibuffer-local-ns-map} is similar, except that @key{SPC} exits | |
1421 | just like @key{RET}. This is used mainly for Mocklisp compatibility. | |
1422 | @item | |
1423 | @code{minibuffer-local-completion-map} is for permissive completion. | |
1424 | @item | |
1425 | @code{minibuffer-local-must-match-map} is for strict completion and | |
1426 | for cautious completion. | |
1427 | @end itemize | |
1428 | ||
1429 | @node Rebinding | |
1430 | @subsection Changing Key Bindings Interactively | |
1431 | @cindex key rebinding, this session | |
1432 | @cindex rebinding keys, this session | |
1433 | ||
1434 | The way to redefine an Emacs key is to change its entry in a keymap. | |
1435 | You can change the global keymap, in which case the change is effective in | |
1436 | all major modes (except those that have their own overriding local | |
1437 | definitions for the same key). Or you can change the current buffer's | |
1438 | local map, which affects all buffers using the same major mode. | |
1439 | ||
1440 | @findex global-set-key | |
1441 | @findex local-set-key | |
1442 | @findex global-unset-key | |
1443 | @findex local-unset-key | |
1444 | @table @kbd | |
1445 | @item M-x global-set-key @key{RET} @var{key} @var{cmd} @key{RET} | |
1446 | Define @var{key} globally to run @var{cmd}. | |
1447 | @item M-x local-set-key @key{RET} @var{key} @var{cmd} @key{RET} | |
1448 | Define @var{key} locally (in the major mode now in effect) to run | |
1449 | @var{cmd}. | |
1450 | @item M-x global-unset-key @key{RET} @var{key} | |
1451 | Make @var{key} undefined in the global map. | |
1452 | @item M-x local-unset-key @key{RET} @var{key} | |
1453 | Make @var{key} undefined locally (in the major mode now in effect). | |
1454 | @end table | |
1455 | ||
1456 | For example, suppose you like to execute commands in a subshell within | |
1457 | an Emacs buffer, instead of suspending Emacs and executing commands in | |
1458 | your login shell. Normally, @kbd{C-z} is bound to the function | |
1459 | @code{suspend-emacs} (when not using the X Window System), but you can | |
1460 | change @kbd{C-z} to invoke an interactive subshell within Emacs, by | |
1461 | binding it to @code{shell} as follows: | |
1462 | ||
1463 | @example | |
1464 | M-x global-set-key @key{RET} C-z shell @key{RET} | |
1465 | @end example | |
1466 | ||
1467 | @noindent | |
1468 | @code{global-set-key} reads the command name after the key. After you | |
1469 | press the key, a message like this appears so that you can confirm that | |
1470 | you are binding the key you want: | |
1471 | ||
1472 | @example | |
1473 | Set key C-z to command: | |
1474 | @end example | |
1475 | ||
1476 | You can redefine function keys and mouse events in the same way; just | |
1477 | type the function key or click the mouse when it's time to specify the | |
1478 | key to rebind. | |
1479 | ||
1480 | You can rebind a key that contains more than one event in the same | |
1481 | way. Emacs keeps reading the key to rebind until it is a complete key | |
1482 | (that is, not a prefix key). Thus, if you type @kbd{C-f} for | |
1483 | @var{key}, that's the end; the minibuffer is entered immediately to | |
1484 | read @var{cmd}. But if you type @kbd{C-x}, another character is read; | |
1485 | if that is @kbd{4}, another character is read, and so on. For | |
1486 | example, | |
1487 | ||
1488 | @example | |
1489 | M-x global-set-key @key{RET} C-x 4 $ spell-other-window @key{RET} | |
1490 | @end example | |
1491 | ||
1492 | @noindent | |
1493 | redefines @kbd{C-x 4 $} to run the (fictitious) command | |
1494 | @code{spell-other-window}. | |
1495 | ||
1496 | The two-character keys consisting of @kbd{C-c} followed by a letter | |
1497 | are reserved for user customizations. Lisp programs are not supposed to | |
1498 | define these keys, so the bindings you make for them will be available | |
1499 | in all major modes and will never get in the way of anything. | |
1500 | ||
1501 | You can remove the global definition of a key with | |
1502 | @code{global-unset-key}. This makes the key @dfn{undefined}; if you | |
1503 | type it, Emacs will just beep. Similarly, @code{local-unset-key} makes | |
1504 | a key undefined in the current major mode keymap, which makes the global | |
1505 | definition (or lack of one) come back into effect in that major mode. | |
1506 | ||
1507 | If you have redefined (or undefined) a key and you subsequently wish | |
1508 | to retract the change, undefining the key will not do the job---you need | |
1509 | to redefine the key with its standard definition. To find the name of | |
1510 | the standard definition of a key, go to a Fundamental mode buffer and | |
1511 | use @kbd{C-h c}. The documentation of keys in this manual also lists | |
1512 | their command names. | |
1513 | ||
1514 | If you want to prevent yourself from invoking a command by mistake, it | |
1515 | is better to disable the command than to undefine the key. A disabled | |
1516 | command is less work to invoke when you really want to. | |
1517 | @xref{Disabling}. | |
1518 | ||
1519 | @node Init Rebinding | |
1520 | @subsection Rebinding Keys in Your Init File | |
1521 | ||
6bf7aab6 DL |
1522 | If you have a set of key bindings that you like to use all the time, |
1523 | you can specify them in your @file{.emacs} file by using their Lisp | |
4ea68fcc | 1524 | syntax. (@xref{Init File}.) |
6bf7aab6 DL |
1525 | |
1526 | The simplest method for doing this works for ASCII characters and | |
1527 | Meta-modified ASCII characters only. This method uses a string to | |
1528 | represent the key sequence you want to rebind. For example, here's how | |
1529 | to bind @kbd{C-z} to @code{shell}: | |
1530 | ||
1531 | @example | |
1532 | (global-set-key "\C-z" 'shell) | |
1533 | @end example | |
1534 | ||
1535 | @noindent | |
1536 | This example uses a string constant containing one character, @kbd{C-z}. | |
1537 | The single-quote before the command name, @code{shell}, marks it as a | |
1538 | constant symbol rather than a variable. If you omit the quote, Emacs | |
1539 | would try to evaluate @code{shell} immediately as a variable. This | |
1540 | probably causes an error; it certainly isn't what you want. | |
1541 | ||
1542 | Here is another example that binds a key sequence two characters long: | |
1543 | ||
1544 | @example | |
1545 | (global-set-key "\C-xl" 'make-symbolic-link) | |
1546 | @end example | |
1547 | ||
1548 | When the key sequence includes function keys or mouse button events, | |
1549 | or non-ASCII characters such as @code{C-=} or @code{H-a}, you must use | |
1550 | the more general method of rebinding, which uses a vector to specify the | |
1551 | key sequence. | |
1552 | ||
1553 | The way to write a vector in Emacs Lisp is with square brackets around | |
1554 | the vector elements. Use spaces to separate the elements. If an | |
1555 | element is a symbol, simply write the symbol's name---no other | |
1556 | delimiters or punctuation are needed. If a vector element is a | |
1557 | character, write it as a Lisp character constant: @samp{?} followed by | |
1558 | the character as it would appear in a string. | |
1559 | ||
1560 | Here are examples of using vectors to rebind @kbd{C-=} (a control | |
1561 | character outside of ASCII), @kbd{H-a} (a Hyper character; ASCII doesn't | |
1562 | have Hyper at all), @key{F7} (a function key), and @kbd{C-Mouse-1} (a | |
1563 | keyboard-modified mouse button): | |
1564 | ||
1565 | @example | |
1566 | (global-set-key [?\C-=] 'make-symbolic-link) | |
1567 | (global-set-key [?\H-a] 'make-symbolic-link) | |
1568 | (global-set-key [f7] 'make-symbolic-link) | |
1569 | (global-set-key [C-mouse-1] 'make-symbolic-link) | |
1570 | @end example | |
1571 | ||
1572 | You can use a vector for the simple cases too. Here's how to rewrite | |
1573 | the first two examples, above, to use vectors: | |
1574 | ||
1575 | @example | |
1576 | (global-set-key [?\C-z] 'shell) | |
1577 | ||
1578 | (global-set-key [?\C-x ?l] 'make-symbolic-link) | |
1579 | @end example | |
1580 | ||
1581 | @node Function Keys | |
1582 | @subsection Rebinding Function Keys | |
1583 | ||
1584 | Key sequences can contain function keys as well as ordinary | |
1585 | characters. Just as Lisp characters (actually integers) represent | |
1586 | keyboard characters, Lisp symbols represent function keys. If the | |
1587 | function key has a word as its label, then that word is also the name of | |
1588 | the corresponding Lisp symbol. Here are the conventional Lisp names for | |
1589 | common function keys: | |
1590 | ||
1591 | @table @asis | |
1592 | @item @code{left}, @code{up}, @code{right}, @code{down} | |
1593 | Cursor arrow keys. | |
1594 | ||
1595 | @item @code{begin}, @code{end}, @code{home}, @code{next}, @code{prior} | |
1596 | Other cursor repositioning keys. | |
1597 | ||
1598 | @item @code{select}, @code{print}, @code{execute}, @code{backtab} | |
1599 | @itemx @code{insert}, @code{undo}, @code{redo}, @code{clearline} | |
1600 | @itemx @code{insertline}, @code{deleteline}, @code{insertchar}, @code{deletechar}, | |
1601 | Miscellaneous function keys. | |
1602 | ||
1603 | @item @code{f1}, @code{f2}, @dots{} @code{f35} | |
1604 | Numbered function keys (across the top of the keyboard). | |
1605 | ||
1606 | @item @code{kp-add}, @code{kp-subtract}, @code{kp-multiply}, @code{kp-divide} | |
1607 | @itemx @code{kp-backtab}, @code{kp-space}, @code{kp-tab}, @code{kp-enter} | |
1608 | @itemx @code{kp-separator}, @code{kp-decimal}, @code{kp-equal} | |
1609 | Keypad keys (to the right of the regular keyboard), with names or punctuation. | |
1610 | ||
1611 | @item @code{kp-0}, @code{kp-1}, @dots{} @code{kp-9} | |
1612 | Keypad keys with digits. | |
1613 | ||
1614 | @item @code{kp-f1}, @code{kp-f2}, @code{kp-f3}, @code{kp-f4} | |
1615 | Keypad PF keys. | |
1616 | @end table | |
1617 | ||
1618 | These names are conventional, but some systems (especially when using | |
1619 | X windows) may use different names. To make certain what symbol is used | |
1620 | for a given function key on your terminal, type @kbd{C-h c} followed by | |
1621 | that key. | |
1622 | ||
1623 | A key sequence which contains function key symbols (or anything but | |
1624 | ASCII characters) must be a vector rather than a string. The vector | |
1625 | syntax uses spaces between the elements, and square brackets around the | |
1626 | whole vector. Thus, to bind function key @samp{f1} to the command | |
1627 | @code{rmail}, write the following: | |
1628 | ||
1629 | @example | |
1630 | (global-set-key [f1] 'rmail) | |
1631 | @end example | |
1632 | ||
1633 | @noindent | |
1634 | To bind the right-arrow key to the command @code{forward-char}, you can | |
1635 | use this expression: | |
1636 | ||
1637 | @example | |
1638 | (global-set-key [right] 'forward-char) | |
1639 | @end example | |
1640 | ||
1641 | @noindent | |
1642 | This uses the Lisp syntax for a vector containing the symbol | |
1643 | @code{right}. (This binding is present in Emacs by default.) | |
1644 | ||
1645 | @xref{Init Rebinding}, for more information about using vectors for | |
1646 | rebinding. | |
1647 | ||
1648 | You can mix function keys and characters in a key sequence. This | |
1649 | example binds @kbd{C-x @key{NEXT}} to the command @code{forward-page}. | |
1650 | ||
1651 | @example | |
1652 | (global-set-key [?\C-x next] 'forward-page) | |
1653 | @end example | |
1654 | ||
1655 | @noindent | |
1656 | where @code{?\C-x} is the Lisp character constant for the character | |
1657 | @kbd{C-x}. The vector element @code{next} is a symbol and therefore | |
1658 | does not take a question mark. | |
1659 | ||
1660 | You can use the modifier keys @key{CTRL}, @key{META}, @key{HYPER}, | |
1661 | @key{SUPER}, @key{ALT} and @key{SHIFT} with function keys. To represent | |
1662 | these modifiers, add the strings @samp{C-}, @samp{M-}, @samp{H-}, | |
1663 | @samp{s-}, @samp{A-} and @samp{S-} at the front of the symbol name. | |
1664 | Thus, here is how to make @kbd{Hyper-Meta-@key{RIGHT}} move forward a | |
1665 | word: | |
1666 | ||
1667 | @example | |
1668 | (global-set-key [H-M-right] 'forward-word) | |
1669 | @end example | |
1670 | ||
1671 | @node Named ASCII Chars | |
1672 | @subsection Named ASCII Control Characters | |
1673 | ||
1674 | @key{TAB}, @key{RET}, @key{BS}, @key{LFD}, @key{ESC} and @key{DEL} | |
1675 | started out as names for certain ASCII control characters, used so often | |
1676 | that they have special keys of their own. Later, users found it | |
1677 | convenient to distinguish in Emacs between these keys and the ``same'' | |
1678 | control characters typed with the @key{CTRL} key. | |
1679 | ||
1680 | Emacs distinguishes these two kinds of input, when used with the X | |
1681 | Window System. It treats the ``special'' keys as function keys named | |
1682 | @code{tab}, @code{return}, @code{backspace}, @code{linefeed}, | |
1683 | @code{escape}, and @code{delete}. These function keys translate | |
1684 | automatically into the corresponding ASCII characters @emph{if} they | |
1685 | have no bindings of their own. As a result, neither users nor Lisp | |
1686 | programs need to pay attention to the distinction unless they care to. | |
1687 | ||
1688 | If you do not want to distinguish between (for example) @key{TAB} and | |
1689 | @kbd{C-i}, make just one binding, for the ASCII character @key{TAB} | |
1690 | (octal code 011). If you do want to distinguish, make one binding for | |
1691 | this ASCII character, and another for the ``function key'' @code{tab}. | |
1692 | ||
1693 | With an ordinary ASCII terminal, there is no way to distinguish | |
1694 | between @key{TAB} and @kbd{C-i} (and likewise for other such pairs), | |
1695 | because the terminal sends the same character in both cases. | |
1696 | ||
1697 | @node Non-ASCII Rebinding | |
1698 | @subsection Non-ASCII Characters on the Keyboard | |
1699 | ||
1700 | If your keyboard has keys that send non-ASCII characters, such as | |
1701 | accented letters, rebinding these keys is a bit tricky. There are | |
1702 | two solutions you can use. One is to specify a keyboard coding system, | |
1703 | using @code{set-keyboard-coding-system} (@pxref{Specify Coding}). | |
0a7790e0 DL |
1704 | Then you can bind these keys in the usual way,@footnote{Note that you |
1705 | should avoid the string syntax for binding 8-bit characters, since | |
1706 | they will be interpreted as meta keys. @xref{(elisp)Strings of | |
1707 | Events}.} by writing | |
6bf7aab6 DL |
1708 | |
1709 | @example | |
1710 | (global-set-key [?@var{char}] 'some-function) | |
1711 | @end example | |
1712 | ||
1713 | @noindent | |
1714 | and typing the key you want to bind to insert @var{char}. | |
1715 | ||
1716 | If you don't specify the keyboard coding system, that approach won't | |
1717 | work. Instead, you need to find out the actual code that the terminal | |
1718 | sends. The easiest way to do this in Emacs is to create an empty buffer | |
1719 | with @kbd{C-x b temp @key{RET}}, make it unibyte with @kbd{M-x | |
1720 | toggle-enable-multibyte-characters @key{RET}}, then type the key to | |
1721 | insert the character into this buffer. | |
1722 | ||
1723 | Move point before the character, then type @kbd{C-x =}. This | |
1724 | displays a message in the minibuffer, showing the character code in | |
1725 | three ways, octal, decimal and hexadecimal, all within a set of | |
1726 | parentheses. Use the second of the three numbers, the decimal one, | |
1727 | inside the vector to bind: | |
1728 | ||
1729 | @example | |
1730 | (global-set-key [@var{decimal-code}] 'some-function) | |
1731 | @end example | |
1732 | ||
0a7790e0 DL |
1733 | If you bind 8-bit characters like this in your init file, you my find it |
1734 | convenient to specify that it is unibyte. @xref{Enabling Multibyte}. | |
1735 | ||
6bf7aab6 DL |
1736 | @node Mouse Buttons |
1737 | @subsection Rebinding Mouse Buttons | |
1738 | @cindex mouse button events | |
1739 | @cindex rebinding mouse buttons | |
1740 | @cindex click events | |
1741 | @cindex drag events | |
1742 | @cindex down events | |
1743 | @cindex button down events | |
1744 | ||
1745 | Emacs uses Lisp symbols to designate mouse buttons, too. The ordinary | |
1746 | mouse events in Emacs are @dfn{click} events; these happen when you | |
1747 | press a button and release it without moving the mouse. You can also | |
1748 | get @dfn{drag} events, when you move the mouse while holding the button | |
1749 | down. Drag events happen when you finally let go of the button. | |
1750 | ||
1751 | The symbols for basic click events are @code{mouse-1} for the leftmost | |
1752 | button, @code{mouse-2} for the next, and so on. Here is how you can | |
1753 | redefine the second mouse button to split the current window: | |
1754 | ||
1755 | @example | |
1756 | (global-set-key [mouse-2] 'split-window-vertically) | |
1757 | @end example | |
1758 | ||
1759 | The symbols for drag events are similar, but have the prefix | |
1760 | @samp{drag-} before the word @samp{mouse}. For example, dragging the | |
1761 | first button generates a @code{drag-mouse-1} event. | |
1762 | ||
1763 | You can also define bindings for events that occur when a mouse button | |
1764 | is pressed down. These events start with @samp{down-} instead of | |
1765 | @samp{drag-}. Such events are generated only if they have key bindings. | |
1766 | When you get a button-down event, a corresponding click or drag event | |
1767 | will always follow. | |
1768 | ||
1769 | @cindex double clicks | |
1770 | @cindex triple clicks | |
1771 | If you wish, you can distinguish single, double, and triple clicks. A | |
1772 | double click means clicking a mouse button twice in approximately the | |
1773 | same place. The first click generates an ordinary click event. The | |
1774 | second click, if it comes soon enough, generates a double-click event | |
1775 | instead. The event type for a double-click event starts with | |
1776 | @samp{double-}: for example, @code{double-mouse-3}. | |
1777 | ||
1778 | This means that you can give a special meaning to the second click at | |
1779 | the same place, but it must act on the assumption that the ordinary | |
1780 | single click definition has run when the first click was received. | |
1781 | ||
1782 | This constrains what you can do with double clicks, but user interface | |
1783 | designers say that this constraint ought to be followed in any case. A | |
1784 | double click should do something similar to the single click, only | |
1785 | ``more so.'' The command for the double-click event should perform the | |
1786 | extra work for the double click. | |
1787 | ||
1788 | If a double-click event has no binding, it changes to the | |
1789 | corresponding single-click event. Thus, if you don't define a | |
1790 | particular double click specially, it executes the single-click command | |
1791 | twice. | |
1792 | ||
1793 | Emacs also supports triple-click events whose names start with | |
1794 | @samp{triple-}. Emacs does not distinguish quadruple clicks as event | |
1795 | types; clicks beyond the third generate additional triple-click events. | |
1796 | However, the full number of clicks is recorded in the event list, so you | |
1797 | can distinguish if you really want to. We don't recommend distinct | |
1798 | meanings for more than three clicks, but sometimes it is useful for | |
1799 | subsequent clicks to cycle through the same set of three meanings, so | |
1800 | that four clicks are equivalent to one click, five are equivalent to | |
1801 | two, and six are equivalent to three. | |
1802 | ||
1803 | Emacs also records multiple presses in drag and button-down events. | |
1804 | For example, when you press a button twice, then move the mouse while | |
1805 | holding the button, Emacs gets a @samp{double-drag-} event. And at the | |
1806 | moment when you press it down for the second time, Emacs gets a | |
1807 | @samp{double-down-} event (which is ignored, like all button-down | |
1808 | events, if it has no binding). | |
1809 | ||
1810 | @vindex double-click-time | |
1811 | The variable @code{double-click-time} specifies how long may elapse | |
1812 | between clicks that are recognized as a pair. Its value is measured | |
1813 | in milliseconds. If the value is @code{nil}, double clicks are not | |
1814 | detected at all. If the value is @code{t}, then there is no time | |
1815 | limit. | |
1816 | ||
1817 | The symbols for mouse events also indicate the status of the modifier | |
1818 | keys, with the usual prefixes @samp{C-}, @samp{M-}, @samp{H-}, | |
1819 | @samp{s-}, @samp{A-} and @samp{S-}. These always precede @samp{double-} | |
1820 | or @samp{triple-}, which always precede @samp{drag-} or @samp{down-}. | |
1821 | ||
1822 | A frame includes areas that don't show text from the buffer, such as | |
1823 | the mode line and the scroll bar. You can tell whether a mouse button | |
1824 | comes from a special area of the screen by means of dummy ``prefix | |
1825 | keys.'' For example, if you click the mouse in the mode line, you get | |
1826 | the prefix key @code{mode-line} before the ordinary mouse-button symbol. | |
1827 | Thus, here is how to define the command for clicking the first button in | |
1828 | a mode line to run @code{scroll-up}: | |
1829 | ||
1830 | @example | |
1831 | (global-set-key [mode-line mouse-1] 'scroll-up) | |
1832 | @end example | |
1833 | ||
1834 | Here is the complete list of these dummy prefix keys and their | |
1835 | meanings: | |
1836 | ||
1837 | @table @code | |
1838 | @item mode-line | |
1839 | The mouse was in the mode line of a window. | |
1840 | @item vertical-line | |
1841 | The mouse was in the vertical line separating side-by-side windows. (If | |
1842 | you use scroll bars, they appear in place of these vertical lines.) | |
1843 | @item vertical-scroll-bar | |
1844 | The mouse was in a vertical scroll bar. (This is the only kind of | |
1845 | scroll bar Emacs currently supports.) | |
1846 | @ignore | |
1847 | @item horizontal-scroll-bar | |
1848 | The mouse was in a horizontal scroll bar. Horizontal scroll bars do | |
1849 | horizontal scrolling, and people don't use them often. | |
1850 | @end ignore | |
1851 | @end table | |
1852 | ||
1853 | You can put more than one mouse button in a key sequence, but it isn't | |
1854 | usual to do so. | |
1855 | ||
1856 | @node Disabling | |
1857 | @subsection Disabling Commands | |
1858 | @cindex disabled command | |
1859 | ||
1860 | Disabling a command marks the command as requiring confirmation before it | |
1861 | can be executed. The purpose of disabling a command is to prevent | |
1862 | beginning users from executing it by accident and being confused. | |
1863 | ||
1864 | An attempt to invoke a disabled command interactively in Emacs | |
1865 | displays a window containing the command's name, its documentation, and | |
1866 | some instructions on what to do immediately; then Emacs asks for input | |
1867 | saying whether to execute the command as requested, enable it and | |
1868 | execute it, or cancel. If you decide to enable the command, you are | |
1869 | asked whether to do this permanently or just for the current session. | |
1870 | Enabling permanently works by automatically editing your @file{.emacs} | |
1871 | file. | |
1872 | ||
1873 | The direct mechanism for disabling a command is to put a | |
1874 | non-@code{nil} @code{disabled} property on the Lisp symbol for the | |
1875 | command. Here is the Lisp program to do this: | |
1876 | ||
1877 | @example | |
1878 | (put 'delete-region 'disabled t) | |
1879 | @end example | |
1880 | ||
1881 | If the value of the @code{disabled} property is a string, that string | |
1882 | is included in the message printed when the command is used: | |
1883 | ||
1884 | @example | |
1885 | (put 'delete-region 'disabled | |
1886 | "It's better to use `kill-region' instead.\n") | |
1887 | @end example | |
1888 | ||
1889 | @findex disable-command | |
1890 | @findex enable-command | |
1891 | You can make a command disabled either by editing the @file{.emacs} | |
1892 | file directly or with the command @kbd{M-x disable-command}, which edits | |
1893 | the @file{.emacs} file for you. Likewise, @kbd{M-x enable-command} | |
1894 | edits @file{.emacs} to enable a command permanently. @xref{Init File}. | |
1895 | ||
1896 | Whether a command is disabled is independent of what key is used to | |
1897 | invoke it; disabling also applies if the command is invoked using | |
1898 | @kbd{M-x}. Disabling a command has no effect on calling it as a | |
1899 | function from Lisp programs. | |
1900 | ||
1901 | @node Keyboard Translations | |
1902 | @section Keyboard Translations | |
1903 | ||
1904 | Some keyboards do not make it convenient to send all the special | |
1905 | characters that Emacs uses. The most common problem case is the | |
1906 | @key{DEL} character. Some keyboards provide no convenient way to type | |
1907 | this very important character---usually because they were designed to | |
1908 | expect the character @kbd{C-h} to be used for deletion. On these | |
1909 | keyboards, if you press the key normally used for deletion, Emacs handles | |
1910 | the @kbd{C-h} as a prefix character and offers you a list of help | |
1911 | options, which is not what you want. | |
1912 | ||
1913 | @cindex keyboard translations | |
1914 | @findex keyboard-translate | |
1915 | You can work around this problem within Emacs by setting up keyboard | |
1916 | translations to turn @kbd{C-h} into @key{DEL} and @key{DEL} into | |
1917 | @kbd{C-h}, as follows: | |
1918 | ||
1919 | @example | |
1920 | ;; @r{Translate @kbd{C-h} to @key{DEL}.} | |
1921 | (keyboard-translate ?\C-h ?\C-?) | |
1922 | ||
1923 | @need 3000 | |
1924 | ;; @r{Translate @key{DEL} to @kbd{C-h}.} | |
1925 | (keyboard-translate ?\C-? ?\C-h) | |
1926 | @end example | |
1927 | ||
1928 | Keyboard translations are not the same as key bindings in keymaps | |
1929 | (@pxref{Keymaps}). Emacs contains numerous keymaps that apply in | |
1930 | different situations, but there is only one set of keyboard | |
1931 | translations, and it applies to every character that Emacs reads from | |
1932 | the terminal. Keyboard translations take place at the lowest level of | |
1933 | input processing; the keys that are looked up in keymaps contain the | |
1934 | characters that result from keyboard translation. | |
1935 | ||
1936 | Under X, the keyboard key named @key{DELETE} is a function key and is | |
1937 | distinct from the ASCII character named @key{DEL}. @xref{Named ASCII | |
1938 | Chars}. Keyboard translations affect only ASCII character input, not | |
1939 | function keys; thus, the above example used under X does not affect the | |
1940 | @key{DELETE} key. However, the translation above isn't necessary under | |
1941 | X, because Emacs can also distinguish between the @key{BACKSPACE} key | |
1942 | and @kbd{C-h}; and it normally treats @key{BACKSPACE} as @key{DEL}. | |
1943 | ||
1944 | For full information about how to use keyboard translations, see | |
1945 | @ref{Translating Input,,,elisp, The Emacs Lisp Reference Manual}. | |
1946 | ||
1947 | @node Syntax | |
1948 | @section The Syntax Table | |
1949 | @cindex syntax table | |
1950 | ||
1951 | All the Emacs commands which parse words or balance parentheses are | |
1952 | controlled by the @dfn{syntax table}. The syntax table says which | |
1953 | characters are opening delimiters, which are parts of words, which are | |
1954 | string quotes, and so on. Each major mode has its own syntax table | |
1955 | (though sometimes related major modes use the same one) which it | |
1956 | installs in each buffer that uses that major mode. The syntax table | |
1957 | installed in the current buffer is the one that all commands use, so we | |
1958 | call it ``the'' syntax table. A syntax table is a Lisp object, a | |
1959 | char-table, whose elements are numbers. | |
1960 | ||
1961 | @kindex C-h s | |
1962 | @findex describe-syntax | |
1963 | To display a description of the contents of the current syntax table, | |
1964 | type @kbd{C-h s} (@code{describe-syntax}). The description of each | |
1965 | character includes both the string you would have to give to | |
1966 | @code{modify-syntax-entry} to set up that character's current syntax, | |
1967 | and some English to explain that string if necessary. | |
1968 | ||
1969 | For full information on the syntax table, see @ref{Syntax Tables,, | |
1970 | Syntax Tables, elisp, The Emacs Lisp Reference Manual}. | |
1971 | ||
1972 | @node Init File | |
1973 | @section The Init File, @file{~/.emacs} | |
1974 | @cindex init file | |
1975 | @cindex Emacs initialization file | |
1976 | @cindex key rebinding, permanent | |
1977 | @cindex rebinding keys, permanently | |
1978 | @cindex startup (init file) | |
1979 | ||
1980 | When Emacs is started, it normally loads a Lisp program from the file | |
1981 | @file{.emacs} or @file{.emacs.el} in your home directory. We call this | |
1982 | file your @dfn{init file} because it specifies how to initialize Emacs | |
1983 | for you. You can use the command line switch @samp{-q} to prevent | |
1984 | loading your init file, and @samp{-u} (or @samp{--user}) to specify a | |
1985 | different user's init file (@pxref{Entering Emacs}). | |
1986 | ||
1987 | There can also be a @dfn{default init file}, which is the library | |
1988 | named @file{default.el}, found via the standard search path for | |
1989 | libraries. The Emacs distribution contains no such library; your site | |
1990 | may create one for local customizations. If this library exists, it is | |
1991 | loaded whenever you start Emacs (except when you specify @samp{-q}). | |
1992 | But your init file, if any, is loaded first; if it sets | |
1993 | @code{inhibit-default-init} non-@code{nil}, then @file{default} is not | |
1994 | loaded. | |
1995 | ||
1996 | Your site may also have a @dfn{site startup file}; this is named | |
1997 | @file{site-start.el}, if it exists. Emacs loads this library before it | |
1998 | loads your init file. To inhibit loading of this library, use the | |
35a2a6a0 | 1999 | option @samp{-no-site-file}. @xref{Initial Options}. |
6bf7aab6 DL |
2000 | |
2001 | If you have a large amount of code in your @file{.emacs} file, you | |
2002 | should rename it to @file{~/.emacs.el}, and byte-compile it. @xref{Byte | |
2003 | Compilation,, Byte Compilation, elisp, the Emacs Lisp Reference Manual}, | |
2004 | for more information about compiling Emacs Lisp programs. | |
2005 | ||
2006 | If you are going to write actual Emacs Lisp programs that go beyond | |
2007 | minor customization, you should read the @cite{Emacs Lisp Reference Manual}. | |
2008 | @ifinfo | |
2009 | @xref{Top, Emacs Lisp, Emacs Lisp, elisp, the Emacs Lisp Reference | |
2010 | Manual}. | |
2011 | @end ifinfo | |
2012 | ||
2013 | @menu | |
2014 | * Init Syntax:: Syntax of constants in Emacs Lisp. | |
2015 | * Init Examples:: How to do some things with an init file. | |
2016 | * Terminal Init:: Each terminal type can have an init file. | |
2017 | * Find Init:: How Emacs finds the init file. | |
2018 | @end menu | |
2019 | ||
2020 | @node Init Syntax | |
2021 | @subsection Init File Syntax | |
2022 | ||
2023 | The @file{.emacs} file contains one or more Lisp function call | |
2024 | expressions. Each of these consists of a function name followed by | |
2025 | arguments, all surrounded by parentheses. For example, @code{(setq | |
2026 | fill-column 60)} calls the function @code{setq} to set the variable | |
2027 | @code{fill-column} (@pxref{Filling}) to 60. | |
2028 | ||
2029 | The second argument to @code{setq} is an expression for the new value of | |
2030 | the variable. This can be a constant, a variable, or a function call | |
2031 | expression. In @file{.emacs}, constants are used most of the time. They can be: | |
2032 | ||
2033 | @table @asis | |
2034 | @item Numbers: | |
2035 | Numbers are written in decimal, with an optional initial minus sign. | |
2036 | ||
2037 | @item Strings: | |
2038 | @cindex Lisp string syntax | |
2039 | @cindex string syntax | |
2040 | Lisp string syntax is the same as C string syntax with a few extra | |
2041 | features. Use a double-quote character to begin and end a string constant. | |
2042 | ||
2043 | In a string, you can include newlines and special characters literally. | |
2044 | But often it is cleaner to use backslash sequences for them: @samp{\n} | |
2045 | for newline, @samp{\b} for backspace, @samp{\r} for carriage return, | |
2046 | @samp{\t} for tab, @samp{\f} for formfeed (control-L), @samp{\e} for | |
2047 | escape, @samp{\\} for a backslash, @samp{\"} for a double-quote, or | |
2048 | @samp{\@var{ooo}} for the character whose octal code is @var{ooo}. | |
2049 | Backslash and double-quote are the only characters for which backslash | |
2050 | sequences are mandatory. | |
2051 | ||
2052 | @samp{\C-} can be used as a prefix for a control character, as in | |
2053 | @samp{\C-s} for ASCII control-S, and @samp{\M-} can be used as a prefix for | |
2054 | a Meta character, as in @samp{\M-a} for @kbd{Meta-A} or @samp{\M-\C-a} for | |
2055 | @kbd{Control-Meta-A}.@refill | |
2056 | ||
2057 | @item Characters: | |
2058 | Lisp character constant syntax consists of a @samp{?} followed by | |
2059 | either a character or an escape sequence starting with @samp{\}. | |
2060 | Examples: @code{?x}, @code{?\n}, @code{?\"}, @code{?\)}. Note that | |
2061 | strings and characters are not interchangeable in Lisp; some contexts | |
2062 | require one and some contexts require the other. | |
2063 | ||
2064 | @item True: | |
2065 | @code{t} stands for `true'. | |
2066 | ||
2067 | @item False: | |
2068 | @code{nil} stands for `false'. | |
2069 | ||
2070 | @item Other Lisp objects: | |
2071 | Write a single-quote (') followed by the Lisp object you want. | |
2072 | @end table | |
2073 | ||
2074 | @node Init Examples | |
2075 | @subsection Init File Examples | |
2076 | ||
2077 | Here are some examples of doing certain commonly desired things with | |
2078 | Lisp expressions: | |
2079 | ||
2080 | @itemize @bullet | |
2081 | @item | |
2082 | Make @key{TAB} in C mode just insert a tab if point is in the middle of a | |
2083 | line. | |
2084 | ||
2085 | @example | |
2086 | (setq c-tab-always-indent nil) | |
2087 | @end example | |
2088 | ||
2089 | Here we have a variable whose value is normally @code{t} for `true' | |
2090 | and the alternative is @code{nil} for `false'. | |
2091 | ||
2092 | @item | |
2093 | Make searches case sensitive by default (in all buffers that do not | |
2094 | override this). | |
2095 | ||
2096 | @example | |
2097 | (setq-default case-fold-search nil) | |
2098 | @end example | |
2099 | ||
2100 | This sets the default value, which is effective in all buffers that do | |
2101 | not have local values for the variable. Setting @code{case-fold-search} | |
2102 | with @code{setq} affects only the current buffer's local value, which | |
2103 | is not what you probably want to do in an init file. | |
2104 | ||
2105 | @item | |
2106 | @vindex user-mail-address | |
2107 | Specify your own email address, if Emacs can't figure it out correctly. | |
2108 | ||
2109 | @example | |
2110 | (setq user-mail-address "coon@@yoyodyne.com") | |
2111 | @end example | |
2112 | ||
2113 | Various Emacs packages that need your own email address use the value of | |
2114 | @code{user-mail-address}. | |
2115 | ||
2116 | @item | |
2117 | Make Text mode the default mode for new buffers. | |
2118 | ||
2119 | @example | |
2120 | (setq default-major-mode 'text-mode) | |
2121 | @end example | |
2122 | ||
2123 | Note that @code{text-mode} is used because it is the command for | |
2124 | entering Text mode. The single-quote before it makes the symbol a | |
2125 | constant; otherwise, @code{text-mode} would be treated as a variable | |
2126 | name. | |
2127 | ||
2128 | @need 1500 | |
2129 | @item | |
2130 | Set up defaults for the Latin-1 character set | |
2131 | which supports most of the languages of Western Europe. | |
2132 | ||
2133 | @example | |
2134 | (set-language-environment "Latin-1") | |
2135 | @end example | |
2136 | ||
2137 | @need 1500 | |
2138 | @item | |
2139 | Turn on Auto Fill mode automatically in Text mode and related modes. | |
2140 | ||
2141 | @example | |
2142 | (add-hook 'text-mode-hook | |
2143 | '(lambda () (auto-fill-mode 1))) | |
2144 | @end example | |
2145 | ||
2146 | This shows how to add a hook function to a normal hook variable | |
2147 | (@pxref{Hooks}). The function we supply is a list starting with | |
2148 | @code{lambda}, with a single-quote in front of it to make it a list | |
2149 | constant rather than an expression. | |
2150 | ||
2151 | It's beyond the scope of this manual to explain Lisp functions, but for | |
2152 | this example it is enough to know that the effect is to execute | |
2153 | @code{(auto-fill-mode 1)} when Text mode is entered. You can replace | |
2154 | that with any other expression that you like, or with several | |
2155 | expressions in a row. | |
2156 | ||
2157 | Emacs comes with a function named @code{turn-on-auto-fill} whose | |
2158 | definition is @code{(lambda () (auto-fill-mode 1))}. Thus, a simpler | |
2159 | way to write the above example is as follows: | |
2160 | ||
2161 | @example | |
2162 | (add-hook 'text-mode-hook 'turn-on-auto-fill) | |
2163 | @end example | |
2164 | ||
2165 | @item | |
2166 | Load the installed Lisp library named @file{foo} (actually a file | |
2167 | @file{foo.elc} or @file{foo.el} in a standard Emacs directory). | |
2168 | ||
2169 | @example | |
2170 | (load "foo") | |
2171 | @end example | |
2172 | ||
2173 | When the argument to @code{load} is a relative file name, not starting | |
2174 | with @samp{/} or @samp{~}, @code{load} searches the directories in | |
2175 | @code{load-path} (@pxref{Lisp Libraries}). | |
2176 | ||
2177 | @item | |
2178 | Load the compiled Lisp file @file{foo.elc} from your home directory. | |
2179 | ||
2180 | @example | |
2181 | (load "~/foo.elc") | |
2182 | @end example | |
2183 | ||
2184 | Here an absolute file name is used, so no searching is done. | |
2185 | ||
2186 | @item | |
2187 | Rebind the key @kbd{C-x l} to run the function @code{make-symbolic-link}. | |
2188 | ||
2189 | @example | |
2190 | (global-set-key "\C-xl" 'make-symbolic-link) | |
2191 | @end example | |
2192 | ||
2193 | or | |
2194 | ||
2195 | @example | |
2196 | (define-key global-map "\C-xl" 'make-symbolic-link) | |
2197 | @end example | |
2198 | ||
2199 | Note once again the single-quote used to refer to the symbol | |
2200 | @code{make-symbolic-link} instead of its value as a variable. | |
2201 | ||
2202 | @item | |
2203 | Do the same thing for Lisp mode only. | |
2204 | ||
2205 | @example | |
2206 | (define-key lisp-mode-map "\C-xl" 'make-symbolic-link) | |
2207 | @end example | |
2208 | ||
2209 | @item | |
2210 | Redefine all keys which now run @code{next-line} in Fundamental mode | |
2211 | so that they run @code{forward-line} instead. | |
2212 | ||
4ea68fcc | 2213 | @findex substitute-key-definition |
6bf7aab6 DL |
2214 | @example |
2215 | (substitute-key-definition 'next-line 'forward-line | |
2216 | global-map) | |
2217 | @end example | |
2218 | ||
2219 | @item | |
2220 | Make @kbd{C-x C-v} undefined. | |
2221 | ||
2222 | @example | |
2223 | (global-unset-key "\C-x\C-v") | |
2224 | @end example | |
2225 | ||
2226 | One reason to undefine a key is so that you can make it a prefix. | |
2227 | Simply defining @kbd{C-x C-v @var{anything}} will make @kbd{C-x C-v} a | |
2228 | prefix, but @kbd{C-x C-v} must first be freed of its usual non-prefix | |
2229 | definition. | |
2230 | ||
2231 | @item | |
2232 | Make @samp{$} have the syntax of punctuation in Text mode. | |
2233 | Note the use of a character constant for @samp{$}. | |
2234 | ||
2235 | @example | |
2236 | (modify-syntax-entry ?\$ "." text-mode-syntax-table) | |
2237 | @end example | |
2238 | ||
2239 | @item | |
2240 | Enable the use of the command @code{narrow-to-region} without confirmation. | |
2241 | ||
2242 | @example | |
2243 | (put 'narrow-to-region 'disabled nil) | |
2244 | @end example | |
2245 | @end itemize | |
2246 | ||
2247 | @node Terminal Init | |
2248 | @subsection Terminal-specific Initialization | |
2249 | ||
2250 | Each terminal type can have a Lisp library to be loaded into Emacs when | |
2251 | it is run on that type of terminal. For a terminal type named | |
2252 | @var{termtype}, the library is called @file{term/@var{termtype}} and it is | |
2253 | found by searching the directories @code{load-path} as usual and trying the | |
2254 | suffixes @samp{.elc} and @samp{.el}. Normally it appears in the | |
2255 | subdirectory @file{term} of the directory where most Emacs libraries are | |
2256 | kept.@refill | |
2257 | ||
2258 | The usual purpose of the terminal-specific library is to map the | |
2259 | escape sequences used by the terminal's function keys onto more | |
2260 | meaningful names, using @code{function-key-map}. See the file | |
2261 | @file{term/lk201.el} for an example of how this is done. Many function | |
2262 | keys are mapped automatically according to the information in the | |
2263 | Termcap data base; the terminal-specific library needs to map only the | |
2264 | function keys that Termcap does not specify. | |
2265 | ||
2266 | When the terminal type contains a hyphen, only the part of the name | |
2267 | before the first hyphen is significant in choosing the library name. | |
2268 | Thus, terminal types @samp{aaa-48} and @samp{aaa-30-rv} both use | |
2269 | the library @file{term/aaa}. The code in the library can use | |
2270 | @code{(getenv "TERM")} to find the full terminal type name.@refill | |
2271 | ||
2272 | @vindex term-file-prefix | |
2273 | The library's name is constructed by concatenating the value of the | |
2274 | variable @code{term-file-prefix} and the terminal type. Your @file{.emacs} | |
2275 | file can prevent the loading of the terminal-specific library by setting | |
2276 | @code{term-file-prefix} to @code{nil}. | |
2277 | ||
2278 | @vindex term-setup-hook | |
2279 | Emacs runs the hook @code{term-setup-hook} at the end of | |
2280 | initialization, after both your @file{.emacs} file and any | |
2281 | terminal-specific library have been read in. Add hook functions to this | |
2282 | hook if you wish to override part of any of the terminal-specific | |
2283 | libraries and to define initializations for terminals that do not have a | |
2284 | library. @xref{Hooks}. | |
2285 | ||
2286 | @node Find Init | |
2287 | @subsection How Emacs Finds Your Init File | |
2288 | ||
60a96371 | 2289 | Normally Emacs uses the environment variable @env{HOME} to find |
6bf7aab6 DL |
2290 | @file{.emacs}; that's what @samp{~} means in a file name. But if you |
2291 | have done @code{su}, Emacs tries to find your own @file{.emacs}, not | |
2292 | that of the user you are currently pretending to be. The idea is | |
2293 | that you should get your own editor customizations even if you are | |
2294 | running as the super user. | |
2295 | ||
2296 | More precisely, Emacs first determines which user's init file to use. | |
60a96371 GM |
2297 | It gets the user name from the environment variables @env{LOGNAME} and |
2298 | @env{USER}; if neither of those exists, it uses effective user-ID. | |
2299 | If that user name matches the real user-ID, then Emacs uses @env{HOME}; | |
6bf7aab6 DL |
2300 | otherwise, it looks up the home directory corresponding to that user |
2301 | name in the system's data base of users. | |
2302 | @c LocalWords: backtab |