Emacs configuration

(use-package avy)
(setq avy-timeout-seconds 0.3)
(bind-key "M-j" 'avy-goto-char-timer)

(bind-key "C-M-p" #'beginning-of-defun)
(bind-key "C-M-n" #'end-of-defun)

(save-place-mode 1)

(global-set-key (kbd "C-a") #'back-to-indentation)

(use-package consult)
(defun consult-org-maybe ()
  (interactive)
  (if (eq major-mode 'org-mode)
      (consult-org-heading)
    (consult-imenu)))

(global-set-key (kbd "M-g i") #'consult-org-maybe)

(when (display-graphic-p)
  (setq mouse-wheel-scroll-amount '(2 ((shift) . 1))
        mouse-wheel-progressive-speed nil))

(setq skeleton-pair t)
(bind-key "(" 'skeleton-pair-insert-maybe)
(bind-key "{" 'skeleton-pair-insert-maybe)
(bind-key "[" 'skeleton-pair-insert-maybe)
(bind-key (char-to-string 34) 'skeleton-pair-insert-maybe)
;char 34 is the single quote, putting the character itself
;ruins prettify symbols mode

(setq auto-revert-interval 1)
(global-auto-revert-mode 1)

(add-hook 'before-save-hook
          'delete-trailing-whitespace)

(use-package multiple-cursors)
(global-set-key (kbd "C->") 'mc/mark-next-like-this)
(global-set-key (kbd "C-<") 'mc/mark-previous-like-this)
(global-set-key (kbd "C-c C-<") 'mc/mark-all-like-this)
(global-set-key (kbd "C-x x SPC") 'set-rectangular-region-anchor)

(delete-selection-mode 1)

(global-set-key (kbd "C-c w")
              (lambda () (interactive)
                (insert (buffer-file-name
                         (window-buffer (minibuffer-selected-window))))))

(global-set-key (kbd "C-c y") #'consult-yank-from-kill-ring)
(global-set-key (kbd "C-x C-SPC") #'consult-mark)

(setq compilation-auto-jump-to-first-error 'first-known)

(keymap-set compilation-mode-map "q" #'kill-buffer-and-window)

(use-package flymake)
(add-hook 'prog-mode-hook #'flymake-mode)
(keymap-set flymake-mode-map "C-c C-x" #'flymake-goto-next-error)

(use-package corfu)
(setq corfu-auto t)

(global-corfu-mode 1)

(use-package nerd-icons-corfu)
(add-to-list 'corfu-margin-formatters #'nerd-icons-corfu-formatter)

(use-package tuareg)

(keymap-set tuareg-mode-map "C-c C-c" #'project-compile)

(add-hook 'tuareg-mode-hook
        (lambda ()
          (if (eq (project-current) nil)
              (setq-local compile-command
                          (concat "ocaml " (buffer-file-name)))
              (setq-local compile-command "dune build && dune install"))))

(add-hook 'dune-mode-hook
         (lambda () (setq-local compile-command "dune build && dune install")))

(use-package ocamlformat)
(setq ocamlformat-enable 'enable-outside-detected-project)
(setq ocamlformat-show-errors nil)
(add-hook 'before-save-hook #'ocamlformat-before-save)

(use-package dune)

(use-package rustic)
(setq rustic-lsp-client #'eglot)

(defun lsp-no-coq ()
  (interactive)
  (unless (eq major-mode 'coq-mode) (eglot-ensure)))

(use-package eglot)
(add-hook 'prog-mode-hook #'lsp-no-coq)

(use-package eldoc-box)
(setq eldoc-box-only-multi-line t)
(bind-key "\C-hj" #'eldoc-box-help-at-point)

(use-package magit)

(keymap-set magit-mode-map "C-c C-p" #'magit-section-up)

(setq magit-display-buffer-function
      #'magit-display-buffer-traditional)

(setq magit-bury-buffer-function
      'magit-restore-window-configuration)

(bind-key "C-x g" #'magit-status)

(use-package git-auto-commit-mode)
(setq gac-automatically-add-new-files-p t)

(use-package yaml-mode)

(defun epic () (setq gac-automatically-push-p t))

(add-hook 'git-auto-commit-mode-hook #'epic)

(defun org-directory (file)
  (concat "~/roam/daily/personal/" file))

(defvar todo-file
  (org-directory "todo.org.gpg"))

(defvar agenda-file
  (org-directory "appoint.org.gpg"))

(setq org-agenda-file-regexp "\\`[^.].*\\.org\\\(\\.gpg\\\)?\\'")
(setq org-agenda-files (list todo-file agenda-file))

(setq org-cite-export-processors '((t biblatex "numeric" "numeric")))
(setq org-cite-global-bibliography '("~/.dot-files/latex/english.bib"))
(setq org-export-with-sub-superscripts nil)

(setq org-agenda-restore-windows-after-quit t)

(use-package org-alert)
(setq alert-default-style 'libnotify)
(setq org-alert-interval 300)
(setq org-alert-notify-cutoff 10)
(setq org-alert-notify-after-event-cutoff 0)

(org-alert-enable)

(setq org-agenda-custom-commands
      '(("t" "List all items with the TODO keyword" ((todo "TODO")))))

(defun what ()
  (interactive)
  (insert "👁️👄👁️")
  )

(setq org-hide-emphasis-markers t)
(setq org-hide-macro-markers t)

(setq org-hide-leading-stars t)

(setq org-pretty-entities t)

(setq org-startup-folded t)

(setq org-startup-indented t)

(add-hook 'org-agenda-mode-hook #'writeroom-mode)

(setq org-agenda-skip-timestamp-if-done t
      org-agenda-skip-deadline-if-done t
      org-agenda-skip-scheduled-if-done t
      org-agenda-skip-scheduled-if-deadline-is-shown t
      org-agenda-skip-timestamp-if-deadline-is-shown t)

(setq org-startup-with-latex-preview t)

(use-package org-fragtog)
(add-hook 'org-mode-hook #'org-fragtog-mode)

(setq org-format-latex-options
      (plist-put org-format-latex-options :scale 3))

(setq org-agenda-window-setup 'only-window)

(setq org-agenda-prefix-format
      '((agenda . "%?-12t% s")
      (todo . "%-12:c") (tags . "%-12:c")
      (search . "%-12:c")))

(setq org-agenda-start-on-weekday nil)

(setq org-capture-templates
      '(
        ("w" "Writing TODO"
         entry (file+headline todo-file "Writing")
         "* TODO %?\n "
         :empty-lines 0)

        ("p" "Phd TODO"
         entry (file+headline todo-file "PhD Tasks")
         "* TODO [[%L][%?]]\n "
         :empty-lines 0)

        ("a" "Appointment"
         entry (file+headline agenda-file "Appointments")
         "* APPOINTMENT %?\n "
         :empty-lines 0)

        ("?" "Question"
         entry (file+headline todo-file "Questions")
         "* 👁️👄👁️ [[%L][%?]]\n "
         :empty-lines 0)

        ("r" "Reading"
         checkitem (file+headline todo-file "Reading List")
         "[ ] %?\n")
      ))

(setq org-todo-keywords
      '((sequence "APPOINTMENT(p)" "SPEC(s)" "TODO(t)" "IN-PROGRESS(i@/!)" "VERIFYING(v!)" "BLOCKED(b@)" "👁️👄👁️(q)" "|" "DONE(d!)" "OBE(o@!)" "WONT-DO(w@/!)" )
        ))
;; TODO colors
(setq org-todo-keyword-faces
      '(
        ("TODO" . (:foreground "GoldenRod" :weight bold))
        ("APPOINTMENT" . (:foreground "DeepPink" :weight bold))
        ("IN-PROGRESS" . (:foreground "Cyan" :weight bold))
        ("VERIFYING" . (:foreground "DarkOrange" :weight bold))
        ("BLOCKED" . (:foreground "Red" :weight bold))
        ("DONE" . (:foreground "LimeGreen" :weight bold))
        ("WONT-DO" . (:foreground "Firebrick" :weight bold))
        ("SPEC" . (:foreground "LightCyan" :weight bold))
        ))

(defun tag-word-or-region (text-begin text-end)
"Surround current word or region with given text."
(interactive "sStart tag: \nsEnd tag: ")
(let (pos1 pos2 bds)
  (if (and transient-mark-mode mark-active)
      (progn
        (goto-char (region-end))
        (insert text-end)
        (goto-char (region-beginning))
        (insert text-begin))
    (progn
      (setq bds (point))
      (goto-char bds)
      (insert text-end)
      (goto-char bds)
      (insert text-begin)))))

(setq env-map '( ("cfml" . "coq")
  ("ocamlenv" . "ocaml")
  ("gospel" . "ocaml")
  ("whylang" . "ocaml :why3")
))

(defun org-insert-code-env (env-name)
  (interactive "sEnvironment name: ")
  (if (equal env-name "elisp")
      (tag-word-or-region
       "#+begin_src emacs-lisp :results none\n"
       "\n#+end_src"
       )
    (tag-word-or-region
     (concat "#+ATTR_LATEX: :environment " env-name
                              "\n#+begin_example " (alist-get env-name env-map nil nil #'equal) "\n")
                      "\n#+end_example"
                      )))

(defun org-insert-macro ()
  (interactive)
  (tag-word-or-region "{{{" "}}}") )

(add-to-list 'ispell-skip-region-alist '("^#\\+BEGIN_SRC" . "#\\+END_SRC"))
(add-to-list 'ispell-skip-region-alist '("^#\\+BEGIN_EXAMPLE" . "#\\+END_EXAMPLE"))
(add-to-list 'ispell-skip-region-alist '("^#\\+begin_src" . "#\\+end_src"))
(add-to-list 'ispell-skip-region-alist '("^#\\+begin_example" . "#\\+end_example"))
(add-to-list 'ispell-skip-region-alist '("^#\\+" . "\n"))
(add-to-list 'ispell-skip-region-alist '("~" . "~"))
(add-to-list 'ispell-skip-region-alist '("/" . "/"))
(add-to-list 'ispell-skip-region-alist '("{{{" . "}}}"))
(add-to-list 'ispell-skip-region-alist '("<<" . ">>"))

(global-set-key "\C-ca" 'org-agenda)
(global-set-key "\C-cc" 'org-capture)

(keymap-set org-agenda-keymap "n" #'org-agenda-next-item)
(keymap-set org-agenda-keymap "p" #'org-agenda-previous-item)

(keymap-set org-mode-map "C-c C-x C-x" #'org-insert-code-env)
(keymap-set org-mode-map "C-c C-x C-m" #'org-insert-macro)

(setq conjugation-table
"|-----------+---|
| Je        |   |
|-----------+---|
| Tu        |   |
|-----------+---|
| Il/Elle   |   |
|-----------+---|
| Nous      |   |
|-----------+---|
| Vous      |   |
|-----------+---|
| Ils/Elles |   |
|-----------+---|")

(defun start-conjugation ()
  (interactive)
  (insert conjugation-table)
  (org-backward-paragraph)
  (org-cycle)
  (org-cycle))

(with-eval-after-load 'ox-latex
  (add-to-list 'org-latex-classes
               '("llncs"
                 "\\documentclass{llncs}"
                 ("\\section{%s}" . "\\section*{%s}")
                 ("\\subsection{%s}" . "\\subsection*{%s}"))))

(with-eval-after-load 'ox-latex
  (add-to-list 'org-latex-classes
               '("IEEEtran"
                 "\\documentclass{IEEEtran}"
                 ("\\section{%s}" . "\\section*{%s}")
                 ("\\subsection{%s}" . "\\subsection*{%s}"))))

(setq org-export-with-toc nil)

(use-package org-roam)
(setq org-roam-directory (file-truename "~/roam"))
(setq org-roam-file-exclude-regexp '("data/" "daily/"))
(setq org-roam-completion-everywhere t)

(keymap-global-set "C-c n l" #'org-roam-buffer-toggle)
(keymap-global-set "C-c n f" #'org-roam-node-find)
(keymap-global-set "C-c n g" #'org-roam-graph)
(keymap-global-set "C-c n i" #'org-roam-node-insert)
(keymap-global-set "C-c n c" #'org-roam-capture)
(keymap-global-set "C-c n j" #'org-roam-dailies-capture-today)

(org-roam-db-autosync-mode)

(setq org-roam-capture-templates
      '(("t" "travel" plain
         "%?"
         :if-new (file+head "travel/%<%Y%m%d%H%M%S>-${slug}.org" "#+title: ${title}\n")
         :unnarrowed t)
      ("r" "Reading note" plain
       (file "~/roam/templates/reading_template.org")
       :if-new (file+head "research/%<%Y%m%d%H%M%S>-${slug}.org.gpg" "#+title: ${title}\n")
       :unnarrowed t)
      ("p" "PhD Note" plain
         "%?"
         :if-new (file+head "research/%<%Y%m%d%H%M%S>-${slug}.org.gpg" "#+title: ${title}\n")
         :unnarrowed t
       :jump-to-captured t)
      ))

(setq org-roam-dailies-capture-templates
      '(("d" "default" plain "* %?" :target (file+head "%<%Y-%m-%d>.org.gpg" "#+title: %<%Y-%m-%d>
") :jump-to-captured t)))

;; Input of unicode symbols
(use-package math-symbol-lists)
                                      ; Automatically use math input method for Coq files
(add-hook 'coq-mode-hook (lambda () (set-input-method "math")))
(add-hook 'tuareg-mode-hook (lambda () (set-input-method "math")))
                                      ; Input method for the minibuffer
;; (defun my-inherit-input-method ()
;;   "Inherit input method from `minibuffer-selected-window'."
;;   (let* ((win (minibuffer-selected-window))
;;          (buf (and win (window-buffer win))))
;;     (when buf
;;       (activate-input-method (buffer-local-value 'current-input-method buf)))))
;; (add-hook '
;; minibuffer-setup-hook #'my-inherit-input-method)

                                      ; Define the actual input method
(quail-define-package "math" "UTF-8" "Ω" t)
(quail-define-rules ; add whatever extra rules you want to define here...
 ("\\fun"    ?λ)
 ("\\mult"   ?⋅)
 ("\\ent"    ?⊢)
 ("\\valid"  ?✓)
 ("\\diamond" ?◇)
 ("\\box"    ?□)
 ("\\bbox"   ?■)
 ("\\later"  ?▷)
 ("\\pred"   ?φ)
 ("\\and"    ?∧)
 ("\\or"     ?∨)
 ("\\comp"   ?∘)
 ("\\ccomp"  ?◎)
 ("\\all"    ?∀)
 ("\\ex"     ?∃)
 ("\\to"     ?→)
 ("\\sep"    ?∗)
 ("\\lc"     ?⌜)
 ("\\rc"     ?⌝)
 ("\\Lc"     ?⎡)
 ("\\Rc"     ?⎤)
 ("\\lam"    ?λ)
 ("\\empty"  ?∅)
 ("\\Lam"    ?Λ)
 ("\\Sig"    ?Σ)
 ("\\-"      ?∖)
 ("\\aa"     ?●)
 ("\\af"     ?◯)
 ("\\auth"   ?●)
 ("\\frag"   ?◯)
 ("\\iff"    ?↔)
 ("\\gname"  ?γ)
 ("\\incl"   ?≼)
 ("\\latert" ?▶)
 ("\\update" ?⇝)
 ("\\nin" ?∉)
 ("\\u" ?∪)
 ("\\points" ?↦)

 ;; accents (for iLöb)
 ("\\o" ?ö)

 ;; subscripts and superscripts
 ("^^+" ?⁺) ("__+" ?₊) ("^^-" ?⁻)
 ("__0" ?₀) ("__1" ?₁) ("__2" ?₂) ("__3" ?₃) ("__4" ?₄)
 ("__5" ?₅) ("__6" ?₆) ("__7" ?₇) ("__8" ?₈) ("__9" ?₉)

 ("__a" ?ₐ) ("__e" ?ₑ) ("__h" ?ₕ) ("__i" ?ᵢ) ("__k" ?ₖ)
 ("__l" ?ₗ) ("__m" ?ₘ) ("__n" ?ₙ) ("__o" ?ₒ) ("__p" ?ₚ)
 ("__r" ?ᵣ) ("__s" ?ₛ) ("__t" ?ₜ) ("__u" ?ᵤ) ("__v" ?ᵥ) ("__x" ?ₓ)
 )
(mapc (lambda (x)
        (if (cddr x)
            (quail-defrule (cadr x) (car (cddr x)))))
                                      ; need to reverse since different emacs packages disagree on whether
                                      ; the first or last entry should take priority...
                                      ; see <https://mattermost.mpi-sws.org/iris/pl/46onxnb3tb8ndg8b6h1z1f7tny> for discussion
      (reverse (append math-symbol-list-basic math-symbol-list-extended)))

(use-package desktop-environment)
(desktop-environment-mode 1)

(define-key desktop-environment-mode-map (kbd "s-l") nil t)

(setq desktop-environment-volume-toggle-command
      "amixer -D pulse set Master 1+ toggle")

(setq desktop-environment-volume-set-command
      "~/.config/vol_set.sh %s")

(setq desktop-environment-volume-get-command
      "amixer -D pulse get Master")

(setq desktop-environment-screenshot-directory
      "~/pictures")

(setq desktop-environment-screenlock-command "~/.config/lock.sh")

(defun efs/run-in-background (command)
  (let ((command-parts (split-string command "[ ]+")))
    (apply #'call-process `(,(car command-parts) nil 0 nil ,@(cdr command-parts)))))

(efs/run-in-background "nm-applet")

(use-package volume)

(defun messaging-apps ()
  (interactive)
  (efs/run-in-background "discord"))

(defun is-substring (haystack needle)
  (string-match-p (regexp-quote needle) haystack))

(defun is-messaging-app ()
  (seq-drop-while
   (lambda (elt) (not (is-substring (buffer-name) elt)))
   '("discord")))

(defun minimize-messaging-app ()
  (interactive)
  (when (is-messaging-app)
    (exwm-workspace-move-window 0)))

(add-hook 'exwm-manage-finish-hook #'minimize-messaging-app)

(add-hook 'exwm-init-hook #'messaging-apps)

(defmacro without-yes-or-no (&rest body)
"Override `yes-or-no-p' & `y-or-n-p',
 not to prompt for input and return t."
(declare (indent 1))
`(cl-letf (((symbol-function 'yes-or-no-p) (lambda (&rest _) t))
           ((symbol-function 'y-or-n-p) (lambda (&rest _) t)))
  ,@body))

(without-yes-or-no (mingus-load-all))
(mingus-shuffle)
(mingus-play)
(mingus-pause)

(start-process-shell-command "config" nil "~/.update.sh")

(start-process-shell-command "autopause" nil "~/.config/autopause.sh")

(efs/run-in-background "dunst")

(efs/run-in-background "cbatticon")

(efs/run-in-background "picom")

(setq exwm-randr-workspace-monitor-plist
      '(1 "eDP-1" 2 "HDMI-1-0"))

(setq exwm-workspace-warp-cursor t)

(setq mouse-atuoselect-window t
      focus-follows-mouse t)

(defun efs/update-displays ()
  (efs/run-in-background "autorandr --change --force")
  (message "Display config: %s"
           (string-trim (shell-command-to-string "autorandr --current")))
  (start-process-shell-command
   "feh" nil
   "feh --bg-scale ~/.dot-files/.config/bg/lain-hands.jpeg --bg-scale ~/.dot-files/.config/bg/lain.jpeg"))

(add-hook 'exwm-randr-screen-change-hook #'efs/update-displays)
(exwm-randr-mode 1)

  (setq exwm-input-global-keys
      `(([?\s-r] . exwm-reset) ;; s-r: Reset (to line-mode).
        ([?\s-w] . exwm-workspace-switch) ;; s-w: Switch workspace.
        ([?\s-&] . (lambda (cmd) ;; s-&: Launch application.
                     (interactive (list (read-shell-command "$ ")))
                     (start-process-shell-command cmd nil cmd)))
        ;; s-N: Switch to certain workspace.
        ,@(mapcar (lambda (i)
                    `(,(kbd (format "s-%d" i)) .
                      (lambda ()
                        (interactive)
                        (exwm-workspace-switch-create ,i))))
                  (number-sequence 0 9))))

(add-hook #'exwm-init-hook
        (lambda () (interactive) (exwm-workspace-switch-create 1)))

(defun kill-or-minimize ()
  (interactive)
  (unless (minimize-messaging-app)
    (kill-current-buffer)))

(exwm-input-set-key (kbd "s-c") 'kill-or-minimize)

(exwm-input-set-key (kbd "s-l") 'windmove-right)
(exwm-input-set-key (kbd "s-j") 'windmove-left)
(exwm-input-set-key (kbd "s-i") 'windmove-up)
(exwm-input-set-key (kbd "s-k") 'windmove-down)

(exwm-input-set-key (kbd "s-L") 'windmove-swap-states-right)
(exwm-input-set-key (kbd "s-J") 'windmove-swap-states-left)
(exwm-input-set-key (kbd "s-I") 'windmove-swap-states-up)
(exwm-input-set-key (kbd "s-K") 'windmove-swap-states-down)

(use-package xdg-launcher
  :vc (:url "https://github.com/emacs-exwm/xdg-launcher"))

(with-eval-after-load 'consult
  (push 'xdg-launcher-consult-source (cdr (memq 'consult-source-buffer consult-buffer-sources))))

(exwm-input-set-key (kbd "s-<escape>") 'desktop-environment-lock-screen)

(defun run-firefox ()
  (interactive)
  (efs/run-in-background "firefox"))

(exwm-input-set-key (kbd "s-<return>") 'run-firefox)

(defun list-firefox ()
  (interactive)
  (minibuffer-with-setup-hook
      (lambda () (insert "firefox "))
    (call-interactively #'switch-to-buffer)))

(exwm-input-set-key (kbd "s-f") #'list-firefox)

(scratch-buffer)
(server-start)
(exwm-wm-mode)

(start-process-shell-command
 "aaa" nil
 "xrandr --output eDP-1 --auto --output HDMI-1-0 --auto --primary --above eDP-1")