mirror of
https://github.com/pestctrl/emacs-config.git
synced 2026-02-16 08:14:15 +00:00
30 KiB
30 KiB
- misc emacs settings
- exwm
- keybindings
- theme
- buffer navigation
- window manipulation
- dired
- emacs lisp
- w3m
- ibuffer
- useful tools
misc emacs settings
(setq backup-directory-alist `(("." . ,(concat user-emacs-directory "backups"))))
;; Don't fricken suspend emacs
(when (eq #'suspend-frame
(key-binding (kbd "C-z")))
(global-set-key (kbd "C-z") nil))
;; Minibuffer reading
(setq switch-window-input-style 'minibuffer)
;; Help window select stuff
(setq help-window-select t)
;; Undo tree is useful
(use-package undo-tree)
(global-undo-tree-mode t)
;; Beacon-mode
;; (use-package beacon)
;; (beacon-mode 1)
;; (setq beacon-blink-delay 0.1)
;; (setq beacon-color "#006400")
;; Use my fork of chinese-etzy
(load-file "~/.emacs.d/my-etzy.el")
;; If I ever decide to turn on display-lines-mode, use relative line
;; numbering
(setq display-line-numbers-type 'relative)
;; Make sure shell and rgrep works in windows
(when (eq 'windows-nt system-type)
(setq-default explicit-shell-file-name "bash")
(setq shell-file-name "bash"))
;; Show the column number!
(column-number-mode t)exwm
;; This will be the hardest to write :/
(use-package exwm
:config
(use-package exwm-x)
;; Editting with Emacs in X-windows
(use-package exwm-edit
:init
(setq exwm-edit-bind-default-keys nil)
:config
(exwm-global-set-key (kbd "s-e") #'exwm-edit--compose))
;; System tray
(require 'exwm-systemtray)
(exwm-systemtray-enable)
;; Multi monitor support
(require 'exwm-randr)
(exwm-enable)
(exwm-randr-enable)
;; This is a new-frame hack. Don't copy faces for floating windows
(require 'face-copier)
(unless (eq 'hash-table (type-of face-new-frame-defaults))
(def-face-copier1 my/frame-dont-copy-faces (sym)
(let ((name (symbol-name sym)))
(string-match-p "^doom-.*" name))
mode-line
mode-line-inactive
variable-pitch
diredp-file-suffix
font-lock-type-face)
(defun my/exwm-floating--advise-make-frame (orig id)
(override1-face my/frame-dont-copy-faces
(funcall orig id)))
(advice-add #'exwm-floating--set-floating
:around
#'my/exwm-floating--advise-make-frame)
(def-face-copier x-show-tip-faces (sym)
nil
tooltip)
(defun dont-copy-faces-for-x-show-tip (orig &rest args)
(override1-face x-show-tip-faces
(apply orig args)))
(advice-add #'x-show-tip
:around
#'dont-copy-faces-for-x-show-tip))
;; Actually launch programs
(require 'exwm-launch-program)
(define-key *root-map* (kbd "C-p") #'launch-program)
;; Volume control
(unless my/at-ti
(use-package volume
:bind (:map *root-map*
("v" . #'volume))))
;; Shut down
(add-hook 'exwm-exit-hook 'org-save-all-org-buffers)
;; Startup programs
(add-hook 'exwm-init-hook 'server-start)
;; Reminder: Hooks execute in order. Make sure megasync launches after systemtray is enabled
(require 'exwm-startup)
(add-hook 'exwm-init-hook 'call-startup-programs)
(require 'exwm-screens)
(add-hook 'exwm-init-hook 'my/setup-screens)
(require 'exwm-systemtray)
(exwm-systemtray-enable)
;; This lets me do rapid emacs iteration
(defun ignore-emacs ()
(when (and exwm-class-name (string= exwm-class-name "Emacs"))
(call-interactively #'exwm-input-release-keyboard)))
(add-hook 'exwm-manage-finish-hook
#'ignore-emacs))keybindings
(defun lock-screen ()
(interactive)
(shell-command "~/Github/my-projects/i3lock-fancy/i3lock-fancy & disown"))
(exwm-global-set-key (kbd "s-r") #'exwm-reset)
(require 'keyboard-toggle)
(exwm-global-set-key (kbd "s-a") #'my/toggle-keyboard)
(setq exwm-input-simulation-keys
'(;; movement
([?\C-b] . left)
([?\M-b] . C-left)
([?\C-f] . right)
([?\M-f] . C-right)
([?\C-p] . up)
([?\C-n] . down)
([?\C-a] . home)
([?\C-e] . end)
([?\M-v] . prior)
([?\C-v] . next)
([?\C-d] . delete)
([?\M-d] . backspace)
([?\C-k] . (S-end delete))
;; cut/paste.
([?\C-w] . ?\C-x)
([?\M-w] . ?\C-c)
([?\C-y] . ?\C-v)
;; search
([?\C-s] . ?\C-f)
([?\C-.] . ?\C-w)
([?\C-/] . ?\C-z)
([?\M-s] . ?\C-s)))theme
;; dashboard looks cool
(use-package dashboard)
(setq fancy-splash-image "~/.emacs.d/res/icon.png")
;; Disable tool and menu bar, keep the fringe though
(tool-bar-mode -1)
(menu-bar-mode -1)
(scroll-bar-mode -1)
(fringe-mode '(10 . 10))
;; I like the general feel of calm forest, but...
(use-package color-theme-modern)
(load-theme 'calm-forest t)
;; I don't like the shade of green for the foreground and the shade of
;; gray for the background. This overrides those
(add-to-list 'custom-theme-load-path "~/.emacs.d/lisp/themes")
(load-theme 'dark-default)
(load-theme 'same-defaults)
;; Need to configure all-the-icons so that mode-line doesn't look fat
;; and ugly
(use-package all-the-icons)
(set-face-attribute 'mode-line nil :height 100)
(set-face-attribute 'mode-line-inactive nil :height 100)
(setq all-the-icons-scale-factor 1.0)
;; The most efficient cool looking modeline I've
;; found. Faster than even smart-mode-line
(use-package doom-modeline)
(setq doom-modeline-height 24)
(doom-modeline-mode)
;; Modeline display useful information
(display-battery-mode t)
(display-time-mode t)
(setq display-time-day-and-date t)
(unless (or (eq 'windows-nt system-type)
(not (executable-find "df")))
(require 'display-hard-drive-space-mode)
(display-hard-drive-space-mode))
;;(set-face-attribute 'variable-pitch nil :font '(:family "ETBookOT"))
;; I like my unicode to be monospace too, so I use these
(set-fontset-font t 'unicode (font-spec :size 10 :name "FontAwesome"))
(set-fontset-font t 'unicode (font-spec :name "SourceCodePro"))
;; (set-fontset-font t 'unicode (font-spec :size 15 :name "DejaVu Sans Mono"))
;; (set-fontset-font t 'japanese-jisx0208 (font-spec :size 10 :name "HanaMinA.ttf"))
;; (set-fontset-font t 'korean-ksc5601 (font-spec :size 18 :name "Baekmuk Gulim"))
;; (set-fontset-font t '(9472 . 9472) (font-spec :size 15 :name "DejaVu Sans Mono"))
(defun my/reading-color ()
(interactive)
(variable-pitch-mode)
(face-remap-add-relative 'default :foreground "white smoke"))
(add-hook 'Man-mode-hook
#'my/reading-color)
(add-hook 'w3m-mode-hook
#'my/reading-color)
;; (custom-set-faces
;; '(default ((t (:family "ETBookOT" :foundry "QUQA"
;; :slant normal :weight normal :height 120
;; :width normal :spacing 90)))))buffer navigation
;; Allow minibuffer-ception
(setq enable-recursive-minibuffers t)
;; I like ido for finding files
(require 'ido)
(global-set-key (kbd "C-x C-f") #'ido-find-file)
(ido-mode t)
;; But I've grown occustomed to ivy for M-x
(use-package ivy)
(use-package counsel)
(ivy-mode t)
;; This lets counsel-M-x keep history
(use-package smex)
;; These commands don't need a carrot(^) at the beginning, usually I
;; don't need a starting string when doing these
(add-to-list 'ivy-initial-inputs-alist '(org-refile . ""))
(add-to-list 'ivy-initial-inputs-alist '(org-agenda-refile . ""))
(add-to-list 'ivy-initial-inputs-alist '(org-capture-refile . ""))
(add-to-list 'ivy-initial-inputs-alist '(counsel-M-x . ""))
(global-set-key (kbd "M-x") 'counsel-M-x)
(global-set-key (kbd "C-x b") 'ivy-switch-buffer)
(global-set-key (kbd "C-c C-r") 'ivy-resume)
(define-key ivy-minibuffer-map (kbd "<return>") 'ivy-alt-done)
(define-key ivy-minibuffer-map (kbd "C-<return>") 'ivy-done)
;; Scrollkeeper is helpful for scrolling up and down
(use-package scrollkeeper)
(global-set-key (kbd "C-v") 'scrollkeeper-down)
(global-set-key (kbd "M-v") 'scrollkeeper-up)
;; Word navigation
(global-set-key (kbd "M-f") 'forward-to-word)
(global-set-key (kbd "M-F") 'forward-word)
;; Goto-char
(require 'brumlow-goto-char)
(global-set-key (kbd "M-m") #'jump-to-char)window manipulation
;; The prefix
(define-prefix-command '*window-map*)
(define-key *root-map* (kbd "w") '*window-map*)
;; Side-window stuff
(use-package resize-window)
(require 'side-window-split)
(define-key *window-map* (kbd "j") 'side-bottom-window)
(define-key *window-map* (kbd "h") 'side-left-window)
(define-key *window-map* (kbd "l") 'side-right-window)
(define-key *window-map* (kbd "d") 'window-toggle-side-windows)
(define-key *window-map* (kbd "r") 'resize-window)
;; Dedicated window
(defun my/toggle-dedicated-window ()
(interactive)
(let ((win (selected-window)))
(set-window-dedicated-p win (not (window-dedicated-p win)))))dired
;; I like dired+'s formatting for listing files
(add-to-list 'load-path
"~/.emacs.d/submodule/dired-plus")
(require 'dired+)
(setq dired-listing-switches "-al --group-directories-first --sort=extension")
(setq diredp-hide-details-initially-flag nil)
(setq diredp-hide-details-propagate-flag nil)
;; diredx lets me hide stuff I don't want to see
(require 'dired-x)
(add-hook 'dired-mode-hook (lambda () (dired-omit-mode)))
(setq dired-omit-files (concat dired-omit-files "\\|^\\..+$"))
;; Useful for traversing folders
(use-package dired-subtree)
(define-key dired-mode-map (kbd "<tab>") 'dired-subtree-insert)
(define-key dired-mode-map (kbd "<backtab>") 'dired-subtree-remove)emacs lisp
;; These are the programming facilities I like the most for a minimal
;; setup for emacs-lisp programming
;; Don't leave any whitespace on the end of lines in a file.
(use-package ws-butler)
(ws-butler-global-mode t)
;; Errors
(use-package flycheck)
(add-to-list 'display-buffer-alist
`(,(rx bos "*Flycheck errors*" eos)
(display-buffer-reuse-window
display-buffer-in-side-window)
(side . bottom)
(reusable-frames . visible)
(window-height . 0.10)))
;; Autocompletion
(use-package company)
(setq company-idle-delay 0.2)
(add-hook 'emacs-lisp-mode-hook 'company-mode)
(add-hook 'lisp-mode-hook 'company-mode)
;; Magit
(use-package magit)
(use-package magit-popup)
(use-package magit-todos)
(global-set-key (kbd "C-x g") 'magit-status)
(global-set-key (kbd "C-x M-g") 'magit-dispatch)
;; Push all branches
(defun my/magit-push-all ()
"Push all branches."
(interactive)
(magit-run-git-async "push" "-v"
(magit-read-remote "Remote")
"--all"))
(transient-append-suffix 'magit-push "m"
'("a" "all remotes" my/magit-push-all))
;; Magit uses ediff
(with-eval-after-load 'ediff
(setq ediff-window-setup-function 'ediff-setup-windows-plain)
(defun ediff-copy-both-to-C ()
(interactive)
(ediff-copy-diff ediff-current-difference nil 'C nil
(concat
(ediff-get-region-contents ediff-current-difference 'A ediff-control-buffer)
(ediff-get-region-contents ediff-current-difference 'B ediff-control-buffer))))
(defun add-d-to-ediff-mode-map () (define-key ediff-mode-map "d" 'ediff-copy-both-to-C))
(add-hook 'ediff-keymap-setup-hook 'add-d-to-ediff-mode-map)
(set-face-attribute 'ediff-even-diff-A nil :background "midnight blue")
(set-face-attribute 'ediff-even-diff-Ancestor nil :background "midnight blue")
(set-face-attribute 'ediff-even-diff-B nil :background "midnight blue")
(set-face-attribute 'ediff-even-diff-C nil :background "midnight blue")
(set-face-attribute 'ediff-odd-diff-A nil :background "midnight blue")
(set-face-attribute 'ediff-odd-diff-Ancestor nil :background "midnight blue")
(set-face-attribute 'ediff-odd-diff-B nil :background "midnight blue")
(set-face-attribute 'ediff-odd-diff-C nil :background "midnight blue")
;; (set-face-attribute 'ediff-odd-diff-A nil :background "gray30")
;; (set-face-attribute 'ediff-odd-diff-B nil :background "gray30")
;; (set-face-attribute 'ediff-even-diff-A nil :background "#5c370f")
;; (set-face-attribute 'ediff-even-diff-B nil :background "#5c370f")
;; ;; (set-face-attribute 'ediff-current-diff-A nil :background "")
;; (set-face-attribute 'ediff-current-diff-B nil :background "dark green")
)
;; Paredit
(use-package paredit
:bind (:map paredit-mode-map
("M-?" . nil))
:hook ((emacs-lisp-mode . paredit-mode)
(lisp-mode . paredit-mode)))
;; Paren highlighting
(show-paren-mode t)
;; Rainbow parens
(use-package rainbow-delimiters)
(add-hook 'prog-mode-hook #'rainbow-delimiters-mode)
;; Macroexpander
(use-package macrostep)
(define-key macrostep-keymap (kbd "C-c C-c") nil)
(define-key macrostep-keymap (kbd "DEL") nil)
(define-key macrostep-keymap (kbd "c") nil)
(define-key macrostep-keymap (kbd "u") nil)
(define-key macrostep-keymap (kbd "C-c q") #'macrostep-collapse)
(define-key macrostep-keymap (kbd "RET") nil)
(define-key macrostep-keymap (kbd "e") nil)
(define-key emacs-lisp-mode-map (kbd "C-c e") #'macrostep-expand)
(define-key macrostep-keymap (kbd "n") nil)
(define-key macrostep-keymap (kbd "C-c C-n") #'macrostep-next-macro)
(define-key macrostep-keymap (kbd "p") nil)
(define-key macrostep-keymap (kbd "C-c C-p") #'macrostep-prev-macro)
;; Auto highlighting of symbols
(use-package auto-highlight-symbol)
(add-hook 'prog-mode-hook
'auto-highlight-symbol-mode)
;; wgrep
(use-package wgrep)
;; Use cursors, sooo good
(use-package multiple-cursors)
(define-prefix-command '*multiple-cursors-map*)
(define-key *multiple-cursors-map* (kbd "a") 'mc/mark-all-like-this)
(define-key *multiple-cursors-map* (kbd "A") 'mc/vertical-align)
(define-key *multiple-cursors-map* (kbd "SPC") 'mc/vertical-align-with-space)
(define-key *multiple-cursors-map* (kbd "n") 'mc/insert-numbers)
(defhydra mc-interactive (*multiple-cursors-map* "i")
"For those looping commands"
("n" mc/mark-next-like-this)
("p" mc/mark-previous-like-this)
("s" mc/skip-to-next-like-this)
("S" mc/skip-to-previous-like-this)
("q" nil))
(global-set-key (kbd "C-c m") '*multiple-cursors-map*)
;; Space and tab configuration
(setq default-tab-width 4)
(setq-default indent-tabs-mode nil)
(setq-default tab-width 4)
;; If I have to switch to viewing tabs
(defun my/TABS (num)
(interactive "p")
(setq tab-width (if (= num 1)
8
num)))
;; Eval buffer, slime-ism
(define-key emacs-lisp-mode-map (kbd "C-c C-k") #'eval-buffer)
;; Make scratch buffers out of nowhere!
(defun scratch-buffer ()
(interactive)
(let ((count 0))
(while (get-buffer (format "*scratch%d*" count))
(incf count))
(switch-to-buffer (get-buffer-create (format "*scratch%d*" count)))
(lisp-interaction-mode)
(insert (substitute-command-keys initial-scratch-message))))
;; Eval and replace
(defun my/eval-and-replace ()
"Replace the preceding sexp with its value."
(interactive)
(backward-kill-sexp)
(condition-case nil
(prin1 (eval (read (current-kill 0)))
(current-buffer))
(error (message "Invalid expression")
(insert (current-kill 0)))))
(define-key emacs-lisp-mode-map (kbd "C-c C-e") 'my/eval-and-replace)
;; Use cider's eval expression
(use-package cider)
(autoload 'cider--make-result-overlay "cider-overlays")
(defun endless/eval-overlay (value point)
(cider--make-result-overlay (format "%S" value)
:where point
:duration 'command)
value)
(advice-add 'eval-region :around
(lambda (f beg end &rest r)
(endless/eval-overlay
(apply f beg end r)
end)))
(advice-add 'eval-last-sexp :filter-return
(lambda (r)
(endless/eval-overlay r (point))))
(advice-add 'eval-defun :filter-return
(lambda (r)
(endless/eval-overlay
r
(save-excursion
(end-of-defun)
(point)))))
;; expand-region
(use-package expand-region
:commands er/expand-region
:bind (("M-E" . #'er/expand-region)))
;; Banner comments
(unless my/at-ti
(use-package banner-comment
:commands banner-comment
:bind (("C-c h" . #'banner-comment))))
(add-hook 'lisp-mode-hook
(lambda () (setq comment-start ";; ")))
(add-hook 'emacs-lisp-mode-hook
(lambda () (setq comment-start ";; ")))
;; re-builder
(require 're-builder)
(setq reb-re-syntax 'rx)w3m
;; Remove when Emacs 27 releases
(when (executable-find "w3m")
(setq w3m-use-tabs nil)
(use-package w3m)
(defun dired-browse-with-w3m (arg)
(interactive "P")
(let ((browse-url-browser-function (if arg
(symbol-function browse-url-browser-function)
#'w3m-browse-url)))
(browse-url-of-dired-file)))
(define-key dired-mode-map (kbd "W") 'dired-browse-with-w3m)
(global-set-key (kbd "C-c g")
(lambda ()
(interactive)
(w3m-goto-url "https://google.com"))))ibuffer
(global-set-key (kbd "C-x C-b") 'ibuffer)
(setq ibuffer-show-empty-filter-groups nil)
(add-hook 'ibuffer-mode-hook
'(lambda ()
(ibuffer-switch-to-saved-filter-groups "default")
(ibuffer-do-sort-by-alphabetic)
;; (ibuffer-auto-mode)
))
(require 'ibuf-ext)
(define-key ibuffer-mode-map my/keymap-key nil)
(eval-after-load "ibuf-ext"
'(define-ibuffer-filter directory-name
"Filter files in the agenda folder"
(:description "agenda")
(and (buffer-file-name buf)
(string-match qualifier
(buffer-file-name buf)))))
(add-to-list 'ibuffer-never-show-predicates
'(lambda (buf)
(with-current-buffer buf
(eq major-mode 'helm-major-mode))))
(setq ibuffer-saved-filter-groups
'(("default"
("X-Windows" (mode . exwm-mode))
("Terminals" (or (mode . vterm-mode)
(mode . term-mode)))
("emacs-config" (not (or (mode . magit-status-mode)
(not (or (filename . ".emacs.d")
(filename . "emacs-config"))))))
("code-aux" (or (mode . slime-repl-mode)
(mode . slime-mode)
(mode . magit-status-mode)
(mode . ein:notebooklist-mode)
(mode . cider-repl-mode)
(mode . comint-mode)
(mode . makefile-gmake-mode)
(mode . conf-space-mode)
(mode . sh-mode)))
("code" (or (mode . perl-mode)
(mode . asm-mode)
(mode . php-mode)
(mode . clojure-mode)
(mode . csharp-mode)
(mode . c++-mode)
(mode . c-mode)
(mode . scala-mode)
(mode . emacs-lisp-mode)
(mode . java-mode)
(mode . js-mode)
(mode . python-mode)
(mode . ng2-ts-mode)
(mode . lisp-mode)
(mode . ein:notebook-multilang-mode)))
("web" (or (mode . web-mode)
(mode . mhtml-mode)
(mode . js2-mode)
(mode . css-mode)))
("Org Mode" (not or (not mode . org-mode)
(directory-name . "agenda")))
("text" (filename . "\\.txt"))
("pdfs" (or (mode . doc-view-mode)
(mode . pdf-view-mode)))
("Agenda Buffers" (mode . org-agenda-mode))
("Agenda Files" (mode . org-mode))
("folders" (mode . dired-mode))
("Help" (or (name . "\*Help\*")
(name . "\*Apropos\*")
(name . "\*info\*"))))))
(defun ibuffer-find-file-with-ido ()
"Like `find-file', but default to the directory of the buffer at point."
(interactive)
(let ((completing-read-function #'ido-completing-read)
(default-directory (let ((buf (ibuffer-current-buffer)))
(if (buffer-live-p buf)
(with-current-buffer buf
default-directory)
default-directory))))
(call-interactively #'ido-find-file)))
(define-key ibuffer-mode-map (kbd "C-x C-f") #'ibuffer-find-file-with-ido)useful tools
org-mode
(require 'org)
(setq org-src-window-setup 'current-window)
(setq org-use-speed-commands t)Indent look
(setq org-startup-indented t)
(defun my/org-indent-prefixes ()
"Compute prefix strings for regular text and headlines."
(setq org-indent--heading-line-prefixes
(make-vector org-indent--deepest-level nil))
(setq org-indent--inlinetask-line-prefixes
(make-vector org-indent--deepest-level nil))
(setq org-indent--text-line-prefixes
(make-vector org-indent--deepest-level nil))
(dotimes (n org-indent--deepest-level)
(let ((indentation (if (<= n 1) 0
(* (1- org-indent-indentation-per-level)
(1- n)))))
;; Headlines line prefixes.
(let ((heading-prefix ""))
(aset org-indent--heading-line-prefixes
n
(org-add-props heading-prefix nil 'face 'org-indent))
;; Inline tasks line prefixes
(aset org-indent--inlinetask-line-prefixes
n
(cond ((<= n 1) "")
((bound-and-true-p org-inlinetask-show-first-star)
(concat org-indent-inlinetask-first-star
(substring heading-prefix 1)))
(t (org-add-props heading-prefix nil 'face 'org-indent)))))
;; Text line prefixes.
(aset org-indent--text-line-prefixes
n
(org-add-props
(concat (make-string (if (< n 2) n
(1+ indentation)) ?\s)
(and (> n 0)
(char-to-string org-indent-boundary-char)))
nil 'face 'org-indent)))))
(advice-add #'org-indent--compute-prefixes
:override
#'my/org-indent-prefixes)terminal
(if (eq system-type 'windows-nt)
(define-key *root-map* "c" #'shell)
(use-package vterm
:commands vterm find-vterm vterm-kill
:bind (:map *root-map*
("c" . #'find-vterm))
:config
(setq ansi-color-names-vector
["black" "red3" "green3" "yellow3" "DodgerBlue2" "magenta3" "cyan3" "gray90"])
(set-face-attribute 'term-bold nil :weight 'bold)
(set-face-attribute 'vterm-color-blue nil :foreground "DodgerBlue2")
(define-key vterm-mode-map my/keymap-key nil)
(if (<= 27 emacs-major-version)
(defun find-vterm ()
(interactive)
(let* ((current-tab (alist-get 'name (tab-bar--current-tab)))
(term-name (concat current-tab "-term")))
(if-let (b (get-buffer term-name))
(switch-to-buffer b)
(vterm)
(rename-buffer term-name))))
(defun find-vterm ()
(interactive)
(if-let (b (get-buffer "vterm"))
(switch-to-buffer b)
(vterm))))
(add-hook 'vterm-exit-functions
(lambda (buf com)
(kill-buffer buf)))
(defun rename-vterm-with-tab (orig name &optional arg)
(let ((current-tab-name (alist-get 'name (tab-bar--current-tab))))
(funcall orig name arg)
(when-let (b (get-buffer (concat current-tab-name "-term")))
(with-current-buffer b
(rename-buffer (concat (alist-get 'name (tab-bar--current-tab))
"-term"))))))
(advice-add #'tab-bar-rename-tab
:around
#'rename-vterm-with-tab)
(defun close-vterm-with-tab (orig)
(let ((current-tab-name (alist-get 'name (tab-bar--current-tab))))
(when (funcall orig)
(when-let (b (get-buffer (concat current-tab-name "-term")))
(with-current-buffer b
(vterm-send-C-d))))))
(advice-add #'close-tab-switch
:around
#'close-vterm-with-tab)))posting source code
(use-package webpaste)
(setq webpaste-paste-confirmation t)
(setq webpaste-provider-priority '("ix.io"))wgrep
Query replace rx
(defun my/query-replace-rx (&rest _)
"Call `query-replace-regexp', reading regexp in `rx' syntax.
Automatically wraps in parens and adds `seq' to the beginning of
the form."
(interactive)
(cl-letf (((symbol-function #'query-replace-read-from) (lambda (&rest _)
(--> (read-string "rx form: ")
(concat "'(seq " it ")")
(read it)
(cadr it)
(rx-to-string it)))))
(call-interactively #'query-replace-regexp)))helm info is pretty slick
(use-package helm)
(require 'helm-info)
(defun helm-info-emacs-stuff ()
"Helm for Emacs, Elisp, and
CL-library info pages."
(interactive)
(helm :sources
'(helm-source-info-emacs helm-source-info-elisp helm-source-info-cl)))
(global-set-key (kbd "C-c C-h") #'helm-info-emacs-stuff)helpful
(use-package helpful)
(global-set-key (kbd "C-h f") #'helpful-function)
(global-set-key (kbd "C-h v") #'helpful-variable)
(global-set-key (kbd "C-h k") #'helpful-key)
(global-set-key (kbd "C-h o") #'helpful-symbol)Ace jump
(use-package ace-jump-mode
:bind (("C-c j" . 'ace-jump-line-mode)
:map *root-map*
("SPC" . 'ace-jump-mode)))olivetti
(use-package olivetti
:commands olivetti-mode
:config
(setq-default olivetti-body-width 140))Change themes on the spot
(require 'light-default-theme)
(require 'dark-default-theme)
(use-package modus-operandi-theme)
(defvar current-theme 'dark)
(defvar light-theme 'modus-operandi)
(defvar dark-theme 'calm-forest)
(defun switch-themes ()
(interactive)
(setq current-theme (if (eq current-theme 'dark) 'light 'dark))
(disable-theme 'same-defaults)
(pcase current-theme
('light
(disable-theme 'dark-default)
(disable-theme dark-theme)
(enable-theme light-theme)
(enable-theme 'light-default))
('dark
(disable-theme 'light-default)
(disable-theme light-theme)
(enable-theme dark-theme)
(enable-theme 'dark-default)))
(enable-theme 'same-defaults)
(set-background-mode current-theme))
(defun reload-theme ()
(interactive)
(disable-theme 'same-defaults)
(pcase current-theme
('light
(disable-theme 'light-default)
(disable-theme light-theme)
(enable-theme light-theme)
(enable-theme 'light-default))
('dark
(disable-theme 'dark-default)
(disable-theme dark-theme)
(enable-theme dark-theme)
(enable-theme 'dark-default)))
(enable-theme 'same-defaults)
(set-background-mode current-theme))
(defun disable-all-theming ()
(interactive)
(disable-theme 'light-default)
(disable-theme light-theme)
(disable-theme 'dark-default)
(disable-theme dark-theme)
(disable-theme 'same-defaults)
(set-background-mode 'light)
(setq default-theme 'light))
(ec/load-or-ask-pred 'my/light-default "Use light-theme? ")
(defun update-frame-background-mode ()
(mapc 'frame-set-background-mode (frame-list)))
(defun set-background-mode (mode)
(setf frame-background-mode mode)
(update-frame-background-mode))
;; Executable
(when my/light-default
(switch-themes))