Keybindings and minor modes

[Bill Atkins <atkinw@rpi.edu>]

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