Mercurial > emacs
changeset 6557:74758cf67338
*** empty log message ***
| author | Richard M. Stallman <rms@gnu.org> |
|---|---|
| date | Mon, 28 Mar 1994 20:02:03 +0000 |
| parents | 79884c55326f |
| children | fa8ff07eaafc |
| files | lispref/commands.texi |
| diffstat | 1 files changed, 357 insertions(+), 335 deletions(-) [+] |
line wrap: on
line diff
--- a/lispref/commands.texi Mon Mar 28 18:48:16 1994 +0000 +++ b/lispref/commands.texi Mon Mar 28 20:02:03 1994 +0000 @@ -1,6 +1,6 @@ @c -*-texinfo-*- @c This is part of the GNU Emacs Lisp Reference Manual. -@c Copyright (C) 1990, 1991, 1992, 1993 Free Software Foundation, Inc. +@c Copyright (C) 1990, 1991, 1992, 1993, 1994 Free Software Foundation, Inc. @c See the file elisp.texi for copying conditions. @setfilename ../info/commands @node Command Loop, Keymaps, Minibuffers, Top @@ -39,42 +39,46 @@ call this function (@pxref{Key Sequence Input}). Lisp programs can also do input at a lower level with @code{read-event} (@pxref{Reading One Event}) or discard pending input with @code{discard-input} -(@pxref{Peeking and Discarding}). +(@pxref{Event Input Misc}). The key sequence is translated into a command through the currently active keymaps. @xref{Key Lookup}, for information on how this is done. The result should be a keyboard macro or an interactively callable function. If the key is @kbd{M-x}, then it reads the name of another -command, which is used instead. This is done by the command +command, which it then calls. This is done by the command @code{execute-extended-command} (@pxref{Interactive Call}). - Once the command is chosen, it must be executed, which includes -reading arguments to be given to it. This is done by calling -@code{command-execute} (@pxref{Interactive Call}). For commands written -in Lisp, the @code{interactive} specification says how to read the -arguments. This may use the prefix argument (@pxref{Prefix Command -Arguments}) or may read with prompting in the minibuffer -(@pxref{Minibuffers}). For example, the command @code{find-file} has an -@code{interactive} specification which says to read a file name using -the minibuffer. The command's function body does not use the -minibuffer; if you call this command from Lisp code as a function, you -must supply the file name string as an ordinary Lisp function argument. + To execute a command requires first reading the arguments for it. +This is done by calling @code{command-execute} (@pxref{Interactive +Call}). For commands written in Lisp, the @code{interactive} +specification says how to read the arguments. This may use the prefix +argument (@pxref{Prefix Command Arguments}) or may read with prompting +in the minibuffer (@pxref{Minibuffers}). For example, the command +@code{find-file} has an @code{interactive} specification which says to +read a file name using the minibuffer. The command's function body does +not use the minibuffer; if you call this command from Lisp code as a +function, you must supply the file name string as an ordinary Lisp +function argument. If the command is a string or vector (i.e., a keyboard macro) then @code{execute-kbd-macro} is used to execute it. You can call this function yourself (@pxref{Keyboard Macros}). - If a command runs away, typing @kbd{C-g} terminates its execution -immediately. This is called @dfn{quitting} (@pxref{Quitting}). + To terminate the execution of a running command, type @kbd{C-g}. This +character causes @dfn{quitting} (@pxref{Quitting}). @defvar pre-command-hook -The editor command loop runs this normal hook before each command. +The editor command loop runs this normal hook before each command. At +that time, @code{this-command} contains the command that is about to +run, and @code{last-command} describes the previous command. @end defvar @defvar post-command-hook -The editor command loop runs this normal hook after each command, -and also when the command loop is entered, or reentered after -an error or quit. +The editor command loop runs this normal hook after each command +(including commands terminated prematurely by quitting or by errors), +and also when the command loop is first entered. At that time, +@code{this-command} describes the command that just ran, and +@code{last-command} describes the command before that. @end defvar @node Defining Commands @@ -108,12 +112,12 @@ This special form declares that the function in which it appears is a command, and that it may therefore be called interactively (via @kbd{M-x} or by entering a key sequence bound to it). The argument -@var{arg-descriptor} declares the way the arguments to the command are -to be computed when the command is called interactively. +@var{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 arguments are supplied by the caller and @var{arg-descriptor} -has no effect. +then the caller supplies the arguments and @var{arg-descriptor} has no +effect. The @code{interactive} form has its effect because the command loop (actually, its subroutine @code{call-interactively}) scans through the @@ -172,7 +176,7 @@ @end smallexample @cindex @samp{*} in interactive -@kindex buffer-read-only +@cindex read-only buffers in interactive If the first character in the string is @samp{*}, then an error is signaled if the buffer is read-only. @@ -222,6 +226,9 @@ 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. + @item Prompt A prompt immediately follows the code character. The prompt ends either with the end of the string or with a newline. @@ -266,7 +273,7 @@ @item d @cindex position argument -The position of point as a number (@pxref{Point}). No I/O. +The position of point, as an integer (@pxref{Point}). No I/O. @item D A directory name. The default is the current default directory of the @@ -280,13 +287,10 @@ You can use @samp{e} more than once in a single command's interactive specification. If the key sequence which invoked the command has -@var{n} events with parameters, the @var{n}th @samp{e} provides the -@var{n}th list event. Events which are not lists, such as function keys +@var{n} events that are lists, the @var{n}th @samp{e} provides the +@var{n}th such event. Events which are not lists, such as function keys and @sc{ASCII} characters, do not count where @samp{e} is concerned. -Even though @samp{e} does not use a prompt string, you must follow -it with a newline if it is not the last code character. - @item f A file name of an existing file (@pxref{File Names}). The default directory is @code{default-directory}. Existing, Completion, Default, @@ -306,7 +310,7 @@ @item m @cindex marker argument -The position of the mark as a number. No I/O. +The position of the mark, as an integer. No I/O. @item n A number read with the minibuffer. If the input is not a number, the @@ -315,8 +319,8 @@ @item N @cindex raw prefix argument usage -The raw prefix argument. If the prefix argument is @code{nil}, then a -number is read as with @kbd{n}. Requires a number. Prompt. +The raw prefix argument. If the prefix argument is @code{nil}, then +read a number as with @kbd{n}. Requires a number. Prompt. @item p @cindex numeric prefix argument usage @@ -429,9 +433,10 @@ The interactively callable objects include strings and vectors (treated as keyboard macros), lambda expressions that contain a top-level call to -@code{interactive}, byte-code function objects, autoload objects that -are declared as interactive (non-@code{nil} fourth argument to -@code{autoload}), and some of the primitive functions. +@code{interactive}, compiled function objects made from such lambda +expressions, autoload objects that are declared as interactive +(non-@code{nil} fourth argument to @code{autoload}), and some of the +primitive functions. A symbol is @code{commandp} if its function definition is @code{commandp}. @@ -461,7 +466,7 @@ @cindex keyboard macro execution This function executes @var{command} as an editing command. The argument @var{command} must satisfy the @code{commandp} predicate; i.e., -it must be an interactively callable function or a string. +it must be an interactively callable function or a keyboard macro. A string or vector as @var{command} is executed with @code{execute-kbd-macro}. A function is passed to @@ -482,9 +487,9 @@ command returns becomes the value of @code{execute-extended-command}. @cindex execute with prefix argument -If the command asks for a prefix argument, the value -@var{prefix-argument} is supplied. If @code{execute-extended-command} -is called interactively, the current raw prefix argument is used for +If the command asks for a prefix argument, it receives the value +@var{prefix-argument}. If @code{execute-extended-command} is called +interactively, the current raw prefix argument is used for @var{prefix-argument}, and thus passed on to whatever command is run. @c !!! Should this be @kindex? @@ -512,11 +517,11 @@ called @code{interactive-p}) was called interactively, with the function @code{call-interactively}. (It makes no difference whether @code{call-interactively} was called from Lisp or directly from the -editor command loop.) Note that if the containing function was called -by Lisp evaluation (or with @code{apply} or @code{funcall}), then it was -not called interactively. +editor command loop.) If the containing function was called by Lisp +evaluation (or with @code{apply} or @code{funcall}), then it was not +called interactively. -The usual application of @code{interactive-p} is for deciding whether to +The most common use of @code{interactive-p} is for deciding whether to print an informative message. As a special exception, @code{interactive-p} returns @code{nil} whenever a keyboard macro is being run. This is to suppress the informative messages and speed @@ -569,9 +574,9 @@ command loop (the one before the current command). Normally the value is a symbol with a function definition, but this is not guaranteed. -The value is set by copying the value of @code{this-command} when a -command returns to the command loop, except when the command specifies a -prefix argument for the following command. +The value is copied from @code{this-command} when a command returns to +the command loop, except when the command specifies a prefix argument +for the following command. @end defvar @defvar this-command @@ -580,17 +585,17 @@ the editor command loop. Like @code{last-command}, it is normally a symbol with a function definition. -This variable is set by the command loop just before the command is run, -and its value is copied into @code{last-command} when the command -finishes (unless the command specifies a prefix argument for the -following command). +The command loop sets this variable just before running a command, and +copies its value into @code{last-command} when the command finishes +(unless the command specifies a prefix argument for the following +command). @cindex kill command repetition -Some commands change the value of this variable during their execution, -simply as a flag for whatever command runs next. In particular, the -functions that kill text set @code{this-command} to @code{kill-region} -so that any kill commands immediately following will know to append the -killed text to the previous kill. +Some commands set this variable during their execution, as a flag for +whatever command runs next. In particular, the functions that kill text +set @code{this-command} to @code{kill-region} so that any kill commands +immediately following will know to append the killed text to the +previous kill. @end defvar If you do not want a particular command to be recognized as the previous @@ -625,7 +630,7 @@ @defvar last-nonmenu-event This variable holds the last input event read as part of a key -sequence, aside from events resulting from mouse menus. +sequence, not counting events resulting from mouse menus. One use of this variable is to figure out a good default location to pop up another menu. @@ -640,7 +645,7 @@ @example @group -last-command-char +last-command-event ;; @r{Now type @kbd{C-u C-x C-e}.} @result{} 5 @end group @@ -666,9 +671,9 @@ This variable determines how much time should elapse before command characters echo. Its value must be an integer, which specifies the number of seconds to wait before echoing. If the user types a prefix -key (say @kbd{C-x}) and then delays this many seconds before continuing, -the key @kbd{C-x} is echoed in the echo area. Any subsequent characters -in the same command will be echoed as well. +key (such as @kbd{C-x}) and then delays this many seconds before +continuing, the prefix key is echoed in the echo area. Any subsequent +characters in the same command will be echoed as well. If the value is zero, then command input is not echoed. @end defvar @@ -683,16 +688,6 @@ are characters or symbols; mouse events are always lists. This section describes the representation and meaning of input events in detail. -A command invoked using events that are lists can get the full values of -these events using the @samp{e} interactive code. @xref{Interactive -Codes}. - -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. - @defun eventp object This function returns non-@code{nil} if @var{event} is an input event. @end defun @@ -700,6 +695,7 @@ @menu * Keyboard Events:: Ordinary characters--keys with symbols on them. * Function Keys:: Function keys--keys with names, not symbols. +* Mouse Events:: Overview of mouse events. * Click Events:: Pushing and releasing a mouse button. * Drag Events:: Moving the mouse before releasing the button. * Button-Down Events:: A button was pushed and not yet released. @@ -720,7 +716,9 @@ There are two kinds of input you can get from the keyboard: ordinary keys, and function keys. Ordinary keys correspond to characters; the events they generate are represented in Lisp as characters. In Emacs -versions 18 and earlier, characters were the only events. +versions 18 and earlier, characters were the only events. The event +type of a character event is the character itself (an integer); +see @ref{Classifying Events}. @cindex modifier bits (of input character) @cindex basic code (of input character) @@ -756,7 +754,7 @@ the 2**21 bit for those characters. However, @sc{ASCII} provides no way to distinguish @kbd{C-A} from -@kbd{C-A}, so Emacs uses the 2**21 bit in @kbd{C-A} and not in +@kbd{C-a}, so Emacs uses the 2**21 bit in @kbd{C-A} and not in @kbd{C-a}. @item hyper @@ -785,13 +783,12 @@ @cindex function keys Most keyboards also have @dfn{function keys}---keys which have names or symbols that are not characters. Function keys are represented in Lisp -as symbols; the symbol's name is the function key's label. For example, -pressing a key labeled @key{F1} places the symbol @code{f1} in the input -stream. +as symbols; the symbol's name is the function key's label, in lower +case. For example, pressing a key labeled @key{F1} places the symbol +@code{f1} in the input stream. -For all keyboard events, the event type (which classifies the event for -key lookup purposes) is identical to the event---it is the character or -the symbol. @xref{Classifying Events}. +The event type of a function key event is the event symbol itself. +@xref{Classifying Events}. Here are a few special cases in the symbol naming convention for function keys: @@ -801,15 +798,16 @@ These keys correspond to common @sc{ASCII} control characters that have special keys on most keyboards. -In @sc{ASCII}, @kbd{C-i} and @key{TAB} are the same character. Emacs -lets you distinguish them if you wish, by returning the former as the -integer 9, and the latter as the symbol @code{tab}. +In @sc{ASCII}, @kbd{C-i} and @key{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 @code{tab}. Most of the time, it's not useful to distinguish the two. So normally -@code{function-key-map} is set up to map @code{tab} into 9. Thus, a -key binding for character code 9 also applies to @code{tab}. Likewise -for the other symbols in this group. The function @code{read-char} -also converts these events into characters. +@code{function-key-map} is set up to map @code{tab} into 9. Thus, a key +binding for character code 9 (the character @kbd{C-i}) also applies to +@code{tab}. Likewise for the other symbols in this group. The function +@code{read-char} likewise converts these events into characters. In @sc{ASCII}, @key{BS} is really @kbd{C-h}. But @code{backspace} converts into the character code 127 (@key{DEL}), not into code 8 @@ -845,9 +843,31 @@ @end table Thus, the symbol for the key @key{F3} with @key{META} held down is -@kbd{M-@key{F3}}. When you use more than one prefix, we recommend you -write them in alphabetical order (though the order does not matter in -arguments to the key-binding lookup and modification functions). +@kbd{M-@key{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. + +@node Mouse Events +@subsection 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 @sc{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 +(@pxref{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 @samp{e} interactive code. +@xref{Interactive Codes}. + +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. @node Click Events @subsection Click Events @@ -860,18 +880,17 @@ @example (@var{event-type} - (@var{window} @var{buffer-pos} - (@var{x} . @var{y}) @var{timestamp}) + (@var{window} @var{buffer-pos} (@var{x} . @var{y}) @var{timestamp}) @var{click-count}) @end example Here is what the elements normally mean: -@table @var -@item event-type +@table @asis +@item @var{event-type} This is a symbol that indicates which mouse button was used. It is one of the symbols @code{mouse-1}, @code{mouse-2}, @dots{}, where the -buttons are numbered numbered left to right. +buttons are numbered left to right. You can also use prefixes @samp{A-}, @samp{C-}, @samp{H-}, @samp{M-}, @samp{S-} and @samp{s-} for modifiers alt, control, hyper, meta, shift @@ -882,30 +901,29 @@ @code{mouse-1}, that binding would apply to all events whose @var{event-type} is @code{mouse-1}. -@item window +@item @var{window} This is the window in which the click occurred. -@item x -@itemx y +@item @var{x}, @var{y} These are the pixel-based coordinates of the click, relative to the top left corner of @var{window}, which is @code{(0 . 0)}. -@item buffer-pos +@item @var{buffer-pos} This is the buffer position of the character clicked on. -@item timestamp +@item @var{timestamp} This is the time at which the event occurred, in milliseconds. (Since this value wraps around the entire range of Emacs Lisp integers in about five hours, it is useful only for relating the times of nearby events.) -@item click-count +@item @var{click-count} This is the number of rapid repeated presses so far of the same mouse button. @xref{Repeat Events}. @end table -The meanings of @var{buffer-pos}, @var{row} and @var{column} are -somewhat different when the event location is in a special part of the -screen, such as the mode line or a scroll bar. +The meanings of @var{buffer-pos}, @var{x} and @var{y} are somewhat +different when the event location is in a special part of the screen, +such as the mode line or a scroll bar. If the location is in a scroll bar, then @var{buffer-pos} is the symbol @code{vertical-scroll-bar} or @code{horizontal-scroll-bar}, and the pair @@ -917,8 +935,8 @@ If the position is on a mode line or the vertical line separating @var{window} from its neighbor to the right, then @var{buffer-pos} is the symbol @code{mode-line} or @code{vertical-line}. For the mode line, -@var{row} does not have meaningful data. For the vertical line, -@var{column} does not have meaningful data. +@var{y} does not have meaningful data. For the vertical line, @var{x} +does not have meaningful data. @var{buffer-pos} may be a list containing a symbol (one of the symbols listed above) instead of just the symbol. This is what happens after @@ -939,10 +957,8 @@ @example (@var{event-type} - (@var{window1} @var{buffer-pos1} - (@var{x1} . @var{y1}) @var{timestamp1}) - (@var{window2} @var{buffer-pos2} - (@var{x2} . @var{y2}) @var{timestamp2}) + (@var{window1} @var{buffer-pos1} (@var{x1} . @var{y1}) @var{timestamp1}) + (@var{window2} @var{buffer-pos2} (@var{x2} . @var{y2}) @var{timestamp2}) @var{click-count}) @end example @@ -972,10 +988,10 @@ If you want to take action as soon as a button is pressed, you need to handle @dfn{button-down} events.@footnote{Button-down is the -conservative antithesis of drag.}. These occur as soon as a button is +conservative antithesis of drag.} These occur as soon as a button is pressed. They are represented by lists which look exactly like click -events (@pxref{Click Events}), except that the name of @var{event-type} -contains the prefix @samp{down-}. The @samp{down-} prefix follows the +events (@pxref{Click Events}), except that the @var{event-type} symbol +name contains the prefix @samp{down-}. The @samp{down-} prefix follows modifier key prefixes such as @samp{C-} and @samp{M-}. The function @code{read-key-sequence}, and the Emacs command loop, @@ -983,10 +999,7 @@ 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. -@ifinfo -@xref{Motion Events}. -@end ifinfo +until the button is released. @xref{Motion Events}. @node Repeat Events @subsection Repeat Events @@ -995,8 +1008,8 @@ @cindex triple-click events If you press the same mouse button more than once in quick succession -without moving the mouse, Emacs uses special @dfn{repeat} mouse events -for the second and subsequent presses. +without moving the mouse, Emacs generates special @dfn{repeat} mouse +events for the second and subsequent presses. The most common repeat events are @dfn{double-click} events. Emacs generates a double-click event when you click a button twice; the event @@ -1004,7 +1017,7 @@ events). The event type of a double-click event contains the prefix -@code{double}. Thus, a double click on the second mouse button with +@samp{double-}. Thus, a double click on the second mouse button with @key{meta} held down comes to the Lisp program as @code{M-double-mouse-2}. If a double-click event has no binding, the binding of the corresponding ordinary click event is used to execute @@ -1012,14 +1025,14 @@ 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, the command -binding of the double click event must be written to assume that the +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 means that it is most convenient to give double clicks a meaning -that somehow ``builds on'' the meaning of a single click. This is what -user interface experts recommend that double clicks should do. +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 @dfn{double-drag} event @@ -1029,11 +1042,12 @@ were an ordinary click. Before the double-click or double-drag event, Emacs generates a -@dfn{double-down} event when the button is pressed down for the second -time. Its event type contains @samp{double-down} instead of just +@dfn{double-down} event when the user presses the button down for the +second time. Its event type contains @samp{double-down} instead of just @samp{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. +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 double-down event, followed by either a @@ -1046,11 +1060,11 @@ 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 quadruple, quintuple, etc. events as separate -event types. However, you can look at the event list to find out -precisely how many times the button was pressed. +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. @defun event-click-count event This function returns the number of consecutive button presses that led @@ -1061,9 +1075,9 @@ @end defun @defvar double-click-time -To count as double- and triple-clicks, mouse clicks must be at the same -location as the first click, and the number of milliseconds between the -first release and the second must be less than the value of +To generate repeat events, successive mouse button presses must be at +the same screen position, and the number of milliseconds between +successive button presses must be less than the value of @code{double-click-time}. Setting @code{double-click-time} to @code{nil} disables multi-click detection entirely. Setting it to @code{t} removes the time limit; Emacs then detects multi-clicks by @@ -1081,8 +1095,7 @@ @example (mouse-movement - (@var{window} @var{buffer-pos} - (@var{x} . @var{y}) @var{timestamp})) + (@var{window} @var{buffer-pos} (@var{x} . @var{y}) @var{timestamp})) @end example The second element of the list describes the current position of the @@ -1099,8 +1112,8 @@ to read the motion events and modify the display accordingly. When the user releases the button, that generates a click event. -Normally @var{body} should return when it sees the click event, and -discard the event. +Typically, @var{body} should return when it sees the click event, and +discard that event. @end defspec @node Focus Events @@ -1123,14 +1136,14 @@ @noindent where @var{new-frame} is the frame switched to. -In X windows, most window managers are set up so that just moving the -mouse into a window is enough to set the focus there. Emacs appears to -do this, because it changes the cursor to solid in the new frame. -However, there is no need for the Lisp program to know about the focus -change until some other kind of input arrives. So Emacs generates the -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. +Most X window window managers are set up so that just moving the mouse +into a window is enough to set the focus there. Emacs appears to do +this, because it changes the cursor to solid in the new frame. However, +there is no need for the Lisp program to know about the focus change +until some other kind of input arrives. So Emacs generates a focus +event only when the user actually types a keyboard key or presses a +mouse button in the new frame; just moving the mouse between frames does +not generate a focus event. A focus event in the middle of a key sequence would garble the sequence. So Emacs never generates a focus event in the middle of a key @@ -1150,7 +1163,7 @@ (mouse-1 (#<window 18 on NEWS> 2613 (0 . 38) -864180)) @end smallexample -Or, while holding the control key down, the user might hold down the +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: @@ -1160,9 +1173,9 @@ (#<window 18 on NEWS> 3510 (0 . 28) -729648)) @end smallexample -Or, while holding down the meta and shift keys, the user might press the +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 the following pair of events: +into another window. That produces a pair of events like these: @smallexample (M-S-down-mouse-2 (#<window 18 on NEWS> mode-line (33 . 31) -457844)) @@ -1186,7 +1199,7 @@ 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 what text to act on. +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 @key{META} key, @@ -1196,11 +1209,16 @@ provided to get such information conveniently. @defun event-modifiers event -This function returns a list of the modifiers that @var{event} has. -The modifiers are symbols; they include @code{shift}, @code{control}, +This function returns a list of the modifiers that @var{event} has. The +modifiers are symbols; they include @code{shift}, @code{control}, @code{meta}, @code{alt}, @code{hyper} and @code{super}. In addition, -the property of a mouse event symbol always has one of @code{click}, -@code{drag}, and @code{down} among the modifiers. For example: +the modifiers list of a mouse event symbol always contains one of +@code{click}, @code{drag}, and @code{down}. + +The argument @var{event} may be an entire event object, or just an event +type. + +Here are some examples: @example (event-modifiers ?a) @@ -1260,14 +1278,14 @@ @subsection Accessing Events This section describes convenient functions for accessing the data in -an event which is a list. +a mouse button or motion event. - The following functions return the starting or ending position of a + These two functions return the starting or ending position of a mouse-button event. The position is a list of this form: -@smallexample +@example (@var{window} @var{buffer-position} (@var{col} . @var{row}) @var{timestamp}) -@end smallexample +@end example @defun event-start event This returns the starting position of @var{event}. @@ -1294,7 +1312,7 @@ @end defun @defun posn-point position -Return the buffer location in @var{position}. +Return the buffer position in @var{position}. This is an integer. @end defun @defun posn-x-y position @@ -1303,22 +1321,22 @@ @end defun @defun posn-col-row position -Return the row and column (in units of characters) in @var{position}, as +Return the row and column (in units of characters) of @var{position}, as a cons cell @code{(@var{col} . @var{row})}. These are computed from the @var{x} and @var{y} values actually found in @var{position}. @end defun @defun posn-timestamp position -Return the timestamp of @var{position}. +Return the timestamp in @var{position}. @end defun @defun scroll-bar-scale ratio total -This function multiples (in effect) @var{ratio} by @var{total}, -rounding the result to an integer. @var{ratio} is not a number, -but rather a pair @code{(@var{num} . @var{denom})}. +This function multiples (in effect) @var{ratio} by @var{total}, rounding +the result to an integer. The argument @var{ratio} is not a number, but +rather a pair @code{(@var{num} . @var{denom})}. -This is handy for scaling a position on a scroll bar into a buffer -position. Here's how to do that: +This function is handy for scaling a position on a scroll bar into a +buffer position. Here's how to do that: @example (+ (point-min) @@ -1348,20 +1366,20 @@ use @samp{\M-} to express meta characters, especially as the argument to @code{define-key} and similar functions. - We provide backward compatibility to run those programs with special + We provide backward compatibility to run those programs using special rules for how to put a keyboard character event in a string. Here are the rules: @itemize @bullet @item -If the keyboard event value is in the range of 0 to 127, it can go in the -string unchanged. +If the keyboard character value is in the range of 0 to 127, it can go +in the string unchanged. @item -The meta variants of those events, with codes in the range of 2**23 to -2**23+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**23 bit, resulting -in a value between 128 and 255. +The meta variants of those characters, with codes in the range of 2**23 +to 2**23+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**23 bit, +resulting in a value between 128 and 255. @item Other keyboard character events cannot fit in a string. This includes @@ -1369,7 +1387,8 @@ @end itemize Functions such as @code{read-key-sequence} that can construct strings -containing events follow these rules. +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 @samp{\M-} in a string, it produces a code in the range of 128 to 255---the same code that you get if you @@ -1377,14 +1396,22 @@ meta events in strings work consistently regardless of how they get into the strings. - New programs can avoid dealing with these rules by using vectors -instead of strings for key sequences when there is any possibility that -these issues might arise. - The reason we changed the representation of meta characters as keyboard events is to make room for basic character codes beyond 127, and support meta variants of such larger character codes. + New programs can avoid dealing with these special compatibility rules +by using vectors instead of strings for key sequences when there is any +possibility that they might contain meta characters, and by using +@code{listify-key-sequence} to access a string of events. + +@defun listify-key-sequence key +This function converts the string or vector @var{key} to a list of +events which you can put in @code{unread-command-events}. Converting a +vector is simple, but converting a string is tricky because of the +special representation used for meta characters in a string. +@end defun + @node Reading Input @section Reading Input @@ -1402,7 +1429,7 @@ * Key Sequence Input:: How to read one key sequence. * Reading One Event:: How to read just one event. * Quoted Character Input:: Asking the user to specify a character. -* Peeking and Discarding:: How to reread or throw away input events. +* Event Input Misc:: How to reread or throw away input events. @end menu @node Key Sequence Input @@ -1426,9 +1453,9 @@ events---characters, symbols, and lists. The elements of the string or vector are the events in the key sequence. -Quitting is suppressed inside @code{read-key-sequence}. In other words, -a @kbd{C-g} typed while reading with this function is treated like any -other character, and does not set @code{quit-flag}. @xref{Quitting}. +The function @code{read-key-sequence} suppresses quitting: @kbd{C-g} +typed while reading with this function works like any other character, +and does not set @code{quit-flag}. @xref{Quitting}. The argument @var{prompt} is either a string to be displayed in the echo area as a prompt, or @code{nil}, meaning not to display a prompt. @@ -1459,7 +1486,7 @@ @cindex upper case key sequence @cindex downcasing in @code{lookup-key} If an input character is an upper case letter and has no key binding, -but the lower case equivalent has one, then @code{read-key-sequence} +but its lower case equivalent has one, then @code{read-key-sequence} converts the character to lower case. Note that @code{lookup-key} does not perform case conversion in this way. @@ -1469,27 +1496,28 @@ never appear in a key sequence with any other events. When mouse events occur in special parts of a window, such as a mode -line or a scroll bar, the event itself shows nothing special---only the -symbol that would normally represent that mouse button and modifier -keys. The information about the screen region is kept elsewhere in the -event---in the coordinates. But @code{read-key-sequence} translates -this information into imaginary prefix keys, all of which are symbols: -@code{mode-line}, @code{vertical-line}, @code{horizontal-scroll-bar} and +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 +@code{read-key-sequence} translates this information into imaginary +prefix keys, all of which are symbols: @code{mode-line}, +@code{vertical-line}, @code{horizontal-scroll-bar} and @code{vertical-scroll-bar}. +You can define meanings for mouse clicks in special window parts by +defining key sequences using these imaginary prefix keys. + For example, if you call @code{read-key-sequence} and then click the -mouse on the window's mode line, this is what happens: +mouse on the window's mode line, you get an event like this: -@smallexample +@example (read-key-sequence "Click on the mode line: ") @result{} [mode-line - (mouse-1 - (#<window 6 on NEWS> mode-line - (40 . 63) 5959987))] -@end smallexample - -You can define meanings for mouse clicks in special window regions by -defining key sequences using these imaginary prefix keys. + (mouse-1 + (#<window 6 on NEWS> mode-line + (40 . 63) 5959987))] +@end example @node Reading One Event @subsection Reading One Event @@ -1505,13 +1533,12 @@ The function @code{read-event} does not display any message to indicate it is waiting for input; use @code{message} first, if you wish to display one. If you have not displayed a message, @code{read-event} -does @dfn{prompting}: it displays descriptions of the events that led to +prompts by echoing: it displays descriptions of the events that led to or were read by the current command. @xref{The Echo Area}. If @code{cursor-in-echo-area} is non-@code{nil}, then @code{read-event} moves the cursor temporarily to the echo area, to the end of any message displayed there. Otherwise @code{read-event} does not move the cursor. -@end defun Here is what happens if you call @code{read-event} and then press the right-arrow function key: @@ -1522,17 +1549,18 @@ @result{} right @end group @end example +@end defun @defun read-char This function reads and returns a character of command input. It -discards any events that are not characters until it gets a character. +discards any events that are not characters, until it gets a character. -In the first example, the user types @kbd{1} (which is @sc{ASCII} code -49). The second example shows a keyboard macro definition that calls -@code{read-char} from the minibuffer. @code{read-char} reads the -keyboard macro's very next character, which is @kbd{1}. The value of -this function is displayed in the echo area by the command -@code{eval-expression}. +In the first example, the user types the character @kbd{1} (@sc{ASCII} +code 49). The second example shows a keyboard macro definition that +calls @code{read-char} from the minibuffer using @code{eval-expression}. +@code{read-char} reads the keyboard macro's very next character, which +is @kbd{1}. Then @code{eval-expression} displays its return value in +the echo area. @example @group @@ -1545,7 +1573,7 @@ @result{} "^[^[(read-char)^M1" @end group @group -(execute-kbd-macro foo) +(execute-kbd-macro 'foo) @print{} 49 @result{} nil @end group @@ -1556,10 +1584,10 @@ @subsection Quoted Character Input @cindex quoted character input - You can use the function @code{read-quoted-char} when you want the user + You can use the function @code{read-quoted-char} when to ask the user to specify a character, and allow the user to specify a control or meta character conveniently with quoting or as an octal character code. The -command @code{quoted-insert} calls this function. +command @code{quoted-insert} uses this function. @defun read-quoted-char &optional prompt @cindex octal character input @@ -1568,13 +1596,13 @@ This function is like @code{read-char}, except that if the first character read is an octal digit (0-7), it reads up to two more octal digits (but stopping if a non-octal digit is found) and returns the -character represented by those digits as an octal number. +character represented by those digits in octal. Quitting is suppressed when the first character is read, so that the user can enter a @kbd{C-g}. @xref{Quitting}. If @var{prompt} is supplied, it specifies a string for prompting the -user. The prompt string is always printed in the echo area and followed +user. The prompt string is always displayed in the echo area, followed by a single @samp{-}. In the following example, the user types in the octal number 177 (which @@ -1595,74 +1623,76 @@ @need 3000 -@node Peeking and Discarding -@subsection Peeking and Discarding +@node Event Input Misc +@subsection 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. @defvar unread-command-events @cindex next input @cindex peeking at input 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. +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 used because in some cases a function reads a 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 when the functions to -read command input are called. +The variable is needed because in some cases a function reads a 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. @cindex prefix argument unreading 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 it does -not recognize. +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 to put +them in @code{unread-command-events} is to use +@code{listify-key-sequence} (@pxref{Strings of Events}). @end defvar @defvar unread-command-char This variable holds a character to be read as command input. A value of -1 means ``empty''. -This variable is pretty much obsolete now that you can use +This variable is mostly obsolete now that you can use @code{unread-command-events} instead; it exists only to support programs written for Emacs versions 18 and earlier. @end defvar -@defun listify-key-sequence key -This function converts the string or vector @var{key} to a list of -events which you can put in @code{unread-command-events}. Converting a -vector is simple, but converting a string is tricky because of the -special representation used for meta characters in a string -(@pxref{Strings of Events}). -@end defun - @defun input-pending-p @cindex waiting for command key input This function determines whether any command input is currently available to be read. It returns immediately, with value @code{t} if -there is input, @code{nil} otherwise. On rare occasions it may return -@code{t} when no input is available. +there is available input, @code{nil} otherwise. On rare occasions it +may return @code{t} when no input is available. @end defun @defvar last-input-event -@defvarx last-input-char - This variable records the last terminal input event read, whether +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, a character is read (the character @kbd{1}, -@sc{ASCII} code 49). It becomes the value of @code{last-input-char}, +In the example below, the Lisp program reads the character @kbd{1}, +@sc{ASCII} code 49. It becomes the value of @code{last-input-event}, while @kbd{C-e} (from the @kbd{C-x C-e} command used to evaluate this -expression) remains the value of @code{last-command-char}. +expression) remains the value of @code{last-command-event}. @example @group (progn (print (read-char)) - (print last-command-char) - last-input-char) + (print last-command-event) + last-input-event) @print{} 49 @print{} 5 @result{} 49 @end group @end example +@vindex last-input-char The alias @code{last-input-char} exists for compatibility with Emacs version 18. @end defvar @@ -1677,11 +1707,12 @@ In the following example, the user may type a number of characters right after starting the evaluation of the form. After the @code{sleep-for} -finishes sleeping, any characters that have been typed are discarded. +finishes sleeping, @code{discard-input} discards any characters typed +during the sleep. @example (progn (sleep-for 2) - (discard-input)) + (discard-input)) @result{} nil @end example @end defun @@ -1691,19 +1722,19 @@ @cindex pausing @cindex waiting - The waiting commands are designed to make Emacs wait for a certain -amount of time to pass or until there is input. For example, you may -wish to pause in the middle of a computation to allow the user time to -view the display. @code{sit-for} pauses and updates the screen, and -returns immediately if input comes in, while @code{sleep-for} pauses -without updating the screen. + The wait functions are designed to wait for a certain amount of time +to pass or until there is input. For example, you may wish to pause in +the middle of a computation to allow the user time to view the display. +@code{sit-for} pauses and updates the screen, and returns immediately if +input comes in, while @code{sleep-for} pauses without updating the +screen. @defun sit-for seconds &optional millisec nodisp This function performs redisplay (provided there is no pending input from the user), then waits @var{seconds} seconds, or until input is -available. The result is @code{t} if @code{sit-for} waited the full -time with no input arriving (see @code{input-pending-p} in @ref{Peeking -and Discarding}). Otherwise, the value is @code{nil}. +available. The value is @code{t} if @code{sit-for} waited the full +time with no input arriving (see @code{input-pending-p} in @ref{Event +Input Misc}). Otherwise, the value is @code{nil}. @c Emacs 19 feature ??? maybe not working yet The optional argument @var{millisec} specifies an additional waiting @@ -1769,14 +1800,14 @@ can be redefined in the minibuffer in this way. @kbd{C-g} following a prefix key is not redefined in the minibuffer, and it has its normal effect of canceling the prefix key and prefix argument. This too -would not be possible if @kbd{C-g} quit directly. +would not be possible if @kbd{C-g} always quit directly. - @kbd{C-g} causes a quit by setting the variable @code{quit-flag} to a -non-@code{nil} value. Emacs checks this variable at appropriate times -and quits if it is not @code{nil}. Setting @code{quit-flag} + When @kbd{C-g} does directly quit, it does so by the variable +@code{quit-flag} to @code{t}. Emacs checks this variable at appropriate +times and quits if it is not @code{nil}. Setting @code{quit-flag} non-@code{nil} in any way thus causes a quit. - At the level of C code, quits cannot happen just anywhere; only at the + At the level of C code, quitting cannot happen just anywhere; only at the special places which check @code{quit-flag}. The reason for this is that quitting at other places might leave an inconsistency in Emacs's internal state. Because quitting is delayed until a safe place, quitting @@ -1804,7 +1835,7 @@ @cindex @code{read-quoted-char} quitting In some functions (such as @code{read-quoted-char}), @kbd{C-g} is handled in a special way which does not involve quitting. This is done -by reading the input with @code{inhibit-quit} bound to @code{t} and +by reading the input with @code{inhibit-quit} bound to @code{t}, and setting @code{quit-flag} to @code{nil} before @code{inhibit-quit} becomes @code{nil} again. This excerpt from the definition of @code{read-quoted-char} shows how this is done; it also shows that @@ -1825,8 +1856,8 @@ @end example @defvar quit-flag -If this variable is non-@code{nil}, then Emacs quits immediately, -unless @code{inhibit-quit} is non-@code{nil}. Typing @kbd{C-g} sets +If this variable is non-@code{nil}, then Emacs quits immediately, unless +@code{inhibit-quit} is non-@code{nil}. Typing @kbd{C-g} ordinarily sets @code{quit-flag} non-@code{nil}, regardless of @code{inhibit-quit}. @end defvar @@ -1887,8 +1918,8 @@ @minus{}1 and the symbol @code{-}. @end itemize -The various possibilities may be illustrated by calling the following -function with various prefixes: +We illustrate these possibilities by calling the following function with +various prefixes: @example @group @@ -1916,11 +1947,11 @@ C-u - M-x display-prefix @print{} - -M- - M-x display-prefix @print{} - ; @r{(Same as @code{C-u -}.)} +M-- M-x display-prefix @print{} - ; @r{(Same as @code{C-u -}.)} -C-u -7 M-x display-prefix @print{} -7 +C-u - 7 M-x display-prefix @print{} -7 -M- -7 M-x display-prefix @print{} -7 ; @r{(Same as @code{C-u -7}.)} +M-- 7 M-x display-prefix @print{} -7 ; @r{(Same as @code{C-u -7}.)} @end example Emacs uses two variables to store the prefix argument: @@ -1937,6 +1968,27 @@ value of the prefix argument directly in the variable @code{current-prefix-arg}, but this is less clean. +@defun prefix-numeric-value arg +This function returns the numeric meaning of a valid raw prefix argument +value, @var{arg}. The argument may be a symbol, a number, or a list. +If it is @code{nil}, the value 1 is returned; if it is any other symbol, +the value @minus{}1 is returned. If it is a number, that number is +returned; if it is a list, the @sc{car} of that list (which should be a +number) is returned. +@end defun + +@defvar current-prefix-arg +This variable holds the raw prefix argument for the @emph{current} +command. Commands may examine it directly, but the usual way to access +it is with @code{(interactive "P")}. +@end defvar + +@defvar prefix-arg +The value of this variable is the raw prefix argument for the +@emph{next} editing command. Commands that specify prefix arguments for +the following command work by setting this variable. +@end defvar + Do not call the functions @code{universal-argument}, @code{digit-argument}, or @code{negative-argument} unless you intend to let the user enter the prefix argument for the @emph{next} command. @@ -1961,47 +2013,26 @@ call this command yourself unless you know what you are doing. @end deffn -@defun prefix-numeric-value arg -This function returns the numeric meaning of a valid raw prefix argument -value, @var{arg}. The argument may be a symbol, a number, or a list. -If it is @code{nil}, the value 1 is returned; if it is any other symbol, -the value @minus{}1 is returned. If it is a number, that number is -returned; if it is a list, the @sc{car} of that list (which should be a -number) is returned. -@end defun - -@defvar current-prefix-arg -This variable is the value of the raw prefix argument for the -@emph{current} command. Commands may examine it directly, but the usual -way to access it is with @code{(interactive "P")}. -@end defvar - -@defvar prefix-arg -The value of this variable is the raw prefix argument for the -@emph{next} editing command. Commands that specify prefix arguments for -the following command work by setting this variable. -@end defvar - @node Recursive Editing @section Recursive Editing @cindex recursive command loop @cindex recursive editing level @cindex command loop, recursive - The Emacs command loop is entered automatically when Emacs starts up. -This top-level invocation of the command loop is never exited until the -Emacs is killed. Lisp programs can also invoke the command loop. Since -this makes more than one activation of the command loop, we call it -@dfn{recursive editing}. A recursive editing level has the effect of -suspending whatever command invoked it and permitting the user to do -arbitrary editing before resuming that command. + The Emacs command loop is entered automatically when Emacs starts up. +This top-level invocation of the command loop never exits; it keeps +running as long as Emacs does. Lisp programs can also invoke the +command loop. Since this makes more than one activation of the command +loop, we call it @dfn{recursive editing}. A recursive editing level has +the effect of suspending whatever command invoked it and permitting the +user to do arbitrary editing before resuming that command. The commands available during recursive editing are the same ones available in the top-level editing loop and defined in the keymaps. Only a few special commands exit the recursive editing level; the others -return to the recursive editing level when finished. (The special -commands for exiting are always available, but do nothing when recursive -editing is not in progress.) +return to the recursive editing level when they finish. (The special +commands for exiting are always available, but they do nothing when +recursive editing is not in progress.) All command loops, including recursive ones, set up all-purpose error handlers so that an error in a command run from the command loop will @@ -2033,12 +2064,12 @@ Most applications should not use recursive editing, except as part of using the minibuffer. Usually it is more convenient for the user if you change the major mode of the current buffer temporarily to a special -major mode, which has a command to go back to the previous mode. (This -technique is used by the @kbd{w} command in Rmail.) Or, if you wish to -give the user different text to edit ``recursively'', create and select -a new buffer in a special mode. In this mode, define a command to -complete the processing and go back to the previous buffer. (The -@kbd{m} command in Rmail does this.) +major mode, which has a command to go back to the previous mode. (The +@kbd{e} command in Rmail uses this technique.) Or, if you wish to give +the user different text to edit ``recursively'', create and select a new +buffer in a special mode. In this mode, define a command to complete +the processing and go back to the previous buffer. (The @kbd{m} command +in Rmail does this.) Recursive edits are useful in debugging. You can insert a call to @code{debug} into a function definition as a sort of breakpoint, so that @@ -2063,7 +2094,7 @@ @example (defun simple-rec () (forward-word 1) - (message "Recursive edit in progress.") + (message "Recursive edit in progress") (recursive-edit) (forward-word 1)) @result{} simple-rec @@ -2119,8 +2150,8 @@ For a few commands, these properties are present by default and may be removed by the @file{.emacs} file. - If the value of the @code{disabled} property is a string, that string -is included in the message printed when the command is used: + If the value of the @code{disabled} property is a string, the message +saying the command is disabled includes that string. For example: @example (put 'delete-region 'disabled @@ -2134,21 +2165,21 @@ @deffn Command enable-command command Allow @var{command} to be executed without special confirmation from now -on. The user's @file{.emacs} file is optionally altered so that this -will apply to future sessions. +on, and optionally alter the user's @file{.emacs} file so that this will +apply to future sessions. @end deffn @deffn Command disable-command command -Require special confirmation to execute @var{command} from now on. The -user's @file{.emacs} file is optionally altered so that this will apply -to future sessions. +Require special confirmation to execute @var{command} from now on, and +optionally alter the user's @file{.emacs} file so that this will apply +to future sessions. @end deffn @defvar disabled-command-hook -This variable is a normal hook that is run instead of a disabled command, -when the user runs the disabled command interactively. The hook functions -can use @code{this-command-keys} to determine what the user typed to run -the command, and thus find the command itself. +This normal hook is run instead of a disabled command, when the user +invokes the disabled command interactively. The hook functions can use +@code{this-command-keys} to determine what the user typed to run the +command, and thus find the command itself. By default, @code{disabled-command-hook} contains a function that asks the user whether to proceed. @@ -2203,8 +2234,10 @@ @cindex keyboard macros A @dfn{keyboard macro} is a canned sequence of input events that can -be considered a command and made the definition of a key. Don't confuse -keyboard macros with Lisp macros (@pxref{Macros}). +be considered a command and made the definition of a key. The Lisp +representation of a keyboard macro is a string or vector containing the +events. Don't confuse keyboard macros with Lisp macros +(@pxref{Macros}). @defun execute-kbd-macro macro &optional count This function executes @var{macro} as a sequence of events. If @@ -2232,26 +2265,15 @@ @defvar executing-macro This variable contains the string or vector that defines the keyboard macro that is currently executing. It is @code{nil} if no macro is -currently executing. -@end defvar - -@defvar defining-kbd-macro -This variable indicates whether a keyboard macro is being defined. It -is set to @code{t} by @code{start-kbd-macro}, and @code{nil} by -@code{end-kbd-macro}. You can use this variable to make a command -behave differently when run from a keyboard macro (perhaps indirectly by -calling @code{interactive-p}). However, do not set this variable +currently executing. A command can test this variable to behave +differently when run from an executing macro. Do not set this variable yourself. @end defvar -@ignore @c It's hard to make this format ok. - The user-level commands for defining, running and editing keyboard -macros include @code{call-last-kbd-macro}, @code{insert-kbd-macro}, -@code{start-kbd-macro}, @code{end-kbd-macro}, @code{kbd-macro-query}, -and @code{name-last-kbd-macro}. -@end ignore +@defvar defining-kbd-macro +This variable indicates whether a keyboard macro is being defined. A +command can test this variable to behave differently while a macro is +being defined. The commands @code{start-kbd-macro} and +@code{end-kbd-macro} set this variable---do not set it yourself. +@end defvar -@c Broke paragraph to prevent overfull hbox. --rjc 15mar92 - The commands are described in the user's manual (@pxref{Keyboard -Macros,,, emacs, The GNU Emacs Manual}). -