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)
;; 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)
(add-hook 'org-mode-hook
(lambda()
    (hl-line-mode -1)
    (global-hl-line-mode -1))
't
)

(require 'org)

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

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

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

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

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

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

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

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

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

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

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

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

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

(setq org-structure-template-alist
      '(("c" . "center")
        ("C" . "comment")
        ("i" . "important")
        ("e" . "example")
        ("q" . "quote")
        ("s" . "src"))
)

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

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

(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))
(setq org-image-actual-width 600)

(defun my-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
            'my-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-image-actual-width 600)

(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 'my-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
    :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)
      (bibtex-set-dialect 'BibTeX)
    )

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

(map! :map org-mode-map :n ",l" 'org-latex-export-to-latex)

(defun tdh/open-org-pdf-externally ()
  (interactive)
  (call-process "xdg-open" nil 0 nil (concat (file-name-sans-extension (buffer-file-name)) ".pdf"))
  )

(map! :map org-mode-map :n ",vp" 'tdh/open-org-pdf-externally)

(defun tdh/open-org-html-externally ()
  (interactive)
  (call-process "xdg-open" nil 0 nil (concat (file-name-sans-extension (buffer-file-name)) ".html"))
  )

(map! :map org-mode-map :n ",vh" 'tdh/open-org-html-externally)

(setq org-contacts-files (list "~/Cloud/org/contacts.org"))

(setq org-wunderlist-client-id "6799d9caeb2f5d8bd641"
      org-wunderlist-token "fd5965cde436c2587850a7c517d366561d8a1cbf7b6d96ab62f3fc8c9930"
      org-wunderlist-file "~/Cloud/thesis/todos/wunderlist.org"
      org-wunderlist-dir "~/.emacs.d/org-wunderlist/")

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

(defun my-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))
          (my-render-org-table (org-element-at-point))
          )))))


(defun my-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 my-render-org-tables-in-buffer ()
  (save-excursion
    (org-element-map (org-element-parse-buffer) 'table 'my-render-org-table)))

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

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

