My Vanilla yet powerful Emacs environment

  (defun my/reload-dir-locals-for-current-buffer ()
    "reload dir locals for the current buffer"
    (interactive)
    (let ((enable-local-variables :all))
      (hack-dir-local-variables-non-file-buffer)))

  (defun my/reload-dir-locals-for-all-buffer-in-this-directory ()
    "For every buffer with the same `default-directory` as the
  current buffer's, reload dir-locals."
    (interactive)
    (let ((dir default-directory))
      (dolist (buffer (buffer-list))
        (with-current-buffer buffer
          (when (equal default-directory dir)
            (my/reload-dir-locals-for-current-buffer))))))

  (defun my/disable-proxy ()
    "Disable the proxy used in emacs"
    (interactive)
    (setq url-proxy-services
          `(("http" . nil)
            ("https" . nil)
            ("no_proxy" . ,(getenv "no_proxy"))))
    ;;backup the proxy settings
    (setenv "http_proxy_backup" (getenv "http_proxy"))
    (setenv "https_proxy_backup" (getenv "https_proxy"))
    (setenv "ftp_proxy_backup" (getenv "ftp_proxy"))
    ;;clean up the proxy settings
    (setenv "http_proxy" nil)
    (setenv "https_proxy" nil)
    (setenv "ftp_proxy" nil)
    )

  (defun my/enable-proxy ()
    "Re-enable proxy from environment variables"
    (interactive)
    (setenv "http_proxy" (getenv "http_proxy_backup"))
    (setenv "https_proxy" (getenv "https_proxy_backup"))
    (setenv "ftp_proxy" (getenv "ftp_proxy_backup"))

    (setq url-proxy-services
          `(("http" . ,(getenv "http_proxy"))
            ("https" . ,(getenv "https_proxy"))
            ("ftp_proxy" . ,(getenv "ftp_proxy"))
            ("no_proxy" . ,(getenv "no_proxy"))))
    )

