christar’s emacs config

Startup

define platform

Define the variable for each platform

(defun mac-p ()
    (eq system-type 'darwin))
(defun linux-p ()
    (eq system-type 'gnu/linux))
(defun win-p ()
    (eq system-type 'windows-nt))

startup config

Hide Scrollbar on Windows Hide Toolbar on Windows Hide ^M on Windows

Remove Welcome Screen Remove Beep on Windows Hide Menu Bar Set Encoding from Windows style(CRLF) to Unix style(LF)

(when (win-p)
    (tool-bar-mode -1)
    (scroll-bar-mode -1)
    (blink-cursor-mode 0))
(setq inhibit-startup-screen t)
(setq visible-bell 1)
(menu-bar-mode -1)
(prefer-coding-system 'utf-8-unix)
(modify-coding-system-alist 'file "\\.bat\\'" 'utf-8-dos)

emacs server

(require 'server)
(if (eq system-type 'windows-nt)
    (or (server-running-p)
        (server-start)))

load custom settings

e.g. Work Proxy Server

(setq custom-file "~/.emacs.d/custom-settings.el")
(load custom-file t)

ELPA repo

GnuTLS manually installed by installing deps package from Emacs FTP server

(require 'package)
(setq package-enable-at-startup nil)
(add-to-list 'package-archives '("melpa" . "http://melpa.org/packages/"))
(package-initialize)
;(unless package-archive-contents
;  (package-refresh-contents))

use-package

There is a debate between using package.el and use-package.el Should look into that later

CHECKME -> bug installing diminish package

(unless (package-installed-p 'use-package)
    (package-refresh-contents)
    (package-install 'use-package))
(eval-when-compile
    (setq use-package-verbose t)
    (setq use-package-always-ensure t)
    (require 'use-package))
(use-package diminish)

(use-package auto-compile
    :config
    (auto-compile-on-load-mode)
    (auto-compile-on-save-mode)
    (setq auto-compile-display-buffer               nil)
    (setq auto-compile-mode-line-counter            t)
    (setq auto-compile-source-recreate-deletes-dest t)
    (setq auto-compile-toggle-deletes-nonlib-dest   t)
    (setq auto-compile-update-autoloads             t))
(setq load-prefer-newer t)

compress byte compile warnings

(setq warning-minimum-level :error)

(setq byte-compile-warnings nil
    gnutls-min-prime-bits 4096)

keep auto backup files

File of the same name but with a tilda ~ at the end

(setq backup-directory-alist '(("." . "~/.emacs.d/backup/"))
    backup-by-copying t    ; Don't delink hardlinks
    version-control t      ; Use version numbers on backups
    delete-old-versions t  ; Automatically delete excess backups
    kept-new-versions 20   ; how many of the newest versions to keep
    kept-old-versions 5    ; and how many of the old
    )

keep auto save files

File of the same name but with # at both sides

(setq auto-save-default t)
(setq auto-save-file-name-transforms '((".*" "~/.emacs.d/backup/" t)))

UI

which-key

display available shortkeys in minibuffer popup

(use-package which-key
    :defer 15
    :diminish which-key-mode
    :config (which-key-mode))

theme

(use-package spacemacs-common
    :ensure spacemacs-theme
    :if window-system
    :config
    (load-theme 'spacemacs-dark t)
    (set-face-attribute 'default nil :font "Consolas-10"))

enable Y/N answer

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

ivy

use ivy fuzzy search (except in swiper) and flx package for better sorting

(use-package flx)
(use-package ivy
    :defer 5
    :config
    (progn
        (ivy-mode 1)
        (setq ivy-use-virtual-buffers t)
        (setq ivy-re-builders-alist
            '((swiper . ivy--regex-plus)
              (t . ivy--regex-fuzzy)))
        (setq ivy-initial-inputs-alist nil)
        (setq enable-recursive-minibuffers t)))

swiper

bind search hotkey to swiper

(use-package swiper
    :defer t
    :bind ("C-s" . swiper))

counsel

(use-package counsel
    :defer 5
    :bind
    (("C-x C-f" . counsel-find-file)
     ("C-h b" . counsel-descbinds)
     ("C-h f" . counsel-describe-function)
     ("C-h v" . counsel-describe-variable)
     ("M-x" . counsel-M-x)))

customize modeline

understand what all areas stand for

(column-number-mode t)

split window with different buffers

(defun hsplit-last-buffer()
    (interactive)
    (split-window-below)
    (other-window 1 nil)
    (switch-to-next-buffer))
(global-set-key (kbd "C-x 2") 'hsplit-last-buffer)
(defun vsplit-last-buffer()
    (interactive)
    (split-window-right)
    (other-window 1 nil)
    (switch-to-next-buffer))
(global-set-key (kbd "C-x 3") 'vsplit-last-buffer)

Editor

FAIL curson position highlighting

(use-package beacon
    :defer t
    :config (beacon-mode 1))

move cursor line by line

(setq scroll-preserve-screen-position 1)
(global-set-key (kbd "M-n") (kbd "C-u 1 C-v"))
(global-set-key (kbd "M-p") (kbd "C-u 1 M-v"))

parentheses

There is smartparens mode worth noting.

(show-paren-mode 1)
(setq show-paren-delay 0)
(electric-pair-mode 1)

page break line

(use-package page-break-lines
    :diminish page-break-lines-mode
    :config (global-page-break-lines-mode 1))

trailing space

auto remove on save

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

toggle (multiple) line comment

global keybind will be shadowed by local mode keymap

(defun comment-or-uncomment-region-or-line ()
  (interactive)
  (let ((start (line-beginning-position))
        (end (line-end-position)))
    (when (or (not transient-mark-mode) (region-active-p))
      (setq start (save-excursion
                    (goto-char (region-beginning))
                    (beginning-of-line)
                    (point))
            end (save-excursion
                  (goto-char (region-end))
                  (end-of-line)
                  (point))))
    (comment-or-uncomment-region start end)))
(add-hook 'c-mode-hook (lambda () (setq comment-start "//"
                                        comment-end   "")))
(defun my-c-mode-keybind ()
    (local-set-key (kbd "M-;") 'comment-or-uncomment-region-or-line))
(add-hook 'c-mode-hook 'my-c-mode-keybind)
;;(global-set-key (kbd "C-c c") 'comment-or-uncomment-region-or-line)

undo-tree

(use-package undo-tree
    :diminish undo-tree-mode
    :defer t
    :bind ("C-x u" . undo-tree-visualize)
    :config (global-undo-tree-mode))

flyspell

prelude-like C-a behavior

first press to the non-whitespace char of a line and then to beginning shadowed by org-beginning-of-line in org-mode

(defun smarter-move-beginning-of-line (arg)
  (interactive "^p")
  (setq arg (or arg 1))

  ;; Move lines first
  (when (/= arg 1)
    (let ((line-move-visual nil))
      (forward-line (1- arg))))

  (let ((orig-point (point)))
    (back-to-indentation)
    (when (= orig-point (point))
      (move-beginning-of-line 1))))

(global-set-key [remap move-beginning-of-line]
                'smarter-move-beginning-of-line)

global auto revert mode

(global-auto-revert-mode t)

highlight current symbol

(use-package highlight-symbol
    :defer 10
    :config
    (global-set-key [(control f3)] 'highlight-symbol-next)
    (global-set-key [f3] 'highlight-symbol)
    (global-set-key [(shift f3)] 'highlight-symbol-prev)
    (global-set-key [(meta f3)] 'highlight-symbol-query-replace))

File Management

dired

(setq dired-recursive-deletes 'always)
(setq dired-recursive-copies 'always)

WIP !!! jump to any file in a deep folder structure

projectile

remember last cursor position in dired & file

someone had recentf-mode is activated, so this function is enabled. just need to gitignore the recentf file in the .emacs.d folder

NeoTree

(use-package neotree
    :config
    (global-set-key [f8] 'neotree-toggle)
    (setq neo-theme 'ascii
          neo-window-fixed-size nil
          neo-window-width 30
          neo-modern-sidebar t
          neo-smart-open t)
    (eval-after-load "neotree"
    '(add-to-list 'window-size-change-functions
                  (lambda (frame)
                    (let ((neo-window (neo-global--get-window)))
                      (unless (null neo-window)
                        (setq neo-window-width (window-width neo-window)))))))
    )

Programming

special type syntax highlighting

(add-to-list 'auto-mode-alist '("\\.can\\'" . c-mode))
(add-to-list 'auto-mode-alist '("\\.cin\\'" . c-mode))
(add-to-list 'auto-mode-alist '("\\.mak\\'" . makefile-mode))

flycheck

WIP yasnippet

(use-package yasnippet-snippets)
(use-package yasnippet
    :commands (yas-minor-mode)
    :init
    (progn (add-hook 'prog-mode-hook #'yas-minor-mode))
    :defer 15
    :config
    (yas-reload-all))

indentation

disable tab to indent globally

(setq-default indent-tabs-mode nil)
(setq-default tab-width 4) ; default is 8
(defvaralias 'c-basic-offset 'tab-width)
(setq c-default-style "linux")
(c-set-offset 'case-label '+)

WIP company + clang

if/for statement auto completion

possible sublime-like fuzzy completion need to input no candidate words input ignore casing

(use-package company
    :defer 10
    :init (add-hook 'after-init-hook 'global-company-mode)
    :config
    (use-package company-irony 
        :defer t)
    (setq company-idle-delay            0
	    company-minimum-prefix-length   2
	    company-show-numbers            t
	    company-tooltip-limit           20
	    company-dabbrev-downcase        nil)
	    ;company-backends                '((company-irony company-gtags)))
    :bind ("C-;" . company-complete-common))

(use-package irony
    :defer t
    :init
    (add-hook 'c-mode-hook 'irony-mode)
    :config
    (when (win-p)
        (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))))
    ;; replace the `completion-at-point' and `complete-symbol' bindings in
    ;; irony-mode's buffers by irony-mode's function
    (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))

multiple line editing

(use-package multiple-cursors
    :defer 5
    :config
    (global-set-key (kbd "C-S-c C-S-c") 'mc/edit-lines))

source code indexing/navigation

(use-package helm-gtags
    :defer t
    :hook cc-mode
    :bind
    (("C-j" . helm-gtags-select)
     ("M-." . helm-gtags-dwim)
     ("M-," . helm-gtags-pop-stack)
     ("C-c <" . helm-gtags-previous-history)
     ("C-c >" . helm-gtags-next-history))
    :config
    (helm-gtags-mode 1)
    (setq
         helm-gtags-ignore-case t
         helm-gtags-auto-update t
         helm-gtags-use-input-at-cursor t
         helm-gtags-pulse-at-cursor t
         helm-gtags-prefix-key "\C-cg"
         helm-gtags-suggested-key-mapping t))

function arguments hinting

GNU global + helm-gtags

prefix + shortkey

add project path (multiple folders)

run build.bat from minibuffer

build.bat is to be created

WIP helm

helm-ag for searching helm window in split windows

(use-package helm
    :config
    (setq helm-split-window-in-side-p t))

Org mode

add org agenda path to custom settings

this one is system-specific and should be defined in the custom settings

(setq org-agenda-files '("~/org"))

use org-indent-mode

(setq org-startup-indented t)

add workflow states with hotkeys

(setq org-todo-keywords
    '((sequence "TODO" "WIP" "|" "DONE(d)")))
(setq org-todo-keyword-faces
      '(("TODO" . "red")))
(setq org-todo-keyword-faces
      '(("WIP" . "blue")))
;(setq org-todo-keyword-faces
;      '(("HOLD" . "red")))

close TODO tasks with timestamp

add file-specific settings: ” #+STARTUP: overview logdone ”

no newline before new heading

without the added newline on top

(setf org-blank-before-new-entry '((heading . nil) (plain-list-item . nil)) )

open files with external app

(add-hook 'org-mode-hook
    '(lambda ()
        (setq org-file-apps
            (append '(
                      ("\\.png\\'" . default)
                      ("\\.doc[x]?\\'" . default)
                      ("\\.xls[x]?\\'" . default)
                      ("\\.ppt[x]?\\'" . default)
                      ) org-file-apps ))))

org-agenda

(add-hook 'org-mode-hook
    '(lambda ()
        (local-set-key (kbd "C-c a") 'org-agenda)))
(setq org-agenda-skip-scheduled-if-done 1)

Notes

emacs lisp

this is a thing for elisp learning: “;; -*- lexical-binding: t -*-”