My Emacs

• Installation
• Resize frame
• General stuff
  • Unsorted
  • Macro's
  • Goto-line
  • Rectangle
  • Garbage collection (gc)
  • Yes-or-no questions
  • Emacs fullscreen at startup
  • Enable disabled commands
  • Buffers
  • Helping vim-users
  • Backup files
  • Describe key
• Which-key
• Theme
  • Highlight line
• Dashboard
• Zygospore
• Mode-line
  • Clock
• Editing settings
  • Kill-ring customization
  • Newline at end-of-file
  • Enable column numbers
  • Look-and-feel modifications
  • Tab-width
  • Automatic indent
  • Delete trailing whitespace
  • Angry faces
  • C Coding settings
  • Tabs vs spaces
• Undo-tree
• Volatile highlights
• iedit
• Smartparens
• Comment-dwim-2
• Expand-region
• Windooze
• Helm
  • General config
  • Helm-gtags
• Mutliple cursors
• GDB
• Magit
• Programming
  • Yasnippet
  • Flycheck
  • Company mode
  • (Relative) Line numbers
  • C/C++ mode
    • Flycheck
    • Company
  • Python mode
• Windows
  • Splitting
  • Switching
  • Multi-frame rebindings (obsolete with switch-window)
• Avy
• Convenience stuff
  • Visiting the configuration
  • Reload the configuration
  • Subword
  • Bell
• Server
• Beacon
• Sunrise commander
  • Install
• Org
  • Org bullets
  • Some basic config
    • Super/Sub-scripts
    • Indentation
    • Runnable languages
      • Dita
  • Note config
• Diminish
• Shell-pop
• Old stuff, maybe usefull for lookup later
  • Diff mode stuff
  • Speedbar
• TODO

Installation

My personal emacs configuration

(Heavily) Inspired by the following configs:

• https://github.com/tuhdo/emacs-c-ide-demo
• https://github.com/daedreth/UncleDavesEmacs

This configuration requires the installation of :

• the GNU global package (for gtags)
• clang (for ivory)
• cmake (for ivory)
• llvm-libs (for cmake, somehow not a dependency on Manjaro when installing cmake)
• Use python-pip to install requirements for elpy: pip install jedi flake8 importmagic autopep8 yapf
• ditaa (for ascii to image generation in org-mode)

When first checking out this config, run irony-install-server to make and install the irony-server.

Resize frame