;; Don't ask for confirmation when evalutating latex blocs
(defun my-org-confirm-babel-evaluate (lang body)
  (not (member lang '("emacs-lisp" "latex" "matlab" "sh"))))
(setq org-confirm-babel-evaluate 'my-org-confirm-babel-evaluate)

;; Use the current window for C-c ' source editing
(setq org-src-window-setup 'current-window)

(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! :map evil-org-mode-map
       :n "<C-return>" #'tdh/ctrl-ret)

;; (evil-define-minor-mode-key 'normal 'org-src-mode "q" 'org-edit-src-exit)

(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! :map evil-org-mode-map
       :n "<C-S-return>" #'tdh/ctrl-shit-ret)

(after! org-babel
  (org-babel-lob-ingest "~/Cloud/thesis/org-mode/org-babel-tutorial/org-babel-library.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');
  ")

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

;; (push "~/.emacs.d/private/ob-session-async/lisp/" load-path)
;; (require 'ob-session-async)

;; (with-eval-after-load "ob"
;;   (require 'org-babel-eval-in-repl))

;; (with-eval-after-load "eval-in-repl"
;;   (setq eir-jump-after-eval nil))

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

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

(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 "tags" field when looking for bib entries
(setq helm-bibtex-additional-search-fields '(tags))

;; 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 "✎")

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

;; 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} :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"))

;; Make "Edit notes" the default action
(after! helm-bibtex
  (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))

(defun tdehaeze/open-pdf-externally (key)
  (call-process "zathura" nil 0 nil (nth 0 (-cons-to-list (bibtex-completion-find-pdf key)))))

;; Action to open the pdf with Zathura
(after! helm-bibtex
  (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))

(defun helm-bibtex-favorites (&optional arg)
  "Search Favorite BibTeX entries"
  (interactive "P")
  (helm-bibtex arg nil "favorite "))

(defun list-bib-without-pdf-associated ()
  (interactive)
  (bibtex-completion-init)
  (setq candidates (bibtex-completion-candidates))

  (defun canditate-is-pdf-present (candidate)
    (bibtex-completion-find-pdf-in-library (cdr (assoc "=key=" candidate)))
    )

  (setq candidates-without-pdf (remove-if #'canditate-is-pdf-present candidates))

  (setq candidate-without-pdf-names (mapcar
                                     (lambda (x) (cdr (assoc "title" x)))
                                     candidates-without-pdf))

  (with-output-to-temp-buffer "*bib-without-pdf*" (princ (string-join candidate-without-pdf-names "\n")))
  (switch-to-buffer-other-window "*bib-without-pdf*")
  )

(setq matlab-shell-command "/home/thomas/bin/matlab")
(setq matlab-shell-command-switches (list "-nodesktop -nosplash"))
(setq mlint-programs '("mlint" "/home/thomas/bin/mlint"))

(defvar mlint-executable "/home/thomas/bin/mlint")

(flycheck-define-command-checker 'matlab-mlint
  "A Matlab checker based on mlint."
  :command `(,mlint-executable source)
  :error-patterns
  '((warning line-start "L " line " (C " (1+ digit)  "): " (message) line-end))
  :modes '(matlab-mode))

(add-to-list 'flycheck-checkers 'matlab-mlint)

;; Automatic startup of flycheck for matlab
(add-hook 'matlab-mode-hook 'flycheck-mode)

(defadvice org-edit-src-code (around set-buffer-file-name activate compile)
  (let ((file-name (buffer-file-name))) ;; (1)
    ad-do-it                            ;; (2)
    (setq buffer-file-name file-name))) ;; (3)

;; (add-to-list 'company-backends 'company-matlab)

(defun matlab-beautify-buffer ()
  "Beautify Current Buffer"
  (interactive)
  (save-buffer)
  (matlab-shell-run-command (concat "MBeautify.formatFile(\"" (buffer-file-name) "\")"))
)

(defun matlab-add-breakpoint ()
  (interactive)
  (matlab-shell-run-command (concat "dbstop in " (buffer-name) " at " (number-to-string (line-number-at-pos nil)))))
(defun matlab-remove-breakpoint ()
  (interactive)
  (matlab-shell-run-command (concat "dbclear in " (buffer-name) " at " (number-to-string (line-number-at-pos nil)))))
(defun matlab-list-breakpoints ()
  (interactive)
  (matlab-shell-run-command (concat "dbstatus " (buffer-name))))
(defun matlab-clear-breakpoints ()
  (interactive)
  (matlab-shell-run-command (concat "dbclear in " (buffer-name))))
(defun matlab-go-to-file-directory ()
  (interactive)
  (matlab-shell-run-command (concat "cd " (file-name-directory buffer-file-name))))

(map! :map matlab-mode-map
      :n ",g" 'matlab-go-to-file-directory
      :n ",da" 'matlab-add-breakpoint
      :n ",dr" 'matlab-remove-breakpoint
      :n ",dL" 'matlab-list-breakpoints
      :n ",dc" 'matlab-clear-breakpoints
      :n ",dl" 'gud-cont
      :n ",ds" 'gud-step
      :n ",dn" 'gud-next
      :n ",dq" 'gud-finish)

(add-hook 'matlab-mode-hook
        ;; `highlight-numbers-mode' breaks MATLAB comment coloring --
        ;; `highlight-numbers-mode' is mostly redundant with
        ;; `rainbow-identifiers-mode' anyway
        (lambda ()
          (highlight-numbers-mode -1))
        ;; We must append the above *after* `spacemacs/run-prog-mode-hooks'
        ;; in `matlab-mode-hook', since the former hook enables
        ;; `highlight-numbers-mode'. Note that
        ;; `spacemacs/run-prog-mode-hooks' is manually added to
        ;; `matlab-mode-hook' by Spacemacs since the upstream `matlab-mode'
        ;; package does not derive `matlab-mode' from `prog-mode' (oddly --
        ;; IIRC the author refused to do so for compatibility with XEmacs).
        'append)

(setq mail-user-agent 'mu4e-user-agent)

(setq mu4e-contexts
      `( ,(make-mu4e-context
           :name "gmail"
           :enter-func (lambda () (mu4e-message "Entering Gmail context"))
           :leave-func (lambda () (mu4e-message "Leaving Gmail context"))
           :match-func (lambda (msg)
                         (when msg
                           (string-match-p "^/gmail" (mu4e-message-field msg :maildir))))
           :vars '(
                   (mu4e-sent-messages-behavior . (delete))
                   (user-mail-address . "dehaeze.thomas@gmail.com")
                   (mu4e-sent-folder . "/gmail/Sent")
                   (mu4e-trash-folder . "/gmail/Trash")
                   (mu4e-drafts-folder . "/gmail/Drafts")
                   (mu4e-refile-folder . "/gmail/Archive")
                   (mu4e-compose-signature  .
                                            (concat
                                             "Thomas Dehaeze\n"
                                             "\n"))
                   ))
         ,(make-mu4e-context
           :name "esrf"
           :enter-func (lambda () (mu4e-message "Entering ESRF context"))
           :leave-func (lambda () (mu4e-message "Leaving ESRF context"))
           :match-func (lambda (msg)
                         (when msg
                           (string-match-p "^/esrf" (mu4e-message-field msg :maildir))))
           :vars '(
                   (user-mail-address . "thomas.dehaeze@esrf.fr")
                   (mu4e-sent-folder . "/esrf/Sent")
                   (mu4e-trash-folder . "/esrf/Trash")
                   (mu4e-drafts-folder . "/esrf/Drafts")
                   (mu4e-refile-folder . "/esrf/Archive")
                   (mu4e-compose-signature  .
                                            (concat
                                             "Thomas Dehaeze\n"
                                             "\n"))
                   ))
         ,(make-mu4e-context
           :name "ulg"
           :enter-func (lambda () (mu4e-message "Entering ULG context"))
           :leave-func (lambda () (mu4e-message "Leaving ULG context"))
           :match-func (lambda (msg)
                         (when msg
                           (string-match-p "^/ulg" (mu4e-message-field msg :maildir))))
           :vars '(
                   (user-mail-address . "thomas.dehaeze@doct.ulg.ac.be")
                   (mu4e-sent-folder . "/ulg/Sent")
                   (mu4e-trash-folder . "/ulg/Trash")
                   (mu4e-drafts-folder . "/ulg/Drafts")
                   (mu4e-refile-folder . "/ulg/Archive")
                   (mu4e-compose-signature  .
                                            (concat
                                             "Thomas Dehaeze\n"
                                             "\n"))
                   ))
         ))
(setq mu4e-context-policy 'pick-first)

(setq mu4e-get-mail-command "true")

(setq mu4e-change-filenames-when-moving t)

(setq smtpmail-default-smtp-server "smtp.gmail.com"
      smtpmail-smtp-server "smtp.gmail.com"
      smtpmail-smtp-service 587)

(setq message-send-mail-function 'message-send-mail-with-sendmail
      sendmail-program "msmtp"
      user-full-name "Thomas Dehaeze")

(setq mu4e-bookmarks
      `(("flag:unread AND NOT flag:trashed" "Unread messages" ?u)
        ("date:today..now" "Today's messages" ?t)
        ("date:7d..now" "Last 7 days" ?w)
        ("mime:image/*" "Messages with images" ?p)
        (,(mapconcat 'identity
                     (mapcar
                      (lambda (maildir)
                        (concat "maildir:" (car maildir)))
                      mu4e-maildir-shortcuts) " OR ")
         "All inboxes" ?i)))

(with-eval-after-load 'mu4e-alert
  (mu4e-alert-set-default-style 'libnotify))
(mu4e-alert-enable-notifications)

(setq mu4e-enable-mode-line t)

(add-hook 'message-mode-hook 'turn-on-orgtbl)
(add-hook 'message-mode-hook 'turn-on-orgstruct++)

(setq org-mu4e-link-query-in-headers-mode nil)

(setq mu4e-sent-messages-behavior 'delete)

(defun tdh/latex/watch ()
  "Watch LaTeX file using latexmk"
  (interactive)
  (start-process-shell-command "latexmk-watch" "*latexmk-watch-output*"
                               "latexmk" (format "-pdflatex=\"xelatex -synctex=1 -shell-escape -interaction nonstopmode  -output-directory='%s'\" -pdf -pvc -bibtex -f %s.tex"
                                                 (file-name-directory buffer-file-name)
                                                 (file-name-base buffer-file-name))))
(defun tdh/latex/watch/kill ()
  "Kill the currently running TeX job."
  (interactive)
  (delete-process "latexmk-watch")
  )

(map! :map org-mode-map
      :n ",ow" 'tdh/latex/watch
      :n ",ok" 'tdh/latex/watch/kill)

(map! :map org-mode-map
      :n ",ob" 'helm-bibtex
      :n ",of" 'helm-bibtex-favorites
      :n ",or" 'helm-resume)

(defun tdh/open-terminal-in-workdir ()
  (interactive)
  (call-process-shell-command
  (concat "termite --directory=" default-directory) nil 0))

(map! :map org-mode-map :n ",ot" 'tdh/open-terminal-in-workdir)

(defun tdh/open-ranger-in-workdir ()
  (interactive)
  (call-process-shell-command
  (concat "termite --directory=" default-directory " --exec=ranger") nil 0))

(map! :map org-mode-map :n ",oo" 'tdh/open-ranger-in-workdir)