How to use meow with Doom Emacs?

[VitalyAnkh]

Here is my config, copied a lot from a Telegram friend. It would be nice if we have a Doom Emacs module. I'm working on it.

(map! :leader
      ;; make doom-leader-buffer-map alive
      (:prefix-map ("b" . "buffer")
       :desc "Toggle narrowing"            "-"   #'doom/toggle-narrow-buffer
       :desc "Previous buffer"             "["   #'previous-buffer
       :desc "Next buffer"                 "]"   #'next-buffer
       (:when (featurep! :ui workspaces)
        :desc "Switch workspace buffer"    "b" #'persp-switch-to-buffer
        :desc "Switch buffer"              "B" #'switch-to-buffer)
       (:unless (featurep! :ui workspaces)
        :desc "Switch buffer"               "b"   #'switch-to-buffer)
       :desc "Clone buffer"                "c"   #'clone-indirect-buffer
       :desc "Clone buffer other window"   "C"   #'clone-indirect-buffer-other-window
       :desc "Kill buffer"                 "d"   #'kill-current-buffer
       :desc "ibuffer"                     "i"   #'ibuffer
       :desc "Kill buffer"                 "k"   #'kill-current-buffer
       :desc "Kill all buffers"            "K"   #'doom/kill-all-buffers
       :desc "Switch to last buffer"       "l"   #'evil-switch-to-windows-last-buffer
       :desc "Set bookmark"                "m"   #'bookmark-set
       :desc "Delete bookmark"             "M"   #'bookmark-delete
       :desc "Next buffer"                 "n"   #'next-buffer
       :desc "New empty buffer"            "N"   #'evil-buffer-new
       :desc "Kill other buffers"          "O"   #'doom/kill-other-buffers
       :desc "Previous buffer"             "p"   #'previous-buffer
       :desc "Revert buffer"               "r"   #'revert-buffer
       :desc "Save buffer"                 "s"   #'basic-save-buffer
       :desc "Save all buffers"            "S"   #'evil-write-all
       :desc "Save buffer as root"         "u"   #'doom/sudo-save-buffer
       :desc "Pop up scratch buffer"       "x"   #'doom/open-scratch-buffer
       :desc "Switch to scratch buffer"    "X"   #'doom/switch-to-scratch-buffer
       :desc "Bury buffer"                 "z"   #'bury-buffer
       :desc "Kill buried buffers"         "Z"   #'doom/kill-buried-buffers)
      )
(defun set-useful-keybindings()
  (global-set-key (kbd "M-o") 'ace-window)
  (define-key doom-leader-workspaces/windows-map (kbd "t") 'treemacs-select-window)
  (global-set-key (kbd "M-j") 'kmacro-start-macro-or-insert-counter)
  (global-set-key (kbd "M-k") 'kmacro-end-or-call-macro)
  )
(defun meow-setup ()
  (set-useful-keybindings)
  (map!
   (:when (featurep! :ui workspaces)
    :n "C-t"   #'+workspace/new
    :n "C-S-t" #'+workspace/display
    :g "M-1"   #'+workspace/switch-to-0
    :g "M-2"   #'+workspace/switch-to-1
    :g "M-3"   #'+workspace/switch-to-2
    :g "M-4"   #'+workspace/switch-to-3
    :g "M-5"   #'+workspace/switch-to-4
    :g "M-6"   #'+workspace/switch-to-5
    :g "M-7"   #'+workspace/switch-to-6
    :g "M-8"   #'+workspace/switch-to-7
    :g "M-9"   #'+workspace/switch-to-8
    :g "M-0"   #'+workspace/switch-to-final
    ))
  (setq meow-cheatsheet-layout meow-cheatsheet-layout-qwerty)
  (meow-motion-overwrite-define-key
   '("j" . meow-next)
   '("k" . meow-prev))
  (meow-leader-define-key
   ;; SPC j/k will run the original command in MOTION state.
   '("j" . "H-j")
   '("k" . "H-k")
   ;; Use SPC (0-9) for digit arguments.
   '("1" . meow-digit-argument)
   '("2" . meow-digit-argument)
   '("3" . meow-digit-argument)
   '("4" . meow-digit-argument)
   '("5" . meow-digit-argument)
   '("6" . meow-digit-argument)
   '("7" . meow-digit-argument)
   '("8" . meow-digit-argument)
   '("9" . meow-digit-argument)
   '("0" . meow-digit-argument)
   '("/" . meow-keypad-describe-key)
   '("?" . meow-cheatsheet)
   (cons "f" doom-leader-file-map)
   ;;(cons "a" org-agenda-keymap )
   (cons "d" doom-leader-code-map)
   (cons "s" doom-leader-search-map)
   (cons "b" doom-leader-buffer-map)
   (cons "o" doom-leader-open-map)
   (cons "v" doom-leader-versioning-map)
   (cons "n" doom-leader-notes-map)
   (cons "p" projectile-command-map)
   (cons "i" doom-leader-insert-map)
   (cons "q" doom-leader-quit/restart-map)
   (cons "h" help-map)
   (cons "t" doom-leader-toggle-map)
   (cons "w" doom-leader-workspaces/windows-map)
   (cons "S" doom-leader-snippets-map)
   ;;(cons "M" doom-leader-multiple-cursors-map)
   )

  (meow-normal-define-key
   '("0" . meow-expand-0)
   '("9" . meow-expand-9)
   '("8" . meow-expand-8)
   '("7" . meow-expand-7)
   '("6" . meow-expand-6)
   '("5" . meow-expand-5)
   '("4" . meow-expand-4)
   '("3" . meow-expand-3)
   '("2" . meow-expand-2)
   '("1" . meow-expand-1)
   '("-" . negative-argument)
   '(";" . meow-reverse)
   '("," . meow-inner-of-thing)
   '("." . meow-bounds-of-thing)
   '("[" . meow-beginning-of-thing)
   '("]" . meow-end-of-thing)
   '("/" . meow-visit)
   '("a" . meow-append)
   '("A" . meow-join)
   '("b" . meow-back-word)
   '("B" . meow-back-symbol)
   '("c" . meow-change)
   '("d" . meow-delete)
   '("D" . meow-backward-delete)
   '("e" . meow-next-symbol)
   '("E" . meow-mark-symbol)
   '("f" . meow-find)
   '("g" . meow-cancel-selection)
   '("G" . meow-grab)
   '("h" . meow-left)
   '("H" . meow-left-expand)
   '("i" . meow-insert)
   '("I" . meow-open-above)
   '("j" . meow-next)
   '("J" . meow-next-expand)
   '("k" . meow-prev)
   '("K" . meow-prev-expand)
   '("l" . meow-right)
   '("L" . meow-right-expand)
   '("m" . meow-mark-word)
   '("M" . meow-mark-symbol)
   '("n" . meow-search)
   '("o" . meow-block)
   '("O" . meow-to-block)
   '("p" . meow-yank)
   '("q" . meow-open-below)
   '("Q" . meow-goto-line)
   '("r" . meow-replace)
   '("R" . meow-swap-grab)
   '("s" . meow-kill)
   '("t" . meow-till)
   '("u" . meow-undo)
   '("U" . meow-undo-in-selection)
   '("v" . meow-grab)
   '("w" . meow-next-word)
   '("x" . meow-line)
   '("X" . meow-line-expand)
   '("y" . meow-save)
   '("Y" . meow-sync-grab)
   '("z" . meow-pop-selection)
   '("'" . repeat)
   '("\\" . quoted-insert)
   ;;'("<escape>" . mode-line-other-buffer)
   )
  (defun meow-insert-define-key (&rest keybindings)
    "Define key for insert state.

Usage:
  (meow-insert-define-key
   '(\"C-<space>\" . meow-insert-exit))"
    (mapcar (lambda (key-ref)
              (define-key meow-insert-state-keymap
                (kbd (car key-ref))
                (meow--parse-key-def (cdr key-ref))))
            keybindings))
  (meow-insert-define-key
   '("\C-[" . meow-insert-exit))

  (setq meow-expand-exclude-mode-list nil)
  (setq meow-expand-hint-remove-delay 1024)
  (define-key input-decode-map (kbd "C-[") [control-bracketleft])
  (define-key meow-insert-state-keymap [control-bracketleft] 'meow-insert-exit)
  (setq meow-use-clipboard t
        meow-visit-sanitize-completion nil
        )
  )
(use-package meow
  :config
  (require 'meow)
  (meow-setup)
  (meow-global-mode 1)
  )

[DogLooksGood]

Glad to see doom-leader-multiple-cursors-map is commented. 😼

[DogLooksGood]

FYI

;; let's assume keymap-a is the leader keymap from doom
;; and keymap-b is the leader keymap from meow

;; keymap-a is defined in doom core
(defvar keymap-a
  (let ((keymap (make-sparse-keymap)))
    keymap))

;; define keymap-b as an alias of keymap-a
;; now keymap-a, keymap-b are the same
(defvaralias 'keymap-b 'keymap-a)

;; defvar here is ignored, since keymap-b is already exist
(defvar keymap-b
  (let ((keymap (make-sparse-keymap)))
    keymap))

;; assume this function is meow-leader-define-key
(defun bind-some-key-in-keymap-b ()
  (define-key keymap-b (kbd "a") #'keyboard-escape-quit))

;; you call helper function which tries to define key in meow leader keymap, but actually key is defined in doom's leader keymap
(bind-some-key-in-keymap-b)

;; check the value of keymap-a
keymap-a

;; check the value of keymap-b
keymap-b

This is an example to make two keymap the same things.

Both meow and doom have helpers functions for keybinding, I think we can use this patch. Otherwise, users have to choice which leader keymap to use.

https://www.gnu.org/software/emacs/manual/html_node/elisp/Variable-Aliases.html

[DogLooksGood]

Let meow-leader-keymap be the alias of doom-leader-keymap.
Doom leader keymap is bound to C-c, and meow-leader-keymap is bound to SPC in meow normal mode. But now, they refer to the same one, which is doom-leader-keymap.

Then you let doom using C-c l as local leader , so l in doom-leader-keymap will become the local leader, later handled by doom.

The result:

1. SPC will call doom-leader-keymap and meow's keypad-start commands are bound to corresponding keys automatically.
2. SPC l is the local leader.
3. meow helper functions should work.
4. doom helper macros should work.

I guess only 1 line is required

(defvaralias 'meow-leader-keymap 'doom-leader-keymap)

This line should be placed to where before meow is required.

[DogLooksGood]

For someone is trying to use meow with doom-emacs

https://github.com/Not-Leader/doom-meow