# -*- fill-column:78 -*-
#+TITLE: emacs init file
#+AUTHOR: Jacopo De Simoi
#+EMAIL: jacopods@math.utoronto.ca
#+OPTIONS: *:t ::t

* TODO Look at tangling at
  [http://thewanderingcoder.com/2015/02/literate-emacs-configuration/]

  although I'd rather do something like a local variable evaluation such as
  #  -*- eval: (add-hook 'before-save-hook 'org-icalendar-export-to-ics nil t) -*-
  Or makefile approach
  [https://emacs.stackexchange.com/questions/27126/is-it-possible-to-org-bable-tangle-an-org-file-from-the-command-line]

  See also [http://orgmode.org/manual/Extracting-source-code.html#Extracting-source-code]

* TODO Find what ~package.el~ does
* Some remarks and comments
** ~setq~ vs ~setq-default~
   Some variables are buffer-local, others are not; for non buffer-local
   variables the two commands are equivalent; for the buffer-local variables,
   setq acts on the current buffer, whereas setq-default sets the default
   value of the variable for buffers that do not have a local value.

   :source:   [https://stackoverflow.com/a/18173666]

* Files and dirs
  Move ~Customize~ to a separate file
  #+BEGIN_SRC emacs-lisp
    (setq custom-file "~/.emacs.d/custom.el")
    (load custom-file 'noerror)
  #+END_SRC
  Add relevant dirs to load path [This is somewhat undesirable; I should
  uniformize the path-loading business at some point…]
  #+BEGIN_SRC emacs-lisp
    (let ((default-directory "~/.emacs.d/"))
      (normal-top-level-add-subdirs-to-load-path)
      (normal-top-level-add-to-load-path '("fringe-helper.el"
                                           "multiple-cursors.el"
                                           "expand-region.el"
                                           "dash.el")))
    (add-to-list 'load-path "~/tmp") ;;what is this for?
    (add-to-list 'load-path "~/kde-emacs")
  #+END_SRC
  Put autosave files (ie #foo#) and backup files (ie foo~) in ~/.emacs.d/.
  create the autosave dir if necessary, since emacs won't.
  #+BEGIN_SRC emacs-lisp
    (make-directory "~/.emacs.d/autosaves/" t)
    (make-directory "~/.emacs.d/backup/" t)
  #+END_SRC

* Theming
  Use (my clone of) the solarized scheme
  #+BEGIN_SRC emacs-lisp
    (add-to-list 'custom-theme-load-path "/home/jacopods/clones/emacs-color-theme-solarized")
    (load-theme 'solarized t)
  #+END_SRC
  Use patched terminus font (this overrides the settings in Customize, but I
  never could it to work otherwise).  See the special treatment later on for
  dealing with bold weight
  #+BEGIN_SRC emacs-lisp
    (set-face-font 'default "-xos4-hackminus-medium-r-normal--20-200-72-72-c-100-ISO10646-1")
  #+END_SRC

* Global settings
** Cosmetics
    Prefer a minimal appearance: no menu, toolbar or scroll-bars; no
    splash screens or messages
    #+BEGIN_SRC emacs-lisp
      (menu-bar-mode -1)
      (tool-bar-mode 0)
      (scroll-bar-mode -1)
      (setq inhibit-startup-screen t
            inhibit-startup-message t)
    #+END_SRC
    a blinking cursor keeps the gpu awake; add global hl-line mode to more
    easily spot the cursor
    #+BEGIN_SRC emacs-lisp
      (blink-cursor-mode 0)
      (set-default 'cursor-type 'box)
      (global-hl-line-mode t)
    #+END_SRC
    Set frame title
    #+BEGIN_SRC emacs-lisp
      (setq frame-title-format
         '((buffer-file-name "%f"
             (dired-directory dired-directory "%b")) " · emacs"));; · " (:eval (kde-current-activity-name)))) ;; "%S"))
    #+END_SRC

** Mouseless
   Disable mouse interaction with emacs
   #+BEGIN_SRC emacs-lisp
     (setq mouse-autoselect-window nil)
     (mouse-wheel-mode -1)
     (setq mouse-yank-at-point nil)
     (setq focus-follows-mouse nil)
   #+END_SRC
*** TODO Find out what of the above is necessary given the disable-mouse mode below
    Use the ~disable-mouse~ package by Steve Purcell available at
    [https://github.com/purcell/disable-mouse]
     #+BEGIN_SRC emacs-lisp
       (require 'disable-mouse)
       (global-disable-mouse-mode)
     #+END_SRC
** Window behavior
   Prevent compilation window eating up other windows
   #+BEGIN_SRC emacs-lisp
      (setq compilation-scroll-output t
            compilation-window-height 12)
   #+END_SRC
*** TODO find out what this was actually meant to do
   #+BEGIN_SRC emacs-lisp
     (setq-default display-buffer-reuse-frames t)
   #+END_SRC

** Whitespace
   Trailing whitespace is evil; get rid of it
*** TODO Have a look at ws-trim.el
    It is conf'ble to avoid removing whitespace from lines that were not
    modified; sounds like a good idea for git
    [ftp://ftp.lysator.liu.se/pub/emacs/ws-trim.el]
    #+BEGIN_SRC emacs-lisp
      (setq-default show-trailing-whitespace t)
      (add-hook 'before-save-hook 'delete-trailing-whitespace)
    #+END_SRC

    Tabs are evil; get rid of them
    #+BEGIN_SRC emacs-lisp
      (setq c-basic-offset 4)
      (setq tab-width 4)
      (setq indent-tabs-mode nil)
    #+END_SRC

** Show matching parens
   Use mic-paren for paren-highlighting
*** TODO find out if there are better options out there
   #+BEGIN_SRC emacs-lisp
;     (setq show-paren-mode t)
     (require 'mic-paren)
     (paren-activate)
   #+END_SRC
* Leftovers
    #+BEGIN_SRC emacs-lisp
      (setq-default abbrev-mode t)
      (read-abbrev-file "~/.abbrev_defs")
      (setq save-abbrevs t)

      (setq search-whitespace-regexp "[ \t\r\n]+")
      (setq flyspell-use-meta-tab nil)

      (setq redisplay-dont-pause t
            scroll-margin 3
            scroll-step 1
            scroll-conservatively 10000
            scroll-preserve-screen-position 1)

      (defvar outline-minor-mode-prefix "\M-#")

      ;; * include other files
      (load "init-latex.el")
      (load "init-org.el")
      (load "init-c++.el")
      (load "init-elisp.el")
      (load "init-kde-integration.el")

      ;; KDE stuff

      (load "qml-mode.el" nil t t)
      (add-to-list 'auto-mode-alist '("\\.qml\\'" . qml-mode))
    #+END_SRC

** TODO find out how kde-emacs makes “make” actually work
  I need to keep this up until I realize what I need to make “make” work
  Please notice that kde-emacs forces the menu to show
  #+BEGIN_SRC emacs-lisp
    (require 'kde-emacs)
    (menu-bar-mode -1)
  #+END_SRC
** Leftovers
#+BEGIN_SRC emacs-lisp
;;(setq kde-full-name "Jacopo De Simoi")
;;(setq kde-email "wilderkde@gmail.com")

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

(require 'linum)
(global-linum-mode 1)
;; check if it works to enable it globally
;; (add-hook 'text-mode-hook 'linum-mode)
;; (add-hook 'qml-mode-hook 'linum-mode)
;; (add-hook 'lua-mode-hook 'linum-mode)

;; (require 'sourcepair)
;; (global-set-key (kbd "<f6>") 'sourcepair-load)

;;(global-set-key (kbd "C-M-<backspace>") 'backward-kill-sexp)

(global-set-key (kbd "C-x k") 'kill-this-buffer) ;;why not?

(setq default-fill-column 110)

;; (require 'pomodoro)

(defun select-frame-on-current-activity ()
 (select-frame-on-activity (kde-current-activity))
)

;; Rehab ↓
;; mark the date 30/1/2014
;; (require 'no-easy-keys)
;; (no-easy-keys 1)
;; conflicts a bit with org-mode

;; Keyboard is faster than mouse
;; Rehab ↑

;;Remove insanely irritating key-binding
(global-unset-key (kbd "C-z"))
(global-unset-key (kbd "C-x f"))
(global-unset-key (kbd "<M-f4>")) ; rly?

;; (global-unset-key (kbd "<backspace>")) ;give this a try
;; (global-unset-key (kbd "DEL")) ;give this a try
;; (global-unset-key (kbd "C-<backspace>")) ;give this a try

;; Change some global bindings:
(global-unset-key (kbd "C-M-u"))
(global-unset-key (kbd "C-M-d"))
(global-set-key (kbd "C-M-i") 'down-list) ;; -i stands for /in/
(global-set-key (kbd "C-M-o") 'up-list)	  ;; -o stands for /out/

(global-set-key (kbd "C-M-d") 'kill-sexp)

;; * magit

(global-set-key (kbd "C-x C-g") 'magit-status) ;; relates to C-x C-f and C-x C-s

;; * iy-go-to char (broken)
;; (require 'iy-go-to-char)
;; (global-set-key (kbd "M-m") 'iy-go-up-to-char)
;; (global-set-key (kbd "M-M") 'iy-go-up-to-char-backward)

;; * smart-tab-mode
(require 'smart-tab)
(global-smart-tab-mode 1)
(global-set-key (kbd "C-j") 'smart-tab) ;; try this; I never use C-j for goto-line

(global-set-key (kbd "C-c SPC") 'avy-goto-word-or-subword-1)
(global-set-key (kbd "M-s") 'avy-goto-word-or-subword-1)
(global-set-key (kbd "M-g M-g") 'avy-goto-line)
(global-set-key (kbd "M-g g") 'avy-goto-line)

;; * redefine line-beginning to handle indentation properly
(defun smart-line-beginning ()
  "Move point to the beginning of text on the current line; if that is already
the current position of point, then move it to the beginning of the line."
  (interactive)
  (let ((pt (point)))
    (beginning-of-line-text)
    (when (eq pt (point))
      (beginning-of-line))))
(global-set-key (kbd "C-a") 'smart-line-beginning)

;; * load expand-region

(require 'expand-region)
(global-set-key (kbd "C-=") 'er/expand-region)

;; * construct emacs-session so with session-id
(defun emacs-session-filename (session-id)
  "Construct a filename to save the session in based on SESSION-ID.
If the directory ~/.emacs.d exists, we make a filename in there, otherwise
a file in the home directory."
  (let ((basename (concat "sessions/session." session-id))
	(emacs-dir user-emacs-directory))
    (expand-file-name (if (file-directory-p emacs-dir)
			  (concat emacs-dir basename)
			(concat "~/.emacs-" basename)))))

;; * Multiple cursors galore
(require 'multiple-cursors)
(define-key mc/keymap (kbd "<return>") nil)

(global-set-key (kbd "C->") 'mc/mark-next-like-this)
(global-set-key (kbd "C-<") 'mc/mark-previous-like-this)
(global-set-key (kbd "C-c C-<") 'mc/mark-all-like-this)

(global-set-key (kbd "H-.") 'mc/mark-next-like-this)
(global-set-key (kbd "H-,") 'mc/mark-previous-like-this)
(global-set-key (kbd "<H-f13>") 'mc/mark-pop)
(global-set-key (kbd "<H-f14>") 'mc/mark-pop)
(global-set-key (kbd "H-#") 'mc/insert-numbers)

(global-set-key (kbd "<f13>") 'set-mark-command)
(global-set-key (kbd "<f14>") 'set-mark-command)

;;(setq help-char (kbd "H-h")
(global-set-key (kbd "M-h") 'backward-kill-word)
(global-set-key (kbd "C-M-h") 'backward-kill-sexp)

;; * clever mark stuff
(require 'visible-mark)
(visible-mark-mode t)
(global-visible-mark-mode t)
(transient-mark-mode 0)
;; ** stuff that works
(defun jump-to-mark ()
  "Jumps to the local mark, respecting the `mark-ring' order.
This is the same as using \\[set-mark-command] with the prefix argument."
  (interactive)
  (set-mark-command 1))
(global-set-key (kbd "<M-f13>") 'jump-to-mark)
(global-set-key (kbd "<M-f14>") 'jump-to-mark)

(defun just-activate-mark ()
  (interactive)
  (activate-mark))

(global-set-key (kbd "<S-f13>") 'just-activate-mark)
(global-set-key (kbd "<S-f14>") 'just-activate-mark)

;; (defun exchange-point-and-mark-no-activate ()
;;   "Identical to \\[exchange-point-and-mark] but will not activate the region."
;;   (interactive)
;;   (exchange-point-and-mark)
;;   (deactivate-mark nil))
;; (define-key global-map [remap exchange-point-and-mark] 'exchange-point-and-mark-no-activate)

;; ** This function is not needed since we are not using transient mode anymore
;; (defun push-mark-no-activate ()
;;   "Pushes `point' to `mark-ring' and does not activate the region
;; Equivalent to \\[set-mark-command] when \\[transient-mark-mode] is disabled"
;;   (interactive)
;;   (push-mark (point) t nil)
;;   (message "Pushed mark to ring"))
;; (global-set-key (kbd "<C-f13>") 'push-mark-no-activate)

;; * Wordnik							      :fixme:
(require 'wordnik-synonym)
(global-set-key (kbd "H-=") 'wn/synonym-at-point)
;; * kill annoying completion buffer
(add-hook 'minibuffer-exit-hook
          '(lambda ()
             (let ((buffer "*Completions*"))
               (and (get-buffer buffer)
                    (kill-buffer buffer)))
	     ))

;; * Open gpg encrypted files on the fly
;;(require 'epa-file)
;;(epa-file-enable)

;; * Time stamps
;; write
;;   Time-stamp: <>
;; in your file and save it to see time stamps at work.
;; Other time stamp format: "%a %b %e, %Y %l:%M %p"
(add-hook 'write-file-hooks 'time-stamp)
(setq time-stamp-active t)
(setq time-stamp-format "%:a %02d %:b %:y, %02H:%02M:%02S, %u")
(setq european-calendar-style 't)
;; first day of the week is monday instead of sunday:
(setq calendar--week--start--day 1)

;; * toorg
(require 'highlight-sexps)

(setq echo-keystrokes 0.10)

(require 'fringe-current-line)
(global-fringe-current-line-mode 1)
(setq fcl-fringe-bitmap 'right-triangle)

(require 'hlinum)
(hlinum-activate)


;; * Try again with ido
;; ** Load ido
(require 'ido)
(ido-mode t)
;; ** Organize ibuffer according to some rules
(setq ibuffer-saved-filter-groups
      (quote (("default"
	       ("LaTeχ" (mode . latex-mode))
	       ("Magit" (name . "^\\*magit.*$"))
	       ("elisp" (mode . emacs-lisp-mode))
	       ("org" (mode . org-mode))
	       ("emacs" (or
			 (name . "^\\*scratch\\*$")
			 (name . "^\\*Messages\\*$")
			 (name . "^\\*compilation\\*$")))))))

(add-hook 'ibuffer-mode-hook
	  '(lambda ()
	     (ibuffer-switch-to-saved-filter-groups "default")))


;; * mode-line setup
(setq-default mode-line-modified '(:eval (if (buffer-modified-p) "●" "·"))) ;still  needs some improvements, does not report Readonly state
(setq-default mode-line-remote '(:eval (let ((s (format-mode-line "%@")))
  (cond
   ((equal s "-") "·") ((equal s "@") "@") (t s)))))

(defvar wilder-buffer-vc-mode-line
	      '("%b" (vc-mode (:propertize
		     ;; Strip the backend name from the VC status information
		     (:eval (let* ((backend (downcase (symbol-name (vc-backend (buffer-file-name)))))
				   (branch (substring vc-mode (+ (length backend) 2)))
				   (s (substring vc-mode (+ (length backend) 1) (+ (length backend) 2)))
				   (status (cond ((equal s "-") "") ((equal s ":") "!") (t s))))
			      (concat "·" branch status)))
		     face font-lock-comment-face))))
(put 'wilder-buffer-vc-mode-line 'risky-local-variable t)

(defvar wilder-position
  '("[%p,%I] " ))

(put 'wilder-position 'risky-local-variable t)

(setq-default mode-line-format
	      '("%e"
		mode-line-front-space
		mode-line-mule-info
		mode-line-client
		mode-line-modified
		mode-line-remote
		mode-line-frame-identification
		wilder-buffer-vc-mode-line "   "
		wilder-position " "
		mode-line-modes
		mode-line-misc-info
		mode-line-end-spaces))

;; * toorg
(require 'outshine)
(add-hook 'outline-minor-mode-hook 'outshine-hook-function)
(setq outshine-use-speed-commands t)
(eval-after-load 'outshine '(define-key outline-minor-mode-map (kbd "C-M-i") nil))
;; (add-hook 'sh-mode-hook 'outline-minor-mode)

(require 'package)
(add-to-list 'package-archives
             '("melpa-stable" . "http://stable.melpa.org/packages/") t)

;; * give it a try
(require 'helm-config)
(helm-mode 1)
(global-set-key (kbd "M-x") 'helm-M-x)
(global-set-key (kbd "C-x C-f") 'helm-find-files)
(global-set-key (kbd "C-x b") 'helm-mini)
(global-set-key (kbd "M-y") 'helm-show-kill-ring)
(define-key helm-map (kbd "C-h") nil)
(define-key helm-find-files-map (kbd "C-h") nil)

;; Tried with golden-ratio, but found it irritating

;; (eval-after-load 'tramp '(setenv "SHELL" "/bin/bash"))

;; Use system proxy
(setq url-proxy-services '(("http" . "127.0.0.1:8118")))


(defun flash-hline ()
  (let ((fg (face-foreground 'default))
	(bg (face-background 'hl-line)))
    (set-face-background 'hl-line fg)
    (run-with-timer
     0.1 nil (lambda ()
	     (set-face-background 'hl-line "#303030") ))))

(global-set-key (kbd "<f15>") 'flash-hline)


   ;;; Stefan Monnier <foo at acm.org>. It is the opposite of fill-paragraph
(defun unfill-paragraph (&optional region)
  "Takes a multi-line paragraph and makes it into a single line of text."
  (interactive (progn (barf-if-buffer-read-only) '(t)))
  (let ((fill-column (point-max))
	;; This would override `fill-column' if it's an integer.
	(emacs-lisp-docstring-fill-column t))
    (fill-paragraph nil region)))

;; * start server named after kde activity name
(setq server-name (kde-current-activity-name))
;; mmh
;; (set-face-font 'default "-xos4-hackminus-medium-r-normal--20-200-72-72-c-100-ISO10646-1") ;
;; Why is the above needed down here?
;;
;; Because it sets the face for packages that have loaded in the meantime;
;; it does not wark perfectly as some packages are still to be loaded
;; (most notably magit)

;; Prevent any automatic splitting to split vertically
(setq split-width-threshold nil)

(mapc
   (lambda (face)
     (set-face-attribute face nil :weight 'normal)
     (set-face-attribute face nil :slant 'normal))
   (face-list))
(server-start)

#+END_SRC