Emacs init

Since everything that isn't installed through Managing Packages is stored under my .emacs.d directory I don't want tons of add-to-list calls in my init file, so I add everything under .emacs.d to the load path.

(let ((default-directory "~/.emacs.d/"))
  (normal-top-level-add-subdirs-to-load-path))

Being asked to type in yes explicitly all the time gets very tedious. I understand that it is safer since y is much easier to type in accidentally than yes and so the potential to say yes to things you don't want is there, but I haven't had any such problems yet.

(defalias 'yes-or-no-p 'y-or-n-p)

Since ibuffer is (almost?) completely compatible with list-buffers but also includes more features than list-buffers, it is safe (and nice) to switch them.

(defalias 'list-buffers 'ibuffer)

Then we can use some of its nicer features like buffer grouping.

(defun oni:ibuffer-mode-func ()
  "Function for `ibuffer-mode-hook'."
  (ibuffer-switch-to-saved-filter-groups "default"))

(setq-default
 ibuffer-saved-filter-groups
 '(("default"
    ("emacs" (or (filename . "emacs\\.d")
                 (mode . emacs-lisp-mode)))
    ("work" (filename . "/aethon/"))
    ("jabber" (name . "^\\*jabber-"))
    ("org" (filename . ".*\\.org$"))
    ("magit" (name . "^\\*magit-.*\\*$"))
    ("mu4e" (name . "^\\*mu4e-.*\\*$"))
    ("scratch" (name . "^\\*.*\\*$")))))

(add-hook 'ibuffer-mode-hook 'oni:ibuffer-mode-func)

Code folding can make a buffer filled with code look a lot less daunting.

Code that goes on too long on a line doesn't look nice, having to check each line you write to see whether or not it is too long is no fun, having auto-fill-mode split your code lines at the worst possible point is not handy, showing an annoying line whenever a piece of code gets too long is motivation enough to want to fix it.

Usually, when coding, I try not to go beyond 72 characters per line, it is handy to have an indication of this margin.

(setq-default fci-rule-column 73)

The default color is not exactly what I want, I think a dark red margin might be quite appropriate.

(setq fci-rule-color "darkred")

I watch a few TV shows, and I like them to be listed in my org agenda. This way I can be reminded of what I need to look for.

(defun oni:mini-fix-timestamp-string (date-string)
  "A minimal version of Xah Lee's `fix-timestamp-string'
  function, found at http://xahlee.org/emacs/elisp_parse_time.html"
  (setq date-string (replace-regexp-in-string "Jan" "01" date-string)
        date-string (replace-regexp-in-string "Feb" "02" date-string)
        date-string (replace-regexp-in-string "Mar" "03" date-string)
        date-string (replace-regexp-in-string "Apr" "04" date-string)
        date-string (replace-regexp-in-string "May" "05" date-string)
        date-string (replace-regexp-in-string "Jun" "06" date-string)
        date-string (replace-regexp-in-string "Jul" "07" date-string)
        date-string (replace-regexp-in-string "Aug" "08" date-string)
        date-string (replace-regexp-in-string "Sep" "09" date-string)
        date-string (replace-regexp-in-string "Oct" "10" date-string)
        date-string (replace-regexp-in-string "Nov" "11" date-string)
        date-string (replace-regexp-in-string "Dec" "12" date-string))
  (string-match
   "^\\([0-9]\\{2\\}\\)-\\([0-9]\\{2\\}\\)-\\([0-9]\\{4\\}\\)$"
   date-string)
  (format "%s-%s-%s"
          (match-string 3 date-string)
          (match-string 2 date-string)
          (match-string 1 date-string)))

(defun oni:myepisodes-formatter (plist)
  (let ((str (plist-get plist :title)))
    (string-match
     "^\\[ \\([^\]]+\\) \\]\\[ \\([^\]]+\\) \\]\\[ \\([^\]]+\\) \\]\\[ \\([^\]]+\\) \\]$"
     str)
    (let* ((title (match-string 1 str))
           (episode (match-string 2 str))
           (name (match-string 3 str))
           (date (oni:mini-fix-timestamp-string (match-string 4 str))))
      (format "* ACQUIRE %s %s - %s <%s>" title episode name date))))

(setq org-feed-alist
      '(("MyEpisodes"
         "http://www.myepisodes.com/rss.php?feed=mylist&uid=Slash&pwdmd5=04028968e1f0b7ee678b748a4320ac17"
         "~/documents/org/org" "MyEpisodes"
         :formatter oni:myepisodes-formatter)))

