BHW Emacs Configuration

;;---------------------------------------------------------------------------
;; These have to be set before Evil loads.
(setq evil-want-keybinding nil          ; evil-collection supplies these
      evil-want-C-g-bindings t
      evil-want-C-i-jump nil
      evil-want-C-u-scroll t            ; the universal argument is on SPC u
      evil-want-C-u-delete t
      evil-want-C-w-delete t
      evil-want-Y-yank-to-eol t
      evil-want-abbrev-expand-on-insert-exit nil
      evil-respect-visual-line-mode t
      evil-undo-system 'undo-redo)

(setq evil-ex-search-vim-style-regexp t
      evil-ex-visual-char-range t       ; column range for ex commands
      evil-mode-line-format nil
      evil-symbol-word-search t
      evil-default-cursor #'bhw/evil-default-cursor-fn
      evil-normal-state-cursor 'box
      evil-emacs-state-cursor '(box bhw/evil-emacs-cursor-fn)
      evil-insert-state-cursor 'bar
      evil-visual-state-cursor 'hollow
      evil-ex-interactive-search-highlight 'selected-window
      evil-kbd-macro-suppress-motion-error t
      evil-visual-update-x-selection-p nil
      save-silently t)

(defun bhw/evil-update-cursor-color-h (&rest _)
  "Take the cursor colours for normal and emacs state from the theme."
  (put 'cursor 'evil-emacs-color (face-foreground 'warning nil t))
  (put 'cursor 'evil-normal-color (face-background 'cursor nil t)))

(defun bhw/evil--set-cursor-color (property)
  "Colour the cursor with the colour stored under PROPERTY, if there is one."
  (let ((color (get 'cursor property)))
    (when (stringp color)
      (evil-set-cursor-color color))))

(defun bhw/evil-default-cursor-fn ()
  "Colour the cursor for normal state."
  (bhw/evil--set-cursor-color 'evil-normal-color))

(defun bhw/evil-emacs-cursor-fn ()
  "Colour the cursor for emacs state."
  (bhw/evil--set-cursor-color 'evil-emacs-color))

(add-hook 'enable-theme-functions #'bhw/evil-update-cursor-color-h -100)
(add-hook 'server-after-make-frame-hook #'bhw/evil-update-cursor-color-h)

(require 'evil)
(evil-select-search-module 'evil-search-module 'evil-search)

(when evil-respect-visual-line-mode
  (evil-define-minor-mode-key 'motion 'visual-line-mode
    [up]   #'evil-previous-visual-line
    [down] #'evil-next-visual-line
    [home] #'evil-beginning-of-visual-line
    [end]  #'evil-end-of-visual-line))

(with-eval-after-load 'eldoc
  (eldoc-add-command 'evil-normal-state 'evil-insert 'evil-change
                     'evil-delete 'evil-replace))

;;---------------------------------------------------------------------------
;; Commands.
(defvar bhw/evil-want-o/O-to-continue-comments t
  "Non-nil if o and O continue a comment when point is on a comment line.")

(defvar bhw/evil-want-move-window-to-wrap-around nil
  "Non-nil if the window-move commands wrap around at the frame's edge.")

(defvar bhw/evil-preprocessor-regexp "^\\s-*#[a-zA-Z0-9_]"
  "What ]# and [# jump between.  By default, C preprocessor directives.")

(defun bhw/evil-escape ()
  "Leave insert, replace, visual or operator state, as ESC would.
C-g is bound to this in those states."
  (interactive)
  (pcase evil-state
    ((or 'insert 'replace) (evil-normal-state))
    ('visual (evil-exit-visual-state))
    (_ (keyboard-quit))))

(defun bhw/evil-shift-right ()
  "Shift the selection right and keep it selected."
  (interactive)
  (call-interactively #'evil-shift-right)
  (evil-normal-state)
  (evil-visual-restore))

(defun bhw/evil-shift-left ()
  "Shift the selection left and keep it selected."
  (interactive)
  (call-interactively #'evil-shift-left)
  (evil-normal-state)
  (evil-visual-restore))

(defun bhw/evil--move-lines (fn count)
  "Call FN, a wizard command that moves the region, on the selected lines.
COUNT is how far.  The lines are taken whole however they were selected,
as `:move' takes them, and are selected by the line afterwards: wizard
moves the text of the region as it stands, and leaves a selection by the
character behind."
  (let ((type (evil-visual-type))
        (dir (evil-visual-direction)))
    ;; A last line with no newline would be joined to its neighbour.
    (save-excursion
      (goto-char (point-max))
      (unless (bolp) (insert "\n")))
    (let* ((beg (save-excursion (goto-char (region-beginning)) (pos-bol)))
           (end (save-excursion (goto-char (region-end))
                                (if (and (bolp) (> (point) beg))
                                    (point)
                                  (pos-bol 2)))))
      (goto-char beg)
      (set-mark end)
      (funcall fn count)
      (evil-visual-select (region-beginning) (region-end)
                          (if (eq type 'screen-line) type 'line) dir nil))))

(defun bhw/evil-move-lines-down (count)
  "Move the selected lines down COUNT lines and keep them selected."
  (interactive "p")
  (bhw/evil--move-lines #'wizard-move-region-down count))

(defun bhw/evil-move-lines-up (count)
  "Move the selected lines up COUNT lines and keep them selected."
  (interactive "p")
  (bhw/evil--move-lines #'wizard-move-region-up count))

(defun bhw/evil-alt-paste ()
  "Call `evil-paste-after' with `evil-kill-on-visual-paste' inverted.
By default that replaces the selection with the clipboard without
putting the selection on the clipboard."
  (interactive)
  (let ((evil-kill-on-visual-paste (not evil-kill-on-visual-paste)))
    (call-interactively #'evil-paste-after)))

(defun bhw/evil-reselect-paste ()
  "Return to visual state and reselect the last pasted region."
  (interactive)
  (cl-destructuring-bind (_ _ _ beg end &optional _)
      evil-last-paste
    (evil-visual-make-selection
     (save-excursion (goto-char beg) (point-marker))
     end)))

(defun bhw/evil--window-swap (direction &optional invert-wrap)
  "Move the current window to the next window in DIRECTION.
With only one window, split in that direction and move there.  With no
window that way but others elsewhere, move to the far edge.  At the
edge of the frame, wrap around if
`bhw/evil-want-move-window-to-wrap-around' says so; INVERT-WRAP
inverts that."
  (unless (memq direction '(left right up down))
    (user-error "Invalid direction: %s" direction))
  (when (window-dedicated-p)
    (user-error "Cannot swap a dedicated window"))
  (let* ((this-window (selected-window))
         (that-window (window-in-direction direction nil this-window))
         (that-buffer (window-buffer that-window)))
    (when (or (minibufferp that-buffer)
              (window-dedicated-p this-window))
      (setq that-buffer nil that-window nil))
    (if (not (or that-window (one-window-p t)))
        (if (and (window-at-side-p
                  this-window (pcase direction ('up 'top) ('down 'bottom) (_ direction)))
                 (not (cl-loop for dir in (if (memq direction '(left right))
                                              '(up down) '(left right))
                               if (window-in-direction dir nil this-window)
                               return t)))
            (if (funcall (if invert-wrap #'not #'identity)
                         bhw/evil-want-move-window-to-wrap-around)
                (call-interactively
                 (pcase direction
                   ('left  #'evil-window-move-far-right)
                   ('right #'evil-window-move-far-left)
                   ('up    #'evil-window-move-very-bottom)
                   ('down  #'evil-window-move-very-top)))
              (user-error "Window is already at the edge"))
          (call-interactively
           (pcase direction
             ('left  #'evil-window-move-far-left)
             ('right #'evil-window-move-far-right)
             ('up    #'evil-window-move-very-top)
             ('down  #'evil-window-move-very-bottom))))
      (unless that-window
        (setq that-window (split-window this-window nil direction))
        (with-selected-window that-window
          (switch-to-buffer (bhw/fallback-buffer)))
        (setq that-buffer (window-buffer that-window)))
      (window-swap-states this-window that-window)
      (select-window that-window))))

(defun bhw/evil-window-move-left (&optional arg)
  "Swap this window with the one to its left."
  (interactive "P")
  (bhw/evil--window-swap 'left (or arg bhw/evil-want-move-window-to-wrap-around)))

(defun bhw/evil-window-move-right (&optional arg)
  "Swap this window with the one to its right."
  (interactive "P")
  (bhw/evil--window-swap 'right (or arg bhw/evil-want-move-window-to-wrap-around)))

(defun bhw/evil-window-move-up (&optional arg)
  "Swap this window with the one above."
  (interactive "P")
  (bhw/evil--window-swap 'up (or arg bhw/evil-want-move-window-to-wrap-around)))

(defun bhw/evil-window-move-down (&optional arg)
  "Swap this window with the one below."
  (interactive "P")
  (bhw/evil--window-swap 'down (or arg bhw/evil-want-move-window-to-wrap-around)))

(defun bhw/evil-window-split-and-follow ()
  "Split the window horizontally and select the new one."
  (interactive)
  (let ((evil-split-window-below (not evil-split-window-below)))
    (call-interactively #'evil-window-split)))

(defun bhw/evil-window-vsplit-and-follow ()
  "Split the window vertically and select the new one."
  (interactive)
  (let ((evil-vsplit-window-right (not evil-vsplit-window-right)))
    (call-interactively #'evil-window-vsplit)))

(evil-define-operator bhw/evil-apply-macro (beg end)
  "Apply a macro to each line."
  :move-point nil
  (interactive "<r>")
  (let ((register (or evil-this-register (read-char)))
        macro)
    (cond ((or (and (eq register ?@) (eq evil-last-register ?:))
               (eq register ?:))
           (setq macro (lambda () (evil-ex-repeat nil))
                 evil-last-register ?:))
          ((eq register ?@)
           (unless evil-last-register
             (user-error "No previously executed keyboard macro"))
           (setq macro (evil-get-register evil-last-register t)))
          ((setq macro (evil-get-register register t)
                 evil-last-register register)))
    (unless macro
      (user-error "No macro recorded in %c register" register))
    (evil-change-state 'normal)
    (evil-with-single-undo
      (let ((lines (count-lines beg end)))
        (message "Applied macro in %c register %d times" register lines)
        (apply-macro-to-region-lines beg end macro)
        (message "Applied macro in %c register %d times...DONE" register lines)))))

(evil-define-operator bhw/evil-narrow-buffer (beg end &optional bang)
  "Narrow the buffer to the region, or widen it if it is narrowed.
With BANG, narrow in an indirect clone of the buffer instead."
  :move-point nil
  (interactive "<r><!>")
  (if (not bang)
      (if (buffer-narrowed-p)
          (widen)
        (narrow-to-region beg end))
    (when (buffer-narrowed-p)
      (bhw/widen-indirectly-narrowed-buffer t))
    (bhw/narrow-buffer-indirectly beg end)))

(evil-define-operator bhw/evil-yank-unindented (beg end _type _register _yank-handler)
  "Yank the text of the motion with its common indentation removed."
  :move-point nil
  :repeat nil
  (interactive "<R><x><y>")
  (let ((indent (save-excursion (goto-char beg) (current-indentation)))
        (text (buffer-substring beg end)))
    (with-temp-buffer
      (insert text)
      (indent-rigidly (point-min) (point-max) (- indent))
      (evil-yank (point-min) (point-max)))))

;; Next and previous, in the manner of vim-unimpaired.
(defun bhw/evil-next-beginning-of-method (count)
  "Jump to the beginning of the COUNT-th function after point."
  (interactive "p")
  (beginning-of-defun (- count)))

(defun bhw/evil-previous-beginning-of-method (count)
  "Jump to the beginning of the COUNT-th function before point."
  (interactive "p")
  (beginning-of-defun count))

(defalias 'bhw/evil-next-end-of-method #'end-of-defun
  "Jump to the end of the COUNT-th function after point.")

(defun bhw/evil-previous-end-of-method (count)
  "Jump to the end of the COUNT-th function before point."
  (interactive "p")
  (end-of-defun (- count)))

(defun bhw/evil-next-preproc-directive (count)
  "Jump to the COUNT-th preprocessor directive after point."
  (interactive "p")
  (if (re-search-forward bhw/evil-preprocessor-regexp nil t count)
      (goto-char (match-beginning 0))
    (user-error "No preprocessor directives %s point"
                (if (> count 0) "after" "before"))))

(defun bhw/evil-previous-preproc-directive (count)
  "Jump to the COUNT-th preprocessor directive before point."
  (interactive "p")
  (bhw/evil-next-preproc-directive (- count)))

(defun bhw/evil-next-comment (count)
  "Jump to the beginning of the COUNT-th comment after point."
  (interactive "p")
  (let ((orig-pt (point)))
    (require 'newcomment)
    (dotimes (_ (abs count))
      (cond ((> count 0)
             (while (and (not (eobp)) (bhw/point-in-comment-p))
               (forward-line 1))
             (unless (comment-search-forward (point-max) 'noerror)
               (goto-char orig-pt)
               (user-error "No comment after point")))
            (t
             (while (and (not (bobp)) (bhw/point-in-comment-p))
               (forward-line -1))
             (unless (comment-search-backward nil 'noerror)
               (goto-char orig-pt)
               (user-error "No comment before point")))))))

(defun bhw/evil-previous-comment (count)
  "Jump to the beginning of the COUNT-th comment before point."
  (interactive "p")
  (bhw/evil-next-comment (- count)))

(defun bhw/evil-insert-newline-below (count)
  "Insert COUNT blank lines below the current line, staying in place."
  (interactive "p")
  (dotimes (_ count)
    (save-excursion (evil-insert-newline-below))))

(defun bhw/evil-insert-newline-above (count)
  "Insert COUNT blank lines above the current line, staying in place."
  (interactive "p")
  (dotimes (_ count)
    (save-excursion (evil-insert-newline-above))))

(defun bhw/evil-next-frame (count)
  "Focus the next frame."
  (interactive "p")
  (dotimes (_ (abs count))
    (let ((frame (if (> count 0) (next-frame) (previous-frame))))
      (if (eq frame (selected-frame))
          (user-error "No other frame")
        (select-frame-set-input-focus frame)))))

(defun bhw/evil-previous-frame (count)
  "Focus the previous frame."
  (interactive "p")
  (bhw/evil-next-frame (- count)))

(defun bhw/evil--next-file (n)
  "Return the file N places after this one in its directory."
  (unless buffer-file-name
    (user-error "Must be called from a file-visiting buffer"))
  (let* ((directory (file-name-directory buffer-file-name))
         (filename (file-name-nondirectory buffer-file-name))
         (files (cl-remove-if-not
                 #'file-regular-p       ; no directories
                 (file-expand-wildcards (file-name-concat directory "[!.]*") t)))
         (index (cl-position filename files
                             :test (lambda (a b)
                                     (file-equal-p (expand-file-name a directory) b)))))
    (when (null index)
      (user-error "Couldn't find this file in current directory"))
    (let ((index (+ index n)))
      (cond ((>= index (length files))
             (user-error "No files after this one"))
            ((< index 0)
             (user-error "No files before this one"))
            ((expand-file-name (nth index files) directory))))))

(defun bhw/evil-next-file (count)
  "Open the file after this one, alphabetically, in the same directory."
  (interactive "p")
  (find-file (bhw/evil--next-file count)))

(defun bhw/evil-previous-file (count)
  "Open the file before this one, alphabetically, in the same directory."
  (interactive "p")
  (find-file (bhw/evil--next-file (- count))))

(defun bhw/evil--encode (beg end fn)
  "Replace the text between BEG and END with FN applied to it."
  (save-excursion
    (goto-char beg)
    (let* ((end (if (eq evil-this-type 'line) (1- end) end))
           (text (buffer-substring-no-properties beg end)))
      (delete-region beg end)
      (insert (funcall fn text)))))

(evil-define-operator bhw/evil-url-encode (beg end)
  "URL-encode the text of the motion."
  (bhw/evil--encode beg end #'url-encode-url))

(evil-define-operator bhw/evil-url-decode (beg end)
  "URL-decode the text of the motion as UTF-8."
  (bhw/evil--encode
   beg end
   (lambda (text) (decode-coding-string (url-unhex-string text t) 'utf-8))))

(evil-define-operator bhw/evil-c-string-encode (beg end)
  "Backslash-escape quotes and backslashes in the text of the motion."
  (bhw/evil--encode
   beg end
   (lambda (text)
     (replace-regexp-in-string "[\"\\]" (lambda (ch) (concat "\\" ch)) text))))

(evil-define-operator bhw/evil-c-string-decode (beg end)
  "Remove the backslash escapes from the text of the motion."
  (bhw/evil--encode
   beg end
   (lambda (text)
     (replace-regexp-in-string "\\\\[\"\\]" (lambda (str) (substring str 1)) text))))

;;---------------------------------------------------------------------------
;; Text objects.
(evil-define-text-object bhw/evil-whole-buffer-txtobj (count &optional _beg _end _type)
  "Select the whole buffer."
  (evil-range (point-min) (point-max) type))

(evil-define-text-object bhw/evil-defun-txtobj (count &optional _beg _end _type)
  "Select the top-level form or function definition at point."
  (cl-destructuring-bind (beg . end)
      (bounds-of-thing-at-point 'defun)
    (evil-range beg end type)))

(evil-define-text-object bhw/evil-inner-url-txtobj (count &optional _beg _end _type)
  "Select the URL at point, without its protocol and query string."
  (cl-destructuring-bind (beg . end)
      (bounds-of-thing-at-point 'url)
    (evil-range
     (save-excursion
       (goto-char beg)
       (re-search-forward "://" end t))
     (save-excursion
       (goto-char end)
       (- (if-let* ((pos (re-search-backward "[?#]" beg t)))
              pos
            end)
          (if (evil-visual-state-p) 1 0)))
     type)))

(evil-define-text-object bhw/evil-outer-url-txtobj (count &optional _beg _end _type)
  "Select the whole URL at point."
  (cl-destructuring-bind (beg . end)
      (bounds-of-thing-at-point 'url)
    (evil-range beg (- end (if (evil-visual-state-p) 1 0)) type)))

(defconst bhw/evil--quote-pairs
  '((?\' . ?\') (?\" . ?\") (?` . ?`) (?‘ . ?’) (?“ . ?”))
  "Quote pairs the any-quote text objects recognise, as (OPEN . CLOSE).")

(defun bhw/evil--quote-range (open close beg end type count inclusive)
  "Return the range of the string between OPEN and CLOSE at or after point.
With INCLUSIVE non-nil the quotes are part of it.  Signals if there is
no such string."
  (save-excursion
    (if (eq open close)
        ;; A count of 2 is how Evil, as Vim, takes the quotes and no
        ;; whitespace with them.
        (evil-select-quote open beg end type (if inclusive 2 1))
      (evil-select-paren open close beg end type count inclusive))))

(defun bhw/evil--any-quote-range (beg end type count inclusive)
  "Return the range of the closest quoted string, whatever its quotes.
Of the strings point is in, the one that holds least; if it is in none,
the one that starts soonest after it."
  (let ((pt (point))
        best rank)
    (pcase-dolist (`(,open . ,close) bhw/evil--quote-pairs)
      (when-let* ((outer (ignore-errors
                           (bhw/evil--quote-range open close beg end type count t)))
                  (from (evil-range-beginning outer))
                  (to (evil-range-end outer))
                  ;; Around point comes before ahead of it, then the
                  ;; smaller or the nearer.
                  (this (cond ((and (<= from pt) (< pt to)) (cons 0 (- to from)))
                              ((> from pt) (cons 1 (- from pt))))))
        (when (or (null rank)
                  (< (car this) (car rank))
                  (and (= (car this) (car rank)) (< (cdr this) (cdr rank))))
          (setq best (cons open close)
                rank this))))
    (unless best
      (user-error "No quoted string found"))
    (bhw/evil--quote-range (car best) (cdr best) beg end type count inclusive)))

(evil-define-text-object bhw/evil-inner-any-quote (count &optional beg end _type)
  "Select inside the closest quotes."
  :extend-selection nil
  (bhw/evil--any-quote-range beg end type count nil))

(evil-define-text-object bhw/evil-outer-any-quote (count &optional beg end _type)
  "Select the closest quotes and what they hold."
  :extend-selection nil
  (bhw/evil--any-quote-range beg end type count t))

;;---------------------------------------------------------------------------
;; Advice.  Each of these changes how a stock Evil command behaves.
(defun bhw/evil--persist-state-a (fn &rest args)
  "Keep Evil's state across a change of major mode."
  (if (bound-and-true-p evil-state)
      (evil-save-state (apply fn args))
    (apply fn args)))
(advice-add #'set-auto-mode :around #'bhw/evil--persist-state-a)

(defun bhw/evil--clean-isearch-overlays-a (&rest _)
  "Remove the isearch overlays an ex search leaves behind."
  (isearch-clean-overlays))
(advice-add #'evil-ex-search :after #'bhw/evil--clean-isearch-overlays-a)

(defun bhw/evil--tutorial-in-emacs-state-a (&rest _)
  "The Emacs tutorial teaches Emacs keys."
  (evil-emacs-state +1))
(advice-add #'help-with-tutorial :after #'bhw/evil--tutorial-in-emacs-state-a)

(defun bhw/evil-escape-a (&rest _)
  "Run `bhw/escape' when ESC is pressed in normal state."
  (when (called-interactively-p 'any)
    (call-interactively #'bhw/escape)))
(advice-add #'evil-force-normal-state :after #'bhw/evil-escape-a)

(defun bhw/evil-disable-ex-highlights-h ()
  "Clear ex search highlights.  For `bhw/escape-hook'."
  (when (or (evil-ex-hl-active-p 'evil-ex-search)
            (bound-and-true-p bhw/modeline--search-here))
    (evil-ex-nohighlight)
    t))
(add-hook 'bhw/escape-hook #'bhw/evil-disable-ex-highlights-h)

(defun bhw/evil-display-vimlike-save-message-h ()
  "Report a save the way Vim does: name, lines, characters."
  (message "\"%s\" %dL, %dC written"
           (if buffer-file-name
               (file-relative-name (file-truename buffer-file-name)
                                   (bhw/project-root))
             (buffer-name))
           (count-lines (point-min) (point-max))
           (buffer-size)))
(add-hook 'after-save-hook #'bhw/evil-display-vimlike-save-message-h)

(defun bhw/evil--dont-move-cursor-a (fn &rest args)
  "Leave point where it was after `evil-indent'."
  (save-excursion (apply fn args)))
(advice-add #'evil-indent :around #'bhw/evil--dont-move-cursor-a)

(defun bhw/evil--make-numbered-markers-global-a (char)
  "Treat the markers 2 to 9 as global."
  (and (>= char ?2) (<= char ?9)))
(advice-add #'evil-global-marker-p :after-until
            #'bhw/evil--make-numbered-markers-global-a)

(defun bhw/evil-join-a (fn beg end)
  "Join lines, dropping comment delimiters between joined comment lines.
Adapted from https://github.com/emacs-evil/evil/issues/606."
  (if-let* (((not (= (line-end-position) (point-max))))
            (cend (save-excursion (goto-char end) (line-end-position)))
            (cbeg (save-excursion
                    (goto-char beg)
                    (and (bhw/point-in-comment-p
                          (save-excursion
                            (goto-char (line-beginning-position 2))
                            (skip-syntax-forward " \t")
                            (point)))
                         (or (comment-search-backward (line-beginning-position) t)
                             (comment-search-forward  (line-end-position) t)
                             (and (bhw/point-in-comment-p beg)
                                  (stringp comment-continue)
                                  (or (search-forward comment-continue
                                                      (line-end-position) t)
                                      beg)))))))
      (let* ((count (count-lines beg end))
             (count (if (> count 1) (1- count) count)))
        (uncomment-region (line-beginning-position 2)
                          (save-excursion
                            (goto-char cend)
                            (line-end-position 0)))
        (dotimes (_ count)
          (join-line 1)
          (save-match-data
            (when (or (and comment-continue
                           (not (string-empty-p comment-continue))
                           (looking-at (concat "\\(\\s-*"
                                               (regexp-quote comment-continue)
                                               "\\) ")))
                      (and comment-start-skip
                           (not (string-empty-p comment-start-skip))
                           (looking-at (concat "\\(\\s-*" comment-start-skip "\\)"))))
              (replace-match "" t nil nil 1)
              (just-one-space)))))
    ;; Outside a comment the stock behaviour is right.
    (funcall fn beg end)))
(advice-add #'evil-join :around #'bhw/evil-join-a)

(defun bhw/evil--no-squeeze-on-fill-a (fn &rest args)
  "Keep `evil-fill' from collapsing runs of whitespace."
  (let ((fill (symbol-function 'fill-region)))
    (cl-letf (((symbol-function 'fill-region)
               (lambda (from to &optional justify _nosqueeze to-eop)
                 (funcall fill from to justify t to-eop))))
      (apply fn args))))
(advice-add #'evil-fill :around #'bhw/evil--no-squeeze-on-fill-a)
(advice-add #'evil-fill-and-move :around #'bhw/evil--no-squeeze-on-fill-a)

;; One set of registers: Emacs' register commands see Evil's.
(defvar bhw/evil--use-evil-registers t)

(defun bhw/evil--use-evil-registers-a (fn register)
  "Let `get-register' read Evil's registers while Evil is on."
  (if (and (characterp register)
           bhw/evil--use-evil-registers
           (or (bound-and-true-p evil-mode)
               (bound-and-true-p evil-local-mode)))
      (if (char-equal register ?=)      ; last expression register input
          evil-last-=-register-input
        (let (bhw/evil--use-evil-registers)
          (evil-get-register register t)))
    (funcall fn register)))
(advice-add #'get-register :around #'bhw/evil--use-evil-registers-a)

(defun bhw/evil--propagate-registers-a (fn &rest args)
  "Show Evil's registers to Emacs' register commands while Evil is on."
  (let ((register-alist
         (if (and bhw/evil--use-evil-registers
                  (or (bound-and-true-p evil-mode)
                      (bound-and-true-p evil-local-mode)))
             (evil-register-list)
           register-alist)))
    (apply fn args)))
(dolist (fn '(register-swap-out register-buffer-to-file-query
              register-read-with-preview-fancy list-registers))
  (advice-add fn :around #'bhw/evil--propagate-registers-a))

(defun bhw/evil-replace-filename-modifiers-a (file-name)
  "Resolve Vim's filename modifiers in FILE-NAME.
Supports most of them (%, #, :p :h :t :r :e :S :~ :. :s :gs), and %:P
for the project root.  See
http://vimdoc.sourceforge.net/htmldoc/cmdline.html#filename-modifiers."
  (let ((origin-buffer (current-buffer))
        case-fold-search)
    (with-temp-buffer
      (let ((buffer-file-name (buffer-file-name origin-buffer)))
        (save-excursion (insert file-name))
        (while (re-search-forward "\\(^\\|[^\\\\]\\)\\(\\([%#]\\)\\(:\\([PphtreS~.]\\|g?s\\)\\)*\\)" nil t)
          (if (null buffer-file-name)
              (replace-match (match-string 1) t t nil 2)
            (let ((beg (match-beginning 2))
                  (path (pcase (match-string 3)
                          ("%" (file-relative-name buffer-file-name default-directory))
                          ("#" (and (other-buffer origin-buffer)
                                    (buffer-file-name (other-buffer origin-buffer)))))))
              (save-match-data
                (goto-char beg)
                (while (re-search-forward ":\\([PphtreS~.]\\|g?s\\)" (+ (point) 3) t)
                  (let* ((modifier (match-string 1))
                         (global (string-prefix-p "gs" modifier)))
                    (when global
                      (setq modifier (substring modifier 1)))
                    (setq path
                          (pcase (and path (substring modifier 0 1))
                            ('nil "")
                            ("p" (expand-file-name path))
                            ("~" (concat "~/" (file-relative-name path "~")))
                            ("." (file-relative-name path))
                            ("t" (file-name-nondirectory (directory-file-name path)))
                            ("r" (file-name-sans-extension path))
                            ("e" (file-name-extension path))
                            ("S" (shell-quote-argument path))
                            ("h"
                             (let ((parent (file-name-directory (expand-file-name path))))
                               (unless (file-equal-p path parent)
                                 (if (file-name-absolute-p path)
                                     (directory-file-name parent)
                                   (file-relative-name parent)))))
                            ("s"
                             (when-let* ((args (evil-delimited-arguments
                                                (substring modifier 1) 2)))
                               (let ((pattern (evil-transform-vim-style-regexp (car args)))
                                     (replace (cadr args)))
                                 (replace-regexp-in-string
                                  (if global pattern (concat "\\(" pattern "\\).*\\'"))
                                  (evil-transform-vim-style-regexp replace) path t t
                                  (unless global 1)))))
                            ("P"
                             (let ((root (bhw/project-root
                                          (file-name-directory (expand-file-name path)))))
                               (unless root
                                 (user-error "Not in a project"))
                               (abbreviate-file-name root)))))
                    ;; Strip a trailing slash.
                    (or (string-empty-p path)
                        (not (equal (substring path -1) "/"))
                        (setq path (substring path 0 -1))))))
              (replace-match path t t nil 2))))
        (replace-regexp-in-string "\\\\\\([#%]\\)" "\\1" (buffer-string) t)))))
(advice-add #'evil-ex-replace-special-filenames :override
            #'bhw/evil-replace-filename-modifiers-a)

(defun bhw/evil--fix-dabbrev-in-minibuffer-h ()
  "Make dabbrev expansion work in the minibuffer by redefining / there."
  (set-syntax-table (let ((table (make-syntax-table)))
                      (modify-syntax-entry ?/ "." table)
                      table)))
(add-hook 'minibuffer-inactive-mode-hook #'bhw/evil--fix-dabbrev-in-minibuffer-h)

;; Splitting.  The ping-pong between the two windows updates the window
;; history, so closing either split afterwards returns to the other rather
;; than to some unrelated window.
(evil-define-command bhw/evil-window-split-a (&optional count file)
  "`evil-window-split' that keeps the window history right."
  :repeat nil
  (interactive "P<f>")
  (let ((origwin (selected-window))
        window-selection-change-functions)
    (select-window (split-window origwin count 'below))
    (unless evil-split-window-below
      (select-window origwin)))
  (run-hook-with-args 'window-selection-change-functions nil)
  (recenter)
  (when (and (not count) evil-auto-balance-windows)
    (balance-windows (window-parent)))
  (when file (evil-edit file)))
(advice-add #'evil-window-split :override #'bhw/evil-window-split-a)

(evil-define-command bhw/evil-window-vsplit-a (&optional count file)
  "`evil-window-vsplit' that keeps the window history right."
  :repeat nil
  (interactive "P<f>")
  (let ((origwin (selected-window))
        window-selection-change-functions)
    (select-window (split-window origwin count 'right))
    (unless evil-vsplit-window-right
      (select-window origwin)))
  (run-hook-with-args 'window-selection-change-functions nil)
  (recenter)
  (when (and (not count) evil-auto-balance-windows)
    (balance-windows (window-parent)))
  (when file (evil-edit file)))
(advice-add #'evil-window-vsplit :override #'bhw/evil-window-vsplit-a)

;; o and O continue a comment.
(defun bhw/evil--insert-newline (&optional above)
  "Insert a line below, or ABOVE, continuing a comment if point is in one."
  (let ((pos (save-excursion (beginning-of-line-text) (point)))
        comment-auto-fill-only-comments)
    (evil-narrow-to-field
      (if above
          (if (save-excursion (nth 4 (syntax-ppss pos)))
              (evil-save-goal-column
                (setq evil-auto-indent nil)
                (goto-char pos)
                (let ((ws (abs (skip-chars-backward " \t"))))
                  (save-excursion
                    (if comment-line-break-function
                        (funcall comment-line-break-function nil)
                      (comment-indent-new-line))
                    (when (and (derived-mode-p 'c-mode 'c++-mode 'objc-mode
                                               'java-mode 'js2-mode)
                               (eq (char-after) ?/))
                      (insert "*"))
                    (insert
                     (make-string (max 0 (+ ws (skip-chars-backward " \t")))
                                  32)))
                  (insert (make-string (max 1 ws) 32))))
            (evil-move-beginning-of-line)
            (insert (if use-hard-newlines hard-newline "\n"))
            (forward-line -1)
            (back-to-indentation))
        (evil-move-end-of-line)
        (cond ((bhw/point-in-comment-p pos)
               (setq evil-auto-indent nil)
               (if comment-line-break-function
                   (funcall comment-line-break-function nil)
                 (comment-indent-new-line)))
              (t
               (insert (if use-hard-newlines hard-newline "\n"))
               (back-to-indentation)))))))

(defun bhw/evil--insert-newline-below-and-respect-comments-a (fn count)
  "Make `evil-open-below' continue a comment."
  (if (or (not bhw/evil-want-o/O-to-continue-comments)
          (not (eq this-command 'evil-open-below))
          (evil-insert-state-p)
          (evil-emacs-state-p))
      (funcall fn count)
    (cl-letf (((symbol-function 'evil-insert-newline-below)
               (lambda () (bhw/evil--insert-newline))))
      (let ((evil-auto-indent evil-auto-indent))
        (funcall fn count)))))
(advice-add #'evil-open-below :around
            #'bhw/evil--insert-newline-below-and-respect-comments-a)

(defun bhw/evil--insert-newline-above-and-respect-comments-a (fn count)
  "Make `evil-open-above' continue a comment."
  (if (or (not bhw/evil-want-o/O-to-continue-comments)
          (not (eq this-command 'evil-open-above))
          (evil-insert-state-p)
          (evil-emacs-state-p))
      (funcall fn count)
    (cl-letf (((symbol-function 'evil-insert-newline-above)
               (lambda () (bhw/evil--insert-newline 'above))))
      (let ((evil-auto-indent evil-auto-indent))
        (funcall fn count)))))
(advice-add #'evil-open-above :around
            #'bhw/evil--insert-newline-above-and-respect-comments-a)

(defun bhw/evil--visual-paste-over-whole-lines-a (fn &rest args)
  "Have `evil-visual-paste' put lines over lines and leave no empty line.
Two faults of Evil's, both there as of 2026-07 (6a3e1dd).

Under `visual-line-mode' V selects by the screen line, and Evil pastes
over such a selection as over one made by the character: lines put in
get an empty line above them, and a word put in is joined to the line
below.  Here a selection that begins with a line and ends with one is
pasted over as lines.  A row out of the middle of a wrapped line is
left to Evil, and so is a last line that has no newline.

And when the lines pasted over were the last of the buffer and took
its last newline with them, point is left below the last line, where
Evil pastes after it: an empty line again, and no newline at the end.
Pasted before point, the lines go where the others were."
  (cl-letf* ((paste-after (symbol-function 'evil-paste-after))
             ((symbol-function 'evil-paste-after)
              (lambda (&rest args)
                (apply (if (and (bolp) (eobp)) #'evil-paste-before paste-after)
                       args))))
    (if (and (evil-visual-state-p)
             (eq (evil-visual-type) 'screen-line)
             (save-excursion (goto-char evil-visual-beginning) (bolp))
             (save-excursion (goto-char evil-visual-end) (bolp)))
        ;; What `evil-visual-type' answers with, when there is one.
        (let ((evil-this-type 'line))
          (apply fn args))
      (apply fn args))))
(advice-add #'evil-visual-paste :around
            #'bhw/evil--visual-paste-over-whole-lines-a)

;;---------------------------------------------------------------------------
;; Indentation of what is yanked and pasted.
(defun bhw/evil--reindent (text column &optional tail)
  "Return TEXT with the indentation its lines share replaced by COLUMN.
Blank lines do not count.  With TAIL non-nil the first line only loses
what is shared: it is going in where point is.  Nothing but leading
whitespace changes, and that is made of tabs or of spaces as the current
buffer makes it."
  (let ((tabs indent-tabs-mode)
        (width tab-width)
        shared)
    (with-temp-buffer
      (setq indent-tabs-mode tabs
            tab-width width)
      (let ((inhibit-read-only t))
        (insert text)
        (goto-char (point-min))
        (while (not (eobp))
          (unless (looking-at-p "[ \t]*$")
            (setq shared (min (or shared (current-indentation))
                              (current-indentation))))
          (forward-line 1))
        (when shared
          (let ((rest (progn (goto-char (point-min))
                             (forward-line (if tail 1 0))
                             (point))))
            (unless (= column shared)
              (indent-rigidly rest (point-max) (- column shared)))
            (unless (or (not tail) (zerop shared))
              (indent-rigidly (point-min) rest (- shared))))))
      (buffer-string))))

(defun bhw/evil-yank-lines-unindented-a (fn beg end &optional type register yank-handler)
  "Have `y' leave out the indentation that the lines it yanks share.
Whole lines only, and only `y' itself: what `d', `c' and `Y' put by is
as it stood, and so is what is yanked by the character or as a block.
Around advice for `evil-yank'."
  (if (not (and (memq type '(line screen-line))
                (eq this-command 'evil-yank)))
      (funcall fn beg end type register yank-handler)
    (let ((text (bhw/evil--reindent (filter-buffer-substring beg end) 0)))
      (with-temp-buffer
        (insert text)
        (funcall fn (point-min) (point-max) type register yank-handler)))))
(advice-add 'evil-yank :around #'bhw/evil-yank-lines-unindented-a)

(defvar bhw/evil--foreign-kills (make-hash-table :test #'eq :weakness 'key)
  "The kills that came from another program, as keys.")

(defvar bhw/evil--paste-indentation nil
  "The indentation pasted lines are to take, or nil for the current line's.
Bound by `bhw/evil-visual-paste-indented-a'.")

(defun bhw/evil--paste-text (register)
  "Return what a paste from REGISTER, or from the kill ring, puts in.
A kill that another program has just put on the clipboard is noted in
`bhw/evil--foreign-kills'."
  (if register
      (evil-get-register register)
    (let* ((head (car kill-ring))
           (text (current-kill 0)))
      (unless (eq head (car kill-ring))
        (puthash text t bhw/evil--foreign-kills))
      text)))

(defun bhw/evil-paste-indented-a (fn count &optional register yank-handler)
  "Have what `p' and `P' put in take the indentation of the current line.
Lines that were yanked or deleted as lines lose the indentation they
share and take the line's, as Vim's ]p has it.  Text of several lines
from another program does the same from its second line on; its first
goes in at point.  What Evil took by the character or as a block is put
back as it was.  The kill itself is never changed.
Around advice for `evil-paste-after' and `evil-paste-before'."
  (if (or (evil-visual-state-p) (minibufferp))
      (funcall fn count register yank-handler)
    (let* ((text (bhw/evil--paste-text register))
           (handler (and (stringp text)
                         (get-text-property 0 'yank-handler text)))
           (text (cond ((not (stringp text)) text)
                       ((eq (or yank-handler (car-safe handler))
                            #'evil-yank-line-handler)
                        (let ((lines (bhw/evil--reindent
                                      text (or bhw/evil--paste-indentation
                                               (current-indentation)))))
                          ;; Indentation put in at the very start has none.
                          (put-text-property 0 (length lines)
                                             'yank-handler handler lines)
                          lines))
                       ((and (gethash text bhw/evil--foreign-kills)
                             (string-search "\n" text))
                        (bhw/evil--reindent text (current-indentation) t))
                       (t text)))
           ;; The text is handed over as `evil-paste-pop' hands a kill
           ;; over, and no register is asked twice: the = register
           ;; evaluates what is typed at it.
           (kill-ring (list text))
           (kill-ring-yank-pointer kill-ring)
           (interprogram-paste-function nil))
      (prog1 (funcall fn count nil yank-handler)
        ;; There is no `evil-paste-pop' after a paste from a register.
        (when register
          (setq evil-last-paste nil))))))
(advice-add 'evil-paste-after :around #'bhw/evil-paste-indented-a)
(advice-add 'evil-paste-before :around #'bhw/evil-paste-indented-a)

(defun bhw/evil-visual-paste-indented-a (fn count &optional register)
  "Have lines that replace a selection take its first line's indentation.
By the time they go in the selection is gone, and the current line is
another.  Around advice for `evil-visual-paste'."
  (if (not (evil-visual-state-p))
      (funcall fn count register)
    ;; Evil fetches the kill before `bhw/evil-paste-indented-a' could see
    ;; that it is new.
    (unless register
      (bhw/evil--paste-text nil))
    (let ((bhw/evil--paste-indentation
           (save-excursion (goto-char evil-visual-beginning)
                           (current-indentation))))
      (funcall fn count register))))
(advice-add 'evil-visual-paste :around #'bhw/evil-visual-paste-indented-a)

;;---------------------------------------------------------------------------
;; Ex commands.
(defvar bhw/evil--flag nil)

(defun bhw/evil--ex-match-init (name &optional face update-hook)
  "Create or delete the highlight NAME, per `bhw/evil--flag'."
  (with-current-buffer evil-ex-original-buffer
    (cond
     ((eq bhw/evil--flag 'start)
      (evil-ex-make-hl name
        :face (or face 'evil-ex-lazy-highlight)
        :update-hook (or update-hook #'evil-ex-pattern-update-ex-info))
      (setq bhw/evil--flag 'update))
     ((eq bhw/evil--flag 'stop)
      (evil-ex-delete-hl name)))))

(defun bhw/evil--ex-buffer-match (arg &optional hl-name flags beg end)
  "Highlight matches of the pattern ARG while it is being typed."
  (when (and (eq bhw/evil--flag 'update)
             evil-ex-substitute-highlight-all
             (not (zerop (length arg))))
    (condition-case lossage
        (let* ((pattern (evil-ex-make-substitute-pattern arg (or flags (list))))
               (range (or (evil-copy-range evil-ex-range)
                          (evil-range (or beg (line-beginning-position))
                                      (or end (line-end-position))
                                      'line
                                      :expanded t))))
          (evil-expand-range range)
          (evil-ex-hl-set-region hl-name
                                 (max (evil-range-beginning range) (window-start))
                                 (min (evil-range-end range) (window-end)))
          (evil-ex-hl-change hl-name pattern))
      (end-of-file
       (evil-ex-pattern-update-ex-info nil "incomplete replacement"))
      (user-error
       (evil-ex-pattern-update-ex-info nil (format "?%s" lossage))))))

(defun bhw/evil-ex-regexp-match (flag &optional arg invert)
  "Ex argument handler that previews a regexp's matches."
  (let ((hl-name 'evil-ex-buffer-match)
        (bhw/evil--flag flag))
    (with-selected-window (minibuffer-selected-window)
      (bhw/evil--ex-match-init hl-name)
      (cl-destructuring-bind (&optional arg flags)
          (evil-delimited-arguments arg 2)
        (let ((evil-ex-substitute-global
               (if invert
                   (not evil-ex-substitute-global)
                 evil-ex-substitute-global)))
          (bhw/evil--ex-buffer-match arg hl-name (string-to-list flags)))))))

(evil-define-command bhw/evil-align (beg end pattern &optional flags)
  "Ex interface to `align-regexp'.
PATTERN is a vim-style regexp.  The flag g repeats the alignment on
every match in a line."
  (interactive "<r></>")
  (align-regexp
   beg end
   (concat "\\(\\s-*\\)" (evil-transform-vim-style-regexp pattern))
   1 1 (memq ?g flags)))

(evil-define-command bhw/evil-align-right (beg end pattern &optional flags)
  "Ex interface to `align-regexp' that right-aligns the matches.
PATTERN is a vim-style regexp.  The flag g repeats the alignment on
every match in a line."
  (interactive "<r></>")
  (align-regexp
   beg end
   (concat "\\(" (evil-transform-vim-style-regexp pattern) "\\)")
   -1 1 (memq ?g flags)))

(evil-define-command bhw/evil-pwd (bang)
  "Show the working directory.  With BANG, copy it to the clipboard."
  (interactive "<!>")
  (if (not bang)
      (pwd)
    (kill-new default-directory)
    (message "Copied to clipboard")))

(evil-define-command bhw/evil-compile (arguments &optional bang)
  "Run `compile-command' with ARGUMENTS.
With BANG, show the output in a comint buffer.  Understands Vim's file
modifiers, such as %:p:h."
  (interactive "<sh><!>")
  (compile (evil-ex-replace-special-filenames
            (format "%s %s" (eval compile-command) arguments))
           bang))

(evil-define-command bhw/evil-make (arguments &optional bang)
  "Run make with ARGUMENTS.
With BANG, show the output in a comint buffer.  Understands Vim's file
modifiers, such as %:p:h."
  (interactive "<sh><!>")
  (let ((compile-command "make"))
    (bhw/evil-compile (if (stringp arguments)
                          (evil-ex-replace-special-filenames arguments)
                        "")
                      bang)))

(evil-define-command bhw/evil-reverse-lines (beg end)
  "Reverse the lines between BEG and END."
  (interactive "<r>")
  (reverse-region beg end))

(evil-define-command bhw/evil-cd (&optional path)
  "Change `default-directory' to PATH, default the home directory."
  (interactive "<f>")
  (let ((path (or path "~")))
    (cd path)
    (message "Changed directory to '%s'"
             (abbreviate-file-name (expand-file-name path)))))

(evil-ex-define-argument-type ex
  "Handle an ex command."
  :collection
  (lambda (string pred action)
    (let (evil-ex-complete-emacs-commands)
      (complete-with-action action (evil-ex-completion-table) string pred))))

(evil-define-interactive-code "<ex>"
  "Ex command argument."
  :ex-arg ex
  (list (when evil-called-from-ex-p evil-ex-argument)))

(evil-define-command bhw/evil-help (&optional query)
  "Look up the documentation for QUERY.
If QUERY is an ex command, describe the function behind it.  Otherwise
run an apropos search for it.  With no QUERY, prompt for an ex command."
  (interactive "<ex>")
  (when (or (null query)
            (string-empty-p (string-trim query)))
    (setq query
          (completing-read
           "Select evil ex command: "
           (cl-remove-duplicates evil-ex-commands :key #'cdr :from-end t)
           nil t)))
  (save-match-data
    (if-let* ((ex (evil-ex-completed-binding query t)))
        (funcall (if (fboundp 'helpful-function)
                     #'helpful-function
                   #'describe-function)
                 ex)
      (cond ((or (string-match "^ *[^a-z0-9-_]$" query)
                 (condition-case nil
                     (ignore (string-match-p query ""))
                   (invalid-regexp t)))
             (user-error "Invalid query: %S" query))
            ((< (string-width query) 3)
             (user-error "Query too short (must be > 2 characters): %S" query))
            ((message "Searching for %S, this may take a while..." query)
             (apropos query t))))))

(evil-ex-define-cmd "al[ign]"   #'bhw/evil-align)
(evil-ex-define-cmd "ral[ign]"  #'bhw/evil-align-right)
(evil-ex-define-cmd "na[rrow]"  #'bhw/evil-narrow-buffer)
(evil-ex-define-cmd "rev[erse]" #'bhw/evil-reverse-lines)
(evil-ex-define-cmd "h[elp]"    #'bhw/evil-help)
(evil-ex-define-cmd "kill"      #'kill-current-buffer)
(evil-ex-define-cmd "msg"       #'view-echo-area-messages)
(evil-ex-define-cmd "a"         #'find-sibling-file)
(evil-ex-define-cmd "cd"        #'bhw/evil-cd)
(evil-ex-define-cmd "pwd"       #'bhw/evil-pwd)
(evil-ex-define-cmd "com[pile]" #'bhw/evil-compile)
(evil-ex-define-cmd "make"      #'bhw/evil-make)
(evil-ex-define-cmd "mk"        #'bhw/evil-make)
(evil-ex-define-cmd "cap[ture]" #'org-capture)

;;---------------------------------------------------------------------------
;; evil-collection: Evil keys for the rest of Emacs.
(defvar bhw/evil-collection-disabled-list
  '(;; evil-collection binds sb/sm/sr under `s' in pdf-view; this
    ;; configuration puts avy on `s' there and binds the mode itself.
    pdf
    ;; Bound here instead, or not worth their keys.
    anaconda-mode company eglot elisp-mode ert lispy)
  "Modules of `evil-collection-mode-list' that are not set up.")

(setq evil-collection-setup-minibuffer nil
      evil-collection-want-unimpaired-p nil
      evil-collection-outline-enable-in-minor-mode-p nil)

(require 'evil-collection)

(dolist (sym bhw/evil-collection-disabled-list)
  (if-let* ((elt (assq sym evil-collection-mode-list)))
      (setq evil-collection-mode-list (delete elt evil-collection-mode-list))
    (setq evil-collection-mode-list (delq sym evil-collection-mode-list))))

(setq evil-collection-binding-overrides
      '((repl-submit :enabled nil)
        (repl-newline :enabled nil)
        (pop-definition :enabled nil)
        (find-file :enabled nil)
        (find-definition :enabled nil)
        (find-usages :enabled nil)
        (lookup-doc :enabled nil)
        (goto-repl :enabled nil))
      ;; Never let a mode take the leader keys.
      evil-collection-key-blacklist
      (delete-dups (append '("SPC" "," "M-m" "M-SPC")
                           evil-collection-key-blacklist
                           '("gz" "<escape>"))))

(evil-mode 1)

(defvar bhw/evil-collection-initialised nil
  "Non-nil once `evil-collection-init' has run.")
;; Once, and not again on a reload: for every keymap that is not loaded yet
;; each run leaves one more function on `after-load-functions'.
(unless bhw/evil-collection-initialised
  (evil-collection-init)
  (setq bhw/evil-collection-initialised t))

;;---------------------------------------------------------------------------
;; Surround, with embrace for the pairs surround does not know.
(global-evil-surround-mode 1)

;;---------------------------------------------------------------------------
;; The smaller ones.
;; evil-nerd-commenter defines these three without autoload cookies.
(dolist (entry '((evilnc-comment-operator . "evil-nerd-commenter-operator")
                 (evilnc-inner-comment . "evil-nerd-commenter-operator")
                 (evilnc-outer-commenter . "evil-nerd-commenter-operator")))
  (autoload (car entry) (cdr entry) nil t))
;; Evil puts this one on C-w f, and ffap has no autoload cookie on it.
(autoload 'ffap-other-window "ffap" nil t)

;; evil-traces previews ex commands as they are typed.  Nothing needs it
;; until the first `:', so it loads then.
(defun bhw/evil--init-traces-a (&rest _)
  "Turn on `evil-traces-mode' the first time the ex line opens."
  (advice-remove 'evil-ex #'bhw/evil--init-traces-a)
  (require 'evil-traces)
  (dolist (argtype '((bhw/evil-align . evil-traces-global)
                     (bhw/evil-align-right . evil-traces-global)))
    (add-to-list 'evil-traces-argument-type-alist argtype))
  (evil-traces-mode 1))
(advice-add 'evil-ex :before #'bhw/evil--init-traces-a)

;;---------------------------------------------------------------------------
;; Keys.  State by state, as Doom bound them.
(evil-define-key* '(insert replace visual operator) 'global
  (kbd "C-g") #'bhw/evil-escape)

(evil-define-key* 'normal 'global
  (kbd "] SPC") #'bhw/evil-insert-newline-below
  (kbd "[ SPC") #'bhw/evil-insert-newline-above
  "]o"  #'bhw/evil-insert-newline-below
  "[o"  #'bhw/evil-insert-newline-above
  "]b"  #'next-buffer
  "[b"  #'previous-buffer
  "]f"  #'bhw/evil-next-file
  "[f"  #'bhw/evil-previous-file
  "]F"  #'bhw/evil-next-frame
  "[F"  #'bhw/evil-previous-frame
  "gp"  #'bhw/evil-reselect-paste
  "g="  #'evil-numbers/inc-at-pt
  "g-"  #'evil-numbers/dec-at-pt
  "gl"  #'evil-lion-left
  "gL"  #'evil-lion-right
  "zx"  #'kill-current-buffer)

(evil-define-key* 'motion 'global
  [C-i] #'evil-jump-forward
  "[u"  #'bhw/evil-url-encode
  "]u"  #'bhw/evil-url-decode
  "[y"  #'bhw/evil-c-string-encode
  "]y"  #'bhw/evil-c-string-decode
  "]#"  #'bhw/evil-next-preproc-directive
  "[#"  #'bhw/evil-previous-preproc-directive
  "]c"  #'bhw/evil-next-comment
  "[c"  #'bhw/evil-previous-comment
  "]e"  #'next-error
  "[e"  #'previous-error
  "]h"  #'outline-next-visible-heading
  "[h"  #'outline-previous-visible-heading
  "]m"  #'bhw/evil-next-beginning-of-method
  "[m"  #'bhw/evil-previous-beginning-of-method
  "]M"  #'bhw/evil-next-end-of-method
  "[M"  #'bhw/evil-previous-end-of-method)

(evil-define-key* 'visual 'global
  "@"   #'bhw/evil-apply-macro
  "gp"  #'bhw/evil-alt-paste
  "g="  #'evil-numbers/inc-at-pt-incremental
  "g-"  #'evil-numbers/dec-at-pt-incremental
  "g+"  #'evil-numbers/inc-at-pt
  "gl"  #'evil-lion-left
  "gL"  #'evil-lion-right
  "<"   #'bhw/evil-shift-left
  ">"   #'bhw/evil-shift-right
  (kbd "M-j") #'bhw/evil-move-lines-down
  (kbd "M-k") #'bhw/evil-move-lines-up
  "S"   #'evil-surround-region)

(evil-define-key* '(normal visual) 'global
  "g@"  #'bhw/evil-apply-macro
  "gc"  #'evilnc-comment-operator
  "gO"  #'imenu
  "gy"  #'bhw/evil-yank-unindented
  "zn"  #'bhw/evil-narrow-buffer)

(evil-define-key* 'operator 'global
  "s"   #'evil-surround-edit
  "S"   #'evil-Surround-edit)

(global-set-key [remap comment-line] #'evilnc-comment-or-uncomment-lines)

;; Windows, under C-w and later under SPC w.
(dolist (binding
         `(("C-h" . evil-window-left)
           ("C-j" . evil-window-down)
           ("C-k" . evil-window-up)
           ("C-l" . evil-window-right)
           ("C-w" . other-window)
           ("S"   . bhw/evil-window-split-and-follow)
           ("V"   . bhw/evil-window-vsplit-and-follow)
           ("H"   . bhw/evil-window-move-left)
           ("J"   . bhw/evil-window-move-down)
           ("K"   . bhw/evil-window-move-up)
           ("L"   . bhw/evil-window-move-right)
           ("u"   . winner-undo)
           ("C-u" . winner-undo)
           ("C-r" . winner-redo)
           ("d"   . evil-window-delete)
           ("T"   . tear-off-window)))
  (define-key evil-window-map (kbd (car binding)) (cdr binding)))

;; Text objects: inner and outer.
(pcase-dolist (`(,key ,inner ,outer)
               '(("c" evilnc-inner-comment evilnc-outer-commenter)
                 ("f" bhw/evil-defun-txtobj bhw/evil-defun-txtobj)
                 ("g" bhw/evil-whole-buffer-txtobj bhw/evil-whole-buffer-txtobj)
                 ("i" evil-indent-plus-i-indent evil-indent-plus-a-indent)
                 ("j" evil-indent-plus-i-indent-up-down evil-indent-plus-a-indent-up-down)
                 ("k" evil-indent-plus-i-indent-up evil-indent-plus-a-indent-up)
                 ("q" bhw/evil-inner-any-quote bhw/evil-outer-any-quote)
                 ("u" bhw/evil-inner-url-txtobj bhw/evil-outer-url-txtobj)))
  (define-key evil-inner-text-objects-map key inner)
  (define-key evil-outer-text-objects-map key outer))

;; Vim's omni-completion keys, on cape.
(evil-define-key* 'insert 'global
  (kbd "C-x C-l") #'cape-line
  (kbd "C-x C-k") #'cape-keyword
  (kbd "C-x C-f") #'cape-file
  (kbd "C-x C-]") #'complete-tag
  (kbd "C-x s")   #'cape-dict
  (kbd "C-x C-s") #'tempel-complete
  (kbd "C-x C-o") #'completion-at-point
  (kbd "C-x C-n") #'cape-dabbrev)

(provide 'bhw-evil)
;;; bhw-evil.el ends here

;;---------------------------------------------------------------------------
;; Files.
(defun bhw/files--update-refs (&rest files)
  "Tell vc, magit, recentf and save-place that FILES changed on disk."
  (let (toplevels)
    (dolist (file files)
      (when (featurep 'vc)
        (vc-file-clearprops file)
        (when-let* ((buffer (get-file-buffer file)))
          (with-current-buffer buffer
            (vc-refresh-state))))
      (when (featurep 'magit)
        (when-let* ((default-directory
                     (magit-toplevel (file-name-directory file))))
          (cl-pushnew default-directory toplevels :test #'equal)))
      (unless (file-readable-p file)
        (when (bound-and-true-p recentf-mode)
          (recentf-remove-if-non-kept file))))
    (dolist (default-directory toplevels)
      (magit-refresh))
    (when (bound-and-true-p save-place-mode)
      (save-place-forget-unreadable-files))))

(defun bhw/delete-this-file (&optional path force-p)
  "Delete PATH and kill its buffers.
PATH defaults to the file this buffer visits.  With FORCE-P, the prefix
argument, delete without asking."
  (interactive
   (list (buffer-file-name (buffer-base-buffer))
         current-prefix-arg))
  (let* ((path (or path (buffer-file-name (buffer-base-buffer))))
         (short-path (and path (abbreviate-file-name path))))
    (unless path
      (user-error "Buffer is not visiting any file"))
    (unless (file-exists-p path)
      (error "File doesn't exist: %s" path))
    (unless (or force-p (y-or-n-p (format "Really delete %S?" short-path)))
      (user-error "Aborted"))
    (let ((buf (current-buffer)))
      (unwind-protect
          (progn (delete-file path t) t)
        (if (file-exists-p path)
            (error "Failed to delete %S" short-path)
          ;; Windows that showed the file move on to a real buffer.
          (bhw/kill-this-buffer-in-all-windows buf t)
          (bhw/files--update-refs path)
          (message "Deleted %S" short-path))))))

(defun bhw/copy-this-file (new-path &optional force-p)
  "Copy this buffer's file to NEW-PATH, then visit NEW-PATH.
With FORCE-P, the prefix argument, overwrite an existing file without
asking."
  (interactive
   (list (read-file-name "Copy file to: ")
         current-prefix-arg))
  (unless (and buffer-file-name (file-exists-p buffer-file-name))
    (user-error "Buffer is not visiting any file"))
  (let ((old-path (buffer-file-name (buffer-base-buffer)))
        (new-path (expand-file-name new-path)))
    (make-directory (file-name-directory new-path) t)
    (copy-file old-path new-path (or force-p 1))
    (find-file new-path)
    (bhw/files--update-refs old-path new-path)
    (message "File copied to %S" (abbreviate-file-name new-path))))

(defun bhw/move-this-file (new-path &optional force-p)
  "Move this buffer's file to NEW-PATH.
With FORCE-P, the prefix argument, overwrite an existing file without
asking."
  (interactive
   (list (read-file-name "Move file to: ")
         current-prefix-arg))
  (unless (and buffer-file-name (file-exists-p buffer-file-name))
    (user-error "Buffer is not visiting any file"))
  (let ((old-path (buffer-file-name (buffer-base-buffer)))
        (new-path (expand-file-name new-path)))
    (when (directory-name-p new-path)
      (setq new-path (concat new-path (file-name-nondirectory old-path))))
    (make-directory (file-name-directory new-path) t)
    (rename-file old-path new-path (or force-p 1))
    (set-visited-file-name new-path t t)
    (bhw/files--update-refs old-path new-path)
    (message "File moved to %S" (abbreviate-file-name new-path))))

(defun bhw/files--sudo-path (file)
  "Return the Tramp path that opens FILE as root."
  (let ((host (or (file-remote-p file 'host) "localhost")))
    (concat "/" (when (file-remote-p file)
                  (concat (file-remote-p file 'method) ":"
                          (if-let* ((user (file-remote-p file 'user)))
                              (concat user "@" host)
                            host)
                          "|"))
            "sudo:root@" host
            ":" (or (file-remote-p file 'localname)
                    file))))

(defun bhw/files--local-name (path)
  "Return PATH without its remote prefix."
  (and path (or (file-remote-p path 'localname) path)))

(defun bhw/files--call-with-local-name (fn)
  "Call FN with this buffer's file and directory stripped of a remote prefix.
`save-place' then treats a file opened through sudo as the local file
it is, and keeps one position for both."
  (when (bound-and-true-p save-place-mode)
    (let ((buffer-file-name (bhw/files--local-name buffer-file-name))
          (default-directory (bhw/files--local-name default-directory)))
      (funcall fn))))

(defun bhw/sudo-find-file (file &optional arg)
  "Open FILE as root.
If the current buffer visits FILE and is modified, offer to save it
first; with prefix ARG, save it without asking."
  (interactive
   (list (read-file-name "Open file as root: ")
         current-prefix-arg))
  (let ((window-start (window-start))
        (buffer (current-buffer)))
    (when (and buffer-file-name (file-equal-p buffer-file-name file))
      (when (buffer-modified-p)
        (save-some-buffers arg (lambda () (eq (current-buffer) buffer))))
      (bhw/files--call-with-local-name #'save-place-to-alist))
    (prog1
        ;; No auto-save in the Tramp buffer.  It can start processes that
        ;; hang in the background and leave the buffer unusable for the rest
        ;; of the session, because Tramp caches them.
        (let ((auto-save-default nil)
              (remote-file-name-inhibit-auto-save t)
              (remote-file-name-inhibit-auto-save-visited t)
              save-place-mode)
          (find-file (bhw/files--sudo-path (expand-file-name file))))
      ;; Point is off the first line only if the buffer was already open.
      ;; Record where it was, in case that is wanted again.
      (unless (bobp)
        (if (bound-and-true-p better-jumper-mode)
            (better-jumper-set-jump)
          (evil-set-jump))
        ;; `save-place-find-file-hook' only acts with point at the start.
        (goto-char (point-min)))
      (bhw/files--call-with-local-name #'save-place-find-file-hook)
      (set-window-start nil window-start))))

(defun bhw/sudo-this-file ()
  "Open the current file as root."
  (interactive)
  (bhw/sudo-find-file
   (or (buffer-file-name (buffer-base-buffer))
       (when (derived-mode-p 'dired-mode 'wdired-mode)
         default-directory)
       (user-error "Current buffer isn't visiting a file"))))

(defun bhw/sudo-save-buffer ()
  "Save this file as root."
  (interactive)
  (let ((file (bhw/files--sudo-path (buffer-file-name (buffer-base-buffer)))))
    (if-let* ((buffer (find-file-noselect file)))
        (let ((origin (current-buffer)))
          (copy-to-buffer buffer (point-min) (point-max))
          (unwind-protect
              (with-current-buffer buffer
                (save-buffer))
            (unless (eq origin buffer)
              (kill-buffer buffer))
            (with-current-buffer origin
              (revert-buffer t t))))
      (user-error "Unable to open %S" file))))

;;---------------------------------------------------------------------------
;; Buffers.
(defun bhw/save-and-kill-buffer ()
  "Save the current buffer to its file, then kill it."
  (interactive)
  (save-buffer)
  (kill-current-buffer))

(defun bhw/kill-this-buffer-in-all-windows (buffer &optional dont-save)
  "Kill BUFFER and give each window that showed it a real buffer.
With DONT-SAVE, discard unsaved changes without asking."
  (interactive
   (list (current-buffer) current-prefix-arg))
  (cl-assert (bufferp buffer) t)
  (when (and (buffer-modified-p buffer) dont-save)
    (with-current-buffer buffer
      (set-buffer-modified-p nil)))
  (bhw/kill-buffer-fixup-windows buffer))

(defun bhw/buffers--killed (buffer-list interactive message)
  "Return how many buffers in BUFFER-LIST are dead.
If INTERACTIVE, report the number with the format string MESSAGE
instead."
  (let ((count (cl-count-if-not #'buffer-live-p buffer-list)))
    (if interactive
        (message message count)
      count)))

(defun bhw/kill-all-buffers (&optional buffer-list interactive)
  "Kill every buffer and close every window but one.
With a prefix argument, kill only the buffers of the current project.
From Lisp, kill BUFFER-LIST; INTERACTIVE non-nil reports the count."
  (interactive
   (list (if current-prefix-arg
             (bhw/project-buffer-list)
           (bhw/buffer-list))
         t))
  (if (null buffer-list)
      (message "No buffers to kill")
    (save-some-buffers)
    (delete-other-windows)
    (when (memq (current-buffer) buffer-list)
      (switch-to-buffer (bhw/fallback-buffer)))
    (mapc #'kill-buffer buffer-list)
    (bhw/buffers--killed buffer-list interactive "Killed %d buffers")))

(defun bhw/kill-other-buffers (&optional buffer-list interactive)
  "Kill every buffer but the current one, and the windows showing them.
With a prefix argument, kill only the buffers of the current project.
From Lisp, kill BUFFER-LIST; INTERACTIVE non-nil reports the count."
  (interactive
   (list (delq (current-buffer)
               (if current-prefix-arg
                   (bhw/project-buffer-list)
                 (bhw/buffer-list)))
         t))
  (mapc #'bhw/kill-buffer-and-windows buffer-list)
  (bhw/buffers--killed buffer-list interactive "Killed %d other buffers"))

(defun bhw/kill-buried-buffers (&optional buffer-list interactive)
  "Kill the buffers that no window shows.
With a prefix argument, only those of the current project.  From Lisp,
kill BUFFER-LIST; INTERACTIVE non-nil reports the count."
  (interactive
   (list (bhw/buried-buffers
          (if current-prefix-arg (bhw/project-buffer-list)))
         t))
  (mapc #'kill-buffer buffer-list)
  (bhw/buffers--killed buffer-list interactive "Killed %d buried buffers"))

(defun bhw/toggle-narrow-buffer (beg end)
  "Narrow the buffer to BEG and END, or widen it if it is narrowed.
Interactively that is the region, or the current line without one."
  (interactive (if (region-active-p)
                   (list (bhw/region-beginning) (bhw/region-end))
                 (list (pos-bol) (pos-eol))))
  (if (buffer-narrowed-p)
      (widen)
    (narrow-to-region beg end)))

(defvar-local bhw/buffers--narrowed-base nil
  "The buffer this one was cloned from by `bhw/narrow-buffer-indirectly'.")

(defun bhw/narrow-buffer-indirectly (beg end)
  "Narrow to BEG and END in an indirect clone of this buffer.
Other windows showing the buffer keep the whole of it.
`bhw/widen-indirectly-narrowed-buffer' undoes this, one level at a
time."
  (interactive (if (region-active-p)
                   (list (bhw/region-beginning) (bhw/region-end))
                 (list (pos-bol) (pos-eol))))
  (deactivate-mark)
  (let ((orig-buffer (current-buffer)))
    (with-current-buffer (switch-to-buffer (clone-indirect-buffer nil nil))
      (narrow-to-region beg end)
      (setq bhw/buffers--narrowed-base orig-buffer))))

(defun bhw/widen-indirectly-narrowed-buffer (&optional arg)
  "Undo `bhw/narrow-buffer-indirectly', one level at a time.
Kill the indirect buffer and return to the one it was cloned from.
With prefix ARG, kill every level and return to the base buffer.  A
buffer narrowed the ordinary way is widened."
  (interactive "P")
  (unless (buffer-narrowed-p)
    (user-error "Buffer isn't narrowed"))
  (let ((orig-buffer (current-buffer))
        (base-buffer bhw/buffers--narrowed-base))
    (cond ((or (not base-buffer)
               (not (buffer-live-p base-buffer)))
           (widen))
          (arg
           (let ((buffer orig-buffer)
                 (buffers-to-kill (list orig-buffer)))
             (while (setq buffer (buffer-local-value
                                  'bhw/buffers--narrowed-base buffer))
               (push buffer buffers-to-kill))
             (switch-to-buffer (buffer-base-buffer))
             (mapc #'kill-buffer (remove (current-buffer) buffers-to-kill))))
          ((switch-to-buffer base-buffer)
           (kill-buffer orig-buffer)))))

;;---------------------------------------------------------------------------
;; Persistent scratch buffers.
(defvar bhw/scratch-default-file "__default"
  "File name, less extension, for the scratch buffer of no project.")

(defvar bhw/scratch-dir (expand-file-name "scratch/" bhw/data-dir)
  "Where scratch buffers are saved.")

(defvar bhw/scratch-initial-major-mode nil
  "Major mode for a scratch buffer that has no saved state.
t takes the mode of the buffer the command was called from, nil leaves
it in `fundamental-mode', and a symbol names the mode.")

(defvar bhw/scratch-buffers nil
  "The scratch buffers opened this session.")

(defvar-local bhw/scratch-current-project nil
  "The name of the project this scratch buffer belongs to.")
(put 'bhw/scratch-current-project 'permanent-local t)

(defun bhw/scratch--initial-mode ()
  "Return the major mode for a fresh scratch buffer, or nil for none."
  (cond ((eq bhw/scratch-initial-major-mode t)
         (unless (or buffer-read-only
                     (derived-mode-p 'special-mode)
                     (string-match-p "^ ?\\*" (buffer-name)))
           major-mode))
        ((null bhw/scratch-initial-major-mode) nil)
        ((symbolp bhw/scratch-initial-major-mode)
         bhw/scratch-initial-major-mode)))

(defun bhw/scratch--file (project-name)
  "Return the file that holds the scratch buffer of PROJECT-NAME."
  (expand-file-name (concat (or project-name bhw/scratch-default-file) ".el")
                    bhw/scratch-dir))

(defun bhw/scratch--load (project-name)
  "Fill the current buffer from the saved scratch buffer of PROJECT-NAME.
Return non-nil if there was one."
  (setq bhw/scratch-current-project
        (or project-name bhw/scratch-default-file))
  (let ((file (bhw/scratch--file bhw/scratch-current-project)))
    (make-directory bhw/scratch-dir t)
    (when (file-readable-p file)
      (message "Reading %s" file)
      (cl-destructuring-bind (content point mode)
          (with-temp-buffer
            (save-excursion (insert-file-contents file))
            (read (current-buffer)))
        (erase-buffer)
        (when (fboundp mode)
          (funcall mode))
        (insert content)
        (goto-char point)
        t))))

(defun bhw/scratch-persist-buffer-h ()
  "Save the current scratch buffer to `bhw/scratch-dir'."
  (let ((content (buffer-substring-no-properties (point-min) (point-max)))
        (point (point))
        (mode major-mode))
    (make-directory bhw/scratch-dir t)
    (with-temp-file (bhw/scratch--file bhw/scratch-current-project)
      (prin1 (list content point mode) (current-buffer)))))

(defun bhw/scratch-persist-buffers-h ()
  "Save every scratch buffer to `bhw/scratch-dir'."
  (setq bhw/scratch-buffers
        (cl-delete-if-not #'buffer-live-p bhw/scratch-buffers))
  (dolist (buffer bhw/scratch-buffers)
    (with-current-buffer buffer
      (bhw/scratch-persist-buffer-h))))

(defun bhw/scratch--persist-once-h (&rest _)
  "Save every scratch buffer, once, at the next change of window or buffer."
  (remove-hook 'window-buffer-change-functions #'bhw/scratch--persist-once-h)
  (remove-hook 'window-selection-change-functions #'bhw/scratch--persist-once-h)
  (bhw/scratch-persist-buffers-h))

(unless noninteractive
  (add-hook 'kill-emacs-hook #'bhw/scratch-persist-buffers-h))

(defun bhw/scratch-buffer (&optional dont-restore-p mode directory project-name)
  "Return the scratch buffer of PROJECT-NAME, or the one of no project.
A buffer that has to be created is filled from its saved state, unless
DONT-RESTORE-P, and put in major MODE if that leaves it in
`fundamental-mode'.  DIRECTORY becomes its `default-directory'."
  (let* ((buffer-name (if project-name
                          (format "*bhw:scratch (%s)*" project-name)
                        "*bhw:scratch*"))
         (buffer (get-buffer buffer-name)))
    (with-current-buffer (or buffer (get-buffer-create buffer-name))
      (setq default-directory directory)
      (setq-local so-long--inhibited t)
      (if dont-restore-p
          (erase-buffer)
        (unless buffer
          (bhw/scratch--load project-name)
          (when (and (eq major-mode 'fundamental-mode)
                     (functionp mode))
            (funcall mode))))
      (cl-pushnew (current-buffer) bhw/scratch-buffers)
      (add-hook 'window-buffer-change-functions #'bhw/scratch--persist-once-h)
      (add-hook 'window-selection-change-functions #'bhw/scratch--persist-once-h)
      (add-hook 'kill-buffer-hook #'bhw/scratch-persist-buffer-h nil 'local)
      (current-buffer))))

(defun bhw/open-scratch-buffer (&optional arg project-p same-window-p)
  "Pop up the persistent scratch buffer.
With prefix ARG, start it empty instead of restoring what was saved.
PROJECT-P non-nil means the scratch buffer of the current project.
SAME-WINDOW-P non-nil shows it in the selected window."
  (interactive "P")
  (funcall (if same-window-p #'switch-to-buffer #'pop-to-buffer)
           (bhw/scratch-buffer arg
                               (bhw/scratch--initial-mode)
                               default-directory
                               (and project-p (bhw/project-name)))))

(defun bhw/switch-to-scratch-buffer (&optional arg project-p)
  "Show the persistent scratch buffer in the selected window.
ARG and PROJECT-P are as for `bhw/open-scratch-buffer'."
  (interactive "P")
  (bhw/open-scratch-buffer arg project-p 'same-window))

(defun bhw/switch-to-project-scratch-buffer (&optional arg)
  "Show the current project's scratch buffer in the selected window.
With prefix ARG, start it empty instead of restoring what was saved."
  (interactive "P")
  (bhw/open-scratch-buffer arg 'project 'same-window))

(defun bhw/toggle-scratch-buffer (&optional arg project-p same-window-p)
  "Close the persistent scratch buffer's window, or open it if it has none.
ARG, PROJECT-P and SAME-WINDOW-P are as for `bhw/open-scratch-buffer'."
  (interactive "P")
  (let* ((buf (bhw/scratch-buffer arg
                                  (bhw/scratch--initial-mode)
                                  default-directory
                                  (and project-p (bhw/project-name))))
         (win (get-buffer-window buf)))
    (if win
        (delete-window win)
      (funcall (if same-window-p #'switch-to-buffer #'pop-to-buffer) buf))))

(defun bhw/toggle-project-scratch-buffer (&optional arg same-window-p)
  "Toggle the current project's scratch buffer.
ARG and SAME-WINDOW-P are as for `bhw/open-scratch-buffer'."
  (interactive "P")
  (bhw/toggle-scratch-buffer arg 'project same-window-p))

;;---------------------------------------------------------------------------
;; Projects and directories.
(defvar bhw/project-search-path nil
  "Directories that `bhw/discover-projects' looks for projects under.
An element is a directory, or (DIRECTORY . t) to search it at every
depth instead of one level down.")

;; In bhw-project, which loads after this file and before any command runs.
(declare-function bhw/project-forget-dead-projects "bhw-project")

(defun bhw/project--read-other (prompt)
  "Read the root of a known project with PROMPT.
The current project is left out, and so are projects that are gone."
  (bhw/project-forget-dead-projects)
  (let* ((current (when-let* ((root (bhw/project-root)))
                    (abbreviate-file-name root)))
         (roots (remove current (project-known-project-roots))))
    (unless roots
      (user-error "There are no known projects"))
    (completing-read
     prompt
     (lambda (string pred action)
       (if (eq action 'metadata)
           '(metadata (category . file))
         (complete-with-action action roots string pred)))
     nil t)))

(defun bhw/find-file-in-other-project (root)
  "Jump to a file in the known project rooted at ROOT."
  (interactive (list (bhw/project--read-other "Find file in project: ")))
  (unless (file-directory-p root)
    (error "Project directory '%s' doesn't exist" root))
  (bhw/project-find-file root))

(defun bhw/browse-in-other-project (root)
  "Run `find-file' from the known project rooted at ROOT."
  (interactive (list (bhw/project--read-other "Browse in project: ")))
  (unless (file-directory-p root)
    (error "Project directory '%s' doesn't exist" root))
  (bhw/project-browse root))

(defun bhw/browse-project ()
  "Run `find-file' from the root of the current project."
  (interactive)
  (bhw/project-browse (or (bhw/project-root) default-directory)))

(defun bhw/find-file-under-here ()
  "Jump to a file under the current directory, searched recursively."
  (interactive)
  (bhw/project-find-file default-directory))

(defun bhw/browse-in-emacsd ()
  "Run `find-file' from `bhw/user-dir'."
  (interactive)
  (bhw/project-browse bhw/user-dir))

(defun bhw/find-file-in-emacsd ()
  "Jump to a file of this configuration.
It is a directory of a larger repository, where `bhw/project-find-file'
would list every file under it, var/ too: list the repository's files
under it instead."
  (interactive)
  (if-let* ((project (project-current nil bhw/user-dir)))
      (project-find-file-in nil (list bhw/user-dir) project)
    (bhw/project-find-file bhw/user-dir)))

(defalias 'bhw/open-private-config #'bhw/browse-in-emacsd)
(defalias 'bhw/find-file-in-private-config #'bhw/find-file-in-emacsd)

(defun bhw/dired (arg)
  "Open a directory in Dired.
With prefix ARG, choose from the known projects instead."
  (interactive "P")
  (if arg
      (dired (completing-read "Open dired in project: "
                              (progn (bhw/project-forget-dead-projects)
                                     (project-known-project-roots))))
    (call-interactively #'dired)))

(defun bhw/discover-projects (arg)
  "Remember the projects found under `bhw/project-search-path'.
With prefix ARG, ask for the directory to look under."
  (interactive "P")
  (cond (arg (call-interactively #'project-remember-projects-under))
        ((null bhw/project-search-path)
         (user-error "`bhw/project-search-path' is empty; don't know where to search"))
        (t
         (dolist (entry bhw/project-search-path)
           (pcase-let ((`(,dir . ,recursive) (if (consp entry)
                                                 entry
                                               (list entry))))
             (if (file-accessible-directory-p dir)
                 (project-remember-projects-under dir recursive)
               (message "%S was inaccessible and couldn't be searched" dir)))))))

;;---------------------------------------------------------------------------
;; Search.
(cl-defun bhw/vertico-file-search (&key query in all-files (recursive t) prompt args)
  "Search files with ripgrep, live, through consult.
QUERY is the initial input; the selection, if there is one, by default.
IN is the directory to search from, by default the root of the current
project, or the current directory outside one.  ALL-FILES includes
hidden and ignored files.  RECURSIVE nil stays out of subdirectories.
PROMPT replaces the default prompt.  ARGS is a list of further ripgrep
arguments."
  (declare (indent defun))
  (unless (executable-find "rg" t)
    (user-error "Couldn't find ripgrep in your PATH"))
  (require 'consult)
  (setq deactivate-mark t)
  (let* ((directory (or in (bhw/project-root) default-directory))
         (prompt (if (stringp prompt) (string-trim prompt) "Search"))
         (query (or query
                    (when (bhw/region-active-p)
                      (regexp-quote (bhw/region t))))))
    (dlet ((consult-ripgrep-args
            (concat "rg "
                    (if all-files "-uu ")
                    (unless recursive "--maxdepth 1 ")
                    "--null --line-buffered --color=never --max-columns=1000 "
                    "--path-separator /   --smart-case --no-heading "
                    "--with-filename --line-number --search-zip "
                    "--hidden -g !.git -g !.svn -g !.hg "
                    (mapconcat #'identity args " ")))
           (consult-async-split-style consult-async-split-style)
           (consult-async-split-styles-alist
            (copy-sequence consult-async-split-styles-alist)))
      ;; A query that contains the split character needs another one.
      (when query
        (cl-destructuring-bind (&key separator initial function)
            (alist-get consult-async-split-style consult-async-split-styles-alist)
          (if (eq consult-async-split-style 'perl)
              ;; The perl style opens with #.  If the query has one, open
              ;; with a character it does not have.
              (when (string-match-p (char-to-string initial) query)
                (setf (alist-get 'perlalt consult-async-split-styles-alist)
                      `(:initial ,(or (cl-loop for char in (list "%" "@" "!" "&" "/" ";")
                                               unless (string-match-p char query)
                                               return char)
                                      "%")
                        :separator ,separator
                        :function ,function)
                      consult-async-split-style 'perlalt))
            ;; Other styles: escape the separator where the query has it.
            (when separator
              (setq query
                    (replace-regexp-in-string
                     (regexp-quote (char-to-string separator))
                     (concat "\\" (char-to-string separator))
                     query t t))))))
      (consult--grep prompt #'consult--ripgrep-make-builder directory query))))

(defun bhw/vertico-project-search (&optional arg initial-query directory)
  "Search the project with ripgrep, live.
With prefix ARG, include hidden and ignored files.  INITIAL-QUERY and
DIRECTORY override the first query and where the search starts."
  (interactive "P")
  (bhw/vertico-file-search :query initial-query :in directory :all-files arg))

(defun bhw/vertico-project-search-from-cwd (&optional arg initial-query)
  "Search the current directory with ripgrep, live.
With prefix ARG, include hidden and ignored files.  INITIAL-QUERY is
the first query."
  (interactive "P")
  (bhw/vertico-project-search arg initial-query default-directory))

(defun bhw/vertico-search-symbol-at-point ()
  "Search the current buffer for the symbol at point."
  (interactive)
  (consult-line (thing-at-point 'symbol)))

(defun bhw/search-cwd (&optional arg)
  "Search the files under the current directory.
With prefix ARG, ask for the directory to search."
  (interactive "P")
  (let ((default-directory
         (if arg
             (read-directory-name "Search directory: ")
           default-directory)))
    (bhw/vertico-project-search-from-cwd)))

(defun bhw/search-other-cwd ()
  "Search the files under a directory to be asked for."
  (interactive)
  (bhw/search-cwd 'other))

(defun bhw/search-emacsd ()
  "Search the files of this configuration."
  (interactive)
  (let ((default-directory bhw/user-dir))
    (bhw/vertico-project-search-from-cwd)))

(defun bhw/search-buffer ()
  "Search the current buffer.
A selection that spans lines restricts the search to those lines.  A
selection within one line is searched for."
  (interactive)
  (let (start end multiline-p)
    (save-restriction
      (when (region-active-p)
        (setq start (region-beginning)
              end   (region-end)
              multiline-p (/= (line-number-at-pos start)
                              (line-number-at-pos end)))
        (deactivate-mark)
        (when multiline-p
          (narrow-to-region start end)))
      (if (and start end (not multiline-p))
          (consult-line
           (bhw/orderless-quote (buffer-substring-no-properties start end)))
        (call-interactively #'consult-line)))))

(defun bhw/search-project (&optional arg)
  "Search the current project.
With prefix ARG, include hidden and ignored files."
  (interactive "P")
  (let ((default-directory
         (if (eq arg 'other)
             (bhw/project--read-other "Search project: ")
           default-directory)))
    (bhw/vertico-project-search (unless (eq arg 'other) arg))))

(defun bhw/search-other-project ()
  "Search a known project to be asked for."
  (interactive)
  (bhw/search-project 'other))

(defun bhw/search-project-for-symbol-at-point (symbol dir)
  "Search the project rooted at DIR for SYMBOL.
Interactively, SYMBOL is the selection or the symbol at point and DIR
is the current project; with a prefix argument, a known project to be
asked for."
  (interactive
   (list (or (bhw/thing-at-point-or-region) "")
         (if current-prefix-arg
             (bhw/project--read-other "Search project: ")
           (bhw/project-root))))
  (bhw/vertico-project-search nil symbol dir))

;;---------------------------------------------------------------------------
;; Paths and text.
(defun bhw/yank-buffer-contents ()
  "Copy the whole buffer to the kill ring."
  (interactive)
  (clipboard-kill-ring-save (point-min) (point-max)))

(defun bhw/yank-buffer-path (&optional root)
  "Copy the path of the current buffer's file to the kill ring.
With ROOT, copy it relative to that directory."
  (interactive)
  (if-let* ((filename (or (buffer-file-name (buffer-base-buffer))
                          (bound-and-true-p list-buffers-directory))))
      (let ((path (abbreviate-file-name
                   (if root
                       (file-relative-name filename root)
                     filename))))
        (kill-new path)
        (if (string= path (car kill-ring))
            (message "Copied path: %s" path)
          (user-error "Couldn't copy filename in current buffer")))
    (error "Couldn't find filename in current buffer")))

(defun bhw/yank-buffer-path-relative-to-project (&optional include-root)
  "Copy the path of the current buffer's file, relative to its project.
With prefix INCLUDE-ROOT, start the path at the project's own
directory."
  (interactive "P")
  (bhw/yank-buffer-path
   (if include-root
       (file-name-directory (directory-file-name (bhw/project-root)))
     (bhw/project-root))))

(defun bhw/insert-file-path (arg)
  "Insert the name of the file this buffer visits.
With prefix ARG, insert its whole path.  A buffer without a file gives
its directory."
  (interactive "P")
  (let ((path (or buffer-file-name default-directory)))
    (insert
     (if arg
         (abbreviate-file-name path)
       (file-name-nondirectory path)))))

(defun bhw/delete-trailing-newlines ()
  "Delete the blank lines at the end of the buffer."
  (interactive)
  (save-excursion
    (goto-char (point-max))
    (delete-blank-lines)))

;;---------------------------------------------------------------------------
;; Toggles.
(defun bhw/toggle-indent-style ()
  "Switch this buffer between indenting with tabs and with spaces."
  (interactive)
  (setq indent-tabs-mode (not indent-tabs-mode))
  (message "Indent style changed to %s" (if indent-tabs-mode "tabs" "spaces")))

(defvar bhw/toggle--line-number-style)

(defun bhw/toggle-line-numbers ()
  "Cycle through absolute, relative and no line numbers.
The cycle starts from `display-line-numbers-type'.  In
`visual-line-mode', relative numbers count screen lines."
  (interactive)
  (require 'display-line-numbers)
  (unless (boundp 'bhw/toggle--line-number-style)
    (setq bhw/toggle--line-number-style display-line-numbers-type))
  (let* ((styles `(t ,(if visual-line-mode 'visual 'relative) nil))
         (order (cons display-line-numbers-type
                      (remq display-line-numbers-type styles)))
         (queue (memq bhw/toggle--line-number-style order))
         (next (if (= (length queue) 1)
                   (car order)
                 (car (cdr queue)))))
    (setq bhw/toggle--line-number-style next)
    (dlet ((display-line-numbers-type next))
      (display-line-numbers-mode +1))
    (message "Switched to %s line numbers"
             (pcase next
               ('t "normal")
               ('nil "disabled")
               (_ (symbol-name next))))))

;;---------------------------------------------------------------------------
;; The session and help.
(defun bhw/restart-server ()
  "Restart the Emacs server."
  (interactive)
  (server-force-delete)
  (while (server-running-p)
    (sleep-for 1))
  (server-start))

(defvar bhw/profiler--running nil
  "Non-nil while `bhw/toggle-profiler' has the profiler running.")

(defun bhw/toggle-profiler ()
  "Start the profiler; called again, show its report and stop it."
  (interactive)
  (if (not bhw/profiler--running)
      (profiler-start 'cpu+mem)
    (profiler-report)
    (profiler-stop))
  (setq bhw/profiler--running (not bhw/profiler--running)))

(defun bhw/man-or-woman ()
  "Read a manual page with `man', or with `woman' where man is missing."
  (interactive)
  (call-interactively
   (if (executable-find "man")
       (or (command-remapping #'man) #'man)
     #'woman)))

(defun bhw/diagnostics (&optional project)
  "List the diagnostics for the current buffer.
With PROJECT, the prefix argument, list those of every buffer of its
project."
  (interactive "P")
  (unless (bound-and-true-p flymake-mode)
    (user-error "No diagnostics here: flymake is not on"))
  (consult-flymake project))

;;---------------------------------------------------------------------------
;; Keys outside the tree.
(evil-define-key* 'normal 'global
  "ZX" #'bhw/save-and-kill-buffer
  "zN" #'bhw/widen-indirectly-narrowed-buffer
  (kbd "C-=")   #'text-scale-increase
  (kbd "C--")   #'text-scale-decrease
  (kbd "C-S-f") #'toggle-frame-fullscreen)

(evil-define-key* 'insert 'global
  (kbd "S-RET") #'electric-newline-and-maybe-indent
  [S-return]    #'electric-newline-and-maybe-indent)

;;---------------------------------------------------------------------------
;; Help.
;; `help-for-help' on C-h gets in the way of which-key's paging under a help
;; prefix; it stays on ? and F1.
(define-key help-map (kbd "C-h") nil)

(bhw/define-keys help-map
  '(("a"   apropos)
    ("A"   apropos-documentation)
    ("b"   nil "bindings")
    ("b b" describe-bindings)
    ("b f" which-key-show-full-keymap)
    ("b i" which-key-show-minor-mode-keymap)
    ("b k" which-key-show-keymap)
    ("b m" which-key-show-major-mode)
    ("b t" which-key-show-top-level)
    ("C-c" describe-coding-system)
    ("C-k" describe-key-briefly)
    ("C-l" describe-language-environment)
    ("C-m" info-emacs-manual)
    ("F"   describe-face)
    ("P"   find-library)
    ("r"   nil "reload")
    ("r r" bhw/reload)
    ("t"   load-theme)
    ("T"   bhw/toggle-profiler)
    ("W"   bhw/man-or-woman)))

;;---------------------------------------------------------------------------
;; The tree.
(bhw/define-keys bhw/leader-map
  '(("*"   bhw/search-project-for-symbol-at-point "Search for symbol in project")
    ("."   find-file                              "Find file")
    ("/"   bhw/search-project                     "Search project")
    (":"   execute-extended-command               "M-x")
    (";"   pp-eval-expression                     "Eval expression")
    ("<"   switch-to-buffer                       "Switch buffer")
    ("`"   evil-switch-to-windows-last-buffer     "Switch to last buffer")
    ("RET" bookmark-jump                          "Jump to bookmark")
    ("u"   universal-argument                     "Universal argument")
    ("X"   org-capture                            "Org Capture")
    ("x"   bhw/toggle-scratch-buffer              "Toggle scratch buffer")
    ("~"   bhw/popup-toggle                       "Toggle last popup")
    ("h" help-command "help")
    ("w" evil-window-map "window")
    ))

;; wizard's clones keep point and the scroll position, and take no search
;; highlight with them; its reload saves the buffer, kills it and visits
;; the file again, which a revert does not do.  That one has no autoload
;; cookie.
(autoload 'wizard-reload-current-buffer "wizard" nil t)

(bhw/define-keys bhw/leader-map
  '(("b"   nil                                        "buffer")
    ("b -" bhw/toggle-narrow-buffer                   "Toggle narrowing")
    ("b B" switch-to-buffer                           "Switch buffer")
    ("b c" wizard-clone-indirect-buffer               "Clone buffer other window")
    ("b K" bhw/kill-all-buffers                       "Kill all buffers")
    ("b M" bookmark-delete                            "Delete bookmark")
    ("b N" evil-buffer-new                            "New empty buffer")
    ("b O" bhw/kill-other-buffers                     "Kill other buffers")
    ("b R" rename-buffer                              "Rename buffer")
    ("b S" evil-write-all                             "Save all buffers")
    ("b X" bhw/switch-to-scratch-buffer               "Switch to scratch buffer")
    ("b Z" bhw/kill-buried-buffers                    "Kill buried buffers")
    ("b [" previous-buffer                            "Previous buffer")
    ("b ]" next-buffer                                "Next buffer")
    ("b C" wizard-clone-and-switch-to-indirect-buffer "Clone buffer")
    ("b d" kill-current-buffer                        "Kill buffer")
    ("b h" wizard-reload-current-buffer               "Save and reopen buffer")
    ("b i" ibuffer                                    "ibuffer")
    ("b k" kill-current-buffer                        "Kill buffer")
    ("b l" evil-switch-to-windows-last-buffer         "Switch to last buffer")
    ("b m" bookmark-set                               "Set bookmark")
    ("b n" next-buffer                                "Next buffer")
    ("b o" wizard-switch-to-base-buffer               "Switch to base buffer")
    ("b p" previous-buffer                            "Previous buffer")
    ("b r" revert-buffer                              "Revert buffer")
    ("b s" basic-save-buffer                          "Save buffer")
    ("b u" bhw/sudo-save-buffer                       "Save buffer as root")
    ("b x" bhw/open-scratch-buffer                    "Pop up scratch buffer")
    ("b y" bhw/yank-buffer-contents                   "Yank buffer")
    ("b z" bury-buffer                                "Bury buffer")))

(bhw/define-keys bhw/leader-map
  '(("c"   nil                               "code")
    ("c C" recompile                         "Recompile")
    ("c D" bhw/lookup-references             "Jump to references")
    ("c E" bhw/evil-eval-replace-region      "Evaluate & replace region")
    ("c W" bhw/delete-trailing-newlines      "Delete trailing newlines")
    ("c a" eglot-code-actions                "LSP Execute code action")
    ("c c" compile                           "Compile")
    ("c d" bhw/lookup-definition             "Jump to definition")
    ("c e" bhw/eval-buffer-or-region         "Evaluate buffer/region")
    ("c f" bhw/format-region-or-buffer       "Format buffer/region")
    ("c i" bhw/lookup-implementations        "Find implementations")
    ("c j" consult-eglot-symbols             "Jump to symbol in current workspace")
    ("c k" bhw/lookup-documentation          "Jump to documentation")
    ("c r" eglot-rename                      "LSP Rename")
    ("c s" bhw/eval-buffer-or-region-in-repl "Send buffer/region to repl")
    ("c t" bhw/lookup-type-definition        "Find type definition")
    ("c w" delete-trailing-whitespace        "Delete trailing whitespace")
    ("c x" bhw/diagnostics                   "List errors")))

(bhw/define-keys bhw/leader-map
  '(("f"   nil                                      "file")
    ("f C" bhw/copy-this-file                       "Copy this file")
    ("f D" bhw/delete-this-file                     "Delete this file")
    ("f E" bhw/browse-in-emacsd                     "Browse emacs.d")
    ("f F" bhw/find-file-under-here                 "Find file from here")
    ("f P" bhw/open-private-config                  "Browse private config")
    ("f R" bhw/move-this-file                       "Rename/move file")
    ("f S" write-file                               "Save file as...")
    ("f U" bhw/sudo-this-file                       "Sudo this file")
    ("f Y" bhw/yank-buffer-path-relative-to-project "Yank file path from project")
    ("f c" editorconfig-find-current-editorconfig   "Open project editorconfig")
    ("f d" bhw/dired                                "Find directory")
    ("f e" bhw/find-file-in-emacsd                  "Find file in emacs.d")
    ("f f" find-file                                "Find file")
    ("f l" locate                                   "Locate file")
    ("f p" bhw/find-file-in-private-config          "Find file in private config")
    ("f r" recentf-open-files                       "Recent files")
    ("f s" basic-save-buffer                        "Save file")
    ("f u" bhw/sudo-find-file                       "Sudo find file")
    ("f y" bhw/yank-buffer-path                     "Yank file path")))

(bhw/define-keys bhw/leader-map
  '(("g"     nil                           "git")
    ("g c"   nil                           "create")
    ("g f"   nil                           "find")
    ("g l"   nil)
    ("g o"   nil                           "open in browser")
    ("g '"   forge-dispatch                "Forge dispatch")
    ("g ."   magit-file-dispatch           "Magit file dispatch")
    ("g /"   magit-dispatch                "Magit dispatch")
    ("g B"   magit-blame-addition          "Magit blame")
    ("g C"   magit-clone                   "Magit clone")
    ("g D"   magit-file-delete             "Magit file delete")
    ("g F"   magit-fetch                   "Magit fetch")
    ("g G"   magit-status-here             "Magit status here")
    ("g L"   magit-log-buffer-file         "Magit buffer log")
    ("g R"   vc-revert                     "Revert file")
    ("g S"   magit-file-stage              "Git stage this file")
    ("g U"   magit-file-unstage            "Git unstage this file")
    ("g Y"   bhw/vc-git-link-kill-homepage "Copy link to homepage")
    ("g b"   magit-branch-checkout         "Magit switch branch")
    ("g c R" magit-clone                   "Clone repo")
    ("g c b" magit-branch-and-checkout     "Branch")
    ("g c c" magit-commit-create           "Commit")
    ("g c f" magit-commit-fixup            "Fixup")
    ("g c i" forge-create-issue            "Issue")
    ("g c p" forge-create-pullreq          "Pull request")
    ("g c r" magit-init                    "Initialize repo")
    ("g f c" magit-show-commit             "Find commit")
    ("g f f" magit-find-file               "Find file")
    ("g f g" magit-find-git-config-file    "Find gitconfig file")
    ("g f i" forge-visit-issue             "Find issue")
    ("g f p" forge-visit-pullreq           "Find pull request")
    ("g g"   magit-status                  "Magit status")
    ("g l i" forge-list-issues             "List issues")
    ("g l n" forge-list-notifications      "List notifications")
    ("g l p" forge-list-pullreqs           "List pull requests")
    ("g l r" magit-list-repositories       "List repositories")
    ("g l s" magit-list-submodules         "List submodules")
    ("g o I" forge-browse-issues           "Browse issues")
    ("g o P" forge-browse-pullreqs         "Browse pull requests")
    ("g o c" forge-browse-commit           "Browse commit")
    ("g o h" bhw/vc-git-link-homepage      "Browse homepage")
    ("g o i" forge-browse-issue            "Browse an issue")
    ("g o o" bhw/vc-git-link               "Browse file or region")
    ("g o p" forge-browse-pullreq          "Browse a pull request")
    ("g o r" forge-browse-remote           "Browse remote")
    ("g t"   git-timemachine-toggle        "Git time machine")
    ("g y"   bhw/vc-git-link-kill          "Copy link to remote")))

(bhw/define-keys bhw/leader-map
  '(("i"   nil                          "insert")
    ("i F" bhw/insert-current-file-path "Current file path")
    ("i e" emoji-search                 "Emoji")
    ("i f" bhw/insert-file-path         "Current file name")
    ("i p" bhw/evil-ex-read-shell       "Evil ex path")
    ("i r" evil-show-registers          "From evil register")
    ("i s" bhw/templates-insert         "Template")
    ("i u" insert-char                  "Unicode")
    ("i y" consult-yank-pop             "From clipboard")))

(bhw/define-keys bhw/leader-map
  '(("n"   nil                     "notes")
    ("n N" org-capture-goto-target "Goto capture")
    ("n a" org-agenda              "Org agenda")
    ("n b" citar-open-notes        "Bibliographic notes")
    ("n e" org-noter               "Org noter")
    ("n l" org-store-link          "Org store link")
    ("n m" org-tags-view           "Tags search")
    ("n n" org-capture             "Org capture")
    ("n v" org-search-view         "View search")))

(bhw/define-keys bhw/leader-map
  '(("o"     nil                               "open")
    ("o a"   nil                               "org agenda")
    ("o -"   dired-jump                        "Dired")
    ("o /"   dirvish                           "Open directory in dirvish")
    ("o A"   org-agenda                        "Org agenda")
    ("o F"   select-frame-by-name              "Select frame")
    ("o P"   bhw/dired-dirvish-side-and-follow "Find file in project sidebar")
    ("o R"   bhw/eval-open-repl-same-window    "REPL (same window)")
    ("o a a" org-agenda                        "Agenda")
    ("o a m" org-tags-view                     "Tags search")
    ("o a t" org-todo-list                     "Todo list")
    ("o a v" org-search-view                   "View search")
    ("o b"   browse-url-of-file                "Default browser")
    ("o f"   make-frame                        "New frame")
    ("o p"   dirvish-side                      "Project sidebar")
    ("o r"   bhw/eval-open-repl-other-window   "REPL")
    ("o t"   bhw/ghostel-toggle                "Toggle ghostel popup")))

(bhw/define-keys bhw/leader-map
  '(("p"   nil                                  "project")
    ("p ." bhw/browse-project                   "Browse project")
    ("p >" bhw/browse-in-other-project          "Browse other project")
    ("p D" bhw/discover-projects                "Discover projects in folder")
    ("p F" bhw/find-file-in-other-project       "Find file in other project")
    ("p X" bhw/switch-to-project-scratch-buffer "Switch to scratch buffer")
    ("p o" find-sibling-file                    "Find sibling file")
    ("p x" bhw/toggle-project-scratch-buffer    "Toggle scratch buffer")))

(bhw/define-keys bhw/leader-map
  '(("q"   nil                           "quit/session")
    ("q F" bhw/kill-all-buffers          "Clear current frame")
    ("q K" save-buffers-kill-emacs       "Kill Emacs (and daemon)")
    ("q Q" evil-quit-all-with-error-code "Quit Emacs without saving")
    ("q d" bhw/restart-server            "Restart emacs server")
    ("q f" delete-frame                  "Delete frame")
    ("q q" save-buffers-kill-terminal    "Quit Emacs")
    ("q r" restart-emacs                 "Restart Emacs")))

(bhw/define-keys bhw/leader-map
  '(("s"   nil                                "search")
    ("s B" bhw/search-all-buffers             "Search all open buffers")
    ("s D" bhw/search-other-cwd               "Search other directory")
    ("s I" consult-imenu-multi                "Jump to symbol in open buffers")
    ("s L" ffap-menu                          "Jump to link")
    ("s P" bhw/search-other-project           "Search other project")
    ("s S" bhw/vertico-search-symbol-at-point "Search buffer for thing at point")
    ("s b" bhw/search-buffer                  "Search buffer")
    ("s d" bhw/search-cwd                     "Search current directory")
    ("s i" imenu                              "Jump to symbol")
    ("s j" evil-show-jumps                    "Jump list")
    ("s m" bookmark-jump                      "Jump to bookmark")
    ("s p" bhw/search-project                 "Search project")
    ("s r" evil-show-marks                    "Jump to mark")
    ("s s" bhw/search-buffer                  "Search buffer")
    ("s u" vundo                              "Undo history")))

(bhw/define-keys bhw/leader-map
  '(("t"   nil                                       "toggle")
    ("t F" toggle-frame-fullscreen                   "Frame fullscreen")
    ("t I" bhw/toggle-indent-style                   "Indent style")
    ("t b" bhw/big-font-mode                         "Big mode")
    ("t c" global-display-fill-column-indicator-mode "Fill Column Indicator")
    ("t f" flymake-mode                              "Flymake")
    ("t h" wizard-toggle-highlight-at-point          "Highlight symbol")
    ("t l" bhw/toggle-line-numbers                   "Line numbers")
    ("t r" read-only-mode                            "Read-only mode")
    ("t s" jinx-mode                                 "Spell checker")
    ("t v" visible-mode                              "Visible mode")
    ("t w" bhw/word-wrap-mode                        "Soft line wrapping")))