Next: Code Characters for interactive, Up: Defining Commands   [Contents][Index]

22.2.1 Using interactive ¶

This section describes how to write the interactive form that makes a Lisp function an interactively-callable command, and how to examine a command’s interactive form.

Special Form: interactive &optional arg-descriptor &rest modes ¶

This special form declares that a function 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 must be located at top-level in the function body, or in the function symbol’s interactive-form property (see Symbol Properties). It has its effect because the command loop looks for it before calling the function (see Interactive Call). Once the function is called, all its body forms are executed; at this time, if the interactive form occurs within the body, the form simply returns nil without even evaluating its argument.

The modes list allows specifying which modes the command is meant to be used in. See Specifying Modes For Commands, for more details about the effect of specifying modes, and when to use it.

By convention, you should put the interactive form in the function body, as the first top-level form. If there is an interactive form in both the interactive-form symbol property and the function body, the former takes precedence. The interactive-form symbol property can be used to add an interactive form to an existing function, or change how its arguments are processed interactively, without redefining the function.

There are three possibilities for the argument arg-descriptor:

• It may be omitted or nil; then the command is called with no arguments. This leads quickly to an error if the command requires one or more arguments.
• It may be a string; its contents are a sequence of elements separated by newlines, one for each argument¹⁹. Each element consists of a code character (see Code Characters for interactive) optionally followed by a prompt (which some code characters use and some ignore). Here is an example:

  (interactive "P\nbFrobnicate buffer: ")
  

  The code letter ‘P’ sets the command’s first argument to the raw command prefix (see Prefix Command Arguments). ‘bFrobnicate buffer: ’ prompts the user with ‘Frobnicate buffer: ’ to enter the name of an existing buffer, which becomes the second and final argument.

  The prompt string can use ‘%’ to include previous argument values (starting with the first argument) in the prompt. This is done using format-message (see 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 ‘*’ appears at the beginning of the string, then an error is signaled if the buffer is read-only.

  If ‘@’ appears at the beginning of the string, 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.

  If ‘^’ appears at the beginning of the string, and if the command was invoked through shift-translation, set the mark and activate the region temporarily, or extend an already active region, before the command is run. If the command was invoked without shift-translation, and the region is temporarily active, deactivate the region before the command is run. Shift-translation is controlled on the user level by shift-select-mode; see Shift Selection in The GNU Emacs Manual.

  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 ‘^’).

