#+title: emacs init file #+author: Jacopo De Simoi #+email: jacopods@math.utoronto.ca #+options: *:t ::t * TODO Make indentation uniform * TODO Look at tangling at [http://thewanderingcoder.com/2015/02/literate-emacs-configuration/] although I'd rather do something like a local variable evaluation such as # -*- eval: (add-hook 'before-save-hook icalendar-export-to-ics nil t) -*- Or makefile approach [https://emacs.stackexchange.com/questions/27126/is-it-possible-to-org-bable-tangle-an-org-file-from-the-command-line] See also [http://orgmode.org/manual/Extracting-source-code.html#Extracting-source-code] * Introduction ** ~setq~ vs ~setq-default~ Some variables are buffer-local, others are not; for non buffer-local variables the two commands are equivalent; for the buffer-local variables, setq acts on the current buffer, whereas setq-default sets the default value of the variable for buffers that do not have a local value. :source: [https://stackoverflow.com/a/18173666] ** Why not ~package.el~ it is convenient, but it is not git-based; ~borg.el~ is promising, but it is way complicated; I can do everything by hand as soon as it is neatly ~org~-anized. In the end we use a few, but I plan to phase them out and replace them with git submodules * Files and dirs Move ~Customize~ to a separate file #+begin_src emacs-lisp (setq custom-file "~/.emacs.d/custom.el") (load custom-file 'noerror) #+end_src Add relevant dirs to load path [This is somewhat undesirable; I should uniformize the path-loading business at some point…] #+begin_src emacs-lisp (let ((default-directory "~/.emacs.d/")) (normal-top-level-add-subdirs-to-load-path) (normal-top-level-add-to-load-path '("biblio.el" "fringe-helper.el" "multiple-cursors.el" "expand-region.el" "dash.el" "webpaste.el" "highlight-parentheses.el"))) #+end_src Put autosave files (ie #foo#) and backup files (ie foo~) in ~/.emacs.d/. create the autosave dir if necessary, since emacs won't. #+begin_src emacs-lisp (make-directory "~/.emacs.d/autosaves/" t) (make-directory "~/.emacs.d/backup/" t) #+end_src * Themes Use (my clone of) the solarized theme #+begin_src emacs-lisp (add-to-list 'custom-theme-load-path "/home/jacopods/.emacs.d/emacs-color-theme-solarized") (load-theme 'lunarized t) #+end_src Use patched terminus font (this overrides the settings in Customize, but I never could it to work otherwise). See the special treatment later on for dealing with bold weight. To avoid flickering one should also set the font in .Xresources #+begin_src emacs-lisp (set-face-font 'default "-xos4-hackminus-medium-r-normal--20-200-72-72-c-100-ISO10646-1") (set-face-font 'fixed-pitch "-xos4-hackminus-medium-r-normal--20-200-72-72-c-100-ISO10646-1") (set-face-font 'fixed-pitch-serif "-xos4-hackminus-medium-r-normal--20-200-72-72-c-100-ISO10646-1") (set-face-font 'variable-pitch "-xos4-hackminus-medium-r-normal--20-200-72-72-c-100-ISO10646-1") #+end_src * Global settings ** Global helper functions This is a helper function used to set several global keys given in provided as a parameter in ~binding-alist~ #+begin_src emacs-lisp (defun global-set-key-alist (binding-alist) "This function iterates over the binding-alist, which should be an alist of key and binding and sets each binding in the global-key-map" (dolist (binding binding-alist) (global-set-key (kbd (car binding)) (cdr binding)))) (defun define-key-alist (keymap binding-alist) "This function iterates over the binding-alist, which should be an alist of key and binding and sets each binding in the global-key-map" (dolist (binding binding-alist) (define-key keymap (kbd (car binding)) (cdr binding)))) #+end_src This is a hack to remove slant and bold from all faces #+begin_src emacs-lisp (defun wilder/fixup-faces () (mapc (lambda (face) (set-face-attribute face nil :weight 'normal) (set-face-attribute face nil :slant 'normal)) (face-list)) (set-face-font 'default "-xos4-hackminus-medium-r-normal--20-200-72-72-c-100-ISO10646-1")) #+end_src ** Cosmetics Prefer a minimal appearance: no menu, toolbar or scroll-bars; no splash screens or messages #+begin_src emacs-lisp (menu-bar-mode -1) (tool-bar-mode 0) (scroll-bar-mode -1) (setq inhibit-startup-screen t inhibit-startup-message t) #+end_src a blinking cursor keeps the gpu awake; add global hl-line mode to more easily spot the cursor #+begin_src emacs-lisp (blink-cursor-mode 0) (set-default 'cursor-type 'box) #+end_src Set frame title #+begin_src emacs-lisp (setq frame-title-format '((buffer-file-name "%f" (dired-directory dired-directory "%b")) " · emacs"));; · " (:eval (kde-current-activity-name)))) ;; "%S")) #+end_src Themed tooltips #+begin_src emacs-lisp (setq x-gtk-use-system-tooltips nil) #+end_src Set =fill-column= to 72, which happens to be good for third-tiled frames and it also is a reasonable standard #+begin_src emacs-lisp (setq default-fill-column 72) #+end_src Highlight sexp (apparently I am not even using this) #+begin_src emacs-lisp ;(require 'highlight-sexps) #+end_src Try to get along with large margins #+begin_src emacs-lisp (setq-default left-margin-width 3 right-margin-width 3) (fringe-mode 10) ;(set-window-buffer nil (current-buffer)) #+end_src ** Mouseless Disable mouse interaction with emacs #+begin_src emacs-lisp (mouse-wheel-mode -1) (setq mouse-autoselect-window nil mouse-yank-at-point nil focus-follows-mouse nil mouse-highlight nil) #+end_src *** TODO Find out what of the above is necessary given the disable-mouse mode below Use the ~disable-mouse~ package by Steve Purcell available at [https://github.com/purcell/disable-mouse] #+begin_src emacs-lisp (require 'disable-mouse) (global-disable-mouse-mode) #+end_src ** Window behavior Prevent compilation window eating up other windows #+begin_src emacs-lisp (setq compilation-window-height 12 compilation-scroll-output nil) #+end_src Prevent any automatic splitting to split vertically #+begin_src emacs-lisp (setq split-height-threshold 0) #+end_src ** Scrolling Scrolling setup #+begin_src emacs-lisp (setq redisplay-dont-pause t scroll-margin 3 scroll-step 1 scroll-conservatively 10000 scroll-preserve-screen-position 1) #+end_src *** TODO find out what this was actually meant to do #+begin_src emacs-lisp (setq-default display-buffer-reuse-frames t) #+end_src ** Mode-line #+begin_src emacs-lisp (setq-default mode-line-modified '(:eval (if (buffer-modified-p) "●" "·")) ;Still needs some improvements, does not report Readonly state mode-line-remote '(:eval (let ((s (format-mode-line "%@"))) (cond ((equal s "-") " ") ((equal s "@") "@") (t s))))) (defface mode-line-indicator '((t nil)) "mode-line active indicator" :group 'mode-line-faces) (defface mode-line-inactive-indicator '((t nil)) "Inactive variant of indicator" :group 'mode-line-faces) ;; This has some issues when two buffers are shown in different windows ;; There are some solutions but let us see if this works first (defun mode-line-update-face (window) "Update the `mode-line' face in WINDOW to indicate whether the window is selected." (with-current-buffer (window-buffer window) (if (eq (current-buffer) (window-buffer (selected-window))) (face-remap-reset-base 'mode-line-indicator) (face-remap-set-base 'mode-line-indicator (face-all-attributes 'mode-line-inactive-indicator))))) (add-hook 'buffer-list-update-hook (lambda () (walk-windows #'mode-line-update-face nil t))) (defvar wilder-buffer-vc-mode-line '("%b" (vc-mode (:propertize ;; Strip the backend name from the VC status information (:eval (let* ((backend (downcase (symbol-name (vc-backend (buffer-file-name))))) (branch (substring vc-mode (+ (length backend) 2))) (s (substring vc-mode (+ (length backend) 1) (+ (length backend) 2))) (status (cond ((equal s "-") "") ((equal s ":") "!") (t s)))) (concat "·" branch status))) face magit-branch-local)))) (defvar wilder-position '("%p · %I" )) (put 'wilder-buffer-vc-mode-line 'risky-local-variable t) (put 'wilder-position 'risky-local-variable t) (defvar wilder/mode-line-modes (let ((recursive-edit-help-echo "Recursive edit, type C-M-c to get out")) (list (propertize "%[" 'help-echo recursive-edit-help-echo) '("" mode-name) '("" mode-line-process) " " '("" minor-mode-alist) (propertize "%n" 'help-echo "mouse-2: Remove narrowing from buffer" 'mouse-face 'mode-line-highlight 'local-map (make-mode-line-mouse-map 'mouse-2 #'mode-line-widen)) (propertize "%]" 'help-echo recursive-edit-help-echo) " ")) "Mode line construct for displaying major and minor modes.") (put 'wilder/mode-line-modes 'risky-local-variable t) (setq-default header-line-format nil);'("%e" ));wilder-buffer-vc-mode-line)) (setq mode-line-separator '(:eval (let* ((len-left (length (format-mode-line mode-line-format-left))) (len-right (length (format-mode-line mode-line-format-right))) (len-separator (- (+ (window-width) 2 2 2) (+ len-left len-right)))) (format (format "%%%ds" len-separator) "")))) (setq mode-line-format-left '("%e" mode-line-front-space mode-line-front-space mode-line-front-space ; mode-line-mule-info mode-line-modified mode-line-remote mode-line-frame-identification wilder-buffer-vc-mode-line "  " wilder-position)) (setq mode-line-format-right '((:propertize " " face mode-line-indicator) wilder/mode-line-modes mode-line-misc-info " ")) (put 'mode-line-format-left 'risky-local-variable t) (put 'mode-line-format-right 'risky-local-variable t) (put 'mode-line-separator 'risky-local-variable t) (setq-default mode-line-format '("%e" mode-line-format-left mode-line-separator mode-line-format-right)) #+end_src The following has been found in [[https://www.masteringemacs.org/article/hiding-replacing-modeline-strings][here]] to clean up the modeline #+begin_src emacs-lisp (defvar mode-line-cleaner-alist `((auto-complete-mode . " α") (yas/minor-mode . " υ") (paredit-mode . " π") (eldoc-mode . "") (abbrev-mode . "") (auto-fill-function . "") (disable-mouse-global-mode . "") (auto-revert-mode . "") (helm-mode . " η" ) (smart-tab-mode . "") (subword-mode . "") (outshine-mode . " o") (outline-minor-mode . "") (reftex-mode . "") (flyspell-mode . "") ;; Major modes (lisp-interaction-mode . "λ") (hi-lock-mode . "") (python-mode . "Py") (emacs-lisp-mode . "EL") (tex-mode . "χ") (latex-mode . "χ") (TeX-latex-mode . "χ") (org-mode . "Ω") (org-agenda-mode . "Ω:Agenda")) "Alist for `clean-mode-line'. When you add a new element to the alist, keep in mind that you must pass the correct minor/major mode symbol and a string you want to use in the modeline *in lieu of* the original.") (defun clean-mode-line () (interactive) (loop for cleaner in mode-line-cleaner-alist do (let* ((mode (car cleaner)) (mode-str (cdr cleaner)) (old-mode-str (cdr (assq mode minor-mode-alist)))) (when old-mode-str (setcar old-mode-str mode-str)) ;; major mode (when (eq mode major-mode) (setq mode-name mode-str))))) (add-hook 'after-change-major-mode-hook 'clean-mode-line) #+end_src ** Coding system Prefer the utf-8 coding system globally. This helps with the issue of magit not correctly staging hunks containing utf-8 characters. See [https://github.com/magit/magit/issues/32] #+begin_src emacs-lisp (prefer-coding-system 'utf-8) #+end_src ** Mark handling No transient mark is more flexible #+begin_src emacs-lisp (transient-mark-mode 0) #+end_src But of course we need to /see/ the mark #+begin_src emacs-lisp (require 'visible-mark) (visible-mark-mode t) (global-visible-mark-mode t) #+end_src The following are some convenient bindings; notice that on my layout F13 and F14 are obtained by tapping the left and right shift respectively #+begin_src emacs-lisp (defun jump-to-mark () "Jumps to the local mark, respecting the `mark-ring' order. This is the same as using \\[set-mark-command] with the prefix argument." (interactive) (set-mark-command 1)) (defun just-activate-mark () (interactive) (activate-mark)) (global-set-key-alist '(("" . set-mark-command) ("" . set-mark-command) ("" . jump-to-mark) ("" . jump-to-mark) ("" . just-activate-mark) ("" . just-activate-mark))) #+end_src ** Global bindings Remove some bindings that I find supremely annoying. Additionally, unbind the ~C-x o~ binding to force me using ~ace-window~ Finally, unbind the ~C-SPC~ to mark the point, as I am using LR-shift Note that I will use ~C-SPC~ as a hydra below to deal with parenthesis #+begin_src emacs-lisp (mapcar (lambda (ch) (global-unset-key (kbd ch))) '("C-z" "C-x f" "" "C-M-u" "C-M-d" "C-x o" "C-SPC")) #+end_src Change {up,down}-list #+begin_src emacs-lisp (global-set-key (kbd "C-M-i") 'down-list) ;; -i stands for /in/ (global-set-key (kbd "C-M-o") 'up-list) ;; -o stands for /out/ #+end_src Add some opinionated bindings #+begin_src emacs-lisp (global-set-key-alist '(("C-M-d" . kill-sexp) ("C-M-" . backward-kill-sexp) ("C-x k" . kill-this-buffer) ("C-S-v" . scroll-down-command) ("C-M-u" . universal-argument))) #+end_src ** Disable commands Enable narrow commands #+begin_src emacs-lisp (put 'narrow-to-region 'disabled nil) (put 'LaTeX-narrow-to-environment 'disabled nil) (put 'narrow-to-page 'disabled nil) #+end_src ** Smart beginning-of-line This is a relatively smart way to go back to the beginning of the line #+begin_src emacs-lisp (defun smart-line-beginning () "Move point to the beginning of text on the current line; if that is already the current position of point, then move it to the beginning of the line." (interactive) (let ((pt (point))) (beginning-of-line-text) (when (eq pt (point)) (beginning-of-line)))) (global-set-key (kbd "C-a") 'smart-line-beginning) #+end_src ** White-space Trailing whitespace is evil; get rid of it #+begin_src emacs-lisp (setq-default show-trailing-whitespace t) (add-hook 'before-save-hook 'delete-trailing-whitespace) #+end_src Define what is whitespace during a search #+begin_src emacs-lisp (setq search-whitespace-regexp "[ \t\r\n]+") #+end_src Tabs are evil; get rid of them #+begin_src emacs-lisp (setq c-basic-offset 4) (setq-default tab-width 4 indent-tabs-mode nil) #+end_src *** TODO Have a look at ws-trim.el It is conf'ble to avoid removing whitespace from lines that were not modified; sounds like a good idea for git [ftp://ftp.lysator.liu.se/pub/emacs/ws-trim.el] ** Show matching parens Use ~show-paren~ for paren-highlighting #+begin_src emacs-lisp (show-paren-mode 1) #+end_src *** TODO find out if there are better options out there ** Load hydra #+begin_src emacs-lisp (require 'hydra) #+end_src ** Abbrevs Set up abbrevs #+begin_src emacs-lisp (setq-default abbrev-mode t) (read-abbrev-file "~/.abbrev_defs") (setq save-abbrevs t) #+end_src ** Spellcheck Use flyspell #+begin_src emacs-lisp (require 'flyspell-lazy) (flyspell-lazy-mode 1) (add-hook 'text-mode-hook 'flyspell-mode) (setq flyspell-use-meta-tab nil) (defface flyspell-margin-incorrect '((t nil)) "flyspell-margin-incorrect" :group 'flyspell) (setq flyspell-before-incorrect-word-string (propertize "." 'display `((margin left-margin) ,(propertize "×" 'face 'flyspell-margin-incorrect)))) #+end_src ** Fringe treatment *** TODO try linum-relative #+begin_src emacs-lisp ; (require 'linum-relative) ; (linum-relative-mode 1) #+end_src Add line numbers globally #+begin_src emacs-lisp ; (global-linum-mode 1) #+end_src Highlight also the linum in the fringe #+begin_src emacs-lisp ; (require 'hlinum) ; (hlinum-activate) #+end_src Add marker for current line in the margin (see [https://github.com/kyanagi/fringe-current-line] and [https://github.com/nschum/fringe-helper.el] for inspiration) #+begin_src emacs-lisp (require 'margin-current-line) (global-margin-current-line-mode 1) #+end_src ** Turn on echo mode Display unfinished commands in the echo area after the specified delay. #+begin_src emacs-lisp (setq echo-keystrokes 0.10) #+end_src ** Disable completion buffer Remove the completion buffer as soon as we get out of the minibuffer #+begin_src emacs-lisp (add-hook 'minibuffer-exit-hook '(lambda () (let ((buffer "*Completions*")) (and (get-buffer buffer) (kill-buffer buffer))) )) #+end_src ** Auto save on compile #+begin_src emacs-lisp (setq compilation-ask-about-save nil) #+end_src ** Idle-kill #+begin_src emacs-lisp (defun kill-buffers-on-idle () "Kill buffers that have the appropriate property set." (save-excursion (save-window-excursion (dolist (b (buffer-list)) (when (and (with-current-buffer b (boundp 'buffer-close-on-idle)) (with-current-buffer b buffer-close-on-idle)) (with-current-buffer b (message "Killed %s" buffer-file-name)) (pop-to-buffer-same-window b) (kill-buffer)))))) (run-with-idle-timer 180 t 'kill-buffers-on-idle) #+end_src ** Calendar #+begin_src emacs-lisp (add-hook 'calendar-load-hook (lambda () (calendar-set-date-style 'european))) ;; first day of the week is monday instead of sunday: (setq calendar-week-start-day 1 calendar-location-name "Toronto, ON Canada" calendar-latitude 43.7 calendar-longitude -79.4) #+end_src ** Use local proxy I need this to route bibretrieve requests through my local proxy, that in turn routes requests to ~mathscinet~ through the University network #+begin_src emacs-lisp ;; Use system proxy (setq url-proxy-services '(("http" . "127.0.0.1:8118") ("https" . "127.0.0.1:8118"))) #+end_src ** Indicator Change cursor color to reflect different layers on the keyboard This is the handler #+begin_src emacs-lisp (defun xkbvleds-indicator-signal-handler (indicator on) (if on (cond ((string-equal indicator "Greek") (set-face-background 'cursor "#2aa198")) ((string-equal indicator "Math") (set-face-background 'cursor "#cb4b16"))) (set-face-background 'cursor "#919191"))) #+end_src Connect the signal from xkbvleds to the handler #+begin_src emacs-lisp (require 'dbus) ;; Register for the signal indicatorChanged coming from our service. It is ;; important that the =service= argument is =nil=, otherwise the registration ;; would stop once the process is respawned. (dbus-register-signal :session nil "/org/xkbvleds" "org.xkbvleds" "indicatorChanged" 'xkbvleds-indicator-signal-handler) #+end_src ** Tarmak-ready Set up all possible combinations of modifiers #+begin_src emacs-lisp (defun concat-recursive (b &optional a) (if b (append (concat-recursive (cdr b) (concat a (car b))) (concat-recursive (cdr b) a)) (when a (list a)))) (setq modifier-combo (concat-recursive '("C-" "M-" "s-" "H-"))) #+end_src Then list the swapped keys #+begin_src emacs-lisp (setq tarmak1-swaps '(("j" . "e") ("e" . "k") ("k" . "n") ("n" . "j"))) #+end_src ** Transmission #+begin_src emacs-lisp (require 'transmission) (setq transmission-host "192.168.0.40") #+end_src * Main major modes ** mu4e #+begin_src emacs-lisp (require 'smtpmail) (require 'mu4e) (global-set-key (kbd "C-c μ") 'mu4e) (setq mu4e-maildir "~/.mail" mu4e-attachment-dir "~/attachments" mu4e-html2text-command "w3m -dump -T text/html -cols 72 -o display_link_number=true -o auto_image=false -o display_image=false -o ignore_null_img_alt=true" mu4e-headers-show-threads nil mu4e-view-use-gnus t mm-text-html-renderer 'gnus-w3m) (setq mu4e-contexts `( ,(make-mu4e-context :name "Work" :enter-func (lambda () (mu4e-message "Switch to the Work context")) ;; no leave-func ;; we match based on the maildir of the message ;; this matches maildir /Arkham and its sub-directories :match-func (lambda (msg) (when msg (string-match-p "^/math" (mu4e-message-field msg :maildir)))) :vars '( ( user-mail-address . "jacopods@math.utoronto.ca" ) ( user-full-name . "Jacopo De Simoi" ) ( mu4e-sent-folder . "/math/Sent") ( mu4e-drafts-folder . "/math/Drafts") ( mu4e-trash-folder . "/math/Trash") ( mu4e-refile-folder . "/math/Archive") ( smtpmail-stream-type . starttls ) ( smtpmail-smtp-service . 9587 ) ( mu4e-compose-signature . (concat "Jacopo De Simoi \n" "Associate Professor — U Toronto\n")))))) ;; set `mu4e-context-policy` and `mu4e-compose-policy` to tweak when mu4e should ;; guess or ask the correct context, e.g. ;; start with the first (default) context; ;; default is to ask-if-none (ask when there's no context yet, and none match) (setq mu4e-context-policy 'pick-first) ;; compose with the current context is no context matches; ;; default is to ask (setq mu4e-compose-context-policy 'pick-first) (add-hook 'mu4e-headers-mode-hook #'(lambda () (setq-local show-trailing-whitespace nil))) (add-hook 'mu4e-view-mode-hook #'(lambda () (setq-local show-trailing-whitespace nil))) ;; Get mail (setq mu4e-get-mail-command "mbsync math-fast" mu4e-change-filenames-when-moving t ; needed for mbsync mu4e-headers-include-related nil ;do not include threaded ;sent messages in inbox queries ) (define-key mu4e-headers-mode-map (kbd "h") 'mu4e-headers-mark-for-refile) (define-key mu4e-headers-mode-map (kbd "h") 'mu4e-headers-mark-for-refile) (define-key mu4e-headers-mode-map (kbd "h") 'mu4e-headers-mark-for-refile) (define-key mu4e-view-mode-map (kbd "h") 'mu4e-view-mark-for-refile) (define-key mu4e-headers-mode-map (kbd "r") 'mu4e-compose-reply) (define-key mu4e-view-mode-map (kbd "r") 'mu4e-compose-reply) (define-key mu4e-headers-mode-map (kbd "f") 'mu4e-compose-forward) (define-key mu4e-headers-mode-map (kbd "C-k") 'mu4e-headers-mark-for-trash) ;; Send mail (setq message-send-mail-function 'smtpmail-send-it smtpmail-servers-requiring-authorization ".*" smtpmail-smtp-server "127.0.0.1") #+end_src ** org-mode *** Require Require the ~org~ package; I also occasionally use org-pomodoro #+begin_src emacs-lisp (with-eval-after-load "org" (define-key org-src-mode-map (kbd "C-c C-c") 'org-edit-src-exit) (define-key org-src-mode-map (kbd "C-c C-k") nil) ;this conflicts with my LaTeX bindings (define-key org-src-mode-map (kbd "C-c C-`") 'org-edit-src-abort)) (require 'org) (require 'org-pomodoro) (require 'org-habit) #+end_src *** Hooks Enable ~auto-fill-mode~ (see [[[https://www.gnu.org/software/emacs/manual/html_node/emacs/Auto-Fill.html][the manual]]]: honestly I do not see where I would not want to use this feature). Also, disable ~truncate-lines~ #+begin_src emacs-lisp (add-hook 'org-mode-hook 'turn-on-auto-fill) (setq org-starting-truncated nil org-startup-folded t) #+end_src *** Cosmetics Change the default ellipsis ~...~ to the unicode ellipsis ~…~ *Does not work properly* #+begin_src emacs-lisp ; (setq org-ellipsis "…") #+end_src *** Ligatures [not in working order] These require a patched ~hackminus~ font. Too bad it does not work for some reason #+begin_src emacs-lisp ;; (defun delayed-org-prettify () ;; (prettify-symbols-mode 0) ;; (run-with-idle-timer 0 nil ;; (lambda () ;; (prettify-symbols-mode 1) ;; (add-to-list 'prettify-symbols-alist '("**" . (? (Br . Bl) ?))) ;; (add-to-list 'prettify-symbols-alist '("***" . (? (Br . Bl) ? (Br . Bl) ?))) ;; (add-to-list 'prettify-symbols-alist '("****" . (? (Br . Bl) ? (Br . Bl) ? (Br . Bl) ?)))))) ;;(add-hook 'org-mode-hook 'delayed-org-prettify) #+end_src *** Links Open links with external stuff #+begin_src emacs-lisp (setq org-file-apps '((auto-mode . emacs) ("\\.x?html?\\'" . "xdg-open %s") ("\\.pdf\\'" . "xdg-open \"%s\""))) #+end_src *** Agenda Set the canonical binding for the agenda #+begin_src emacs-lisp (global-set-key (kbd "C-c a") 'org-agenda) #+end_src Define agenda files: the main one is ~master.org~, but then I have a bunch of them on orgzly #+begin_src emacs-lisp (setq org-agenda-files '("~/org/master.org" "~/org/next.org" "~/org/orgzly/work.org" "~/org/orgzly/scheduled.org" "~/org/orgzly/hack.org" "~/org/orgzly/library.org" "~/org/orgzly/kaizen.org" "~/org/orgzly/refile.org")) #+end_src Default to daily agenda #+begin_src emacs-lisp (setq org-agenda-span 1) #+end_src Prevent headlines to be marked as DONE if some sub-headings are still TODO. #+begin_src emacs-lisp (setq org-enforce-todo-dependencies t) #+end_src Do not show scheduled or deadline'd stuff in the Global TODO list #+begin_src emacs-lisp (setq org-agenda-todo-ignore-deadlines 'all org-agenda-todo-ignore-scheduled 'all) #+end_src Do not show stuff marked with DONE even if they have a deadline #+begin_src emacs-lisp (setq org-agenda-skip-deadline-if-done t) #+end_src Custom separator #+begin_src emacs-lisp (setq org-agenda-block-separator ?─) #+end_src Turn on speed keys #+begin_src emacs-lisp (setq org-use-speed-commands t) #+end_src Customize the agenda interface a bit - Sleeker time-grid #+begin_src emacs-lisp (setq org-agenda-time-grid '((daily today require-timed) (800 1000 1200 1400 1600 1800 2000) " ······ " "───────────────") org-agenda-current-time-string "····· now ·····") #+end_src - Use figlet-type fonts to display the date #+begin_src emacs-lisp (setq figlet [["███" "██ " "███" "███" "█ █" "███" "███" "███" "███" "███"] ["█ █" " █ " " █" " █" "█ █" "█ " "█ " " █" "█ █" "█ █"] ["█ █" " █ " "███" "███" "███" "███" "███" " █" "███" "███"] ["█ █" " █ " "█ " " █" " █" " █" "█ █" " █" "█ █" " █"] ["███" "███" "███" "███" " █" "███" "███" " █" "███" "███"]]) (setq figlet-lean [["┌──┐" "╶┐ " "╶──┐" "╶──┐" "╷ ╷" "┌──╴" "┌──╴" "╶──┐" "┌──┐" "┌──┐"] ["│ │" " │ " " │" " │" "│ │" "│ " "│ " " │" "│ │" "│ │"] ["│ │" " │ " "┌──┘" "╶──┤" "└──┤" "└──┐" "├──┐" " │" "├──┤" "└──┤"] ["│ │" " │ " "│ " " │" " │" " │" "│ │" " │" "│ │" " │"] ["└──┘" "╶┴╴" "└──╴" "╶──┘" " ╵" "╶──┘" "└──┘" " ╵" "└──┘" "╶──┘"]]) (defun figlet-digit (digit row) (aref (aref figlet-lean row) digit)) (defun figlet-num (number row) (let ((n number) (d (list))) (while (> n 0) (setq d (append (list (mod n 10)) d)) (setq n (/ n 10))) (string-join (mapcar (lambda (digit) (concat (figlet-digit digit row) " ")) d)))) (defun org-agenda-format-date-figlet (date) "Format a DATE string for display in the daily/weekly agenda. This function makes sure that dates are aligned for easy reading." ;(require 'cal-iso) (let* ((dayname (calendar-day-name date)) (day (cadr date)) (day-of-week (calendar-day-of-week date)) (month (car date)) (monthname (calendar-month-name month)) (year (nth 2 date))nf (iso-week (org-days-to-iso-week (calendar-absolute-from-gregorian date))) (weekyear (cond ((and (= month 1) (>= iso-week 52)) (1- year)) ((and (= month 12) (<= iso-week 1)) (1+ year)) (t year))) (weekstring (if (= day-of-week 1) (format " W%02d" iso-week) ""))) (format (concat "\n" "%12s %s %4d%s\n" "%12s \n" "%12s %-10s\n" "%12s \n" "%12s %s\n") (figlet-num day 0) monthname year weekstring (figlet-num day 1) (figlet-num day 2) dayname (figlet-num day 3) (figlet-num day 4) (sunrise-sunset)))) (setq org-agenda-format-date #'org-agenda-format-date-figlet) (setq org-agenda-prefix-format '((agenda . " %i %9c · %?-12t% s") (todo . " %i %9c · ") (tags . " %i %9c · ") (search . " %i %9c · "))) #+end_src - Add a whiteline after the header Now, this is a horrible hack: the string that forms the header is obtained by constructing some pretty-text in a temporary buffer and then retrieving the string with #'buffer-string Hence we add (and remove) an advice to the function buffer-string that concat's a newline around each function that produces the headers #+begin_src emacs-lisp (defun concat-newline (s) (concat s "\n")) (mapcar (lambda (fun) (advice-add fun :around (lambda (orig-fun &rest args) (advice-add #'buffer-string :filter-return #'concat-newline) (apply orig-fun args) (advice-remove #'buffer-string #'concat-newline)))) '(org-tags-view org-todo-list)) #+end_src #+begin_src emacs-lisp (advice-add #'org-agenda--insert-overriding-header :filter-args (lambda (params) (list `(concat ,(car params) "\n")))) #+end_src Improve the org-habit graph thing #+begin_src emacs-lisp (setq org-habit-regular-glyph ?□ org-habit-today-glyph ?□ org-habit-completed-glyph ?▣) (defun wilder/org-habit-build-graph (habit starting current ending) "Build a graph for the given HABIT, from STARTING to ENDING. CURRENT gives the current time between STARTING and ENDING, for the purpose of drawing the graph. It need not be the actual current time." (let* ((all-done-dates (sort (org-habit-done-dates habit) #'<)) (done-dates all-done-dates) (scheduled (org-habit-scheduled habit)) (s-repeat (org-habit-scheduled-repeat habit)) (start (time-to-days starting)) (now (time-to-days current)) (end (time-to-days ending)) (graph (make-string (- end start) org-habit-regular-glyph)) (index 0) last-done-date) (while (and done-dates (< (car done-dates) start)) (setq last-done-date (car done-dates) done-dates (cdr done-dates))) (while (< start end) (let* ((in-the-past-p (< start now)) (todayp (= start now)) (donep (and done-dates (= start (car done-dates)))) (faces (if (and in-the-past-p (not last-done-date) (not (< scheduled now))) (if (and all-done-dates (= (car all-done-dates) start)) ;; This is the very first done of this habit. '(org-habit-ready-face . org-habit-ready-future-face) '(org-habit-clear-face . org-habit-clear-future-face)) (org-habit-get-faces habit start (and in-the-past-p last-done-date ;; Compute scheduled time for habit at the time ;; START was current. (let ((type (org-habit-repeat-type habit))) (cond ;; At the last done date, use current ;; scheduling in all cases. ((null done-dates) scheduled) ((equal type ".+") (+ last-done-date s-repeat)) ((equal type "+") ;; Since LAST-DONE-DATE, each done mark ;; shifted scheduled date by S-REPEAT. (- scheduled (* (length done-dates) s-repeat))) (t ;; Compute the scheduled time after the ;; first repeat. This is the closest time ;; past FIRST-DONE which can reach SCHEDULED ;; by a number of S-REPEAT hops. ;; ;; Then, play TODO state change history from ;; the beginning in order to find current ;; scheduled time. (let* ((first-done (car all-done-dates)) (s (let ((shift (mod (- scheduled first-done) s-repeat))) (+ (if (= shift 0) s-repeat shift) first-done)))) (if (= first-done last-done-date) s (catch :exit (dolist (done (cdr all-done-dates) s) ;; Each repeat shifts S by any ;; number of S-REPEAT hops it takes ;; to get past DONE, with a minimum ;; of one hop. (cl-incf s (* (1+ (/ (max (- done s) 0) s-repeat)) s-repeat)) (when (= done last-done-date) (throw :exit s)))))))))) donep))) markedp face) (cond (donep (aset graph index org-habit-completed-glyph) (setq markedp t) (while (and done-dates (= start (car done-dates))) (setq last-done-date (car done-dates)) (setq done-dates (cdr done-dates)))) (todayp (aset graph index org-habit-today-glyph))) (setq face (if (or in-the-past-p todayp) (car faces) (cdr faces))) (when (and in-the-past-p (not (eq face 'org-habit-overdue-face)) (not markedp)) (setq face (cdr faces))) (put-text-property index (1+ index) 'face face graph) (put-text-property index (1+ index) 'help-echo (concat (format-time-string (org-time-stamp-format) (time-add starting (days-to-time (- start (time-to-days starting))))) (if donep " DONE" "")) graph)) (setq start (1+ start) index (1+ index))) graph)) (advice-add 'org-habit-build-graph :override #'wilder/org-habit-build-graph) #+end_src Ideally I should tag some tasks as “break” tasks, which are suitable to be taken care of during a pomodoro break. Such tasks should be marked with tags ~:5m:~ and ~:20m:~ according to the estimate on the time it would take to take care of them #+begin_src emacs-lisp (setq org-agenda-custom-commands '( ("a" "Main agenda" ((agenda "") (todo "NEXT|ONGOING") (tags-todo "hack") (tags-todo "5m") (todo "TODO"))) ("h" "Agenda and Android tasks" ((agenda "") (tags-todo "Android"))) ("5" "Agenda and Break tasks" ((agenda "") (tags-todo "5m") (tags-todo "20m"))))) #+end_src Custom agenda view - cleanup stuff (TODO, what is this doing, exactly? ) #+begin_src emacs-lisp (defun org-agenda-prepare (&optional name) (let ((filter-alist (if org-agenda-persistent-filter (with-current-buffer (get-buffer-create org-agenda-buffer-name) (list `(tag . ,org-agenda-tag-filter) `(re . ,org-agenda-regexp-filter) `(effort . ,org-agenda-effort-filter) `(cat . ,org-agenda-category-filter)))))) (if (org-agenda-use-sticky-p) (progn (put 'org-agenda-tag-filter :preset-filter nil) (put 'org-agenda-category-filter :preset-filter nil) (put 'org-agenda-regexp-filter :preset-filter nil) ;; Popup existing buffer (org-agenda-prepare-window (get-buffer org-agenda-buffer-name) filter-alist) (message "Sticky Agenda buffer, use `r' to refresh") (or org-agenda-multi (org-agenda-fit-window-to-buffer)) (throw 'exit "Sticky Agenda buffer, use `r' to refresh")) (setq org-todo-keywords-for-agenda nil) (put 'org-agenda-tag-filter :preset-filter org-agenda-tag-filter-preset) (put 'org-agenda-category-filter :preset-filter org-agenda-category-filter-preset) (put 'org-agenda-regexp-filter :preset-filter org-agenda-regexp-filter-preset) (put 'org-agenda-effort-filter :preset-filter org-agenda-effort-filter-preset) (if org-agenda-multi (progn (setq buffer-read-only nil) (goto-char (point-max)) (unless (or (bobp) org-agenda-compact-blocks (not org-agenda-block-separator)) (insert "\n" (if (stringp org-agenda-block-separator) org-agenda-block-separator (make-string (window-width) org-agenda-block-separator)) "\n\n")) (narrow-to-region (point) (point-max))) (setq org-done-keywords-for-agenda nil) ;; Setting any org variables that are in org-agenda-local-vars ;; list need to be done after the prepare call (org-agenda-prepare-window (get-buffer-create org-agenda-buffer-name) filter-alist) (setq buffer-read-only nil) (org-agenda-reset-markers) (let ((inhibit-read-only t)) (erase-buffer)) (org-agenda-mode) (setq org-refile-targets '((org-agenda-files :level . 1))) (setq org-refile-use-outline-path 'file) (setq org-agenda-buffer (current-buffer)) (setq org-agenda-contributing-files nil) (setq org-agenda-columns-active nil) (org-agenda-prepare-buffers (org-agenda-files nil 'ifmode)) (setq org-todo-keywords-for-agenda (org-uniquify org-todo-keywords-for-agenda)) (setq org-done-keywords-for-agenda (org-uniquify org-done-keywords-for-agenda)) (setq org-agenda-last-prefix-arg current-prefix-arg) (setq org-agenda-this-buffer-name org-agenda-buffer-name) (and name (not org-agenda-name) (setq-local org-agenda-name name))) (setq buffer-read-only nil)))) (add-hook 'org-agenda-mode-hook (lambda () (setq truncate-lines t show-trailing-whitespace nil))) #+end_src *** Automate saving This will take care of most of the other stuff #+begin_src emacs-lisp (add-hook 'auto-save-hook 'org-save-all-org-buffers) #+end_src *** Reverting stuff from orgzly #+begin_src emacs-lisp (defun org-revert-all-orgzly-buffers (&optional ALL) "Revert all Org buffers that are sitting in orgzly Prompt for confirmation when there are unsaved changes. Be sure you know what you are doing before letting this function overwrite your changes." (interactive) (message "Reverting Orgzly buffers…") (save-excursion (save-window-excursion (dolist (b (buffer-list)) (when (and (with-current-buffer b (derived-mode-p 'org-mode)) (with-current-buffer b buffer-file-name) (with-current-buffer b (string-match-p "orgzly" default-directory))) (pop-to-buffer-same-window b) (revert-buffer t 'no-confirm))))) (org-agenda-redo-all)) (define-key org-agenda-mode-map (kbd "Z") 'org-revert-all-orgzly-buffers) #+end_src *** Capture Set default keybinding #+begin_src emacs-lisp (global-set-key (kbd "C-c c") 'org-capture) #+end_src This is my capture template: it needs to be revised as I really do not use The Idea, journal and break entry #+begin_src emacs-lisp (setq org-default-notes-file "~/org/master.org") (setq org-capture-templates '(("t" "TODO today" entry (file+headline "~/org/master.org" "Tasks") "* TODO %?\n SCHEDULED: %t" :clock-in t :clock-resume t) ("n" "TODO next" entry (file+headline "~/org/master.org" "Tasks") "* NEXT %?\n " :clock-in t :clock-resume t) ("T" "TODO" entry (file+headline "~/org/master.org" "Tasks") "* TODO %?\n %a" :clock-in t :clock-resume t) ("i" "Idea" entry (file+headline "~/org/master.org" "Ideas") "* IDEA %?\n %u" :clock-in t :clock-resume t ) ("j" "Journal" entry (file+datetree "~/org/master.org") "* %?\n%U\n" :clock-in t :clock-resume t) ("b" "Break" entry (file+datetree "~/org/master.org") "* break %?\n" :clock-in t :clock-resume t) ("e" "Mail To" entry (file+headline "~/org/master.org" "E-mails") "* DONE mailto:%?") ("r" "Reply to" entry (file+headline "~/org/master.org" "E-mails") "* DONE mailto:%?"))) #+end_src *** LaTeX export #+begin_src emacs-lisp ; (add-to-list 'org-latex-classes ; '("amsart" "\\documentclass[11pt]{amsart}" ; ("\\section{%s}" . "\\section*{%s}") ; ("\\subsection{%s}" . "\\subsection*{%s}") ; ("\\subsubsection{%s}" . "\\subsubsection*{%s}") ; ("\\paragraph{%s}" . "\\paragraph*{%s}") ; ("\\subparagraph{%s}" . "\\subparagraph*{%s}"))) #+end_src *** Source blocks Add template for a source block in a few selected languages; for now I have - emacs-lisp - shell . This is useful for writing the emacs init file in literate form, or dotfiles for other code. Since Org 9.2, the behavior that I grew accustomed to (e.g. ~ \"#+title\" \"#+BEGIN_EXAMPLE\" -> \"#+begin_example\" Inspiration: https://code.orgmode.org/bzg/org-mode/commit/13424336a6f30c50952d291e7a82906c1210daf0." (interactive) (save-excursion (goto-char (point-min)) (let ((case-fold-search nil) (count 0)) ;; Match examples: "#+foo bar", "#+foo:", "=#+foo=", "~#+foo~", ;; "‘#+foo’", "“#+foo”", ",#+foo bar", ;; "#+FOO_bar", "#+FOO". (while (re-search-forward "\\(?1:#\\+[A-Z_]+\\(?:_[[:alpha:]]+\\)*\\)\\(?:[ :=~’”]\\|$\\)" nil :noerror) (setq count (1+ count)) (replace-match (downcase (match-string-no-properties 1)) :fixedcase nil nil 1)) (message "Lower-cased %d matches" count)))) #+end_src *** Clocking #+begin_src emacs-lisp ;; Separate drawers for clocking and logs (setq org-drawers (quote ("PROPERTIES" "CLOCKBOOK"))) ;; Save clock data and state changes and notes in the CLOCK drawer (setq org-clock-into-drawer "CLOCKBOOK") ;; Sometimes I change tasks I'm clocking quickly - this removes clocked tasks with 0:00 duration (setq org-clock-out-remove-zero-time-clocks t) ;; Clock out when moving task to a done state (setq org-clock-out-when-done t) (setq org-clock-persist 'history) (setq org-duration-format 'h:mm) (setq org-clock-clocktable-default-properties '(:maxlevel 2 :scope subtree)) (org-clock-persistence-insinuate) #+end_src *** COMMENT Tangle to different files This has been broken by commit 3ebee033103ccd3c3e8c354bad01c15332b9d901 and a2cb9b853d30fc301f4553d1556dba4ee6bc1ead. Try some workarounds to pinpoint the issue: #+begin_src emacs-lisp (setq org-babel-tangle-use-relative-file-links nil) #+end_src ---- This is some some super-clever stuff. See [https://emacs.stackexchange.com/questions/39032/tangle-the-same-src-block-to-different-files] #+begin_src emacs-lisp (defun org-babel-tangle-collect-blocks-handle-tangle-list (&optional language tangle-file) "Can be used as :override advice for `org-babel-tangle-collect-blocks'. Handles lists of :tangle files." (let ((counter 0) last-heading-pos blocks) (org-babel-map-src-blocks (buffer-file-name) (let ((current-heading-pos (org-with-wide-buffer (org-with-limited-levels (outline-previous-heading))))) (if (eq last-heading-pos current-heading-pos) (cl-incf counter) (setq counter 1) (setq last-heading-pos current-heading-pos))) (unless (org-in-commented-heading-p) (let* ((info (org-babel-get-src-block-info)) (src-lang (nth 0 info)) (src-tfiles (cdr (assq :tangle (nth 2 info))))) ; Tobias: accept list for :tangle (unless (consp src-tfiles) ; Tobias: unify handling of strings and lists for :tangle (setq src-tfiles (list src-tfiles))) ; Tobias: unify handling (dolist (src-tfile src-tfiles) ; Tobias: iterate over list (unless (or (string= src-tfile "no") (and tangle-file (not (equal tangle-file src-tfile))) (and language (not (string= language src-lang)))) ;; Add the spec for this block to blocks under its ;; language. (let ((by-lang (assoc src-lang blocks)) (block (org-babel-tangle-single-block counter))) (setcdr (assoc :tangle (nth 4 block)) src-tfile) ; Tobias: (if by-lang (setcdr by-lang (cons block (cdr by-lang))) (push (cons src-lang (list block)) blocks)))))))) ; Tobias: just () ;; Ensure blocks are in the correct order. (mapcar (lambda (b) (cons (car b) (nreverse (cdr b)))) blocks))) (defun org-babel-tangle-single-block-handle-tangle-list (oldfun block-counter &optional only-this-block) "Can be used as :around advice for `org-babel-tangle-single-block'. If the :tangle header arg is a list of files. Handle all files" (let* ((info (org-babel-get-src-block-info)) (params (nth 2 info)) (tfiles (cdr (assoc :tangle params)))) (message nil) (if (null (and only-this-block (consp tfiles))) (funcall oldfun block-counter only-this-block) (cl-assert (listp tfiles) nil ":tangle only allows a tangle file name or a list of tangle file names") (let ((ret (mapcar (lambda (tfile) (message tfile) (sleep-for 1) (let (old-get-info) (cl-letf* (((symbol-function 'old-get-info) (symbol-function 'org-babel-get-src-block-info)) ((symbol-function 'org-babel-get-src-block-info) `(lambda (&rest get-info-args) (let* ((info (apply 'old-get-info get-info-args)) (params (nth 2 info)) (tfile-cons (assoc :tangle params))) (setcdr tfile-cons ,tfile) info)))) (funcall oldfun block-counter only-this-block)))) tfiles))) (if only-this-block (list (cons (cl-caaar ret) (mapcar #'cadar ret))) ret))))) (advice-add 'org-babel-tangle-collect-blocks :override #'org-babel-tangle-collect-blocks-handle-tangle-list) (advice-add 'org-babel-tangle-single-block :around #'org-babel-tangle-single-block-handle-tangle-list) #+end_src *** Append tangle #+begin_src emacs-lisp (defun org-babel-tangle-append (filename) "Append source code block at point to its tangle file. The command works like `org-babel-tangle' with prefix arg but `delete-file' is ignored." (interactive) (cl-letf (((symbol-function 'delete-file) #'ignore)) (org-babel-tangle '(4) filename))) #+end_src *** Tangle file This can be used to tangle one or more files to their output files [[https://gitlab.com/to1ne/literate-dotfiles/blob/master/elisp/tangle.el][ Source on gitlab]] #+begin_src emacs-lisp (defun tangle-file(&rest files nokill) "Tangle FILES or all files in the project." (when (null files) (setq files command-line-args-left)) (dolist (file files) (with-current-buffer (find-file-noselect file) (org-babel-tangle) ; (unless nokill (kill-buffer)) ))) #+end_src *** Export file This can be used to tangle one or more files to their output files [[https://gitlab.com/to1ne/literate-dotfiles/blob/master/elisp/tangle.el][ Source on gitlab]] #+begin_src emacs-lisp (defun export-org-file-pdf(&rest files nokill) "Export FILES or all files in the project." (when (null files) (setq files command-line-args-left)) (dolist (file files) (with-current-buffer (find-file-noselect file) (org-latex-export-to-pdf) (kill-buffer)))) #+end_src *** Crypto stuff #+begin_src emacs-lisp (require 'org-crypt) (org-crypt-use-before-save-magic) (setq org-tags-exclude-from-inheritance (quote ("crypt"))) (setq org-crypt-key "C86A9E7675295C62") #+end_src *** ox-export Load ox-hugo #+begin_src emacs-lisp (with-eval-after-load 'ox (require 'ox-hugo)) #+end_src ** elisp *** Paredit #+begin_src emacs-lisp (autoload 'enable-paredit-mode "paredit" "Turn on pseudo-structural editing of Lisp code." t) (add-hook 'emacs-lisp-mode-hook #'enable-paredit-mode) (require 'hydra) (require 'highlight-parentheses) (defun hydra-paren/hl-paren-force-fix () ;;; This is needed b/c hl-parent caches the point position and ;;; refuses to update if the point did not move (let ((hl-paren-last-point -1)) (hl-paren-highlight))) (defun hydra-paren/pre () (unless (boundp 'hydra-paren/hpm) (highlight-parentheses-mode 1)) (setq hydra-paren/hpm t)) (defun hydra-paren/post () (highlight-parentheses-mode -1) (makunbound 'hydra-paren/hpm)) (global-set-key (kbd "C-SPC") (defhydra hydra-paren (:pre hydra-paren/pre :post hydra-paren/post) "paren slurp and barf" ("l" (progn (paredit-forward-slurp-sexp) (hydra-paren/hl-paren-force-fix)) "slurp forward") ("j" (progn (paredit-forward-barf-sexp) (hydra-paren/hl-paren-force-fix)) "barf forward") ("s" (progn (paredit-backward-slurp-sexp) (hydra-paren/hl-paren-force-fix)) "slurp backward") ("f" (progn (paredit-backward-barf-sexp) (hydra-paren/hl-paren-force-fix)) "barf backward"))) #+end_src *** Replace last sexp I use this a lot to evaluate (e.g.) quick computations in files #+begin_src emacs-lisp (defun replace-last-sexp () (interactive) (let ((value (eval (preceding-sexp)))) (kill-sexp -1) (insert (format "%S" value)))) (global-set-key (kbd "C-c C-x C-e") #'replace-last-sexp) #+end_src ** qml Load ~qml-mode~ #+begin_src emacs-lisp (autoload 'qml-mode "qml-mode.el" t) (add-to-list 'auto-mode-alist '("\\.qml\\'" . qml-mode)) #+end_src ** C and C++ *** Hooks #+begin_src emacs-lisp ;; (require 'doxymacs) (add-hook 'c-mode-hook (lambda () (subword-mode) (doxymacs-mode) (define-key c-mode-map (kbd "C-c C-c") 'make))) (add-hook 'c++-mode-hook (lambda () (subword-mode) (doxymacs-mode) (define-key c++-mode-map (kbd "C-c C-c") 'make))) #+end_src ** TODO split --- LaTeX *** TODO Setup ~reftex~ #+begin_src emacs-lisp (with-eval-after-load "reftex" (setq reftex-cite-format "~\\cite{%l}" reftex-plug-into-AUCTeX '(t t nil t t) reftex-insert-label-flags '(t t) reftex-label-alist '(("thm" ?t "thm:" "~\\ref{%s}" thm (regexp "theorems?")) ("lem" ?l "lem:" "~\\ref{%s}" lem (regexp "lemma{ta}?")) ("prop" ?p "prp:" "~\\ref{%s}" prp (regexp "propositions?")) ("cor" ?c "cor:" "~\\ref{%s}" cor (regexp "corollary")) ("def" ?d "def:" "~\\ref{%s}" cor (regexp "defintions?"))))) ;;; advice the auctex function to replace the ;;; lighter with somthing softer (with-eval-after-load "auctex" (defun cleanup-TeX-mode (&optional mode) "Advice for the base auctex MODE naming" (setq mode-name (replace-regexp-in-string "LaTeX" "χ" mode-name t)) (setq mode-name (replace-regexp-in-string "/" "·" mode-name))) (advice-add 'TeX-set-mode-name :after 'cleanup-TeX-mode)) #+end_src *** Setup ~latex-mode~ #+begin_src emacs-lisp (eval-after-load 'latex '(progn (font-lock-add-keywords 'latex-mode `((,(rx "$") 0 'font-latex-sedate-face t)) t) (defface font-latex-special-comment-face '((t (:foreground "#2aa198"))) "Cyan") (font-lock-add-keywords 'latex-mode '(("^% \\([^*].*\\)" 1 'font-latex-special-comment-face t))) (define-key-alist LaTeX-mode-map '(("M-S-SPC" . TeX-insert-braces) ("C-c C-v" . wilder/TeX-insert-reference) ("C-M-" . wilder/TeX-insert-align-dwim) ;; unbind return - NOTE it is important to unbind ;; and not RET. If we unbind RET then C-m won't work ;; either. ("" . (lambda() (interactive) (insert "\\"))) ("S-" . (lambda() (interactive) (insert "|"))) ("C-c C-." . LaTeX-mark-environment) ("C-c C-k" . (lambda (r-begin r-end) (interactive "r") (add-delimiter "_{" "}" r-begin r-end))) ("C-c C-i" . (lambda (r-begin r-end) (interactive "r") (add-delimiter "^{" "}" r-begin r-end))) ("M-|" . (lambda (r-begin r-end) (interactive "r") (add-delimiter "|" "|" r-begin r-end))) ("M-," . (lambda (r-begin r-end) (interactive "r") (add-delimiter ", " ", " r-begin r-end))) ("M-\"" . (lambda (r-begin r-end) (interactive "r") (add-delimiter "“" "”" r-begin r-end))) ;; This is the rationale: C-M-SPC starts inline math C-M-RET starts display math ("C-M-SPC" . (lambda (r-begin r-end) (interactive "r") (add-delimiter "$" "$" r-begin r-end))) ("C-c C-d" . wilder/TeX-insert-todonote) ("C-M-d" . kill-sexp) ("C-M-i" . down-list) ;; -i stands for /in/ ("C-M-o" . up-list) ;; -o stands for /out/ ("" . ( lambda() (interactive) (message "Use C-c C-c"))) ("C-c C-c" . ( lambda() (interactive) (compile "/home/jacopods/scripts/latex-mk")) ) ("~" . wilder/TeX-replace-tilde) ("C-o" . wilder/open-line-and-indent) ;; Force moves around to be more “semantic” ("C-v" . goto-next-comment-line) ("M-v" . goto-previous-comment-line) ("C-x n c" . narrow-between-comments) ("C-S-v" . backward-paragraph))) (mapcar (lambda (ch) (define-key LaTeX-mode-map (kbd ch) 'insert-char-with-padding)) '("=" "≠" ">" "<" "≥" "≤" "⇒" "∩" "∪" "∨" "∧" "×" "⊂" "⊃")) ;; Move around commands in the Right Way™ (modify-syntax-entry ?\\ "w" LaTeX-mode-syntax-table) ;; add fancy quotes to the syntax table (modify-syntax-entry ?“ "(”" LaTeX-mode-syntax-table) (modify-syntax-entry ?” ")“" LaTeX-mode-syntax-table) (setq subword-forward-regexp "\\W*\\(\\([\\\\[:upper:]]*\\W?\\)[[:lower:][:digit:]]*\\)") (setq subword-backward-regexp "\\(\\(\\W\\|[[:lower:][:digit:]]\\)\\([\\\\[:upper:]]+\\W*\\)\\|\\W\\w+\\)"))) #+end_src *** Require Load auctex, reftex and set up related hooks #+begin_src emacs-lisp (require 'tex-site) (require 'reftex) #+end_src *** Set default TeX options #+begin_src emacs-lisp (setq-default TeX-master nil) (setq TeX-auto-save t TeX-parse-self t TeX-insert-braces nil) #+end_src *** Appearance No fontification for sub and superscripts #+begin_src emacs-lisp (setq font-latex-fontify-script nil) #+end_src Add unicode quotes to the quote-list #+begin_src emacs-lisp ; (defvar font-latex-quote-list '(("``" "''") ("“" "”") ("<<" ">>" french) ("«" "»" french)) ; #+end_src Redefine fold ellipsis #+begin_src emacs-lisp (setq TeX-fold-ellipsis " …") #+end_src *** Default labels #+begin_src emacs-lisp (setq LaTeX-equation-label "e_" LaTeX-section-label "s_" LaTeX-figure-label "f_") #+end_src *** Spell checking help Do not spell-check inside the following commands. See [https://tex.stackexchange.com/questions/117204/skip-spelling-in-emacs-for-the-content-of-a-user-macro] #+begin_src emacs-lisp (setq ispell-tex-skip-alists (list (append (car ispell-tex-skip-alists) ;tell ispell to ignore content of this: '(("\\\\eqref" ispell-tex-arg-end) ("\\\\cite" ispell-tex-arg-end) ("\\\\author" ispell-tex-arg-end) ("\\\\address" ispell-tex-arg-end) ("\\\\include" ispell-tex-arg-end) )) (cadr ispell-tex-skip-alists))) #+end_src *** Specialty functions This function adds a pair of delimiters or surrounds the active region with the given delimiters. TODO it breaks when there is no mark #+begin_src emacs-lisp (defun add-delimiter (delim-begin delim-end r-begin r-end) "Add the pair of delimiters given in delim at the ends of the region if it is activated" (interactive "cBegin delimiter: \ncEnd delimiter: \nr") (if (region-active-p) (progn (save-excursion (goto-char r-end) (insert delim-end) (goto-char r-begin) (insert delim-begin))) (progn (save-excursion (insert delim-end)) (insert delim-begin)))) #+end_src The following re-implements =TeX-insert-braces= to work with negative argument #+begin_src emacs-lisp (defun TeX-insert-braces (arg) "Make a pair of braces around next ARG sexps and leave point inside. No argument is equivalent to zero: just insert braces and leave point between. If there is an active region, ARG will be ignored, braces will be inserted around the region, and point will be left after the closing brace." (interactive "P") (if (TeX-active-mark) (progn (if (< (point) (mark)) (exchange-point-and-mark)) (insert TeX-grcl) (save-excursion (goto-char (mark)) (insert TeX-grop))) (if (and arg (< arg 0)) (progn (save-excursion (backward-sexp (prefix-numeric-value (- 0 arg))) (insert TeX-grop)) (insert TeX-grcl)) (insert TeX-grop) (save-excursion (if arg (forward-sexp (prefix-numeric-value arg))) (insert TeX-grcl))))) (defun TeX-back-insert-braces (arg) (interactive "P") (if arg (TeX-insert-braces (- 0 arg)) (insert TeX-grcl))) #+end_src This is a helper for [[https://www.gnu.org/software/emacs/manual/html_node/emacs/Dynamic-Abbrevs.html][Dynamic abbrev expansion]] #+begin_src emacs-lisp (defun dabbrev-expand-helper () (interactive) (call-interactively 'dabbrev-expand)) #+end_src This inserts a char adding some whitespace padding whenever necessary #+begin_src emacs-lisp (defun insert-char-with-padding (arg) (interactive "*P") (unless (string-match (string (preceding-char)) " \&") (insert " ")) (self-insert-command (prefix-numeric-value arg)) (unless (char-equal (following-char) ?\s) (insert " "))) ;; decide what to do with the point #+end_src This function opens a line and indents it #+begin_src emacs-lisp (defun wilder/open-line-and-indent (arg) "This function opens a line using (open-line) and indents it" (interactive "p") (open-line arg) (save-excursion (forward-char arg) (unless (eolp) (indent-according-to-mode)))) #+end_src This inserts a plain reference (or a reference to an equation with prefix arg) #+begin_src emacs-lisp (defun wilder/TeX-insert-reference (arg) (interactive "P") (insert "~") (if arg (TeX-insert-macro "eqref") (TeX-insert-macro "ref"))) #+end_src This inserts a citation #+begin_src emacs-lisp (defun wilder/TeX-insert-cite (arg) (interactive "P") (insert "~") (TeX-insert-macro "cite")) #+end_src This inserts an ~align~ environment (or an ~align*~ with prefix arg) #+begin_src emacs-lisp (defun wilder/TeX-insert-align (arg) (interactive "P") (if arg (LaTeX-insert-environment "align") (LaTeX-insert-environment "align*")) (indent-according-to-mode)) (defun wilder/TeX-insert-align-dwim (arg) (interactive "P") (if (texmathp) (let ((why (car texmathp-why))) (cond ((string-prefix-p "$" why) (wilder/TeX-promote-inline-math arg)) ((string-equal "equation*" why) (LaTeX-modify-environment "align*")) ((string-equal "equation" why) (LaTeX-modify-environment "align")) ((string-equal "align*" why) (when arg (LaTeX-modify-environment "align"))))) (wilder/TeX-insert-align arg))) #+end_src This replaces horizontal space with a tilde #+begin_src emacs-lisp (defun wilder/TeX-replace-tilde (arg) (interactive "P") (delete-horizontal-space) (insert "~")) #+end_src Insert a todonote at point or wrap the region in a todonote. #+begin_src emacs-lisp (defun wilder/TeX-insert-todonote (arg r-begin r-end) (interactive "P\nr") (if arg (add-delimiter "{\\todo[inline]{" "}}" r-begin r-end) (add-delimiter "{\\todo{" "}}" r-begin r-end))) #+end_src Promote inline math to an align #+begin_src emacs-lisp (defun wilder/char-punctuation-p (ch) "returns t if the char is a punctuation" (interactive) (string-match (string ch) ".,:;")) (defun wilder/TeX-promote-inline-math (arg) (interactive "P") (when (and (texmathp) (string-prefix-p "$" (car texmathp-why))) (let* ((delim (car texmathp-why)) (pos (cdr texmathp-why)) (n (length delim))) (goto-char pos) (push-mark) (delete-char n) (search-forward delim) (delete-backward-char n) ;; include punctuations in the align (when (wilder/char-punctuation-p (char-after)) (forward-char)) (activate-mark) (wilder/TeX-insert-align arg) (pop-mark) (pop-mark)))) #+end_src Shadow the AucTeX version of this function #+begin_src emacs-lisp (defun LaTeX-insert-environment (environment &optional extra) "Insert LaTeX ENVIRONMENT with optional argument EXTRA." (let ((active-mark (and (TeX-active-mark) (not (eq (mark) (point))))) prefix content-start env-start env-end) (when (and active-mark (< (mark) (point))) (exchange-point-and-mark)) ;; Compute the prefix. (when (and LaTeX-insert-into-comments (TeX-in-commented-line)) (save-excursion (beginning-of-line) (looking-at (concat "^\\([ \t]*" TeX-comment-start-regexp "+\\)+[ \t]*")) (setq prefix (match-string 0)))) ;; What to do with the line containing point. (cond (;; if the line contains only whitespace, delete them (save-excursion (beginning-of-line) (looking-at (concat prefix "[ \t]*$"))) (delete-region (match-beginning 0) (match-end 0))) ;; otherwise, something is written on the line. We can be ;; at the beginning of the text ((TeX-looking-at-backward (concat "^" prefix "[ \t]*") (line-beginning-position)) ;;this morally opens a new line (beginning-of-line) (newline) (beginning-of-line 0)) ((bolp) (delete-horizontal-space) (newline) (beginning-of-line 0)) ((looking-at "[ \t]*$") (delete-horizontal-space) (newline) (when prefix (insert prefix)) (beginning-of-line)) (t (delete-horizontal-space) (newline 2) (when prefix (insert prefix)) (beginning-of-line 0))) ;; What to do with the line containing mark. (when active-mark (save-excursion (goto-char (mark)) (cond ((save-excursion (beginning-of-line) (or (looking-at (concat prefix "[ \t]*$")) (looking-at "[ \t]*$"))) (delete-region (match-beginning 0) (match-end 0))) ((TeX-looking-at-backward (concat "^" prefix "[ \t]*") (line-beginning-position)) (beginning-of-line) (newline) (beginning-of-line 0)) ((looking-at "[ \t]*$") (delete-horizontal-space) (insert-before-markers "\n") ;(newline) (when prefix (insert prefix))) (t (delete-horizontal-space) (insert-before-markers "\n") (newline) (when prefix (insert prefix)))))) ;; Now insert the environment. (when prefix (insert prefix)) (setq env-start (point)) (insert TeX-esc "begin" TeX-grop environment TeX-grcl) (indent-according-to-mode) (when extra (insert extra)) (setq content-start (line-beginning-position 2)) (unless active-mark (newline) (when prefix (insert prefix)) (newline)) (when active-mark (goto-char (mark))) (when prefix (insert prefix)) (insert TeX-esc "end" TeX-grop environment TeX-grcl) (end-of-line 0) (if active-mark (progn (or (assoc environment LaTeX-indent-environment-list) (if auto-fill-function ;; Fill the region only when `auto-fill-mode' is active. (LaTeX-fill-region content-start (line-beginning-position 2)))) (set-mark content-start)) (indent-according-to-mode)) (save-excursion (beginning-of-line 2) (indent-according-to-mode)) (TeX-math-input-method-off) (setq env-end (save-excursion (search-forward (concat TeX-esc "end" TeX-grop environment TeX-grcl)) (match-beginning 0))) (run-hook-with-args 'LaTeX-after-insert-env-hooks environment env-start env-end))) #+end_src *** Patch auctex I don't particularly like the way that the prefix arguments works with font selection. The function below patches the annoying behavior, by defaulting to the default behavior if the prefix argument is 0 #+begin_src emacs-lisp (defun wilder/TeX-font (replace what) "Insert template for font change command. If REPLACE is not nil, replace current font. WHAT determines the font to use, as specified by `TeX-font-list'." (interactive "*P\nc") (TeX-update-style) (let* ((entry (assoc what TeX-font-list)) (in-math (texmathp)) (before (nth 1 entry)) (after (nth 2 entry))) (setq replace (or replace (eq t (nth 3 entry)) (eq t (nth 5 entry)))) (if (and in-math (stringp (nth 3 entry))) (setq before (nth 3 entry) after (nth 4 entry))) (setq arg (prefix-numeric-value replace)) (cond ((null entry) (let ((help (concat "Font list: " "KEY TEXTFONT MATHFONT\n\n" (mapconcat 'TeX-describe-font-entry TeX-font-list "\n")))) (with-output-to-temp-buffer "*Help*" (set-buffer "*Help*") (insert help)))) ((and replace (eq 0 arg)) (funcall TeX-font-replace-function before after)) ((and replace (< arg 0) ) (progn (save-excursion (backward-sexp (- 0 arg)) (insert before)) (insert after))) ((and replace (> arg 0)) (insert before) (save-excursion (forward-sexp arg) (insert after))) ((TeX-active-mark) (save-excursion (cond ((> (mark) (point)) (insert before) (goto-char (mark)) (insert after)) (t (insert after) (goto-char (mark)) (insert before))))) (t (insert before) (save-excursion (insert after)))))) (advice-add 'TeX-font :override #'wilder/TeX-font) #+end_src *** The hook #+begin_src emacs-lisp (add-hook 'LaTeX-mode-hook (lambda () (turn-on-reftex) (setq comment-column 0) (setq prettify-symbols-alist nil) (add-to-list 'prettify-symbols-alist '(" ⊂ " . (? (Br . Bl) ? (Br . Bl) ?))) (turn-on-auto-fill) (subword-mode) (TeX-fold-mode 1) (outshine-mode))) #+end_src *** Compilation fixes Load appropriate compliation filters for warnings #+begin_src emacs-lisp (load "latex-compile-filters.el") #+end_src Fix erroneous parsing of the LuaLaTeχ output "avail lists" as an error (works on ≥ emacs-27.1) #+begin_src emacs-lisp (add-to-list 'compilation-transform-file-match-alist '(" avail lists" nil)) #+end_src *** Load ~bibretrieve~ #+begin_src emacs-lisp (byte-recompile-directory "~/.emacs.d/bibretrieve" 0) (load "bibretrieve") (setq bibretrieve-backends '(("msn" . 10))) (require 'biblio) #+end_src ** TODO KDE integration *** TODO cleanup and split These functions connects to dbus to find out the current activity id and name #+begin_src emacs-lisp (defun kde-current-activity () "Returns the current KDE activity" (substring (shell-command-to-string "qdbus org.kde.ActivityManager /ActivityManager/Activities org.kde.ActivityManager.Activities.CurrentActivity") 0 -1) ) (defun kde-current-activity-name () "Returns the name of the current KDE activity" (substring (shell-command-to-string (concat "qdbus org.kde.ActivityManager /ActivityManager/Activities org.kde.ActivityManager.Activities.ActivityName " (kde-current-activity))) 0 -1)) #+end_src #+begin_src emacs-lisp (defun X-window-id-belongs-to-activity (window-id activity) (= (shell-command (concat "xprop -id " window-id " | grep _KDE_NET_WM_ACTIVITIES | grep " activity ">/dev/null")) 0) ) (defun select-frame-on-activity (activity) (setq framelist (frame-list)) (setq done nil) (while (and framelist (not done)) (setq cur (car framelist)) (setq cur-id (cdr (assq 'window-id (frame-parameters cur)))) (if cur-id (if (X-window-id-belongs-to-activity cur-id activity) (progn; (setq done 't) (select-frame cur)) )) (setq framelist (cdr framelist))) done ) (defun select-X-frame () (setq framelist (frame-list)) (setq done nil) (while (and framelist (not done)) (setq cur (car framelist)) (setq cur-id (cdr (assq 'window-id (frame-parameters cur)))) (if cur-id (progn; (setq done 't) (raise-frame cur))) (setq framelist (cdr framelist))) done ) #+end_src This function is used to raise the frame associated to the current activity *** TODO These entries should be added to the subtree once it is split #+begin_src emacs-lisp (defun select-frame-on-current-activity () (select-frame-on-activity (kde-current-activity))) #+end_src I prefer to keep one server for each KDE activity, so set the server name to be the name of the current activity #+begin_src emacs-lisp ; (setq server-name (kde-current-activity-name)) #+end_src *** Journal Setup ~org-journal~ #+begin_src emacs-lisp (require 'org-journal) (setq org-journal-dir "~/org/journal" org-journal-file-type 'yearly org-journal-file-format "%Y" org-journal-encrypt-journal t) #+end_src * Specialties ** beacon =beacon= is a package that helps finding the point when switching buffers. I like the idea but the aesthetics is a bit baroque. I should do the same with =flash-hline= ** flash-hline This function is defined to help in training with new keybindings. It acts as a visual bell which flashes the current line. It is (arbitrarily) bound to F15 which is supposed to be triggered by some “illegal” key hit #+begin_src emacs-lisp (defun flash-hline () "Flash the current line to emph some mistake" (interactive) (let ((fg (face-foreground 'default)) (bg (face-background 'hl-line))) (set-face-background 'hl-line fg) (run-with-timer 0.1 nil (lambda () (set-face-background 'hl-line "#303030") )))) (global-set-key (kbd "") 'flash-hline) #+end_src ** unfill-paragraph This is authored by Stefan Monnier . It is the opposite of fill-paragraph #+begin_src emacs-lisp (defun unfill-paragraph (&optional region) "Takes a multi-line paragraph and makes it into a single line of text." (interactive (progn (barf-if-buffer-read-only) '(t))) (let ((fill-column (point-max)) ;; This would override `fill-column' if it's an integer. (emacs-lisp-docstring-fill-column t)) (fill-paragraph nil region))) #+end_src ** kill-word dwim manage space after kill-word. This has been morally pasted from [[https://www.reddit.com/r/emacs/comments/3nlws0/automanage_spaces_post_word_kills/][this reddit post]]. The original version does not allow for double spaces after a period. #+begin_src emacs-lisp (defun modi/just-one-space-post-kill-word (&rest _) "Function to manage white space after `kill-word' operations. 1. If point is at the beginning of the line after possibly some white space, remove that white space and re-indent that line. 2. If there is space before or after the point, ensure that there is only one white space around the point. 3. Otherwise, do nothing. During the whole operation do not change the point position with respect to the surrounding white space. abc| def ghi <-- point on the left of white space after 'abc' abc| ghi <-- point still before white space after calling this function abc |def ghi <-- point on the right of white space before 'def' abc |ghi <-- point still after white space after calling this function." (save-excursion ; maintain the initial position of the pt with respect to space (cond ((looking-back "^ *") ; remove extra space at beginning of line (just-one-space 0) (indent-according-to-mode)) ((looking-back "\\. *") (just-one-space 2)) ((or (looking-at " ") (looking-back " ")) ; adjust space only if it exists (just-one-space 1)) (t ; do nothing otherwise, includes case where the point is at EOL )))) ;; Delete extra horizontal white space after `kill-word' and `backward-kill-word' (advice-add 'kill-word :after #'modi/just-one-space-post-kill-word) #+end_src #+results: ** word-count Add word count in modeline; useful to prepare those pesky grant applications #+begin_src emacs-lisp (require 'word-count) #+end_src ** gist Use [[https://github.com/defunkt/gist.el][gist.el]] #+begin_src emacs-lisp (require 'gist) #+end_src * Main packages ** Magit #+begin_src emacs-lisp (require 'magit) (global-set-key (kbd "C-x C-g") 'magit-status) (magit-add-section-hook 'magit-status-sections-hook #'magit-insert-modules-overview #'magit-insert-unpushed-to-pushremote :append) (magit-add-section-hook 'magit-status-sections-hook #'magit-insert-untracked-files #'magit-insert-modules-overview :append) #+end_src *** magit-todos #+begin_src emacs-lisp (require 'magit-todos) #+end_src ** smart-tab This package is a gem: it allows to make tab work dwim #+begin_src emacs-lisp (require 'smart-tab) (global-smart-tab-mode 1) #+end_src ** Outshine #+begin_src emacs-lisp (defvar outline-minor-mode-prefix "\M-#") (setq outshine-use-speed-commands t) (with-eval-after-load 'outshine (define-key outshine-mode-map (kbd "C-M-i") nil)) (add-hook 'sh-mode-hook 'outshine-mode) (require 'outshine) (require 'outorg) #+end_src Cook up some extra narrowing function #+begin_src emacs-lisp (defun goto-next-comment-line () (interactive) (re-search-forward "^\\S<" nil 1) (re-search-forward "^\\s<" nil 1) (beginning-of-line) ) (defun goto-previous-comment-line () (interactive) (re-search-backward "^\\s<" nil 1 ) (re-search-backward "^\\S<" nil 1 ) (beginning-of-line) (unless (bobp) (next-line)) ) (defun narrow-between-comments () (interactive) (save-excursion (next-line) (goto-previous-comment-line) (setq beginning (point))) (save-excursion (goto-next-comment-line) (unless (bobp) (previous-line) (end-of-line)) (setq ending (point))) (narrow-to-region beginning ending)) #+end_src ** helm #+begin_src emacs-lisp (require 'helm-config) (helm-mode 1) (defun fix-helm-margins () (setq helm-left-margin-width left-margin-width)) (global-set-key-alist '(("M-x" . helm-M-x) ("C-x C-f" . helm-find-files) ("C-x b" . helm-mini) ("C-x C-b" . helm-mini) ("M-y" . helm-show-kill-ring))) (define-key helm-map (kbd "C-h") nil) (define-key helm-find-files-map (kbd "C-h") nil) (define-key helm-find-files-map (kbd "C-") nil) (define-key helm-read-file-map (kbd "C-") nil) (helm-define-key-with-subkeys helm-find-files-map (kbd "DEL") ?\d 'helm-ff-delete-char-backward '(([C-c DEL] . helm-ff-run-toggle-auto-update)) nil 'helm-ff-delete-char-backward--exit-fn) (add-hook 'helm-after-initialize-hook 'fix-helm-margins) #+end_src ** multiple-cursors #+begin_src emacs-lisp (require 'multiple-cursors) (define-key mc/keymap (kbd "") nil) (global-set-key-alist '(("C->" . mc/mark-next-like-this) ("C-<" . mc/mark-previous-like-this) ("C-c C-<" . mc/mark-all-like-this) ("C-c C-#" . mc/insert-numbers) ("C-c C-\\" . mc/mark-all-dwim) ("C-c " . mc/mark-pop) ("C-c " . mc/mark-pop))) #+end_src ** =avy= and =avy-zap= These packages allow fast navigation and zapping #+begin_src emacs-lisp (require 'avy-zap) (avy-setup-default) (global-set-key-alist '(("C-c C-j" . avy-resume) ("M-z" . avy-zap-up-to-char-dwim) ("M-Z" . avy-zap-to-char-dwim) ("C-c SPC" . avy-goto-word-or-subword-1) ("M-s" . avy-goto-word-or-subword-1) ("M-g M-g" . avy-goto-line) ("M-g g" . avy-goto-line))) (require 'ace-window) (global-set-key (kbd "M-o") 'ace-window) (setq aw-keys '(?f ?j ?d ?k ?s ?l ?a ?g ?h) aw-scope 'frame aw-ignore-current t) (require 'ace-link) ; (defalias 'avy-process 'avy--process) (ace-link-setup-default) (setq avy-styles-alist nil avy-background t) ; (add-to-list 'avy-styles-alist '(ace-link-org-agenda . at-full)) ; (add-to-list 'avy-styles-alist '(ace-link-org . at-full)) (define-key org-mode-map (kbd "C-c M-o") 'ace-link-org) (define-key org-agenda-mode-map (kbd "C-c M-o") 'ace-link-org) #+end_src ** expand-region This is an excellent package, although I do not use it that much I should find a better binding #+begin_src emacs-lisp (require 'expand-region) (global-set-key (kbd "C-=") 'er/expand-region) #+end_src ** ERC Enable ~erc dcc~ files transfer #+begin_src emacs-lisp (require 'erc-dcc) #+end_src ** vterm #+begin_src emacs-lisp (require 'vterm) #+end_src ** TODO Phase out Package.el Load package.el #+begin_src emacs-lisp (require 'package) (add-to-list 'package-archives '("melpa-stable" . "http://stable.melpa.org/packages/") t) #+end_src * Tidy-up ** Save emacs-session files in appropriate directory Save session files to the ~sessions~ directory so that they do not litter the ~.emacs.d~ base directory. #+begin_src emacs-lisp (defun emacs-session-filename (session-id) "Construct a filename to save the session in based on SESSION-ID. If the directory ~/.emacs.d exists, we make a filename in there, otherwise a file in the home directory." (let ((basename (concat "sessions/session." session-id)) (emacs-dir user-emacs-directory)) (expand-file-name (if (file-directory-p emacs-dir) (concat emacs-dir basename) (concat "~/.emacs-" basename))))) #+end_src * Moving to colemak #+begin_src emacs-lisp (defun set-key-translation-map (pairs) (dolist (p pairs) (define-key key-translation-map (kbd (downcase (car p))) (kbd (downcase (cdr p)))) (define-key key-translation-map (kbd (upcase (car p))) (kbd (upcase (cdr p)))))) (defun reset-key-translation-map () (dolist (c '("j" "k" "n" "e")) (define-key key-translation-map (kbd (downcase c)) nil) (define-key key-translation-map (kbd (upcase c)) nil))) (defun tarmak1 () (interactive) (set-key-translation-map '(("j" . "n") ("k" . "e") ("n" . "k") ("e" . "j")))) (defun qwerty() (interactive) (reset-key-translation-map)) #+end_src * Finale ** Fixup faces This is really a workaround as I do not like either bold or italic. It needs to be at the end of the file since it sets the face for packages that have loaded in the meantime; yet it does not work perfectly as some packages are still to be loaded (most notably ~magit~) #+begin_src emacs-lisp ;; (set-face-font 'default "-xos4-hackminus-medium-r-normal--20-200-72-72-c-100-ISO10646-1") (set-face-bold 'bold nil) (wilder/fixup-faces) (with-eval-after-load "info" (wilder/fixup-faces) nil) (with-eval-after-load "mu4e" (wilder/fixup-faces) nil) (with-eval-after-load "vterm" (wilder/fixup-faces) nil) #+end_src ** Start server #+begin_src emacs-lisp ; (server-start) #+end_src