Einstellen von Emacs zum Aufteilen von Puffern nebeneinander

90

Viele Emacs-Funktionen teilen den Bildschirm automatisch auf. Sie alle tun dies jedoch so, dass die Fenster übereinander liegen. Gibt es eine Möglichkeit, sie so aufzuteilen, dass sie stattdessen standardmäßig nebeneinander stehen?

emacs 
— Nikwin
quelle
12
Ich würde in dieser Frage die Verwendung von horizontal und vertikal vertauschen - ich würde sagen, das Standardverhalten ist horizontales Teilen (das Teilen ist eine horizontale Linie über den Bildschirm).
— Skilldrick
22
Cx 3 führt den Befehl split-window-horizontal für den Befehl aus, der nebeneinander liegende Fenster angibt, daher verwende ich denselben.
— Nikwin
@Skilldrick "Vertikal" und "Horizontal" sind mehrdeutig und können unterschiedlich interpretiert werden. Sie könnten beschreiben, wie der Teiler ausgerichtet ist oder wie die Partitionen ausgerichtet sind. Meine normale Neigung ist es, dem Wortlaut der ursprünglichen Frage zuzustimmen (das heißt, ich würde "vertikal teilen" normalerweise als "vertikalen Raum teilen" interpretieren).
— Jamesdlin

Antworten:

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

GNU Emacs Lisp Referenzhandbuch: Auswählen von Fensteroptionen

— offby1
quelle
8
Beachten Sie, dass diese Funktionen funktionieren, da sie sich auf die Split-Window-Preferred-Funktion und die Split-Window-Sensible-Funktion auswirken. Wenn Sie die entsprechenden Dokumente lesen, können Sie herausfinden, wie sich diese Variablen auf die Dinge auswirken. Für diejenigen von uns, die standardmäßig die vertikale Aufteilung bevorzugen, können wir nur (setq split-width-schwelle nil) verwenden, wodurch das System Fenster nicht horizontal aufteilen kann.
— Kendall Helmstetter Gelner
5
Nachdem ich die Dokumente gelesen und ein wenig herumgespielt habe, habe ich den Schwellenwert für die geteilte Höhe auf Null und den Schwellenwert für die geteilte Breite auf 80 gesetzt, damit zuerst geprüft wird, ob er horizontal geteilt werden kann, und erst dann vertikal versucht wird. Wenn es nur vertikal geteilt wird, wird es oft hässlich, wenn die Fenster zu eng werden.
— Nikwin
Das klingt sehr plausibel. Dies funktioniert jedoch nicht für die GDB / GUD-Integration in Emacs. Wenn ich ein einzelnes Fenster habe und den Debugger starte, wird emacs immer vertikal geteilt. Gibt es dafür eine GUD / GDB-spezifische Einstellung?
— MefiX
@Nikwin: In meinem Fall beschränkt diese Lösung "Cx 4 b" auf zwei Fenster mit 80 Spalten nebeneinander (meine aktuelle Bildschirmfläche kann nur so viel passen). Wenn Sie "Cx 4 b" ein zweites Mal aufrufen, wird kein neues vertikal geteiltes "anderes" Fenster geöffnet. Stattdessen wird der Puffer im "anderen" aktuell verfügbaren Fenster geöffnet. Wie kann ich dafür sorgen, dass es sich so verhält (versuchen Sie es horizontal und dann vertikal), wie Sie es beschrieben haben?
— Avendael
Dies ist nicht in dem bekannten Cx-Format, das ich kenne. Wie führe ich diese Befehle aus?
— user1552512
5

Verwenden Sie hier zwei beliebige Lösungen:

A: Standardmäßig vertikal (links / rechts): 

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

B: Fenster automatisch vertikal teilen (links / rechts), wenn das aktuelle Fenster breit genug ist 

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

Setze jemanden in dich ein .emacs/init.el Datei Datei ein. Sie können die "100" je nach Bildschirm auf den gewünschten Wert ändern.

Wenn Sie zwei Fenster in einem Rahmen haben und das Layout von vertikal nach horizontal oder umgekehrt ändern möchten, finden Sie hier eine Lösung:

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

Fügen Sie es in Ihre .emacs/init.elDatei ein. Verwenden Sie C-x 4 tdiese Option, um das Layout Ihrer Fenster umzuschalten.

— CodyChan
quelle
In der Lösungsansicht, als ich das undo-treeDrücken qverwendet habe, wird der Puffer nicht geschlossen
— alper
4 
(setq split-height-threshold 0) (setq split-width-threshold 0)

ist das, was ich verwenden musste, um das gewünschte Verhalten zu erhalten (keine horizontale Aufteilung)

— eoj
quelle
1

Die einfache Antwort, 2 Variablen auf null und 0 zu setzen, hat bei mir nicht funktioniert, daher habe ich zwei einfache Funktionen geschrieben: Eine teilt das Fenster einfach in vertikale NX-Puffer auf und öffnet Dateien mit dem Namen (zum Beispiel) file.1 file.2 .. . file.NX in jedem und einem anderen macht das gleiche Denken, außer in 2D (NY-Zeilen nach NX-Spalten zum Öffnen von Dateien f.1 f.2 ... f. [NX * NY]). Fügen Sie diesen Code zur Installation zu .emacs hinzu:

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

und dann die vertikalen zu verwenden, gehe ich zu * scratch * ( C-x b *scratch* RET, C-x 1), gibt (grid-files-h 3 20 "file.")dann C-x C-e, oder wenn Sie wollen den Platz qrid ein testen, C-x 1geben Sie in (grid-files-sq 2 15 3 20 "f.")und dannC-x C-e , und Sie sollten sehen , so etwas wie 2x3 Gitter

Dies kann wahrscheinlich besser / effizienter gemacht werden, aber es ist ein Anfang und es macht das, was ich brauche (um eine Reihe von nacheinander benannten kleinen Dateien anzuzeigen). Fühlen Sie sich frei zu verbessern oder wiederzuverwenden.

— alexey
quelle
1

Ich verwende regelmäßig mehrere Frames (OSX-Fenster) in Emacs für verschiedene Projekte. Hier ist, wie ich ein paar Frames einrichte, die anfänglich in ein linkes und ein rechtes Fenster aufgeteilt sind.

  (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
quelle
Durch die Nutzung unserer Website bestätigen Sie, dass Sie unsere Cookie-Richtlinie und Datenschutzrichtlinie gelesen und verstanden haben.
Licensed under cc by-sa 3.0 with attribution required.