How can I simulate an arbitary key event from Elisp?

Question

Is it possible to simulate an arbitrary key event from elisp? I am aware of ways that I can find the binding for a given key, and then call that command interactively, but what if that key event is not bound to a command?

As one example, what if I wanted to bind C-` to behave the same as the ESC key in all contexts?

Answer 1

You can feed arbitrary events (keystrokes, mouse clicks, etc.) to the command loop by putting them onto unread-command-events. For example, the following will cause the command loop to execute a break the next time it is run:

(setq unread-command-events (listify-key-sequence "\C-g"))

Note that this only feeds events to the command loop, so it will do nothing interesting if you're looping in your own code.

A different approach, which you seem to be aware of, is to find the function a given key is bound to, and execute it yourself:

(funcall (global-key-binding "\C-g"))

This will execute the command immediately. Beware, however, that some commands have different behaviour depending on whether they are called interactively, such as defaulting arguments. You'll want to compensate for that by using call-interactively:

(call-interactively (global-key-binding "\C-g"))

Answer 2

The simplest way I know of is just to use execute-kbd-macro:

(defun foo () (interactive) (execute-kbd-macro (kbd "<escape>")))
(global-set-key (kbd "C-`") 'foo)

Answer 3

Taken from this answer, you can use global-set-key like this

(global-set-key (kbd "C-`") (kbd "<escape>"))

Which will treat C-` as escape

This does seem to have some problems though if the second combination doesn't execute a function. So if escape is being used like Meta, then it doesn't work correctly. But it seems to work for commands bound to functions.

Answer 4

After reading the suggestion from jch to use unread-command-events, I was able to hack together a solution that will do some of the things that I am looking for.

(defun my-simulate-key-event (event &optional N)
  "Simulate an arbitrary keypress event.

This function sets the `unread-command-events' variable in order to simulate a
series of key events given by EVENT. Can also For negative N, simulate the
specified key EVENT directly.  For positive N, removes the last N elements from
the list of key events in `this-command-keys' and then appends EVENT.  For N nil,
treat as N=1."
  (let ((prefix (listify-key-sequence (this-command-keys)))
         (key (listify-key-sequence event))
         (n (prefix-numeric-value N)))
     (if (< n 0)
         (setq prefix key)
       (nbutlast prefix n)
       (nconc prefix key))
       (setq unread-command-events prefix)))

There are still a number of kinks to work out. Namely, I don't get the correct result if I call this function twice in a row within a single defun.

---

Side Note:

After checking out phils' suggestion to use key-translation-map I was able to find local-function-key-map which is also very helpful in achieving some of my broader goals.