embark-setup.el

;;; Keys


(global-set-key (kbd "M-o") 'embark-act)
(define-key minibuffer-local-map (kbd "M-o") 'embark-exit-and-act)
(define-key minibuffer-local-map (kbd "C-M-o") 'embark-act)

;; occur and export are still under developement and in flux!
(define-key minibuffer-local-map (kbd "C-o") 'embark-export)
(define-key minibuffer-local-map (kbd "C-c o") 'embark-occur)

;;; Selectrum setup

(setcar (memq 'embark-category-type embark-classifiers)
        (defun embark-category-type+ ()
          (cond (selectrum--active-p
                 (completion-metadata-get
                  (completion-metadata
                   (buffer-substring
                    selectrum--start-of-input-marker
                    selectrum--end-of-input-marker)
                   minibuffer-completion-table
                   minibuffer-completion-predicate)
                  'category))
                ((minibufferp)
                 (embark-category-type)))))


(defun selectrum-get-full-candidate (&optional cand)
  "Return full version of CAND which defaults to the current."
  (when selectrum--active-p
    (let ((cand (or cand
                     (selectrum--get-candidate
                      selectrum--current-candidate-index))) )
      (selectrum--get-full cand))))
(add-hook 'embark-target-finders 'selectrum-get-full-candidate)


(add-hook 'embark-candidate-collectors
          (defun embark-selectrum-candidates ()
            (when selectrum--active-p
              (cl-loop for cand in selectrum--refined-candidates
                       collect (if minibuffer-completing-file-name
                                   cand ;; pass relative names for dired
                                 (selectrum--get-full cand))))))
                                
(add-hook 'embark-setup-hook
          (defun embark-selectrum-handle-inject ()
            (when selectrum--active-p
              ;; use the injected candidate and make sure selectrum doesn't
              ;; update afterwards
              (setq selectrum--current-candidate-index -1)
              (setq selectrum--previous-input-string
                    (buffer-substring
                     selectrum--start-of-input-marker
                     selectrum--end-of-input-marker)))))


;;; Display setup

(add-hook 'embark-occur-mode-hook
          (defun embark-occur-setup+ ()
            (set-window-dedicated-p (selected-window) 'yes)))

(defvar embark-prev-occur-window+ nil)

(add-hook 'embark-pre-action-hook
          (defun embark-occur-remember+ ()
            (when (derived-mode-p 'embark-occur-mode)
              (setq embark-prev-occur-window+ (selected-window)))))

(add-hook 'embark-post-action-hook
          (defun embark-occur-reselect+ ()
            (when (window-live-p embark-prev-occur-window+)
              (select-window embark-prev-occur-window+)
              (setq embark-prev-occur-window+ nil))))


;;; Which key as key prompter

(setq embark-indicator
      (defun embark-which-key-setup ()
        (let ((which-key-show-transient-maps t)
              (which-key-replacement-alist
               (cons '(("^[0-9-]\\|kp-[0-9]\\|kp-subtract\\|C-u$" . nil) . ignore)
                     which-key-replacement-alist)))
          (setq-local which-key-show-prefix nil)
          (setq-local which-key-persistent-popup t)
          (which-key--update))))

(add-hook 'embark-pre-action-hook
          (defun embark-which-key-tear-down ()
            (kill-local-variable 'which-key-persistent-popup)
            (kill-local-variable 'which-key-show-prefix)
            (unless which-key-persistent-popup
              (which-key--hide-popup))))