Cacher is the code snippet organizer for pro developers

(add-to-list 'load-path "~/.emacs.d")

;; Increase window size
(if (window-system)
    (set-frame-size (selected-frame) 124 40))

; Add more package sources
(setq package-archives '(("gnu" . "http://elpa.gnu.org/packages/")
                         ("org" . "http://orgmode.org/elpa/")
                         ("marmalade" . "http://marmalade-repo.org/packages/")
                         ("melpa-stable" . "http://melpa-stable.milkbox.net/packages/")))
(package-initialize)

(defun require-package (package)
  (setq-default highlight-tabs t)
  "Install given PACKAGE."
  (unless (package-installed-p package)
    (unless (assoc package package-archive-contents)
      (package-refresh-contents))
    (package-install package)))


;; Set theme
(load-theme 'wombat)

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

;; Don't create backup files
(setq make-backup-files nil)

;; Show matching parens
(setq show-paren-delay 0)
(setq show-paren-mode 1)

;; Automatically match parens
(require 'autopair)
(autopair-global-mode)

;; Auto-indent with Return
(define-key global-map (kbd "RET") 'newline-and-indent)

;; Evil mode
(add-to-list 'load-path "~/.emacs.d/evil/")
(require 'evil)
(evil-mode 1)

;(setcdr evil-insert-state-map nil)
;(define-key evil-insert-state-map
;  (read-kbd-macro evil-toggle-key) ‘evil-emacs-state)

; Define j k to work as escape   
;(key-chord-define evil-insert-state-map "jk" 'evil-normal-state)

; Evil leader for <leader> support
(add-to-list 'load-path "~/.emacs.d/evil-leader")
(require 'evil-leader)
(setq evil-leader/in-all-states 1)
(global-evil-leader-mode)
(evil-leader/set-leader ",")

; Key bindings from .vimrc
(define-key evil-insert-state-map "\C-s" 'save-buffer) ; save
(define-key evil-normal-state-map "\C-s" 'save-buffer) ; save
(define-key evil-insert-state-map "\M-j" 'add-empty-line-below)   ; Add empty line to cursor position
(define-key evil-normal-state-map "\M-j" 'add-empty-line-below)
(define-key evil-insert-state-map "\M-k" 'add-empty-line-above)   ; Add empty line to cursor position
(define-key evil-normal-state-map "\M-k" 'add-empty-line-above)
;; (evil-leader/set-key "j" 'add-empty-line-below)   ; Add empty line to cursor position
;; (evil-leader/set-key "k" 'add-empty-line-above)

;; (global-set-key "\M-k" 'open-line)
;; (global-set-key (kbd "\M-j") 'add-empty-line-below)

(defun add-empty-line-below ()
  "Adds a new line below the current position."
  (interactive)
  (setq pos (point))
  (move-beginning-of-line nil)
  (next-line)
  (open-line 1)
  (previous-line)
  (goto-char pos))

(defun add-empty-line-above ()
  "Adds a new line above the current position."
  (interactive)
  (setq pos (point))
  (move-beginning-of-line nil)
  (open-line 1)
  (next-line)
  (goto-char (+ pos 1)))

;; c-k, c-j for pg up/down
(define-key evil-normal-state-map (kbd "C-k") (lambda ()
                    (interactive)
                    (evil-scroll-up nil)))
(define-key evil-normal-state-map (kbd "C-j") (lambda ()
                        (interactive)
                        (evil-scroll-down nil)))

;; Browse wrapped lines
(define-key evil-normal-state-map (kbd "j") 'evil-next-visual-line)
(define-key evil-normal-state-map (kbd "k") 'evil-previous-visual-line)

(add-hook 'c-mode-common-hook
	  (lambda()
	    (evil-leader/set-key "s" 'ff-find-other-file)))

(define-key evil-normal-state-map (kbd "<f2>") 'switch-to-prev-buffer)
(define-key evil-insert-state-map (kbd "<f2>") 'switch-to-prev-buffer)
(define-key evil-normal-state-map (kbd "<f3>") 'switch-to-next-buffer)
(define-key evil-insert-state-map (kbd "<f3>") 'switch-to-next-buffer)
  
;;; esc quits
(defun minibuffer-keyboard-quit ()
  "Abort recursive edit.
In Delete Selection mode, if the mark is active, just deactivate it;
then it takes a second \\[keyboard-quit] to abort the minibuffer."
  (interactive)
  (if (and delete-selection-mode transient-mark-mode mark-active)
      (setq deactivate-mark  t)
    (when (get-buffer "*Completions*") (delete-windows-on "*Completions*"))
    (abort-recursive-edit)))
(define-key evil-normal-state-map [escape] 'keyboard-quit)
(define-key evil-visual-state-map [escape] 'keyboard-quit)
(define-key minibuffer-local-map [escape] 'minibuffer-keyboard-quit)
(define-key minibuffer-local-ns-map [escape] 'minibuffer-keyboard-quit)
(define-key minibuffer-local-completion-map [escape] 'minibuffer-keyboard-quit)
(define-key minibuffer-local-must-match-map [escape] 'minibuffer-keyboard-quit)
(define-key minibuffer-local-isearch-map [escape] 'minibuffer-keyboard-quit)

; Vim-like search highlighting
(require 'evil-search-highlight-persist)
(global-evil-search-highlight-persist t)
(evil-leader/set-key "SPC" 'evil-search-highlight-persist-remove-all)

;;;;;;;;;;;;;;;;;;;;;;;;;;
; Helm (CtrlP-like search)

;; helm settings (TAB in helm window for actions over selected items,
;; C-SPC to select items)
(require 'helm-config)
(require 'helm-misc)
(require 'helm-projectile)
(require 'helm-locate)
(setq helm-quick-update t)
(setq helm-bookmark-show-location t)
(setq helm-buffers-fuzzy-matching t)
(helm-mode 1)
(define-key evil-normal-state-map " " 'helm-mini)

;; Helm-Projectile
(projectile-global-mode)
(setq projectile-require-project-root nil)
(define-key projectile-mode-map [?\s-h] 'helm-projectile)
(define-key projectile-mode-map [?\s-d] 'helm-projectile-find-dir)
(define-key projectile-mode-map [?\s-p] 'projectile-switch-project)
(define-key projectile-mode-map [?\s-f] 'helm-projectile-find-file)
(define-key projectile-mode-map [?\s-g] 'projectile-grep)

;; ;; These lines give an error 
;; ;(after 'projectile
;; ;  (package 'helm-projectile))
;; (global-set-key (kbd "M-x") 'helm-M-x)

(defun helm-my-buffers ()
  (interactive)
  (let ((helm-ff-transformer-show-only-basename nil))
  (helm-other-buffer '(helm-c-source-buffers-list
                       helm-c-source-elscreen
                       helm-c-source-ctags
                       helm-c-source-projectile-files-list
                       helm-c-source-recentf
                       helm-c-source-locate)
                     "*helm-my-buffers*")))


(evil-leader/set-key "p" 'helm-my-buffers)

; Evil-nerd-commenter
(require 'evil-nerd-commenter)
(evilnc-default-hotkeys)

;;;;;;;;;;;;
;; Powerline

(require 'powerline)
;; (powerline-default-theme)

;;;;;;;;
;; etags

(setq path-to-ctags "/usr/bin/ctags-exuberant")

(defun create-tags (dir-name)
  "Create tags file"
  (interactive "DDirectory: ")
  (shell-command "~/scripts/update_tags.sh")
;   (format "%s -R --extra=+qf -L %s/cscope.files" path-to-ctags (directory-file-name dir-name)))
)

;;;;;;;;;
;; cscope

(if (file-readable-p "./cscope.out")
		 (cscope-minor-mode 1))
(define-key global-map (kbd "M-n") 'cscope-next-symbol)
(define-key global-map (kbd "M-p") 'cscope-prev-symbol)
(define-key global-map (kbd "M-S-n") 'cscope-next-file)
(define-key global-map (kbd "M-S-p") 'cscope-prev-file)
(define-key global-map (kbd "M-g") 'cscope-find-global-definition)
(define-key global-map (kbd "M-d") 'cscope-find-this-symbol)
(define-key global-map (kbd "M-o") 'cscope-pop-mark)

;;;;;;;;;;;
;; flycheck
  
(require 'flycheck)
(add-hook 'after-init-hook 'global-flycheck-mode)

;(after 'flycheck
(setq flycheck-check-syntax-automatically '(save mode-enabled))
(setq flycheck-checkers (delq 'emacs-lisp-checkdoc flycheck-checkers))
(setq flycheck-checkers (delq 'html-tidy flycheck-checkers))
(setq flycheck-standard-error-navigation nil)
;; (add-hook 'c-mode-hook
;; 	  (lambda () (setq flycheck-clang-include-path 
;; 			   (list (expand-file-name "~/src/OEBASE/arm_prod/src/dsppipe")))))

(global-flycheck-mode t)

;flycheck errors on a tooltip (doesnt work on console)
(when (display-graphic-p (selected-frame))
 (eval-after-load 'flycheck
   '(custom-set-variables
     '(flycheck-display-errors-function #'flycheck-pos-tip-error-messages))))

;;;;;;
;; GDB
(setq gdb-many-windows t)

;(add-hook ')
;;;;;;;;;;;;;;;
;; Haskell-mode
; Add hook for Haskell mode indent
(add-to-list 'load-path "~/.emacs.d/haskell-mode/")
(load "haskell-mode-autoloads.el")
(add-hook 'haskell-mode-hook 'turn-on-haskell-indent)
(add-hook 'haskell-mode-hook 'interactive-haskell-mode)
(custom-set-variables
    ;; custom-set-variables was added by Custom.
    ;; If you edit it by hand, you could mess it up, so be careful.
    ;; Your init file should contain only one such instance.
    ;; If there is more than one, they won't work right.
    '(haskell-process-auto-import-loaded-modules t)
    '(haskell-process-log t)
    '(haskell-process-suggest-remove-import-lines t)
    '(ido-enable-flex-matching t)
    '(ido-enable-regexp t)
    '(inhibit-startup-screen t))

(define-key haskell-mode-map (kbd "C-c C-l") 'haskell-process-load-or-reload)
(define-key haskell-mode-map (kbd "C-'") 'haskell-interactive-bring)
(define-key haskell-mode-map (kbd "C-c C-t") 'haskell-process-do-type)
(define-key haskell-mode-map (kbd "C-c C-i") 'haskell-process-do-info)
(define-key haskell-mode-map (kbd "C-c C-c") 'haskell-process-cabal-build)
(define-key haskell-mode-map (kbd "C-c C-k") 'haskell-interactive-mode-clear)
(define-key haskell-mode-map (kbd "C-c c") 'haskell-process-cabal)
(define-key haskell-mode-map (kbd "SPC") 'haskell-mode-contextual-space)

(custom-set-faces
 ;; custom-set-faces was added by Custom.
 ;; If you edit it by hand, you could mess it up, so be careful.
 ;; Your init file should contain only one such instance.
 ;; If there is more than one, they won't work right.
 )

;; Add Wind Move support. Shift + arrows changes windows.
(when (fboundp 'windmove-default-keybindings)
  (windmove-default-keybindings))


(defun set-flycheck-include-path (filePath)
    "Read a file that has the paths to add to flycheck's include path"
    "(one per line) and add them."
    (setq splitPos 0)
    (setq restLine "")
    (setq moreLines t )
    (setq includePath '("./"))
 
    (set-buffer (find-file-noselect filePath))
    (goto-char 1)

    (while moreLines
      "The file has string 'echo ' at the beginning"
      (forward-char 5)

      (setq splitPos (point))

      (end-of-line)
      (setq restLine (buffer-substring-no-properties splitPos (point) ))

      (setq moreLines (= 0 (forward-line 1)))
      (setcdr includePath (cons restLine (cdr includePath)))))

;; (if (file-readable-p "./cscope.dirs")
;;     (setq flycheck-clang-include-path (set-flycheck-include-path "./cscope.dirs")))

(custom-set-variables
 ;; custom-set-variables was added by Custom.
 ;; If you edit it by hand, you could mess it up, so be careful.
 ;; Your init file should contain only one such instance.
 ;; If there is more than one, they won't work right.
 '(inhibit-startup-screen t))
(custom-set-faces
 ;; custom-set-faces was added by Custom.
 ;; If you edit it by hand, you could mess it up, so be careful.
 ;; Your init file should contain only one such instance.
 ;; If there is more than one, they won't work right.
  )

(provide '.emacs)
;;; .emacs ends here