Minor-mode to easily resize frames (works with EXWM (firefox, …)). Courtesy goes to kuanyui (https://gist.github.com/kuanyui/65a408d393871048771c):

;;; resize-frame.el --- A minor mode to resize frames easily.  -*- lexical-binding: t; -*-

;; Copyright (C) 2014  kuanyui

;; Author: kuanyui <azazabc123@gmail.com>
;; Keywords: frames, tools, convenience
;; License: WTFPL 1.0

;;; Commentary:

;; Press "ESC `" and use arrow-keys or i/j/k/l to adjust frames. press any key to done.

;;; Code:

(defvar resize-frame-map
  (let ((map (make-keymap)))
    (define-key map (kbd "<up>") 'enlarge-window)
    (define-key map (kbd "<down>") 'shrink-window)
    (define-key map (kbd "<right>") 'enlarge-window-horizontally)
    (define-key map (kbd "<left>") 'shrink-window-horizontally)
    (set-char-table-range (nth 1 map) t 'resize-frame-done)
    (define-key map (kbd "C-p") 'enlarge-window)
    (define-key map (kbd "C-n") 'shrink-window)
    (define-key map (kbd "C-f") 'enlarge-window-horizontally)
    (define-key map (kbd "C-b") 'shrink-window-horizontally)
    map))

(define-minor-mode resize-frame
  "A simple minor mode to resize-frame.
C-c C-c to apply."
  ;; The initial value.
  :init-value nil
  ;; The indicator for the mode line.
  :lighter " ResizeFrame"
  ;; The minor mode bindings.
  :keymap resize-frame-map
  :global t
  (if (<= (length (window-list)) 1)
      (progn (setq resize-frame nil)
             (message "Only root frame exists, abort."))
      (message "Use arrow-keys or i/j/k/l to adjust frames.")))

(defun resize-frame-done ()
  (interactive)
  (setq resize-frame nil)
  (message "Done."))

(global-set-key (kbd "C-x C-r") 'resize-frame)

General stuff

Unsorted

Collection of stuff that needs to be sorted…someday….maybe…

(global-set-key (kbd "M-p") 'fill-paragraph)

Macro's

Rebind the macro keys to Fx keys to give them a decent purpose.

(global-set-key [f9]  'start-kbd-macro)
(global-set-key [f10]  'end-kbd-macro)
(global-set-key [f11]  'call-last-kbd-macro)

Goto-line

Starting with Emacs 23.2, M-g g is bound to goto-line. However, I find this too long. So rebind it:

(global-set-key (kbd "M-g") 'goto-line)

Rectangle

Most rectangle functions are by default mapped to something like C-x r (other-char). I use string-insert-rectangle and query-replace-regexp quite a lot, so rebind it to something easy to remember.

(global-set-key (kbd "C-x r i") 'string-insert-rectangle)
(global-set-key (kbd "C-x r r") 'query-replace-regexp)

Garbage collection (gc)

I used to have the following enabled in my init to increase the gc threshold to speed-up emacs startup: (stolen from http://bling.github.io/blog/2016/01/18/why-are-you-changing-gc-cons-threshold/)

(setq gc-cons-threshold 100000000)

But according to this: https://lists.gnu.org/archive/html/help-gnu-emacs/2007-06/msg00243.html , it is no longer necessary. But I found that I still have to do this to speed up emacs.

Yes-or-no questions

Because I'm lazy, important yes-or-no questions can be answered with y-or-n:

(defalias 'yes-or-no-p 'y-or-n-p)

Emacs fullscreen at startup

(add-to-list 'default-frame-alist '(fullscreen . maximized))

Enable disabled commands

Some commands are disabled to protect the user. Narrow-region/page is a really handy feature, enable it:

(put 'narrow-to-page 'disabled nil)
(put 'narrow-to-region 'disabled nil)

Buffers

Why is this not built-in?

(defun kill-all-buffers ()
  "Kill all buffers without regard for their origin."
  (interactive)
  (mapc 'kill-buffer (buffer-list)))

Helping vim-users

(defconst wq "This is not vi!  Use C-x C-c instead.")
(defconst w "This is not vi!  Use C-x C-s instead.")
(defconst q! "This is EMACS not vi!  Use C-x C-c instead.")
(defconst wq! "This is EMACS not vi!  Use C-x C-c instead.")

Backup files

Disable the generation of backup-files, I don't use them.

(setq make-backup-files nil)

Describe key

Describe key will open a new buffer with the relevant information. However, it stays in the current window and opens a new window with the help-info, forcing you to switch buffers to close the help window. This small function just switches the focus to the newly opened window so we can close it more easily.

(defun move-to-help-window ()
  (switch-to-buffer-other-window "*Help*")
)
(add-hook 'help-mode-hook 'move-to-help-window)

move-to-help-window

Which-key

Display available keybindings in popup: https://github.com/justbur/emacs-which-key

(use-package which-key
  :ensure t
  :config
    (which-key-setup-side-window-bottom)
    (which-key-mode))

Theme

(use-package monokai-theme
  :ensure t
  :init
    (load-theme 'monokai t)

)

Highlight line

Highlight line will highlight the current line we are on. Enable highlight-line globally and replace its background colour.

(global-hl-line-mode 1)
(set-face-background hl-line-face "dark slate grey")

Dashboard

I use the dashboard as start screen. Since I like it to give me a list of recent files, we need to enable recentf-mode.

(use-package dashboard
  :ensure t
  :init
    (recentf-mode 1)
  :config
    (dashboard-setup-startup-hook)
    (setq dashboard-startup-banner "~/.emacs.d/img/dash_logo.png")
    (setq dashboard-items '((recents  . 10)
                            (bookmarks . 5)
                            ))
    (setq dashboard-banner-logo-title "")
)

Zygospore

Revert C-x 1 by pressing C-x 1 again: https://github.com/louiskottmann/zygospore.el

FYI: At one point, used this together with sr-speedbar. They did not play well together…

(use-package zygospore
  :ensure t
  :config
    (global-set-key (kbd "C-x 1") 'zygospore-toggle-delete-other-windows)
)

Mode-line

https://github.com/Malabarba/smart-mode-line

(use-package smart-mode-line
  :ensure t
  :config
    (setq sml/no-confirm-load-theme t)
    (setq sml/theme 'respectful)
    (sml/setup)
)

Clock

  (setq display-time-24hr-format t)
  (setq display-time-format "%H:%M - %d %b %Y")
  (setq display-time-default-load-average nil)

  (display-time-mode 1)

Editing settings

Kill-ring customization

Setting kill-whole-line to non-nil means when we execute C-k at the beginning of a line will the entire line including the following newline will be deleted.

(setq kill-ring-max 5000) ; increase kill-ring capacity
(setq kill-whole-line t)

Newline at end-of-file

(setq mode-require-final-newline t) ; add a newline to end of file

Enable column numbers

(setq column-number-mode 1)

Look-and-feel modifications

Remove scroll-, tool- and menu-bar. I don't use them so free some space.

(scroll-bar-mode -1)
(tool-bar-mode -1)
(menu-bar-mode -1)

Tab-width

Set the default tab width.

(setq-default tab-width 4)

Automatic indent

Automatically indent when pressing RET.

(global-set-key (kbd "RET") 'newline-and-indent)

Delete trailing whitespace

Automatically delete trailing whitespace when saving a file.

(add-hook 'before-save-hook 'delete-trailing-whitespace)

Angry faces

;; make angry face to get my attention
(setq prog-modes '(c++-mode python-mode erlang-mode java-mode c-mode emacs-lisp-mode scheme-mode prog-mode))
(make-face 'font-lock-angry-face)
(modify-face 'font-lock-angry-face "Red" "Yellow" nil t nil t nil nil)

;; Add keywords to recognize to angry face
(mapc (lambda (mode)
		(font-lock-add-keywords
		 mode
		 '(("\\<\\(FIXME\\)" 1 'font-lock-angry-face t)))
		)
	  prog-modes)
(mapc (lambda (mode)
		(font-lock-add-keywords
		 mode
		 '(("\\<\\(TODO\\)" 1 'font-lock-angry-face t)))
		)
	  prog-modes)

C Coding settings

Some basic C-coding settings (style, indentation offset, …).

;; default coding style
(setq c-default-style "linux")

;; sane indentation offset
(setq c-basic-offset 4)

Tabs vs spaces

Tabs are evil.

(setq-default indent-tabs-mode nil)

Undo-tree

Undo with C-/.

(use-package undo-tree
  :ensure t
  :config
    (global-undo-tree-mode)
)

Volatile highlights

Show/highlight changes when doing undo/yanks/kills/…

https://github.com/k-talo/volatile-highlights.el

(use-package volatile-highlights
  :ensure t
  :config
    (volatile-highlights-mode t)
)

iedit

Highlight occurences of symbol and replace them simultanously. Shortkey: C-;

https://github.com/victorhge/iedit

(use-package iedit
  :ensure t
)

Smartparens

Smart minor-mode to deal with pairs. Extra options:

• show-smartparens-global-mode : highlight corresponding bracket/pair/…
• smartparens-global-mode : enable smartparens

https://github.com/Fuco1/smartparens

(use-package smartparens
  :ensure t
  :config
    (require 'smartparens-config)
    (show-smartparens-global-mode t)
    (smartparens-global-mode t)
)

;; old config stuff
;; (setq sp-base-key-bindings 'paredit)
;; (setq sp-autoskip-closing-pair 'always)
;; (setq sp-hybrid-kill-entire-symbol nil)
;; (sp-use-paredit-bindings)
;;
;; (show-smartparens-global-mode +1)
;; (smartparens-global-mode 1)

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; keybinding management smartparens ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; cl-package contains the loop macro
;; (require 'cl)
;;
;; (defmacro def-pairs (pairs)
;;   `(progn
;;      ,@(loop for (key . val) in pairs
;;           collect
;;             `(defun ,(read (concat
;;                             "wrap-with-"
;;                             (prin1-to-string key)
;;                             "s"))
;;                  (&optional arg)
;;                (interactive "p")
;;                (sp-wrap-with-pair ,val)))))
;;
;; (def-pairs ((paren . "(")
;;             (bracket . "[")
;;             (brace . "{")
;;             (single-quote . "'")
;;             (double-quote . "\"")
;;             (underscore . "_")
;;             (back-quote . "`")))
;;
;; (define-key smartparens-mode-map (kbd "C-c (") 'wrap-with-parens)
;; (define-key smartparens-mode-map (kbd "C-c [") 'wrap-with-brackets)
;; (define-key smartparens-mode-map (kbd "C-c {") 'wrap-with-braces)
;; (define-key smartparens-mode-map (kbd "C-c '") 'wrap-with-single-quotes)
;; (define-key smartparens-mode-map (kbd "C-c \"") 'wrap-with-double-quotes)
;; (define-key smartparens-mode-map (kbd "C-c _") 'wrap-with-underscores)
;; (define-key smartparens-mode-map (kbd "C-c `") 'wrap-with-back-quotes)
;;
;; (define-key smartparens-mode-map (kbd "C-c s r") 'sp-rewrap-sexp)
;; (define-key smartparens-mode-map (kbd "C-c s u") 'sp-unwrap-sexp)
;;
;; (define-key smartparens-mode-map (kbd "C-M-f") 'sp-forward-sexp)
;; (define-key smartparens-mode-map (kbd "C-M-b") 'sp-backward-sexp)
;;
;; ;; TODO: in manjaro this selects keyboard-layout or something
;; ;;(define-key smartparens-mode-map (kbd "C-M-k") 'sp-kill-sexp)
;; (define-key smartparens-mode-map (kbd "C-M-w") 'sp-copy-sexp)
;;
;; (define-key smartparens-mode-map (kbd "C-M-n") 'sp-next-sexp)
;; (define-key smartparens-mode-map (kbd "C-M-p") 'sp-previous-sexp)
;;
;; ;; TODO: for some reason this does not work
;; (define-key smartparens-mode-map (kbd "C-M-a") 'sp-beginning-of-sexp)
;; (define-key smartparens-mode-map (kbd "C-M-e") 'sp-end-of-sexp)
;;
;; (define-key smartparens-mode-map (kbd "C-M-h") 'mark-defun)
;;
;; (smartparens-global-mode t)

Comment-dwim-2

Replacement for built-in comment-dwim, more comment features.

https://github.com/remyferre/comment-dwim-2

(use-package comment-dwim-2
  :ensure t
  :config
    (global-set-key (kbd "M-;") 'comment-dwim-2)
)

Expand-region

Expand region increases the selected region by semantic units. I also enable pending-delete-mode, this means when we mark a region and start typing, the text within the mark is deleted with the new typed text and the mark disappears.

https://github.com/magnars/expand-region.el

(use-package expand-region
   :ensure t
   :init
     (pending-delete-mode t)
   :config
     (global-set-key (kbd "C-=") 'er/expand-region)
)

Windooze

When we use windows as our bootloader, we have to setup some things first:

;; Windows performance tweaks
;;
(when (boundp 'w32-pipe-read-delay)
  (setq w32-pipe-read-delay 0))
;; Set the buffer size to 64K on Windows (from the original 4K)
(when (boundp 'w32-pipe-buffer-size)
  (setq irony-server-w32-pipe-buffer-size (* 64 1024)))

;; Set pipe delay to 0 to reduce latency of irony
(setq w32-pipe-read-delay 0)

;; From "setting up irony mode on Windows" :
;; Make sure the path to clang.dll is in emacs' exec_path and shell PATH.
(setenv "PATH"
        (concat
         "C:\\msys64\\usr\\bin" ";"
         "C:\\msys64\\mingw64\\bin" ";"
         (getenv "PATH")
         )
)
(setq exec-path (append '("c:/msys64/usr/bin" "c:/alt/msys64/mingw64/bin")
                        exec-path))

To be fair, I didn't test this in a while…

Helm

General config

(use-package helm
  :ensure t
  :bind
    ("M-x" . helm-M-x)
    ("M-y" . helm-show-kill-ring)
    ("C-x b" . helm-mini)
    ("C-x C-b" . helm-mini)
    ("C-x C-f" . helm-find-files)
  :init
  (helm-mode 1)
  :config
  (setq helm-M-x-fuzzy-match t
        helm-buffers-fuzzy-matching t
        helm-recentf-fuzzy-match t
        helm-semantic-fuzzy-match t
        helm-imenu-fuzzy-match t
        helm-split-window-inside-p t ;; open helm buffer inside current window
        helm-scroll-amount 8 ;; scroll 8 lines other window using M-<next>/M-<prior>
;;        helm-move-to-line-cycle-in-source nil ;; move to end or beginning of source when reaching to por bottom of source
;;        helm-ff-search-library-in-sexp t ;; search for library in 'require' and 'declare-function' sexp
;;        helm-echo-input-in-header-line t
  )
  ;; rebind tab to do persistent action
  ;; we use helm-execute-persistent-action more than helm-select-action (default for <tab>)
  (define-key helm-map (kbd "<tab>") 'helm-execute-persistent-action)
  (helm-autoresize-mode 1) ;; Awesome feature together with helm-split-window-inside-p != nil
)

(use-package helm-swoop
  :ensure t
  :bind
    ("C-s" . helm-swoop)
  :config
    ;; "C-s" + "C-s" results in mult-swoop
    (define-key helm-swoop-map (kbd "C-s") 'helm-multi-swoop-all-from-helm-swoop)
    ;; split window inside the current window when multiple windows open
    (setq helm-swoop-split-with-multiple-windows t)
)

;; (require 'helm-config)
;; ;; (define-key helm-find-files-map (kbd "C-b") 'helm-find-files-up-one-level)
;; ;; (define-key helm-find-files-map (kbd "C-f") 'helm-execute-persistent-action)
;;
;; make TAB work in terminal/minibuffer
(define-key helm-map (kbd "C-i") 'helm-execute-persistent-action)
;; remap helm-select-action: lists actions
(define-key helm-map (kbd "C-z")  'helm-select-action)

;; remap calculator
;; (global-set-key (kbd "C-c C-c") 'helm-calcul-expression)

;; TODO: experiment with mark ring   (breadcrumbs something?)
;; TODO: experiment with helm-regexp (build and test regexes)
;; TODO: remember helm-top (helm interface for top program)

Helm-gtags

(use-package helm-gtags
  :ensure t
  :bind
    ( "M-." . helm-gtags-find-tag-from-here)
    ( "M-," . helm-gtags-pop-stack)
    ( "C-c f" . helm-gtags-find-files)
    ( "C-c p" . helm-gtags-parse-file)
  :config
    (add-hook 'c-mode-hook 'helm-gtags-mode)
    (add-hook 'c++-mode-hook 'helm-gtags-mode)
    (add-hook 'python-mode-hook 'helm-gtags-mode)
    (add-hook 'java-mode-hook 'helm-gtags-mode)
    (add-hook 'asm-mode-hook 'helm-gtags-mode)

    (custom-set-variables '(helm-gtags-auto-update t))
)

Mutliple cursors

https://github.com/magnars/multiple-cursors.el

(use-package multiple-cursors
  :ensure t
  :bind
    ("C-x r a" . mc/edit-lines)
    ("C-x r e" . mc/edit-ends-of-lines)
    ("C->" . mc/mark-next-like-this)
    ("C-<" . mc/mark-previous-like-this)
    ("C-c C->" . mc/mark-all-like-this)
)

GDB

TODO: need to document this

(setq gdb-many-windows 1)

;; Select a register number which is unlikely to get used elsewere
(defconst egdbe-windows-config-register 313465989
  "Internal used")

(defvar egdbe-windows-config nil)

(defun set-egdbe-windows-config ()
  (interactive)
  (setq egdbe-windows-config (window-configuration-to-register egdbe-windows-config-register)))

(defun egdbe-restore-windows-config ()
  (interactive)
  (jump-to-register egdbe-windows-config-register))

(defun egdbe-start-gdb (&optional gdb-args)
  ""
  (interactive)
  (set-egdbe-windows-config)
  (call-interactively 'gdb))

(defun egdbe-quit ()
  "finish."
  (interactive)
  (gud-basic-call "quit")
  (egdbe-restore-windows-config))

(defun egdbe-gud-mode-hook ()
  ""
  (local-unset-key (kbd "q"))
  (local-set-key (kbd "q") 'egdbe-quit))

(add-hook 'gud-mode-hook 'egdbe-gud-mode-hook)

Magit

(use-package magit
  :ensure t
  :bind
    ("C-c m" . magit-status)
)

Programming

Yasnippet

Template system for Emacs.

https://github.com/joaotavora/yasnippet

(use-package yasnippet
  :ensure t
  :init
    (add-to-list 'load-path
              "~/.emacs.d/plugins/yasnippet")
  :config
    (add-hook 'prog-mode-hook 'yas-minor-mode)
)

Flycheck

On-the-fly syntax checking.

(use-package flycheck
  :ensure t
  :config
    (add-hook 'prog-mode-hook 'flycheck-mode)
)

Company mode

(use-package company
  :ensure t
  :config
    (setq company-idle-delay 0)
    (setq company-minimum-prefix-length 2))
    (add-hook 'prog-mode-hook 'company-mode)

(Relative) Line numbers

(use-package linum-relative
  :ensure t
  :config
    (setq linum-relative-current-symbol "")
    (add-hook 'prog-mode-hook 'linum-relative-mode))

C/C++ mode

Flycheck

Clang static analyzer with flycheck

https://github.com/alexmurray/flycheck-clang-analyzer https://github.com/Sarcasm/flycheck-irony

(use-package flycheck-clang-analyzer
  :ensure t
  :config
  (with-eval-after-load 'flycheck
    (require 'flycheck-clang-analyzer)
     (flycheck-clang-analyzer-setup)))

(use-package flycheck-irony
  :ensure t
  :config
    (eval-after-load 'flycheck
      '(add-hook 'flycheck-mode-hook #'flycheck-irony-setup))
)

Company

https://github.com/ikirill/irony-eldoc

(use-package company-c-headers
  :ensure t)

(use-package company-irony
  :ensure t
  :config
  (setq company-backends '((company-c-headers
;;                            company-dabbrev-code ;; not sure what this is
                            company-irony))))

(use-package irony
  :ensure t
  :config
    (add-hook 'irony-mode-hook 'irony-cdb-autosetup-compile-options)
    (add-hook 'c++-mode-hook 'irony-mode)
    (add-hook 'c-mode-hook 'irony-mode)
    (add-hook 'objc-mode-hook 'irony-mode)
)

(use-package irony-eldoc
  :ensure t
  :config
    (add-hook 'irony-mode-hook 'irony-eldoc)
)

Python mode

Use elpy: https://github.com/jorgenschaefer/elpy

It is a full dev env and sometimes feels like a bit too much but overal good experience.

(use-package elpy
  :ensure t
  :config
    (elpy-enable)
)

Windows

Splitting

After you split a window, your focus remains in the previous one. Credit goes to https://github.com/daedreth/UncleDavesEmacs

(defun split-and-follow-horizontally ()
  (interactive)
  (split-window-below)
  (balance-windows)
  (other-window 1))
(global-set-key (kbd "C-x 2") 'split-and-follow-horizontally)

(defun split-and-follow-vertically ()
  (interactive)
  (split-window-right)
  (balance-windows)
  (other-window 1))
(global-set-key (kbd "C-x 3") 'split-and-follow-vertically)

Switching

https://github.com/dimitri/switch-window

(use-package switch-window
  :ensure t
  :config
    (setq switch-window-input-style 'minibuffer)
    (setq switch-window-increase 6)
    (setq switch-window-threshold 2)
    (setq switch-window-shortcut-style 'qwerty)
    (setq switch-window-qwerty-shortcuts
        '("a" "s" "d" "f" "j" "k" "l" "i" "o"))
;;    (setq switch-window-multiple-frames t) ;; TODO: doesn't work properly..
  :bind
    ("C-x o" . switch-window))

When using exwm, have a look at this: https://github.com/dimitri/switch-window/pull/62

Multi-frame rebindings (obsolete with switch-window)

Sometimes I have multiple emacs-frames open. In the past, I preferred that the normal C-x o can deal with this but this is used by switch-window now.

;; Use C-x o to switch to other frame when using multi-monitor
;; (global-set-key (kbd "C-x o") 'next-multiframe-window)

Now that next-multiframe-window is bound to C-x o, Bind C-x p to previous-multiframe-window.

;; (global-set-key (kbd "\C-x p") 'previous-multiframe-window)

Avy

https://github.com/abo-abo/avy

(use-package avy
  :ensure t
  :bind
    ("M-s" . avy-goto-char))

Convenience stuff

Visiting the configuration

(defun config-visit ()
  (interactive)
  (find-file "~/.emacs.d/config.org"))
(global-set-key (kbd "C-c e") 'config-visit)

Reload the configuration

(defun config-reload ()
  "Reloads ~/.emacs.d/config.org at runtime"
  (interactive)
  (org-babel-load-file (expand-file-name "~/.emacs.d/config.org")))
(global-set-key (kbd "C-c r") 'config-reload)

Subword

(global-subword-mode 1)

Bell

The audible bell is annoying AF.

(setq visible-bell 1)

Server

Emacs as a server. Emacsclient will then use this emacs as its server.

(server-start)

Beacon

https://github.com/Malabarba/beacon

(use-package beacon
  :ensure t
  :config
    (beacon-mode 1)
    (setq beacon-color "#FFFFCC") ;; yelowish
)

Sunrise commander

https://github.com/escherdragon/sunrise-commander

Install

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

(require 'sunrise-commander)
(require 'sunrise-x-buttons)
(require 'sunrise-x-modeline)

(global-set-key (kbd "C-c s") 'sunrise)
(global-set-key (kbd "C-c c") 'sunrise-cd)

(add-to-list 'auto-mode-alist '("\\.srvm\\'" . sr-virtual-mode))

Org

Org bullets

https://github.com/sabof/org-bullets

(use-package org-bullets
  :ensure t
  :config
    (add-hook 'org-mode-hook (lambda () (org-bullets-mode))))

Some basic config

Super/Sub-scripts

Use {} for subscripting:

https://orgmode.org/manual/Subscripts-and-superscripts.html

(setq org-use-sub-superscripts '{})

Indentation

Preserve indentation in SRC blocks

(setq org-src-preserve-indentation t)

Runnable languages

(org-babel-do-load-languages
 'org-babel-load-languages '(
                             (ditaa . t))
 )

Dita

Tell org where to look for ditaa

(setq org-ditaa-jar-path "/usr/share/java/ditaa/ditaa-0_10.jar")

Note config

;; when ending TODO (C-C C-t) end with a note + timestamp
(setq org-log-done 'note)
;; Add extra states for keywords
(setq org-todo-keywords
      '((sequence "TODO" "IN-PROGRESS" "WAITING" "DONE")))

Diminish

https://github.com/myrjola/diminish.el

(use-package diminish
  :ensure t
  :config
  (diminish 'volatile-highlights-mode)
  (diminish 'smartparens-mode)
  (diminish 'beacon-mode)
  (diminish 'subword-mode)
  (diminish 'auto-revert-mode)
  (diminish 'helm-mode)
  (diminish 'undo-tree-mode)
  (diminish 'page-break-lines-mode)
)

Shell-pop

https://github.com/kyagi/shell-pop-el

(use-package shell-pop
  :ensure t
  :bind (("C-c t" . shell-pop))
  :config
  (setq shell-pop-shell-type (quote ("eshell" "*eshell*" (lambda nil (eshell shell-pop-term-shell)))))
  (setq shell-pop-term-shell "/bin/zsh")
  ;; need to do this manually or not picked up by `shell-pop'
  (shell-pop--set-shell-type 'shell-pop-shell-type shell-pop-shell-type))

Old stuff, maybe usefull for lookup later

Diff mode stuff

;; show whitespace in diff-mode
;; (add-hook 'diff-mode-hook (lambda ()
;;                             (setq-local whitespace-style
;;                                         '(face
;;                                           tabs
;;                                           tab-mark
;;                                           spaces
;;                                           space-mark
;;                                           trailing
;;                                           indentation::space
;;                                           indentation::tab
;;                                           newline
;;                                           newline-mark))
;;                             (whitespace-mode 1)))

Speedbar

;; Package: sr-speedbar
;;(require 'sr-speedbar)
;; (add-hook 'emacs-startup-hook (lambda () ; Open sr speedbar on startup
;; 								(sr-speedbar-open)
;; 								))
;; (setq speedbar-show-unknown-files t) ; Enable speedbar to show all files
;; (setq speedbar-use-images nil) ; use text for buttons
;; (setq sr-speedbar-right-side nil) ; put on left side
;; (setq sr-speedbar-width 40)
;;
;; (provide 'setup-speedbar)

TODO

stuff i need to look into:

• ibuffer
• switch-window
• symon
• spaceline
• async
• exwm
• helm-hide-minibuffer