#+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)) auto-save-list-file-prefix (alex/cache-file "auto-save-list/.saves-")) #+end_src ** Remove some annoyances *** No startup message Remove the startup screen. #+begin_src emacs-lisp (setq inhibit-startup-message t) #+end_src Remote the message in the message area: For information about GNU Emacs and the GNU system, type C-h C-a =inhibit-startup-echo-area-message= could be used, but it has to be set to the username (as elisp literal), So =(user-login-name)= does not work. To generalize the config, this simply overwrites the config printing the message. #+begin_src emacs-lisp (defun display-startup-echo-area-message ()) #+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 *** Unbind C-z, if not running in terminal C-z is a relict from terminal programms to suspend the currently running programm. It is not needed under X11 and the gui will freeze, if you press it by accident. #+begin_src emacs-lisp (when window-system (global-unset-key (kbd "C-z"))) #+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 <<hydra>>) #+end_src *** move splitter With this hydra I can move the splitter between frames using the cursor keys. #+begin_src emacs-lisp :noweb-ref hydra :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 hydra :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 hydra :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 *** org-id org-id can create, save and find global unique ids for linking to org entries. I want to customize location of the file, that tracks the ids globally and enable the use of org-ids for creating of links. #+begin_src emacs-lisp (use-package org-id :init (setq org-id-locations-file (alex/cache-file "org-id-locations") org-id-link-to-org-use-id 't)) #+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 #+begin_src emacs-lisp (use-package yasnippet :diminish yas-minor-mode :config <<yas>>) #+end_src *** Own snippet directory In addition to the default snippets I have some in my personal dir. #+begin_src emacs-lisp :tangle no :noweb-ref yas (setq yas-snippet-dirs `("~/.emacs.d/snippets/" ,yas-installed-snippets-dir)) #+end_src *** Enable global mode I want to use yasnippets everywhere, so I enable the global mode. 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 :tangle no :noweb-ref yas (yas-global-mode 1) #+end_src *** Reduce verbosity I do not need the messages about loading all the snippets. The default verbosity of =4= can be reduced. #+begin_src emacs-lisp :tangle no :noweb-ref yas (setq yas-verbosity 2) #+end_src