make local map bindings available through a global prefix

Question

I am trying to set up something like Spacemacs, but fully under my control. I have already created a tree of my own keymaps with global commands, and it is available on M-SPC. But now I'd like to also make available local bindings for major modes, those that typically start with C-c, through the same prefix M-SPC, but without the C-c.

Clearly I cannot just get the part of the local map after C-c and graft it onto my M-SPC tree - it would have to be a function that looks up the binding on the fly. But how to read the key sequence? read-key-sequence only works on "active" maps according to the doc - indeed it has to because it has no keymap argument. But the keymap I need to consult when reading the keys is not active, it is the sub-keymap of the local map after C-c. So I seem to be stuck.

Answer 1

Based on the clarifications to the question, something like this might do the trick?

(defvar my-leader-map (make-sparse-keymap)
  "Prefix binding for custom things.")

(global-set-key (kbd "M-SPC") my-leader-map)

;; My global bindings go here.  E.g.:
(define-key my-leader-map (kbd "C-b") 'other-window)
;; etc...

;; Default binding.
(define-key my-leader-map [t] 'my-leader-map-default)

(defun my-leader-map-default ()
  "Use the binding under the C-c prefix of `current-local-map'."
  (interactive)
  (let ((prefix (lookup-key (current-local-map) (kbd "C-c"))))
    (when (keymapp prefix)
      (let ((map (make-sparse-keymap)))
        (set-keymap-parent map prefix)
        (define-key map [t] 'undefined)
        (set-transient-map map)
        (push last-command-event unread-command-events)))))

---

Or perhaps this, which would make the bindings more discoverable:

(defvar my-leader-map (make-sparse-keymap)
  "Prefix binding for custom things.")

(global-set-key (kbd "M-SPC") my-leader-map)

;; My global bindings go here.  E.g.:
(define-key my-leader-map (kbd "C-b") 'other-window)
;; etc...

(add-hook 'after-change-major-mode-hook #'my-leader-map-set-local)

(defun my-leader-map-set-local ()
  "Set `current-local-map' to include C-c bindings under `my-leader-map'."
  (when (current-local-map)
    (let ((prefix (lookup-key (current-local-map) (kbd "C-c"))))
      (when (keymapp prefix)
        (use-local-map
         (let ((map (make-sparse-keymap)))
           (set-keymap-parent map (current-local-map))
           (define-key map (kbd "M-SPC")
                       (make-composed-keymap my-leader-map prefix))
           map))))))

You might cache and re-use the latter maps on a per-major-mode basis.

---

Edit: One more... this somewhere between the others, functionality-wise: C-hkM-SPC<foo> will work for local-map bindings, but M-SPCC-h will only show your custom bindings.

Caveat: I'm not 100% certain that (lookup-key prefix (vector last-input-event)) is valid for all situations.

(defvar my-leader-map (make-sparse-keymap)
  "Prefix binding for custom things.")

(global-set-key (kbd "M-SPC") my-leader-map)

;; My global bindings go here.  E.g.:
(define-key my-leader-map (kbd "C-b") 'other-window)
;; etc...

(define-key my-leader-map [t]
  `(menu-item "" nil :filter ,#'my-leader-map-default-filter))

(defun my-leader-map-default-filter (_cmd)
  "Use the binding under the C-c prefix of `current-local-map'."
  (let ((prefix (lookup-key (current-local-map) (kbd "C-c"))))
    (when (keymapp prefix)
      (lookup-key prefix (vector last-input-event)))))

Answer 2

• Using general.el, you can bind a key under SPC to a general-simulate-key call:

(general-def
  "SPC c" (general-simulate-key "C-c"))

Since C-c and C-x bindings will have conflicts if merged (like C-c @ and C-x @), this is probably the most doable method.

• There is a builtin function, describe-buffer-bindings, that tells you which keys are bound to what in the current buffer, and it accepts a prefix as an argument, but it is a C function that inserts something like this into the current buffer:

(describe-buffer-bindings (current-buffer) (kbd "C-c")) ; in an Elisp buffer

`magit-file-mode' Minor Mode Bindings Starting With C-c:
key             binding
---             -------

C-c ESC         Prefix Command

C-c M-g         magit-file-dispatch


`magit-file-mode' Minor Mode Bindings Starting With C-c:
key             binding
---             -------

C-c ESC         Prefix Command


`hs-minor-mode' Minor Mode Bindings Starting With C-c:
key             binding
---             -------

C-c @           Prefix Command

C-c @ C-a       hs-show-all
C-c @ C-c       hs-toggle-hiding
C-c @ C-d       hs-hide-block
C-c @ C-e       hs-toggle-hiding
C-c @ C-h       hs-hide-block
C-c @ C-l       hs-hide-level
C-c @ C-s       hs-show-block
C-c @ C-t       hs-hide-all
C-c @ ESC       Prefix Command

C-c @ C-M-h     hs-hide-all
C-c @ C-M-s     hs-show-all


`nameless-mode' Minor Mode Bindings Starting With C-c:
key             binding
---             -------

C-c C--         nameless-insert-name


Global Bindings Starting With C-c:
key             binding
---             -------

C-c c           org-capture

So there doesn't seem to be a proper way to get bindings that you can use to get a raw keymap.

Answer 3

I am a fool. There was never a problem to start with. Since bindings from active keymaps (including the global and local) are merged, all that is necessary is to add the desired bindings, starting with M-SPC, to each mode keymap where I want it to happen. This is much simpler and also a bit safer than the proposal by @phils because it keeps the effect isolated to an explicitly chosen handful of mode keymaps.

Nonetheless I'm acking @phils answer because I think it is correct.