nixos/pkgsets/emacs.nix

{ config, lib, pkgs, ... }:

with lib;

let
  fn = import (toString ../fn.nix) { inherit lib; };
  modefiles = fn.lst { p = (toString ./emacs); b = true; };
in rec {
  imports = [
    ../options/emacs-init.nix
  ] ++ modefiles;

  programs.emacs.init = {
    enable = (elem "emacs" config.machine.pkgs);
    recommendedGcSettings = true;

    prelude = ''
      ;; Disable UI Clutter
      (menu-bar-mode -1)
      (tool-bar-mode -1)
      (scroll-bar-mode -1)
      (tooltip-mode -1)
      (blink-cursor-mode -1)
      (setq ring-bell-function 'ignore)
      (setq inhibit-startup-buffer-menu t)
      (setq use-dialog-box nil)
      (setq inhibit-startup-message t)
      (setq inhibit-splash-screen t)
      (setq initial-scratch-message nil)
      (fset 'yes-or-no-p 'y-or-n-p)
      (setq-default show-trailing-whitespace t)



      ;; Save and Backup behaviour
      (add-hook 'before-save-hook 'delete-trailing-whitespace)
      (setq create-lockfiles nil)
      (setq backup-directory-alist `(("." . "~/.emacs_saves")))
      (setq backup-by-copying t)
      (setq delete-old-versions t
            kept-new-versions 6
            kept-old-versions 2
            version-control t)



      ;; Tabs vs Spaces... I like Spaces
      (setq-default indent-tabs-mode nil
            tab-width 2
            c-basic-offset 2
            js-indent-level 2)



      ;; General Functions I want
      (put 'narrow-to-region 'disabled nil)
      (put 'upcase-region 'disabled nil)
      (put 'downcase-region 'disabled nil)



      ;; Global UI related Modes
      (global-display-line-numbers-mode)
      (setq display-line-numbers-width-start t)
      (setq display-line-numbers-grow-only t)
      (column-number-mode t)
      (global-hl-line-mode t)
      (size-indication-mode t)
      (show-paren-mode t)
      (setq split-height-threshold 200)
      (setq split-width-threshold nil)



      ;; Text Scaling
      (global-set-key (kbd "C-+") 'text-scale-increase)
      (global-set-key (kbd "C--") 'text-scale-decrease)



      ;; Font Config
      (defun set-fonts (frame)
        (interactive)
        "Adjust the font settings of FRAME so Emacs can display emoji and chinese properly."
        (set-fontset-font t 'ascii (font-spec :family "DejaVu Sans Mono") frame 'preprend)
        (set-fontset-font t 'big5 (font-spec :family "AR PL UMing TW") frame)
        (set-fontset-font t 'chinese-gbk (font-spec :family "AR PL UMing CN") frame)
        (set-fontset-font t 'symbol (font-spec :family "Symbola") frame 'prepend))

      ;; For when Emacs is started in GUI mode:
      (set-fonts nil)
      ;; Hook for when a frame is created with emacsclient
      ;; see https://www.gnu.org/software/emacs/manual/html_node/elisp/Creating-Frames.html
      (add-hook 'after-make-frame-functions 'set-fonts)

      ;; Fix keyboard input of 'dead-keys'
      (require 'iso-transl)



      ;; Some small helper functions
      ;; These are based on the already existing 'kill' versions of the function
      ;; It's literally just a M-x r-str kill delete (and getting rid of tabs)
      (defun delete-word (arg)
        "Delete characters forward until encountering the end of a word.
      With argument ARG, do this that many times."
        (interactive "p")
        (delete-region (point) (progn (forward-word arg) (point))))
      (define-key global-map [remap kill-word] 'delete-word)
      ;; (define-key global-map (kbd <>) 'kill-word)

      (defun backward-delete-word (arg)
        "Delete characters backward until encountering the beginning of a word.
      With argument ARG, do this that many times."
        (interactive "p")
        (delete-word (- arg)))
      (define-key global-map [remap backward-kill-word] 'backward-delete-word)

      (defun delete-whole-line (&optional arg)
        "Delete current line.
      With prefix ARG, delete that many lines starting from the current line.
      If ARG is negative, delete backward.  Also delete the preceding newline.
      \(This is meant to make \\[repeat] work well with negative arguments.)
      If ARG is zero, delete current line but exclude the trailing newline."
        (interactive "p")
        (or arg (setq arg 1))
        (if (and (> arg 0) (eobp) (save-excursion (forward-visible-line 0) (eobp)))
            (signal 'end-of-buffer nil))
        (if (and (< arg 0) (bobp) (save-excursion (end-of-visible-line) (bobp)))
            (signal 'beginning-of-buffer nil))
        (unless (eq last-command 'delete-region)
          (delete-new "")
          (setq last-command 'delete-region))
        (cond ((zerop arg)
         ;; We need to delete in two steps, because the previous command
         ;; could have been a delete command, in which case the text
         ;; before point needs to be prepended to the current delete
         ;; ring entry and the text after point appended.  Also, we
         ;; need to use save-excursion to avoid copying the same text
         ;; twice to the delete ring in read-only buffers.
         (save-excursion
           (delete-region (point) (progn (forward-visible-line 0) (point))))
         (delete-region (point) (progn (end-of-visible-line) (point))))
        ((< arg 0)
         (save-excursion
           (delete-region (point) (progn (end-of-visible-line) (point))))
         (delete-region (point)
                (progn (forward-visible-line (1+ arg))
                 (unless (bobp) (backward-char))
                 (point))))
        (t
         (save-excursion
           (delete-region (point) (progn (forward-visible-line 0) (point))))
         (delete-region (point)
                (progn (forward-visible-line arg) (point))))))
      (define-key global-map [remap kill-whole-line] 'delete-whole-line)
    '';
  };
}