• It may be a Lisp expression that is not a string; then it should be a form that is evaluated to get a list of arguments to pass to the command. Usually this form will call various functions to read input from the user, most often through the minibuffer (see Minibuffers) or directly from the keyboard (see Reading Input).

  Providing point or the mark as an argument value is also common, but if you do this and read input (whether using the minibuffer or not), be sure to get the integer values of point or the mark after reading. 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 after reading the keyboard input:

  (interactive
   (let ((string (read-string "Foo: " nil 'my-history)))
     (list (region-beginning) (region-end) string)))
  

  Warning: the argument values should not include any data types that can’t be printed and then read. Some facilities save command-history in a file to be read in the subsequent sessions; if a command’s arguments contain a data type that prints using ‘#<…>’ syntax, those facilities won’t work.

  There are, however, a few exceptions: it is ok to use a limited set of expressions such as (point), (mark), (region-beginning), and (region-end), because Emacs recognizes them specially and puts the expression (rather than its value) into the command history. To see whether the expression you wrote is one of these exceptions, run the command, then examine (car command-history).

Function: interactive-form function ¶

This function returns the interactive form of function. If function is an interactively callable function (see Interactive Call), the value is the command’s interactive form (interactive spec), which specifies how to compute its arguments. Otherwise, the value is nil. If function is a symbol, its function definition is used. When called on an OClosure, the work is delegated to the generic function oclosure-interactive-form.

Function: oclosure-interactive-form function ¶

Just like interactive-form, this function takes a command and returns its interactive form. The difference is that it is a generic function and it is only called when function is an OClosure (see Open Closures). The purpose is to make it possible for some OClosure types to compute their interactive forms dynamically instead of carrying it in one of their slots.

This is used for example for kmacro functions in order to reduce their memory size, since they all share the same interactive form. It is also used for advice functions, where the interactive form is computed from the interactive forms of its components, so as to make this computation more lazily and to correctly adjust the interactive form when one of its component’s is redefined.

Next: Examples of Using interactive, Previous: Using interactive, Up: Defining Commands   [Contents][Index]

22.2.2 Code Characters for interactive ¶

The code character descriptions below contain a number of key words, defined here as follows:

Completion ¶

Provide completion. TAB, SPC, and RET perform name completion because the argument is read using completing-read (see Completion). ? displays a list of possible completions.

Existing

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.

Default ¶

A default value of some sort is used if the user enters no text in the minibuffer. The default depends on the code character.

No I/O

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.

Prompt

A prompt immediately follows the code character. The prompt ends either with the end of the string or with a newline.

Special

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. Note that many Emacs primitives will signal an error if a command attempts to modify text of a read-only buffer, even if the command’s interactive spec does not include ‘*’. So this character is for when you want to forcibly signal an error even if the command’s implementation doesn’t invoke any primitives which modify the buffer, or if you want to avoid processing or side effects of a command that will fail later due to buffer modifications. For example, a command that binds inhibit-read-only non-nil (because it affects more than just read-only buffers), or a command which, depending on the conditions, might end up not modifying the buffer, but you want it to signal this error anyway.

‘@’

Select the window mentioned in the first mouse event in the key sequence that invoked this command. Special.

‘^’

If the command was invoked through shift-translation, set the mark and activate the region temporarily, or extend an already active region, before the command is run. If the command was invoked without shift-translation, and the region is temporarily active, deactivate the region before the command is run. Special.

‘a’

A function name (i.e., a symbol satisfying fboundp). Existing, Completion, Prompt.

‘b’

The name of an existing buffer. By default, uses the name of the current buffer (see Buffers). Existing, Completion, Default, Prompt.

‘B’

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.

‘c’

A character. The cursor does not move into the echo area. Prompt.

‘C’

A command name (i.e., a symbol satisfying commandp). Existing, Completion, Prompt.

‘d’ ¶

The position of point, as an integer (see Point). No I/O.

‘D’

A directory. The default is the current default directory of the current buffer, default-directory (see Functions that Expand Filenames). Existing, Completion, Default, Prompt.

‘e’

The first or next non-keyboard 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 Input Events. No I/O.

You use ‘e’ for mouse events and for special system events (see Miscellaneous System Events). The event list that the command receives depends on the event. See Input Events, which describes the forms of the list for each event in the corresponding subsections.

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.

‘f’

A file name of an existing file (see File Names). See Reading File Names, for details about default values. Existing, Completion, Default, Prompt.

‘F’

A file name. The file need not exist. Completion, Default, Prompt.

‘G’

A file name. The file need not exist. If the user enters just a directory name, then the value is just that directory name, with no file name within the directory added. Completion, Default, Prompt.

‘i’

An irrelevant argument. This code always supplies nil as the argument’s value. No I/O.

‘k’

A key sequence (see Key Sequences). 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.

If ‘k’ reads a key sequence that ends with a down-event, it also reads and discards the following up-event. You can get access to that up-event with the ‘U’ code character.

This kind of input is used by commands such as describe-key and keymap-global-set.

‘K’

A key sequence on a form that can be used as input to functions like keymap-set. 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 (see Key Sequence Input), so this form is usually used when prompting for a new key sequence that is to be bound to a command.

‘m’ ¶

The position of the mark, as an integer. No I/O.

‘M’

Arbitrary text, read in the minibuffer using the current buffer’s input method, and returned as a string (see Input Methods in The GNU Emacs Manual). Prompt.

‘n’

A number, read with the minibuffer. If the input is not a number, the user has to try again. ‘n’ never uses the prefix argument. Prompt.

‘N’

The numeric prefix argument; but if there is no prefix argument, read a number as with n. The value is always a number. See Prefix Command Arguments. Prompt.

‘p’ ¶

The numeric prefix argument. (Note that this ‘p’ is lower case.) No I/O.

‘P’ ¶

The raw prefix argument. (Note that this ‘P’ is upper case.) No I/O.

‘r’ ¶

Point and the mark, as two numeric arguments, smallest first. This and the following are the only code letters that specify two successive arguments rather than one. ‘r’ will signal an error if the mark is not set in the buffer which is current when the command is invoked. If Transient Mark mode is turned on (see The Mark) — as it is by default — and user option mark-even-if-inactive is nil, Emacs will signal an error even if the mark is set, but is inactive. No I/O.

‘R’

Point and the mark, as two numeric arguments, smallest first, but only if the region is active and it is appropriate to act on it, in the sense of use-region-p (see The Region). Otherwise supplies nil twice, for each of the successive arguments. This code letter never signals an error because if the mark is not set, use-region-p just returns nil. Use this code letter instead of ‘r’ for commands which act specially on an active region. No I/O.

‘s’

Arbitrary text, read in the minibuffer and returned as a string (see 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.

‘S’

An interned symbol whose name is read in the minibuffer. Terminate the input with either C-j or RET. Other characters that normally terminate a symbol (e.g., whitespace, parentheses and brackets) do not do so here. Prompt.

‘U’

A key sequence or nil. Can be used after a ‘k’ or ‘K’ argument to get the up-event that was discarded (if any) after ‘k’ or ‘K’ read a down-event. If no up-event has been discarded, ‘U’ provides nil as the argument. No I/O.

‘v’

A variable declared to be a user option (i.e., satisfying the predicate custom-variable-p). This reads the variable using read-variable. See Definition of read-variable. Existing, Completion, Prompt.

‘x’

A Lisp object, specified with its read syntax, terminated with a C-j or RET. The object is not evaluated. See Reading Lisp Objects with the Minibuffer. Prompt.

‘X’ ¶

A Lisp form’s value. ‘X’ reads as ‘x’ does, then evaluates the form so that its value becomes the argument for the command. Prompt.

‘z’

A coding system name (a symbol). If the user enters null input, the argument value is nil. See Coding Systems. Completion, Existing, Prompt.

‘Z’

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.

Next: Specifying Modes For Commands, Previous: Code Characters for interactive, Up: Defining Commands   [Contents][Index]

22.2.3 Examples of Using interactive ¶

Here are some examples of interactive:

(defun foo1 ()              ; foo1 takes no arguments,
    (interactive)           ;   just moves forward two words.
    (forward-word 2))
     ⇒ foo1

(defun foo2 (n)             ; foo2 takes one argument,
    (interactive "^p")      ;   which is the numeric prefix.
                            ; under shift-select-mode,
                            ;   will activate or extend region.
    (forward-word (* 2 n)))
     ⇒ foo2

(defun foo3 (n)             ; foo3 takes one argument,
    (interactive "nCount:") ;   which is read with the Minibuffer.
    (forward-word (* 2 n)))
     ⇒ foo3

(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

Next: Select among Command Alternatives, Previous: Examples of Using interactive, Up: Defining Commands   [Contents][Index]

22.2.4 Specifying Modes For Commands ¶

Many commands in Emacs are general, and not tied to any specific mode. For instance, M-x kill-region can be used in pretty much any mode that has editable text, and commands that display information (like M-x list-buffers) can be used in pretty much any context.

Many other commands, however, are specifically tied to a mode, and make no sense outside of that context. For instance, M-x dired-diff will just signal an error if used outside of a Dired buffer.

Emacs therefore has a mechanism for specifying what mode (or modes) a command “belongs” to:

(defun dired-diff (...)
  ...
  (interactive "p" dired-mode)
  ...)

This will mark the command as applicable to dired-mode only (or any modes that are derived from dired-mode). Any number of modes can be added to the interactive form.

Specifying modes affects command completion in M-S-x (execute-extended-command-for-buffer, see Interactive Call). It may also affect completion in M-x, depending on the value of read-extended-command-predicate.

For instance, when using the command-completion-default-include-p predicate as the value of read-extended-command-predicate, M-x won’t list commands that have been marked as being applicable to a specific mode (unless you are in a buffer that uses that mode, of course). This goes for both major and minor modes. (By contrast, M-S-x always omits inapplicable commands from the completion candidates.)

By default, read-extended-command-predicate is nil, and completion in M-x lists all the commands that match what the user has typed, whether those commands are or aren’t marked as applicable to the current buffer’s mode.

Marking commands to be applicable to a mode will also make C-h m list these commands (if they aren’t bound to any keys).

If using this extended interactive form isn’t convenient (because the code is supposed to work in older versions of Emacs that don’t support the extended interactive form), the following equivalent declaration (see The declare Form) can be used instead:

(declare (modes dired-mode))

Which commands to tag with modes is to some degree a matter of taste, but commands that clearly do not work outside of the mode should be tagged. This includes commands that will signal an error if called from somewhere else, but also commands that are destructive when called from an unexpected mode. (This usually includes most of the commands that are written for special (i.e., non-editing) modes.)

Some commands may be harmless, and “work” when called from other modes, but should still be tagged with a mode if they don’t actually make much sense to use elsewhere. For instance, many special modes have commands to exit the buffer bound to q, and may not do anything but issue a message like "Goodbye from this mode" and then call kill-buffer. This command will “work” from any mode, but it is highly unlikely that anybody would actually want to use the command outside the context of this special mode.

Many modes have a set of different commands that start the mode in different ways (e.g., eww-open-in-new-buffer and eww-open-file). Commands like that should never be tagged as mode-specific, as they can be issued by the user from pretty much any context.

Previous: Specifying Modes For Commands, Up: Defining Commands   [Contents][Index]

22.2.5 Select among Command Alternatives ¶

Sometimes it is useful to define a command that serves as a “generic dispatcher” capable of invoking one of a set of commands according to the user’s needs. For example, imagine that you want to define a command named ‘open’ that can “open” and display several different types of objects. Or you could have a command named ‘mua’ (which stands for Mail User Agent) that can read and send email using one of several email backends, such as Rmail, Gnus, or MH-E. The macro define-alternatives can be used to define such generic commands. A generic command is an interactive function whose implementation can be selected from several alternatives, as a matter of user preference.

Macro: define-alternatives command &rest customizations ¶

This macro defines the new generic command, which can have several alternative implementations. The argument command should be an unquoted symbol.

When invoked, the macro creates an interactive Lisp closure (see Closures). When the user runs M-x command RET for the first time, Emacs asks to select one of the alternative implementations of command, offering completion for the names of these alternatives. These names come from the user option whose name is command-alternatives, which the macro creates (if it didn’t exist before). To be useful, this variable’s value should be an alist whose elements have the form (alt-name . alt-func), where alt-name is the name of the alternative and alt-func is the interactive function to be called if this alternative is selected. When the user selects an alternative, Emacs remembers the selection, and will thereafter automatically call that selected alternative without prompting when the user invokes M-x command again. To choose a different alternative, type C-u M-x command RET–then Emacs will again prompt for one of the alternatives, and the selection will override the previous one.

The variable command-alternatives can be created before calling define-alternatives, with the appropriate values; otherwise the macro creates the variable with a nil value, and it should then be populated with the associations describing the alternatives. Packages that wish to provide their own implementation of an existing generic command can use autoload cookies (see Autoload) to add to the alist, for example:

;;;###autoload (push '("My name" . my-foo-symbol) foo-alternatives

If the optional argument customizations is non-nil, it should consist of alternating defcustom keywords (typically :group and :version) and values to add to the definition of the defcustom command-alternatives.

Here is an example of a simple generic dispatcher command named open with 3 alternative implementations:

(define-alternatives open
  :group 'files
  :version "42.1")

(setq open-alternatives
      '(("file" . find-file)
	("directory" . dired)
	("hexl" . hexl-find-file)))

Next: Function Keys, Up: Input Events   [Contents][Index]

22.7.1 Keyboard Events ¶

There are two kinds of input you can get from the keyboard: ordinary keys, and function keys. Ordinary keys correspond to (possibly modified) characters; the events they generate are represented in Lisp as characters. The event type of a character event is the character itself (an integer), which might have some modifier bits set; see Classifying Events.

An input character event consists of a basic code between 0 and 524287, plus any or all of these modifier bits:

meta

The 2**27 bit in the character code indicates a character typed with the meta key held down.

control

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), i.e. with the 27th bit set.

shift

The 2**25 bit (the 26th bit) in the character event 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 character events.

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.

hyper

The 2**24 bit in the character event code indicates a character typed with the hyper key held down.

super

The 2**23 bit in the character event code indicates a character typed with the super key held down.

alt

The 2**22 bit in the character event code indicates a character typed with the alt key held down. (The key labeled Alt on most keyboards is actually treated as the meta key, not this.)

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 Classifying Events). When making key bindings with keymap-set, you specify these events using strings like ‘C-H-x’ instead (for “control hyper x”) (see Changing Key Bindings).

Next: Mouse Events, Previous: Keyboard Events, Up: Input Events   [Contents][Index]

22.7.2 Function Keys ¶

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 generates an input event represented by the symbol f1.

The event type of a function key event is the event symbol itself. See 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 local-function-key-map (see Keymaps for Translating Sequences of 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:

‘A-’

The alt modifier.

‘C-’

The control modifier.

‘H-’

The hyper modifier.

‘M-’

The meta modifier.

‘S-’

The shift modifier.

‘s-’

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.

Next: Click Events, Previous: Function Keys, Up: Input Events   [Contents][Index]

22.7.3 Mouse Events ¶

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 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 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.

Next: Drag Events, Previous: Mouse Events, Up: Input Events   [Contents][Index]

22.7.4 Click Events ¶

When the user presses a mouse button and releases it at the same location, that generates a click event. Depending on how your window-system reports mouse-wheel events, turning the mouse wheel can generate either a mouse click or a mouse-wheel event. All mouse event share the same format:

(event-type position click-count)

event-type

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. For mouse-wheel event, it can be wheel-up or wheel-down.

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.

position ¶

This is a mouse position list specifying where the mouse event occurred; see below for details.

click-count

This is the number of rapid repeated presses so far of the same mouse button or the number of repeated turns of the wheel. See Repeat Events.

To access the contents of a mouse position list in the position slot of a mouse event, you should typically use the functions documented in Accessing Mouse Events.

The explicit format of the list depends on where the event occurred. For clicks in the text area, mode line, header line, tab line, or in the fringe or marginal areas, the mouse position list has the form

(window pos-or-area (x . y) timestamp
 object text-pos (col . row)
 image (dx . dy) (width . height))

The meanings of these list elements are as follows:

window

The window in which the mouse event occurred.

pos-or-area

The buffer position of the character clicked on in the text area; or, if the event was outside the text area, the window area where it occurred. It is one of the symbols mode-line, header-line, tab-line, vertical-line, left-margin, right-margin, left-fringe, or right-fringe.

In one special case, pos-or-area 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 registered by Emacs. See Key Sequence Input.

x, y

The relative pixel coordinates of the event. For events in the text area of a window, the coordinate origin (0 . 0) is taken to be the top left corner of the text area. See Window Sizes. For events in a mode line, header line or tab line, the coordinate origin is the top left corner of the window itself. For fringes, margins, and the vertical border, x does not have meaningful data. For fringes and margins, y is relative to the bottom edge of the header line. In all cases, the x and y coordinates increase rightward and downward respectively.

timestamp

The time at which the event occurred, as an integer number of milliseconds since a system-dependent initial time.

object

Either nil, which means the event occurred on buffer text, or a cons cell of the form (string . string-pos) if there is a string from a text property or an overlay at the event position.

string

The string which was clicked on, including any properties.

string-pos

The position in the string where the click occurred.

text-pos

For clicks on a marginal area or on a fringe, this is the buffer position of the first visible character in the corresponding line in the window. For clicks on the mode line, the header line or the tab line, this is nil. For other events, it is the buffer position closest to the click.

col, row

These are the actual column and row coordinate numbers of the glyph under the x, y position. If x lies beyond the last column of actual text on its line, col is reported by adding fictional extra columns that have the default character width. Row 0 is taken to be the header line if the window has one, or Row 1 if the window also has the tab line, or the topmost row of the text area otherwise. Column 0 is taken to be the leftmost column of the text area for clicks on a window text area, or the leftmost mode line or header line column for clicks there. For clicks on fringes or vertical borders, these have no meaningful data. For clicks on margins, col is measured from the left edge of the margin area and row is measured from the top of the margin area.

image

If there is an image at the click location, this is the image object as returned by find-image (see Defining Images); otherwise this is nil.

dx, dy

These are the pixel offsets of the click relative to the top left corner of the object’s glyph that is the nearest one to the click. The relevant objects can be either a buffer, or a string, or an image, see above. If object is nil or a string, the coordinates are relative to the top left corner of the character glyph clicked on. Note that the offsets are always zero on text-mode frames, when object is nil, since each glyph there is considered to have exactly 1x1 pixel dimensions.

width, height

If the click is on a character, either from buffer text or from overlay or display string, these are the pixel width and height of that character’s glyph; otherwise they are dimensions of object clicked on.

For clicks on a scroll bar, position has this form:

(window area (portion . whole) timestamp part)

window

The window whose scroll bar was clicked on.

area

This is the symbol vertical-scroll-bar.

portion

The number of pixels from the top of the scroll bar to the click position. On some toolkits, including GTK+, Emacs cannot extract this data, so the value is always 0.

whole

The total length, in pixels, of the scroll bar. On some toolkits, including GTK+, Emacs cannot extract this data, so the value is always 0.

timestamp

The time at which the event occurred, in milliseconds. On some toolkits, including GTK+, Emacs cannot extract this data, so the value is always 0.

part

The part of the scroll bar on which the click occurred. It is one of the symbols handle (the scroll bar handle), above-handle (the area above the handle), below-handle (the area below the handle), up (the up arrow at one end of the scroll bar), or down (the down arrow at one end of the scroll bar).

For clicks on the frame’s internal border (see Frame Layout), the frame’s tool bar (see Tool bars) or tab bar or menu bar, position has this form:

 (frame part (X . Y) timestamp object)

frame

The frame whose internal border or tool bar or tab bar or menu bar was clicked on.

part

The part of the frame which was clicked on. This can be one of the following:

tool-bar ¶

The frame has a tool bar, and the event was in the tool-bar area.

tab-bar ¶

The frame has a tab bar, and the event was in the tab-bar area.

menu-bar ¶

The event was on the frame’s menu bar area. This kind of click event can happen only on text-only frames or on X frames in a non-toolkit build of Emacs. (In toolkit builds of Emacs, menu-bar clicks are handled by the toolkit, and are not visible to Emacs as click events.)

left-edge

top-edge

right-edge

bottom-edge

The click was on the corresponding border at an offset of at least one canonical character from the border’s nearest corner.

top-left-corner

top-right-corner

bottom-right-corner

bottom-left-corner

The click was on the corresponding corner of the internal border.

nil

The frame does not have an internal border, and the event was not on the tab bar or the tool bar. This usually happens on text-mode frames. This can also happen on GUI frames with internal border if the frame doesn’t have its drag-internal-border parameter (see Mouse Dragging Parameters) set to a non-nil value.

object

This member is present only for clicks on the tab bar, and it is the propertized string with information about the clicked button.

Next: Button-Down Events, Previous: Click Events, Up: Input Events   [Contents][Index]

22.7.5 Drag Events ¶

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 start-position end-position)

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, start-position and end-position in the foregoing illustration, are set to the start and end positions of the drag as mouse position lists (see Click Events). You can access the second element of any mouse event in the same way. However, the drag event may end outside the boundaries of the frame that was initially selected. In that case, the third element’s position list contains that frame in place of a window.

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.

Next: Repeat Events, Previous: Drag Events, Up: Input Events   [Contents][Index]

22.7.6 Button-Down Events ¶

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.²⁰ These occur as soon as a button is pressed. They are represented by lists that look exactly like click events (see 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 Motion Events.

Next: Motion Events, Previous: Button-Down Events, Up: Input Events   [Contents][Index]

22.7.7 Repeat Events ¶

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.

Function: event-click-count event ¶

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.

User Option: double-click-fuzz ¶

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 (horizontally or vertically) between two successive clicks to make a double-click.

This variable is also the threshold for motion of the mouse to count as a drag.

User Option: double-click-time ¶

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.

Next: Touchscreen Events, Previous: Repeat Events, Up: Input Events   [Contents][Index]

22.7.8 Motion Events ¶

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 POSITION)

position is a mouse position list (see Click Events), specifying the current position of the mouse cursor. As with the end-position of a drag event, this position list may represent a location outside the boundaries of the initially selected frame, in which case the list contains that frame in place of a window.

The track-mouse macro enables generation of motion events within its body. Outside of track-mouse body, Emacs does not generate events for mere motion of the mouse, and these events do not appear. See Mouse Tracking.

Variable: mouse-fine-grained-tracking ¶

When non-nil, mouse motion events are generated even for very small movements. Otherwise, motion events are not generated as long as the mouse cursor remains pointing to the same glyph in the text.

Next: Focus Events, Previous: Motion Events, Up: Input Events   [Contents][Index]

22.7.9 Touchscreen Events ¶

Some window systems provide support for input devices that react to the user’s touching the screen and moving fingers while touching the screen. These input devices are known as touchscreens, and Emacs reports the events they generate as touchscreen events.

Most individual events generated by a touchscreen only have meaning as part of a larger sequence of other events: for instance, the simple operation of tapping the touchscreen involves the user placing and raising a finger on the touchscreen, and swiping the display to scroll it involves placing a finger, moving it many times upwards or downwards, and then raising the finger.

While a simplistic model consisting of one finger is adequate for taps and scrolling, more complicated gestures require support for keeping track of multiple fingers, where the position of each finger is represented by a touch point. For example, a “pinch to zoom” gesture might consist of the user placing two fingers and moving them individually in opposite directions, where the distance between the positions of their individual points determine the amount by which to zoom the display, and the center of an imaginary line between those positions determines where to pan the display after zooming.

The low-level touchscreen events described below can be used to implement all the touch sequences described above. In those events, each point is represented by a cons of an arbitrary number identifying the point and a mouse position list (see Click Events) specifying the position of the finger when the event occurred.

(touchscreen-begin point) ¶

This event is sent when point is created by the user pressing a finger against the touchscreen.

Imaginary prefix keys are also affixed to these events read-key-sequence when they originate on top of a special part of a frame or window. See Key Sequence Input.

(touchscreen-update points) ¶

This event is sent when a point on the touchscreen has changed position. points is a list of touch points containing the up-to-date positions of each touch point currently on the touchscreen.

(touchscreen-end point canceled) ¶

This event is sent when point is no longer present on the display, because another program took the grab, or because the user raised the finger from the touchscreen.

canceled is non-nil if the touch sequence has been intercepted by another program (such as the window manager), and Emacs should undo or avoid any editing commands that would otherwise result from the touch sequence.

Imaginary prefix keys are also affixed to these events read-key-sequence when they originate on top of a special part of a frame or window.

If a touchpoint is pressed against the menu bar, then Emacs will not generate any corresponding touchscreen-begin or touchscreen-end events; instead, the menu bar may be displayed after touchscreen-end would have been delivered under other circumstances.

When no command is bound to touchscreen-begin, touchscreen-end or touchscreen-update, Emacs calls a “key translation function” (see Keymaps for Translating Sequences of Events) to translate key sequences containing touch screen events into ordinary mouse events (see Mouse Events.) Since Emacs doesn’t support distinguishing events originating from separate mouse devices, it assumes that a maximum of two touchpoints are active while translation takes place, and does not place any guarantees on the results of event translation when that restriction is overstepped.

Emacs applies two different strategies for translating touch events into mouse events, contingent on factors such as the commands bound to keymaps that are active at the location of the touchscreen-begin event. If a command is bound to down-mouse-1 at that location, the initial translation consists of a single down-mouse-1 event, with subsequent touchscreen-update events translated to mouse motion events (see Motion Events), and a final touchscreen-end event translated to a mouse-1 or drag-mouse-1 event (unless the touchscreen-end event indicates that the touch sequence has been intercepted by another program.) This is dubbed “simple translation”, and produces a simple correspondence between touchpoint motion and mouse motion.

However, some commands bound to down-mouse-1–mouse-drag-region, for example–either conflict with defined touch screen gestures (such as “long-press to drag”), or with user expectations for touch input, and should not subject the touch sequence to simple translation. If a command whose name contains the property (see Symbol Properties) ignored-mouse-command is encountered or there is no command bound to down-mouse-1, a more irregular form of translation takes place: here, Emacs processes touch screen gestures (see Touchscreens in The GNU Emacs Manual) first, and finally attempts to translate touch screen events into mouse events if no gesture was detected prior to a closing touchscreen-end event (with its canceled parameter nil, as with simple translation) and a command is bound to mouse-1 at the location of that event. Before generating the mouse-1 event, point is also set to the location of the touchscreen-end event, and the window containing the position of that event is selected, as a compromise for packages which assume mouse-drag-region has already set point to the location of any mouse click and selected the window where it took place.

To prevent unwanted mouse-1 events from arriving after a mouse menu is dismissed (see Menus and the Mouse), Emacs also disables simple translation if down-mouse-1 is bound to a keymap, making it a prefix key. In lieu of simple translation, it translates the closing touchscreen-end to a down-mouse-1 event with the starting position of the touch sequence, consequently displaying the mouse menu.

Simple conversion will be enabled without regard to the existence of command or menu bindings if the variable touch-screen-simple-mouse-conversion is bound or set to a non-nil value, as, for example, it may be by a caller of read-key expecting to receive mouse-movement and drag-mouse-1 events.

Since certain commands are also bound to down-mouse-1 for the purpose of displaying pop-up menus, Emacs additionally behaves as illustrated in the last paragraph if down-mouse-1 is bound to a command whose name has the property mouse-1-menu-command.

When a second touch point is registered as a touch point is already being translated, gesture translation is terminated, and the distance from the second touch point (the ancillary tool) to the first is measured. Subsequent motion from either of those touch points will yield touchscreen-pinch events incorporating the ratio formed by the distance between their new positions and the distance measured at the outset, as illustrated in the following table.

If touch gestures are detected during translation, one of the following input events may be generated:

(touchscreen-scroll window dx dy) ¶

If a “scrolling” gesture is detected during the translation process, each subsequent touchscreen-update event is translated to a touchscreen-scroll event, where dx and dy specify, in pixels, the relative motion of the touchpoint from the position of the touchscreen-begin event that started the sequence or the last touchscreen-scroll event, whichever came later.

(touchscreen-hold posn) ¶

If the single active touchpoint remains stationary for more than touch-screen-delay seconds after a touchscreen-begin is generated, a “long-press” gesture is detected during the translation process, and a touchscreen-hold event is sent, with posn set to a mouse position list containing the position of the touchscreen-begin event.

(touchscreen-drag posn) ¶

If a “long-press” gesture is detected while translating the current touch sequence or “drag-to-select” is being resumed as a result of the touch-screen-extend-selection user option, a touchscreen-drag event is sent upon each subsequent touchscreen-update event with posn set to the new position of the touchpoint.

(touchscreen-restart-drag posn) ¶

This event is sent upon the start of a touch sequence resulting in the continuation of a “drag-to-select” gesture (subject to the aforementioned user option) with posn set to the position list of the initial touchscreen-begin event within that touch sequence.

(touchscreen-pinch posn ratio pan-x pan-y ratio-diff) ¶

This event is delivered upon significant changes to the positions of either active touch point when an ancillary tool is active.

posn is a mouse position list for the midpoint of a line drawn from the ancillary tool to the other touch point being observed.

ratio is the distance between both touch points being observed divided by that distance when the ancillary point was first registered; which is to say, the scale of the “pinch” gesture.

pan-x and pan-y are the difference between the pixel position of posn and this position within the last event delivered appertaining to this series of touch events, or in the case that no such event exists, the centerpoint between both touch points when the ancillary tool was first registered.

ratio-diff is the difference between this event’s ratio and ratio in the last event delivered; it is ratio if no such event exists.

Such events are sent when the magnitude of the changes they represent will yield a ratio which differs by more than 0.2 from that in the previous event, or the sum of pan-x and pan-y will surpass half the frame’s character width in pixels (see Frame Font).

Several functions are provided for Lisp programs that handle touch screen events. The intended use of the first two functions described below is from commands bound directly to touchscreen-begin events; they allow responding to commonly used touch screen gestures separately from mouse event translation.

Function: touch-screen-track-tap event &optional update data threshold ¶

This function is used to track a single “tap” gesture originating from the touchscreen-begin event event, often used to set the point or to activate a button. It waits for a touchscreen-end event with the same touch identifier to arrive, at which point it returns t, signifying the end of the gesture.

If a touchscreen-update event arrives in the mean time and contains at least one touchpoint with the same identifier as in event, the function update is called with two arguments, the list of touchpoints in that touchscreen-update event, and data.

If threshold is non-nil and such an event indicates that the touchpoint represented by event has moved beyond a threshold of either threshold or 10 pixels if it is not a number from the position of event, nil is returned and mouse event translation is resumed for that touchpoint, so as not to impede the recognition of any subsequent touchscreen gesture arising from its sequence.

If any other event arrives in the mean time, nil is returned. The caller should not perform any action in that case.

Function: touch-screen-track-drag event update &optional data ¶

This function is used to track a single “drag” gesture originating from the touchscreen-begin event event.

It behaves like touch-screen-track-tap, except that it returns no-drag and refrains from calling update if the touchpoint in event did not move far enough (by default, 5 pixels from its position in event) to qualify as an actual drag.

In addition to those two functions, a function is provided for commands bound to some types of events generated through mouse event translation to prevent unwanted events from being generated after it is called.

Function: touch-screen-inhibit-drag ¶

This function inhibits the generation of touchscreen-drag events during mouse event translation for the duration of the touch sequence being translated after it is called. It must be called from a command which is bound to a touchscreen-hold or touchscreen-drag event, and signals an error otherwise.

Since this function can only be called after a gesture is already recognized during mouse event translation, no mouse events will be generated from touch events constituting the previously mentioned touch sequence after it is called.

Next: Xwidget events, Previous: Touchscreen Events, Up: Input Events   [Contents][Index]

22.7.10 Focus Events ¶

This section talks about both window systems and Emacs frames. When talking about just “frames” or “windows”, it refers to Emacs frames and Emacs windows. When talking about window system windows, which are also Emacs frames, this section always says “window system window”.

Window systems provide general ways for the user to control which window system window, or Emacs frame, gets keyboard input. This choice of window system window is called the focus. When the user does something to switch between Emacs frames, that generates a focus event. Emacs also generates focus events when using mouse-autoselect-window to switch between Emacs windows within Emacs frames.

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.

Focus events for frames ¶

The normal definition of a focus event that switches frames, in the global keymap, is to select that new frame within Emacs, as the user would expect. See Input Focus, which also describes hooks related to focus events for frames. Focus events for frames are represented in Lisp as lists that look like this:

(switch-frame new-frame)

where new-frame is the frame switched to.

Some X window managers are set up so that just moving the mouse into a frame is enough to set the focus there. Usually, there is no need for a Lisp program to know about the focus change until some other kind of input arrives. 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.

Focus events for windows ¶

When mouse-autoselect-window is set, moving the mouse over a new window within a frame can also switch the selected window. See Mouse Window Auto-selection, which describes the behavior for different values. When the mouse is moved over a new window, a focus event for switching windows is generated. Focus events for windows are represented in Lisp as lists that look like this:

(select-window new-window)

where new-window is the window switched to.

Next: Miscellaneous System Events, Previous: Focus Events, Up: Input Events   [Contents][Index]

22.7.11 Xwidget events ¶

Xwidgets (see Embedded Native Widgets) can send events to update Lisp programs on their status. These events are dubbed xwidget-events, and contain various data describing the nature of the change.

(xwidget-event kind xwidget arg) ¶

This event is sent whenever some kind of update occurs in xwidget. There are several types of updates, identified by their kind.

It is a special event (see Special Events), which should be handled by adding a callback to an xwidget that is called whenever an xwidget event for xwidget is received.

You can add a callback by setting the callback of an xwidget’s property list, which should be a function that accepts xwidget and kind as arguments.

load-changed ¶

This xwidget event indicates that the xwidget has reached a particular point of the page-loading process. When these events are sent, arg will contain a string that further describes the status of the widget:

‘load-started’ ¶

This means the widget has begun a page-loading operation.

‘load-finished’ ¶

This means the xwidget has finished processing whatever page-loading operation that it was previously performing.

‘load-redirected’ ¶

This means the xwidget has encountered and followed a redirect during the page-loading operation.

‘load-committed’ ¶

This means the xwidget has committed to a given URL during the page-loading operation, i.e. the URL is the final URL that will be rendered by xwidget during the current page-loading operation.

download-callback ¶

This event indicates that a download of some kind has been completed.

In the above events, there can be arguments after arg, which itself indicates the URL from which the download file was retrieved: the first argument after arg indicates the MIME type of the download, as a string, while the second argument contains the full file name of the downloaded file.

download-started ¶

This event indicates that a download has been started. In these events, arg contains the URL of the file that is currently being downloaded.

javascript-callback ¶

This event contains JavaScript callback data. These events are used internally by xwidget-webkit-execute-script.

(xwidget-display-event xwidget source) ¶

This event is sent whenever an xwidget requests that another xwidget be displayed. xwidget is the xwidget that should be displayed, and source is the xwidget that asked to display xwidget.

It is also a special event which should be handled through callbacks. You can add such a callback by setting the display-callback of source’s property list, which should be a function that accepts xwidget and source as arguments.

xwidget’s buffer will be set to a temporary buffer. When displaying the widget, care should be taken to replace the buffer with the buffer in which the xwidget will be displayed, using set-xwidget-buffer (see Embedded Native Widgets).

Next: Event Examples, Previous: Xwidget events, Up: Input Events   [Contents][Index]

22.7.12 Miscellaneous System Events ¶

A few other event types represent occurrences within the system.

text-conversion ¶

This kind of event is sent after a system-wide input method performs an edit to one or more buffers.

Once the event is sent, the input method may already have made changes to multiple buffers inside many different frames. To determine which buffers have been changed, and what edits have been made to them, use the variable text-conversion-edits, which is set prior to each text-conversion event being sent; it is a list of the form:

((buffer beg end ephemeral) ...)

Where ephemeral is the buffer which was modified, beg and end are markers set to the positions of the edit at the time it was completed, and ephemeral is either a string, containing any text which was inserted (or any text before point which was deleted), t, meaning that the edit is a temporary edit made by the input method, or nil, meaning that some text was deleted after point.

Whether or not this event is sent depends on the value of the buffer-local variable text-conversion-style, which determines how an input method that wishes to make edits to buffer contents will behave.

This variable can have one of four values:

nil

This means that the input method will be disabled entirely, and key events will be sent instead of text conversion events.

action

This means that the input method will be enabled, but RET will be sent whenever the input method wants to insert a new line.

password

This is largely identical to action, but also requests an input method capable of inserting ASCII characters, and instructs it not to save input in locations from which it might be subsequently retrieved by features of the input method that cannot handle sensitive information, such as text suggestions.

t

This, or any other value, means that the input method will be enabled and make edits followed by text-conversion events.

Changes to the value of this variable will only take effect upon the next redisplay after the buffer becomes the selected buffer of a frame. If you need to disable text conversion in a way that takes immediate effect, call the function set-text-conversion-style instead. This has the potential to lock up the input method for a significant amount of time, and should be used with care.

In addition, text conversion is automatically disabled after a prefix key is read by the command loop or read-key-sequence. This can be disabled by setting or binding the variable disable-inhibit-text-conversion to a non-nil value.

(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.

(touch-end (position)) ¶

This kind of event indicates that the user’s finger moved off the mouse wheel or the touchpad. The position element is a mouse position list (see Click Events), specifying the position of the mouse cursor when the finger moved off the mouse wheel.

(wheel-up position clicks lines pixel-delta) ¶

(wheel-down position clicks lines pixel-delta)

These events are generated by moving a mouse wheel. The position element is a mouse position list (see Click Events), specifying the position of the mouse cursor when the event occurred.

clicks, if present, is the number of times that the wheel was moved in quick succession. See Repeat Events. lines, if present and not nil, is the positive number of screen lines that should be scrolled (either up, when the event is wheel-up, or down when the event is wheel-down). pixel-delta, if present, is a cons cell of the form (x . y), where x and y are the numbers of pixels by which to scroll in each axis, a.k.a. pixelwise deltas. Usually, only one of the two will be non-zero, the other will be either zero or very close to zero; the larger number indicates the axis to scroll the window. When the variable mwheel-coalesce-scroll-events is nil, the scroll commands ignore the lines element, even if it’s non-nil, and use the pixel-delta data instead; in that case, the direction of scrolling is determined by the sign of the pixelwise deltas, and the direction (up or down) implied by the event kind is ignored.

You can use these x and y pixelwise deltas to determine how much the mouse wheel has actually moved at pixel resolution. For example, the pixelwise deltas could be used to scroll the display at pixel resolution, exactly according to the user’s turning the mouse wheel. This pixelwise scrolling is possible only when mwheel-coalesce-scroll-events is nil, and in general the pixel-delta data is not generated when that variable is non-nil.

The wheel-up and wheel-down events are generated only on some kinds of systems. On other systems, other events like mouse-4 and mouse-5 are used instead. Portable code should handle both wheel-up and wheel-down events as well as the events specified in the variables mouse-wheel-up-event and mouse-wheel-down-event, defined in mwheel.el. Beware that for historical reasons the mouse-wheel-up-event is the variable that holds an event that should be handled similarly to wheel-down and vice versa.

The same holds for the horizontal wheel movements which are usually represented by wheel-left and wheel-right events, but for which portable code should also obey the variables mouse-wheel-left-event and mouse-wheel-right-event, defined in mwheel.el. However, some mice also generate other events at the same time as they’re generating these scroll events which may get in the way. The way to fix this is generally to unbind these events (for instance, mouse-6 or mouse-7, but this is very hardware and operating system dependent).

(pinch position dx dy scale angle) ¶

This kind of event is generated by the user performing a “pinch” gesture by placing two fingers on a touchpad and moving them towards or away from each other. position is a mouse position list (see Click Events) that provides the position of the mouse pointer when the event occurred, dx is the change in the horizontal distance between the fingers since the last event in the same sequence, dy is the vertical movement of the fingers since the last event in the same sequence, scale is the ratio of the current distance between the fingers to that distance at the start of the sequence, and angle is the angular difference in degrees between the direction of the line connecting the fingers in this event and the direction of that line in the last event of the same sequence.

As pinch events are only sent at the beginning or during a pinch sequence, they do not report gestures where the user moves two fingers on a touchpad in a rotating fashion without pinching the fingers.

All arguments after position are floating point numbers.

This event is usually sent as part of a sequence, which begins with the user placing two fingers on the touchpad, and ends with the user removing those fingers. dx, dy, and angle will be 0.0 in the first event of a sequence; subsequent events will report non-zero values for these members of the event structure.

dx and dy are reported in imaginary relative units, in which 1.0 is the width and height of the touchpad respectively. They are usually interpreted as being relative to the size of the object beneath the gesture: image, window, etc.

(preedit-text arg) ¶

This event is sent when a system input method tells Emacs to display some text to indicate to the user what will be inserted. The contents of arg are dependent on the window system being used.

On X, arg is a string describing some text to place behind the cursor. It can be nil, which means to remove any text previously displayed.

On PGTK frames (see Frames), arg is a list of strings with information about their color and underline attributes. It has the following form:

   ((string1
     (ul . underline-color)
     (bg . background-color)
     (fg . foreground-color))
    (string2
     (ul . underline-color)
     (bg . background-color)
     (fg . foreground-color))
    ...
   )

Color information can be omitted, leaving just the text of the strings. underline-color can be t, meaning underlined text with default underline color, or it can be a string, the name of the color to draw the underline.

This is a special event (see Special Events), which normally should not be bound by the user to any command. Emacs will typically display the text contained in the event in an overlay behind point when it is received.

(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 (see Click Events), 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.

help-echo ¶

This kind of event is generated when a mouse pointer moves onto a portion of buffer text which has a help-echo text property. The generated event has this form:

(help-echo frame help window object pos)

The precise meaning of the event parameters and the way these parameters are used to display the help-echo text are described in Text help-echo.

sigusr1 ¶

sigusr2

These events are generated when the Emacs process receives the signals SIGUSR1 and SIGUSR2. They contain no additional data because signals do not carry additional information. They can be useful for debugging (see Entering the Debugger on an Error).

To catch a user signal, bind the corresponding event to an interactive command in the special-event-map (see Controlling the Active Keymaps). The command is called with no arguments, and the specific signal event is available in last-input-event (see Miscellaneous Event Input Features. For example:

(defun sigusr-handler ()
  (interactive)
  (message "Caught signal %S" last-input-event))

(keymap-set special-event-map "<sigusr1>" 'sigusr-handler)

To test the signal handler, you can make Emacs send a signal to itself:

(signal-process (emacs-pid) 'sigusr1)

(sleep-event state) ¶

This event is injected when the device Emacs is running on is about to enter a sleep state, or has just awoken from one. state will be the symbol pre-sleep or post-wake.

This is implemented on GNU/Linux, macOS, and MS-Windows.

language-change ¶

This kind of event is generated on MS-Windows when the input language has changed. This typically means that the keyboard keys will send to Emacs characters from a different language. The generated event has this form:

(language-change frame codepage language-id)

Here frame is the frame which was current when the input language changed; codepage is the new codepage number; and language-id is the numerical ID of the new input language. The coding-system (see Coding Systems) that corresponds to codepage is cpcodepage or windows-codepage. To convert language-id to a string (e.g., to use it for various language-dependent features, such as set-language-environment), use the w32-get-locale-info function, like this:

;; Get the abbreviated language name, such as "ENU" for English
(w32-get-locale-info language-id)
;; Get the full English name of the language,
;; such as "English (United States)"
(w32-get-locale-info language-id 4097)
;; Get the full localized name of the language
(w32-get-locale-info language-id t)

end-session ¶

This event is generated on MS-Windows when the operating system informs Emacs that the user terminated the interactive session, or that the system is shutting down. The standard definition of this event is to invoke the kill-emacs command (see Killing Emacs) so as to shut down Emacs in an orderly fashion; if there are unsaved changes, this will produce auto-save files (see Auto-Saving) that the user can use after restarting the session to restore the unsaved edits.

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.

Some of these special events, such as delete-frame, invoke Emacs commands by default; others are not bound. If you want to arrange for a special event to invoke a command, you can do that via special-event-map. The command you bind to a function key in that map can then examine the full event which invoked it in last-input-event. See Special Events.

Next: Classifying Events, Previous: Miscellaneous System Events, Up: Input Events   [Contents][Index]

22.7.13 Event Examples ¶

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))

The frame with input focus might not take up the entire screen, and the user might move the mouse outside the scope of the frame. Inside the track-mouse macro, that produces an event like this:

(mouse-movement (#<frame *ielm* 0x102849a30> nil (563 . 205) 532301936))

Next: Accessing Mouse Events, Previous: Event Examples, Up: Input Events   [Contents][Index]

22.7.14 Classifying Events ¶

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.

Function: event-modifiers event ¶

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. For double or triple events, it also contains double or triple.

The argument event may be an entire event object, or just an event type. If event is a symbol that has never been used in an event that has been read as input in the current Emacs session, then event-modifiers can return nil, even when event actually has modifiers.

Here are some examples:

(event-modifiers ?a)
     ⇒ nil
(event-modifiers ?A)
     ⇒ (shift)
(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’. Similarly, the modifiers list for an ASCII control character, such as ‘C-a’, contains control, even though reading such an event via read-char will return the value 1 with the control modifier bit removed.

Function: event-basic-type event ¶

This function returns the key or mouse button that event describes, with all modifiers removed. The event argument is as in event-modifiers. 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

Function: mouse-movement-p object ¶

This function returns non-nil if object is a mouse movement event. See Motion Events.

Next: Accessing Scroll Bar Events, Previous: Classifying Events, Up: Input Events   [Contents][Index]

22.7.15 Accessing Mouse Events ¶

This section describes convenient functions for accessing the data in a mouse button or motion event. Keyboard event data can be accessed using the same functions, but data elements that aren’t applicable to keyboard events are zero or nil.

The following two functions return a mouse position list (see Click Events), specifying the position of a mouse event.

Function: event-start event ¶

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.

Function: event-end event ¶

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.

Function: posnp object ¶

This function returns non-nil if object is a mouse position list, in the format documented in Click Events); and nil otherwise.

These functions take a mouse position list as argument, and return various parts of it:

Function: posn-window position ¶

Return the window that position is in. If position represents a location outside the frame where the event was initiated, return that frame instead.

Function: posn-area position ¶

Return the window area recorded in position. It returns nil when the event occurred in the text area of the window; otherwise, it is a symbol identifying the area in which the event occurred.

Function: posn-point position ¶

Return the buffer position in position. When the event occurred in the text area of the window, in a marginal area, or on a fringe, this is an integer specifying a buffer position. Otherwise, the value is undefined.

Function: posn-x-y position ¶

Return the pixel-based x and y coordinates in position, as a cons cell (x . y). These coordinates are relative to the window given by posn-window.

This example shows how to convert the window-relative coordinates in the text area of a window into frame-relative coordinates:

(defun frame-relative-coordinates (position)
  "Return frame-relative coordinates from POSITION.
POSITION is assumed to lie in a window text area."
  (let* ((x-y (posn-x-y position))
         (window (posn-window position))
         (edges (window-inside-pixel-edges window)))
    (cons (+ (car x-y) (car edges))
          (+ (cdr x-y) (cadr edges)))))

Function: posn-col-row position &optional use-window ¶

This function returns a cons cell (col . row), containing the estimated column and row corresponding to buffer position described by position. The return value is given in units of the frame’s default character width and default line height (including spacing), as computed from the x and y values corresponding to position. (So, if the actual characters have non-default sizes, the actual row and column may differ from these computed values.) If the optional window argument is non-nil, use the default character width in the window indicated by position instead of the frame. (This makes a difference if that window is showing a buffer with a non-default zooming level, for instance.)

Note that row is counted from the top of the text area. If the window given by position possesses a header line (see Window Header Lines) or a tab line, they are not included in the row count.

Function: posn-actual-col-row position ¶

Return the actual row and column in position, as a cons cell (col . row). The values are the actual row and column numbers in the window given by position. See Click Events, for details. The function returns nil if position does not include actual position values; in that case posn-col-row can be used to get approximate values.

Note that this function doesn’t account for the visual width of characters on display, like the number of visual columns taken by a tab character or an image. If you need the coordinates in canonical character units, use posn-col-row instead.

Function: posn-string position ¶

Return the string object described by position, either nil (which means position describes buffer text), or a cons cell (string . string-pos).

Function: posn-image position ¶

Return the image object in position, either nil (if there’s no image at position), or an image spec (image …).

Function: posn-object position ¶

Return the image or string object described by position, either nil (which means position describes buffer text), an image (image …), or a cons cell (string . string-pos).

Function: posn-object-x-y position ¶

Return the pixel-based x and y coordinates relative to the upper left corner of the object described by position, as a cons cell (dx . dy). If the position describes buffer text, return the relative coordinates of the buffer-text character closest to that position.

Function: posn-object-width-height position ¶

Return the pixel width and height of the object described by position, as a cons cell (width . height). If the position describes a buffer position, return the size of the character at that position.

Function: posn-timestamp position ¶

Return the timestamp in position. This is the time at which the event occurred, in milliseconds. Such a timestamp is reported relative to an arbitrary starting time that varies according to the window system in use. On the X Window System, for example, it is the number of milliseconds since the X server was started.

These functions compute a position list given particular buffer position or screen position. You can access the data in this position list with the functions described above.

Function: posn-at-point &optional pos window ¶

This function returns a position list for position pos in window. pos defaults to point in window; window defaults to the selected window.

posn-at-point returns nil if pos is not visible in window.

Function: posn-at-x-y x y &optional frame-or-window whole ¶

This function returns position information corresponding to pixel coordinates x and y in a specified frame or window, frame-or-window, which defaults to the selected window. The coordinates x and y are relative to the text area of the selected window. If whole is non-nil, the x coordinate is relative to the entire window area including scroll bars, margins and fringes.

User Option: mouse-prefer-closest-glyph ¶

If this variable is non-nil, the posn-point of a mouse position list will be set to the position of the glyph whose leftmost edge is the closest to the mouse click, as opposed to the position of the glyph underneath the mouse pointer itself. For example, if posn-at-x-y is called with x set to 9, which is contained within a character of width 10 displayed at column 0, the point saved within the mouse position list will be after that character, not before it.

Next: Putting Keyboard Events in Strings, Previous: Accessing Mouse Events, Up: Input Events   [Contents][Index]

22.7.16 Accessing Scroll Bar Events ¶

These functions are useful for decoding scroll bar events.

Function: scroll-bar-event-ratio event ¶

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.

Function: scroll-bar-scale ratio total ¶

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.

Previous: Accessing Scroll Bar Events, Up: Input Events   [Contents][Index]

22.7.17 Putting Keyboard Events in Strings ¶

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 containing control characters or the like, but instead store them in the common Emacs format as understood by key-valid-p.

If you read a key sequence with read-key-sequence-vector (or read-key-sequence), or access a key sequence with this-command-keys-vector (or this-command-keys), you can transform this to the recommended format by using key-description.

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:

• If the keyboard character value is in the range of 0 to 127, it can go in the string unchanged.
• The meta variants of those characters, with codes in the range of 2**27 to 2**27+127, can also go in the string, but you must change their numeric values. You must set the 2**7 bit instead of the 2**27 bit, resulting in a value between 128 and 255. Only a unibyte string can include these codes.
• Non-ASCII characters above 256 can be included in a multibyte string.
• Other keyboard character events cannot fit in a string. This includes keyboard events in the range of 128 to 255.

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.

Next: Reading One Event, Up: Reading Input   [Contents][Index]

22.8.1 Key Sequence Input ¶

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.

Function: read-key-sequence prompt &optional continue-echo dont-downcase-last switch-frame-ok command-loop disable-text-conversion ¶

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. (Remember that 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.)

If the events are all characters and all can fit in a string, then read-key-sequence returns a string (see 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.

Reading a key sequence includes translating the events in various ways. See Keymaps for Translating Sequences of Events.

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. The argument continue-echo, if non-nil, means to echo this key as a continuation of the previous key.

Normally any upper case event is converted to lower case if the original event is undefined and the lower case equivalent is defined. The argument dont-downcase-last, if non-nil, means do not convert the last event to lower case. This is appropriate for reading a key sequence to be defined.

The argument switch-frame-ok, if non-nil, means that this function should process a switch-frame event if the user switches frames before typing anything. If the user switches frames in the middle of a key sequence, or at the start of the sequence but switch-frame-ok is nil, then the event will be put off until after the current key sequence.

The argument command-loop, if non-nil, means that this key sequence is being read by something that will read commands one after another. It should be nil if the caller will read just one key sequence.

The argument disable-text-conversion, if non-nil, means that system input methods will not directly perform edits to buffer text while this key sequence is being read; user input will always generated individual key events instead. See Miscellaneous System Events, for more about text conversion.

In the following example, Emacs displays the prompt ‘?’ in the echo area, and then 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 Quitting.

Function: read-key-sequence-vector prompt &optional continue-echo dont-downcase-last switch-frame-ok command-loop disable-text-conversion ¶

This is like read-key-sequence except that it always returns the key sequence as a vector, never as a string. See Putting Keyboard Events in Strings.

If an input character is upper-case (or has the shift modifier) and has no key binding, but its lower-case equivalent has one, then read-key-sequence converts the character to lower case. (This behavior can be disabled by setting the translate-upper-case-key-bindings user option to nil.) Note that lookup-key does not perform case conversion in this way.

When reading input results in such a shift-translation, Emacs sets the variable this-command-keys-shift-translated to a non-nil value. Lisp programs can examine this variable if they need to modify their behavior when invoked by shift-translated keys. For example, the function handle-shift-selection examines the value of this variable to determine how to activate or deactivate the region (see handle-shift-selection).

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 or touchscreen-begin and touchscreen-end events occur in special parts of a window or frame, 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: tab-line, header-line, horizontal-scroll-bar, menu-bar, tab-bar, mode-line, vertical-line, vertical-scroll-bar, left-margin, right-margin, left-fringe, right-fringe, right-divider, and bottom-divider. 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))]

Variable: num-input-keys ¶

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.

Next: Modifying and Translating Input Events, Previous: Key Sequence Input, Up: Reading Input   [Contents][Index]

22.8.2 Reading One Event ¶

The lowest level functions for command input are read-event, read-char, and read-char-exclusive.

If you need a function to read a character using the minibuffer, use read-char-from-minibuffer (see Asking Multiple-Choice Questions).

Function: read-event &optional prompt inherit-input-method seconds ¶

This function reads and returns the next event of command input, waiting if necessary until an event is available.

The returned event may come directly from the user, or from a keyboard macro. It is not decoded by the keyboard’s input coding system (see Terminal I/O Encoding).

If the optional argument prompt is non-nil, it should be a string to display in the echo area as a prompt. If prompt is nil or the string ‘""’, 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 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 seconds is non-nil, it should be a number specifying the maximum time to wait for input, in seconds. If no input arrives within that time, read-event stops waiting and returns nil. A floating point seconds means to wait for a fractional number of seconds. Some systems support only a whole number of seconds; on these systems, seconds is rounded down. If seconds is nil, read-event waits as long as necessary for input to arrive.

If seconds is nil, Emacs is considered idle while waiting for user input to arrive. Idle timers—those created with run-with-idle-timer (see Idle Timers)—can run during this period. However, if seconds is non-nil, the state of idleness remains unchanged. If Emacs is non-idle when read-event is called, it remains non-idle throughout the operation of read-event; if Emacs is idle (which can happen if the call happens inside an idle timer), it remains idle.

If read-event gets an event that is defined as a help character, then in some cases read-event processes the event directly without returning. See Help Functions. Certain other events, called special events, are also processed directly within read-event (see Special Events).

Here is what happens if you call read-event and then press the right-arrow function key:

(read-event)
     ⇒ right

Function: read-char &optional prompt inherit-input-method seconds ¶

This function reads and returns a character input event. 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.

If the event has modifiers, Emacs attempts to resolve them and return the code of the corresponding character. For example, if the user types C-a, the function returns 1, which is the ASCII code of the ‘C-a’ character. If some of the modifiers cannot be reflected in the character code, read-char leaves the unresolved modifier bits set in the returned event. For example, if the user types C-M-a, the function returns 134217729, 8000001 in hex, i.e. ‘C-a’ with the Meta modifier bit set. This value is not a valid character code: it fails the characterp test (see Character Codes). Use event-basic-type (see Classifying Events) to recover the character code with the modifier bits removed; use event-modifiers to test for modifiers in the character event returned by read-char.

In the first example below, 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

Function: read-char-exclusive &optional prompt inherit-input-method seconds ¶

This function reads and returns a character input event. If the user generates an event which is not a character event, read-char-exclusive ignores it and reads another event, until it gets a character. The arguments work as in read-event. The returned value may include modifier bits, as with read-char.

None of the above functions suppress quitting.

Variable: num-nonmacro-input-events ¶

This variable holds the total number of input events received so far from the terminal—not counting those generated by keyboard macros.

We emphasize that, unlike read-key-sequence, the functions read-event, read-char, and read-char-exclusive do not perform the translations described in Keymaps for Translating Sequences of Events. If you wish to read a single key taking these translations into account (for example, to read Function Keys in a terminal or Mouse Events from xterm-mouse-mode), use the function read-key:

Function: read-key &optional prompt disable-fallbacks ¶

This function reads a single key. It is intermediate between read-key-sequence and read-event. Unlike the former, it reads a single key, not a key sequence. Unlike the latter, it does not return a raw event, but decodes and translates the user input according to input-decode-map, local-function-key-map, and key-translation-map (see Keymaps for Translating Sequences of Events).

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.

If argument disable-fallbacks is non-nil then the usual fallback logic for unbound keys in read-key-sequence is not applied. This means that mouse button-down and multi-click events will not be discarded and local-function-key-map and key-translation-map will not get applied. If nil or unspecified, the only fallback disabled is downcasing of the last event.

Function: read-char-choice prompt chars &optional inhibit-quit ¶

This function uses read-from-minibuffer to read and return a single character that is a member of chars, which should be a list of single characters. It discards any input characters that are not members of chars, and shows a message to that effect.

The optional argument inhibit-quit is by default ignored, but if the variable read-char-choice-use-read-key is non-nil, this function uses read-key instead of read-from-minibuffer, and in that case inhibit-quit non-nil means ignore keyboard-quit events while waiting for valid input. In addition, if read-char-choice-use-read-key is non-nil, binding help-form (see Help Functions) to a non-nil value while calling this function causes it to evaluate help-form and display the result when the user presses help-char; it then continues to wait for a valid input character, or for keyboard-quit.

Function: read-multiple-choice prompt choices &optional help-string show-help long-form ¶

Ask user a multiple-choice question and return user’s choice. prompt should be a string to display as the prompt.

choices is an alist where the first element in each entry is a character the user can type, the second element is a short name for the entry to be displayed while prompting (if there’s room, it might be shortened), and the third, optional entry is a longer explanation that will be displayed in a help buffer if the user requests more help.

The return value is the entry from choices that matches the character the user types.

If optional argument help-string is non-nil, it should be a string with a more detailed description of all choices. It will be displayed in a help buffer instead of the default auto-generated description when the user types ?.

If optional argument show-help is non-nil, the help buffer will be displayed immediately, before any user input. If it is a string, use it as the name of the help buffer.

If optional argument long-form is non-nil, the user will have to type in long-form answers (using completing-read) instead of hitting a single key. The answers must be among the second elements of the values in the choices list.

By default, this function uses read-from-minibuffer (see Reading Text Strings with the Minibuffer) to read user input, but if the variable read-char-choice-use-read-key is non-nil, it uses read-key instead.

(read-multiple-choice
 "Continue connecting?"
 '((?a "always" "Accept certificate for this and future sessions.")
   (?s "session only" "Accept certificate this session only.")
   (?n "no" "Refuse to use certificate, close connection.")))

The read-multiple-choice-face face is used to highlight the matching characters in the name string on graphical terminals.

Next: Invoking the Input Method, Previous: Reading One Event, Up: Reading Input   [Contents][Index]

22.8.3 Modifying and Translating Input Events ¶

Emacs modifies every event it reads according to extra-keyboard-modifiers, then translates it through keyboard-translate-table (if applicable), before returning it from read-event.

Variable: extra-keyboard-modifiers ¶

This variable lets Lisp programs “press” the modifier keys on the keyboard. The value is a character. Only the modifiers of the character matter. Each time the user types a keyboard key, it is altered as if those modifier keys were held down. For instance, if you bind extra-keyboard-modifiers to ?\C-\M-a, then all keyboard input characters typed during the scope of the binding will have the control and meta modifiers applied to them. The character ?\C-@, equivalent to the integer 0, does not count as a control character for this purpose, but as a character with no modifiers. Thus, setting extra-keyboard-modifiers to zero cancels any modification.

When using a window system, the program can press any of the modifier keys in this way. Otherwise, only the CTL and META keys can be virtually pressed.

Note that this variable applies only to events that really come from the keyboard, and has no effect on mouse events or any other events.

Variable: keyboard-translate-table ¶

This terminal-local variable is the translate table for keyboard characters. It lets you reshuffle the keys on the keyboard without changing any command bindings. Its value is normally a char-table, or else nil. (It can also be a string or vector, but this is considered obsolete.)

If keyboard-translate-table is a char-table (see Char-Tables), then each character read from the keyboard is looked up in this char-table. If the value found there is non-nil, then it is used instead of the actual input character.

Note that this translation is the first thing that happens to a character after it is read from the terminal. Record-keeping features such as recent-keys and dribble files record the characters after translation.

Note also that this translation is done before the characters are supplied to input methods (see Input Methods). Use translation-table-for-input (see Translation of Characters), if you want to translate characters after input methods operate.

Command: key-translate from to ¶

This command modifies keyboard-translate-table to translate character code from into character code to. Interactively, it prompts for from and to. It creates the keyboard translate table if necessary. Both from and to should be strings that satisfy key-valid-p (see Key Sequences). If to is nil, the function removes any existing translation for from.

Here’s an example of using the keyboard-translate-table to make C-x, C-c and C-v perform the cut, copy and paste operations:

(key-translate "C-x" "<control-x>")
(key-translate "C-c" "<control-c>")
(key-translate "C-v" "<control-v>")
(keymap-global-set "<control-x>" 'kill-region)
(keymap-global-set "<control-c>" 'kill-ring-save)
(keymap-global-set "<control-v>" 'yank)

On a graphical terminal that supports extended ASCII input, you can still get the standard Emacs meanings of one of those characters by typing it with the shift key. That makes it a different character as far as keyboard translation is concerned, but it has the same usual meaning.

See Keymaps for Translating Sequences of Events, for mechanisms that translate event sequences at the level of read-key-sequence. If you need to translate input events that are not characters (i.e., characterp returns nil for them), you must use the event translation mechanism described there.

Command: key-translate-remove from ¶

This command prompts for a key from and its translation, and removes the translation from the translation table. When calling from Lisp, specify just the key from, without its translation.

Next: Quoted Character Input, Previous: Modifying and Translating Input Events, Up: Reading Input   [Contents][Index]

22.8.4 Invoking the Input Method ¶

The event-reading functions invoke the current input method, if any (see 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.

Variable: input-method-function ¶

If this is non-nil, its value specifies the current input method function.

Warning: 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 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.

Next: Miscellaneous Event Input Features, Previous: Invoking the Input Method, Up: Reading Input   [Contents][Index]

22.8.5 Quoted Character Input ¶

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.

Function: read-quoted-char &optional prompt ¶

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. If the character that terminates the sequence of octal digits is RET, it is discarded. Any other terminating character is used as input after this function returns.

Quitting is suppressed when the first character is read, so that the user can enter a C-g. See 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 1 7 7-
---------- Echo Area ----------

     ⇒ 127

Previous: Quoted Character Input, Up: Reading Input   [Contents][Index]

22.8.6 Miscellaneous Event Input Features ¶

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 Reading a Password).

Variable: unread-command-events ¶

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 below).

Normally you add events to the front of this list, so that the events most recently unread will be reread first.

Events read from this list are not normally added to the current command’s key sequence (as returned by, e.g., this-command-keys), as the events will already have been added once as they were read for the first time. An element of the form (t . event) forces event to be added to the current command’s key sequence.

Elements read from this list are normally recorded by the record-keeping features (see Recording Input) and while defining a keyboard macro (see Keyboard Macros). However, an element of the form (no-record . event) causes event to be processed normally without recording it.

Function: listify-key-sequence key ¶

This function converts the string or vector key to a list of individual events, which you can put in unread-command-events.

Function: input-pending-p &optional check-timers ¶

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.

If the optional argument check-timers is non-nil, then if no input is available, Emacs runs any timers which are ready. See Timers for Delayed Execution.

Variable: last-input-event ¶

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

Macro: while-no-input body… ¶

This construct runs the body forms and returns the value of the last one—but only if no input arrives. If any input arrives during the execution of the body forms, it aborts them (working much like a quit). The while-no-input form returns nil if aborted by a real quit, and returns t if aborted by arrival of other input.

If a part of body binds inhibit-quit to non-nil, arrival of input during those parts won’t cause an abort until the end of that part.

If you want to be able to distinguish all possible values computed by body from both kinds of abort conditions, write the code like this:

(while-no-input
  (list
    (progn . body)))

Variable: while-no-input-ignore-events ¶

This variable allow setting which special events while-no-input should ignore. It is a list of event symbols (see Event Examples).

Function: discard-input ¶

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