mirror of
https://github.com/pestctrl/emacs-config.git
synced 2026-02-16 16:24:18 +00:00
167 KiB
167 KiB
Emacs Configuration
- Neo keyboard issues
- Lib
- Custom file
- EXWM
- Emacs
- Look and feel
- Navigation
- Tools
- Encryption
- Org Mode
- Elfeed
- Programming
- Freekeys
- Eww
- New
- Youtube-dl
- Spaces
- pdf-tools use isearch
- Dired+
- Time to game!
- Winner Mode
- Skewer Mode (web development)
- Gnus
- Ledger mode
- ediff
- Scroll interval
- AUR PKGBUILD
- Eyebrowse
- org-jira
- Writing mode
- re-builder specify read method
- new-text-color
- dired-du
- scrollkeeper
- set-default-directory
- hydra
- org-mru-clock
- org-clock-convenience
- org-clock-consisitency
- org-clock stfuf
- org-edna
- org agenda goto headline AND narrow
- World time include Taiwan
- org-brain
- Open links with firefox
- org-export
- desktop-environment
- arch-linux
- skeletor project templates
- Compile java run test
- ansi-term colors
- sml faces
- expand-region
- wtf
- buffer-time-tracking
- auto-save files in same directory
- csv-mode
- kdeconnect
- Purpose-mode
- Broken
- Disabled
Neo keyboard issues
(global-set-key (kbd "M-Ä") 'eval-expression)
(defun reset-keyboard ()
(interactive)
(shell-command "setxkbmap de neo_dvorak"))Lib
memoize
(use-package memoize)Custom file
(setq custom-file "~/.emacs.d/custom.el")
(load custom-file 'noerror)
(setq backup-directory-alist `(("." . ,(concat user-emacs-directory "backups"))))EXWM
Meta
(use-package exwm)
(require 'exwm-config)
(exwm-config-default)
(fringe-mode '(10 . 0))Naming Windows
(defvar my/window-name nil)
(defun exwmx-name-buffer ()
(interactive)
(let ((name (completing-read "Name: " (mapcar (lambda (a) (plist-get a :instance)) (exwmx-appconfig--get-all-appconfigs)))))
(exwm-workspace-rename-buffer name)
(setq-local exwm-instance-name name)))
(defun exwm-rename-buffer ()
(interactive)
(when my/window-name
(exwm-workspace-rename-buffer my/window-name)
(setq-local exwm-instance-name my/window-name)
(setq my/window-name nil)))
;; Add these hooks in a suitable place (e.g., as done in exwm-config-default)
(add-hook 'exwm-manage-finish-hook 'exwm-rename-buffer)
(defun launch-program-with-name (cmd name)
(interactive)
(when name (setq my/window-name name))
(start-process-shell-command cmd nil cmd))exwm-x stuff and naming windows
(use-package exwm-x)
(require 'exwmx-quickrun)
(defun exwmx-quickrun (command &optional search-alias ruler)
(exwmx--switch-window)
(let* ((ruler-plist-p (and ruler (exwmx--plist-p ruler)))
(keys
;; Deal with ruler which is like (:class :instance :title)
(if (and ruler (listp ruler) (not ruler-plist-p))
(exwmx--clean-keylist ruler)
'(:class :instance)))
(appconfigs (exwmx-appconfig--get-all-appconfigs))
(cmd (if search-alias
(or (plist-get (exwmx-appconfig--search
`((:alias ,command)))
:command)
(when appconfigs
(let ((appconfig (exwmx-appconfig--select-appconfig)))
(plist-put appconfig :alias command)
(exwmx-appconfig--add-appconfig appconfig)
(plist-get appconfig :command))))
command))
(buffer (or (if search-alias
(exwmx-quickrun--find-buffer
(if ruler-plist-p
ruler
(exwmx-appconfig--get-subset
(exwmx-appconfig--search
`((:alias ,command)))
keys)))
(exwmx-quickrun--find-buffer
(if ruler-plist-p
ruler
(exwmx-appconfig--get-subset
(exwmx-appconfig--search
`((:command ,command)))
keys)))))))
(if (and search-alias (not cmd))
(message "EXWM-X: please run `exwmx-appconfig' to add appconfig.")
(message "EXWM-X Quick Run: %s" cmd))
;; If current application window is a floating-window, minumize it.
(when (and (eq major-mode 'exwm-mode)
exwm--floating-frame)
(exwm-floating-hide))
(if buffer
(exwm-workspace-switch-to-buffer buffer)
(when cmd
(launch-program-with-name cmd (plist-get ruler :instance))))))
(defun exwmx-quickrun--find-buffer (ruler)
"Find a exwm buffer which match `ruler', ruler is
a plist with three keys: :class, :instance and :title."
(let ((current (current-buffer))
(buffers (buffer-list))
(result '()))
(while buffers
(let ((buffer (pop buffers))
(class (plist-get ruler :class))
(instance (plist-get ruler :instance))
(title (plist-get ruler :title)))
(with-current-buffer buffer
(when (and (or class instance title)
(exwmx--string-match-p (or class ".*") exwm-class-name)
(exwmx--string-match-p (or instance ".*") exwm-instance-name)
(exwmx--string-match-p (or title ".*") exwm-title))
(push buffer result)))))
(setq result (reverse result))
;; If two more buffers are found, switch between these buffer.
(if (and (cadr result)
(eq (car result) current))
(cadr result)
(car result))))
(defmacro quickrun-lambda (cmd instance)
(if (null instance)
`(lambda ()
(interactive)
(exwmx-quickrun ,cmd))
`(lambda ()
(interactive)
(exwmx-quickrun ,cmd nil '(:class ".*" :instance ,instance)))))
(use-package dmenu)
(make-thread
#'dmenu--cache-executable-files)
(defun read-program ()
(funcall #'ido-completing-read "$ "
(append dmenu--history-list
(cl-remove-if (lambda (x)
(member x dmenu--history-list))
dmenu--cache-executable-files))))
(defun launch-program (command &optional process-name)
(interactive (list (read-program)))
(setq dmenu--history-list (cons command (remove command dmenu--history-list)))
(when (> (length dmenu--history-list)
dmenu-history-size)
(setcdr (nthcdr (- dmenu-history-size 1)
dmenu--history-list)
nil))
(let ((name (or process-name command)))
(start-process-shell-command name nil command)))
(defun exwmx-launch-program (command &optional process-name)
(interactive (list (read-program)))
(setq dmenu--history-list (cons command (remove command dmenu--history-list)))
(when (> (length dmenu--history-list)
dmenu-history-size)
(setcdr (nthcdr (- dmenu-history-size 1)
dmenu--history-list)
nil))
(exwmx-quickrun command))
;; (exwmx-quickrun "firefox" nil '(:class ".*" :instance "School"))
;; (exwmx-quickrun--find-buffer '(:class ".*" :instance "Hello"))Youtube split
(defun youtube-split (arg)
(interactive "P")
(let ((buf (get-buffer "youtube"))
(back (current-buffer)))
(delete-other-windows)
(if buf
(switch-to-buffer buf)
(when arg
(launch-program-with-name "firefox" "youtube")))
(side-window-op 'left 472 buf)
(switch-to-buffer back)))
(defun big-youtube-split (arg)
(interactive "P")
(delete-other-windows)
(let ((buf (get-buffer "youtube")))
(if buf
(switch-to-buffer buf)
(when arg
(launch-program-with-name "firefox" "youtube")))
(side-window-op 'left 630 buf)))
(defun side-window-op (side &optional size buffer)
(let ((prev-win (selected-window))
(win (display-buffer-in-side-window
(or buffer (current-buffer))
`((side . ,side)))))
(select-window win)
(set-window-dedicated-p win t)
(set-window-parameter win 'no-delete-other-windows t)
(when size
(window-resize win (- size (window-pixel-width)) t nil t))
(select-window prev-win)))
(defun side-left-window ()
(interactive)
(side-window-op 'left))
(defun side-right-window ()
(interactive)
(side-window-op 'right))
(defun side-bottom-window ()
(interactive)
(side-window-op 'bottom))
(setq window-sides-vertical t)Disable simulation keys on an emacs window
(add-hook 'exwm-manage-finish-hook
(lambda ()
(when (and exwm-class-name (string= exwm-class-name "Emacs"))
(exwm-input-set-local-simulation-keys nil))))Custom keymap
(defmacro exec (body)
`(lambda ()
(interactive)
,body))
(defun toggle-notifications ()
(interactive)
(shell-command "kill -s USR1 $(pidof deadd-notification-center)"))
(define-prefix-command '*root-map*)
;(global-set-key (kbd "C-t") '*root-map*)
(add-to-list 'exwm-input-prefix-keys ?\C-t)
(defun simulate-C-t (arg)
(interactive "P")
(if (eq major-mode 'exwm-mode)
(exwm-input--fake-key ?\C-t)
(transpose-chars arg)))
(define-key *root-map* (kbd "C-b") (lambda () (interactive) (switch-to-buffer nil)))
(define-key *root-map* (kbd "C-t") 'simulate-C-t)
(define-key *root-map* (kbd "c") 'multi-term)
(define-key *root-map* (kbd "C-p") 'exwmx-launch-program)
(define-key *root-map* (kbd "e") (quickrun-lambda "emacs" "emacs"))
(define-key *root-map* (kbd "s") (quickrun-lambda "steam" nil))
(define-key *root-map* (kbd "q") (quickrun-lambda "qutebrowser" nil))
(define-key *root-map* (kbd "V") (quickrun-lambda "VBoxManage startvm \"Windows 7\"" "VirtualBox Machine"))
(define-key *root-map* (kbd "r") 'exwmx-name-buffer)
(define-key *root-map* (kbd ")") (lambda () (interactive) (leaving-computer) (shell-command "sleep 2s ; xset dpms force off")))
(define-key *root-map* (kbd "C-n") 'switch-window)
(define-key *root-map* (kbd "i") 'org-mru-clock-in)
(define-key *root-map* (kbd "C-i") 'leaving-computer)
(define-key *root-map* (kbd "C") 'org-resolve-clocks)
(define-key *root-map* (kbd "j") 'org-clock-goto)
(define-key *root-map* (kbd "n") 'toggle-notifications)
(define-prefix-command '*window-map*)
(define-key *root-map* (kbd "w") '*window-map*)
(define-key *window-map* (kbd "y") 'youtube-split)
(define-key *window-map* (kbd "Y") 'big-youtube-split)
(define-key *window-map* (kbd "j") 'side-bottom-window)
(define-key *window-map* (kbd "h") 'side-left-window)
(define-key *window-map* (kbd "l") 'side-right-window)
(define-key *window-map* (kbd "t") 'window-toggle-side-windows)
(define-key *window-map* (kbd "d") 'delete-all-side-windows)
(define-prefix-command '*firefox-map*)
(define-key *firefox-map* (kbd "f") (quickrun-lambda "firefox" "firefox"))
(define-key *firefox-map* (kbd "d") (quickrun-lambda "firefox" "development"))
(define-key *firefox-map* (kbd "s") (quickrun-lambda "firefox" "school"))
(define-key *firefox-map* (kbd "w") (quickrun-lambda "firefox" "work"))
(define-key *firefox-map* (kbd "y") (quickrun-lambda "firefox" "youtube"))
(define-key *root-map* (kbd "f") '*firefox-map*)
(define-prefix-command '*music-map*)
(define-key *music-map* (kbd "SPC") (exec (shell-command "clementine -t")))
(define-key *music-map* (kbd "n") (exec (shell-command "clementine --next")))
(define-key *music-map* (kbd "p") (exec (shell-command "clementine --previous")))
(define-key *root-map* (kbd "m") '*music-map*)
;; Disable these
(with-eval-after-load "ibuf-ext"
(define-key ibuffer-mode-map (kbd "C-t") nil))
(define-key dired-mode-map (kbd "C-t") nil)Switch window
(setq switch-window-input-style 'minibuffer)Multimonitor support
(require 'exwm-randr)
(exwm-randr-enable)Keybindings
(use-package transpose-frame)
(setq exwm-input-global-keys
`(([?\s-r] . exwm-reset)
([?\s-w] . exwm-workspace-switch)
([?\s-l] . lock-screen)
,@(mapcar (lambda (i)
`(,(kbd (format "s-%d" (mod (1+ i) 10))) .
(lambda ()
(interactive)
(exwm-workspace-switch-create ,i))))
(number-sequence 0 9))
(,(kbd "s-b") . ivy-switch-buffer)
(,(kbd "s-c") . org-capture)
(,(kbd "s-h") . split-window-right)
(,(kbd "s-t") . split-window-below)
(,(kbd "s-n") . switch-window)
(,(kbd "s-k") . ido-kill-buffer)
(,(kbd "C-t") . *root-map*)
(,(kbd "s-z") . resize-window)
(,(kbd "s-s") . youtube-split)
(,(kbd "s-n") . switch-to-next-buffer)
(,(kbd "s-p") . switch-to-prev-buffer)
(,(kbd "s-a") . my/toggle-keyboard)
(,(kbd "s-!") . (lambda () (interactive) (exwm-workspace-move-window 0)))
(,(kbd "s-@") . (lambda () (interactive) (exwm-workspace-move-window 1)))
(,(kbd "s-#") . (lambda () (interactive) (exwm-workspace-move-window 2)))
(,(kbd "s-$") . (lambda () (interactive) (exwm-workspace-move-window 3)))))
(defun dvorak? ()
(string-match-p "de(neo_dvorak)"
(shell-command-to-string "setxkbmap -v | grep symbols")))
(defun set-keyboard (layout)
(shell-command (format "setxkbmap %s" layout)))
(defun my/toggle-keyboard ()
(interactive)
(if (dvorak?)
(set-keyboard "us")
(set-keyboard "de neo_dvorak")))
(global-set-key (kbd "M-T") 'flop-frame)
(global-set-key (kbd "C-x p") 'launch-program)
(global-set-key (kbd "M-…") 'multi-term)
(global-set-key (kbd "C-ü") 'undo-tree-undo)
(defun prompt-workspace (&optional prompt)
"Prompt for a workspace, returning the workspace frame."
(exwm-workspace--update-switch-history)
(let* ((current-idx (exwm-workspace--position exwm-workspace--current))
(history-add-new-input nil) ;prevent modifying history
(history-idx (read-from-minibuffer
(or prompt "Workspace: ")
(elt exwm-workspace--switch-history current-idx)
exwm-workspace--switch-map nil
`(exwm-workspace--switch-history . ,current-idx)))
(workspace-idx (mod (1- (cl-position history-idx exwm-workspace--switch-history
:test #'equal))
10)))
(elt exwm-workspace--list workspace-idx)))
(advice-add 'exwm-workspace--prompt-for-workspace
:override
#'prompt-workspace)Helper functions
(defvar wallpaper-path "/home/benson/.emacs.d/res/digital_space_universe_4k_8k-wide.jpg")
(defvar live-wallpaper-path "/home/benson/MEGA/pictures/wallpapers/videos/bg.mp4")
(setq i3-string "Xephyr -br -ac -noreset -resizeable -screen 1920x1080 :8 & sleep 1s; DISPLAY=:8 i3")
(setq xfce4-string "Xephyr -br -ac -noreset -resizeable -screen 1920x1080 :8 & sleep 1s; DISPLAY=:8 xfce4-session")
(setq kde-string "Xephyr -br -ac -noreset -resizeable -screen 1920x1080 :8 & sleep 1s; DISPLAY=:8 startkde")
(defvar exwm-startup-programs
'("megasync"
"deadd-notification-center"
"/usr/lib/kdeconnectd"
("compton -f -i .7 -b")
("/usr/lib/polkit-gnome/polkit-gnome-authentication-agent-1")
("/usr/lib/notification-daemon-1.0/notification-daemon")
("nm-applet")
))
(defvar hard-drive-space "")
(defun launch-i3 ()
(interactive)
(launch-program i3-string))
(defun launch-xfce ()
(interactive)
(launch-program xfce4-string))
(defun launch-kde ()
(interactive)
(launch-program kde-string))
(defun lock-screen ()
(interactive)
(let ((res (shell-command-to-string "pgrep i3lock-fancy")))
(when (zerop (length res))
(shell-command "i3lock-fancy"))))
(setq enable-recursive-minibuffers t)
(defun counsel-shell-command ()
"Forward to `shell-command'."
(interactive)
(ivy-read "Shell Command: "
shell-command-history
:caller 'counsel-shell-command))
(defun dmenu-run ()
(interactive)
(shell-command "dmenu" nil "dmenu_run -b"))
(defun call-startup-programs ()
(dolist (program exwm-startup-programs)
(if (listp program)
(launch-program (car program) (cadr program))
(launch-program program))))
(defun setup-wallpaper ()
(launch-program (concat "feh --bg-fill " wallpaper-path) "feh"))
(defun setup-live-wallpaper ()
(if (get-process "xwinwrap")
(delete-process "xwinwrap"))
(launch-program (concat "xwinwrap -ni -ov -g 1920x1080+1280+0 -s -st -sp -nf -- mpv --loop=inf -wid WID " live-wallpaper-path) "xwinwrap"))
(defun get-hard-drive-space ()
(shell-command-to-string "df -h -P -l ~/ | tail -n 1 | tr -s ' ' | cut -d ' ' -f 4"))
(defun update-hard-drive-space-string ()
(setq hard-drive-space
(let ((space-left (get-hard-drive-space)))
(propertize (concat " "
(substring space-left
0
(1- (length space-left))))
'face 'sml/time))))
(defun display-hard-drive-space-mode ()
(if (not (member 'hard-drive-space
global-mode-string))
(add-to-list 'global-mode-string
'hard-drive-space
t)))Workspace WIP
(defvar workspace-list '(("s" 0 "school")
("y" 1 "youtube")
("w" 2 "work")
("r" 3 "research")
("c" 4 "code"))
"My custom workspace list")
(defun workspace-switch-prompt ()
(exwm-workspace--update-switch-history)
(let* ((current-workspace (exwm-workspace--position exwm-workspace--current))
(workspace-string (elt exwm-workspace--switch-history current-workspace)))
(mapcar (lambda (x)
(setq workspace-string
(replace-regexp-in-string (number-to-string (cadr x))
(caddr x)
workspace-string)))
workspace-list)
workspace-string))
(defun my-workspace-switch ()
(interactive)
(let* ((letter (read-char (workspace-switch-prompt)))
(ws-info (assoc (char-to-string letter)
workspace-list)))
(if ws-info
(exwm-workspace-switch (cadr ws-info))
(exwm-workspace-switch (string-to-number
(char-to-string
letter))))))
(global-set-key (kbd "s-w") 'my-workspace-switch)
(global-set-key (kbd "s-l") '(lambda () (interactive) (launch-program "i3lock-fancy")))Simulation keys
(setq exwm-input-simulation-keys
'(
;; movement
([?\C-b] . left)
([?\M-b] . C-left)
([?\C-f] . right)
([?\M-f] . C-right)
([?\C-p] . up)
([?\C-n] . down)
([?\C-a] . home)
([?\C-e] . end)
([?\M-v] . prior)
([?\C-v] . next)
([?\C-d] . delete)
([?\M-d] . backspace)
([?\C-k] . (S-end delete))
;; cut/paste.
([?\C-w] . ?\C-x)
([?\M-w] . ?\C-c)
([?\C-y] . ?\C-v)
;; search
([?\C-s] . ?\C-f)
([?\C-.] . ?\C-w)
([?\C-/] . ?\C-z)
([?\M-s] . ?\C-s)
))Startup
Emacs server, startup programs, wallpaper
(add-hook 'exwm-init-hook 'server-start)
; Reminder: Hooks execute in order. Make sure megasync launches after systemtray is enabled
(add-hook 'exwm-init-hook 'call-startup-programs)
(add-hook 'exwm-init-hook 'setup-wallpaper)
(defun my/setup-screens ()
(interactive)
(let ((primary (shell-command-to-string "xrandr --query | grep ' connected' | grep eDP | cut -d ' ' -f 1 | tr -d '\n'"))
(secondary (shell-command-to-string "xrandr --query | grep ' connected' | grep -v eDP | cut -d ' ' -f 1 | tr -d '\n'")))
(setq exwm-randr-workspace-output-plist `(0 ,primary 1 ,primary 2 ,secondary 3 ,secondary))
(when (and (> (length secondary) 0)
(string= "yes" (completing-read (format "Monitor %s detected. Setup? " secondary) '("yes" "no"))))
(let* ((response (completing-read (format "Resolution for %s? " secondary) '("2560x1440" "1920x1080" "3840x2160") nil t "^"))
(length (string-to-number (substring response 0 4)))
(height (string-to-number (substring response 5 9))))
(shell-command (format "xrandr --output %s --mode %s --above %s" secondary response primary))
(let ((pos (completing-read "Position? " '("left-of" "above") nil t "^")))
(shell-command (format "xrandr --output %s --%s %s" secondary pos primary))))))
(setup-wallpaper))
(add-hook 'exwm-init-hook 'my/setup-screens)System tray, display time, display battery, display hard-drive-space
(require 'exwm-systemtray)
(exwm-systemtray-enable)
(setq display-time-day-and-date t)
(defvar my/exclude-buffer-modes '(helm-major-mode messages-buffer-mode special-mode))
(defun my-buffer-predicate (buf)
(with-current-buffer buf
(if (memq major-mode my/exclude-buffer-modes)
nil
(exwm-layout--other-buffer-predicate buf))))
(add-hook 'exwm-init-hook
(lambda ()
(interactive)
(modify-all-frames-parameters
'((buffer-predicate . my-buffer-predicate)))))
;(add-to-list 'default-frame-alist '(alpha . (85 . 50)))
(setq window-system-default-frame-alist '((x . ((alpha . (85 . 50)) ))))
;Display hard drive space
(add-hook 'display-time-hook 'update-hard-drive-space-string)
(display-time-mode)
(display-battery-mode)
(display-hard-drive-space-mode)Shutdown
(add-hook 'exwm-exit-hook 'org-save-all-org-buffers)
(add-hook 'exwm-exit-hook 'save-org-agenda-files)
(eval-after-load "term"
'(progn
(define-key term-raw-map (kbd "C-c C-y") 'term-paste)
(define-key term-raw-map (kbd "M-x") 'helm-M-x)))Xephyr launches in tiling-mode
(setq exwm-manage-configurations `(((equal exwm-class-name "Xephyr")
floating nil
char-mode t
fullscreen t)
((equal exwm-class-name "plasmashell")
floating t)))Wallpaper
(setq wallpaper-path "/home/benson/.emacs.d/res/digital_space_universe_4k_8k-wide.jpg")Volume
(use-package volume)
(define-key *root-map* (kbd "v") 'volume)Emacs
Reload Config
(defun reload-config () (interactive) (load-file "~/.emacs.d/init.el"))Select Help Window
(setq help-window-select t)Multi-term
(use-package multi-term)
(define-key term-mode-map (kbd "M-'") 'scroll-down)
(unbind-key (kbd "C-t") term-mode-map)
(add-hook 'term-mode-hook
(lambda ()
(add-to-list 'term-bind-key-alist '("M-[" . multi-term-prev))
(add-to-list 'term-bind-key-alist '("M-]" . multi-term-next))
(add-to-list 'term-bind-key-alist '("M-'" . scroll-down))
(add-to-list 'term-bind-key-alist '("C-t" . *root-map*))))resize-window
(use-package resize-window)
(global-set-key (kbd "M-1") 'resize-window)which-key
(use-package which-key)
(setq which-key-idle-delay 3)
(which-key-mode)beacon
(use-package beacon)
(beacon-mode 1)
(setq beacon-color "#006400")Dashboard
(use-package dashboard)
;(dashboard-setup-startup-hook)undo-tree
(use-package undo-tree)Look and feel
Theme
(use-package color-theme-modern)
(load-theme 'calm-forest t)Font
;;(set-face-attribute 'default t :font "Dotsies Training Wheels-20")
;;(add-to-list 'default-frame-alist '(font . "Dotsies Training Wheels-20"))
;; (set-default-font "LinuxLibertine")
;; (set-default-font "Hack 10")
;; (set-default-font "UbuntuMono 11")
;; (set-default-font "OfficeCodePro 11")
(if (eq system-type 'windows-nt)
(set-frame-font "Roboto Mono 10")
(set-frame-font "RobotoMono 11")
(let ((font
(format "%s"
"RobotoMono-11"
;; "Tamzen"
;; "SourceCodePro"
;; "Gohu Gohufont"
)))
(add-to-list 'default-frame-alist `(font . ,font))))
;; (set-frame-font "Menlo")
(defun reading-buffer ()
(interactive)
(setq buffer-face-mode-face '(:family "LinuxLibertine" :height 200))
(buffer-face-mode))mode-line
Powerline
Test new mode-line
(defun my-airline-theme ()
"Set the airline mode-line-format"
(interactive)
(setq-default mode-line-format
'("%e"
(:eval
(let* ((active (powerline-selected-window-active))
(separator-left (intern (format "powerline-%s-%s"
(powerline-current-separator)
(car powerline-default-separator-dir))))
(separator-right (intern (format "powerline-%s-%s"
(powerline-current-separator)
(cdr powerline-default-separator-dir))))
(mode-line-face (if active 'mode-line 'mode-line-inactive))
(visual-block (if (featurep 'evil)
(and (evil-visual-state-p)
(eq evil-visual-selection 'block))
nil))
(visual-line (if (featurep 'evil)
(and (evil-visual-state-p)
(eq evil-visual-selection 'line))
nil))
(current-evil-state-string (if (featurep 'evil)
(upcase (concat (symbol-name evil-state)
(cond (visual-block "-BLOCK")
(visual-line "-LINE"))))
nil))
(outer-face
(if (powerline-selected-window-active)
(if (featurep 'evil)
(cond ((eq evil-state (intern "normal")) 'airline-normal-outer)
((eq evil-state (intern "insert")) 'airline-insert-outer)
((eq evil-state (intern "visual")) 'airline-visual-outer)
((eq evil-state (intern "replace")) 'airline-replace-outer)
((eq evil-state (intern "emacs")) 'airline-emacs-outer)
(t 'airline-normal-outer))
'airline-normal-outer)
'powerline-inactive1))
(inner-face
(if (powerline-selected-window-active)
(if (featurep 'evil)
(cond ((eq evil-state (intern "normal")) 'airline-normal-inner)
((eq evil-state (intern "insert")) 'airline-insert-inner)
((eq evil-state (intern "visual")) 'airline-visual-inner)
((eq evil-state (intern "replace")) 'airline-replace-inner)
((eq evil-state (intern "emacs")) 'airline-emacs-inner)
(t 'airline-normal-inner))
'airline-normal-inner)
'powerline-inactive2))
(center-face
(if (powerline-selected-window-active)
(if (featurep 'evil)
(cond ((eq evil-state (intern "normal")) 'airline-normal-center)
((eq evil-state (intern "insert")) 'airline-insert-center)
((eq evil-state (intern "visual")) 'airline-visual-center)
((eq evil-state (intern "replace")) 'airline-replace-center)
((eq evil-state (intern "emacs")) 'airline-emacs-center)
(t 'airline-normal-center))
'airline-normal-center)
'airline-inactive3))
;; Left Hand Side
(lhs-mode (if (featurep 'evil)
(list
;; Evil Mode Name
(powerline-raw (concat " " current-evil-state-string " ") outer-face)
(funcall separator-left outer-face inner-face)
;; Modified string
(powerline-raw "%*" inner-face 'l)
)
(list
;; Modified string
(powerline-raw "%*" outer-face 'l)
;; Separator >
(powerline-raw " " outer-face)
(funcall separator-left outer-face inner-face))))
(lhs-rest (list
;; ;; Separator >
;; (powerline-raw (char-to-string #x2b81) inner-face 'l)
;; Eyebrowse current tab/window config
(if (featurep 'eyebrowse)
(powerline-raw (concat " " (eyebrowse-mode-line-indicator)) inner-face))
;; Git Branch
(powerline-raw (airline-get-vc) inner-face)
;; Separator >
(powerline-raw " " inner-face)
(funcall separator-left inner-face center-face)
;; Directory
;(when (eq airline-display-directory 'airline-directory-shortened)
; (powerline-raw (airline-shorten-directory default-directory airline-shortened-directory-length) center-face 'l))
;(when (eq airline-display-directory 'airline-directory-full)
; (powerline-raw default-directory center-face 'l))
;(when (eq airline-display-directory nil)
; (powerline-raw " " center-face))
;; Buffer ID
;; (powerline-buffer-id center-face)
;; (powerline-raw "%b" center-face)
(powerline-buffer-id center-face)
(powerline-major-mode center-face 'l)
(powerline-process center-face)
;(powerline-minor-modes center-face 'l)
;; Current Function (which-function-mode)
(when (and (boundp 'which-func-mode) which-func-mode)
;; (powerline-raw which-func-format 'l nil))
(powerline-raw which-func-format center-face 'l))
;; ;; Separator >
;; (powerline-raw " " center-face)
;; (funcall separator-left mode-line face1)
(when (boundp 'erc-modified-channels-object)
(powerline-raw erc-modified-channels-object center-face 'l))
;; ;; Separator <
;; (powerline-raw " " face1)
;; (funcall separator-right face1 face2)
))
(lhs (append lhs-mode lhs-rest))
;; Right Hand Side
(rhs (list (powerline-raw global-mode-string center-face 'r)
;; ;; Separator <
;; (powerline-raw (char-to-string #x2b83) center-face 'l)
;; Minor Modes
;(powerline-minor-modes center-face 'l)
;; (powerline-narrow center-face 'l)
;; Subseparator <
(powerline-raw (char-to-string airline-utf-glyph-subseparator-right) center-face 'l)
;; Major Mode
;(powerline-major-mode center-face 'l)
;(powerline-process center-face)
;; Separator <
(powerline-raw " " center-face)
(funcall separator-right center-face inner-face)
;; Buffer Size
(when powerline-display-buffer-size
(powerline-buffer-size inner-face 'l))
;; Mule Info
(when powerline-display-mule-info
(powerline-raw mode-line-mule-info inner-face 'l))
(powerline-raw " " inner-face)
;; Separator <
(funcall separator-right inner-face outer-face)
;; LN charachter
(powerline-raw (char-to-string airline-utf-glyph-linenumber) outer-face 'l)
;; Current Line
(powerline-raw "%4l" outer-face 'l)
(powerline-raw ":" outer-face 'l)
;; Current Column
(powerline-raw "%3c" outer-face 'r)
;; % location in file
(powerline-raw "%6p" outer-face 'r)
;; position in file image
(when powerline-display-hud
(powerline-hud inner-face outer-face)))
))
;; Combine Left and Right Hand Sides
(concat (powerline-render lhs)
(powerline-fill center-face (powerline-width rhs))
(powerline-render rhs))))))
(powerline-reset)
(kill-local-variable 'mode-line-format))
(defun my-show-minor-modes ()
"Set the airline mode-line-format"
(interactive)
(setq-default mode-line-format
'("%e"
(:eval
(let* ((active (powerline-selected-window-active))
(separator-left (intern (format "powerline-%s-%s"
(powerline-current-separator)
(car powerline-default-separator-dir))))
(separator-right (intern (format "powerline-%s-%s"
(powerline-current-separator)
(cdr powerline-default-separator-dir))))
(mode-line-face (if active 'mode-line 'mode-line-inactive))
(visual-block (if (featurep 'evil)
(and (evil-visual-state-p)
(eq evil-visual-selection 'block))
nil))
(visual-line (if (featurep 'evil)
(and (evil-visual-state-p)
(eq evil-visual-selection 'line))
nil))
(current-evil-state-string (if (featurep 'evil)
(upcase (concat (symbol-name evil-state)
(cond (visual-block "-BLOCK")
(visual-line "-LINE"))))
nil))
(outer-face
(if (powerline-selected-window-active)
(if (featurep 'evil)
(cond ((eq evil-state (intern "normal")) 'airline-normal-outer)
((eq evil-state (intern "insert")) 'airline-insert-outer)
((eq evil-state (intern "visual")) 'airline-visual-outer)
((eq evil-state (intern "replace")) 'airline-replace-outer)
((eq evil-state (intern "emacs")) 'airline-emacs-outer)
(t 'airline-normal-outer))
'airline-normal-outer)
'powerline-inactive1))
(inner-face
(if (powerline-selected-window-active)
(if (featurep 'evil)
(cond ((eq evil-state (intern "normal")) 'airline-normal-inner)
((eq evil-state (intern "insert")) 'airline-insert-inner)
((eq evil-state (intern "visual")) 'airline-visual-inner)
((eq evil-state (intern "replace")) 'airline-replace-inner)
((eq evil-state (intern "emacs")) 'airline-emacs-inner)
(t 'airline-normal-inner))
'airline-normal-inner)
'powerline-inactive2))
(center-face
(if (powerline-selected-window-active)
(if (featurep 'evil)
(cond ((eq evil-state (intern "normal")) 'airline-normal-center)
((eq evil-state (intern "insert")) 'airline-insert-center)
((eq evil-state (intern "visual")) 'airline-visual-center)
((eq evil-state (intern "replace")) 'airline-replace-center)
((eq evil-state (intern "emacs")) 'airline-emacs-center)
(t 'airline-normal-center))
'airline-normal-center)
'airline-inactive3))
;; Left Hand Side
(lhs-mode (if (featurep 'evil)
(list
;; Evil Mode Name
(powerline-raw (concat " " current-evil-state-string " ") outer-face)
(funcall separator-left outer-face inner-face)
;; Modified string
(powerline-raw "%*" inner-face 'l)
)
(list
;; Modified string
(powerline-raw "%*" outer-face 'l)
;; Separator >
(powerline-raw " " outer-face)
(funcall separator-left outer-face inner-face))))
(lhs-rest (list
;; ;; Separator >
;; (powerline-raw (char-to-string #x2b81) inner-face 'l)
;; Eyebrowse current tab/window config
(if (featurep 'eyebrowse)
(powerline-raw (concat " " (eyebrowse-mode-line-indicator)) inner-face))
;; Git Branch
(powerline-raw (airline-get-vc) inner-face)
;; Separator >
(powerline-raw " " inner-face)
(funcall separator-left inner-face center-face)
;; Directory
;(when (eq airline-display-directory 'airline-directory-shortened)
; (powerline-raw (airline-shorten-directory default-directory airline-shortened-directory-length) center-face 'l))
;(when (eq airline-display-directory 'airline-directory-full)
; (powerline-raw default-directory center-face 'l))
;(when (eq airline-display-directory nil)
; (powerline-raw " " center-face))
;; Buffer ID
;; (powerline-buffer-id center-face)
;; (powerline-raw "%b" center-face)
(powerline-buffer-id center-face)
(powerline-major-mode center-face 'l)
(powerline-process center-face)
(powerline-minor-modes center-face 'l)
;; Current Function (which-function-mode)
(when (and (boundp 'which-func-mode) which-func-mode)
;; (powerline-raw which-func-format 'l nil))
(powerline-raw which-func-format center-face 'l))
;; ;; Separator >
;; (powerline-raw " " center-face)
;; (funcall separator-left mode-line face1)
(when (boundp 'erc-modified-channels-object)
(powerline-raw erc-modified-channels-object center-face 'l))
;; ;; Separator <
;; (powerline-raw " " face1)
;; (funcall separator-right face1 face2)
))
(lhs (append lhs-mode lhs-rest))
;; Right Hand Side
(rhs (list (powerline-raw global-mode-string center-face 'r)
;; ;; Separator <
;; (powerline-raw (char-to-string #x2b83) center-face 'l)
;; Minor Modes
;(powerline-minor-modes center-face 'l)
;; (powerline-narrow center-face 'l)
;; Subseparator <
(powerline-raw (char-to-string airline-utf-glyph-subseparator-right) center-face 'l)
;; Major Mode
;(powerline-major-mode center-face 'l)
;(powerline-process center-face)
;; Separator <
(powerline-raw " " center-face)
(funcall separator-right center-face inner-face)
;; Buffer Size
(when powerline-display-buffer-size
(powerline-buffer-size inner-face 'l))
;; Mule Info
(when powerline-display-mule-info
(powerline-raw mode-line-mule-info inner-face 'l))
(powerline-raw " " inner-face)
;; Separator <
(funcall separator-right inner-face outer-face)
;; LN charachter
(powerline-raw (char-to-string airline-utf-glyph-linenumber) outer-face 'l)
;; Current Line
(powerline-raw "%4l" outer-face 'l)
(powerline-raw ":" outer-face 'l)
;; Current Column
(powerline-raw "%3c" outer-face 'r)
;; % location in file
(powerline-raw "%6p" outer-face 'r)
;; position in file image
(when powerline-display-hud
(powerline-hud inner-face outer-face)))
))
;; Combine Left and Right Hand Sides
(concat (powerline-render lhs)
(powerline-fill center-face (powerline-width rhs))
(powerline-render rhs))))))
(powerline-reset)
(kill-local-variable 'mode-line-format))Config
(use-package powerline)
(use-package airline-themes)
(setq powerline-default-separator 'arrow)
(load-theme 'airline-powerlineish)
(my-airline-theme)
(setq battery-mode-line-format "[%b%p%%%%]")Smart Mode Line
(use-package smart-mode-line-powerline-theme)
(use-package smart-mode-line)
(require 'smart-mode-line-powerline-theme)
(require 'smart-mode-line)
(setq sml/theme 'powerline)
;; (add-to-list
;; 'after-make-frame-functions
;; (lambda (&optional x)
;; (require 'smart-mode-line-powerline-theme)
;; (require 'smart-mode-line)
;; (setq sml/theme 'powerline)
;; (sml/setup)))Ocodo
(use-package ocodo-svg-modelines)Splash image
(setq fancy-splash-image "~/.emacs.d/res/icon.png")Navigation
IDO
(use-package ido)
(ido-mode t)Helm & counsel/ivy
(use-package helm)
(require 'helm-config)
;(helm-mode 1)
;(setq ivy-initial-inputs-alist nil)
(use-package ivy)
(use-package smex)
(use-package counsel)
(ivy-mode 1)
;(advice-add 'ivy-completion-in-region :before (lambda (start end collection &optional predicate) (insert " ")))
(add-to-list 'ivy-initial-inputs-alist '(org-refile . ""))
(add-to-list 'ivy-initial-inputs-alist '(org-agenda-refile . ""))
(add-to-list 'ivy-initial-inputs-alist '(org-capture-refile . ""))
(add-to-list 'ivy-initial-inputs-alist '(counsel-M-x . ""))
(define-key ivy-minibuffer-map (kbd "<return>") 'ivy-alt-done)
(define-key ivy-minibuffer-map (kbd "C-<return>") 'ivy-done)
(global-set-key (kbd "C-h M-x") 'helm-M-x)
(global-set-key (kbd "M-x") 'counsel-M-x)
;; (global-set-key (kbd "C-x b") 'counsel-switch-buffer)Swiper or counsel-grep
(global-set-key (kbd "C-s") 'counsel-grep-or-swiper)
(setq counsel-grep-base-command "grep --ignore-case -E -n -e %s %s")help should still use regular search
(define-key Info-mode-map (kbd "C-s") 'isearch-forward)transpose-frame
Evil mode
(use-package evil)
(global-set-key (kbd "C-z") 'evil-local-mode)
(setq evil-insert-state-modes nil)
(setq evil-motion-state-modes nil)
(setq evil-default-state 'emacs)
(evil-set-initial-state 'term-mode 'emacs)
(evil-set-initial-state 'help-mode 'emacs)
(evil-mode 1)Ace window
(use-package switch-window)
(global-set-key (kbd "C-x o") 'switch-window)
(setq switch-window-shortcut-style 'qwerty)
(setq switch-window-qwerty-shortcuts
'("a" "o" "e" "u" "i" "d" "h" "t" "n" "s"))ibuffer
Keybindings
(global-set-key (kbd "C-x C-b") 'ibuffer)Config
(require 'ibuf-ext)
(autoload 'ibuffer "ibuffer" "List buffers." t)
(add-to-list 'ibuffer-never-show-predicates
'(lambda (buf)
(with-current-buffer buf
(eq major-mode 'helm-major-mode))))
(setq ibuffer-saved-filter-groups
'(("General"
("X-Windows" (mode . exwm-mode))
("Terminals" (mode . term-mode))
("emacs-config" (or (filename . ".emacs.d")
(filename . "emacs-config")))
("code-aux" (or (mode . slime-repl-mode)
(mode . magit-status-mode)
(mode . ein:notebooklist-mode)
(mode . cider-repl-mode)
(mode . comint-mode)
(mode . makefile-gmake-mode)))
("code" (or (mode . clojure-mode)
(mode . csharp-mode)
(mode . c++-mode)
(mode . c-mode)
(mode . scala-mode)
(mode . emacs-lisp-mode)
(mode . java-mode)
(mode . js-mode)
(mode . python-mode)
(mode . ng2-ts-mode)
(mode . lisp-mode)
(mode . ein:notebook-multilang-mode)))
("web" (or (mode . web-mode)
(mode . mhtml-mode)
(mode . js2-mode)
(mode . css-mode)))
("Org Mode" (not or (not mode . org-mode)
(directory-name . "agenda")))
("text" (filename . "\\.txt"))
("pdfs" (or (mode . doc-view-mode)
(mode . pdf-view-mode)))
("Agenda Buffers" (mode . org-agenda-mode))
("Agenda Files" (mode . org-mode))
("folders" (mode . dired-mode))
("Help" (or (name . "\*Help\*")
(name . "\*Apropos\*")
(name . "\*info\*"))))))
(setq ibuffer-show-empty-filter-groups nil)
(add-hook 'ibuffer-mode-hook
'(lambda ()
(ibuffer-auto-mode 1)
(ibuffer-switch-to-saved-filter-groups "General")
(ibuffer-do-sort-by-alphabetic)))Custom Filters
(eval-after-load "ibuf-ext"
'(define-ibuffer-filter directory-name
"Filter files in the agenda folder"
(:description "agenda")
(and (buffer-file-name buf)
(string-match qualifier
(buffer-file-name buf)))))
;(add-hook 'exwm-workspace-switch-hook 'ibuffer)Ace jump
(use-package ace-jump-mode)
(global-set-key (kbd "C-c SPC") 'ace-jump-mode)
(global-set-key (kbd "C-c j") 'ace-jump-line-mode)Tools
Encryption
(require 'epa-file)
(epa-file-enable)
(setq epa-pinentry-mode 'loopback)
(setq epa-file-cache-passphrase-for-symmetric-encryption t)Org Mode
Keybindings and customization
(use-package org)
(require 'org-agenda)
(global-set-key (kbd "M-–") (lambda () (interactive) (org-agenda "" "p")))
(global-set-key (kbd "M-•") (lambda () (interactive) (org-agenda "" "n")))
(global-set-key "\C-cl" 'org-store-link)
(global-set-key "\C-ca" 'org-agenda)
(global-set-key (kbd "M-∀") 'org-agenda)
(global-set-key "\C-cc" 'org-capture)
(global-set-key "\C-cb" 'org-iswitchb)
(global-set-key (kbd "<f5>") 'org-agenda)
(global-set-key (kbd "<f11>") (lambda () (interactive) (org-agenda "" "p")))
(global-set-key (kbd "<f9>") 'org-capture)
(global-set-key (kbd "<f12>") (lambda () (interactive) (org-agenda "" "n")))
(global-set-key (kbd "C-x C-o") 'org-agenda)
(define-key org-mode-map (kbd "C-c SPC") nil)
(define-key org-agenda-mode-map (kbd "a") 'org-agenda)
(setq org-src-window-setup 'current-window)
(add-hook 'org-mode-hook (lambda () (visual-line-mode 1)))
(setq org-list-allow-alphabetical t)
;; This is for safety
(define-key org-mode-map (kbd "C-S-<backspace>")
(lambda (arg)
(interactive "P")
(if (string= "yes" (completing-read "Are you sure you want to use that keybinding? " '("yes" "no")))
(kill-whole-line arg)
(org-cut-subtree))))Face
(when (not (eq system-type 'windows-nt))
(setq org-ellipsis " "))My Template BROKEN
;; (add-to-list 'org-structure-template-alist
;; '("sv" . "#+BEGIN_SRC ? :results value\n\n#+END_SRC"))
;; (add-to-list 'org-structure-template-alist
;; '("so" . "#+BEGIN_SRC ? :results output\n\n#+END_SRC"))Capture templates
(setq org-default-notes-file "~/MEGA/org-old/notes.org")
(setq org-capture-templates
'(("t" "Todo" entry (file "~/MEGA/org/agenda/refile.org")
"* STUFF %?\n :PROPERTIES:\n :CREATED: %U\n :VIEWING: %a\n :END:")
("r" "Review" entry (file+function "~/MEGA/org/entries/reviews.gpg" setup-automatic-review)
(file "~/MEGA/org/templates/review-interactive-entry.org"))
("rt" "Review Task" entry (file+headline "~/MEGA/org/entries/reviews.gpg" "Tasks")
"* TODO %?")
("d" "Dream" entry (file+olp+datetree "~/MEGA/org/entries/dream.org")
"* %?")
("D" "Distracted" entry (file "~/MEGA/org/agenda/refile.org")
"* TODO %?" :clock-in t :clock-resume t)
("T" "New Task" entry (file "~/MEGA/org/agenda/refile.org")
"* TODO %?" :clock-in t :clock-keep t)
("m" "Money" plain (file "~/MEGA/org/entries/finances/ledger.ledger")
(file "~/MEGA/org/templates/basic.ledger") :unnarrowed t :empty-lines 1)
("c" "Record Comms Message" entry (file+olp+datetree "~/MEGA/org/entries/comms.org")
"* TODO %?")
("j" "Journal")
("je" "Journal Entry" entry (file+olp+datetree "~/MEGA/org/entries/journal.gpg")
"* %<%R> %?\n%U\n\n")
("jp" "Plan your day" entry (file+olp+datetree "~/MEGA/org/entries/journal.gpg")
(file "~/MEGA/org/templates/daily-plan.org"))
("C" "Create checklist")
("Cc" "Conference Via Bus" entry (file "~/MEGA/org/agenda/refile.org")
(file "~/MEGA/org/checklists/conference.org")
:conference/airplane nil)
("Cm" "Morning routine" entry (file "~/MEGA/org/entries/routines.org")
(file "~/MEGA/org/checklists/mornings.org"))
("Cn" "Nightly routine" entry (file "~/MEGA/org/entries/routines.org")
(file "~/MEGA/org/checklists/nights.org"))
("y" "Elfeed YouTube" entry (file+olp "~/MEGA/org/agenda/agenda.org" "rewards" "Videos")
"* TODO %(identity elfeed-link-org-capture)")
("p" "Protocol" entry (file "~/MEGA/org/agenda/refile.org")
"* STUFF %^{Title}\nSource: %u, %c\n #+BEGIN_QUOTE\n%i\n#+END_QUOTE\n\n\n%?")
("L" "Protocol Link" entry (file "~/MEGA/org/agenda/refile.org")
"* STUFF %? [[%:link][%:description]] \nCaptured On: %U")))disabled
(setq org-capture-templates
'(("w" "Web" entry (file "~/MEGA/org/agenda/refile.org")
"* TODO [[%^{URL}][%^{Title}]]\n :PROPERTIES:\n :CREATED: %U\n :END:")
("f" "Reference" entry (file "~/MEGA/org/agenda/reference.org")
"* %?\n%i%U")
("rm" "Make-up Weekly Review" plain (function make-up-review-file)
(file "~/MEGA/org/templates/review-interactive.org"))
("rw" "Weekly Review" plain (function weekly-review-file)
(file "~/MEGA/org/templates/weekly-review-template.org"))
("i" "Important information" entry (file "~/MEGA/org/entries/important.gpg")
"* %?")
("e" "Entries")
("ee" "Exercise" table-line (file "~/MEGA/org/entries/exercise.org")
"| %u | %^{Push-ups} | %^{Leg-lifts} | %^{Squats}")
("l" "Later")
("lr" "Read Later" entry (file+headline "~/MEGA/org/agenda/lists.org" "Things to read")
"* TODO %?\n%U\n")
("ll" "Links for life" entry (file "~/MEGA/org/entries/links.org")
"* %?")
("w" "Weekly Thoughts" entry (function org-capture-function)
"** %<%R> %?")))Custom Journal
Attempt 3
(defvar yearly-theme "Thought")
(defun completed-tags-search (start-date end-date)
(let ((org-agenda-overriding-header "* Log")
(tag-search (concat (format "TODO=\"DONE\"&CLOSED>=\"<%s>\"&CLOSED<=\"<%s>\""
start-date
end-date))))
(org-tags-view nil tag-search)))
(defun get-tasks-from (start-date end-date)
(let (string)
(save-window-excursion
(completed-tags-search start-date end-date)
(setq string (mapconcat 'identity
(mapcar (lambda (a)
(concat "***" a))
(butlast (cdr (split-string (buffer-string) "\n")) 1))
"\n"))
(kill-buffer))
string))
(defun get-journal-entries-from (start-date end-date)
(let ((string "")
match)
(save-window-excursion
(switch-to-buffer (find-file "~/MEGA/org/entries/journal.gpg"))
(goto-char (point-min))
(while (setq match
(re-search-forward
"^\\*\\*\\* \\(2[0-9]\\{3\\}-[0-9]\\{2\\}-[0-9]\\{2\\}\\) \\w+$" nil t))
(let ((date (match-string 1)))
(when (and (org-time< start-date date)
(or (not end-date) (org-time< date end-date)))
(org-narrow-to-subtree)
(setq string (concat string "\n" (buffer-string)))
(widen))))
(not-modified)
(kill-buffer))
string))
(defun weekly-review-file ()
(set-buffer
(org-capture-target-buffer (format "~/MEGA/org/entries/review/%s/Year of %s, Week %s.org"
(format-time-string "%Y")
yearly-theme
(format-time-string "%V")))))
(defun make-up-review-file ()
(let* ((date (org-read-date))
(week (number-to-string
(org-days-to-iso-week
(org-time-string-to-absolute date)))))
(org-capture-put :start-date date)
(org-capture-put :start-week week)
(set-buffer
(org-capture-target-buffer
(format "~/MEGA/org/entries/review/%s/Year of %s, Week %s-%s.org"
(format-time-string "%Y")
yearly-theme
week
(format-time-string "%V"))))))
(defun output-date ()
(when my/review-date-old
(save-window-excursion
(switch-to-buffer (find-file "~/.emacs.d/last-review.el"))
(erase-buffer)
(insert (org-read-date nil nil ""))
(save-buffer)
(kill-buffer)
"")
)
(setq my/review-date-old nil))
(add-hook 'org-capture-before-finalize-hook 'output-date)
(defun get-last-review-date ()
(save-window-excursion
(set-buffer (find-file "~/.emacs.d/last-review.el"))
(let ((res (buffer-string)))
(kill-buffer)
res)))
(defun setup-make-up-review ()
(let* ((date (org-read-date))
(week (number-to-string
(org-days-to-iso-week
(org-time-string-to-absolute date)))))
(org-capture-put :start-date date)
(org-capture-put :start-week week)))
(defvar my/review-date-old nil)
(defun setup-automatic-review ()
(let* ((date (org-read-date nil nil (get-last-review-date)))
(week (format "%02d"
(org-days-to-iso-week
(org-time-string-to-absolute date)))))
(setq my/review-date-old date)
(setq my/review-visibility-level 6)
(org-capture-put :start-date date)
(org-capture-put :start-week week)
(goto-char (point-min))
(re-search-forward "Reviews")))
(defvar my/review-visibility-level nil)
(defun my/review-set-visibility ()
(when my/review-visibility-level
(outline-hide-sublevels my/review-visibility-level)
(org-show-entry)
(setq my/review-visibility-level nil)))
(add-hook 'org-capture-mode-hook
'my/review-set-visibility)org-agenda
Agenda Files
(defvar org-agenda-files-list
"~/.emacs.d/agenda-files.el"
"Path to save org-agenda-files list")
(defun save-org-agenda-files ()
""
(interactive)
(save-excursion
(let ((buf (find-file-noselect org-agenda-files-list)))
(set-buffer buf)
(erase-buffer)
(print (list 'quote org-agenda-files) buf)
(save-buffer)
(kill-buffer)
(message "org-agenda file list saved to: %s" org-agenda-files-list))))
(defun org-agenda-load-file-list ()
""
(interactive)
(save-excursion
(let ((buf (find-file-noselect org-agenda-files-list)))
(set-buffer buf)
(setq org-agenda-files (eval (read (buffer-string))))
(kill-buffer)
(message "org-agenda-files-list loaded from: %s" org-agenda-files-list))))General config
(setq org-log-done 'time)
(setq org-agenda-window-setup 'current-window)
(setq org-agenda-restore-windows-after-quit t)
(setq org-agenda-sticky t)
(setq org-todo-keywords
'((sequence "STUFF(s)" "SOMEDAY(P)" "INACT(i)" "|")
(sequence "TODO(t)" "GOAL(g)" "ONE(o)" "NEXT(n)" "HABIT(H)" "|" "DONE(d!)")
(sequence "PROJECT(p)" "SEQUENTIAL(S)" "ETERNAL(e)" "|" "COMPLETE(c)")
(sequence "WAIT(w@/!)" "HOLD(h)" "TICKLER())" "FORGOTTEN(f)" "|" "ABANDON(a@/!)")
(sequence "TOP" "|")))
(setq org-todo-keyword-faces
'(("ONE" :foreground "royal blue" :weight bold)
("STUFF" :foreground "goldenrod" :weight bold)
("NEXT" :foreground "cyan" :weight bold)
("WAIT" :foreground "yellow" :weight bold)
("HOLD" :foreground "red" :weight bold)
("PROJECT" :foreground "white" :weight bold)
("SEQUENTIAL" :foreground "white" :weight bold)
("ABANDON" :foreground "dark gray" :weight bold)
("FORGOTTEN" :foreground "dark gray" :weight bold)
("TOP" :foreground "royal blue" :weight bold)
("INACT" :foreground "dark gray" :weight bold)))
(setq org-todo-state-tags-triggers
(quote (("HOLD" ("HOLD" . t))
("WAIT" ("WAITING" . t))
(todo ("HOLD") ("WAITING")))))
(setq org-use-fast-todo-selection t)
;(setq org-agenda-files (quote ("~/MEGA/org/agenda/dallas.org")))
(org-agenda-load-file-list)
; Targets include this file and any file contributing to the agenda - up to 9 levels deep
(setq org-refile-targets `((nil :maxlevel . 9)
(org-agenda-files :maxlevel . 9)
("~/MEGA/org/entries/panic.org" :maxlevel . 9)))
(setq org-refile-use-cache t)
(setq org-refile-target-verify-function
(lambda ()
(let ((tags (org-get-tags-at)))
(and (not (member "ARCHIVE" tags))
(not (equal "DONE" (org-get-todo-state)))))))
(setq org-agenda-show-future-repeats nil)
; Use full outline paths for refile targets - we file directly with IDO
(setq org-refile-use-outline-path 'file)
; Targets complete directly with IDO
(setq org-outline-path-complete-in-steps nil)
; Allow refile to create parent tasks with confirmation
(setq org-refile-allow-creating-parent-nodes (quote confirm))
; Use the current window for indirect buffer display
(setq org-indirect-buffer-display 'current-window)
;; Do not dim blocked tasks
(setq org-agenda-dim-blocked-tasks nil)
(setq org-agenda-compact-blocks t)My org traversal functions
(defun get-variables (l)
(cond ((null l) nil)
((consp (car l))
(append (extract-variables (car l))
(get-variables (cdr l))))
(t (cons (car l)
(get-variables (cdr l))))))
(defun extract-variables (l)
(if (not (consp l))
l
(get-variables (cdr l))))
(defmacro org-loop/descendants (&rest body)
(declare (indent defun))
(let ((subtree-symbol (make-symbol "subtree-end")))
`(let ((,subtree-symbol (save-excursion (org-end-of-subtree t))))
(while (and (outline-next-heading)
(< (point) ,subtree-symbol))
,@body))))
(defmacro org-loop/children (&rest body)
(declare (indent defun))
(let ((subtree-symbol (make-symbol "subtree-end")))
`(let ((,subtree-symbol (save-excursion (org-end-of-subtree t))))
(outline-next-heading)
(while (and (org-end-of-subtree t t)
(< (point) ,subtree-symbol))
,@body))))
(defmacro orgc-loop/descendants (condition &rest body)
(declare (indent defun))
(let ((subtree-symbol (make-symbol "subtree-end")))
`(let ((,subtree-symbol (save-excursion (org-end-of-subtree t)))
(,condition nil))
(while (and (not ,condition)
(outline-next-heading)
(< (point) ,subtree-symbol))
,@body)
,condition)))
(defmacro orgb-loop/descendants (condition &rest body)
(declare (indent defun))
(let ((subtree-symbol (make-symbol "subtree-end"))
(vars (extract-variables condition)))
`(let ((,subtree-symbol (save-excursion (org-end-of-subtree t)))
,@vars)
(while (and ,condition
(outline-next-heading)
(< (point) ,subtree-symbol))
,@body)
,condition)))
;; (orgb-loop/descendants (and not-stuff stuff)
;; (+ 1 2))
(defmacro orgc-loop/children (condition &rest body)
(declare (indent defun))
(let ((subtree-symbol (make-symbol "subtree-end")))
`(let ((,subtree-symbol (save-excursion (org-end-of-subtree t)))
(,condition nil))
(outline-next-heading)
(while (and (not ,condition)
(< (point) ,subtree-symbol))
,@body
(org-end-of-subtree t t))
,condition)))
(defmacro orgc-loop/todo-descendants (condition &rest body)
(declare (indent defun))
(let ((todo-state (make-symbol "todo-state"))
(tags (make-symbol "tags")))
`(orgc-loop/descendants ,condition
(let ((,todo-state (org-get-todo-state))
(,tags (org-get-tags (point))))
(when ,todo-state
(if (member "ARCHIVE" ,tags)
(org-end-of-subtree t)
,@body))))))
(defmacro orgc-loop/todo-children (condition &rest body)
(declare (indent defun))
(let ((todo-state (make-symbol "todo-state"))
(tags (make-symbol "tags")))
`(orgc-loop/children ,condition
(let ((,todo-state (org-get-todo-state))
(,tags (org-get-tags (point))))
(when ,todo-state
(if (member "ARCHIVE" ,tags)
(org-end-of-subtree t)
,@body))))))
(defmacro orgb-loop/todo-children (condition &rest body)
(declare (indent defun))
(let ((todo-state (make-symbol "todo-state"))
(tags (make-symbol "tags")))
`(orgb-loop/children ,condition
(let ((,todo-state (org-get-todo-state))
(,tags (org-get-tags (point))))
(when ,todo-state
(if (member "ARCHIVE" ,tags)
(org-end-of-subtree t)
,@body))))))
;; (insert (format "\n%s" (macroexpand-all
;; '(orgc-loop/todo-children todo
;; (setq todo t)))))
(defmacro org-loop/todo-descendants (&rest body)
(declare (indent defun))
(let ((todo-state (make-symbol "todo-state"))
(tags (make-symbol "tags")))
`(org-loop/descendants
(let ((,todo-state (org-get-todo-state))
(,tags (org-get-tags (point))))
(when ,todo-state
(if (member "ARCHIVE" ,tags)
(org-end-of-subtree t)
,@body))))))
(defmacro org-loop/todo-children (condition &rest body)
(declare (indent defun))
(let ((todo-state (make-symbol "todo-state"))
(tags (make-symbol "tags")))
`(org-loop/children
(let ((,todo-state (org-get-todo-state))
(,tags (org-get-tags (point))))
(when (and ,todo-state
(not (member "ARCHIVE") ,tags))
,@body)))))
(defmacro traverse-org-headlines (headline &rest body)
(declare (indent defun))
(let ((buffer-symbol (make-symbol "buffer")))
`(let (,buffer-symbol)
(org-check-agenda-file ,(cadr headline))
(setq ,buffer-symbol (if (file-exists-p ,(cadr headline))
(org-get-agenda-file-buffer ,(cadr headline))
(error "No such file %s" ,(cadr headline))))
(with-current-buffer ,buffer-symbol
(while (and (not (eobp))
(outline-next-heading))
,@body)))))
(defmacro traverse-org-files (files &rest body)
(declare (indent defun))
(let ((file-symbol (make-symbol "file")))
`(dolist (,file-symbol ,(cadr files))
(traverse-org-headlines (,(car files) ,file-symbol)
,@body))))
;; (insert (format "%s" (macroexpand-all
;; ' (traverse-org-files (a org-agenda-files)
;; (+ 1 2)))))My Project code
(defun my/is-part-of-subtree ()
(save-excursion
(and (not (= 1 (org-current-level)))
(let (has-parent-project)
(while (and (not has-parent-project)
(org-up-heading-safe))
(when (org-get-todo-state)
(setq has-parent-project t)))
has-parent-project))))
(defun my/is-standalone-task ()
(and (not (member (org-get-todo-state) '("HOLD" "PROJECT" "SOMEDAY" "TICKLER" "SEQUENTIAL")))
(not (member "ARCHIVE" (org-get-tags (point))))
(not (my/is-part-of-subtree))
(not (my/is-a-project))))
(defun my/no-children ()
"t if heading has one subheading with a todo keyword"
(save-excursion
(not (orgc-loop/todo-children has-children
(setq has-children t)))))
(defun my/is-unactionable-task ()
(or (member "NOT_TASKS" (org-get-tags (point)))
(member (org-get-todo-state) (cons "INACT" org-done-keywords))))
(defun my/has-non-done-task ()
(save-excursion
(orgc-loop/todo-children has-non-done-task
(when (not (member (org-get-todo-state)
org-done-keywords))
(setq has-non-done-task t)))))
(defun my/is-a-task ()
(save-excursion
(and (not (member "NOT_TASKS" (org-get-tags (point))))
(or (and (equal "ONE" (org-get-todo-state))
(not (my/has-non-done-task)))
(and (org-get-todo-state)
(not (member (org-get-todo-state) '("PROJECT" "SOMEDAY" "WAIT" "HOLD")))
(my/no-children))))))
(defun my/has-subtask ()
(save-excursion
(orgc-loop/todo-children has-subtask
(when (org-get-todo-state)
(setq has-subtask t)))))
(defun my/has-next-task ()
(save-excursion
(orgc-loop/todo-children has-next-task
(when (my/is-next-task)
(setq has-next-task t)))))
(defun my/is-next-task ()
(let ((todo (org-get-todo-state)))
(or ;;(equal todo "NEXT")
(and (member todo '("TODO" "ONE" "NEXT"))
(or (org-get-scheduled-time (point))
(org-get-deadline-time (point)))))))
(defun my/is-a-project ()
(save-excursion
(let ((todo (org-get-todo-state)))
(when todo
(or (member todo '("PROJECT" "ETERNAL" "HOLD" "SEQUENTIAL"))
(and (equal todo "ONE")
(my/has-non-done-task))
(and (member todo '("TODO"))
(my/has-subtask)))))))
(defvar my/ambiguous-projects-default-to-stuck t)
(defun my/greedy-active-project (file point)
(save-excursion
(let ((subtree-end (save-excursion (org-end-of-subtree t)))
has-next-task has-active-project)
(outline-next-heading)
(while (and (not (and has-next-task
has-active-project))
(< (point) subtree-end))
(cond ((and (my/is-a-task)
(my/is-next-task))
(setq has-next-task t))
((and (my/is-a-project)
(eq (my/get-project-type file (point) nil)
'active))
(setq has-active-project t)))
(org-end-of-subtree t t))
(or has-next-task
has-active-project))))
(defun my/active-sequential-project (file point)
(save-excursion
(let ((subtree-end (save-excursion (org-end-of-subtree t)))
has-next-task has-active-project)
(outline-next-heading)
(while (and (not (or has-next-task
has-active-project))
(< (point) subtree-end))
(cond ((and (my/is-a-task)
(my/is-next-task))
(setq has-next-task t))
((and (my/is-a-project)
(eq (my/get-project-type file (point) nil)
'active))
(setq has-active-project t)))
(org-end-of-subtree t t))
(or has-next-task
has-active-project))))
(defun my/generous-active-project (file point)
(save-excursion
(let (has-task has-next-task has-project has-stuck-project)
(orgc-loop/todo-children custom-condition
(if (and has-next-task has-stuck-project)
(setq custom-condition t)
(cond ((my/is-a-project)
(setq has-project t)
(when (eq (my/get-project-type file (point) t)
'stuck)
(setq has-stuck-project t)))
((my/is-a-task)
(setq has-task t)
(when (or (my/is-next-task)
(equal (org-get-todo-state) "WAIT")) ;; Ew
(setq has-next-task t))))))
(or (and has-next-task
(not has-stuck-project))
(and (not has-task)
has-project
(not has-stuck-project))))))
(defun my/get-project-type (file point &optional ambiguous-to-stuck)
(save-excursion
(when (my/is-a-project)
(let ((subtree-end (save-excursion (org-end-of-subtree t)))
(todo (org-get-todo-state)))
(cond ((equal todo "ETERNAL") 'eternal)
((equal todo "SOMEDAY") 'someday)
((equal todo "HOLD") 'hold)
((equal todo "WAIT") 'wait)
((org-time> (org-entry-get (point) "SCHEDULED") (org-matcher-time "<now>")) 'delayed)
;;((my/is-a-task) nil)
((equal "SEQUENTIAL" (org-get-todo-state))
(if (my/active-sequential-project file point)
'active
'stuck))
(ambiguous-to-stuck
(if (my/generous-active-project file point)
'active
'stuck))
((not ambiguous-to-stuck)
(if (my/greedy-active-project file point)
'active
'stuck)))))))
;; (defmacro measure-time (&rest body)
;; "Measure the time it takes to evaluate BODY."
;; `(let ((time (current-time)))
;; ,@body
;; (message "%.06f" (float-time (time-since time)))))
;; (require 'memoize)
;; (defun reset-memo-for-projects ()
;; (interactive)
;; (ignore-errors
;; (memoize-restore 'my/get-project-type))
;; (memoize 'my/get-project-type))
;; (add-hook 'org-agenda-finalize-hook
;; #'reset-memo-for-projects)
(defun my/show-stuck-projects ()
"Only show subtrees that are stuck projects"
(save-restriction
(widen)
(let ((subtree-end (save-excursion (org-end-of-subtree t))))
;; (setq debug-p (point)
;; debuf-f (buffer-file-name))
(unless (or (and (my/is-a-task)
(my/is-standalone-task)
(not (org-get-scheduled-time (point)))
(not (org-get-deadline-time (point))))
(eq (my/get-project-type buffer-file-name (point) t)
'stuck))
subtree-end))))
;; (defvar my/stuck-projects-flag nil)
;; (defvar my/stuck-projects-file nil)
;; (defun my/show-stuck-projects ()
;; "Only show subtrees that are stuck projects"
;; (setq stuck-here t)
;; (save-restriction
;; (widen)
;; (let ((subtree-end (save-excursion (org-end-of-subtree t))))
;; (if (and my/stuck-projects-flag
;; (string= my/stuck-projects-file
;; (buffer-file-name))
;; (< (point) my/stuck-projects-flag))
;; (if (or (my/is-next-task)
;; (my/is-unactionable-task)
;; (and (not (my/is-a-task))
;; (not (eq (my/get-project-type buffer-file-name (point) t)
;; 'stuck))))
;; subtree-end
;; nil)
;; (setq my/stuck-projects-flag nil
;; my/stuck-projects-file nil)
;; (cond ((and (my/is-a-task)
;; (my/is-standalone-task)
;; (not (org-get-scheduled-time (point)))
;; (not (org-get-deadline-time (point))))
;; nil)
;; ((eq (my/get-project-type buffer-file-name
;; (point) t)
;; 'stuck)
;; (setq my/stuck-projects-flag subtree-end)
;; (setq my/stuck-projects-file (buffer-file-name))
;; nil)
;; (t subtree-end))))))
(defvar my/done-projects-flag nil)
(defun my/show-done-projects-and-tasks ()
"Show top level leaf of these todos: DONE|CANCELLED|COMPLETE"
(save-restriction
(widen)
(let ((subtree-end (save-excursion (org-end-of-subtree t)))
(next-headline (save-excursion (or (outline-next-heading) (point-max)))))
(if my/done-projects-flag
(let ((ov my/done-projects-flag))
(setq my/done-projects-flag nil)
ov)
(if (member (org-get-todo-state) org-done-keywords)
(progn (setq my/done-projects-flag subtree-end)
nil)
next-headline)))))
(defun my/org-agenda-reset-vars ()
(interactive)
(setq my/stuck-projects-flag nil
my/done-projects-flag nil
my/next-task-flag nil))
(add-to-list 'org-agenda-finalize-hook
#'my/org-agenda-reset-vars)
(defun my/show-active-projects ()
"Only show subtrees that are stuck projects"
(save-restriction
(widen)
(let ((subtree-end (save-excursion (org-end-of-subtree t))))
(unless (eq (my/get-project-type buffer-file-name (point) nil)
'active)
subtree-end))))
(defun my/show-hold-projects ()
"Only show subtrees that are stuck projects"
(save-restriction
(widen)
(let ((subtree-end (save-excursion (org-end-of-subtree t))))
(unless (eq (my/get-project-type buffer-file-name (point))
'hold)
subtree-end))))
(defun my/show-delayed-projects ()
(save-restriction
(widen)
(let ((subtree-end (save-excursion (org-end-of-subtree t))))
(unless (eq (my/get-project-type buffer-file-name (point))
'delayed)
subtree-end))))
(defun my/show-next-tasks-and-standalone-tasks ()
(let ((next-headline (save-excursion (or (outline-next-heading) (point-max))))
(current (point))
display)
(save-restriction
(widen)
(save-excursion
(while (and (not (eobp))
(not display))
(if (or (and (my/is-a-task)
(my/is-next-task))
(my/is-standalone-task))
(setq display (point))
(let ((project-type (my/get-project-type buffer-file-name (point) nil)))
(if (and project-type
(not (eq project-type 'active)))
(goto-char (save-excursion (org-end-of-subtree t)))
(outline-next-heading)))))
(cond ((eobp)
(point-max))
((not (= display current))
display))))))
(defun my/show-next-tasks-and-standalone-tasks ()
(let ((next-headline (save-excursion (or (outline-next-heading) (point-max)))))
(unless (and (my/is-a-task)
(or
(my/is-next-task)
(my/is-standalone-task)))
next-headline)))
(defun my/not-scheduled ()
(let ((next-headline (save-excursion (or (outline-next-heading) (point-max)))))
(when (org-get-scheduled-time)
next-headline)))
;; (defun my/agenda-custom-skip ()
;; (let ((next-headline (save-excursion (or (outline-next-heading) (point-max))))
;; (current (point))
;; display)
;; (save-restriction
;; (widen)
;; (save-excursion
;; (when (or (my/get-project-type "" "")
;; (member (org-get-todo-state) '("SOMEDAY" "WAIT" "HABIT" nil)))
;; next-headline)))))
(defun my/agenda-custom-skip ()
(let ((next-headline (save-excursion (or (outline-next-heading) (point-max))))
(current (point))
display)
(save-restriction
(widen)
(save-excursion
(when (or (my/is-a-project)
(member (org-get-todo-state) '("SOMEDAY" "WAIT" "HABIT" nil)))
next-headline)))))
(defvar my/next-task-flag nil)
;; (setq my/next-task-flag nil)
(defun my/has-next-todo ()
(save-excursion
(let ((end-of-subtree (save-excursion (org-end-of-subtree t)))
flag)
(while (and (not flag)
(outline-next-heading)
(< (point) next-headline))
(when (string= (org-get-todo-state) "NEXT")
(setq flag (point))))
flag)))
(defun my/show-leaf-tasks ()
(let ((next-headline (save-excursion (org-end-of-subtree t))))
(unless (or (string= "NEXT" (org-get-todo-state))
(my/has-next-todo))
next-headline)))Views
(setq org-agenda-tags-todo-honor-ignore-options t)
(defun bh/org-auto-exclude-function (tag)
"Automatic task exclusion in the agenda with / RET"
(when (string= tag "online")
(concat "-" tag)))
(org-defkey org-agenda-mode-map
"A"
'org-agenda)
(setq org-agenda-auto-exclude-function 'bh/org-auto-exclude-function)
(setq org-agenda-skip-deadline-prewarning-if-scheduled 'pre-scheduled)
(setq org-agenda-skip-scheduled-if-deadline-is-shown nil)
(setq org-agenda-log-mode-items '(clock closed))
(defun org-agenda-delete-empty-compact-blocks ()
"Function removes empty compact blocks.
If two lines next to each other have the
org-agenda-structure face, then delete the
previous block."
(unless org-agenda-compact-blocks
(user-error "Compact blocks must be on"))
(setq buffer-read-only nil)
(save-excursion
(goto-char (point-min))
(let ((start-pos (point))
(previous t))
(while (and (forward-line)
(not (eobp)))
(cond
((let ((face (get-char-property (point) 'face)))
(or (eq face 'org-agenda-structure)
(eq face 'org-agenda-date-today)))
(if previous
(delete-region start-pos
(point))
(setq start-pos (point)))
(setq previous t))
(t (setq previous nil)))))))
(add-hook 'org-agenda-finalize-hook #'org-agenda-delete-empty-compact-blocks)
(defun org-agenda-add-separater-between-project ()
(setq buffer-read-only nil)
(save-excursion
(goto-char (point-min))
(let ((start-pos (point))
(previous t))
(re-search-forward " +agenda: +[^\\. ]" nil t)
(while (re-search-forward " +agenda: +[^\\. ]" nil t)
(beginning-of-line)
(insert "=============================================\n")
(forward-line)))))
;; I don't think this code is necessary
;; (add-to-list 'org-agenda-entry-types :deadlines*)
(setq org-agenda-hide-tags-regexp "NOT_TASKS\\|PROJECT")
(use-package org-super-agenda)
(use-package htmlize)
(org-super-agenda-mode)
(setq org-super-agenda-header-separator "")
(let* ((stuck-projects-view '(tags-todo "-REFILE/!"
((org-agenda-overriding-header "Stuck Projects")
(org-tags-match-list-sublevels 'indented)
(org-agenda-skip-function 'my/show-stuck-projects)
(org-agenda-sorting-strategy
'(category-keep))))))
(setq org-agenda-custom-commands
`(("p" "Project View"
((tags-todo "-REFILE-HOLD/!"
((org-agenda-overriding-header "Active Projects")
(org-agenda-skip-function 'my/show-active-projects)
(org-tags-match-list-sublevels 'indented)))
,stuck-projects-view
(tags-todo "-REFILE/!"
((org-agenda-overriding-header "Delayed projects")
(org-agenda-skip-function 'my/show-delayed-projects)))
(tags-todo "-PEOPLE/!HOLD"
((org-agenda-overriding-header "Projects on hold")))
(tags-todo "+PEOPLE/!HOLD"
((org-agenda-overriding-header "People on hold")))
(todo "SOMEDAY"
((org-agenda-overriding-header "Someday projects")
(org-agenda-sorting-strategy '(tag-up))))
(todo "ETERNAL"
((org-agenda-overriding-header "Eternal Projects")))))
("g" "General View"
(;; (tags-todo "+PLAN"
;; ((org-agenda-files '("~/MEGA/org/entries/journal.gpg"))
;; (org-agenda-overriding-header "Today's plan")))
(tags-todo "+REFILE|TODO=\"STUFF\""
((org-agenda-overriding-header "Refile tasks")))
,stuck-projects-view
;; (tags-todo "-REFILE-HOLD+TODO=\"WAIT\""
;; (;(org-agenda-skip-function 'my/only-next-projects-and-tasks)
;; (org-agenda-overriding-header "Tasks in other courts")
;; (org-tags-match-list-sublevels t)))
;; (tags-todo "+DEADLINE<\"<tomorrow>\"-SCHEDULED>\"<now>\"/!HABIT"
;; ((org-agenda-overriding-header "Incomplete Habits")))
;; This is an inline replacement
(org-ql-agenda-function "")
(agenda ""
((org-agenda-skip-function 'my/agenda-custom-skip)
(org-agenda-span 'day)
;(org-agenda-show-log t)
(org-agenda-skip-deadline-if-done t)
(org-agenda-skip-scheduled-if-done t)
(org-super-agenda-groups '((:name "Overdue" :and (:deadline past :log nil :not (:tag "Work")))
(:name "Should do" :and (:scheduled past :log nil :not (:tag "Work")))
(:name "Today" :time-grid t
:and (:not (:tag "Work")
:not (:and (:not (:scheduled today)
:not (:deadline today)))))
(:name "Work Related" :tag "WORK")
))))))
("c" "Access Comms" tags-todo "+COMMS/!TODO"
((org-agenda-files '("~/MEGA/org/agenda/agenda.org" "~/MEGA/org/entries/comms.org"))))
("P" "Time to panic"
((tags-todo "+MOTIVATION/!TOP"
((org-agenda-overriding-header "Remember your motivation")
(org-agenda-files '("~/MEGA/org/entries/motivation.org"))))
(tags-todo "+PANIC"
((org-agenda-overriding-header "TIME TO PANIC")
(org-use-tag-inheritance nil)))))
("n" "Next Tasks List" tags-todo "-REFILE-HOLD-WAIT"
((org-agenda-skip-function 'my/show-next-tasks-and-standalone-tasks)
(org-agenda-overriding-header "Next Tasks list")
(org-tags-match-list-sublevels t)
(org-agenda-sorting-strategy '(deadline-up))))
("L" "Leaf Task List" tags-todo "-REFILE-HOLD-WAIT"
((org-agenda-skip-function 'my/show-leaf-tasks)
(org-tags-match-list-sublevels 'indented)
(org-agenda-overriding-header "Next Tasks list")
(org-agenda-finalize-hook '(org-agenda-add-separater-between-project))))
("r" "Review Tasks"
((todo "TODO"
((org-agenda-files '("~/MEGA/org/entries/reviews.gpg"))
(org-agenda-overriding-header "Active")
(org-agenda-skip-function '(org-agenda-skip-entry-if 'notscheduled))))
(todo "TODO"
((org-agenda-files '("~/MEGA/org/entries/reviews.gpg"))
(org-agenda-overriding-header "Inactive")))))
("l" . "Leisure")
("la" "Articles" tags-todo "READ/!TODO")
("lv" "Videos"
((tags-todo "+VIDEO+LEARN/!TODO" ((org-agenda-overriding-header "Longer")))
(tags-todo "+VIDEO-LEARN/!TODO" ((org-agenda-overriding-header "Shorter")))))
("f" "Calfw"
cfw:open-org-calendar-no-projects)
("w" "Next week"
((tags-todo "-REFILE/!"
((org-agenda-overriding-header "Stuck Projects")
(org-tags-match-list-sublevels 'indented)
(org-agenda-skip-function 'my/show-stuck-projects)
(org-agenda-sorting-strategy
'(category-keep))))
(agenda ""
((org-agenda-skip-function 'my/show-next-tasks-and-standalone-tasks)
(org-agenda-start-on-weekday 5)))))
("h" "Projects on hold" todo "HOLD" ((org-tags-match-list-sublevels 'indented)))
("t" "Today" agenda ""
((org-agenda-skip-function 'my/agenda-custom-skip)
(org-agenda-span 'day)
(org-agenda-start-with-log-mode '(closed clock))
(org-agenda-clockreport-mode t)))
("C" . "Categories")
("Cb" "Bus tasks" tags-todo "BUS")
("Cr" "Articles to read" tags-todo "READ")
;; ("D" "Old done tasks" todo "DONE|CANCELLED|COMPLETE")
("d" "Done Tasks" todo "DONE|CANCELLED|COMPLETE|ABANDON"
((org-agenda-overriding-header "Done Tasks")
(org-agenda-skip-function 'my/show-done-projects-and-tasks))))))
(defun cfw:open-org-calendar-no-projects (&args)
"Open an org schedule calendar in the new buffer."
(interactive)
(save-excursion
(let ((buf (get-buffer "*cfw-calendar*")))
(if buf
(switch-to-buffer buf)
(let* ((org-agenda-skip-function 'my/agenda-custom-skip)
(source1 (cfw:org-create-source))
(curr-keymap (if cfw:org-overwrite-default-keybinding cfw:org-custom-map cfw:org-schedule-map))
(cp (cfw:create-calendar-component-buffer
:view 'two-weeks
:contents-sources (list source1)
:custom-map curr-keymap
:sorter 'cfw:org-schedule-sorter)))
(switch-to-buffer (cfw:cp-get-buffer cp))
(set (make-variable-buffer-local 'org-agenda-skip-function)
'my/agenda-custom-skip)
(when (not org-todo-keywords-for-agenda)
(message "Warn : open org-agenda buffer first.")))
))))
;; (defun cfw:open-org-calendar-no-projects (&args)
;; (interactive)
;; (let ((buf (get-buffer "*cfw-calendar*")))
;; (if buf
;; (switch-to-buffer buf)
;; (progn
;; (let ((org-agenda-skip-function 'my/agenda-custom-skip))
;; (cfw:open-org-calendar))
;; (set (make-variable-buffer-local 'org-agenda-skip-function)
;; 'my/agenda-custom-skip)))))
;; (remove-hook 'org-agenda-mode-hook
;; 'org-store-agenda-views)Face
(custom-set-faces
'(org-agenda-date-today ((t (:inherit org-agenda-date :foreground "cyan" :slant italic :weight bold :height 1.1))))
'(org-agenda-structure ((t (:foreground "LightSkyBlue" :box (:line-width 1 :color "grey75" :style released-button))))))My own agenda renderer
(add-to-list 'load-path
"~/.emacs.d/custom/org-ql")
(require 'org-ql)
(require 'org-ql-agenda)
(require 'org-habit)
;; (org-ql-agenda '("~/MEGA/org/agenda/agenda.org") (or (and (todo "HABIT") (deadline <= today)) (todo "WAIT")) :super-groups ((:name "Tasks in other courts" :todo "WAIT") (:name "Incomplete Habits" :todo "HABIT")))
(defun org-ql-agenda-function (ignore)
(org-agenda-prepare "org-ql")
(insert
(save-window-excursion
(org-ql-agenda org-agenda-files
(or (and (todo "HABIT")
(deadline <= today))
(todo "WAIT")
(and (todo "TODO")
(tags "REWARD")
(priority = "A")))
:super-groups ((:name "Waiting tasks" :todo "WAIT")
(:name "Incomplete Habits" :todo "HABIT")
(:name "Rewards" :tag "REWARD")))
(switch-to-buffer "*Org Agenda NG*")
(let ((res (buffer-string)))
(kill-buffer)
res))
"\n\n"
)
(org-agenda-finalize))
(defvar my/org-agenda-types nil)
(defun test (throwaway)
(if (null my/org-agenda-types)
(error "Need to specify my/org-agenda-types")
(org-agenda-prepare "This is a test")
(org-agenda--insert-overriding-header
;; This string will be inserted if there is no overriding header
"This is a test")
(insert throwaway "\n")
(org-agenda-finalize))
;; (setq buffer-read-only t)
)
(add-to-list 'org-agenda-custom-commands
'("E" "Experimental stuff"
((tags-todo "-REFILE/!"
((org-agenda-overriding-header "Stuck Projects")
(org-tags-match-list-sublevels 'indented)
(org-agenda-skip-function 'my/show-stuck-projects)
(org-agenda-sorting-strategy
'(category-keep))))
(test "Hello"
((org-agenda-overriding-header "Hello World")
(my/org-agenda-types t)))
(org-ql-agenda-function ""))))
;; Helper function
;; (setq org-agenda-custom-commands (remove-if (lambda (a) (string= (car a) "E")) org-agenda-custom-commands))Checkbox
(defun my/org-checkbox-todo ()
"Switch header TODO state to DONE when all checkboxes are ticked, to TODO otherwise"
(let ((todo-state (org-get-todo-state)) beg end)
(unless (not todo-state)
(save-excursion
(org-back-to-heading t)
(setq beg (point))
(end-of-line)
(setq end (point))
(goto-char beg)
(if (re-search-forward "\\[\\([0-9]*%\\)\\]\\|\\[\\([0-9]*\\)/\\([0-9]*\\)\\]"
end t)
(if (match-end 1)
(if (equal (match-string 1) "100%")
(unless (string-equal todo-state "DONE")
(org-todo 'done))
(unless (string-equal todo-state "TODO")
(org-todo 'todo)))
(if (and (> (match-end 2) (match-beginning 2))
(equal (match-string 2) (match-string 3)))
(unless (string-equal todo-state "DONE")
(org-todo 'done))
(unless (string-equal todo-state "TODO")
(org-todo 'todo)))))))))
(add-hook 'org-checkbox-statistics-hook 'my/org-checkbox-todo)Plugins
fstree
(add-to-list 'load-path
"~/.emacs.d/custom/org-fstree")
(require 'org-fstree)org-bullets
(use-package org-bullets)
(when (not (eq system-type 'windows-nt))
(add-hook 'org-mode-hook (lambda () (org-bullets-mode 1))))calfw-org
(use-package calfw)
(use-package calfw-ical)
(use-package calfw-gcal)
(use-package calfw-org)
(global-set-key (kbd "C-c A") 'cfw:open-org-calendar)
(setq cfw:org-overwrite-default-keybinding t)sync with google calendar
(require 'url-http)
(use-package org-caldav)
(use-package oauth2)
(setq epa-pinentry-mode 'loopback)
(setq plstore-cache-passphrase-for-symmetric-encryption t)
(save-excursion
(let ((filename "~/.emacs.d/google-calendar-secret.el"))
(when (file-exists-p filename)
(set-buffer (find-file-noselect filename))
(let ((var (eval (read (buffer-string)))))
(setq org-caldav-oauth2-client-id (car var)
org-caldav-oauth2-client-secret (cadr var)))
(kill-buffer))))
;; (setq org-caldav-url 'google
;; org-caldav-calendar-id "jqeua8pamjrclakq3bg8mpnlis@group.calendar.google.com"
;; org-caldav-inbox "~/MEGA/org/agenda/test.org"
;; org-caldav-files '("~/MEGA/org/agenda/agenda.org")
;; org-icalendar-include-todo nil
;; org-icalendar-include-sexps t
;; org-icalendar-categories '(all-tags category)
;; org-icalendar-use-deadline '(event-if-todo event-if-not-todo todo-due)
;; org-icalendar-use-scheduled '(event-if-todo event-if-not-todo todo-start)
;; org-icalendar-with-timestamps nil
;; org-caldav-delete-org-entries 'never)
(setq org-caldav-url "https://99.57.234.31/remote.php/dav/calendars/bchu"
org-caldav-calendar-id "orgmode"
org-caldav-inbox "~/MEGA/org/agenda/test.org"
org-caldav-files '("~/MEGA/org/agenda/agenda.org" "~/MEGA/org/agenda/classes_caldav_workaround.org"))
(setq org-icalendar-alarm-time 30
org-icalendar-include-todo nil
org-icalendar-include-sexps t
org-icalendar-categories '(all-tags category)
org-icalendar-use-deadline '(event-if-todo event-if-not-todo todo-due)
org-icalendar-use-scheduled '(todo-start event-if-todo)
org-icalendar-with-timestamps nil
org-caldav-delete-org-entries 'never)
(setq org-caldav-skip-conditions '(nottodo ("TODO" "NEXT"))
org-caldav-exclude-tags '("ARCHIVE" "ONLYEMACS"))
(defun always-use-loopback (fun context args)
(setf (epg-context-pinentry-mode context) epa-pinentry-mode)
(funcall fun context args))
(advice-add 'epg--start :around #'always-use-loopback)Reveal.js
(use-package ox-reveal)
(setq org-reveal-root "file:///home/benson/reveal.js")org-protocol
(require 'org-protocol)org-timeline
(use-package org-timeline)
(remove-hook 'org-agenda-finalize-hook 'org-timeline-insert-timeline)Code-blocks
(require 'ob-core)
(require 'ob-clojure)
(require 'ob-plantuml)
(use-package plantuml-mode)
(setq org-babel-clojure-backend 'cider)
(org-babel-do-load-languages
'org-babel-load-languages
'((clojure . t)
(plantuml . t)))
(defun my-org-confirm-babel-evaluate (lang body)
(not (member lang '("plantuml"))))
(setq org-confirm-babel-evaluate 'my-org-confirm-babel-evaluate)
(setq org-plantuml-jar-path "/usr/share/java/plantuml/plantuml.jar")View org files
(defun make-org-file (filename)
"Make an org buffer in folder for all new incoming org files"
(interactive "MName: ")
(switch-to-buffer (find-file-noselect (concat "~/MEGA/org/random/" filename ".org"))))
(defun make-encrypted-org-file (filename)
(interactive "MName: ")
(switch-to-buffer (find-file-noselect (concat "~/MEGA/org/random/" filename ".gpg")))
(insert "# -*- mode:org; epa-file-encrypt-to: (\"bensonchu457@gmail.com\") -*-\n\n")
(org-mode))
(defun view-org-files ()
"Convenient way for openning up org folder in dired"
(interactive)
(dired "~/MEGA/org/"))Remove faulty template from org-reveal
(setq org-structure-template-alist (remove-if (lambda (a) (string= (car a) "n")) org-structure-template-alist))Elfeed
Setup feeds
;; Load elfeed-org
(use-package elfeed)
(use-package elfeed-org)
(setq rmh-elfeed-org-files (list "~/.emacs.d/elfeed.org"))
(elfeed-org)
(setq-default elfeed-search-filter "@6-months-ago +unread -youtube")
(define-key elfeed-search-mode-map "U" 'elfeed-search-fetch-visible)
(define-key elfeed-search-mode-map "Y" (lambda ()
(interactive)
(elfeed-search-set-filter "+youtube +unread")))
(define-key elfeed-search-mode-map "A" (lambda ()
(interactive)
(elfeed-search-set-filter "@6-months-ago +unread -youtube")))
(define-key elfeed-search-mode-map "h" (lambda ()
(interactive)
(elfeed-search-set-filter nil)))youtube-dl
(defun elfeed-show-youtube-dl ()
"Download the current entry with youtube-dl."
(interactive)
(pop-to-buffer (youtube-dl (elfeed-entry-link elfeed-show-entry))))
(cl-defun elfeed-search-youtube-dl (&key slow)
"Download the current entry with youtube-dl."
(interactive)
(let ((entries (elfeed-search-selected)))
(dolist (entry entries)
(if (null (youtube-dl (elfeed-entry-link entry)
:title (elfeed-entry-title entry)
:slow slow))
(message "Entry is not a YouTube link!")
(message "Downloading %s" (elfeed-entry-title entry)))
(elfeed-untag entry 'unread)
(elfeed-search-update-entry entry)
(unless (use-region-p) (forward-line)))))
(define-key elfeed-search-mode-map "d" 'elfeed-search-youtube-dl)
(setq youtube-dl-directory "~/big_files/Videos/youtube-dl")
(require 'dired-aux)
(defvar dired-filelist-cmd
'(("vlc" "-L")))
(defun dired-start-process (cmd &optional file-list)
(interactive
(let ((files (dired-get-marked-files
t current-prefix-arg)))
(list
(dired-read-shell-command "& on %s: "
current-prefix-arg files)
files)))
(let (list-switch)
(start-process
cmd nil shell-file-name
shell-command-switch
(format
"nohup 1>/dev/null 2>/dev/null %s \"%s\""
(if (and (> (length file-list) 1)
(setq list-switch
(cadr (assoc cmd dired-filelist-cmd))))
(format "%s %s" cmd list-switch)
cmd)
(mapconcat #'expand-file-name file-list "\" \"")))))
(define-key dired-mode-map "r" 'dired-start-process)
(defun watch-youtube ()
(interactive)
(dired "~/big_files/Videos/youtube-dl")
(local-set-key (kbd "RET") 'dired-start-process))
(defun dired-async-save-excursion (orig-fun &rest args)
(save-window-excursion
(apply orig-fun args)))
(advice-add 'dired-do-async-shell-command :around #'dired-async-save-excursion)Youtube show thumbnail
(use-package dash)
(defun elfeed-entries-from-atom (url xml)
"Turn parsed Atom content into a list of elfeed-entry structs."
(let* ((feed-id url)
(protocol (url-type (url-generic-parse-url url)))
(namespace (elfeed-url-to-namespace url))
(feed (elfeed-db-get-feed feed-id))
(title (elfeed-cleanup (xml-query* (feed title *) xml)))
(author (elfeed-cleanup (xml-query* (feed author name *) xml)))
(xml-base (or (xml-query* (feed :base) xml) url))
(autotags (elfeed-feed-autotags url)))
(setf (elfeed-feed-url feed) url
(elfeed-feed-title feed) title
(elfeed-feed-author feed) author)
(cl-loop for entry in (xml-query-all* (feed entry) xml) collect
(let* ((title (or (xml-query* (title *) entry) ""))
(xml-base (elfeed-update-location
xml-base (xml-query* (:base) (list entry))))
(anylink (xml-query* (link :href) entry))
(altlink (xml-query* (link [rel "alternate"] :href) entry))
(link (elfeed--fixup-protocol
protocol
(elfeed-update-location xml-base
(or altlink anylink))))
(date (or (xml-query* (published *) entry)
(xml-query* (updated *) entry)
(xml-query* (date *) entry)
(xml-query* (modified *) entry) ; Atom 0.3
(xml-query* (issued *) entry))) ; Atom 0.3
(author-name (or (xml-query* (author name *) entry)
;; Dublin Core
(xml-query* (creator *) entry)))
(author-email (xml-query* (author email *) entry))
(author (cond ((and author-name author-email)
(format "%s <%s>" author-name author-email))
(author-name)))
(categories (xml-query-all* (category :term) entry))
(content (elfeed--atom-content entry))
(id (or (xml-query* (id *) entry) link
(elfeed-generate-id content)))
(type (or (xml-query* (content :type) entry)
(xml-query* (summary :type) entry)
""))
(tags (elfeed-normalize-tags autotags elfeed-initial-tags))
(content-type (if (string-match-p "html" type) 'html nil))
(etags (xml-query-all* (link [rel "enclosure"]) entry))
(thumb (xml-query* (group thumbnail :url) entry))
(enclosures
(cl-loop for enclosure in etags
for wrap = (list enclosure)
for href = (xml-query* (:href) wrap)
for type = (xml-query* (:type) wrap)
for length = (xml-query* (:length) wrap)
collect (list href type length)))
(db-entry (elfeed-entry--create
:title (elfeed-cleanup title)
:feed-id feed-id
:id (cons namespace (elfeed-cleanup id))
:link (elfeed-cleanup link)
:tags tags
:date (or (elfeed-float-time date) (float-time))
:content content
:enclosures enclosures
:content-type content-type
:meta `(,@(when author
(list :author author))
,@(when categories
(list :categories categories))
,@(when thumb
(list :thumbnail (elfeed-get-thumbnail thumb)))))))
(setq debug/entry db-entry)
(dolist (hook elfeed-new-entry-parse-hook)
(funcall hook :atom entry db-entry))
db-entry))))
(defun elfeed-insert-sliced-thumbnail (orig-fun entry)
(let ((thumbnail (elfeed-meta entry :thumbnail)))
(if (null thumbnail)
(funcall orig-fun entry)
(insert-sliced-image (create-image thumbnail 'imagemagick nil :height 150) nil nil 4)
(delete-backward-char 1)
(previous-line)
(previous-line)
(end-of-line)
(let* ((date (elfeed-search-format-date (elfeed-entry-date entry)))
(title (or (elfeed-meta entry :title) (elfeed-entry-title entry) ""))
(title-faces (elfeed-search--faces (elfeed-entry-tags entry)))
(feed (elfeed-entry-feed entry))
(feed-title
(when feed
(or (elfeed-meta feed :title) (elfeed-feed-title feed))))
(tags (mapcar #'symbol-name (elfeed-entry-tags entry)))
(tags-str (mapconcat
(lambda (s) (propertize s 'face 'elfeed-search-tag-face))
tags ","))
(title-width (- (window-width) 10 elfeed-search-trailing-width))
(title-column (elfeed-format-column
title (elfeed-clamp
elfeed-search-title-min-width
title-width
elfeed-search-title-max-width)
:left)))
(insert " " (propertize title-column 'face title-faces 'kbd-help title) " ")
(next-line)
(insert " " (propertize date 'face 'elfeed-search-date-face) " ")
(when feed-title
(insert (propertize feed-title 'face 'elfeed-search-feed-face) " "))
(when tags
(insert "(" tags-str ")")))
(next-line)
(end-of-line))))
(defun elfeed-insert-sliced-thumbnail (orig-fun entry)
(let ((thumbnail (elfeed-meta entry :thumbnail)))
(if (null thumbnail)
(funcall orig-fun entry)
(insert-sliced-image (create-image thumbnail 'imagemagick nil :height 150) nil nil 4)
(delete-backward-char 1)
(previous-line)
(previous-line)
(end-of-line)
(let* ((date (elfeed-search-format-date (elfeed-entry-date entry)))
(title (or (elfeed-meta entry :title) (elfeed-entry-title entry) ""))
(title-faces (elfeed-search--faces (elfeed-entry-tags entry)))
(feed (elfeed-entry-feed entry))
(feed-title
(when feed
(or (elfeed-meta feed :title) (elfeed-feed-title feed))))
(tags (mapcar #'symbol-name (elfeed-entry-tags entry)))
(tags-str (mapconcat
(lambda (s) (propertize s 'face 'elfeed-search-tag-face))
tags ","))
(title-width (- (window-width) 10 elfeed-search-trailing-width))
(title-column (elfeed-format-column
title (elfeed-clamp
elfeed-search-title-min-width
title-width
elfeed-search-title-max-width)
:left)))
(insert " " (propertize title-column 'face title-faces 'kbd-help title) " ")
(next-line)
(insert " " (propertize date 'face 'elfeed-search-date-face) " ")
(when feed-title
(insert (propertize feed-title 'face 'elfeed-search-feed-face) " "))
(when tags
(insert "(" tags-str ")")))
(next-line)
(end-of-line))))
(defun elfeed-insert-thumbnail (entry)
(let ((thumbnail (elfeed-meta entry :thumbnail)))
(if (null thumbnail)
(insert "")
(insert " ")
(insert-image (create-image thumbnail 'imagemagick nil :height 150))
(insert " "))))
(advice-add 'elfeed-search-print-entry--default :before #'elfeed-insert-thumbnail)
(defvar elfeed-link-org-capture nil)
(defun elfeed-show-insert-thumbnail ()
(let ((inhibit-read-only t)
(thumbnail (elfeed-meta elfeed-show-entry :thumbnail)))
(if (null thumbnail)
(insert "")
(insert-image (create-image thumbnail 'imagemagick nil :height 150))
(insert "\n"))
(goto-char (point-min))
(setq elfeed-link-org-capture
(format "[[%s][%s]] :%s:%s:"
(elfeed-entry-link elfeed-show-entry)
(elfeed-entry-title elfeed-show-entry)
(elfeed-meta elfeed-show-entry :author)
(string-join (mapcar #'symbol-name (elfeed-entry-tags elfeed-show-entry)) ":")))))
(advice-add 'elfeed-show-refresh--mail-style :after #'elfeed-show-insert-thumbnail)
(defun elfeed-get-thumbnail (url)
(let* ((file (--> url
(split-string it "/")
(nth 4 it)
(concat it ".jpg")))
(img-url (replace-regexp-in-string "/hqdefault.jpg$" "/mqdefault.jpg" url))
(img-folder (--> "images"
(expand-file-name it elfeed-db-directory)
(file-name-as-directory it)))
(filepath (concat img-folder file)))
(unless (file-directory-p img-folder)
(make-directory img-folder))
(unless (file-exists-p filepath)
(start-process-shell-command "wget" nil (format "wget %s -O %s" img-url filepath)))
filepath))Programming
Autocompletion
(use-package company)
(setq company-idle-delay 0.2)
(add-hook 'emacs-lisp-mode-hook
'company-mode)irony
(use-package irony)
(add-hook 'c++-mode-hook 'irony-mode)
(add-hook 'c-mode-hook 'irony-mode)
(add-hook 'objc-mode-hook 'irony-mode)
(add-hook 'irony-mode-hook 'irony-cdb-autosetup-compile-options)
(global-company-mode)Yasnippets
(use-package yasnippet)
;(define-key yas-minor-mode-map (kbd "<backtab>") 'yas-expand)
(yas-global-mode 1)Projectile and dumb-jump
(use-package projectile)
(use-package treemacs-projectile)
(use-package helm-projectile)
(use-package counsel-projectile)
(defun projectile-stop-project-running ()
(interactive)
(if-let (buf (get-buffer "*compilation*"))
(let ((kill-buffer-query-functions nil))
(kill-buffer buf)
(delete-window))
(message "Project is not running")))
(projectile-global-mode)
; Deprecated?
(counsel-projectile-mode)
(cons 'projectile-root-bottom-up
(remove 'projectile-root-bottom-up
projectile-project-root-files-functions))
(setq projectile-indexing-method 'native)
(setq projectile-completion-system 'ivy)
(define-key projectile-mode-map (kbd "C-c C-p") 'projectile-command-map)
(define-key projectile-command-map (kbd "C-a") 'projectile-add-known-project)
(define-key projectile-command-map (kbd "C-r") 'projectile-remove-known-project)
(define-key projectile-command-map (kbd "C-f") 'counsel-projectile-find-file)
(define-key projectile-command-map (kbd "C-b") 'projectile-ibuffer)
(define-key projectile-command-map (kbd "C-c") 'projectile-compile-project)
(define-key projectile-command-map (kbd "C-d") 'projectile-stop-project-running)
(defun this-is-a-project (dir)
(interactive "f")
(setq projectile-project-root dir)
(set (make-local-variable 'dumb-jump-project) dir))
(define-key projectile-command-map (kbd "C-t") 'this-is-a-project)
(use-package dumb-jump)
(dumb-jump-mode)hs-minor-mode
(defun set-hiding-indentation (column)
(interactive "P")
(set-selective-display
(or column
(unless selective-display
(1+ (current-column))))))
(defun set-hiding-indentation-to-point (column)
(interactive "P")
(if hs-minor-mode
(if (condition-case nil
(hs-toggle-hiding)
(error t))
(hs-show-all))
(set-hiding-indentation column)))
(global-set-key (kbd "C-=") 'hs-toggle-hiding)
(global-set-key (kbd "C--") 'set-hiding-indentation-to-point)
(add-hook 'c-mode-common-hook 'hs-minor-mode)
(add-hook 'emacs-lisp-mode-hook 'hs-minor-mode)
(add-hook 'java-mode-hook 'hs-minor-mode)
(add-hook 'lisp-mode-hook 'hs-minor-mode)
(add-hook 'perl-mode-hook 'hs-minor-mode)
(add-hook 'sh-mode-hook 'hs-minor-mode)Ensime (scala)
(use-package ensime)Magit
(use-package magit)
(global-set-key (kbd "C-x g") 'magit-status)
(global-set-key (kbd "C-x M-g") 'magit-dispatch-popup)SPACES
(setq TeX-auto-untabify 't)
(setq indent-tabs-mode nil)
(add-hook 'java-mode-hook
(lambda ()
(setq indent-tabs-mode nil)))
(add-hook 'clojure-mode
(lambda ()
(setq indent-tabs-mode nil)))Geiser
(use-package geiser)
(setq geiser-default-implementation 'chez)Paredit
(use-package paredit)Cider
(use-package clj-refactor)
(use-package cider)
(use-package clojure-mode)YAML
(use-package yaml-mode)show parens
(show-paren-mode t)lsp-mode
(use-package flycheck)
(global-flycheck-mode)
(use-package lsp-mode)
(use-package lsp-ui)
(define-key lsp-mode-map (kbd "M-.") 'lsp-ui-peek-find-definitions)
(define-key lsp-mode-map (kbd "C-c C-r") 'lsp-ui-peek-find-references)
(define-key lsp-mode-map (kbd "C-c C-f") 'lsp-ui-peek-jump-forward)
(define-key lsp-mode-map (kbd "C-c C-b") 'lsp-ui-peek-jump-backward)
(setq lsp-ui-flycheck-enable t)
(setq lsp-ui-flycheck-live-reporting t)
(use-package dap-mode
:config
(dap-mode t)
(dap-ui-mode t)
(define-key dap-mode-map (kbd "C-c n") 'dap-next))
;; (defhydra dap-hydra (:color pink :hint nil :foreign-keys run)
;; ;; "
;; ;; ^Stepping^ ^Switch^ ^Breakpoints^ ^Eval
;; ;; ^^^^^^^^-----------------------------------------------------------------------------------------
;; ;; _n_: Next _ss_: Session _bt_: Toggle _ee_: Eval
;; ;; _i_: Step in _st_: Thread _bd_: Delete _er_: Eval region
;; ;; _o_: Step out _sf_: Stack frame _ba_: Add _es_: Eval thing at point
;; ;; _c_: Continue _sl_: List locals _bc_: Set condition _eii_: Inspect
;; ;; _r_: Restart frame _sb_: List breakpoints _bh_: Set hit count _eir_: Inspect region
;; ;; _Q_: Disconnect _sS_: List sessions _bl_: Set log message _eis_: Inspect thing at point
;; ;; "
;; ("n" dap-next)
;; ("i" dap-step-in)
;; ("o" dap-step-out)
;; ("c" dap-continue)
;; ("r" dap-restart-frame)
;; ("ss" dap-switch-session)
;; ("st" dap-switch-thread)
;; ("sf" dap-switch-stack-frame)
;; ("sl" dap-ui-locals)
;; ("sb" dap-ui-breakpoints)
;; ("sS" dap-ui-sessions)
;; ("bt" dap-breakpoint-toggle)
;; ("ba" dap-breakpoint-add)
;; ("bd" dap-breakpoint-delete)
;; ("bc" dap-breakpoint-condition)
;; ("bh" dap-breakpoint-hit-condition)
;; ("bl" dap-breakpoint-log-message)
;; ("ee" dap-eval)
;; ("er" dap-eval-region)
;; ("es" dap-eval-thing-at-point)
;; ("eii" dap-ui-inspect)
;; ("eir" dap-ui-inspect-region)
;; ("eis" dap-ui-inspect-thing-at-point)
;; ("q" nil "quit" :color blue)
;; ("Q" dap-disconnect :color red))
;(use-package lsp-python)Java
(use-package lsp-java)
(require 'dap-java)ccls
(use-package ccls)
(require 'ccls)Rainbow delimiters
(use-package rainbow-delimiters)
(rainbow-delimiters-mode)
(add-hook 'prog-mode-hook #'rainbow-delimiters-mode)
(add-hook 'org-mode-hook #'rainbow-delimiters-mode)
(let ((rainbow-purple "#9E1CB2")
(rainbow-blue "#1194f6")
(rainbow-green "#47B04B")
(rainbow-yellow "#FFED18")
(rainbow-orange "#E7B500")
(rainbow-red "#C90067")
(rainbow-7 "#00AA5D")
(rainbow-8 "#FE7380"))
(custom-set-faces
`(rainbow-delimiters-depth-1-face ((t (:foreground ,rainbow-purple))))
`(rainbow-delimiters-depth-2-face ((t (:foreground ,rainbow-green))))
`(rainbow-delimiters-depth-3-face ((t (:foreground ,rainbow-blue))))
`(rainbow-delimiters-depth-4-face ((t (:foreground ,rainbow-red))))
`(rainbow-delimiters-depth-5-face ((t (:foreground ,rainbow-yellow))))
`(rainbow-delimiters-depth-6-face ((t (:foreground ,rainbow-blue))))
`(rainbow-delimiters-depth-7-face ((t (:foreground ,rainbow-red))))
`(rainbow-delimiters-depth-8-face ((t (:foreground ,rainbow-8))))
`(rainbow-delimiters-depth-9-face ((t (:foreground ,rainbow-purple))))
`(rainbow-delimiters-depth-10-face ((t (:foreground ,rainbow-blue))))
`(rainbow-delimiters-depth-11-face ((t (:foreground ,rainbow-green))))
`(rainbow-delimiters-depth-12-face ((t (:foreground ,rainbow-yellow))))))elisp
pp-macros
(define-key emacs-lisp-mode-map (kbd "C-c e") 'pp-macroexpand-last-sexp)auto-highlight-symbol
(use-package auto-highlight-symbol)
(add-hook 'emacs-lisp-mode-hook
'auto-highlight-symbol-mode)C#
(use-package csharp-mode)
(use-package dotnet)
(use-package omnisharp
:bind (:map omnisharp-mode-map
([remap xref-find-definitions] . omnisharp-go-to-definition)
([remap xref-find-references] . omnisharp-find-usages)))
(add-hook 'csharp-mode-hook 'omnisharp-mode)
(add-hook 'csharp-mode-hook 'company-mode)
(add-hook 'csharp-mode-hook 'flycheck-mode)
(add-hook 'csharp-mode-hook 'auto-highlight-symbol-mode)
(add-hook 'csharp-mode-hook 'dotnet-mode)React js
(use-package rjsx-mode)Golang
(use-package go-mode)
(add-hook 'go-mode-hook
(lambda ()
(add-hook 'before-save-hook 'gofmt-before-save)
(setq tab-width 4)
(setq indent-tabs-mode 1)))Elpy
(use-package elpy)
(elpy-enable)EIN
(use-package ein)
(add-to-list 'exec-path
"/home/benson/anaconda3/bin/")Web-mode
(use-package web-mode)
(add-to-list 'auto-mode-alist '("\\.phtml\\'" . web-mode))
(add-to-list 'auto-mode-alist '("\\.tpl\\.php\\'" . web-mode))
(add-to-list 'auto-mode-alist '("\\.[agj]sp\\'" . web-mode))
(add-to-list 'auto-mode-alist '("\\.as[cp]x\\'" . web-mode))
(add-to-list 'auto-mode-alist '("\\.erb\\'" . web-mode))
(add-to-list 'auto-mode-alist '("\\.mustache\\'" . web-mode))
(add-to-list 'auto-mode-alist '("\\.djhtml\\'" . web-mode))
(add-to-list 'auto-mode-alist '("\\.cshtml\\'" . web-mode))
(add-to-list 'auto-mode-alist '("\\.html?\\'" . web-mode))
(setq web-mode-auto-close-style 2)Processing
(use-package processing-mode)
(setq processing-location "/usr/bin/processing-java")Treemacs
(use-package treemacs)
(load "treemacs-mode.el")Hy-mode
(use-package hy-mode)glsl-mode
(autoload 'glsl-mode "glsl-mode" nil t)
(add-to-list 'auto-mode-alist '("\\.glsl\\'" . glsl-mode))
(add-to-list 'auto-mode-alist '("\\.vert\\'" . glsl-mode))
(add-to-list 'auto-mode-alist '("\\.frag\\'" . glsl-mode))
(add-to-list 'auto-mode-alist '("\\.geom\\'" . glsl-mode))indent-guide
(use-package indent-guide)
;(indent-guide-global-mode)rust cargo
(use-package cargo)Freekeys
(use-package free-keys)
(bind-key "C-h C-k" 'free-keys)Eww
(global-set-key (kbd "C-c g")
(lambda ()
(interactive)
(w3m-goto-url "https://google.com")))New
Youtube-dl
(add-to-list 'load-path "~/.emacs.d/custom/youtube-dl-emacs/")
(require 'youtube-dl)Spaces
(setq default-tab-width 4)
(setq-default indent-tabs-mode nil)pdf-tools use isearch
(use-package pdf-tools)
(pdf-tools-install)
(define-key pdf-view-mode-map (kbd "C-s") 'isearch-forward)
(define-key pdf-view-mode-map (kbd "d") (lambda () (interactive) (pdf-view-next-line-or-next-page 8)))
(define-key pdf-view-mode-map (kbd "u") (lambda () (interactive) (pdf-view-previous-line-or-previous-page 8)))Dired+
(add-to-list 'load-path
"~/.emacs.d/custom/dired-plus")
(require 'dired+)
(setq dired-listing-switches "-al --group-directories-first --sort=extension")
(setq diredp-hide-details-initially-flag nil)
(setq diredp-hide-details-propagate-flag nil)
(require 'dired-x)
(setq-default dired-omit-files-p t)
(setq dired-omit-files (concat dired-omit-files "\\|^\\..+$"))
(use-package dired-narrow
:ensure t
:bind (:map dired-mode-map
("/" . dired-narrow)))Time to game!
(defvar my/games '("desmume" "mednaffe" "dolphin-emu" "m64py" "citra-qt" "steam " "th12"))
(defun time-to-game ()
(interactive)
(let ((selection (completing-read "What would you like to play? "
my/games)))
(launch-program selection)))Winner Mode
(require 'winner)
(winner-mode)Skewer Mode (web development)
(use-package js2-mode)
(add-to-list 'auto-mode-alist '("\\.js\\'" . js2-mode))
(use-package skewer-mode)
(add-hook 'js2-mode-hook 'skewer-mode)
(add-hook 'css-mode-hook 'skewer-css-mode)
(add-hook 'html-mode-hook 'skewer-html-mode)Gnus
(add-hook 'gnus-group-mode-hook 'gnus-topic-mode)
(setq user-mail-address "bensonchu457@gmail.com"
user-full-name "Benson Chu")
(setq gnus-select-method
'(nnimap "gmail"
(nnimap-address "imap.gmail.com")
(nnimap-server-port "imaps")
(nnimap-stream ssl)
(nnimap-authinfo-file "~/.authinfo.gpg")))
(setq gnus-secondary-select-methods
'((nnimap "work"
(nnimap-address "outlook.office365.com")
(nnimap-server-port "imaps")
(nnimap-stream ssl)
(nnimap-authinfo-file "~/.authinfo.gpg"))))
(setq smtpmail-smtp-server "smtp.gmail.com"
smtpmail-smtp-service 587)
(setq gnus-mark-article-hook nil)
(gnus-add-configuration
'(article
(horizontal 1.0
(vertical 25
(group 1.0))
(vertical 1.0
(summary 0.25 point)
(article 1.0)))))
(gnus-add-configuration
'(summary
(horizontal 1.0
(vertical 25
(group 1.0))
(vertical 1.0
(summary 1.0 point)))))Ledger mode
(use-package ledger-mode
:mode "\\.dat\\'")
(setq ledger-reports
'(("expmonth" "%(binary) -f %(ledger-file) -M reg Expenses")
("owedmom" "%(binary) -f %(ledger-file) reg Liabilities")
("progress" "%(binary) -f %(ledger-file) reg Assets Equity Liabilities")
("cleared" "%(binary) -f %(ledger-file) cleared")
("food" "%(binary) -f %(ledger-file) --add-budget reg Assets")
(#("bal" 0 1
(idx 1))
"%(binary) -f %(ledger-file) bal")
(#("reg" 0 1
(idx 4))
"%(binary) -f %(ledger-file) reg")
(#("payee" 0 1
(idx 3))
"%(binary) -f %(ledger-file) reg @%(payee)")
(#("account" 0 1
(idx 0))
"%(binary) -f %(ledger-file) reg %(account)")))
(setq dynamic-reports
'(("budgetcal" "%(binary) -f ~/MEGA/org/entries/food.ledger --daily --add-budget reg Expenses")))
(defun ledger-dynamic-report ()
(interactive)
(let* ((ledger-reports dynamic-reports)
(report-name (ledger-report-read-name)))
(ledger-report report-name nil)))ediff
(setq ediff-window-setup-function 'ediff-setup-windows-plain)Scroll interval
(setq scroll-margin 1
hscroll-margin 2
hscroll-step 1
scroll-conservatively 101
scroll-preserve-screen-position t
mouse-wheel-scroll-amount '(3)
mouse-wheel-progressive-speed nil)AUR PKGBUILD
(use-package pkgbuild-mode)Eyebrowse
(use-package eyebrowse
:init (setq eyebrowse-keymap-prefix (kbd "C-c w"))
:config
(eyebrowse-mode)
(global-set-key (kbd "C->") 'eyebrowse-next-window-config)
(global-set-key (kbd "C-<") 'eyebrowse-prev-window-config))org-jira
(use-package org-jira)
(setq jiralib-url "https://wenningbai.atlassian.net/")Writing mode
(defun org-writing-mode ()
(interactive)
(setq org-bullets-bullet-list (quote (" ")))
(buffer-face-set '(:family "ETBookOT")))re-builder specify read method
(require 're-builder)
(setq reb-re-syntax 'string)new-text-color
(custom-set-faces
'(default ((t (:background "gray8" :foreground "#70FF00")))))dired-du
(use-package dired-du)scrollkeeper
(use-package scrollkeeper)
(global-set-key (kbd "C-v") 'scrollkeeper-down)
(global-set-key (kbd "M-v") 'scrollkeeper-up)set-default-directory
(defun set-default-directory (dir)
(interactive "f")
(setq default-directory dir))hydra
(use-package hydra)org-mru-clock
(use-package org-mru-clock)org-clock-convenience
(defun my/org-clock-move-to-other ()
(interactive)
(forward-char 6)
(while (condition-case nil
(progn
(previous-line)
(org-clock-convenience-goto-ts)
nil)
(error t))))
(defun my/org-clock-move-up ()
(interactive)
(org-clock-convenience-timestamp-up)
(my/org-clock-move-to-other)
(org-clock-convenience-timestamp-up))
(use-package org-clock-convenience
:ensure t
:bind (:map org-agenda-mode-map
("<S-up>" . org-clock-convenience-timestamp-up)
("<S-down>" . org-clock-convenience-timestamp-down)
("<S-M-up>" . org-clock-convenience-timestamp-up)
("<S-M-down>" . org-clock-convenience-timestamp-down)
("ö" . org-clock-convenience-fill-gap)
("é" . org-clock-convenience-fill-gap-both)))org-clock-consisitency
(setq org-agenda-clock-consistency-checks
'(:max-duration "10:00"
:min-duration 0
:max-gap 0
:gap-ok-around ("4:00")
;; :default-face ((:background "DarkRed")
;; (:foreground "white"))
;; :overlap-face nil
;; :gap-face ((:background "DarkRed")
;; (:foreground "white"))
;; :no-end-time-face nil
;; :long-face nil
;; :short-face nil
))org-clock stfuf
(org-clock-persistence-insinuate)
(setq org-clock-in-resume t)
(setq org-clock-mode-line-total 'today)
(setq org-clock-persist t)
(org-clock-persistence-insinuate)
(setq org-clock-continuously t)org-edna
(use-package org-edna)
(org-edna-load)org agenda goto headline AND narrow
(defun my/org-agenda-narrow ()
(interactive)
(org-agenda-switch-to)
(org-narrow-to-subtree)
(org-cycle)
(org-cycle))
(define-key org-agenda-mode-map (kbd "S-<return>") 'my/org-agenda-narrow)World time include Taiwan
;; (("America/Los_Angeles" "Seattle")
;; ("America/New_York" "New York")
;; ("Europe/London" "London")
;; ("Europe/Paris" "Paris")
;; ("Asia/Calcutta" "Bangalore")
;; ("Asia/Tokyo" "Tokyo"))
(setq display-time-world-list
'(("Asia/Taipei" "Taiwan")))org-brain
(use-package org-brain :ensure t
:init
(global-set-key (kbd "M-'") 'org-brain-visualize)
(setq org-brain-path "~/MEGA/org/brain/")
;; For Evil users
(with-eval-after-load 'evil
(evil-set-initial-state 'org-brain-visualize-mode 'emacs))
:config
(setq org-id-track-globally t)
(setq org-id-locations-file "~/.emacs.d/.org-id-locations")
(push '("b" "Brain" plain (function org-brain-goto-end)
"* %i%?" :empty-lines 1)
org-capture-templates)
(setq org-brain-visualize-default-choices 'all)
(setq org-brain-title-max-length 0)
(define-key org-brain-visualize-mode-map (kbd "^") 'org-brain-visualize-back))Open links with firefox
(setq browse-url-browser-function 'browse-url-firefox)org-export
(require 'ox-latex)
(require 'ox-beamer)desktop-environment
(use-package desktop-environment)
(desktop-environment-mode)arch-linux
(use-package arch-packer)skeletor project templates
(use-package skeletor)Compile java run test
(defun compile-java ()
(interactive)
(let ((fname (file-name-nondirectory buffer-file-name)))
(shell-command (format "javac %s" fname))
(message (shell-command-to-string (format "java %s" (substring fname 0 (- (length fname) 5)))))))
(global-set-key (kbd "C-<f1>") 'compile-java)ansi-term colors
(setq ansi-color-names-vector
["black" "red3" "green3" "yellow3" "DodgerBlue2" "magenta3" "cyan3" "gray90"])sml faces
;; (custom-set-faces
;; '(sml/line-number ((t (:inherit sml/global :background "#5f00af" :foreground "light gray" :weight normal))))
;; '(sml/time ((t (:inherit sml/global :background "#5f00af" :foreground "light gray" :weight normal))))
;; '(sml/charging ((t (:inherit sml/global :background "#5f00af" :foreground "#00FF00" :weight normal))))
;; '(sml/discharging ((t (:inherit sml/global :background "#5f00af" :foreground "deep pink" :weight normal)))))expand-region
(use-package expand-region)
(global-set-key (kbd "C-'") 'er/expand-region)wtf
(use-package wtf)buffer-time-tracking
(use-package switch-buffer-functions)
;;(load "switch-buffer-functions-autoloads.el")
(defun my/insert-into-buffers-csv (str str2 symb str3)
(let* ((buffer (find-file-noselect "~/MEGA/org/agenda/buffer_times.csv"))
(inhibit-message t))
(with-current-buffer buffer
(goto-char (point-max))
(insert (format-time-string "%Y-%m-%d %H:%M:%S" (current-time)))
(insert "," str "," (if str2 str2 "") "," str3 "," (if symb (symbol-name symb) ""))
(insert "\n")
(save-buffer))))
(defun my/record-buffer-switch (prev cur)
(let* (obuffer-name buffer-name buffer-fname buffer-mode buffer-def-dir)
(with-current-buffer cur
(setq buffer-name (buffer-name)
buffer-fname (buffer-file-name)
buffer-mode major-mode
buffer-def-dir default-directory))
(when (buffer-live-p prev)
(with-current-buffer prev
(setq obuffer-name (buffer-name))))
(when (and (not (string= buffer-name " *Minibuf-1*"))
;; (or (not obuffer-name) (not (string= obuffer-name " *Minibuf-1*")))
)
(my/insert-into-buffers-csv buffer-name buffer-fname buffer-mode buffer-def-dir))))
;; (add-hook 'switch-buffer-functions
;; 'my/record-buffer-switch)
(defun leaving-computer ()
(interactive)
(my/insert-into-buffers-csv "Inactive" "" nil "")
(message "Computer is now inactive!"))auto-save files in same directory
(setq backup-directory-alist `(("." . "~/.emacs.d/backups/")))
(setq backup-by-copying t)csv-mode
(use-package csv-mode)kdeconnect
(use-package kdeconnect)
(setq kdeconnect-devices "ddcc003536dcf16d")
(setq kdeconnect-active-device "ddcc003536dcf16d")Purpose-mode
(use-package window-purpose)
(add-to-list 'purpose-user-mode-purposes '(exwm-mode . research))
(add-to-list 'purpose-user-mode-purposes '(js2-mode . dev))
(purpose-compile-user-configuration)
(purpose-mode)Broken
mu4e
General config
(require 'mu4e)
(add-to-list 'mu4e-view-actions
'("ViewInBrowser" . mu4e-action-view-in-browser) t)
(global-set-key (kbd "<f8>") 'mu4e)Multiple accounts
(setq mu4e-sent-folder "/Gmail/[Gmail].Sent Mail"
mu4e-drafts-folder "/Gmail/[Gmail].Drafts"
mu4e-refile-folder "/Gmail/[Gmail].Archive"
user-mail-address "bensonchu457@gmail.com"
smtpmail-default-smtp-server "smtp.gmail.com"
smtpmail-smtp-server "smtp.gmail.com")
(defvar my-mu4e-account-alist
'(("Gmail"
(mu4e-sent-folder "/work/Sent Mail")
(mu4e-drafts-folder "/Gmail/[Gmail].Drafts")
(mu4e-refile-folder "/Gmail/[Gmail].Archive")
(user-mail-address "bensonchu457@gmail.com")
(smtpmail-default-smtp-server "smtp.gmail.com")
(smtpmail-smtp-user "bensonchu457")
(smtpmail-smtp-server "smtp.gmail.com"))
("work"
(mu4e-sent-folder "/work/Sent")
(mu4e-drafts-folder "/work/Drafts")
(mu4e-refile-folder "/work/Archive")
(user-mail-address "bchu3@uh.edu")
(smtpmail-default-smtp-server "smtp.account2.example.com")
(smtpmail-smtp-user "bchu3")
(smtpmail-smtp-server "smtp.account2.example.com"))))
;(defun my-mu4e-set-account ()
; "Set the account for composing a message."
; (let* ((account
; (if mu4e-compose-parent-message
; (let ((maildir (mu4e-message-field mu4e-compose-parent-message :maildir)))
; (string-match "/\\(.*?\\)/" maildir)
; (match-string 1 maildir))
; (completing-read (format "Compose with account: (%s) "
; (mapconcat #'(lambda (var) (car var))
; my-mu4e-account-alist "/"))
; (mapcar #'(lambda (var) (car var)) my-mu4e-account-alist)
; nil t nil nil (caar my-mu4e-account-alist))))
; (account-vars (cdr (assoc account my-mu4e-account-alist))))
; (if account-vars
; (mapc #'(lambda (var)
; (set (car var) (cadr var)))
; account-vars)
; (error "No email account found"))))
; (add-hook 'mu4e~headers-jump-to-maildir 'my-mu4e-set-account)Wunderlist
(use-package org-wunderlist)
(save-excursion
(let ((filename "~/.emacs.d/wunderlist.el"))
(if (not (file-exists-p filename))
(message "Wunderlist secret file missing")
(set-buffer (find-file-noselect filename))
(let ((var (eval (read (buffer-string)))))
(setq org-wunderlist-client-id (car var)
org-wunderlist-token (cadr var)))
(kill-buffer))))
(setq org-wunderlist-file "~/MEGA/org/agenda/Wunderlist.org"
org-wunderlist-dir "~/MEGA/org/agenda/org-wunderlist/")Disabled
nnreddit
(use-package nnredit "~/.emacs.d/nnreddit/nnreddit.el")
(add-to-list 'gnus-secondary-select-methods '(nnreddit ""))xwidget
(define-key xwidget-webkit-mode-map [mouse-4] 'xwidget-webkit-scroll-down)
(define-key xwidget-webkit-mode-map [mouse-5] 'xwidget-webkit-scroll-up)Slime mode
(use-package slime)
(add-hook 'lisp-mode-hook (lambda () (slime-mode t)))
(add-hook 'inferior-lisp-mode-hook (lambda () (inferior-slime-mode t)))
(setq inferior-lisp-program "/usr/bin/sbcl")
(slime-setup '(slime-fancy slime-asdf))i3wm interaction
(use-package i3wm)
(defun insert-mode ()
(interactive)
(i3wm-command "mode insert"))
(global-set-key (kbd "M-\"") 'insert-mode)Cyberpunk Theme
(load-theme 'cyberpunk t)
(use-package moe-theme)
(moe-dark)
(powerline-moe-theme)Wanderlust
(autoload 'wl "wl" "Wanderlust" t)linum
(use-package linum)
(linum-relative-global-mode)
(setq linum-relative-current-symbol "")
;(setq linum-format
; (lambda (line)
; (propertize (format (let ((w (length (number-to-string (count-lines (point-min) (point-max))))))
; (concat "%" (number-to-string w) "d "))
; line)
; 'face
; 'linum)))
;(setq linum-relative-format "%3s\u2502 ")CTD Minor Mode
Keybinding
(use-package multi-term)
(define-minor-mode ctd-mode
"This is the mode for the CoderTillDeath"
:init-value t
:lighter " ctd"
:keymap (let ((map (make-sparse-keymap)))
(define-key map (kbd "M-e") 'launch-program)
(define-key map (kbd "C-x p") 'launch-program)
(define-key map (kbd "M-`") 'multi-term)
(define-key map (kbd "M-1") 'windresize)
map))
(ctd-mode 1)Precedence
(add-hook 'after-load-functions 'ctd-mode-priority)
(defun ctd-mode-priority (_file)
"Try to ensure that my keybindings retain priority over other minor modes.
Called via the `after-load-functions' special hook."
(unless (eq (caar minor-mode-map-alist) 'ctd-mode)
(let ((mykeys (assq 'ctd-mode minor-mode-map-alist)))
(assq-delete-all 'ctd-mode minor-mode-map-alist)
(add-to-list 'minor-mode-map-alist mykeys))))Screw delete
(global-set-key (kbd "C-d") 'delete-backward-char)
(global-set-key (kbd "M-d") 'backward-kill-word)Custom Journal Attempt 1
(defvar yearly-theme "Insight")
(defun insert-time-stamp ()
(insert "** "
(format-time-string "%A, %x")))
(defun current-date-exists? ()
(save-excursion
(let ((match (re-search-forward (format-time-string "\\(* %A, %x\\)")
nil t)))
(match-beginning 1))))
(defun add-date ()
(search-forward "* Journal")
(beginning-of-line)
(org-narrow-to-subtree)
(let ((point (current-date-exists?)))
(if point
(goto-char point)
(goto-char (point-max))
(insert-time-stamp)))
(widen))
(defun add-weekly-journal-entry ()
(add-date))
(defun org-capture-function ()
(unless (file-exists-p "~/MEGA/org/entries/review/current.org")
(create-weekly-review-file))
(set-buffer (org-capture-target-buffer "~/MEGA/org/entries/review/current.org"))
(let ((m (point-marker)))
(set-buffer (marker-buffer m))
(org-capture-put-target-region-and-position)
(widen)
(goto-char m)
(set-marker m nil)
(add-weekly-journal-entry)))
(defun create-weekly-review-file ()
(save-excursion
(let ((entry-path "~/MEGA/org/entries/review/current.org"))
(find-file-other-window entry-path)
(insert (format "#+TITLE: Year of %s, week %s\n\n"
yearly-theme
(format-time-string "%V"))
"* Log\n"
"* Journal\n")
(save-buffer)
(kill-buffer))))
(defun weekly-review ()
(interactive)
(let ((entry-path "~/MEGA/org/entries/review/current.org"))
(find-file entry-path)
(goto-char (point-max))
(insert "\n* Review\n")))
(defun wr/done ()
(interactive)
(save-buffer)
(kill-buffer)
(unless (file-directory-p (format-time-string "~/MEGA/org/entries/review/%Y"))
(make-directory (format-time-string "~/MEGA/org/entries/review/%Y")))
(rename-file "~/MEGA/org/entries/review/current.org"
(format-time-string "~/MEGA/org/entries/review/%Y/Year of Insight, Week %V.org")
t)
(create-weekly-review-file))Custom Journal Attempt 2
(defvar yearly-theme "Surpass")
(defun completed-tags-search (start-date end-date)
(let ((org-agenda-overriding-header "* Log")
(tag-search (concat (format "TODO=\"DONE\"&CLOSED>=\"[%s]\"&CLOSED<=\"[%s]\""
start-date
end-date))))
(org-tags-view nil tag-search)))
(defun get-tasks-from (start-date end-date)
(let (string)
(save-window-excursion
(completed-tags-search start-date end-date)
(setq string (mapconcat 'identity
(mapcar (lambda (a)
(concat "**" a))
(butlast (cdr (split-string (buffer-string) "\n")) 1))
"\n"))
(kill-buffer))
string))
(defun get-journal-entries-from (start-date end-date)
(let ((string "")
match)
(save-window-excursion
(switch-to-buffer (find-file "~/MEGA/org/entries/journal.gpg"))
(goto-char (point-min))
(while (setq match (re-search-forward "^\\*\\*\\* \\(2[0-9]\\{3\\}-[0-9]\\{2\\}-[0-9]\\{2\\}\\) \\w+$" nil t))
(let ((date (match-string 1)))
(when (and (org-time< start-date date)
(or (not end-date) (org-time< date end-date)))
(org-narrow-to-subtree)
(org-shiftmetaleft)
(setq string (concat string "\n" (buffer-string)))
(org-shiftmetaright)
(widen))))
(not-modified)
(kill-buffer))
string))
(defun generate-view-between (start-date end-date)
(let ((start-date (or start-date
(org-read-date)))
(end-date (or end-date
(org-read-date)))
(org-agenda-skip-archived-trees nil))
(get-buffer-create "review.org")
(switch-to-buffer "review.org")
(org-mode)
(insert (format "#+Title of %s, Week %s\n\n"
yearly-theme
(format-time-string "%V")))
(insert "* Log\n")
(insert (get-tasks-from start-date end-date))
(insert "\n* Journal"))
(insert (get-journal-entries-from start-date end-date))
(when (> (funcall outline-level) 1) (outline-up-heading 2))
(org-cycle)
(org-cycle)
(goto-char (point-max)))
(defun generate-view-from ()
(interactive)
(let ((date (org-read-date)))
(generate-view-between date
(org-read-date nil nil ""))))
(defun generate-weekly-view ()
(interactive)
(let ((start-date (org-read-date nil nil "-1w"))
(end-date (org-read-date nil nil "")))
(generate-view-between start-date end-date)))
(defun weekly-review ()
(interactive)
(generate-weekly-view)
(goto-char (point-max))
(insert "\n* Review\n"))
(defun offday-review ()
(interactive)
(generate-view-from)
(goto-char (point-max))
(insert "\n* Review\n"))
(defun wr/done ()
(interactive)
(write-file (concat "~/MEGA/org/entries/review/"
(format-time-string "%Y/")
(format "Year of %s, Week "
yearly-theme)
(format-time-string "%V")
".org"))
(kill-buffer))
(defun view-reports ()
(interactive)
(dired (format-time-string "~/MEGA/org/entries/review/%Y/")))Norang Projects code
(require 'org-habit)
(defun bh/find-project-task ()
"Move point to the parent (project) task if any"
(save-restriction
(widen)
(let ((parent-task (save-excursion (org-back-to-heading 'invisible-ok) (point))))
(while (org-up-heading-safe)
(when (member (nth 2 (org-heading-components)) org-todo-keywords-1)
(setq parent-task (point))))
(goto-char parent-task)
parent-task)))
(defun bh/is-project-p ()
"Any task with a todo keyword subtask"
(or (equal (org-get-todo-state) "PROJECT")
(save-restriction
(widen)
(let ((subtree-end (save-excursion (org-end-of-subtree t)))
(is-a-task (member (nth 2 (org-heading-components)) org-todo-keywords-1))
has-subtask has-task)
(save-excursion
(forward-line 1)
(while (and (not has-subtask)
(< (point) subtree-end)
(re-search-forward "^\*+ " subtree-end t))
(when (member (org-get-todo-state) org-todo-keywords-1)
(setq has-subtask t)
(when (not (equal (org-get-todo-state) "DONE"))
(setq has-task t)))))
(and is-a-task (or has-task
(and has-subtask
(equal "TODO"
(org-get-todo-state)))))))))
(defun bh/is-project-subtree-p ()
"Any task with a todo keyword that is in a project subtree.
Callers of this function already widen the buffer view."
(let ((task (save-excursion (org-back-to-heading 'invisible-ok)
(point))))
(save-excursion
(bh/find-project-task)
(if (equal (point) task)
nil
t))))
(defun bh/is-task-p ()
"Any task with a todo keyword and no subtask"
(save-restriction
(widen)
(let ((has-subtask)
(subtree-end (save-excursion (org-end-of-subtree t)))
(is-a-task (member (nth 2 (org-heading-components)) org-todo-keywords-1)))
(save-excursion
(forward-line 1)
(while (and (not has-subtask)
(< (point) subtree-end)
(re-search-forward "^\*+ " subtree-end t))
(when (member (org-get-todo-state) org-todo-keywords-1)
(setq has-subtask t))))
(and is-a-task (or (equal (org-get-todo-state)
"ONE")
(not has-subtask))))))
(defun my/is-standalone-task-p ()
(and (my/is-a-task)
(not (bh/is-subproject-p))))
(defun bh/is-next-task-p ()
(and (bh/is-task-p)
(or (equal (org-get-todo-state)
"NEXT")
(and (equal (org-get-todo-state)
"TODO")
(or (org-get-scheduled-time (point))
(org-get-deadline-time (point)))))))
(defun bh/is-subproject-p ()
"Any task which is a subtask of another project"
(let ((is-subproject)
(is-a-task (member (nth 2 (org-heading-components)) org-todo-keywords-1)))
(save-excursion
(while (and (not is-subproject) (org-up-heading-safe))
(when (member (nth 2 (org-heading-components)) org-todo-keywords-1)
(setq is-subproject t))))
(and is-a-task is-subproject)))
(defvar memoized-stuck-function nil
"DO NOT SETQ. Use in agenda views")
(defun my/make-memoized-stuck-projects ()
(memoize (lambda (point)
(message "Hello, world!")
(my/is-stuck-project-p))))
(defun my/is-stuck-project-p ()
(let ((subtree-end (save-excursion (org-end-of-subtree t)))
has-next
has-stuck-project)
(save-restriction
(save-excursion
(while (and (or (not has-next)
(not has-stuck-project))
(outline-next-heading)
(< (point) subtree-end))
(cond ((and (bh/is-project-p)
(my/is-stuck-project-p))
(setq has-stuck-project t))
((or (bh/is-next-task-p)
(equal (org-get-todo-state) "WAIT"))
(setq has-next t))))))
(and (bh/is-project-p)
(or (not has-next)
has-stuck-project))))
(defun my/is-inactive-project-p ()
(let (has-next
has-stuck-project)
(and (bh/is-project-p)
(or (not (member (org-get-todo-state)
'("TASK" "PROJECT" "TODO")))
(org-time> (org-entry-get (point) "SCHEDULED") "<now>")))))
(defun my/is-delayed-project-p ()
(and (bh/is-project-p)
(org-entry-get (point) "SCHEDULED")
(org-time> (org-entry-get (point) "SCHEDULED") "<now>")))
(defun my/is-ignored-project ()
;; Need to finish
)
(defun my/is-active-project-p ()
;; Need to finish
)
(defun bh/list-sublevels-for-projects-indented ()
"Set org-tags-match-list-sublevels so when restricted to a subtree we list all subtasks.
This is normally used by skipping functions where this variable is already local to the agenda."
(if (marker-buffer org-agenda-restrict-begin)
(setq org-tags-match-list-sublevels 'indented)
(setq org-tags-match-list-sublevels nil))
nil)
(defun bh/list-sublevels-for-projects ()
"Set org-tags-match-list-sublevels so when restricted to a subtree we list all subtasks.
This is normally used by skipping functions where this variable is already local to the agenda."
(if (marker-buffer org-agenda-restrict-begin)
(setq org-tags-match-list-sublevels t)
(setq org-tags-match-list-sublevels nil))
nil)
(defvar bh/hide-scheduled-and-waiting-next-tasks t)
(defun bh/toggle-next-task-display ()
(interactive)
(setq bh/hide-scheduled-and-waiting-next-tasks (not bh/hide-scheduled-and-waiting-next-tasks))
(when (equal major-mode 'org-agenda-mode)
(org-agenda-redo))
(message "%s WAITING and SCHEDULED NEXT Tasks" (if bh/hide-scheduled-and-waiting-next-tasks "Hide" "Show")))
(defun bh/skip-stuck-projects ()
"Skip trees that are not stuck projects"
(save-restriction
(widen)
(let ((next-headline (save-excursion (or (outline-next-heading) (point-max)))))
(when (my/is-stuck-project-p)
next-headline))))
(defun my/show-stuck-projects ()
"Only show subtrees that are stuck projects"
;; (bh/list-sublevels-for-projects-indented)
(save-restriction
(widen)
(let ((next-headline (save-excursion (or (outline-next-heading) (point-max))))
(subtree-end (save-excursion (org-end-of-subtree t))))
(cond ((my/is-inactive-project-p)
subtree-end)
((not (my/is-stuck-project-p))
next-headline)))))
(defun my/show-inactive-projects ()
"Only show subtrees that are stuck projects"
;; (bh/list-sublevels-for-projects-indented)
(save-restriction
(widen)
(let ((next-headline (save-excursion (or (outline-next-heading) (point-max))))
(subtree-end (save-excursion (org-end-of-subtree t))))
(unless (my/is-inactive-project-p)
subtree-end))))
(defun my/show-delayed-projects ()
"Only show subtrees that are stuck projects"
;; (bh/list-sublevels-for-projects-indented)
(save-restriction
(widen)
(let ((next-headline (save-excursion (or (outline-next-heading) (point-max))))
(subtree-end (save-excursion (org-end-of-subtree t))))
(unless (my/is-delayed-project-p)
subtree-end))))
(defun bh/show-active-projects ()
"Skip trees that are not projects"
;; (bh/list-sublevels-for-projects-indented)
(let ((next-headline (save-excursion (or (outline-next-heading) (point-max)))))
(unless (and (bh/is-project-p)
(not (my/is-stuck-project-p)))
next-headline)))
(defun bh/skip-non-tasks ()
"Show non-project tasks.
Skip project and sub-project tasks, habits, and project related tasks."
(save-restriction
(widen)
(let ((next-headline (save-excursion (or (outline-next-heading) (point-max)))))
(cond
((bh/is-task-p)
nil)
(t
next-headline)))))
(defun bh/skip-project-trees-and-habits ()
"Skip trees that are projects"
(save-restriction
(widen)
(let ((subtree-end (save-excursion (org-end-of-subtree t))))
(cond
((bh/is-project-p)
subtree-end)
((org-is-habit-p)
subtree-end)
(t
nil)))))
(defun bh/skip-projects-and-habits-and-single-tasks ()
"Skip trees that are projects, tasks that are habits, single non-project tasks"
(save-restriction
(widen)
(let ((next-headline (save-excursion (or (outline-next-heading) (point-max)))))
(cond
((org-is-habit-p)
next-headline)
((and bh/hide-scheduled-and-waiting-next-tasks
(member "WAITING" (org-get-tags-at)))
next-headline)
((bh/is-project-p)
next-headline)
((and (bh/is-task-p) (not (bh/is-project-subtree-p)))
next-headline)
(t
nil)))))
(defun my/only-next-projects-and-tasks ()
(save-restriction
(widen)
(let ((next-headline (save-excursion (or (outline-next-heading) (point-max)))))
(cond
((org-is-habit-p)
next-headline)
((and bh/hide-scheduled-and-waiting-next-tasks
(member "WAITING" (org-get-tags-at)))
next-headline)
((bh/is-project-p)
next-headline)
(t (unless (or (bh/is-next-task-p)
(my/is-standalone-task-p))
next-headline))))))
(defun bh/skip-project-tasks-maybe ()
"Show tasks related to the current restriction.
When restricted to a project, skip project and sub project tasks, habits, NEXT tasks, and loose tasks.
When not restricted, skip project and sub-project tasks, habits, and project related tasks."
(save-restriction
(widen)
(let* ((subtree-end (save-excursion (org-end-of-subtree t)))
(next-headline (save-excursion (or (outline-next-heading) (point-max))))
(limit-to-project (marker-buffer org-agenda-restrict-begin)))
(cond
((bh/is-project-p)
next-headline)
((org-is-habit-p)
subtree-end)
((and (not limit-to-project)
(bh/is-project-subtree-p))
subtree-end)
((and limit-to-project
(bh/is-project-subtree-p)
(member (org-get-todo-state) (list "NEXT")))
subtree-end)
(t
nil)))))
(defun bh/show-non-project-tasks ()
"Show non-project tasks.
Skip project and sub-project tasks, habits, and project related tasks."
(save-restriction
(widen)
(let* ((subtree-end (save-excursion (org-end-of-subtree t))))
(cond
((bh/is-project-p)
subtree-end)
((org-is-habit-p)
subtree-end)
((bh/is-project-subtree-p)
subtree-end)
(t
nil)))))
(defun bh/skip-non-project-tasks ()
"Show project tasks.
Skip project and sub-project tasks, habits, and loose non-project tasks."
(save-restriction
(widen)
(let* ((subtree-end (save-excursion (org-end-of-subtree t)))
(next-headline (save-excursion (or (outline-next-heading) (point-max)))))
(cond
((bh/is-project-p)
next-headline)
((org-is-habit-p)
subtree-end)
((and (bh/is-project-subtree-p)
(member (org-get-todo-state) (list "NEXT")))
subtree-end)
((not (bh/is-project-subtree-p))
subtree-end)
(t
nil)))))
(defun bh/skip-projects-and-habits ()
"Skip trees that are projects and tasks that are habits"
(save-restriction
(widen)
(let ((subtree-end (save-excursion (org-end-of-subtree t))))
(cond
((bh/is-project-p)
subtree-end)
((org-is-habit-p)
subtree-end)
(t
nil)))))
(defun bh/skip-non-subprojects ()
"Skip trees that are not projects"
(let ((next-headline (save-excursion (outline-next-heading))))
(if (bh/is-subproject-p)
nil
next-headline)))
(defun bh/widen ()
(interactive)
(if (equal major-mode 'org-agenda-mode)
(progn
(org-agenda-remove-restriction-lock)
(when org-agenda-sticky
(org-agenda-redo)))
(widen)))