legacy-dotfiles/emacs/init.el

;;;; Turn off useless visual components
;;; Turn the menu, scroll-bar and tool-bar off quickly, emacs startup
;;; isn't as jittery.
(menu-bar-mode -1)
(scroll-bar-mode -1)
(tool-bar-mode -1)

(defmacro eval-after-init (&rest body)
  "Defer execution of BODY until after Emacs init.

Some functionality is dependent on code loaded by package.el.
Instead of requiring package.el to load very early on, have some
functionality deferred to a point after Emacs has initialized and
package.el is loaded anyway."
  `(add-hook 'emacs-startup-hook #'(lambda () ,@body)))

;;; Load my very own theme. Wait until after Emacs initialization has
;;; completed so we can be sure that `package-initialize' has been
;;; called and the theme should be autoloaded.
(eval-after-init (load-theme 'yoshi t))

;;; Add some project directories and my site-lisp directory to the
;;; load path to make it easy to (auto)load them.
(mapc #'(lambda (dir)
          (add-to-list 'load-path dir)
          (let ((loaddefs (concat dir "/loaddefs.el")))
            (when (file-exists-p loaddefs)
              (load loaddefs))))
      '("~/.emacs.d/site-lisp" "~/projects/emacs/pony-mode/src"
        "~/projects/emacs/php-mode"))

;;; I have never, yet, accidentally said `y' or `n' when asked.
(defalias 'yes-or-no-p 'y-or-n-p)

;;; These are much more feature-rich.
(defalias 'list-buffers 'ibuffer)
(defalias 'dabbrev-expand 'hippie-expand)

(defun ext:comp-finish-function (buf str)
  "Close the compilation buffer quickly if everything went OK."
  (if (string-match "exited abnormally" str)
      ;; there were errors
      (message "compilation errors, press C-x ` to visit")
    ;; no errors, make the compilation window go away in 0.5 seconds
    (when (member (buffer-name) '("*Compilation*" "*compilation*"))
      (run-at-time 0.5 nil 'delete-windows-on buf)
      (message "No compilation errors!"))))

(add-to-list 'compilation-finish-functions 'ext:comp-finish-function)

;;; I close the compilation window if there are no errors. Seeing it
;;; scroll past lets me see if there were any warnings I might want to
;;; look at.
(setq compilation-scroll-output t)

;;;; Hooks
;;;;; Enable `auto-fill-mode' for some text-heavy modes.

(add-hook 'prog-mode-hook 'auto-fill-mode)
(add-hook 'text-mode-hook 'auto-fill-mode)

;;;;; Enable `eldoc-mode' for some nice programming modes.

(add-hook 'emacs-lisp-mode-hook 'eldoc-mode)

;;;;; Enable `fill-column-indicator' for most programming modes.

(add-hook 'html-mode-hook 'fci-mode)
(add-hook 'prog-mode-hook 'fci-mode)

;;;;; Enable `flycheck-mode' for supported modes.

(add-hook 'css-mode-hook 'flycheck-mode)
(add-hook 'emacs-lisp-mode-hook 'flycheck-mode)
(add-hook 'go-mode-hook 'flycheck-mode)
(add-hook 'html-mode-hook 'flycheck-mode)
(add-hook 'js2-mode-hook 'flycheck-mode)
(add-hook 'lua-mode-hook 'flycheck-mode)
(add-hook 'php-mode-hook 'flycheck-mode)
(add-hook 'python-mode-hook 'flycheck-mode)
(add-hook 'rst-mode-hook 'flycheck-mode)
(add-hook 'ruby-mode-hook 'flycheck-mode)
(add-hook 'rust-mode-hook 'flycheck-mode)
(add-hook 'sh-mode-hook 'flycheck-mode)

;;;;; Enable `flyspell-mode' for some text modes.

(add-hook 'text-mode-hook 'flyspell-mode)

;;;;; Enable `paredit-mode' for any lisp-like languages.
;;; Since all of these modes care heavily about their parentheses it
;;; is very easy to edit them as syntax trees, rather than unrelated
;;; bits of text. I also helps keep parens balanced.

(add-hook 'clojure-mode-hook 'paredit-mode)
(add-hook 'emacs-lisp-mode-hook 'paredit-mode)
(add-hook 'lisp-mode-hook 'paredit-mode)
(add-hook 'sawfish-mode-hook 'paredit-mode)
(add-hook 'scheme-mode-hook 'paredit-mode)

;;;;; Enable `rainbow-delimiters-mode' for programming modes.

(add-hook 'prog-mode-hook 'rainbow-delimiters-mode)

;;;;; Enable `rainbow-mode' for some colorful modes.

(add-hook 'css-mode-hook 'rainbow-mode)

;;;;; Enable `slime-js-minor-mode' for `js2-mode'.

(add-hook 'js2-mode-hook 'slime-js-minor-mode)

;;;;; Enable `smartparens-mode' for some non-lisp modes.

(add-hook 'html-mode-hook 'smartparens-mode)
(add-hook 'python-mode-hook 'smartparens-mode)

;;;;; Enable `visual-line-mode' for some text modes.

(add-hook 'jabber-chat-mode-hook 'visual-line-mode)

;;;;; Enable `whitespace-mode' for some whitespace-caring modes.

(add-hook 'markdown-mode-hook 'whitespace-mode)
(add-hook 'python-mode-hook 'whitespace-mode)

;;;;; Enable `yas-minor-mode' for some heavy-duty modes.

(add-hook 'html-mode-hook 'yas-minor-mode)
(add-hook 'org-mode-hook 'yas-minor-mode)
(add-hook 'prog-mode-hook 'yas-minor-mode)


;;;; Rest
;;; Remove the pylint and pyflakes checkers from the flycheck
;;; configuration so the flake8 checker remains.
(eval-after-load "flycheck"
  '(progn
     (mapc (lambda (c) (delq c flycheck-checkers))
           '(python-pylint python-pyflakes))))

(defun oni:pretty-control-l-function (win)
  "Just make a string of either `fci-rule-column' or
`fill-column' length -1. Use the `-' character. WIN is ignored."
  (ignore win)
  (make-string
   (1- (if (boundp 'fci-rule-column) fci-rule-column fill-column)) ?-))

;;; Use `oni:pretty-control-l-function' to create a nice horizontal
;;; line.
(setq pp^L-^L-string-function 'oni:pretty-control-l-function)

;;; Don't put anything before the pp^L string.
(setq pp^L-^L-string-pre nil)

;;; Enable pp^L at startup and again for each frame created.
(add-hook 'emacs-startup-hook 'pretty-control-l-mode)
(add-hook 'after-make-frame-functions
          '(lambda (arg) (pretty-control-l-mode)))

(setq erc-autojoin-channels-alist
      '(("freenode.net" "#ninthfloor" "#emacs")))
(setq erc-hide-list '("PART"))
(setq erc-insert-timestamp-function 'erc-insert-timestamp-left)
(setq erc-timestamp-format "[%H:%M] ")
(setq erc-timestamp-only-if-changed-flag nil)
(setq erc-nick "ryuslash")

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

(add-hook 'erc-mode-hook 'oni:erc-mode-func)

;;; Since unison requires unbuffered input it should not show up in
;;; eshell, but a real term shell.
(eval-after-load "em-term"
  '(add-to-list 'eshell-visual-commands "unison"))

;;; To be able to highlight the eshell prompt just as I want it with
;;; regular text properties the standard highlighting should be turned
;;; off, otherwise it always overwrites whatever text properties it
;;; finds.
(setq eshell-highlight-prompt nil)

(defun oni:eshell-prompt-function ()
  "Show a pretty shell prompt."
  (let ((status (if (zerop eshell-last-command-status) ?+ ?-))
        (hostname (shell-command-to-string "hostname"))
        (dir (abbreviate-file-name (eshell/pwd)))
        (branch
         (shell-command-to-string
          "git branch --contains HEAD 2>/dev/null | sed -e '/^[^*]/d'"))
        (userstatus (if (zerop (user-uid)) ?# ?$)))
    (concat
     (propertize (char-to-string status)
                 'face `(:foreground ,(if (= status ?+)
                                          "green"
                                        "red")))
     " "
     (propertize (substring hostname 0 -1) 'face 'mode-line-buffer-id)
     " "
     (propertize (oni:shorten-dir dir) 'face 'font-lock-string-face)
     " "
     (when (not (string= branch ""))
       (propertize
        ;; Cut off "* " and "\n"
        (substring branch 2 -1)
        'face 'font-lock-function-name-face))
     " \n"
     (propertize (char-to-string userstatus)
                 'face `(:foreground "blue"))
     "> ")))

(setq eshell-prompt-function 'oni:eshell-prompt-function
      eshell-prompt-regexp "^[#$]> ")

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

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

(defun oni:raise-eshell ()
  "Start or switch back to `eshell'.
Also change directories to current working directory."
  (interactive)
  (let ((dir (file-name-directory
              (or (buffer-file-name) "~/")))
        (hasfile (not (eq (buffer-file-name) nil))))
    (eshell)
    (if (and hasfile (eq eshell-process-list nil))
        (progn
          (eshell/cd dir)
          (eshell-reset)))))

(global-set-key (kbd "<f8>") 'oni:raise-eshell)

;;; Since I don't ever get any mail from people that use right-to-left
;;; text, and even if I did I wouldn't be able to read it, I don't
;;; need bidirectional text support. You shouldn't actually disable it
;;; (if that's even still possible) since, supposedly, it is an
;;; integral part of the display engine now, but telling it to always
;;; use left-to-right should keep it from slowing your emacs down.
(setq-default bidi-paragraph-direction 'left-to-right)

;;; Enable the following commands because they're useful sometimes and
;;; I'm not an Emacs beginner anymore, they don't confuse me.

(put 'downcase-region 'disabled nil)
(put 'narrow-to-page 'disabled nil)
(put 'narrow-to-region 'disabled nil)
(put 'scroll-left 'disabled nil)
(put 'upcase-region 'disabled nil)

(defun oni:jabber-init ()
  "Initialization function for jabber."
  (remove-hook 'jabber-alert-presence-hooks 'jabber-presence-echo))

(eval-after-load "jabber" '(oni:jabber-init))

(autoload 'jabber-message-libnotify "jabber-libnotify")
(autoload 'jabber-muc-libnotify "jabber-libnotify")

(add-hook 'jabber-alert-message-hooks 'jabber-message-libnotify)
(add-hook 'jabber-alert-muc-hooks 'jabber-muc-libnotify)

(setq jabber-history-enabled t
      jabber-history-muc-enabled t)

(setq jabber-use-global-history nil
      jabber-history-dir "~/.emacs.d/jabber-hist")

(setq jabber-account-list '(("ryuslash@jabber.org")
                            ("tom@ryuslash.org/drd"
                             (:connection-type . ssl))))

(defun oni:ido-init ()
  "Initialization functionn for ido."
  (setq ido-ignore-buffers
        (list "^\\` " "^irc\\." "^\\#" "^\\*Customize Option:"
              (eval-when-compile
                (regexp-opt
                 '("*-jabber-roster-*"
                   "*Messages*"
                   "*fsm-debug*"
                   "*magit-process*"
                   "*magit-edit-log*"
                   "*Backtrace*"
                   "*Ibuffer*"))))))

(eval-after-load "ido" '(oni:ido-init))

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

(setq ido-default-buffer-method 'selected-window)

(setq ido-max-window-height 1)

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

(ido-mode)

(setq ido-ubiquitous-command-exceptions
      '(org-refile org-capture-refile))

(add-hook 'emacs-startup-hook 'ido-ubiquitous-mode)

(global-set-key (kbd "M-n") 'idomenu)

(setq minibuffer-eldef-shorten-default t)
(minibuffer-electric-default-mode)

(setq mode-line-default-help-echo "")

(eval-after-load "jedi" '(setcar jedi:server-command "python2"))
(add-hook 'python-mode-hook 'jedi:setup)

(setq jedi:tooltip-method nil)

(defface git-commit-summary-face
  '((t (:inherit org-level-1)))
  "Face for the git title line."
  :group 'local)

(defface git-commit-overlong-summary-face
  '((t (:background "#873732")))
  "Face for commit titles that are too long."
  :group 'local)

(defface git-commit-nonempty-second-line-face
  '((t (:inherit git-commit-overlong-summary-face)))
  "Face for the supposedly empty line in commit messages."
  :group 'local)

(eval-after-load "org" '(require 'org-init))

(defun indent-defun ()
  "Indent the current defun."
  (interactive)
  (save-excursion
    (mark-defun)
    (indent-region (region-beginning) (region-end))))

(global-set-key (kbd "C-M-z") 'indent-defun)

(defadvice term-handle-exit (after oni:kill-buffer-after-exit activate)
  "Kill the term buffer if the process finished."
  (let ((msg (ad-get-arg 1)))
    (when (string-equal msg "finished\n")
      (kill-buffer (current-buffer)))))

(defun oni:change-prev-case (num dir)
  (let ((regfunc (if (eq dir 'up) 'upcase-region 'downcase-region))
        (wordfunc (if (eq dir 'up) 'upcase-word 'downcase-word)))
    (if (> num 1)
        (funcall regfunc (point) (- (point) num))
      (funcall wordfunc -1))))

(defun oni:upcase-prev (num)
  (interactive "p")
  (oni:change-prev-case num 'up))

(defun oni:downcase-prev (num)
  (interactive "p")
  (oni:change-prev-case num 'down))

(global-set-key (kbd "C-c u") 'oni:upcase-prev)
(global-set-key (kbd "C-c d") 'oni:downcase-prev)

(defun oni:vala-mode-func ()
  "Function for `vala-mode-hook'."
  (setq indent-tabs-mode nil))

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

(eval-after-load "rainbow-mode" '(oni:rainbow-mode-init))
(eval-after-load "smex" '(oni:smex-init))
(eval-after-load "yasnippet" '(oni:yasnippet-init))

(autoload 'define-slime-contrib "slime")
(autoload 'gtags-mode "gtags" nil t)
(autoload 'jabber-connect "jabber" nil t)
(autoload 'php-mode "php-mode" nil t)
(autoload 'po-mode "po-mode" nil t)
(autoload 'pony-mode "pony-mode" nil t)
(autoload 'sawfish-mode "sawfish" nil t)
(autoload 'server-running-p "server")
(autoload 'slime-js-minor-mode "slime-js" nil t)
(autoload 'xmodmap-mode "xmodmap-mode" nil t)
(autoload 'w3m-bookmark-view "w3m" nil t)
(autoload 'w3m-goto-url "w3m" nil t)

(require 'uniquify)
(require 'ext)
(require 'oni)

(setq-default c-basic-offset 4)
(setq-default fci-rule-column 73)
(setq-default indent-tabs-mode nil)
(setq-default php-mode-warn-if-mumamo-off nil)
(setq-default require-final-newline t)
(setq-default tab-width 4)
(setq-default truncate-lines t)

(setq appt-disp-window-function #'oni:appt-display-window-and-jabber)
(setq appt-display-diary nil)
(setq auto-mode-case-fold nil)
(setq auto-save-file-name-transforms oni:auto-save-name-transforms)
(setq avandu-article-render-function #'avandu-view-w3m)
(setq backup-directory-alist oni:backup-directory-alist)
(setq browse-url-browser-function 'browse-url-generic)
(setq browse-url-generic-program (getenv "BROWSER"))
(setq c-offsets-alist '((statement-block-intro . +)
   (knr-argdecl-intro . 5)
   (substatement-open . +)
   (substatement-label . 0)
   (label . 0)
   (statement-case-open . +)
   (statement-cont . +)
   (arglist-intro . +)
   (arglist-close . 0)
   (inline-open . 0)
   (brace-list-open . +)
   (topmost-intro-cont first c-lineup-topmost-intro-cont
                       c-lineup-gnu-DEFUN-intro-cont)))
(setq custom-file "~/.emacs.d/custom.el")
(setq custom-theme-directory "~/.emacs.d/themes")
(setq default-frame-alist
      `((border-width . 0)
        (internal-border-width . 0)
        (vertical-scroll-bars . nil)
        (menu-bar-lines . nil)
        (tool-bar-lines . nil)
        (font . "Envy Code R:pixelsize=18")))
(setq elnode-do-init nil)
(setq fci-rule-color "darkred")
(setq frame-title-format '(:eval (concat "emacs: " (buffer-name))))
(setq geiser-repl-history-filename "~/.emacs.d/geiser-history")
(setq gnus-init-file "~/.emacs.d/gnus")
(setq gtags-auto-update t)
(setq help-at-pt-display-when-idle t)
(setq highlight-80+-columns 72)
(setq identica-enable-striping t)
(setq inferior-lisp-program "sbcl")
(setq inhibit-default-init t)
(setq inhibit-local-menu-bar-menus t)
(setq inhibit-startup-message t)
(setq initial-major-mode 'emacs-lisp-mode)
(setq initial-scratch-message nil)
(setq jabber-avatar-cache-directory "~/.emacs.d/jabber-avatars/")
(setq jabber-chat-buffer-format "*jab:%n*")
(setq jabber-chat-buffer-show-avatar nil)
(setq jabber-chat-fill-long-lines nil)
(setq jabber-chat-foreign-prompt-format "%t %u/%r <\n")
(setq jabber-chat-local-prompt-format "%t %u/%r >\n")
(setq jabber-chatstates-confirm nil)
(setq jabber-muc-autojoin '("aethon@muc.ryuslash.org"))
(setq jabber-roster-show-bindings nil)
(setq jabber-vcard-avatars-publish nil)
(setq jabber-vcard-avatars-retrieve nil)
(setq jit-lock-defer-time 0.2)
(setq magit-repo-dirs '("~/projects/"))
(setq message-log-max 1000)
(setq message-send-mail-function 'message-send-mail-with-sendmail)
(setq message-sendmail-extra-arguments '("-a" "ryuslash"))
(setq package-archives
      '(("melpa" . "http://melpa.milkbox.net/packages/")
        ("marmalade" . "http://marmalade-repo.org/packages/")
        ("gnu" . "http://elpa.gnu.org/packages/")))
(setq package-load-list '((htmlize "1.39")
                          (lua-mode "20111107")
                          all))
(setq php-function-call-face 'font-lock-function-name-face)
(setq php-mode-force-pear t)
(setq pony-tpl-indent-moves t)
(setq rainbow-delimiters-max-face-count 12)
(setq redisplay-dont-pause t)
(setq send-mail-function 'smtpmail-send-it)
(setq sendmail-program "/usr/bin/msmtp")
(setq sentence-end-double-space nil)
(setq smex-key-advice-ignore-menu-bar t)
(setq smex-save-file "~/.emacs.d/smex-items")
(setq split-height-threshold 40)
(setq time-stamp-active t)
(setq time-stamp-format "%04y-%02m-%02d %02H:%02M:%02S (%u)")
(setq type-break-good-rest-interval (* 60 10))
(setq type-break-interval (* 60 50))
(setq type-break-keystroke-threshold '(nil . nil))
(setq uniquify-buffer-name-style 'post-forward)
(setq use-dialog-box nil)
(setq user-full-name "Tom Willemse")
(setq user-mail-address "tom@ryuslash.org")
(setq w3m-fill-column 72)
(setq window-combination-resize t)
(setq yas-fallback-behavior nil)
(setq yas-prompt-functions '(yas-ido-prompt))

(add-hook 'after-change-major-mode-hook 'set-current-mode-icon)
(add-hook 'after-save-hook 'oni:after-save-func t)
(add-hook 'before-save-hook 'oni:before-save-func)
(add-hook 'c-mode-hook 'oni:c-mode-func)
(add-hook 'css-mode-hook 'oni:css-mode-func)
(add-hook 'diary-display-hook 'oni:diary-display-func)
(add-hook 'emacs-startup-hook 'oni:emacs-startup-func)
(add-hook 'go-mode-hook 'oni:go-mode-func)
(add-hook 'gtags-mode-hook 'oni:gtags-mode-func)
(add-hook 'haskell-mode-hook 'oni:haskell-mode-func)
(add-hook 'jabber-roster-mode-hook 'oni:jabber-roster-mode-func)
(add-hook 'java-mode-hook 'oni:java-mode-func)
(add-hook 'js-mode-hook 'oni:js-mode-func)
(add-hook 'js2-mode-hook 'oni:js2-mode-func)
(add-hook 'lua-mode-hook 'oni:lua-mode-func)
(add-hook 'magit-log-edit-mode-hook 'oni:magit-log-edit-mode-func)
(add-hook 'markdown-mode-hook 'oni:markdown-mode-func)
(add-hook 'php-mode-hook 'oni:php-mode-func)
(add-hook 'prog-mode-hook 'oni:prog-mode-func)
(add-hook 'python-mode-hook 'oni:python-mode-func)
(add-hook 'term-mode-hook 'oni:term-mode-func)
(add-hook 'write-file-hooks 'oni:write-file-func)
(add-hook 'yas-minor-mode-hook 'oni:yas-minor-mode-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 (kbd "'") 'oni:self-insert-dwim)
(global-set-key (kbd "<XF86HomePage>") 'oni:raise-scratch)
(global-set-key (kbd "<XF86Mail>") 'gnus)
(global-set-key (kbd "<f10>") 'git-project-show-files)
(global-set-key (kbd "<f5>") 'ext:reload-buffer)
(global-set-key (kbd "<f6>") 'jabber-switch-to-roster-buffer)
(global-set-key (kbd "<f7>") 'magit-status)
(global-set-key (kbd "<hiragana>") 'oni:show-org-index)
(global-set-key (kbd "C-<") 'oni:indent-shift-left)
(global-set-key (kbd "C->") 'oni:indent-shift-right)
(global-set-key (kbd "C-M-4") 'split-window-vertically)
(global-set-key (kbd "C-M-SPC") 'er/expand-region)
(global-set-key (kbd "C-M-d") 'kill-word)
(global-set-key (kbd "C-M-w") 'backward-kill-word)
(global-set-key (kbd "C-S-k") 'kill-whole-line)
(global-set-key (kbd "C-a") 'oni:move-beginning-of-dwim)
(global-set-key (kbd "C-c a") 'org-agenda)
(global-set-key (kbd "C-c c") 'org-capture)
(global-set-key (kbd "C-c i p") 'identica-update-status-interactive)
(global-set-key (kbd "C-c p") 'oni:show-buffer-position)
(global-set-key (kbd "C-c t") 'oni:raise-ansi-term)
(global-set-key (kbd "C-d") 'oni:kill-region-or-forward-char)
(global-set-key (kbd "C-e") 'oni:move-end-of-dwim)
(global-set-key (kbd "C-k") 'oni:kill-region-or-line)
(global-set-key (kbd "C-w") 'oni:kill-region-or-backward-char)
(global-set-key (kbd "M-0") 'delete-window)
(global-set-key (kbd "M-1") 'delete-other-windows)
(global-set-key (kbd "M-2") 'split-window-below)
(global-set-key (kbd "M-3") 'split-window-right)
(global-set-key (kbd "M-4") 'split-window-horizontally)
(global-set-key (kbd "M-o") 'other-window)
(global-set-key (kbd "\"") 'oni:self-insert-dwim)

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

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

(add-to-list 'auto-mode-alist '("\\.jl$" . sawfish-mode))
(add-to-list 'auto-mode-alist '("\\.js\\(on\\)?$" . js2-mode))
(add-to-list 'auto-mode-alist
             '("\\.m\\(ark\\)?d\\(?:o?wn\\)?$" . markdown-mode))
(add-to-list 'auto-mode-alist '("\\.php[345]?$" . php-mode))
(add-to-list 'auto-mode-alist '("\\.po\\'\\|\\.po\\." . po-mode))
(add-to-list 'auto-mode-alist '("\\.tpl$" . html-mode))
(add-to-list 'auto-mode-alist '("^PKGBUILD$" . shell-script-mode))
(add-to-list 'auto-mode-alist '("^\\.Xmodmap$" . xmodmap-mode))

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

(add-to-list
 'display-buffer-alist
 '("^\\*\\(?:.+-\\)?scratch\\*$" . ((display-buffer-same-window . nil))))
(add-to-list
 'display-buffer-alist
 '("^\\*git-project-list\\*$" . ((git-project-show-window . nil))))
(add-to-list
 'display-buffer-alist
 '("^\\*magit: .*\\*$" . ((display-buffer-same-window . nil))))

(blink-cursor-mode -1)
(column-number-mode -1)
(line-number-mode -1)
(tooltip-mode -1)

(package-initialize)

(auto-insert-mode)
(electric-indent-mode)
(savehist-mode)
(show-paren-mode)
(winner-mode)

(smex-initialize)
(help-at-pt-set-timer)
(windmove-default-keybindings)
(global-diff-hl-mode)

;;; Diminish lighter for a bunch of minor modes that should be on in
;;; certain modes and usually just clogg up the mode line.
(diminish 'auto-fill-function)
(eval-after-load "eldoc" '(diminish 'eldoc-mode))
(eval-after-load "paredit" '(diminish 'paredit-mode))
(eval-after-load "auto-complete" '(diminish 'auto-complete-mode))
(eval-after-load "flycheck" '(diminish 'flycheck-mode))
(eval-after-load "smartparens" '(diminish 'smartparens-mode))

;;; Popping up multiple frames out of the blue does not usually play
;;; well with (manual) tiling window managers.
(setq ediff-window-setup-function 'ediff-setup-windows-plain)

;;; Not being able to find newly written functions in imenu is a pain.
(setq imenu-auto-rescan t)

;;; Yanking at click makes not sense to me. I normally have my cursor
;;; where it needs to point and if I *have* to use the mouse I prefer
;;; just clicking it wherever it lands, without having to drag it all
;;; the way to the proper place.
(setq mouse-yank-at-point t)

;;; Always having to move the cursor around so much after scrolling
;;; gets annoying.
(setq scroll-preserve-screen-position t)

;;; I store my blog posts in `~/documents/blog', not the default
;;; `~/Blog'.
(setq eltuki-blog-dir "~/documents/blog")

(setq sp-cancel-autoskip-on-backward-movement nil)

(defun oni:scroll-down-or-prev-page (arg)
  "Either scroll down or go to the previous page.

Depending on the value of `buffer-narrowed-p'."
  (interactive "^P")
  (if (buffer-narrowed-p)
      (let ((scroll-error-top-bottom nil))
        (condition-case nil
            (scroll-down-command arg)
          (beginning-of-buffer
           (narrow-to-page -1)
           (goto-char (point-min)))))
    (scroll-down-command arg)))

(defun oni:scroll-up-or-next-page (arg)
  "Either scroll up or go to the next page.

Depending on the value of `buffer-narrowed-p'."
  (interactive "^P")
  (if (buffer-narrowed-p)
      (let ((scroll-error-top-bottom nil))
        (condition-case nil
            (scroll-up-command arg)
          (end-of-buffer
           (narrow-to-page 1)
           (goto-char (point-min)))))
    (scroll-up-command arg)))

(global-set-key (kbd "<prior>") 'oni:scroll-down-or-prev-page)
(global-set-key (kbd "<next>") 'oni:scroll-up-or-next-page)

;;; Emacs Alsa Player
(add-to-list 'load-path "~/.emacs.d/site-lisp/eap")
(load "eap-autoloads")

(setq eap-music-library "/mnt/music")
(setq eap-playlist-library "~/music/playlists")

;;; Turn on `compilation-minor-mode' whenever `pony-minor-mode' starts
;;; in a `comint-mode' buffer. Since buffers like `*ponymanage*' and
;;; `*ponyserver*' don't have their own specialized modes, but use
;;; `comint-mode' and turn on `pony-minor-mode', and I don't want to
;;; enable `compilation-minor-mode' for *every* `comint-mode' buffer,
;;; we can add a hook that adds a local hook.
(defun turn-on-compilation-for-pony ()
  (add-hook 'pony-minor-mode-hook 'compilation-minor-mode nil t))
(add-hook 'comint-mode-hook 'turn-on-compilation-for-pony)

;;; Finally, load any `customize' settings and slime.
(load custom-file)
(load (expand-file-name "~/quicklisp/slime-helper.el"))

;; Local Variables:
;; outline-regexp: ";;;;+"
;; End: