Impostare Emacs per dividere i buffer fianco a fianco

90

Molte funzioni di Emacs dividono automaticamente lo schermo. Tuttavia, lo fanno tutti in modo tale che le finestre siano una sopra l'altra. C'è un modo per farli dividere in modo che siano invece fianco a fianco per impostazione predefinita?

emacs 
— Nikwin
fonte
12
In questa domanda cambierei l'uso di orizzontale e verticale: direi che il comportamento predefinito è di dividere orizzontalmente (la divisione è una linea orizzontale sullo schermo).
— Skilldrick
22
Cx 3 esegue il comando split-window-horizontally, per il comando che dà finestre affiancate, quindi sto usando lo stesso.
— Nikwin
@Skilldrick "Vertical" e "horizontal" sono ambigui e potrebbero essere interpretati in modo diverso; potrebbero descrivere come è orientato il divisore o come sono orientate le partizioni. La mia normale inclinazione è quella di concordare con la formulazione della domanda originale (cioè, interpreterei normalmente "dividere verticalmente" come "dividere lo spazio verticale").
— jamesdlin

Risposte:

92 
(setq split-height-threshold nil)
(setq split-width-threshold 0)

GNU Emacs Lisp Reference Manual: Scegliere le opzioni della finestra

— offby1
fonte
8
Si noti che questi funzionano a causa del modo in cui influenzano la funzione preferita della finestra divisa e la funzione della finestra divisa sensibilmente impostata su: se leggi i documenti per questo, puoi scoprire come queste variabili impostate influenzano le cose. Per quelli di noi che preferiscono la divisione verticale per impostazione predefinita, possiamo semplicemente usare (setq split-width-threshold nil) che non consente al sistema di dividere le finestre orizzontalmente.
— Kendall Helmstetter Gelner
5
Dopo aver letto i documenti e aver giocato un po ', ho impostato la soglia dell'altezza di divisione su zero e la soglia della larghezza di divisione su 80 in modo che possa prima vedere se può dividere orizzontalmente e solo dopo provare in verticale. Averlo diviso solo verticalmente spesso diventa brutto quando le finestre si restringono.
— Nikwin
Sembra molto plausibile. Tuttavia, questo non funziona per l'integrazione GDB / GUD in emacs. Se ho una sola finestra e avvio il debugger, emacs si divide sempre verticalmente. Esiste un'impostazione specifica per GUD / GDB per questo?
— mefiX
@ Nikwin: Nel mio caso, questa soluzione limita "Cx 4 b" a due finestre a 80 colonne affiancate (il mio attuale spazio sullo schermo può adattarsi solo a quel punto). Invocare "Cx 4 b" una seconda volta non apre una nuova finestra "altro" diviso verticalmente. Invece, apre il buffer sull '"altra" finestra attualmente disponibile. Come posso farlo comportare (prova orizzontalmente poi verticalmente) come hai descritto?
— avendael
Questo non è nel familiare formato Cx che conosco. Come eseguo questi comandi?
— user1552512
6

Due soluzioni qui, usa quella che ti piace:

A: in verticale (sinistra / destra) per impostazione predefinita: 

(setq split-height-threshold nil)
(setq split-width-threshold 0)

B: Dividi automaticamente la finestra verticalmente (sinistra / destra) se la finestra corrente è sufficientemente ampia 

(defun display-new-buffer (buffer force-other-window)
  "If BUFFER is visible, select it.
If it's not visible and there's only one window, split the
current window and select BUFFER in the new window. If the
current window (before the split) is more than 100 columns wide,
split horizontally(left/right), else split vertically(up/down).
If the current buffer contains more than one window, select
BUFFER in the least recently used window.
This function returns the window which holds BUFFER.
FORCE-OTHER-WINDOW is ignored."
  (or (get-buffer-window buffer)
    (if (one-window-p)
        (let ((new-win
               (if (> (window-width) 100)
                   (split-window-horizontally)
                 (split-window-vertically))))
          (set-window-buffer new-win buffer)
          new-win)
      (let ((new-win (get-lru-window)))
        (set-window-buffer new-win buffer)
        new-win))))
