Come faccio a rendere la finestra della compilation in Emacs sempre di una certa dimensione?

Question

Voglio rendere la finestra della compilation in Emacs sempre visualizzata nella parte inferiore di una finestra, e avere sempre una certa altezza. Finora ho messo le seguenti righe nel mio file .emacs:

(setq split-height-threshold 0) 
(setq compilation-window-height 10) 

... e lo fa il lavoro per quando ho solo una finestra aperta, ma non appena ho diviso lo schermo in due finestre in senso orizzontale (che la linea di divisione nel mezzo va dall'alto verso il basso), la finestra di compilazione smette di rispettare la variabile di altezza e divide la finestra nel mezzo.

Come posso risolvere questo problema?

Answer 1

userei qualcosa di simile, liberamente tratto dal EmacsWiki:

(defun my-compilation-hook() 
    (when (not (get-buffer-window "*compilation*")) 
    (save-selected-window 
     (save-excursion 
     (let* ((w (split-window-vertically)) 
       (h (window-height w))) 
      (select-window w) 
      (switch-to-buffer "*compilation*") 
      (shrink-window (- h compilation-window-height))))))) 
(add-hook 'compilation-mode-hook 'my-compilation-hook) 

Se il buffer *compilation* non è visibile, questo sarà diviso verticalmente la finestra, ridimensionare la finestra appena aperta altezza 10 linee, e aprire il buffer *compilation* in esso.

Answer 2

È possibile personalizzare la variabile compilation-window-height.

Answer 3

La combinazione di codice dal How can I prevent emacs from opening new window for compilation output? e il codice da http://www.emacswiki.org/emacs/CompilationMode, questo è tutto il mio codice per compile, vi offre 4 caratteristiche:

1). Utilizzare compile-again per eseguire automaticamente la stessa compilazione dell'ultima volta, nessun prompt. Se non c'è l'ultima volta, o c'è un argomento prefisso, si comporta come M-x compilare.

2). compile dividerà la finestra corrente (sempre di una certa dimensione), non influenzerà le altre finestre in questo frame.

3). chiuderà automaticamente il buffer *compilation* (finestra) se non ci sono errori, tienilo in caso di errore.

4). evidenzierà la riga di errore e il numero di riga del codice sorgente nel buffer *compilation*, utilizzare M-n/p per navigare ogni errore nel buffer *compilation*, nella riga di errore per passare alla riga del codice.

(require 'compile) 
(setq compilation-last-buffer nil) 
(defun compile-again (ARG) 
    "Run the same compile as the last time. 

If there is no last time, or there is a prefix argument, this acts like M-x compile." 
    (interactive "p") 
    (if (and (eq ARG 1) 
      compilation-last-buffer) 
     (progn 
     (set-buffer compilation-last-buffer) 
     (revert-buffer t t)) 
    (progn 
     (call-interactively 'compile) 
     (setq cur (selected-window)) 
     (setq w (get-buffer-window "*compilation*")) 
     (select-window w) 
     (setq h (window-height w)) 
     (shrink-window (- h 10)) 
     (select-window cur)))) 
(global-set-key (kbd "C-x C-m") 'compile-again) 
(defun my-compilation-hook() 
    "Make sure that the compile window is splitting vertically." 
    (progn 
    (if (not (get-buffer-window "*compilation*")) 
     (progn 
      (split-window-vertically))))) 
(add-hook 'compilation-mode-hook 'my-compilation-hook) 
(defun compilation-exit-autoclose (STATUS code msg) 
    "Close the compilation window if there was no error at all." 
    ;; If M-x compile exists with a 0 
    (when (and (eq STATUS 'exit) (zerop code)) 
    ;; then bury the *compilation* buffer, so that C-x b doesn't go there 
    (bury-buffer) 
    ;; and delete the *compilation* window 
    (delete-window (get-buffer-window (get-buffer "*compilation*")))) 
    ;; Always return the anticipated result of compilation-exit-message-function 
    (cons msg code)) 
(setq compilation-exit-message-function 'compilation-exit-autoclose) 
(defvar all-overlays()) 
(defun delete-this-overlay(overlay is-after begin end &optional len) 
    (delete-overlay overlay) 
) 
(defun highlight-current-line() 
"Highlight current line." 
    (interactive) 
    (setq current-point (point)) 
    (beginning-of-line) 
    (setq beg (point)) 
    (forward-line 1) 
    (setq end (point)) 
    ;; Create and place the overlay 
    (setq error-line-overlay (make-overlay 1 1)) 

    ;; Append to list of all overlays 
    (setq all-overlays (cons error-line-overlay all-overlays)) 

    (overlay-put error-line-overlay 
       'face '(background-color . "red")) 
    (overlay-put error-line-overlay 
       'modification-hooks (list 'delete-this-overlay)) 
    (move-overlay error-line-overlay beg end) 
    (goto-char current-point)) 
(defun delete-all-overlays() 
    "Delete all overlays" 
    (while all-overlays 
    (delete-overlay (car all-overlays)) 
    (setq all-overlays (cdr all-overlays)))) 
(defun highlight-error-lines(compilation-buffer process-result) 
    (interactive) 
    (delete-all-overlays) 
    (condition-case nil 
     (while t 
     (next-error) 
     (highlight-current-line)) 
    (error nil))) 
(setq compilation-finish-functions 'highlight-error-lines)