Some org-bable config

2 files changed, 2716 insertions, 0 deletions

diff --git a/init.d/.gitignore b/init.d/.gitignore
new file mode 100644
index 0000000..abf136d
--- /dev/null
+++ b/init.d/.gitignore
@@ -0,0 +1 @@
+*.el
diff --git a/init.d/main.org b/init.d/main.org
new file mode 100644
index 0000000..db999ab
--- /dev/null
+++ b/init.d/main.org
@@ -0,0 +1,2715 @@
+#+PROPERTY: header-args :comments link :tangle yes :noweb no-export :results silent
+#+STARTUP: overview
+
+* About this file
+
+This is my main emacs init file. It can be loaded by the init.el with
+org-babel or can be tangled and compiled to =main.elc= and loaded
+directly.
+
+If you're viewing this file in an org-mode buffer, you can open source
+code blocks (those are the ones in begin_src) in a separate buffer by
+moving your point inside them and typing C-c '
+(org-edit-special). This opens another buffer in emacs-lisp-mode, so
+you can use M-x eval-buffer to load the changes.
+
+* Personal information
+
+#+begin_src emacs-lisp
+  (setq user-full-name "Alexander Sulfrian"
+        user-mail-address "alexander@sulfrian.net")
+#+end_src
+
+* Initialization
+** packages
+
+Add some more package repositories.
+
+#+begin_src emacs-lisp
+  (nconc package-archives
+         '(("melpa-stable" . "http://stable.melpa.org/packages/")
+           ("melpa" . "http://melpa.org/packages/")
+           ("org" . "http://orgmode.org/elpa/")
+           ("marmalade" . "http://marmalade-repo.org/packages/")))
+#+end_src
+
+By default the package system is initialized after evaluating the
+user-init-file (this file) and I could not customize packages in this
+file. So I initialize the package system right here and disable the
+automatic initialization.
+
+#+begin_src emacs-lisp
+  (setq package-enable-at-startup nil
+        package-user-dir (locate-user-emacs-file "cache/elpa/"))
+  (package-initialize nil)
+#+end_src
+
+** use-package
+
+I require use-package to simplify the configuration. This is a
+requirement for this configuration, so I install it here.
+
+#+begin_src emacs-lisp
+  (eval-when-compile
+    (unless (package-installed-p 'use-package)
+      (package-install 'use-package))
+    (setq use-package-verbose t)
+    (require 'use-package))
+#+end_src
+
+** auto-compile
+
+For faster start-up times, this init file should be compiled into
+byte code. I use auto-compile mode for this. It will recompile files
+on load if the byte compiled file exists but is outdated.
+
+#+begin_src emacs-lisp
+  (use-package auto-compile
+    :ensure t
+    :config (auto-compile-on-load-mode))
+#+end_src
+
+For safety reasons emacs should prefer the newer file, if the =*.el=
+and =*.elc= file exists.
+
+#+begin_src emacs-lisp
+  (setq load-prefer-newer t)
+#+end_src
+
+** dash
+
+#+begin_src emacs-lisp
+(use-package dash
+  :demand t
+  :ensure t)
+#+end_src emacs-lisp
+
+* General Setup
+** Encoding
+
+Set all the encoding stuff to utf-8 (but to latin-1 on ZEDAT hosts).
+
+#+begin_src emacs-lisp
+  (let ((encoding
+         (if (string-match "\\.zedat.fu-berlin.de\\'" system-name)
+             'latin-1
+           'utf-8)))
+    (setq locale-coding-system encoding)
+    (set-terminal-coding-system encoding)
+    (set-keyboard-coding-system encoding)
+    (set-selection-coding-system encoding)
+    (prefer-coding-system encoding))
+#+end_src
+
+** Customizing
+
+Emacs should not edit the init.el file when saving stuff from
+customize. So I set a separate custom-file and load it.
+
+#+begin_src emacs-lisp
+  (setq custom-file "~/.emacs.d/emacs-custom.el")
+  (load custom-file)
+#+end_src
+
+** Helper for configuration
+
+I need some functions to simplify the configuration below. They are
+defined here.
+
+*** Get buffers with specific minor-mode
+
+Simply get a list of all buffers, where the specified minor-mode is
+active.
+
+#+begin_src emacs-lisp
+  (defun alex/get-buffers-with (mode)
+    "Get a list of buffers where the given MODE is active. It is done by
+  evaluating the given symbol in all buffers and return a list with
+  all buffers where it evaluates to t. So actually MODE could be any
+  buffer-local variable."
+    (let ((state (mapcar (lambda (buf)
+                           (with-current-buffer buf
+                             (when (and (boundp mode)
+                                        (symbol-value mode))
+                               buf)))
+                         (buffer-list))))
+      (delq nil state)))
+#+end_src
+
+*** Ignore errors of a function
+
+This macro first tries to execute the given fun and evaluate the body
+afterwards, even if fun raised an error. After evaluation of body the
+original return value (or error) of fun is returned.
+
+This is useful for around advices, that should be reset something
+after calling the adviced function, even if it raises an error.
+
+#+begin_src emacs-lisp
+  (defmacro alex/safe-call (fun &rest body)
+    "Evaluate FUN and catch all errors, evaluates BODY afterwards
+  (regardless whether an error was raised or not) and finally returns
+  the result of FUN captured earlier or re-throw the error."
+    `(let* ((tmp (condition-case err
+                     (list (,@fun) nil)
+                   (error (list nil err))))
+            (err (cadr tmp))
+            (result (car tmp)))
+       ,@body
+       (when err
+         (signal (car err) (cdr err)))
+       result))
+#+end_src
+
+*** Get next element from list
+
+This lisp function returns the next element from a list. It is useful
+if you want to switch a setting between multiple values.
+
+#+begin_src emacs-lisp
+  (defun alex/get-next (old list)
+    "Returns the element after OLD in LIST or the first element if OLD
+  is the last element or is not in LIST."
+    (let ((index (or (cl-position old list) -1))
+          (len (length list)))
+      (nth (% (+ 1 index) len) list)))
+#+end_src
+
+*** Exclude list for globalized minor-modes
+
+I want to define some global-minor-modes, but keep them disabled in
+certain modes, buffers or in the minibuffer. So I declare some helper
+to define exclude lists for custom global-minor-modes.
+
+#+begin_src emacs-lisp
+  (defun alex/parse-exclude-list (exclude-list)
+    "Convert a free from exlude list (with multiple keywords) in a
+    propper assoc list with the keywords as key and the values in
+    between as values."
+    (let ((keyword nil)
+          (res '())
+          (args '()))
+      (dolist (elem exclude-list)
+        (if (keywordp elem)
+            (progn
+              (when keyword (setq res (nconc res (list keyword (or args 'empty)))))
+              (setq keyword elem
+                    args '()))
+          (setq args (nconc args (list elem)))))
+      (nconc res (list keyword (or args 'empty)))))
+
+  (defmacro alex/check-list (list var &rest body)
+    "Simple macro to check if body returns non-nil for any element in
+    the list."
+    `(if (eq ,list 'empty)
+         nil
+       (delq nil (mapcar
+                  (lambda (,var)
+                    ,@body)
+                ,list))))
+
+  (defun alex/safe-get-value (var)
+    "Get the value of the variable of nil if the given variable does not exists."
+    (if (boundp var)
+        (symbol-value var)
+      nil))
+
+  (defun alex/minor-mode-exclude (mode)
+    "Check the exclude list for the given mode. Returns t if the mode
+    should be excluded, else nil."
+    (let* ((exclude-list (intern (concat (symbol-name mode) "-exclude-list")))
+           (excludes (alex/parse-exclude-list (symbol-value exclude-list))))
+      (cond
+       ((and (plist-get excludes :minibuffer) (minibufferp))
+        t)
+       ((alex/check-list (plist-get excludes :mode) mode
+                         (cond ((derived-mode-p mode) t)
+                               ((alex/safe-get-value mode) t)))
+        t)
+       ((alex/check-list (plist-get excludes :buffer) buf
+                         (cond
+                          ((and (symbolp buf) (eq (current-buffer)
+                                                  (alex/safe-get-value buf)))
+                           t)
+                          ((and buf (eq (current-buffer) buf))
+                           t)))
+        t)
+       (t nil))))
+#+end_src
+
+Last I define a macro for defining a globalized minor-mode with the
+exclude list feature.
+
+#+begin_src emacs-lisp
+  (defmacro alex/global-excluding-minor-mode (global mode &rest body)
+    "Define a global-minor-mode that can be disabled on some modes or
+    buffers. BODY is executed each time when the mode should be
+    activated (it passed the exclude list at this position). If BODY
+    is empty the mode will be simply activated."
+    (if `(not ,body)
+        `(define-globalized-minor-mode ,global ,mode
+           (lambda ()
+             (unless (alex/minor-mode-exclude ',mode)
+               (,mode 1))))
+      `(define-globalized-minor-mode ,global ,mode
+         (lambda ()
+           (unless (alex/minor-mode-exclude ',mode)
+             ,@body)))))
+
+  (defmacro alex/minor-mode-exclude-list (mode)
+    `(defvar ,(intern (concat (symbol-name mode) "-exclude-list"))
+       ()
+       (concat "Exclude list for " (symbol-name ',mode) ". "
+               "Can contain :minibuffer, :modeq and :buffer.")))
+
+  (defun alex/build-global-name (mode)
+    "Build the symbol for the global mode by inserting 'global-' after
+    'alex/' or prepending 'alex/gloabl-' if MODE does not start with the
+    personal prefix."
+    (let ((name (symbol-name mode)))
+      (intern
+       (if (string-match "^alex/" name)
+           (replace-regexp-in-string "^alex/" "\\&global-" name)
+         (concat "alex/global-" name)))))
+
+  (defun alex/define-global-excluding-minor-mode (mode &rest body)
+    (let ((global (alex/build-global-name mode)))
+      (eval `(alex/global-excluding-minor-mode ,global ,mode ,body))
+      (eval `(alex/minor-mode-exclude-list ,mode))))
+#+end_src
+
+** Cache directory
+
+I want to keep all the changing files in one place, so I create
+=~/.emacs.d/cache/= for this purpose.
+
+#+begin_src emacs-lisp
+  (let ((cache (locate-user-emacs-file "cache/")))
+    (unless (file-directory-p cache)
+      (make-directory cache)))
+#+end_src
+
+Additionally I define a helper function to create a file name inside
+this cache directory.
+
+#+begin_src emacs-lisp
+  (defun alex/cache-file (filename)
+    (locate-user-emacs-file (concat "cache/" filename)))
+#+end_src
+
+*** recentf
+
+Save the history of the last 1000 visited files.
+
+#+begin_src emacs-lisp
+  (setq recentf-save-file (alex/cache-file "recentf")
+        recentf-max-saved-items 1000)
+  (recentf-mode 1)
+#+end_src
+
+*** save-place
+
+Save the last position in a file and raise the limit to 10k elements.
+
+#+begin_src emacs-lisp
+    (use-package saveplace
+      :config
+      (setq save-place-file (alex/cache-file "saveplace")
+            save-place-limit 10000)
+      (setq-default save-place t))
+#+end_src
+
+*** savehist
+
+Save a lot of history between emacs restarts. Save everything, but do
+not keep duplicates.
+
+#+begin_src emacs-lisp
+  (setq savehist-file (alex/cache-file "savehist")
+
+        history-length t
+        history-delete-duplicates t
+
+        savehist-save-minibuffer-history t
+        savehist-additional-variables '(kill-ring
+                                        search-ring
+                                        regexp-search-ring))
+#+end_src
+
+Enable the =savehist-mode=. This has to be below the configuration,
+because the history is loaded when this mode is activated the first
+time. So the =savehist-file= has to be configured when activating.
+
+#+begin_src emacs-lisp
+  (savehist-mode 1)
+#+end_src
+
+*** bookmarks
+
+Bookmarks are great to remember various positions in files. Save the
+bookmark file every time I make a modification (so that I do not loose
+a change, even if emacs or my laptop crashes).
+
+#+begin_src emacs-lisp
+  (setq bookmark-default-file (alex/cache-file "bookmarks")
+        bookmark-save-flag 1)
+#+end_src
+
+*** backups
+
+Do not save backup files into the directory of the original file.
+
+#+begin_src emacs-lisp
+  (setq backup-directory-alist '(("." . "~/.emacs.d/backups")))
+#+end_src
+
+Do not delete old backup files.
+
+#+begin_src emacs-lisp
+  (setq delete-old-versions -1
+        version-control t)
+#+end_src
+
+Make backups even for files under version control.
+
+#+begin_src emacs-lisp
+  (setq vc-make-backup-files t)
+#+end_src
+
+*** auto-save
+
+Do not save auto-save files into the directory of the original
+file (especially important for editing files via tramp).
+
+#+begin_src emacs-lisp
+  (setq auto-save-file-name-transforms
+        `((".*" ,(alex/cache-file "auto-save-list/") t)))
+#+end_src
+
+** Remove some annoyances
+*** No startup message
+
+#+begin_src emacs-lisp
+  (setq inhibit-startup-message t)
+#+end_src
+
+*** Newline at end of file
+
+Require a newline at end of file, but do not insert newlines
+automatically just by moving the cursor down.
+
+#+begin_src emacs-lisp
+  (setq require-final-newline t
+        next-line-add-newlines nil)
+#+end_src
+
+*** Yes or No
+
+I do not want to have to type =yes= and =no=. =y= or =n= should be
+sufficient.
+
+#+begin_src emacs-lisp
+  (fset 'yes-or-no-p 'y-or-n-p)
+#+end_src
+
+*** Symbolic links and version control
+
+Visit the real file (without question), if editing a symbolic links
+that points to a file under version control.
+
+#+begin_src emacs-lisp
+  (setq vc-follow-symlinks t)
+#+end_src
+
+** Visual
+*** Window configuration
+
+Clean up the UI. No toolbar, but use scrollbars and tooltips to keep
+the minibuffer clean.
+
+#+begin_src emacs-lisp
+  (tool-bar-mode -1)
+  (tooltip-mode 1)
+  (scroll-bar-mode 1)
+#+end_src
+
+Use extremely small scroll-bars on the right.
+
+#+begin_src emacs-lisp
+  (set-scroll-bar-mode 'right)
+  (set-frame-parameter nil 'scroll-bar-width 10)
+  (nconc default-frame-alist '((scroll-bar-width . 10)))
+#+end_src
+
+The menu-bar is helpful in the terminal (under X you can get a menu on
+demand with <F10>). So I enable the menu-bar if no window-system is
+available. To show the menu also in an emacsclient in the terminal, I
+have to add a hook in the =after-make-frame-function=.
+
+#+begin_src emacs-lisp
+  (defun alex/update-menu-bar (&optional frame)
+    "This displays the menu bar if the given FRAME (default: selected
+  frame) is in a terminal"
+    (let ((status (if (display-graphic-p frame) 0 1)))
+      (set-frame-parameter frame 'menu-bar-lines status)))
+
+  (alex/update-menu-bar)
+  (add-hook 'after-make-frame-functions 'alex/update-menu-bar)
+#+end_src
+
+*** Color-theme
+
+Use own color theme and switch it depending whether the frame is on
+terminal or under X11.
+
+#+begin_src emacs-lisp
+  (use-package color-theme
+    :demand t
+    :config
+    (setq color-theme-directory "~/.emacs.d/lisp/themes/"
+          color-theme-load-all-themes nil)
+
+    (color-theme-initialize)
+    (color-theme-monokai-alex)
+
+    (defun alex/update-color-theme (&optional frame)
+      (let ((color-theme-is-global nil))
+        (if (display-graphic-p frame)
+            (color-theme-monokai-alex)
+          (color-theme-alex-console))))
+    (add-hook 'after-make-frame-functions 'alex/update-color-theme))
+#+end_src
+
+I always want to have as much as possible syntax highlighting.
+
+#+begin_src emacs-lisp
+  (global-font-lock-mode t)
+  (setq font-lock-maximum-decoration t)
+#+end_src
+
+*** Cleanup minor-modes in modeline
+
+I want to hide some minor-modes, if they are activated in nearly all
+buffers or it is irrelevant if they are activated.
+
+To be compatible with powerline I use rich-minority, but I add some
+custom stuff to fake the interface of diminish so that I can use the
+diminish feature of use-package.
+
+I can use :diminish in use-package with either a mode name or e regexp
+to hide matching modes.
+
+#+begin_src emacs-lisp
+  (use-package rich-minority
+    :ensure t
+    :config
+    (defvar alex/minor-mode-blacklist ()
+      "List of regexp that is matched against the lighter of all
+    minor-modes. All matching minor-modes are hidden in the mode line.")
+
+    (defun alex/rm-add-blacklist (regexp)
+      "Add the given REGEXP to alex/minor-modes-blacklist and updates the
+    combined regexp in rm-blacklist afterwards."
+      (unless (member regexp alex/minor-mode-blacklist)
+        (setq alex/minor-mode-blacklist
+              (nconc alex/minor-mode-blacklist (list regexp)))
+        (alex/update-rm-blacklist))
+      alex/minor-mode-blacklist)
+
+    (defun alex/update-rm-blacklist ()
+      "Update rm-blacklist and build a regexp from the multiple values in
+    alex/minor-modes-blacklist."
+      (setq rm-blacklist
+            (format "^\\(%s\\)$"
+                    (mapconcat #'identity alex/minor-mode-blacklist "\\|"))))
+
+    (defun alex/get-lighter (mode)
+      "Get the lighter for the given minor-mode."
+      (let ((value (assoc mode minor-mode-alist)))
+        (if value
+            (let ((lighter (cadr value)))
+              (if (symbolp lighter)
+                  (when (boundp lighter)
+                    (eval lighter))
+                lighter))
+          nil)))
+
+    (defun diminish (mode &optional regexp)
+      "This is a fake diminish with rich-minority-mode. It accepts uses
+    either the MODE or if given the REGEXP to hide the mode."
+      (if (and regexp (> (length regexp) 0))
+          (alex/rm-add-blacklist regexp)
+        (let ((lighter (alex/get-lighter mode)))
+          (when lighter
+            (alex/rm-add-blacklist lighter)))))
+
+    (rich-minority-mode 1))
+#+end_src
+
+*** Trailing whitespaces
+
+I generally want to show trailing whitespaces, but there are several
+exceptions. Per default there is only a buffer local variable to
+control this feature. I create a simple minor-mode, so that I could
+simply activate or deactivate this feature.
+
+#+begin_src emacs-lisp
+  (define-minor-mode alex/tw-mode
+    "trailing-whitespace-mode"
+    :lighter " TW"
+    (setq show-trailing-whitespace alex/tw-mode))
+
+  (alex/define-global-excluding-minor-mode 'alex/tw-mode)
+#+end_src
+
+I want to disable trailing whitespaces in the minibuffer, in weechat,
+helm and term-mode and in the which-key buffer. So I define here the
+exclude list.
+
+#+begin_src emacs-lisp
+  (setq alex/tw-mode-exclude-list
+        '(:minibuffer
+          :mode
+          helm--remap-mouse-mode
+          weechat-mode
+          term-mode
+          Custom-mode
+          :buffer
+          which-key--buffer))
+#+end_src
+
+And now activate the new global mode and hide it from the mode line.
+
+#+begin_src emacs-lisp
+  (alex/global-tw-mode t)
+  (diminish 'alex/tw-mode)
+#+end_src
+
+*** Visual-wrap-column
+
+Sometimes I want to force =visual-line-wrap= at a specific column (in
+contrast to the window width). This is especially useful for emails,
+that are badly formatted with long lines. =visual-line-wrap= will
+split long lines at the word-break before the specified column. 
+
+#+begin_src emacs-lisp
+  (defvar alex/visual-wrap-column nil
+    "Column to force visual line wrap. Use `alex/set-visual-wrap-column'
+  to change the value.")
+
+  (defun alex/set-visual-wrap-column (new-wrap-column &optional buffer)
+    "Force visual line wrap at NEW-WRAP-COLUMN in BUFFER (defaults to
+  current buffer) by setting the right-hand margin on every window that
+  displays BUFFER. A value of NIL or 0 for NEW-WRAP-COLUMN disables this
+  behavior."
+    (interactive (list (read-number "New visual wrap column, 0 to disable: "
+                                    (or alex/visual-wrap-column fill-column 0))))
+    (when (and (numberp new-wrap-column)
+             (zerop new-wrap-column))
+      (setq new-wrap-column nil))
+  
+    (with-current-buffer (or buffer (current-buffer))
+      (visual-line-mode t)
+      (set (make-local-variable 'alex/visual-wrap-column) new-wrap-column)
+      (add-hook 'window-configuration-change-hook
+                'alex/update-visual-wrap-column nil t)
+    
+      (let ((windows (get-buffer-window-list)))
+        (dolist (win windows)
+          (when (window-live-p win)
+            (with-selected-window win
+              (alex/update-visual-wrap-column)))))))
+
+  (defun alex/update-visual-wrap-column ()
+    "Update the right margin of the current window, to match the
+  available space to `alex/visual-wrap-column'."
+    (if (not alex/visual-wrap-column)
+        (set-window-margins nil nil)
+      (let* ((current-margins (window-margins))
+             (right-margin (or (cdr current-margins) 0))
+             (current-width (window-width))
+             (current-available (+ current-width right-margin)))
+        (if (<= current-available alex/visual-wrap-column)
+            (set-window-margins nil (car current-margins))
+          (set-window-margins nil (car current-margins)
+                              (- current-available alex/visual-wrap-column))))))
+#+end_src
+
+** Localization
+
+I want to use german names for month and weekdays.
+
+#+begin_src emacs-lisp
+  (setq calendar-week-start-day 1
+        calendar-day-name-array ["Sonntag" "Montag" "Dienstag" "Mittwoch"
+                                 "Donnerstag" "Freitag" "Samstag"]
+        calendar-month-name-array ["Januar" "Februar" "März" "April" "Mai"
+                                   "Juni" "Juli" "August" "September"
+                                   "Oktober" "November" "Dezember"])
+#+end_src
+
+** Browser
+
+I have a simple wrapper script to be able to easily switch to a
+different browser. So I only have to configure to use this wrapper
+script.
+
+#+begin_src emacs-lisp
+  (setq browse-url-browser-function 'browse-url-generic
+        browse-url-generic-program "browser")
+#+end_src
+
+** Movement
+
+The defaults for the cursor movement and scrolling are not very good,
+so I need to customize the settings to match the expectations.
+
+*** Scrolling
+
+If I move the cursor out of screen, I do not want to jump to recenter
+the cursor, but scroll just as far to display the cursor again.
+
+#+begin_src emacs-lisp
+  (setq scroll-conservatively 10000
+        auto-window-vscroll nil)
+#+end_src
+
+Do not accelerate mouse scrolling.
+
+#+begin_src emacs-lisp
+  (setq mouse-wheel-progressive-speed nil)
+#+end_src
+
+Automatic scroll the compilation output to the bottom (or the first
+error).
+
+#+begin_src emacs-lisp
+  (setq compilation-scroll-output t)
+#+end_src
+
+*** Automatic indentation
+
+Automatic indent new lines.
+
+#+begin_src emacs-lisp
+  (bind-key "RET" 'newline-and-indent)
+#+end_src
+
+But clean whitespaces, if the indentation is abandoned.
+
+#+begin_src emacs-lisp
+  (use-package clean-aindent-mode
+    :config
+    (clean-aindent-mode t))
+#+end_src
+
+*** Back to indentation
+
+I want to have a better handling for the =<home>= key. Per default I
+want to move the cursor to the end of the indentation (first
+non-whitespace character). Only if the cursor is already at that
+position, I want to move to the beginning of the line.
+
+#+begin_src emacs-lisp
+  (defun alex/back-to-indentation-or-beginning ()
+    "Move the point to the first non-whitespace character on the line,
+  of if it is already there, to the beginning of the line."
+    (interactive)
+    (if (= (point) (save-excursion (back-to-indentation) (point)))
+        (beginning-of-line)
+      (back-to-indentation)))
+
+  (bind-key "<home>" 'alex/back-to-indentation-or-beginning)
+#+end_src
+
+*** Ungreedy kill-word
+
+The default =kill-word= (and =backward-kill-word=) is a bit greedy. I
+want to replace =forward-word= in the original definition with
+=forward-same-syntax=.
+
+This could not be done with an advice because =forward-word= is a byte
+code primitive and could not be replaced with =flet= or something like
+that. So I have to copy the original definition of kill-word here and
+simple do the replacement in the source.
+
+#+begin_src emacs-lisp
+  (defun kill-word (arg)
+    "Kill characters forward until encountering the end of a word.
+  With argument ARG, do this that many times."
+    (interactive "p")
+    (kill-region (point) (progn (forward-same-syntax arg) (point))))
+#+end_src
+
+** Selection
+
+The selection is the region between the mark and the point. But I want
+to see the active region, so I want to ensure, that
+transient-mark-mode is enabled globally.
+
+#+begin_src emacs-lisp
+(transient-mark-mode 1)
+#+end_src
+
+Additionally I have some enhancements to the default behaviour of some
+commands.
+
+*** Kill or copy whole line
+
+If no region is active, I want to kill/copy the current line.
+
+#+begin_src emacs-lisp
+  (defun alex/whole-line (func beg end &rest region)
+    (interactive (if mark-active
+                     (list (region-beginning) (region-end))
+                   (list (line-beginning-position)
+                         (line-beginning-position 2))))
+    (apply func beg end region))
+
+  (advice-add 'kill-ring-save :around #'alex/whole-line)
+  (advice-add 'kill-region :around #'alex/whole-line)
+#+end_src
+
+*** Rectangle selection
+
+The rectangle selection of cua mode works very well, but I only want
+the rectangle selection mode and not the C-z/C-x/C-c/C-v bindings.
+
+#+begin_src emacs-lisp
+  (setq cua-rectangle-mark-key (kbd "M-SPC")
+        cua-delete-selection nil)
+  (cua-selection-mode t)
+#+end_src
+
+*** X11 clipboard
+
+Use the X11 clipboard in addition to the primary selection, because
+some other X11 apps can only use the X11 clipboard.
+
+#+begin_src emacs-lisp
+  (setq x-select-enable-clipboard t)
+  (setq interprogram-paste-function 'x-selection-value)
+#+end_src
+
+** Custom commands
+
+Here I define some global custom commands. These commands are bind
+in the =global-map= and are not associated with any other package.
+
+*** Open terminal
+
+Open an external terminal in the default directory of the current
+buffer. In most cases this is the directory containing the file of the
+current buffer.
+
+#+begin_src emacs-lisp
+  (defun alex/open-buffer-shell ()
+    "Open a terminal in the default directory of the current buffer."
+    (interactive)
+    (if default-directory
+        (start-process-shell-command
+         "urxvt"
+         nil
+         (concat "DIR=" default-directory " urxvt"))
+      (message "Buffer does not contain a file.")))
+
+  (bind-key "<f12>" 'alex/open-buffer-shell)
+#+end_src
+
+** Bug fixes
+
+A few workarounds about some strange emacs behaviour.
+
+*** Key mapping
+
+Some versions of urxvt send some strange key codes for some key
+combinations. The following table contains the mappings from the
+key codes send by urxvt and the real keys.
+
+#+tblname: key-mappings
+| Keycode     | Key         |
+|-------------+-------------|
+| M-[ Z       | <S-tab>     |
+| <select>    | <S-up>      |
+| M-[ b       | <S-down>    |
+| M-[ c       | <S-right>   |
+| M-[ d       | <S-left>    |
+| M-O a       | <C-up>      |
+| M-O b       | <C-down>    |
+| M-O c       | <C-right>   |
+| M-O d       | <C-left>    |
+| ESC M-O a   | <C-M-up>    |
+| ESC M-O b   | <C-M-down>  |
+| ESC M-O c   | <C-M-right> |
+| ESC M-O d   | <C-M-left>  |
+| ESC M-O A   | <M-up>      |
+| ESC M-O B   | <M-down>    |
+| ESC M-O C   | <M-right>   |
+| ESC M-O D   | <M-left>    |
+| ESC M-[ a   | <M-S-up>    |
+| ESC M-[ b   | <M-S-down>  |
+| ESC M-[ c   | <M-S-right> |
+| ESC M-[ d   | <M-S-left>  |
+| <clearline> | <C-end>     |
+
+The tables is converted into the real key mappings with the following
+function. It uses the org-babel stuff to convert the org-table into an
+emacs-lisp variable.
+
+#+begin_src emacs-lisp :var mappings=key-mappings
+  (if (not window-system)
+      (mapc (lambda (row)
+              (define-key function-key-map
+                (read-kbd-macro (car row))
+                (read-kbd-macro (cadr row))))
+            mappings))
+#+end_src
+
+*** Scroll speed
+
+The scroll speed of emacs (at least 24.1) was very slow (esp. in
+wanderlust summary buffers). The problem was, that for each line the
+paragraph direction was checked. Because I do not use right-to-left
+languages, I disable the auto detection
+
+#+begin_src emacs-lisp
+  (when (boundp 'bidi-paragraph-direction)
+    (setq-default bidi-paragraph-direction 'left-to-right))
+#+end_src
+
+*** Sit-for
+
+=sit-for= seems to modify the current-buffer and causes error message
+during find-file (if a backup file exists). This fixes the problem
+providing =sit-for= with a temporary buffer, that is destroyed
+afterwards.
+
+#+begin_src emacs-lisp
+  (defun alex/save-current-buffer (orig-fun &rest args)
+    "Do not allow the advised function to change the current-buffer."
+    (with-temp-buffer
+      (apply orig-fun args)))
+  (advice-add 'sit-for :around #'alex/save-current-buffer)
+#+end_src
+* Modes
+** Core modes
+
+These modes are part of the core and the auto-mode-alist is set up
+automatically. So the mode should not be required.
+
+*** cc-mode
+
+Here I only add a hook for the configuration and a key-binding for the
+mode key-map.
+
+#+begin_src emacs-lisp
+  (defun alex/c-mode-setup ()
+    ;; auto fill at column 80
+    (setq fill-column 80)
+    (turn-on-auto-fill)
+
+    ;; semantic as for auto-complete
+    (add-to-list 'ac-sources ac-source-semantic)
+
+    ;; now '_' is not considered a word-delimiter
+    (modify-syntax-entry ?_ "w")
+
+    ;; indentation style
+    (c-set-style "linux")
+    (setq indent-tabs-mode t
+          c-basic-offset 4
+          tab-width 4)
+
+    (bind-key "C-c o" 'ff-find-other-file 'c-mode-map))
+
+  (add-hook 'c-mode-common-hook 'alex/c-mode-setup)
+#+end_src
+
+*** text-mode
+
+I only activate =auto-fill-mode= for =text-mode= here. Additionally I
+activate =text-mode= automatically for all files called only with
+capital letters and without extension (like README or INSTALL).
+
+#+begin_src emacs-lisp
+(setq text-mode-hook 'turn-on-auto-fill)
+(add-to-list 'auto-mode-alist '("\\`[A-Z]+\\'" . text-mode))
+#+end_src
+
+** Additional modes 
+
+Some additional modes for editing of special files types. Most of
+them do not requires special configuration only =:mode= or
+=:interpreter= from use-package to enable auto loading.
+
+*** apache-mode
+
+#+begin_src emacs-lisp
+  (use-package apache-mode
+    :mode ("\.htaccess$" "htpd\\.conf$" "srm\\.conf$" "access\\.conf$"
+           "apache[12]\?\\.conf$" "commonapache[12]\?\\.conf$"
+           "\/sites-enabled\/.*\.conf$"))
+#+end_src
+
+*** arduino-mode
+
+#+begin_src emacs-lisp
+  (use-package arduino-mode
+    :mode "\\.pde\\'")
+#+end_src
+
+*** auctex
+
+#+begin_src emacs-lisp
+  (use-package auctex
+    :mode ("\\.tex\\'" . latex-mode)
+    :commands (latex-mode LaTeX-mode plain-tex-mode)
+    :config
+    (setq TeX-view-program-list '(("Zathura" "zathura %o"))
+          TeX-view-program-selection '((output-pdf "Zathura"))))
+#+end_src
+
+*** autoconf-mode
+
+#+begin_src emacs-lisp
+  (use-package autoconf-mode
+    :mode ("\\.ac\\'" "configure\\.in\\'"
+           ("\\.at\\'" . autotest-mode)))
+#+end_src
+
+*** bibtex
+
+#+begin_src emacs-lisp
+  (use-package bibtex
+    :mode ("\\.bib" . bibtex-mode))
+#+end_src
+
+*** crontab-mode
+
+#+begin_src emacs-lisp
+  (use-package crontab-mode
+    :commands (crontab-mode))
+#+end_src
+
+*** css-mode
+
+The css-mode requires a few adjustments for the indentation style.
+
+#+begin_src emacs-lisp
+  (use-package css-mode
+    :mode "\\.css\\'"
+    :functions (cssm-c-style-indenter)
+    :config
+    (setq cssm-indent-level 4
+          cssm-newline-before-closing-bracket t
+          cssm-indent-function #'cssm-c-style-indenter))
+#+end_src
+
+*** csv-mode
+
+#+begin_src emacs-lisp
+  (use-package csv-mode
+    :mode "\\.[Cc][Ss][Vv]\\'")
+#+end_src
+
+*** ebuild-mode
+
+#+begin_src emacs-lisp
+  (use-package ebuild-mode
+    :mode ("\\.ebuild\\'" "\\.eclass\\'" "\\.eblit\\'"
+           ("/[0-9]\\{4\\}-[01][0-9]-[0-3][0-9]-.+\\.[a-z]\\{2\\}\\.txt\\'"
+            . gentoo-newsitem-mode))
+    :interpreter ("runscript" . sh-mode))
+#+end_src
+
+*** eselect-mode
+
+#+begin_src emacs-lisp
+  (use-package eselct-mode
+    :mode "\\.eselect\\'")
+#+end_src
+
+*** graphviz-dot-mode
+
+#+begin_src emacs-lisp
+  (use-package graphviz-dot-mode
+    :mode ("\\.dot\\'" "\\.gv\\'"))
+#+end_src
+
+*** haskell-mode
+
+I need haskell-mode and it is required to initialize the indentation
+scheme on activation (else a pop-up will ask you to do so, if you press
+=<TAB>= inside a haskell buffer).
+
+#+begin_src emacs-lisp
+  (use-package haskell-mode
+    :mode ("\\.hs\\'" "\\.gs\\'" "\\.hi\\'"
+           ("\\.l[gh]s\\'" . literate-haskell-mode)
+           ("\\.cabal\\'" . haskell-cabal-mode))
+    :interpreter ("runghc" "runhaskell")
+    :config
+    (add-hook 'haskell-mode-hook 'turn-on-haskell-indentation))
+#+end_src
+
+*** javascript
+
+#+begin_src emacs-lisp
+  (use-package javascript
+    :mode ("\\.js\\'" . javascript-mode))
+#+end_src
+
+*** lua-mode
+
+#+begin_src emacs-lisp
+  (use-package lua-mode
+    :mode "\\.lua\\'")
+#+end_src
+
+*** php-mode
+
+#+begin_src emacs-lisp
+  (use-package php-mode
+    :mode ("\\.php[s34]?\\'" "\\.phtml\\'" "\\.inc\\'"))
+#+end_src
+
+*** po-mode
+
+#+begin_src emacs-lisp
+  (use-package po-mode
+    :mode "\\.po\\'\\|\\.po\\.")
+#+end_src
+
+*** promela-mode
+
+Simple mode for promela files. The file extension is not standardized,
+so I add a few different extensions.
+
+#+begin_src emacs-lisp
+  (use-package promela-mode
+    :mode ("\\.promela\\'" "\\.spin\\'" "\\.pml\\'" "\\.prm\\'" "\\.porm\\'")
+    :config
+    (setq promela-block-indent 2
+          promela-selection-indent 0
+          promela-selection-option-indent 3))
+#+end_src
+
+*** protobuf-mode
+
+#+begin_src emacs-lisp
+  (use-package protobuf-mode
+    :mode "\\.proto\\'")
+#+end_src
+
+*** python
+
+#+begin_src emacs-lisp
+  (use-package python
+    :mode ("\\.py\\'" . python-mode)
+    :interpreter ("python" . python-mode)
+    :functions (python-continuation-line-p)
+    :config
+    <<python>>)
+#+end_src
+
+**** Fix indentation of closing brackets
+
+This fixes the indentation of the closing brackets for line
+continuations in python. The opening and closing brackets should be
+lined up in the same column.
+
+#+begin_src emacs-lisp :noweb-ref python :tangle no
+  (defun alex/python-indent-closing-brackets (func &rest args)
+    "Handle lines beginning with a closing bracket and indent them so that
+  they line up with the line containing the corresponding opening bracket."
+    (save-excursion
+      (beginning-of-line)
+      (let ((syntax (syntax-ppss)))
+        (if (and (not (eq 'string (syntax-ppss-context syntax)))
+                 (python-continuation-line-p)
+                 (cadr syntax)
+                 (skip-syntax-forward "-")
+                 (looking-at "\\s)"))
+            (progn
+              (forward-char 1)
+              (ignore-errors (backward-sexp))
+              (current-indentation))
+          (apply func args)))))
+
+  (advice-add 'python-calculate-indentation :around
+              #'alex/python-indent-closing-brackets)
+#+end_src
+
+*** xrdb-mode
+
+#+begin_src emacs-lisp
+  (use-package xrdb-mode
+    :mode ("\\.Xdefaults\\'" "\\.Xenvironment\\'" "\\.Xresources\'"
+           "\\.Xdefaults.d/"))
+#+end_src
+
+* Packages
+** ace-window
+
+ace-window is a replacement for =C-x o= that let you switch to a
+specific window. It displays a marker in all windows and switch to the
+select one. It is also possible execute some actions on the window
+(swap, split or delete) by pressing a dispatch key before selecting
+the window. It is not optimal, because it does not display the
+possibility. Maybe I will replace it with a custom hydra.
+
+#+begin_src emacs-lisp
+  (use-package ace-window
+    :bind (("C-x o" . ace-window)
+           ("C-x C-o" . aw-flip-window))
+    :config
+    (setq aw-scope 'frame
+          aw-dispatch-always t
+          aw-dispatch-alist '((?x aw-delete-window " Ace - Delete Window")
+                              (?m aw-swap-window " Ace - Swap Window")
+                              (?n aw-flip-window)
+                              (?v aw-split-window-vert " Ace - Split Vert Window")
+                              (?h aw-split-window-horz " Ace - Split Horz Window")
+                              (?i delete-other-windows " Ace - Maximize Window")
+                              (?o delete-other-windows))))
+#+end_src
+
+** auto-complete
+
+auto-complete uses a popup to display possible completions of the
+input. The popup is displayed automatically after some idle time or
+when pressing the shortcut (but the auto-complete-mode has to be
+enabled before).
+
+#+begin_src emacs-lisp
+  (use-package auto-complete
+    :bind ("M-<tab>" . auto-complete)
+    :demand t
+    :diminish auto-complete-mode
+    :config
+    (require 'auto-complete-config)
+    (ac-config-default)
+
+    (setq ac-comphist-file (alex/cache-file "ac-comphist.dat")
+          ac-quick-help-delay 1.0)
+
+    (global-auto-complete-mode t))
+#+end_src
+
+** TODO company-mode
+
+Should be better than auto-complete-mode and the code should be more
+modern.
+
+** cursor-chg
+
+I want to change the cursor if the buffer is readonly or if I enabled
+overwrite. =cursor-chg= can change the shape of the cursor. The color
+of the cursor could not be changed, because the cursor-color is a
+frame parameter and could be set for a single buffer.
+
+#+begin_src emacs-lisp
+  (use-package cursor-chg
+    :config
+    (toggle-cursor-type-when-idle 1)
+    (change-cursor-mode 1))
+#+end_src
+
+** deft
+
+#+begin_src emacs-lisp
+  (use-package deft
+    :bind ("<f9>" . deft)
+    :config
+    (setq deft-extension "org"
+           deft-directory "~/.org/deft/"
+           deft-text-mode 'org-mode))
+#+end_src
+
+** dired-x
+
+I use dired-x mostly for the features for omitting files. I customize
+the arguments for the listing to add a trailing slash for directories
+(that way I can omit files like =*.d= but keep directories matching
+the same regexp). I enable =dired-omit-mode= per default in all dired
+buffers.
+
+#+begin_src emacs-lisp
+  (use-package dired-x
+    :config  
+    (setq dired-omit-files "^\\.?#\\|~$\\|^\\.svn/$\\|^\\.git\$"
+          dired-omit-extensions (append completion-ignored-extensions
+                                        dired-latex-unclean-extensions
+                                        dired-bibtex-unclean-extensions
+                                        dired-texinfo-unclean-extensions)
+          dired-listing-switches "-pal --group-directories-first")
+
+    (add-hook 'dired-mode-hook (lambda () (dired-omit-mode 1))))
+#+end_src
+** doxymacs
+
+Currently I use doxymacs only to add font-lock for doxymacs tags.
+
+#+begin_src emacs-lisp
+  (defun alex/doxymacs-font-lock ()
+    (when (member major-mode '(c-mode c++-mode))
+      (when (not (fboundp 'doxymacs-font-lock))
+        (use-package doxymacs
+          :load-path "/usr/share/emacs/site-lisp/doxymacs/")
+        (when (not (fboundp 'doxymacs-font-lock))
+          (fset 'doxymacs-font-lock 'ignore)))
+      (doxymacs-font-lock)))
+
+  (add-hook 'font-lock-mode-hook 'alex/doxymacs-font-lock)
+#+end_src
+
+** edit-server
+
+Allow to exit text areas from a browser with emacs. Open the buffers
+in a new frame in org-mode.
+
+#+begin_src emacs-lisp
+  (use-package edit-server
+    :config
+    (setq edit-server-new-frame t
+          edit-server-default-major-mode 'org-mode
+          edit-server-new-frame-alist '((name . "EDIT with Emacs")))
+
+    (edit-server-start))
+#+end_src
+
+** expand-region
+
+This will create a region around semantic elements and let you expand
+and contract it around larger/smaller semantic units.
+
+#+begin_src emacs-lisp
+  (use-package expand-region
+    :bind (("C-<return>" . er/expand-region)
+           ("M-<return>" . er/contract-region)))
+#+end_src
+
+** filladapt
+
+Indent a filled line (manual or with auto-fill-mode) according to some
+heuristics with spaces, comments or citation marks. This is not
+available on ELPA so we need to load it from the local =lisp/= folder
+in the =user-emacs-directory=.
+
+#+begin_src emacs-lisp
+  (use-package filladapt
+    :load-path "lisp/"
+    :diminish filladapt-mode
+    :config
+    (setq-default filladapt-mode t)
+    (add-hook 'org-mode-hook #'turn-off-filladapt-mode)
+    (add-hook 'compilation-mode-hook #'turn-off-filladapt-mode))
+#+end_src
+** flymake-jshint
+
+When entering a javascript buffer, try to load flymake-jshint and
+activate flymake-mode when it could be loaded successfully. This is a
+possibility to defer the loading of the flymake-jshint library until
+it is really required.
+
+#+begin_src emacs-lisp
+  (defun alex/jshint-init ()
+    "Try to load `flymake-jshint' if not already loaded and activate
+  flymake-mode if it could be loaded successfully."
+  (if (fboundp 'flymake-jshint-init)
+        (flymake-mode 1)
+      (use-package flymake-jshint)
+      (when (fboundp 'flymake-jshint-init)
+        (flymake-mode 1))))
+
+  (add-hook 'js-mode-hook 'alex/jshint-init)
+#+end_src
+
+** git-gutter-fringe
+
+If running under X11 I want to have little git marker on the right
+side in the fringe. Therefore I use git-gutter-fringe and I override
+the modification function from =fringe-helper= because it does
+something strange with the beg and end parameters.
+
+To make space for the git-gutter signs, I extend the width of the
+right fringe a bit (left side is kept at the default width).
+
+#+begin_src emacs-lisp
+  (use-package git-gutter-fringe
+    :if window-system
+    :config
+    (setq git-gutter-fr:side 'right-fringe)
+    (fringe-mode '(nil . 15))
+    (global-git-gutter-mode +1)
+
+    ;; fix the helper function (does something strange with beg and end)
+    (defun fringe-helper-modification-func (ov after-p beg end &optional len)
+      ;; Sometimes this hook is called with a deleted overlay.
+      (when (overlay-start ov)
+        (let ((ov-beg (overlay-start ov))
+              (ov-end (overlay-end ov)))
+          (if after-p
+              (if (eq beg end)
+                  ;; evaporate overlay
+                  (delete-overlay ov)
+                ;; if new lines are inserted, add new bitmaps
+                (let ((before-string (overlay-get ov 'before-string))
+                      fringe-ov)
+                  (save-excursion
+                    (goto-char ov-beg)
+                    (while (search-forward "\n" ov-end t)
+                      (setq fringe-ov (make-overlay (point) (point)))
+                      (overlay-put fringe-ov 'before-string before-string)
+                      (overlay-put fringe-ov 'fringe-helper-parent ov)))))
+            ;; if a \n is removed, remove the fringe overlay
+            (save-excursion
+              (goto-char ov-beg)
+              (while (search-forward "\n" ov-end t)
+                (let ((overlays (overlays-in (point) (1+ (point)))))
+                  (while overlays
+                    (when (eq (overlay-get (car overlays) 'fringe-helper-parent) ov)
+                      (delete-overlay (car overlays))
+                      (setq overlays nil))
+                    (pop overlays)))))))))
+    :diminish
+    git-gutter-mode)
+#+end_src
+** helm
+
+I use helm completion everywhere and I do /not/ autoload helm, because
+it would slow down the first completions and I am sure I will use helm
+every time I start emacs.
+
+#+begin_src emacs-lisp
+  (use-package helm
+    :bind (("M-x" . helm-M-x)
+           ("M-X" . execute-extended-command)
+           ("C-x f" . helm-mini)
+           ("C-x b" . helm-buffers-list)
+           ("C-x C-b" . helm-buffers-list)
+           ("M-y" . helm-show-kill-ring))
+    :demand t
+    :ensure t
+    :diminish helm-mode
+    :config
+    <<helm-config>>
+    (helm-mode 1))
+#+end_src
+
+The basic configuration for helm is provided by helm-config.
+
+#+begin_src emacs-lisp :noweb-ref helm-config :tangle no
+  (use-package helm-config)
+#+end_src
+
+Customize the prefix key and setup =<tab>= as convenient execute the
+persistent-action without quitting helm.
+
+#+begin_src emacs-lisp :noweb-ref helm-config :tangle no
+  (bind-key "<tab>" 'helm-execute-persistent-action helm-map)
+  (setq helm-command-prefix-key "C-c h")
+#+end_src
+
+*** configuration
+
+Now I customize the helm configuration:
+
+**** visual
+
+I want to split the current window to display the helm completion
+window and want to cycle through the results.
+
+#+begin_src emacs-lisp :noweb-ref helm-config :tangle no
+  (setq helm-split-window-in-side-p t
+        helm-move-to-line-cycle-in-source t)
+#+end_src
+
+**** scroll other window
+
+I do not want to scroll the other window by pages, but by 10
+lines. This is useful, if I preview a file or a buffer with the
+persistent action and want to scoll around a bit.
+
+#+begin_src emacs-lisp :noweb-ref helm-config :tangle no
+  (setq helm-scroll-amount 10)
+#+end_src
+
+**** history
+
+I want to use =recentf-list= instead of the normal =file-name-history=,
+because it is more configurable and more complete. 
+
+I /always/ want to save the history for executed commands, even if the
+command has failed.
+
+#+begin_src emacs-lisp :noweb-ref helm-config :tangle no
+  (setq helm-ff-file-name-history-use-recentf t
+        helm-M-x-always-save-history t)
+#+end_src
+
+**** fuzzy matching
+
+Enable fuzzy matching on some helm modes. There is also
+=helm-mode-fuzzy-match= that would enable fuzzy match in every helm
+mode, that would also modify sorting.
+
+#+begin_src emacs-lisp :noweb-ref helm-config :tangle no
+  (setq helm-apropos-fuzzy-match t
+        helm-buffers-fuzzy-matching t
+        helm-ff-fuzzy-matching t
+        helm-projectile-fuzzy-match t
+        helm-recentf-fuzzy-match t
+        helm-M-x-fuzzy-match t)
+#+end_src
+
+**** recursive minibuffers
+
+Recursive minibuffers allow to execute a minibuffer command while
+currently in the minibuffer. With this enabled, I could use the
+/completion at point/ from the minibuffer (maybe from
+=eval-expression=).
+
+#+begin_src emacs-lisp :noweb-ref helm-config :tangle no
+  (setq enable-recursive-minibuffers t)
+#+end_src
+
+*** helm-projectile
+
+Enable helm support for projectile and replace many projectile
+commands with helm completion.
+
+#+begin_src emacs-lisp
+  (use-package helm-projectile
+    :ensure t
+    :after (helm)
+    :init
+    ; This needs to be set before loading helm-projectile
+    (setq helm-projectile-fuzzy-match t)
+    :config
+    (helm-projectile-on))
+#+end_src
+** hydra
+
+With hydra I can build easy groups of commands that (maybe) can
+repeated and share a common prefix. The advantage over other
+mechanisms is, that hydra will show a overview of the available keys
+after pressing the prefix. It is very flexible and maybe I should
+create more hydras.
+
+#+begin_src emacs-lisp
+  (use-package hydra
+    :bind (("C-M-s" . alex/hydra-splitter/body)
+           ("<f2>" . alex/hydra-zoom/body)
+           ("C-t" . alex/hydra-toggle/body))
+    :config
+    <<helm>>)
+#+end_src
+
+*** move splitter
+
+With this hydra I can move the splitter between frames using the
+cursor keys.
+
+#+begin_src emacs-lisp :noweb-ref helm :tangle no
+  (require 'hydra-examples)
+  (defhydra alex/hydra-splitter ()
+    "Move window spitter"
+    ("<left>" hydra-move-splitter-left)
+    ("<right>" hydra-move-splitter-right)
+    ("<up>" hydra-move-splitter-up)
+    ("<down>" hydra-move-splitter-down))
+#+end_src
+
+*** zoom
+
+With this hydra I can change font site on demand, by repeatedly
+pressing + or - until the desired font-size is reached.
+
+#+begin_src emacs-lisp :noweb-ref helm :tangle no
+  (defhydra alex/hydra-zoom ()
+    "Change font size"
+    ("+" text-scale-increase "zoom in")
+    ("-" text-scale-decrease "zoom out"))
+#+end_src
+
+*** toggle
+
+With this hydra I can toggle various common settings (or minor-modes)
+using some shortcuts.
+
+Because the keys are already documented in the docstring, hydra should
+not show all the keys again in the mode line and we globally set the
+hint to nil.
+
+#+begin_src emacs-lisp :noweb-ref helm :tangle no
+  (defhydra alex/hydra-toggle (:hint nil)
+    "
+
+  Toggle common settings/minor-modes:
+
+  \[_d_\] debug-on-error:        %`debug-on-error
+  \[_f_\] auto-fill-mode:        %`auto-fill-function
+  \[_l_\] truncate-lines:        %`truncate-lines
+  \[_w_\] whitespace-mode:       %`whitespace-mode
+  \[_t_\] trailing-whitespaces:  %`alex/tw-mode
+  \[_s_\] flyspell-mode:         %`flyspell-mode
+
+  \[_q_\] quit
+  "
+    ("d" toggle-debug-on-error)
+    ("f" auto-fill-mode)
+    ("l" toggle-truncate-lines)
+    ("w" whitespace-mode)
+    ("t" alex/tw-mode)
+    ("s" flyspell-mode)
+    ("q" nil))
+#+end_src
+
+** imenu
+
+=imenu= is part of core and does not need to be required.
+
+#+begin_src emacs-lisp
+  (bind-key [mouse-3] 'imenu)
+#+end_src
+
+** ispell
+
+I want to use aspell to check the spelling. It correctly supports
+Unicode and can have a very good quality of the suggestions.
+
+#+begin_src emacs-lisp
+  (setq ispell-program-name "aspell"
+        ispell-extra-args '("--sug-mode=slow"))
+#+end_src
+
+Normally I do not want to enable flyspell-mode automatically. I only
+want to enable it, if I specify a dictionary with =flyspell-dict= as
+file-local variable.
+
+Here I define a buffer-local variable and allow the setting of all
+strings as local variable without question.
+
+#+begin_src emacs-lisp
+  (defvar flyspell-dict nil
+    "Dictionary name, that should be set during `find-file' for
+  `flyspell-mode'. Set this as file-local or dir-local variable to
+  enable `flyspell-mode' automaticaly.")
+  (make-variable-buffer-local 'flyspell-dict)
+  (put 'flyspell-dict 'safe-local-variable #'stringp)
+#+end_src
+
+Enable ispell (if available) and iterate with =F8= over the list of
+preferred dictionaries.
+
+#+begin_src emacs-lisp
+  (use-package ispell
+    :config
+    (defvar alex/dictionaries '("english" "german")
+      "List of available dictionaries for ispell.")
+
+    (defun alex/switch-dictionary()
+      (interactive)
+      (let ((new (alex/get-next ispell-current-dictionary alex/dictionaries)))
+        (ispell-change-dictionary new)
+        (message "Dictionary switched to %s" new)))
+    (global-set-key (kbd "<f8>") 'switch-dictionary)
+
+    (use-package flyspell
+      :config
+      <<flyspell-config>>))
+#+end_src
+
+Update the flyspell status on various changes to the spell checking
+(selecting a different dictionary or adding a word to the personal
+dictionary).
+
+#+begin_src emacs-lisp :noweb-ref flyspell-config :tangle no
+  (defun alex/flyspell-update (&rest args)
+    (when flyspell-mode
+      (flyspell-buffer)))
+
+  (add-hook 'flyspell-mode-hook 'alex/flyspell-update)
+  (advice-add 'ispell-change-dictionary :after #'alex/flyspell-update)
+  (advice-add 'ispell-pdict-save :after #'alex/flyspell-update)
+#+end_src
+
+If =flyspell-dict= is set for the current buffer, set the value as
+current ispell dictionary and enable flyspell-mode. =flyspell-dict=
+should be set as local variable (file-local or dir-local).
+
+#+begin_src emacs-lisp :noweb-ref flyspell-config :tangle no
+  (defun alex/auto-flyspell-mode ()
+    "Automatically set `flyspell-dict' as dictionary for ispell and
+  enable `flyspell-mode'."
+    (when flyspell-dict
+      (ispell-change-dictionary flyspell-dict)
+      (flyspell-mode 1)))
+  (add-hook 'find-file-hook 'alex/auto-flyspell-mode)
+#+end_src
+
+This ignores all incorrect words in lines starting with
+=#include=. =flyspell-prog-mode= only checks strings and comments, but
+the include files could look like strings.
+
+#+begin_src emacs-lisp :noweb-ref flyspell-config :tangle no
+  (defun alex/flyspell-ignore-include (start end sug)
+    "Ignores all spelling errors in lines starting with #include."
+    (save-excursion
+      (goto-char start)
+      (beginning-of-line)
+      (if (looking-at "#include")
+          t
+        nil)))
+
+  (add-hook 'flyspell-incorrect-hook 'alex/flyspell-ignore-include)
+#+end_src
+
+** magit
+
+magit is a great mode for managing git repositories. I generally use
+=magit-status= as entry point for viewing repository status, staging
+and committing. For writing good commit messages, I activate
+=flyspell-mode= in the =magit-log-edit-mode=.
+
+#+begin_src emacs-lisp
+  (use-package magit
+    :bind ("<f5>" . magit-status)
+    :config
+    (add-hook 'magit-log-edit-mode-hook (lambda () (flyspell-mode 1))))
+#+end_src
+** multi-term
+
+multi-term supports much more terminal applications than similar modes
+and can automatically toggle a dedicated window. The only disadvantage
+is, that it does not work in combination with tramp.
+
+#+begin_src emacs-lisp
+  (use-package multi-term
+    :bind (("C-c t" . multi-term-dedicated-toggle)
+           ("C-c T" . multi-term))
+    :config
+    ;;(setq multi-term-dedicated-select-after-open-p t)
+    )
+#+end_src
+** neotree
+
+I rarely use a files browser in parallel to the main window. Usually I
+simply use =find-file= or a dired buffer. But if I really need it,
+neotree is a nice replacement for speedbar and simply work out of the
+box. I only added projectile support, so that the neotree open per
+default the project root (aka. the root of the git repository).
+
+#+begin_src emacs-lisp
+  (use-package neotree
+    :commands (neotree-dir neotree-find neotree-show)
+    :bind ("C-<tab>" . neotree-project-dir)
+    :init
+    (defun alex/neotree-find-file (dir file)
+      (neotree-dir dir)
+      (if file
+          (neotree-find (file-relative-name file dir))))
+
+    (defun neotree-project-dir ()
+      "Open NeoTree using the git root."
+      (interactive)
+      (if (and (fboundp 'neo-global--window-exists-p)
+               (neo-global--window-exists-p))
+          (neotree-hide)
+        (if (fboundp 'projectile-project-root)
+            (let ((projectile-require-project-root nil))
+              (let ((project-dir (projectile-project-root))
+                    (file-name (projectile-file-truename (buffer-file-name))))
+                (if project-dir
+                    (alex/neotree-find-file project-dir file-name)))))
+        (neotree-show))))
+#+end_src
+
+** nlinum
+
+I generally want to have line numbers. nlinum works best with folding,
+so I use that.
+
+#+begin_src emacs-lisp
+  (use-package nlinum
+    :config
+    <<nlinum-config>>)
+#+end_src
+
+*** global mode
+
+I use my global-excluding-minor-mode stuff an define some exceptions,
+where I do not want to have line numbers.
+
+#+begin_src emacs-lisp :noweb-ref nlinum-config :tangle no
+  (alex/define-global-excluding-minor-mode 'nlinum-mode)
+
+  (setq nlinum-mode-exclude-list
+        '(:minibuffer
+          :mode
+          Custom-mode
+          Man-mode
+          compilation-mode
+          dired-mode
+          doc-view-mode
+          eshell-mode
+          helm--mode
+          helm--remap-mouse-mode
+          image-mode
+          magit-mode
+          magit-status-mode
+          neotree-mode
+          term-mode
+          text-mode
+          weechat-mode
+          wl-folder-mode
+          wl-summary-mode))
+
+  (alex/global-nlinum-mode t)
+#+end_src
+
+*** number format
+
+I want to have some spacing around the numbers and calculate the
+width, so that the width does not change during scrolling.
+
+#+begin_src emacs-lisp :noweb-ref nlinum-config :tangle no
+  (setq nlinum-format " %d ")
+
+  (defun alex/nlinum-max-width ()
+    "Calculate maximum width of line numbers"
+    (setq nlinum--width
+          (length (format nlinum-format
+                          (count-lines (point-min) (point-max)))))
+    (nlinum--flush))
+  (add-hook 'nlinum-mode-hook 'alex/nlinum-max-width)
+#+end_src
+
+*** fix make-frame
+
+linum/nlinum currently triggers a bug in emacs: [[https://lists.gnu.org/archive/html/emacs-devel/2014-09/msg00022.html][Trunk emacs infelicity
+with linum mode]] that make it impossible to create a new frame while
+linum mode is active in at least on buffer. To fix this I
+around-advice =make-frame= and deactivate nlinum before and reactivate
+it again after creating the frame.
+
+#+begin_src emacs-lisp :noweb-ref nlinum-config :tangle no
+  (defun alex/deactivate-nlinum (buffer)
+    "Deactivates nlinum in the given BUFFER"
+    (with-current-buffer buffer
+      (nlinum-mode 0)))
+
+  (defun alex/activate-nlinum (buffer)
+    "Activates nlinum in the given BUFFER"
+    (with-current-buffer buffer
+      (let ((res (nlinum-mode 1)))
+        (nlinum--flush)
+        res)))
+
+  (defun alex/fix-nlinum (func &rest args)
+    "nlinum currently (emacs-24) triggers a bug, that makes it
+  impossible to create new frames because the linum face is not
+  defined. This is a fix, that deactivates nlinum in all buffers and
+  activate it again after creating the new frame."
+    (let ((nlinum-buffers (alex/get-buffers-with 'nlinum-mode)))
+      (mapc 'alex/deactivate-nlinum nlinum-buffers)
+      (alex/safe-call
+       (apply func args)
+       (mapc 'alex/activate-nlinum nlinum-buffers))))
+  (advice-add 'make-frame :around #'alex/fix-nlinum)
+#+end_src
+
+** org
+
+I use org-mode for my emacs config, taking notes, scheduling tasks and
+maybe more.
+
+#+begin_src emacs-lisp
+  (use-package org
+    :mode ("\\.org\\'" . org-mode)
+    :demand t
+    :config
+    <<org>>)
+#+end_src
+
+*** visual
+
+I want to have a nice display.
+
+On opening a org file, I want to see the outline but not the content
+of all nodes. This is useful to get an overview.
+
+The nested org nodes should be intended, so that it is easy to see the
+level, but I do not want to see the repeated stars in front of the
+nodes. (The nodes may even got more fancy, if org-bullets is
+available. See below.)
+
+If some parts are hidden, I want to prevent editing. If an edit action
+is started the hidden region will be unfolded and the action has to be
+confirmed.
+
+#+begin_src emacs-lisp :noweb-ref org :tangle no
+  (setq org-startup-folded 'content
+        org-startup-indented t
+        org-catch-invisible-edits t)
+#+end_src
+
+Hide =org-indent-mode= from modeline.
+
+#+begin_src emacs-lisp
+  (alex/rm-add-blacklist " Ind")
+#+end_src
+
+*** modules
+
+Setup some default modules to load. Some other modules might get
+loaded on demand (see below).
+
+#+begin_src emacs-lisp :noweb-ref org :tangle no
+  (setq org-modules '(org-annotate-file org-bbdb
+                      org-checklist org-collector org-eval org-expiry
+                      org-habit org-info org-man org-mouse org-protocol
+                      org-toc org-wl))
+
+  (org-load-modules-maybe t)
+#+end_src
+
+*** todo keywords
+
+Define some default TODO keywords and corresponding faces, that match
+my theme with a dark background.
+
+#+begin_src emacs-lisp :noweb-ref org :tangle no
+  (setq org-todo-keywords
+        '((sequence "TODO" "STARTED(s)" "WAITING(w)" "DELEGATED(l)" "|"
+                    "DONE(d)" "DEFERRED(f)" "CANCELLED(x)"))
+
+        org-todo-keyword-faces
+        '(("TODO"      . (:inherit org-warning))
+          ("STARTED"   . (:foreground "yellow" :weight bold))
+          ("DELEGATED" . (:foreground "darkred" :weight bold))
+          ("DEFERRED"  . (:foreground "gray" :weight bold))
+          ("CANCELLED" . (:foreground "gray" :weight normal))
+          ("DONE"      . (:foreground "cyan" :weight bold))))
+#+end_src
+
+*** bullets
+
+Automatically use org-bullets-mode if available and add the
+possibility to disable it on a per-file basis with
+=#+STARTUP: nobullets=.
+
+#+begin_src emacs-lisp :noweb-ref org :tangle no
+  (defvar alex/org-startup-with-bullets t
+    "Not-nil means entering Org-mode will enable org-bullets. This can
+  also be configured on a per-file basis adding on of the following
+  lines anywhere in the buffer:
+
+    ,#+STARTUP: bullets
+    ,#+STARTUP: nobullets")
+
+  (defun alex/org-bullets-setup ()
+    "Enable org-bullets if `alex/org-startup-with-bullets' is not-nil."
+    (when alex/org-startup-with-bullets
+      (org-bullets-mode 1)))
+  (add-hook 'org-mode-hook 'alex/org-bullets-setup)
+
+  (setq org-startup-options
+        (append org-startup-options
+                '(("bullets" org-startup-with-bullets t)
+                  ("nobullets" org-startup-with-bullets nil))))
+
+  (use-package org-bullets
+    :commands (org-bullets-mode))
+#+end_src
+
+*** agenda
+
+The agenda view should be generated only from the =todo.org= file.
+This file is the central place where I manage all TODO entries used
+for the agenda view and the daily schedule. The agenda view should
+always display 7 days from today, even if there are no scheduled tasks
+for a day.
+
+#+begin_src emacs-lisp :noweb-ref org :tangle no
+  (use-package org-agenda
+    :bind ("C-c a" . org-agenda)
+    :config
+    (setq org-agenda-files '("~/doc/org/todo.org")
+          org-agenda-span 'week
+          org-deadline-warning-days 14
+          org-agenda-show-all-dates t
+          org-agenda-skip-deadline-if-done t
+          org-agenda-skip-scheduled-if-done t
+          org-agenda-start-on-weekday nil
+          org-reverse-note-order t
+          org-fast-tag-selection-single-key 'expert))
+#+end_src
+
+*** capture
+
+Org-capture can quickly create notes or todo entries. It can also used
+in combination with org-protocol to receive information from other
+programs (like a web browser).
+
+#+begin_src emacs-lisp :noweb-ref org :tangle no
+  (use-package org-capture
+    :commands (org-capture)
+    :bind ("C-c o" . org-capture)
+    :config
+    (setq org-default-notes-file "~/doc/org/notes.org"
+          org-capture-templates
+          '(("t" "Tasks" entry
+             (file "~/doc/org/todo.org")
+             "* TODO %?\n%u")
+            ("n" "Notes" entry
+             (file+headline "~/doc/org/notes.org" "Notes")
+             "* %u %?")
+            ("c" "Capture" entry
+             (file+headline "~/doc/org/notes.org" "Links")
+             "* %^{Title}\n\nSource: %u, %c\n\n%i"))))
+#+end_src
+
+*** protocol
+
+Set default org-capture-template for org-protocol.
+
+#+begin_src emacs-lisp :noweb-ref org :tangle no
+  (setq org-protocol-default-template-key "c")
+#+end_src
+
+When I start an org-capture in an org-protocol popup, I want to show
+only the org-capture buffer (default behaviour would be to split the
+current buffer) and I want to close the popup after finishing the
+capture.
+
+When using org-capture with placeholders, we need to delete the other
+windows just before starting to filling out the placeholders. The
+advice after org-capture is too late, it would delete the other
+windows after filling the placeholders.
+
+#+begin_src emacs-lisp :noweb-ref org :tangle no
+  (defun alex/org-capture-single-window (&rest args)
+    "Make the org-capture the only window when used as a popup"
+    (when (equal "emacs-capture" (frame-parameter nil 'name))
+      (delete-other-windows)))
+  (advice-add 'org-capture :after #'alex/org-capture-single-window)
+  (advice-add 'org-completing-read-no-i :before #'alex/org-capture-single-window)
+
+  (defun alex/org-capture-delete-frame (&rest args)
+    "Close the frame after finishing the capture, when used org-capture
+  as a popup"
+    (when (equal "emacs-capture" (frame-parameter nil 'name))
+      (delete-frame)))
+  (advice-add 'org-capture-finalize :after #'alex/org-capture-delete-frame)
+#+end_src
+
+*** journal
+
+#+begin_src emacs-lisp :noweb org-config :tangle no
+  (use-package org-journal
+    :bind ("C-c C-j" . org-journal-new-entry)
+    :config
+    (setq org-journal-dir "~/doc/org/journal/"
+          org-agenda-file-regexp "\\`\\([^.].*\\.org\\|[0-9]+\\)\\'"))
+#+end_src
+
+*** org without helm
+
+org has a function, that requests input without ido completion. For
+this function I disable helm.
+
+#+begin_src emacs-lisp :noweb-ref org :tangle no
+  (defun alex/run-without-helm (orig-func &rest args)
+    "Run a function without helm completion."
+    (if (boundp 'helm-mode)
+        (let ((orig-helm-mode helm-mode))
+          (helm-mode 0)
+          (alex/safe-call
+           (apply orig-func args)
+           (when orig-helm-mode
+             (helm-mode 1))))
+      (apply orig-func args)))
+
+  (advice-add 'org-completing-read-no-i :around #'alex/run-without-helm)
+#+end_src
+** origami
+
+Sometimes I want to fold some code sections. There are several mode
+available, but only origami supports insertion of new regions without
+reopening or parsing the whole buffer. But I do not want to use the
+semantic expression feature of origami and my markers should support a
+title in the first line after the marker. 
+
+I define my own parser for origami and modify the behaviour for my
+needs.
+
+#+begin_src emacs-lisp
+  (use-package origami
+    :demand t
+    :bind (("C-c C-f" . origami-toggle-node)
+           ("C-c M-f" . origami-close-all-nodes)
+           ("C-c f" . origami-open-all-nodes))
+
+    :config
+    <<origami-config>>)
+#+end_src
+
+*** custom format for folded display
+
+Per default origami is used to fold semantic expressions and only
+shows the marker at the front and end of the region. I want to use
+explicit marker inside comments and want to add a description (title)
+for the region after the opening marker. So I want to keep the whole
+first line visible while the region is folded.
+
+#+begin_src emacs-lisp :noweb-ref origami-config :tangle no
+  (defun alex/origami-build-pair-tree (create open close positions)
+    "This is like `origami-build-pair-tree' and now keeps the whole
+  first line visible while folded."
+    (cl-labels ((build (positions)
+                       ;; this is so horrible, but fast
+                       (let (acc beg (should-continue t))
+                         (while (and should-continue positions)
+                           (cond ((equal (caar positions) open)
+                                  (if beg                       ;go down a level
+                                      (let* ((res (build positions))
+                                             (new-pos (car res))
+                                             (children (cdr res))
+                                             (beg-end (save-excursion
+                                                        (goto-char beg)
+                                                        (line-end-position)))
+                                             (end (cdar new-pos)))
+                                        (setq positions (cdr new-pos))
+                                        (setq acc (cons (funcall create beg (+ end (length close)) (- beg-end beg) children)
+                                                        acc))
+                                        (setq beg nil))
+                                    ;; begin a new pair
+                                    (setq beg (cdar positions))
+                                    (setq positions (cdr positions))))
+                                 ((equal (caar positions) close)
+                                  (if beg
+                                      (let ((beg-end (save-excursion
+                                                       (goto-char beg)
+                                                       (line-end-position)))
+                                            (end (cdar positions)))
+                                        (if (< beg-end end)
+                                            ;;close with no children
+                                            (setq acc (cons (funcall create beg (+ end (length close)) (- beg-end beg) nil)
+                                                            acc)))
+                                        (setq positions (cdr positions))
+                                        (setq beg nil))
+                                    (setq should-continue nil)))))
+                         (cons positions (reverse acc)))))
+      (cdr (build positions))))
+#+end_src
+
+*** respect derived modes
+
+I manually specify the parser for the origami markers. For more
+flexibility I want to support derived modes (f.e. if I assign a value
+for emacs-list-mode, this parser should also support the
+lisp-interaction-mode).
+
+Therefore I advice the =origami-get-parser= function and temporarily
+overwrite the =origami-parser-alist= and change all definitions with a
+compatible mode to the exact major mode of the requested buffer.
+
+#+begin_src emacs-lisp :noweb-ref origami-config :tangle no
+  (defun alex/origami-is-derived-mode (buffer parser-elem)
+    "Helper for `alex/origami-parser-derived-modes' to check if the
+  current major-mdoe in BUFFER is a dreived mode of the mode part of
+  an element from the  `origami-parser-alist'."
+    (let ((mode (car parser-elem))
+          (parser (cdr parser-elem)))
+      (with-current-buffer buffer
+        (if (derived-mode-p mode)
+            (cons major-mode parser)
+          nil))))
+
+  (defun alex/origami-parser-derived-modes (func buffer &rest args)
+    "Modify the origami-parser-alist on demand to respect the derived
+  major-modes of the defined modes."
+      (let* ((check (apply-partially 'alex/origami-is-derived-mode buffer))
+           (origami-parser-alist (delq nil (mapcar check origami-parser-alist))))
+      (apply func buffer args)))
+
+  (advice-add 'origami-get-parser :around #'alex/origami-parser-derived-modes)
+#+end_src
+
+*** define simple marker for different modes
+
+#+begin_src emacs-lisp :noweb-ref origami-config :tangle no
+  (defun alex/origami-markers-parser (begin end create)
+    "Create a origami parser for regions between BEGIN and END
+  markers. The folded region will show the complete first line after the
+  marker but not the END marker."
+    (lexical-let ((create-tmp create)
+                  (begin-tmp begin)
+                  (end-tmp end)
+                  (regexp (rx-to-string `(or ,begin ,end))))
+      (lambda (content)
+        (let ((positions (origami-get-positions content regexp)))
+          (alex/origami-build-pair-tree create-tmp begin-tmp end-tmp positions)))))
+
+  (defun alex/origami-marker (mode start end)
+    "Define a cons with MODE and the marker-parser for origmai, that
+  could be used directly as element for `origami-parser-alist'."
+    `(,mode . ,(apply-partially 'alex/origami-markers-parser start end)))
+
+  (setq origami-parser-alist
+        `(,(alex/origami-marker 'emacs-lisp-mode ";;{{{" ";;}}}")
+          ,(alex/origami-marker 'lisp-mode ";;{{{" ";;}}}")
+          ,(alex/origami-marker 'sh-mode "#{{{" "#}}}")
+          ,(alex/origami-marker 'php-mode "//{{{" "//}}}")
+          ,(alex/origami-marker 'haskell-mode "--{{{" "--}}}")))
+#+end_src
+
+*** global-minor-mode
+
+I want to use origami-mode everywhere, so I create a global minor-mode
+and activate it.
+
+#+begin_src emacs-lisp :noweb-ref origami-config :tangle no
+  (alex/define-global-excluding-minor-mode 'origami-mode)
+  (alex/global-origami-mode t)
+#+end_src
+** powerline
+
+I use powerline to get a nicer modeline, but I change some aspects to
+enhance it even more.
+
+#+begin_src emacs-lisp
+  (use-package powerline
+    :config
+    <<powerline-config>>)
+#+end_src
+
+*** display utf8 glyphs
+
+Currently powerline only displays the nice utf-8 glyphs (f.e. for git
+branches) if =window-system= is nil. So we simply wrap =powerline-vc=
+and temporarily unset =window-system=.
+
+#+begin_src emacs-lisp :noweb-ref powerline-config :tangle no
+  (defun alex/fix-powerline-vc (orig-fun &rest args)
+    "Fix utf8 glyphs display." 
+    (let ((window-system nil))
+      (apply orig-fun args)))
+  (advice-add 'powerline-vc :around #'alex/fix-powerline-vc)
+#+end_src
+
+*** smart-mode-line
+
+I only use smart-mode-line for the file paths feature. I need to call
+=sml/setup=, but I do not want to load a theme because it is
+incompatible with powerline. So I simply overwrite =sml/-setup-theme=
+with =ignore=.
+
+#+begin_src emacs-lisp :noweb-ref powerline-config :tangle no
+  (use-package smart-mode-line
+    :config
+    (advice-add 'sml/-setup-theme :around #'ignore)
+    (sml/setup))
+#+end_src
+
+*** rich-minority
+
+I use rich-minority-mode, that has no support for powerline out of the
+box. So I advice the =powerline-minor-modes= function and let
+rich-minority temporarily overwrite the minor-mode-alist.
+
+#+begin_src emacs-lisp :noweb-ref powerline-config :tangle no
+  (defun alex/powerline-rm-setup ()
+    (defun alex/powerline-rm (orig-fun &rest args)
+      "Applies the rich-minority-mode on the powerline display of the
+    minor-modes."
+      (let ((minor-mode-alist (if rich-minority-mode
+                                  (rm--mode-list-as-string-list)
+                                minor-mode-alist)))
+        (apply orig-fun args)))
+    (advice-add 'powerline-minor-modes :around #'alex/powerline-rm))
+
+  (eval-after-load 'rich-minority #'alex/powerline-rm-setup)
+#+end_src
+
+*** powerline theme
+
+Setup the powerline theme. Currently I only change the separator and
+make it a little bit higher.
+
+#+begin_src emacs-lisp :noweb-ref powerline-config :tangle no
+  (setq powerline-default-separator 'wave
+        powerline-height 25)
+
+  (powerline-default-theme)
+#+end_src
+
+** projectile
+
+Projectile allows fast search for files in project directories. I want
+to use it everywhere but do not want to see the minor-mode. It
+automatically recognize git repositories as projects.
+
+#+begin_src emacs-lisp
+  (use-package projectile
+    :diminish " Projectile.*"
+    :config
+    (projectile-global-mode)
+    (setq projectile-enable-caching t
+          projectile-cache-file (alex/cache-file "projectile")
+          projectile-known-projects-file (alex/cache-file "projectile-bookmarks")))
+#+end_src
+
+** semantic
+
+semantic is an emacs mode, that parses the source code of the current
+buffer. It has support for many languages out of the box (C/C++,
+Python, elisp, Erlang...). I want to enable it in all buffers. The
+only disadvantage is, that opening a file could trigger the parsing
+and will block emacs for a while (depending on how many files are in
+the including hierarchy).
+
+#+begin_src emacs-lisp
+  (use-package semantic
+    :config
+    (use-package semantic/ia)
+    (setq semanticdb-default-save-directory (alex/cache-file "semantic"))
+
+    (semantic-mode 1)
+    (global-semantic-idle-summary-mode 1))
+#+end_src
+
+** server
+
+Start server (if not running) to edit files with emacsclient and
+rebind =C-x k= in server buffers to close it.
+
+#+begin_src emacs-lisp
+  (use-package server
+    :config
+    (when (and (fboundp 'server-running-p)
+               (not (server-running-p)))
+      (server-start))
+
+    (defun alex/server-swtich-hook ()
+      (when (current-local-map)
+        (use-local-map (copy-keymap (current-local-map))))
+      (when server-buffer-clients
+        (local-set-key (kbd "C-x k") 'server-edit)))
+
+    (add-hook 'server-switch-hook 'alex/server-swtich-hook))
+
+#+end_src
+
+** smartparens
+
+smartparens-mode has various features. I only want to have the
+highlighting of matching parens and the automatic wrapping of the
+region, but I do not want that it inserts, deletes or skips some
+parens.
+
+#+begin_src emacs-lisp
+  (use-package smartparens-config
+    :config
+    (setq-default sp-autoinsert-pair nil
+                  sp-autodelete-pair nil
+                  sp-autodelete-opening-pair nil
+                  sp-autodelete-closing-pair nil
+                  sp-autoskip-closing-pair nil)
+
+    (smartparens-global-mode t)
+    (show-smartparens-global-mode t)
+    :diminish
+    " SP")
+#+end_src
+
+** template
+
+I want to insert template automatically in new empty files with the
+correct extension. But I only want to search for global templates by
+default and not in a sub directory of the new file. I also do not want
+to update the content of a file after saving (f.e. when saving under a
+different name).
+
+#+begin_src emacs-lisp
+  (use-package template
+    :config
+    (setq template-auto-insert t
+          template-auto-update nil
+          template-confirm-insecure nil
+
+          template-date-format "%Y-%m-%d"
+          template-time-format "%T"
+
+          template-subdirectories nil
+          template-default-directories (list (concat user-emacs-directory
+                                                     "templates/")))
+    (template-initialize))
+#+end_src
+** tramp
+
+I usually have very heavy shell customization on remote hosts. I do
+not want to depend, that tramp can parse my custom prompt format. So I
+set =sshx= as default tramp method, that explicit invoke =/bin/sh= as
+shell on the remote host.
+
+#+begin_src emacs-lisp
+  (use-package tramp
+    :config
+    (setq tramp-default-method "sshx"
+          tramp-persistency-file-name (alex/cache-file "tramp")))
+#+end_src
+
+*** dir-locals
+
+Support dir-locals also via tramp. This leads to a additional delay
+while opening a file via tramp (because it has to check for the
+dir-locals file over ssh) but usually I do not want to clutter single
+files with file-local variables.
+
+#+begin_src emacs-lisp
+  (setq enable-remote-dir-locals t)
+#+end_src
+** uniquify
+
+Use a better approach to make unique buffer names. The default
+algorithm just adds a count after the filename if you opened two files
+with the same name. =uniquify= adds the path to the buffer name, so
+that the right buffer is easier to identify.
+
+#+begin_src emacs-lisp
+  (use-package uniquify
+    :config
+    (setq uniquify-buffer-name-style 'reverse))
+#+end_src
+
+** uptimes
+
+I want to measure the uptime of emacs. This should not be deferred
+loaded, because it captures the start time of in the moment it gets
+loaded.
+
+#+begin_src emacs-lisp
+  (use-package uptimes
+    :demand t
+    :config
+    (setq uptimes-database (alex/cache-file "uptimes")))
+#+end_src
+
+** weechat
+
+#+begin_src emacs-lisp
+  (use-package weechat
+    :commands (weechat-connect)
+    :functions (weechat-channel-names
+                weechat-monitor-buffer
+                weechat--find-buffer
+                weechat-buffer-hash)
+
+    :init
+    (defun weechat ()
+      "Start weechat with `weechat-connect' and automatically switch to
+    the first buffer in `weechat-auto-monitor-buffers'."
+      (interactive)
+      (weechat-connect)
+      (when weechat-auto-monitor-buffers
+        (switch-to-buffer
+         (car weechat-auto-monitor-buffers))))
+
+    :config
+    <<weechat-config>>)
+#+end_src
+
+*** config
+
+I connect to weechat running on the host called =island= via ssh
+tunneling, monitor only a few buffers by default and close the buffers
+on disconnect.
+
+#+begin_src emacs-lisp :noweb-ref weechat-config :tangle no
+  (setq weechat-buffer-kill-buffers-on-disconnect t
+
+        weechat-host-default "is.zedat.fu-berlin.de"
+        weechat-port-default 58224
+        weechat-mode-default "ssh -W localhost:%p %h"
+
+        weechat-text-column 25
+        weechat-header-line-format "%c/%s: %t"
+
+        weechat-auto-monitor-buffers '("freenode.#spline"
+                                       "ircnet.&ZEDAT-IS"
+                                       "oftc.#vserver"))
+
+  (defun alex/weechat-mode-hook ()
+    "Activate `visual-line-mode'."
+    (visual-line-mode 1))
+  (add-hook 'weechat-mode-hook 'alex/weechat-mode-hook)
+#+end_src
+
+*** helm support
+
+#+begin_src emacs-lisp :noweb-ref weechat-config :tangle no
+  (defun alex/helm-weechat-support ()
+
+    (defun alex/weechat-new-buffers ()
+      (let ((current (weechat-channel-names t))
+            (all (weechat-channel-names nil)))
+        (mapc (lambda (cur) (setq all (delete cur all))) current)
+        (sort all 'string-lessp)))
+
+    (defun alex/weechat-add-buffer (name)
+      (weechat-monitor-buffer (weechat--find-buffer name) t))
+
+    (defun alex/weechat-get-count (channel type)
+      (let ((hash (gethash type channel)))
+        (if (not (not hash))
+            (gethash :count hash)
+          0)))
+
+    (defun alex/weechat-show-topic (channels)
+      (mapcar
+       (lambda (channel)
+         (let* ((hash (weechat-buffer-hash (weechat--find-buffer channel)))
+                (hlight (alex/weechat-get-count hash :background-highlight))
+                (message (alex/weechat-get-count hash :background-message))
+                (chan-name (if (> (string-width channel) helm-buffer-max-length)
+                               (helm-substring-by-width
+                                channel helm-buffer-max-length)
+                             (concat channel (make-string
+                                              (- (+ helm-buffer-max-length 3)
+                                                 (string-width channel)) ? ))))
+                (chan (cond
+                       ((> hlight 0)
+                        (propertize chan-name 'face 'helm-buffer-saved-out))
+                       ((> message 0)
+                        (propertize chan-name 'face 'helm-buffer-not-saved))
+                       (t chan-name)))
+                (hlight-count (if (> hlight 0)
+                                  (propertize (format "%-3d" hlight)
+                                              'face 'helm-buffer-saved-out)
+                                "   "))
+                (message-count (if (> message 0)
+                                   (format "%3d" message) "   "))
+                (count-sep (if (and (> message 0) (> hlight 0))
+                               "," " "))
+                (topic (propertize
+                        (gethash "title" hash)
+                        'face 'helm-ff-symlink)))
+           (cons (format "%s\t%s%s%s\t%s" chan message-count count-sep
+                         hlight-count topic)
+                 channel)))
+       channels))
+
+    (defun alex/weechat-ignore-buffer (channels)
+      (delq nil
+            (mapcar
+             (lambda (channel)
+               (let* ((hash (weechat-buffer-hash (weechat--find-buffer channel)))
+                      (plugin (cdr (assoc "plugin" (gethash "local_variables" hash))))
+                      (type (cdr (assoc "type" (gethash "local_variables" hash)))))
+                 (when (and (string= "irc" plugin) (string= "channel" type))
+                   channel)))
+             channels)))
+
+    (defun alex/helm-weechat-buffer-toggle-ignore ()
+      (interactive)
+      (with-helm-alive-p
+        (let ((filter-attrs (helm-attr 'candidate-transformer
+                                       alex/weechat-new-buffers-source)))
+          (if (memq 'alex/weechat-ignore-buffer filter-attrs)
+              (helm-attrset 'candidate-transformer
+                            (remove 'alex/weechat-ignore-buffer
+                                    filter-attrs)
+                            alex/weechat-new-buffers-source t)
+            (helm-attrset 'candidate-transformer
+                          (cons 'alex/weechat-ignore-buffer
+                                filter-attrs)
+                          alex/weechat-new-buffers-source t))
+          (helm-force-update))))
+
+    (setq alex/helm-weechat-buffer-map (copy-keymap helm-map))
+    (bind-key "C-c C-c" 'alex/helm-weechat-buffer-toggle-ignore
+              alex/helm-weechat-buffer-map)
+
+    (setq alex/weechat-new-buffers-source nil)
+    (defun alex/helm-weechat-buffer ()
+      (interactive)
+      (setq alex/weechat-new-buffers-source
+            (helm-build-sync-source "Available channel"
+              :candidates (alex/weechat-new-buffers)
+              :action '(("Monitor channel" . alex/weechat-add-buffer))
+              :candidate-transformer '(alex/weechat-ignore-buffer
+                                       alex/weechat-show-topic)))
+      (let ((helm-truncate-lines t))
+        (helm
+         :sources (list
+                   (helm-build-sync-source "Buffers"
+                     :candidates (weechat-channel-names t)
+                     :action '(("Open buffer" . switch-to-buffer))
+                     :candidate-transformer '(alex/weechat-show-topic))
+                   alex/weechat-new-buffers-source)
+         :buffer "*weechat*"
+         :keymap alex/helm-weechat-buffer-map)))
+
+    (bind-key "C-c C-b" 'alex/helm-weechat-buffer weechat-mode-map)
+
+    (defun alex/mark-read ()
+      "Mark buffer as read up to current line."
+      (interactive)
+      (let ((inhibit-read-only t))
+        (put-text-property
+         (point-min) (line-beginning-position)
+         'face       'font-lock-comment-face)))
+    (bind-key "<escape>" 'alex/mark-read weechat-mode-map))
+
+  (eval-after-load 'helm #'alex/helm-weechat-support)
+#+end_src
+** which-key
+
+I cannot remember all the key combinations. which-key will show a
+hint for possible completions, if I start a key combo and wait longer
+than 1s before continue with the next key.
+
+#+begin_src emacs-lisp
+  (use-package which-key
+    :config
+    (setq which-key-idle-delay 1.0)
+    (which-key-mode t)
+    :diminish
+    which-key-mode)
+#+end_src
+
+** winner
+
+I use winner to quickly restore a previous window configuration after
+it was changed by something. I demand it here, because winner mode
+need to be active to keep track of the changes and helm will notice it
+and will insert the helm buffer names into =winner-boring-buffers=.
+
+#+begin_src emacs-lisp
+  (use-package winner
+    :bind (("C-c <left>" . winner-undo)
+           ("C-c <right>" . winner-redo))
+    :demand t
+    :config
+    (winner-mode 1))
+#+end_src
+
+** winring
+
+With winring it is possible to manage different window configurations
+and switching between. This could be useful if working with
+specialized window configurations (f.e. for debugging) and activating
+it when needed.
+
+#+begin_src emacs-lisp
+  (use-package winring
+    :bind (("C-x j" . winring-jump-to-configuration)
+           ("C-x n" . winring-new-configuration)
+           ("C-x K" . winring-delete-configuration))
+    :functions (winring-initialize)
+    :config
+    (winring-initialize)
+
+    (defun alex/confirm-winring-deletion (&rest args)
+      (y-or-n-p (format "Delete winring configuration %s? " winring-name)))
+
+    (advice-add 'winring-delete-configuration
+                :before-while
+                #'alex/confirm-winring-deletion))
+#+end_src
+
+** wl
+
+Here are only the functions for auto-loading. I customize wanderlust,
+to load the profile from the org-babel file =init.d/wl.org= during
+start-up of wanderlust.
+
+I use a separate frame for wanderlust with a custom name, so that
+XMonad can shift it to a different desktop. Additionally I create
+a function, that should be called with emacsclient to compose a new
+message from a mailto link. This function also creates a new frame
+with a custom name and closes it after sending the mail.
+
+#+begin_src emacs-lisp
+  (use-package wl
+    :commands (wl-other-frame wl-draft)
+    :init
+    (defun wl-start ()
+      "Start wanderlust in a seperate frame and set the name of the new
+    frame to `wanderlust'."
+      (interactive)
+      (let ((default-frame-alist
+              (cons '(name . "wanderlust") default-frame-alist)))
+        (wl-other-frame)))
+
+    (defun alex/wl-mailto-compose-new-frame (mailto-url)
+      "Compose a new mail from a mailto link with wanderlust in a new
+    frame and customize the name of the new frame to
+    `wanderlust-draft'."
+      (let ((default-frame-alist
+              (cons '(name . "wanderlust-draft") default-frame-alist))
+            (wl-draft-use-frame t))
+        (alex/wl-mailto-compose mailto-url)
+        (set-window-dedicated-p (selected-window) t)
+
+        (make-local-variable 'wl-draft-force-delete-frame)
+        (setq wl-draft-force-delete-frame t)
+        (run-hooks 'wl-mail-setup-hook)))
+
+    (require 'rfc2368)
+    (defun alex/wl-mailto-compose (mailto-url)
+      "Parse a rfc2368 mailto links and call `wl-draft' with the
+    information for the headers and the body."
+      (when (and (stringp mailto-url) (string-match "\\`mailto:" mailto-url))
+        (let* ((headers (mapcar (lambda (h) (cons (intern (car h)) (cdr h)))
+                                (rfc2368-parse-mailto-url mailto-url)))
+               (good-headers (assq-delete-all 'Body (copy-alist headers)))
+               (body (cdr (assoc 'Body headers))))
+          (wl-draft good-headers nil nil body))))
+
+    (defvar wl-draft-force-delete-frame nil
+      "If this variable is t `alex/wl-draft-force-hide' always delete
+    the frame after closing the draft. You may want to make this
+    variable buffer-local whenever you use it. This variable is used by
+    `alex/wl-mailto-compose-new-frame' to close the created frame after
+    composing the mail.")
+
+    (defun alex/wl-draft-force-hide (func &rest args)
+      "This advice removes the draft-frame even if no other frame is
+    visible if `alex/wl-draft-force-delete-frame' is non-nil."
+      (let ((force-delete (and (boundp 'wl-draft-force-delete-frame)
+                               wl-draft-force-delete-frame)))
+        (apply func args)
+        (if force-delete
+            (delete-frame))))
+    (advice-add 'wl-draft-hide :around #'alex/wl-draft-force-hide)
+
+    :config
+    (defun alex/wl-babel-load-profile ()
+      "Load `wl-init-file' with `org-babel-load-file'."
+      (org-babel-load-file wl-init-file))
+
+    (setq wl-init-file (locate-user-emacs-file "init.d/wl.org")
+          wl-load-profile-function 'alex/wl-babel-load-profile))
+#+end_src
+
+** yasnippet
+
+I want to use yasnippets everywhere, so I enable the global mode. In
+addition to the default snippets I have some in my personal dir. It
+does not load the all snippets during startup, but only if the first
+buffer switches to the corresponding mode (only the directories are
+searched during activation of the global mode).
+
+#+begin_src emacs-lisp
+  (use-package yasnippet
+    :config
+    (setq yas-snippet-dirs `("~/.emacs.d/snippets/"
+                             ,yas-installed-snippets-dir))
+    (yas-global-mode 1)
+    :diminish yas-minor-mode)
+#+end_src
+