Ustawienie Emacsa na dzielenie buforów obok siebie

Wiele funkcji Emacsa automatycznie dzieli ekran. Jednak wszystkie robią to w taki sposób, że okna znajdują się jedno na drugim. Czy istnieje sposób, aby podzielić je tak, aby zamiast tego były domyślnie obok siebie?

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

Podręcznik GNU Emacs Lisp: Wybór opcji okna

Dwa rozwiązania tutaj, użyj dowolnego, które lubisz:

O: Domyślnie pionowo (w lewo / w prawo):

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

B: Automatycznie podziel okno w pionie (w lewo / w prawo), jeśli bieżące okno jest wystarczająco szerokie

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

Umieść kogokolwiek w swoim .emacs/init.elpliku. Możesz zmienić wartość „100” na żądaną, w zależności od ekranu.

Jeśli masz dwa okna w jednej ramce i chcesz zmienić układ z pionowego na poziomy lub odwrotnie, oto rozwiązanie:

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

Umieść go w swoim .emacs/init.elpliku, użyj, C-x 4 taby przełączyć układ okien.

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

jest tym, czego musiałem użyć, aby uzyskać pożądane zachowanie (bez podziału poziomego)

Czasami potrzebujemy zmiany między poziomą a pionową zgodnie z bieżącym wyświetlaniem i naszymi wymaganiami (więcej linii lub więcej kolumn).

Polecam świetny ToggleWindowSplit i przypisuję klawisz „Cc y”

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

prosta odpowiedź polegająca na ustawieniu 2 zmiennych na zero i 0 nie zadziałała dla mnie, więc napisałem 2 proste funkcje: jedna po prostu dzieli okno na bufory pionowe NX i otwiera pliki o nazwie (na przykład) plik.1 plik.2 .. . file.NX w każdym i innym myśli to samo, z wyjątkiem tego, że robi to w 2D (wiersze NY przez kolumny NX do otwierania plików f.1 f.2 ... f. [NX * NY]). Aby zainstalować, dodaj ten kod do .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)
          )
        )
      )

a następnie, aby użyć pionowego, przechodzę do * scratch * ( C-x b *scratch* RET, C-x 1), wpisuję (grid-files-h 3 20 "file.")następnie C-x C-e, lub jeśli chcesz przetestować kwadratowy qrid C-x 1, wpisz (grid-files-sq 2 15 3 20 "f.")i wtedy C-x C-ei powinieneś zobaczyć coś takiego

Prawdopodobnie można to zrobić lepiej / wydajniej, ale to początek i robi to, czego potrzebuję (wyświetla kilka kolejno nazwanych małych plików). Zapraszam do ulepszania lub ponownego wykorzystania.

Używam wielu ramek (okien OSX) w emacs regularnie dla różnych projektów. Oto, jak skonfigurować kilka ramek początkowo podzielonych na lewe i prawe okno.

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