Configurer Emacs pour diviser les tampons côte à côte

De nombreuses fonctions Emacs divisent automatiquement l'écran. Cependant, ils le font tous de manière à ce que les fenêtres se superposent. Existe-t-il un moyen de les séparer de manière à ce qu'ils soient côte à côte par défaut?

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

Manuel de référence GNU Emacs Lisp: Choix des options de fenêtre

Deux solutions ici, utilisez celle que vous aimez:

A: verticalement (gauche / droite) par défaut:

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

B: diviser automatiquement la fenêtre verticalement (gauche / droite) si la fenêtre actuelle est suffisamment large

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

Mettez n'importe lequel dans votre .emacs/init.elfichier. Vous pouvez changer le "100" à la valeur que vous aimez, selon votre écran.

Si vous avez deux fenêtres dans un cadre et que vous souhaitez changer la disposition de la verticale à l'horizontale ou vice versa, voici une solution:

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

Mettez-le dans votre .emacs/init.elfichier, utilisez C-x 4 tpour basculer la disposition de vos fenêtres.

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

est ce que j'ai dû utiliser pour obtenir le comportement souhaité (pas de division horizontale)

Parfois, nous avons besoin de changer entre Horizontal et Vertical en fonction de l'affichage actuel et de nos besoins (plus de lignes ou plus de colonnes).

Je recommande le grand ToggleWindowSplit , et je lie la clé à "Cc y"

http://www.emacswiki.org/emacs/ToggleWindowSplit

la réponse simple de définir 2 variables à nil et 0 n'a pas fonctionné pour moi, j'ai donc écrit 2 fonctions simples: on divise simplement la fenêtre en tampons verticaux NX et ouvre les fichiers nommés (par exemple) file.1 file.2 .. . file.NX dans chacun d'eux fait la même chose, sauf en 2D (lignes NY par colonnes NX pour ouvrir des fichiers f.1 f.2 ... f. [NX * NY]). Pour installer, ajoutez ce code à .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)
          )
        )
      )

puis pour utiliser le vertical, je vais à * scratch * ( C-x b *scratch* RET, C-x 1), tapez (grid-files-h 3 20 "file.")alors C-x C-e, ou si vous voulez tester le carré qrid C-x 1, tapez (grid-files-sq 2 15 3 20 "f.")et puis C-x C-evous devriez voir quelque chose comme

Cela peut probablement être fait mieux / plus efficacement, mais c'est un début et cela fait ce que j'ai besoin de faire (afficher un tas de petits fichiers nommés séquentiellement). N'hésitez pas à améliorer ou réutiliser.

J'utilise régulièrement plusieurs cadres (fenêtres OSX) dans emacs pour différents projets. Voici comment j'ai configuré quelques images initialement divisées en une fenêtre gauche et droite.

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