que - manual de emacs en español pdf

¿Cómo escribir una combinación de teclas en emacs para repetir fácilmente?

Question

Supongamos que ato la clave a una determinada función de la siguiente manera:

(global-set-key (kbd "C-c =") ''function-foo)

Ahora, quiero que el enlace de claves funcione como:
Después de presionar Cc = por primera vez, si quiero repetir la función-foo, no necesito presionar Cc nuevamente, sino simplemente repetir presionando = . Luego, después de llamar a la función-foo durante las suficientes veces, solo puedo presionar teclas que no sean = (o presionar explícitamente Cg ) para salir.

¿Como hacer esto?

Answer 1

Desea que su function-foo use set-temporary-overlay-map .

Answer 2

Hay un paquete de smartrep.el que hace exactamente lo que necesita. La documentación es un poco escasa, pero se puede obtener una idea de cómo se supone que se debe utilizar buscando en numerosas configuraciones de emacs encontradas en github. Por ejemplo (tomado de aquí ):

(require ''smartrep)
(smartrep-define-key
    global-map "C-q" ''(("n" . (scroll-other-window 1))
                       ("p" . (scroll-other-window -1))
                       ("N" . ''scroll-other-window)
                       ("P" . (scroll-other-window ''-))
                       ("a" . (beginning-of-buffer-other-window 0))
                       ("e" . (end-of-buffer-other-window 0))))

Answer 3

Esto es lo que uso Me gusta porque no tienes que especificar la tecla de repetición.

(require ''repeat)
(defun make-repeatable-command (cmd)
  "Returns a new command that is a repeatable version of CMD.
The new command is named CMD-repeat.  CMD should be a quoted
command.

This allows you to bind the command to a compound keystroke and
repeat it with just the final key.  For example:

  (global-set-key (kbd /"C-c a/") (make-repeatable-command ''foo))

will create a new command called foo-repeat.  Typing C-c a will
just invoke foo.  Typing C-c a a a will invoke foo three times,
and so on."
  (fset (intern (concat (symbol-name cmd) "-repeat"))
        `(lambda ,(help-function-arglist cmd) ;; arg list
           ,(format "A repeatable version of `%s''." (symbol-name cmd)) ;; doc string
           ,(interactive-form cmd) ;; interactive form
           ;; see also repeat-message-function
           (setq last-repeatable-command '',cmd)
           (repeat nil)))
  (intern (concat (symbol-name cmd) "-repeat")))

Answer 4

Esto puede ser lo que estás buscando:

(defun function-foo ()
  (interactive)
  (do-your-thing)
  (set-temporary-overlay-map
    (let ((map (make-sparse-keymap)))
      (define-key map (kbd "=") ''function-foo)
      map)))

Answer 5

Además de lo que sugirió @juanleon, que usa set-temporary-overlay-map , aquí hay una alternativa que uso bastante. Utiliza la biblioteca estándar repeat.el .

;; This function builds a repeatable version of its argument COMMAND.
(defun repeat-command (command)
  "Repeat COMMAND."
 (interactive)
 (let ((repeat-previous-repeated-command  command)
       (last-repeatable-command           ''repeat))
   (repeat nil)))

Úselo para definir diferentes comandos repetibles. P.ej,

(defun backward-char-repeat ()
  "Like `backward-char'', but repeatable even on a prefix key."
  (interactive)
  (repeat-command ''backward-char))

A continuación, enlace dicho comando a una clave con un sufijo repetible, por ejemplo, Cc = (para Cc = = = = ...)

Vea esta publicación SO para más información.