emenel/doomemacs
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Rewrite core-popups

Browse source
This commit is contained in:
Henrik Lissner 2017-01-28 02:00:38 -05:00
parent 77cda0ad49
commit a2ed275d07
2 changed files with 343 additions and 244 deletions
Download patch file Download diff file Expand all files Collapse all files

105
core/autoload/popups.el Normal file
View file

@ -0,0 +1,105 @@
;;; popups.el
;;;###autoload
(defun doom-popup-p (&optional window)
"Return t if WINDOW is a popup. Uses current window if WINDOW is omitted."
(let ((window (or window (selected-window))))
(and window
(window-parameter window 'popup))))
;;;###autoload
(defun doom-popup-buffer (buffer &optional plist)
"Display BUFFER in a shackle popup. See `shackle-rules' for possible rules."
(let* ((buffer-name (cond ((stringp buffer) buffer)
((bufferp buffer) (buffer-name buffer))
(t (error "Not a valid buffer"))))
(buffer (get-buffer-create buffer-name)))
(unless (doom-popup-p)
(setq doom-popup-other-window (selected-window)))
(shackle-display-buffer
buffer
nil (or plist (shackle-match buffer-name)))))
;;;###autoload
(defun doom-popup-file (file &optional plist)
"Display FILE in a shackle popup, with PLIST rules. See `shackle-rules' for
possible rules."
(unless (file-exists-p file)
(user-error "Can't display file in popup, it doesn't exist: %s" file))
(doom-popup-buffer (find-file-noselect file t) plist))
;;;###autoload
(defun doom-popup-windows ()
"Get a list of open poups."
(-filter 'doom-popup-p (window-list)))
;;;###autoload
(defun doom/popup-restore ()
"Restore the last popup."
(interactive)
(unless doom-popup-history
(error "No popups to restore"))
(dolist (spec doom-popup-history)
(let ((buffer (get-buffer (car spec)))
(path (plist-get spec :file)))
(when (and (not buffer) path)
(setq buffer (find-file-noselect path t)))
(when buffer
(doom-popup-buffer buffer (plist-get spec :rules)))))
(setq doom-popup-history '()))
;;;###autoload
(defun doom/popup-restore-or-switch ()
(interactive)
(let (popups)
(cond ((doom-popup-p)
(unless (doom-visible-windows)
(user-error "No non-popups available"))
(other-window 1))
((setq popups (doom-popup-windows))
(select-window (car popups)))
(t
(doom/popup-restore)))))
;;;###autoload
(defun doom/popup-close (&optional window)
"Find and close WINDOW if it's a popup. If WINDOW is omitted, it will use
`selected-window'. The contained buffer is buried."
(interactive)
(let ((window (or window (selected-window))))
(when (and (doom-popup-p window)
(window-live-p window))
(with-selected-window window
(when (called-interactively-p 'interactive)
(run-hooks 'doom-popup-close-hook))
(doom-popup-mode -1)
(when doom-popup-remember-history
(setq doom-popup-history (list (doom--popup-data window)))))
(delete-window window))))
;;;###autoload
(defun doom/popup-close-all ()
"Closes all open popups. If DONT-KILL is non-nil, don't kill their buffers."
(interactive)
(let* ((orig-win (selected-window))
(popups (--filter (and (doom-popup-p it) (not (eq it orig-win)))
(window-list))))
(when popups
(setq doom-popup-history (mapcar 'doom--popup-data (doom-popup-windows)))
(run-hooks 'doom-popup-close-hook)
(let (doom-popup-remember-history)
(mapc 'doom/popup-close popups)))))
;;;###autoload
(defun doom/popup-close-maybe ()
"Close the current popup *if* its window doesn't have a noesc parameter."
(interactive)
(if (window-parameter (selected-window) 'noesc)
(call-interactively 'evil-force-normal-state)
(doom/popup-close)))
(defun doom--popup-data (window)
(let ((buffer (window-buffer window)))
`(,(buffer-name buffer)
:file ,(buffer-file-name buffer)
:rules ,(window-parameter window 'popup))))

464
core/core-popups.el
View file

@ -1,129 +1,146 @@
;;; core-popups.el --- taming sudden yet inevitable windows ;;; core-popups.el --- taming sudden yet inevitable windows
;; I'd like certain buffers--like prompts or informational/terminal/temporary ;; I'd like certain buffers--like help windows, prompts or
;; buffers--to act independently from my work buffers, to minimize the context ;; informational/terminal/temporary buffers--to have less presence among my work
;; switch between them. To do this, I relegate them to disposable "popup ;; buffers (typically, source code buffers). I'd also like them to be easy to
;; windows" that can be invoked from anywhere. ;; both dispose of quickly and invoke from anywhere. It will also hide the
;; mode-line in popups using `doom-hide-modeline-mode'
;; ;;
;; I use a slew of hackery to get Emacs to treat these popups consistently. It ;; I use `shackle' to make this as consistent as possible, which lets you
;; goes through great lengths to tame helm, flycheck, help buffers--*even* the ;; specify rules on how to treat certain buffers. I go through great lengths to
;; beast that is org-mode, with the help of `display-buffer-alist' and ;; tame helm, flycheck, help buffers--*even* the beast that is org-mode, with
;; `shackle'. ;; the help of `display-buffer-alist' and `shackle'.
;; ;;
;; Be warned, this could break. ;; Be warned, there is a lot of hackery voodoo here that could break with an
;; emacs update, or an update to any of the packages it tries to tame (like helm
;; or org-mode).
(package! shackle :demand t (package! shackle :demand t
:config :config
(shackle-mode 1) (shackle-mode 1)
(setq shackle-default-alignment 'below (setq shackle-default-alignment 'below
shackle-rules shackle-select-reused-windows t)
`(;; Doom
(" *doom*" :size 35 :select t) (defmacro defpopup! (&rest rules)
("^ ?\\*doom:.+\\*$" :size 35 :select t :regexp t) "Define one or more popup rules. See `shackle-rules' for the format of these
("^ ?\\*doom.+\\*$" :size 12 :noselect t :regexp t) rules. If :align is omitted, it will use `shackle-default-alignment'."
(declare (indent 0))
(macroexp-progn
(mapcar (lambda (rule)
;; Ensure some default attributes are set for window rules
(let ((pattern (car rule))
(ruleset (cdr rule)))
;; Align popups by default (error if this doesn't happen)
(unless (plist-member ruleset :align)
(plist-put ruleset :align shackle-default-alignment))
;; Select popups by default
(unless (or (plist-member ruleset :select)
(plist-member ruleset :noselect))
(plist-put ruleset :select t))
(setq rule (append (list pattern) ruleset))
`(push ',rule shackle-rules)))
rules)))
;; :noesc and :modeline are custom settings and are not part of shackle. See
;; `doom*popup-init' and `doom-popup-buffer' for how they're used.
(defpopup! ("^ ?\\*doom:.+\\*$" :size 35 :regexp t :modeline t)
("^ ?\\*doom .+\\*$" :size 12 :noselect t :regexp t :modeline t)
("^\\*.+-Profiler-Report .+\\*$" :size 0.3 :regexp t) ("^\\*.+-Profiler-Report .+\\*$" :size 0.3 :regexp t)
("*esup*" :size 0.4 :noselect t) ("*esup*" :size 0.4 :noselect t :noesc t)
("*minor-modes*" :size 0.5 :noselect t) ("*minor-modes*" :size 0.5 :noselect t)
("*eval*" :size 16 :noselect t) ("*eval*" :size 16 :noselect t)
;; Emacs
("*Pp Eval Output*" :size 0.3) ("*Pp Eval Output*" :size 0.3)
("*Apropos*" :size 0.3) ("*Apropos*" :size 0.3)
("*Backtrace*" :size 25 :noselect t) ("*Backtrace*" :size 25 :noselect t)
("*Help*" :size 16 :select t) ("*Help*" :size 16)
("*Messages*" :size 15 :select t) ("*Messages*" :size 10 :select t)
("*Warnings*" :size 10 :noselect t) ("*Warnings*" :size 10 :noselect t)
(compilation-mode :size 15 :noselect t)
(eww-mode :size 30 :select t)
("*command-log*" :size 28 :noselect t :align right) ("*command-log*" :size 28 :noselect t :align right)
;; evil (compilation-mode :size 15 :noselect t :noesc t)
("*evil-registers*" :size 0.3) (ivy-occur-grep-mode :size 25 :noesc t)
("*Command Line*" :size 8 :select t) (eww-mode :size 30)
;; git-gutter (comint-mode :noesc t)
("^\\*git-gutter.+\\*$" :regexp t :size 15 :noselect t) (tabulated-list-mode :noesc t))
;; vcs
("*vc-diff*" :size 15 :noselect t)
("*vc-change-log*" :size 15 :select t)
(vc-annotate-mode :same t)
))
;; :noesc = Can't be closed with a single ESC (defvar doom-popup-history nil
;; :nokill = Won't be killed when closed (only buried) "A list of popups that were last closed. Used by `doom/popup-restore' and
(defvar doom-popup-rules `doom*popup-save'.")
'(("^\\*doom\\(:scratch\\)?\\*$" :noesc :nokill)
("^\\*doom.*\\*$" :noesc :nokill)
(ivy-occur-grep-mode :noesc)
(compilation-mode :noesc)
(comint-mode :noesc :nokill)
(eshell-mode :noesc :nokill)
(messages-buffer-mode :nokill)
(esup-mode :noesc)
(tabulated-list-mode :noesc)))
(defvar-local doom-popup-rule nil (defvar doom-popup-remember-history t
"A list of rules applied to this popup.") "If non-nil, DOOM will remember the last popup(s) that were open in
(put 'doom-popup-rule 'permanent-local t) `doom-popup-history'.")
(defvar doom-popup-other-window nil
"The last window selected before a popup was opened.")
(defvar-local doom-popup-rules nil
"The shackle rule that caused this buffer to be recognized as a popup.")
(defvar doom-popup-mode-map (defvar doom-popup-mode-map
(let ((map (make-sparse-keymap))) (let ((map (make-sparse-keymap)))
(define-key map [remap doom/kill-real-buffer] 'doom/popup-close)
(define-key map [remap evil-window-delete] 'doom/popup-close)
(define-key map [remap evil-window-move-very-bottom] 'ignore)
(define-key map [remap evil-window-move-very-top] 'ignore)
(define-key map [remap evil-window-move-far-left] 'ignore)
(define-key map [remap evil-window-move-far-right] 'ignore)
(define-key map [remap evil-window-split] 'ignore)
(define-key map [remap evil-window-vsplit] 'ignore)
(define-key map [remap evil-force-normal-state] 'doom/popup-close-maybe)
(define-key map [escape] 'doom/popup-close-maybe) (define-key map [escape] 'doom/popup-close-maybe)
(define-key map (kbd "ESC") 'doom/popup-close-maybe) (define-key map (kbd "ESC") 'doom/popup-close-maybe)
map) map)
"Active keymap in popup windows.") "Active keymap in popup windows.")
(define-minor-mode doom-popup-mode (define-minor-mode doom-popup-mode
"Minor mode for pop-up windows. Enables local keymaps and sets state "Minor mode for pop-up windows."
variables."
:global nil
:init-value nil :init-value nil
:keymap doom-popup-mode-map :keymap doom-popup-mode-map
(let ((rules (--any (let ((key (car it))) (if (and (not doom-popup-mode)
(when (cond ((symbolp key) doom-hide-modeline-mode)
(or (eq major-mode key) (doom-hide-modeline-mode -1)
(derived-mode-p key))) (let ((modeline (plist-get doom-popup-rules :modeline)))
((stringp key) (cond ((eq modeline 'nil)
(string-match-p key (buffer-name)))) (doom-hide-modeline-mode +1))
(cdr it))) ((symbolp modeline)
doom-popup-rules))) (let ((doom--hidden-modeline-format (+doom-modeline modeline)))
(set-window-dedicated-p nil doom-popup-mode) (doom-hide-modeline-mode +1))))))
(setq doom-last-popup (current-buffer)) (set-window-dedicated-p nil doom-popup-mode))
(setq-local doom-popup-rule rules)))
(put 'doom-popup-mode 'permanent-local t) (put 'doom-popup-mode 'permanent-local t)
;; Tell `window-state-get' and `current-window-configuration' to persist these
;; custom parameters.
(dolist (param '(popup noesc))
(add-to-list 'window-persistent-parameters (cons param 'writable)))
(defun doom*popup-init (orig-fn &rest args) (defun doom*popup-init (orig-fn &rest args)
"Enables `doom-popup-mode' in every popup window and returns the window." "Enables `doom-popup-mode' in popup windows and returns the window."
(let ((window (apply orig-fn args))) (unless (doom-popup-p)
(setq doom-popup-other-window (selected-window)))
(let ((window (apply orig-fn args))
(rules (nth 2 args)))
(unless window
(error "No window was found (%s)" args))
(mapc (lambda (cfg) (set-window-parameter window (car cfg) (cdr cfg)))
(append `((popup . ,rules)
(no-other-window . ,t))
(when (plist-get rules :noesc)
`((noesc . ,t)))))
(with-selected-window window (with-selected-window window
(setq-local doom-popup-rules rules)
(doom-popup-mode +1)) (doom-popup-mode +1))
;; NOTE orig-fn returns a window, so `doom*popup-init' must too ;; NOTE orig-fn returns a window, so `doom*popup-init' must too
window)) window))
(defun doom*popup-save (orig-fun &rest args) (defun doom*popup-save (orig-fn &rest args)
"Prevents messing up a popup buffer on window changes." "Puts aside all popups before executing the original function, usually to
prevent the popups from interfering (or the other way around)."
(let ((in-popup-p (doom-popup-p)) (let ((in-popup-p (doom-popup-p))
(popups-p (and doom-last-popup (popups (doom-popup-windows))
(window-live-p (get-buffer-window doom-last-popup))))) (doom-popup-remember-history t))
(when popups-p (when popups
(mapc (lambda (w) (doom/popup-close w t)) (mapc 'doom/popup-close popups))
(-filter 'doom-popup-p (window-list)))) (unwind-protect (apply orig-fn args)
(unwind-protect (apply orig-fun args) (when popups
(when popups-p (let ((origin (selected-window)))
(let ((origin-win (selected-window))) (doom/popup-restore)
(doom/popup-last-buffer) (unless in-popup-p
(when in-popup-p (select-window origin)))))))
(select-window origin-win)))))))
;; There is no shackle-popup hook, so I created one: ;; There is no shackle-popup hook, so I created one:
(advice-add 'shackle-display-buffer :around 'doom*popup-init) (advice-add 'shackle-display-buffer :around 'doom*popup-init)
;; Order matters for these two ;; Don't affect popup windows
(advice-add 'balance-windows :around 'doom*popup-save)) (advice-add 'balance-windows :around 'doom*popup-save))
@ -132,16 +149,28 @@ variables."
;; ;;
(after! evil (after! evil
;; Tell these functions not to mess with popups: (let ((map doom-popup-mode-map))
(advice-add 'doom-evil-window-move :around 'doom*popup-save) (define-key map [remap evil-window-delete] 'doom/popup-close)
(advice-add 'evil-window-move-very-bottom :around 'doom*popup-save) (define-key map [remap evil-window-move-very-bottom] 'ignore)
(advice-add 'evil-window-move-very-top :around 'doom*popup-save) (define-key map [remap evil-window-move-very-top] 'ignore)
(advice-add 'evil-window-move-far-left :around 'doom*popup-save) (define-key map [remap evil-window-move-far-left] 'ignore)
(advice-add 'evil-window-move-far-right :around 'doom*popup-save) (define-key map [remap evil-window-move-far-right] 'ignore)
(define-key map [remap evil-window-split] 'ignore)
(define-key map [remap evil-window-vsplit] 'ignore)
(define-key map [remap evil-force-normal-state] 'doom/popup-close-maybe))
(defun doom*evil-command-window (hist cmd-key execute-fn) ;; Close popups when you press ESC in normal mode, in any buffer
(defun doom*popup-evil-close-on-esc ()
"Close non-repl popups and clean up `doom-popup-windows'."
(unless (or (minibuffer-window-active-p (minibuffer-window))
(evil-ex-hl-active-p 'evil-ex-search))
(doom/popup-close-all)))
(advice-add 'evil-force-normal-state :after 'doom*popup-evil-close-on-esc)
;; Tame the command window
(defun doom*popup-evil-command-window (hist cmd-key execute-fn)
"The evil command window has a mind of its own (uses `switch-to-buffer'). We "The evil command window has a mind of its own (uses `switch-to-buffer'). We
monkey patch it to use pop-to-buffer." monkey patch it to use pop-to-buffer, and to remember the previous window."
(when (eq major-mode 'evil-command-window-mode) (when (eq major-mode 'evil-command-window-mode)
(user-error "Cannot recursively open command line window")) (user-error "Cannot recursively open command line window"))
(dolist (win (window-list)) (dolist (win (window-list))
@ -156,63 +185,94 @@ monkey patch it to use pop-to-buffer."
(setq-local evil-command-window-cmd-key cmd-key) (setq-local evil-command-window-cmd-key cmd-key)
(evil-command-window-mode) (evil-command-window-mode)
(evil-command-window-insert-commands hist))) (evil-command-window-insert-commands hist)))
(advice-add 'evil-command-window :override 'doom*popup-evil-command-window)
(advice-add 'evil-command-window :override 'doom*evil-command-window)) (defun doom*popup-evil-command-window-execute ()
"Execute the command under the cursor in the appropriate buffer."
(interactive)
(let ((result (buffer-substring (line-beginning-position)
(line-end-position)))
(execute-fn evil-command-window-execute-fn)
(popup (selected-window)))
(select-window doom-popup-other-window)
(unless (equal evil-command-window-current-buffer (current-buffer))
(user-error "Originating buffer is no longer active"))
;; (kill-buffer "*Command Line*")
(doom/popup-close popup)
(funcall execute-fn result)
(setq evil-command-window-current-buffer nil)))
(advice-add 'evil-command-window-execute :override 'doom*popup-evil-command-window-execute)
(after! help-mode ;; Tell these functions not to mess with popups
;; Help buffers use itself (or `other-window') to decide where to open (advice-add 'doom-evil-window-move :around 'doom*popup-save)
;; followed links, which can be unpredictable. It should *only* replace the (advice-add 'evil-window-move-very-bottom :around 'doom*popup-save)
;; original buffer we opened the popup from. To fix this these three button (advice-add 'evil-window-move-very-top :around 'doom*popup-save)
;; types need to be redefined to set aside the popup before following a link. (advice-add 'evil-window-move-far-left :around 'doom*popup-save)
(define-button-type 'help-function-def (advice-add 'evil-window-move-far-right :around 'doom*popup-save)
:supertype 'help-xref
'help-function (lambda (fun file)
(require 'find-func)
(when (eq file 'C-source)
(setq file (help-C-file-name (indirect-function fun) 'fun)))
(let ((location (find-function-search-for-symbol fun nil file)))
(doom/popup-close)
(switch-to-buffer (car location) nil t)
(if (cdr location)
(progn
(goto-char (cdr location))
(recenter nil))
(message "Unable to find location in file")))))
(define-button-type 'help-variable-def ;; Don't block moving to/from popup windows
:supertype 'help-xref (defun doom*ignore-window-parameters-in-popups (dir &optional arg window)
'help-function (lambda (var &optional file) (window-in-direction
(when (eq file 'C-source) (cond ((eq dir 'up) 'above)
(setq file (help-C-file-name var 'var))) ((eq dir 'down) 'below)
(let ((location (find-variable-noselect var file))) (t dir))
(doom/popup-close) window t arg windmove-wrap-around t))
(switch-to-buffer (car location) nil t) (advice-add 'windmove-find-other-window :override 'doom*ignore-window-parameters-in-popups))
(if (cdr location)
(progn
(goto-char (cdr location))
(recenter nil))
(message "Unable to find location in file")))))
(define-button-type 'help-face-def ;; (after! help-mode
:supertype 'help-xref ;; ;; Help buffers use itself (or `other-window') to decide where to open
'help-function (lambda (fun file) ;; ;; followed links, which can be unpredictable. It should *only* replace the
(require 'find-func) ;; ;; original buffer we opened the popup from. To fix this these three button
(let ((location ;; ;; types need to be redefined to set aside the popup before following a link.
(find-function-search-for-symbol fun 'defface file))) ;; (define-button-type 'help-function-def
(doom/popup-close) ;; :supertype 'help-xref
(switch-to-buffer (car location) nil t) ;; 'help-function (lambda (fun file)
(if (cdr location) ;; (require 'find-func)
(progn ;; (when (eq file 'C-source)
(goto-char (cdr location)) ;; (setq file (help-C-file-name (indirect-function fun) 'fun)))
(recenter nil)) ;; (let ((location (find-function-search-for-symbol fun nil file)))
(message "Unable to find location in file")))))) ;; (doom/popup-close)
;; (switch-to-buffer (car location) nil t)
;; (if (cdr location)
;; (progn
;; (goto-char (cdr location))
;; (recenter nil))
;; (message "Unable to find location in file")))))
(after! magit ;; (define-button-type 'help-variable-def
;; Don't open files (from magit) in the magit popup ;; :supertype 'help-xref
(advice-add 'magit-display-file-buffer-traditional :around 'doom*popup-save)) ;; 'help-function (lambda (var &optional file)
;; (when (eq file 'C-source)
;; (setq file (help-C-file-name var 'var)))
;; (let ((location (find-variable-noselect var file)))
;; (doom/popup-close)
;; (switch-to-buffer (car location) nil t)
;; (if (cdr location)
;; (progn
;; (goto-char (cdr location))
;; (recenter nil))
;; (message "Unable to find location in file")))))
;; (define-button-type 'help-face-def
;; :supertype 'help-xref
;; 'help-function (lambda (fun file)
;; (require 'find-func)
;; (let ((location
;; (find-function-search-for-symbol fun 'defface file)))
;; (doom/popup-close)
;; (switch-to-buffer (car location) nil t)
;; (if (cdr location)
;; (progn
;; (goto-char (cdr location))
;; (recenter nil))
;; (message "Unable to find location in file"))))))
;; (after! magit
;; ;; Don't open files (from magit) within the magit popup
;; (advice-add 'magit-display-file-buffer-traditional :around 'doom*popup-save))
(after! neotree (after! neotree
(defun doom*save-neotree (orig-fun &rest args) (defun doom*popup-save-neotree (orig-fun &rest args)
"Prevents messing up the neotree buffer on window changes." "Prevents messing up the neotree buffer on window changes."
(let ((neo-p (and (featurep 'neotree) (neo-global--window-exists-p)))) (let ((neo-p (and (featurep 'neotree) (neo-global--window-exists-p))))
(when neo-p (when neo-p
@ -224,38 +284,40 @@ monkey patch it to use pop-to-buffer."
(neotree-show)))))) (neotree-show))))))
;; Prevent neotree from interfering with popups ;; Prevent neotree from interfering with popups
(advice-add 'shackle-display-buffer :around 'doom*save-neotree) (advice-add 'shackle-display-buffer :around 'doom*popup-save-neotree)
;; Prevents messing up the neotree buffer on window changes ;; Prevents messing up the neotree buffer on window changes
(advice-add 'doom-evil-window-move :around 'doom*save-neotree) (advice-add 'doom-evil-window-move :around 'doom*popup-save-neotree)
;; (advice-add 'doom-popup-buffer :around 'doom*save-neotree) ;; (advice-add 'doom-popup-buffer :around 'doom*popup-save-neotree)
;; Don't let neotree interfere with moving, splitting or rebalancing windows ;; Don't let neotree interfere with moving, splitting or rebalancing windows
(advice-add 'balance-windows :around 'doom*save-neotree) (advice-add 'balance-windows :around 'doom*popup-save-neotree)
(advice-add 'split-window :around 'doom*save-neotree) (advice-add 'split-window :around 'doom*popup-save-neotree)
(advice-add 'shackle-display-buffer :around 'doom*save-neotree) (advice-add 'shackle-display-buffer :around 'doom*popup-save-neotree)
(advice-add 'evil-window-move-very-bottom :around 'doom*save-neotree) (advice-add 'evil-window-move-very-bottom :around 'doom*popup-save-neotree)
(advice-add 'evil-window-move-very-top :around 'doom*save-neotree) (advice-add 'evil-window-move-very-top :around 'doom*popup-save-neotree)
(advice-add 'evil-window-move-far-left :around 'doom*save-neotree) (advice-add 'evil-window-move-far-left :around 'doom*popup-save-neotree)
(advice-add 'evil-window-move-far-right :around 'doom*save-neotree)) (advice-add 'evil-window-move-far-right :around 'doom*popup-save-neotree))
(add-hook! org-load (add-hook! org-load
;; Ensures org-src-edit yields control of its buffer to shackle. ;; Ensures org-src-edit yields control of its buffer to shackle.
(defun org-src-switch-to-buffer (buffer context) (defun doom*org-src-switch-to-buffer (buffer context) (pop-to-buffer buffer))
(pop-to-buffer buffer)) (advice-add 'org-src-switch-to-buffer :override 'doom*org-src-switch-to-buffer)
;; And these for org-todo, org-link and org-agenda ;; ...for org-todo, org-link and org-agenda popups
(defun org-pop-to-buffer-same-window (&optional buffer-or-name norecord label) (defun doom*org-pop-to-buffer-same-window (&optional buffer-or-name norecord label)
"Pop to buffer specified by BUFFER-OR-NAME in the selected window." "Pop to buffer specified by BUFFER-OR-NAME in the selected window."
(display-buffer buffer-or-name)) (display-buffer buffer-or-name))
(advice-add 'org-pop-to-buffer-same-window :override 'doom*org-pop-to-buffer-same-window)
(defun org-switch-to-buffer-other-window (&rest args) (defun doom*org-switch-to-buffer-other-window (&rest args)
(car-safe (car-safe
(mapc (lambda (b) (mapc (lambda (b)
(let ((buf (if (stringp b) (get-buffer-create b) b))) (let ((buf (if (stringp b) (get-buffer-create b) b)))
(pop-to-buffer buf t t))) (pop-to-buffer buf t t)))
args))) args)))
(advice-add 'org-switch-to-buffer-other-window :override 'doom*org-switch-to-buffer-other-window)
(defun doom/org-agenda-quit () (defun doom/popup-org-agenda-quit ()
"Necessary to finagle org-agenda into shackle popups and behave properly on quit." "Necessary to finagle org-agenda into shackle popups & behave on quit."
(interactive) (interactive)
(if org-agenda-columns-active (if org-agenda-columns-active
(org-columns-quit) (org-columns-quit)
@ -269,83 +331,15 @@ monkey patch it to use pop-to-buffer."
(after! org-agenda (after! org-agenda
(map! :map org-agenda-mode-map (map! :map org-agenda-mode-map
:e "<escape>" 'doom/org-agenda-quit :e "<escape>" 'doom/popup-org-agenda-quit
:e "ESC" 'doom/org-agenda-quit :e "ESC" 'doom/popup-org-agenda-quit
:e [escape] 'doom/org-agenda-quit :e [escape] 'doom/popup-org-agenda-quit
"q" 'doom/org-agenda-quit "q" 'doom/popup-org-agenda-quit
"Q" 'doom/org-agenda-quit))) "Q" 'doom/popup-org-agenda-quit)))
(after! repl-toggle
;; (add-hook! doom-popup-close
;; Functions (setq rtog/--last-buffer nil)))
;;
(defun doom-popup-p (&optional window)
"Whether WINDOW is a popup window or not. If WINDOW is nil, use current
window. Returns nil or the popup window."
(setq window (or window (selected-window)))
(and (window-live-p window)
(buffer-local-value 'doom-popup-mode (window-buffer window))
window))
(defun doom-popup-buffer (buffer &optional plist)
"Display BUFFER in a shackle popup."
(let* ((buffer-name (cond ((stringp buffer) buffer)
((bufferp buffer) (buffer-name buffer))
(t (error "Not a valid buffer"))))
(buffer (get-buffer-create buffer-name)))
(when (doom/real-buffer-p (window-buffer))
(setq doom-last-window (selected-window)))
(shackle-display-buffer
buffer
nil (or plist (shackle-match buffer-name)))))
(defun doom/popup-messages ()
"Pop up the messages buffer."
(interactive)
(doom-popup-buffer (messages-buffer))
(goto-char (point-max)))
(defun doom/popup-last-buffer ()
"Restore the last popup."
(interactive)
(unless (buffer-live-p doom-last-popup)
(setq doom-last-popup nil)
(error "No popup to restore"))
(doom-popup-buffer doom-last-popup))
(defun doom/popup-close (&optional window dont-kill)
"Find and close the currently active popup (if available)."
(interactive)
(setq window (or window (selected-window)))
(when (doom-popup-p window)
(with-selected-window window
;; If REPL...
(when (bound-and-true-p repl-toggle-mode)
(setq rtog/--last-buffer nil))
(doom-popup-mode -1)
(unless (or dont-kill (memq :nokill doom-popup-rule))
(let ((kill-buffer-query-functions
(delq 'process-kill-buffer-query-function
kill-buffer-query-functions)))
(kill-buffer (window-buffer window)))))
(delete-window window)))
(defun doom/popup-close-maybe ()
"Close the current popup *if* its buffer doesn't have a :noesc rule in
`doom-popup-rules'."
(interactive)
(if (memq :noesc doom-popup-rule)
(call-interactively 'evil-force-normal-state)
(doom/popup-close)))
(defun doom/popup-close-all (&optional dont-kill)
"Closes all popups (kill them if DONT-KILL-BUFFERS is non-nil)."
(interactive)
(let ((orig-win (selected-window)))
(mapc (lambda (w) (doom/popup-close w dont-kill))
(--filter (and (doom-popup-p it) (not (eq it orig-win)))
(window-list)))))
(provide 'core-popups) (provide 'core-popups)
;;; core-popups.el ends here ;;; core-popups.el ends here