my-emacs-d/configuration.org

* Emacs configuration

** Configure ~use-package~

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

  (setq use-package-always-ensure t
        use-package-verbose t)

  (require 'use-package)
#+END_SRC

** Set up my personal keymap

I set it up early so I can use it in ~use-package~ calls immediately.

#+BEGIN_SRC emacs-lisp
(defvar gpolonkai/pers-map (make-sparse-keymap)
  "My own, personal, keymap!")
(define-prefix-command 'gpolonkai/pers-map)
(define-key ctl-x-map "t" 'gpolonkai/pers-map)
#+END_SRC

** I really don’t want to type more than I really must…

#+BEGIN_SRC emacs-lisp
(defalias 'yes-or-no-p 'y-or-n-p)
#+END_SRC
* Set personal information

** Who am I?   Where am I?

#+BEGIN_SRC emacs-lisp
(setq user-full-name "Gergely Polonkai"
      user-mail-address "gergely@polonkai.eu"
      calendar-latitude 47.4
      calendar-longitude 19.0
      calendar-location-name "Budapest, Hungary")
#+END_SRC

* Add ~lisp/~ to ~load-path~

#+BEGIN_SRC emacs-lisp
(add-to-list 'load-path (expand-file-name
                         (convert-standard-filename "lisp/")
                         user-emacs-directory))
#+END_SRC

* Custom commands and functions

** Misc text manipulation functions

*** Delete the current line

#+BEGIN_SRC emacs-lisp
(defun gpolonkai/delete-current-line ()
  "Kill the whole line on which point is."
  (interactive)

  (beginning-of-line)
  (kill-line 1))
#+END_SRC

*** Duplicate current line

#+BEGIN_SRC emacs-lisp
(defun gpolonkai/duplicate-line()
  "Duplicate line at point."

  (interactive)

  (save-excursion
    (move-beginning-of-line 1)
    (kill-line)
    (yank)
    (open-line 1)
    (forward-line 1)
    (yank)))
#+END_SRC

*** Toggle case of character at point

Based on [[http://ergoemacs.org/emacs/modernization_upcase-word.html][Xah’s toggle letter case defun version 2015-12-22]]

#+BEGIN_SRC emacs-lisp
(defun toggle-char-case (arg-move-point)
  "Toggle the case of the char after point.

If prefix argument ARG-MOVE-POINT is non-nil, move point after the char."
  (interactive "P")
  (let ((case-fold-search nil))
    (cond
     ((looking-at "[[:lower:]]") (upcase-region (point) (1+ (point))))
     ((looking-at "[[:upper:]]") (downcase-region (point) (1+ (point)))))
    (cond
     (arg-move-point (right-char)))))
#+END_SRC

*** Open a new line below

Copied from http://whattheemacsd.com/editing-defuns.el-01.html

#+BEGIN_SRC emacs-lisp
(defun open-line-below ()
  "Open a new line below point."

  (interactive)

  (end-of-line)
  (newline)
  (indent-for-tab-command))
#+END_SRC

*** Open a new line above

#+BEGIN_SRC emacs-lisp
(defun open-line-above ()
  "Open a new line above point."

  (interactive)

  (beginning-of-line)
  (newline)
  (forward-line -1)
  (indent-for-tab-command))
#+END_SRC

*** TODO Kill or copy the whole line

Got from Xah’s site (TODO is for adding a link here.)

#+BEGIN_SRC emacs-lisp
(defun æ-kill-or-copy-whole-line (kill)
  "Kill or copy the whole line point is on.

If KILL is non-nil, the line gets killed.  Otherwise, it gets just
copied to the kill ring."
  (interactive "P")

  (if kill
      (kill-whole-line)
    (let ((beginning (progn (beginning-of-line) (point)))
          (end (progn (end-of-line) (point))))
      (copy-region-as-kill beginning end))))
#+END_SRC

** Navigation

*** Move to different beginnings of the current line

Inspired by Bozhidar Batsov's [[http://emacsredux.com/blog/2013/05/22/smarter-navigation-to-the-beginning-of-a-line/][solution]].

#+BEGIN_SRC emacs-lisp
(defun gpolonkai/move-to-beginning-of-line ()
  "Move to different beginnings of the line.

These are, in order:

- beginning of the visual line if `visual-line-mode' is active,
- the first non-whitespace (indentation),
- the actual beginning of the line.

This function will jump between the first character and the
indentation if used multiple times."
  (interactive)
  (let ((last-pos (point)))
    (when visual-line-mode
      (beginning-of-visual-line))
    (when (= (point) last-pos)
      (back-to-indentation))
    (when (= (point) last-pos)
      (beginning-of-line))
    (when (and (eq major-mode 'org-mode)
               (= (point) last-pos))
      (org-beginning-of-line))
    (when (= (point) last-pos)
      (back-to-indentation))))
#+END_SRC

*** Move to the different ends of the current line

#+BEGIN_SRC emacs-lisp
(defun gpolonkai/move-to-end-of-line ()
  "Move to the end of the line.

If `visual-line-mode' is active, jump to the end of the visual
line first.  Then jump to the actual end of the line."
  (interactive)
  (let ((last-pos (point)))
    (when visual-line-mode
      (end-of-visual-line))
    (when (= (point) last-pos)
      (end-of-line))
    (when (and (eq major-mode 'org-mode)
               (= (point) last-pos))
      (org-end-of-line))))
#+END_SRC

** File manipulation

*** Rename the current file

Copied from http://whattheemacsd.com/file-defuns.el-01.html

#+BEGIN_SRC emacs-lisp
(defun rename-current-buffer-file ()
  "Renames current buffer and file it is visiting."
  (interactive)

  (let ((name (buffer-name))
        (filename (buffer-file-name)))
    (if (not (and filename (file-exists-p filename)))
        (error "Buffer '%s' is not visiting a file!" name)
      (let ((new-name (read-file-name "New name: " filename)))
        (if (get-buffer new-name)
            (error "A buffer named '%s' already exists!" new-name)
          (rename-file filename new-name 1)
          (rename-buffer new-name)
          (set-visited-file-name new-name)
          ; TODO: this is suspicious for me…
          (set-buffer-modified-p nil)
          (message "File '%s' successfully renamed to '%s'"
                   name (file-name-nondirectory new-name)))))))
#+END_SRC

*** Delete the current file

Copied from http://whattheemacsd.com/file-defuns.el-02.html

#+BEGIN_SRC emacs-lisp
(defun delete-current-buffer-file ()
  "Remove file connected to current buffer and kill the buffer."
  (interactive)

  (let ((filename (buffer-file-name))
        (name (buffer-name))
        (buffer (current-buffer)))
    (if (not (and filename (file-exists-p filename)))
        (kill-buffer buffer)
      (when (yes-or-no-p "Are you sure you want to remove this file? ")
        (delete-file filename)
        (kill-buffer buffer)
        (message "File '%s' successfully removed" filename)))))
#+END_SRC

*** Allow reopening the previously closed file

#+BEGIN_SRC emacs-lisp
(defvar gpolonkai/last-killed-buffer-file-name
  nil
  "The last killed buffer.

Used by `gpolonkai/kill-this-buffer' and `gpolonkai/undo-buffer-kill'.")

(defun gpolonkai/kill-this-buffer ()
  "Kill the current buffer, but save the buffer file name so it can be undone."
  (interactive)
  (setq gpolonkai/last-killed-buffer-file-name (buffer-file-name))
  (kill-this-buffer))

(defun gpolonkai/undo-buffer-kill ()
  "Undo killing the last buffer.

Esentially it visits the file again."
  (interactive)
  (if gpolonkai/last-killed-buffer-file-name
      (progn
        (find-file gpolonkai/last-killed-buffer-file-name)
        (setq gpolonkai/last-killed-buffer-file-name nil))
    (message "The buffer last killed didn’t visit a file.")))
#+END_SRC
** ~c-mode~ related

*** Copy the prototype of the current function

#+BEGIN_SRC emacs-lisp
(defun gpolonkai/copy-func-prototype ()
  "Copy the current function's prototype to the kill ring."

  (interactive)

  (save-excursion
    (beginning-of-defun)
    (let ((protocopy-begin (point)))
      (forward-list)
      (let ((protocopy-end (point)))
        (kill-ring-save protocopy-begin protocopy-end)))))
#+END_SRC

** EShell related

*** Delete a character, or close ~eshell~ if nothing to delet

Copied from https://ryuslash.org/posts/C-d-to-close-eshell.html

#+BEGIN_SRC emacs-lisp
(defun eshell-C-d ()
  "Either call `delete-char' interactively or quit."
  (interactive)

  (condition-case err
      (call-interactively #'delete-char)
    (error (if (and (eq (car err) 'end-of-buffer)
                    (looking-back eshell-prompt-regexp nil))
               (kill-buffer)
             (signal (car err) (cdr err))))))
#+END_SRC

* UI preferences

** Tweak window chrome

Turn off the scroll bar (that’s why Nyan-cat is here), the toolbar (I don’t really use it), and
the menu bar (I rarely use it, and in those rare occasions I can simply turn it on.)

Also, maximise the frame.

#+BEGIN_SRC emacs-lisp
(tool-bar-mode 0)
(menu-bar-mode 0)
(when window-system
  (scroll-bar-mode -1))

(set-frame-parameter nil 'fullscreen 'maximized)
#+END_SRC

** Set the default font and configure font resizing

#+BEGIN_SRC emacs-lisp
(set-face-attribute 'default t :font "Hack-10")
(set-frame-font "Hack-10" nil t)
#+END_SRC

* Set up global minor modes provided by Emacs

** Pretty lambdas

Because we can.

#+BEGIN_SRC emacs-lisp
(global-prettify-symbols-mode t)
#+END_SRC

* ~use-package~ packages

** Highlight the current line

#+BEGIN_SRC emacs-lisp
(use-package hl-line
  :config
  (when window-system
    (global-hl-line-mode)))
#+END_SRC

** Hide certain modes from the mode line

#+BEGIN_SRC emacs-lisp
(use-package diminish
  :defer t)
#+END_SRC