21.3 Interactive Call

After the command loop has translated a key sequence into a command it invokes that command using the function command-execute. If the command is a function, command-execute calls call-interactively, which reads the arguments and calls the command. You can also call these functions yourself.

Function: commandp object &optional for-call-interactively

Returns t if object is suitable for calling interactively; that is, if object is a command. Otherwise, returns nil.

The interactively callable objects include strings and vectors (treated as keyboard macros), lambda expressions that contain a top-level call to interactive, byte-code function objects made from such lambda expressions, autoload objects that are declared as interactive (non-nil fourth argument to autoload), and some of the primitive functions.

A symbol satisfies commandp if its function definition satisfies commandp. Keys and keymaps are not commands. Rather, they are used to look up commands (voir la section Keymaps).

If for-call-interactively is non-nil, then commandp returns t only for objects that call-interactively could call—thus, not for keyboard macros.

See documentation in Access to Documentation Strings, for a realistic example of using commandp.

Function: call-interactively command &optional record-flag keys

This function calls the interactively callable function command, reading arguments according to its interactive calling specifications. It returns whatever command returns. An error is signaled if command is not a function or if it cannot be called interactively (i.e., is not a command). Note that keyboard macros (strings and vectors) are not accepted, even though they are considered commands, because they are not functions. If command is a symbol, then call-interactively uses its function definition.

If record-flag is non-nil, then this command and its arguments are unconditionally added to the list command-history. Otherwise, the command is added only if it uses the minibuffer to read an argument. Voir la section Command History.

The argument keys, if given, should be a vector which specifies the sequence of events to supply if the command inquires which events were used to invoke it. If keys is omitted or nil, the default is the return value of this-command-keys-vector. Voir Definition of this-command-keys-vector.

Function: command-execute command &optional record-flag keys special

This function executes command. The argument command must satisfy the commandp predicate; i.e., it must be an interactively callable function or a keyboard macro.

A string or vector as command is executed with execute-kbd-macro. A function is passed to call-interactively, along with the optional record-flag and keys.

A symbol is handled by using its function definition in its place. A symbol with an autoload definition counts as a command if it was declared to stand for an interactively callable function. Such a definition is handled by loading the specified library and then rechecking the definition of the symbol.

The argument special, if given, means to ignore the prefix argument and not clear it. This is used for executing special events (voir la section Special Events).

Command: execute-extended-command prefix-argument

This function reads a command name from the minibuffer using completing-read (voir la section Completion). Then it uses command-execute to call the specified command. Whatever that command returns becomes the value of execute-extended-command.

If the command asks for a prefix argument, it receives the value prefix-argument. If execute-extended-command is called interactively, the current raw prefix argument is used for prefix-argument, and thus passed on to whatever command is run.

execute-extended-command is the normal definition of M-x, so it uses the string ‘M-x ’ as a prompt. (It would be better to take the prompt from the events used to invoke execute-extended-command, but that is painful to implement.) A description of the value of the prefix argument, if any, also becomes part of the prompt.

(execute-extended-command 3) ---------- Buffer: Minibuffer ---------- 3 M-x forward-word RET ---------- Buffer: Minibuffer ---------- ⇒ t

Function: interactive-p

This function returns t if the containing function (the one whose code includes the call to interactive-p) was called in direct response to user input. This means that it was called with the function call-interactively, and that a keyboard macro is not running, and that Emacs is not running in batch mode.

If the containing function was called by Lisp evaluation (or with apply or funcall), then it was not called interactively.

The most common use of interactive-p is for deciding whether to give the user additional visual feedback (such as by printing an informative message). For example:

;; Here's the usual way to use interactive-p.
(defun foo ()
  (interactive)
  (when (interactive-p)
    (message "foo")))
     ⇒ foo

;; This function is just to illustrate the behavior.
(defun bar ()
  (interactive)
  (setq foobar (list (foo) (interactive-p))))
     ⇒ bar

;; Type M-x foo.
     -| foo

;; Type M-x bar.
;; This does not display a message.

foobar
     ⇒ (nil t)

If you want to test only whether the function was called using call-interactively, add an optional argument print-message which should be non-nil in an interactive call, and use the interactive spec to make sure it is non-nil. Here's an example:

(defun foo (&optional print-message)
  (interactive "p")
  (when print-message
    (message "foo")))

Defined in this way, the function does display the message when called from a keyboard macro. We use "p" because the numeric prefix argument is never nil.

Function: called-interactively-p

This function returns t when the calling function was called using call-interactively.

When possible, instead of using this function, you should use the method in the example above; that method makes it possible for a caller to “pretend” that the function was called interactively.

Ce document a été généré par Eric Reinbold le 13 Octobre 2007 en utilisant texi2html 1.78.