Configuración de Emacs para dividir búferes uno al lado del otro

90

Muchas funciones de Emacs dividen automáticamente la pantalla. Sin embargo, todos lo hacen de manera que las ventanas estén una encima de la otra. ¿Hay alguna forma de dividirlos de manera que estén uno al lado del otro de forma predeterminada?

emacs 
— Nikwin
fuente
12
Cambiaría el uso de horizontal y vertical en esta pregunta; diría que el comportamiento predeterminado es dividir horizontalmente (la división es una línea horizontal en la pantalla).
— Skilldrick
22
Cx 3 ejecuta el comando split-window-horizontally, para el comando que da ventanas una al lado de la otra, así que estoy usando el mismo.
— Nikwin
@Skilldrick "Vertical" y "horizontal" son ambiguos y podrían interpretarse de manera diferente; podrían describir cómo está orientado el divisor o cómo están orientadas las particiones. Mi inclinación normal es estar de acuerdo con la redacción de la pregunta original (es decir, normalmente interpretaría "dividir verticalmente" como "dividir el espacio vertical").
— jamesdlin

Respuestas:

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

GNU Emacs Lisp Reference Manual: Elegir opciones de ventana

— offby1
fuente
8
Tenga en cuenta que estos funcionan debido a la forma en que afectan la función preferida de ventana dividida y la función sensiblemente dividida de ventana que está configurada; si lee los documentos para eso, puede descubrir cómo estas variables configuradas afectan las cosas. Para aquellos de nosotros que preferimos la división vertical por defecto, podemos usar (setq split-width -reshold nil) que no permite que el sistema divida las ventanas horizontalmente.
— Kendall Helmstetter Gelner
5
Después de leer los documentos y jugar un poco, establecí el umbral de altura dividida en cero y el umbral de ancho dividido en 80 para que primero vea si se puede dividir horizontalmente y solo luego intentarlo verticalmente. Tenerlo solo dividido verticalmente a menudo se vuelve feo a medida que las ventanas se vuelven demasiado estrechas.
— Nikwin
Esto suena muy plausible. Sin embargo, esto no funciona para la integración de GDB / GUD en emacs. Si tengo una sola ventana y inicio el depurador, emacs siempre se divide verticalmente. ¿Hay alguna configuración específica de GUD / GDB para eso?
— mefiX
@Nikwin: En mi caso, esta solución limita "Cx 4 b" a dos ventanas de 80 columnas una al lado de la otra (mi espacio de pantalla actual solo puede ajustarse a esa cantidad). Invocar "Cx 4 b" por segunda vez no abre una nueva ventana dividida verticalmente "otro". En su lugar, abre el búfer en la "otra" ventana disponible actualmente. ¿Cómo puedo hacer que se comporte (intente horizontalmente y luego verticalmente) como lo ha descrito?
— avendael
Esto no está en el formato Cx algo familiar que conozco. ¿Cómo ejecuto estos comandos?
— user1552512
6

Aquí hay dos soluciones, use la que desee:

R: Verticalmente (izquierda / derecha) por defecto: 

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

B: dividir automáticamente la ventana verticalmente (izquierda / derecha) si la ventana actual es lo suficientemente amplia 

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

Ponga cualquiera en su .emacs/init.elarchivo. Puede cambiar el "100" al valor que desee, dependiendo de su pantalla.

Si tiene dos ventanas en un marco y desea cambiar el diseño de vertical a horizontal o viceversa, aquí tiene una solución:

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

Ponlo en tu .emacs/init.elarchivo, utilízalo C-x 4 tpara alternar el diseño de tus ventanas.

— CodyChan
fuente
En la vista de solución cuando estaba usando undo-treepresionando qno cluse el búfer
— alper
4 
(setq split-height-threshold 0) (setq split-width-threshold 0)

es lo que tuve que usar para obtener el comportamiento deseado (sin división horizontal)

— eoj
fuente
1

la respuesta simple de establecer 2 variables en cero y 0 no funcionó para mí, así que escribí 2 funciones simples: una simplemente divide la ventana en búferes verticales NX y abre archivos llamados (por ejemplo) archivo.1 archivo.2 .. .archivo.NX en cada uno y otro piensa lo mismo, excepto que lo hace en 2D (filas NY por columnas NX para abrir archivos f.1 f.2 ... f. [NX * NY]). Para instalar, agregue 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)
          )
        )
      )

y luego utilizar el vertical, voy a cero * * ( C-x b *scratch* RET, C-x 1), escriba (grid-files-h 3 20 "file.")a continuación C-x C-e, o si desea poner a prueba la qrid cuadrado, C-x 1, escriba (grid-files-sq 2 15 3 20 "f.")a continuación, C-x C-ey usted debería ver algo como Cuadrícula 2x3

Esto probablemente se puede hacer mejor / más eficientemente, pero es un comienzo y hace lo que necesito que haga (mostrar un montón de archivos pequeños con nombres secuenciales). Siéntase libre de mejorar o reutilizar.

— alexey
fuente
1

Utilizo varios marcos (ventanas OSX) en emacs con regularidad para diferentes proyectos. Así es como configuro algunos cuadros inicialmente divididos en una ventana izquierda y derecha.

  (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
fuente
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.