path: root/emacs

;; -*- self-compile-mode: t -*-

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

;; load-path anpassen
(let* ((my-lisp-dir "~/.emacs.d/lisp")
       (default-directory my-lisp-dir)
       (orig-load-path load-path))
  (setq load-path (cons my-lisp-dir nil))
  (normal-top-level-add-subdirs-to-load-path)
  (nconc load-path orig-load-path))

;; load own color theme
(when (require 'color-theme nil 'noerror)
  (color-theme-initialize)
  (if (not window-system)
      (color-theme-alex-console)
    (color-theme-alex)))

;; user settings
(setq user-full-name "Alexander Sulfrian"
      user-mail-address "alexander@sulfrian.net")

;; define F1 to display man page of the current word
(global-set-key [(f1)] (lambda () (interactive) (manual-entry (current-word))))

(load "/usr/share/emacs/site-lisp/site-gentoo" 'noerror)

(setq text-mode-hook 'turn-on-auto-fill)
(setq fill-column 72)

(setq semanticdb-default-save-directory "~/.emacs.d/semantic")

(setq locale-coding-system 'utf-8)
(set-terminal-coding-system 'utf-8)
(set-keyboard-coding-system 'utf-8)
(set-selection-coding-system 'utf-8)
(prefer-coding-system 'utf-8)

(global-set-key [mouse-3] 'imenu)

;; fix keys for urxvt
(if (not window-system)
    (mapc (lambda (map)
	    (define-key function-key-map
	      (read-kbd-macro (cadr map))
	      (read-kbd-macro (car map))))
	  '(("<S-tab>"     "M-[ Z")
	    ("<S-up>"      "<select>")
	    ("<S-down>"    "M-[ b")
	    ("<S-right>"   "M-[ c")
	    ("<S-left>"    "M-[ d")
	    ("<M-up>"      "ESC M-O A")
	    ("<M-down>"    "ESC M-O B")
	    ("<M-right>"   "ESC M-O C")
	    ("<M-left>"    "ESC M-O D")
	    ("<C-up>"      "M-O a")
	    ("<C-down>"    "M-O b")
	    ("<C-right>"   "M-O c")
	    ("<C-left>"    "M-O d")
	    ("<C-M-up>"    "ESC M-O a")
	    ("<C-M-down>"  "ESC M-O b")
	    ("<C-M-right>" "ESC M-O c")
	    ("<C-M-left>"  "ESC M-O d")
	    ("<M-S-up>"    "ESC M-[ a")
	    ("<M-S-down>"  "ESC M-[ b")
	    ("<M-S-right>" "ESC M-[ c")
	    ("<M-S-left>"  "ESC M-[ d")
	    )))

(setq auto-mode-alist (cons '("README" . text-mode) auto-mode-alist))
(setq compilation-scroll-output t)

;; css-mode
(setq cssm-indent-level 4)
(setq cssm-newline-before-closing-bracket t)
(setq cssm-indent-function #'cssm-c-style-indenter)

;; delphi-mode
(load "delphi-mode-ench.el")

;: removing annoyances
(setq inhibit-startup-message t)
(setq require-final-newline t)
(fset 'yes-or-no-p 'y-or-n-p)
(setq next-line-add-newlines nil)

;: general settings
(require 'paren) (show-paren-mode t)
(global-font-lock-mode t)
(setq font-lock-maximum-decoration t)
(follow-mode t)
(setq vc-follow-symlinks t)

(require 'uniquify)
(setq uniquify-buffer-name-style 'reverse)

(defun back-to-indentation-or-beginning () (interactive)
  (if (= (point) (progn (back-to-indentation) (point)))
      (beginning-of-line)))
(global-set-key (kbd "<home>") 'back-to-indentation-or-beginning)

;; c/c++-mode stuff
(setq indent-tabs-mode t)
(setq c-default-style "linux")
(c-set-offset 'arglist-cont-nonempty '(c-lineup-arglist-tabs-only c-lineup-gcc-asm-reg))

(add-hook 'c-mode-common-hook
            (lambda ()
              (setq fill-column 80)
              (turn-on-auto-fill)

              ;; now '_' is not considered a word-delimiter
              (modify-syntax-entry ?_ "w")

              ;; set indentation style
              (c-set-style "linux")
              (local-set-key (kbd "M-m") 'eassist-list-methods)
              (local-set-key (kbd "C-o") 'semantic-complete-jump-local)
              (local-set-key (kbd "C-c o") 'ff-find-other-file)))

(global-set-key [C-return] 'dabbrev-expand)
(define-key esc-map [C-return] 'dabbrev-completion)

(global-set-key [f12] 'indent-region)

;; Enable Doxygen syntax highlighting for C and C++
(when (require 'doxymacs nil 'noerror)
  (add-hook 'font-lock-mode-hook
	    '(lambda ()
	       (if (or (eq major-mode 'c-mode) (eq major-mode 'c++-mode))
		   (doxymacs-font-lock)))))

;; flyspell (with aspell for Unicode)
(setq ispell-program-name "aspell"
      ispell-extra-args '("--sug-mode=ultra"))

;; define variable to store default dictionary for automatic flyspell enabling
(defvar flyspell-dict nil "Dictionary name, that should be set during find-file for flyspell-mode.
If this is set during find-file, flyspell mode gets enabled automaticaly.")
(make-variable-buffer-local 'flyspell-dict)

(when (require 'ispell nil 'noerror)
  ;; change dictionary
  (defun switch-dictionary()
    (interactive)
    (let* ((dic ispell-current-dictionary)
           (change (if (string= dic "german") "english" "german")))
      (ispell-change-dictionary change)
      (message "Dictionary switched from %s to %s" dic change)
      (if flyspell-mode (save-excursion (flyspell-buffer)))))
  (global-set-key (kbd "<f8>") 'switch-dictionary)

  (when (require 'flyspell nil 'noerror)
    ;; check buffer if enable flyspell
    (add-hook 'flyspell-mode-hook
              (lambda ()
                (when flyspell-mode (flyspell-buffer))))

    ;; ignore all #include stings
    (add-hook 'flyspell-incorrect-hook
              (lambda (left right undef)
                (save-excursion
                  (goto-char left)
                  (beginning-of-line)
                  (if (looking-at "#include") t nil))))

    ;; activate flyspell mode during find-file if flyspell-dict is set
    (add-hook 'find-file-hook
              (lambda ()
                (when flyspell-dict
                  (ispell-change-dictionary flyspell-dict)
                  (flyspell-mode t))))

    ;; update flyspell after changing personal dictionary
    (defadvice ispell-pdict-save (after advice)
      (save-excursion (flyspell-buffer)))
    (ad-activate 'ispell-pdict-save t)))


;; auto compile files
(require 'self-compile-mode)

;; keine Abfrage wenn ein template existiert
(setq template-query nil)
(require 'template-simple nil 'noerror)

;; remember last position in file
(setq save-place-file "~/.emacs.d/saveplace")
(setq-default save-place t)
(require 'saveplace)

;; ignore .d files in completion
(setq completion-ignored-extensions
    (append (list ".d") completion-ignored-extensions))

;; clever auto complete mode
(require 'ido)
(ido-mode t)
(setq
   ido-ignore-buffers '("\\` " "^\*Mess" "^\*Back" ".*Completion" "^\*Ido")
   ido-case-fold  t
   ido-use-filename-at-point nil
   ido-use-url-at-point nil
   ido-enable-flex-matching t
   ido-max-prospects 10
   ido-enable-tramp-completion nil
   ido-confirm-unique-completion t)

;; start server if not running (to edit files with emacsclient)
(when (require 'server nil 'noerror)
  (if (and (fboundp 'server-running-p)
	   (not (server-running-p)))
      (server-start))

  (add-hook 'server-switch-hook
          (lambda ()
            (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)))))

; emacs code browser
(when (require 'ecb nil 'noerror)
  (ecb-activate))

;; smex
(setq smex-save-file "~/.emacs.d/smex.save")
(when (require 'smex nil 'noerror)
  (smex-initialize)
  (global-set-key (kbd "M-X") 'smex))

;; snippets
(when (require 'yasnippet nil 'noerror)
  (yas/initialize)
  (yas/load-directory "~/.emacs.d/snippets"))

;; html-php-multi-mode
(when (require 'html-php nil 'noerror)
  (setq auto-mode-alist (cons '("\\.php" . html-php-mode) auto-mode-alist)))

;; copy/paste enhancements
;; share clipboard with other X11-Apps
(when (fboundp 'x-cut-buffer-or-selection-value)
  (progn
    (setq x-select-enable-clipboard t)
    (setq interprogram-paste-function 'x-cut-buffer-or-selection-value)))

;; use cua-mode, but only for rectangle selections
(setq cua-enable-cua-keys nil)
(cua-mode t)

;; copy/kill whole line when no region is active
(defadvice kill-ring-save (before slick-copy activate compile)
  (interactive (if mark-active (list (region-beginning) (region-end)) (message
  "Copied line") (list (line-beginning-position) (line-beginning-position
  2)))))
(ad-activate 'kill-ring-save)

(defadvice kill-region (before slick-cut activate compile)
  (interactive
    (if mark-active (list (region-beginning) (region-end))
      (list (line-beginning-position)
        (line-beginning-position 2)))))
(ad-activate 'kill-region)

;; rudel (obby/... connection)
(load "rudel-loaddefs.el")

;; magit
(when (require 'magit nil 'noerror)
  ;; magit-status (bind if available on <f5>)
  (global-set-key (kbd "<f5>") 'magit-status)
  (add-hook 'magit-log-edit-mode-hook (lambda () (flyspell-mode 1))))


;; linum (generic & *scratch*)
(when (require 'linum-narrow nil 'noerror)
  (add-hook 'find-file-hook (lambda () (linum-mode 1)))
  (add-hook 'lisp-interaction-mode-hook (lambda () (linum-mode 1))))

;; bookmarks
(setq bookmark-default-file "~/.emacs.d/bookmarks")
(setq bookmark-save-flag 1)

;; winring
(when (require 'winring nil 'noerror)
  ;; ecb support if ecb is available
  (when (fboundp 'ecb-winman-winring-enable-support)
    (ecb-winman-winring-enable-support))

  (winring-initialize)
  (global-set-key (kbd "C-x j") 'winring-jump-to-configuration)
  (global-set-key (kbd "C-x n") 'winring-new-configuration)

  ;; ask before deleting winring configuration
  (defun winring-ask-delete-configuration ()
    (interactive)
    (if (y-or-n-p "Delete winring configuration? ")
	(winring-delete-configuration)))

  (global-set-key (kbd "C-x K") 'winring-ask-delete-configuration))

;; etags
(require 'etags-table nil 'noerror)

; autocompletion for etags
(require 'auto-complete-etags nil 'noerror)

;; change cursor according to the mode (normal, read only, overwrite)
(when (require 'cursor-chg nil 'noerror)
  (toggle-cursor-type-when-idle 1)
  (change-cursor-mode 1))

;; windmove (only if available)
(when (fboundp 'windmove-default-keybindings) (windmove-default-keybindings))

;; lisp-eassist
(define-key lisp-mode-shared-map (kbd "M-m") 'eassist-list-methods)

;; dir-locals
(require 'dir-locals nil 'noerror)

;; use sml-modeline if available
(when (require 'sml-modeline nil 'noerror)
  (progn
    ;; show buffer pos in the mode line
    ;; and turn off the scrollbar
    (sml-modeline-mode 1)
    (when (fboundp 'scroll-bar-mode) (scroll-bar-mode -1)))
  (when (fboundp 'scroll-bar-mode)
    (progn
      ;; otherwise, show a scrollbar...
      ;; ... on the right
      (scroll-bar-mode 1)
      (set-scroll-bar-mode 'right))))

;; browse-kill-ring
(when (require 'browse-kill-ring nil 'noerror)
  (progn (browse-kill-ring-default-keybindings)
	(global-set-key "\C-cy" '(lambda () (interactive)
				   (popup-menu 'yank-menu)))))

;; fill adapt
(when (require 'filladapt nil 'noerror)
  (setq-default filladapt-mode t))

;; jshint-mode
(when (require 'flymake-jshint nil 'noerror)
  (add-hook 'js-mode-hook
          (lambda () (flymake-mode t))))

;; org-mode
(when (require 'org nil 'noerror)
  (progn
    (setq org-todo-keywords
        '((sequence "TODO(t)" "PROGRESS(p!)" "WAIT(w@/!)" "|"
                    "CANCELED(c@/!)" "DONE(d!)")))

    (setq org-todo-keyword-faces
          '(("TODO" . org-warning) ("PROGRESS" . "yellow")
            ("CANCELED" . (:foreground "blue" :weight bold))))
    (setq org-startup-folded 'content)
    (setq org-startup-indented t)))

;; promela-mode
(when (require 'promela-mode nil 'noerror)
  (setq auto-mode-alist
        (append
         (list (cons "\\.promela$" 'promela-mode)
               (cons "\\.spin$" 'promela-mode)
               (cons "\\.pml$" 'promela-mode)
               (cons "\\.prm$" 'promela-mode)
               (cons "\\.porm$" 'promela-mode)
               )
         auto-mode-alist)))

;; dired+ mode
(when (require 'dired-x nil 'noerror)
  (setq dired-omit-files (rx (or (seq bol (? ".") "#")
                                 (seq "~" eol)
                                 (seq bol "svn" eol)
                                 (seq ".pyc" eol)
                                 (seq bol ".git" eol)
                                 (seq ".d" eol)
                                 (seq ".o" eol)))

        dired-omit-extensions (append dired-latex-unclean-extensions
                                      dired-bibtex-unclean-extensions
                                      dired-texinfo-unclean-extensions))

  (add-hook 'dired-mode-hook (lambda () (dired-omit-mode 1))))

;; arduino-mode
(require 'arduino-mode nil 'noerror)

;; deft
(when (require 'deft nil 'noerror)
   (setq deft-extension "org"
         deft-directory "~/.org/deft/"
         deft-text-mode 'org-mode)
   (global-set-key (kbd "<f9>") 'deft))