Masquer la fenêtre * compilation *

20

Il est ennuyeux de voir apparaître la fenêtre de compilation lorsqu'elle réussit. Comment supprimer cela automatiquement?

Je veux le voir si ça ne réussit pas.

window compilation Husain
la source

Réponses:

11

il y a des années sur le canal IRC #emacs, j'ai obtenu ce morceau de code que j'utilise depuis toujours. La valeur "2 sec" définit la durée pendant laquelle la fenêtre de compilation réussie reste visible.

; from enberg on #emacs
(setq compilation-finish-function
  (lambda (buf str)
    (if (null (string-match ".*exited abnormally.*" str))
        ;;no errors, make the compilation window go away in a few seconds
        (progn
          (run-at-time
           "2 sec" nil 'delete-windows-on
           (get-buffer-create "*compilation*"))
          (message "No Compilation Errors!")))))
shapr
la source
14

En regardant rapidement le code (dans la bibliothèque compile.el), vous devriez pouvoir simplement tuer ou masquer le tampon affiché en utilisant une fonction raccrochée compilation-finish-functions. Pour ce faire, utilisez quelque chose comme ceci:

 (add-hook 'compilation-finish-functions (lambda (buf strg) (kill-buffer buf))

Si vous ne voulez pas tuer le tampon, utilisez quelque chose comme ceci:

 (add-hook 'compilation-finish-functions
           (lambda (buf strg)
             (let ((win  (get-buffer-window buf 'visible)))
               (when win (delete-window win)))))

En général, vous pouvez imaginer que pour quelque chose comme ça, il y a probablement un crochet déjà fourni, vous pouvez donc facilement attacher du code à un endroit aussi important dans le traitement. Une petite navigation dans le code ou une utilisation vous en M-x aproposinforme généralement rapidement. Les noms des crochets se terminent généralement par -hookou -functions.

A dessiné
la source
2

Ce fil est également pertinent, au cas où quelqu'un serait intéressé:

/programming/11043004/emacs-compile-buffer-auto-close

Le mérite revient à l'auteur original jpkotta . Voici sa réponse:

J'utilise ce qui suit pour la compilation. Il conserve le tampon de compilation s'il y a des avertissements ou des erreurs et l'enterre sinon (après 1 seconde).

(defun bury-compile-buffer-if-successful (buffer string)
  "Bury a compilation buffer if succeeded without warnings "
  (if (and
       (string-match "compilation" (buffer-name buffer))
       (string-match "finished" string)
       (not
        (with-current-buffer buffer
          (search-forward "warning" nil t))))
      (run-with-timer 1 nil
                      (lambda (buf)
                        (bury-buffer buf)
                        (switch-to-prev-buffer (get-buffer-window buf) 'kill))
                      buffer)))
(add-hook 'compilation-finish-functions 'bury-compile-buffer-if-successful)
Swarnendu Biswas
la source
1
Veuillez ne pas publier de réponse qui consiste simplement en un lien . Incluez les parties essentielles de la réponse dans votre message, afin que votre message réponde à la question. Fournissez le lien comme source et pour plus d'informations. Pour plus d'informations, veuillez lire nos directives sur la rédaction des réponses .
Gilles 'SO- arrête d'être méchant'
Mis à jour ma réponse.
Swarnendu Bis était le
Notez qu'il est correct de citer la réponse de quelqu'un d'autre de Stack Exchange , mais vous devez fournir une attribution appropriée , y compris le nom de l'auteur.
Gilles 'SO- arrête d'être méchant'
1

J'ai cet extrait dans mon .emacs.d:

    (defcustom compilation-auto-quit-window-delay 1
      "Time in seconds before auto closing the window."
      :group 'compilation
      :type 'number)  

    (defun compilation-auto-quit-window-finish-function (buffer status)
      "Quit the *compilation* window if it went well."
      (let ((window (get-buffer-window buffer)))
        (when (and (equal status "finished\n")
                   (compilation-went-super-p))
          (run-with-timer
              (or compilation-auto-quit-window-delay 0) nil
            (lambda nil
              (when (and (window-live-p window)
                         (eq (window-buffer window)
                             buffer)
                         (not (eq (selected-window)
                                  window)))
                (save-selected-window
                  (quit-window nil window))))))))

    (define-minor-mode compilation-auto-quit-window
      "Automatically close the *compilation* window if it went well."
      :global t
      (cond (compilation-auto-quit-window
             (add-hook 'compilation-finish-functions
                       'compilation-auto-quit-window-finish-function))
            (t
             (remove-hook 'compilation-finish-functions
                          'compilation-auto-quit-window-finish-function))))

    (defun compilation-went-super-p (&optional buffer)
      "Return t, if no gotoable output appeared."
      (with-current-buffer (or buffer (current-buffer))
        (save-excursion
          (goto-char (point-min))
          (let (;; (compilation-skip-threshold 1)
                )
            (not (ignore-errors
                   (compilation-next-error 1)
                   t))))))
politza
la source