142 lines
5.1 KiB
EmacsLisp
142 lines
5.1 KiB
EmacsLisp
;;; syd-buffers.el -*- lexical-binding: t; -*-
|
|
|
|
(require 'syd-prelude)
|
|
|
|
(syd-define-stub
|
|
syd/kill-all-buffers
|
|
:desc "Kill all buffers. See `doom/kill-all-buffers'."
|
|
:interactive t)
|
|
|
|
(syd-define-stub
|
|
syd/kill-other-buffers
|
|
:desc "Kill other buffers. See `doom/kill-other-buffers'."
|
|
:interactive t)
|
|
|
|
(syd-define-stub
|
|
syd/kill-burried-buffers
|
|
:desc "Kill burried buffers. See `doom/kill-burried-buffers'."
|
|
:interactive t)
|
|
|
|
(syd-define-stub
|
|
syd/save-buffer-as-root
|
|
:desc "Sudo save buffer as root. See `doom/sudo-save-buffer'"
|
|
:interactive t)
|
|
|
|
(defvar syd-fallback-buffer-name "*scratch*"
|
|
"The name of the buffer to fall back to if no other buffers exist (will create
|
|
it if it doesn't exist).")
|
|
|
|
(defun syd-fallback-buffer ()
|
|
"Returns the fallback buffer, creating it if necessary. By default this is the
|
|
scratch buffer. See `syd-fallback-buffer-name' to change this."
|
|
(let (buffer-list-update-hook)
|
|
(get-buffer-create syd-fallback-buffer-name)))
|
|
|
|
(defvar-local syd-real-buffer-p nil
|
|
"If non-nil, this buffer should be considered real no matter what. See
|
|
`syd-real-buffer-p' for more information.")
|
|
|
|
(defun syd-special-buffer-p (buf)
|
|
"Returns non-nil if BUF's name starts and ends with an *."
|
|
(char-equal ?* (aref (buffer-name buf) 0)))
|
|
|
|
(defun syd-non-file-visiting-buffer-p (buf)
|
|
(with-current-buffer buf
|
|
(if buffer-file-name t nil)))
|
|
|
|
(defvar syd-unreal-buffer-functions
|
|
'(minibufferp syd-special-buffer-p syd-non-file-visiting-buffer-p)
|
|
"A list of predicate functions run to determine if a buffer is *not* real,
|
|
unlike `syd-real-buffer-functions'. They are passed one argument: the buffer to
|
|
be tested.
|
|
|
|
Should any of these functions return non-nil, the rest of the functions are
|
|
ignored and the buffer is considered unreal.
|
|
|
|
See `syd-real-buffer-p' for more information.")
|
|
|
|
(defun syd-dired-buffer-p (buf)
|
|
"Returns non-nil if BUF is a dired buffer."
|
|
(provided-mode-derived-p (buffer-local-value 'major-mode buf)
|
|
'dired-mode))
|
|
|
|
(defvar syd-real-buffer-functions
|
|
'(syd-dired-buffer-p)
|
|
"A list of predicate functions run to determine if a buffer is real, unlike
|
|
`syd-unreal-buffer-functions'. They are passed one argument: the buffer to be
|
|
tested.
|
|
|
|
Should any of its function returns non-nil, the rest of the functions are
|
|
ignored and the buffer is considered real.
|
|
|
|
See `syd-real-buffer-p' for more information.")
|
|
|
|
(defun syd-temp-buffer-p (buf)
|
|
"Returns non-nil if BUF is temporary."
|
|
(char-equal ?\s (aref (buffer-name buf) 0)))
|
|
|
|
(defun syd-real-buffer-p (buffer-or-name)
|
|
"Returns t if BUFFER-OR-NAME is a 'real' buffer.
|
|
|
|
A real buffer is a useful buffer; a first class citizen. Real ones should get
|
|
special treatment, because we will be spending most of our time in them. Unreal
|
|
ones should be low-profile and easy to cast aside, so we can focus on real ones.
|
|
|
|
The exact criteria for a real buffer is:
|
|
|
|
1. A non-nil value for the buffer-local value of the `syd-real-buffer-p'
|
|
variable OR
|
|
2. Any function in `syd-real-buffer-functions' returns non-nil OR
|
|
3. None of the functions in `syd-unreal-buffer-functions' must return
|
|
non-nil.
|
|
|
|
If BUFFER-OR-NAME is omitted or nil, the current buffer is tested."
|
|
(or (bufferp buffer-or-name)
|
|
(stringp buffer-or-name)
|
|
(signal 'wrong-type-argument (list '(bufferp stringp) buffer-or-name)))
|
|
(when-let (buf (get-buffer buffer-or-name))
|
|
(when-let (basebuf (buffer-base-buffer buf))
|
|
(setq buf basebuf))
|
|
(and (buffer-live-p buf)
|
|
(not (syd-temp-buffer-p buf))
|
|
(or (buffer-local-value 'syd-real-buffer-p buf)
|
|
(run-hook-with-args-until-success 'syd-real-buffer-functions buf)
|
|
(not (run-hook-with-args-until-success 'syd-unreal-buffer-functions buf))))))
|
|
|
|
(defun syd-unreal-buffer-p (buffer-or-name)
|
|
"Return t if BUFFER-OR-NAME is an 'unreal' buffer.
|
|
|
|
See `syd-real-buffer-p' for details on what that means."
|
|
(not (syd-real-buffer-p buffer-or-name)))
|
|
|
|
(defun syd-fixup-windows (windows)
|
|
"Ensure that each of WINDOWS is showing a real buffer or the fallback buffer."
|
|
(dolist (window windows)
|
|
(with-selected-window window
|
|
(when (syd-unreal-buffer-p (window-buffer))
|
|
(previous-buffer)
|
|
(when (syd-unreal-buffer-p (window-buffer))
|
|
(switch-to-buffer (syd-fallback-buffer)))))))
|
|
|
|
(defun syd-kill-buffer-fixup-windows (buffer)
|
|
"Kill the BUFFER and ensure all the windows it was displayed in have switched
|
|
to a real buffer or the fallback buffer."
|
|
(let ((windows (get-buffer-window-list buffer)))
|
|
(kill-buffer buffer)
|
|
(syd-fixup-windows (cl-remove-if-not #'window-live-p windows))))
|
|
|
|
(defun syd/kill-this-buffer-in-all-windows (buffer &optional dont-save)
|
|
"Kill BUFFER globally and ensure all windows previously showing this buffer
|
|
have switched to a real buffer or the fallback buffer.
|
|
|
|
If DONT-SAVE, don't prompt to save modified buffers (discarding their changes)."
|
|
(interactive
|
|
(list (current-buffer) current-prefix-arg))
|
|
(cl-assert (bufferp buffer) t)
|
|
(when (and (buffer-modified-p buffer) dont-save)
|
|
(with-current-buffer buffer
|
|
(set-buffer-modified-p nil)))
|
|
(syd-kill-buffer-fixup-windows buffer))
|
|
|
|
(provide 'syd-buffers)
|