Come eseguire il link emacs grep-find nella stessa finestra?

Question

Quando uso grep - find apre un'altra finestra (area nel frame) con un elenco di risultati che è possibile selezionare. Quando seleziono uno si apre il file di destinazione in una finestra diversa da quella grep -. find è in

Come posso ottenere il file di destinazione per aprire nella stessa finestra come grep risultati (in sostituzione della finestra grep risultati di ciò che ho sto davvero cercando).

Come posso mantenere grep-find dall'apertura di una finestra separata (è necessario che si apra nella finestra corrente). Il mio obiettivo è cercare qualcosa, lo trovo, ci vado, tutto all'interno della stessa finestra. Vorrei aggiungere questo al mio file .emacs.

Answer 1

Non sembra che ci sia un modo per configurare il pacchetto compile per fare quello che stai chiedendo. E non c'è un modo semplice per usare advice per modificare il comportamento. Io penso che si debba ricorrere alla modifica la funzione che salta in realtà per l'errore che si può fare con la seguente aggiunta al vostro .emacs (testato in Emacs 23.1):

(eval-after-load "compile" 
'(defun compilation-goto-locus (msg mk end-mk) 
    "Jump to an error corresponding to MSG at MK. 
All arguments are markers. If END-MK is non-nil, mark is set there 
and overlay is highlighted between MK and END-MK." 
    ;; Show compilation buffer in other window, scrolled to this error. 
    (let* ((from-compilation-buffer (eq (window-buffer (selected-window)) 
        (marker-buffer msg))) 
    ;; Use an existing window if it is in a visible frame. 
    (pre-existing (get-buffer-window (marker-buffer msg) 0)) 
    (w (if (and from-compilation-buffer pre-existing) 
     ;; Calling display-buffer here may end up (partly) hiding 
     ;; the error location if the two buffers are in two 
     ;; different frames. So don't do it if it's not necessary. 
     pre-existing 
     (let ((display-buffer-reuse-frames t) 
     (pop-up-windows t)) 
     ;; Pop up a window. 
     (display-buffer (marker-buffer msg))))) 
    (highlight-regexp (with-current-buffer (marker-buffer msg) 
      ;; also do this while we change buffer 
      (compilation-set-window w msg) 
      compilation-highlight-regexp))) 
;; Ideally, the window-size should be passed to `display-buffer' (via 
;; something like special-display-buffer) so it's only used when 
;; creating a new window. 
(unless pre-existing (compilation-set-window-height w)) 

(switch-to-buffer (marker-buffer mk)) 

    ;; was 
;; (if from-compilation-buffer 
;;  ;; If the compilation buffer window was selected, 
;;  ;; keep the compilation buffer in this window; 
;;  ;; display the source in another window. 
;;  (let ((pop-up-windows t)) 
;;  (pop-to-buffer (marker-buffer mk) 'other-window)) 
;; (if (window-dedicated-p (selected-window)) 
;;  (pop-to-buffer (marker-buffer mk)) 
;;  (switch-to-buffer (marker-buffer mk)))) 
;; If narrowing gets in the way of going to the right place, widen. 
(unless (eq (goto-char mk) (point)) 
    (widen) 
    (goto-char mk)) 
(if end-mk 
    (push-mark end-mk t) 
    (if mark-active (setq mark-active))) 
;; If hideshow got in the way of 
;; seeing the right place, open permanently. 
(dolist (ov (overlays-at (point))) 
    (when (eq 'hs (overlay-get ov 'invisible)) 
    (delete-overlay ov) 
    (goto-char mk))) 

(when highlight-regexp 
    (if (timerp next-error-highlight-timer) 
     (cancel-timer next-error-highlight-timer)) 
    (unless compilation-highlight-overlay 
    (setq compilation-highlight-overlay 
     (make-overlay (point-min) (point-min))) 
    (overlay-put compilation-highlight-overlay 'face 'next-error)) 
    (with-current-buffer (marker-buffer mk) 
    (save-excursion 
     (if end-mk (goto-char end-mk) (end-of-line)) 
     (let ((end (point))) 
    (if mk (goto-char mk) (beginning-of-line)) 
    (if (and (stringp highlight-regexp) 
     (re-search-forward highlight-regexp end t)) 
     (progn 
      (goto-char (match-beginning 0)) 
      (move-overlay compilation-highlight-overlay 
       (match-beginning 0) (match-end 0) 
       (current-buffer))) 
     (move-overlay compilation-highlight-overlay 
      (point) end (current-buffer))) 
    (if (or (eq next-error-highlight t) 
     (numberp next-error-highlight)) 
     ;; We want highlighting: delete overlay on next input. 
     (add-hook 'pre-command-hook 
       'compilation-goto-locus-delete-o) 
     ;; We don't want highlighting: delete overlay now. 
     (delete-overlay compilation-highlight-overlay)) 
    ;; We want highlighting for a limited time: 
    ;; set up a timer to delete it. 
    (when (numberp next-error-highlight) 
     (setq next-error-highlight-timer 
     (run-at-time next-error-highlight nil 
       'compilation-goto-locus-delete-o))))))) 
(when (and (eq next-error-highlight 'fringe-arrow)) 
    ;; We want a fringe arrow (instead of highlighting). 
    (setq next-error-overlay-arrow-position 
    (copy-marker (line-beginning-position))))))) 

La porzione eval-afer-load solo assicura che si ridefinirlo dopo il Emacs lo ha definito, in modo che la modifica venga presa.

Answer 2

È possibile aggiungere un assorbente (ad esempio Alt-m) e procedere come segue

(define-key grep-mode-map "\M-m" (lambda() 
            (interactive) 
            (compile-goto-error) 
            (delete-other-windows) 
            (kill-buffer "*grep*"))) 

non ho trovato un modo per sostituire lo standard "Enter"/mouse-click vincolante con una funzione personalizzata

Answer 3

C'è un altro approccio:

(defun eab/compile-goto-error() 
    (interactive) 
    (let ((cwc (current-window-configuration))) 
    (funcall 
    `(lambda() 
     (defun eab/compile-goto-error-internal() 
      (let ((cb (current-buffer)) 
       (p (point))) 
      (set-window-configuration ,cwc) 
      (switch-to-buffer cb) 
      (goto-char p)))))) 
    (compile-goto-error) 
    (run-with-timer 0.01 nil 'eab/compile-goto-error-internal))