Emacs Init File

;; init file proper begins here

;; customizations
(setq custom-file (concat user-emacs-directory "customizations.el"))
(when (file-exists-p custom-file) (load custom-file 't))

;; package manager
(with-eval-after-load 'package
  (dolist (arc '(("melpa-stable" . "http://stable.melpa.org/packages/")
                 ("melpa" . "https://melpa.org/packages/")
                 ("kw" . "https://www2.lib.uchicago.edu/keith/software/emacs/packages/")))
    (add-to-list 'package-archives arc t))
  (setq package-archive-priorities '(("kw" . 11) ("gnu" . 10) ("nongnu" . 9) ("melpa-stable" . 8)))
  (add-hook 'package-menu-mode-hook 'hl-line-mode))

(unless (fboundp 'use-package)
  (message "`use-package' not available!")
  (defmacro use-package (name &rest args)
    (message "%S disabled because `use-package' unavailable." name)))

(setq inhibit-startup-screen t)

(when (string= "" user-full-name) (setq user-full-name "Keith Waclena"))

;; ffap can try to ping hostname-like things which can take forever to timeout...
(mapc
 (lambda (var) (set var 'reject))
 '(ffap-machine-p-local ffap-machine-p-known ffap-machine-p-unknown))

(setq auth-sources `(,(expand-file-name "~/emacs/authinfo.gpg"))) ; authentication
(add-to-list 'auto-mode-alist `(,(rx bos (eval (expand-file-name (car auth-sources))) eos) . authinfo-mode))

(defconst home-emacs (file-name-as-directory (expand-file-name "~/emacs"))
  "My Emacs Lisp code lives here.")
(add-to-list 'load-path home-emacs)

(setq save-interprogram-paste-before-kill t yank-pop-change-selection t)
(setq select-enable-primary t select-enable-clipboard t)

(cd "~")

(setq-default tab-always-indent t)

(defvar kw-handy-keymap (make-sparse-keymap)
  "*Handy f12 keymap.")
(global-set-key (kbd "<f12>") kw-handy-keymap)

;; very general M-x aliases
(defalias 'qrr 'query-replace-regexp)
(defalias 'ffr 'find-file-read-only)
(defalias 'firefox 'browse-url-firefox)

(cond
 ((eq 'gnu/linux system-type)
  ;; I run Linux on a Macbook and want the command key for Meta
  (setq x-super-keysym 'meta))
 ((eq 'darwin system-type)     ; homebrew
  (add-to-list 'exec-path "/usr/local/bin")))

(with-eval-after-load 'chistory
  (setq list-command-history-max 120)
  (define-key command-history-mode-map (kbd "<return>") #'command-history-repeat))

(defun kw-scroll-one-paragraph (&optional arg)
  "Scroll forward by ARG paragraphs."
  (interactive "P")
  (let ((here (point)))
    (move-to-window-line 0)
    (forward-paragraph arg)
    (re-search-forward "\\=[[:space:]\n]+" nil t)
    (forward-line -1)
    (recenter 0)
    (when (> here (point))
      (goto-char here))))

(defun kw-scroll-one-paragraph-back (&optional arg)
  "Scroll backward by ARG paragraphs."
  (interactive "P")
  (kw-scroll-one-paragraph (or arg -1)))

(with-eval-after-load 'help-mode
  (define-key help-mode-map "[" #'kw-scroll-one-paragraph-back)
  (define-key help-mode-map "]" #'kw-scroll-one-paragraph))

(setq world-clock-list
      '(("America/Chicago" "Chicago")
        ("America/New_York" "Kalamazoo")
        ("America/New_York" "Syracuse")
        ("Europe/Vienna" "Vienna")))
(setq calendar-location-name "Chicago, IL" ;your default location
      calendar-latitude 41.795088232902785
      calendar-longitude -87.5813341140747
      calendar-mark-holidays-flag t        ;colorize holidays in the calendar
      calendar-mark-diary-entries-flag t   ;also diary entries
      appt-display-format 'echo            ;appointment notifications in echo area
      holiday-bahai-holidays nil           ;these religions have MANY holidays
      holiday-islamic-holidays nil         ;... that I don't get off
      diary-file (expand-file-name "~/notes/diary")
      diary-comment-start "(*"             ;comments allowed in diary
      diary-comment-end   "*)")
(add-hook 'diary-list-entries-hook         ; recursive diary files are good
          'diary-include-other-diary-files)
(add-hook 'diary-mark-entries-hook         ; ... so mark them too
          'diary-mark-included-diary-files)
(appt-activate 1)                          ; appointment notifications, please
(require 'notifications)               ;also via desktop notifications
;; notable holidays that Emacs doesn't know about
(with-eval-after-load 'holidays
  (add-to-list 'calendar-holidays
               '(holiday-sexp
                 '(if (zerop (% year 4))
                      (calendar-gregorian-from-absolute
                       (1+ (calendar-dayname-on-or-before
                            1 (+ 6 (calendar-absolute-from-gregorian
                                    (list 11 1 year)))))))
                 "US Presidential Election")))

(setq gc-cons-threshold             20000000) ; 20MB means less gc

(setq delete-active-region nil)         ; too GUIish
(setq select-active-regions 'only)      ; too eager

(when (version<= "27.1" emacs-version)    ;speed up long lines
  (global-so-long-mode 1))

(setq-default bidi-paragraph-direction 'left-to-right)
(when (version<= "27.1" emacs-version)
  (setq bidi-inhibit-bpa t))

(require 'server)
(if (fboundp 'server-running-p)         ; new in v28?
    (unless (server-running-p)
      (server-start))
  ;; server-start will fail if the server is already running...
  (ignore-errors (server-start)))

(setq confirm-kill-emacs 'yes-or-no-p)        ; exiting emacs is silly
;; restore state on the rare occasion that I have exited...
(when (string= "jfcl" (system-name))
  (setq desktop-restore-frames nil))       ; I don't want frames restored on jfcl
(setq desktop-restore-eager 12)         ; be lazier for quicker startup
(desktop-save-mode 1) ; startup emacs with previous state (files, buffers)
(save-place-mode 1)   ; come back to where we were in that file

(require 'midnight)
(midnight-mode 1)     ; clean up old buffers at midnight
;; some buffers should never be cleaned up
(dolist (buf '("*Calculator*" "*Calc Trail*" "*quick*" ".newsrc-dribble"))
  (add-to-list 'clean-buffer-list-kill-never-buffer-names buf))
(dolist (rex `(,(rx ".epub" eos) ,(rx bos "bbdb" eos)))
  (add-to-list 'clean-buffer-list-kill-never-regexps rex))
;; proced continuously updates its buffer htop-style in the backgground (I think?) and thus increases the load average
(add-to-list 'clean-buffer-list-kill-buffer-names "*Proced*")
;; CANDIDATES FOR DELETION
;; ^ \*diff-syn
;; *sent wide reply to
;; *sent mail to
;; *Org Help*
;; ^ *RNC Input<9>*
;; diff-mode leaves a million of these and they can be HUGE
(add-to-list 'clean-buffer-list-kill-regexps (rx bos " *diff-syntax:"))
;; TODO move to dot.gnus
(dolist (rex `(,(rx bos "*Group*" eos) ,(rx bos "*Summary ")))
  (add-to-list 'clean-buffer-list-kill-never-regexps rex))

;; windows and scrolling
(setq window-min-height 2)            ; small windows save real estate
(temp-buffer-resize-mode 1)           ; the greatest thing ever! or is it!?

(winner-mode 1)                       ; C-c <left> restores previous window config
;; add more felicitous bindings
(define-key winner-mode-map [(control c) (control left)] 'winner-undo)
(define-key winner-mode-map [(control c) (control right)] 'winner-redo)

(setq-default truncate-lines t)       ; good for tiling window managers
; but not in Elispy buffers that display long sexprs
(dolist (hook '(help-mode-hook ielm-mode-hook))
  (add-hook hook (lambda () (setq truncate-lines nil))))

(windmove-default-keybindings)        ; S-{left,right,up,down} switches windows

(global-set-key [(control {)]   'shrink-window-horizontally)
(global-set-key [(control })]   'enlarge-window-horizontally)
(global-set-key "\C-x\C-^"      'enlarge-window)
(global-set-key "\C-^"          'enlarge-window)
(defun kw-shrink-other-window ()
  "Minimize the other window."
  (interactive)
  (let ((win (selected-window)))
    (save-excursion
      (other-window 1)
      (shrink-window-if-larger-than-buffer)
      (select-window win))))
(global-set-key "\C-x+"         'kw-shrink-other-window)
(global-set-key "\M-\C-^"       'shrink-window)

(setq window-combination-resize t)      ;split windows proportionately

(use-package transpose-frame :defer t
  :commands
  (transpose-frame
   flip-frame
   flop-frame
   rotate-frame
   rotate-frame-clockwise
   rotate-frame-anticlockwise))

(with-demoted-errors "%s"
  (let ((key "C-x |"))
    (use-package hydra)
    (global-set-key
     (kbd key)
     (condition-case err
         (defhydra kw-transposing (:hint nil)
           "\n_t_, _|_: ⮳ transpose _v_: ↕ vert flip _h_: ↔ horiz flip _8_: ⟳ 180° _9_: ↷ 90° _0_: ↶ 90° "
           ("t" transpose-frame)
           ("|" transpose-frame)
           ("v" flip-frame)
           ("h" flop-frame)
           ("8" rotate-frame)
           ("9" rotate-frame-clockwise)
           ("0" rotate-frame-anticlockwise)
           ("q" nil "exit"))
       (error
        (message "warning: %s unbound: %S" key err)
        nil)))))

;; simulating my old buffer-stack-untracked settings
(setq switch-to-prev-buffer-skip
      (lambda (_win buf _bury)
        (member (buffer-name buf)
                '("*Pinentry*" "*Ediff Registry*" "*log-edit-files*"
                  "*Org Help*" "*Org PDF LaTeX Output*" "*Ibuffer*"
                  ".newsrc-dribble" "*caml-help*" "*Pp Eval Output*"))))
;; my old buffer stack bindings
(dolist (pair '(("C-S-k"        . previous-buffer)
                ("C-c <down>"   . previous-buffer)
                ("C-c C-<down>" . previous-buffer)
                ("<C-down>"     . previous-buffer)
                ("C-c <up>"     . next-buffer)
                ("C-c C-<up>"   . next-buffer)
                ("<C-up>"       . next-buffer)))
  (global-set-key (kbd (car pair)) (cdr pair)))

;;; buffer-stack
(ignore
 '(use-package buffer-stack
    :config
    (setq buffer-stack-show-position 'buffer-stack-show-position-buffers)
    (setq buffer-stack-untracked (remove "*Group*" buffer-stack-untracked))
    ;; I never want to switch to these buffers
    (dolist (b '("*Pinentry*" "*Ediff Registry*" "*log-edit-files*"
                 "*Org Help*" "*Org PDF LaTeX Output*"
                 ".newsrc-dribble" "*caml-help*" "*Pp Eval Output*"))
      (add-to-list 'buffer-stack-untracked b))
    :bind
    (("C-S-k" . buffer-stack-down)
     ("C-c <down>" . buffer-stack-down)
     ("C-c C-<down>" . buffer-stack-down)
     ("<C-down>"   . buffer-stack-down)
     ("C-c <up>"   . buffer-stack-up)
     ("C-c C-<up>"   . buffer-stack-up)
     ("<C-up>"     . buffer-stack-up))))

;; ibuffer: dired for buffers
(global-set-key (kbd "C-x C-b") 'ibuffer)
(with-eval-after-load 'ibuffer
  (define-key ibuffer-mode-map (kbd "/ d") 'ibuffer-filter-by-directory))
(defun kw-ibuffer-recent-buffer (old-ibuffer &rest arguments)
  "Open ibuffer with cursor pointed to most recent buffer name."
  (let ((recent-buffer-name (buffer-name)))
    (apply old-ibuffer arguments)
    (with-demoted-errors "FYI: %s"
      (ibuffer-jump-to-buffer recent-buffer-name))))
(advice-add #'ibuffer :around #'kw-ibuffer-recent-buffer)
(setq ibuffer-default-shrink-to-minimum-size t)

(global-set-key (kbd "C-x x k") #'kill-buffer)

(setq backup-by-copying-when-linked t)        ; make hard links stick

;; computers are fast now
(setq auto-save-interval 20 ; default: 300
      auto-save-timeout 30) ; default: 960
(setq auto-save-no-message t) ; I trust you
;; computers are big now
(setq large-file-warning-threshold 100000000) ; 100MB

(recentf-mode 1)                      ; keep track of recently opened files
(setq recentf-max-saved-items 100)
;; tramp file names cause completion to raise pointless errors if, say, the remote is down
(push (lambda (fn) (string-match tramp-file-name-regexp fn)) recentf-exclude)

;; horizontal scrolling
(global-set-key [(control <)]   'scroll-left)
(global-set-key [(control >)]   'scroll-right)

;; Single-line scrolling
(setq scroll-margin 0 scroll-conservatively 100000) ; make scrolling less jumpy

(defun scroll-down-line (arg)
  "Scroll text of selected window downward ARG lines; or one line if no ARG.
If ARG is omitted or nil, scroll downward by one line."
  (interactive "p")
  (scroll-up-line (if arg (- arg) -1)))

(global-set-key "\C-z"    #'scroll-up-line)
(global-set-key "\M-\C-z" #'scroll-down-line)

(global-set-key [(control meta })] 'kw-scroll-one-paragraph)
(global-set-key [(control meta {)] 'kw-scroll-one-paragraph-back)

(setq default-input-method "latin-1-postfix") ; default input method for C-\

(setq shell-prompt-pattern "^[^#$%>;\n]*[#$%>;] .*") ; my shell prompt is weird
(setq tramp-completion-use-auth-sources nil)         ; very interruptive with selectrum
(setq tramp-allow-unsafe-temporary-files t)          ; they're not really unsafe...

(add-hook 'grep-mode-hook (lambda () (setq truncate-lines t)))

(defun kw-keep-or-flush (func)
  (save-excursion
    (let ((inhibit-read-only t))
      (goto-char (point-min))
      (save-restriction
        (when (text-property-search-forward 'mouse-face)
          (narrow-to-region (point-at-bol) (point-max)))
        (funcall func nil nil nil t)))))

(add-hook 'grep-mode-hook
          (lambda ()
            (define-key grep-mode-map (kbd "f")
              (lambda (regexp &optional rstart rend interactive)
                (interactive (keep-lines-read-args "Flush lines containing match for regexp"))
                (kw-keep-or-flush #'flush-lines)))))
(add-hook 'grep-mode-hook
          (lambda ()
            (define-key grep-mode-map (kbd "k")
              (lambda (regexp &optional rstart rend interactive)
                (interactive (keep-lines-read-args "Keep lines containing match for regexp"))
                (kw-keep-or-flush #'keep-lines)))))

(with-eval-after-load 'grep
  (add-to-list 'grep-files-aliases '("m" . "GNUmakefile [Mm]akefile*"))
  (add-to-list 'grep-files-aliases '("db" . "*.db")))

(with-eval-after-load 'grep
  (grep-compute-defaults)
  (grep-apply-setting 'grep-command "grep --color -EinH --null -e ")
  (grep-apply-setting 'grep-template (replace-regexp-in-string "\\<grep\\>" "grep -E" grep-template))
  (grep-apply-setting 'grep-find-command "find . -type f -exec grep --color -EniH --null -e  \\{\\} +"))

(with-eval-after-load 'grep
  ;; the "..?*" in grep-files-aliases blows up (in the typical dir with no match) with system-shell "zsh"...
  ;; (N): zsh glob qualifier (zshexpn(1)) prevents .[!.]* from blowing up if there are no dot files
  (setf (alist-get "all" grep-files-aliases nil nil 'string-equal) "* .[!.]*(N)"))

;;; info bindings
(define-key 'help-command (kbd "C-i") 'info-display-manual)

(with-eval-after-load 'info
  (add-to-list 'Info-additional-directory-list (concat home-emacs "info"))
  (delete-dups Info-additional-directory-list) ; destructive
  (delete-dups Info-directory-list)
  (with-demoted-errors "%s"
    (info-rename-buffer-mode +1))
  (add-hook 'Info-selection-hook 'info-colors-fontify-node))

(dolist (pair '((Man-mode-hook . Man-mode-map) (Info-mode-hook . Info-mode-map)))
  (add-hook (car pair)
            `(lambda ()
               (define-key ,(cdr pair) "[" #'kw-scroll-one-paragraph-back)
               (define-key ,(cdr pair) "]" #'kw-scroll-one-paragraph))))

(add-hook 'Man-mode-hook #'goto-address-mode)

;; incremental search
(setq isearch-allow-scroll t)           ; scroll while searching
(setq search-default-mode 'char-fold-to-regexp) ; cafe = café

(add-hook 'occur-mode-hook 'hl-line-mode)

;; completion
(setq completion-styles '(partial-completion substring flex))
(setq read-file-name-completion-ignore-case t)
(setq read-buffer-completion-ignore-case t)
(with-demoted-errors "%S"
  (selectrum-mode +1)
  (selectrum-prescient-mode +1)
  (prescient-persist-mode +1)
  (marginalia-mode +1))
(setq selectrum-show-indices t)
;; go to completions window; nice if selectrum's not available
(define-key minibuffer-local-map [?\M-C] #'switch-to-completions)
;; pointless with good completion, and can erase useful messages
(setq extended-command-suggest-shorter nil)

(global-set-key "\M-/" 'hippie-expand)
;; I want longer expansions (and especially try-expand-list) to come later
(setq hippie-expand-try-functions-list
      '(try-expand-all-abbrevs
        try-expand-dabbrev
        try-expand-dabbrev-all-buffers
        try-expand-dabbrev-from-kill
        try-complete-lisp-symbol-partially
        try-complete-lisp-symbol
        try-expand-line
        try-expand-list
        try-complete-file-name-partially
        try-complete-file-name))

;;; printing
(setq
 lpr-command "lpr"
 printer-name ""                        ;cups lpr blows up with any other value
 lpr-add-switches nil
 lpr-switches '("-U" "kdw1" "-o" "sides=two-sided-long-edge")
 ps-print-color-p t)
(defvar kw-print-command
  (format "%s %s" lpr-command (mapconcat 'identity lpr-switches " "))
  "*Preferred command to print a file, duplex.")
;; I run emacs with "reverse video"; if color-printing, the colors come out
;; unreadable on white paper; this advice flips to "normal video"
;; while printing...
(mapc
 (lambda (func) (advice-add func :around #'kw-with-print-colors))
 '(ps-print-buffer-with-faces
   ps-print-region-with-faces
   ps-spool-buffer-with-faces
   ps-spool-region-with-faces))

(defun kw-with-print-colors (f &rest args)
  "Evaluate (apply F ARGS) after switching the frame colors to \"normal video\", i.e.
black on white.  The original frame colors are guaranteed to be
restored after F returns.  This is typically used when generating
printed output from a colorized emacs buffer."
  (let ((fg (frame-parameter nil 'foreground-color))
        (bg (frame-parameter nil 'background-color)))
    (unwind-protect
        (progn
          (set-foreground-color "black")
          (set-background-color "white")
          (apply f args))
      (set-foreground-color fg)
      (set-background-color bg))))
(defun kw-print-buffer-by-file (&optional simplex)
  "Print the current buffer's file duplex by default; an argument means simplex.
This function assumes that your printer can handle this buffer's
file type.  The command used is constructed from `lpr-command'
and `lpr-switches'.  Duplex switches assume CUPS."
  (interactive "P")
  (let ((fn (buffer-file-name)))
    (unless fn (error "No file associated with %S" (current-buffer)))
    (apply
     `(call-process
       ,lpr-command nil nil nil
       ,@lpr-switches ,@(if (not simplex) '("-o" "sides=two-sided-long-edge")) ,fn))))

(with-demoted-errors "%s"
  (let ((key "<print>"))
    (require 'hydra)
    (global-set-key
     (kbd key)
     (condition-case err
         (defhydra printing-menu (:color blue :hint nil)
           "
^File^         ^Buffer^             ^Region^           ^Screenshot^
^^^^^^-----------------------------------------------------------------
_d_: duplex    _b_: colorized       _r_: colorized     _w_: window
_s_: simplex   _B_: no colors       _R_: no colors     _n_: window, no modeline
^ ^            ^ ^                  _f_: frame
"
           ("d" kw-print-buffer-by-file)
           ("s" (lambda () (interactive) (kw-print-buffer-by-file 1)))
           ("b" ps-print-buffer-with-faces)
           ("B" ps-print-buffer)
           ("r" ps-print-region-with-faces)
           ("R" ps-print-region)
           ("w" emacsshot-snap-window)
           ("n" emacsshot-snap-window-exclude-modeline)
           ("f" emacsshot-snap-frame)
           ("q" nil "cancel"))
       (error
        (message "warning: %s unbound: %S" key err)
        nil)))))

;; yes I really want to run that 2nd process
(setq async-shell-command-buffer 'new-buffer)
;; async buffer is just blank 99% of the time...
(setq async-shell-command-display-buffer nil)

(dolist (hook '(shell-mode-hook eshell-mode-hook))
  (add-hook hook #'goto-address-mode))
;; TODO bind <tab> to a function that uses completion-at-point if we're at a prompt,
;;      and kw-goto-address-next-link if not
(with-eval-after-load 'shell
  (dolist (key (list (kbd "C-c j") (kbd "<backtab>")))
    (define-key shell-mode-map key #'kw-goto-previous-address)))
;; eshell does weird things with eshell-mode-map!
;; (with-eval-after-load 'eshell
;;   (dolist (key (list (kbd "C-c j") (kbd "<backtab>")))
;;     (define-key eshell-mode-map key #'kw-goto-previous-address)))

;;; shell-mode
(add-hook 'shell-mode-hook
          (lambda ()
            (local-set-key (kbd "C-c C-o") #'kw-comint-delete-output)
            (setq comint-input-ring-file-name "~/.zsh_history")
            (comint-read-input-ring t)
            (setq-local comint-output-filter-functions
                        '(comint-truncate-buffer
                          ansi-color-process-output
                          comint-postoutput-scroll-to-bottom
                          comint-watch-for-password-prompt))
            (setq-local comint-process-echoes t)))

(add-to-list 'comint-preoutput-filter-functions #'kw-comint-chunkify t)

;; shell-mode completion
(add-hook 'shell-mode-hook
          (lambda ()
            (when (and (executable-find "fish")
                       (require 'fish-completion nil t))
              (fish-completion-mode +1)
              (when (and (executable-find "bash")
                         (require 'bash-completion nil t))
                (setq fish-completion-fallback-on-bash-p t)))))

(setq comint-buffer-maximum-size 65336)

(global-set-key (kbd "C-x C-d") 'dired) ; replaces list-directory
(with-eval-after-load 'dired
  (load "dired-x"))
(add-hook 'dired-mode-hook 'turn-on-gnus-dired-mode) ; TODO move me to dot.gnus
(add-hook 'dired-mode-hook 'hl-line-mode)
;; (add-hook 'dired-mode-hook                           ; ^ shouldn't create a new buffer
;;           (define-key dired-mode-map (kbd "^")
;;             (lambda ()
;;               "Go up in the same buffer."
;;               (find-alternate-file ".."))))
(setq dired-listing-switches "-alh") ; I know what dot files are, and like human-readable file sizes
(setq dired-dwim-target t)          ; suggest other visible dired buffer
(put 'dired-find-alternate-file 'disabled nil) ; enable this very useful command
(setq wdired-allow-to-change-permissions t)
(setq dired-guess-shell-alist-user
      `((,(rx ".pdf" eos)
         ,kw-pdf-viewer
         ,(mapconcat #'identity (cons lpr-command lpr-switches) " "))
        (,(rx ".doc" (? "x") eos) "libreoffice")))
(setq find-ls-option '("-exec ls -ldh {} +" . "-ldh"))
(if (member "FreeBSD" (ignore-errors (process-lines "uname" "-s")))
    (setq find-grep-options "-qsE")
  (when (member "Linux" (ignore-errors (process-lines "uname" "-s")))
    (setq find-grep-options "-qE")))
;; code below stolen from dired-diff
(defun kw-dired-ediff (file)
  "Compare file at point with FILE using `ediff-files'.
If called interactively, prompt for FILE.
If the mark is active in Transient Mark mode, use the file at the mark
as the default for FILE.  (That's the mark set by \\[set-mark-command],
not by Dired's \\[dired-mark] command.)
If the file at point has a backup file, use that as the default FILE.
If the file at point is a backup file, use its original, if that exists
and can be found.  Note that customizations of `backup-directory-alist'
and `make-backup-file-name-function' change where this function searches
for the backup file, and affect its ability to find the original of a
backup file.

FILE is the first argument given to the `diff' function.  The file at
point is the second argument given to `diff'."
  (interactive
   (progn
     (require 'dired-aux)
     (let* ((current (dired-get-filename t))
          ;; Get the latest existing backup file or its original.
          (oldf (if (backup-file-name-p current)
                    (file-name-sans-versions current)
                  (diff-latest-backup-file current)))
          ;; Get the file at the mark.
          (file-at-mark (if (and transient-mark-mode mark-active)
                            (save-excursion (goto-char (mark t))
                                            (dired-get-filename t t))))
          (separate-dir (and oldf
                             (not (equal (file-name-directory oldf)
                                         (dired-current-directory)))))
          (default-file (or file-at-mark
                            ;; If the file with which to compare
                            ;; doesn't exist, or we cannot intuit it,
                            ;; we forget that name and don't show it
                            ;; as the default, as an indication to the
                            ;; user that she should type the file
                            ;; name.
                            (and (if (and oldf (file-readable-p oldf)) oldf)
                                 (if separate-dir
                                     oldf
                                   (file-name-nondirectory oldf)))))
          ;; Use it as default if it's not the same as the current file,
          ;; and the target dir is current or there is a default file.
          (default (if (and (not (equal default-file current))
                            (or (equal (dired-dwim-target-directory)
                                       (dired-current-directory))
                                default-file))
                       default-file))
          (target-dir (if default
                          (if separate-dir
                              (file-name-directory default)
                            (dired-current-directory))
                        (dired-dwim-target-directory)))
          (defaults (dired-dwim-target-defaults (list current) target-dir)))
     (list
      (minibuffer-with-setup-hook
          (lambda ()
            (set (make-local-variable 'minibuffer-default-add-function) nil)
            (setq minibuffer-default defaults))
        (read-file-name
         (format "Diff %s with%s: " current
                 (if default (format " (default %s)" default) ""))
         target-dir default t))))))
  (let ((current (dired-get-filename t)))
    (when (or (equal (expand-file-name file)
                     (expand-file-name current))
              (and (file-directory-p file)
                   (equal (expand-file-name current file)
                          (expand-file-name current))))
      (error "Attempt to compare the file to itself"))
    (if (and (backup-file-name-p current)
             (equal file (file-name-sans-versions current)))
        (ediff-files current file)
      (ediff-files file current))))
(defun kw-dired-mark-backups ()
  "Mark all backup files (files ending with ~) for use in later commands. [KW]"
  (interactive)
  (dired-mark-files-regexp "~\\'"))
(eval-after-load 'dired
  '(progn
     (define-key dired-mode-map (kbd "C-M-f") #'dired-next-subdir)
     (define-key dired-mode-map (kbd "C-M-b") #'dired-prev-subdir)
     (define-key dired-mode-map "*~" #'kw-dired-mark-backups)
     (define-key dired-mode-map "="  #'kw-dired-ediff)))
(with-demoted-errors "%s" (diredfl-global-mode +1)) ;more color

(with-eval-after-load 'image-dired
  (defun kw-dired-thumbs-jump ()
    "Jump to the file corresponding to this thumbnail in a `dired' buffer."
    (interactive)
    (dired-other-window (file-name-directory (image-dired-original-file-name))))
  (define-key image-dired-thumbnail-mode-map "j" #'kw-dired-thumbs-jump))

(setq proced-auto-update-flag t proced-auto-update-interval 2)

(show-paren-mode 1)                     ; more noticeable
(mapc (lambda (binding) (define-key global-map binding 'insert-pair))
      ;; note that M-' steals abbrev-prefix-mark, but I don't use abbrevs
      `(,(kbd "M-'") ,(kbd "M-\"") ,(kbd "M-[") ))

(define-key kw-handy-keymap (kbd "f")   ; browse-url-firefox
  (lambda ()
    "Browse url at point in firefox."
    (interactive)
    (let ((url (thing-at-point-url-at-point)))
      (if url (browse-url-firefox url) (browse-url-firefox (read-string "URL: "))))))
(defalias 'find-url 'browse-url-emacs)
;; url
(setq url-cookie-untrusted-urls '(".*")) ; cookies: generally a bad idea
;; browse-url
(setq browse-url-browser-function #'eww-browse-url) ; default: eww
(setq browse-url-secondary-browser-function 'browse-url-firefox)
;; shr
(setq shr-image-animate nil)            ; animated gifs too slow / annoying
(setq shr-use-fonts nil)                ; no proportional fonts please!
(setq shr-width 84)                     ; shr's fill-column, effectively
(setq shr-use-colors nil)               ; no background colors
;; eww
(with-eval-after-load 'eww
  (add-to-list 'clean-buffer-list-kill-never-regexps "^\\*eww")
  (defun kw-eww-copy-link-url ()
    "Make the url at point the newest entry in the kill ring."
    (interactive)
    (let ((url (get-text-property (point) 'shr-url)))
      (message "%s" url)
      (kill-new url)))
  (defun eww-tag-body (cont)
    "KW: implementation of eww's own `eww-tag-body' but without setting foreground
and background-color."                  ;
    (shr-generic cont))
  (add-hook 'eww-mode-hook
            (lambda ()
              (define-key eww-mode-map "k" #'kw-maybe-kill-buffer)
              (define-key eww-mode-map [(backtab)] #'shr-previous-link)
              (define-key eww-mode-map "[" #'kw-scroll-one-paragraph-back)
              (define-key eww-mode-map "]" #'kw-scroll-one-paragraph)
              (define-key eww-mode-map "}" #'forward-paragraph)
              (define-key eww-mode-map "{" #'backward-paragraph)
              (define-key eww-mode-map "y" #'kw-eww-copy-link-url)))
  (add-hook 'eww-after-render-hook
            (lambda ()
              (when (string-match "^https?://news.ansible.uk/" (eww-current-url))
                (let ((msg "Fixing Ansible bullets...") buffer-read-only)
                  (message msg)
                  (save-excursion
                    (goto-char (point-min))
                    (while (search-forward "•" nil t)
                      (delete-char -1)
                      (insert "•")))
                  (message (format "%s done." msg)))))))

(setq remember-handler-functions '(remember-append-to-file))
(setq remember-data-file (expand-file-name "~/notes/remember/Inbox.org"))
(setq remember-notes-initial-major-mode 'org-mode)
(setq remember-leader-text "* ")

(put 'org-toggle-comment 'disabled t)
(setq org-replace-disputed-keys t)
(setq org-M-RET-may-split-line nil)
(setq org-special-ctrl-a/e 'reversed)
(setq org-refile-targets
      '((org-agenda-files :level . 1)
        (nil :level . 1)))
(add-hook 'org-mode-hook 'org-indent-mode)
(add-hook 'org-mode-hook
          (lambda ()
            (with-demoted-errors "Ignoring: %S"
              (flyspell-mode 1))
            (setq indicate-empty-lines t
                  tab-always-indent t
                  show-trailing-whitespace t
                  org-src-fontify-natively t
                  org-catch-invisible-edits 'smart
                  org-hide-emphasis-markers t)))

(with-eval-after-load 'org
  ;; for my fixed-pitch font
  (setq org-emphasis-alist (cons '("/" underline) org-emphasis-alist))
  ;; easy templates
  (require 'org-tempo)
  (add-to-list 'org-structure-template-alist
               '("se" . "src emacs-lisp"))
  (add-to-list 'org-structure-template-alist
               '("so" . "src ocaml"))
  (org-babel-do-load-languages
   'org-babel-load-languages
   '((emacs-lisp . t)
     (shell . t)
     (org . t)
     (ditaa . t)
     (ocaml . t)
     (gnuplot . t)
     (R . t))))

;; the agenda
(setq org-agenda-restore-windows-after-quit t)
(defvar kw-agenda-files-dir "~/notes/remember/")
(defun kw-buffer-is-rememberp (buf)
  "Is this buffer one of my \"remember\" buffers?
I.e. contained in the directory `kw-agenda-files-dir'?"
  (let ((fn (buffer-file-name (get-buffer buf)))
        (dir (file-name-as-directory (expand-file-name kw-agenda-files-dir))))
    (and fn (string-match-p (rx bos (literal dir) any) fn))))
(when (file-exists-p (file-name-as-directory  kw-agenda-files-dir))
  (setq org-agenda-files `(,(file-name-as-directory  kw-agenda-files-dir))))
(setq org-agenda-include-diary t)
(setq org-agenda-custom-commands
      '(("b" todo "BUY")
        ("B" todo-tree "BUY")))
;; when adding a new appt with org-capture, arrange for notifications
(add-hook 'org-capture-after-finalize-hook #'org-agenda-to-appt)
;; run when starting Emacs and everyday at 12:05am
(org-agenda-to-appt)
(run-at-time "12:05am" (* 24 3600) #'org-agenda-to-appt)

;; global org commands and org additions to non-org variables
(global-set-key (kbd "C-c a") #'org-agenda)
(global-set-key (kbd "C-c l") #'org-store-link)
;; org leaves these files behind if you use dot, gnuplot, or ditaa src blocks
(with-eval-after-load 'dired
  (setq dired-garbage-files-regexp
        (concat dired-garbage-files-regexp "\\|" (rx bos (or "gnuplot-" "babel-" "dot-" "ditaa-")))))
(dolist (ext '(".ilg" ".ind"))          ; add some latex extensions
  (add-to-list 'completion-ignored-extensions ext))

;; publishing

;; tufte-handout class for writing classy handouts and papers
;; select with #+LaTeX_CLASS: tuftehandout
(with-eval-after-load 'ox-latex
  (add-to-list 'org-latex-classes
               '("tuftehandout"
                 "\\documentclass{tufte-handout}
                \\usepackage{color}
                \\usepackage{amssymb}
                \\usepackage{amsmath}
                \\usepackage{gensymb}"
                 ("\\section{%s}" . "\\section*{%s}")
                 ("\\subsection{%s}" . "\\subsection*{%s}")
                 ("\\paragraph{%s}" . "\\paragraph*{%s}")
                 ("\\subparagraph{%s}" . "\\subparagraph*{%s}")))
  ;; select with #+LaTeX_CLASS: tuftehandout
  (add-to-list 'org-latex-classes
               '("tuftebook"
                 "\\documentclass{tufte-book}\n
                \\usepackage{color}
                \\usepackage{amssymb}
                \\usepackage{gensymb}
                \\usepackage{nicefrac}
                \\usepackage{units}"
                 ("\\section{%s}" . "\\section*{%s}")
                 ("\\subsection{%s}" . "\\subsection*{%s}")
                 ("\\paragraph{%s}" . "\\paragraph*{%s}")
                 ("\\subparagraph{%s}" . "\\subparagraph*{%s}"))))

(setq-default major-mode
              (lambda ()
                (unless buffer-file-name
                  (let ((buffer-file-name (buffer-name)))
                    (set-auto-mode)))))

(setq vc-handled-backends '(RCS Git Hg)) ; speeds thing up, especially with tramp

(defun kw-hg-addremove ()
  "Do hg addremove -v in `default-directory'.
If `major-mode' is `vc-dir-mode', revert the buffer."
  (interactive)
  (call-process "hg" nil nil nil "addremove" "-v")
  (when (derived-mode-p 'vc-dir-mode)
    (revert-buffer)))
(with-eval-after-load 'vc-dir
  (define-key vc-dir-mode-map "a" #'kw-hg-addremove))

(defun kw-vc-log-view-push-pull ()
  "Do a `vc-push' or `vc-pull', as appropriate."
  (interactive)
  (cond
   ((equal (buffer-name) "*vc-incoming*")
    (if (eq 0 (call-process "make" nil nil nil "-n" "pull"))
        (compile "make pull")
      (vc-pull '(4))))
   ((equal (buffer-name) "*vc-outgoing*")
    (if (eq 0 (call-process "make" nil nil nil "-n" "push"))
        (compile "make push")
      (vc-push '(4))))
   (t (user-error "yikes"))))
(with-eval-after-load 'vc-hg
  (define-key vc-hg-log-view-mode-map (kbd "C-c C-c") #'kw-vc-log-view-push-pull))

(with-eval-after-load 'vc-dir
  (define-key vc-dir-mode-map (kbd "k") 'kw-kill-buffer-and-window))

(setq-default indent-tabs-mode nil)     ; make tabs insert spaces by default
(add-hook 'prog-mode-hook 'yafolding-mode)
(add-hook 'prog-mode-hook 'goto-address-prog-mode)
(add-hook 'prog-mode-hook
          (lambda ()
            (setq indicate-empty-lines t
                  show-trailing-whitespace t)))

;; eudc aka ldap
(customize-set-variable 'eudc-server "ldaps://ldap.uchicago.edu")
(setq eudc-server-hotlist `((,eudc-server . ldap)))
(customize-set-variable 'eudc-default-return-attributes
                        '(displayname ucdepartment unit title uid mail mailLocalAddress gecos))
(customize-set-variable 'eudc-query-form-attributes '(name firstname mailLocalAddress uid))
(customize-set-variable 'ldap-host-parameters-alist
                        '(("ldaps://ldap.uchicago.edu"
                           base "dc=uchicago,dc=edu"
                           binddn "uid=dldcservice,ou=people,dc=uchicago,dc=edu"
                           auth-source t)))
(with-eval-after-load 'eudc
  (eudc-set-server eudc-server 'ldap t)
  (add-to-list 'eudc-user-attribute-names-alist
               '(mailLocalAddress . "E-Mail")))
(defalias 'ldap 'eudc-query-form)

(with-eval-after-load 'eudcb-ldap
  (defun eudc-bob-make-button (label keymap &optional menu plist)
    "Create a button with LABEL.
Attach KEYMAP, MENU and properties from PLIST to a new overlay covering
LABEL.  BUGFIX by KW."
    (let (overlay
          (p (point))
          prop val)
      (insert (or label "NONE"))
      (put-text-property p (point) 'face 'bold)
      (setq overlay (make-overlay p (point)))
      (overlay-put overlay 'mouse-face 'highlight)
      (overlay-put overlay 'keymap keymap)
      (overlay-put overlay 'local-map keymap)
      (overlay-put overlay 'menu menu)
      (while plist
        (setq prop (car plist)
              plist (cdr plist)
              val (car plist)
              plist (cdr plist))
        (overlay-put overlay prop val)))))

;; DLDC web publishing
(when (string= "jfcl" (system-name))
    (with-demoted-errors "%S"
      (load-file "/data/web/dldc/local/CONFIG/init.el")))

(setq spelling-bee-dictionary-file
      (expand-file-name "~/docs/word-lists/twl06.txt"))

(setq fortune-dir "/usr/share/fortune/")
(setq fortune-always-compile nil)
(with-eval-after-load 'fortune
  (defun kw-switch-fortune-file (&rest ign)
    (unless current-prefix-arg
      (setq fortune-file
            (car
             ;; this dumb sort is standing in for a choose-random-list-element function
             (sort
              ;; fortune-mod's compiled files end in .dat...
              (directory-files fortune-dir t (rx bos (+ (not ?.)) eos))
              (lambda (_x _y) (= 1 (random 2))))))))
  ;; switch fortune file before every fortune, unless prefix arg
  (dolist (func '(fortune fortune-message))
    (advice-add func :before #'kw-switch-fortune-file)))

(with-eval-after-load 'tetris
  (define-key tetris-mode-map (kbd "<end>")
    (lambda ()
      "TBIC."
      (interactive)
      (let ((inhibit-message t))
        (tetris-pause-game))
      (let ((buffer (current-buffer)))
        (delete-windows-on buffer)
        (bury-buffer buffer)))))

(use-package pacman :defer t
  :commands (pacman-mode pacman-Q pacman-Qi pacman-Ql pacman-Qo
                         pacman-Qs pacman-Si pacman-Ss))

(add-hook 'pacman-after-Syu-hook
          (lambda ()
            (call-process "setxkbmap" nil nil nil
                          "-option" "altwin:prtsc_rwin")
            (call-process "setxkbmap" nil nil nil
                          "-layout" "us" "-option" "ctrl:nocaps")
            (message "Restored X key mappings.")))

(defvar cocktail-sources
      (mapcar (lambda (it) (expand-file-name it "~/notes/cocktails/"))
              '("cocktails.db" "vintage.db" "baker.db")))
(defvar cocktail-history-source (expand-file-name "~/.cocktailcalc/history"))
(defvar cocktail-default-servings 2)
(add-hook 'cocktail-list-mode-hook #'hl-line-mode)
(add-hook 'cocktail-history-mode-hook #'hl-line-mode)

;; load skeletor skeletons
(ignore-errors
  (load-file (expand-file-name "~/emacs/project-skeletons/init.el")))

(use-package tuareg
  :defer t
  :bind (:map tuareg-mode-map
              ("M-q"   . fill-paragraph)
              ("M-RET" . tuareg-interactive-send-input-end-of-phrase)
              ("C-c >" . kw-tuareg-align->)
              ("C-c :" . kw-tuareg-align-:)
              ("C-c A" . kw-tuareg-assert-false)))

;; my major mode for Chord files (lead sheets)
(use-package chord-mode :defer t
  :init
  (add-to-list 'auto-mode-alist
               (cons (format "%slyrics/" abbreviated-home-dir) 'chord-mode)))

;; major mode for editing CSV files
(use-package csv-mode :defer t
  :init (add-to-list 'auto-mode-alist '("\\.[Cc][Ss][Vv]\\'" . csv-mode)))

;; visible scrollbar replacement
(use-package sml-modeline
  :config (sml-modeline-mode 1))

;; the late lamented enhancement to Emacs pdf file handling (it still
;; works but Arch Linux's bleeding edge pdf libraries have
;; outdistanced this Emacs package...
(use-package pdf-tools :defer t
  :config
  (pdf-tools-install t nil t)
  (setq pdf-view-mode-hook
        (lambda ()
          (with-demoted-errors "Ignoring: %S"
            (pdf-tools-enable-minor-modes)))))

;; minor mode for composing MIME articles; not sure if I still use this!
(use-package mml :defer t
  :config
  (defadvice mml-preview (after kw-mml-preview-advice)
    "Make mml-preview go full-screen."
    (delete-other-windows))
  (ad-activate 'mml-preview))

(use-package compile :defer t
  :config
  (add-to-list 'compilation-error-regexp-alist ; for refertool
               '("^%\\w+ +\\([^:\n]+\\):\\([0-9]+\\)" 1 2) t)
  (add-to-list 'compilation-error-regexp-alist    ;for qtest
               '("^Error: .*>\\(.*\\):\\([0-9]+\\)" 1 2)))

(use-package grep :defer t
  :config
  ;; from: refertool annotate -e
  ;; must append due to emacs bug or refertool annotate -e error!
  (add-to-list 'grep-regexp-alist '("^%\\w+ +\\([^:\n]+\\):\\([0-9]+\\)" 1 2) t))

;; google-translate
(use-package google-translate :defer t
  :config (require 'google-translate-smooth-ui))

  ;;; google-this
(use-package google-this
  :bind (("C-c /"   . google-this-mode-submap)
         :map google-this-mode-submap
         ("C-c / t" . google-translate-smooth-translate)
         ("C-c / /" . google-this)))

;;; page-break-lines
(use-package page-break-lines
  :init (global-page-break-lines-mode)
  :config (mapc (apply-partially 'add-to-list 'page-break-lines-modes)
                '(text-mode org-mode tuareg-mode)))

;;; Nov-mode: read .epub files
(use-package nov :defer t
  :config
  (setq nov-text-width 84 nov-variable-pitch nil)
  (bind-keys :map nov-mode-map ("[" . kw-scroll-one-paragraph-back))
  (bind-keys :map nov-mode-map ("]" . kw-scroll-one-paragraph))
  :mode ("\\.epub\\'" . nov-mode))

;; can't load hyperbole without figuring out how to turn some of its
;; global key bindings off
;; (use-package hyperbole :bind (("C-=" . hui-select-thing)))

(use-package refer-mode :defer t
  :init
  (add-to-list 'auto-mode-alist '("\\.db\\'" . refer-mode))
  (add-hook 'refer-browse-mode-hook #'hl-line-mode)
  (add-hook 'refer-mode-hook #'goto-address-mode))

  ;;; docket
(use-package docket :defer t
  :init
  (dolist (mode '(prog-mode-hook org-mode-hook LilyPond-mode-hook))
    (add-hook mode #'docket-highlight-mode)))

;; quick
(use-package quick :defer t
  :bind (("<f12> q" . 'quick))
  :config
  (require 'midnight)
  (add-to-list 'clean-buffer-list-kill-never-buffer-names quick-buffer-name))

;; windsize
(use-package windsize
  :config (windsize-default-keybindings))

;; BBDB
(use-package bbdb :defer t
  :init (setq bbdb-file "~/emacs/bbdb")
  :config
  (setq bbdb-default-area-code 773
        bbdb-default-country "USA"
        bbdb/mail-auto-create-p nil
        bbdb-use-pop-up nil
        bbdb-completion-display-record nil
        bbdb-completion-list '(aka fl-name lf-name mail)
        bbdb-always-add-addresses 'never
        bbdb-quiet-about-name-mismatches 0 ;was t
        bbdb-complete-name-allow-cycling t
        bbdb-offer-save nil)
  (bbdb-initialize 'gnus 'message)
  (bbdb-insinuate-gnus)
  :bind (:map bbdb-mode-map
              ("z" . quit-window)))

(use-package ocp-index :defer t
  :commands ocp-index-mode)

(use-package projectile
  :bind-keymap
  ("C-x p" . projectile-command-map)
  :config (setq projectile-completion-system 'default)
  (projectile-mode +1))

;; lilypond
(let ((debug-on-error nil))
  (with-demoted-errors "%S"
    (load-library "lilypond-init")
    (add-hook 'LilyPond-mode-hook
              (lambda ()
                (with-demoted-errors "%S"
                  (setf (cadr (assoc "LilyPond" LilyPond-command-alist))
                        ;; the pkill is kind of extreme, but what does it hurt to reload any running llpp?
                        '(LilyPond-lilypond-command " %s && pkill -HUP llpp")))))))

(use-package acme :defer t
  :bind (("C-1" . acme-button-1)
         ("C-2" . acme-button-2)
         ("C-3" . acme-button-3)
         ("C-S-t" . acme-tag-jump-to-tag)))

(use-package move-text :defer t
  :bind (("M-<up>" . move-text-up)
         ("M-<down>" . move-text-down)))

;; fielded-mode
(use-package fielded :defer t
  :mode ("\\`/etc/\\(?:group-?\\|passwd-?\\|shadow-?\\)\\'" . fielded-mode))

;; nxml-mode
;; TODO do I still want to use nxml instead of html mode or web mode?
;; C-c C-c will view the html in eww
(use-package nxml-mode :defer t
  :init
  (mapc (lambda (ext) (add-to-list 'auto-mode-alist (cons ext 'nxml-mode)))
        '("\\.xml$" "\\.html$" "\\.htm$" "\\.xhtml$" "\\.inc$" "\\.gema$" "\\.dgema$"))
  (setq nxml-sexp-element-flag t)               ;sexp commands move over entire elements
  (add-hook 'nxml-mode-hook 'yafolding-mode)
  :config
  (bind-keys :map nxml-mode-map ("C-c C-c" . (lambda () (interactive) (eww-open-file (buffer-file-name))))))

(use-package chess :defer t
  :config (setq chess-default-display 'chess-ics1))

(use-package empc :defer t
  :init (add-hook 'empc-mode-hook 'hl-line-mode))

(use-package dictionary :defer t
  :bind (("<f12> d" . 'dictionary-search)
         (:map dictionary-mode-map
               ( "[" . kw-scroll-one-paragraph-back)
               ( "]" . kw-scroll-one-paragraph))))

(use-package man :defer t
  :init (setq Man-width 82))

(use-package synosaurus
  :config (define-key kw-handy-keymap (kbd "s") synosaurus-command-map)
  :init
  (setq synosaurus-backend 'synosaurus-backend-wordnet)
  (setq synosaurus-choose-method 'ido))

(use-package flycheck :defer t
  :init
  (setq flycheck-standard-error-navigation nil) ; flycheck too aggressively takes over next-error!
  (setq flycheck-emacs-lisp-initialize-packages nil))

(use-package elfeed :defer t
  :init
  (setq elfeed-search-filter "@6-months-ago +unread ")
  (add-hook 'elfeed-show-mode-hook #'hl-line-mode)
  (add-hook 'elfeed-show-mode-hook
            (lambda ()
              (setq-local shr-max-image-proportion 0.4)))
  (add-hook 'elfeed-show-mode-hook
            (lambda ()
              (save-match-data
                (save-excursion
                  (goto-char (point-min))
                  (when (re-search-forward "^Title:.*" nil t)
                    (let ((inhibit-read-only t))
                      (add-face-text-property (match-beginning 0) (match-end 0) '(:height 1.4))))))))
  (add-to-list 'clean-buffer-list-kill-never-buffer-names "*elfeed-entry*")
  :config
  (put 'elfeed-add-feed 'disabled t) ; i'm maintaining my feeds manually
  (load-file (concat (file-name-as-directory elfeed-db-directory) "kw-feeds.el"))
  (bind-keys :map elfeed-show-mode-map ("[" . kw-scroll-one-paragraph-back))
  (bind-keys :map elfeed-show-mode-map ("]" . kw-scroll-one-paragraph))
  (bind-keys :map elfeed-show-mode-map ("{" . backward-paragraph))
  (bind-keys :map elfeed-show-mode-map ("}" . forward-paragraph))
  (bind-keys :map elfeed-show-mode-map
             ("q" .
              (lambda ()
                "Switch to *elfeed-search* buffer."
                (interactive)
                (switch-to-buffer "*elfeed-search*"))))
  (bind-keys :map elfeed-search-mode-map ("q" . elfeed-db-unload))
  (bind-keys :map elfeed-search-mode-map ("d" . elfeed-search-untag-all-unread))
  (bind-keys :map elfeed-search-mode-map ("SPC" . elfeed-search-show-entry)))

;; lorem-ipsum
(dolist (fn '(Lorem-ipsum-insert-sentences Lorem-ipsum-insert-paragraphs))
  (autoload fn "lorem-ipsum" nil t)
  (defalias (intern (downcase (symbol-name fn))) fn))