(use-package uuidgen
  :ensure t
  :pin melpa
  :init
  (defun my/insert-uuid ()
    "insert UUID at the point"
    (interactive)
    (insert (uuidgen-4)))
  )

  (prefer-coding-system 'utf-8-unix)
  (set-default-coding-systems 'utf-8-unix)

(setq
   backup-by-copying t      ; don't clobber symlinks
   backup-directory-alist
    '(("." . "~/.saves/"))    ; don't litter my fs tree
   delete-old-versions t
   kept-new-versions 6
   kept-old-versions 2
   version-control t)       ; use versioned backups

(require 'org-funcs)
(defun my/org-dir-set (dir)
  (and dir (not (string= dir "")) (file-exists-p dir)))
(defun my/org-file (path)
  (my/concat-path org-directory path))

  (use-package org
    :ensure t
    :mode (("\\.org$" . org-mode))
    :commands org-capture
    :custom
    (org-log-done  'time)
    (org-clock-persist 'history)
    (org-adapt-indentation nil)
    (org-image-actual-width 300) ;;set to 300px
    ;;setup the column, this max length for the first level we can go, maybe we
    ;;can somehow calculate it?
    (org-tags-column -54)
  
    ;;faces
    (org-todo-keywords '((sequence "TODO" "DOIN" "|" "DONE" "PEND" "CANC")))

    :hook
    ((org-after-todo-statistics . org-funcs-summary-todo)
     (org-checkbox-statistics . org-funcs-checkbox-todo)
     (org-mode . org-funcs-define-faces))
    ;; I am not sure this global key setting is good or not, capture stuff
    ;; globally is great
    :bind (:map global-map
                ("\C-ca"   . org-agenda)
                ("\C-cc"   . org-capture)
                :map org-mode-map
                ("M-<left>"  . org-metaleft)
                ("M-<right>" . org-metaright)
                ("M-<up>"    . org-metaup)
                ("M-<down>"  . org-metadown))
    :init
    <<ORG_DIRECTORY>>

    ;; enable images
    (setq org-startup-with-inline-images t)

    ;;activate babel languages
    :config
    ;;note files
    <<ORG_NOTE_AGENDA>>
    ;;latex setup
    <<ORG_LATEX>>

    (setf (cdr (assoc 'file org-link-frame-setup)) 'find-file)
    (org-clock-persistence-insinuate)
    ;; I just use PEND to define stuck projects.
    (setq org-stuck-projects
          '("/-DONE-CANC" ("DOIN" "TODO") nil ""))
    ;;capture templates

    (setq org-capture-templates
          `(
            <<ORG_CAPTURE>>            
            ))
    (org-funcs-load-babel-compiler))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; journal
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(use-package org-journal
  :ensure t :pin melpa :after org :defer t
  :init
  (defun my/journal-dir () (my/org-file "journals/"))
  (defun my/org-journal-find-location ()
    ;; Open today's journal, but specify a non-nil prefix argument in order to
    ;; inhibit inserting the heading; org-capture will insert the heading.
    (org-journal-new-entry t)
    (unless (eq org-journal-file-type 'daily)
      (org-narrow-to-subtree))
    (goto-char (point-max)))

  (with-eval-after-load 'org
    (add-to-list 'org-capture-templates
		 '("j" "Journal entry" plain (function org-journal-find-location)
                   "\n** %?"
                   :jump-to-captured t
		   :immediate-finish t
		   :prepend t)))
  :custom
  (org-journal-file-type 'daily)
  (org-journal-dir (my/org-file "journals/"))
  (org-journal-time-format "")
  (org-journal-file-format "%Y-%m-%d.org")
  (org-journal-file-header "#+title: %A, %d %B %Y\n\n* Review:\n \n* Planning:\n")
  (org-journal-enable-agenda-integration t)

  :bind-keymap
  ("C-c n j" . org-journal-mode-map)
  :bind (:map org-journal-mode-map
	      ("C-f" . org-journal-next-entry)
	      ("C-b" . org-journal-previous-entry)
	      ("C-s" . org-journal-search))
  )

(use-package mixed-pitch
  :ensure t
  :hook
  (org-mode . mixed-pitch-mode)
  :custom
  (mixed-pitch-variable-pitch-cursor 'box))

(use-package org-modern
  :ensure t
  :after org
  :hook
  (org-mode . org-modern-mode)
  (org-agenda-finalize . org-modern-agenda)
  :custom
  (org-startup-indented t)
  (org-hide-emphasis-markers t)
  (line-spaceing 0.3)

  (org-fontify-done-headline nil)
  :config
  ;; (let* ((base-font-color     (face-foreground 'default nil 'default))
  ;;        (headline           `(:inherit default :weight bold
  ;; 					:foreground ,base-font-color)))
  ;;   (custom-theme-set-faces
  ;;    'user
  ;;    `(org-level-8 ((t (,@headline))))
  ;;    `(org-level-7 ((t (,@headline))))
  ;;    `(org-level-6 ((t (,@headline))))
  ;;    `(org-level-5 ((t (,@headline))))
  ;;    `(org-level-4 ((t (,@headline :background unspecified :height 1.1))))
  ;;    `(org-level-3 ((t (,@headline :background unspecified :height 1.25))))
  ;;    `(org-level-2 ((t (,@headline :background unspecified :height 1.5))))
  ;;    `(org-level-1 ((t (,@headline :background unspecified :height 2.0))))
  ;;    `(org-document-title ((t (,@headline :underline nil))))
  ;;    )
  ;;   )

  (custom-theme-set-faces
   'user
   '(org-block ((t (:inherit fixed-pitch))))
   '(org-code ((t (:inherit (shadow fixed-pitch)))))
   '(org-document-info ((t (:foreground "dark orange"))))
   '(org-document-info-keyword ((t (:inherit (shadow fixed-pitch)))))
   '(org-indent ((t (:inherit (org-hide fixed-pitch)))))
   '(org-link ((t (:foreground "royal blue" :underline t))))
   '(org-meta-line ((t (:inherit (font-lock-comment-face fixed-pitch)))))
   '(org-property-value ((t (:inherit fixed-pitch))) t)
   '(org-special-keyword ((t (:inherit (font-lock-comment-face fixed-pitch)))))
   '(org-table ((t (:inherit fixed-pitch :foreground "#83a598"))))
   '(org-tag ((t (:inherit (shadow fixed-pitch) :weight bold :height 0.8))))
   '(org-verbatim ((t (:inherit (shadow fixed-pitch))))))
  )

  (if (version< emacs-version "29.0")
      (setq org-roam-database-connector 'sqlite)
    (setq org-roam-database-connector 'sqlite-builtin))

  (use-package org-roam
    :ensure t
    :after org
    :init
    <<ROAM_SQLITE>>
    ;; disable org-roam warning
    (setq org-roam-v2-ack t)
    (defun my/roam-dir () (my/org-file "pages/"))
    <<ROAM_VISIT>>

    :custom
    (org-roam-directory (my/org-file "pages/"))
    (org-roam-completion-everywhere t)
    (org-roam-db-update-on-save t)
    ;;template for v2
    (org-roam-capture-templates
     '(
       <<ROAM_CAPTURES>>
       ))
    ;; displaying tags along with title for org roam
    (org-roam-node-display-template
     (concat "${title:*} " (propertize "${tags:10}" 'face 'org-tag)))

    :bind  (("C-c n r" . org-roam-buffer-toggle) ;;toggle-back-links
            ("C-c n f" . org-roam-node-find)
            ("C-c n c" . org-roam-capture)
            ("C-c n i" . org-roam-node-insert)
            ("C-c n g" . org-roam-ui-mode)
            :map org-roam-mode-map
            ;;NOTE alternatively, use C-u RET to visit in other window
            ("RET" . my/roam-visit))
    :config
    ;;start db sync automatically, also you are able to refresh back link buffer,
    ;;alternatively you hook org-roam-db-auto-sync-mode to org-roam-mode
    (org-roam-db-autosync-enable)
    ;; configure org-roam-buffer
    <<ROAM_BUFFER>>
    )

(use-package org-roam-ui
  :ensure t
  :diminish org-roam-ui-mode
  :after org-roam
  :config
  (setq org-roam-ui-sync-theme nil
        org-roam-ui-follow t
        org-roam-ui-update-on-save t
        org-roam-ui-open-on-start t))

(use-package org-contrib
  :ensure t
  :after org
  :init
  (require 'ox-groff))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; disabled-config
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;; My synchronizer
;; (use-package org-msync :load-path "lisp/"
;;   :hook ((org-mode . org-msync-after-save-hook)
;; 	 (auto-save . org-msync-auto-save-hook))
;;   :custom
;;   (org-msync-local-dir org-directory)
;;   (org-msync-remote-dir "~/Documents/org-remote/")
;;   )

  (defun my/backward-kill-line (arg)
    "Kill ARG line backwards"
    (interactive "p")
    (kill-line (- 1 arg)))
  (define-key prog-mode-map (kbd "C-c u") 'my/backward-kill-line)

(defun my/copy-line ()
  "copy current line, from the first character that is not \t or
  ' ', to the last of that line, this feature is from vim.
  Case to use this feature:
  - repeat similar lines in the code.
  "
  (interactive)
  (save-excursion
    (back-to-indentation)
    (let* ((beg (point))
	   (end (line-end-position))
	   (mystr (buffer-substring beg end)))
      (kill-ring-save beg end)
      (message "%s" mystr)))
  ;;This is silly, find a way to print out last-kill.
  )

(define-key prog-mode-map (kbd "C-c C-k") 'my/copy-line)

(defmacro save-column (&rest body)
  `(let ((column (current-column)))
     (unwind-protect
         (progn ,@body)
       (move-to-column column))))
(put 'save-column 'lisp-indent-function 0)

(defun my/move-line-up ()
  (interactive)
  (save-column
    (transpose-lines 1)
    (forward-line -2)))

(defun my/move-line-down ()
  (interactive)
  (save-column
    (forward-line 1)
    (transpose-lines 1)
    (forward-line -1)))

(define-key prog-mode-map (kbd "M-<up>") 'my/move-line-up)
(define-key prog-mode-map (kbd "M-<down>") 'my/move-line-down)

  (use-package backward-forward
    :ensure t
    :demand
    :config
    (backward-forward-mode t)
    :bind (:map backward-forward-mode-map
                ("<C-left>" . nil)
                ("<C-right>" . nil)
                ("C-c C-<left>" . backward-forward-previous-location)
                ("C-c C-<right>" . backward-forward-next-location)
                ("<mouse-8>" . backward-forward-previous-location)
                ("<mouse-9>" . backward-forward-next-location)))

  (global-set-key (kbd "C-x <up>") 'windmove-up)
  (global-set-key (kbd "C-x <down>") 'windmove-down)
  (global-set-key (kbd "C-x <left>") 'windmove-left)
  (global-set-key (kbd "C-x <right>") 'windmove-right)

(use-package winner
  :defer t
  :diminish winner-mode
  :hook ((prog-mode text-mode) . winner-mode))

  (global-set-key (kbd  "\C-x r i") 'string-insert-rectangle)

(use-package ivy :ensure t
  :diminish (ivy-mode . "")
  :hook (after-init . ivy-mode)
  :config
  (setq ivy-use-virtual-buffers t)
  ;;number of result lines to display
  (setq ivy-count-format "(%d/%d) ")
  (setq ivy-wrap t)
  )

(use-package flyspell
  :if (or (executable-find "ispell") (executable-find "hunspell") (executable-find "aspell"))
  :defer t
  :hook ((prog-mode . flyspell-prog-mode)
	 (text-mode . flyspell-mode) ;;for markdown, org, nxml
	 ;;also disable it for specific mode
	 (change-log-mode . (turn-off-flyspell)))
  :init
  ;;for flyspell to work, you need to set LANG first
  ;; on windows, getenv has strange behavior, getenv-internal seems to work correctly.
  ;; (when (not (getenv-internal "LANG" initial-environment))
  (setenv "LANG" "en_US")
  :custom  (ispell-program-name (or (executable-find "hunspell")
				    (executable-find "aspell")
				    (executable-find "ispell")))
  ;;:config
  ;;TODO flyspell language-tool
  )

;; correcting word and save it to personal dictionary
(use-package flyspell-correct
  :ensure t
  :after flyspell
  :bind (:map flyspell-mode-map ("C-c ;" . flyspell-correct-wrapper)))

(use-package flyspell-correct-ivy
  ;;switch to use ivy interface
  ;;TODO there is a face bug on popup interface
  ;;NOTE: use M-o to access ivy menus
  :ensure t
  :after (ivy flyspell-correct))

(use-package modus-themes
  ;; TODO have to disable defer to get circadian to work
  :ensure t
  :init
  (setq modus-themes-mixed-fonts t)
  (setq modus-themes-common-palette-overrides
	`(
	  ;; From the section "Make the mode line borderless"
	  (border-mode-line-active unspecified)
	  (border-mode-line-inactive unspecified))))

  (setq appr-dark-theme-name 'modus-vivendi-tinted)
  (setq appr-light-theme-name 'modus-operandi-tinted)
  (setq appr-dark-theme-hour 17)
  (setq appr-light-theme-hour 8)

(use-package ligature
  :vc (:fetcher github :repo "mickeynp/ligature.el")
  :if (string-match "HARFBUZZ" system-configuration-features)
  :hook ((prog-mode text-mode) . ligature-mode)
  :config
  ;; Enable "www" ligature in every possible major mode
  (ligature-set-ligatures 't '("www")))

  (use-package appr
    :load-path "lisp"
    :hook (after-init . appr)
    :init
    <<THEME>>
    :custom
    (appr-default-font-size 13)
    (appr-cjk-font-list     '("WenQuanYi Micro Hei"
                              "WenQuanYi Zen Hei"
                              "Microsoft YaHei"
                              "Microsoft JhengHei"))
    (appr-emoji-font-list '("Noto Color Emoji"
                            "Noto Emoji"
                            "Segoe UI Emoji"
                            "Symbola"
                            "Apple Color Emoji"))

    (appr-variable-pitch-font-list '("Fira Sans"
                                     "Iosevka Aile"))
    )

(use-package company-c-headers :ensure t)
;; (setq clang-known-modes '(c++-mode c-mode))

  (use-package company
    :ensure t
    :defer t
    :hook (((c++-mode c++-ts-mode) . company-mode)
           ((c-mode c-ts-mode)     . company-mode)
           ((c++-mode c++-ts-mode c-mode c-ts-mode) .
            ;;override default company backends because eglot not compatible with company-clang
            (lambda () (set (make-local-variable 'company-backends)
                            '(company-capf company-files company-keywords company-dabbrev company-yasnippet))))
           (emacs-lisp-mode . company-mode)
           ;; company-elisp is removed
           (emacs-lisp-mode . (lambda () (my/merge-list-to-list
                                          (make-local-variable 'company-backends)
                                          (list
                                           'company-dabbrev-code
                                           'company-files
                                           'company-keywords))))
           (outline-mode    . company-mode) ;;enable for org mode
           (outline-mode    . (lambda () (my/merge-list-to-list
                                          (make-local-variable 'company-backends)
                                          (list'company-dabbrev 'company-emoji))))
           (text-mode       . company-mode)
           (text-mode       . (lambda () (my/merge-list-to-list
                                          (make-local-variable 'company-backends)
                                          (list 'company-dabbrev 'company-emoji))))
           (meson-mode . company-mode)
           ;;cmake
           (cmake-mode . company-mode)
           (cmake-mode .  (lambda () (my/merge-list-to-list
                                      (make-local-variable 'company-backends)
                                      (list 'company-cmake 'company-dabbrev))))
           ;;lua
           (lua-mode . company-mode)
           (lua-mode . (lambda ()
                         (add-to-list (make-local-variable 'company-backends)
                                      'company-lua)))
           ;; shaders
           (hlsl-mode . company-mode)
           (hlsl-mode . (lambda () (my/merge-list-to-list
                                    (make-local-variable 'company-backends)
                                    (list 'company-keywords 'company-dabbrev))))
           (azsl-mode . company-mode)
           (azsl-mode . (lambda () (my/merge-list-to-list
                                    (make-local-variable 'company-backends)
                                    (list 'company-keywords 'company-dabbrev))))
           (glsl-mode . company-mode)
           (glsl-mode . (lambda ()
                          (when (executable-find "glslangValidator")
                            (add-to-list (make-local-variable 'company-backends)
                                         'company-glsl))))
           )
    :config

    (setq company-minimum-prefix-length 2
          company-idle-delay 0.1
          company-async-timeout 10
          company-backends  '((company-files
                               company-keywords
                               company-yasnippet
                               company-capf)))

    (defun complete-or-indent ()
      (interactive)
      (if (company-manual-begin)
          (company-complete-common)
        (indent-according-to-mode)))
    (defun indent-or-complete ()
      (interactive)
      (if (looking-at "\\_>")
          (company-complete-common)
        (indent-according-to-mode)))
    )

  (use-package company-emoji
    :defer t
    :ensure t
    :after company)

  (use-package company-glsl
    :defer t
    :ensure t
    :after company)

;; eglot configuration, switching to eglot after emacs 29
(use-package eglot
  :ensure t
  :hook (((c++-mode c++-ts-mode) . eglot-ensure)
	 ((c-mode c-ts-mode) . eglot-ensure)
	 (python-mode . eglot-ensure))
  :custom
  (eglot-extend-to-xref t)
  ;;inlay-hints are annoying
  (eglot-ignored-server-capabilities '(:inlayHintProvider))
  :config
  ;;by default eglot forces company to only use company-capf, I lose a lot of
  ;;backends in this way
  (setq eglot-stay-out-of '(company))
  ;;eldoc's multi-line mini buffer is really annoying, turn it off
  (setq eldoc-echo-area-use-multiline-p nil)
  ;;C++ requires clangd, python requires python-language server
  :bind (:map eglot-mode-map
	      ;; we just use the default binding here, so comment it out
	      ;; ("M-." . xref-find-definitions)
	      ;; ("M-?" . xref-find-references)
	      ;; ("M-," . xref-go-back)
	      ("C-c r"  . eglot-rename)
	      ("C-c h"  . eldoc))
  )

(use-package openwith
  :vc (:fetcher github :repo "garberw/openwith" :rev "master")
  :init (openwith-mode 1)
  :config (setq openwith-associations '(("\\.pdf\\'" "sioyek" (file)))))

(use-package which-key :ensure t
  :diminish which-key-mode
  :hook ((prog-mode text-mode outline-mode) . which-key-mode))

;; pdf-tools, only run this on windows
(use-package pdf-tools
  :if (eq system-type 'windows-nt)
  :disabled
  :defer t
  :pin manual
  :magic ("%PDF" . pdf-view-mode)
  :config
  (pdf-tools-install)
  (setq-default pdf-view-display-size 'fit-width)
  (define-key pdf-view-mode-map (kbd "C-s") 'isearch-forward)
  :custom
  (pdf-annot-activate-created-annotations t "automatically annotate highlights"))

(when (executable-find "ollama")
  (use-package ellama :ensure t
    :init
    ;; setup key bindings
    (setopt ellama-keymap-prefix "C-c e")
    ;; we only use the default model "zephyr:latest"
    ;; TODO : adding new models
    ;; language you want ellama to translate to
    (setopt ellama-language "French")))