Emacs has many programs to facilitate communication with others, from email and chat to integration with social networks.

Seeing Ovwrt in the mode-line when overwrite-mode is on and %% instead of -- when a buffer is read-only is not good enough, a proper indication, much like vi, of what we're in for is needed.

(defvar oni:normal-color "yellow"
  "Cursor color to pass along to `set-cursor-color' for normal
  buffers.")

(defvar oni:normal-cursor-type 'bar
  "A `cursor-type' for normal buffers.")

(defvar oni:overwrite-color "red"
  "Cursor color to pass along to `set-cursor-color' for buffers
  in overwrite mode.")

(defvar oni:overwrite-cursor-type 'box
  "A `cursor-type' for buffers in overwrite mode.")

(defvar oni:read-only-color "gray"
  "Cursor color to pass along to `set-cursor-color' for read-only
  buffers.")

(defvar oni:read-only-cursor-type 'hbar
  "A `cursor-type' for read-only buffers.")

(defun oni:set-cursor-according-to-mode ()
  "Change cursor color and type according to some minor modes."
  (cond
   (buffer-read-only
    (set-cursor-color oni:read-only-color)
    (setq cursor-type oni:read-only-cursor-type))
   (overwrite-mode
    (set-cursor-color oni:overwrite-color)
    (setq cursor-type oni:overwrite-cursor-type))
   (t
    (set-cursor-color oni:normal-color)
    (setq cursor-type oni:normal-cursor-type))))

(defun oni:post-command-func ()
  "Function for `post-command-hook'."
  (oni:set-cursor-according-to-mode))

(add-hook 'post-command-hook 'oni:post-command-func)

With package.el we have a real package manager for emacs, and it is nice to have.

(defvar oni:required-packages
  '(graphviz-dot-mode htmlize jabber magit rainbow-delimiters
                      rainbow-mode yasnippet markdown-mode flymake
                      flymake-cursor pony-mode python sauron)
  "List of all the packages I have (want) installed")

(defun oni:required-packages-installed-p ()
  "Check if all the packages I need are installed."
  (let ((tmp-packages oni:required-packages)
        (result t))
    (while (and tmp-packages result)
      (if (not (package-installed-p (car tmp-packages)))
          (setq result nil))
      (setq tmp-packages (cdr tmp-packages)))
    result))

(setq package-archives
      '(("melpa" . "http://melpa.milkbox.net/packages/")
        ("ELPA" . "http://tromey.com/elpa/")
        ("gnu" . "http://elpa.gnu.org/packages/")
        ("marmalade" . "http://marmalade-repo.org/packages/")))

(package-initialize)
(unless (oni:required-packages-installed-p)
  (message "%s" "Refreshing package database...")
  (package-refresh-contents)
  (message "%s" " done.")
  (mapc #'(lambda (package)
            (when (not (package-installed-p package))
              (package-install package)))
        oni:required-packages))

When writing emacs lisp scripts/programs its nice to have them automatically compiled, catches some errors at times and makes them nice and speedy.

When writing python, shell and other scripts its also nice to have them marked as executable when saved. This way I don't have to chmod them myself.

(defun oni:compile-el ()
  "Compile the current buffer file if it is an .el file."
  (let* ((full-file-name (buffer-file-name))
         (file-name (file-name-nondirectory full-file-name))
         (suffix (file-name-extension file-name)))
      (if (and (not (string-equal file-name ".dir-locals.el"))
               (string-equal suffix "el"))
          (byte-compile-file full-file-name))))

(defun oni:after-save-func ()
  "Function for `after-save-hook'."
  (oni:compile-el)
  (executable-make-buffer-file-executable-if-script-p))

When editing HTML files it can be useful to have certain characters replaced by their HTML-safe codes. Right now this is only é, since I haven't had a need for any others yet.

The only mode that I know I use that cares about white space is markdown-mode since ~ ~ (two spaces) there means <br>, but any other mode I want all of it gone.

(defun oni:what-major-mode (buffer-or-string)
    "Find out which major-mode is currently used"
    (with-current-buffer buffer-or-string major-mode))

(defun oni:replace-occurrences (from to)
  (save-excursion
    (goto-char (point-min))
    (while (search-forward from nil t)
      (replace-match to))))

(defun oni:replace-html-special-chars ()
  (oni:replace-occurrences "é" "é"))

