|
428
|
1
|
|
|
2 @node Keystrokes, Pull-down Menus, Frame, Top
|
|
|
3 @chapter Keystrokes, Key Sequences, and Key Bindings
|
|
|
4
|
|
|
5 @iftex
|
|
|
6 This chapter discusses the character set Emacs uses for input commands
|
|
|
7 and inside files. You have already learned that the more frequently
|
|
|
8 used Emacs commands are bound to keys. For example, @kbd{Control-f} is
|
|
|
9 bound to @code{forward-char}. The following issues are covered:
|
|
|
10
|
|
|
11 @itemize @bullet
|
|
|
12 @item
|
|
|
13 How keystrokes can be represented
|
|
|
14 @item
|
|
|
15 How you can create key sequences from keystrokes
|
|
|
16 @item
|
|
|
17 How you can add to the available modifier keys by customizing your
|
|
|
18 keyboard: for example, you could have the
|
|
|
19 @key{Capslock} key be understood as the @key{Super} key by Emacs. A
|
|
|
20 @key{Super} key is used like @key{Control} or @key{Meta} in that you hold
|
|
|
21 it while typing another key.
|
|
|
22 @end itemize
|
|
|
23
|
|
|
24 You will also learn how to customize existing key bindings and
|
|
|
25 create new ones.
|
|
|
26 @end iftex
|
|
|
27
|
|
|
28 @menu
|
|
|
29 * Intro to Keystrokes:: Keystrokes as building blocks of key sequences.
|
|
|
30 * Representing Keystrokes:: Using lists of modifiers and keysyms to
|
|
|
31 represent keystrokes.
|
|
|
32 * Key Sequences:: Combine key strokes into key sequences you can
|
|
|
33 bind to commands.
|
|
|
34 * String Key Sequences:: Available for upward compatibility.
|
|
|
35 * Meta Key:: Using @key{ESC} to represent @key{Meta}
|
|
|
36 * Super and Hyper Keys:: Adding modifier keys on certain keyboards.
|
|
|
37 * Character Representation:: How characters appear in Emacs buffers.
|
|
|
38 * Commands:: How commands are bound to key sequences.
|
|
3171
|
39 * Non-Latin keyboards:: Commands on keyboards where one can't type Latin.
|
|
428
|
40 @end menu
|
|
|
41
|
|
|
42 @node Intro to Keystrokes, Representing Keystrokes, Keystrokes, Keystrokes
|
|
|
43 @section Keystrokes as Building Blocks of Key Sequences
|
|
|
44 @cindex character set
|
|
|
45 @cindex ASCII
|
|
|
46 @cindex keystroke
|
|
|
47
|
|
|
48 Earlier versions of Emacs used only the ASCII character set,
|
|
|
49 which defines 128 different character codes. Some of these codes are
|
|
|
50 assigned graphic symbols like @samp{a} and @samp{=}; the rest are
|
|
|
51 control characters, such as @kbd{Control-a} (also called @kbd{C-a}).
|
|
|
52 @kbd{C-a} means you hold down the @key{CTRL} key and then press
|
|
|
53 @kbd{a}.@refill
|
|
|
54
|
|
|
55 Keybindings in XEmacs are not restricted to the set of
|
|
|
56 keystrokes that can be represented in ASCII. XEmacs can tell the
|
|
|
57 difference between, for example, @kbd{Control-h}, @kbd{Control-Shift-h},
|
|
|
58 and @kbd{Backspace}.
|
|
|
59
|
|
|
60 @cindex modifier key
|
|
|
61 @cindex keysym
|
|
|
62 @kindex meta key
|
|
|
63 @kindex control key
|
|
|
64 @kindex hyper key
|
|
|
65 @kindex super key
|
|
|
66 @kindex shift key
|
|
|
67 @kindex button1
|
|
|
68 @kindex button2
|
|
|
69 @kindex button3
|
|
|
70 @kindex button1up
|
|
|
71 @kindex button2up
|
|
|
72 @kindex button3up
|
|
|
73
|
|
|
74 A keystroke is like a piano chord: you get it by simultaneously
|
|
|
75 striking several keys. To be more precise, a keystroke consists
|
|
|
76 of a possibly empty set of modifiers followed by a single
|
|
|
77 @dfn{keysym}. The set of modifiers is small; it consists of
|
|
|
78 @kbd{Control}, @kbd{Meta}, @kbd{Super}, @kbd{Hyper}, and @kbd{Shift}.
|
|
|
79
|
|
|
80 The rest of the keys on your keyboard, along with the mouse buttons,
|
|
|
81 make up the set of keysyms. A keysym is usually what is printed on the
|
|
|
82 keys on your keyboard. Here is a table of some of the symbolic names
|
|
|
83 for keysyms:
|
|
|
84 @table @kbd
|
|
|
85 @item a,b,c...
|
|
|
86 alphabetic keys
|
|
|
87 @item f1,f2...
|
|
|
88 function keys
|
|
|
89 @item button1
|
|
|
90 left mouse button
|
|
|
91 @item button2
|
|
|
92 middle mouse button
|
|
|
93 @item button3
|
|
|
94 right mouse button
|
|
|
95 @item button1up
|
|
|
96 upstroke on the left mouse button
|
|
|
97 @item button2up
|
|
|
98 upstroke on the middle mouse button
|
|
|
99 @item button3up
|
|
|
100 upstroke on the right mouse button
|
|
|
101 @item return
|
|
|
102 Return key
|
|
|
103 @end table
|
|
|
104
|
|
|
105 @vindex keyboard-translate-table
|
|
|
106 Use the variable @code{keyboard-translate-table} only if you are on a
|
|
|
107 dumb tty, as it cannot handle input that cannot be represented as ASCII.
|
|
|
108 The value of this variable is a string used as a translate table for
|
|
|
109 keyboard input or @code{nil}. Each character is looked up in this
|
|
|
110 string and the contents used instead. If the string is of length
|
|
|
111 @code{n}, character codes @code{N} and up are untranslated. If you are
|
|
|
112 running Emacs under X, you should do the translations with the
|
|
|
113 @code{xmodmap} program instead.
|
|
|
114
|
|
|
115
|
|
|
116 @node Representing Keystrokes, Key Sequences, Intro to Keystrokes, Keystrokes
|
|
|
117 @comment node-name, next, previous, up
|
|
|
118 @subsection Representing Keystrokes
|
|
|
119 @kindex hyper key
|
|
|
120 @kindex super key
|
|
|
121 @findex read-key-sequence
|
|
|
122
|
|
|
123 XEmacs represents keystrokes as lists. Each list consists of
|
|
|
124 an arbitrary combination of modifiers followed by a single keysym at the
|
|
|
125 end of the list. If the keysym corresponds to an ASCII character, you
|
|
|
126 can use its character code. (A keystroke may also be represented by an
|
|
|
127 event object, as returned by the @code{read-key-sequence} function;
|
|
|
128 non-programmers need not worry about this.)
|
|
|
129
|
|
|
130 The following table gives some examples of how to list representations
|
|
|
131 for keystrokes. Each list consists of sets of modifiers followed by
|
|
|
132 keysyms:
|
|
|
133
|
|
|
134 @table @kbd
|
|
|
135 @item (control a)
|
|
|
136 Pressing @key{CTRL} and @kbd{a} simultaneously.
|
|
|
137 @item (control ?a)
|
|
|
138 Another way of writing the keystroke @kbd{C-a}.
|
|
|
139 @item (control 65)
|
|
|
140 Yet another way of writing the keystroke @kbd{C-a}.
|
|
|
141 @item (break)
|
|
|
142 Pressing the @key{BREAK} key.
|
|
|
143 @item (control meta button2up)
|
|
|
144 Release the middle mouse button, while pressing @key{CTRL} and
|
|
|
145 @key{META}.
|
|
|
146 @end table
|
|
442
|
147 @cindex shift modifier
|
|
428
|
148 Note: As you define keystrokes, you can use the @kbd{shift} key only
|
|
|
149 as a modifier with characters that do not have a second keysym on the
|
|
|
150 same key, such as @kbd{backspace} and @kbd{tab}. It is an error to
|
|
|
151 define a keystroke using the @key{shift} modifier with keysyms such as
|
|
|
152 @kbd{a} and @kbd{=}. The correct forms are @kbd{A} and @kbd{+}.
|
|
|
153
|
|
|
154 @node Key Sequences, String Key Sequences, Representing Keystrokes, Keystrokes
|
|
|
155 @subsection Representing Key Sequences
|
|
|
156
|
|
|
157 A @dfn{complete key sequence} is a sequence of keystrokes that Emacs
|
|
|
158 understands as a unit. Key sequences are significant because you can
|
|
|
159 bind them to commands. Note that not all sequences of keystrokes are
|
|
|
160 possible key sequences. In particular, the initial keystrokes in a key
|
|
|
161 sequence must make up a @dfn{prefix key sequence}.
|
|
|
162
|
|
|
163 Emacs represents a key sequence as a vector of keystrokes. Thus, the
|
|
|
164 schematic representation of a complete key sequence is as follows:
|
|
|
165
|
|
|
166 @example
|
|
442
|
167 [(modifier .. modifier keysym) ... (modifier .. modifier keysym)]
|
|
428
|
168 @end example
|
|
|
169
|
|
|
170 Here are some examples of complete key sequences:
|
|
|
171
|
|
|
172 @table @kbd
|
|
440
|
173 @item [(control c) (control a)]
|
|
428
|
174 Typing @kbd{C-c} followed by @kbd{C-a}
|
|
440
|
175 @item [(control c) (control 65)]
|
|
428
|
176 Typing @kbd{C-c} followed by @kbd{C-a}. (Using the ASCII code
|
|
|
177 for the character `a')@refill
|
|
|
178 @item [(control c) (break)]
|
|
|
179 Typing @kbd{C-c} followed by the @kbd{break} character.@refill
|
|
|
180 @end table
|
|
|
181
|
|
|
182 @kindex C-c
|
|
|
183 @kindex C-x
|
|
|
184 @kindex C-h
|
|
|
185 @kindex ESC
|
|
|
186 @cindex prefix key sequence
|
|
|
187
|
|
|
188 A @dfn{prefix key sequence} is the beginning of a series of longer
|
|
|
189 sequences that are valid key sequences; adding any single keystroke to
|
|
|
190 the end of a prefix results in a valid key sequence. For example,
|
|
|
191 @kbd{control-x} is standardly defined as a prefix. Thus there is a
|
|
|
192 two-character key sequence starting with @kbd{C-x} for each valid
|
|
|
193 keystroke, giving numerous possibilities. Here are some samples:
|
|
|
194
|
|
|
195 @itemize @bullet
|
|
|
196 @item
|
|
|
197 @kbd{[(control x) (c)]}
|
|
|
198 @item
|
|
|
199 @kbd{[(control x) (control c)]}
|
|
|
200 @end itemize
|
|
|
201
|
|
|
202 Adding one character to a prefix key does not have to form a complete
|
|
|
203 key. It could make another, longer prefix. For example, @kbd{[(control
|
|
|
204 x) (\4)]} is itself a prefix that leads to any number of different
|
|
|
205 three-character keys, including @kbd{[(control x) (\4) (f)]},
|
|
|
206 @kbd{[(control x) (\4) (b)]} and so on. It would be possible to define
|
|
|
207 one of those three-character sequences as a prefix, creating a series of
|
|
|
208 four-character keys, but we did not define any of them this way.@refill
|
|
|
209
|
|
|
210 By contrast, the two-character sequence @kbd{[(control f) (control
|
|
|
211 k)]} is not a key, because the @kbd{(control f)} is a complete key
|
|
|
212 sequence in itself. You cannot give @kbd{[(control f (control k)]} an
|
|
|
213 independent meaning as a command while @kbd{(control f)} is a complete
|
|
|
214 sequence, because Emacs would understand @key{C-f C-k} as two
|
|
|
215 commands.@refill
|
|
|
216
|
|
|
217 The predefined prefix key sequences in Emacs are @kbd{(control c)},
|
|
|
218 @kbd{(control x)}, @kbd{(control h)}, @kbd{[(control x) (\4)]}, and
|
|
|
219 @kbd{escape}. You can customize Emacs and could make new prefix keys or
|
|
|
220 eliminate the default key sequences. @xref{Key Bindings}. For example,
|
|
|
221 if you redefine @kbd{(control f)} as a prefix, @kbd{[(control f)
|
|
|
222 (control k)]} automatically becomes a valid key sequence (complete,
|
|
|
223 unless you define it as a prefix as well). Conversely, if you remove
|
|
|
224 the prefix definition of @kbd{[(control x) (\4)]}, @kbd{[(control x)
|
|
|
225 (\4) (f)]} (or @kbd{[(control x) (\4) @var{anything}]}) is no longer a
|
|
|
226 valid key sequence.
|
|
|
227
|
|
|
228 Note that the above paragraphs uses \4 instead of simply 4, because \4
|
|
|
229 is the symbol whose name is "4", and plain 4 is the integer 4, which
|
|
|
230 would have been interpreted as the ASCII value. Another way of
|
|
|
231 representing the symbol whose name is "4" is to write ?4, which would be
|
|
|
232 interpreted as the number 52, which is the ASCII code for the character
|
|
|
233 "4". We could therefore actually have written 52 directly, but that is
|
|
|
234 far less clear.
|
|
|
235
|
|
|
236 @node String Key Sequences, Meta Key, Key Sequences, Keystrokes
|
|
|
237 @comment node-name, next, previous, up
|
|
|
238 @subsection String Key Sequences
|
|
|
239 For backward compatibility, you may also represent a key sequence using
|
|
|
240 strings. For example, we have the following equivalent representations:
|
|
|
241
|
|
|
242 @table @kbd
|
|
|
243 @item "\C-c\C-c"
|
|
|
244 @code{[(control c) (control c)]}
|
|
|
245 @item "\e\C-c"
|
|
|
246 @code{[(meta control c)]}
|
|
|
247 @end table
|
|
|
248
|
|
|
249 @kindex LFD
|
|
|
250 @kindex TAB
|
|
|
251
|
|
|
252 @node Meta Key, Super and Hyper Keys, String Key Sequences, Keystrokes
|
|
|
253 @comment node-name, next, previous, up
|
|
|
254 @subsection Assignment of the @key{META} Key
|
|
|
255
|
|
|
256 @kindex META
|
|
|
257 @kindex ESC
|
|
|
258 Not all terminals have the complete set of modifiers.
|
|
|
259 Terminals that have a @key{Meta} key allow you to type Meta characters
|
|
|
260 by just holding that key down. To type @kbd{Meta-a}, hold down
|
|
|
261 @key{META} and press @kbd{a}. On those terminals, the @key{META} key
|
|
|
262 works like the @key{SHIFT} key. Such a key is not always labeled
|
|
|
263 @key{META}, however, as this function is often a special option for a
|
|
|
264 key with some other primary purpose.@refill
|
|
|
265
|
|
|
266 If there is no @key{META} key, you can still type Meta characters
|
|
|
267 using two-character sequences starting with @key{ESC}. To enter
|
|
|
268 @kbd{M-a}, you could type @kbd{@key{ESC} a}. To enter @kbd{C-M-a}, you
|
|
|
269 would type @kbd{ESC C-a}. @key{ESC} is allowed on terminals with
|
|
|
270 Meta keys, too, in case you have formed a habit of using it.@refill
|
|
|
271
|
|
|
272 If you are running under X and do not have a @key{META} key, it
|
|
|
273 is possible to reconfigure some other key to be a @key{META}
|
|
|
274 key. @xref{Super and Hyper Keys}. @refill
|
|
|
275
|
|
|
276 @vindex meta-flag
|
|
|
277 Emacs believes the terminal has a @key{META} key if the variable
|
|
|
278 @code{meta-flag} is non-@code{nil}. Normally this is set automatically
|
|
|
279 according to the termcap entry for your terminal type. However, sometimes
|
|
|
280 the termcap entry is wrong, and then it is useful to set this variable
|
|
|
281 yourself. @xref{Variables}, for how to do this.
|
|
|
282
|
|
|
283 Note: If you are running under the X window system, the setting of
|
|
|
284 the @code{meta-flag} variable is irrelevant.
|
|
|
285
|
|
|
286 @node Super and Hyper Keys, Character Representation, Meta Key, Keystrokes
|
|
|
287 @comment node-name, next, previous, up
|
|
|
288 @subsection Assignment of the @key{SUPER} and @key{HYPER} Keys
|
|
|
289 @kindex hyper key
|
|
|
290 @kindex super key
|
|
|
291
|
|
|
292 Most keyboards do not, by default, have @key{SUPER} or @key{HYPER}
|
|
|
293 modifier keys. Under X, you can simulate the @key{SUPER} or
|
|
|
294 @key{HYPER} key if you want to bind keys to sequences using @kbd{super}
|
|
|
295 and @kbd{hyper}. You can use the @code{xmodmap} program to do this.
|
|
|
296
|
|
|
297 For example, to turn your @key{CAPS-LOCK} key into a @key{SUPER} key,
|
|
|
298 do the following:
|
|
|
299
|
|
|
300 Create a file called @code{~/.xmodmap}. In this file, place the lines
|
|
|
301
|
|
|
302 @example
|
|
440
|
303 remove Lock = Caps_Lock
|
|
|
304 keysym Caps_Lock = Super_L
|
|
|
305 add Mod2 = Super_L
|
|
428
|
306 @end example
|
|
|
307
|
|
|
308 The first line says that the key that is currently called @code{Caps_Lock}
|
|
|
309 should no longer behave as a ``lock'' key. The second line says that
|
|
|
310 this should now be called @code{Super_L} instead. The third line says that
|
|
|
311 the key called @code{Super_L} should be a modifier key, which produces the
|
|
|
312 @code{Mod2} modifier.
|
|
|
313
|
|
|
314 To create a @key{META} or @key{HYPER} key instead of a @key{SUPER} key,
|
|
|
315 replace the word @code{Super} above with @code{Meta} or @code{Hyper}.
|
|
|
316
|
|
|
317 Just after you start up X, execute the command @code{xmodmap /.xmodmap}.
|
|
|
318 You can add this command to the appropriate initialization file to have
|
|
|
319 the command executed automatically.@refill
|
|
|
320
|
|
|
321 If you have problems, see the documentation for the @code{xmodmap}
|
|
|
322 program. The X keyboard model is quite complicated, and explaining
|
|
|
323 it is beyond the scope of this manual. However, we reprint the
|
|
|
324 following description from the X Protocol document for your convenience:
|
|
|
325
|
|
|
326 @cindex keysyms
|
|
|
327 @cindex keycode
|
|
|
328
|
|
|
329 A list of keysyms is associated with each keycode. If that list
|
|
|
330 (ignoring trailing @code{NoSymbol} entries) is a single keysym @samp{K},
|
|
|
331 then the list is treated as if it were the list
|
|
|
332 @code{``K NoSymbol K NoSymbol''}. If the list (ignoring trailing
|
|
|
333 @code{NoSymbol} entries) is a pair of keysyms @samp{K1 K2}, then the
|
|
|
334 list is treated as if it were the list @code{``K1 K2 K1 K2''}. If the
|
|
|
335 list (ignoring trailing @code{NoSymbol} entries) is a triple of keysyms
|
|
|
336 @samp{K1 K2 K3}, then the list is treated as if it were the list
|
|
|
337 @code{``K1 K2 K3 NoSymbol''}.
|
|
|
338
|
|
|
339 The first four elements of the list are split into two groups of
|
|
|
340 keysyms. Group 1 contains the first and second keysyms; Group 2 contains
|
|
|
341 third and fourth keysyms. Within each group, if the second element of
|
|
|
342 the group is NoSymbol, then the group should be treated as if the second
|
|
|
343 element were the same as the first element, except when the first
|
|
|
344 element is an alphabetic keysym @samp{K} for which both lowercase and
|
|
|
345 uppercase forms are defined. In that case, the group should be treated
|
|
|
346 as if the first element were the lowercase form of @samp{K} and the second
|
|
|
347 element were the uppercase form of @samp{K}.
|
|
|
348
|
|
|
349 The standard rules for obtaining a keysym from a KeyPress event make use of
|
|
|
350 only the Group 1 and Group 2 keysyms; no interpretation of other keysyms in
|
|
|
351 the list is given here. (That is, the last four keysyms are unused.)
|
|
|
352
|
|
|
353 Which group to use is determined by modifier state. Switching between
|
|
|
354 groups is controlled by the keysym named @code{Mode_switch}. Attach that
|
|
|
355 keysym to some keycode and attach that keycode to any one of the
|
|
|
356 modifiers Mod1 through Mod5. This modifier is called the @dfn{group
|
|
|
357 modifier}. For any keycode, Group 1 is used when the group modifier is
|
|
|
358 off, and Group 2 is used when the group modifier is on.
|
|
|
359
|
|
|
360 Within a group, which keysym to use is also determined by modifier
|
|
|
361 state. The first keysym is used when the @code{Shift} and @code{Lock}
|
|
|
362 modifiers are off. The second keysym is used when the @code{Shift}
|
|
|
363 modifier is on, or when the @code{Lock} modifier is on and the second
|
|
|
364 keysym is uppercase alphabetic, or when the @code{Lock} modifier is on
|
|
|
365 and is interpreted as @code{ShiftLock}. Otherwise, when the @code{Lock}
|
|
|
366 modifier is on and is interpreted as @code{CapsLock}, the state of the
|
|
|
367 @code{Shift} modifier is applied first to select a keysym,
|
|
|
368 but if that keysym is lower-case alphabetic, then the corresponding
|
|
|
369 upper-case keysym is used instead.
|
|
|
370
|
|
|
371 In addition to the above information on keysyms, we also provide the
|
|
|
372 following description of modifier mapping from the InterClient
|
|
|
373 Communications Conventions Manual:
|
|
|
374
|
|
|
375 @cindex modifier mapping
|
|
|
376
|
|
|
377 X11 supports 8 modifier bits, of which 3 are pre-assigned to
|
|
|
378 @code{Shift}, @code{Lock}, and @code{Control}. Each modifier bit is
|
|
|
379 controlled by the state of a set of keys, and these sets are specified
|
|
|
380 in a table accessed by @code{GetModifierMapping()} and
|
|
|
381 @code{SetModifierMapping()}.
|
|
|
382
|
|
|
383 A client needing to use one of the pre-assigned modifiers should assume
|
|
|
384 that the modifier table has been set up correctly to control these
|
|
|
385 modifiers. The @code{Lock} modifier should be interpreted as @code{Caps
|
|
|
386 Lock} or @code{Shift Lock} according to whether the keycodes in its
|
|
|
387 controlling set include @code{XK_Caps_Lock} or @code{XK_Shift_Lock}.
|
|
|
388
|
|
|
389 Clients should determine the meaning of a modifier bit from the keysyms
|
|
|
390 being used to control it.
|
|
|
391
|
|
|
392 A client needing to use an extra modifier, for example @code{Meta}, should:
|
|
|
393
|
|
|
394 @enumerate
|
|
|
395 @item
|
|
|
396 Scan the existing modifier mappings.
|
|
|
397
|
|
|
398 @enumerate
|
|
|
399 @item
|
|
|
400 If it finds a modifier that contains a keycode whose set of keysyms
|
|
|
401 includes @code{XK_Meta_L} or @code{XK_Meta_R}, it should use that
|
|
|
402 modifier bit.
|
|
|
403
|
|
|
404 @item
|
|
|
405 If there is no existing modifier controlled by @code{XK_Meta_L} or
|
|
|
406 @code{XK_Meta_R}, it should select an unused modifier bit (one with
|
|
|
407 an empty controlling set) and:
|
|
|
408 @end enumerate
|
|
|
409
|
|
|
410 @item
|
|
|
411 If there is a keycode with @code{XL_Meta_L} in its set of keysyms,
|
|
|
412 add that keycode to the set for the chosen modifier, and then:
|
|
|
413
|
|
|
414 @enumerate
|
|
|
415 @item
|
|
|
416 If there is a keycode with @code{XL_Meta_R} in its set of keysyms,
|
|
|
417 add that keycode to the set for the chosen modifier, and then:
|
|
|
418
|
|
|
419 @item
|
|
|
420 If the controlling set is still empty, interact with the user to
|
|
|
421 select one or more keys to be @code{Meta}.
|
|
|
422 @end enumerate
|
|
|
423
|
|
|
424
|
|
|
425 @item
|
|
|
426 If there are no unused modifier bits, ask the user to take corrective action.
|
|
|
427 @end enumerate
|
|
|
428
|
|
|
429 This means that the @code{Mod1} modifier does not necessarily mean
|
|
|
430 @code{Meta}, although some applications (such as twm and emacs 18)
|
|
|
431 assume that. Any of the five unassigned modifier bits could mean
|
|
|
432 @code{Meta}; what matters is that a modifier bit is generated by a
|
|
|
433 keycode which is bound to the keysym @code{Meta_L} or @code{Meta_R}.
|
|
|
434
|
|
|
435 Therefore, if you want to make a @key{META} key, the right way
|
|
|
436 is to make the keycode in question generate both a @code{Meta} keysym
|
|
|
437 and some previously-unassigned modifier bit.
|
|
|
438
|
|
|
439 @node Character Representation, Commands, Super and Hyper Keys, Keystrokes
|
|
|
440 @comment node-name, next, previous, up
|
|
|
441 @section Representation of Characters
|
|
|
442
|
|
|
443 This section briefly discusses how characters are represented in Emacs
|
|
|
444 buffers. @xref{Key Sequences}, for information on representing key
|
|
|
445 sequences to create key bindings.
|
|
|
446
|
|
|
447 ASCII graphic characters in Emacs buffers are displayed with their
|
|
|
448 graphics. @key{LFD} is the same as a newline character; it is displayed
|
|
|
449 by starting a new line. @key{TAB} is displayed by moving to the next
|
|
|
450 tab stop column (usually every 8 spaces). Other control characters are
|
|
|
451 displayed as a caret (@samp{^}) followed by the non-control version of
|
|
|
452 the character; thus, @kbd{C-a} is displayed as @samp{^A}. Non-ASCII
|
|
|
453 characters 128 and up are displayed with octal escape sequences; thus,
|
|
|
454 character code 243 (octal), also called @kbd{M-#} when used as an input
|
|
|
455 character, is displayed as @samp{\243}.
|
|
|
456
|
|
|
457 The variable @code{ctl-arrow} may be used to alter this behavior.
|
|
|
458 @xref{Display Vars}.
|
|
|
459
|
|
3171
|
460 @node Commands, Non-Latin keyboards, Character Representation, Keystrokes
|
|
428
|
461 @section Keys and Commands
|
|
|
462
|
|
|
463 @cindex binding
|
|
|
464 @cindex customization
|
|
|
465 @cindex keymap
|
|
|
466 @cindex function
|
|
|
467 @cindex command
|
|
|
468 This manual is full of passages that tell you what particular keys do.
|
|
|
469 But Emacs does not assign meanings to keys directly. Instead, Emacs
|
|
|
470 assigns meanings to @dfn{functions}, and then gives keys their meanings
|
|
|
471 by @dfn{binding} them to functions.
|
|
|
472
|
|
|
473 A function is a Lisp object that can be executed as a program. Usually
|
|
|
474 it is a Lisp symbol that has been given a function definition; every
|
|
|
475 symbol has a name, usually made of a few English words separated by
|
|
|
476 dashes, such as @code{next-line} or @code{forward-word}. It also has a
|
|
|
477 @dfn{definition}, which is a Lisp program. Only some functions can be the
|
|
|
478 bindings of keys; these are functions whose definitions use
|
|
|
479 @code{interactive} to specify how to call them interactively. Such
|
|
|
480 functions are called @dfn{commands}, and their names are @dfn{command
|
|
|
481 names}. More information on this subject will appear in the @i{XEmacs
|
|
|
482 Lisp Reference Manual}.
|
|
|
483
|
|
|
484 The bindings between keys and functions are recorded in various tables
|
|
|
485 called @dfn{keymaps}. @xref{Key Bindings}, for more information on key
|
|
|
486 sequences you can bind commands to. @xref{Keymaps}, for information on
|
|
|
487 creating keymaps.
|
|
|
488
|
|
|
489 When we say ``@kbd{C-n} moves down vertically one line'' we are
|
|
|
490 glossing over a distinction that is irrelevant in ordinary use but is
|
|
|
491 vital in understanding how to customize Emacs. The function
|
|
|
492 @code{next-line} is programmed to move down vertically. @kbd{C-n}
|
|
|
493 has this effect @i{because} it is bound to that function. If you rebind
|
|
|
494 @kbd{C-n} to the function @code{forward-word} then @kbd{C-n} will move
|
|
|
495 forward by words instead. Rebinding keys is a common method of
|
|
|
496 customization.@refill
|
|
|
497
|
|
|
498 The rest of this manual usually ignores this subtlety to keep
|
|
|
499 things simple. To give the customizer the information needed, we often
|
|
|
500 state the name of the command that really does the work in parentheses
|
|
|
501 after mentioning the key that runs it. For example, we will say that
|
|
|
502 ``The command @kbd{C-n} (@code{next-line}) moves point vertically
|
|
|
503 down,'' meaning that @code{next-line} is a command that moves vertically
|
|
|
504 down and @kbd{C-n} is a key that is standardly bound to it.
|
|
|
505
|
|
|
506 @cindex variables
|
|
|
507 While we are on the subject of information for customization only,
|
|
|
508 it's a good time to tell you about @dfn{variables}. Often the
|
|
|
509 description of a command will say, ``To change this, set the variable
|
|
|
510 @code{mumble-foo}.'' A variable is a name used to remember a value.
|
|
|
511 Most of the variables documented in this manual exist just to facilitate
|
|
|
512 customization: some command or other part of Emacs uses the variable
|
|
|
513 and behaves differently depending on its setting. Until you are interested in
|
|
|
514 customizing, you can ignore the information about variables. When you
|
|
|
515 are ready to be interested, read the basic information on variables, and
|
|
|
516 then the information on individual variables will make sense.
|
|
|
517 @xref{Variables}.
|
|
3171
|
518
|
|
|
519 @node Non-Latin keyboards, ,Commands, Keystrokes
|
|
|
520
|
|
|
521 @cindex russian
|
|
|
522 @cindex greek
|
|
|
523 @cindex ``russian c-x''
|
|
|
524 @cindex try-alternate-layouts-for-commands
|
|
|
525
|
|
|
526 If your computer has a keyboard designed for a language like Russian or
|
|
|
527 Greek, where you have to go to some trouble to type Roman-alphabet
|
|
|
528 characters, then typing @kbd{C-f} to call @code{forward-character} is
|
|
|
529 very inconvenient.
|
|
|
530
|
|
|
531 To address this, XEmacs allows you to pretend that your keyboard has a
|
|
|
532 US layout for such commands. That is, you can type @kbd{C-Cyrillic_che
|
|
|
533 C-Cyrillic_a} and XEmacs will work out that it should call the command
|
|
|
534 that @kbd{C-x C-f} is bound to@footnote{You can, of course, override
|
|
|
535 this with an explicit binding for @kbd{C-Cyrillic_che C-Cyrillic_a} to
|
|
|
536 something else.}. Function keys, like @key{F1},
|
|
|
537 @key{Shift} or @key{Control} are not handled by this, just alphanumeric
|
|
|
538 characters and punctuation.
|
|
|
539
|
|
|
540 The main user variable associated with this functionality is
|
|
|
541 @code{try-alternate-layouts-for-commands}. Setting this to @code{nil}
|
|
|
542 inhibits this translation, which would be appropriate if your keyboard
|
|
|
543 can handle the Roman alphabet but doesn't have the US layout, and you
|
|
|
544 want to avoid the possible confusion.
|
|
|
545
|
|
|
546 If @code{try-alternate-layouts-for-commands} is @code{t} but this
|
|
|
547 functionality doesn't work for you under X11, check the value of the
|
|
|
548 variable @code{x-us-keymap-description}. This is a hardware-specific
|
|
|
549 map from key codes to the US layout, and can be initialized from the
|
|
|
550 output of @code{xmodmap -pke}; see the documentation for that variable
|
|
|
551 and for @code{x-us-keymap-first-keycode}.
|
|
|
552
|
