gistfile1.el

;(setq inferior-lisp-program "/home/zoldar/Programy/sbcl/bin/sbcl") ; your Lisp system
;(setq inferior-lisp-program "/home/zoldar/bin/ecl") ; your Lisp system
;(add-to-list 'load-path "/home/zoldar/LISP/clbuild/source/slime/")  ; your SLIME directory
;(require 'slime-autoloads)
;(slime-setup '(slime-repl))

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

;; package
(require 'package)
(add-to-list 'package-archives
             '("marmalade" . "http://marmalade-repo.org/packages/"))
(add-to-list 'package-archives 
	     '("org" . "http://orgmode.org/elpa/") t)
(add-to-list 'package-archives
             '("melpa" . "http://melpa.milkbox.net/packages/") t)
(package-initialize)

(require 'auto-complete)
(global-auto-complete-mode t)
(define-key ac-completing-map "\M-/" 'ac-stop) ;; use M-/ to stop completion

(require 'yasnippet-bundle)
(yas/initialize)

;; w3m
(require 'w3m-load)
(require 'mime-w3m)
(setq browse-url-generic-program (executable-find "w3m"))
(setq browse-url-browser-function (quote w3m))

;; GIST

;;(require 'gist)

;; Gtags

(defun djcb-gtags-create-or-update ()
  "create or update the gnu global tag file"
  (interactive)
  (if (not (= 0 (call-process "global" nil nil nil " -p"))) ; tagfile doesn't exist?
    (let ((olddir default-directory)
          (topdir (read-directory-name  
                    "gtags: top of source tree:" default-directory)))
      (cd topdir)
      (shell-command "gtags && echo 'created tagfile'")
      (cd olddir)) ; restore   
    ;;  tagfile already exists; update it
    (shell-command "global -u && echo 'updated tagfile'")))

(add-hook 'gtags-mode-hook 
  (lambda()
    (local-set-key (kbd "M-.") 'gtags-find-tag)   ; find a tag, also M-.
    (local-set-key (kbd "M-,") 'gtags-find-rtag)  ; reverse tag
    (local-set-key (kbd "M-m") 'gtags-pop-stack)
    (local-set-key (kbd "M-n") 'djcb-gtags-create-or-update)
    (add-hook 'after-save-hook 'djcb-gtags-create-or-update nil 'make-it-local)))  

(defun gtags-hook-handler ()
  (require 'gtags)
  (gtags-mode t)
  (djcb-gtags-create-or-update))

;; PHP

(require 'php-mode)

(defun clean-php-mode ()
  (interactive)
  (php-mode)
  (setq c-basic-offset 2) ; 2 tabs indenting
  (setq indent-tabs-mode nil)
  (setq fill-column 78)
  (c-set-offset 'case-label '+)
  (c-set-offset 'arglist-close 'c-lineup-arglist-operators))
(c-set-offset 'arglist-intro '+) ; for FAPI arrays and DBTNG
(c-set-offset 'arglist-cont-nonempty 'c-lineup-math) ; for DBTNG fields and values


;; Gtags for php

(add-hook 'php-mode-hook (lambda () (gtags-hook-handler)))

;; javascript

(autoload 'js2-mode "js2" nil t)
(add-to-list 'auto-mode-alist '("\\.js$" . js2-mode))
(autoload 'espresso-mode "espresso")

(defun my-js2-indent-function ()
  (interactive)
  (save-restriction
    (widen)
    (let* ((inhibit-point-motion-hooks t)
           (parse-status (save-excursion (syntax-ppss (point-at-bol))))
           (offset (- (current-column) (current-indentation)))
           (indentation (espresso--proper-indentation parse-status))
           node)

      (save-excursion

        ;; I like to indent case and labels to half of the tab width
        (back-to-indentation)
        (if (looking-at "case\\s-")
            (setq indentation (+ indentation (/ espresso-indent-level 2))))

        ;; consecutive declarations in a var statement are nice if
        ;; properly aligned, i.e:
        ;;
        ;; var foo = "bar",
        ;;     bar = "foo";
        (setq node (js2-node-at-point))
        (when (and node
                   (= js2-NAME (js2-node-type node))
                   (= js2-VAR (js2-node-type (js2-node-parent node))))
          (setq indentation (+ 4 indentation))))

      (indent-line-to indentation)
      (when (> offset 0) (forward-char offset)))))

(defun my-indent-sexp ()
  (interactive)
  (save-restriction
    (save-excursion
      (widen)
      (let* ((inhibit-point-motion-hooks t)
             (parse-status (syntax-ppss (point)))
             (beg (nth 1 parse-status))
             (end-marker (make-marker))
             (end (progn (goto-char beg) (forward-list) (point)))
             (ovl (make-overlay beg end)))
        (set-marker end-marker end)
        (overlay-put ovl 'face 'highlight)
        (goto-char beg)
        (while (< (point) (marker-position end-marker))
          ;; don't reindent blank lines so we don't set the "buffer
          ;; modified" property for nothing
          (beginning-of-line)
          (unless (looking-at "\\s-*$")
            (indent-according-to-mode))
          (forward-line))
        (run-with-timer 0.5 nil '(lambda(ovl)
                                   (delete-overlay ovl)) ovl)))))

(defun my-js2-mode-hook ()
  (require 'espresso)
  (setq espresso-indent-level 4
        indent-tabs-mode nil
        c-basic-offset 4)
  (c-toggle-auto-state 0)
  (c-toggle-hungry-state 1)
  (set (make-local-variable 'indent-line-function) 'my-js2-indent-function)
  (define-key js2-mode-map [(meta control |)] 'cperl-lineup)
  (define-key js2-mode-map [(meta control \;)] 
    '(lambda()
       (interactive)
       (insert "/* -----[ ")
       (save-excursion
         (insert " ]----- */"))
       ))
  (define-key js2-mode-map [(return)] 'newline-and-indent)
  (define-key js2-mode-map [(backspace)] 'c-electric-backspace)
  (define-key js2-mode-map [(control d)] 'c-electric-delete-forward)
  (define-key js2-mode-map [(control meta q)] 'my-indent-sexp)
  (if (featurep 'js2-highlight-vars)
    (js2-highlight-vars-mode))
  (message "My JS2 hook"))

(add-hook 'js2-mode-hook 'my-js2-mode-hook)

;; python

;(load-file "~/.emacs.d/init_python.el")

(require 'python)

(defadvice py-execute-buffer (around python-keep-focus activate)
  "return focus to python code buffer"
  (save-excursion ad-do-it))

;; rainbow delimiters
(global-rainbow-delimiters-mode)



;; clojure-mode

(require 'clojure-mode)

(add-to-list 'auto-mode-alist '("\.cljs$" . clojure-mode))

(require 'midje-mode)
(add-hook 'clojure-mode-hook 'midje-mode)

(add-hook 'clojure-mode-hook 
	  (lambda ()
		  (local-set-key "C-," 'midje-check-fact)
		  (local-set-key "C-k" 'midje-clear-comments)))

(require 'ac-nrepl)
(add-hook 'nrepl-mode-hook 'ac-nrepl-setup)
(add-hook 'nrepl-interaction-mode-hook 'ac-nrepl-setup)
(eval-after-load "auto-complete" '(add-to-list 'ac-modes 'nrepl-mode))

(require 'ido)
(ido-mode t)

(require 'paredit)
(defun turn-on-paredit () (paredit-mode 1))
(add-hook 'clojure-mode-hook 'turn-on-paredit)
(add-hook 'nrepl-mode-hook 'turn-on-paredit)
(global-set-key [f7] 'paredit-mode)

(add-hook 'nrepl-interaction-mode-hook
	  'nrepl-turn-on-eldoc-mode) 

(setq nrepl-popup-stacktraces nil)

(setq tab-always-indent 'complete) 

(add-to-list 'same-window-buffer-names "*nrepl*")

(global-set-key [f9] 'nrepl-jack-in)

(add-hook 'clojure-mode-hook 
	  (lambda () 
		  (local-set-key "\M-{" 'paredit-wrap-curly)
		  (local-set-key "\M-}" 'paredit-close-curly-and-newline)
		  (local-set-key "\M-[" 'paredit-wrap-square)
		  (local-set-key "\M-]" 'paredit-close-square-and-newline)))

;; slime
;; (eval-after-load "slime" 
;;  '(progn (slime-setup '(slime-repl))))

;; (add-to-list 'load-path "~/Programy/clj/slime")
;; (require 'slime)
;; (slime-setup)

;; (require 'slime-ritz)

(set-language-environment "UTF-8")
;; (setq slime-net-coding-system 'utf-8-unix)

(require 'undo-tree)
(global-undo-tree-mode 1)
(require 'evil)
(evil-mode 1)
(setq evil-default-cursor t)

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

;;; esc quits

(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)


(autoload 'enable-paredit-mode "paredit"
  "Turn on pseudo-structural editing of Lisp code."
  t)

(show-paren-mode 1)
(setq make-backup-files nil)
(setq undo-limit 100000)
(column-number-mode t)
(setq blink-matching-paren-distance nil)
(setq show-paren-style 'expression)
;; disable bell function
(setq ring-bell-function 'ignore)
;; disable toolbar
(tool-bar-mode -1)
;; disable scrollbar
(toggle-scroll-bar -1)
;; disable splash screen
(custom-set-variables '(inhibit-startup-screen t)
		      '(initial-scratch-message nil))
;; current buffer name in title bar
(setq frame-title-format "%b")
;; start emacs server
(server-start)

(custom-set-faces
 '(default ((t (:inherit nil :stipple nil :background "white" :foreground "black" 
                         :inverse-video nil :box nil :strike-through nil 
                         :overline nil :underline nil :slant normal :weight normal 
                         :height 130 :width normal :foundry "unknown" 
                         :family "Inconsolata")))))

(defun toggle-window-split ()
  (interactive)
  (if (= (count-windows) 2)
      (let* ((this-win-buffer (window-buffer))
             (next-win-buffer (window-buffer (next-window)))
             (this-win-edges (window-edges (selected-window)))
             (next-win-edges (window-edges (next-window)))
             (this-win-2nd (not (and (<= (car this-win-edges)
                                         (car next-win-edges))
                                     (<= (cadr this-win-edges)
                                         (cadr next-win-edges)))))
             (splitter
              (if (= (car this-win-edges)
                     (car (window-edges (next-window))))
                  'split-window-horizontally
                'split-window-vertically)))
        (delete-other-windows)
        (let ((first-win (selected-window)))
          (funcall splitter)
          (if this-win-2nd (other-window 1))
          (set-window-buffer (selected-window) this-win-buffer)
          (set-window-buffer (next-window) next-win-buffer)
          (select-window first-win)
          (if this-win-2nd (other-window 1))))))

(define-key ctl-x-4-map "t" 'toggle-window-split)

;; font size control

(defun sacha/increase-font-size ()
  (interactive)
  (set-face-attribute 'default
                      nil
                      :height
                      (ceiling (* 1.10
                                  (face-attribute 'default :height)))))
(defun sacha/decrease-font-size ()
  (interactive)
  (set-face-attribute 'default
                      nil
                      :height
                      (floor (* 0.9
                                  (face-attribute 'default :height)))))
(global-set-key (kbd "C-+") 'sacha/increase-font-size)
(global-set-key (kbd "C--") 'sacha/decrease-font-size)

;; Kawa Scheme
(defun run-kawa ()
  "Run Kawa Scheme in an Emacs buffer."
  (interactive)
  (require 'cmuscheme)
  (let ((scheme-program-name "/usr/bin/kawa"))
    (run-scheme scheme-program-name)))

(require 'scheme-complete)
(eval-after-load 'scheme
  '(define-key scheme-mode-map "\t" 'scheme-complete-or-indent))
;;;
;;; If you use eldoc-mode (included in Emacs), you can also get live
;;; scheme documentation with:
;;;

(add-hook 'scheme-mode-hook (lambda () (paredit-mode +1)))
(add-hook 'inferior-scheme-mode-hook (lambda () (paredit-mode +1)))

(autoload 'scheme-get-current-symbol-info "scheme-complete" nil t)

(add-hook 'scheme-mode-hook
  (lambda ()
    (make-local-variable 'eldoc-documentation-function)
    (setq eldoc-documentation-function 'scheme-get-current-symbol-info)
    (eldoc-mode)))

(add-hook 'inferior-scheme-mode-hook
  (lambda ()
    (make-local-variable 'eldoc-documentation-function)
    (setq eldoc-documentation-function 'scheme-get-current-symbol-info)
    (eldoc-mode)))

;;;
;;; You can enable slightly smarter indentation with
;;;
(setq lisp-indent-function 'scheme-smart-indent-function)

(require 'info-look)


;;; solarized theme
(setq load-path (cons "~/.emacs.d/emacs-color-theme-solarized/" load-path))
(require 'color-theme-solarized)
(require 'color-theme-desert)
(require 'color-theme-humane)
(color-theme-desert)

(defun clojurescript-repl ()
 (interactive)
 (run-lisp "lein trampoline cljsbuild repl-listen"))


;; flymake php-mode

(require 'flymake)

(defun flymake-php-init ()
  "Use php to check the syntax of the current file."
  (let* ((temp (flymake-init-create-temp-buffer-copy 'flymake-create-temp-inplace))
	 (local (file-relative-name temp (file-name-directory buffer-file-name))))
    (list "/home/zoldar/Programy/php5.2/bin/php" (list "-f" local "-l"))))

(add-to-list 'flymake-err-line-patterns
  '("\\(Parse\\|Fatal\\) error: +\\(.*?\\) in \\(.*?\\) on line \\([0-9]+\\)$" 3 4 nil 2))

(add-to-list 'flymake-allowed-file-name-masks '("\\.php$" flymake-php-init))

(add-hook 'php-mode-hook (lambda () (flymake-mode 1)))
(define-key php-mode-map '[M-S-up] 'flymake-goto-prev-error)
(define-key php-mode-map '[M-S-down] 'flymake-goto-next-error)

;; php documentation

(setq phpdoc-root-dir "/home/zoldar/Dokumenty/php-chunked-xhtml")
(load "browse-php-doc")