Emacs.org
Welcome back to the church, my child.

;; C-*- lexical-binding: t; -*-

(defun prot-emacs-add-to-list (list element)
  "Add to symbol of LIST the given ELEMENT.
    Simplified version of `add-to-list'."
  (set list (cons element (symbol-value list))))

    (mapc
     (lambda (var)
       (prot-emacs-add-to-list var '(width . (text-pixels . 1200)))
       (prot-emacs-add-to-list var '(height . (text-pixels . 900)))
       (prot-emacs-add-to-list var '(scroll-bar-width  . 10)))
     '(default-frame-alist initial-frame-alist))

    (setq
          frame-resize-pixelwise t
          frame-inhibit-implied-resize t
          frame-title-format '("%b")
          ring-bell-function 'ignore
          use-dialog-box t ; only for mouse events, which I seldom use
          use-file-dialog nil
          use-short-answers t
          inhibit-splash-screen t
          inhibit-startup-screen t
          inhibit-x-resources t
          inhibit-startup-echo-area-message user-login-name ; read the docstring
          inhibit-startup-buffer-menu t)

    ;; I do not use those graphical elements by default, but I do enable
    ;; them from time-to-time for testing purposes or to demonstrate
    ;; something.  NEVER tell a beginner to disable any of these.  They
    ;; are helpful.
    (menu-bar-mode -1)
    (scroll-bar-mode -1)
    (tool-bar-mode -1)

    ;; Temporarily increase the garbage collection threshold.  These
    ;; changes help shave off about half a second of startup time.  The
    ;; `most-positive-fixnum' is DANGEROUS AS A PERMANENT VALUE.  See the
    ;; `emacs-startup-hook' a few lines below for what I actually use.
    (setq gc-cons-threshold most-positive-fixnum
          gc-cons-percentage 0.5)

    ;; Same idea as above for the `file-name-handler-alist' and the
    ;; `vc-handled-backends' with regard to startup speed optimisation.
    ;; Here I am storing the default value with the intent of restoring it
    ;; via the `emacs-startup-hook'.
    (defvar prot-emacs--file-name-handler-alist file-name-handler-alist)
    (defvar prot-emacs--vc-handled-backends vc-handled-backends)

    (setq file-name-handler-alist nil
          vc-handled-backends nil)

    (add-hook 'emacs-startup-hook
              (lambda ()
                (setq gc-cons-threshold (* 100 100 8)
                      gc-cons-percentage 0.1
                      file-name-handler-alist prot-emacs--file-name-handler-alist
                      vc-handled-backends prot-emacs--vc-handled-backends)))

    ;; Initialise installed packages at this early stage, by using the
    ;; available cache.  I had tried a setup with this set to nil in the
    ;; early-init.el, but (i) it ended up being slower and (ii) various
    ;; package commands, like `describe-package', did not have an index of
    ;; packages to work with, requiring a `package-refresh-contents'.
    (setq package-enable-at-startup t)


    ;; Set custom file location early
  (setq custom-file (expand-file-name "custom.el" user-emacs-directory))

;; -*- lexical-binding: t; -*-
(setq package-vc-register-as-project nil) ; Emacs 30

  (setq package-archives
        '(("gnu-elpa" . "https://elpa.gnu.org/packages/")
          ("nongnu" . "https://elpa.nongnu.org/nongnu/")
          ("melpa" . "https://melpa.org/packages/")))

  ;; Highest number gets priority (what is not mentioned has priority 0)
  (setq package-archive-priorities
        '(("gnu-elpa" . 3)
          ("melpa" . 2)
          ("nongnu" . 1)))

  (setq package-install-upgrade-built-in t)
  (require 'use-package-ensure)
  (setq use-package-always-ensure t)
  (setq use-package-always-defer nil)
  (setq use-package-verbose t)

  ;; Load custom file
(when (file-exists-p custom-file)
  (load custom-file))

(use-package benchmark-init
  :ensure t
  :hook
  ;; To disable collection of benchmark data after init is done.
  (after-init . benchmark-init/deactivate))

(defun xcvh/display-startup-info ()
  "Display package count and startup time in the echo area."
  (message "%d packages loaded in %.2f seconds"
           (length package-activated-list)
           (float-time (time-subtract after-init-time before-init-time))))

(add-hook 'emacs-startup-hook #'xcvh/display-startup-info)

(defun xcvh/goto-line-with-feedback ()
  "Show line numbers temporarily while using goto-line."
  (interactive)
  (unwind-protect
      (progn
        (display-line-numbers-mode 1)
        (call-interactively #'goto-line))
    (display-line-numbers-mode -1)))

(global-set-key (kbd "M-g M-g") 'xcvh/goto-line-with-feedback)

(use-package server
  :ensure nil)

(unless (server-running-p)
  (server-start))

(use-package gtd
      :load-path "~/.emacs.d/lisp")

(use-package embark
  :bind (("C-." . embark-act)
         :map embark-email-map
         ("n" . #'xcvh/notmuch-search-from-sender)))

(use-package embark-consult)

(use-package spacious-padding)

;; These are the default values, but I keep them here for visibility.
(setq spacious-padding-widths
      '( :internal-border-width 15
         :header-line-width 6
         :mode-line-width 1
         :tab-width 4
         :right-divider-width 30
         :scroll-bar-width 8
         :fringe-width 8))

;; Read the doc string of `spacious-padding-subtle-mode-line' as it
;; is very flexible and provides several examples.
(setq spacious-padding-subtle-frame-lines
      `( :mode-line-active 'default
         :mode-line-inactive vertical-border))

(spacious-padding-mode 1)

;; Set a key binding if you need to toggle spacious padding.
(define-key global-map (kbd "<f8>") #'spacious-padding-mode)

(with-mac
 (set-fontset-font t 'unicode "Apple Symblos" nil 'prepend))

(use-package notmuch
  :load-path "/opt/homebrew/share/emacs/site-lisp/notmuch/"
  :ensure nil
  :demand t
  :bind ((:map notmuch-search-mode-map
               ("F" . xcvh/notmuch-filter-by-from)
               ("f" . xcvh/notmuch-search-by-from)
               ("A" . xcvh/notmuch-archive-all-visible)
               ("D" . xcvh/notmuch-delete-all-visible))
         (:map notmuch-show-mode-map
               ("A" . notmuch-show-archive-thread-then-next)))
  :config
  (setq notmuch-archive-tags '("-inbox")
        mm-text-html-renderer 'shr
        shr-width 80
        shr-use-colors nil
        notmuch-multipart/alternative-discouraged '("text/plain" "text/html")
        notmuch-search-oldest-first nil)

  (defun xcvh/notmuch-filter-by-from ()
    "Filter this view by messages from the sender of the current thread."
    (interactive)
    (let* ((authors (notmuch-search-find-authors))
           (from (car (split-string authors "[,<]" t " "))))
      (notmuch-search-filter (format "from:%s" from))))

  (defun xcvh/notmuch-search-by-from ()
    "Search all messages from the sender of the current thread."
    (interactive)
    (let* ((authors (notmuch-search-find-authors))
           (from (car (split-string authors "[,<]" t " "))))
      (notmuch-search (format "from:%s" from))))

  (defun xcvh/notmuch-archive-all-visible ()
    "Archive all visible messages."
    (interactive)
    (notmuch-search-tag-all '("-inbox")))

  (defun xcvh/notmuch-delete-all-visible ()
    "Delete all visible messages after confirmation."
    (interactive)
    (when (yes-or-no-p "Delete all visible messages? ")
      (notmuch-search-tag-all '("+deleted"))))

  (defun xcvh/notmuch-search-from-sender (email)
    "Search notmuch for emails from EMAIL."
    (notmuch-search (concat "from:" email))))

(use-package pinboard :config (add-to-list 'auth-sources "~/.authinfo" t))

(use-package elfeed :config (setq elfeed-feeds
                                  '("https://velvetshark.com/articles"
                                  "https://joshblais.com/posts/index.xml"
                                    "https://protesilaos.com/news.xml"
                                    "https://protesilaos.com/codelog.xml"
                                  "https://200ok.ch/atom.xml"
                                  "https://sqrtminusone.xyz/posts/")))

(use-package undo-tree
  :ensure t
  :config
  (setq undo-tree-history-directory-alist '(("." . "~/.emacs.d/undo"))
        undo-tree-auto-save-history t
        undo-tree-visualizer-diff t
        undo-tree-visualizer-timestamps t)
  (global-undo-tree-mode))

(use-package expand-region
  :bind ("C-=" . er/expand-region))

;; Configure Tempel
(use-package tempel
  ;; Require trigger prefix before template name when completing.
  ;; :custom
  ;; (tempel-trigger-prefix "<")

  :bind (("M-+" . tempel-complete) ;; Alternative tempel-expand
         ("M-*" . tempel-insert))

  :init

  ;; Setup completion at point
  (defun tempel-setup-capf ()
    ;; Add the Tempel Capf to `completion-at-point-functions'.
    ;; `tempel-expand' only triggers on exact matches. Alternatively use
    ;; `tempel-complete' if you want to see all matches, but then you
    ;; should also configure `tempel-trigger-prefix', such that Tempel
    ;; does not trigger too often when you don't expect it. NOTE: We add
    ;; `tempel-expand' *before* the main programming mode Capf, such
    ;; that it will be tried first.
    (setq-local completion-at-point-functions
                (cons #'tempel-expand
                      completion-at-point-functions)))

  (add-hook 'conf-mode-hook 'tempel-setup-capf)
  (add-hook 'prog-mode-hook 'tempel-setup-capf)
  (add-hook 'text-mode-hook 'tempel-setup-capf)

  ;; Optionally make the Tempel templates available to Abbrev,
  ;; either locally or globally. `expand-abbrev' is bound to C-x '.
  ;; (add-hook 'prog-mode-hook #'tempel-abbrev-mode)
  ;; (global-tempel-abbrev-mode)
)

;; Optional: Add tempel-collection.
;; The package is young and doesn't have comprehensive coverage.
(use-package tempel-collection)

(use-package hungry-delete
  :ensure t
  :bind (("s-<backspace>" . hungry-delete-backward)
         ("s-<delete>" . hungry-delete-forward))
  :config
  (global-hungry-delete-mode))

(use-package diff-hl
  :ensure t
  :hook ((prog-mode . diff-hl-margin-mode)
         (org-mode . diff-hl-margin-mode)
         (dired-mode . diff-hl-dired-mode)
         (magit-post-refresh . diff-hl-magit-post-refresh))
  :config
  (setq diff-hl-margin-side 'left
        diff-hl-fringe-bmp-function 'diff-hl-fringe-bmp-from-type)
  (global-diff-hl-mode 1)
  (diff-hl-flydiff-mode 1))

(use-package project
  :ensure nil  ; built-in package
  :bind (("C-x p f" . project-find-file)
         ("C-x p p" . project-switch-project)
         ("C-x p d" . project-dired)
         ("C-x p g" . project-find-regexp)
         ("C-x p r" . project-query-replace-regexp)
         ("C-x p b" . consult-project-buffer))
  :config
  ;; Auto-discover projects under specific directories
  (project-remember-projects-under "~/Developer/" t))

(use-package grep
  :ensure t
  :config
  (grep-apply-setting
   'grep-find-command
   '("rg -n -H --no-heading -e '' $(git rev-parse --show-toplevel || pwd)" . 27)
   )

  (global-set-key (kbd "C-x C-g") 'grep-find))

(use-package exercism
  :ensure t
  :bind ("C-c e" . exercism))

(use-package envrc
  :hook (after-init . envrc-global-mode))

(use-package applescript-mode
  :ensure t
  :mode ("\\.\\(applescript\\|scpt\\)\\'" . applescript-mode)
  :hook (applescript-mode . font-lock-mode))

(add-to-list 'treesit-language-source-alist
             '(typst "https://github.com/uben0/tree-sitter-typst"))

(add-to-list 'treesit-language-source-alist
             '(xml "https://github.com/tree-sitter-grammars/tree-sitter-xml"))

(treesit-install-language-grammar 'typst)

(use-package typst-ts-mode
  :ensure t
  :custom
  ;; don't add "--open" if you'd like `watch` to be an error detector
  (typst-ts-mode-watch-options "--open")
  (typst-ts-preview-function #'find-file))

(with-eval-after-load 'eglot
  (with-eval-after-load 'typst-ts-mode
    (add-to-list 'eglot-server-programs
                 `((typst-ts-mode) .
                   ,(eglot-alternatives `(,typst-ts-lsp-download-path
                                          "tinymist"
                                          "typst-lsp"))))))

(setq-default eglot-workspace-configuration
              '(:tinymist (:exportPdf "onSave")))

(defun xcvh/typst-toggle-bold-region (start end)
  "Toggle Typst bold syntax on selected text."
  (interactive "r")
  (if (use-region-p)
      (let ((text (buffer-substring start end)))
        (if (and (string-prefix-p "*" text)
                 (string-suffix-p "*" text)
                 (> (length text) 2))
            ;; Remove bold
            (progn
              (delete-region start end)
              (insert (substring text 1 -1)))
          ;; Add bold
          (delete-region start end)
          (insert (format "*%s*" text))))
    (insert "**")
    (backward-char 1)))

(defun xcvh/typst-toggle-emph-region (start end)
  "Toggle Typst emphasis syntax on selected text."
  (interactive "r")
  (if (use-region-p)
      (let ((text (buffer-substring start end)))
        (if (and (string-prefix-p "#emph[" text)
                 (string-suffix-p "]" text)
                 (> (length text) 7))
            ;; Remove emphasis
            (progn
              (delete-region start end)
              (insert (substring text 6 -1)))
          ;; Add emphasis
          (delete-region start end)
          (insert (format "#emph[%s]" text))))
    (insert "#emph[]")
    (backward-char 1)))

(with-eval-after-load 'typst-ts-mode
  (define-key typst-ts-mode-map (kbd "s-b") 'xcvh/typst-toggle-bold-region)
  (define-key typst-ts-mode-map (kbd "s-i") 'xcvh/typst-toggle-emph-region))

(defun my-typst-compile-master-and-preview ()
  "Compile and preview main.typ instead of current buffer."
  (interactive)
  (let ((master-file (or (and (boundp 'typst-ts-master-file)
                              typst-ts-master-file)
                         "main.typ"))
        (original-buffer (current-buffer)))
    (if (file-exists-p master-file)
        (progn
          (save-buffer)
          (find-file master-file)
          (typst-ts-compile-and-preview)
          (switch-to-buffer original-buffer))
      (message "Master file %s not found" master-file))))

(defun my-typst-compile-master-and-zathura ()
  "Compile main.typ and open/update in Zathura."
  (interactive)
  (let ((master-file (or (and (boundp 'typst-ts-master-file)
                              typst-ts-master-file)
                         "main.typ"))
        (pdf-file (or (and (boundp 'typst-ts-master-file)
                           (concat (file-name-sans-extension typst-ts-master-file) ".pdf"))
                      "main.pdf")))
    (if (file-exists-p master-file)
        (progn
          (save-buffer)
          ;; Compile the master file
          (shell-command (format "typst compile %s" (shell-quote-argument master-file)))
          ;; Check if Zathura is already running with this PDF
          (let ((zathura-running
                 (string-match-p pdf-file
                                 (shell-command-to-string "ps aux | grep zathura"))))
            (unless zathura-running
              ;; Open in Zathura with --fork so it doesn't block
              (start-process "zathura" nil "zathura" "--fork" pdf-file)))
          (message "Compiled %s and updated Zathura" master-file))
      (message "Master file %s not found" master-file))))

(with-eval-after-load 'typst-ts-mode
  (define-key typst-ts-mode-map (kbd "C-c C-c") #'my-typst-compile-master-and-zathura))

(use-package pdf-tools
  :ensure t
  :mode ("\\.pdf\\'" . pdf-view-mode)
  :config
  (pdf-tools-install :no-query)
  (setq-default pdf-view-display-size 'fit-page)

  ;; Optional: Enable auto-revert for PDFs
  (add-hook 'pdf-view-mode-hook (lambda () (auto-revert-mode 1)))

  ;; Optional: More comfortable scrolling
  (setq pdf-view-resize-factor 1.1)

  ;; Optional: Midnight mode (dark theme for PDFs)
  ;; (add-hook 'pdf-view-mode-hook (lambda () (pdf-view-midnight-minor-mode)))

  :bind (:map pdf-view-mode-map
              ("C-s" . isearch-forward)
              ("C-r" . isearch-backward)
              ("j" . pdf-view-next-line-or-next-page)
              ("k" . pdf-view-previous-line-or-previous-page)))

(defun my-pdf-tools-backdrop ()
  (face-remap-add-relative 'default '(:background "#f2f2f2")))

(add-hook 'pdf-tools-enabled-hook #'my-pdf-tools-backdrop)

(use-package jinx
  :hook (emacs-startup . global-jinx-mode)
  :bind (("M-$" . jinx-correct)
         ("C-M-$" . jinx-languages))
  :config
  (setq jinx-languages "en_GB-ise"))


;; ;; This is a wrong word. Customise is wrong.

;; ;; Limitations:
;; ;; 1. since raw block highlighting let the local parser highlights the area,
;; ;; some area doesn't contain face (like `bash-ts-mode'), and those areas will
;; ;; be checked by jinx
;; (add-to-list
;;   'jinx-exclude-faces
;;   '(typst-ts-mode
;;   ;; not included font lock faces
;;   ;; `font-lock-comment-face', `font-lock-string-face', `font-lock-doc-face'
;;   ;; `font-lock-doc-markup-face'
;;   font-lock-warning-face font-lock-function-name-face font-lock-function-call-face
;;   font-lock-variable-name-face font-lock-variable-use-face font-lock-keyword-face
;;   font-lock-comment-delimiter-face font-lock-type-face font-lock-constant-face
;;   font-lock-builtin-face font-lock-preprocessor-face
;;   font-lock-negation-char-face font-lock-escape-face font-lock-number-face
;;   font-lock-operator-face font-lock-property-use-face font-lock-punctuation-face
;;   font-lock-bracket-face font-lock-delimiter-face font-lock-misc-punctuation-face
;;   ;; typst-ts-mode created faces
;;   typst-ts-markup-item-indicator-face typst-ts-markup-term-indicator-face
;;   typst-ts-markup-rawspan-indicator-face typst-ts-markup-rawspan-blob-face
;;   typst-ts-markup-rawblock-indicator-face typst-ts-markup-rawblock-lang-face
;;   typst-ts-markup-rawblock-blob-face
;;   typst-ts-error-face typst-ts-shorthand-face typst-ts-markup-linebreak-face
;;   typst-ts-markup-quote-face typst-ts-markup-url-face typst-ts-math-indicator-face))

(use-package howm
  :ensure t
  :init
  (require 'howm-org)
  (setq howm-directory "~/Documents/Howm/"
        howm-home-directory "~/Documents/Howm/"
        howm-keyword-file (expand-file-name ".howm-keys" howm-home-directory)
        howm-history-file (expand-file-name ".howm-history" howm-home-directory))
  (setq howm-follow-theme t)
  ;; Use ripgrep
  ;; (setq howm-view-use-grep t)
  ;; (setq howm-view-grep-command "rg")
  ;; (setq howm-view-grep-option "-nH --no-heading --color never")
  ;; (setq howm-view-grep-extended-option nil)
  ;; (setq howm-view-grep-fixed-option "-F")
  ;; (setq howm-view-grep-expr-option nil)
  ;; (setq howm-view-grep-file-stdin-option nil)
  )

(use-package calfw)
;(use-package calfw-howm)
(eval-after-load "howm-menu" '(progn
                                (require 'calfw-howm)
                                (calfw-howm-install-schedules)
                                (define-key howm-mode-map (kbd "M-C") 'calfw-howm-open-calendar)
                                ))