;; use display-buffer-alist instead of display-buffer-function if the following line won't work
(setq display-buffer-function 'display-new-buffer)

Metti uno qualsiasi nel tuo .emacs/init.elfile. È possibile modificare il "100" al valore che ti piace, a seconda dello schermo.

Se hai due finestre in un frame e vuoi cambiare il layout da verticale a orizzontale o viceversa, ecco una soluzione:

(defun toggle-window-split ()
  (interactive)
    (if (= (count-windows) 2)
      (let* ((this-win-buffer (window-buffer))
            (next-win-buffer (window-buffer (next-window)))
            (this-win-edges (window-edges (selected-window)))
            (next-win-edges (window-edges (next-window)))
            (this-win-2nd
             (not (and (<= (car this-win-edges)
                        (car next-win-edges))
                    (<= (cadr this-win-edges)
                        (cadr next-win-edges)))))
         (splitter
          (if (= (car this-win-edges)
                 (car (window-edges (next-window))))
              'split-window-horizontally
            'split-window-vertically)))
    (delete-other-windows)
    (let ((first-win (selected-window)))
      (funcall splitter)
      (if this-win-2nd (other-window 1))
      (set-window-buffer (selected-window) this-win-buffer)
      (set-window-buffer (next-window) next-win-buffer)
      (select-window first-win)
      (if this-win-2nd (other-window 1))))))
;; C-x 4 t 'toggle-window-split
(define-key ctl-x-4-map "t" 'toggle-window-split)

Mettilo nel tuo .emacs/init.elfile, usa C-x 4 tper cambiare il layout delle tue finestre.

— CodyChan
fonte
Nella visualizzazione della soluzione quando stavo usando la undo-treepressatura qnon cluse il buffer
— alper
4 
(setq split-height-threshold 0) (setq split-width-threshold 0)

è quello che ho dovuto usare per ottenere il comportamento desiderato (nessuna divisione orizzontale)

— eoj
fonte
1

la semplice risposta di impostare 2 variabili a zero e 0 non ha funzionato per me, quindi ho scritto 2 semplici funzioni: una divide semplicemente la finestra in buffer verticali NX e apre i file denominati (ad esempio) file.1 file.2 .. . file.NX in ognuno e in un altro fa la stessa cosa, tranne che in 2D (righe NY per colonne NX per l'apertura di file f.1 f.2 ... f. [NX * NY]). Per installare, aggiungi questo codice a .emacs:

    (defun grid-files-h (nx wx pfx)
  "Using dotimes, split the window into NX side-by-side buffers of width WX and load files starting with prefix PFX and ending in numbers 1 through NX"
  (let (ox fn k)  ; ox is not used, but fn is used to store the filename, and k to store the index string
    (dotimes (x (- nx 1) ox) ; go through buffers, x goes from 0 to nx-2 and ox is not used here
;     (print x)
      (setq k (number-to-string (+ x 1) ) )  ; k is a string that goes from "1" to "nx-1"
;     (print k)
      (setq fn (concat pfx k) ) ; fn is filename - concatenate prefix with k
;     (print fn)
      (find-file fn) ; open the filename in current buffer
      (split-window-horizontally wx) ; split window (current buffer gets wx-columns)
      (other-window 1) ; switch to the next (right) buffer
      )
    (setq k (number-to-string nx )) ; last (rightmost) buffer gets the "nx" file
    (setq fn (concat pfx k) ) ; fn = "pfx"+"nx"
    (find-file fn ) ; open fn
    (other-window 1) ; go back to the first buffer
    )  
  )

   (defun grid-files-sq (ny wy nx wx pfx)
      "Using dotimes, split the window into NX columns of width WX and NY rows of height WY and load files starting with prefix PFX and ending in numbers 1 through NX*NY"
      (let (oy ox fn k)  
        (dotimes (y ny oy) ; go through rows, y goes from 0 to ny-1 and oy is not used here
          (split-window-vertically wy) ; create this row
          (dotimes (x (- nx 1) ox) ; go through columns, x goes from 0 to nx-2 and ox is not used here
        (setq k (number-to-string (+ 1 (+ x (* y nx) ) ) ) ) ; k must convert 2 indecies (x,y) into one linear one (like sub2ind in matlab)
        (setq fn (concat pfx k) ) ; filename
        (find-file fn ) ; open
        (split-window-horizontally wx) ; create this column in this row (this "cell")
        (other-window 1) ; go to the next buffer on the right 
        )
          (setq k (number-to-string (+ nx (* y nx) ) ) ) ; rightmost buffer in this row needs a file too
          (setq fn (concat pfx k) ) ; filename
          (find-file fn ) ; open
          (other-window 1) ; go to next row (one buffer down)
          )
        )
      )

e poi per usare quello verticale, vado a * scratch * ( C-x b *scratch* RET, C-x 1), digito (grid-files-h 3 20 "file.")then C-x C-e, o se vuoi testare quello quadrato qrid,, C-x 1digita (grid-files-sq 2 15 3 20 "f.")e poi C-x C-ee dovresti vedere qualcosa di simile Griglia 2x3

Questo probabilmente può essere fatto meglio / in modo più efficiente, ma è un inizio e fa quello che mi serve (mostra un mucchio di piccoli file con nome sequenziale). Sentiti libero di migliorare o riutilizzare.

— alexey
fonte
1

Uso regolarmente più frame (finestre OSX) in emacs per diversi progetti. Ecco come ho impostato alcuni frame inizialmente divisi in una finestra sinistra e destra.

  (defun make-maximized-split-frame (name)
    (let (( f (make-frame (list (cons 'name  name))) ))
      (maximize-frame f)
      (split-window (frame-root-window f) nil t)
      ))

  (make-maximized-split-frame "DocRaptor")
  (make-maximized-split-frame "Gauges")
  (make-maximized-split-frame "Instrumental")
— Jason
fonte
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.