[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
When you run Emacs, it enters the editor command loop almost immediately. This loop reads key sequences, executes their definitions, and displays the results. In this chapter, we describe how these things are done, and the subroutines that allow Lisp programs to do them.
21.1 Command Loop Overview | How the command loop reads commands. | |
21.2 Defining Commands | Specifying how a function should read arguments. | |
21.3 Interactive Call | Calling a command, so that it will read arguments. | |
21.4 Information from the Command Loop | Variables set by the command loop for you to examine. | |
21.5 Adjusting Point After Commands | Adjustment of point after a command. | |
21.6 Input Events | What input looks like when you read it. | |
21.7 Reading Input | How to read input events from the keyboard or mouse. | |
21.8 Special Events | Events processed immediately and individually. | |
21.9 Waiting for Elapsed Time or Input | Waiting for user input or elapsed time. | |
21.10 Quitting | How C-g works. How to catch or defer quitting. | |
21.11 Prefix Command Arguments | How the commands to set prefix args work. | |
21.12 Recursive Editing | Entering a recursive edit, and why you usually shouldn’t. | |
21.13 Disabling Commands | How the command loop handles disabled commands. | |
21.14 Command History | How the command history is set up, and how accessed. | |
21.15 Keyboard Macros | How keyboard macros are implemented. |
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
The first thing the command loop must do is read a key sequence, which
is a sequence of events that translates into a command. It does this by
calling the function read-key-sequence
. Your Lisp code can also
call this function (see section Key Sequence Input). Lisp programs can also
do input at a lower level with read-event
(see section Reading One Event) or discard pending input with discard-input
(see section Miscellaneous Event Input Features).
The key sequence is translated into a command through the currently
active keymaps. See section Key Lookup, for information on how this is done.
The result should be a keyboard macro or an interactively callable
function. If the key is M-x, then it reads the name of another
command, which it then calls. This is done by the command
execute-extended-command
(see section Interactive Call).
To execute a command requires first reading the arguments for it.
This is done by calling command-execute
(see section Interactive Call). For commands written in Lisp, the interactive
specification says how to read the arguments. This may use the prefix
argument (see section Prefix Command Arguments) or may read with prompting
in the minibuffer (see section Minibuffers). For example, the command
find-file
has an interactive
specification which says to
read a file name using the minibuffer. The command’s function body does
not use the minibuffer; if you call this command from Lisp code as a
function, you must supply the file name string as an ordinary Lisp
function argument.
If the command is a string or vector (i.e., a keyboard macro) then
execute-kbd-macro
is used to execute it. You can call this
function yourself (see section Keyboard Macros).
To terminate the execution of a running command, type C-g. This character causes quitting (see section Quitting).
The editor command loop runs this normal hook before each command. At
that time, this-command
contains the command that is about to
run, and last-command
describes the previous command.
See section Hooks.
The editor command loop runs this normal hook after each command
(including commands terminated prematurely by quitting or by errors),
and also when the command loop is first entered. At that time,
this-command
describes the command that just ran, and
last-command
describes the command before that. See section Hooks.
Quitting is suppressed while running pre-command-hook
and
post-command-hook
. If an error happens while executing one of
these hooks, it terminates execution of the hook, and clears the hook
variable to nil
so as to prevent an infinite loop of errors.
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
A Lisp function becomes a command when its body contains, at top
level, a form that calls the special form interactive
. This
form does nothing when actually executed, but its presence serves as a
flag to indicate that interactive calling is permitted. Its argument
controls the reading of arguments for an interactive call.
21.2.1 Using interactive | General rules for interactive .
| |
21.2.2 Code Characters for interactive | The standard letter-codes for reading arguments in various ways. | |
21.2.3 Examples of Using interactive | Examples of how to read interactive arguments. |
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
interactive
This section describes how to write the interactive
form that
makes a Lisp function an interactively-callable command, and how to
examine a commands’s interactive
form.
This special form declares that the function in which it appears is a command, and that it may therefore be called interactively (via M-x or by entering a key sequence bound to it). The argument arg-descriptor declares how to compute the arguments to the command when the command is called interactively.
A command may be called from Lisp programs like any other function, but then the caller supplies the arguments and arg-descriptor has no effect.
The interactive
form has its effect because the command loop
(actually, its subroutine call-interactively
) scans through the
function definition looking for it, before calling the function. Once
the function is called, all its body forms including the
interactive
form are executed, but at this time
interactive
simply returns nil
without even evaluating its
argument.
There are three possibilities for the argument arg-descriptor:
nil
; then the command is called with no
arguments. This leads quickly to an error if the command requires one
or more arguments.
If this expression reads keyboard input (this includes using the minibuffer), keep in mind that the integer value of point or the mark before reading input may be incorrect after reading input. This is because the current buffer may be receiving subprocess output; if subprocess output arrives while the command is waiting for input, it could relocate point and the mark.
Here’s an example of what not to do:
(interactive (list (region-beginning) (region-end) (read-string "Foo: " nil 'my-history))) |
Here’s how to avoid the problem, by examining point and the mark only after reading the keyboard input:
(interactive (let ((string (read-string "Foo: " nil 'my-history))) (list (region-beginning) (region-end) string))) |
(interactive "bFrobnicate buffer: ") |
The code letter ‘b’ says to read the name of an existing buffer, with completion. The buffer name is the sole argument passed to the command. The rest of the string is a prompt.
If there is a newline character in the string, it terminates the prompt. If the string does not end there, then the rest of the string should contain another code character and prompt, specifying another argument. You can specify any number of arguments in this way.
The prompt string can use ‘%’ to include previous argument values
(starting with the first argument) in the prompt. This is done using
format
(see section Formatting Strings). For example, here is how
you could read the name of an existing buffer followed by a new name to
give to that buffer:
(interactive "bBuffer to rename: \nsRename buffer %s to: ") |
If the first character in the string is ‘*’, then an error is signaled if the buffer is read-only.
If the first character in the string is ‘@’, and if the key sequence used to invoke the command includes any mouse events, then the window associated with the first of those events is selected before the command is run.
You can use ‘*’ and ‘@’ together; the order does not matter. Actual reading of arguments is controlled by the rest of the prompt string (starting with the first character that is not ‘*’ or ‘@’).
This function returns the interactive
form of function. If
function is a command (see section Interactive Call), the value is a
list of the form (interactive spec)
, where spec is
the descriptor specification used by the command’s interactive
form to compute the function’s arguments (see section Using interactive
).
If function is not a command, interactive-form
returns
nil
.
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
interactive
The code character descriptions below contain a number of key words, defined here as follows:
Provide completion. <TAB>, <SPC>, and <RET> perform name
completion because the argument is read using completing-read
(see section Completion). ? displays a list of possible completions.
Require the name of an existing object. An invalid name is not accepted; the commands to exit the minibuffer do not exit if the current input is not valid.
A default value of some sort is used if the user enters no text in the minibuffer. The default depends on the code character.
This code letter computes an argument without reading any input. Therefore, it does not use a prompt string, and any prompt string you supply is ignored.
Even though the code letter doesn’t use a prompt string, you must follow it with a newline if it is not the last code character in the string.
A prompt immediately follows the code character. The prompt ends either with the end of the string or with a newline.
This code character is meaningful only at the beginning of the interactive string, and it does not look for a prompt or a newline. It is a single, isolated character.
Here are the code character descriptions for use with interactive
:
Signal an error if the current buffer is read-only. Special.
Select the window mentioned in the first mouse event in the key sequence that invoked this command. Special.
A function name (i.e., a symbol satisfying fboundp
). Existing,
Completion, Prompt.
The name of an existing buffer. By default, uses the name of the current buffer (see section Buffers). Existing, Completion, Default, Prompt.
A buffer name. The buffer need not exist. By default, uses the name of a recently used buffer other than the current buffer. Completion, Default, Prompt.
A character. The cursor does not move into the echo area. Prompt.
A command name (i.e., a symbol satisfying commandp
). Existing,
Completion, Prompt.
The position of point, as an integer (see section Point). No I/O.
A directory name. The default is the current default directory of the
current buffer, default-directory
(see section Operating System Environment).
Existing, Completion, Default, Prompt.
The first or next mouse event in the key sequence that invoked the command. More precisely, ‘e’ gets events that are lists, so you can look at the data in the lists. See section Input Events. No I/O.
You can use ‘e’ more than once in a single command’s interactive specification. If the key sequence that invoked the command has n events that are lists, the nth ‘e’ provides the nth such event. Events that are not lists, such as function keys and ASCII characters, do not count where ‘e’ is concerned.
A file name of an existing file (see section File Names). The default
directory is default-directory
. Existing, Completion, Default,
Prompt.
A file name. The file need not exist. Completion, Default, Prompt.
An irrelevant argument. This code always supplies nil
as
the argument’s value. No I/O.
A key sequence (see section Keymap Terminology). This keeps reading events until a command (or undefined command) is found in the current key maps. The key sequence argument is represented as a string or vector. The cursor does not move into the echo area. Prompt.
This kind of input is used by commands such as describe-key
and
global-set-key
.
A key sequence, whose definition you intend to change. This works like ‘k’, except that it suppresses, for the last input event in the key sequence, the conversions that are normally used (when necessary) to convert an undefined key into a defined one.
The position of the mark, as an integer. No I/O.
Arbitrary text, read in the minibuffer using the current buffer’s input method, and returned as a string (see (emacs)Input Methods section ‘Input Methods’ in The GNU Emacs Manual). Prompt.
A number read with the minibuffer. If the input is not a number, the user is asked to try again. The prefix argument, if any, is not used. Prompt.
The numeric prefix argument; but if there is no prefix argument, read a number as with n. Requires a number. See section Prefix Command Arguments. Prompt.
The numeric prefix argument. (Note that this ‘p’ is lower case.) No I/O.
The raw prefix argument. (Note that this ‘P’ is upper case.) No I/O.
Point and the mark, as two numeric arguments, smallest first. This is the only code letter that specifies two successive arguments rather than one. No I/O.
Arbitrary text, read in the minibuffer and returned as a string (see section Reading Text Strings with the Minibuffer). Terminate the input with either C-j or <RET>. (C-q may be used to include either of these characters in the input.) Prompt.
An interned symbol whose name is read in the minibuffer. Any whitespace character terminates the input. (Use C-q to include whitespace in the string.) Other characters that normally terminate a symbol (e.g., parentheses and brackets) do not do so here. Prompt.
A variable declared to be a user option (i.e., satisfying the predicate
user-variable-p
). See section High-Level Completion Functions. Existing,
Completion, Prompt.
A Lisp object, specified with its read syntax, terminated with a C-j or <RET>. The object is not evaluated. See section Reading Lisp Objects with the Minibuffer. Prompt.
A Lisp form is read as with x, but then evaluated so that its value becomes the argument for the command. Prompt.
A coding system name (a symbol). If the user enters null input, the
argument value is nil
. See section Coding Systems. Completion,
Existing, Prompt.
A coding system name (a symbol)—but only if this command has a prefix
argument. With no prefix argument, ‘Z’ provides nil
as the
argument value. Completion, Existing, Prompt.
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
interactive
Here are some examples of interactive
:
(defun foo1 () ; (defun foo2 (n) ; (defun foo3 (n) ; (defun three-b (b1 b2 b3) "Select three existing buffers. Put them into three windows, selecting the last one." (interactive "bBuffer1:\nbBuffer2:\nbBuffer3:") (delete-other-windows) (split-window (selected-window) 8) (switch-to-buffer b1) (other-window 1) (split-window (selected-window) 8) (switch-to-buffer b2) (other-window 1) (switch-to-buffer b3)) ⇒ three-b (three-b "*scratch*" "declarations.texi" "*mail*") ⇒ nil |
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
After the command loop has translated a key sequence into a command it
invokes that command using the function command-execute
. If the
command is a function, command-execute
calls
call-interactively
, which reads the arguments and calls the
command. You can also call these functions yourself.
Returns t
if object is suitable for calling interactively;
that is, if object is a command. Otherwise, returns nil
.
The interactively callable objects include strings and vectors (treated
as keyboard macros), lambda expressions that contain a top-level call to
interactive
, byte-code function objects made from such lambda
expressions, autoload objects that are declared as interactive
(non-nil
fourth argument to autoload
), and some of the
primitive functions.
A symbol satisfies commandp
if its function definition satisfies
commandp
.
Keys and keymaps are not commands. Rather, they are used to look up commands (see section Keymaps).
See documentation
in Access to Documentation Strings, for a
realistic example of using commandp
.
This function calls the interactively callable function command, reading arguments according to its interactive calling specifications. An error is signaled if command is not a function or if it cannot be called interactively (i.e., is not a command). Note that keyboard macros (strings and vectors) are not accepted, even though they are considered commands, because they are not functions.
If record-flag is non-nil
, then this command and its
arguments are unconditionally added to the list command-history
.
Otherwise, the command is added only if it uses the minibuffer to read
an argument. See section Command History.
The argument keys, if given, specifies the sequence of events to supply if the command inquires which events were used to invoke it.
This function executes command. The argument command must
satisfy the commandp
predicate; i.e., it must be an interactively
callable function or a keyboard macro.
A string or vector as command is executed with
execute-kbd-macro
. A function is passed to
call-interactively
, along with the optional record-flag.
A symbol is handled by using its function definition in its place. A
symbol with an autoload
definition counts as a command if it was
declared to stand for an interactively callable function. Such a
definition is handled by loading the specified library and then
rechecking the definition of the symbol.
The argument keys, if given, specifies the sequence of events to supply if the command inquires which events were used to invoke it.
The argument special, if given, means to ignore the prefix argument and not clear it. This is used for executing special events (see section Special Events).
This function reads a command name from the minibuffer using
completing-read
(see section Completion). Then it uses
command-execute
to call the specified command. Whatever that
command returns becomes the value of execute-extended-command
.
If the command asks for a prefix argument, it receives the value
prefix-argument. If execute-extended-command
is called
interactively, the current raw prefix argument is used for
prefix-argument, and thus passed on to whatever command is run.
execute-extended-command
is the normal definition of M-x,
so it uses the string ‘M-x ’ as a prompt. (It would be better
to take the prompt from the events used to invoke
execute-extended-command
, but that is painful to implement.) A
description of the value of the prefix argument, if any, also becomes
part of the prompt.
(execute-extended-command 1) ---------- Buffer: Minibuffer ---------- 1 M-x forward-word RET ---------- Buffer: Minibuffer ---------- ⇒ t |
This function returns t
if the containing function (the one whose
code includes the call to interactive-p
) was called
interactively, with the function call-interactively
. (It makes
no difference whether call-interactively
was called from Lisp or
directly from the editor command loop.) If the containing function was
called by Lisp evaluation (or with apply
or funcall
), then
it was not called interactively.
The most common use of interactive-p
is for deciding whether to
print an informative message. As a special exception,
interactive-p
returns nil
whenever a keyboard macro is
being run. This is to suppress the informative messages and speed
execution of the macro.
For example:
(defun foo () (interactive) (when (interactive-p) (message "foo"))) ⇒ foo (defun bar () (interactive) (setq foobar (list (foo) (interactive-p)))) ⇒ bar ;; Type M-x foo.
-| foo
;; Type M-x bar. ;; This does not print anything. foobar ⇒ (nil t) |
The other way to do this sort of job is to make the command take an
argument print-message
which should be non-nil
in an
interactive call, and use the interactive
spec to make sure it is
non-nil
. Here’s how:
(defun foo (&optional print-message) (interactive "p") (when print-message (message "foo"))) |
The numeric prefix argument, provided by ‘p’, is never nil
.
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
The editor command loop sets several Lisp variables to keep status records for itself and for commands that are run.
This variable records the name of the previous command executed by the command loop (the one before the current command). Normally the value is a symbol with a function definition, but this is not guaranteed.
The value is copied from this-command
when a command returns to
the command loop, except when the command has specified a prefix
argument for the following command.
This variable is always local to the current terminal and cannot be buffer-local. See section Multiple Displays.
This variable is set up by Emacs just like last-command
,
but never altered by Lisp programs.
This variable records the name of the command now being executed by
the editor command loop. Like last-command
, it is normally a symbol
with a function definition.
The command loop sets this variable just before running a command, and
copies its value into last-command
when the command finishes
(unless the command specified a prefix argument for the following
command).
Some commands set this variable during their execution, as a flag for
whatever command runs next. In particular, the functions for killing text
set this-command
to kill-region
so that any kill commands
immediately following will know to append the killed text to the
previous kill.
If you do not want a particular command to be recognized as the previous
command in the case where it got an error, you must code that command to
prevent this. One way is to set this-command
to t
at the
beginning of the command, and set this-command
back to its proper
value at the end, like this:
(defun foo (args…)
(interactive …)
(let ((old-this-command this-command))
(setq this-command t)
…do the work…
(setq this-command old-this-command)))
|
We do not bind this-command
with let
because that would
restore the old value in case of error—a feature of let
which
in this case does precisely what we want to avoid.
This function returns a string or vector containing the key sequence that invoked the present command, plus any previous commands that generated the prefix argument for this command. The value is a string if all those events were characters. See section Input Events.
(this-command-keys)
;; Now use C-u C-x C-e to evaluate that.
⇒ "^U^X^E"
|
Like this-command-keys
, except that it always returns the events
in a vector, so you don’t need to deal with the complexities of storing
input events in a string (see section Putting Keyboard Events in Strings).
This function empties out the table of events for
this-command-keys
to return, and also empties the records that
the function recent-keys
(see section Recording Input) will
subsequently return. This is useful after reading a password, to
prevent the password from echoing inadvertently as part of the next
command in certain cases.
This variable holds the last input event read as part of a key sequence, not counting events resulting from mouse menus.
One use of this variable is for telling x-popup-menu
where to pop
up a menu. It is also used internally by y-or-n-p
(see section Yes-or-No Queries).
This variable is set to the last input event that was read by the
command loop as part of a command. The principal use of this variable
is in self-insert-command
, which uses it to decide which
character to insert.
last-command-event
;; Now use C-u C-x C-e to evaluate that.
⇒ 5
|
The value is 5 because that is the ASCII code for C-e.
The alias last-command-char
exists for compatibility with
Emacs version 18.
This variable records which frame the last input event was directed to. Usually this is the frame that was selected when the event was generated, but if that frame has redirected input focus to another frame, the value is the frame to which the event was redirected. See section Input Focus.
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
It is not easy to display a value of point in the middle of a sequence
of text that has the display
or composition
property. So
after a command finishes and returns to the command loop, if point is
within such a sequence, the command loop normally moves point to the
edge of the sequence.
A command can inhibit this feature by setting the variable
disable-point-adjustment
:
If this variable is non-nil
when a command returns to the command
loop, then the command loop does not check for text properties such as
display
and composition
, and does not move point out of
sequences that have these properties.
The command loop sets this variable to nil
before each command,
so if a command sets it, the effect applies only to that command.
If you set this variable to a non-nil
value, the feature of
moving point out of these sequences is completely turned off.
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
The Emacs command loop reads a sequence of input events that represent keyboard or mouse activity. The events for keyboard activity are characters or symbols; mouse events are always lists. This section describes the representation and meaning of input events in detail.
This function returns non-nil
if object is an input event
or event type.
Note that any symbol might be used as an event or an event type.
eventp
cannot distinguish whether a symbol is intended by Lisp
code to be used as an event. Instead, it distinguishes whether the
symbol has actually been used in an event that has been read as input in
the current Emacs session. If a symbol has not yet been so used,
eventp
returns nil
.
21.6.1 Keyboard Events | Ordinary characters–keys with symbols on them. | |
21.6.2 Function Keys | Function keys–keys with names, not symbols. | |
21.6.3 Mouse Events | Overview of mouse events. | |
21.6.4 Click Events | Pushing and releasing a mouse button. | |
21.6.5 Drag Events | Moving the mouse before releasing the button. | |
21.6.6 Button-Down Events | A button was pushed and not yet released. | |
21.6.7 Repeat Events | Double and triple click (or drag, or down). | |
21.6.8 Motion Events | Just moving the mouse, not pushing a button. | |
21.6.9 Focus Events | Moving the mouse between frames. | |
21.6.10 Miscellaneous Window System Events | Other events window systems can generate. | |
21.6.11 Event Examples | Examples of the lists for mouse events. | |
21.6.12 Classifying Events | Finding the modifier keys in an event symbol. Event types. | |
21.6.13 Accessing Events | Functions to extract info from events. | |
21.6.14 Putting Keyboard Events in Strings | Special considerations for putting keyboard character events in a string. |
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
There are two kinds of input you can get from the keyboard: ordinary keys, and function keys. Ordinary keys correspond to characters; the events they generate are represented in Lisp as characters. The event type of a character event is the character itself (an integer); see Classifying Events.
An input character event consists of a basic code between 0 and 524287, plus any or all of these modifier bits:
The 2**27 bit in the character code indicates a character typed with the meta key held down.
The 2**26 bit in the character code indicates a non-ASCII control character.
ASCII control characters such as C-a have special basic codes of their own, so Emacs needs no special bit to indicate them. Thus, the code for C-a is just 1.
But if you type a control combination not in ASCII, such as % with the control key, the numeric value you get is the code for % plus 2**26 (assuming the terminal supports non-ASCII control characters).
The 2**25 bit in the character code indicates an ASCII control character typed with the shift key held down.
For letters, the basic code itself indicates upper versus lower case; for digits and punctuation, the shift key selects an entirely different character with a different basic code. In order to keep within the ASCII character set whenever possible, Emacs avoids using the 2**25 bit for those characters.
However, ASCII provides no way to distinguish C-A from C-a, so Emacs uses the 2**25 bit in C-A and not in C-a.
The 2**24 bit in the character code indicates a character typed with the hyper key held down.
The 2**23 bit in the character code indicates a character typed with the super key held down.
The 2**22 bit in the character code indicates a character typed with the alt key held down. (On some terminals, the key labeled <ALT> is actually the meta key.)
It is best to avoid mentioning specific bit numbers in your program.
To test the modifier bits of a character, use the function
event-modifiers
(see section Classifying Events). When making key
bindings, you can use the read syntax for characters with modifier bits
(‘\C-’, ‘\M-’, and so on). For making key bindings with
define-key
, you can use lists such as (control hyper ?x)
to
specify the characters (see section Changing Key Bindings). The function
event-convert-list
converts such a list into an event type
(see section Classifying Events).
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
Most keyboards also have function keys—keys that have names or
symbols that are not characters. Function keys are represented in Emacs
Lisp as symbols; the symbol’s name is the function key’s label, in lower
case. For example, pressing a key labeled <F1> places the symbol
f1
in the input stream.
The event type of a function key event is the event symbol itself. See section Classifying Events.
Here are a few special cases in the symbol-naming convention for function keys:
backspace
, tab
, newline
, return
, delete
These keys correspond to common ASCII control characters that have special keys on most keyboards.
In ASCII, C-i and <TAB> are the same character. If the
terminal can distinguish between them, Emacs conveys the distinction to
Lisp programs by representing the former as the integer 9, and the
latter as the symbol tab
.
Most of the time, it’s not useful to distinguish the two. So normally
function-key-map
(see section Translating Input Events) is set up to map
tab
into 9. Thus, a key binding for character code 9 (the
character C-i) also applies to tab
. Likewise for the other
symbols in this group. The function read-char
likewise converts
these events into characters.
In ASCII, <BS> is really C-h. But backspace
converts into the character code 127 (<DEL>), not into code 8
(<BS>). This is what most users prefer.
left
, up
, right
, down
Cursor arrow keys
kp-add
, kp-decimal
, kp-divide
, …Keypad keys (to the right of the regular keyboard).
kp-0
, kp-1
, …Keypad keys with digits.
kp-f1
, kp-f2
, kp-f3
, kp-f4
Keypad PF keys.
kp-home
, kp-left
, kp-up
, kp-right
, kp-down
Keypad arrow keys. Emacs normally translates these into the
corresponding non-keypad keys home
, left
, …
kp-prior
, kp-next
, kp-end
, kp-begin
, kp-insert
, kp-delete
Additional keypad duplicates of keys ordinarily found elsewhere. Emacs normally translates these into the like-named non-keypad keys.
You can use the modifier keys <ALT>, <CTRL>, <HYPER>, <META>, <SHIFT>, and <SUPER> with function keys. The way to represent them is with prefixes in the symbol name:
The alt modifier.
The control modifier.
The hyper modifier.
The meta modifier.
The shift modifier.
The super modifier.
Thus, the symbol for the key <F3> with <META> held down is
M-f3
. When you use more than one prefix, we recommend you
write them in alphabetical order; but the order does not matter in
arguments to the key-binding lookup and modification functions.
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
Emacs supports four kinds of mouse events: click events, drag events, button-down events, and motion events. All mouse events are represented as lists. The CAR of the list is the event type; this says which mouse button was involved, and which modifier keys were used with it. The event type can also distinguish double or triple button presses (see section Repeat Events). The rest of the list elements give position and time information.
For key lookup, only the event type matters: two events of the same type
necessarily run the same command. The command can access the full
values of these events using the ‘e’ interactive code.
See section Code Characters for interactive
.
A key sequence that starts with a mouse event is read using the keymaps of the buffer in the window that the mouse was in, not the current buffer. This does not imply that clicking in a window selects that window or its buffer—that is entirely under the control of the command binding of the key sequence.
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
When the user presses a mouse button and releases it at the same location, that generates a click event. Mouse click events have this form:
(event-type (window buffer-pos (x . y) timestamp) click-count) |
Here is what the elements normally mean:
This is a symbol that indicates which mouse button was used. It is
one of the symbols mouse-1
, mouse-2
, …, where the
buttons are numbered left to right.
You can also use prefixes ‘A-’, ‘C-’, ‘H-’, ‘M-’, ‘S-’ and ‘s-’ for modifiers alt, control, hyper, meta, shift and super, just as you would with function keys.
This symbol also serves as the event type of the event. Key bindings
describe events by their types; thus, if there is a key binding for
mouse-1
, that binding would apply to all events whose
event-type is mouse-1
.
This is the window in which the click occurred.
These are the pixel-denominated coordinates of the click, relative to
the top left corner of window, which is (0 . 0)
.
This is the buffer position of the character clicked on.
This is the time at which the event occurred, in milliseconds. (Since this value wraps around the entire range of Emacs Lisp integers in about five hours, it is useful only for relating the times of nearby events.)
This is the number of rapid repeated presses so far of the same mouse button. See section Repeat Events.
The meanings of buffer-pos, x and y are somewhat different when the event location is in a special part of the screen, such as the mode line or a scroll bar.
If the location is in a scroll bar, then buffer-pos is the symbol
vertical-scroll-bar
or horizontal-scroll-bar
, and the pair
(x . y)
is replaced with a pair (portion
. whole)
, where portion is the distance of the click from
the top or left end of the scroll bar, and whole is the length of
the entire scroll bar.
If the position is on a mode line or the vertical line separating
window from its neighbor to the right, then buffer-pos is
the symbol mode-line
, header-line
, or
vertical-line
. For the mode line, y does not have
meaningful data. For the vertical line, x does not have
meaningful data.
In one special case, buffer-pos is a list containing a symbol (one of the symbols listed above) instead of just the symbol. This happens after the imaginary prefix keys for the event are inserted into the input stream. See section Key Sequence Input.
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
With Emacs, you can have a drag event without even changing your clothes. A drag event happens every time the user presses a mouse button and then moves the mouse to a different character position before releasing the button. Like all mouse events, drag events are represented in Lisp as lists. The lists record both the starting mouse position and the final position, like this:
(event-type (window1 buffer-pos1 (x1 . y1) timestamp1) (window2 buffer-pos2 (x2 . y2) timestamp2) click-count) |
For a drag event, the name of the symbol event-type contains the
prefix ‘drag-’. For example, dragging the mouse with button 2 held
down generates a drag-mouse-2
event. The second and third
elements of the event give the starting and ending position of the drag.
Aside from that, the data have the same meanings as in a click event
(see section Click Events). You can access the second element of any mouse
event in the same way, with no need to distinguish drag events from
others.
The ‘drag-’ prefix follows the modifier key prefixes such as ‘C-’ and ‘M-’.
If read-key-sequence
receives a drag event that has no key
binding, and the corresponding click event does have a binding, it
changes the drag event into a click event at the drag’s starting
position. This means that you don’t have to distinguish between click
and drag events unless you want to.
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
Click and drag events happen when the user releases a mouse button. They cannot happen earlier, because there is no way to distinguish a click from a drag until the button is released.
If you want to take action as soon as a button is pressed, you need to handle button-down events.(5) These occur as soon as a button is pressed. They are represented by lists that look exactly like click events (see section Click Events), except that the event-type symbol name contains the prefix ‘down-’. The ‘down-’ prefix follows modifier key prefixes such as ‘C-’ and ‘M-’.
The function read-key-sequence
ignores any button-down events
that don’t have command bindings; therefore, the Emacs command loop
ignores them too. This means that you need not worry about defining
button-down events unless you want them to do something. The usual
reason to define a button-down event is so that you can track mouse
motion (by reading motion events) until the button is released.
See section Motion Events.
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
If you press the same mouse button more than once in quick succession without moving the mouse, Emacs generates special repeat mouse events for the second and subsequent presses.
The most common repeat events are double-click events. Emacs generates a double-click event when you click a button twice; the event happens when you release the button (as is normal for all click events).
The event type of a double-click event contains the prefix
‘double-’. Thus, a double click on the second mouse button with
<meta> held down comes to the Lisp program as
M-double-mouse-2
. If a double-click event has no binding, the
binding of the corresponding ordinary click event is used to execute
it. Thus, you need not pay attention to the double click feature
unless you really want to.
When the user performs a double click, Emacs generates first an ordinary click event, and then a double-click event. Therefore, you must design the command binding of the double click event to assume that the single-click command has already run. It must produce the desired results of a double click, starting from the results of a single click.
This is convenient, if the meaning of a double click somehow “builds on” the meaning of a single click—which is recommended user interface design practice for double clicks.
If you click a button, then press it down again and start moving the mouse with the button held down, then you get a double-drag event when you ultimately release the button. Its event type contains ‘double-drag’ instead of just ‘drag’. If a double-drag event has no binding, Emacs looks for an alternate binding as if the event were an ordinary drag.
Before the double-click or double-drag event, Emacs generates a double-down event when the user presses the button down for the second time. Its event type contains ‘double-down’ instead of just ‘down’. If a double-down event has no binding, Emacs looks for an alternate binding as if the event were an ordinary button-down event. If it finds no binding that way either, the double-down event is ignored.
To summarize, when you click a button and then press it again right away, Emacs generates a down event and a click event for the first click, a double-down event when you press the button again, and finally either a double-click or a double-drag event.
If you click a button twice and then press it again, all in quick succession, Emacs generates a triple-down event, followed by either a triple-click or a triple-drag. The event types of these events contain ‘triple’ instead of ‘double’. If any triple event has no binding, Emacs uses the binding that it would use for the corresponding double event.
If you click a button three or more times and then press it again, the events for the presses beyond the third are all triple events. Emacs does not have separate event types for quadruple, quintuple, etc. events. However, you can look at the event list to find out precisely how many times the button was pressed.
This function returns the number of consecutive button presses that led up to event. If event is a double-down, double-click or double-drag event, the value is 2. If event is a triple event, the value is 3 or greater. If event is an ordinary mouse event (not a repeat event), the value is 1.
To generate repeat events, successive mouse button presses must be at
approximately the same screen position. The value of
double-click-fuzz
specifies the maximum number of pixels the
mouse may be moved between two successive clicks to make a
double-click.
To generate repeat events, the number of milliseconds between
successive button presses must be less than the value of
double-click-time
. Setting double-click-time
to
nil
disables multi-click detection entirely. Setting it to
t
removes the time limit; Emacs then detects multi-clicks by
position only.
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
Emacs sometimes generates mouse motion events to describe motion of the mouse without any button activity. Mouse motion events are represented by lists that look like this:
(mouse-movement (window buffer-pos (x . y) timestamp)) |
The second element of the list describes the current position of the mouse, just as in a click event (see section Click Events).
The special form track-mouse
enables generation of motion events
within its body. Outside of track-mouse
forms, Emacs does not
generate events for mere motion of the mouse, and these events do not
appear. See section Mouse Tracking.
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
Window systems provide general ways for the user to control which window gets keyboard input. This choice of window is called the focus. When the user does something to switch between Emacs frames, that generates a focus event. The normal definition of a focus event, in the global keymap, is to select a new frame within Emacs, as the user would expect. See section Input Focus.
Focus events are represented in Lisp as lists that look like this:
(switch-frame new-frame) |
where new-frame is the frame switched to.
Most X window managers are set up so that just moving the mouse into a window is enough to set the focus there. Emacs appears to do this, because it changes the cursor to solid in the new frame. However, there is no need for the Lisp program to know about the focus change until some other kind of input arrives. So Emacs generates a focus event only when the user actually types a keyboard key or presses a mouse button in the new frame; just moving the mouse between frames does not generate a focus event.
A focus event in the middle of a key sequence would garble the sequence. So Emacs never generates a focus event in the middle of a key sequence. If the user changes focus in the middle of a key sequence—that is, after a prefix key—then Emacs reorders the events so that the focus event comes either before or after the multi-event key sequence, and not within it.
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
A few other event types represent occurrences within the window system.
(delete-frame (frame))
This kind of event indicates that the user gave the window manager a command to delete a particular window, which happens to be an Emacs frame.
The standard definition of the delete-frame
event is to delete frame.
(iconify-frame (frame))
This kind of event indicates that the user iconified frame using
the window manager. Its standard definition is ignore
; since the
frame has already been iconified, Emacs has no work to do. The purpose
of this event type is so that you can keep track of such events if you
want to.
(make-frame-visible (frame))
This kind of event indicates that the user deiconified frame using
the window manager. Its standard definition is ignore
; since the
frame has already been made visible, Emacs has no work to do.
(mouse-wheel position delta)
This kind of event is generated by moving a wheel on a mouse (such as the MS Intellimouse). Its effect is typically a kind of scroll or zoom.
The element delta describes the amount and direction of the wheel rotation. Its absolute value is the number of increments by which the wheel was rotated. A negative delta indicates that the wheel was rotated backwards, towards the user, and a positive delta indicates that the wheel was rotated forward, away from the user.
The element position is a list describing the position of the event, in the same format as used in a mouse-click event.
This kind of event is generated only on some kinds of systems.
(drag-n-drop position files)
This kind of event is generated when a group of files is selected in an application outside of Emacs, and then dragged and dropped onto an Emacs frame.
The element position is a list describing the position of the event, in the same format as used in a mouse-click event, and files is the list of file names that were dragged and dropped. The usual way to handle this event is by visiting these files.
This kind of event is generated, at present, only on some kinds of systems.
If one of these events arrives in the middle of a key sequence—that is, after a prefix key—then Emacs reorders the events so that this event comes either before or after the multi-event key sequence, not within it.
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
If the user presses and releases the left mouse button over the same location, that generates a sequence of events like this:
(down-mouse-1 (#<window 18 on NEWS> 2613 (0 . 38) -864320)) (mouse-1 (#<window 18 on NEWS> 2613 (0 . 38) -864180)) |
While holding the control key down, the user might hold down the second mouse button, and drag the mouse from one line to the next. That produces two events, as shown here:
(C-down-mouse-2 (#<window 18 on NEWS> 3440 (0 . 27) -731219)) (C-drag-mouse-2 (#<window 18 on NEWS> 3440 (0 . 27) -731219) (#<window 18 on NEWS> 3510 (0 . 28) -729648)) |
While holding down the meta and shift keys, the user might press the second mouse button on the window’s mode line, and then drag the mouse into another window. That produces a pair of events like these:
(M-S-down-mouse-2 (#<window 18 on NEWS> mode-line (33 . 31) -457844)) (M-S-drag-mouse-2 (#<window 18 on NEWS> mode-line (33 . 31) -457844) (#<window 20 on carlton-sanskrit.tex> 161 (33 . 3) -453816)) |
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
Every event has an event type, which classifies the event for key binding purposes. For a keyboard event, the event type equals the event value; thus, the event type for a character is the character, and the event type for a function key symbol is the symbol itself. For events that are lists, the event type is the symbol in the CAR of the list. Thus, the event type is always a symbol or a character.
Two events of the same type are equivalent where key bindings are concerned; thus, they always run the same command. That does not necessarily mean they do the same things, however, as some commands look at the whole event to decide what to do. For example, some commands use the location of a mouse event to decide where in the buffer to act.
Sometimes broader classifications of events are useful. For example, you might want to ask whether an event involved the <META> key, regardless of which other key or mouse button was used.
The functions event-modifiers
and event-basic-type
are
provided to get such information conveniently.
This function returns a list of the modifiers that event has. The
modifiers are symbols; they include shift
, control
,
meta
, alt
, hyper
and super
. In addition,
the modifiers list of a mouse event symbol always contains one of
click
, drag
, and down
.
The argument event may be an entire event object, or just an event type.
Here are some examples:
(event-modifiers ?a) ⇒ nil (event-modifiers ?\C-a) ⇒ (control) (event-modifiers ?\C-%) ⇒ (control) (event-modifiers ?\C-\S-a) ⇒ (control shift) (event-modifiers 'f5) ⇒ nil (event-modifiers 's-f5) ⇒ (super) (event-modifiers 'M-S-f5) ⇒ (meta shift) (event-modifiers 'mouse-1) ⇒ (click) (event-modifiers 'down-mouse-1) ⇒ (down) |
The modifiers list for a click event explicitly contains click
,
but the event symbol name itself does not contain ‘click’.
This function returns the key or mouse button that event describes, with all modifiers removed. For example:
(event-basic-type ?a) ⇒ 97 (event-basic-type ?A) ⇒ 97 (event-basic-type ?\C-a) ⇒ 97 (event-basic-type ?\C-\S-a) ⇒ 97 (event-basic-type 'f5) ⇒ f5 (event-basic-type 's-f5) ⇒ f5 (event-basic-type 'M-S-f5) ⇒ f5 (event-basic-type 'down-mouse-1) ⇒ mouse-1 |
This function returns non-nil
if object is a mouse movement
event.
This function converts a list of modifier names and a basic event type to an event type which specifies all of them. For example,
(event-convert-list '(control ?a)) ⇒ 1 (event-convert-list '(control meta ?a)) ⇒ -134217727 (event-convert-list '(control super f1)) ⇒ C-s-f1 |
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
This section describes convenient functions for accessing the data in a mouse button or motion event.
These two functions return the starting or ending position of a mouse-button event, as a list of this form:
(window buffer-position (x . y) timestamp) |
This returns the starting position of event.
If event is a click or button-down event, this returns the location of the event. If event is a drag event, this returns the drag’s starting position.
This returns the ending position of event.
If event is a drag event, this returns the position where the user released the mouse button. If event is a click or button-down event, the value is actually the starting position, which is the only position such events have.
These five functions take a position list as described above, and return various parts of it.
Return the window that position is in.
Return the buffer position in position. This is an integer.
Return the pixel-based x and y coordinates in position, as a cons
cell (x . y)
.
Return the row and column (in units of characters) of position, as
a cons cell (col . row)
. These are computed from the
x and y values actually found in position.
Return the timestamp in position.
These functions are useful for decoding scroll bar events.
This function returns the fractional vertical position of a scroll bar
event within the scroll bar. The value is a cons cell
(portion . whole)
containing two integers whose ratio
is the fractional position.
This function multiplies (in effect) ratio by total,
rounding the result to an integer. The argument ratio is not a
number, but rather a pair (num . denom)
—typically a
value returned by scroll-bar-event-ratio
.
This function is handy for scaling a position on a scroll bar into a buffer position. Here’s how to do that:
(+ (point-min) (scroll-bar-scale (posn-x-y (event-start event)) (- (point-max) (point-min)))) |
Recall that scroll bar events have two integers forming a ratio, in place of a pair of x and y coordinates.
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
In most of the places where strings are used, we conceptualize the string as containing text characters—the same kind of characters found in buffers or files. Occasionally Lisp programs use strings that conceptually contain keyboard characters; for example, they may be key sequences or keyboard macro definitions. However, storing keyboard characters in a string is a complex matter, for reasons of historical compatibility, and it is not always possible.
We recommend that new programs avoid dealing with these complexities by not storing keyboard events in strings. Here is how to do that:
lookup-key
and
define-key
. For example, you can use
read-key-sequence-vector
instead of read-key-sequence
, and
this-command-keys-vector
instead of this-command-keys
.
define-key
.
listify-key-sequence
(see section Miscellaneous Event Input Features)
first, to convert it to a list.
The complexities stem from the modifier bits that keyboard input characters can include. Aside from the Meta modifier, none of these modifier bits can be included in a string, and the Meta modifier is allowed only in special cases.
The earliest GNU Emacs versions represented meta characters as codes
in the range of 128 to 255. At that time, the basic character codes
ranged from 0 to 127, so all keyboard character codes did fit in a
string. Many Lisp programs used ‘\M-’ in string constants to stand
for meta characters, especially in arguments to define-key
and
similar functions, and key sequences and sequences of events were always
represented as strings.
When we added support for larger basic character codes beyond 127, and additional modifier bits, we had to change the representation of meta characters. Now the flag that represents the Meta modifier in a character is 2**27 and such numbers cannot be included in a string.
To support programs with ‘\M-’ in string constants, there are special rules for including certain meta characters in a string. Here are the rules for interpreting a string as a sequence of input characters:
Functions such as read-key-sequence
that construct strings of
keyboard input characters follow these rules: they construct vectors
instead of strings, when the events won’t fit in a string.
When you use the read syntax ‘\M-’ in a string, it produces a code in the range of 128 to 255—the same code that you get if you modify the corresponding keyboard event to put it in the string. Thus, meta events in strings work consistently regardless of how they get into the strings.
However, most programs would do well to avoid these issues by following the recommendations at the beginning of this section.
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
The editor command loop reads key sequences using the function
read-key-sequence
, which uses read-event
. These and other
functions for event input are also available for use in Lisp programs.
See also momentary-string-display
in Temporary Displays,
and sit-for
in Waiting for Elapsed Time or Input. See section Terminal Input, for
functions and variables for controlling terminal input modes and
debugging terminal input. See section Translating Input Events, for features you
can use for translating or modifying input events while reading them.
For higher-level input facilities, see Minibuffers.
21.7.1 Key Sequence Input | How to read one key sequence. | |
21.7.2 Reading One Event | How to read just one event. | |
21.7.3 Invoking the Input Method | How reading an event uses the input method. | |
21.7.4 Quoted Character Input | Asking the user to specify a character. | |
21.7.5 Miscellaneous Event Input Features | How to reread or throw away input events. |
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
The command loop reads input a key sequence at a time, by calling
read-key-sequence
. Lisp programs can also call this function;
for example, describe-key
uses it to read the key to describe.
This function reads a key sequence and returns it as a string or vector. It keeps reading events until it has accumulated a complete key sequence; that is, enough to specify a non-prefix command using the currently active keymaps.
If the events are all characters and all can fit in a string, then
read-key-sequence
returns a string (see section Putting Keyboard Events in Strings).
Otherwise, it returns a vector, since a vector can hold all kinds of
events—characters, symbols, and lists. The elements of the string or
vector are the events in the key sequence.
The argument prompt is either a string to be displayed in the echo
area as a prompt, or nil
, meaning not to display a prompt.
In the example below, the prompt ‘?’ is displayed in the echo area, and the user types C-x C-f.
(read-key-sequence "?") ---------- Echo Area ---------- ?C-x C-f ---------- Echo Area ---------- ⇒ "^X^F" |
The function read-key-sequence
suppresses quitting: C-g
typed while reading with this function works like any other character,
and does not set quit-flag
. See section Quitting.
This is like read-key-sequence
except that it always
returns the key sequence as a vector, never as a string.
See section Putting Keyboard Events in Strings.
If an input character is an upper-case letter and has no key binding,
but its lower-case equivalent has one, then read-key-sequence
converts the character to lower case. Note that lookup-key
does
not perform case conversion in this way.
The function read-key-sequence
also transforms some mouse events.
It converts unbound drag events into click events, and discards unbound
button-down events entirely. It also reshuffles focus events and
miscellaneous window events so that they never appear in a key sequence
with any other events.
When mouse events occur in special parts of a window, such as a mode
line or a scroll bar, the event type shows nothing special—it is the
same symbol that would normally represent that combination of mouse
button and modifier keys. The information about the window part is kept
elsewhere in the event—in the coordinates. But
read-key-sequence
translates this information into imaginary
“prefix keys”, all of which are symbols: header-line
,
horizontal-scroll-bar
, menu-bar
, mode-line
,
vertical-line
, and vertical-scroll-bar
. You can define
meanings for mouse clicks in special window parts by defining key
sequences using these imaginary prefix keys.
For example, if you call read-key-sequence
and then click the
mouse on the window’s mode line, you get two events, like this:
(read-key-sequence "Click on the mode line: ") ⇒ [mode-line (mouse-1 (#<window 6 on NEWS> mode-line (40 . 63) 5959987))] |
This variable’s value is the number of key sequences processed so far in this Emacs session. This includes key sequences read from the terminal and key sequences read from keyboard macros being executed.
This variable holds the total number of input events received so far from the terminal—not counting those generated by keyboard macros.
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
The lowest level functions for command input are those that read a single event.
This function reads and returns the next event of command input, waiting if necessary until an event is available. Events can come directly from the user or from a keyboard macro.
If the optional argument prompt is non-nil
, it should be a
string to display in the echo area as a prompt. Otherwise,
read-event
does not display any message to indicate it is waiting
for input; instead, it prompts by echoing: it displays descriptions of
the events that led to or were read by the current command. See section The Echo Area.
If inherit-input-method is non-nil
, then the current input
method (if any) is employed to make it possible to enter a
non-ASCII character. Otherwise, input method handling is disabled
for reading this event.
If cursor-in-echo-area
is non-nil
, then read-event
moves the cursor temporarily to the echo area, to the end of any message
displayed there. Otherwise read-event
does not move the cursor.
If read-event
gets an event that is defined as a help character, in
some cases read-event
processes the event directly without
returning. See section Help Functions. Certain other events, called
special events, are also processed directly within
read-event
(see section Special Events).
Here is what happens if you call read-event
and then press the
right-arrow function key:
(read-event) ⇒ right |
This function reads and returns a character of command input. If the
user generates an event which is not a character (i.e. a mouse click or
function key event), read-char
signals an error. The arguments
work as in read-event
.
In the first example, the user types the character 1 (ASCII
code 49). The second example shows a keyboard macro definition that
calls read-char
from the minibuffer using eval-expression
.
read-char
reads the keyboard macro’s very next character, which
is 1. Then eval-expression
displays its return value in
the echo area.
(read-char) ⇒ 49 ;; We assume here you use M-: to evaluate this.
(symbol-function 'foo)
⇒ "^[:(read-char)^M1"
(execute-kbd-macro 'foo) -| 49 ⇒ nil |
This function reads and returns a character of command input. If the
user generates an event which is not a character,
read-char-exclusive
ignores it and reads another event, until it
gets a character. The arguments work as in read-event
.
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
The event-reading functions invoke the current input method, if any
(see section Input Methods). If the value of input-method-function
is non-nil
, it should be a function; when read-event
reads
a printing character (including <SPC>) with no modifier bits, it
calls that function, passing the character as an argument.
If this is non-nil
, its value specifies the current input method
function.
Note: Don’t bind this variable with let
. It is often
buffer-local, and if you bind it around reading input (which is exactly
when you would bind it), switching buffers asynchronously while
Emacs is waiting will cause the value to be restored in the wrong
buffer.
The input method function should return a list of events which should
be used as input. (If the list is nil
, that means there is no
input, so read-event
waits for another event.) These events are
processed before the events in unread-command-events
(see section Miscellaneous Event Input Features). Events
returned by the input method function are not passed to the input method
function again, even if they are printing characters with no modifier
bits.
If the input method function calls read-event
or
read-key-sequence
, it should bind input-method-function
to
nil
first, to prevent recursion.
The input method function is not called when reading the second and
subsequent events of a key sequence. Thus, these characters are not
subject to input method processing. The input method function should
test the values of overriding-local-map
and
overriding-terminal-local-map
; if either of these variables is
non-nil
, the input method should put its argument into a list and
return that list with no further processing.
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
You can use the function read-quoted-char
to ask the user to
specify a character, and allow the user to specify a control or meta
character conveniently, either literally or as an octal character code.
The command quoted-insert
uses this function.
This function is like read-char
, except that if the first
character read is an octal digit (0-7), it reads any number of octal
digits (but stopping if a non-octal digit is found), and returns the
character represented by that numeric character code.
Quitting is suppressed when the first character is read, so that the user can enter a C-g. See section Quitting.
If prompt is supplied, it specifies a string for prompting the user. The prompt string is always displayed in the echo area, followed by a single ‘-’.
In the following example, the user types in the octal number 177 (which is 127 in decimal).
(read-quoted-char "What character") ---------- Echo Area ---------- What character-177 ---------- Echo Area ---------- ⇒ 127 |
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
This section describes how to “peek ahead” at events without using
them up, how to check for pending input, and how to discard pending
input. See also the function read-passwd
(see section Reading a Password).
This variable holds a list of events waiting to be read as command input. The events are used in the order they appear in the list, and removed one by one as they are used.
The variable is needed because in some cases a function reads an event and then decides not to use it. Storing the event in this variable causes it to be processed normally, by the command loop or by the functions to read command input.
For example, the function that implements numeric prefix arguments reads any number of digits. When it finds a non-digit event, it must unread the event so that it can be read normally by the command loop. Likewise, incremental search uses this feature to unread events with no special meaning in a search, because these events should exit the search and then execute normally.
The reliable and easy way to extract events from a key sequence so as to
put them in unread-command-events
is to use
listify-key-sequence
(see section Putting Keyboard Events in Strings).
Normally you add events to the front of this list, so that the events most recently unread will be reread first.
This function converts the string or vector key to a list of
individual events, which you can put in unread-command-events
.
This variable holds a character to be read as command input. A value of -1 means “empty”.
This variable is mostly obsolete now that you can use
unread-command-events
instead; it exists only to support programs
written for Emacs versions 18 and earlier.
This function determines whether any command input is currently
available to be read. It returns immediately, with value t
if
there is available input, nil
otherwise. On rare occasions it
may return t
when no input is available.
This variable records the last terminal input event read, whether as part of a command or explicitly by a Lisp program.
In the example below, the Lisp program reads the character 1,
ASCII code 49. It becomes the value of last-input-event
,
while C-e (we assume C-x C-e command is used to evaluate
this expression) remains the value of last-command-event
.
(progn (print (read-char)) (print last-command-event) last-input-event) -| 49 -| 5 ⇒ 49 |
The alias last-input-char
exists for compatibility with
Emacs version 18.
This function discards the contents of the terminal input buffer and
cancels any keyboard macro that might be in the process of definition.
It returns nil
.
In the following example, the user may type a number of characters right
after starting the evaluation of the form. After the sleep-for
finishes sleeping, discard-input
discards any characters typed
during the sleep.
(progn (sleep-for 2) (discard-input)) ⇒ nil |
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
Special events are handled at a very low level—as soon as they are
read. The read-event
function processes these events itself, and
never returns them.
Events that are handled in this way do not echo, they are never grouped
into key sequences, and they never appear in the value of
last-command-event
or (this-command-keys)
. They do not
discard a numeric argument, they cannot be unread with
unread-command-events
, they may not appear in a keyboard macro,
and they are not recorded in a keyboard macro while you are defining
one.
These events do, however, appear in last-input-event
immediately
after they are read, and this is the way for the event’s definition to
find the actual event.
The events types iconify-frame
, make-frame-visible
and
delete-frame
are normally handled in this way. The keymap which
defines how to handle special events—and which events are special—is
in the variable special-event-map
(see section Active Keymaps).
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
The wait functions are designed to wait for a certain amount of time
to pass or until there is input. For example, you may wish to pause in
the middle of a computation to allow the user time to view the display.
sit-for
pauses and updates the screen, and returns immediately if
input comes in, while sleep-for
pauses without updating the
screen.
This function performs redisplay (provided there is no pending input
from the user), then waits seconds seconds, or until input is
available. The value is t
if sit-for
waited the full
time with no input arriving (see input-pending-p
in Miscellaneous Event Input Features). Otherwise, the value is nil
.
The argument seconds need not be an integer. If it is a floating
point number, sit-for
waits for a fractional number of seconds.
Some systems support only a whole number of seconds; on these systems,
seconds is rounded down.
The optional argument millisec specifies an additional waiting period measured in milliseconds. This adds to the period specified by seconds. If the system doesn’t support waiting fractions of a second, you get an error if you specify nonzero millisec.
The expression (sit-for 0)
is a convenient way to request a
redisplay, without any delay. See section Forcing Redisplay.
If nodisp is non-nil
, then sit-for
does not
redisplay, but it still returns as soon as input is available (or when
the timeout elapses).
Iconifying or deiconifying a frame makes sit-for
return, because
that generates an event. See section Miscellaneous Window System Events.
The usual purpose of sit-for
is to give the user time to read
text that you display.
This function simply pauses for seconds seconds without updating
the display. It pays no attention to available input. It returns
nil
.
The argument seconds need not be an integer. If it is a floating
point number, sleep-for
waits for a fractional number of seconds.
Some systems support only a whole number of seconds; on these systems,
seconds is rounded down.
The optional argument millisec specifies an additional waiting period measured in milliseconds. This adds to the period specified by seconds. If the system doesn’t support waiting fractions of a second, you get an error if you specify nonzero millisec.
Use sleep-for
when you wish to guarantee a delay.
See section Time of Day, for functions to get the current time.
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
Typing C-g while a Lisp function is running causes Emacs to quit whatever it is doing. This means that control returns to the innermost active command loop.
Typing C-g while the command loop is waiting for keyboard input
does not cause a quit; it acts as an ordinary input character. In the
simplest case, you cannot tell the difference, because C-g
normally runs the command keyboard-quit
, whose effect is to quit.
However, when C-g follows a prefix key, they combine to form an
undefined key. The effect is to cancel the prefix key as well as any
prefix argument.
In the minibuffer, C-g has a different definition: it aborts out of the minibuffer. This means, in effect, that it exits the minibuffer and then quits. (Simply quitting would return to the command loop within the minibuffer.) The reason why C-g does not quit directly when the command reader is reading input is so that its meaning can be redefined in the minibuffer in this way. C-g following a prefix key is not redefined in the minibuffer, and it has its normal effect of canceling the prefix key and prefix argument. This too would not be possible if C-g always quit directly.
When C-g does directly quit, it does so by setting the variable
quit-flag
to t
. Emacs checks this variable at appropriate
times and quits if it is not nil
. Setting quit-flag
non-nil
in any way thus causes a quit.
At the level of C code, quitting cannot happen just anywhere; only at the
special places that check quit-flag
. The reason for this is
that quitting at other places might leave an inconsistency in Emacs’s
internal state. Because quitting is delayed until a safe place, quitting
cannot make Emacs crash.
Certain functions such as read-key-sequence
or
read-quoted-char
prevent quitting entirely even though they wait
for input. Instead of quitting, C-g serves as the requested
input. In the case of read-key-sequence
, this serves to bring
about the special behavior of C-g in the command loop. In the
case of read-quoted-char
, this is so that C-q can be used
to quote a C-g.
You can prevent quitting for a portion of a Lisp function by binding
the variable inhibit-quit
to a non-nil
value. Then,
although C-g still sets quit-flag
to t
as usual, the
usual result of this—a quit—is prevented. Eventually,
inhibit-quit
will become nil
again, such as when its
binding is unwound at the end of a let
form. At that time, if
quit-flag
is still non-nil
, the requested quit happens
immediately. This behavior is ideal when you wish to make sure that
quitting does not happen within a “critical section” of the program.
In some functions (such as read-quoted-char
), C-g is
handled in a special way that does not involve quitting. This is done
by reading the input with inhibit-quit
bound to t
, and
setting quit-flag
to nil
before inhibit-quit
becomes nil
again. This excerpt from the definition of
read-quoted-char
shows how this is done; it also shows that
normal quitting is permitted after the first character of input.
(defun read-quoted-char (&optional prompt)
"…documentation…"
(let ((message-log-max nil) done (first t) (code 0) char)
(while (not done)
(let ((inhibit-quit first)
…)
(and prompt (message "%s-" prompt))
(setq char (read-event))
(if inhibit-quit (setq quit-flag nil)))
…set the variable |
If this variable is non-nil
, then Emacs quits immediately, unless
inhibit-quit
is non-nil
. Typing C-g ordinarily sets
quit-flag
non-nil
, regardless of inhibit-quit
.
This variable determines whether Emacs should quit when quit-flag
is set to a value other than nil
. If inhibit-quit
is
non-nil
, then quit-flag
has no special effect.
This function signals the quit
condition with (signal 'quit
nil)
. This is the same thing that quitting does. (See signal
in Errors.)
You can specify a character other than C-g to use for quitting.
See the function set-input-mode
in Terminal Input.
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
Most Emacs commands can use a prefix argument, a number
specified before the command itself. (Don’t confuse prefix arguments
with prefix keys.) The prefix argument is at all times represented by a
value, which may be nil
, meaning there is currently no prefix
argument. Each command may use the prefix argument or ignore it.
There are two representations of the prefix argument: raw and numeric. The editor command loop uses the raw representation internally, and so do the Lisp variables that store the information, but commands can request either representation.
Here are the possible values of a raw prefix argument:
nil
, meaning there is no prefix argument. Its numeric value is
1, but numerous commands make a distinction between nil
and the
integer 1.
-
. This indicates that M-- or C-u - was
typed, without following digits. The equivalent numeric value is
-1, but some commands make a distinction between the integer
-1 and the symbol -
.
We illustrate these possibilities by calling the following function with various prefixes:
(defun display-prefix (arg) "Display the value of the raw prefix arg." (interactive "P") (message "%s" arg)) |
Here are the results of calling display-prefix
with various
raw prefix arguments:
M-x display-prefix -| nil C-u M-x display-prefix -| (4) C-u C-u M-x display-prefix -| (16) C-u 3 M-x display-prefix -| 3 M-3 M-x display-prefix -| 3 ; (Same as |
Emacs uses two variables to store the prefix argument:
prefix-arg
and current-prefix-arg
. Commands such as
universal-argument
that set up prefix arguments for other
commands store them in prefix-arg
. In contrast,
current-prefix-arg
conveys the prefix argument to the current
command, so setting it has no effect on the prefix arguments for future
commands.
Normally, commands specify which representation to use for the prefix
argument, either numeric or raw, in the interactive
declaration.
(See section Using interactive
.) Alternatively, functions may look at the
value of the prefix argument directly in the variable
current-prefix-arg
, but this is less clean.
This function returns the numeric meaning of a valid raw prefix argument
value, arg. The argument may be a symbol, a number, or a list.
If it is nil
, the value 1 is returned; if it is -
, the
value -1 is returned; if it is a number, that number is returned;
if it is a list, the CAR of that list (which should be a number) is
returned.
This variable holds the raw prefix argument for the current
command. Commands may examine it directly, but the usual method for
accessing it is with (interactive "P")
.
The value of this variable is the raw prefix argument for the
next editing command. Commands such as universal-argument
that specify prefix arguments for the following command work by setting
this variable.
The raw prefix argument value used by the previous command.
The following commands exist to set up prefix arguments for the following command. Do not call them for any other reason.
This command reads input and specifies a prefix argument for the following command. Don’t call this command yourself unless you know what you are doing.
This command adds to the prefix argument for the following command. The argument arg is the raw prefix argument as it was before this command; it is used to compute the updated prefix argument. Don’t call this command yourself unless you know what you are doing.
This command adds to the numeric argument for the next command. The argument arg is the raw prefix argument as it was before this command; its value is negated to form the new prefix argument. Don’t call this command yourself unless you know what you are doing.
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
The Emacs command loop is entered automatically when Emacs starts up. This top-level invocation of the command loop never exits; it keeps running as long as Emacs does. Lisp programs can also invoke the command loop. Since this makes more than one activation of the command loop, we call it recursive editing. A recursive editing level has the effect of suspending whatever command invoked it and permitting the user to do arbitrary editing before resuming that command.
The commands available during recursive editing are the same ones available in the top-level editing loop and defined in the keymaps. Only a few special commands exit the recursive editing level; the others return to the recursive editing level when they finish. (The special commands for exiting are always available, but they do nothing when recursive editing is not in progress.)
All command loops, including recursive ones, set up all-purpose error handlers so that an error in a command run from the command loop will not exit the loop.
Minibuffer input is a special kind of recursive editing. It has a few special wrinkles, such as enabling display of the minibuffer and the minibuffer window, but fewer than you might suppose. Certain keys behave differently in the minibuffer, but that is only because of the minibuffer’s local map; if you switch windows, you get the usual Emacs commands.
To invoke a recursive editing level, call the function
recursive-edit
. This function contains the command loop; it also
contains a call to catch
with tag exit
, which makes it
possible to exit the recursive editing level by throwing to exit
(see section Explicit Nonlocal Exits: catch
and throw
). If you throw a value other than t
,
then recursive-edit
returns normally to the function that called
it. The command C-M-c (exit-recursive-edit
) does this.
Throwing a t
value causes recursive-edit
to quit, so that
control returns to the command loop one level up. This is called
aborting, and is done by C-] (abort-recursive-edit
).
Most applications should not use recursive editing, except as part of using the minibuffer. Usually it is more convenient for the user if you change the major mode of the current buffer temporarily to a special major mode, which should have a command to go back to the previous mode. (The e command in Rmail uses this technique.) Or, if you wish to give the user different text to edit “recursively”, create and select a new buffer in a special mode. In this mode, define a command to complete the processing and go back to the previous buffer. (The m command in Rmail does this.)
Recursive edits are useful in debugging. You can insert a call to
debug
into a function definition as a sort of breakpoint, so that
you can look around when the function gets there. debug
invokes
a recursive edit but also provides the other features of the debugger.
Recursive editing levels are also used when you type C-r in
query-replace
or use C-x q (kbd-macro-query
).
This function invokes the editor command loop. It is called automatically by the initialization of Emacs, to let the user begin editing. When called from a Lisp program, it enters a recursive editing level.
In the following example, the function simple-rec
first
advances point one word, then enters a recursive edit, printing out a
message in the echo area. The user can then do any editing desired, and
then type C-M-c to exit and continue executing simple-rec
.
(defun simple-rec () (forward-word 1) (message "Recursive edit in progress") (recursive-edit) (forward-word 1)) ⇒ simple-rec (simple-rec) ⇒ nil |
This function exits from the innermost recursive edit (including
minibuffer input). Its definition is effectively (throw 'exit
nil)
.
This function aborts the command that requested the innermost recursive
edit (including minibuffer input), by signaling quit
after exiting the recursive edit. Its definition is effectively
(throw 'exit t)
. See section Quitting.
This function exits all recursive editing levels; it does not return a value, as it jumps completely out of any computation directly back to the main command loop.
This function returns the current depth of recursive edits. When no recursive edit is active, it returns 0.
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
Disabling a command marks the command as requiring user confirmation before it can be executed. Disabling is used for commands which might be confusing to beginning users, to prevent them from using the commands by accident.
The low-level mechanism for disabling a command is to put a
non-nil
disabled
property on the Lisp symbol for the
command. These properties are normally set up by the user’s
init file (see section The Init File, ‘.emacs’) with Lisp expressions such as this:
(put 'upcase-region 'disabled t) |
For a few commands, these properties are present by default (you can remove them in your init file if you wish).
If the value of the disabled
property is a string, the message
saying the command is disabled includes that string. For example:
(put 'delete-region 'disabled "Text deleted this way cannot be yanked back!\n") |
See (emacs)Disabling section ‘Disabling’ in The GNU Emacs Manual, for the details on what happens when a disabled command is invoked interactively. Disabling a command has no effect on calling it as a function from Lisp programs.
Allow command to be executed without special confirmation from now on, and (if the user confirms) alter the user’s init file (see section The Init File, ‘.emacs’) so that this will apply to future sessions.
Require special confirmation to execute command from now on, and (if the user confirms) alter the user’s init file so that this will apply to future sessions.
When the user invokes a disabled command interactively, this normal hook
is run instead of the disabled command. The hook functions can use
this-command-keys
to determine what the user typed to run the
command, and thus find the command itself. See section Hooks.
By default, disabled-command-hook
contains a function that asks
the user whether to proceed.
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
The command loop keeps a history of the complex commands that have
been executed, to make it convenient to repeat these commands. A
complex command is one for which the interactive argument reading
uses the minibuffer. This includes any M-x command, any
M-: command, and any command whose interactive
specification reads an argument from the minibuffer. Explicit use of
the minibuffer during the execution of the command itself does not cause
the command to be considered complex.
This variable’s value is a list of recent complex commands, each
represented as a form to evaluate. It continues to accumulate all
complex commands for the duration of the editing session, but when it
reaches the maximum size (specified by the variable
history-length
), the oldest elements are deleted as new ones are
added.
command-history ⇒ ((switch-to-buffer "chistory.texi") (describe-key "^X^[") (visit-tags-table "~/emacs/src/") (find-tag "repeat-complex-command")) |
This history list is actually a special case of minibuffer history (see section Minibuffer History), with one special twist: the elements are expressions rather than strings.
There are a number of commands devoted to the editing and recall of
previous commands. The commands repeat-complex-command
, and
list-command-history
are described in the user manual
(see (emacs)Repetition section ‘Repetition’ in The GNU Emacs Manual). Within the
minibuffer, the usual minibuffer history commands are available.
[ << ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
This document was generated by Yasutaka SHINDOH on April 18, 2010 using texi2html 1.82.