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
  ))

(with-eval-after-load 'better-jumper
  (map!
  :desc "Jump Forward"
  "C-i" #'better-jumper-jump-forward))

(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)

  ;; 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 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"
     :ni "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
    (set-face-attribute 'org-block nil :background (face-background 'fringe))
    (set-face-attribute 'org-block-begin-line nil :background (face-background 'fringe))
    (set-face-attribute 'org-block-end-line nil :background (face-background 'fringe))
)

;; (after! org
;;   (setq org-src-block-faces
;;     '(("emacs-lisp" (:background (face-background 'org-block)))
;;       ("matlab" (:background (face-background 'fringe)))))
;; )

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

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

(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")))
  )

(defun tdh-matlab-whos (&optional start end)
"Get what is in the Matlab workspace"
  (interactive)
  (if (use-region-p)
    (let ((regionp (buffer-substring (region-beginning) (region-end))))
      (process-send-string "*MATLAB*" (concat "whosEmacs " regionp "\n")))
    (process-send-string "*MATLAB*" (concat "whosEmacs" "\n"))))

(defun tdh-matlab-help (&optional start end)
  "Get help on the selected function"
  (interactive)
  (if (use-region-p)
    (let ((regionp (buffer-substring (region-beginning) (region-end))))
        (process-send-string "*MATLAB*" (concat "help " regionp "\n")))
    (process-send-string "*MATLAB*" (concat "help " (read-string "Matlab help:") "\n")))
  )

(defun tdh-matlab-run-command ()
  "Prompt user to enter a matlab command"
  (interactive)
  (process-send-string "*MATLAB*" (concat (read-string "Matlab Command: ") "\n")))

(defun tdh-matlab-run-command-show-output ()
  "Prompt user to enter a matlab command"
  (interactive)
  (process-send-string "*MATLAB*" (concat "evalEmacs('" (read-string "Matlab Command: ") "')\n")))

(defun tdh-matlab-tangle-and-execute ()
  "Jump to tangle file for the source block at point."
  (interactive)
  (let (file org-babel-pre-tangle-hook org-babel-post-tangle-hook)
    (cl-letf (((symbol-function 'write-region) (lambda (start end filename &rest _ignore)
                         (setq file filename)))
          ((symbol-function 'delete-file) #'ignore))
      (org-babel-tangle '(4)))
    (when file
      (setq file (expand-file-name file))
      (if (file-readable-p file)
      (process-send-string "*MATLAB*" (concat "run " file "\n"))
    (error "Cannot open tangle file %S" file)))))

(after! org
  (map! :map org-mode-map
        (:prefix (",m" . "Matlab")
        :n  "e" 'tdh-matlab-run-command
        :n  "E" 'tdh-matlab-run-command-show-output
        :n  "T" 'tdh-matlab-tangle-and-execute
        :nv "h" 'tdh-matlab-help
        :nv "w" 'tdh-matlab-whos)))

(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"))))

  (if (in-src-block-p)
      (progn
        (org-babel-execute-src-block)
        (org-babel-next-src-block))
    (+org--insert-item 'below)))

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

(defun tdh-org-babel-tangle-subtree ()
  "Tangle the current subtree"
  (interactive)
  (progn
    (org-narrow-to-subtree)
    (org-babel-tangle)
    (widen))
  )

(defun tdh-org-babel-jump-to-tangle-file ()
  "Jump to tangle file for the source block at point."
  (interactive)
  (let (file org-babel-pre-tangle-hook org-babel-post-tangle-hook)
    (cl-letf (((symbol-function 'write-region) (lambda (start end filename &rest _ignore)
                         (setq file filename)))
          ((symbol-function 'delete-file) #'ignore))
      (org-babel-tangle '(4)))
    (when file
      (setq file (expand-file-name file))
      (if (file-readable-p file)
      (find-file file)
    (error "Cannot open tangle file %S" file)))))

(after! org
  (map! :map org-mode-map
        (:prefix (",b" . "Tangle")
        :n  "F" 'tdh-org-babel-jump-to-tangle-file
        :n  "T" 'tdh-org-babel-tangle-subtree)))

(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)

(with-eval-after-load 'font-latex
  (set-face-attribute 'font-latex-math-face nil :foreground (face-foreground 'org-meta-line))
)

(setq-default TeX-master nil)

(setq TeX-view-program-selection '((output-pdf "Zathura")))
(setq TeX-source-correlate-mode t)
(setq TeX-source-correlate-start-server t)
(setq TeX-source-correlate-method 'synctex)
(setq TeX-view-program-list
      '(("PDF Tools" TeX-pdf-tools-sync-view)))

(use-package! bibtex
  :config
  (bibtex-set-dialect 'BibTeX))

(use-package! helm-bibtex
  :init
  :config
  ;; Bibliography file
  (setq bibtex-completion-bibliography "~/Cloud/thesis/ressources/references.bib")

  ;; Directory with all the pdfs
  (setq bibtex-completion-library-path "~/Cloud/thesis/ressources/pdfs")

  ;; Directory with notes files
  (setq bibtex-completion-notes-path "~/Cloud/thesis/ressources/notes/notes.org")

  (setq bibtex-completion-notes-extension ".org")

  (setq bibtex-completion-pdf-extension '(".pdf" ".djvu"))

  ;; Use "tags" field when looking for bib entries
  (setq helm-bibtex-additional-search-fields '(tags))

  (setq helm-bibtex-full-frame nil)

  ;; Display of bibtex entries with helm
  (setq bibtex-completion-display-formats
          '((t . "${author:36} ${title:*} ${year:4} ${=type=:7} ${=has-note=:1}")))

  ;; Special symbols for notes and pdf
  (setq bibtex-completion-pdf-symbol "⌘")
  (setq bibtex-completion-notes-symbol "✎")

  ;; Template used when creating new Note file
  (setq bibtex-completion-notes-template-multiple-files (concat "#+TITLE: ${title}\n"
    ":DRAWER:\n"
    "#+LATEX_CLASS: biblioreport\n"
    "\n"
    "#+OPTIONS: toc:nil title:nil\n"
    "#+OPTIONS: ':t -:t\n"
    "\n"
    "#+LATEX_HEADER: \\newcommand{\\refType}{${=type=}}\n"
    "#+LATEX_HEADER: \\newcommand{\\refKey}{${=key=}}\n"
    "#+LATEX_HEADER: \\newcommand{\\refTitle}{${title}}\n"
    "#+LATEX_HEADER: \\newcommand{\\refAuthor}{${author-or-editor}}\n"
    "#+LATEX_HEADER: \\newcommand{\\refJournal}{${journal}}\n"
    "#+LATEX_HEADER: \\newcommand{\\refYear}{${year}}\n"
    "#+LATEX_HEADER: \\newcommand{\\refDoi}{${DOI}}\n"
    "#+LATEX_HEADER: \\newcommand{\\refUrl}{${url}}\n"
    "#+LATEX_HEADER: \\newcommand{\\refKeywords}{${tags}}\n"
    "#+LATEX_HEADER: \\input{config.tex}\n"
    "#+LATEX_HEADER: \\graphicspath{{./figs/${=key=}/}}\n"
    "# #+TOC: headlines 2\n"
    ":END:\n"
    "\n"
    "#+BEGIN_abstract\n"
    "\n"
    "#+END_abstract\n"
    "\n"
    "* ${title} :${=type=}:ignore:\n"
    ":PROPERTIES:\n"
    ":CUSTOM_ID: ${=key=}\n"
    ":AUTHOR:    ${author}\n"
    ":TYPE:      ${=type=}\n"
    ":JOURNAL:   ${journal}\n"
    ":YEAR:      ${year}\n"
    ":VOLUME:    ${volume}\n"
    ":PAGES:     ${pages}\n"
    ":DOI:       ${DOI}\n"
    ":URL:       ${url}\n"
    ":NOTER_DOCUMENT: ../pdfs/${=key=}.pdf\n"
    ":END:\n"
    "\n"))

  (setq bibtex-completion-notes-template-one-file (concat "\n"
    "* ${author-abbrev} (${year}): ${title} :${=type=}:ignore:\n"
    ":PROPERTIES:\n"
    ":CUSTOM_ID: ${=key=}\n"
    ":EXPORT_FILE_NAME: ${=key=}\n"
    ":EXPORT_TITLE: ${title}\n"
    ":AUTHOR:    ${author}\n"
    ":TYPE:      ${=type=}\n"
    ":JOURNAL:   ${journal}\n"
    ":YEAR:      ${year}\n"
    ":VOLUME:    ${volume}\n"
    ":PAGES:     ${pages}\n"
    ":DOI:       ${DOI}\n"
    ":URL:       ${url}\n"
    ":NOTER_DOCUMENT: ../pdfs/${=key=}.pdf\n"
    ":END:\n"
    "\n"))

  ;; Make "Edit notes" the default action
  (helm-delete-action-from-source "Edit notes" helm-source-bibtex)
  (helm-add-action-to-source "Edit notes" 'helm-bibtex-edit-notes helm-source-bibtex 0)

  (helm-delete-action-from-source "Open PDF Externally" helm-source-bibtex)
  (helm-add-action-to-source "Open PDF Externally" 'tdehaeze/open-pdf-externally helm-source-bibtex 1)
)