Comment puis-je simuler un événement clé arbitraire depuis Elisp?

Est-il possible de simuler un événement clé arbitraire depuis elisp? Je connais les moyens de trouver la liaison pour une clé donnée, puis d'appeler cette commande de manière interactive, mais que se passe-t-il si cet événement clé n'est pas lié à une commande?

À titre d' exemple , que se passe-t-il si je souhaite lier C-`pour se comporter de la même manière que la ESCclé dans tous les contextes ?

Vous pouvez envoyer des événements arbitraires (frappes, clics de souris, etc.) à la boucle de commande en les plaçant dessus unread-command-events. Par exemple, ce qui suit entraînera la boucle de commande pour exécuter une pause lors de sa prochaine exécution:

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

Notez que cela ne fait que nourrir les événements dans la boucle de commande, donc cela ne fera rien d'intéressant si vous bouclez dans votre propre code.

Une approche différente, dont vous semblez être au courant, consiste à trouver la fonction à laquelle une touche donnée est liée et à l'exécuter vous-même:

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

Cela exécutera la commande immédiatement. Attention, cependant, certaines commandes ont un comportement différent selon qu'elles sont appelées de manière interactive, comme les arguments par défaut. Vous voudrez compenser cela en utilisant call-interactively:

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

La façon la plus simple que je connaisse est simplement d'utiliser execute-kbd-macro:

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

Tiré de cette réponse , vous pouvez utiliser global-set-key comme ceci

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

Qui traitera C-`commeescape

Cela semble avoir quelques problèmes si la deuxième combinaison n'exécute pas de fonction. Donc, si escapeest utilisé comme Meta, alors cela ne fonctionne pas correctement. Mais cela semble fonctionner pour les commandes liées aux fonctions.

Après avoir lu la suggestion de jch à utiliser unread-command-events, j'ai pu pirater ensemble une solution qui fera certaines des choses que je recherche.

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

Il y a encore un certain nombre de problèmes à résoudre. À savoir, je n'obtiens pas le résultat correct si j'appelle cette fonction deux fois de suite dans un seul defun.

Note latérale:

Après avoir vérifié la suggestion d'utilisation de phils,key-translation-map j'ai pu trouver local-function-key-mapce qui est également très utile pour atteindre certains de mes objectifs plus larges.