¿Cómo ejecutar emacs grep-find link en la misma ventana?

Question

Cuando uso grep - find abre otra ventana (área en el marco) con una lista de resultados que puedo seleccionar. Cuando selecciono uno se abre el archivo de destino en una ventana diferente de grep -. find está en

¿Cómo puedo obtener el archivo de destino para abrir en la misma ventana que los grep resultados (en sustitución de la ventana grep resultados con lo que estoy realmente buscando).

¿Cómo puedo evitar que grep-find abra una ventana separada (tenerlo para que se abra en la ventana actual). Mi objetivo es buscar algo, lo encuentro, voy a él, todo dentro de la misma ventana. Me gustaría agregar esto a mi archivo .emacs.

Answer 1

No parece que haya ninguna forma de configurar el paquete compile para hacer lo que está pidiendo. Y no hay una manera fácil de usar advice para modificar el comportamiento. Yo creo que hay que recurrir a la edición de la función que en realidad salta al error, lo que se puede hacer con la siguiente adición a su .emacs (probado en 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 parte eval-afer-load simplemente asegura que vuelva a definirlo después de Emacs lo definió, por lo que su cambio se lleva a cabo.

Answer 2

Puede agregar un enlace (por ejemplo, Alt-m) y hacer lo siguiente

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

no he encontrado una forma de reemplazar el estándar "Enter"/Mouse-clic unión con una función personalizada

Answer 3

Hay un otro enfoque:

(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))