Configurando o Emacs para dividir buffers lado a lado

90

Muitas funções do Emacs dividem a tela automaticamente. No entanto, todos eles fazem isso de forma que as janelas fiquem uma em cima da outra. Existe alguma maneira de separá-los de forma que fiquem lado a lado por padrão?

emacs 
— Nikwin
fonte
12
Eu trocaria o uso de horizontal e vertical nesta questão - eu diria que o comportamento padrão é dividir horizontalmente (a divisão é uma linha horizontal na tela).
— Skilldrick
22
Cx 3 executa o comando split-window-horizontalally, para o comando que dá janelas lado a lado, então estou usando o mesmo.
— Nikwin
@Skilldrick "Vertical" e "horizontal" são ambíguos e podem ser interpretados de maneira diferente; eles podem descrever como o divisor é orientado ou como as partições são orientadas. Minha inclinação normal é concordar com o texto da pergunta original (isto é, eu normalmente interpretaria "dividir verticalmente" como "dividir o espaço vertical").
— Jamesdlin

Respostas:

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

GNU Emacs Lisp Manual de Referência: Escolhendo Opções de Janela

— offby1
fonte
8
Observe que eles funcionam por causa de como afetam a função de divisão de janela preferencial e a função de divisão de janela sensível que está definida para - se você ler os documentos para isso, poderá descobrir como essas variáveis ​​definidas afetam as coisas. Para aqueles de nós que preferem a divisão vertical por padrão, podemos apenas usar (setq split-width-threshold nil) que não permite que o sistema divida as janelas horizontalmente.
— Kendall Helmstetter Gelner
5
Depois de ler a documentação e brincar um pouco, defini limite de altura de divisão como nulo e limite de largura de divisão como 80 para que primeiro veja se pode dividir horizontalmente e só então tente verticalmente. Tê-la apenas dividida verticalmente, muitas vezes só fica feia quando as janelas ficam estreitas.
— Nikwin
Isso parece muito plausível. No entanto, isso não está funcionando para integração GDB / GUD no emacs. Se eu tiver uma única janela e iniciar o depurador, o emacs sempre se divide verticalmente. Existe alguma configuração específica de GUD / GDB para isso?
— mefiX de
@Nikwin: No meu caso, esta solução limita "Cx 4 b" a duas janelas de 80 colunas lado a lado (meu estado atual da tela só pode caber isso). Invocar "Cx 4 b" uma segunda vez não abre uma nova janela "outra" dividida verticalmente. Em vez disso, ele abre o buffer na "outra" janela atualmente disponível. Como posso fazer com que ele se comporte (tente horizontalmente e depois verticalmente) conforme você descreveu?
— avendael
Este não é o formato Cx familiar que eu conheço. Como faço para executar esses comandos?
— user1552512
6

Duas soluções aqui, use qualquer uma de sua preferência:

R: Verticalmente (esquerda / direita) por padrão: 

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

B: Dividir automaticamente a janela verticalmente (esquerda / direita) se a janela atual for grande o suficiente 

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

Coloque qualquer um em você .emacs/init.el arquivo. Você pode alterar o "100" para o valor que desejar, dependendo da tela.

Se você tem duas janelas em um quadro e deseja alterar o layout de vertical para horizontal ou vice-versa, aqui está uma solução:

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

Coloque-o em seu .emacs/init.elarquivo, use C-x 4 tpara alternar o layout de suas janelas.

— CodyChan
fonte
Na visão da solução, quando eu estava usando a undo-treeprensagem qnão cluse o buffer
— alper
4 
(setq split-height-threshold 0) (setq split-width-threshold 0)

é o que eu tive que usar para obter o comportamento desejado (sem divisão horizontal)

— eoj
fonte
1

a resposta simples de definir 2 variáveis ​​como nulo e 0 não funcionou para mim, então eu escrevi 2 funções simples: uma apenas divide a janela em buffers verticais NX e abre arquivos chamados (por exemplo) arquivo.1 arquivo.2 .. . file.NX em cada um e em outro faz o mesmo, exceto em 2D (linhas NY por colunas NX para abrir arquivos f.1 f.2 ... f. [NX * NY]). Para instalar, adicione este código 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 então para usar o vertical, eu vou para * scratch * ( C-x b *scratch* RET, C-x 1), digito (grid-files-h 3 20 "file.")então C-x C-e, ou se você quiser testar o qrid quadrado,, C-x 1digito (grid-files-sq 2 15 3 20 "f.")e entãoC-x C-e e você deve ver algo como Grade 2x3

Isso provavelmente pode ser feito melhor / mais eficientemente, mas é um começo e faz o que eu preciso fazer (exibir um monte de pequenos arquivos nomeados sequencialmente). Sinta-se à vontade para melhorar ou reutilizar.

— alexey
fonte
1

Eu uso vários frames (janelas OSX) no emacs regularmente para diferentes projetos. Veja como eu configuro alguns quadros inicialmente divididos em uma janela esquerda e direita.

  (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
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.