* Pre-init

** Add my own, version controlled ~lisp~ directory to ~load-path~

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

** Do the same with the local ~site-lisp~ if it’s there

#+begin_src emacs-lisp
(let ((site-lisp-dir "/usr/local/share/emacs/site-lisp"))
  (when (file-directory-p site-lisp-dir)
    (dolist (elt (directory-files site-lisp-dir))
      (unless (or (string= elt ".") (string= elt ".."))
        (add-to-list 'load-path (expand-file-name elt site-lisp-dir))))))
#+end_src

** Load ~xdg-paths~

I prefer using freedesktop’s desktop specification everywhere.

#+begin_src emacs-lisp
(load "xdg-paths")
#+end_src

* Set up the package manager

I’m a ~package.el~ user.  Don’t package-shame me!

** Set up the package archives

#+begin_src emacs-lisp
(require 'package)
(add-to-list 'package-archives
             '("gnu" . "https://elpa.gnu.org/packages/"))
(add-to-list 'package-archives
             '("melpa-stable" . "https://stable.melpa.org/packages/") t)
(add-to-list 'package-archives
             '("melpa" . "https://melpa.org/packages/") t)
(add-to-list 'package-archives
             '("org" . "https://orgmode.org/elpa/") t)
(package-initialize)
#+end_src

** Set up ~use-package~

It is built-in since 29.1, and let’s hope I never get back using older versions, but let’s stay on the safe side for now.

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

(require 'use-package)

(use-package use-package
  :custom
  (use-package-always-ensure t)
  (use-package-verbose nil))

(use-package bind-key)
#+end_src

*** Install Quelpa so we can add packages not present in MELPA yet

#+begin_src emacs-lisp
(unless (package-installed-p 'quelpa)
  (with-temp-buffer
    (url-insert-file-contents "https://raw.githubusercontent.com/quelpa/quelpa/master/quelpa.el")
    (eval-buffer)
    (quelpa-self-upgrade)))
#+end_src

*** Finally, combine the powers of use-package and quelpa

#+begin_src emacs-lisp
(quelpa
 '(quelpa-use-package
   :fetcher git
   :url "https://github.com/quelpa/quelpa-use-package.git"))
(require 'quelpa-use-package)
#+end_src

* Emacs configuration

** Set up the really basic things

#+begin_src emacs-lisp
(use-package emacs
  :ensure nil
  :init
  (defun crm-indicator (args)
    (cons (format "[CRM%s] %s"
                  (replace-regexp-in-string
                   "\\`\\[.*?]\\*\\|\\[.*?]\\*\\'" ""
                   crm-separator)
                  (car args))
          (cdr args)))
  (advice-add #'completing-read-multiple :filter-args #'crm-indicator)
  :custom
  (user-full-name "Gergely Polonkai")
  (user-mail-address "gergely@polonkai.eu")
  (kill-read-only-ok t)
  (use-dialog-box nil)
  (cursor-type 'bar)
  (echo-keystrokes .01)
  (fill-column 80)
  (initial-scratch-message "")
  (minibuffer-prompt-properties '(read-only t cursor-intangible t face minibuffer-prompt))
  (enable-recursive-minibuffers t)
  :hook
  (minibuffer-setup .  cursor-intangible-mode))
#+end_src

** Set up some default faces

#+begin_src emacs-lisp
(use-package faces
  :ensure nil
  :custom-face
  (default ((t (:family "Fira Code Retina" :foundry "simp" :slant normal :weight normal :height 110 :width normal))))
  (trailing-whitespace ((t (:inherit nil :background "red3")))))
#+end_src

** Use ligatures

#+begin_src emacs-lisp
(use-package ligature
  :config
  ;; Enable the "www" ligature in every possible major mode
  (ligature-set-ligatures 't '("www"))
  ;; Enable traditional ligature support in eww-mode, if the
  ;; `variable-pitch' face supports it
  (ligature-set-ligatures 'eww-mode '("ff" "fi" "ffi"))
  ;; Enable all Cascadia and Fira Code ligatures in programming modes
  (ligature-set-ligatures 'prog-mode
                          '(;; == === ==== => =| =>>=>=|=>==>> ==< =/=//=// =~
                            ;; =:= =!=
                            ("=" (rx (+ (or ">" "<" "|" "/" "~" ":" "!" "="))))
                            ;; ;; ;;;
                            (";" (rx (+ ";")))
                            ;; && &&&
                            ("&" (rx (+ "&")))
                            ;; !! !!! !. !: !!. != !== !~
                            ("!" (rx (+ (or "=" "!" "\." ":" "~"))))
                            ;; ?? ??? ?:  ?=  ?.
                            ("?" (rx (or ":" "=" "\." (+ "?"))))
                            ;; %% %%%
                            ("%" (rx (+ "%")))
                            ;; |> ||> |||> ||||> |] |} || ||| |-> ||-||
                            ;; |->>-||-<<-| |- |== ||=||
                            ;; |==>>==<<==<=>==//==/=!==:===>
                            ("|" (rx (+ (or ">" "<" "|" "/" ":" "!" "}" "\]"
                                            "-" "=" ))))
                            ;; \\ \\\ \/
                            ("\\" (rx (or "/" (+ "\\"))))
                            ;; ++ +++ ++++ +>
                            ("+" (rx (or ">" (+ "+"))))
                            ;; :: ::: :::: :> :< := :// ::=
                            (":" (rx (or ">" "<" "=" "//" ":=" (+ ":"))))
                            ;; // /// //// /\ /* /> /===:===!=//===>>==>==/
                            ("/" (rx (+ (or ">"  "<" "|" "/" "\\" "\*" ":" "!"
                                            "="))))
                            ;; .. ... .... .= .- .? ..= ..<
                            ("\." (rx (or "=" "-" "\?" "\.=" "\.<" (+ "\."))))
                            ;; -- --- ---- -~ -> ->> -| -|->-->>->--<<-|
                            ("-" (rx (+ (or ">" "<" "|" "~" "-"))))
                            ;; *> */ *)  ** *** ****
                            ("*" (rx (or ">" "/" ")" (+ "*"))))
                            ;; www wwww
                            ("w" (rx (+ "w")))
                            ;; <> <!-- <|> <: <~ <~> <~~ <+ <* <$ </  <+> <*>
                            ;; <$> </> <|  <||  <||| <|||| <- <-| <-<<-|-> <->>
                            ;; <<-> <= <=> <<==<<==>=|=>==/==//=!==:=>
                            ;; << <<< <<<<
                            ("<" (rx (+ (or "\+" "\*" "\$" "<" ">" ":" "~"  "!"
                                            "-"  "/" "|" "="))))
                            ;; >: >- >>- >--|-> >>-|-> >= >== >>== >=|=:=>>
                            ;; >> >>> >>>>
                            (">" (rx (+ (or ">" "<" "|" "/" ":" "=" "-"))))
                            ;; #: #= #! #( #? #[ #{ #_ #_( ## ### #####
                            ("#" (rx (or ":" "=" "!" "(" "\?" "\[" "{" "_(" "_"
                                         (+ "#"))))
                            ;; ~~ ~~~ ~=  ~-  ~@ ~> ~~>
                            ("~" (rx (or ">" "=" "-" "@" "~>" (+ "~"))))
                            ;; __ ___ ____ _|_ __|____|_
                            ("_" (rx (+ (or "_" "|"))))
                            ;; Fira code: 0xFF 0x12
                            ("0" (rx (and "x" (+ (in "A-F" "a-f" "0-9")))))
                            ;; Fira code:
                            "Fl"  "Tl"  "fi"  "fj"  "fl"  "ft"
                            ;; The few not covered by the regexps.
                            "{|"  "[|"  "]#"  "(*"  "}#"  "$>"  "^="))
  ;; Enables ligature checks globally in all buffers. You can also do it
  ;; per mode with `ligature-mode'.
  (global-ligature-mode t))
#+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)
(define-key global-map (kbd "C-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 UTF-8 as the default encoding

Just to make sure, although most Linux DEs do this for me.

#+BEGIN_SRC emacs-lisp
(set-language-environment "UTF-8")
(set-default-coding-systems 'utf-8)
#+END_SRC

** Set Org’s main directory

Since a lot of packages use it as their base (org-projectile, org-caldav, etc.), i need
it as early as possible.

#+BEGIN_SRC emacs-lisp
(setq org-directory (expand-file-name "NextCloud/orgmode" user-documents-directory))
#+END_SRC

** ~simple.el~ settings

#+begin_src emacs-lisp
(use-package simple
  :ensure nil
  :custom
  (column-number-mode t))
#+end_src

** Default frame settings

#+begin_src emacs-lisp
(use-package frame
  :ensure nil
  :custom
  (blink-cursor-mode t))
#+end_src

* Custom commands and functions

** Utility functions

*** Round number at point to the given decimals

#+BEGIN_SRC emacs-lisp
(defun round-number-at-point-to-decimals (decimal-count)
  (interactive "NDecimal count: ")
  (let ((mult (expt 10 decimal-count)))
    (replace-match (number-to-string
              (/
               (fround
                (*
                 mult
                 (number-at-point)))
                mult)))))
#+END_SRC

*** Make a backup filename under ~user-emacs-cache-directory~

Taken from [[http://ergoemacs.org/emacs/emacs_set_backup_into_a_directory.html][Xah’s site]].

#+BEGIN_SRC emacs-lisp
(defun xah/backup-file-name (fpath)
    "Return a new file path for FPATH under `user-emacs-cache-directory'"
    (let* ((backup-root-dir (expand-file-name "backup" user-emacs-cache-directory))
           (file-path (replace-regexp-in-string "[A-Za-z]:" "" fpath))
           (backup-file-path (replace-regexp-in-string "//" "/" (concat backup-root-dir file-path "~"))))
      (make-directory (file-name-directory backup-file-path) (file-name-directory backup-file-path))
      backup-file-path))
#+END_SRC

*** Find the first number on line

#+begin_src emacs-lisp
(defun gpolonkai/find-number-on-line ()
  "Find the first number on the current line."
  (save-excursion
    (without-restriction
      (goto-char (pos-bol))
      (when (re-search-forward "[0-9]+" (pos-eol) t)
        (number-at-point)))))
#+end_src

** Check if we are running under Termux

We need to do things differently, if so.

#+BEGIN_SRC emacs-lisp
(defun termux-p ()
  "Check if Emacs is running under Termux."
  (string-match-p
   (regexp-quote "/com.termux/")
   (expand-file-name "~")))
#+END_SRC

** Misc text manipulation functions

*** 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

*** Insert two spaces after specific characters

#+BEGIN_SRC emacs-lisp
(defun org-space-key (&optional arg)
  "Insert two spaces after a period.

ARG will be passed down verbatim to `self-insert-command'"
  (interactive "p")

  (when (looking-back "[.!?…]" nil)
    (call-interactively 'self-insert-command arg))
  (call-interactively 'self-insert-command arg))
#+END_SRC

*** Fill or unfill a paragraph
:PROPERTIES:
:SOURCE:   http://pages.sachachua.com/.emacs.d/Sacha.html
:END:

#+BEGIN_SRC emacs-lisp
(defun sachachua/fill-or-unfill-paragraph (&optional unfill region)
  "Fill (or unfill, if UNFILL is non-nil) paragraph (or REGION)."
  (interactive (progn
                 (barf-if-buffer-read-only)
                 (list (if current-prefix-arg 'unfill) t)))
  (let ((fill-column (if unfill (point-max) fill-column)))
    (fill-paragraph nil region)))
#+END_SRC

*** Swap occurences of strings
:PROPERTIES:
:SOURCE:   http://emacs.stackexchange.com/a/27170/507
:END:

#+BEGIN_SRC emacs-lisp
(defun so/query-swap-strings (from-string
                              to-string
                              &optional delimited start end)
  "Swap occurrences of FROM-STRING and TO-STRING.

DELIMITED, START, and END are passed down verbatim to `perform-replace'."
  (interactive
   (let ((common
          (query-replace-read-args
           (concat "Query swap"
                   (if current-prefix-arg
                       (if (eq current-prefix-arg '-) " backward" " word")
                     "")
                   (if (use-region-p) " in region" ""))
           nil)))
     (list (nth 0 common) (nth 1 common) (nth 2 common)
           (if (use-region-p) (region-beginning))
           (if (use-region-p) (region-end)))))
  (perform-replace
   (concat "\\(" (regexp-quote from-string) "\\)\\|" (regexp-quote to-string))
   `(replace-eval-replacement replace-quote
                              (if (match-string 1)
                                  ,to-string
                                ,from-string))
   t t delimited nil nil start end))
#+END_SRC

*** Insert the current file’s name at point
:PROPERTIES:
:SOURCE:   http://mbork.pl/2019-02-17_Inserting_the_current_file_name_at_point
:END:

#+BEGIN_SRC emacs-lisp
(defun insert-current-file-name-at-point (&optional full-path)
  "Insert the current filename at point.
With prefix argument, use full path."
  (interactive "P")
  (let* ((buffer
          (if (minibufferp)
              (window-buffer
               (minibuffer-selected-window))
            (current-buffer)))
         (filename (buffer-file-name buffer)))
    (if filename
        (insert (if full-path filename (file-name-nondirectory filename)))
      (error (format "Buffer %s is not visiting a file" (buffer-name buffer))))))
#+END_SRC

*** Sort lines by the first number on it

#+begin_src emacs-lisp
(defun gpolonkai/numeric-sort-lines (reverse beg end)
  "Sort lines in region by version.
Interactively, REVERSE is the prefix argument, and BEG and END are the region.
Non-nil REVERSE means to sort in reverse order."
  (interactive "P\nr")
  (save-excursion
    (save-restriction
      (narrow-to-region beg end)
      (goto-char (point-min))
      (let ((indibit-field-text-motion t))
        (sort-subr reverse 'forward-line 'end-of-line #'gpolonkai/find-number-on-line)))))
#+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

*** Move to the next occurence of a character within the same line

#+begin_src emacs-lisp
(defun goto-next-char (chr)
  (interactive "c")
  (let ((substr (char-to-string chr))
        (end (save-excursion (end-of-line) (point))))
    (when (search-forward substr end t)
      (backward-char))))
#+end_src

*** Move to the beginning of the next word

#+begin_src emacs-lisp
(defun gpolonkai/beginning-of-next-word ()
  (interactive)
  (let ((current-point (point)))
    (forward-word 1)
    (backward-word 1)

    (when (<= (point) current-point)
      (forward-word 2)
      (backward-word 1))))
#+end_src

** File manipulation

*** Rename the current file
:PROPERTIES:
:SOURCE:   http://whattheemacsd.com/file-defuns.el-01.html
:END:

#+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
:PROPERTIES:
:SOURCE:   http://whattheemacsd.com/file-defuns.el-02.html
:END:

#+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

** Frame manipulation

*** Hidden modeline mode
:PROPERTIES:
:SOURCE:   http://emacs-doctor.com/emacs-strip-tease.html
:END:

To temporarily hide the mode line.

#+BEGIN_SRC emacs-lisp
(defvar hidden-mode-line-mode nil)
(defvar hide-mode-line nil)

(define-minor-mode hidden-mode-line-mode
  "Minor mode to hide the mode-line in the current buffer."
  :init-value nil
  :global nil
  :variable hidden-mode-line-mode
  :group 'editing-basics
  (if hidden-mode-line-mode
      (setq hide-mode-line mode-line-format
            mode-line-format nil)
    (setq mode-line-format hide-mode-line
          hide-mode-line nil))
  (force-mode-line-update)
  (redraw-display)
  (when (and (called-interactively-p 'interactive)
             hidden-mode-line-mode)
    (run-with-idle-timer
     0 nil 'message
     (concat "Hidden Mode Line Mode enabled.  "
             "Use M-x hidden-mode-line-mode to make mode-line appear."))))
#+END_SRC

** Window manipulation

*** Transpose windows

#+BEGIN_SRC emacs-lisp
(defun transpose-windows (arg)
  "Transpose the buffers shown in two windows."
  (interactive "p")
  (let ((selector (if (>= arg 0) 'next-window 'previous-window)))
    (while (/= arg 0)
      (let ((this-win (window-buffer))
            (next-win (window-buffer (funcall selector))))
        (set-window-buffer (selected-window) next-win)
        (set-window-buffer (funcall selector) this-win)
        (select-window (funcall selector)))
      (setq arg (if (plusp arg) (1- arg) (1+ arg))))))
#+END_SRC

*** Toggle window split between horizontal and vertical

#+BEGIN_SRC emacs-lisp
(defun toggle-window-split ()
  (interactive)
  (if (= (count-windows) 2)
      (let* ((this-win-buffer (window-buffer))
             (next-win-buffer (window-buffer (next-window)))
             (this-win-edges (window-edges (selected-window)))
             (next-win-edges (window-edges (next-window)))
             (this-win-2nd (not (and (<= (car this-win-edges)
                                         (car next-win-edges))
                                     (<= (cadr this-win-edges)
                                         (cadr next-win-edges)))))
             (splitter
              (if (= (car this-win-edges)
                     (car (window-edges (next-window))))
                  'split-window-horizontally
                'split-window-vertically)))
        (delete-other-windows)
        (let ((first-win (selected-window)))
          (funcall splitter)
          (if this-win-2nd (other-window 1))
          (set-window-buffer (selected-window) this-win-buffer)
          (set-window-buffer (next-window) next-win-buffer)
          (select-window first-win)
          (if this-win-2nd (other-window 1))))
    (error "This works only for two windows!")))
#+END_SRC

*** Scroll up or down in a specific window

#+BEGIN_SRC emacs-lisp
(defun gpolonkai/scroll-window-up (window)
  "Scroll WINDOW up as `scroll-up-command' would."
  (interactive)
  (save-selected-window
    (select-window window)
    (scroll-up)))

(defun gpolonkai/scroll-window-down (window)
  "Scroll WINDOW down as `scroll-down-command' would."
  (interactive)
  (save-selected-window
    (select-window window)
    (scroll-down)))
#+END_SRC

*** Bury a window

#+BEGIN_SRC emacs-lisp
(defun gpolonkai/bury-window (window)
  "Quit WINDOW without killing it."
  (interactive)
  (quit-window nil window))
#+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

** Programming related

*** Add code references to Org documents
:PROPERTIES:
:SOURCE:   http://www.howardism.org/Technical/Emacs/capturing-content.html
:END:

#+BEGIN_SRC emacs-lisp
(defun ha/org-capture-fileref-snippet (f type headers func-name)
  (let* ((code-snippet
          (buffer-substring-no-properties (mark) (- (point) 1)))
         (file-name   (buffer-file-name))
         (file-base   (file-name-nondirectory file-name))
         (line-number (line-number-at-pos (region-beginning)))
         (initial-txt (if (null func-name)
                          (format "From [[file:%s::%s][%s]]:"
                                  file-name line-number file-base)
                        (format "From ~%s~ (in [[file:%s::%s][%s]]):"
                                func-name file-name line-number
                                file-base))))
    (format "
   %s

   ,#+BEGIN_%s %s
%s
   ,#+END_%s" initial-txt type headers code-snippet type)))

(defun ha/org-capture-clip-snippet (f)
  "Given a file, F, this captures the currently selected text
within an Org EXAMPLE block and a backlink to the file."
  (with-current-buffer (find-buffer-visiting f)
    (ha/org-capture-fileref-snippet f "EXAMPLE" "" nil)))

(defun ha/org-capture-code-snippet (f)
  "Given a file, F, this captures the currently selected text
within an Org SRC block with a language based on the current mode
and a backlink to the function and the file."
  (with-current-buffer (find-buffer-visiting f)
    (let ((org-src-mode (replace-regexp-in-string "-mode" "" (format "%s" major-mode)))
          (func-name (which-function)))
      (ha/org-capture-fileref-snippet f "SRC" org-src-mode func-name))))
#+END_SRC

** Utility functions for EDiff
:PROPERTIES:
:SOURCE:   http://article.gmane.org/gmane.emacs.orgmode/75222
:END:

EDiff and Org-mode files don’t play nice together…

#+BEGIN_SRC emacs-lisp
(defun f-ediff-org-showhide (buf command &rest cmdargs)
  "If buffer BUF exists and in `org-mode', execute COMMAND with CMDARGS."
  (when buf
    (when (eq (buffer-local-value 'major-mode (get-buffer buf)) 'org-mode)
      (save-excursion
        (set-buffer buf)
        (apply command cmdargs)))))

(defun f-ediff-org-unfold-tree-element ()
  "Unfold tree at diff location."
  (f-ediff-org-showhide ediff-buffer-A 'org-reveal)
  (f-ediff-org-showhide ediff-buffer-B 'org-reveal)
  (f-ediff-org-showhide ediff-buffer-C 'org-reveal))

(defun f-ediff-org-fold-tree ()
  "Fold tree back to top level."
  (f-ediff-org-showhide ediff-buffer-A 'hide-sublevels 1)
  (f-ediff-org-showhide ediff-buffer-B 'hide-sublevels 1)
  (f-ediff-org-showhide ediff-buffer-C 'hide-sublevels 1))
#+END_SRC

** Leave ~isearch~ at the other end of the matched string
:PROPERTIES:
:SOURCE:   http://endlessparentheses.com/leave-the-cursor-at-start-of-match-after-isearch.html
:END:

#+BEGIN_SRC emacs-lisp
(defun isearch-exit-other-end ()
  "Exit isearch, at the opposite end of the string."
  (interactive)

  (isearch-exit)
  (goto-char isearch-other-end))
#+END_SRC

** Mark the current match after leaving ~isearch~
:PROPERTIES:
:SOURCE:   http://emacs.stackexchange.com/a/31321/507
:END:

#+BEGIN_SRC emacs-lisp
(defun isearch-exit-mark-match ()
  "Exit isearch and mark the current match."
  (interactive)
  (isearch-exit)
  (push-mark isearch-other-end)
  (activate-mark))
#+END_SRC

** Org mode stuff

*** Filter out tasks from the Org agenda if they have a specific priority

The whole idea comes from [[https://blog.aaronbieber.com/2016/09/24/an-agenda-for-life-with-org-mode.html][here]], which i use almost verbatim.  This is also the reason it has the
~air-~ prefix.

#+begin_src emacs-lisp
(defun air-org-skip-subtree-if-priority (priority)
  "Skip an agenda subtree if it has a priority of PRIORITY.

PRIORITY may be one of the characters ?A, ?B, or ?C."
  (let ((subtree-end (save-excursion (org-end-of-subtree t)))
        (pri-value (* 1000 (- org-lowest-priority priority)))
        (pri-current (org-get-priority (thing-at-point 'line t))))
    (if (= pri-value pri-current)
        subtree-end
      nil)))
#+end_src

*** Filter out habits from the Org agenda

#+begin_src emacs-lisp
(defun air-org-skip-subtree-if-habit ()
  "Skip an agenda entry if it has a STYLE property equal to \"habit\"."
  (let ((subtree-end (save-excursion (org-end-of-subtree t))))
    (if (string= (org-entry-get nil "STYLE") "habit")
        subtree-end
      nil)))
#+end_src

*** Filter out entries from the Org agenda with a specific state

#+begin_src emacs-lisp
(defun gpolonkai/org-skip-subtree-if-state (state)
  "Skip an agenda entry if its state is STATE."
  (let ((subtree-end (save-excursion (org-end-of-subtree t))))
    (if (string= (org-get-todo-state) state)
        subtree-end
      nil)))
#+end_src

*** Wrapper around ~org-agenda~ to open my own custom list

#+begin_src emacs-lisp
(defun gpolonkai/org-agenda-list (&optional arg)
  (interactive "P")
  (org-agenda arg "c"))
#+end_src

*** Insert the current timestamp

#+begin_src emacs-lisp
(defun gpolonkai/org-insert-current-timestamp (&optional arg)
  "Insert the current timestamp"
  (interactive "P")
  (org-time-stamp '(16) arg))
#+end_src

*** Insert a heading with CREATED set to the current time

This emulates how Orgzly work with my current settings.

#+begin_src emacs-lisp
(defun gpolonkai/org-insert-heading-created (&optional arg)
  (interactive "p")
  (let* ((org-insert-heading-respect-content t)
         (format-string (concat "[" (substring (cdr org-time-stamp-formats) 1 -1) "]"))
         (timestamp (format-time-string format-string (current-time))))
    (if (> arg 1)
        (org-insert-subheading '(4))
      (org-insert-heading))
    (org-set-property "CREATED" timestamp)))
#+end_src

*** Display horizontal rulers as a full-width line

From [[https://matrix.to/#/@suckless_shill:matrix.org][viz]] in the [[https://matrix.to/#/#org-mode:matrix.org][org-mode]] Matrix room.

#+begin_src emacs-lisp
(defun vz/org-fontify-horizontal-break ()
  "Display Org’s horizontal break (-----) as a full-width horizontal line"
  (push '("^[[:space:]]*\\(------*\\)\n"
          (0 (progn
               (put-text-property (match-beginning 1) (match-end 1)
                                  'display (make-string (- (match-end 1) (match-beginning 1)) ?\s))
               (put-text-property (match-beginning 1) (match-end 0)
                                  'face '(:strike-through t :extend t)))))
        org-font-lock-extra-keywords)
  (setq-local font-lock-extra-managed-props (cons 'display font-lock-extra-managed-props)))

(add-hook 'org-font-lock-set-keywords-hook #'vz/org-fontify-horizontal-break)
#+end_src

** Org Roam

Let’s see if i can get my brain more organised this way…

#+begin_src emacs-lisp
(use-package org-roam
  :after org
  :ensure t
  :config
  (setq org-roam-node-display-template (concat "${title:*} "
                                               (propertize "${tags:10}" 'face 'org-tag)))
  (org-roam-db-autosync-mode)
  (require 'org-roam-dailies)
  (require 'org-roam-protocol)
  :custom
  (org-roam-directory (file-truename (expand-file-name "roam" org-directory)))
  (org-roam-dailies-directory (file-truename (expand-file-name "roam/journal" org-directory)))
  (org-roam-completion-everywhere t)
  (org-roam-capture-templates '(("d" "default" plain "\n%?"
                                 :target (file+head
                                          "${slug}-%<%Y%m%d%H%M%S>.org"
                                          "#+title: ${title}")
                                 :unnarrowed t)))
  (org-roam-dailies-capture-templates '(
                                        ("d" "default" entry "* %<%H:%M>: %?"
                                         :if-new (file+head "%<%Y-%m-%d>.org" "#+title: %<%Y-%m-%d>\n"))))
  :bind
  (("C-c n l" . org-roam-buffer-toggle)
   ("C-c n f" . org-roam-node-find)
   ("C-c n g" . org-roam-graph)
   ("C-c n i" . org-roam-node-insert)
   ("C-c n c" . org-roam-capture)
   :map org-mode-map
   ("C-M-i" . completion-at-point)
   :map org-roam-dailies-map
   ("Y" . org-roam-dailies-capture-yesterday)
   ("j" . org-roam-dailies-capture-today)
   ("T" . org-roam-dailies-capture-tomorrow))
  :bind-keymap
  ("C-c n d" . org-roam-dailies-map))
#+end_src

*** Timestamps for roam nodes

#+begin_src emacs-lisp
(use-package org-roam-timestamps
  :after org-roam
  :config
  (org-roam-timestamps-mode)
  :custom
  (org-roam-timestamps-remember-timestamps t)
  (org-roam-timestamps-timestamp-parent-file t))
#+end_src

*** Org Roam UI

#+begin_src emacs-lisp
(use-package org-roam-ui
  :after org-roam
  :custom
  (org-roam-ui-sync-theme t)
  (org-roam-ui-follow t)
  (org-roam-ui-update-on-save t)
  (org-roam-ui-open-on-start nil))
#+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

Before this can be used, make sure the [[https://zhm.github.io/symbola/][Symbola]] font is installed.

#+BEGIN_SRC emacs-lisp
(defun gpolonkai/set-font-size (frame)
  (when (display-graphic-p frame)
    (set-face-attribute 'default frame :font "Fira Code Retina-14")
    (set-frame-font "Fira Code Retina-14" t (list frame))))

(defun --set-emoji-font (frame)
  "Adjust the font setting of FRAME so Emacs can display Emoji properly."
  (when (display-graphic-p frame)
    (set-fontset-font t 'symbol
                      (font-spec :family "Symbola")
                      frame 'prepend)
    (set-fontset-font t 'unicode
                      "Noto Emoji"
                      nil 'append)))

(add-hook 'after-make-frame-functions 'gpolonkai/set-font-size)
(add-hook 'after-make-frame-functions '--set-emoji-font)

(gpolonkai/set-font-size nil)
(--set-emoji-font nil)
#+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

And set up all the pretty symbols.

#+BEGIN_SRC emacs-lisp
(setq prettify-symbols-alist
      '(("lambda" . ?λ)
        ("function" . ?ƒ)
        ("map" . ?↦)
        ("not" . ?¬)
        ("and" . ?∧)
        ("or" . ?∨)))
#+END_SRC

Finally, set the frame title to the current file name

#+BEGIN_SRC emacs-lisp
(setq frame-title-format '((:eval (concat system-name
                                          ": "
                                          (if (buffer-file-name)
                                              (abbreviate-file-name (buffer-file-name))
                                            "%b")))))
#+END_SRC

** Treat soft line breaks as hard ones in textual modes

#+BEGIN_SRC emacs-lisp
(add-hook 'text-mode-hook (lambda () (visual-line-mode t)))
#+END_SRC

* Enable disabled commands

Because i’m a rock star like that.

#+BEGIN_SRC emacs-lisp
(put 'downcase-region 'disabled nil)
(put 'upcase-region 'disabled nil)
(put 'erase-buffer 'disabled nil)
(put 'narrow-to-region 'disabled nil)
(put 'narrow-to-page 'disabled nil)
(put 'set-goal-column 'disabled nil)
(put 'scroll-left 'disabled nil)
(put 'dired-find-alternate-file 'disabled nil)
(put 'Info-edit 'disabled nil)
(put 'list-timers 'disabled nil)
#+END_SRC

* Load some built-in libraries

** ~thingatpt~

#+BEGIN_SRC emacs-lisp
(use-package thingatpt
  :ensure nil)
#+END_SRC

** Calendar

#+BEGIN_SRC emacs-lisp
(use-package calendar
  :ensure nil
  :custom
  (calendar-week-start-day 1))

(use-package cal-dst
  :ensure nil
  :custom
  (calendar-time-zone 60)
  (calendar-standard-time-zone-name "CET")
  (calendar-daylight-time-zone-name "CEST"))

(use-package solar
  :ensure nil
  :custom
  (calendar-latitude 47.4)
  (calendar-longitude 19.0)
  (calendar-location-name "Budapest, Hungary"))
#+END_SRC

*** Add the SysAdmin day to the calendar

Because I’m a sysadmin, too.

#+BEGIN_SRC emacs-lisp
(add-to-list 'holiday-other-holidays '(holiday-float 7 5 -1 "SysAdmin Day") t)
(add-to-list 'holiday-other-holidays '(holiday-fixed 10 21 "Reptile Awareness Day") t)
#+END_SRC

** nXML

#+BEGIN_SRC emacs-lisp
(use-package nxml-mode
  :ensure nil
  :custom
  (nxml-attribute-indent 4)
  (nxml-child-indent 4)
  (nxml-outline-child-indent 4))
#+END_SRC

** ~recentf~

#+BEGIN_SRC emacs-lisp
(use-package recentf
  :ensure nil
  :config
  (run-at-time nil (* 5 60) 'recentf-save-list)
  (add-to-list 'recentf-exclude (expand-file-name "elpa" user-emacs-directory)))
#+END_SRC

** ~files~

#+BEGIN_SRC emacs-lisp
(use-package files
  :ensure nil
  :custom
  (make-backup-file-name-function 'xah/backup-file-name))
#+END_SRC

** ~whitespace~

~whitespace-mode~ is turned on by default, and can be toggled with ~F10~.

#+BEGIN_SRC emacs-lisp
(defun prevent-whitespace-mode-for-some ()
  "Prevent whitespace-mode from running in some modes."
  (and
   (not (derived-mode-p 'magit-mode))
   (not (derived-mode-p 'org-mode))))

(use-package whitespace
  :demand
  :config
  (add-function :before-while whitespace-enable-predicate 'prevent-whitespace-mode-for-some)
  (global-whitespace-mode 1)
  :custom
  (whitespace-line-column 100)
  :bind
  (([f10] . whitespace-mode)
   ([(shift f10)] . global-whitespace-mode)
   :map gpolonkai/pers-map
   ("w" . whitespace-cleanup))
  :custom-face
  (whitespace-line ((t (:inherit nil :background "orange4")))))
#+END_SRC

** ~eshell~

This is a function to delete a character, or close ~eshell~ if there’s nothing to delete.  Taken
from [[https://ryuslash.org/posts/C-d-to-close-eshell.html][here]].

#+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

Function to bind it locally to =C-d=.

#+BEGIN_SRC emacs-lisp
(defun gpolonkai/eshell-set-c-d-locally ()
  (local-set-key (kbd "C-d") #'eshell-C-d))
#+END_SRC

Now set up eshell.

#+BEGIN_SRC emacs-lisp
(use-package eshell
  :bind
  (:map gpolonkai/pers-map
   ("e" . eshell))
  :hook
  (eshell-mode . gpolonkai/eshell-set-c-d-locally))
#+END_SRC

** ~saveplace~

#+BEGIN_SRC emacs-lisp
;; Save place
(use-package saveplace
  :config
  (save-place-mode 1)
  :custom
  (save-place-file (expand-file-name ".places" user-emacs-directory)))
#+END_SRC

** EDiff

#+BEGIN_SRC emacs-lisp
(use-package ediff
  :custom
  (ediff-merge-split-window-function 'split-window-horizontally)
  (ediff-split-window-function 'split-window-vertically)
  (ediff-window-setup-function 'ediff-setup-windows-plain))
#+END_SRC

** Automatically revert changed files

…unless they are modified, of course.

#+BEGIN_SRC emacs-lisp
(use-package autorevert
  :config
  (global-auto-revert-mode 1))
#+END_SRC

** Eww

For in-Emacs browsing needs.

#+BEGIN_SRC emacs-lisp
(use-package eww
  :custom
  (eww-search-prefix "https://duckduckgo.com/html/?q="))
#+END_SRC

** Electric indent mode

#+BEGIN_SRC emacs-lisp
(use-package electric
  :config
  ;; This seems to be the default, but let’s make sure…
  (electric-indent-mode 1))
#+END_SRC

** Save history

#+BEGIN_SRC emacs-lisp
(use-package savehist
  :config
  (savehist-mode 1))
#+END_SRC

** Web jump

#+BEGIN_SRC emacs-lisp
(use-package webjump
  :bind
  (:map gpolonkai/pers-map
   ("j" . webjump)))
#+END_SRC

** Which function am i in?

#+BEGIN_SRC emacs-lisp
(defun gpolonkai/activate-which-func-mode ()
  (if (fboundp 'which-function-mode)
      (which-function-mode)
    (which-func-mode)))
#+END_SRC

#+BEGIN_SRC emacs-lisp
(use-package which-func
  :config
  (setq which-func-unknown "∅")
  :hook
  (prog-mode . gpolonkai/activate-which-func-mode))
#+END_SRC

** Fortune cookies

The cookies are from the Hungarian version an ancient MS-DOS based program called ~TAGLINE~.

#+BEGIN_SRC emacs-lisp
(use-package cookie1
  :demand t
  :custom
  (cookie-file (expand-file-name "fortune-cookies.txt" user-emacs-directory))
  :bind
  (:map gpolonkai/pers-map
   ("k" . cookie)))
#+END_SRC

** Browse URL functionality in Termux

#+BEGIN_SRC emacs-lisp
(when (termux-p)
  (use-package browse-url
    :ensure nil
    :config
    (advice-add 'browse-url-default-browser :override
                (lambda (url &rest args)
                  (start-process-shell-command
                   "open-url"
                   nil
                   (concat "am start -a android.intent.action.VIEW --user 0 -d "
                           url))))))
#+END_SRC

** Dired customisation

#+BEGIN_SRC emacs-lisp
(use-package dired
  :ensure nil
  :custom
  (dired-dwim-target t)
  (wdired-create-parent-directories t)
  (wdired-allow-to-change-permissions t)
  :bind
  (:map dired-mode-map
   ("RET" . dired-find-alternate-file)
   ("^" . (lambda () (interactive) (find-alternate-file "..")))
   ("W" . wdired-change-to-wdired-mode)))
#+END_SRC

** Actionable URLs

#+BEGIN_SRC emacs-lisp
(use-package goto-addr
  :hook ((compilation-mode . goto-address-mode)
         (prog-mode . goto-address-prog-mode)
         (eshell-mode . goto-address-mode)
         (shell-mode . goto-address-mode))
  :bind
  (:map goto-address-highlight-keymap
   ("<RET>" . goto-address-at-point)
   ("M-<RET>" . newline))
  :commands (goto-address-prog-mode goto-address-mode))
#+END_SRC

** Do things at midnight

By default, it closes a bunch of unused buffers.  I might add some more things there later.

#+BEGIN_SRC emacs-lisp
(use-package midnight
  :ensure nil
  :config
  (setq clean-buffer-list-kill-never-buffer-names '("*scratch*"
                                                    "*Messages*"
                                                    "*dashboard*"))
  (midnight-mode t))
#+END_SRC

** Show line numbers

I don’t usually like to see them, but there are occasions when they can be useful.

#+BEGIN_SRC emacs-lisp
(use-package display-line-numbers
  :bind
  (:map gpolonkai/pers-map
   ("C-n" . display-line-numbers-mode)))
#+END_SRC

** Check for spelling errors

#+BEGIN_SRC emacs-lisp
(use-package ispell
  :custom
  (ispell-dictionary "en_GB")
  (ispell-program-name "/usr/bin/hunspell")
  :hook
  (mail-send . ispell-message)
  (message-send . ispell-message))
#+END_SRC

** Speed bar

#+BEGIN_SRC emacs-lisp
(use-package speedbar)
#+END_SRC

* ~use-package~ packages

** Make sure we have the latest ELPA GPG keys

#+BEGIN_SRC emacs-lisp
(use-package gnu-elpa-keyring-update)
#+END_SRC

** Automatically upgrade packages every week

#+BEGIN_SRC emacs-lisp
(use-package auto-package-update
  :custom
  (auto-package-update-interval 7)
  (auto-package-update-delete-old-versions t)
  ;; Let’s do this in after-init-hook, as use-package invocations may modify
  ;; the list of installed packages
  :hook
  (after-init . auto-package-update-maybe))
#+END_SRC

** Nyanyanyanyanya

*** Nyan-cat style position marker

#+BEGIN_SRC emacs-lisp
(use-package nyan-mode
  :config
  (nyan-mode t)
  :custom
  (nyan-bar-length 20)
  (nyan-animate-nyancat t)
  (nyan-wavy-trail t))
#+END_SRC

** De-light some minor modes

#+BEGIN_SRC emacs-lisp
(use-package delight)
#+END_SRC

** Eye candy

*** Doom mode line

#+begin_src emacs-lisp
(use-package doom-modeline
  :init
  (doom-modeline-mode 1)
  :custom
  (doom-modeline-continuous-word-count-modes '(markdown-mode gfm-mode org-mode rst-mode))
  (doom-modeline-hud t)
  (doom-modeline-minor-modes t))
#+end_src

*** Minions

#+BEGIN_SRC emacs-lisp
(use-package minions
  :config
  (minions-mode 1))
#+END_SRC

*** Spinner, e.g. to display running background tasks

#+BEGIN_SRC emacs-lisp
(use-package spinner)
#+END_SRC

*** Beacon

Highlight point.  Sometimes it’s not easy to see.

#+BEGIN_SRC emacs-lisp
(use-package beacon
  :demand
  :config
  (beacon-mode 1)
  :bind
  (:map gpolonkai/pers-map
   ("b" . beacon-blink)))
#+END_SRC

*** Display the status of the last command in the fringe of EShell

#+BEGIN_SRC emacs-lisp
(use-package eshell-fringe-status
  :hook
  (eshell-mode . eshell-fringe-status-mode))
#+END_SRC

*** Extras for the EShell prompt

#+BEGIN_SRC emacs-lisp
(use-package eshell-prompt-extras
  :config
  (with-eval-after-load "esh-opt"
    (autoload 'epe-theme-lambda "eshell-prompt-extras"))
  :custom
  (eshell-highlight-prompt nil)
  (eshell-prompt-function 'epe-theme-lambda))
#+END_SRC

*** Show form feeds as a horizontal line

#+BEGIN_SRC emacs-lisp
(use-package form-feed
  :hook
  (emacs-lisp-mode . form-feed-mode)
  (compilation-mode . form-feed-mode)
  (help-mode . form-feed-mode))
#+END_SRC

** Highlight the current line

#+BEGIN_SRC emacs-lisp
(use-package hl-line
  :config
  (when window-system
    (global-hl-line-mode))
  :custom-face
  (hl-line ((t (:inherit nil :background "gray25")))))
#+END_SRC

** GNU Globals

#+BEGIN_SRC emacs-lisp
(defun gpolonkai/cond-enable-ggtags-mode ()
  (when (derived-mode-p 'c-mode 'c++-mode 'java-mode)
    (ggtags-mode t)))

(use-package ggtags
  :hook
  (c-mode-common . gpolonkai/cond-enable-ggtags-mode))
#+END_SRC

** Multiple cursors

Because one is never enough.

#+BEGIN_SRC emacs-lisp
(defun gpolonkai/no-blink-matching-paren ()
  (customize-set-variable 'blink-matching-paren nil))

(defun gpolonkai/blink-matching-paren ()
  (customize-set-variable 'blink-matching-paren t))

(use-package multiple-cursors
  :init
  (defvar gpolonkai/mc-prefix-map (make-sparse-keymap)
    "Prefix keymap for multiple-cursors")
  (define-prefix-command 'gpolonkai/mc-prefix-map)
  (define-key global-map (kbd "C-c m") 'gpolonkai/mc-prefix-map)
  :hook
  (multiple-cursors-mode-enabled . gpolonkai/no-blink-matching-paren)
  (multiple-cursors-mode-disabled . gpolonkai/blink-matching-paren)
  :bind
  (:map gpolonkai/mc-prefix-map
   ("t" . mc/mark-all-like-this)
   ("m" . mc/mark-all-like-this-dwim)
   ("l" . mc/edit-lines)
   ("e" . mc/edit-ends-of-lines)
   ("a" . mc/edit-beginnings-of-lines)
   ("n" . mc/mark-next-like-this)
   ("p" . mc/mark-previous-like-this)
   ("s" . mc/mark-sgml-tag-pair)
   ("d" . mc/mark-all-like-this-in-defun)
   ("M-<mouse-1>" . mc/add-cursor-on-click)))
#+END_SRC

*** Incremental search for multiple cursors

#+BEGIN_SRC emacs-lisp
(use-package phi-search)

(use-package phi-search-mc
  :config
  (phi-search-mc/setup-keys))
#+END_SRC

*** Some extras

#+BEGIN_SRC emacs-lisp
(use-package mc-extras
  :demand
  :bind
  (:map mc/keymap
   ("C-c m =" . mc/compare-chars)))
#+END_SRC

*** Add extra cursors via ~ace-jump~

#+BEGIN_SRC emacs-lisp
(use-package ace-mc
  :bind
  (:map gpolonkai/mc-prefix-map
   ("SPC" . ace-mc-add-multiple-cursors)
   ("C-SPC" . ace-mc-add-single-cursor)))
#+END_SRC

** Magit

#+BEGIN_SRC emacs-lisp
(use-package magit
  :custom
  (magit-auto-revert-mode nil)
  (magit-last-seen-setup-instructions "1.4.0")
  :bind
  (:map ctl-x-map
   ("g" . magit-status))
  :hook
  (git-commit-mode . turn-on-flyspell))

#+END_SRC

*** Make Magit work with Git forges

#+BEGIN_SRC emacs-lisp
(use-package forge)
#+END_SRC

** Smart parens

#+BEGIN_SRC emacs-lisp
(use-package smartparens
  :demand
  :config
  (require 'smartparens-config)
  (show-smartparens-global-mode t)
  :hook
  (prog-mode . turn-on-smartparens-strict-mode)
  (markdown-mode . turn-on-smartparens-strict-mode)
  :bind
  (([f9] . smartparens-strict-mode)
   ("C-c s u" . sp-unwrap-sexp)
   ("C-c s k" . sp-kill-sexp)))
#+END_SRC

** Projectile

#+BEGIN_SRC emacs-lisp
(use-package projectile
  :delight '(:eval (concat " [" projectile-project-name "]"))
  :pin melpa-stable
  :config
  (projectile-mode t)
  :bind
  (:map projectile-mode-map
   ("C-c p" . projectile-command-map)))
#+END_SRC

*** Repository-based ToDo management with Org mode

#+BEGIN_SRC emacs-lisp
(use-package org-projectile
  :after (:all projectile org)
  :defer t
  :bind
  (:map projectile-command-map
   ("n" . org-projectile-project-todo-completing-read))
  :custom
  (org-projectile-projects-file (expand-file-name "projects.org" org-directory))
  :config
  (push (org-projectile-project-todo-entry) org-capture-templates))
#+END_SRC

** Text object manipulation

From the package description:

#+BEGIN_QUOTE
Text objects are textual patterns like a line, a top level definition, a word, a sentence or any
other unit of text. When objed-mode is enabled, certain editing commands (configurable) will
activate objed and enable its modal editing features.
#+END_QUOTE

#+BEGIN_SRC emacs-lisp
(use-package objed
  :demand t
  :bind
  (:map global-map
   ("M-SPC" . objed-activate)))
#+END_SRC

** Ace window

Besides its standard functionality, I also make add key bindings for burying or scrolling another
window.

#+BEGIN_SRC emacs-lisp
(use-package ace-window
  :custom
  (aw-background nil)
  (aw-dispatch-always t)
  :config
  (add-to-list 'aw-dispatch-alist
               '(?s gpolonkai/scroll-window-up " Scroll window up")
               t)
  (add-to-list 'aw-dispatch-alist
               '(?S gpolonkai/scroll-window-down " Scroll window down")
               t)
  (add-to-list 'aw-dispatch-alist
               '(?q gpolonkai/bury-window " Bury (quit) window")
               t)
  :bind
  (:map ctl-x-map
   ("o" . ace-window))
  :custom-face
  (aw-leading-char-face ((t (:inherit ace-jump-face-foreground :height 2.0)))))
#+END_SRC

** Avy

#+BEGIN_SRC emacs-lisp
(use-package avy
  :demand
  :config
  (avy-setup-default)
  :bind
  (("M-g c" . avy-goto-char)
   ("M-g C" . avy-goto-char-2)
   ("M-g f" . avy-goto-line)
   ("M-g w" . avy-goto-word-1)
   ("M-g e" . avy-goto-word-0)))
#+END_SRC

** Goto last change

#+BEGIN_SRC emacs-lisp
(use-package goto-last-change
  :bind
  (("M-g /" . goto-last-change)))
#+END_SRC

** Rainbow mode

To highlight colours based on their name or hex code.

#+BEGIN_SRC emacs-lisp
(use-package rainbow-mode
  :hook
  (css-mode . rainbow-mode)
  (scss-mode . rainbow-mode)
  (sass-mode . rainbow-mode))
#+END_SRC

** Zygospore

Toggle other windows for maximum focus.  When focus is no longer needed, they can be toggled back.
~C-x 1~ is conveniently bound to it.

#+BEGIN_SRC emacs-lisp
(use-package zygospore
  :bind
  (:map ctl-x-map
   ("1" . zygospore-toggle-delete-other-windows)))
#+END_SRC

** Highlight dired buffer by file size, modified time, git status

#+BEGIN_SRC emacs-lisp
(use-package dired-k
  :bind
  (:map dired-mode-map
   ("K" . dired-k)))
#+END_SRC

** Show number of matches in the mode line while searching

#+BEGIN_SRC emacs-lisp
(use-package anzu
  :delight
  :config
  (global-anzu-mode 1))
#+END_SRC

** An Emacs Dashboard

#+BEGIN_SRC emacs-lisp
(use-package dashboard
  :after
  projectile
  :config
  (add-to-list 'dashboard-items '(projects . 5) t)
  (dashboard-setup-startup-hook)
  :custom
  (dashboard-set-heading-icons t)
  (dashboard-set-file-icons t)
  (dashboard-center-content t)
  (dashboard-set-navigator t)
  (dashboard-items '((agenda . 5)
                     (projects . 5)
                     (recents . 5)
                     (bookmarks . 5))))
#+END_SRC

** Hungarian holidays in the Calendar

#+BEGIN_SRC emacs-lisp
(use-package hungarian-holidays
  :config
  (hungarian-holidays-add))
#+END_SRC

** FlySpell

For all your spell-checking needs.

#+BEGIN_SRC emacs-lisp
(use-package flyspell
  :hook
  (prog-mode . flyspell-prog-mode)
  (text-mode . flyspell-mode))
#+END_SRC

*** FlySpell with Ace

#+begin_src emacs-lisp
(use-package ace-flyspell
  :bind
  (:map flyspell-mode-map
   ("C-M-i" . ace-flyspell-correct-word)))
#+end_src

** Delete all the whitespace

#+BEGIN_SRC emacs-lisp
(use-package hungry-delete
  :config
  (global-hungry-delete-mode))
#+END_SRC

** Send alerts to a notification system

#+BEGIN_SRC emacs-lisp
(use-package alert
  :config
  (setq alert-default-style
        (if (termux-p)
            (progn
              ;; TODO Remove this as soon as my PR gets merged
              ;; https://github.com/jwiegley/alert/pull/41
              (unless (fboundp 'alert-termux-notify)
                (defcustom alert-termux-command (executable-find "termux-notification")
                  "Path to the termux-notification command.
This is found in the termux-api package, and it requires the Termux
API addon app to be installed."
                  :type 'file
                  :group 'alert)

                (defun alert-termux-notify (info)
                  "Send INFO using termux-notification.
Handles :TITLE and :MESSAGE keywords from the
INFO plist."
                  (if alert-termux-command
                      (let ((args (nconc
                                   (when (plist-get info :title)
                                     (list "-t" (alert-encode-string (plist-get info :title))))
                                   (list "-c" (alert-encode-string (plist-get info :message))))))
                        (apply #'call-process alert-termux-command nil
                               (list (get-buffer-create " *termux-notification output*") t)
                               nil args))
                    (alert-message-notify info)))

                (alert-define-style 'termux :title "Notify using termux"
                                    :notifier #'alert-termux-notify))
              'termux)
          'libnotify)))
#+END_SRC

** Secretaria

Because even secretaries need a secretary today.

#+BEGIN_SRC emacs-lisp
(use-package secretaria
  :after
  alert
  :hook
  ;; use this for getting a reminder every 30 minutes of those tasks
  ;; scheduled for today and which have no time of day defined.
  (after-init . secretaria-unknown-time-always-remind-me))
#+END_SRC

** Undo tree

#+BEGIN_SRC emacs-lisp
(use-package undo-tree)
#+END_SRC

** All the icons!

Should the fonts be missing, run ~(all-the-icons-install-fonts)~.  It’s not run automatically, as it
requires connecting to a website and download a pretty large font file.

#+BEGIN_SRC emacs-lisp
(use-package all-the-icons)
#+END_SRC

And apply it to dired, too.

#+begin_src emacs-lisp
(use-package all-the-icons-dired
  :hook
  (dired-mode . all-the-icons-dired-mode))
#+end_src

** Jump to character, word, line

#+BEGIN_SRC emacs-lisp
(use-package ace-jump-mode
  :bind
  (:map gpolonkai/pers-map
   ("SPC" . ace-jump-mode)))
#+END_SRC

** Mailing with mu4e

Due to my programming (and maybe a bit of OCD) needs, i set trailing whitespace to have a red
background so it stands out *a lot*.  However, many emails contain a lot of trailing whitespace
which makes them really hard to read in Emacs.

The below snippet creates a trailing whitespace face specific to mu4e view buffers.  The
accompanying function will be added to ~mu4e-view-mode-hook~.

#+BEGIN_SRC emacs-lisp
(copy-face 'trailing-whitespace 'trailing-whitespace-mu4e)
(set-face-attribute 'trailing-whitespace-mu4e nil :background 'unspecified)

(defun gpolonkai/mu4e-trailing-whitespace-fix ()
  (set (make-local-variable 'face-remapping-alist)
       '((trailing-whitespace trailing-whitespace-mu4e))))
#+END_SRC

#+BEGIN_SRC emacs-lisp
(use-package mu4e
  :after vertico
  :ensure nil
  :config
  (require 'org-mu4e)
  (setq mu4e-contexts
        `( ,(make-mu4e-context
             :name "polonkai.eu"
             :enter-func (lambda () (mu4e-message "Entering polonkai.eu Context"))
             :leave-func (lambda () (mu4e-message "Leaving polonkai.eu Context"))
             :match-func (lambda (msg)
                           (when msg
                             (mu4e-message-contact-field-matches
                              msg
                              :to "gergely@polonkai.eu")))
             :vars '((user-mail-address . "gergely@polonkai.eu")
                     (mu4e-sent-folder . "/Polonkai/[Gmail].Sent Mail")
                     (mu4e-drafts-folder . "/Polonkai/[Gmail].Drafts")
                     (mu4e-trash-folder . "/Polonkai/[Gmail].Bin")
                     (mu4e-refile-folder . "/Polonkai/[Gmail].Drafts")
                     (message-sendmail-extra-arguments . ("--account=polonkai"))))
           ,(make-mu4e-context
             :name "Benchmark.games"
             :enter-func (lambda () (mu4e-message "Entering Benchmark.games Context"))
             :leave-func (lambda () (mu4e-message "Leaving Benchmark.games Context"))
             :match-func (lambda (msg)
                           (when msg
                             (or
                              (mu4e-message-contact-field-matches
                               msg
                               :to "gergo@gt2.io")
                              (mu4e-message-contact-field-matches
                               msg
                               :to "gergo@benchmarked.games")
                              (mu4e-message-contact-field-matches
                               msg
                               :to "gergo@benchmark.games"))))
             :vars '((user-mail-address . "gergely@benchmark.games")
                     (mu4e-sent-folder . "/GT2/[Gmail].Sent Mail")
                     (mu4e-drafts-folder . "/GT2/[Gmail].Drafts")
                     (mu4e-trash-folder . "/GT2/[Gmail].Trash")
                     (mu4e-refile-folder . "/GT2/[Gmail].Drafts")
                     (message-sendmail-extra-arguments . ("--account=gt2"))))
           ,(make-mu4e-context
             :name "Private"
             :enter-func (lambda () (mu4e-message "Entering Private Context"))
             :leave-func (lambda () (mu4e-message "Leaving Private Context"))
             :match-func (lambda (msg)
                                       (when msg
                                         (string-match-p "^/Private" (mu4e-message-field msg :maildir))))
             :vars '((user-mail-address . "me@gergely.polonkai.eu")
                     (mu4e-sent-folder . "/Private/Sent")
                     (mu4e-drafts-folder . "/Private/Drafts")
                     (mu4e-trash-folder . "/Private/Trash")
                     (mu4e-refile-folder . "/Private/Drafts")
                     (message-sendmail-extra-arguments . ("--account=private" "--read-envelope-from")))))
        org-mu4e-link-query-in-headers-mode nil)
  :custom
  (mu4e-context-policy 'pick-first)
  (mu4e-confirm-quit nil)
  (mail-user-agent 'sendmail-user-agent)
  :hook
  (mu4e-view-mode . gpolonkai/mu4e-trailing-whitespace-fix)
  :bind
  (:map gpolonkai/pers-map
   ("m m" . mu4e)
   ("m i" . mu4e~headers-jump-to-maildir)
   ("m c" . mu4e-compose-new)
   ("m s" . mu4e-headers-search)))
#+END_SRC

*** Also, some sendmail hacking

#+begin_src emacs-lisp
(use-package sendmail
  :custom
  (sendmail-program "/usr/bin/msmtp")
  (message-sendmail-f-is-evil t)
  (message-sendmail-extra-arguments '("--read-envelope-from"))
  (send-mail-function 'sendmail-send-it)
  (message-send-mail-function 'message-send-mail-with-sendmail))
#+end_src

** ViM’s ~ci~ functionality

#+BEGIN_SRC emacs-lisp
(use-package ciel
  :bind
  (:map global-map
   ("C-c i" . ciel-ci)
   ("C-c o" . ciel-co)))
#+END_SRC

** Speed bar in the same frame

#+BEGIN_SRC emacs-lisp
(use-package sr-speedbar
  :after speedbar)
#+END_SRC

** Speedbar for projectile

#+BEGIN_SRC emacs-lisp
(use-package projectile-speedbar
  :after (:all projectile sr-speedbar)
  :bind
  (:map projectile-mode-map
   ("C-c p B" . projectile-speedbar-toggle)))
#+END_SRC

** Kubernetes dashboard

#+BEGIN_SRC emacs-lisp
(use-package kubernetes
  :commands (kubernetes-overview))
#+END_SRC

** A Gopher client

Gopher is the next generation text protocol.  Despite its age (40-ish, as of writing), it still
beats the Web in a lot of aspects.

#+BEGIN_SRC emacs-lisp
(use-package elpher)
#+END_SRC

** Tidal, for improvising music

#+BEGIN_SRC emacs-lisp
(use-package tidal)
#+END_SRC

** Paradox, for better package management

I don’t always use the package menu, but when i do, i want to do it in style…

#+begin_src emacs-lisp
(use-package paradox
  :custom
  (paradox-lines-per-entry 2)
  (paradox-automatically-star t)
  (paradox-github-token (nth 1 (auth-source-user-and-password "api.github.com" "gergelypolonkai^paradox")))
  :bind
  (:map gpolonkai/pers-map
   ("C-p" . paradox-list-packages)))
#+end_src

** Mastodon

#+begin_src emacs-lisp
(use-package mastodon
  :custom
  (mastodon-instance-url "https://social.polonkai.eu/")
  (mastodon-active-user "gergely"))
#+end_src

** TwTxt

#+begin_src emacs-lisp
(use-package twtxt
  :custom
  (twtxt-file (expand-file-name "NextCloud/twtxt.txt" user-documents-directory))
  (twtxt-following '(("benaiah" "https://benaiah.me/twtxt.txt")
                     ("jomo" "https://gist.githubusercontent.com/jomo/64d6bd1b95ec0a24612b/raw/twtxt.txt")
                     ("quite" "https://lublin.se/twtxt.txt")
                     ("xena" "https://xena.greedo.xeserv.us/files/xena.txt"))))
#+end_src

** Show available key bindings

#+begin_src emacs-lisp
(use-package which-key
  :config
  (which-key-mode)
  (which-key-setup-minibuffer)
  :custom
  (which-key-idle-delay 0.3))
#+end_src

** Doom themes

#+begin_src emacs-lisp
(use-package doom-themes
  :custom
  (doom-themes-enable-bold t)
  (doom-themes-enable-italic t)
  :config
  (load-theme 'doom-nord-aurora t)
  (doom-themes-visual-bell-config)
  (doom-themes-org-config))
#+end_src

* Dired related packages

** Collapse directories that only contain one file somewhere deep

#+BEGIN_SRC emacs-lisp
(use-package dired-collapse)
#+END_SRC

** Show directory sizes

#+BEGIN_SRC emacs-lisp
(use-package dired-du)
#+END_SRC

** Show Git version information

#+BEGIN_SRC emacs-lisp
(use-package dired-git-info
  :bind
  (:map dired-mode-map
   (")" . dired-git-info-mode)))
#+END_SRC

** Show/hide dot (hidden) files

#+BEGIN_SRC emacs-lisp
(use-package dired-hide-dotfiles
  :bind
  (:map dired-mode-map
   ("." . dired-hide-dotfiles-mode)))
#+END_SRC

** Rainbow to the stars…

#+BEGIN_SRC emacs-lisp
(use-package dired-rainbow
  :config
  (dired-rainbow-define-chmod executable-unix "Green" "-.*x.*"))
#+END_SRC

* Make programming a bit easier

** Electric operator

Automatically add spaces around operators.

#+BEGIN_SRC emacs-lisp
(use-package electric-operator
  :config
  ;; Apply electric-operator-mode to vala-mode, too
  (apply #'electric-operator-add-rules-for-mode 'vala-mode
         (electric-operator-get-rules-for-mode 'prog-mode))
  :hook
  (c-mode-common . electric-operator-mode)
  (python-mode . electric-operator-mode))
#+END_SRC

** Colourful delimiters

#+BEGIN_SRC emacs-lisp
(use-package rainbow-delimiters
  :hook
  (prog-mode . rainbow-delimiters-mode))
#+END_SRC

** Colourful identifiers

#+begin_src emacs-lisp
(use-package rainbow-identifiers)
#+end_src

** Highlight current symbol

A big help during refactoring.

#+BEGIN_SRC emacs-lisp
(use-package auto-highlight-symbol
  :config
  (global-auto-highlight-symbol-mode t))
#+END_SRC

** Make ReallyLongCamelCaseWords more readable

#+BEGIN_SRC emacs-lisp
(use-package glasses
  :delight " 👓"
  :hook
  (prog-mode . glasses-mode))
#+END_SRC

** Highlight TODO, FIXME, and XXX

#+BEGIN_SRC emacs-lisp
(use-package hl-todo)
#+END_SRC

** Bug and patch links

#+BEGIN_SRC emacs-lisp
(defvar gpolonkai/bug-reference-url-bug-string "issues"
  "String to insert in a `bug-reference-url-format' for bug references.")

(put 'gpolonkai/bug-reference-url-bug-string 'safe-local-variable 'stringp)

(defvar gpolonkai/bug-reference-url-patch-string "merge_requests"
  "String to insert in a `bug-reference-url-format' for patch references.")

(defvar-local bug-reference-host "gitlab.com"
  "The hostname to use in `bug-reference-url-format'.")

(defvar-local bug-reference-group "gamesystems"
  "The group name or username to use in `bug-reference-url-format'.")

(defvar-local bug-reference-repository "game-app"
  "The repository name to use in `bug-reference-url-format'.")

(put 'gpolonkai/bug-reference-url-patch-string 'safe-local-variable 'stringp)

(defun gpolonkai/bug-reference-url ()
  "Return a GitLab issue or Merge Request URL.
Intended as a value for `bug-referecne-url-format'."
  (format "https://%s/%s/%s/%s/%s"
          bug-reference-host
          bug-reference-group
          bug-reference-repository
          (if (string-suffix-p "!" (match-string-no-properties 1))
              gpolonkai/bug-reference-url-patch-string
            gpolonkai/bug-reference-url-bug-string)
          (match-string-no-properties 2))
  )

(use-package bug-reference
  :custom
  (bug-reference-bug-regexp (rx (group word-boundary
                                       (: (| (: (in ?B ?b) "ug" (? " ") (? ?#))
                                             (: (in ?P ?p) "atch" (? " ") ?#)
                                             (: "RFE" (? " ") ?#)
                                             (: "PR " (+ (any "a-z+-")) "/")
                                             (: "MR" (? " ") (? "!"))))
                                       (group (+ (any "0-9")) (opt (: ?# (+ (any "0-9"))))))))
  (bug-reference-url-format #'my-gitlab-url)
  :hook
  (text-mode . bug-reference-mode)
  (prog-mode . bug-reference-prog-mode))
#+END_SRC

** Highlight indentation

#+begin_src emacs-lisp
(use-package highlight-indentation
  :hook
  (python-mode . highlight-indentation-mode))
#+end_src

* Python related setup and ~use-package~ calls

Because, well, that’s my job now.  Of course it gets a dedicated section.

** Set up pretty symbols for Python

Because they are fancy.

- not: ¬
- in: ∈
- def: ƒ

Maybe add ∉ for ~not in~ later, if possible.

#+BEGIN_SRC emacs-lisp
(add-hook 'python-mode-hook
          (lambda ()
            (add-to-list 'prettify-symbols-alist
                         '("not in" . ?∉))
            (add-to-list 'prettify-symbols-alist
                         '("in" . ?∈))
            (add-to-list 'prettify-symbols-alist
                         '("def" . ?ƒ))
            (add-to-list 'prettify-symbols-alist
                         '("is not" . ?≭))
            (add-to-list 'prettify-symbols-alist
                         '("is" . ?≍))
            ))
#+END_SRC

** Poetry

Because it’s also great.

#+BEGIN_SRC emacs-lisp
(use-package poetry
  :config
  (poetry-tracking-mode)
  (remove-hook 'post-command-hook 'poetry-track-virtualenv)
  :hook
  (poetry-tracking-mode . (lambda () (remove-hook 'post-command-hook 'poetry-track-virtualenv)))
  (python-mode . poetry-track-virtualenv)
  (projectile-after-switch-project-hook . poetry-track-virtualenv))
#+END_SRC

* C mode

Because that’s still my favourite language.

** Set up my own C style

#+BEGIN_SRC emacs-lisp
(defconst my-c-style
  '((c-tab-always-indent        . t)
    (c-comment-only-line-offset . 4)
    (c-hanging-braces-alist     . ((substatement-open after)
                                   (brace-list-open)))
    (c-hanging-colons-alist     . ((member-init-intro before)
                                   (inher-intro)
                                   (case-label after)
                                   (label after)
                                   (access-label after)))
    (c-cleanup-list             . (scope-operator
                                   empty-defun-braces
                                   defun-close-semi))
    (c-offsets-alist             . ((arglist-close . +)
                                    (arglist-intro . +)
                                    (substatement-open . 0)
                                    (case-label . 4)
                                    (block-open . 0)
                                    (knr-argdecl-intro . -)
                                    (comment-intro . 0)
                                    (member-init-intro . ++)))
    (c-echo-syntactic-information-p . t))
  "My C Programming Style.")
(c-add-style "PERSONAL" my-c-style)
#+END_SRC

** Some common initialisation for C mode

#+BEGIN_SRC emacs-lisp
(add-hook 'c-mode-common-hook
          (lambda ()
            (local-set-key (kbd "C-c o") 'ff-find-other-file)
            (c-set-style "PERSONAL")
            (customize-set-variable 'c-basic-offset 4)
            (customize-set-variable 'tab-width 4)
            (customize-set-variable 'indent-tabs-mode nil)
            (c-toggle-auto-newline 1)))
(add-hook 'c-initialization-hook
          (lambda ()
            (define-key c-mode-base-map (kbd "C-m") 'c-context-line-break)))
#+END_SRC

** Set indentation levels to the same as the tab width

#+BEGIN_SRC emacs-lisp :tangle no
(defvaralias 'c-basic-offset 'tab-width)
(defvaralias 'cperl-indent-level 'tab-width)
#+END_SRC

* Web development

** Web mode

#+BEGIN_SRC emacs-lisp
(use-package web-mode
  :mode "\\.html?\\'"
  :custom
  (web-mode-enable-auto-indentation nil)
  (web-mode-enable-engine-detection t))
#+END_SRC

** Emmet mode

#+BEGIN_SRC emacs-lisp
(use-package emmet-mode
  :custom
  (emmet-self-closing-tag-style "")
  :hook
  (web-mode . emmet-mode)
  (css-mode . emmet-mode))
#+END_SRC

** Query HTML tags by CSS selectors

#+BEGIN_SRC emacs-lisp
(use-package enlive)
#+END_SRC

* FlyCheck

#+BEGIN_SRC emacs-lisp
(use-package flycheck
  :config
  (global-flycheck-mode)
  :custom
  (flycheck-python-pylint-executable "python3"))
#+END_SRC

** FlyCheck for pkg-config files

#+BEGIN_SRC emacs-lisp
(use-package flycheck-pkg-config)
#+END_SRC

* Org mode

** Outline mode

This is mostly needed for customizing faces.

#+begin_src emacs-lisp
(use-package outline
  :ensure nil
  :custom-face
  (outline-1 ((t (:inherit font-lock-function-name-face :overline t :weight bold :height 1.2))))
  (outline-2 ((t (:inherit font-lock-variable-name-face :overline t :weight bold :height 1.1))))
  (outline-3 ((t (:inherit font-lock-keyword-face :overline t :weight bold)))))
#+end_src

** The main Org config
This is a big one; I use a lot of customisation here.

#+BEGIN_SRC emacs-lisp
(defun gpolonkai/setup-org-mode ()
  (org-indent-mode)
  (variable-pitch-mode 1)
  (auto-fill-mode 0)
  (visual-line-mode 1))

(use-package org
  :demand
  :custom-face
  (org-block ((t (:inherit fixed-pitch))))
  (org-code ((t (:inherit (shadow fixed-pitch)))))
  (org-indent ((t (:inherit (org-hide fixed-pitch)))))
  (org-verbatim ((t (:inherit (shadow fixed-pitch)))))
  (org-special-keyword ((t (:inherit (font-lock-comment-face fixed-pitch)))))
  (org-meta-line ((t (:inherit (font-lock-comment-face fixed-pitch)))))
  (org-checkbox ((t (:inherit fixed-pitch))))
  (org-table ((t (:inherit (shadow fixed-pitch)))))
  (org-_drawer ((t (:inherit (shadow fixed-pitch)))))
  :init
  (require 'xdg-paths)
  (defface org-checkbox-todo-text
    '((t (:inherit org-todo)))
    "Face for the text part of an unchecked org-mode checkbox.")
  (defface org-checkbox-done-text
    '((t (:inherit org-done)))
    "Face for the text part of a checked org-mode checkbox.")
  (font-lock-add-keywords
   'org-mode
   `(("^[ \t]*\\(?:[-+*]\\|[0-9]+[).]\\)[ \t]+\\(\\(?:\\[@\\(?:start:\\)?[0-9]+\\][ \t]*\\)?\\[\\(?: \\|\\([0-9]+\\)/\\2\\)\\][^\n]*\n\\)" 1 'org-checkbox-todo-text prepend))
   'append)
  (font-lock-add-keywords
   'org-mode
   `(("^[ \t]*\\(?:[-+*]\\|[0-9]+[).]\\)[ \t]+\\(\\(?:\\[@\\(?:start:\\)?[0-9]+\\][ \t]*\\)?\\[\\(?:X\\|\\([0-9]+\\)/\\2\\)\\][^\n]*\n\\)" 12 'org-checkbox-done-text prepend))
   'append)
  (setq-default org-default-notes-file (expand-file-name "notes.org" org-directory)
                org-agenda-files `(,org-directory)
                org-time-stamp-formats '("<%Y-%m-%d>" . "<%Y-%m-%d %H:%M>")
                org-todo-keywords '((sequence "TODO(t)"
                                              "DOING(w@/!)"
                                              "BLOCKED(b@/!)"
                                              "SOMEDAY(s!)"
                                              "|"
                                              "CANCELED(c@/!)"
                                              "REVIEW(r@/!)"
                                              "DONE(d@/!)"))
                org-todo-keyword-faces '(("SOMEDAY" . (:foreground "goldenrod"))
                                         ("CANCELED" . (:foreground "#228b22" :strike-through t)))
                org-html-checkbox-types
                '((unicode (on . "<span class=\"task-done\">☑</span>")
                           (off . "<span class=\"task-todo\">☐</span>")
                           (trans . "<span class=\"task-in-progress\">▣</span>"))))
  :config
  ;; Load the markdown exporter
  (require 'ox-md)
  ;; Handle org-protocol:// links
  (require 'org-protocol)
  ;; Make it possible to encrypt headings
  (require 'org-crypt)
  ;; Make it possible to use inline tasks
  (require 'org-inlinetask)
  ;; Make sure we load Python babel stuff
  (org-babel-do-load-languages
   'org-babel-load-languages
   '((python . t)))
  ;; Track habits
  (require 'org-habit)
  :custom
  (org-log-into-drawer t)
  (org-ellipsis "…#")
  (org-startup-folded 'content)
  (org-log-done 'time)
  (org-src-preserve-indentation t)
  (org-tags-column 0)
  (org-startup-indented t)
  (org-special-ctrl-a/e t)
  (org-return-follows-link t)
  (org-src-fontify-natively t)
  (org-goto-interface 'outline-path-completion)
  (org-goto-max-level 10)
  (org-html-checkbox-type 'unicode)
  (org-src-window-setup 'current-window)
  (org-pretty-entities t)
  (org-pretty-entities-include-sub-superscripts t)
  (org-use-speed-commands t)
  (org-hide-leading-stars t)
  (org-enforce-todo-dependencies t)
  (org-enforce-todo-checkbox-dependencies t)
  (org-catch-invisible-edits 'show)
  (org-log-reschedule 'time)
  (org-log-redeadline 'note)
  (org-refile-use-outline-path 'file)
  (org-outline-path-complete-in-steps nil)
  (org-refile-allow-creating-parent-nodes 'confirm)
  (org-crypt-key "B0740C4C")
  (org-speed-commands-user '(("m" . org-mark-subtree)))
  (org-refile-targets '((nil :maxlevel . 6)
                        (org-agenda-files :maxlevel . 3)))
  (org-agenda-custom-commands '(("c" "Simple agenda view"
                                 ((tags "PRIORITY=\"A\""
                                        ((org-agenda-skip-function '(org-agenda-skip-entry-if 'todo 'done))
                                         (org-agenda-overriding-header "High priority unfinished tasks")))
                                  (agenda "")
                                  (alltodo ""
                                           ((org-agenda-skip-function
                                             '(or (air-org-skip-subtree-if-habit)
                                                  (air-org-skip-subtree-if-priority ?A)
                                                  (gpolonkai/org-skip-subtree-if-state "SOMEDAY")
                                                  (org-agenda-skip-if nil '(scheduled deadline))))
                                            (org-agenda-overriding-header "ALL normal priority tasks"))))
                                 ((org-agenda-compact-blocks t)))))
  (org-log-note-clock-out t)
  (org-capture-templates '(("L" "Org-protocol capture" entry
                            (file+headline
                             (lambda ()
                               (expand-file-name "index.org" org-directory))
                             "Captures")
                            "** %:description\n:PROPERTIES:\n:SOURCE: %:link\n:END:\n\n%:initial"
                            :empty-lines 1)
                           ("R" "Region to Current Clocked Task" plain
                            (clock)
                            "%i"
                            :immediate-finish t
                            :empty-lines 1)
                           ("K" "Kill-ring to Current Clocked Task" plain
                            (clock)
                            "%c"
                            :immediate-finish t
                            :empty-lines 1)
                           ("c" "Item to current Clocked Task" item
                            (clock)
                            "%i%?"
                            :empty-lines 1)
                           ("g" "GT2 note" entry
                            (file+headline
                             (lambda ()
                               (expand-file-name "gt2-notes.org" org-directory))
                             "Captures")
                            "** %^{Title}\n:PROPERTIES:\n:CREATED: %T\n:END:\n\n%a\n\n%i%?")
                           ("p" "Blog post" entry
                            (file+olp+datetree
                             (lambda ()
                               (expand-file-name "blog.org" org-directory)))
                            "* %^{Title}  :blog:\n:PROPERTIES:\n:CREATED:  %T\n:END:\n\n%i%?")))
  (org-read-date-force-compatible-dates nil)
  (org-agenda-prefix-format '((agenda . " %i %-12:c%?-12t% s")
                              (todo . " %i %-12:c %(concat \"[ \"(org-format-outline-path (org-get-outline-path)) \" ]\") ")
                              (tags . " %i %-12:c %(concat \"[ \"(org-format-outline-path (org-get-outline-path)) \" ]\") ")
                              (timeline . "  % s")
                              (search . " %i %-12:c")))
  (org-agenda-dim-blocked-tasks t)
  :hook
  (ediff-select . f-ediff-org-unfold-tree-element)
  (ediff-unselect . f-ediff-org-fold-tree)
  (org-mode .  gpolonkai/setup-org-mode)
  :bind
  (:map gpolonkai/pers-map
        ("a" . gpolonkai/org-agenda-list)
        ("C" . org-capture)
        ("l" . org-store-link)
        :map org-mode-map
        ("SPC" . org-space-key)
        ("C-c l" . org-toggle-link-display)
        ("C-a" . gpolonkai/move-to-beginning-of-line)
        ("C-e" . gpolonkai/move-to-end-of-line)
        ("C-c h" . outline-previous-heading)
        ("C-c ." . gpolonkai/org-insert-current-timestamp)
        ("C-c ;" . org-toggle-timestamp-type)))
#+END_SRC

** Show a random ToDo every hour

#+BEGIN_SRC emacs-lisp
(use-package org-random-todo
  :demand
  :config
  ;; Don’t bug me too often…
  (setq org-random-todo-how-often 3600)
  :custom
  (org-random-todo-skip-keywords '("SOMEDAY"))
  :bind
  (:map gpolonkai/pers-map
   ("r" . org-random-todo)))
#+END_SRC

** Improved list management

#+BEGIN_SRC emacs-lisp
(use-package org-autolist
  :hook
  (org-mode . org-autolist-mode))
#+END_SRC

** Write messages with Org-mode

#+BEGIN_SRC emacs-lisp
(use-package org-msg
  :after mu4e
  :defer t
  :config
  (org-msg-mode)
  :custom
  (org-msg-supported-mua '((sendmail-user-agent . "mu4e")))
  (org-msg-options "html-postamble:nil H:5 num:nil ^:{} toc:nil")
  (org-msg-startup "hidestars indent inlineimages")
  (org-msg-greeting-fmt "\nHello,\n\n")
  (org-msg-greeting-fmt-mailto nil)
  (org-msg-signature "\n\nBest,\n\n,#+begin_signature\n-- *Gergely Polonkai* \\\\\n,#+end_signature"))
#+END_SRC

** Sticky headers so i always know where i am

#+BEGIN_SRC emacs-lisp
(use-package org-sticky-header
  :custom
  (org-sticky-header-full-path 'full)
  :hook
  (org-mode . org-sticky-header-mode))
#+END_SRC

** Custom bullets

#+BEGIN_SRC emacs-lisp
(use-package org-bullets
  :custom
  (org-bullets-face-name 'org-bullet-face)
  (org-bullets-bullet-list '("✙" "♱" "♰" "☥" "✞" "✟" "✝" "†" "✠" "✚" "✜" "✛" "✢" "✣" "✤" "✥"))
  :hook
  (org-mode . org-bullets-mode))
#+END_SRC

** Edit diagrams with mermaid

#+BEGIN_SRC emacs-lisp
(use-package ob-mermaid
  :custom
  (ob-mermaid-cli-path "/home/polesz/.local/node/bin/mmdc"))
#+END_SRC

** Allow exporting to ReSTructured text

#+BEGIN_SRC emacs-lisp
(use-package ox-rst
  :after org)
#+END_SRC

** Export currently clocked in task for Waybar

#+begin_src emacs-lisp
(use-package org-clock-waybar
  :ensure nil
  :quelpa (org-clock-waybar
           :fetcher git
           :url "https://gitea.polonkai.eu/gergely/org-clock-waybar.git")
  :config
  (org-clock-waybar-setup))
#+end_src

** Width-limited text view

#+begin_src emacs-lisp
(use-package visual-fill-column
  :custom
  (visual-fill-column-center-text t)
  :hook
  (org-mode . visual-fill-column-mode))
#+end_src

* Git & Co.

** Git status on the fringe

In graphical modes we use ~git-gutter-fringe~, and ~git-gutter~ otherwise.

#+BEGIN_SRC emacs-lisp
;; Git gutter
;; If we are in text-only mode, there is no fringe.
(let ((gitgutter-package
       (if (display-graphic-p)
           "git-gutter-fringe"
         "git-gutter")))
  (eval `(use-package ,gitgutter-package
    :demand
    :config
    (global-git-gutter-mode t)
    :bind
    (:map gpolonkai/pers-map
     ("gg" . git-gutter:update-all-windows)
     ("gn" . git-gutter:next-hunk)
     ("gp" . git-gutter:previous-hunk)))))
#+END_SRC

** Git messenger

AKA blame current line.

#+BEGIN_SRC emacs-lisp
(use-package git-messenger
  :bind
  (:map gpolonkai/pers-map
   ("gm" . git-messenger:popup-message)))
#+END_SRC

** Git time machine

See previous versions of the current file.

#+BEGIN_SRC emacs-lisp
(use-package git-timemachine
  :bind
  (([f6] . git-timemachine-toggle)))
#+END_SRC

* Consult, Vertico, Orderless

The new completing system!

** Vertico

#+begin_src emacs-lisp
(use-package vertico
  :init
  (vertico-mode))
#+end_src

** Consult

#+begin_src emacs-lisp
(use-package consult
  :bind (:map global-map
         ([remap Info-search] . consult-info)
         ("M-y" . consult-yank-pop)     
         :map mode-specific-map
         ("M-x" . consult-mode-command)
         ("h" . consult-history)
         ("k" . consult-kmacro)
         ("m" . consult-man)
         ("i" . consult-info)
         :map ctl-x-map
         ("M-:" . consult-complex-command)
         ("b" . consult-buffer)
         ("4 b" . consult-buffer-other-window)
         ("5 b" . consult-buffer-other-frame)
         ("r b" . consult-bookmark)
         ("x b" . consult-project-buffer)
         :map goto-map
         ("e" . consult-compile-error)
         ("f" . consult-flymake)
         ("g" . consult-goto-line)
         ("M-g" . consult-goto-line)
         ("o" . consult-org-heading)
         ("m" . consult-mark)
         ("k" . consult-global-mark)
         ("i" . consult-imenu)
         ("I" . consult-imenu-multi)
         :map search-map
         ("d" . consult-find)
         ("D" . consult-locate)
         ("g" . consult-grep)
         ("G" . consult-git-grep)
         ("r" . consult-ripgrep)
         ("l" . consult-line)
         ("L" . consult-line-multi)
         ("k" . consult-keep-lines)
         ("u" . consilt-focus-lines)
         ("e" . consult-isearch-history)
         :map isearch-mode-map
         ("M-e" . consult-isearch-history)
         :map minibuffer-local-map
         ("M-s" . consult-history)
         ("M-r" . consult-history))
  :hook
  (completion-list-mode . consult-preview-at-point-mode)
  :custom
  (consult-narrow-key "<")
  (consult-project-function (lambda (_) (projectile-project-root)))
  (register-preview-delay 0.5)
  (xref-show-xrefs-function #'consult-xref)
  (xref-show-definitions-function #'consult-xref)
  :init
  (setq register-preview-function #'consult-register-format)
  (advice-add #'register-preview :override #'consult-register-window)
  :config
  (defalias 'consult-line-thing-at-point 'consult-line)
  (consult-customize
   consult-theme :preview-key '(:debounce 0.2 any)
   consult-buffer :preview-key "M-."
   consult-line-thing-at-point :initial (thing-at-point 'symbol)
   consult-ripgrep
   consult-git-grep
   consult-grep
   consult-bookmark
   consult-recent-file
   consult-xref
   consult--source-bookmark
   consult--source-file-register
   consult--source-recent-file
   consult--source-project-recent-file
   :preview-key '(:debounce 0.4 any))
  (autoload 'projectile-project-root "projectile"))
#+end_src

** Orderless

#+begin_src emacs-lisp
(use-package orderless
  :init
  (setq completion-category-defaults nil)
  :custom
  (completion-styles '(orderless basic))
  (completion-category-overrides '((file (styles basic partial-completion)))))
#+end_src

** Marginalia

#+begin_src emacs-lisp
(use-package marginalia
  :bind (:map minibuffer-local-map
              ("M-A" . marginalia-cycle))
  :init
  (marginalia-mode))
#+end_src

** Embark

#+begin_src emacs-lisp
(use-package embark
  :bind (:map global-map
         ("C-." . embark-act))
  :config
  (add-to-list 'display-buffer-alist
               '("\\`\\*Embark Collect \\(Live\\|Completions\\)\\*"
                 nil
                 (window-parameters (mode-line-format . none)))))

(use-package embark-consult
  :hook
  (embark-collect-mode . consult-preview-at-point-mode))
#+end_src

** Projectile with Consult

#+begin_src emacs-lisp
(use-package consult-projectile)
#+end_src

* Mode specific ~use-package~ calls

** JavaScript

#+BEGIN_SRC emacs-lisp
(use-package js2-mode
  :pin melpa-stable
  :mode "\\.js\\'")
#+END_SRC

** Jinja templates

#+begin_src emacs-lisp
(use-package jinja2-mode
  :mode "\\.j2\\'")
#+end_src

** TypeScript

#+BEGIN_SRC emacs-lisp
(use-package typescript-mode
  :mode "\\.ts\\'")
#+END_SRC

** JSON

#+BEGIN_SRC emacs-lisp
(use-package json-mode
  :mode "\\.json\\'")
#+END_SRC

** YAML

#+BEGIN_SRC emacs-lisp
(use-package yaml-mode
  :mode (("\\.yml\\'" . yaml-mode)
         ("\\.yaml\\'" . yaml-mode))
  :init
  (add-to-list 'auto-mode-alist '("\\.yml\\'" . yaml-mode)))
#+END_SRC

** Markdown

#+BEGIN_SRC emacs-lisp
(use-package markdown-mode
  :mode (("\\.md\\'" . markdown-mode)
         ("\\.markdown\\'" . markdown-mode)))
#+END_SRC

** Less

#+BEGIN_SRC emacs-lisp
(use-package less-css-mode
  :mode "\\.less\\'")
#+END_SRC

** Sass

#+BEGIN_SRC emacs-lisp
(use-package sass-mode
  :mode "\\.sass\\'")
#+END_SRC

** Vala

#+BEGIN_SRC emacs-lisp
(use-package vala-mode
  :mode "\\.vala\\'")
#+END_SRC

** Dockerfile

#+BEGIN_SRC emacs-lisp
(use-package dockerfile-mode)
#+END_SRC

** ~po-mode~

#+BEGIN_SRC emacs-lisp
(use-package po-mode
  :ensure nil
  :mode "\\.po\\'")
#+END_SRC

** PlantUML

Before using this, make sure the latest PlantUML JAR file is downloaded into the downloads
directory.  It is available from [[http://plantuml.com/download][here]].

#+BEGIN_SRC emacs-lisp
(use-package plantuml-mode
  :init
  (setq plantuml-jar-path
        (expand-file-name
         ;; Make sure we have a download location even if XDG is not working
         (cond
          ((xdg-user-dir "DOWNLOAD")
           (expand-file-name "plantuml.jar" (xdg-user-dir "DOWNLOAD")))
          (t
           "~/Downloads/plantuml.jar"))))
  (defvaralias 'org-plantuml-jar-path 'plantuml-jar-path)
  :config
  (org-babel-do-load-languages
   'org-babel-load-languages
   '((plantuml . t))))
#+END_SRC

** For editing CSV files

#+BEGIN_SRC emacs-lisp
(use-package csv-mode
  :mode "\\.csv\\'")
#+END_SRC

** Meson build system

#+BEGIN_SRC emacs-lisp
(use-package meson-mode
  :mode "\\.meson\\'")
#+END_SRC

** Gitlab-CI

#+BEGIN_SRC emacs-lisp
(use-package gitlab-ci-mode
  :mode "\\.gitlab-ci.yml\\'")
(use-package gitlab-ci-mode-flycheck
  :after flycheck gitlab-ci-mode
  :init
  (gitlab-ci-mode-flycheck-enable))
#+END_SRC

** Arduino

#+BEGIN_SRC emacs-lisp
(use-package arduino-mode
  :mode "\\.ino\\'")
#+END_SRC

** Vue templates

#+BEGIN_SRC emacs-lisp
(use-package vue-html-mode
  :mode "\\.vue\\'")
#+END_SRC

** Rust

#+BEGIN_SRC emacs-lisp
(use-package rust-mode
  :mode "\\.rs\\'")
(use-package cargo)
(use-package flycheck-rust)
#+END_SRC

** Fish shell

#+BEGIN_SRC emacs-lisp
(use-package fish-mode
  :hook
  (fish-mode . (lambda () (add-hook 'before-save-hook 'fish_indent-before-save))))
#+END_SRC

** Bats, for testing shell scripts

#+begin_src emacs-lisp
(use-package bats-mode
  :mode "\\.bats\\'")
#+end_src

** Terraform

#+begin_src emacs-lisp
(use-package terraform-mode
  :mode "\\.tf\\'")
#+end_src

** Systemd editing

#+begin_src emacs-lisp
(use-package systemd)
#+end_src

** NGinX

#+begin_src emacs-lisp
(use-package nginx-mode)
#+end_src

* Last, but not least, key bindings!

** The actual key bindings

#+begin_src emacs-lisp
(defun gpolonkai/isearch-regexp (prefix)
  "Call `isearch-forward-regex'.  If PREFIX is non-nil, call `isearch-backward-regex' instead."
  (interactive "P")
  (call-interactively
   (if prefix
       'isearch-backward-regexp
     'isearch-forward-regexp)))
#+end_src

#+BEGIN_SRC emacs-lisp
(bind-keys
 :map global-map
 ("<C-return>" . open-line-below)
 ("<C-S-return>" . open-line-above)
 ("M-t" . nil) ;; Remove the old keybinding
 ("M-t c" . transpose-chars)
 ("M-t w" . transpose-words)
 ("M-t l" . transpose-lines)
 ("M-t e" . transpose-sexps)
 ("M-t s" . transpose-sentences)
 ("M-t p" . transpose-paragraphs)
 ("M-t W" . transpose-windows)
 ("C-a" . gpolonkai/move-to-beginning-of-line)
 ("C-e" . gpolonkai/move-to-end-of-line)
 ("M-q" . sachachua/fill-or-unfill-paragraph)
 ("C-c r" . round-number-at-point-to-decimals)
 ("C-s" . consult-line)
 ("C-r" . gpolonkai/isearch-regexp)
 ("C-M-s" . isearch-forward)
 ("C-M-r" . isearch-backward)
 ("C-~" . toggle-char-case)
 ("C-z" .  nil)
 ("M-g SPC" . goto-next-char)
 ("M-F" . gpolonkai/beginning-of-next-word)
 :map ctl-x-map
 ("C-y" . duplicate-line)
 ("_" . maximize-window)
 ("C-r" . rename-current-buffer-file)
 ("C-d" . delete-current-buffer-file)
 ("|" . toggle-window-split)
 ("k" . kill-this-buffer)
 ("C-b" . bury-buffer)
 ("/" . repeat)
 :map isearch-mode-map
 ("<C-return>" . isearch-exit-other-end)
 ("<S-return>" . isearch-exit-mark-match)
 :map gpolonkai/pers-map
 ("h" . hidden-mode-line-mode)
 ("C-i e" . "gergely@polonkai.eu")
 ("C-i w" . "http://gergely.polonkai.eu/")
 ("u" . browse-url-at-point)
 ("M-C" . clean-buffer-list)
 ("C-c" . calc)
 ("c i" . org-clock-in)
 ("c I" . org-clock-in-last)
 ("c o" . org-clock-out)
 ("c g" . org-clock-goto)
 ("M-o" . insert-current-file-name-at-point)
 ("i" .  string-inflection-all-cycle))
#+END_SRC

** TODO These fail to work using ~bind-keys~, but why?

#+BEGIN_SRC emacs-lisp
(define-key 'help-command (kbd "C-l") 'find-library)
(define-key 'help-command (kbd "C-f") 'find-function)
(define-key 'help-command (kbd "C-k") 'find-function-on-key)
(define-key 'help-command (kbd "C-v") 'find-variable)
#+END_SRC

* And finally, server mode

Sometimes i start an ~emacsclient~ process, like for editing a commit message or something
similar.  As my startup time is pretty long, waiting for everything to complete is undesirable.

#+BEGIN_SRC emacs-lisp
(require 'server)
(unless (server-running-p)
  (server-start))
#+END_SRC