56 KiB

Raw Blame History Unescape Escape

emacs init file

Uniformize indentation
Look at tangling at
Introduction
- setq vs setq-default
- Why not package.el
Files and dirs
Themes
Global settings
Main major modes
Specialties
Main packages
Tidy-up
- Save emacs-session files in appropriate directory
Finale
- Fixup faces
- Start server

TODO Uniformize indentation

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

Or makefile approach [https://emacs.stackexchange.com/questions/27126/is-it-possible-to-org-bable-tangle-an-org-file-from-the-command-line]

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

  (setq custom-file "~/.emacs.d/custom.el")
  (load custom-file 'noerror)

Add relevant dirs to load path [This is somewhat undesirable; I should uniformize the path-loading business at some point…]

  (let ((default-directory "~/.emacs.d/"))
    (normal-top-level-add-subdirs-to-load-path)
    (normal-top-level-add-to-load-path '("fringe-helper.el"
                                         "multiple-cursors.el"
                                         "expand-region.el"
                                         "dash.el"
			                       "webpaste.el")))

Put autosave files (ie #foo#) and backup files (ie foo~) in ~/.emacs.d/. create the autosave dir if necessary, since emacs won't.

  (make-directory "~/.emacs.d/autosaves/" t)
  (make-directory "~/.emacs.d/backup/" t)

Themes

Use (my clone of) the solarized theme

  (add-to-list 'custom-theme-load-path "/home/jacopods/.emacs.d/emacs-color-theme-solarized")
  (load-theme 'lunarized t)

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

  (set-face-font 'default "-xos4-hackminus-medium-r-normal--20-200-72-72-c-100-ISO10646-1")

Global settings

Global helper funs

This is a helper function used to set several global keys given in provided as a paremeter in binding-alist

  (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"
    (mapcar
     (lambda (binding)
       (global-set-key (kbd (car binding)) (cdr binding))) binding-alist))

  (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"
    (mapcar
     (lambda (binding)
       (define-key keymap (kbd (car binding)) (cdr binding))) binding-alist))

Cosmetics

Prefer a minimal appearance: no menu, toolbar or scroll-bars; no splash screens or messages

  (menu-bar-mode -1)
  (tool-bar-mode 0)
  (scroll-bar-mode -1)
  (setq inhibit-startup-screen t
        inhibit-startup-message t)

a blinking cursor keeps the gpu awake; add global hl-line mode to more easily spot the cursor

  (blink-cursor-mode 0)
  (set-default 'cursor-type 'box)
  (global-hl-line-mode t)

Set frame title

  (setq frame-title-format
     '((buffer-file-name "%f"
         (dired-directory dired-directory "%b")) " · emacs"));; · " (:eval (kde-current-activity-name)))) ;; "%S"))

Themed tooltips

(setq x-gtk-use-system-tooltips nil)

Set fill-column to 72, which happens to be good for third-tiled frames and it also is a reasonable standard

  (setq default-fill-column 72)

Highlight sexp (apparently I am not even using this)

  ;(require 'highlight-sexps)

Mouseless

Disable mouse interaction with emacs

  (mouse-wheel-mode -1)
  (setq mouse-autoselect-window nil
        mouse-yank-at-point nil
        focus-follows-mouse nil)

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]

  (require 'disable-mouse)
  (global-disable-mouse-mode)

Window behavior

Prevent compilation window eating up other windows

   (setq compilation-scroll-output t
         compilation-window-height 12)

Prevent any automatic splitting to split vertically

  (setq split-height-threshold 0)

Scrolling

Scrolling setup

   (setq redisplay-dont-pause t
         scroll-margin 3
         scroll-step 1
         scroll-conservatively 10000
         scroll-preserve-screen-position 1)

TODO find out what this was actually meant to do

  (setq-default display-buffer-reuse-frames t)

Modeline

  (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 mode-line-format
                     '("%e"
                       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
                       (:propertize " " face mode-line-indicator)
                       wilder/mode-line-modes
                       mode-line-misc-info
                       mode-line-end-spaces))

The following has been found in here to clean up the modeline

  (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)

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]

  (prefer-coding-system 'utf-8)

Mark handling

No transient mark is more flexible

(transient-mark-mode 0)

But of course we need to see the mark

(require 'visible-mark)
(visible-mark-mode t)
(global-visible-mark-mode t)

The following are some convenient bindings; notice that on my layout F13 and F14 are obtained by tapping the left and right shift respectively

  (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
   '(("<f13>"   . set-mark-command)
     ("<f14>"   . set-mark-command)
     ("<M-f13>" . jump-to-mark)
     ("<M-f14>" . jump-to-mark)
     ("<S-f13>" . just-activate-mark)
     ("<S-f14>" . just-activate-mark)))

Global bindings

Remove some supremely annoying bindings

  (mapcar
   (lambda (ch)
     (global-unset-key (kbd ch)))
     '("C-z" "C-x f" "<M-f4>" "C-M-u" "C-M-d"))

Change {up,down}-list

  (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/

Add some opinionated bindings

  (global-set-key-alist
   '(("C-M-d"           . kill-sexp)
     ("C-M-<backspace>" . backward-kill-sexp)
     ("C-x k"           . kill-this-buffer)
     ("C-S-v"           . scroll-down-command)
     ("C-M-u"           . universal-argument)))

Disable commands

Enable narrow commands

  (put 'narrow-to-region 'disabled nil)
  (put 'LaTeX-narrow-to-environment 'disabled nil)
  (put 'narrow-to-page 'disabled nil)

Smart beginning-of-line

This is a relatively smart way to go back to the beginning of the line

  (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)

Whitespace

Trailing whitespace is evil; get rid of it

  (setq-default show-trailing-whitespace t)
  (add-hook 'before-save-hook 'delete-trailing-whitespace)

Define what is whitespace during a search

     (setq search-whitespace-regexp "[ \t\r\n]+")

Tabs are evil; get rid of them

  (setq c-basic-offset 4)
  (setq-default tab-width 4
                indent-tabs-mode nil)

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

  (show-paren-mode 1)

TODO find out if there are better options out there

Abbrevs

Set up abbrevs

   (setq-default abbrev-mode t)
   (read-abbrev-file "~/.abbrev_defs")
   (setq save-abbrevs t)

Spellcheck

Use flyspell

   (add-hook 'text-mode-hook 'flyspell-mode)
   (setq flyspell-use-meta-tab nil)

Fringe treatment

TODO try linum-relative

;      (require 'linum-relative)
;      (linum-relative-mode 1)

Add line numbers globally

;    (global-linum-mode 1)

Highlight also the linum in the fringe

;    (require 'hlinum)
;    (hlinum-activate)

Add marker for current line in the fringe (see [https://github.com/kyanagi/fringe-current-line] and [https://github.com/nschum/fringe-helper.el])

  (fringe-mode 10)
  (require 'fringe-current-line)
  (global-fringe-current-line-mode 1)

  (defun +-fringe-helper-decimal (&rest strings)
  "Convert STRINGS into a vector usable for `define-fringe-bitmap'.
  Each string in STRINGS represents a line of the fringe bitmap.
  Periods (.) are background-colored pixel; Xs are foreground-colored. The
  fringe bitmap always is aligned to the right. If the fringe has half
  width, only the left 4 pixels of an 8 pixel bitmap will be shown.
  For example, the following code defines a diagonal line.
  \(+-fringe-helper-decimal
  \"XX......\"
  \"..XX....\"
  \"....XX..\"
  \"......XX\"\)"
    (unless (cdr strings)
      (setq strings (split-string (car strings) "\n")))
    (apply 'vector
      (mapcar
        (lambda (str)
          (let ((num 0))
            (dolist (c (string-to-list str))
              (setq num (+ (* num 2) (if (eq c ?.) 0 1))))
            num))
        strings)))
  (define-fringe-bitmap '+-cursor-left-fringe-bitmap (+-fringe-helper-decimal
    "x......."
    "xx......"
    "xxx....."
    "xxxx...."
    "xxxxx..."
    "xxxxxx.."
    "xxxxxxx."
    "xxxxxxxx"
    "xxxxxxx."
    "xxxxxx.."
    "xxxxx..."
    "xxxx...."
    "xxx....."
    "xx......"
    "x.......") nil nil 'center)


  (setq fcl-fringe-bitmap '+-cursor-left-fringe-bitmap)

Turn on echo mode

Display unfinished commands in the echo area after the specified delay.

  (setq echo-keystrokes 0.10)

Disable completion buffer

Remove the completion buffer as soon as we get out of the minibuffer

  (add-hook 'minibuffer-exit-hook
            '(lambda ()
               (let ((buffer "*Completions*"))
                 (and (get-buffer buffer)
                      (kill-buffer buffer))) ))

Auto save on compile

  (setq compilation-ask-about-save nil)

Idle-kill

  (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)

Calendar

  (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)

Use system proxy

     ;; Use system proxy
    (setq url-proxy-services '(("http" . "127.0.0.1:8118")))

Indicator

Change cursor color to reflect different layers on the keyboard This is the handler

  (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 "#859900")))
  (set-face-background 'cursor "#919191")))

Connect the signal from xkbvleds to the handler

  (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)

Main major modes

org-mode

Require

Require the org package; I also occasionally use org-pomodoro

  (with-eval-after-load "org"
    (define-key org-src-mode-map (kbd "C-c C-c") 'org-edit-src-exit))
  (require 'org)
  (require 'org-pomodoro)

Hooks

Enable auto-fill-mode (see [https://www.gnu.org/software/emacs/manual/html_node/emacs/Auto-Fill.html]) honestly I do not see where I would not want to use this.

  (add-hook 'org-mode-hook 'turn-on-auto-fill)

Cosmetics

Change the default ellipsis ... to the unicode ellipsis … Does not work properly

;      (setq org-ellipsis "…")

Ligatures

These require a patched hackminus font. Too bad it does not work for some reason

  ;; (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)

Links

Open links with external stuff

  (setq org-file-apps
        '((auto-mode . emacs)
          ("\\.x?html?\\'" . "xdg-open %s")
          ("\\.pdf\\'" . "xdg-open \"%s\"")))

Agenda

Set the canonical binding for the agenda

 (global-set-key (kbd "C-c a") 'org-agenda)

Define agenda files: the main one is master.org, but then I have a bunch of them on orgzly

  (setq org-agenda-files
  '("~/org/master.org"
    "~/org/orgzly/work.org"
    "~/org/orgzly/hack.org"
    "~/org/orgzly/live.org"
    "~/org/orgzly/refile.org"))

Default to daily agenda

  (setq org-agenda-span 1)

Prevent headlines to be marked as DONE if some sub-headings are still TODO.

  (setq org-enforce-todo-dependencies t)

Do not show scheduled or deadline'd stuff in the Global TODO list

  (setq org-agenda-todo-ignore-deadlines 'all)
  (setq org-agenda-todo-ignore-scheduled 'all)

Do not show stuff marked with DONE even if they have a deadline

  (setq org-agenda-skip-deadline-if-done t)

Custom separator

  (setq org-agenda-block-separator ?─)

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

  (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")))))

Custom agenda view

(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-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))))

Reverting stuff from orgzly

  (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))))))
  (define-key org-agenda-mode-map (kbd "Z") 'org-revert-all-orgzly-buffers)

Capture

Set default keybinding

  (global-set-key (kbd "C-c c") 'org-capture)

This is my capture template: it needs to be revised as I really do not use The Idea, journal and break entry

 (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:%?")))

Source blocks

Add template for a source block in emacs-lisp. This is useful for writing the emacs init file in literate form

 (add-to-list 'org-structure-template-alist
'("el" "#+BEGIN_SRC emacs-lisp\n?\n#+END_SRC"))

Fontify src blocks

  (setq org-src-fontify-natively t)

Clocking

 ;; 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)

Tangle to different files

This is some some super-clever stuff. See [https://emacs.stackexchange.com/questions/39032/tangle-the-same-src-block-to-different-files]

(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 'light))
(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))))
(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)
(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)

elisp

Paredit

  (autoload 'enable-paredit-mode "paredit" "Turn on
  pseudo-structural editing of Lisp code." t)
  (add-hook 'emacs-lisp-mode-hook #'enable-paredit-mode)
  (with-eval-after-load "paredit"
    (define-key-alist paredit-mode-map
      '(("C-H-l" . paredit-forward-slurp-sexp)
        ("C-H-M-j" . paredit-backward-slurp-sexp)
        ("C-H-j" . paredit-forward-barf-sexp)
        ("C-H-M-l" . paredit-backward-barf-sexp))))

Replace last sexp

I use this a lot to evaluate (e.g.) quick computations in files

  (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)

qml

Load qml-mode

  (autoload 'qml-mode "qml-mode.el" t)
  (add-to-list 'auto-mode-alist '("\\.qml\\'" . qml-mode))

C and C++

Hooks

  (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)))

TODO split — LaTeX

TODO Setup `reftex`

  (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?")))))

Setup `latex-mode`

  (eval-after-load 'latex
    '(progn
       (font-lock-add-keywords 'latex-mode
                               `((,(rx "$") 0 'font-latex-sedate-face t)) t)

       (define-key-alist LaTeX-mode-map
         '(("M-S-SPC"      . TeX-insert-braces)
           ("C-c C-v"      . wilder/TeX-insert-reference)
           ("C-M-<return>" . wilder/TeX-insert-align-dwim)
           ;; unbind return - NOTE it is important to unbind
           ;; <return> and not RET. If we unbind RET then C-m won't work
           ;; either.
           ("<return>"   . (lambda() (interactive) (insert "\\")))
           ("S-<return>" . (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/
           ("<f4>"    . ( lambda() (interactive) (message "Use C-c C-c")))
           ("C-c C-c" . ( lambda() (interactive) (compile "/home/jacopods/scripts/latex-mk")) )
           ("~"       . wilder/TeX-replace-tilde)
           ;; Force moves around to be more “semantic”
           ("C-v"     . forward-paragraph)
           ("M-v"     . backward-paragraph)
           ("C-S-v"   . backward-paragraph)))

       (mapcar (lambda (ch)
                 (define-key LaTeX-mode-map (kbd ch) 'insert-char-with-padding))
               '("=" "≠" ">" "<" "≥" "≤" "⇒" "∩" "∪" "∨" "∧" "×" "⊂" "⊃"))

       ))

Require

Load auctex, reftex and set up related hooks

 (require 'tex-site)
 (require 'reftex)

Set default TeX options

  (setq-default TeX-master nil)
  (setq TeX-auto-save t
        TeX-parse-self t
        TeX-insert-braces nil)

Appearance

No fontification for sub and superscripts

  (setq font-latex-fontify-script nil)

Add unicode quotes to the quote-list

;      (defvar font-latex-quote-list '(("``" "''") ("“" "”") ("<<" ">>" french) ("«" "»" french)) ;

Default labels

 (setq LaTeX-equation-label "e_"
       LaTeX-section-label "s_"
       LaTeX-figure-label "f_")

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]

  (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)
            ))
         (cadr ispell-tex-skip-alists)))

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

  (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))))

The following re-implements TeX-insert-braces to work with negative argument

  (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)))

This is a helper for Dynamic abbrev expansion

  (defun dabbrev-expand-helper ()
    (interactive)
     (call-interactively 'dabbrev-expand))

This inserts a char adding some whitespace padding whenever necessary

(defun insert-char-with-padding (arg)
    (interactive "*P")
    (if (string= (string (preceding-char)) " ") ()
  (if (string= (string (preceding-char)) "\&") () (insert " ")))
    (self-insert-command (prefix-numeric-value arg))
    (if (string= (string (following-char)) " ") () (insert " ")) ;; decide what to do with the point
  )

This inserts a plain reference (or a reference to an equation with prefix arg)

(defun wilder/TeX-insert-reference (arg)
          (interactive "P")
          (insert "~")
          (if arg (TeX-insert-macro "eqref")
            (TeX-insert-macro "ref")))

This inserts a citation

(defun wilder/TeX-insert-cite (arg)
          (interactive "P")
          (insert "~")
          (TeX-insert-macro "cite"))

This inserts an align environment (or an align* with prefix arg)

  (defun wilder/TeX-insert-align (arg)
    (interactive "P")
    (if arg
        (LaTeX-insert-environment "align")
      (LaTeX-insert-environment "align*")))

  (defun wilder/TeX-insert-align-dwim (arg)
    (interactive "P")
    (if (texmathp) (wilder/TeX-promote-inline-math arg)
      (wilder/TeX-insert-align arg)))

This replaces horizontal space with a tilde

  (defun wilder/TeX-replace-tilde (arg)
  (interactive "P")
  (delete-horizontal-space)
  (insert "~"))

Insert a todonote at point or wrap the region in a todonote.

  (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)))

Promote inline math to an align

  (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))))

The hook

  (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)

          ;; Move around commands in the Right Way™
          (modify-syntax-entry ?\\ "w" LaTeX-mode-syntax-table)
          (setq subword-forward-regexp "\\W*\\(\\([\\\\[:upper:]]*\\W?\\)[[:lower:][:digit:]]*\\)")
          (setq subword-backward-regexp "\\(\\(\\W\\|[[:lower:][:digit:]]\\)\\([\\\\[:upper:]]+\\W*\\)\\|\\W\\w+\\)")



        ))

TODO Leftovers

  (setq TeX-fold-ellipsis " …")

        (load "latex-compile-filters.el")

Finally load bibretrieve

  (byte-recompile-directory "~/.emacs.d/bibretrieve" 0)
  (load "bibretrieve")
  (setq bibretrieve-backends '(("mrl" . 8) ("arxiv" . 5)))

TODO KDE integration

TODO cleanup and split

These functions connects to dbus to find out the current activity id and name

  (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))

  (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
  )

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

  (defun select-frame-on-current-activity ()
  (select-frame-on-activity (kde-current-activity)))

I prefer to keep one server for each KDE activity, so set the server name to be the name of the current activity

;      (setq server-name (kde-current-activity-name))

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

  (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 "<f15>") 'flash-hline)

unfill-paragraph

This is authored by Stefan Monnier <foo at acm.org>. It is the opposite of fill-paragraph

  (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)))

kill-word

dwim manage space after kill-word. This has been morally pasted from this reddit post. The original version does not allow for double spaces after a period.

  (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)

word-count

Add word count in modeline; useful to prepare those pesky grant applications

  (require 'word-count)

Main packages

Magit

  (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)

magit-todos

  (require 'magit-todos)

smart-tab

This package is a gem: it allows to make tab work dwim

  (require 'smart-tab)
  (global-smart-tab-mode 1)

Outshine

  (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)

helm

  (require 'helm-config)
  (helm-mode 1)

  (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-<backspace>") 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)

multiple-cursors

  (require 'multiple-cursors)
  (define-key mc/keymap (kbd "<return>") 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 <f13>" . mc/mark-pop)
     ("C-c <f14>" . mc/mark-pop)))

`avy` and `avy-zap`

These packages allow fast navigation and zapping

  (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)

expand-region

This is an excellent package, although I do not use it that much I should find a better binding

  (require 'expand-region)
  (global-set-key (kbd "C-=") 'er/expand-region)

Atomic chrome

This is commented out as it is incompatible with the multiple-activity business that I like to keep

; (require 'atomic-chrome)
;;  (atomic-chrome-start-server)

ERC

Enable erc dcc files transfer

  (require 'erc-dcc)

TODO Phase out Package.el

Load package.el

  (require 'package)
  (add-to-list 'package-archives
 '("melpa-stable" . "http://stable.melpa.org/packages/") t)

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.

  (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)))))

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 wark perfectly as some packages are still to be loaded (most notably magit)

;; (set-face-font 'default "-xos4-hackminus-medium-r-normal--20-200-72-72-c-100-ISO10646-1")
(set-face-bold 'bold nil)
 (mapc
    (lambda (face)
(set-face-attribute face nil :weight 'normal)
(set-face-attribute face nil :slant 'normal))
    (face-list))

Start server

;    (server-start)

56 KiB Raw Blame History Unescape Escape

emacs init file

TODO Uniformize indentation

TODO Look at tangling at

Introduction

setq vs setq-default

Why not package.el

Files and dirs

Themes

Global settings

Global helper funs

Cosmetics

Mouseless

TODO Find out what of the above is necessary given the disable-mouse mode below

Window behavior

Scrolling

TODO find out what this was actually meant to do

Modeline

Coding system

Mark handling

Global bindings

Disable commands

Smart beginning-of-line

Whitespace

TODO Have a look at ws-trim.el

Show matching parens

TODO find out if there are better options out there

Abbrevs

Spellcheck

Fringe treatment

TODO try linum-relative

Turn on echo mode

Disable completion buffer

Auto save on compile

Idle-kill

Calendar

Use system proxy

Indicator

Main major modes

org-mode

Require

Hooks

Cosmetics

Ligatures

Links

Agenda

Reverting stuff from orgzly

Capture

Source blocks

Clocking

Tangle to different files

elisp

Paredit

Replace last sexp

qml

C and C++

Hooks

TODO split — LaTeX

TODO Setup reftex

Setup latex-mode

Require

Set default TeX options

Appearance

Default labels

Spell checking help

Specialty functions

The hook

TODO Leftovers

TODO KDE integration

TODO cleanup and split

TODO These entries should be added to the subtree once it is split

Specialties

beacon

flash-hline

unfill-paragraph

kill-word

word-count

Main packages

Magit

magit-todos

56 KiB

Raw Blame History Unescape Escape

`setq` vs `setq-default`

Why not `package.el`

TODO Setup `reftex`

Setup `latex-mode`

`avy` and `avy-zap`