Doom Emacs Configuration

(global-visual-line-mode nil)

(auto-fill-mode -1)
(remove-hook 'text-mode-hook 'turn-on-auto-fill)
;; turn on auto-fill for text-mode
(add-hook 'text-mode-hook 'turn-on-auto-fill)
(after! org
  ;; turn off auto-fill for org-mode
  (add-hook 'org-mode-hook 'turn-off-auto-fill))

(setq alert-default-style 'libnotify)

(setq create-lockfiles nil)

(global-hl-line-mode -1)
(after! org
  (add-hook 'org-mode-hook
      (lambda()
          (hl-line-mode -1)
          (global-hl-line-mode -1))
      't
  ))

(after! org
  (setq org-directory "~/Cloud/org/")

  ;; Replace the content marker, “⋯”, with a nice unicode arrow.
  (setq org-ellipsis " ⤵")

  (setq org-default-notes-file "~/Cloud/org/refile.org")

  ;; Avoid accidentally editing folded regions, say by adding text after an Org “⋯”.
  (setq org-catch-invisible-edits 'show)

  ;; Highligh latex parts in org mode
  (setq org-highlight-latex-and-related '(native))

  ;; The following setting hides blank lines between headings which keeps folded view nice and compact.
  (setq org-cycle-separator-lines 0)

  ;; Indent according to the outline structure
  (setq org-startup-indented t)

  ;; Record the information of when the task was marked as DONE
  (setq org-log-done 'time)

  ;; begining of line on heading behavior
  (setq org-special-ctrl-a/e nil)
)

(after! evil-org
  (remove-hook 'org-tab-first-hook #'+org-cycle-only-current-subtree-h))

(after! org
  (setq font-latex-fontify-script nil))

(defvar tdh-org-latex-fragment-last nil
  "Holds last fragment/environment you were on.")

(defun tdh-org-in-latex-fragment-p ()
  "Return the point where the latex fragment begins, if inside
a latex fragment. Else return false"
  (let* ((el (org-element-context))
         (el-type (car el)))
    (and (or (eq 'latex-fragment el-type) (eq 'latex-environment el-type))
        (org-element-property :begin el))))

(defun tdh-org-latex-fragment-toggle ()
  "Toggle a latex fragment image "
  (and (eq 'org-mode major-mode)
 (let ((begin (tdh-org-in-latex-fragment-p)))
         (cond
          ;; were on a fragment and now on a new fragment
          ((and
            ;; fragment we were on
            tdh-org-latex-fragment-last
            ;; and are on a fragment now
            begin

            ;; but not on the last one this is a little tricky. as you edit the
            ;; fragment, it is not equal to the last one. We use the begin
            ;; property which is less likely to change for the comparison.
            (not (and tdh-org-latex-fragment-last
    (= begin
       tdh-org-latex-fragment-last))))
           ;; go back to last one and put image back, provided there is still a fragment there
           (save-excursion
             (goto-char tdh-org-latex-fragment-last)
             (when (tdh-org-in-latex-fragment-p) (org-preview-latex-fragment))

             ;; now remove current image
             (goto-char begin)
             (let ((ov (loop for ov in (org--list-latex-overlays)
                             if
                             (and
      (<= (overlay-start ov) (point))
      (>= (overlay-end ov) (point)))
                             return ov)))
   (when ov
                 (delete-overlay ov)))
             ;; and save new fragment
             (setq tdh-org-latex-fragment-last begin)))

          ;; were on a fragment and now are not on a fragment
          ((and
            ;; not on a fragment now
            (not begin)
            ;; but we were on one
            tdh-org-latex-fragment-last)
           ;; put image back on, provided that there is still a fragment here.
           (save-excursion
             (goto-char tdh-org-latex-fragment-last)
             (when (tdh-org-in-latex-fragment-p) (org-preview-latex-fragment)))

           ;; unset last fragment
           (setq tdh-org-latex-fragment-last nil))

          ;; were not on a fragment, and now are
          ((and
            ;; we were not one one
            (not tdh-org-latex-fragment-last)
            ;; but now we are
            begin)
           ;; remove image
           (save-excursion
             (goto-char begin)
             (let ((ov (loop for ov in (org--list-latex-overlays)
                             if
                             (and
      (<= (overlay-start ov) (point))
      (>= (overlay-end ov) (point)))
                             return ov)))
   (when ov
                 (delete-overlay ov))))
           (setq tdh-org-latex-fragment-last begin))))))

(after! org
  (setq org-image-actual-width t))

(after! org
  (map! :map org-mode-map "C-c l" 'org-store-link)

  (setq org-link-abbrev-alist
    '(("bib" . "~/Cloud/thesis/ressources/references.bib::%s")
      ("notes" . "~/Cloud/thesis/ressources/notes/notes.org::#%s")
      ("papers" . "~/Cloud/thesis/ressources/pdfs/%s.pdf")))
  )

(after! org
  ;; Align Tags and flush right
  (setq org-tags-column -78)
  ;; Tags with fast selection keys
  (setq org-tag-alist (quote (("@home" . ?h)
                              ("@work" . ?w)
                              ("@christophe" . ?c)
                              ("@veijo" . ?v))))
  )

(after! org
  (setq org-refile-targets '((org-agenda-files . (:maxlevel . 6))))
  )

(after! org
  ;; Tags with fast selection keys
  (setq org-todo-keywords '(
                              (sequence "TODO(t)" "NEXT(n)" "MAIL(m)" "|" "DONE(d)")
                              (sequence "READ(r)" "BKMK(b)" "EXER(x)" "|" "DONE(d)")
                              (sequence "WAIT(w@/!)" "SDAY(s)" "|" "CANC(c@/!)")
                              (sequence "QUES(q)" "|" "ANSW(a)")
                              (sequence "EXAM(e)" "IDEA(i)" "|")
                              ))

  ;; Display of the keywords
  (setq org-todo-keyword-faces
          '(("TODO" . (:foreground "#cc241d" :weight bold)) ;; red
          ("EXER" . (:foreground "#cc241d" :weight bold)) ;; red
          ("NEXT" . (:foreground "#cc241d" :weight bold)) ;; red
          ("MAIL" . (:foreground "#cc241d" :weight bold)) ;; red
          ("READ" . (:foreground "#cc241d" :weight bold)) ;; red
          ("ANSW" . (:foreground "#689d6a" :weight bold)) ;; aqua
          ("DONE" . (:foreground "#689d6a" :weight bold)) ;; aqua
          ("WAIT" . (:foreground "#d65d0e" :weight bold)) ;; orange
          ("QUES" . (:foreground "#d79921" :weight bold)) ;; yellow
          ("CANC" . (:foreground "#a89984" :weight bold)) ;; grey
          ("SDAY" . (:foreground "#98971a" :weight bold)) ;; green
          ("BKMK" . (:foreground "#98971a" :weight bold)) ;; green
          ("IDEA" . (:foreground "#98971a" :weight bold)) ;; green
          ("EXAM" . (:foreground "#98971a" :weight bold)))) ;; green
  )

(after! org
  (defadvice org-archive-subtree (around fix-hierarchy activate)
      (let* ((fix-archive-p (and (not current-prefix-arg)
                              (not (use-region-p))))
          (location (org-archive--compute-location org-archive-location))
          (afile (car location))
          (offset (if (= 0 (length (cdr location)))
                      1
                      (1+ (string-match "[^*]" (cdr location)))))
          (buffer (or (find-buffer-visiting afile) (find-file-noselect afile))))
      ad-do-it
      (when fix-archive-p
          (with-current-buffer buffer
          (goto-char (point-max))
          (while (> (org-current-level) offset) (org-up-heading-safe))
          (let* ((olpath (org-entry-get (point) "ARCHIVE_OLPATH"))
                  (path (and olpath (split-string olpath "/")))
                  (level offset)
                  tree-text)
              (when olpath
              (org-mark-subtree)
              (setq tree-text (buffer-substring (region-beginning) (region-end)))
              (let (this-command) (org-cut-subtree))
              (goto-char (point-min))
              (save-restriction
                  (widen)
                  (-each path
                  (lambda (heading)
                      (if (re-search-forward
                          (rx-to-string
                          `(: bol (repeat ,level "*") (1+ " ") ,heading)) nil t)
                          (org-narrow-to-subtree)
                      (goto-char (point-max))
                      (unless (looking-at "^")
                          (insert "\n"))
                      (insert (make-string level ?*)
                              " "
                              heading
                              "\n"))
                      (cl-incf level)))
                  (widen)
                  (org-end-of-subtree t t)
                  (org-paste-subtree level tree-text))))))))
)

(use-package! org-fancy-priorities ; priority icons
  :hook (org-mode . org-fancy-priorities-mode)
  :config (setq org-fancy-priorities-list '("■" "■" "■")))

(after! org-agenda
  (setq appt-message-warning-time 5)
  (defun tdh-org-agenda-to-appt ()
      (interactive)
      (setq appt-time-msg-list nil)
      (org-agenda-to-appt))

  (tdh-org-agenda-to-appt)
  ; Display appointments as a window manager notification
  (setq appt-disp-window-function 'tdh-appt-display)
  (setq appt-delete-window-function (lambda () t))

  (setq tdh-appt-notification-app (concat (getenv "HOME") "/bin/appt-notification"))
  (defun tdh-appt-display (min-to-app new-time msg)
      (if (atom min-to-app)
          (start-process "tdh-appt-notification-app" nil tdh-appt-notification-app min-to-app msg)
          (dolist (i (number-sequence 0 (1- (length min-to-app))))
          (start-process "tdh-appt-notification-app" nil tdh-appt-notification-app (nth i min-to-app) (nth i msg)))))
  )

(after! org
  (setq org-structure-template-alist
    '(("c" . "center")
      ("C" . "comment")
      ("m" . "src matlab\n")
      ("l" . "src emacs-lisp\n")
      ("i" . "important")
      ("e" . "example")
      ("q" . "quote")
      ("s" . "src")))
)

(after! org
  (map! :map org-mode-map "C-c c" 'org-capture))

(after! org
  (setq org-capture-templates
          (quote (("t"    ; key
                  "todo" ; name
                  entry  ; type
                  (file+headline "~/Cloud/org/work-notebook.org" "Inbox") ; target
                  "** TODO %?\n%U\n" ; template
                  )
                  ("M"    ; key
                  "Meeting" ; name
                  entry  ; type
                  (file+headline "~/Cloud/org/work-notebook.org" "Meetings") ; target
                  "** %?\n%(org-insert-time-stamp (org-read-date nil t \"+0d\"))\n" ; template
                  )
                  ("m"    ; key
                  "mail" ; name
                  entry  ; type
                  (file+headline "~/Cloud/org/work-notebook.org" "Mails") ; target
                  "** TODO [#A] %?\nSCHEDULED: %(org-insert-time-stamp (org-read-date nil t \"+0d\"))\n%a\n" ; template
                  )
                  ("pm"
                  "Org-Protocol Mail"
                  entry
                  (file+headline "~/Cloud/org/work-notebook.org" "Mails")
                  "* MAIL %:description [[message:%:link][link]]\nSCHEDULED: %(org-insert-time-stamp (org-read-date nil t \"+0d\"))\n\n"
                  :immediate-finish t
                  )
                  ("pu"
                  "Org-Protocol Url"
                  entry
                  (file+headline "~/Cloud/org/work-notebook.org" "Inbox")
                  "* [[%:link][%:description]]\nCaptured On: %U\n\n"
                  :immediate-finish t
                  )
                  ("pt"
                  "Org-Protocol text"
                  entry
                  (file+headline "~/Cloud/org/work-notebook.org" "Inbox")
                  "* %:description\nSource: %:link\nCaptured On: %U\n\n#+BEGIN_QUOTE\n%i\n#+END_QUOTE\n\n"
                  :immediate-finish t
                  )
                  )))
)

(after! org
  (add-to-list 'org-src-lang-modes '("latex-macros" . latex))

  (defvar org-babel-default-header-args:latex-macros
    '((:results . "raw")
      (:exports . "results")))

  (defun prefix-all-lines (pre body)
    (with-temp-buffer
      (insert body)
      (string-insert-rectangle (point-min) (point-max) pre)
      (buffer-string)))

  (defun org-babel-execute:latex-macros (body _params)
    (concat
     "\n#+HTML_HEAD_EXTRA: <div style=\"display: none\"> \\(\n"
     (prefix-all-lines "#+HTML_HEAD_EXTRA: " body)
     "\n#+HTML_HEAD_EXTRA: \\)</div>\n"))
  )

(defun tdh-org-include-img-from-pdf (&rest _)
  "Convert pdf files to image files in org-mode bracket links.
    # ()convertfrompdf:t # This is a special comment; tells that the upcoming
                         # link points to the to-be-converted-to file.
    # If you have a foo.pdf that you need to convert to foo.png, use the
    # foo.png file name in the link.
    [[./foo.png]]
"
  (interactive)
  (if (executable-find "convert")
      (save-excursion
        (goto-char (point-min))
        (while (re-search-forward "^[ \t]*#\\s-+()convertfrompdf\\s-*:\\s-*t"
                                  nil :noerror)
          ;; Keep on going to the next line till it finds a line with bracketed
          ;; file link.
          (while (progn
                   (forward-line 1)
                   (not (looking-at org-bracket-link-regexp))))
          ;; Get the sub-group 1 match, the link, from `org-bracket-link-regexp'
          (let ((link (match-string-no-properties 1)))
            (when (stringp link)
              (let* ((imgfile (expand-file-name (file-name-sans-extension link)))
                     (pdffile (expand-file-name
                               (concat imgfile
                                       "." "pdf")))
                     (cmd (concat "pdftocairo -png -transp -singlefile "
                                  pdffile " " imgfile)))

                (message "%s" imgfile)
                (when (and (file-readable-p pdffile)
                           (file-newer-than-file-p pdffile imgfile))
                  ;; This block is executed only if pdffile is newer than
                  ;; imgfile or if imgfile does not exist.
                  (shell-command cmd)
                  (message "%s" cmd)))))))
    (user-error "`convert' executable (part of Imagemagick) is not found")))
  (add-hook 'org-export-before-processing-hook #'tdh-org-include-img-from-pdf)

(add-to-list 'image-type-file-name-regexps '("\\.pdf\\'" . imagemagick))
(add-to-list 'image-file-name-extensions "pdf")
(setq imagemagick-types-inhibit (remove 'PDF imagemagick-types-inhibit))

(defun tdh-latex-filter-nobreaks (text backend info)
  "Ensure \" \" are properly handled in LaTeX export."
  (when (org-export-derived-backend-p backend 'latex)
    (replace-regexp-in-string " " "~" text)))

(add-to-list 'org-export-filter-plain-text-functions
            'tdh-latex-filter-nobreaks)

(setq image-file-name-extensions
   (quote
    ("png" "jpeg" "jpg" "gif" "tiff" "tif" "xbm" "xpm" "pbm" "pgm" "ppm" "pnm" "svg" "pdf" "bmp")))

(setq org-imagemagick-display-command "convert -density 600 \"%s\" -thumbnail \"%sx%s>\" \"%s\"")
(defun org-display-inline-images (&optional include-linked refresh beg end)
  "Display inline images.
Normally only links without a description part are inlined, because this
is how it will work for export.  When INCLUDE-LINKED is set, also links
with a description part will be inlined.  This
can be nice for a quick
look at those images, but it does not reflect what exported files will look
like.
When REFRESH is set, refresh existing images between BEG and END.
This will create new image displays only if necessary.
BEG and END default to the buffer boundaries."
  (interactive "P")
  (unless refresh
    (org-remove-inline-images)
    (if (fboundp 'clear-image-cache) (clear-image-cache)))
  (save-excursion
    (save-restriction
      (widen)
      (setq beg (or beg (point-min)) end (or end (point-max)))
      (goto-char beg)
      (let ((re (concat "\\[\\[\\(\\(file:\\)\\|\\([./~]\\)\\)\\([^]\n]+?"
                        (substring (org-image-file-name-regexp) 0 -2)
                        "\\)\\]" (if include-linked "" "\\]")))
            old file ov img)
        (while (re-search-forward re end t)
          (setq old (get-char-property-and-overlay (match-beginning 1)
                                                   'org-image-overlay)
        file (expand-file-name
                      (concat (or (match-string 3) "") (match-string 4))))
          (when (file-exists-p file)
            (let ((file-thumb (format "%s%s_thumb.png" (file-name-directory file) (file-name-base file))))
              (if (file-exists-p file-thumb)
                  (let ((thumb-time (nth 5 (file-attributes file-thumb 'string)))
                        (file-time (nth 5 (file-attributes file 'string))))
                    (if (time-less-p thumb-time file-time)
            (shell-command (format org-imagemagick-display-command
                           file org-image-actual-width org-image-actual-width file-thumb) nil nil)))
                (shell-command (format org-imagemagick-display-command
                                         file org-image-actual-width org-image-actual-width file-thumb) nil nil))
              (if (and (car-safe old) refresh)
                  (image-refresh (overlay-get (cdr old) 'display))
                (setq img (save-match-data (create-image file-thumb)))
                (when img
                  (setq ov (make-overlay (match-beginning 0) (match-end 0)))
                  (overlay-put ov 'display img)
                  (overlay-put ov 'face 'default)
                  (overlay-put ov 'org-image-overlay t)
                  (overlay-put ov 'modification-hooks
                               (list 'org-display-inline-remove-overlay))
                  (push ov org-inline-image-overlays))))))))))

(defun tdh-change-png-to-pdf (text backend info)
  "Change png images to pdf images when existing"
  (when (org-export-derived-backend-p backend 'latex)
    (let ((text (replace-regexp-in-string "[^\\w]\\(:\\)[^\n\t\r]+\\(:\\)[^\\w]" "<mark>"  text nil nil 1 nil)))
      (replace-regexp-in-string "[^\\w]\\(<mark>\\)[^\n\t\r]+\\(:\\)[^\\w]" "</mark>" text nil nil 2 nil))))

(add-to-list 'org-export-filter-plain-text-fucntions 'tdh-html-mark-tag)

(save-excursion
        (goto-char (point-min))
        (while (re-search-forward "^[ \t]*#\\s-+()convertfrompdf\\s-*:\\s-*t"
                                  nil :noerror)
          ;; Keep on going to the next line till it finds a line with bracketed
          ;; file link.
          (while (progn
                   (forward-line 1)
                   (not (looking-at org-bracket-link-regexp))))
          ;; Get the sub-group 1 match, the link, from `org-bracket-link-regexp'
          (let ((link (match-string-no-properties 1)))
            (when (stringp link)
              (let* ((imgfile (expand-file-name link))
                     (pdffile (expand-file-name
                               (concat (file-name-sans-extension imgfile)
                                       "." "pdf")))
                     (cmd (concat "convert -density 96 -quality 85 "
                                  pdffile " " imgfile)))
                (when (and (file-readable-p pdffile)
                           (file-newer-than-file-p pdffile imgfile))
                  ;; This block is executed only if pdffile is newer than
                  ;; imgfile or if imgfile does not exist.
                  (shell-command cmd)
                  (message "%s" cmd)))))))

(use-package! org-ref
  :after org
  :init
  :config
  ;; Folder where the notes files are located (or file if just one Note file)
  (setq org-ref-notes-directory "~/Cloud/thesis/ressources/notes")
  (setq org-ref-bibliography-notes "~/Cloud/thesis/ressources/notes")

  ;; Bibliography File
  (setq reftex-default-bibliography  '("~/Cloud/thesis/ressources/references.bib"))
  (setq org-ref-default-bibliography '("~/Cloud/thesis/ressources/references.bib"))

  ;; Folder where all the pdf are located
  (setq org-ref-pdf-directory "~/Cloud/thesis/ressources/pdfs")

  ;; Tell org-ref to let helm-bibtex find notes for it
  (setq org-ref-notes-function
        (lambda (thekey)
          (let ((bibtex-completion-bibliography (org-ref-find-bibliography)))
            (bibtex-completion-edit-notes
             (list (car (org-ref-get-bibtex-key-and-file thekey)))))))

  ;; Problem with speed: don't display broken links
  (setq org-ref-show-broken-links t)
  ;; Display information on the citation
  (setq org-ref-show-citation-on-enter t)

  (add-to-list 'org-ref-helm-user-candidates
               '("Open pdf in Zathura" . (lambda () (call-process "zathura" nil 0 nil  (concat
                                                                                        (file-name-as-directory org-ref-pdf-directory)
                                                                                        (car (org-ref-get-bibtex-key-and-file))
                                                                                        ".pdf"))))
               t)

  (add-to-list 'org-ref-helm-user-candidates
               '("Drag and Drop" . (lambda () (call-process "/bin/bash" nil 0 nil "-c" (concat
                                                                                        "dragon-drag-and-drop "
                                                                                        (file-name-as-directory org-ref-pdf-directory)
                                                                                        (car (org-ref-get-bibtex-key-and-file))
                                                                                        ".pdf"))))
               t)

  (map!
   :map org-mode-map
   (:desc "Insert Link"
     :n "C-c i" #'org-ref-insert-ref-link))
  )

(defun tdh-org-ref-open-pdf-at-point ()
  "Open the pdf in external program for bibtex key under point if it exists."
  (interactive)
  (let* ((results (org-ref-get-bibtex-key-and-file))
         (key (car results))
         (pdf-file (funcall org-ref-get-pdf-filename-function key)))
    (if (file-exists-p pdf-file)
        (call-process "zathura" nil 0 nil pdf-file)
      (message "no pdf found for %s" key))))

(use-package! org-noter
  :defer t
  :after (:any org pdf-view)
  :config
  (setq org-noter-always-create-frame nil)

  (setq org-noter-kill-frame-at-session-end nil)

  ;; Fraction of the frame that the document window will occupy when split
  (setq org-noter-doc-split-fraction '(0.6 . 0.6))

  ;; Save the last visited location automatically; when starting a new session, go to that location
  (setq org-noter-auto-save-last-location nil)

  ;; Add an empty line between each note's heading and content
  (setq org-noter-separate-notes-from-heading t)

  ;; List of paths to check (non recursively) when searching for a notes file
  (setq org-noter-notes-search-path "~/Cloud/thesis/ressources/notes")

  (defun org-noter-init-pdf-view ()
    (pdf-view-fit-page-to-window)
    (pdf-view-auto-slice-minor-mode)
    (run-at-time "0.5 sec" nil #'org-noter))
  (add-hook 'pdf-view-mode-hook 'org-noter-init-pdf-view)

  (map!
   :map pdf-view-mode-map
   (:desc "Insert Note"
     :n "i" #'org-noter-insert-note))
  )

(setq org-publish-project-alist
      '(("config"
         :base-directory "~/.config/literate-dotfiles/dotfiles/"
         :publishing-directory "~/.config/literate-dotfiles/docs/"
         :recursive nil
         :publishing-function org-html-publish-to-html
         :auto-sitemap nil
         :section-numbers nil
         :table-of-contents nil)
        ("stewart-simscape"
         :base-directory "~/Cloud/thesis/matlab/stewart-simscape/org/"
         :base-extension "org"
         :publishing-directory "~/Cloud/thesis/matlab/stewart-simscape/docs/"
         :author "Dehaeze Thomas"
         :email "dehaeze.thomas@gmail.com/"
         :recursive nil
         :publishing-function org-html-publish-to-html
         :auto-preamble t
         :auto-sitemap nil
         :html-link-up "index.html"
         :html-link-home "index.html"
         :with-todo-keywords nil
         :html-wrap-src-lines nil
         :table-of-contents nil)
        ("bibliography"
         :base-directory "~/Cloud/thesis/ressources/notes/"
         :base-extension "org"
         :publishing-directory "~/Cloud/thesis/ressources/docs/"
         :author "Dehaeze Thomas"
         :email "dehaeze.thomas@gmail.com/"
         :recursive nil
         :publishing-function org-html-publish-to-html
         :auto-preamble t
         :auto-sitemap nil
         :html-link-up "index.html"
         :html-link-home "index.html"
         :with-todo-keywords nil
         :html-wrap-src-lines nil
         :table-of-contents nil)
        ("nass-simscape"
         :base-directory "~/Cloud/thesis/matlab/nass-simscape/org/"
         :base-extension "org"
         :publishing-directory "~/Cloud/thesis/matlab/nass-simscape/docs/"
         :author "Dehaeze Thomas"
         :email "dehaeze.thomas@gmail.com/"
         :recursive nil
         :publishing-function org-html-publish-to-html
         :auto-preamble t
         :auto-sitemap nil
         :html-link-up "index.html"
         :html-link-home "index.html"
         :with-todo-keywords nil
         :html-wrap-src-lines nil
         :table-of-contents nil)
        ("tikz-maker"
         :base-directory "~/Cloud/thesis/latex/org/"
         :base-extension "org"
         :publishing-directory "~/Cloud/thesis/latex/docs/"
         :author "Dehaeze Thomas"
         :email "dehaeze.thomas@gmail.com/"
         :recursive nil
         :publishing-function org-html-publish-to-html
         :auto-preamble t
         :auto-sitemap nil
         :html-link-up "index.html"
         :html-link-home "index.html"
         :with-todo-keywords nil
         :html-wrap-src-lines nil
         :table-of-contents nil)))

(after! org
  (defun tdh-eval-startblock ()
      (if (member "startblock" (org-babel-src-block-names))
      (save-excursion
          (org-babel-goto-named-src-block "startblock")
          (org-babel-execute-src-block))
      nil
      )
      )

  (add-hook 'org-mode-hook 'tdh-eval-startblock)
)

;; required libraries
(require 'dash)
;; (require 'swiper)
(require 's)

;; start directory
(defvar tdh-image-dir (expand-file-name "/home/thomas/Pictures"))

(defun tdh-insert-conference-image ()
  "Insert image from conference directory, rename and add link in current file.

The file is taken from a start directory set by `tdh-image-dir' and moved to the current directory, renamed and embedded at the point as an org-mode link. The user is presented with a list of files in the start directory, from which to select the file to move, sorted by most recent first."
  (interactive)
  (let (file-list target-dir file-list-sorted start-file start-file-full file-ext end-file end-file-base end-file-full file-number)
    ;; Clean directories from list but keep times
    (setq file-list
          (-remove (lambda (x) (nth 1 x))
                   (directory-files-and-attributes tdh-image-dir)))

    ;; Get target directory
    (setq target-dir (file-name-directory (buffer-file-name)))

    ;; Sort list by most recent
    (setq file-list-sorted
          (mapcar #'car
                  (sort file-list
                        #'(lambda (x y) (time-less-p (nth 6 y) (nth 6 x))))))

    ;; Use ivy to select start-file
    (setq start-file (ivy-read
                      (concat "Move selected file to " target-dir ":")
                      file-list-sorted
                      :re-builder #'ivy--regex
                      :sort nil
                      :initial-input nil))

    ;; add full path to start file and end-file
    (setq start-file-full
          (expand-file-name start-file tdh-image-dir))

    ;; final file name including path
    (setq end-file-full
          (expand-file-name start-file target-dir))

    ;; rename file
    (rename-file start-file-full end-file-full)
    (message "moved %s to %s" start-file-full start-file)

    ;; insert link
    (insert (org-make-link-string (format "file:%s" start-file)))

    ;; display image
    (org-display-inline-images t t)))

(after! org
  (defun tdh-render-org-table-at-point ()
      (interactive)
      (save-excursion
      (beginning-of-line)
      ;; removes the overlay is already there
      (if (overlays-at (point))
          (delete-overlay (car (overlays-at (point))))

          (let* ((element-type (org-element-type (org-element-at-point))))
          (if (and (not (eq element-type 'table))
                  (not (eq element-type 'table-row)))
              (error "not at an org table")

              (while (not (eq 'table (org-element-type (org-element-at-point))))
              (forward-line -1))
              (tdh-render-org-table (org-element-at-point))
              )))))


  (defun tdh-render-org-table (table)
      (interactive)
      (let* ((begin (org-element-property :begin table))
          (end (let ((pos (org-element-property :end table)))
                  (goto-char pos)
                  (beginning-of-line)
                  ;; skip possible space after table
                  (while (not (looking-at " *[|#]"))
                      (setq pos (point))
                      (forward-line -1))
                  pos))
          (tabletxt (buffer-substring-no-properties begin end))
          (img (with-temp-buffer
                  (insert tabletxt)
                  (mark-whole-buffer)
                  (org-latex-convert-region-to-latex)
                  (org-latex-preview)
                  (goto-char (point-min))
                  (overlay-get  (car (overlays-at (point))) 'display)))
          (overlay (make-overlay begin end)))
      (overlay-put overlay 'display img)
      (forward-line -1))
      )


  (defun tdh-render-org-tables-in-buffer ()
      (save-excursion
      (org-element-map (org-element-parse-buffer) 'table 'tdh-render-org-table)))

  ;; Use F9 to globally generate tables
  (map! :map org-mode-map :n "<f8>" (lambda () (interactive) (tdh-render-org-table-at-point)))
)

(use-package! org-gcal
  :after org
  :init
  :config
  (setq org-gcal-client-id "396102378658-dcmbcmrnthbe925519otsjbd921otq0v.apps.googleusercontent.com"
        org-gcal-client-secret "4M5PWrbhQjwYEMXGK85lDYX9"
        org-gcal-file-alist '(("dehaeze.thomas@gmail.com" . "~/Cloud/org/gcal.org")
                              ("8kjmhe2ar0abnm054ill1fb0gc@group.calendar.google.com" . "~/Cloud/org/gcal_phd.org")))
  ;; Automatic fetch of the new events
  ;; (add-hook 'org-agenda-mode-hook (lambda () (org-gcal-fetch) ))
)

(defun tdh-org-confirm-babel-evaluate (lang body)
    (not (member lang '("emacs-lisp" "latex" "matlab" "sh" "latex-macros"))))

(after! org
  (setq org-confirm-babel-evaluate 'tdh-org-confirm-babel-evaluate))

(after! org
  (setq org-src-window-setup 'current-window))

(defun tdh-org-prettify-symbols ()
  (mapc (apply-partially 'add-to-list 'prettify-symbols-alist)
        (cl-reduce 'append
                   (mapcar (lambda (x) (list x (cons (upcase (car x)) (cdr x))))
                           `(("#+begin_src" . ?✎)
                             ("#+end_src"   . ?□)
                             ("#+begin_quote" . ?«)
                             ("#+end_quote" . ?»)))))
  (turn-on-prettify-symbols-mode))
(add-hook 'org-mode-hook #'tdh-org-prettify-symbols)

(after! org
  (org-babel-lob-ingest "~/Cloud/thesis/org-mode/org-babel-tutorial/org-babel-library.org"))

(defun tdh-ctrl-ret ()
    (interactive)
    (defun in-src-block-p ()
      "Returns t when the point is inside a source code block"
      (string= "src" (org-in-block-p '("src"))))

    (defun in-src-block-function ()
      "Function to do when inside the src block"
      (progn
          (org-babel-execute-src-block)
          (org-babel-next-src-block)))

    (if (in-src-block-p)
        (in-src-block-function)
        (+org--insert-item 'below)))

(map! :after evil-org
      :map evil-org-mode-map
      :n "<C-return>" #'tdh-ctrl-ret)

(defun tdh-ctrl-shit-ret ()
    (interactive)
    (defun in-src-block-p ()
    "Returns t when the point is inside a source code block"
    (string= "src" (org-in-block-p '("src"))))

    (if (in-src-block-p)
        (tdh-org-babel-execute-goto-next)
    (+org/insert-item-above)))

(map! :after evil-org
      :map evil-org-mode-map
      :n "<C-S-return>" #'tdh-ctrl-shit-ret)

(after! org
  (setq org-babel-matlab-shell-command "/home/thomas/bin/matlab -nodesktop -nosplash")

  (setq org-babel-matlab-emacs-link-wrapper-method
      "%s
      if ischar(ans);
      echo('test');
      fid = fopen('%s', 'w');
      fprintf(fid, '%s', ans);
      fclose(fid);
      else;
      save -ascii %s ans;
      end
      delete('%s');
      ")
  )

(after! org
  (setq org-babel-default-header-args:matlab
          '((:results . "none")
          (:session . "*MATLAB*")
          (:comments . "org")
          (:exports . "both")
          (:cache .   "no")
          (:noweb . "no")
          (:hlines . "no")
          (:tangle . "no")
          (:mkdir . "yes")
          (:eval . "no-export")))
  )

;; (after! org
;;   (require 'color)
;;   (set-face-attribute 'org-block nil :background (color-darken-name (face-attribute 'default :background) 3))
;;   )

(after! org
  (setq org-edit-src-content-indentation 2
        org-src-tab-acts-natively nil
        org-src-preserve-indentation nil)
  )

(defun latex/clean ()
  "Clean LaTeX output using latexmk"
  (interactive)
  (async-shell-command
   ;; command and parameters
   "latexmk -c "
   (shell-quote-argument buffer-file-name)
   " &"
  ))

(map! :map LaTeX-mode-map :n ",C" 'latex/clean)

(add-hook 'TeX-mode-hook #'TeX-fold-mode)

(setq-default TeX-master nil)