Ustawienie Emacsa na dzielenie buforów obok siebie

92

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?

emacs 
— Nikwin
źródło
12
Zamieniłbym użycie poziomego i pionowego w tym pytaniu - powiedziałbym, że domyślnym zachowaniem jest podział w poziomie (podział to pozioma linia na ekranie).
— Skilldrick
22
Cx 3 uruchamia polecenie split-window-Horizontal, dla polecenia, które daje okna obok siebie, więc używam tego samego.
— Nikwin
@Skilldrick „Pionowo” i „poziomo” są niejednoznaczne i mogą być różnie interpretowane; mogliby opisać, w jaki sposób zorientowana jest przegroda lub jak zorientowane są przegrody. Moją normalną skłonnością jest zgodzić się ze sformułowaniem pierwotnego pytania (to znaczy, normalnie zinterpretowałbym „podzielenie w pionie” jako „podzielenie przestrzeni pionowej”).
— jamesdlin

Odpowiedzi:

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

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

— offby1
źródło
8
Zauważ, że działają one z powodu tego, jak wpływają na preferowaną funkcję podzielonego okna i rozsądną funkcję podzielonego okna, która jest ustawiona na - jeśli przeczytasz dokumentację, możesz dowiedzieć się, jak te zmienne wpływają na rzeczy. Dla tych z nas, którzy domyślnie preferują podział w pionie, możemy po prostu użyć (setq split-width-threshold nil), które nie pozwala systemowi na dzielenie okien w poziomie.
— Kendall Helmstetter Gelner
5
Po przeczytaniu dokumentów i pobawieniu się trochę, ustawiłem próg podziału wysokości na zero, a próg podziału na 80, aby najpierw zobaczył, czy można go podzielić w poziomie, a dopiero potem spróbować w pionie. Dzielenie go tylko w pionie często staje się brzydkie, gdy okna stają się wąskie.
— Nikwin,
Brzmi to bardzo wiarygodnie. Jednak to nie działa w przypadku integracji GDB / GUD w emacsie. Jeśli mam jedno okno i uruchom debugera, emacs zawsze dzieli w pionie. Czy jest do tego jakieś ustawienie specyficzne dla GUD / GDB?
— mefiX
@Nikwin: W moim przypadku to rozwiązanie ogranicza "Cx 4 b" do dwóch 80-kolumnowych okien obok siebie (moja obecna powierzchnia ekranu może pasować tylko tyle). Wywołanie „Cx 4 b” po raz drugi nie otwiera nowego, podzielonego pionowo „innego” okna. Zamiast tego otwiera bufor w „innym” aktualnie dostępnym oknie. Jak mogę sprawić, by zachowywał się (spróbuj w poziomie, a następnie w pionie) tak, jak opisałeś?
— avendael
To nie jest w znanym mi formacie Cx. Jak wykonać te polecenia?
— user1552512
8

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.

— CodyChan
źródło
Widok rozwiązania, gdy używałem undo-treetłoczenia q, nie zamyka bufora
— alper
4 
(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)

— eoj
źródło
1

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

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.

— Alexey
źródło
1

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")
— Jason
źródło
Korzystając z naszej strony potwierdzasz, że przeczytałeś(-aś) i rozumiesz nasze zasady używania plików cookie i zasady ochrony prywatności.
Licensed under cc by-sa 3.0 with attribution required.