Emacs

./configure --with-dbus --with-gif --with-jpeg --with-png --with-rsvg --with-tiff --with-xft --with-xpm --with-xml2 --with-xwidgets --with-modules --with-native-compilation --with-pgtk --with-json --with-mailutils CFLAGS="-O3 -mtune=native -march=native -fomit-frame-pointer"

(defvar zenith-font (font-spec :family "Iosevka Term SS09" :size 16 :weight 'semi-bold))
(defvar zenith-unicode-font (font-spec :family "Sarasa Term SC" :weight 'bold))
(setq inhibit-x-resources t)

(defun zenith/init-font ()
  (add-to-list 'default-frame-alist `(font . ,(font-xlfd-name zenith-font)))
  (set-fontset-font t 'unicode zenith-unicode-font nil 'prepend))

(zenith/init-font)

(define-key special-event-map [config-changed-event] 'ignore)

(setq org-outline-path-complete-in-steps nil
      org-goto-interface 'outline-path-completion)

(setq org-format-latex-options (plist-put org-format-latex-options :scale 1.5))
(setq-default
 org-format-latex-options
 (plist-put org-format-latex-options
            :background
            (face-attribute (or (cadr (assq 'default face-remapping-alist))
                                'default)
                            :background nil t)))

(add-to-list 'org-emphasis-alist
             '("*" (:foreground "pink")))
(setcar (nthcdr 4 org-emphasis-regexp-components) 4)
(org-set-emph-re 'org-emphasis-regexp-components org-emphasis-regexp-components)

(defun zenith/refile-targets-notes ()
  (directory-files zenith/note-directory t ".*\\.org\\'"))

(setq-default org-refile-targets
              '((nil :maxlevel 3)
                (org-agenda-files :maxlevel 3)
                (zenith/refile-targets-notes :maxlevel 3)))

(setq org-todo-keywords
      '((sequence "TODO(t)" "WAITING(w@/!)" "PAUSE(p)" "SOMEDAY(s)" "NEXT(n)" "|" "DONE(d!)" "CANCELLED(c@)")
        (sequence "[ ](T)" "[-](P)" "[?](m)" "|" "[X](D)"))
      org-todo-keyword-faces
      '(("[-]" :inherit (font-lock-constant-face bold))
        ("[?]" :inherit (warning bold))
        ("WAITING" :inherit bold)
        ("LATER" :inherit (warning bold))))

(setq org-capture-templates
      '(
        ("h" "Homework" entry (file+headline "~/Dropbox/task.org"  "Homework")
         "* TODO %? :Homework:\n")
        ("s" "Schedule" entry (file+headline "~/Dropbox/task.org" "Schedule")
         "* %?\n")
        ("r" "Project" entry (file+headline "~/Dropbox/task.org" "Project")
         "* TODO %?\n")
        ("q" "Question" entry (file+headline "~/Dropbox/task.org" "Question")
         "* TODO %? :Question:\n")
        ("d" "Idea" entry (file+headline "~/Dropbox/task.org" "Idea")
         "* TODO %? :Idea:\n")))

;; Org tag
(setq org-tag-alist
      '(("Improvement" . ?i)
        (:startgrouptag)
        ("Must")
        (:grouptags)
        ("Homework" . ?h)
        ("Job" . ?j)
        (:endgrouptag)
        ("Personal" . ?p)
        ("Question" . ?q)
        ("Idea" . ?d)))

;; Org agenda settings
(setq org-agenda-start-on-weekday nil
      org-agenda-skip-scheduled-if-deadline-is-shown t
      org-agenda-skip-deadline-prewarning-if-scheduled (quote pre-scheduled)
      org-agenda-skip-scheduled-if-done t
      org-agenda-skip-deadline-if-done t
      org-agenda-span 7
      org-agenda-compact-blocks t
      org-agenda-show-all-dates nil
      org-deadline-warning-days 365
      org-agenda-show-future-repeats t
      org-agenda-window-setup 'only-window)


(setq org-agenda-custom-commands
      '(("b" "Agenda View" ((tags "AGENDAHEADER"
                                  ((org-agenda-overriding-header "Today's Schedule:")))
                            (agenda ""
                                    ((org-agenda-show-all-dates t)
                                     (org-agenda-span 'day)
                                     (org-deadline-warning-days 0)
                                     (org-agenda-start-day "+0d")))
                            (todo "NEXT"
                                  ((org-agenda-overriding-header "========================================\nNext Tasks:")))
                            (tags-todo "Must/!-NEXT"
                                       ((org-agenda-overriding-header "========================================\nMust Do:")))
                            (tags "BEFOREWEEKGLANCE"
                                  ((org-agenda-overriding-header "========================================\nNext Week Glance:")))
                            (agenda ""
                                    ((org-agenda-show-all-dates t)
                                     (org-agenda-span 6)
                                     (org-agenda-start-day "+1d")))
                            (tags "BEFOREDEADLINE"
                                  ((org-agenda-overriding-header "========================================\nFar Away Tasks:")))
                            (agenda ""
                                    ((org-agenda-span 180)
                                     (org-agenda-time-grid nil)
                                     (org-agenda-show-all-dates nil)
                                     (org-agenda-entry-types '(:deadline :scheduled))
                                     (org-agenda-start-day "+7d")))))
        ("i" "Improvement" ((tags-todo "Question"
                                       ((org-agenda-overriding-header "Unsolved Questions:")))
                            (tags-todo "Improvement" ((org-agenda-overriding-header "\n\nImprovment:")))
                            (tags-todo "Idea+TODO<>\"NEXT\"|Personal+TODO<>\"NEXT\""
                                       ((org-agenda-overriding-header "\n\nPersonal Project:")))))))

;; ox-icalendar
(with-eval-after-load 'ox-icalendar
  (setq org-icalendar-combined-agenda-file (expand-file-name "~/Dropbox/agenda.ics")
        org-icalendar-include-todo t
        org-icalendar-use-deadline '(event-if-not-todo todo-due)
        org-icalendar-use-scheduled '(event-if-not-todo todo-start)
        org-icalendar-alarm-time 15
        org-icalendar-store-UID t
        org-agenda-default-appointment-duration 90))
(add-hook 'org-agenda-finalize-hook 'org-icalendar-combine-agenda-files)

;; Org attach
(setq org-attach-method 'lns)

(zenith/autoload '(org-attach org-attach-open) "org-attach")

(defun org-agenda-attach-open ()
  "Open attachment with one-key stroke."
  (interactive)
  (unless (eq major-mode 'org-agenda-mode)
    (let ((debug-on-quit nil))
      (signal 'quit '("This was written expressly for `*Org Agenda*`."))))
  (let ((marker (or (get-text-property (point) 'org-hd-marker)
                    (get-text-property (point) 'org-marker))))
    (if marker
        (save-excursion
          (set-buffer (marker-buffer marker))
          (goto-char marker)
          (org-back-to-heading t)
          (call-interactively 'org-attach-open))
      (error "No task in current line"))))

(setq org-id-track-globally t
      org-id-link-to-org-use-id t
      org-id-locations-file (expand-file-name ".org-id-locations" zenith-emacs-local-dir))

(with-eval-after-load 'org-id
  (setq org-id-extra-files (directory-files-recursively zenith/note-directory ".*\\.org"))
  (org-id-update-id-locations)
  (defun org-id-complete-link (&optional arg)
    "Create an id: link using completion"
    (concat "id:"
            (org-id-get-with-outline-path-completion org-refile-targets)))
  (org-link-set-parameters "id"
                           :complete 'org-id-complete-link)
  (defun zenith/search-id-reverse-link ()
    "Search the id in the directory"
    (interactive)
    (let ((query
           (cdr (first (org-entry-properties nil "ID")))))
      (rg-project query "*.org")))
  (defun zenith/org-insert-link-by-id ()
    "Insert the link by id"
    (interactive)
    (let ((link (org-link--try-special-completion "id")))
      (org-insert-link nil link))))

(with-eval-after-load 'ox-latex
  (add-to-list 'org-latex-classes
               '("myart"
                 "\\documentclass{article}
[DEFAULT-PACKAGES]
[PACKAGES]
\\usepackage[backend=biber,style=alphabetic]{biblatex}
\\addbibresource[location=local]{~/Dropbox/Library.bib}
\\setCJKmainfont{Source Han Sans CN}
\\setmonofont{Source Code Pro}
\\gappto{\\UrlBreaks}{\\UrlOrds}
"
                 ("\\section{%s}" . "\\section*{%s}")
                 ("\\subsection{%s}" . "\\subsection*{%s}")
                 ("\\subsubsection{%s}" . "\\subsubsection*{%s}")
                 ("\\paragraph{%s}" . "\\paragraph*{%s}")
                 ("\\subparagraph{%s}" . "\\subparagraph*{%s}")))
  (setq org-latex-compiler "xelatex"
        org-latex-default-class "myart"
        org-export-with-sub-superscripts nil
        org-latex-listings 'minted
        org-latex-minted-options '(("breaklines" "true")
                                   ("frame" "single")
                                   ("breakanywhere" "true"))
        org-latex-pdf-process
        '("latexmk -g -pdf -pdflatex=\"%latex\" -shell-escape -outdir=%o %f"))
  (setq org-latex-packages-alist '(("" "minted")
                                   ("" "xcolor")
                                   ("" "xeCJK")
                                   ("" "fontspec")
                                   ("" "etoolbox"))))

(remove-hook! org-mode
              #'auto-fill-mode)
(global-visual-line-mode)

(defun zenith/fill-and-indent-region ()
  "Fill paragraph and indent region at once"
  (interactive)
  (when (or
         (derived-mode-p 'text-mode)
         (nth 4 (syntax-ppss))
         (nth 8 (syntax-ppss)))
    (call-interactively 'fill-paragraph))
  (call-interactively 'indent-region))

;; visual fill column
(autoload 'visual-fill-column-mode "visual-fill-column" "" t)
(setq-default visual-fill-column-width (+ fill-column 20))
(add-hook 'visual-line-mode-hook 'visual-fill-column-mode)
(add-hook 'auto-fill-mode-hook 'visual-line-mode)

;; evil-nerd-commenter
;; dependencies: evil
(zenith/autoload
 '(evilnc-comment-operator
   evilnc-comment-or-uncomment-lines
   evilnc-comment-or-uncomment-paragraphs
   evilnc-comment-or-uncomment-to-the-line
   evilnc-copy-and-comment-lines
   evilnc-copy-and-comment-operator
   evilnc-copy-to-line)
 "evil-nerd-commenter")

;; evil
;; dependencies: undo-tree goto-chg
(setq evil-want-integration t  ; This is optional since it's already set to t by default.
      evil-want-keybinding nil ; loading keybindings
      evil-disable-insert-state-bindings t ; Use emacs's binding in insert state
      evil-want-C-d-scroll nil ; Use emacs's C-d
      evil-want-C-u-scroll nil ; Use emacs's C-u
      evil-want-C-i-jump t     ; Use vim's C-i
      evil-want-fine-undo t    ; Don not aggregate changes when exiting insert state
      evil-want-C-w-delete t   ; Use emacs's C-w
      evil-toggle-key ""       ; C-z not entering emacs state
      )

(require 'evil)

(evil-mode 1)

;; The code is adjusted from https://github.com/manateelazycat/auto-save. The
;; problem of the original code is that it calls buffer-modified-p which makes
;; ws-butler unhappy.
(setq auto-save-idle 2)

(defun zenith/auto-save-buffers ()
  (interactive)
  (when (and
         (not (minibufferp))
         (or (not (boundp 'yas--active-snippets))
             (not yas--active-snippets))
         (or (not (boundp 'company-candidates))
             (not company-candidates)))
    (with-temp-message ""
      (let ((inhibit-message t))
        (evil-write-all nil)))))

(defun zenith/auto-save-enable ()
  (interactive)
  (run-with-idle-timer auto-save-idle t #'zenith/auto-save-buffers))

(zenith/auto-save-enable)

(add-hook 'LaTeX-mode-hook 'turn-on-reftex)
;; Get ReTeX working with biblatex
;; http://tex.stackexchange.com/questions/31966/setting-up-reftex-with-biblatex-citation-commands/31992#31992
(setq reftex-cite-format
      '((?a . "\\autocite[]{%l}")
        (?b . "\\blockcquote[]{%l}{}")
        (?c . "\\cite[]{%l}")
        (?f . "\\footcite[]{%l}")
        (?n . "\\nocite{%l}")
        (?p . "\\parencite[]{%l}")
        (?s . "\\smartcite[]{%l}")
        (?t . "\\textcite[]{%l}"))
      reftex-plug-into-AUCTeX t
      reftex-toc-split-windows-fraction 0.3
      reftex-bibpath-environment-variables '("/home/zenith-john/Dropbox/")
      reftex-bibliography-commands '("bibliography" "nobibiliography" "addbibresource")
      reftex-label-alist
      '(("theorem" ?m "thm:" "~\\ref{%s}" nil (regexp "[Tt]heorem" "[Tt]h\\.") -3)
        ("lemma"   ?m "lem:" "~\\ref{%s}" nil (regexp "[Ll]emma"   "[Ll]m\\.") -3)
        ("proposition" ?m "prop:" "~\\ref{%s}" nil (regexp "[Pp]roposition" "[Pp]rop\\.") -3)
        ("remark"      ?m "rmk:"  "~\\ref{%s}" nil (regexp "[Rr]emark" "[Rr]mk\\.") -3)
        ("definition"  ?m "def:"  "~\\ref{%s}" nil (regexp "[Dd]efinition" "[Dd]ef\\.") -3)
        ("corollary"   ?m "cor:"  "~\\ref{%s}" nil (regexp "[Cc]orollary" "[Cc]or\\.") -3))
      reftex-ref-macro-prompt nil)

(with-eval-after-load 'tex
  ;; the order of company-backend is important.
  ;; company-auctex
  ;; dependencies: yasnippet company auctex
  (require 'company-auctex)
  ;; company-math
  ;; dependencies: company math-symbol-lists
  (require 'company-math)

  (add-to-list '+latex-company-backends 'company-auctex-labels)
  (add-to-list '+latex-company-backends 'company-math-symbols-latex)
  (add-to-list '+latex-company-backends '(company-auctex-macros company-auctex-environments)))

(defun zenith/latex-company-setup ()
  "Setup company backends for latex editing."
  (make-local-variable 'company-backends)
  (setq zenith/local-company-backends nil)
  (dolist (backend +latex-company-backends)
    (add-to-list 'company-backends backend)))

(add-hook 'LaTeX-mode-hook 'zenith/latex-company-setup)

(defun LaTeX-star-environment-dwim ()
  "Convert between the starred and the not starred version of the current environment."
  (interactive)
  ;; If the current environment is starred.
  (if (string-match "\*$" (LaTeX-current-environment))
      ;; Remove the star from the current environment.
      (LaTeX-modify-environment (substring (LaTeX-current-environment) 0 -1))
    ;; Else add a star to the current environment.
    (LaTeX-modify-environment (concat (LaTeX-current-environment) "*"))))

(defun zenith/latex-toggle-section-with-star ()
  (interactive)
  (if (member '("section" 2) LaTeX-section-list) ;; TODO: Make it more robust.
      (setq LaTeX-section-list
            '(("part" 0)
              ("chapter" 1)
              ("section*" 2)
              ("subsection*" 3)
              ("subsubsection*" 4)
              ("paragraph" 5)
              ("subparagraph" 6)
              ("section" 2)
              ("subsection" 3)
              ("subsubsection" 4)))
    (setq LaTeX-section-list
          '(("part" 0)
            ("chapter" 1)
            ("section" 2)
            ("subsection" 3)
            ("subsubsection" 4)
            ("paragraph" 5)
            ("subparagraph" 6)))))
(defvar zenith/equation-env-list
  '(("\\begin{equation}\n" . "\n\\end{equation}")
    ("\\[" . "\\]")
    ("\\(" . "\\)"))
  "The pairs of equation environment")

(defun zenith/regex-or (l)
  (let ((regex "\\(?:")
        (first-one t))
    (dolist (e l)
      (if (not first-one)
          (setq regex
                (concat regex "\\\|"))
        (setq first-one nil))
      (setq regex
            (concat regex (regexp-quote e))))
    (concat regex "\\)")))

(defun zenith/equation-match (beg end)
  "Check whether `beg' and `end' matches as equation"
  (let ((beg-string (buffer-substring-no-properties beg (min (+ beg 20) (point-max))))
        (end-string (buffer-substring-no-properties (max (point-min) (- end 20)) end))
        ret)
    (dolist (e zenith/equation-env-list)
      (when (and
             (string-prefix-p (car e) beg-string)
             (string-suffix-p (cdr e) end-string))
        (setq ret e)))
    ret))

(defun zenith/cycle-equation ()
  (interactive)
  (if-let* ((regex (zenith/regex-or (append (mapcar 'car zenith/equation-env-list)
                                            (mapcar 'cdr zenith/equation-env-list))))
            (beg (save-excursion (re-search-backward regex nil t)))
            (end (save-excursion (re-search-forward regex nil t)))
            (kind (zenith/equation-match beg end))
            (len (safe-length zenith/equation-env-list))
            (pos (cl-position kind zenith/equation-env-list))
            (next (nth (if (= pos (- len 1))
                           0
                         (+ pos 1)) zenith/equation-env-list)))
      (progn
        (save-excursion
          (goto-char beg)
          (delete-char (length (car kind)))
          (insert (car next))
          (re-search-forward (zenith/regex-or (mapcar
                                               'cdr zenith/equation-env-list)))
          (delete-backward-char (length (cdr kind)))
          (insert (cdr next))))
    (message "No match equation environment found.")))

;; Redefine `doom-modeline-redisplay' to ignore `doom-modeline--size-hacked-p'
;; to fix the problem caused by reuse of some buffer, for example *Org Tags*
(defun zenith/doom-modeline-always-redisplay ()
  "Check whether this buffer should always display"
  (or (string-equal (buffer-name) " *Org tags*")
      (string-equal (buffer-name) " *Org todo*")))
(defun doom-modeline-redisplay (&rest _)
  "Call `redisplay' to trigger mode-line height calculations.

Certain functions, including e.g. `fit-window-to-buffer', base
their size calculations on values which are incorrect if the
mode-line has a height different from that of the `default' face
and certain other calculations have not yet taken place for the
window in question.

These calculations can be triggered by calling `redisplay'
explicitly at the appropriate time and this functions purpose
is to make it easier to do so.

This function is like `redisplay' with non-nil FORCE argument.
It accepts an arbitrary number of arguments making it suitable
as a `:before' advice for any function.  If the current buffer
has no mode-line or this function has already been called in it,
then this function does nothing."
  (when (and (bound-and-true-p doom-modeline-mode)
             mode-line-format
             (not doom-modeline--size-hacked-p))
    (redisplay t)
    (unless (zenith/doom-modeline-always-redisplay)
      (setq doom-modeline--size-hacked-p t))))

;; Redefine `hl-line-highlight' to disable highlight line when selection is
;; active.
(defun hl-line-highlight ()
  "Activate the Hl-Line overlay on the current line."
  (if
      (and hl-line-mode	; Might be changed outside the mode function.
           (not (region-active-p)))
      (progn
        (unless hl-line-overlay
          (setq hl-line-overlay (hl-line-make-overlay))) ; To be moved.
        (overlay-put hl-line-overlay
                     'window (unless hl-line-sticky-flag (selected-window)))
	(hl-line-move hl-line-overlay))
    (hl-line-unhighlight)))

;; Make yasnippet expandsion easy for me.
(defvar zenith/snippet-prefix ?,
  "The first character of expanding yasnippet")

(defun zenith/may-expand ()
  "Auto expand if the word before the point are started with
`zenith/snippet-prefix'. Return `t' if the expansion is successful
and `nil' otherwise."
  (interactive)
  (let* ((word-end (point))
         (word-start (save-excursion
                       (save-restriction
                         (narrow-to-region (line-beginning-position 0) (line-end-position))
                         (search-backward-regexp "^\\|[[:blank:]]\\|(\\|)\\|\\[\\|]\\|{\\|}" nil t))))
         (word)
         (len))

    (when word-start
      (if (eq (char-after word-start) zenith/snippet-prefix)
          (setq word (buffer-substring-no-properties word-start word-end))
        (setq
         word-start (+ word-start 1)
         word (buffer-substring-no-properties word-start word-end)))
      (when (eq zenith/snippet-prefix (string-to-char word))
        (delete-region word-start (+ word-start 1))
        (if (call-interactively 'yas-expand)
            t
          (setq len (- (length word) 1))
          (backward-char len)
          (insert-char zenith/snippet-prefix)
          (forward-char len)
          nil)))))

(defun zenith/post-command-hook ()
  "Check whether or not to expand after insertion of ~SPC~."
  (interactive)
  (when
      (and
       yas-minor-mode
       (eq last-command 'self-insert-command)
       (eq (char-before) ?\s))
    (delete-backward-char 1)
    (unless (zenith/may-expand)
      (insert-char ?\s)
      (when (boundp company-mode)
        (company-abort)))))

(define-minor-mode auto-expand-mode
  "Minor mode for zenith/may-expand"
  nil nil nil
  (if auto-expand-mode
      ;; Priority of the function should be high enough to run before fill
      ;; column
      (add-hook 'post-command-hook 'zenith/post-command-hook 0 t)
    (remove-hook 'post-command-hook 'zenith/post-command-hook t)))
(define-globalized-minor-mode global-auto-expand-mode auto-expand-mode auto-expand-mode-on)

(defun auto-expand-mode-on ()
  (auto-expand-mode 1))

(global-auto-expand-mode 1)

(defun zenith/open-by-external-program (path)
  "Open file in external program"
  (let ((display-buffer-alist '(("*Async Shell Command*" . (display-buffer-no-window)))))
    (async-shell-command (format "nohup xdg-open \"%s\" >/dev/null 2>&1"
                                 (file-relative-name path default-directory)))))

;; https://github.com/tumashu/emacs-helper/commit/1932a9e8a64f08bb9603cf244df41f6c0bbc3dac
;; Search chinese with pinyin
(defun zenith/ivy-cregexp-helper (str)
  (cons (pyim-cregexp-build str) t))

(defun zenith/ivy-cregexp-ignore-order (str)
  (let ((str-list (split-string str)))
    (if str-list
      (mapcar 'zenith/ivy-cregexp-helper (split-string str))
      "")))

(setq ivy-re-builders-alist '((counsel-company . ivy--regex-fuzzy)
                              (t . zenith/ivy-cregexp-ignore-order)))

;; Delete word in a more user friendly way
(defun zenith/aggressive-delete-space ()
  "Remove all the space until non-space character."
  (interactive)
  (let ((end (point))
        (begin (save-excursion
                 (re-search-backward "[^ \t\n\r]" nil t))))
    (delete-region (+ 1 begin) end)))

(defun zenith/delete-word-or-space ()
  "Remove all the space until non-space character if the char at
point and before are all space characters and delete word
otherwise."
  (interactive)
  (if (and (zenith/is-space (char-before))
           (zenith/is-space (char-before (- (point) 1))))
      (zenith/aggressive-delete-space)
    (backward-kill-word 1)))

;; jump in my way
(defvar zenith/jump-function-alist
  '((org-mode . org-goto)
    (latex-mode . reftex-toc)
    (org-agenda-mode . org-agenda-redo)
    (t . counsel-imenu))
  "The function to call when jump")

(defun zenith/jump ()
  "Jump as `zenith/jump-function-alist' like."
  (interactive)
  (if-let ((func (alist-get major-mode zenith/jump-function-alist)))
      (funcall func)
    (funcall (alist-get t zenith/jump-function-alist))))