Org Mode configuration to support usage like I've been doing in my DALT 7003 presentations

org-mode-dalt.el

;; ~/.emacs.d/init.el

;;; Commentary:

;; This code does two things
;; - Shows a basic emacs configuration
;; - Sets up Org Mode and friends

;; It makes some assumptions about operating environment:

;; GNU Emacs 27 or greater (but less might work too, who knows!)
;; Obtain org mode via  git clone https://code.orgmode.org/bzg/org-mode.git
;; Obtain texlive following instructions from https://www.tug.org/texlive/
;; Obtain Exp2Exp wiki contents via  git clone [email protected]:exp2exp/exp2exp.github.io.git

;; You’ll need to install some packages — uncomment and run the following expressions once (C-x C-e, or M-x eval-region)

;; (setq package-selected-packages
;;      '(ess ess-view-data org-roam org-roam-server org-tree-slide org-roam-server toc-org command-log-mode))
;; (package-install-selected-packages)

;; A few lines that may need further attention on your installation are marked ***

;; Note that bibtex for managing references is commented out below: that can come in as a later step

;;; Code:

;;; Basic sanity stuff

(setq debug-on-error t)
(setq backtrace-on-error t)

;;; Use MELPA

(when (>= emacs-major-version 24)
  (require 'package)
  (add-to-list 'package-archives '("melpa" .  "https://raw.githubusercontent.com/d12frosted/elpa-mirror/master/melpa/") t)
  (package-initialize)
  )

;;; Load some dependencies

(add-to-list 'load-path "~/.emacs.d/lisp/")
(add-to-list 'load-path "~/org-mode/contrib/lisp/")
(add-to-list 'load-path "~/org-mode/lisp/")
(server-start)

(require 'use-package)

;;; Ess

(require 'ess)

;; Make * into an operator
(setq ess-fl-keyword:operators
      (cons "\\(\\*\\|[-=+></]\\)+" 'ess-operator-face))

;;; Org mode

(load "~/org-mode/lisp/org.el")

;;; Allow long italics expressions

;; You need to reload Org or to restart Emacs after setting this — poor design
(setcar (nthcdr 2 org-emphasis-regexp-components) " \t\r\n,\"")
(setf (nth 4 org-emphasis-regexp-components) 10)

(load "~/org-mode/lisp/org.el")

;;; Load some backends

(load "~/org-mode/lisp/ob-shell.el")
(load "~/org-mode/lisp/ob-clojure.el")
(load "~/org-mode/lisp/ob-maxima.el")

;; you could use bb here, you’d have to install it ***
(setq org-babel-clojure-backend 'cider)

;; You’ll need to set the path for Texlive, or comment this out ***
(setq exec-path (append '("/usr/local/texlive/2019/bin/x86_64-linux") exec-path))

;;; Fancy inline display of equations and such

(setq org-latex-create-formula-image-program 'dvisvgm)
(plist-put org-format-latex-options :scale 2)
(add-hook 'org-mode-hook 'org-fragtog-mode)

;; Set to nil here, b/c its incompatible with viewing the agenda
(setq org-startup-with-latex-preview nil)

;; NB. org-preview-latex-image-directory — this is where the images are stored

;;; Further configuration of org mode

;; Drop src boxes back visually
(require 'color)
(set-face-attribute 'org-block nil :background
                    (color-darken-name
                     (face-attribute 'default :background) 3))

;; Change display for org block (e.g., output from Org Babel)
(setq org-src-block-faces '(("org" (:foreground "Green"))))

;; Use fontlock in source blocks
(setq org-src-fontify-natively t)

;; Markers from https://zzamboni.org/post/beautifying-org-mode-in-emacs/

(use-package org-bullets
  :config
  (add-hook 'org-mode-hook (lambda () (org-bullets-mode 1))))

(setq org-bullets-bullet-list
      '(;;; Large
        "👻"
        "🍒"
        "🍓"
        "⚫"
        "👻"
        "👻"
        "👻"
        "👻"
        "𝗔"
        "𝗕"
        "𝗖"
        "𝗗"
        "𝗘"
        ))

;; Further gratuitous icons for bullet and number lists

(font-lock-add-keywords 'org-mode
                        '(("^ *\\([-]\\) "
                           (0 (prog1 () (compose-region (match-beginning 1) (match-end 1) "•"))))
                          ("^ *\\([1]\\.\\) "
                           (0 (prog1 () (compose-region (match-beginning 1) (match-end 1) "①"))))
                          ("^ *\\([2]\\.\\) "
                           (0 (prog1 () (compose-region (match-beginning 1) (match-end 1) "②"))))
                          ("^ *\\([3]\\.\\) "
                           (0 (prog1 () (compose-region (match-beginning 1) (match-end 1) "③"))))
                          ("^ *\\([4]\\.\\) "
                           (0 (prog1 () (compose-region (match-beginning 1) (match-end 1) "④"))))
                          ("^ *\\([5]\\.\\) "
                           (0 (prog1 () (compose-region (match-beginning 1) (match-end 1) "⑤"))))
                          ("^ *\\([6]\\.\\) "
                           (0 (prog1 () (compose-region (match-beginning 1) (match-end 1) "⑥"))))
                          ("^ *\\([7]\\.\\) "
                           (0 (prog1 () (compose-region (match-beginning 1) (match-end 1) "⑦"))))
                          ("^ *\\([8]\\.\\) "
                           (0 (prog1 () (compose-region (match-beginning 1) (match-end 1) "⑧"))))
                          ("^ *\\([9]\\.\\) "
                           (0 (prog1 () (compose-region (match-beginning 1) (match-end 1) "⑨"))))))

;; Make colorful extension for numbered and bullet lists.
(add-hook 'org-mode-hook
          (lambda ()
           (font-lock-add-keywords nil
             ;; possible white space followed by - or N. and then white space
            '(("^\\s-*?\\(-\\{1\\}\\|[0-9]+\\.\\)\\s-" 1
               font-lock-warning-face t)))
           (font-lock-add-keywords nil
            '(("^\\(-\\{5,\\}\\)" 1
               font-lock-type-face t)))))

;;; Some convenience bindings
(defun my-org-open-at-point (&optional arg)
  (interactive "P")
  (if (not arg)
      (org-open-at-point)
      (let ((browse-url-browser-function 'eww-browse-url))
        (org-open-at-point))))
(define-key org-mode-map (kbd "<insert>") 'my-org-open-at-point)

(defun my-org-return (&optional arg indent)
  (interactive "*p")
  (dotimes (number arg) (org-return indent)))
(define-key org-mode-map (kbd "<return>") 'my-org-return)

(setq org-priority-regexp "^\\*+.*\\(\\[#\\([A-Z0-9]+\\)\\] ?\\)")
(setq org-hide-emphasis-markers t)

;; Compatibility with LaTeX

(require 'ox-latex)
(setq org-latex-inputenc-alist '(("utf8" . "utf8x")))
(setq org-latex-prefer-user-labels t)

(setq font-latex-fontify-script nil)
(setq font-latex-fontify-sectioning 'color)

;; This gets it to use xelatex...
(setq org-latex-pdf-process
      (list
       "latexmk -pdflatex='xelatex -8bit -shell-escape -interaction nonstopmode' -pdf -f  %f")) 

(setq org-export-with-smart-quotes t)

(add-to-list 'org-file-apps '(directory . emacs))

;;; Quickly insert some structures, E.g. via <R TAB
(require 'org-tempo)
(setq org-structure-template-alist
      '(("a" . "export ascii")
       ("c" . "center")
       ("C" . "comment")
       ("e" . "example")
       ("E" . "export")
       ("h" . "export html")
       ("l" . "export latex")
       ("q" . "quote")
       ("Q" . "src sql")
       ("s" . "src")
       ("R" . "src R :session :results output org")
       ("v" . "verse")))

;; Tab at beginning of buffer
(setq org-cycle-global-at-bob t)

;; Execute code blocks quickly
(setq org-confirm-babel-evaluate nil)
(setq org-export-use-babel nil)

(setq org-adapt-indentation nil)

;;; Various bindings
(define-key org-mode-map (kbd "C-<tab>") nil)
(define-key org-mode-map (kbd "<f12>") 'org-open-at-point)
(define-key org-mode-map (kbd "<kp-right>") 'org-next-link)
(define-key org-mode-map (kbd "<kp-left>") 'org-previous-link)
(define-key org-mode-map (kbd "<kp-begin>") 'org-open-at-point)
(define-key org-mode-map (kbd "s-n") 'org-next-link)
(define-key org-mode-map (kbd "s-p") 'org-previous-link)
(define-key global-map "\C-ca" 'org-agenda)

;;; Org Agenda stuff

(setq org-agenda-use-time-grid nil)
(setq org-agenda-include-deadlines nil)
;; 0 to start on Sunday or 1 to start on Monday, nil to start "today"
(setq org-agenda-start-on-weekday 1)

(add-hook 'org-agenda-finalize-hook 'place-agenda-tags)

(defun place-agenda-tags ()
  "Put the agenda tags by the right border of the agenda window."
  (let ((org-agenda-tags-column (- 4 (window-width))))
    (org-agenda-align-tags)))

(add-hook 'org-agenda-finalize-hook 'remove-todo-and-cookies)

(defun remove-todo-and-cookies ()
  (when (eq org-agenda-type 'agenda)
    (goto-char (point-min))
    (while (re-search-forward "\\(TODO \\[#[AB]\\]\\)\\|\\(LOW \\[#[AB]\\]\\)" nil t)
      (replace-match ""))))

;;; Useful for managing projects

(setq org-todo-keywords
      '((sequence "TODO" "STARTED" "BLOCKED" "BACKBURNER" "FROZEN" "|" "DONE" "DEFERRED" "WONTFIX")))

(setq org-log-done 'time)

(setq org-agenda-files '("~/exp2exp.github.io/src/"))

(setq org-agenda-log-mode-items '(closed clock state))

;; Example:
;; Here’s what makes Emacs fun (or funny) — advice to override contents of Org
;; Agenda buffer when pressing E, and turn the quoted text dark green:

(load "~/org-mode/lisp/org-agenda.el")

(defun org-green-entries (arg &optional x)
  (with-temp-buffer (insert arg)
                    (add-text-properties (point-min)
                                         (point-max)
                                         '(face ((background-color . "darkgreen"))))
                    (buffer-string)))

(defun advise-org-no-properties (r)
  (advice-add 'org-no-properties :override 'org-green-entries))

(defun unadvise-org-no-properties (r)
  (advice-remove 'org-no-properties 'org-green-entries))

(advice-add 'org-agenda-entry-text-mode :before 'advise-org-no-properties)
(advice-add 'org-agenda-entry-text-mode :after 'unadvise-org-no-properties)

;; This shows all of the items, though the sorting leaves something to be desired

(defun org-scrum-board ()
  (interactive)
  (org-todo-list "TODO|STARTED|BLOCKED|BACKBURNER|FROZEN|DONE|DEFERRED|WONTFIX"))
(global-set-key (kbd "C-c r") 'org-scrum-board)

(setq org-agenda-sorting-strategy '((todo todo-state-down category-down tag-up)))

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

(setq org-agenda-todo-keyword-format "%-1s")
(setq org-agenda-hide-tags-regexp "write")

;;; Bindings for dealing with links

(global-set-key (kbd "C-c s") 'org-store-link)
(global-set-key (kbd "C-c l") 'org-insert-link)
(global-set-key (kbd "C-c a") 'org-agenda)
(global-set-key (kbd "C-c c") 'org-capture)

;;; Org Roam

(require 'org-roam)
(setq org-roam-tag-sources '(prop all-directories))

(setq org-roam-directory "~/exp2exp.github.io/src/")
(setq org-roam-db-location "~/exp2exp.github.io/src/org-roam.db")

;; (setq org-roam-completion-system 'helm) ***

(define-key org-roam-mode-map (kbd "C-c n l") #'org-roam)
(define-key org-roam-mode-map (kbd "C-c n f") #'org-roam-find-file)
(define-key org-roam-mode-map (kbd "C-c n b") #'org-roam-switch-to-buffer)
(define-key org-roam-mode-map (kbd "C-c n g") #'org-roam-graph)
(define-key org-roam-mode-map (kbd "C-c n a") #'org-roam-db-build-cache)
(define-key org-mode-map (kbd "C-c n i") #'org-roam-insert)
(org-roam-mode +1)

(defun org-roam-insert-link (beg end)
  (interactive "r")
  (save-window-excursion
    (let* ((text (buffer-substring-no-properties beg end))
           (file (concat (funcall
                          org-roam-title-to-slug-function
                          text) ".org")))
      (delete-region beg end)
      (insert "[[file:./" file "][" text "]]")
      (with-temp-buffer
        (insert "#+TITLE: " text)
        (write-file file)))))

(defun org-roam-insert-link-follow (beg end)
  (interactive "r")
  (org-roam-insert-link beg end)
  (backward-char 1)
  (org-open-at-point)
  (goto-char (point-max)))

(define-key org-mode-map (kbd "C-c n d") #'org-roam-insert-link-follow)

;; Here’s a quick way to kill a buffer, useful if you’ve created links by following them and then want to go back
(global-set-key (kbd "<home>") (lambda () (interactive)
                                 (save-buffer)
                                 (kill-this-buffer)
                                 (condition-case nil
                                     (delete-window)
                                   (error nil))))

;; useful in combination with M-x org-roam-server functionality
(require 'org-roam-protocol)

;;; Some extra navigation stuff

(defun org-fold-and-move ()
  (interactive)
  (hide-subtree)
  (org-next-visible-heading 1)
  (show-subtree))

(define-key org-mode-map (kbd "C-H-n") 'org-fold-and-move)

(defun org-fold-and-move-back ()
  (interactive)
  (hide-subtree)
  (org-previous-visible-heading 1)
  (show-subtree))

(define-key org-mode-map (kbd "C-H-p") 'org-fold-and-move-back)

;;; Further Extras

(require 'ox-extra)
(ox-extras-activate '(ignore-headlines))

(require 'toc-org)

;;; Jump to a certain line number in text files... this seems pretty obscure
(add-hook 'org-create-file-search-functions
      '(lambda ()
         (when (eq major-mode 'text-mode)
           (number-to-string (line-number-at-pos)))))

(add-hook 'org-execute-file-search-functions
      '(lambda (search-string)
         (when (eq major-mode 'text-mode)
           (goto-line (string-to-number search-string)))))


;; Org-roam context switcher

;; Add more org roams repos here as needed — right now there’s just one, but this becomes useful when there are more
(defvar org-roam-library
  `(,(concat "/home/" (getenv "USER") "/exp2exp.github.io/src/")))

;; Check out an org roam from the library
(defun org-roam-checkout ()
  (interactive)
  (let ((ctx org-roam-directory))
    (if (eq (length org-roam-library) 1)
        ;; Still go ahead and set the variable in this case!
        (progn (setq org-roam-directory (car org-roam-library)
                     org-roam-db-location (concat org-roam-directory "org-roam.db"))
               (message "You only have one choice for org-roam-directory defined."))
      (let ((lib (completing-read "Choose a volume: " org-roam-library)))
        (when lib
          (setq org-roam-directory lib
                org-roam-db-location (concat org-roam-directory "org-roam.db")))))
    ;; Assuming that the user changes context, let’s rebuild the cache
    ;; and prompt them to choose a new file in that context
    (when (not (eq ctx org-roam-directory))
      (org-roam-db-build-cache)
      (org-roam-find-file))))

(define-key org-roam-mode-map (kbd "C-c n c") #'org-roam-checkout)

(defun org-scrum-board-max ()
  (interactive)
  (let ((org-agenda-files org-roam-library))
    (org-scrum-board)))

;; Different views of your work in progress are possible this way, just define variants of the above
(define-prefix-command 'scrum-board-map)
(global-set-key (kbd "C-c R") 'scrum-board-map)
(global-set-key (kbd "C-c R m") 'scrum-board-map-max)

;;; For making the agenda easier to read

;; My regexp doesn’t catch the last line for some reason?
(defun fontify-agenda ()
  (let ((kw '("TODO" "STARTED" "BLOCKED" "BACKBURNER" "FROZEN" "DONE" "DEFERRED" "WONTFIX")))
    (save-excursion
      (goto-char (point-min))
      (next-line 4)
      (while (re-search-forward (concat "^.*\\(" (regexp-opt kw) "\\)+ \\(.*\\)\n.") nil t)
        (add-text-properties (match-beginning 2) (match-end 2) '(face ((background-color . "gray20"))))
        ))))

(add-hook 'org-agenda-finalize-hook 'fontify-agenda)


(define-key org-roam-mode-map (kbd "C-c n r")
  (lambda (pattern) (interactive "PRG-PATTERN:")
    (let ((default-directory org-roam-directory))
      (helm-rg pattern))))


;;; Org Tree Slide

(require 'org-tree-slide)

;; Weird but needed to get images to respond
(setq org-image-actual-width '(3))

(setq org-tree-slide-slide-in-effect nil)
(setq org-tree-slide-skip-outline-level 3)

(defvar-local org-show-comments-state t)

(defun engage-org-cloaking ()
  (interactive)
  (let ((cloak (face-attribute 'default :background)))
    (set-face-attribute 'org-meta-line (selected-frame) :foreground cloak)
    (set-face-attribute 'org-block-begin-line (selected-frame) :foreground cloak)
    (set-face-attribute 'org-block-end-line (selected-frame) :foreground cloak))
  (setq org-show-comments-state nil)
  (setq mode-line-format nil)
  (org-display-inline-images t t))

(defun disengage-org-cloaking ()
  (interactive)
  (let ((uncloak (face-attribute 'default :foreground)))
    (set-face-attribute 'org-meta-line (selected-frame) :foreground uncloak)
    (set-face-attribute 'org-block-begin-line (selected-frame) :foreground uncloak)
    (set-face-attribute 'org-block-end-line (selected-frame) :foreground uncloak))
  (setq org-show-comments-state t)
  (setq mode-line-format t)
  (org-display-inline-images nil t))

(defun toggle-org-cloaking ()
  (interactive)
  (cond
   (org-show-comments-state (engage-org-cloaking))
   (t (disengage-org-cloaking))))

(add-hook 'org-tree-slide-mode-hook  'toggle-org-cloaking)

(define-key org-tree-slide-mode-map (kbd "M-p") 'org-tree-slide-move-previous-tree)
(define-key org-tree-slide-mode-map (kbd "M-n") 'org-tree-slide-move-next-tree)

(defun org-next-visible-heading-to-top ()
  (interactive)
  (org-next-visible-heading 1)
  (recenter-top-bottom 1)
  (show-subtree))

(define-key org-tree-slide-mode-map (kbd "M-z") 'org-next-visible-heading-to-top)

;;; Show what you’re doing via M-x command-log-mode

(require 'command-log-mode)

;;; Eww — make the built-in browser easier to use

(setq shr-color-visible-luminance-min 80)

;;; Bibtex stuff ***

;; (setq bibtex-completion-bibliography
;;       '("~/Downloads/vitae/corneli-citations.bib"
;;         "~/arxana/org/refs.org"))

;; (setq bibtex-completion-library-path '("~/pdfs"))
;; (setq bibtex-completion-notes-path "~/notes")

;; (autoload 'helm-bibtex "helm-bibtex" "" t)

;; ;; If you installed via MELPA
;; (use-package org-roam-bibtex
;;   :after org-roam
;;   :hook (org-roam-mode . org-roam-bibtex-mode)
;;   :bind (:map org-mode-map
;;               (("C-c n a" . orb-note-actions))))

;; (setq orb-note-actions-frontend 'helm)

;;; Custom

(custom-set-variables
 ;; custom-set-variables was added by Custom.
 ;; If you edit it by hand, you could mess it up, so be careful.
 ;; Your init file should contain only one such instance.
 ;; If there is more than one, they won't work right.
 '(electric-quote-mode t)
 '(ess-R-font-lock-keywords
   '((ess-R-fl-keyword:keywords . t)
     (ess-R-fl-keyword:constants . t)
     (ess-R-fl-keyword:modifiers . t)
     (ess-R-fl-keyword:fun-defs . t)
     (ess-R-fl-keyword:assign-ops . t)
     (ess-R-fl-keyword:assign-vars . t)
     (ess-R-fl-keyword:%op% . t)
     (ess-fl-keyword:fun-calls . t)
     (ess-fl-keyword:numbers . t)
     (ess-fl-keyword:operators . t)
     (ess-fl-keyword:delimiters . t)
     (ess-fl-keyword:= . t)
     (ess-R-fl-keyword:F&T . t)))
 '(org-format-latex-header
   "\\documentclass{article}
\\usepackage[usenames]{color}
[PACKAGES]
[DEFAULT-PACKAGES]
\\pagestyle{empty}             % do not remove
% The settings below are copied from fullpage.sty
\\setlength{\\textwidth}{\\paperwidth}
\\addtolength{\\textwidth}{-3cm}
\\setlength{\\oddsidemargin}{1.5cm}
\\addtolength{\\oddsidemargin}{-2.54cm}
\\setlength{\\evensidemargin}{\\oddsidemargin}
\\setlength{\\textheight}{\\paperheight}
\\addtolength{\\textheight}{-\\headheight}
\\addtolength{\\textheight}{-\\headsep}
\\addtolength{\\textheight}{-\\footskip}
\\addtolength{\\textheight}{-3cm}
\\setlength{\\topmargin}{1.5cm}
\\addtolength{\\topmargin}{-2.54cm}
\\usepackage{concmath}"))

(put 'upcase-region 'disabled nil)
(put 'narrow-to-region 'disabled nil)
(put 'list-timers 'disabled nil)
(put 'downcase-region 'disabled nil)
(custom-set-faces
 ;; custom-set-faces was added by Custom.
 ;; If you edit it by hand, you could mess it up, so be careful.
 ;; Your init file should contain only one such instance.
 ;; If there is more than one, they won't work right.
 '(org-block-begin-line ((t (:inherit default :background "gray6" :foreground "aquamarine" :slant italic :height 0.5))))
 '(org-block-end-line ((t (:inherit org-block-begin-line :background "gray6"))))
 '(org-document-info ((t (:foreground "DarkGoldenrod1"))))
 '(org-document-title ((t (:inherit default :foreground "#dcdccc" :underline nil :slant normal :weight bold :height 1.0 :width normal :foundry "MS  " :family "Verdana"))))
 '(org-level-1 ((t (:extend nil :foreground "dark turquoise"))))
 '(org-level-2 ((t (:extend nil :foreground "hot pink"))))
 '(org-level-3 ((t (:extend nil :foreground "red2"))))
 '(org-level-4 ((t (:extend nil :foreground "white smoke"))))
 '(org-level-5 ((t (:extend nil :foreground "royal blue"))))
 '(org-level-6 ((t (:extend nil :foreground "dark orange"))))
 '(org-level-7 ((t (:extend nil :foreground "DeepPink1"))))
 '(org-level-8 ((t (:extend nil :foreground "red"))))
 '(org-meta-line ((t (:inherit font-lock-comment-face :foreground "aquamarine" :slant italic :height 0.8))))
 '(org-table ((t (:background "gray1"))))
 '(org-tree-slide-header-overlay-face ((t (:background "#0d0e14" :foreground "#dcdccc" :inverse-video nil :weight bold))))
 '(whitespace-line ((t (:background "gray20"))))
 '(widget-field ((t (:extend t :background "thistle3" :foreground "gray9")))))