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

90

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?

emacs 
— Nikwin
source
12
Je voudrais permuter l'utilisation de l'horizontale et de la verticale dans cette question - je dirais que le comportement par défaut est de diviser horizontalement (la division est une ligne horizontale sur l'écran).
— Skilldrick
22
Cx 3 exécute la commande split-window-horizontalement, pour la commande qui donne des fenêtres côte à côte, donc j'utilise la même chose.
— Nikwin
@Skilldrick "Vertical" et "horizontal" sont ambigus et pourraient être interprétés différemment; ils pourraient décrire comment le diviseur est orienté ou comment les partitions sont orientées. Mon inclination normale est d'être d'accord avec le libellé de la question initiale (c'est-à-dire que j'interpréterais normalement «divisé verticalement» comme «diviser l'espace vertical»).
— jamesdlin

Réponses:

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

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

— offby1
source
8
Notez que ceux-ci fonctionnent en raison de la façon dont ils affectent la fonction de partage de fenêtre préférée et la fonction de division de fenêtre sensible qui est définie sur - si vous lisez la documentation pour cela, vous pouvez découvrir comment ces variables définies affectent les choses. Pour ceux d'entre nous qui préfèrent le fractionnement vertical par défaut, nous pouvons simplement utiliser (setq split-width-threshold nil) qui ne permet pas au système de fractionner les fenêtres horizontalement.
— Kendall Helmstetter Gelner
5
Après avoir lu la documentation et joué un peu, j'ai défini le seuil de hauteur de division sur zéro et le seuil de largeur de division sur 80 afin qu'il puisse d'abord voir s'il peut se diviser horizontalement et ensuite seulement essayer verticalement. Le fait de ne le diviser que verticalement devient souvent laid à mesure que les fenêtres deviennent trop étroites.
— Nikwin
Cela semble très plausible. Cependant, cela ne fonctionne pas pour l'intégration GDB / GUD dans emacs. Si j'ai une seule fenêtre pour démarrer le débogueur, emacs se divise toujours verticalement. Existe-t-il un paramètre spécifique à GUD / GDB pour cela?
— mefiX
@Nikwin: Dans mon cas, cette solution limite "Cx 4 b" à deux fenêtres de 80 colonnes côte à côte (mon écran actuel ne peut convenir qu'à cela). Invoquer "Cx 4 b" une seconde fois n'ouvre pas une nouvelle fenêtre "autre" fractionnée verticalement. Au lieu de cela, il ouvre le tampon sur «l'autre» fenêtre actuellement disponible. Comment puis-je le faire se comporter (essayez horizontalement puis verticalement) comme vous l'avez décrit?
— avendael
Ce n'est pas dans le format familier Cx que je connais. Comment exécuter ces commandes?
— user1552512
6

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.

— CodyChan
source
Sur la vue de la solution lorsque j'utilisais le undo-treepressage qne cluse pas le tampon
— alper le
4 
(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)

— eoj
source
1

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 Grille 2x3

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.

— Alexey
source
1

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")
— Jason
source
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.