30 KiB
Applications for Emacs
Applications are greater than packages; they provide a set of functionality to create an interface in Emacs. Emacs comes with applications and others may be installed.
WAIT Dashboard
Dashboard creates a custom dashboard for Emacs that replaces the initial startup screen in default Emacs. It has a lot of customising options.
Unfortunately not that useful, many things are easier to invoke directly such as recent files or project changing.
(use-package dashboard
:straight t
:demand t
:general
(app-leader
"b" #'dashboard-refresh-buffer)
(:states '(normal motion emacs)
:keymaps 'dashboard-mode-map
"q" (proc (interactive) (kill-this-buffer)))
(nmmap
:keymaps 'dashboard-mode-map
"r" #'dashboard-jump-to-recent-files
"p" #'dashboard-jump-to-projects
"}" #'dashboard-next-section
"{" #'dashboard-previous-section)
:init
(setq initial-buffer-choice nil
dashboard-banner-logo-title "Oreomacs"
dashboard-center-content t
dashboard-set-init-info t
dashboard-startup-banner (no-littering-expand-etc-file-name "dashboard/logo.png")
dashboard-set-footer t
dashboard-set-navigator t
dashboard-items '((projects . 5)
(recents . 5))
dashboard-footer-messages (list
"Collecting parentheses..."
"Linking 'coffee_machine.o'..."
"Uploading ip to hacker named 4chan..."
"Dividing by zero..."
"Solving 3-sat..."
"Obtaining your health record..."
(format "Recompiling Emacs for the %dth time..." (random 1000))
"Escaping the cycle of samsara..."))
:config
(dashboard-setup-startup-hook))EWW
Emacs Web Wowser is the inbuilt text based web browser for Emacs. It can render images and basic CSS styles but doesn't have a JavaScript engine, which makes sense as it's primarily a text interface.
(use-package eww
:defer t
:general
(app-leader
"ww" #'eww
"wb" #'+eww/bookmarks-search
"we" #'+eww/bookmarks-edit)
(nmmap
:keymaps 'eww-mode-map
"w" #'evil-forward-word-begin
"Y" #'shr-probe-and-copy-url)
:straight nil
:config
(with-eval-after-load "evil-collection"
(evil-collection-eww-setup))
(defun bookmark->alist (bookmark)
(cons (plist-get bookmark :title)
(plist-get bookmark :url)))
(defun +eww/bookmarks-edit nil
(interactive)
(find-file (concat eww-bookmarks-directory "eww-bookmarks")))
(defun +eww/bookmarks-search nil
(interactive)
(let ((bookmarks (mapcar #'bookmark->alist eww-bookmarks)))
(eww
(alist-get (completing-read "Bookmark: " (mapcar #'car bookmarks) nil t)
bookmarks
nil
nil
#'string=)))))Calendar
Calendar is a simple inbuilt application that helps with date functionalities. I add functionality to copy dates from the calendar to the kill ring and bind it to "Y".
(use-package calendar
:straight nil
:defer t
:commands (+calendar/copy-date +calendar/toggle-calendar)
:display
("\\*Calendar\\*"
(display-buffer-at-bottom)
(inhibit-duplicate-buffer . t)
(window-height . 0.17))
:general
(nmmap
:keymaps 'calendar-mode-map
"Y" #'+calendar/copy-date)
(app-leader
"d" #'calendar)
:config
(defun +calendar/copy-date ()
"Copy date under cursor into kill ring."
(interactive)
(if (use-region-p)
(call-interactively #'kill-ring-save)
(let ((date (calendar-cursor-to-date)))
(when date
(setq date (encode-time 0 0 0 (nth 1 date) (nth 0 date) (nth 2 date)))
(kill-new (format-time-string "%Y-%m-%d" date)))))))Mail is a funny thing; most people use it just for business or advertising and it's come out of use in terms of personal communication in the west for the most part (largely due to "social" media applications). However, this isn't true for the open source and free software movement who heavily use mail for communication.
Integrating mail into Emacs helps as I can send source code and integrate it into my workflow just a bit better.
Notmuch
(use-package notmuch
:defer t
:commands (notmuch +mail/flag-thread)
:general
(app-leader "m" #'notmuch)
(nmap
:keymaps 'notmuch-search-mode-map
"f" #'+mail/flag-thread)
:init
(defconst +mail/signature "---------------\nAryadev Chavali")
(defconst +mail/local-dir (no-littering-expand-var-file-name "mail/"))
(setq notmuch-show-logo nil
notmuch-search-oldest-first nil
notmuch-hello-sections '(notmuch-hello-insert-saved-searches
notmuch-hello-insert-alltags
notmuch-hello-insert-recent-searches)
notmuch-archive-tags '("-inbox" "-unread" "+archive")
mail-signature +mail/signature
mail-default-directory +mail/local-dir
mail-source-directory +mail/local-dir
message-signature +mail/signature
message-auto-save-directory +mail/local-dir
message-directory +mail/local-dir)
(defun +mail/sync-mail ()
"Sync mail via mbsync."
(interactive)
(start-process-shell-command "" nil "mbsync -a"))
(defun +mail/trash-junk ()
"Delete any mail in junk"
(interactive)
(start-process-shell-command "" nil "notmuch search --output=files --format=text0 tag:deleted tag:spam tag:trash tag:junk | xargs -r0 rm"))
:config
(defun +mail/flag-thread (&optional unflag beg end)
(interactive (cons current-prefix-arg (notmuch-interactive-region)))
(notmuch-search-tag
(notmuch-tag-change-list '("-inbox" "+flagged") unflag) beg end)
(when (eq beg end)
(notmuch-search-next-thread)))
(advice-add #'notmuch-poll-and-refresh-this-buffer :after
#'+mail/trash-junk)
(with-eval-after-load "evil-collection"
(evil-collection-notmuch-setup)))Smtpmail
(use-package smtpmail
:straight nil
:commands mail-send
:init
(setq-default
smtpmail-smtp-server "mail.aryadevchavali.com"
smtpmail-smtp-user "aryadev"
smtpmail-smtp-service 587
smtpmail-stream-type 'starttls
send-mail-function #'smtpmail-send-it
message-send-mail-function #'smtpmail-send-it))Dired
Setup for dired. Make dired-hide-details-mode the default mode when using dired-mode, as it removes the clutter. Setup evil collection for dired (even though dired doesn't really conflict with evil, there are some corners I'd like to adjust).
(use-package dired
:straight nil
:commands (dired find-dired)
:hook
(dired-mode-hook . auto-revert-mode)
(dired-mode-hook . dired-hide-details-mode)
:init
(setq-default dired-listing-switches "-AFBlu --group-directories-first"
dired-omit-files "^\\."
dired-dwim-target t
image-dired-external-viewer "nsxiv")
(with-eval-after-load "evil-collection"
(evil-collection-dired-setup))
:general
(nmmap
:keymaps 'dired-mode-map
"SPC" nil
"SPC ," nil
"T" #'dired-create-empty-file
"H" #'dired-up-directory
"L" #'dired-find-file)
(dir-leader
"f" #'find-dired
"d" #'dired
"D" #'dired-other-window
"i" #'image-dired
"p" `(,(proc (interactive)
(dired "~/Text/PDFs/"))
:which-key "Open PDFs"))
(local-leader
:keymaps 'dired-mode-map
"i" #'dired-maybe-insert-subdir
"I" #'+dired/insert-all-subdirectories
"k" #'dired-prev-subdir
"j" #'dired-next-subdir
"K" #'dired-kill-subdir
"m" #'dired-mark-files-regexp
"u" #'dired-undo)
(nmmap
:keymaps 'image-dired-thumbnail-mode-map
"h" #'image-dired-backward-image
"l" #'image-dired-forward-image
"j" #'image-dired-next-line
"k" #'image-dired-previous-line
"H" #'image-dired-display-previous
"L" #'image-dired-display-next
"RET" #'image-dired-display-this
"m" #'image-dired-mark-thumb-original-file
"q" #'quit-window)
:config
(add-to-list 'dired-guess-shell-alist-user '("\\.pdf\\'" "zathura"))
(defun +dired/insert-all-subdirectories ()
"Insert all subdirectories currently viewable."
(interactive)
(dired-mark-directories nil)
(mapc #'dired-insert-subdir (dired-get-marked-files))
(dired-unmark-all-marks)))fd-dired
Uses fd for finding file results in a directory: find-dired ->
fd-dired.
(use-package fd-dired
:after dired
:straight t
:general
(dir-leader
"g" #'fd-dired))wdired
Similar to wgrep wdired provides
the ability to use Emacs motions and editing on file names. This
makes stuff like mass renaming and other file management tasks way
easier than even using the mark based system.
(use-package wdired
:after dired
:straight t
:general
(nmmap
:keymaps 'dired-mode-map
"W" #'wdired-change-to-wdired-mode)
(nmmap
:keymaps 'wdired-mode-map
"ZZ" #'wdired-finish-edit
"ZQ" #'wdired-abort-changes))WAIT Xwidget
Xwidget is a package which allows for the insertion of arbitrary
xwidgets into Emacs through buffers. It must be compiled into Emacs
so you might need to customise your install. One of its premier uses
is in navigating the web which it provides through the function
xwidget-webkit-browse-url. This renders a fully functional web
browser within Emacs.
Though I am not to keen on using Emacs to browse the web via xwidget (EWW does a good job on its own), I am very interested in its capability to render pages with JavaScript, as it may come of use when doing web development. I can see the results of work very quickly without switching windows all within Emacs.
2023-10-20: Disabled as it didn't seem to work, and honestly wasn't that useful.
Xwidget Core
(use-package xwidget
:straight nil
:general
(app-leader
"u" #'xwidget-webkit-browse-url)
(nmmap
:keymaps 'xwidget-webkit-mode-map
"q" #'quit-window
"h" #'xwidget-webkit-scroll-backward
"j" #'xwidget-webkit-scroll-up
"k" #'xwidget-webkit-scroll-down
"l" #'xwidget-webkit-scroll-forward
"+" #'xwidget-webkit-zoom-in
"-" #'xwidget-webkit-zoom-out
(kbd "C-f") #'xwidget-webkit-scroll-up
(kbd "C-b") #'xwidget-webkit-scroll-down
"H" #'xwidget-webkit-back
"L" #'xwidget-webkit-forward
"gu" #'xwidget-webkit-browse-url
"gr" #'xwidget-webkit-reload
"gg" #'xwidget-webkit-scroll-top
"G" #'xwidget-webkit-scroll-bottom))Xwidget Extensions
Define a function +xwidget/render-file that reads a file name and
presents it in an xwidget. If the current file is an HTML file, ask
if user wants to open current file. Bind it to aU in the leader.
Also define a function +xwidget/search-query that first asks the
user what search engine they want to use (Duck Duck Go and DevDocs
currently) then asks for a query, which it parses then presents in an
xwidget window. Bind to as in the leader.
(use-package xwidget
:straight nil
:commands (+xwidget/render-file +xwidget/search)
:general
(app-leader
"U" #'+xwidget/render-file
"s" #'+xwidget/search)
:config
(setenv "WEBKIT_FORCE_SANDBOX" "0")
(defun +xwidget/render-file (&optional FORCE)
"Find file (or use current file) and render in xwidget."
(interactive)
(cond
((and (not FORCE) (or (string= (replace-regexp-in-string ".*.html"
"html" (buffer-name)) "html")
(eq major-mode 'web-mode)
(eq major-mode 'html-mode))) ; If in html file
(if (y-or-n-p "Open current file?: ") ; Maybe they want to open a separate file
(xwidget-webkit-browse-url (format "file://%s" (buffer-file-name)))
(+xwidget/render-file t))) ; recurse and open file via prompt
(t
(xwidget-webkit-browse-url
(format "file://%s" (read-file-name "Enter file to open: "))))))
(defun +xwidget/search ()
"Run a search query on some search engine and display in
xwidget."
(interactive)
(let* ((engine (completing-read "Engine: " '("duckduckgo.com" "devdocs.io") nil t))
(query-raw (read-string "Enter query: "))
(query
(cond
((string= engine "duckduckgo.com") query-raw)
((string= engine "devdocs.io") (concat "_ " query-raw)))))
(xwidget-webkit-browse-url (concat "https://" engine "/?q=" query)))))Eshell
Why Eshell?
Eshell is an integrated shell environment for Emacs, written in Emacs Lisp. I argue that it is the best shell/command interpreter to use in Emacs.
Eshell is unlike the alternatives in Emacs as it's a shell first, not a terminal emulator. It has the ability to spoof some aspects of a terminal emulator (through the shell parser), but it is NOT a terminal emulator.
The killer benefits of eshell (which would appeal to Emacs users) are a direct result of eshell being written in Emacs lisp:
- incredible integration with Emacs utilities (such as
dired,find-file, any read functions, etc) - very extensible, easy to write new commands which leverage Emacs commands as well as external utilities
-
agnostic of platform: "eshell/cd" will call the underlying change directory function for you, so commands will (usually) mean the same thing regardless of platform
- this means as long as Emacs can run on an operating system, one may run eshell
However, my favourite feature of eshell is the set of evaluators that run on command input. Some of the benefits listed above come as a result of this powerful feature. These evaluators are described below.
Lisp evaluator: works on braced expressions, evaluating them as Lisp
expressions (e.g. (message "Hello, World!\n")). Any returned
objects are printed. This makes eshell a LISP REPL!
External evaluator: works within curly braces, evaluating them via
some external shell process (like sh) (e.g. {echo "Hello,
world!\n"}). This makes eshell a (kinda dumb) terminal emulator!
The alias evaluator is the top level evaluator. It is the main evaluator for each expression given to eshell. When given an expression it tries to evaluate it by testing against these conditions:
- it's an alias defined by the user or in the
eshell/namespace of functions (simplest evaluator) - it's some form of lisp expression (lisp evaluator)
- it's an external command (bash evaluator)
Essentially, you get the best of both Emacs and external shell programs ALL WITHIN Emacs for free.
Eshell functionality
Bind some evil-like movements for easy shell usage, and a toggle function to pull up the eshell quickly.
(use-package eshell
:defer t
:general
(shell-leader
"t" #'eshell)
:init
(add-hook
'eshell-mode-hook
(proc
(interactive)
(general-def
:states '(normal insert)
:keymaps 'eshell-mode-map
"M-j" #'eshell-next-matching-input-from-input
"M-k" #'eshell-previous-matching-input-from-input)
(local-leader
:keymaps 'eshell-mode-map
"c" (proc (interactive) (eshell/clear)
(recenter))
"k" #'eshell-kill-process))))Eshell pretty symbols and display
Pretty symbols and a display record.
(use-package eshell
:defer t
:pretty
(eshell-mode-hook
("lambda" . "λ")
("numberp" . "ℤ")
("t" . "⊨")
("nil" . "Ø"))
:display
("\\*e?shell\\*" ; for general shells as well
(display-buffer-at-bottom)
(window-height . 0.33)))Eshell variables and aliases
Set some sane defaults, a banner and a prompt. The prompt checks for a git repo in the current directory and provides some extra information in that case (in particular, branch name and if there any changes that haven't been committed).
(use-package eshell
:defer t
:config
(defun +eshell/--git-get-remote-status ()
(let* ((branch-status (split-string
(shell-command-to-string "git status | grep 'Your branch is'")))
(status (nth 3 branch-status))
(diff (cl-position "by" branch-status :test #'string=)))
(if (null diff)
(propertize "=" 'font-lock-face '(:foreground "green"))
(let ((n (nth (+ 1 diff) branch-status)))
(concat
(cond
((string= status "ahead")
(propertize "→ " 'font-lock-face '(:foreground "dodger blue")))
((string= status "behind")
(propertize "← " 'font-lock-face '(:foreground "orange red"))))
n)))))
(defun +eshell/--git-get-change-status ()
(let ((changed-files (- (length (split-string (shell-command-to-string "git status -s" ) "\n")) 1)))
(if (= changed-files 0)
(propertize "✓" 'font-lock-face '(:foreground "green"))
(propertize (number-to-string changed-files) 'font-lock-face '(:foreground "red")))))
(defun +eshell/get-git-properties ()
(let ((git-branch (shell-command-to-string "git branch")))
(if (or (string= git-branch "")
(not (string= "*" (substring git-branch 0 1))))
""
(format
"(%s<%s>[%s])"
(nth 2 (split-string git-branch "\n\\|\\*\\| "))
(+eshell/--git-get-change-status)
(+eshell/--git-get-remote-status)))))
(defun +eshell/prompt-function ()
(let ((git (+eshell/get-git-properties)))
(mapconcat
(lambda (item)
(if (listp item)
(propertize (car item)
'read-only t
'font-lock-face (cdr item)
'front-sticky '(font-lock-face read-only)
'rear-nonsticky '(font-lock-face read-only))
item))
(list
'("[")
`(,(abbreviate-file-name (eshell/pwd)) :foreground "LimeGreen")
'("]")
(if (string= git "")
""
(concat "-" git ""))
"\n"
`(,(format-time-string "[%H:%M:%S]") :foreground "purple")
"\n"
'("𝜆> " :foreground "DeepSkyBlue")))))
(defun +eshell/banner-message ()
(concat (shell-command-to-string "~/.local/scripts/cowfortune")
"\n"))
(setq eshell-cmpl-ignore-case t
eshell-cd-on-directory t
eshell-banner-message '(+eshell/banner-message)
eshell-highlight-prompt nil
eshell-prompt-function #'+eshell/prompt-function
eshell-prompt-regexp "^𝜆> "))Eshell change directory quickly
Add eshell/goto, which is actually a command accessible from within
eshell (this is because eshell/* creates an accessible function
within eshell with name *). eshell/goto makes it easier to change
directories by using Emacs' find-file interface (which is much faster
than cd ..; ls -l).
eshell/goto is a better cd for eshell. However it is really just
a plaster over a bigger issue for my workflow; many times I want
eshell to be present in the current directory of the buffer I am
using. So here's also a command for opening eshell with the current
directory.
(use-package eshell
:defer t
:general
(leader
"T" #'+eshell/current-buffer)
:config
(defun eshell/goto (&rest args)
"Use `read-directory-name' to change directories."
(eshell/cd (list (read-directory-name "Directory?: "))))
(defun eshell/project-root (&rest args)
"Change to directory `project-root'"
(if (project-current)
(eshell/cd (list (project-root (project-current))))
(eshell/echo (format "[%s]: No project in current directory"
(propertize "Error" 'font-lock-face '(:foreground "red"))))))
(defun +eshell/current-buffer ()
(interactive)
(let ((dir (if buffer-file-name
(file-name-directory buffer-file-name)
default-directory))
(buf (eshell)))
(if dir
(with-current-buffer buf
(eshell/cd dir)
(eshell-send-input))
(message "Could not switch eshell: buffer is not real file")))))WAIT Elfeed
Elfeed is the perfect RSS feed reader, integrated into Emacs perfectly. I've got a set of feeds that I use for a large variety of stuff, mostly media and entertainment. I've also bound "<leader> ar" to elfeed for loading the system.
(use-package elfeed
:general
(app-leader "r" #'elfeed)
(nmmap
:keymaps 'elfeed-search-mode-map
"gr" #'elfeed-update
"s" #'elfeed-search-live-filter
"<return>" #'elfeed-search-show-entry)
:init
(setq elfeed-db-directory (no-littering-expand-var-file-name "elfeed/"))
(setq +rss/feed-urls
'(("Arch Linux"
"https://www.archlinux.org/feeds/news/"
News Technology)
("The Onion"
"https://www.theonion.com/rss"
Social)
("Protesilaos Stavrou"
"https://www.youtube.com/@protesilaos"
YouTube Technology)
("Tsoding Daily"
"https://www.youtube.com/feeds/videos.xml?channel_id=UCrqM0Ym_NbK1fqeQG2VIohg"
YouTube Technology)
("Tsoding"
"https://www.youtube.com/feeds/videos.xml?channel_id=UCrqM0Ym_NbK1fqeQG2VIohg"
YouTube Technology)
("Nexpo"
"https://www.youtube.com/feeds/videos.xml?channel_id=UCpFFItkfZz1qz5PpHpqzYBw"
YouTube Stories)
("3B1B"
"https://www.youtube.com/feeds/videos.xml?channel_id=UCYO_jab_esuFRV4b17AJtAw"
YouTube)
("Fredrik Knusden"
"https://www.youtube.com/feeds/videos.xml?channel_id=UCbWcXB0PoqOsAvAdfzWMf0w"
YouTube Stories)
("Barely Sociable"
"https://www.youtube.com/feeds/videos.xml?channel_id=UC9PIn6-XuRKZ5HmYeu46AIw"
YouTube Stories)
("Atrocity Guide"
"https://www.youtube.com/feeds/videos.xml?channel_id=UCn8OYopT9e8tng-CGEWzfmw"
YouTube Stories)
("Hacker News"
"https://news.ycombinator.com/rss"
Social News Technology)
("Hacker Factor"
"https://www.hackerfactor.com/blog/index.php?/feeds/index.rss2"
Social)))
:config
(with-eval-after-load "evil-collection"
(evil-collection-elfeed-setup))
(setq elfeed-feeds (cl-map 'list #'(lambda (item)
(append (list (nth 1 item)) (cdr (cdr item))))
+rss/feed-urls))
(advice-add 'elfeed-search-show-entry :after #'+elfeed/dispatch-entry)
(defun +elfeed/dispatch-entry (entry)
"Process each type of entry differently.
e.g., you may want to open HN entries in eww."
(let ((url (elfeed-entry-link entry)))
(pcase url
((pred (string-match-p "https\\:\\/\\/www.youtube.com\\/watch"))
(mpv-play-url url))
(_ (eww url))))))Magit
Magit is the git porcelain for Emacs, which perfectly encapsulates the git cli. In this case I just need to setup the bindings for it. As magit will definitely load after evil (as it must be run by a binding, and evil will load after init), I can use evil-collection freely. Also, define an auto insert for commit messages so that I don't need to write everything myself.
(use-package magit
:defer t
:display
("magit:.*"
(display-buffer-same-window)
(inhibit-duplicate-buffer . t))
("magit-diff:.*"
(display-buffer-below-selected))
("magit-log:.*"
(display-buffer-same-window))
:general
(leader
"g" '(magit-dispatch :which-key "Magit"))
(code-leader
"b" #'magit-blame)
:auto-insert
(("COMMIT_EDITMSG" . "Commit skeleton")
""
"(" (read-string "Enter feature/module: ") ")"
(read-string "Enter simple description: ") "\n\n")
:init
(setq vc-follow-symlinks t
magit-blame-echo-style 'lines
magit-copy-revision-abbreviated t)
:config
(with-eval-after-load "evil"
(evil-set-initial-state 'magit-status-mode 'motion))
(with-eval-after-load "evil-collection"
(evil-collection-magit-setup)))IBuffer
IBuffer is the dired of buffers: providing the ability to mark buffers, mass rename/delete and just observe stuff.
(use-package ibuffer
:general
(buffer-leader
"i" #'ibuffer)
:config
(with-eval-after-load "evil-collection"
(evil-collection-ibuffer-setup)))Proced
Emacs has two systems for process management:
- proced: a general 'top' like interface which allows general management of linux processes
- list-processes: a specific Emacs based system that lists processes spawned by Emacs (similar to a top for Emacs specifically)
Core proced config, just a few bindings and evil collection setup.
(use-package proced
:straight nil
:general
(app-leader
"p" #'proced)
(nmap
:keymaps 'proced-mode-map
"za" #'proced-toggle-auto-update)
:display
("\\*Proced\\*"
(display-buffer-at-bottom)
(window-height . 0.25))
:init
(setq proced-auto-update-interval 0.5)
:config
(with-eval-after-load "evil-collection"
(evil-collection-proced-setup)))Calculator
Surprise, surprise Emacs comes with a calculator.
Greater surprise, this thing is over powered. It can perform the following (and more):
- Matrix calculations
- Generalised calculus operations
- Equation solvers for n-degree multi-variable polynomials
- Embedded mode (check below)!
calc-mode is a calculator system within Emacs that provides a
diverse array of mathematical operations. It uses reverse polish
notation to do calculations (though there is a standard infix
algebraic notation mode).
Embedded mode allows computation with the current buffer as the echo area. This basically means I can compute stuff within a buffer without invoking calc directly: $1 + 2\rightarrow_{\text{calc-embed}} 3$.
(use-package calc
:straight nil
:display
("*Calculator*"
(display-buffer-at-bottom)
(window-height . 0.18))
:general
(app-leader
"c" #'calc-dispatch)
(mode-leader
"c" #'calc-embedded)
:init
(setq calc-algebraic-mode t)
:config
(with-eval-after-load "evil-collection"
(evil-collection-calc-setup)))WAIT Calctex
calc-mode also has a 3rd party package called calctex. It renders
mathematical expressions within calc as if they were rendered in TeX.
You can also copy the expressions in their TeX forms, which is pretty
useful when writing a paper. I've set a very specific lock on this
repository as it's got quite a messy work-tree and this commit seems to
work for me given the various TeX utilities installed via Arch.
(use-package calctex
:after calc
:straight (calctex :type git :host github :repo "johnbcoughlin/calctex")
:hook (calc-mode-hook . calctex-mode))WAIT Ledger
(use-package ledger-mode
:defer t)
(use-package evil-ledger
:after ledger-mode)Zone
Of course Emacs has a cool screensaver software.
(use-package zone-matrix
:straight t
:commands (zone)
:general
(leader
"z" #'zone)
:init
(setq zone-programs
[zone-pgm-drip
zone-pgm-drip-fretfully
zone-pgm-martini-swan-dive
zone-pgm-stress
zone-pgm-random-life]))(Wo)man
Man pages are the user manuals for most software on Linux. Really useful when writing code for Un*x systems, though they can be very verbose.
2023-08-17: `Man-notify-method' is the reason the `:display' record doesn't work here. I think it's to do with how Man pages are rendered or something, but very annoying as it's a break from standards!
(use-package man
:demand t
:straight nil
:init
(setq Man-notify-method 'pushy)
:display
("^\\*Man.*"
(display-buffer-reuse-mode-window display-buffer-same-window))
:general
(file-leader
"m" #'man) ;; kinda like "find man page"
(nmmap
:keymaps 'Man-mode-map
"RET" #'man-follow))WAIT gif-screencast
Little application that uses gifsicle to make essentially videos of
Emacs. Useful for demonstrating features.
(use-package gif-screencast
:straight t
:general
(app-leader
"x" #'gif-screencast-start-or-stop)
:init
(setq gif-screencast-output-directory (expand-file-name "~/Media/emacs/")))Image-mode
Image mode, for viewing images. Supports tons of formats, easy to use and integrates slickly into image-dired. Of course,
(use-package image-mode
:straight nil
:general
(nmmap
:keymaps 'image-mode-map
"+" #'image-increase-size
"-" #'image-decrease-size
"p" #'image-animate
"P" #'image-animate-set-speed
"h" #'image-backward-hscroll
"j" #'image-next-line
"k" #'image-previous-line
"l" #'image-forward-hscroll))WAIT ERC
(use-package erc
:defer t
:init
(setq erc-server "irc.libera.chat"
erc-nick "oreodave"
erc-buffer-display "current"))MPV
Basically a porcelain over mpv via the IPC interface.
(use-package mpv
:defer t
:straight t
:config
(with-eval-after-load "org"
(defun org-mpv-complete-link (&optional arg)
(replace-regexp-in-string
"file:" "mpv:"
(org-link-complete-file arg)
t t))
(org-link-set-parameters "mpv"
:follow #'mpv-play :complete #'org-mpv-complete-link)))