(defun oni:before-save-func ()
  "Function for `before-save-hook'."
  (if (eq (oni:what-major-mode (current-buffer)) 'html-mode)
      (oni:replace-html-special-chars))
  (if (not (eq (oni:what-major-mode (current-buffer)) 'markdown-mode))
      (delete-trailing-whitespace)))

I'm a programmer, or at the moment officially a Software Engineer, and I like it. Emacs makes it even more fun.

Many programming modes derive from prog-mode, this makes it easy to collectively configure both rainbow-delimiters-mode for many of these, as well as Fill Column Indicator.

(defun oni:prog-mode-func ()
  "Function for `prog-mode-hook'."
  (rainbow-delimiters-mode)
  (fci-mode))

(add-hook 'prog-mode-hook 'oni:prog-mode-func)

Since I have quite a big init file by now (as you can see) and being able to communicate with emacs from other processes is a cool thing, I usually start emacs with:

emacs --daemon

This starts emacs in the background and then later on you can create a new frame for it by calling:

emacsclient -c

This way other programs can call the emacsclient program as well to either create new frames of open new files in an existing frame.

This does create some other problems, for example I would often accidentally close the daemon by using C-xC-c. I fixed this by changing the C-xC-c key binding when a the daemon is being run.

(defun oni:close-client-window ()
  "Close a client's frames."
  (interactive)
  (server-save-buffers-kill-terminal nil))

(when (daemonp)
  (global-set-key "\C-x\C-c" 'oni:close-client-window))

org-mode is awesome, I use it quite a bit. I use it to keep track of my tasks, I use it to build/maintain my website, I use it to blog and now I even use it to maintain my emacs init file, this file.

(defun oni:org-mode-func ()
  "Function for `org-mode-hook'."
  (flyspell-mode)
  (auto-fill-mode))

When org loads, load appt, org-protocol, org-habit and org-contacts. Add org-habit to the enabled org-modules, enable org-indent-mode, send org tasks with dates to the diary and activate automatic updating of the diary file with org tasks.

(eval-after-load "org"
  '(progn
     (require 'appt)
     (require 'org-protocol)
     (require 'org-habit)
     (require 'org-contacts)

     (add-to-list 'org-modules 'habit)

     (org-indent-mode t)

     (org-agenda-to-appt)
     (ad-activate 'org-agenda-redo)))

When org-crypt gets loaded, make sure that entries that should be encrypted get encrypted.

(eval-after-load "org-crypt"
  '(org-crypt-use-before-save-magic))

diary can be used to show, for example, appointments. Since I'm not interested in editing it I can easily display it in the fancy way.

(defun oni:diary-display-func ()
  "Function for `diary-display-hook'."
  (diary-fancy-display))

And I don't want my diary to be the first thing I see when starting emacs/org.

(setq appt-display-diary nil)

When writing code that uses { } to signify the beginning and end of blocks, it's nice to have them place themselves in the correct position automatically. Once an opening block has been placed, electric-pair-mode takes care of that, when I then press C-j it is nice to have the } jump to a new line and indent itself.

(defun oni:newline-and-indent ()
  (interactive)
  (if (and (not (or (= (point) (point-max))
                    (= (point) (point-min))))
           (or (and (char-equal (char-before) ?{)
                    (char-equal (char-after) ?}))
               (and (char-equal (char-before) ?\()
                    (char-equal (char-after) ?\)))))
      (save-excursion (newline-and-indent)))
  (newline-and-indent))

emms is the Emacs Multimedia System, it allows you to control a number of external music players, such as mplayer, mpd, ogg123, etc, from within emacs.

(defun oni:emms-toggle-playing ()
  "Toggle between playing/paused states."
  (interactive)
  (if (eq emms-player-playing-p nil)
      (emms-start)
    (emms-pause)))

(eval-after-load "emms-source-file"
      '(progn
         (require 'emms-setup)

         (emms-standard)
         (require 'emms-player-mpd)

         (setq emms-player-mpd-server-name "localhost")
         (setq emms-player-mpd-server-port "6600")

         (add-to-list 'emms-info-functions 'emms-info-mpd)
         (add-to-list 'emms-player-list 'emms-player-mpd)
         (setq emms-player-mpd-music-directory "/mnt/music/mp3")))

(setq emms-source-file-default-directory "/mnt/music/")

(global-set-key [XF86AudioNext] 'emms-next)
(global-set-key [XF86AudioPlay] 'oni:emms-toggle-playing)
(global-set-key [XF86AudioPrev] 'emms-previous)
(global-set-key [XF86AudioStop] 'emms-stop)
(global-set-key [XF86Tools] 'emms)

IRC is a fun and interesting way to communicate with people. erc is a fun and interesting way to use IRC.

I don't like the way erc does filling, so I use visual-line-mode instead.

(defun oni:erc-mode-func ()
  "Function for `erc-mode-hook'."
  (erc-fill-mode -1)
  (visual-line-mode)
  (setq truncate-lines nil))

(setq erc-autojoin-channels-alist
      '(("freenode.net" "#herbstluftwm" "#ninthfloor" "#emacs"
         "#dispass")))

(setq erc-nick "ryuslash")

(add-hook 'erc-mode-hook 'oni:erc-mode-func)

eshell is an awesome cross between an emacs lisp REPL and a full-on shell.

Since eshell doesn't really deal with sentences and such I prefer setting truncate-lines to nil over using visual-line-mode so that whatever shows up is just cut off to the next line.

(defun oni:eshell-mode-func ()
  "Function for `eshell-mode-hook'."
  (setq truncate-lines nil))

(add-hook 'eshell-mode-hook 'oni:eshell-mode-func)

flymake is an excellent tool to help during development. When set up correctly it will show you the error of your ways.

Anywhere where flymake is running it should be easy to find the generated errors.

pyflakes is a very nice error checking tool for python.

flymake-cursor is the awesome functionality of showing the flymake generated error near the text cursor in the minibuffer instead of showing the one near the mouse pointer in a tooltip.

I had a working setup of using flymake with go. It just uses the normal makefile based approach to flymake as is done with c and such, but the trouble with it was that it needed to actually compile the code, it had no syntax only option.

(defun oni:flymake-mode-func ()
  "Function for `flymake-mode-hook'."
  (local-set-key [M-P] 'flymake-goto-prev-error)
  (local-set-key [M-N] 'flymake-goto-next-error))

(add-hook 'flymake-mode-hook 'oni:flymake-mode-func)

(defun oni:flymake-pyflakes-init ()
  "Initialize function for flymake with pyflakes."
  (let* ((temp-file (flymake-init-create-temp-buffer-copy
                     'flymake-create-temp-inplace))
         (local-file (file-relative-name temp-file (file-name-directory
                                                    buffer-file-name))))
    (list "pyflakes" (list local-file))))

(eval-after-load "flymake"
  '(progn
     (require 'flymake-cursor)

     (add-to-list                       ; Make sure pyflakes is loaded
      'flymake-allowed-file-name-masks  ; for python files.
      '("\\.py\\'" oni:flymake-pyflakes-init))

     (add-to-list                       ; Error line repexp for go
      'flymake-err-line-patterns        ; compilation.
      '("^\\([a-zA-Z0-9_]+\\.go\\):\\([0-9]+\\):\\(.*\\)$"
        1 2 nil 3))

     (add-to-list                       ; Go uses makefiles, makes
      'flymake-allowed-file-name-masks  ; flymaking 'easy'.
      '("\\.go$" flymake-simple-make-init))))

There are at least 3 tag browsers that I know of, etags, (exuberant?) ctags and GNU Global. That last one works especially well, at least for php.

I got the oni:gtags-create-or-update function from emacs-fu.

(autoload 'gtags-mode "gtags" nil t)

(defun oni:gtags-create-or-update ()
  "Create or update the GNU Global tag file"
  (interactive)
  (if (not (= 0 (call-process "global" nil nil nil " -p")))
      (let ((olddir default-directory)
            (topdir (read-directory-name
                     "gtags: top of source tree:" default-directory)))
        (cd topdir)
        (shell-command "~/bin/create_gtags")
        (cd olddir))
    ;; Tagfile already exists; update it
    (shell-command "~/bin/update_gtags")))

(defun oni:gtags-for-php ()
  "Setup gtags for `php-mode'."
  (let* ((file-name (buffer-file-name))
         (fext (if (not (eq nil file-name))
                   (file-name-extension (buffer-file-name))
                 nil)))
    (if (equal fext "php")
        (progn
          (gtags-mode)
          (oni:gtags-create-or-update)))))

(defun oni:gtags-mode-func ()
  "Function for `gtags-mode-hook'."
  (local-set-key "\M-," 'gtags-find-tag)
  (local-set-key "\M-." 'gtags-find-rtag))

(add-hook 'gtags-mode-hook 'oni:gtags-mode-func)

Do What I Mean commands are very cool. Only comment-dwim is shipped with emacs, but it has inspired me to look into writing some other ones. Some of these functions aren't really DWIM, but they were inspired by it.

(require 'newcomment)

(defun oni:kill-region-or-backward-char ()
  "Kill either the active region, or delete the character left of
  the cursor"
  (interactive)
  (if (region-active-p)
      (kill-region (region-beginning) (region-end))
    (backward-delete-char-untabify 1)))

(defun oni:kill-region-or-forward-char ()
  "Kill either the active region, or delete the character right
  of the cursor"
  (interactive)
  (if (region-active-p)
      (kill-region (region-beginning) (region-end))
    (delete-forward-char 1)))

(defun oni:kill-region-or-line ()
  "Kill either the active region, or the rest of the line,
  depending on whether or not `region-active-p' is t"
  (interactive)
  (if (region-active-p)
      (kill-region (region-beginning) (region-end))
    (kill-line)))

(defun oni:move-beginning-of-dwim ()
  "Move to the beginning of line, either after the indentatoin of
  before."
  (interactive)
  (let ((start (point)))
    (back-to-indentation)
    (if (= start (point))
        (beginning-of-line))))

(defun oni:move-end-of-dwim ()
  "Move to the end of line, either before any comments or after
  them."
  (interactive)
  (let ((start (point))
        (eolpos (line-end-position)))
    (beginning-of-line)
    (if (and comment-start
             (comment-search-forward eolpos t))
        (progn
          (search-backward-regexp (concat "[^ \t" comment-start "]"))
          (forward-char)

          (when (or (bolp)
                    (= start (point)))
            (end-of-line)))
      (end-of-line))))

(defun oni:self-insert-dwim ()
  "Execute self insert, but when the region is active call self
  insert at the end of the region and at the beginning."
  (interactive)
  (if (region-active-p)
      (let ((electric-pair-mode nil)
            (beginning (region-beginning))
            (end (region-end)))
        (goto-char end)
        (self-insert-command 1)
        (save-excursion
          (goto-char beginning)
          (self-insert-command 1)))
    (self-insert-command 1)))

I use git a lot, and magit is the best git interface (emacs or otherwise) I know. I'll admit I don't know that many since I've never felt a need for any interface to git other than its own command line one, but having it in emacs is just cooler.

(defun oni:magit-log-edit-mode-func ()
  "Function for `magit-log-edit-mode-hook'."
  (auto-fill-mode)
  (flyspell-mode))

(add-hook 'magit-log-edit-mode-hook 'oni:magit-log-edit-mode-func)

(global-set-key [f7] 'magit-status)

Markdown is the only place where I might intentionally leave whitespace in the file, since that is the equivalent of <br/>.

Also, seeing as how it's a text mode auto-fill-mode is vary useful here.

(defun oni:markdown-mode-func ()
  "Function for `markdown-mode-hook'."
  (auto-fill-mode)
  (whitespace-mode))

(add-hook 'markdown-mode-hook 'oni:markdown-mode-func)

(add-to-list 'auto-mode-alist '("\\.m\\(ark\\)?do?wn$" . markdown-mode))

message-mode is excellent for writing emails. In fact, that's exactly what it is made for.

(defun oni:message-mode-func ()
  "Function for `message-mode-hook'."
  (auto-fill-mode)
  (flyspell-mode)
  (ispell-change-dictionary (read-string "New dictionary: ")))

(setq message-send-mail-function 'message-send-mail-with-sendmail)

(add-hook 'message-mode-hook 'oni:message-mode-func)

Browsing the web for documentation, which is usually text-only anyway, can be very handy in emacs.

(require 'w3m-load)

The default way of ensuring unique buffer names is not a very nice one.

(require 'uniquify)

(setq uniquify-buffer-name-style 'post-forward)

Sometimes its useful to have a buffer ready to put some elisp code in for testing, especially when you're writing some elisp. I don't care much for the lisp-interaction-mode that is uses by default, I'm too used to using C-j for newline+indent to be comfortable with it evaluating each expression behind it when I use it.

(defun oni:raise-scratch ()
  "Show the *scratch* buffer."
  (interactive)
  (switch-to-buffer "*scratch*"))

(setq initial-major-mode 'emacs-lisp-mode
      initial-scratch-message nil)

(global-set-key [XF86HomePage] 'oni:raise-scratch)

When a buffer gets updated outside of emacs it is nice to be able to easily reload it to its state on disk.

(defun oni:reload-buffer ()
  "Reload current buffer."
  (interactive)
  (revert-buffer nil t nil))

(global-set-key [f5] 'oni:reload-buffer)

Don't truncate lines, just having them continue on the next line is fine for terminal output.

(defun oni:term-mode-func ()
  "Function for `term-mode-hook'."
  (setq truncate-lines nil))

Automatically fill paragraphs while writing, makes for nice, readable, paragraphs.

(defun oni:texinfo-mode-func ()
  "Function for `texinfo-mode-hook'."
  (auto-fill-mode))

Load xmodmap-mode when xmodmap-mode is called and automatically call xmodmap-mode when loading files named .Xmodmap.

(autoload 'xmodmap-mode "xmodmap-mode" nil t)
(add-to-list 'auto-mode-alist '("^\\.Xmodmap$" . xmodmap-mode))

These functions were copied and modified from python-mode. They shift indentation left or right by tab-width columns. If they can't, the error Can't shift all lines enough is thrown, this is to be expected, so it should not be caught by the debugger.

(defun oni:indent-shift-left (start end &optional count)
  (interactive
   (if mark-active
       (list (region-beginning) (region-end) current-prefix-arg)
     (list (line-beginning-position)
           (line-end-position)
           current-prefix-arg)))
  (if count
      (setq count (prefix-numeric-value count))
    (setq count tab-width))
  (when (> count 0)
    (let ((deactivate-mark nil))
      (save-excursion
        (goto-char start)
        (while (< (point) end)
          (if (and (< (current-indentation) count)
                   (not (looking-at "[ \t]*$")))
              (error "Can't shift all lines enough"))
          (forward-line))
        (indent-rigidly start end (- count))))))

(add-to-list 'debug-ignored-errors "^Can't shift all lines enough")

(defun oni:indent-shift-right (start end &optional count)
  (interactive
   (if mark-active
       (list (region-beginning) (region-end) current-prefix-arg)
     (list (line-beginning-position)
           (line-end-position)
           current-prefix-arg)))
  (let ((deactivate-mark nil))
    (if count
        (setq count (prefix-numeric-value count))
      (setq count tab-width))
    (indent-rigidly start end count)))

These should be usable in just about any situation.

(global-set-key (kbd "C-<") 'indent-shift-left)
(global-set-key (kbd "C->") 'indent-shift-right)

Automatically load po-mode when po-mode is called and automatically call po-mode for .po and .po.* files.

(autoload 'po-mode "po-mode" nil t)
(add-to-list 'auto-mode-alist '("\\.po\\'\\|\\.po\\." . po-mode))

A window manager that has a configuration file format that looks a lot like emacs-lisp. It also has some great features for emacs integration.

(autoload 'sawfish-mode "sawfish-mode" nil t)

Enable…

column-number-mode

Shows the current column in the mode-line.

electric-indent-mode

Automatically indent lines.

electric-pair-mode

Automatically add closing braces and such upon opening them.

show-paren-mode

Highlight the opening/closing parenthesis.

savehist-mode

Save minibuffer history across emacs sessions.

(column-number-mode)
(electric-indent-mode)
(electric-pair-mode)
(show-paren-mode)
(savehist-mode)

Disable…

blink-cursor-mode

Blinking cursors are distracting.

menu-bar-mode

No menu bar is needed. Takes up screen space.

scroll-bar-mode

This information is also shown in the mode-line.

tool-bar-mode

No tool bar is needed. Takes up screen space.

tooltip-mode

Not very useful, there are other ways to get this information.

(blink-cursor-mode -1)
(menu-bar-mode -1)
(scroll-bar-mode -1)
(tool-bar-mode -1)
(tooltip-mode -1)

Only useful in very specific situations, usually only a bit of fun. Update any time-stamp found before saving the file.

(defun oni:write-file-func ()
  "Function for `write-file-hooks'."
  (time-stamp))

Turn on ido-mode at startup.

(ido-mode)

Don't let ido show its file suggestions so quickly. It would be better to turn it off completely, but how.

(setq ido-auto-merge-delay-time 1000000)

Don't save any history, it just takes up space.

(setq ido-save-directory-list-file nil)

Make ido ignore buffers like *scratch*, irc.freenode.net:6938 and #emacs, these clutter up the file list and aren't actually useful when writing software. They will still show up if searched for and there are only ignored buffers that match.

Make sure that ido is loaded before setting this, otherwise ido-ignore-buffers would be unbound and unusable.

(eval-after-load "ido"
  '(setq ido-ignore-buffers `(,@ido-ignore-buffers
                              "^\\*.*\\*$" "^irc\\." "^\\#")))

Enable smex.

(smex-initialize)

Bind smex keys to <dead-circumflex> and C-<dead-circumflex>. These keys are effectively AltGR-x and C-AltGR-x on a colemak keyboard.

(eval-after-load "smex"
  '(progn
     (global-set-key (kbd "<dead-circumflex>") 'smex)
     (global-set-key (kbd "C-<dead-circumflex>") 'smex-major-mode-commands)))

Don't save any history or the likes in HOME.

(setq smex-save-file "~/.emacs.d/smex-items")

Since smex isn't bound to M-x, it is not useful to have the prompt say so.

(setq smex-prompt-string "smex ")

In order to be able to easily write characters like ë, iso-transl is required.

(require 'iso-transl)

Emacs has so many settings, its hard to keep track of them all.

I'm still working on this…

(setq inhibit-default-init t)           ; I don't use it.

(setq inhibit-local-menu-bar-menus t)   ; I don't think I use them.

(setq inhibit-startup-message t)        ; I don't care, I know it.

(setq inhibit-x-resources t)            ; I'll set my own settings.

(setq jit-lock-defer-time 0.2)          ; Faster scrolling.

(setq line-move-visual nil)             ; Just move around.

(setq mail-header-separator "")         ; Empty line.

(setq message-log-max 1000)             ; 100 is not always enough.

(setq mode-line-position                ; Hide the TOP/BOT part.
      (cdr mode-line-position))

(setq org2blog/wp-blog-alist            ; My wordpress blogs
      '(("wordpress"
         :url "http://ryuslash.wordpress.com/xmlrpc.php"
         :username "ryuslash")))

(setq org-agenda-custom-commands        ; Overwrite default `t' list.
      '(("b" "Bookmarks to look at."
         todo "LOOKAT")
        ("w" "Work todo."
         tags-todo "CATEGORY=\"Work\"")))

(setq org-blank-before-new-entry        ; Insert blank line before new
      '((heading . t)                   ; headings/list items.
        (plain-list-item . t)))

(setq org-directory                     ; Where my org files live.
      (expand-file-name "~/documents/org"))

(setq org-agenda-files
      `(,(concat org-directory "/org")
        ,(concat org-directory "/misc/contacts.org")
        ,(concat org-directory "/misc/bookmarks.org")))

(setq org-agenda-include-diary t)       ; Do include my diary.

(setq org-agenda-sorting-strategy       ; How to sort my agenda.
      '((agenda habit-down time-up priority-down category-keep)
        (todo priority-down category-up)
        (tags priority-down category-keep)
        (search category-keep)))

(setq org-blog-directory                ; Location for finished posts.
      "~/code/projects/orgweb/blog")

(setq org-blog-unfinished-directory     ; And drafts here.
      "~/documents/blog/drafts")

(setq org-capture-templates             ; What to capture when.
           '(("t" "Task" entry (file+headline "" "tasks")
              "* TODO %^{Description}\n  %u\n\n  %?")
             ("T" "Task with link" entry (file+headline "" "tasks")
              "* TODO %^{Description}\n  %u\n\n  %a\n  %?")
             ("h" "Habit" entry (file+headline "" "tasks")
              (concat "* TODO %^{Description}\n"
                      "  SCHEDULED: %^T\n"
                      "  :PROPERTIES:\n"
                      "  :STYLE:    habit\n"
                      "  :END:")
              :immediate-finish t)
             ("l" "Log" entry (file+headline "" "notes")
              (concat "* %n %<%d-%m-%Y %H:%M:%S>\n"
                      "  %a\n\n"
                      "  %?")
              :prepend t :empty-lines 1)
             ("a" "Appointment" entry (file+headline "" "appointments")
              "* %^{Description} %^T" :immediate-finish t)
             ("b" "Bookmark" entry (file "~/documents/org/misc/bookmarks.org")
              "* %c\n\n  %:initial")))

(setq org-contacts-files                ; To store my contacts in.
      '("~/documents/org/misc/contacts.org"))

(setq org-crypt-key "33E8CC1CC4")       ; Shhhh, don't tell anyone.

(setq org-default-notes-file (concat org-directory "/org"))

(setq org-export-htmlize-output-type    ; Make it color-agnostic?
      'css)

(setq                                   ; Keep completions clean.
 org-outline-path-complete-in-steps t)

(setq org-refile-targets                ; Where to allow sending it.
      '((nil . (:maxlevel . 5))))

(setq org-refile-use-outline-path       ; Select file first.
      'file)

(setq org-return-follows-link t)        ; Easy url opening.

(setq org-src-fontify-natively t)       ; Fontification of code.

(setq org-tags-exclude-from-inheritance ; Don't inherit crypt.
      '("crypt"))

(setq org-todo-keyword-faces            ; What they look like.
      '(("TODO"        :foreground "red")
        ("IN PROGRESS" :foreground "yellow")
        ("DONE"        :foreground "forest green")
        ("SUCCEEDED"   :foreground "forest green")
        ("WAITING"     :foreground "orange")
        ("CANCELLED"   :foreground "orangered")
        ("FAILED"      :foreground "orangered")))

(setq org-todo-keywords                 ; States for todo items.
      '((sequence "TODO(t)" "IN PROGRESS" "WAITING(@/!)" "|"
                  "DONE(!/!)" "CANCELLED(@/!)")))

(setq org-use-fast-todo-selection t)    ; Faster, FASTER!

(setq rainbow-delimiters-max-face-count ; That's quite enough.
      8)

(setq redisplay-dont-pause t)           ; Speedup? Don't remember.

(setq sauron-column-alist               ; I don't need as much
      '((timestamp . 6)                 ; information as the default.
        (message)))

(setq sauron-hide-mode-line t)          ; No need in that frame.

(setq sauron-max-line-length 53)        ; Less info == less space.

(setq sauron-timestamp-format "%H:%M")  ; Even less space.

(setq sauron-watch-nicks '("ryuslash")) ; I'm important.

(setq sauron-watch-patterns             ; Very important.
      '("ryuslash"))

(setq scroll-conservatively 101)        ; Move screen a single line.

(setq send-mail-function                ; Use smtpmail to send email.
      'smtpmail-send-it)

(setq sendmail-program                  ; sendmail is actually msmtp.
      "/usr/bin/msmtp")

(setq special-display-buffer-names      ; Treat sauron specially.
      '("*Sauron*"))

(setq special-display-frame-alist       ; No minibuffer for sauron.
      '((minibuffer . nil)
        (right-fringe . 0)))

(setq time-stamp-active t)              ; I kinda like it.

(setq time-stamp-format                 ; I like this format.
      "%04y-%02m-%02d %02H:%02M:%02S (%u)")

(setq use-dialog-box nil)               ; I hate them.

(setq user-full-name "Tom Willemsen")   ; For things not changelog.

(setq whitespace-style                  ; Only trailing whitespace.
      '(face trailing))

(add-hook 'after-save-hook          'oni:after-save-func)
(add-hook 'before-save-hook         'oni:before-save-func)
(add-hook 'diary-display-hook       'oni:diary-fancy-func)
(add-hook 'org-mode-hook            'oni:org-mode-func)
(add-hook 'scheme-mode-hook         'oni:scheme-mode-func)
(add-hook 'term-mode-hook           'oni:term-mode-func)
(add-hook 'texinfo-mode-hook        'oni:texinfo-mode-func)
(add-hook 'write-file-hooks         'oni:write-file-func)

(define-key key-translation-map (kbd "C-j") (kbd "C-l"))
(define-key key-translation-map (kbd "C-l") (kbd "C-j"))

(global-set-key "'" 'oni:self-insert-dwim)
(global-set-key "\"" 'oni:self-insert-dwim)
(global-set-key "\C-\M-d" 'kill-word)
(global-set-key "\C-\M-w" 'backward-kill-word)
(global-set-key "\C-a" 'oni:move-beginning-of-dwim)
(global-set-key "\C-ca" 'org-agenda)
(global-set-key "\C-cc" 'org-capture)
(global-set-key "\C-d" 'oni:kill-region-or-forward-char)
(global-set-key "\C-e" 'oni:move-end-of-dwim)
(global-set-key "\C-j" 'newline-and-indent)
(global-set-key "\C-k" 'oni:kill-region-or-line)
(global-set-key "\C-l" 'recenter-top-bottom)
(global-set-key "\C-w" 'oni:kill-region-or-backward-char)
(global-set-key "\C-x n r" 'narrow-to-region)
(global-set-key "\M-0" 'delete-window)
(global-set-key "\M-1" 'delete-other-windows)
(global-set-key "\M-2" 'split-window-below)
(global-set-key "\M-3" 'split-window-right)
(global-set-key "\M-s" 'other-window)
(global-set-key (kbd "C-'") 'execute-extended-command)
(global-set-key (kbd "C-S-k") 'kill-whole-line)

(when (or window-system (daemonp))
  (global-unset-key "\C-z"))

(load custom-file)
(load "rudel-loaddefs.el")

(put 'upcase-region 'disabled nil)
(put 'downcase-region 'disabled nil)
(put 'narrow-to-region 'disabled nil)