2 @c This is part of the GNU Emacs Lisp Reference Manual.
3 @c Copyright (C) 1990, 1991, 1992, 1993, 1994, 1995, 1998 Free Software Foundation, Inc.
4 @c See the file elisp.texi for copying conditions.
5 @setfilename ../info/commands
6 @node Command Loop, Keymaps, Minibuffers, Top
8 @cindex editor command loop
11 When you run Emacs, it enters the @dfn{editor command loop} almost
12 immediately. This loop reads key sequences, executes their definitions,
13 and displays the results. In this chapter, we describe how these things
14 are done, and the subroutines that allow Lisp programs to do them.
17 * Command Overview:: How the command loop reads commands.
18 * Defining Commands:: Specifying how a function should read arguments.
19 * Interactive Call:: Calling a command, so that it will read arguments.
20 * Command Loop Info:: Variables set by the command loop for you to examine.
21 * Input Events:: What input looks like when you read it.
22 * Reading Input:: How to read input events from the keyboard or mouse.
23 * Special Events:: Events processed immediately and individually.
24 * Waiting:: Waiting for user input or elapsed time.
25 * Quitting:: How @kbd{C-g} works. How to catch or defer quitting.
26 * Prefix Command Arguments:: How the commands to set prefix args work.
27 * Recursive Editing:: Entering a recursive edit,
28 and why you usually shouldn't.
29 * Disabling Commands:: How the command loop handles disabled commands.
30 * Command History:: How the command history is set up, and how accessed.
31 * Keyboard Macros:: How keyboard macros are implemented.
34 @node Command Overview
35 @section Command Loop Overview
37 The first thing the command loop must do is read a key sequence, which
38 is a sequence of events that translates into a command. It does this by
39 calling the function @code{read-key-sequence}. Your Lisp code can also
40 call this function (@pxref{Key Sequence Input}). Lisp programs can also
41 do input at a lower level with @code{read-event} (@pxref{Reading One
42 Event}) or discard pending input with @code{discard-input}
43 (@pxref{Event Input Misc}).
45 The key sequence is translated into a command through the currently
46 active keymaps. @xref{Key Lookup}, for information on how this is done.
47 The result should be a keyboard macro or an interactively callable
48 function. If the key is @kbd{M-x}, then it reads the name of another
49 command, which it then calls. This is done by the command
50 @code{execute-extended-command} (@pxref{Interactive Call}).
52 To execute a command requires first reading the arguments for it.
53 This is done by calling @code{command-execute} (@pxref{Interactive
54 Call}). For commands written in Lisp, the @code{interactive}
55 specification says how to read the arguments. This may use the prefix
56 argument (@pxref{Prefix Command Arguments}) or may read with prompting
57 in the minibuffer (@pxref{Minibuffers}). For example, the command
58 @code{find-file} has an @code{interactive} specification which says to
59 read a file name using the minibuffer. The command's function body does
60 not use the minibuffer; if you call this command from Lisp code as a
61 function, you must supply the file name string as an ordinary Lisp
64 If the command is a string or vector (i.e., a keyboard macro) then
65 @code{execute-kbd-macro} is used to execute it. You can call this
66 function yourself (@pxref{Keyboard Macros}).
68 To terminate the execution of a running command, type @kbd{C-g}. This
69 character causes @dfn{quitting} (@pxref{Quitting}).
71 @defvar pre-command-hook
72 The editor command loop runs this normal hook before each command. At
73 that time, @code{this-command} contains the command that is about to
74 run, and @code{last-command} describes the previous command.
78 @defvar post-command-hook
79 The editor command loop runs this normal hook after each command
80 (including commands terminated prematurely by quitting or by errors),
81 and also when the command loop is first entered. At that time,
82 @code{this-command} describes the command that just ran, and
83 @code{last-command} describes the command before that. @xref{Hooks}.
86 Quitting is suppressed while running @code{pre-command-hook} and
87 @code{post-command-hook}. If an error happens while executing one of
88 these hooks, it terminates execution of the hook, and clears the hook
89 variable to @code{nil} so as to prevent an infinite loop of errors.
91 @node Defining Commands
92 @section Defining Commands
93 @cindex defining commands
94 @cindex commands, defining
95 @cindex functions, making them interactive
96 @cindex interactive function
98 A Lisp function becomes a command when its body contains, at top
99 level, a form that calls the special form @code{interactive}. This
100 form does nothing when actually executed, but its presence serves as a
101 flag to indicate that interactive calling is permitted. Its argument
102 controls the reading of arguments for an interactive call.
105 * Using Interactive:: General rules for @code{interactive}.
106 * Interactive Codes:: The standard letter-codes for reading arguments
108 * Interactive Examples:: Examples of how to read interactive arguments.
111 @node Using Interactive
112 @subsection Using @code{interactive}
114 This section describes how to write the @code{interactive} form that
115 makes a Lisp function an interactively-callable command.
117 @defspec interactive arg-descriptor
118 @cindex argument descriptors
119 This special form declares that the function in which it appears is a
120 command, and that it may therefore be called interactively (via
121 @kbd{M-x} or by entering a key sequence bound to it). The argument
122 @var{arg-descriptor} declares how to compute the arguments to the
123 command when the command is called interactively.
125 A command may be called from Lisp programs like any other function, but
126 then the caller supplies the arguments and @var{arg-descriptor} has no
129 The @code{interactive} form has its effect because the command loop
130 (actually, its subroutine @code{call-interactively}) scans through the
131 function definition looking for it, before calling the function. Once
132 the function is called, all its body forms including the
133 @code{interactive} form are executed, but at this time
134 @code{interactive} simply returns @code{nil} without even evaluating its
138 There are three possibilities for the argument @var{arg-descriptor}:
142 It may be omitted or @code{nil}; then the command is called with no
143 arguments. This leads quickly to an error if the command requires one
147 It may be a Lisp expression that is not a string; then it should be a
148 form that is evaluated to get a list of arguments to pass to the
150 @cindex argument evaluation form
152 If this expression reads keyboard input (this includes using the
153 minibuffer), keep in mind that the integer value of point or the mark
154 before reading input may be incorrect after reading input. This is
155 because the current buffer may be receiving subprocess output;
156 if subprocess output arrives while the command is waiting for input,
157 it could relocate point and the mark.
159 Here's an example of what @emph{not} to do:
163 (list (region-beginning) (region-end)
164 (read-string "Foo: " nil 'my-history)))
168 Here's how to avoid the problem, by examining point and the mark only
169 after reading the keyboard input:
173 (let ((string (read-string "Foo: " nil 'my-history)))
174 (list (region-beginning) (region-end) string)))
178 @cindex argument prompt
179 It may be a string; then its contents should consist of a code character
180 followed by a prompt (which some code characters use and some ignore).
181 The prompt ends either with the end of the string or with a newline.
182 Here is a simple example:
185 (interactive "bFrobnicate buffer: ")
189 The code letter @samp{b} says to read the name of an existing buffer,
190 with completion. The buffer name is the sole argument passed to the
191 command. The rest of the string is a prompt.
193 If there is a newline character in the string, it terminates the prompt.
194 If the string does not end there, then the rest of the string should
195 contain another code character and prompt, specifying another argument.
196 You can specify any number of arguments in this way.
199 The prompt string can use @samp{%} to include previous argument values
200 (starting with the first argument) in the prompt. This is done using
201 @code{format} (@pxref{Formatting Strings}). For example, here is how
202 you could read the name of an existing buffer followed by a new name to
207 (interactive "bBuffer to rename: \nsRename buffer %s to: ")
211 @cindex @samp{*} in interactive
212 @cindex read-only buffers in interactive
213 If the first character in the string is @samp{*}, then an error is
214 signaled if the buffer is read-only.
216 @cindex @samp{@@} in interactive
218 If the first character in the string is @samp{@@}, and if the key
219 sequence used to invoke the command includes any mouse events, then
220 the window associated with the first of those events is selected
221 before the command is run.
223 You can use @samp{*} and @samp{@@} together; the order does not matter.
224 Actual reading of arguments is controlled by the rest of the prompt
225 string (starting with the first character that is not @samp{*} or
229 @node Interactive Codes
230 @comment node-name, next, previous, up
231 @subsection Code Characters for @code{interactive}
232 @cindex interactive code description
233 @cindex description for interactive codes
234 @cindex codes, interactive, description of
235 @cindex characters for interactive codes
237 The code character descriptions below contain a number of key words,
238 defined here as follows:
242 @cindex interactive completion
243 Provide completion. @key{TAB}, @key{SPC}, and @key{RET} perform name
244 completion because the argument is read using @code{completing-read}
245 (@pxref{Completion}). @kbd{?} displays a list of possible completions.
248 Require the name of an existing object. An invalid name is not
249 accepted; the commands to exit the minibuffer do not exit if the current
253 @cindex default argument string
254 A default value of some sort is used if the user enters no text in the
255 minibuffer. The default depends on the code character.
258 This code letter computes an argument without reading any input.
259 Therefore, it does not use a prompt string, and any prompt string you
262 Even though the code letter doesn't use a prompt string, you must follow
263 it with a newline if it is not the last code character in the string.
266 A prompt immediately follows the code character. The prompt ends either
267 with the end of the string or with a newline.
270 This code character is meaningful only at the beginning of the
271 interactive string, and it does not look for a prompt or a newline.
272 It is a single, isolated character.
275 @cindex reading interactive arguments
276 Here are the code character descriptions for use with @code{interactive}:
280 Signal an error if the current buffer is read-only. Special.
283 Select the window mentioned in the first mouse event in the key
284 sequence that invoked this command. Special.
287 A function name (i.e., a symbol satisfying @code{fboundp}). Existing,
291 The name of an existing buffer. By default, uses the name of the
292 current buffer (@pxref{Buffers}). Existing, Completion, Default,
296 A buffer name. The buffer need not exist. By default, uses the name of
297 a recently used buffer other than the current buffer. Completion,
301 A character. The cursor does not move into the echo area. Prompt.
304 A command name (i.e., a symbol satisfying @code{commandp}). Existing,
308 @cindex position argument
309 The position of point, as an integer (@pxref{Point}). No I/O.
312 A directory name. The default is the current default directory of the
313 current buffer, @code{default-directory} (@pxref{System Environment}).
314 Existing, Completion, Default, Prompt.
317 The first or next mouse event in the key sequence that invoked the command.
318 More precisely, @samp{e} gets events that are lists, so you can look at
319 the data in the lists. @xref{Input Events}. No I/O.
321 You can use @samp{e} more than once in a single command's interactive
322 specification. If the key sequence that invoked the command has
323 @var{n} events that are lists, the @var{n}th @samp{e} provides the
324 @var{n}th such event. Events that are not lists, such as function keys
325 and @sc{ascii} characters, do not count where @samp{e} is concerned.
328 A file name of an existing file (@pxref{File Names}). The default
329 directory is @code{default-directory}. Existing, Completion, Default,
333 A file name. The file need not exist. Completion, Default, Prompt.
336 An irrelevant argument. This code always supplies @code{nil} as
337 the argument's value. No I/O.
340 A key sequence (@pxref{Keymap Terminology}). This keeps reading events
341 until a command (or undefined command) is found in the current key
342 maps. The key sequence argument is represented as a string or vector.
343 The cursor does not move into the echo area. Prompt.
345 This kind of input is used by commands such as @code{describe-key} and
346 @code{global-set-key}.
349 A key sequence, whose definition you intend to change. This works like
350 @samp{k}, except that it suppresses, for the last input event in the key
351 sequence, the conversions that are normally used (when necessary) to
352 convert an undefined key into a defined one.
355 @cindex marker argument
356 The position of the mark, as an integer. No I/O.
359 Arbitrary text, read in the minibuffer using the current buffer's input
360 method, and returned as a string (@pxref{Input Methods,,, emacs, The GNU
361 Emacs Manual}). Prompt.
364 A number read with the minibuffer. If the input is not a number, the
365 user is asked to try again. The prefix argument, if any, is not used.
369 @cindex raw prefix argument usage
370 The numeric prefix argument; but if there is no prefix argument, read a
371 number as with @kbd{n}. Requires a number. @xref{Prefix Command
375 @cindex numeric prefix argument usage
376 The numeric prefix argument. (Note that this @samp{p} is lower case.)
380 The raw prefix argument. (Note that this @samp{P} is upper case.) No
384 @cindex region argument
385 Point and the mark, as two numeric arguments, smallest first. This is
386 the only code letter that specifies two successive arguments rather than
390 Arbitrary text, read in the minibuffer and returned as a string
391 (@pxref{Text from Minibuffer}). Terminate the input with either
392 @kbd{C-j} or @key{RET}. (@kbd{C-q} may be used to include either of
393 these characters in the input.) Prompt.
396 An interned symbol whose name is read in the minibuffer. Any whitespace
397 character terminates the input. (Use @kbd{C-q} to include whitespace in
398 the string.) Other characters that normally terminate a symbol (e.g.,
399 parentheses and brackets) do not do so here. Prompt.
402 A variable declared to be a user option (i.e., satisfying the predicate
403 @code{user-variable-p}). @xref{High-Level Completion}. Existing,
407 A Lisp object, specified with its read syntax, terminated with a
408 @kbd{C-j} or @key{RET}. The object is not evaluated. @xref{Object from
412 @cindex evaluated expression argument
413 A Lisp form is read as with @kbd{x}, but then evaluated so that its
414 value becomes the argument for the command. Prompt.
417 A coding system name (a symbol). If the user enters null input, the
418 argument value is @code{nil}. @xref{Coding Systems}. Completion,
422 A coding system name (a symbol)---but only if this command has a prefix
423 argument. With no prefix argument, @samp{Z} provides @code{nil} as the
424 argument value. Completion, Existing, Prompt.
427 @node Interactive Examples
428 @comment node-name, next, previous, up
429 @subsection Examples of Using @code{interactive}
430 @cindex examples of using @code{interactive}
431 @cindex @code{interactive}, examples of using
433 Here are some examples of @code{interactive}:
437 (defun foo1 () ; @r{@code{foo1} takes no arguments,}
438 (interactive) ; @r{just moves forward two words.}
444 (defun foo2 (n) ; @r{@code{foo2} takes one argument,}
445 (interactive "p") ; @r{which is the numeric prefix.}
446 (forward-word (* 2 n)))
451 (defun foo3 (n) ; @r{@code{foo3} takes one argument,}
452 (interactive "nCount:") ; @r{which is read with the Minibuffer.}
453 (forward-word (* 2 n)))
458 (defun three-b (b1 b2 b3)
459 "Select three existing buffers.
460 Put them into three windows, selecting the last one."
462 (interactive "bBuffer1:\nbBuffer2:\nbBuffer3:")
463 (delete-other-windows)
464 (split-window (selected-window) 8)
465 (switch-to-buffer b1)
467 (split-window (selected-window) 8)
468 (switch-to-buffer b2)
470 (switch-to-buffer b3))
473 (three-b "*scratch*" "declarations.texi" "*mail*")
478 @node Interactive Call
479 @section Interactive Call
480 @cindex interactive call
482 After the command loop has translated a key sequence into a command it
483 invokes that command using the function @code{command-execute}. If the
484 command is a function, @code{command-execute} calls
485 @code{call-interactively}, which reads the arguments and calls the
486 command. You can also call these functions yourself.
488 @defun commandp object
489 Returns @code{t} if @var{object} is suitable for calling interactively;
490 that is, if @var{object} is a command. Otherwise, returns @code{nil}.
492 The interactively callable objects include strings and vectors (treated
493 as keyboard macros), lambda expressions that contain a top-level call to
494 @code{interactive}, byte-code function objects made from such lambda
495 expressions, autoload objects that are declared as interactive
496 (non-@code{nil} fourth argument to @code{autoload}), and some of the
499 A symbol satisfies @code{commandp} if its function definition satisfies
502 Keys and keymaps are not commands. Rather, they are used to look up
503 commands (@pxref{Keymaps}).
505 See @code{documentation} in @ref{Accessing Documentation}, for a
506 realistic example of using @code{commandp}.
509 @defun call-interactively command &optional record-flag keys
510 This function calls the interactively callable function @var{command},
511 reading arguments according to its interactive calling specifications.
512 An error is signaled if @var{command} is not a function or if it cannot
513 be called interactively (i.e., is not a command). Note that keyboard
514 macros (strings and vectors) are not accepted, even though they are
515 considered commands, because they are not functions.
517 @cindex record command history
518 If @var{record-flag} is non-@code{nil}, then this command and its
519 arguments are unconditionally added to the list @code{command-history}.
520 Otherwise, the command is added only if it uses the minibuffer to read
521 an argument. @xref{Command History}.
523 The argument @var{keys}, if given, specifies the sequence of events to
524 supply if the command inquires which events were used to invoke it.
527 @defun command-execute command &optional record-flag keys special
528 @cindex keyboard macro execution
529 This function executes @var{command}. The argument @var{command} must
530 satisfy the @code{commandp} predicate; i.e., it must be an interactively
531 callable function or a keyboard macro.
533 A string or vector as @var{command} is executed with
534 @code{execute-kbd-macro}. A function is passed to
535 @code{call-interactively}, along with the optional @var{record-flag}.
537 A symbol is handled by using its function definition in its place. A
538 symbol with an @code{autoload} definition counts as a command if it was
539 declared to stand for an interactively callable function. Such a
540 definition is handled by loading the specified library and then
541 rechecking the definition of the symbol.
543 The argument @var{keys}, if given, specifies the sequence of events to
544 supply if the command inquires which events were used to invoke it.
546 The argument @var{special}, if given, means to ignore the prefix
547 argument and not clear it. This is used for executing special events
548 (@pxref{Special Events}).
551 @deffn Command execute-extended-command prefix-argument
552 @cindex read command name
553 This function reads a command name from the minibuffer using
554 @code{completing-read} (@pxref{Completion}). Then it uses
555 @code{command-execute} to call the specified command. Whatever that
556 command returns becomes the value of @code{execute-extended-command}.
558 @cindex execute with prefix argument
559 If the command asks for a prefix argument, it receives the value
560 @var{prefix-argument}. If @code{execute-extended-command} is called
561 interactively, the current raw prefix argument is used for
562 @var{prefix-argument}, and thus passed on to whatever command is run.
564 @c !!! Should this be @kindex?
566 @code{execute-extended-command} is the normal definition of @kbd{M-x},
567 so it uses the string @w{@samp{M-x }} as a prompt. (It would be better
568 to take the prompt from the events used to invoke
569 @code{execute-extended-command}, but that is painful to implement.) A
570 description of the value of the prefix argument, if any, also becomes
575 (execute-extended-command 1)
576 ---------- Buffer: Minibuffer ----------
577 1 M-x forward-word RET
578 ---------- Buffer: Minibuffer ----------
585 This function returns @code{t} if the containing function (the one whose
586 code includes the call to @code{interactive-p}) was called
587 interactively, with the function @code{call-interactively}. (It makes
588 no difference whether @code{call-interactively} was called from Lisp or
589 directly from the editor command loop.) If the containing function was
590 called by Lisp evaluation (or with @code{apply} or @code{funcall}), then
591 it was not called interactively.
594 The most common use of @code{interactive-p} is for deciding whether to
595 print an informative message. As a special exception,
596 @code{interactive-p} returns @code{nil} whenever a keyboard macro is
597 being run. This is to suppress the informative messages and speed
598 execution of the macro.
606 (when (interactive-p)
614 (setq foobar (list (foo) (interactive-p))))
619 ;; @r{Type @kbd{M-x foo}.}
624 ;; @r{Type @kbd{M-x bar}.}
625 ;; @r{This does not print anything.}
634 The other way to do this sort of job is to make the command take an
635 argument @code{print-message} which should be non-@code{nil} in an
636 interactive call, and use the @code{interactive} spec to make sure it is
637 non-@code{nil}. Here's how:
640 (defun foo (&optional print-message)
646 The numeric prefix argument, provided by @samp{p}, is never @code{nil}.
648 @node Command Loop Info
649 @comment node-name, next, previous, up
650 @section Information from the Command Loop
652 The editor command loop sets several Lisp variables to keep status
653 records for itself and for commands that are run.
656 This variable records the name of the previous command executed by the
657 command loop (the one before the current command). Normally the value
658 is a symbol with a function definition, but this is not guaranteed.
660 The value is copied from @code{this-command} when a command returns to
661 the command loop, except when the command has specified a prefix
662 argument for the following command.
664 This variable is always local to the current terminal and cannot be
665 buffer-local. @xref{Multiple Displays}.
668 @tindex real-last-command
669 @defvar real-last-command
670 This variable is set up by Emacs just like @code{last-command},
671 but never altered by Lisp programs.
675 @cindex current command
676 This variable records the name of the command now being executed by
677 the editor command loop. Like @code{last-command}, it is normally a symbol
678 with a function definition.
680 The command loop sets this variable just before running a command, and
681 copies its value into @code{last-command} when the command finishes
682 (unless the command specified a prefix argument for the following
685 @cindex kill command repetition
686 Some commands set this variable during their execution, as a flag for
687 whatever command runs next. In particular, the functions for killing text
688 set @code{this-command} to @code{kill-region} so that any kill commands
689 immediately following will know to append the killed text to the
693 If you do not want a particular command to be recognized as the previous
694 command in the case where it got an error, you must code that command to
695 prevent this. One way is to set @code{this-command} to @code{t} at the
696 beginning of the command, and set @code{this-command} back to its proper
697 value at the end, like this:
700 (defun foo (args@dots{})
701 (interactive @dots{})
702 (let ((old-this-command this-command))
703 (setq this-command t)
704 @r{@dots{}do the work@dots{}}
705 (setq this-command old-this-command)))
709 We do not bind @code{this-command} with @code{let} because that would
710 restore the old value in case of error---a feature of @code{let} which
711 in this case does precisely what we want to avoid.
713 @defun this-command-keys
714 This function returns a string or vector containing the key sequence
715 that invoked the present command, plus any previous commands that
716 generated the prefix argument for this command. The value is a string
717 if all those events were characters. @xref{Input Events}.
722 ;; @r{Now use @kbd{C-u C-x C-e} to evaluate that.}
728 @defun this-command-keys-vector
729 Like @code{this-command-keys}, except that it always returns
730 the events in a vector, so you do never need to deal with the complexities
731 of storing input events in a string (@pxref{Strings of Events}).
734 @tindex clear-this-command-keys
735 @defun clear-this-command-keys
736 This function empties out the table of events for
737 @code{this-command-keys} to return. This is useful after reading a
738 password, to prevent the password from echoing inadvertently as part of
739 the next command in certain cases.
742 @defvar last-nonmenu-event
743 This variable holds the last input event read as part of a key sequence,
744 not counting events resulting from mouse menus.
746 One use of this variable is for telling @code{x-popup-menu} where to pop
747 up a menu. It is also used internally by @code{y-or-n-p}
748 (@pxref{Yes-or-No Queries}).
751 @defvar last-command-event
752 @defvarx last-command-char
753 This variable is set to the last input event that was read by the
754 command loop as part of a command. The principal use of this variable
755 is in @code{self-insert-command}, which uses it to decide which
761 ;; @r{Now use @kbd{C-u C-x C-e} to evaluate that.}
767 The value is 5 because that is the @sc{ascii} code for @kbd{C-e}.
769 The alias @code{last-command-char} exists for compatibility with
774 @defvar last-event-frame
775 This variable records which frame the last input event was directed to.
776 Usually this is the frame that was selected when the event was
777 generated, but if that frame has redirected input focus to another
778 frame, the value is the frame to which the event was redirected.
783 @section Input Events
787 The Emacs command loop reads a sequence of @dfn{input events} that
788 represent keyboard or mouse activity. The events for keyboard activity
789 are characters or symbols; mouse events are always lists. This section
790 describes the representation and meaning of input events in detail.
793 This function returns non-@code{nil} if @var{object} is an input event
796 Note that any symbol might be used as an event or an event type.
797 @code{eventp} cannot distinguish whether a symbol is intended by Lisp
798 code to be used as an event. Instead, it distinguishes whether the
799 symbol has actually been used in an event that has been read as input in
800 the current Emacs session. If a symbol has not yet been so used,
801 @code{eventp} returns @code{nil}.
805 * Keyboard Events:: Ordinary characters--keys with symbols on them.
806 * Function Keys:: Function keys--keys with names, not symbols.
807 * Mouse Events:: Overview of mouse events.
808 * Click Events:: Pushing and releasing a mouse button.
809 * Drag Events:: Moving the mouse before releasing the button.
810 * Button-Down Events:: A button was pushed and not yet released.
811 * Repeat Events:: Double and triple click (or drag, or down).
812 * Motion Events:: Just moving the mouse, not pushing a button.
813 * Focus Events:: Moving the mouse between frames.
814 * Misc Events:: Other events window systems can generate.
815 * Event Examples:: Examples of the lists for mouse events.
816 * Classifying Events:: Finding the modifier keys in an event symbol.
818 * Accessing Events:: Functions to extract info from events.
819 * Strings of Events:: Special considerations for putting
820 keyboard character events in a string.
823 @node Keyboard Events
824 @subsection Keyboard Events
826 There are two kinds of input you can get from the keyboard: ordinary
827 keys, and function keys. Ordinary keys correspond to characters; the
828 events they generate are represented in Lisp as characters. The event
829 type of a character event is the character itself (an integer); see
830 @ref{Classifying Events}.
832 @cindex modifier bits (of input character)
833 @cindex basic code (of input character)
834 An input character event consists of a @dfn{basic code} between 0 and
835 524287, plus any or all of these @dfn{modifier bits}:
846 bit in the character code indicates a character
847 typed with the meta key held down.
857 bit in the character code indicates a non-@sc{ascii}
860 @sc{ascii} control characters such as @kbd{C-a} have special basic
861 codes of their own, so Emacs needs no special bit to indicate them.
862 Thus, the code for @kbd{C-a} is just 1.
864 But if you type a control combination not in @sc{ascii}, such as
865 @kbd{%} with the control key, the numeric value you get is the code
873 (assuming the terminal supports non-@sc{ascii}
884 bit in the character code indicates an @sc{ascii} control
885 character typed with the shift key held down.
887 For letters, the basic code itself indicates upper versus lower case;
888 for digits and punctuation, the shift key selects an entirely different
889 character with a different basic code. In order to keep within the
890 @sc{ascii} character set whenever possible, Emacs avoids using the
897 bit for those characters.
899 However, @sc{ascii} provides no way to distinguish @kbd{C-A} from
900 @kbd{C-a}, so Emacs uses the
907 bit in @kbd{C-A} and not in
918 bit in the character code indicates a character
919 typed with the hyper key held down.
929 bit in the character code indicates a character
930 typed with the super key held down.
940 bit in the character code indicates a character typed with
941 the alt key held down. (On some terminals, the key labeled @key{ALT}
942 is actually the meta key.)
945 It is best to avoid mentioning specific bit numbers in your program.
946 To test the modifier bits of a character, use the function
947 @code{event-modifiers} (@pxref{Classifying Events}). When making key
948 bindings, you can use the read syntax for characters with modifier bits
949 (@samp{\C-}, @samp{\M-}, and so on). For making key bindings with
950 @code{define-key}, you can use lists such as @code{(control hyper ?x)} to
951 specify the characters (@pxref{Changing Key Bindings}). The function
952 @code{event-convert-list} converts such a list into an event type
953 (@pxref{Classifying Events}).
956 @subsection Function Keys
958 @cindex function keys
959 Most keyboards also have @dfn{function keys}---keys that have names or
960 symbols that are not characters. Function keys are represented in Emacs
961 Lisp as symbols; the symbol's name is the function key's label, in lower
962 case. For example, pressing a key labeled @key{F1} places the symbol
963 @code{f1} in the input stream.
965 The event type of a function key event is the event symbol itself.
966 @xref{Classifying Events}.
968 Here are a few special cases in the symbol-naming convention for
972 @item @code{backspace}, @code{tab}, @code{newline}, @code{return}, @code{delete}
973 These keys correspond to common @sc{ascii} control characters that have
974 special keys on most keyboards.
976 In @sc{ascii}, @kbd{C-i} and @key{TAB} are the same character. If the
977 terminal can distinguish between them, Emacs conveys the distinction to
978 Lisp programs by representing the former as the integer 9, and the
979 latter as the symbol @code{tab}.
981 Most of the time, it's not useful to distinguish the two. So normally
982 @code{function-key-map} (@pxref{Translating Input}) is set up to map
983 @code{tab} into 9. Thus, a key binding for character code 9 (the
984 character @kbd{C-i}) also applies to @code{tab}. Likewise for the other
985 symbols in this group. The function @code{read-char} likewise converts
986 these events into characters.
988 In @sc{ascii}, @key{BS} is really @kbd{C-h}. But @code{backspace}
989 converts into the character code 127 (@key{DEL}), not into code 8
990 (@key{BS}). This is what most users prefer.
992 @item @code{left}, @code{up}, @code{right}, @code{down}
994 @item @code{kp-add}, @code{kp-decimal}, @code{kp-divide}, @dots{}
995 Keypad keys (to the right of the regular keyboard).
996 @item @code{kp-0}, @code{kp-1}, @dots{}
997 Keypad keys with digits.
998 @item @code{kp-f1}, @code{kp-f2}, @code{kp-f3}, @code{kp-f4}
1000 @item @code{kp-home}, @code{kp-left}, @code{kp-up}, @code{kp-right}, @code{kp-down}
1001 Keypad arrow keys. Emacs normally translates these into the
1002 corresponding non-keypad keys @code{home}, @code{left}, @dots{}
1003 @item @code{kp-prior}, @code{kp-next}, @code{kp-end}, @code{kp-begin}, @code{kp-insert}, @code{kp-delete}
1004 Additional keypad duplicates of keys ordinarily found elsewhere. Emacs
1005 normally translates these into the like-named non-keypad keys.
1008 You can use the modifier keys @key{ALT}, @key{CTRL}, @key{HYPER},
1009 @key{META}, @key{SHIFT}, and @key{SUPER} with function keys. The way to
1010 represent them is with prefixes in the symbol name:
1016 The control modifier.
1027 Thus, the symbol for the key @key{F3} with @key{META} held down is
1028 @code{M-f3}. When you use more than one prefix, we recommend you
1029 write them in alphabetical order; but the order does not matter in
1030 arguments to the key-binding lookup and modification functions.
1033 @subsection Mouse Events
1035 Emacs supports four kinds of mouse events: click events, drag events,
1036 button-down events, and motion events. All mouse events are represented
1037 as lists. The @sc{car} of the list is the event type; this says which
1038 mouse button was involved, and which modifier keys were used with it.
1039 The event type can also distinguish double or triple button presses
1040 (@pxref{Repeat Events}). The rest of the list elements give position
1041 and time information.
1043 For key lookup, only the event type matters: two events of the same type
1044 necessarily run the same command. The command can access the full
1045 values of these events using the @samp{e} interactive code.
1046 @xref{Interactive Codes}.
1048 A key sequence that starts with a mouse event is read using the keymaps
1049 of the buffer in the window that the mouse was in, not the current
1050 buffer. This does not imply that clicking in a window selects that
1051 window or its buffer---that is entirely under the control of the command
1052 binding of the key sequence.
1055 @subsection Click Events
1057 @cindex mouse click event
1059 When the user presses a mouse button and releases it at the same
1060 location, that generates a @dfn{click} event. Mouse click events have
1065 (@var{window} @var{buffer-pos} (@var{x} . @var{y}) @var{timestamp})
1069 Here is what the elements normally mean:
1072 @item @var{event-type}
1073 This is a symbol that indicates which mouse button was used. It is
1074 one of the symbols @code{mouse-1}, @code{mouse-2}, @dots{}, where the
1075 buttons are numbered left to right.
1077 You can also use prefixes @samp{A-}, @samp{C-}, @samp{H-}, @samp{M-},
1078 @samp{S-} and @samp{s-} for modifiers alt, control, hyper, meta, shift
1079 and super, just as you would with function keys.
1081 This symbol also serves as the event type of the event. Key bindings
1082 describe events by their types; thus, if there is a key binding for
1083 @code{mouse-1}, that binding would apply to all events whose
1084 @var{event-type} is @code{mouse-1}.
1087 This is the window in which the click occurred.
1089 @item @var{x}, @var{y}
1090 These are the pixel-denominated coordinates of the click, relative to
1091 the top left corner of @var{window}, which is @code{(0 . 0)}.
1093 @item @var{buffer-pos}
1094 This is the buffer position of the character clicked on.
1096 @item @var{timestamp}
1097 This is the time at which the event occurred, in milliseconds. (Since
1098 this value wraps around the entire range of Emacs Lisp integers in about
1099 five hours, it is useful only for relating the times of nearby events.)
1101 @item @var{click-count}
1102 This is the number of rapid repeated presses so far of the same mouse
1103 button. @xref{Repeat Events}.
1106 The meanings of @var{buffer-pos}, @var{x} and @var{y} are somewhat
1107 different when the event location is in a special part of the screen,
1108 such as the mode line or a scroll bar.
1110 If the location is in a scroll bar, then @var{buffer-pos} is the symbol
1111 @code{vertical-scroll-bar} or @code{horizontal-scroll-bar}, and the pair
1112 @code{(@var{x} . @var{y})} is replaced with a pair @code{(@var{portion}
1113 . @var{whole})}, where @var{portion} is the distance of the click from
1114 the top or left end of the scroll bar, and @var{whole} is the length of
1115 the entire scroll bar.
1117 If the position is on a mode line or the vertical line separating
1118 @var{window} from its neighbor to the right, then @var{buffer-pos} is
1119 the symbol @code{mode-line}, @code{header-line}, or
1120 @code{vertical-line}. For the mode line, @var{y} does not have
1121 meaningful data. For the vertical line, @var{x} does not have
1124 In one special case, @var{buffer-pos} is a list containing a symbol (one
1125 of the symbols listed above) instead of just the symbol. This happens
1126 after the imaginary prefix keys for the event are inserted into the
1127 input stream. @xref{Key Sequence Input}.
1130 @subsection Drag Events
1132 @cindex mouse drag event
1134 With Emacs, you can have a drag event without even changing your
1135 clothes. A @dfn{drag event} happens every time the user presses a mouse
1136 button and then moves the mouse to a different character position before
1137 releasing the button. Like all mouse events, drag events are
1138 represented in Lisp as lists. The lists record both the starting mouse
1139 position and the final position, like this:
1143 (@var{window1} @var{buffer-pos1} (@var{x1} . @var{y1}) @var{timestamp1})
1144 (@var{window2} @var{buffer-pos2} (@var{x2} . @var{y2}) @var{timestamp2})
1148 For a drag event, the name of the symbol @var{event-type} contains the
1149 prefix @samp{drag-}. For example, dragging the mouse with button 2 held
1150 down generates a @code{drag-mouse-2} event. The second and third
1151 elements of the event give the starting and ending position of the drag.
1152 Aside from that, the data have the same meanings as in a click event
1153 (@pxref{Click Events}). You can access the second element of any mouse
1154 event in the same way, with no need to distinguish drag events from
1157 The @samp{drag-} prefix follows the modifier key prefixes such as
1158 @samp{C-} and @samp{M-}.
1160 If @code{read-key-sequence} receives a drag event that has no key
1161 binding, and the corresponding click event does have a binding, it
1162 changes the drag event into a click event at the drag's starting
1163 position. This means that you don't have to distinguish between click
1164 and drag events unless you want to.
1166 @node Button-Down Events
1167 @subsection Button-Down Events
1168 @cindex button-down event
1170 Click and drag events happen when the user releases a mouse button.
1171 They cannot happen earlier, because there is no way to distinguish a
1172 click from a drag until the button is released.
1174 If you want to take action as soon as a button is pressed, you need to
1175 handle @dfn{button-down} events.@footnote{Button-down is the
1176 conservative antithesis of drag.} These occur as soon as a button is
1177 pressed. They are represented by lists that look exactly like click
1178 events (@pxref{Click Events}), except that the @var{event-type} symbol
1179 name contains the prefix @samp{down-}. The @samp{down-} prefix follows
1180 modifier key prefixes such as @samp{C-} and @samp{M-}.
1182 The function @code{read-key-sequence} ignores any button-down events
1183 that don't have command bindings; therefore, the Emacs command loop
1184 ignores them too. This means that you need not worry about defining
1185 button-down events unless you want them to do something. The usual
1186 reason to define a button-down event is so that you can track mouse
1187 motion (by reading motion events) until the button is released.
1188 @xref{Motion Events}.
1191 @subsection Repeat Events
1192 @cindex repeat events
1193 @cindex double-click events
1194 @cindex triple-click events
1196 If you press the same mouse button more than once in quick succession
1197 without moving the mouse, Emacs generates special @dfn{repeat} mouse
1198 events for the second and subsequent presses.
1200 The most common repeat events are @dfn{double-click} events. Emacs
1201 generates a double-click event when you click a button twice; the event
1202 happens when you release the button (as is normal for all click
1205 The event type of a double-click event contains the prefix
1206 @samp{double-}. Thus, a double click on the second mouse button with
1207 @key{meta} held down comes to the Lisp program as
1208 @code{M-double-mouse-2}. If a double-click event has no binding, the
1209 binding of the corresponding ordinary click event is used to execute
1210 it. Thus, you need not pay attention to the double click feature
1211 unless you really want to.
1213 When the user performs a double click, Emacs generates first an ordinary
1214 click event, and then a double-click event. Therefore, you must design
1215 the command binding of the double click event to assume that the
1216 single-click command has already run. It must produce the desired
1217 results of a double click, starting from the results of a single click.
1219 This is convenient, if the meaning of a double click somehow ``builds
1220 on'' the meaning of a single click---which is recommended user interface
1221 design practice for double clicks.
1223 If you click a button, then press it down again and start moving the
1224 mouse with the button held down, then you get a @dfn{double-drag} event
1225 when you ultimately release the button. Its event type contains
1226 @samp{double-drag} instead of just @samp{drag}. If a double-drag event
1227 has no binding, Emacs looks for an alternate binding as if the event
1228 were an ordinary drag.
1230 Before the double-click or double-drag event, Emacs generates a
1231 @dfn{double-down} event when the user presses the button down for the
1232 second time. Its event type contains @samp{double-down} instead of just
1233 @samp{down}. If a double-down event has no binding, Emacs looks for an
1234 alternate binding as if the event were an ordinary button-down event.
1235 If it finds no binding that way either, the double-down event is
1238 To summarize, when you click a button and then press it again right
1239 away, Emacs generates a down event and a click event for the first
1240 click, a double-down event when you press the button again, and finally
1241 either a double-click or a double-drag event.
1243 If you click a button twice and then press it again, all in quick
1244 succession, Emacs generates a @dfn{triple-down} event, followed by
1245 either a @dfn{triple-click} or a @dfn{triple-drag}. The event types of
1246 these events contain @samp{triple} instead of @samp{double}. If any
1247 triple event has no binding, Emacs uses the binding that it would use
1248 for the corresponding double event.
1250 If you click a button three or more times and then press it again, the
1251 events for the presses beyond the third are all triple events. Emacs
1252 does not have separate event types for quadruple, quintuple, etc.@:
1253 events. However, you can look at the event list to find out precisely
1254 how many times the button was pressed.
1256 @defun event-click-count event
1257 This function returns the number of consecutive button presses that led
1258 up to @var{event}. If @var{event} is a double-down, double-click or
1259 double-drag event, the value is 2. If @var{event} is a triple event,
1260 the value is 3 or greater. If @var{event} is an ordinary mouse event
1261 (not a repeat event), the value is 1.
1264 @defvar double-click-time
1265 To generate repeat events, successive mouse button presses must be at
1266 the same screen position, and the number of milliseconds between
1267 successive button presses must be less than the value of
1268 @code{double-click-time}. Setting @code{double-click-time} to
1269 @code{nil} disables multi-click detection entirely. Setting it to
1270 @code{t} removes the time limit; Emacs then detects multi-clicks by
1275 @subsection Motion Events
1276 @cindex motion event
1277 @cindex mouse motion events
1279 Emacs sometimes generates @dfn{mouse motion} events to describe motion
1280 of the mouse without any button activity. Mouse motion events are
1281 represented by lists that look like this:
1284 (mouse-movement (@var{window} @var{buffer-pos} (@var{x} . @var{y}) @var{timestamp}))
1287 The second element of the list describes the current position of the
1288 mouse, just as in a click event (@pxref{Click Events}).
1290 The special form @code{track-mouse} enables generation of motion events
1291 within its body. Outside of @code{track-mouse} forms, Emacs does not
1292 generate events for mere motion of the mouse, and these events do not
1293 appear. @xref{Mouse Tracking}.
1296 @subsection Focus Events
1299 Window systems provide general ways for the user to control which window
1300 gets keyboard input. This choice of window is called the @dfn{focus}.
1301 When the user does something to switch between Emacs frames, that
1302 generates a @dfn{focus event}. The normal definition of a focus event,
1303 in the global keymap, is to select a new frame within Emacs, as the user
1304 would expect. @xref{Input Focus}.
1306 Focus events are represented in Lisp as lists that look like this:
1309 (switch-frame @var{new-frame})
1313 where @var{new-frame} is the frame switched to.
1315 Most X window managers are set up so that just moving the mouse into a
1316 window is enough to set the focus there. Emacs appears to do this,
1317 because it changes the cursor to solid in the new frame. However, there
1318 is no need for the Lisp program to know about the focus change until
1319 some other kind of input arrives. So Emacs generates a focus event only
1320 when the user actually types a keyboard key or presses a mouse button in
1321 the new frame; just moving the mouse between frames does not generate a
1324 A focus event in the middle of a key sequence would garble the
1325 sequence. So Emacs never generates a focus event in the middle of a key
1326 sequence. If the user changes focus in the middle of a key
1327 sequence---that is, after a prefix key---then Emacs reorders the events
1328 so that the focus event comes either before or after the multi-event key
1329 sequence, and not within it.
1332 @subsection Miscellaneous Window System Events
1334 A few other event types represent occurrences within the window system.
1337 @cindex @code{delete-frame} event
1338 @item (delete-frame (@var{frame}))
1339 This kind of event indicates that the user gave the window manager
1340 a command to delete a particular window, which happens to be an Emacs frame.
1342 The standard definition of the @code{delete-frame} event is to delete @var{frame}.
1344 @cindex @code{iconify-frame} event
1345 @item (iconify-frame (@var{frame}))
1346 This kind of event indicates that the user iconified @var{frame} using
1347 the window manager. Its standard definition is @code{ignore}; since the
1348 frame has already been iconified, Emacs has no work to do. The purpose
1349 of this event type is so that you can keep track of such events if you
1352 @cindex @code{make-frame-visible} event
1353 @item (make-frame-visible (@var{frame}))
1354 This kind of event indicates that the user deiconified @var{frame} using
1355 the window manager. Its standard definition is @code{ignore}; since the
1356 frame has already been made visible, Emacs has no work to do.
1358 @cindex @code{mouse-wheel} event
1359 @item (mouse-wheel @var{position} @var{delta})
1360 This kind of event is generated by moving a wheel on a mouse (such as
1361 the MS Intellimouse). Its effect is typically a kind of scroll or zoom.
1363 The element @var{delta} describes the amount and direction of the wheel
1364 rotation. Its absolute value is the number of increments by which the
1365 wheel was rotated. A negative @var{delta} indicates that the wheel was
1366 rotated backwards, towards the user, and a positive @var{delta}
1367 indicates that the wheel was rotated forward, away from the user.
1369 The element @var{position} is a list describing the position of the
1370 event, in the same format as used in a mouse-click event.
1372 This kind of event is generated only on some kinds of systems.
1374 @cindex @code{drag-n-drop} event
1375 @item (drag-n-drop @var{position} @var{files})
1376 This kind of event is generated when a group of files is
1377 selected in an application outside of Emacs, and then dragged and
1378 dropped onto an Emacs frame.
1380 The element @var{position} is a list describing the position of the
1381 event, in the same format as used in a mouse-click event, and
1382 @var{files} is the list of file names that were dragged and dropped.
1383 The usual way to handle this event is by visiting these files.
1385 This kind of event is generated, at present, only on some kinds of
1389 If one of these events arrives in the middle of a key sequence---that
1390 is, after a prefix key---then Emacs reorders the events so that this
1391 event comes either before or after the multi-event key sequence, not
1394 @node Event Examples
1395 @subsection Event Examples
1397 If the user presses and releases the left mouse button over the same
1398 location, that generates a sequence of events like this:
1401 (down-mouse-1 (#<window 18 on NEWS> 2613 (0 . 38) -864320))
1402 (mouse-1 (#<window 18 on NEWS> 2613 (0 . 38) -864180))
1405 While holding the control key down, the user might hold down the
1406 second mouse button, and drag the mouse from one line to the next.
1407 That produces two events, as shown here:
1410 (C-down-mouse-2 (#<window 18 on NEWS> 3440 (0 . 27) -731219))
1411 (C-drag-mouse-2 (#<window 18 on NEWS> 3440 (0 . 27) -731219)
1412 (#<window 18 on NEWS> 3510 (0 . 28) -729648))
1415 While holding down the meta and shift keys, the user might press the
1416 second mouse button on the window's mode line, and then drag the mouse
1417 into another window. That produces a pair of events like these:
1420 (M-S-down-mouse-2 (#<window 18 on NEWS> mode-line (33 . 31) -457844))
1421 (M-S-drag-mouse-2 (#<window 18 on NEWS> mode-line (33 . 31) -457844)
1422 (#<window 20 on carlton-sanskrit.tex> 161 (33 . 3)
1426 @node Classifying Events
1427 @subsection Classifying Events
1430 Every event has an @dfn{event type}, which classifies the event for
1431 key binding purposes. For a keyboard event, the event type equals the
1432 event value; thus, the event type for a character is the character, and
1433 the event type for a function key symbol is the symbol itself. For
1434 events that are lists, the event type is the symbol in the @sc{car} of
1435 the list. Thus, the event type is always a symbol or a character.
1437 Two events of the same type are equivalent where key bindings are
1438 concerned; thus, they always run the same command. That does not
1439 necessarily mean they do the same things, however, as some commands look
1440 at the whole event to decide what to do. For example, some commands use
1441 the location of a mouse event to decide where in the buffer to act.
1443 Sometimes broader classifications of events are useful. For example,
1444 you might want to ask whether an event involved the @key{META} key,
1445 regardless of which other key or mouse button was used.
1447 The functions @code{event-modifiers} and @code{event-basic-type} are
1448 provided to get such information conveniently.
1450 @defun event-modifiers event
1451 This function returns a list of the modifiers that @var{event} has. The
1452 modifiers are symbols; they include @code{shift}, @code{control},
1453 @code{meta}, @code{alt}, @code{hyper} and @code{super}. In addition,
1454 the modifiers list of a mouse event symbol always contains one of
1455 @code{click}, @code{drag}, and @code{down}.
1457 The argument @var{event} may be an entire event object, or just an event
1460 Here are some examples:
1463 (event-modifiers ?a)
1465 (event-modifiers ?\C-a)
1467 (event-modifiers ?\C-%)
1469 (event-modifiers ?\C-\S-a)
1470 @result{} (control shift)
1471 (event-modifiers 'f5)
1473 (event-modifiers 's-f5)
1475 (event-modifiers 'M-S-f5)
1476 @result{} (meta shift)
1477 (event-modifiers 'mouse-1)
1479 (event-modifiers 'down-mouse-1)
1483 The modifiers list for a click event explicitly contains @code{click},
1484 but the event symbol name itself does not contain @samp{click}.
1487 @defun event-basic-type event
1488 This function returns the key or mouse button that @var{event}
1489 describes, with all modifiers removed. For example:
1492 (event-basic-type ?a)
1494 (event-basic-type ?A)
1496 (event-basic-type ?\C-a)
1498 (event-basic-type ?\C-\S-a)
1500 (event-basic-type 'f5)
1502 (event-basic-type 's-f5)
1504 (event-basic-type 'M-S-f5)
1506 (event-basic-type 'down-mouse-1)
1511 @defun mouse-movement-p object
1512 This function returns non-@code{nil} if @var{object} is a mouse movement
1516 @defun event-convert-list list
1517 This function converts a list of modifier names and a basic event type
1518 to an event type which specifies all of them. For example,
1521 (event-convert-list '(control ?a))
1523 (event-convert-list '(control meta ?a))
1524 @result{} -134217727
1525 (event-convert-list '(control super f1))
1530 @node Accessing Events
1531 @subsection Accessing Events
1533 This section describes convenient functions for accessing the data in
1534 a mouse button or motion event.
1536 These two functions return the starting or ending position of a
1537 mouse-button event, as a list of this form:
1540 (@var{window} @var{buffer-position} (@var{x} . @var{y}) @var{timestamp})
1543 @defun event-start event
1544 This returns the starting position of @var{event}.
1546 If @var{event} is a click or button-down event, this returns the
1547 location of the event. If @var{event} is a drag event, this returns the
1548 drag's starting position.
1551 @defun event-end event
1552 This returns the ending position of @var{event}.
1554 If @var{event} is a drag event, this returns the position where the user
1555 released the mouse button. If @var{event} is a click or button-down
1556 event, the value is actually the starting position, which is the only
1557 position such events have.
1560 These five functions take a position list as described above, and
1561 return various parts of it.
1563 @defun posn-window position
1564 Return the window that @var{position} is in.
1567 @defun posn-point position
1568 Return the buffer position in @var{position}. This is an integer.
1571 @defun posn-x-y position
1572 Return the pixel-based x and y coordinates in @var{position}, as a cons
1573 cell @code{(@var{x} . @var{y})}.
1576 @defun posn-col-row position
1577 Return the row and column (in units of characters) of @var{position}, as
1578 a cons cell @code{(@var{col} . @var{row})}. These are computed from the
1579 @var{x} and @var{y} values actually found in @var{position}.
1582 @defun posn-timestamp position
1583 Return the timestamp in @var{position}.
1586 These functions are useful for decoding scroll bar events.
1588 @defun scroll-bar-event-ratio event
1589 This function returns the fractional vertical position of a scroll bar
1590 event within the scroll bar. The value is a cons cell
1591 @code{(@var{portion} . @var{whole})} containing two integers whose ratio
1592 is the fractional position.
1595 @defun scroll-bar-scale ratio total
1596 This function multiplies (in effect) @var{ratio} by @var{total},
1597 rounding the result to an integer. The argument @var{ratio} is not a
1598 number, but rather a pair @code{(@var{num} . @var{denom})}---typically a
1599 value returned by @code{scroll-bar-event-ratio}.
1601 This function is handy for scaling a position on a scroll bar into a
1602 buffer position. Here's how to do that:
1607 (posn-x-y (event-start event))
1608 (- (point-max) (point-min))))
1611 Recall that scroll bar events have two integers forming a ratio, in place
1612 of a pair of x and y coordinates.
1615 @node Strings of Events
1616 @subsection Putting Keyboard Events in Strings
1618 In most of the places where strings are used, we conceptualize the
1619 string as containing text characters---the same kind of characters found
1620 in buffers or files. Occasionally Lisp programs use strings that
1621 conceptually contain keyboard characters; for example, they may be key
1622 sequences or keyboard macro definitions. However, storing keyboard
1623 characters in a string is a complex matter, for reasons of historical
1624 compatibility, and it is not always possible.
1626 We recommend that new programs avoid dealing with these complexities
1627 by not storing keyboard events in strings. Here is how to do that:
1631 Use vectors instead of strings for key sequences, when you plan to use
1632 them for anything other than as arguments to @code{lookup-key} and
1633 @code{define-key}. For example, you can use
1634 @code{read-key-sequence-vector} instead of @code{read-key-sequence}, and
1635 @code{this-command-keys-vector} instead of @code{this-command-keys}.
1638 Use vectors to write key sequence constants containing meta characters,
1639 even when passing them directly to @code{define-key}.
1642 When you have to look at the contents of a key sequence that might be a
1643 string, use @code{listify-key-sequence} (@pxref{Event Input Misc})
1644 first, to convert it to a list.
1647 The complexities stem from the modifier bits that keyboard input
1648 characters can include. Aside from the Meta modifier, none of these
1649 modifier bits can be included in a string, and the Meta modifier is
1650 allowed only in special cases.
1652 The earliest GNU Emacs versions represented meta characters as codes
1653 in the range of 128 to 255. At that time, the basic character codes
1654 ranged from 0 to 127, so all keyboard character codes did fit in a
1655 string. Many Lisp programs used @samp{\M-} in string constants to stand
1656 for meta characters, especially in arguments to @code{define-key} and
1657 similar functions, and key sequences and sequences of events were always
1658 represented as strings.
1660 When we added support for larger basic character codes beyond 127, and
1661 additional modifier bits, we had to change the representation of meta
1662 characters. Now the flag that represents the Meta modifier in a
1670 and such numbers cannot be included in a string.
1672 To support programs with @samp{\M-} in string constants, there are
1673 special rules for including certain meta characters in a string.
1674 Here are the rules for interpreting a string as a sequence of input
1679 If the keyboard character value is in the range of 0 to 127, it can go
1680 in the string unchanged.
1683 The meta variants of those characters, with codes in the range of
1692 @math{2^{27} + 127},
1697 can also go in the string, but you must change their
1698 numeric values. You must set the
1712 bit, resulting in a value between 128 and 255. Only a unibyte string
1713 can include these codes.
1716 Non-@sc{ascii} characters above 256 can be included in a multibyte string.
1719 Other keyboard character events cannot fit in a string. This includes
1720 keyboard events in the range of 128 to 255.
1723 Functions such as @code{read-key-sequence} that construct strings of
1724 keyboard input characters follow these rules: they construct vectors
1725 instead of strings, when the events won't fit in a string.
1727 When you use the read syntax @samp{\M-} in a string, it produces a
1728 code in the range of 128 to 255---the same code that you get if you
1729 modify the corresponding keyboard event to put it in the string. Thus,
1730 meta events in strings work consistently regardless of how they get into
1733 However, most programs would do well to avoid these issues by
1734 following the recommendations at the beginning of this section.
1737 @section Reading Input
1739 The editor command loop reads key sequences using the function
1740 @code{read-key-sequence}, which uses @code{read-event}. These and other
1741 functions for event input are also available for use in Lisp programs.
1742 See also @code{momentary-string-display} in @ref{Temporary Displays},
1743 and @code{sit-for} in @ref{Waiting}. @xref{Terminal Input}, for
1744 functions and variables for controlling terminal input modes and
1745 debugging terminal input. @xref{Translating Input}, for features you
1746 can use for translating or modifying input events while reading them.
1748 For higher-level input facilities, see @ref{Minibuffers}.
1751 * Key Sequence Input:: How to read one key sequence.
1752 * Reading One Event:: How to read just one event.
1753 * Invoking the Input Method:: How reading an event uses the input method.
1754 * Quoted Character Input:: Asking the user to specify a character.
1755 * Event Input Misc:: How to reread or throw away input events.
1758 @node Key Sequence Input
1759 @subsection Key Sequence Input
1760 @cindex key sequence input
1762 The command loop reads input a key sequence at a time, by calling
1763 @code{read-key-sequence}. Lisp programs can also call this function;
1764 for example, @code{describe-key} uses it to read the key to describe.
1766 @defun read-key-sequence prompt
1767 @cindex key sequence
1768 This function reads a key sequence and returns it as a string or
1769 vector. It keeps reading events until it has accumulated a complete key
1770 sequence; that is, enough to specify a non-prefix command using the
1771 currently active keymaps.
1773 If the events are all characters and all can fit in a string, then
1774 @code{read-key-sequence} returns a string (@pxref{Strings of Events}).
1775 Otherwise, it returns a vector, since a vector can hold all kinds of
1776 events---characters, symbols, and lists. The elements of the string or
1777 vector are the events in the key sequence.
1779 The argument @var{prompt} is either a string to be displayed in the echo
1780 area as a prompt, or @code{nil}, meaning not to display a prompt.
1782 In the example below, the prompt @samp{?} is displayed in the echo area,
1783 and the user types @kbd{C-x C-f}.
1786 (read-key-sequence "?")
1789 ---------- Echo Area ----------
1791 ---------- Echo Area ----------
1797 The function @code{read-key-sequence} suppresses quitting: @kbd{C-g}
1798 typed while reading with this function works like any other character,
1799 and does not set @code{quit-flag}. @xref{Quitting}.
1802 @defun read-key-sequence-vector prompt
1803 This is like @code{read-key-sequence} except that it always
1804 returns the key sequence as a vector, never as a string.
1805 @xref{Strings of Events}.
1808 @cindex upper case key sequence
1809 @cindex downcasing in @code{lookup-key}
1810 If an input character is an upper-case letter and has no key binding,
1811 but its lower-case equivalent has one, then @code{read-key-sequence}
1812 converts the character to lower case. Note that @code{lookup-key} does
1813 not perform case conversion in this way.
1815 The function @code{read-key-sequence} also transforms some mouse events.
1816 It converts unbound drag events into click events, and discards unbound
1817 button-down events entirely. It also reshuffles focus events and
1818 miscellaneous window events so that they never appear in a key sequence
1819 with any other events.
1821 When mouse events occur in special parts of a window, such as a mode
1822 line or a scroll bar, the event type shows nothing special---it is the
1823 same symbol that would normally represent that combination of mouse
1824 button and modifier keys. The information about the window part is kept
1825 elsewhere in the event---in the coordinates. But
1826 @code{read-key-sequence} translates this information into imaginary
1827 ``prefix keys'', all of which are symbols: @code{mode-line},
1828 @code{vertical-line}, @code{horizontal-scroll-bar} and
1829 @code{vertical-scroll-bar}. You can define meanings for mouse clicks in
1830 special window parts by defining key sequences using these imaginary
1833 For example, if you call @code{read-key-sequence} and then click the
1834 mouse on the window's mode line, you get two events, like this:
1837 (read-key-sequence "Click on the mode line: ")
1838 @result{} [mode-line
1840 (#<window 6 on NEWS> mode-line
1841 (40 . 63) 5959987))]
1844 @defvar num-input-keys
1846 This variable's value is the number of key sequences processed so far in
1847 this Emacs session. This includes key sequences read from the terminal
1848 and key sequences read from keyboard macros being executed.
1851 @defvar num-nonmacro-input-events
1852 @tindex num-nonmacro-input-events
1853 This variable holds the total number of input events received so far
1854 from the terminal---not counting those generated by keyboard macros.
1857 @node Reading One Event
1858 @subsection Reading One Event
1860 The lowest level functions for command input are those that read a
1863 @defun read-event &optional prompt inherit-input-method
1864 This function reads and returns the next event of command input, waiting
1865 if necessary until an event is available. Events can come directly from
1866 the user or from a keyboard macro.
1868 If the optional argument @var{prompt} is non-@code{nil}, it should be a
1869 string to display in the echo area as a prompt. Otherwise,
1870 @code{read-event} does not display any message to indicate it is waiting
1871 for input; instead, it prompts by echoing: it displays descriptions of
1872 the events that led to or were read by the current command. @xref{The
1875 If @var{inherit-input-method} is non-@code{nil}, then the current input
1876 method (if any) is employed to make it possible to enter a
1877 non-@sc{ascii} character. Otherwise, input method handling is disabled
1878 for reading this event.
1880 If @code{cursor-in-echo-area} is non-@code{nil}, then @code{read-event}
1881 moves the cursor temporarily to the echo area, to the end of any message
1882 displayed there. Otherwise @code{read-event} does not move the cursor.
1884 If @code{read-event} gets an event that is defined as a help character, in
1885 some cases @code{read-event} processes the event directly without
1886 returning. @xref{Help Functions}. Certain other events, called
1887 @dfn{special events}, are also processed directly within
1888 @code{read-event} (@pxref{Special Events}).
1890 Here is what happens if you call @code{read-event} and then press the
1891 right-arrow function key:
1901 @defun read-char &optional prompt inherit-input-method
1902 This function reads and returns a character of command input. If the
1903 user generates an event which is not a character (i.e. a mouse click or
1904 function key event), @code{read-char} signals an error. The arguments
1905 work as in @code{read-event}.
1907 In the first example, the user types the character @kbd{1} (@sc{ascii}
1908 code 49). The second example shows a keyboard macro definition that
1909 calls @code{read-char} from the minibuffer using @code{eval-expression}.
1910 @code{read-char} reads the keyboard macro's very next character, which
1911 is @kbd{1}. Then @code{eval-expression} displays its return value in
1921 ;; @r{We assume here you use @kbd{M-:} to evaluate this.}
1922 (symbol-function 'foo)
1923 @result{} "^[:(read-char)^M1"
1926 (execute-kbd-macro 'foo)
1933 @defun read-char-exclusive &optional prompt inherit-input-method
1934 This function reads and returns a character of command input. If the
1935 user generates an event which is not a character,
1936 @code{read-char-exclusive} ignores it and reads another event, until it
1937 gets a character. The arguments work as in @code{read-event}.
1940 @node Invoking the Input Method
1941 @subsection Invoking the Input Method
1943 The event-reading functions invoke the current input method, if any
1944 (@pxref{Input Methods}). If the value of @code{input-method-function}
1945 is non-@code{nil}, it should be a function; when @code{read-event} reads
1946 a printing character (including @key{SPC}) with no modifier bits, it
1947 calls that function, passing the character as an argument.
1949 @defvar input-method-function
1950 If this is non-@code{nil}, its value specifies the current input method
1953 @strong{Note:} Don't bind this variable with @code{let}. It is often
1954 buffer-local, and if you bind it around reading input (which is exactly
1955 when you @emph{would} bind it), switching buffers asynchronously while
1956 Emacs is waiting will cause the value to be restored in the wrong
1960 The input method function should return a list of events which should
1961 be used as input. (If the list is @code{nil}, that means there is no
1962 input, so @code{read-event} waits for another event.) These events are
1963 processed before the events in @code{unread-command-events}. Events
1964 returned by the input method function are not passed to the input method
1965 function again, even if they are printing characters with no modifier
1968 If the input method function calls @code{read-event} or
1969 @code{read-key-sequence}, it should bind @code{input-method-function} to
1970 @code{nil} first, to prevent recursion.
1972 The input method function is not called when reading the second and
1973 subsequent events of a key sequence. Thus, these characters are not
1974 subject to input method processing. The input method function should
1975 test the values of @code{overriding-local-map} and
1976 @code{overriding-terminal-local-map}; if either of these variables is
1977 non-@code{nil}, the input method should put its argument into a list and
1978 return that list with no further processing.
1980 @node Quoted Character Input
1981 @subsection Quoted Character Input
1982 @cindex quoted character input
1984 You can use the function @code{read-quoted-char} to ask the user to
1985 specify a character, and allow the user to specify a control or meta
1986 character conveniently, either literally or as an octal character code.
1987 The command @code{quoted-insert} uses this function.
1989 @defun read-quoted-char &optional prompt
1990 @cindex octal character input
1991 @cindex control characters, reading
1992 @cindex nonprinting characters, reading
1993 This function is like @code{read-char}, except that if the first
1994 character read is an octal digit (0-7), it reads any number of octal
1995 digits (but stopping if a non-octal digit is found), and returns the
1996 character represented by that numeric character code.
1998 Quitting is suppressed when the first character is read, so that the
1999 user can enter a @kbd{C-g}. @xref{Quitting}.
2001 If @var{prompt} is supplied, it specifies a string for prompting the
2002 user. The prompt string is always displayed in the echo area, followed
2003 by a single @samp{-}.
2005 In the following example, the user types in the octal number 177 (which
2009 (read-quoted-char "What character")
2012 ---------- Echo Area ----------
2013 What character-@kbd{177}
2014 ---------- Echo Area ----------
2022 @node Event Input Misc
2023 @subsection Miscellaneous Event Input Features
2025 This section describes how to ``peek ahead'' at events without using
2026 them up, how to check for pending input, and how to discard pending
2027 input. See also the function @code{read-passwd} (@pxref{Reading a
2030 @defvar unread-command-events
2032 @cindex peeking at input
2033 This variable holds a list of events waiting to be read as command
2034 input. The events are used in the order they appear in the list, and
2035 removed one by one as they are used.
2037 The variable is needed because in some cases a function reads an event
2038 and then decides not to use it. Storing the event in this variable
2039 causes it to be processed normally, by the command loop or by the
2040 functions to read command input.
2042 @cindex prefix argument unreading
2043 For example, the function that implements numeric prefix arguments reads
2044 any number of digits. When it finds a non-digit event, it must unread
2045 the event so that it can be read normally by the command loop.
2046 Likewise, incremental search uses this feature to unread events with no
2047 special meaning in a search, because these events should exit the search
2048 and then execute normally.
2050 The reliable and easy way to extract events from a key sequence so as to
2051 put them in @code{unread-command-events} is to use
2052 @code{listify-key-sequence} (@pxref{Strings of Events}).
2054 Normally you add events to the front of this list, so that the events
2055 most recently unread will be reread first.
2058 @defun listify-key-sequence key
2059 This function converts the string or vector @var{key} to a list of
2060 individual events, which you can put in @code{unread-command-events}.
2063 @defvar unread-command-char
2064 This variable holds a character to be read as command input.
2065 A value of -1 means ``empty''.
2067 This variable is mostly obsolete now that you can use
2068 @code{unread-command-events} instead; it exists only to support programs
2069 written for Emacs versions 18 and earlier.
2072 @defun input-pending-p
2073 @cindex waiting for command key input
2074 This function determines whether any command input is currently
2075 available to be read. It returns immediately, with value @code{t} if
2076 there is available input, @code{nil} otherwise. On rare occasions it
2077 may return @code{t} when no input is available.
2080 @defvar last-input-event
2081 @defvarx last-input-char
2082 This variable records the last terminal input event read, whether
2083 as part of a command or explicitly by a Lisp program.
2085 In the example below, the Lisp program reads the character @kbd{1},
2086 @sc{ascii} code 49. It becomes the value of @code{last-input-event},
2087 while @kbd{C-e} (we assume @kbd{C-x C-e} command is used to evaluate
2088 this expression) remains the value of @code{last-command-event}.
2092 (progn (print (read-char))
2093 (print last-command-event)
2101 The alias @code{last-input-char} exists for compatibility with
2105 @defun discard-input
2107 @cindex discard input
2108 @cindex terminate keyboard macro
2109 This function discards the contents of the terminal input buffer and
2110 cancels any keyboard macro that might be in the process of definition.
2111 It returns @code{nil}.
2113 In the following example, the user may type a number of characters right
2114 after starting the evaluation of the form. After the @code{sleep-for}
2115 finishes sleeping, @code{discard-input} discards any characters typed
2119 (progn (sleep-for 2)
2125 @node Special Events
2126 @section Special Events
2128 @cindex special events
2129 Special events are handled at a very low level---as soon as they are
2130 read. The @code{read-event} function processes these events itself, and
2133 Events that are handled in this way do not echo, they are never grouped
2134 into key sequences, and they never appear in the value of
2135 @code{last-command-event} or @code{(this-command-keys)}. They do not
2136 discard a numeric argument, they cannot be unread with
2137 @code{unread-command-events}, they may not appear in a keyboard macro,
2138 and they are not recorded in a keyboard macro while you are defining
2141 These events do, however, appear in @code{last-input-event} immediately
2142 after they are read, and this is the way for the event's definition to
2143 find the actual event.
2145 The events types @code{iconify-frame}, @code{make-frame-visible} and
2146 @code{delete-frame} are normally handled in this way. The keymap which
2147 defines how to handle special events---and which events are special---is
2148 in the variable @code{special-event-map} (@pxref{Active Keymaps}).
2151 @section Waiting for Elapsed Time or Input
2155 The wait functions are designed to wait for a certain amount of time
2156 to pass or until there is input. For example, you may wish to pause in
2157 the middle of a computation to allow the user time to view the display.
2158 @code{sit-for} pauses and updates the screen, and returns immediately if
2159 input comes in, while @code{sleep-for} pauses without updating the
2162 @defun sit-for seconds &optional millisec nodisp
2163 This function performs redisplay (provided there is no pending input
2164 from the user), then waits @var{seconds} seconds, or until input is
2165 available. The value is @code{t} if @code{sit-for} waited the full
2166 time with no input arriving (see @code{input-pending-p} in @ref{Event
2167 Input Misc}). Otherwise, the value is @code{nil}.
2169 The argument @var{seconds} need not be an integer. If it is a floating
2170 point number, @code{sit-for} waits for a fractional number of seconds.
2171 Some systems support only a whole number of seconds; on these systems,
2172 @var{seconds} is rounded down.
2174 The optional argument @var{millisec} specifies an additional waiting
2175 period measured in milliseconds. This adds to the period specified by
2176 @var{seconds}. If the system doesn't support waiting fractions of a
2177 second, you get an error if you specify nonzero @var{millisec}.
2179 The expression @code{(sit-for 0)} is a convenient way to request a
2180 redisplay, without any delay. @xref{Forcing Redisplay}.
2182 If @var{nodisp} is non-@code{nil}, then @code{sit-for} does not
2183 redisplay, but it still returns as soon as input is available (or when
2184 the timeout elapses).
2186 Iconifying or deiconifying a frame makes @code{sit-for} return, because
2187 that generates an event. @xref{Misc Events}.
2189 The usual purpose of @code{sit-for} is to give the user time to read
2190 text that you display.
2193 @defun sleep-for seconds &optional millisec
2194 This function simply pauses for @var{seconds} seconds without updating
2195 the display. It pays no attention to available input. It returns
2198 The argument @var{seconds} need not be an integer. If it is a floating
2199 point number, @code{sleep-for} waits for a fractional number of seconds.
2200 Some systems support only a whole number of seconds; on these systems,
2201 @var{seconds} is rounded down.
2203 The optional argument @var{millisec} specifies an additional waiting
2204 period measured in milliseconds. This adds to the period specified by
2205 @var{seconds}. If the system doesn't support waiting fractions of a
2206 second, you get an error if you specify nonzero @var{millisec}.
2208 Use @code{sleep-for} when you wish to guarantee a delay.
2211 @xref{Time of Day}, for functions to get the current time.
2218 Typing @kbd{C-g} while a Lisp function is running causes Emacs to
2219 @dfn{quit} whatever it is doing. This means that control returns to the
2220 innermost active command loop.
2222 Typing @kbd{C-g} while the command loop is waiting for keyboard input
2223 does not cause a quit; it acts as an ordinary input character. In the
2224 simplest case, you cannot tell the difference, because @kbd{C-g}
2225 normally runs the command @code{keyboard-quit}, whose effect is to quit.
2226 However, when @kbd{C-g} follows a prefix key, they combine to form an
2227 undefined key. The effect is to cancel the prefix key as well as any
2230 In the minibuffer, @kbd{C-g} has a different definition: it aborts out
2231 of the minibuffer. This means, in effect, that it exits the minibuffer
2232 and then quits. (Simply quitting would return to the command loop
2233 @emph{within} the minibuffer.) The reason why @kbd{C-g} does not quit
2234 directly when the command reader is reading input is so that its meaning
2235 can be redefined in the minibuffer in this way. @kbd{C-g} following a
2236 prefix key is not redefined in the minibuffer, and it has its normal
2237 effect of canceling the prefix key and prefix argument. This too
2238 would not be possible if @kbd{C-g} always quit directly.
2240 When @kbd{C-g} does directly quit, it does so by setting the variable
2241 @code{quit-flag} to @code{t}. Emacs checks this variable at appropriate
2242 times and quits if it is not @code{nil}. Setting @code{quit-flag}
2243 non-@code{nil} in any way thus causes a quit.
2245 At the level of C code, quitting cannot happen just anywhere; only at the
2246 special places that check @code{quit-flag}. The reason for this is
2247 that quitting at other places might leave an inconsistency in Emacs's
2248 internal state. Because quitting is delayed until a safe place, quitting
2249 cannot make Emacs crash.
2251 Certain functions such as @code{read-key-sequence} or
2252 @code{read-quoted-char} prevent quitting entirely even though they wait
2253 for input. Instead of quitting, @kbd{C-g} serves as the requested
2254 input. In the case of @code{read-key-sequence}, this serves to bring
2255 about the special behavior of @kbd{C-g} in the command loop. In the
2256 case of @code{read-quoted-char}, this is so that @kbd{C-q} can be used
2257 to quote a @kbd{C-g}.
2259 You can prevent quitting for a portion of a Lisp function by binding
2260 the variable @code{inhibit-quit} to a non-@code{nil} value. Then,
2261 although @kbd{C-g} still sets @code{quit-flag} to @code{t} as usual, the
2262 usual result of this---a quit---is prevented. Eventually,
2263 @code{inhibit-quit} will become @code{nil} again, such as when its
2264 binding is unwound at the end of a @code{let} form. At that time, if
2265 @code{quit-flag} is still non-@code{nil}, the requested quit happens
2266 immediately. This behavior is ideal when you wish to make sure that
2267 quitting does not happen within a ``critical section'' of the program.
2269 @cindex @code{read-quoted-char} quitting
2270 In some functions (such as @code{read-quoted-char}), @kbd{C-g} is
2271 handled in a special way that does not involve quitting. This is done
2272 by reading the input with @code{inhibit-quit} bound to @code{t}, and
2273 setting @code{quit-flag} to @code{nil} before @code{inhibit-quit}
2274 becomes @code{nil} again. This excerpt from the definition of
2275 @code{read-quoted-char} shows how this is done; it also shows that
2276 normal quitting is permitted after the first character of input.
2279 (defun read-quoted-char (&optional prompt)
2280 "@dots{}@var{documentation}@dots{}"
2281 (let ((message-log-max nil) done (first t) (code 0) char)
2283 (let ((inhibit-quit first)
2285 (and prompt (message "%s-" prompt))
2286 (setq char (read-event))
2287 (if inhibit-quit (setq quit-flag nil)))
2288 @r{@dots{}set the variable @code{code}@dots{}})
2293 If this variable is non-@code{nil}, then Emacs quits immediately, unless
2294 @code{inhibit-quit} is non-@code{nil}. Typing @kbd{C-g} ordinarily sets
2295 @code{quit-flag} non-@code{nil}, regardless of @code{inhibit-quit}.
2298 @defvar inhibit-quit
2299 This variable determines whether Emacs should quit when @code{quit-flag}
2300 is set to a value other than @code{nil}. If @code{inhibit-quit} is
2301 non-@code{nil}, then @code{quit-flag} has no special effect.
2304 @deffn Command keyboard-quit
2305 This function signals the @code{quit} condition with @code{(signal 'quit
2306 nil)}. This is the same thing that quitting does. (See @code{signal}
2310 You can specify a character other than @kbd{C-g} to use for quitting.
2311 See the function @code{set-input-mode} in @ref{Terminal Input}.
2313 @node Prefix Command Arguments
2314 @section Prefix Command Arguments
2315 @cindex prefix argument
2316 @cindex raw prefix argument
2317 @cindex numeric prefix argument
2319 Most Emacs commands can use a @dfn{prefix argument}, a number
2320 specified before the command itself. (Don't confuse prefix arguments
2321 with prefix keys.) The prefix argument is at all times represented by a
2322 value, which may be @code{nil}, meaning there is currently no prefix
2323 argument. Each command may use the prefix argument or ignore it.
2325 There are two representations of the prefix argument: @dfn{raw} and
2326 @dfn{numeric}. The editor command loop uses the raw representation
2327 internally, and so do the Lisp variables that store the information, but
2328 commands can request either representation.
2330 Here are the possible values of a raw prefix argument:
2334 @code{nil}, meaning there is no prefix argument. Its numeric value is
2335 1, but numerous commands make a distinction between @code{nil} and the
2339 An integer, which stands for itself.
2342 A list of one element, which is an integer. This form of prefix
2343 argument results from one or a succession of @kbd{C-u}'s with no
2344 digits. The numeric value is the integer in the list, but some
2345 commands make a distinction between such a list and an integer alone.
2348 The symbol @code{-}. This indicates that @kbd{M--} or @kbd{C-u -} was
2349 typed, without following digits. The equivalent numeric value is
2350 @minus{}1, but some commands make a distinction between the integer
2351 @minus{}1 and the symbol @code{-}.
2354 We illustrate these possibilities by calling the following function with
2359 (defun display-prefix (arg)
2360 "Display the value of the raw prefix arg."
2367 Here are the results of calling @code{display-prefix} with various
2368 raw prefix arguments:
2371 M-x display-prefix @print{} nil
2373 C-u M-x display-prefix @print{} (4)
2375 C-u C-u M-x display-prefix @print{} (16)
2377 C-u 3 M-x display-prefix @print{} 3
2379 M-3 M-x display-prefix @print{} 3 ; @r{(Same as @code{C-u 3}.)}
2381 C-u - M-x display-prefix @print{} -
2383 M-- M-x display-prefix @print{} - ; @r{(Same as @code{C-u -}.)}
2385 C-u - 7 M-x display-prefix @print{} -7
2387 M-- 7 M-x display-prefix @print{} -7 ; @r{(Same as @code{C-u -7}.)}
2390 Emacs uses two variables to store the prefix argument:
2391 @code{prefix-arg} and @code{current-prefix-arg}. Commands such as
2392 @code{universal-argument} that set up prefix arguments for other
2393 commands store them in @code{prefix-arg}. In contrast,
2394 @code{current-prefix-arg} conveys the prefix argument to the current
2395 command, so setting it has no effect on the prefix arguments for future
2398 Normally, commands specify which representation to use for the prefix
2399 argument, either numeric or raw, in the @code{interactive} declaration.
2400 (@xref{Using Interactive}.) Alternatively, functions may look at the
2401 value of the prefix argument directly in the variable
2402 @code{current-prefix-arg}, but this is less clean.
2404 @defun prefix-numeric-value arg
2405 This function returns the numeric meaning of a valid raw prefix argument
2406 value, @var{arg}. The argument may be a symbol, a number, or a list.
2407 If it is @code{nil}, the value 1 is returned; if it is @code{-}, the
2408 value @minus{}1 is returned; if it is a number, that number is returned;
2409 if it is a list, the @sc{car} of that list (which should be a number) is
2413 @defvar current-prefix-arg
2414 This variable holds the raw prefix argument for the @emph{current}
2415 command. Commands may examine it directly, but the usual method for
2416 accessing it is with @code{(interactive "P")}.
2420 The value of this variable is the raw prefix argument for the
2421 @emph{next} editing command. Commands such as @code{universal-argument}
2422 that specify prefix arguments for the following command work by setting
2426 @tindex last-prefix-arg
2427 @defvar last-prefix-arg
2428 The raw prefix argument value used by the previous command.
2431 The following commands exist to set up prefix arguments for the
2432 following command. Do not call them for any other reason.
2434 @deffn Command universal-argument
2435 This command reads input and specifies a prefix argument for the
2436 following command. Don't call this command yourself unless you know
2440 @deffn Command digit-argument arg
2441 This command adds to the prefix argument for the following command. The
2442 argument @var{arg} is the raw prefix argument as it was before this
2443 command; it is used to compute the updated prefix argument. Don't call
2444 this command yourself unless you know what you are doing.
2447 @deffn Command negative-argument arg
2448 This command adds to the numeric argument for the next command. The
2449 argument @var{arg} is the raw prefix argument as it was before this
2450 command; its value is negated to form the new prefix argument. Don't
2451 call this command yourself unless you know what you are doing.
2454 @node Recursive Editing
2455 @section Recursive Editing
2456 @cindex recursive command loop
2457 @cindex recursive editing level
2458 @cindex command loop, recursive
2460 The Emacs command loop is entered automatically when Emacs starts up.
2461 This top-level invocation of the command loop never exits; it keeps
2462 running as long as Emacs does. Lisp programs can also invoke the
2463 command loop. Since this makes more than one activation of the command
2464 loop, we call it @dfn{recursive editing}. A recursive editing level has
2465 the effect of suspending whatever command invoked it and permitting the
2466 user to do arbitrary editing before resuming that command.
2468 The commands available during recursive editing are the same ones
2469 available in the top-level editing loop and defined in the keymaps.
2470 Only a few special commands exit the recursive editing level; the others
2471 return to the recursive editing level when they finish. (The special
2472 commands for exiting are always available, but they do nothing when
2473 recursive editing is not in progress.)
2475 All command loops, including recursive ones, set up all-purpose error
2476 handlers so that an error in a command run from the command loop will
2479 @cindex minibuffer input
2480 Minibuffer input is a special kind of recursive editing. It has a few
2481 special wrinkles, such as enabling display of the minibuffer and the
2482 minibuffer window, but fewer than you might suppose. Certain keys
2483 behave differently in the minibuffer, but that is only because of the
2484 minibuffer's local map; if you switch windows, you get the usual Emacs
2487 @cindex @code{throw} example
2489 @cindex exit recursive editing
2491 To invoke a recursive editing level, call the function
2492 @code{recursive-edit}. This function contains the command loop; it also
2493 contains a call to @code{catch} with tag @code{exit}, which makes it
2494 possible to exit the recursive editing level by throwing to @code{exit}
2495 (@pxref{Catch and Throw}). If you throw a value other than @code{t},
2496 then @code{recursive-edit} returns normally to the function that called
2497 it. The command @kbd{C-M-c} (@code{exit-recursive-edit}) does this.
2498 Throwing a @code{t} value causes @code{recursive-edit} to quit, so that
2499 control returns to the command loop one level up. This is called
2500 @dfn{aborting}, and is done by @kbd{C-]} (@code{abort-recursive-edit}).
2502 Most applications should not use recursive editing, except as part of
2503 using the minibuffer. Usually it is more convenient for the user if you
2504 change the major mode of the current buffer temporarily to a special
2505 major mode, which should have a command to go back to the previous mode.
2506 (The @kbd{e} command in Rmail uses this technique.) Or, if you wish to
2507 give the user different text to edit ``recursively'', create and select
2508 a new buffer in a special mode. In this mode, define a command to
2509 complete the processing and go back to the previous buffer. (The
2510 @kbd{m} command in Rmail does this.)
2512 Recursive edits are useful in debugging. You can insert a call to
2513 @code{debug} into a function definition as a sort of breakpoint, so that
2514 you can look around when the function gets there. @code{debug} invokes
2515 a recursive edit but also provides the other features of the debugger.
2517 Recursive editing levels are also used when you type @kbd{C-r} in
2518 @code{query-replace} or use @kbd{C-x q} (@code{kbd-macro-query}).
2520 @defun recursive-edit
2521 @cindex suspend evaluation
2522 This function invokes the editor command loop. It is called
2523 automatically by the initialization of Emacs, to let the user begin
2524 editing. When called from a Lisp program, it enters a recursive editing
2527 In the following example, the function @code{simple-rec} first
2528 advances point one word, then enters a recursive edit, printing out a
2529 message in the echo area. The user can then do any editing desired, and
2530 then type @kbd{C-M-c} to exit and continue executing @code{simple-rec}.
2533 (defun simple-rec ()
2535 (message "Recursive edit in progress")
2538 @result{} simple-rec
2544 @deffn Command exit-recursive-edit
2545 This function exits from the innermost recursive edit (including
2546 minibuffer input). Its definition is effectively @code{(throw 'exit
2550 @deffn Command abort-recursive-edit
2551 This function aborts the command that requested the innermost recursive
2552 edit (including minibuffer input), by signaling @code{quit}
2553 after exiting the recursive edit. Its definition is effectively
2554 @code{(throw 'exit t)}. @xref{Quitting}.
2557 @deffn Command top-level
2558 This function exits all recursive editing levels; it does not return a
2559 value, as it jumps completely out of any computation directly back to
2560 the main command loop.
2563 @defun recursion-depth
2564 This function returns the current depth of recursive edits. When no
2565 recursive edit is active, it returns 0.
2568 @node Disabling Commands
2569 @section Disabling Commands
2570 @cindex disabled command
2572 @dfn{Disabling a command} marks the command as requiring user
2573 confirmation before it can be executed. Disabling is used for commands
2574 which might be confusing to beginning users, to prevent them from using
2575 the commands by accident.
2578 The low-level mechanism for disabling a command is to put a
2579 non-@code{nil} @code{disabled} property on the Lisp symbol for the
2580 command. These properties are normally set up by the user's
2581 init file (@pxref{Init File}) with Lisp expressions such as this:
2584 (put 'upcase-region 'disabled t)
2588 For a few commands, these properties are present by default (you can
2589 remove them in your init file if you wish).
2591 If the value of the @code{disabled} property is a string, the message
2592 saying the command is disabled includes that string. For example:
2595 (put 'delete-region 'disabled
2596 "Text deleted this way cannot be yanked back!\n")
2599 @xref{Disabling,,, emacs, The GNU Emacs Manual}, for the details on
2600 what happens when a disabled command is invoked interactively.
2601 Disabling a command has no effect on calling it as a function from Lisp
2604 @deffn Command enable-command command
2605 Allow @var{command} to be executed without special confirmation from now
2606 on, and (if the user confirms) alter the user's init file (@pxref{Init
2607 File}) so that this will apply to future sessions.
2610 @deffn Command disable-command command
2611 Require special confirmation to execute @var{command} from now on, and
2612 (if the user confirms) alter the user's init file so that this
2613 will apply to future sessions.
2616 @defvar disabled-command-hook
2617 When the user invokes a disabled command interactively, this normal hook
2618 is run instead of the disabled command. The hook functions can use
2619 @code{this-command-keys} to determine what the user typed to run the
2620 command, and thus find the command itself. @xref{Hooks}.
2622 By default, @code{disabled-command-hook} contains a function that asks
2623 the user whether to proceed.
2626 @node Command History
2627 @section Command History
2628 @cindex command history
2629 @cindex complex command
2630 @cindex history of commands
2632 The command loop keeps a history of the complex commands that have
2633 been executed, to make it convenient to repeat these commands. A
2634 @dfn{complex command} is one for which the interactive argument reading
2635 uses the minibuffer. This includes any @kbd{M-x} command, any
2636 @kbd{M-:} command, and any command whose @code{interactive}
2637 specification reads an argument from the minibuffer. Explicit use of
2638 the minibuffer during the execution of the command itself does not cause
2639 the command to be considered complex.
2641 @defvar command-history
2642 This variable's value is a list of recent complex commands, each
2643 represented as a form to evaluate. It continues to accumulate all
2644 complex commands for the duration of the editing session, but when it
2645 reaches the maximum size (specified by the variable
2646 @code{history-length}), the oldest elements are deleted as new ones are
2652 @result{} ((switch-to-buffer "chistory.texi")
2653 (describe-key "^X^[")
2654 (visit-tags-table "~/emacs/src/")
2655 (find-tag "repeat-complex-command"))
2660 This history list is actually a special case of minibuffer history
2661 (@pxref{Minibuffer History}), with one special twist: the elements are
2662 expressions rather than strings.
2664 There are a number of commands devoted to the editing and recall of
2665 previous commands. The commands @code{repeat-complex-command}, and
2666 @code{list-command-history} are described in the user manual
2667 (@pxref{Repetition,,, emacs, The GNU Emacs Manual}). Within the
2668 minibuffer, the usual minibuffer history commands are available.
2670 @node Keyboard Macros
2671 @section Keyboard Macros
2672 @cindex keyboard macros
2674 A @dfn{keyboard macro} is a canned sequence of input events that can
2675 be considered a command and made the definition of a key. The Lisp
2676 representation of a keyboard macro is a string or vector containing the
2677 events. Don't confuse keyboard macros with Lisp macros
2680 @defun execute-kbd-macro kbdmacro &optional count
2681 This function executes @var{kbdmacro} as a sequence of events. If
2682 @var{kbdmacro} is a string or vector, then the events in it are executed
2683 exactly as if they had been input by the user. The sequence is
2684 @emph{not} expected to be a single key sequence; normally a keyboard
2685 macro definition consists of several key sequences concatenated.
2687 If @var{kbdmacro} is a symbol, then its function definition is used in
2688 place of @var{kbdmacro}. If that is another symbol, this process repeats.
2689 Eventually the result should be a string or vector. If the result is
2690 not a symbol, string, or vector, an error is signaled.
2692 The argument @var{count} is a repeat count; @var{kbdmacro} is executed that
2693 many times. If @var{count} is omitted or @code{nil}, @var{kbdmacro} is
2694 executed once. If it is 0, @var{kbdmacro} is executed over and over until it
2695 encounters an error or a failing search.
2697 @xref{Reading One Event}, for an example of using @code{execute-kbd-macro}.
2700 @defvar executing-macro
2701 This variable contains the string or vector that defines the keyboard
2702 macro that is currently executing. It is @code{nil} if no macro is
2703 currently executing. A command can test this variable so as to behave
2704 differently when run from an executing macro. Do not set this variable
2708 @defvar defining-kbd-macro
2709 This variable indicates whether a keyboard macro is being defined. A
2710 command can test this variable so as to behave differently while a macro
2711 is being defined. The commands @code{start-kbd-macro} and
2712 @code{end-kbd-macro} set this variable---do not set it yourself.
2714 The variable is always local to the current terminal and cannot be
2715 buffer-local. @xref{Multiple Displays}.
2718 @defvar last-kbd-macro
2719 This variable is the definition of the most recently defined keyboard
2720 macro. Its value is a string or vector, or @code{nil}.
2722 The variable is always local to the current terminal and cannot be
2723 buffer-local. @xref{Multiple Displays}.