#+TITLE: GNU Emacs Configuration
#+DATE: <2017-08-11 Fri>
#+AUTHOR: Yann Herklotz
#+EMAIL: ymherklotz@gmail.com
#+STARTUP: indent

* Introduction
This is my GNU Emacs Configuration that is mostly focused on C++ development, but
also has support for Python, F#, Haskell and Clojure.

#+BEGIN_SRC emacs-lisp
  (setq user-full-name "Yann Herklotz")
  (setq user-mail-address "ymherklotz@gmail.com")
#+END_SRC

* Interface
** Setup
Defining all the package repositories that are going to be used.

- ~gnu~ :: The default package repository for emacs
- ~melpa~ :: Contains a lot of additional packages for emacs that are made by
             the community.
- ~melpa-stable~ :: The stable melpa repository that only contains that full versions
                    for packages. This repository will be used for packages that maybe
                    get updated often, so that they do not break the config.
- ~org~ :: org package repository that contains many packages to extend org-mode.

#+BEGIN_SRC emacs-lisp
  (require 'package)

  (defvar gnu '("gnu" . "https://elpa.gnu.org/packages/"))
  (defvar melpa '("melpa" . "https://melpa.org/packages/"))
  (defvar melpa-stable '("melpa-stable" . "https://stable.melpa.org/packages/"))
  (defvar org-elpa '("org" . "http://orgmode.org/elpa/"))
#+END_SRC

These packages are then added to the list of package archives.

#+BEGIN_SRC emacs-lisp
  (setq package-archives nil)
  (add-to-list 'package-archives melpa-stable t)
  (add-to-list 'package-archives melpa t)
  (add-to-list 'package-archives gnu t)
  (add-to-list 'package-archives org-elpa t)
#+END_SRC

Initialise the packages and if the directories don't exist, create them.

#+BEGIN_SRC emacs-lisp
  (setq package-enable-at-startup nil)
  (package-initialize)

  (unless (and (file-exists-p (concat init-dir "elpa/archives/gnu"))
               (file-exists-p (concat init-dir "elpa/archives/melpa"))
               (file-exists-p (concat init-dir "elpa/archives/melpa-stable"))
               (file-exists-p (concat init-dir "elpa/archives/org")))
    (package-refresh-contents))
#+END_SRC

Use ~use-package~ to manage other packages, and improve load times.

#+BEGIN_SRC emacs-lisp
  (unless (package-installed-p 'use-package)
    (package-refresh-contents)
    (package-install 'use-package))

  (require 'use-package)
#+END_SRC

Server so that a client can connect to it. This makes using emacs much smoother, as frames
can be opened using the emacsclient.

#+BEGIN_SRC emacs-lisp
  (setq server-socket-file "/tmp/emacs1000/server")
  (setq server-socket-dir "/tmp/emacs1000")
  (unless (file-exists-p server-socket-file)
    (server-start))
#+END_SRC

Threshold for faster startup.

#+BEGIN_SRC emacs-lisp
  (setq gc-cons-threshold 500000000)
#+END_SRC

Move the backup files into the temporaty directory so that they are out of the way.

#+BEGIN_SRC emacs-lisp
  (setq backup-directory-alist
        `((".*" . ,temporary-file-directory)))
  (setq auto-save-file-name-transforms
        `((".*" ,temporary-file-directory t)))
#+END_SRC

** Editor
Editor specific options such as adding line numbers and showing.

Disable UI that starts when starting emacs and also set the y or n instead of
yes or no.

#+BEGIN_SRC emacs-lisp
  (setq inhibit-startup-message t)
  (tool-bar-mode -1)
  (menu-bar-mode -1)
  (fset 'yes-or-no-p 'y-or-n-p)
#+END_SRC

Make it easier to refresh the buffer by setting it to ~<f5>~.

#+BEGIN_SRC emacs-lisp
  (show-paren-mode 'expression)
  (global-set-key (kbd "<f5>") 'revert-buffer)
#+END_SRC

Revert the buffer automatically when a file changes on disc. This is
useful when monitoring a file such as a log file. It will also do this silently.

#+BEGIN_SRC emacs-lisp
  (global-auto-revert-mode 1)
  (setq auto-revert-verbose nil)
#+END_SRC

Disable tabs, I want to move towards only using spaces everywhere as that is my
preferred style. This is just personal preference though.

#+BEGIN_SRC emacs-lisp
  (setq-default indent-tabs-mode nil)
  (setq-default tab-width 4)
  (setq-default python-indent-offset 4)
#+END_SRC


#+BEGIN_SRC emacs-lisp
  (setq line-number-display-limit 2000000)
#+END_SRC

** Font
Set the font to monaco. It has to use the xft syntax, otherwise it doesn't render properly.
The font is also set twice, so that it is properly set when using emacs normally or
using the emacsclient.

#+BEGIN_SRC emacs-lisp
  (set-default-font "Monaco-9") ;;; set default font
  (setq default-frame-alist '((font . "Monaco-9"))) ;;; set default font for emacs --daemon and emacsclient
#+END_SRC

* Mail
~mu4e~ is automatically in the load path when installed through a package manager.

For archlinux, the command to install mu4e is:

#+BEGIN_SRC shell
pacman -S mu
#+END_SRC

which comes with mu.

#+BEGIN_SRC emacs-lisp
  (require 'mu4e)
#+END_SRC

Set the email client to be mu4e in emacs, and set the correct 
mail directory. As I am downloading all the mailboxes, there will be duplicates,
which can be ignored in searches by setting ~mu4e-headers-skip-duplicates~.

Also delete messages when they are sent, and don't copy them over to the 
sent directory, as Gmail will do that for us.

To download the mail using imap, I use ~mbsync~, which downloads all mail with the
~-a~ flag.

Finally, remove buffers when an email has been sent.

#+BEGIN_SRC emacs-lisp
  (setq mail-user-agent 'mu4e-user-agent)
  (setq mu4e-maildir "~/.mail")
  (setq mu4e-headers-skip-duplicates t)
  (setq mu4e-sent-messages-behavior 'delete)
  (setq mu4e-get-mail-command "mbsync -a")
  (setq message-kill-buffer-on-exit t)
#+END_SRC

Setting the directories that I use and set shortcuts to them.

#+BEGIN_SRC emacs-lisp
  (setq mu4e-drafts-folder "/gmail/[Gmail]/Drafts")
  (setq mu4e-sent-folder   "/gmail/[Gmail]/Sent Mail")
  (setq mu4e-trash-folder  "/gmail/[Gmail]/Trash")

  (setq mu4e-maildir-shortcuts
        '( ("/gmail/Inbox"               . ?i)
           ("/gmail/[Gmail]/Sent Mail"   . ?s)
           ("/gmail/[Gmail]/Trash"       . ?t)
           ("/gmail/[Gmail]/All Mail"    . ?a)))
#+END_SRC

Setting the name and email, with the signature.

#+BEGIN_SRC emacs-lisp
  (setq
   user-mail-address "ymherklotz@gmail.com"
   user-full-name  "Yann Herklotz"
   mu4e-compose-signature
   (concat
    "Yann Herklotz\n"))
#+END_SRC

Setting up ~smtp~ to send messages using gmail.

#+BEGIN_SRC emacs-lisp
  (require 'smtpmail)
  (setq message-send-mail-function 'smtpmail-send-it
        starttls-use-gnutls t
        smtpmail-starttls-credentials '(("smtp.gmail.com" 587 nil nil))
        smtpmail-auth-credentials
        '(("smtp.gmail.com" 587 "ymherklotz@gmail.com" nil))
        smtpmail-default-smtp-server "smtp.gmail.com"
        smtpmail-smtp-server "smtp.gmail.com"
        smtpmail-smtp-service 587)
#+END_SRC

* Utility
** Discover-ability
#+BEGIN_SRC emacs-lisp
  (use-package which-key
    :ensure t
    :diminish which-key-mode
    :config
    (which-key-mode))
#+END_SRC
** Navigation
*** Ace Windows
#+BEGIN_SRC emacs-lisp
  (use-package ace-window
    :ensure t
    :bind (("C-x o" . ace-window)))
#+END_SRC
*** Avy
#+BEGIN_SRC emacs-lisp
  (use-package avy
    :config
    (global-set-key (kbd "C-:") 'avy-goto-char)
    (global-set-key (kbd "C-'") 'avy-goto-char-2))
#+END_SRC
*** Helm
#+BEGIN_SRC emacs-lisp
  (use-package helm
    :ensure t
    :config (require 'helm-config))

  (use-package helm-mode
    :config (helm-mode 1))

  (use-package helm-utils
    ;; Popup buffer-name or filename in grep/moccur/imenu-all etc...
    :config (helm-popup-tip-mode 1))

  (use-package helm-sys
    :commands (helm-top)
    :config (helm-top-poll-mode 1))

  (global-set-key (kbd "M-x")                          'undefined)
  (global-set-key (kbd "M-x")                          'helm-M-x)
  (global-set-key (kbd "M-y")                          'helm-show-kill-ring)
  (global-set-key (kbd "C-x C-f")                      'helm-find-files)
  (global-set-key (kbd "C-c <SPC>")                    'helm-all-mark-rings)
  (global-set-key (kbd "C-x r b")                      'helm-filtered-bookmarks)
  (global-set-key (kbd "C-:")                          'helm-eval-expression-with-eldoc)
  (global-set-key (kbd "C-,")                          'helm-calcul-expression)
  (global-set-key (kbd "C-h d")                        'helm-info-at-point)
  (global-set-key (kbd "C-h i")                        'helm-info)
  (global-set-key (kbd "C-x C-d")                      'helm-browse-project)
  (global-set-key (kbd "C-h C-f")                      'helm-apropos)
  (global-set-key (kbd "C-h a")                        'helm-apropos)
  (global-set-key (kbd "C-h C-d")                      'helm-debug-open-last-log)
  (global-set-key (kbd "C-c i")                        'helm-imenu-in-all-buffers)
  (global-set-key (kbd "C-s")                          'helm-occur)
  (define-key global-map [remap jump-to-register]      'helm-register)
  (define-key global-map [remap list-buffers]          'helm-mini)
  (define-key global-map [remap dabbrev-expand]        'helm-dabbrev)
  (define-key global-map [remap find-tag]              'helm-etags-select)
  (define-key global-map [remap xref-find-definitions] 'helm-etags-select)
  (define-key global-map (kbd "M-g a")                 'helm-do-grep-ag)
  (define-key global-map (kbd "M-g g")                 'helm-grep-do-git-grep)
  (define-key global-map (kbd "M-g i")                 'helm-gid)
  (define-key global-map (kbd "C-x r p")               'helm-projects-history)
  (define-key global-map (kbd "C-x r c") 'helm-addressbook-bookmarks)
#+END_SRC
** Visual
*** All the icons
#+BEGIN_SRC emacs-lisp
  (use-package all-the-icons
    :ensure t)
#+END_SRC
*** Org Bullets
#+BEGIN_SRC emacs-lisp
  (use-package org-bullets
    :ensure t
    :config
    (add-hook 'org-mode-hook (lambda () (org-bullets-mode 1))))
#+END_SRC
** Editing
*** Hungry Delete
#+BEGIN_SRC emacs-lisp
  (use-package hungry-delete
    :ensure t
    :config
    (global-hungry-delete-mode))
#+END_SRC
*** Multiple Cursors
#+BEGIN_SRC emacs-lisp
  (use-package multiple-cursors
    :ensure t
    :bind (("C->" . mc/mark-next-like-this)
           ("C-<" . mc/mark-previous-like-this)
           ("C-c C-<" . mc/mark-all-like-this)))
#+END_SRC
*** SmartParens
#+BEGIN_SRC emacs-lisp
  (use-package smartparens
    :ensure t
    :bind (("M-[" . sp-backward-unwrap-sexp)
           ("M-]" . sp-unwrap-sexp)
           ("C-M-f" . sp-forward-sexp)
           ("C-M-b" . sp-backward-sexp)
           ("C-M-d" . sp-down-sexp)
           ("C-M-a" . sp-backward-down-sexp)
           ("C-M-e" . sp-up-sexp)
           ("C-M-u" . sp-backward-up-sexp)
           ("C-M-t" . sp-transpose-sexp)
           ("C-M-n" . sp-next-sexp)
           ("C-M-p" . sp-previous-sexp)
           ("C-M-k" . sp-kill-sexp)
           ("C-M-w" . sp-copy-sexp)
           ("C-<right>" . sp-forward-slurp-sexp)
           ("C-<left>" . sp-forward-barf-sexp)
           ("C-M-<left>" . sp-backward-slurp-sexp)
           ("C-M-<right>" . sp-backward-barf-sexp)
           ("M-D" . sp-splice-sexp)
           ("C-]" . sp-select-next-thing-exchange)
           ("C-<left_bracket>" . sp-select-previous-thing)
           ("C-M-]" . sp-select-next-thing)
           ("M-F" . sp-forward-symbol)
           ("M-B" . sp-backward-symbol))
    :init
    (require 'smartparens-config)
    (show-smartparens-global-mode +1)
    (smartparens-global-mode 1)

    (add-hook 'minibuffer-setup-hook 'turn-on-smartparens-strict-mode)

    (sp-with-modes '(c-mode c++-mode)
      (sp-local-pair "{" nil :post-handlers '(("||\n[i]" "RET")))
      (sp-local-pair "/*" "*/" :post-handlers '((" | " "SPC")
                                                ("* ||\n[i]" "RET")))))
#+END_SRC
*** Undo Tree
#+BEGIN_SRC emacs-lisp
  (use-package undo-tree
    :diminish undo-tree-mode
    :config
    (global-undo-tree-mode))
#+END_SRC
*** Whitespace
#+BEGIN_SRC emacs-lisp
  (use-package whitespace
    :bind (("C-x w" . whitespace-mode)))
#+END_SRC
** Misc
Reduce the ringing in emacs.

#+BEGIN_SRC emacs-lisp
  ;; http://stackoverflow.com/questions/11679700/emacs-disable-beep-when-trying-to-move-beyond-the-end-of-the-document
  (defun my-bell-function ())

  (setq ring-bell-function 'my-bell-function)
  (setq visible-bell nil)
#+END_SRC

* Writing
** Spellcheck in emacs
#+BEGIN_SRC emacs-lisp
  (defun spell-buffer-german ()
    (interactive)
    (ispell-change-dictionary "de_DE")
    (flyspell-buffer))

  (defun spell-buffer-english ()
    (interactive)
    (ispell-change-dictionary "en_US")
    (flyspell-buffer))

  (use-package ispell
    :config
    (when (executable-find "hunspell")
      (setq-default ispell-program-name "hunspell")
      (setq ispell-really-hunspell t))

    ;; (setq ispell-program-name "aspell"
    ;;       ispell-extra-args '("--sug-mode=ultra"))
    :bind (("C-c N" . spell-buffer-dutch)
           ("C-c n" . spell-buffer-english)))
#+END_SRC
** Word Wrapping
Wrap words when in text mode.

#+BEGIN_SRC emacs-lisp
  (dolist (hook '(text-mode-hook))
    (add-hook hook (lambda ()
                     (flyspell-mode 1)
                     (visual-line-mode 1)
                     )))
#+END_SRC
** Markdown
 Markdown is the standard for writing documentation. This snippet loads
 GFM (Github Flavoured Markdown) style.

 #+BEGIN_SRC emacs-lisp
   (use-package markdown-mode
     :ensure t
     :commands (markdown-mode gfm-mode)
     :mode (("README\\.md\\'" . gfm-mode)
            ("\\.md\\'" . markdown-mode)
            ("\\.markdown\\'" . markdown-mode))
     :init (setq markdown-command "multimarkdown"))
 #+END_SRC

** Org
 Agenda setup for org mode, pointing to the write files.

 #+BEGIN_SRC emacs-lisp
   (setq org-agenda-files (quote ("~/Dropbox/Org")))

   (defun y/append-to-list (list-var elements)
     "Append ELEMENTS to the end of LIST-VAR.

   The return value is the new value of LIST-VAR."
     (unless (consp elements)
       (error "ELEMENTS must be a list"))
     (let ((list (symbol-value list-var)))
       (if list
           (setcdr (last list) elements)
         (set list-var elements)))
     (symbol-value list-var))

   (setq org-icalendar-store-UID t)
   (setq org-icalendar-use-scheduled '(event-if-todo event-if-not-todo todo-start))
   (setq org-icalendar-use-deadline'(even-if-not-todo todo-due event-if-todo))

   (use-package org-gcal
     :ensure t
     :config
     (setq org-gcal-client-id "56042666758-7tq2364l4glivj0hdsd3p3f2cd9cucq1.apps.googleusercontent.com"
         org-gcal-client-secret "Zn47gN5ImfeMsNbmWQbPtv3w"
         org-gcal-file-alist '(("ymherklotz@gmail.com" .  "~/Dropbox/Org/personal.org")
                               ("p8po34fuo3vv1ugrjki895aetg@group.calendar.google.com" .  "~/Dropbox/Org/project.org"))))
 #+END_SRC

 Publishing to website.

 #+BEGIN_SRC emacs-lisp
   (use-package ox-twbs
     :ensure t
     :config
     (setq org-publish-project-alist
         '(("org-notes"
            :base-directory "~/Documents/Org/Website"
            :publishing-directory "~/Documents/Website"
            :publishing-function org-twbs-publish-to-html
            :with-sub-superscript nil
            ))))
 #+END_SRC

 Set global keys for org mode to access agenda.

 #+BEGIN_SRC emacs-lisp
   (global-set-key "\C-cl" 'org-store-link)
   (global-set-key "\C-ca" 'org-agenda)
   (global-set-key "\C-cc" 'org-capture)
   (global-set-key "\C-cb" 'org-iswitchb)
 #+END_SRC

  Set up ob for executing code blocks
  
 #+BEGIN_SRC emacs-lisp
   (require 'ob)
   ;; Babel settings, enabling languages
   (org-babel-do-load-languages
    'org-babel-load-languages
    '((emacs-lisp . t)
      (js . t)
      (java . t)
      (haskell . t)
      (python . t)
      (ruby . t)
      (sh . t)
      (org . t)
      (matlab . t)
      (ditaa . t)
      (clojure . t)
      ))
   (setq org-image-actual-width nil)
 #+END_SRC

 #+BEGIN_SRC emacs-lisp
   (setq org-format-latex-options (plist-put org-format-latex-options :scale 1.5))
 #+END_SRC
* Programming
My emacs configuration is mostly focused on programming, therefore there is a lot of different
language support.

** Version Control and Project Management
*** Magit
#+BEGIN_SRC emacs-lisp
  (use-package magit
    :ensure t
    :bind (("C-x g" . magit-status)))
#+END_SRC

*** Projectile
#+BEGIN_SRC emacs-lisp
  (use-package projectile
    :ensure t
    :diminish projectile-mode
    :config
    (projectile-global-mode 1)
    (setq projectile-indexing-method 'alien)
    (setq projectile-enable-caching t))

  (use-package counsel-projectile
    :ensure t
    :config
    (counsel-projectile-mode t))
#+END_SRC

** Language Support
*** C++
 Setting up CC mode with a hook that uses my settings.

 #+BEGIN_SRC emacs-lisp
   (use-package cc-mode
     :config
     (add-to-list 'auto-mode-alist '("\\.h\\'" . c++-mode))
     (setq c-default-style "linux"
           c-basic-offset 4
           c-indent-level 4)
     (defun my-c++-mode-hook ()
       (c-set-offset 'inline-open 0)
       (c-set-offset 'inline-close 0)
       (c-set-offset 'innamespace 0)
       (c-set-offset 'arglist-cont-nonempty 8)
       (setq indent-tabs-mode nil))
     (add-hook 'c-mode-hook 'my-c++-mode-hook)
     (add-hook 'c++-mode-hook 'my-c++-mode-hook)

     (define-key c-mode-map (kbd "C-c C-c") 'comment-or-uncomment-region))
 #+END_SRC

 Adding C headers to company backend for completion.

 #+BEGIN_SRC emacs-lisp
   (use-package irony
     :ensure t
     :config
     (add-hook 'c++-mode-hook 'irony-mode)
     (add-hook 'c-mode-hook 'irony-mode)
     (add-hook 'objc-mode-hook 'irony-mode)

     (defun my-irony-mode-hook ()
       (define-key irony-mode-map [remap completion-at-point]
         'irony-completion-at-point-async)
       (define-key irony-mode-map [remap complete-symbol]
         'irony-completion-at-point-async))
     (add-hook 'irony-mode-hook 'my-irony-mode-hook)
     (add-hook 'irony-mode-hook 'irony-cdb-autosetup-compile-options))

   (use-package company-irony
     :ensure t)

   (use-package flycheck-irony
     :ensure t
     :config
     (add-hook 'c++-mode-hook #'flycheck-irony-setup))

   (use-package company-c-headers
     :ensure t
     :config
     (add-to-list 'company-backends 'company-c-headers)
     (add-to-list 'company-backends 'company-irony)

     (add-hook 'irony-mode-hook 'company-irony-setup-begin-commands))
 #+END_SRC

 Using clang format to format the region that is currently being selected (need to install
 clang format script).

 #+BEGIN_SRC emacs-lisp
   (use-package clang-format
     :ensure t
     :config
     (global-set-key (kbd "C-c i") 'clang-format-region)
     (global-set-key (kbd "C-c u") 'clang-format-buffer))
 #+END_SRC

 #+BEGIN_SRC emacs-lisp
   (use-package rtags
     :ensure t
     :config
     (rtags-enable-standard-keybindings))

   (use-package ivy-rtags
     :ensure t
     :config
     (setq rtags-use-ivy t))
 #+END_SRC
*** Clojure
 Using Cider for clojure environment.

 #+BEGIN_SRC emacs-lisp
   (use-package cider
     :ensure t
     :config
     (setq cider-repl-display-help-banner nil))
 #+END_SRC

 Adding hook to clojure mode to enable strict parentheses mode.

 #+BEGIN_SRC emacs-lisp
   (use-package clojure-mode
     :ensure t
     :init
     (add-hook 'clojure-mode-hook 'turn-on-smartparens-strict-mode))
 #+END_SRC
*** CMake
#+BEGIN_SRC emacs-lisp

  (use-package cmake-mode
    :config
    (setq auto-mode-alist
          (append
           '(("CMakeLists\\.txt\\'" . cmake-mode))
           '(("\\.cmake\\'" . cmake-mode))
           auto-mode-alist))
    (autoload 'cmake-mode "~/CMake/Auxiliary/cmake-mode.el" t))

#+END_SRC
*** Emacs Lisp
 Adding strict parentheses to emacs lisp.

 #+BEGIN_SRC emacs-lisp
   (add-hook 'emacs-lisp-mode-hook 'turn-on-smartparens-strict-mode)
 #+END_SRC
 
*** F#
 F# mode for uni work.

 #+BEGIN_SRC emacs-lisp
   (use-package fsharp-mode
     :ensure t)
 #+END_SRC
*** Haskell
 Haskell mode with company mode completion.

 #+BEGIN_SRC emacs-lisp
   (use-package haskell-mode
     :ensure t)
 #+END_SRC
*** Python
 Elpy package for python, which provides an IDE type environment for python.

 #+BEGIN_SRC emacs-lisp
   (use-package elpy
     :ensure t
     :config
     (elpy-enable)
     (setq py-python-command "python3")
     (setq python-shell-interpreter "python3"))

   (with-eval-after-load 'python
     (defun python-shell-completion-native-try ()
       "Return non-nil if can trigger native completion."
       (let ((python-shell-completion-native-enable t)
             (python-shell-completion-native-output-timeout
              python-shell-completion-native-try-output-timeout))
         (python-shell-completion-native-get-completions
          (get-buffer-process (current-buffer))
          nil "_"))))
 #+END_SRC
*** JSON
 JSON files should be opened in js-mode.

 #+BEGIN_SRC emacs-lisp
   (add-to-list 'auto-mode-alist '("\\.json\\'" . js-mode))
 #+END_SRC
*** Shell
#+BEGIN_SRC emacs-lisp
  (setq sh-basic-offset 2)
  (setq sh-indentation 2)
#+END_SRC

** Completion Support
*** Company
#+BEGIN_SRC emacs-lisp
  (use-package company
    :ensure t
    :config
    (add-hook 'after-init-hook 'global-company-mode)

    (setq company-backends (delete 'company-semantic company-backends))

    (define-key c-mode-map (kbd "C-c n") 'company-complete)
    (define-key c++-mode-map (kbd "C-c n") 'company-complete)
    (setq company-dabbrev-downcase 0))
#+END_SRC

*** Flycheck
Enabling global flycheck support.
#+BEGIN_SRC emacs-lisp
  (use-package flycheck
    :ensure t
    :diminish flycheck-mode
    :init (global-flycheck-mode))
#+END_SRC

*** Yasnippets
#+BEGIN_SRC emacs-lisp
  (use-package yasnippet
    :ensure t
    :diminish yas-minor-mode
    :init
    (yas-global-mode 1))
#+END_SRC

* Look and Feel
#+BEGIN_SRC emacs-lisp
  ;; (use-package color-theme-sanityinc-tomorrow
  ;;   :ensure t)

  ;; (use-package leuven-theme
  ;;   :ensure t)

  (use-package zenburn-theme
    :ensure t)

  ;; (use-package gruvbox-theme
  ;;   :ensure t)

  ;; (use-package material-theme
  ;;   :ensure t)

  ;; (use-package monokai-theme
  ;;   :ensure t)

  ;; (use-package plan9-theme
  ;;   :ensure t)

  ;; (use-package doom-themes
  ;;    :ensure t)

  (use-package telephone-line
    :ensure t
    :init
    (setq telephone-line-primary-left-separator 'telephone-line-cubed-left
          telephone-line-secondary-left-separator 'telephone-line-cubed-hollow-left
          telephone-line-primary-right-separator 'telephone-line-cubed-right
          telephone-line-secondary-right-separator 'telephone-line-cubed-hollow-right)
    (setq telephone-line-height 24
          telephone-line-evil-use-short-tag t))

  (if (daemonp)
      (add-hook 'after-make-frame-functions
                (lambda (frame)
                  (select-frame frame)
                  (load-theme 'zenburn t)
                  (telephone-line-mode 1)
                  (toggle-scroll-bar -1)))
    (progn (load-theme 'zenburn t)
           (telephone-line-mode 1)
           (toggle-scroll-bar -1)))
#+END_SRC

* My Code
#+BEGIN_SRC emacs-lisp
  (defun y/swap-windows ()
    "Swaps two windows and leaves the cursor in the original one"
    (interactive)
    (ace-swap-window)
    (aw-flip-window))

  (defun y/fsharp-reload-file ()
    "Reloads the whole file when in fsharp mode."
    (interactive)
    (fsharp-eval-region (point-min) (point-max)))

  (defun y/exit-emacs-client ()
    "consistent exit emacsclient.
     if not in emacs client, echo a message in minibuffer, don't exit emacs.
     if in server mode
        and editing file, do C-x # server-edit
        else do C-x 5 0 delete-frame"
    (interactive)
    (if server-buffer-clients
        (server-edit)
      (delete-frame)))

  (defun y/beautify-json ()
    (interactive)
    (let ((b (if mark-active (min (point) (mark)) (point-min)))
          (e (if mark-active (max (point) (mark)) (point-max))))
      (shell-command-on-region b e
       "python -m json.tool" (current-buffer) t)))
#+END_SRC

#+RESULTS:
: y/beautify-json

Setting up my keybindings
#+BEGIN_SRC emacs-lisp
  (define-prefix-command 'y-map)
  (global-set-key (kbd "C-c y") 'y-map)

  (define-key y-map (kbd "s") 'y/swap-windows)
  (global-set-key (kbd "C-c q") 'y/exit-emacs-client)
  (define-key y-map (kbd "j") 'y/beautify-json)

  (add-hook 'fsharp-mode-hook
            (lambda () (local-set-key (kbd "C-c C-c") #'y/fsharp-reload-file)))
#+END_SRC

#+RESULTS:
| lambda | nil | (local-set-key (kbd C-c C-c) (function y/fsharp-reload-file)) |

Registers
#+BEGIN_SRC emacs-lisp
  (set-register ?e (cons 'file "~/.emacs.d/myinit.org"))
  (set-register ?n (cons 'file "~/Dropbox/Org/note.org"))
  (set-register ?s (cons 'file "~/Dropbox/Org/schedule.org"))
  (set-register ?p (cons 'file "~/Dropbox/Org/project.org"))
#+END_SRC

* Conclusion
Setting the gc-cons threshold back to what it was at the beginning.

#+BEGIN_SRC emacs-lisp
  (setq gc-cons-threshold 10000000)
#+END_SRC