Keybindings and minor modes

Keybindings and minor modes

[Bill Atkins]

I apologize if this is the wrong place to post this, but it seemed
like the most appropriate list.

I'd like to bind a command to tab in a minor mode I'm writing, but I'd
also like to preserve any command that might have been attached to that
key before making my binding (such as indentation).  In other words,
I'd like to add functionality to an existing keybinding without
completely overwriting the binding.

The solution I came up with was to simply store the currently bound
command in a buffer-local variable whenever the minor mode is invoked.
Then the keys are bound to functions that provide my additional
functionality and then funcall the old bindings.  This works, but I
wonder if there isn't a cleaner way to pass a keychord event on to the
next handler.  The code I have now is pretty ugly, since a key bound to
self-insert-command has to be handled separately so that
self-insert-command will get an argument of 0.

I've attached my code below in case it's useful.

Thanks,
Bill Atkins

--

;; ehinter.el - echo lambda-lists when editing emacs lisp code

(defvar ehinter--old-space)
(defvar ehinter--old-tab)
(defvar ehinter--old-ret)

(make-variable-buffer-local 'ehinter--old-space)
(make-variable-buffer-local 'ehinter--old-tab)
(make-variable-buffer-local 'ehinter--old-ret)

(defvar ehinter-mode-map
  (let ((keymap (make-sparse-keymap)))
    (define-key keymap " "     'ehinter--space-cmd)
    (define-key keymap "\t"    'ehinter--tab-cmd)
    (define-key keymap "\C-m"  'ehinter--ret-cmd)
    keymap)
  "Keymap for the Elisp Hinter minor mode")

(define-minor-mode ehinter-mode
    "A minor mode that echoes an arglist for whatever Elisp function is
being
called at point.

\\{ehinter-mode-map}"
  :lighter " EHinter"
  :init-value nil
  (setq ehinter--old-space (ehinter--old-binding " "))
  (setq ehinter--old-tab (ehinter--old-binding "\t"))
  (setq ehinter--old-ret (ehinter--old-binding "\C-m")))

(defun ehinter--old-binding (key)
  (or (lookup-key (current-local-map) key)
      (lookup-key (current-global-map) key)))

(defun ehinter--invoke-binding (binding)
  (if (eq binding 'self-insert-command)
      (self-insert-command 1)
      (funcall binding)))

(defun ehinter--space-cmd ()
  (interactive)
  (ehinter-hint)
  (ehinter--invoke-binding ehinter--old-space))

(defun ehinter--ret-cmd ()
  (interactive)
  (ehinter-hint)
  (ehinter--invoke-binding ehinter--old-ret))

(defun ehinter--tab-cmd ()
  (interactive)
  (ehinter-hint)
  (ehinter--invoke-binding ehinter--old-tab))

(defun ehinter-hint ()
  (interactive)
  (when (and (function-called-at-point)
             (condition-case () (symbol-function (function-called-at-point))
               (void-function nil)))
    (message "%s" (lambda-list (function-called-at-point))))
  (self-insert-command 0))

(defun strip-ends (str)
  (substring str 1 (1- (length str))))

(defun lambda-list (func)
  (let ((fn (symbol-function func)))
    (cond ((and (consp fn)
                (eq (car-safe fn) 'lambda))
           (prin1-to-string (cons func (second fn))))
          ((and (consp fn)
                (eq (car-safe fn) 'macro))
           (prin1-to-string (cons func (svref (cdr fn) 0))))
          ((subrp fn)
           (strip-ends (downcase
                        (prin1-to-string
                         (first (help-split-fundoc (documentation func)
                                                   func))))))
          (t (error "%s" (type-of func))))))

--
Bill Atkins

Re: Keybindings and minor modes

[Stefan Monnier]

> I'd like to bind a command to tab in a minor mode I'm writing, but I'd
> also like to preserve any command that might have been attached to that
> key before making my binding (such as indentation).  In other words,
> I'd like to add functionality to an existing keybinding without
> completely overwriting the binding.

> The solution I came up with was to simply store the currently bound
> command in a buffer-local variable whenever the minor mode is invoked.
> Then the keys are bound to functions that provide my additional
> functionality and then funcall the old bindings.  This works, but I
> wonder if there isn't a cleaner way to pass a keychord event on to the
> next handler.  The code I have now is pretty ugly, since a key bound to
> self-insert-command has to be handled separately so that
> self-insert-command will get an argument of 0.

There's no supported way to do just that.  Among the possible ways to do
something similar:

- (call-interactively
   (let ((my-minor-mode nil)) (key-binding (this-command-keys))))

- don't change the key-bindings.  Instead put advice on the commands.

- do neither.  Use a post/pre-command-hook instead (and check this-command
  or somesuch to decide whether you should do something or not).

- another one I still haven't actually seen used:

   [...]
   (add-hook 'pre-command-hook 'my-pch-reenable)
   (setq my-minor-mode nil)
   (setq unread-command-events
         (nconc (mapcar 'identity (this-command-keys))
                unread-command-events))
   [...]

   (defun my-pch-reenable ()
     (setq my-minor-mode t)
     (remove-hook 'pre-command-hook 'my-pch-reenable))

> I've attached my code below in case it's useful.

Your code seems to do something similar to what eldoc-mode does.
Have you looked at eldoc-mode?


        Stefan