Comment exécuter le lien grep-find d'emacs dans la même fenêtre?

Question

Lorsque j'utilise grep - find il ouvre une autre fenêtre (zone dans le cadre) avec une liste de résultats que je peux sélectionner. Lorsque je sélectionne une ouvre le fichier cible dans une autre fenêtre que grep -. find est dans

Comment puis-je obtenir le fichier cible à ouvrir dans la même fenêtre que les grep résultats (remplaçant la fenêtre grep résultats avec ce que je Je cherche réellement).

Comment puis-je empêcher grep-find d'ouvrir une fenêtre séparée (le faire pour qu'il s'ouvre dans la fenêtre en cours). Mon but est de chercher quelque chose, je le trouve, j'y vais, tous dans la même fenêtre. Je voudrais ajouter ceci à mon dossier .emacs.

Answer 1

Il ne semble pas possible de configurer le package compile pour qu'il réponde à vos besoins. Et il n'y a pas de moyen facile d'utiliser advice pour modifier le comportement. Je pense que vous devez recourir à la modification de la fonction qui saute en fait à l'erreur, que vous pouvez faire avec l'ajout suivant à votre .emacs (testé dans 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 partie eval-afer-load assure juste que vous le redéfinir après Emacs l'a défini, de sorte que votre changement s'installe.

Answer 2

Vous pouvez ajouter une liaison (par exemple Alt-m) et procédez comme suit

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

Je n'ai pas trouvé un moyen de remplacer la norme « Enter »/Mausklick liaison avec une fonction personnalisée

Answer 3

Il y a une autre approche:

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