So tauschen Sie die Puffer in 2 Windows-Emacs aus

Ich benutze Emacs Ich finde, dass ich manchmal 2 Dateien in 2 Fenster getrennt habe.

Zum Beispiel: Ich öffne 1 Datei mit C-x C-f file1.c RET

und ich teilte den Rahmen in zwei Fenster: C-x 3

Ich öffne dann eine andere Datei C-x C-f file2.c RET

Ich habe also 2 Dateien:

Fenster 1 (links) file1.c

Fenster 2 (rechts) file2.c

Ich frage mich, ob es eine Tastenkombination gibt, um die Dateien auszutauschen. Normalerweise arbeite ich gerne am linken Fenster, wenn ich 2 Fenster habe. Ich weiß, dass ich C-x oden Cursor leicht in das rechte Fenster bewegen kann .

Ich frage mich jedoch nur, ob ich die Dateien so austauschen kann, dass sie file2.csich im linken und file1.cim rechten Fenster befinden.

Ich benutze dafür Buffer-Move . Wenn Sie nun an dem Puffer auf der linken Seite arbeiten, wird er durch Aufrufen von 'buf-move-right' gegen den Puffer auf der rechten Seite ausgetauscht. Ich denke, das ist was du willst.

Die Transponierungsrahmenbibliothek bietet einen ziemlich umfassenden Satz von Funktionen zum Spiegeln oder Drehen der Fensteranordnungen in Rahmen.

M-x flop-frame RET tut, was diese spezielle Frage braucht.

Die folgenden Diagramme stammen aus dem Kommentar in der Bibliothek (und ihrer EmacsWiki-Seite):

‘transpose-frame’ … Swap x-direction and y-direction

       +------------+------------+      +----------------+--------+
       |            |     B      |      |        A       |        |
       |     A      +------------+      |                |        |
       |            |     C      |  =>  +--------+-------+   D    |
       +------------+------------+      |   B    |   C   |        |
       |            D            |      |        |       |        |
       +-------------------------+      +--------+-------+--------+

‘flip-frame’ … Flip vertically

       +------------+------------+      +------------+------------+
       |            |     B      |      |            D            |
       |     A      +------------+      +------------+------------+
       |            |     C      |  =>  |            |     C      |
       +------------+------------+      |     A      +------------+
       |            D            |      |            |     B      |
       +-------------------------+      +------------+------------+

‘flop-frame’ … Flop horizontally

       +------------+------------+      +------------+------------+
       |            |     B      |      |     B      |            |
       |     A      +------------+      +------------+     A      |
       |            |     C      |  =>  |     C      |            |
       +------------+------------+      +------------+------------+
       |            D            |      |            D            |
       +-------------------------+      +-------------------------+

‘rotate-frame’ … Rotate 180 degrees

       +------------+------------+      +-------------------------+
       |            |     B      |      |            D            |
       |     A      +------------+      +------------+------------+
       |            |     C      |  =>  |     C      |            |
       +------------+------------+      +------------+     A      |
       |            D            |      |     B      |            |
       +-------------------------+      +------------+------------+

‘rotate-frame-clockwise’ … Rotate 90 degrees clockwise

       +------------+------------+      +-------+-----------------+
       |            |     B      |      |       |        A        |
       |     A      +------------+      |       |                 |
       |            |     C      |  =>  |   D   +--------+--------+
       +------------+------------+      |       |   B    |   C    |
       |            D            |      |       |        |        |
       +-------------------------+      +-------+--------+--------+

‘rotate-frame-anti-clockwise’ … Rotate 90 degrees anti-clockwise

       +------------+------------+      +--------+--------+-------+
       |            |     B      |      |   B    |   C    |       |
       |     A      +------------+      |        |        |       |
       |            |     C      |  =>  +--------+--------+   D   |
       +------------+------------+      |        A        |       |
       |            D            |      |                 |       |
       +-------------------------+      +-----------------+-------+

In der Emacs 26.1 NEWS-Datei befindet sich der folgende Eintrag:

+++
*** New command 'window-swap-states' swaps the states of two live
windows.

Was scheint ähnliche Funktionen zu bieten crux-transpose-windows, kann aber auch einige Höhen / Breiten-Transpositionen durchführen?

Wenn Sie Prelude verwenden , können Sie einfach C-c s( prelude-swap-windows) verwenden. Aus der Prelude-Dokumentation:

C-c sführt den Befehl crux-swap-windows(gefunden in prelude-mode-map) aus, der ein Alias ​​für crux-transpose-windowsin crux.el ist .

Mir ist keine eingebaute Funktion bekannt, die dies tut.

Es scheint jedoch nicht allzu schwierig zu sein, ein Elisp dafür zu zaubern. Der Teufel steckt jedoch im Detail.

(defun swap-buffers-in-windows ()
  "Put the buffer from the selected window in next window, and vice versa"
  (interactive)
  (let* ((this (selected-window))
     (other (next-window))
     (this-buffer (window-buffer this))
     (other-buffer (window-buffer other)))
    (set-window-buffer other this-buffer)
    (set-window-buffer this other-buffer)
    )
  )

Insbesondere kann dies nicht das tun, was Sie sich wünschen, wenn es darum geht, wo das Caret landet. Sie müssen jedoch zuerst sagen, was Sie möchten: p

Wenn Sie das Vorspiel haben, können Sie das Ass-Fenster mit verwenden S-w. Von dort aus können Sie viele Dinge tun, die in ihren Dokumenten aufgeführt sind .

Sie können auch beginnen, indem Sie ace-window aufrufen und dann entscheiden, die Aktion auf Löschen oder Tauschen usw. umzustellen. Standardmäßig lauten die Bindungen:

x - Fenster löschen

m - Fenster tauschen (verschieben)

c - Fenster fair teilen, entweder vertikal oder horizontal

v - Fenster vertikal teilen

b - Fenster horizontal teilen

n - Wählen Sie das vorherige Fenster aus

...

So wäre es S-w m

Das folgende Code-Snippet kann den Puffer wechseln.

(defun ab/switch-buffer-each-other (arg)
  "switch current buffer with other window buffer 
   right-2-left and up-2-down"
  (interactive "p")
  (cond
   ((windmove-find-other-window 'right) (buf-move-right))
   ((windmove-find-other-window 'left) (buf-move-left))
   ((windmove-find-other-window 'up) (buf-move-up))
   ((windmove-find-other-window 'down) (buf-move-down)))
(message "switch buffer done"))

Ich würde es erfinden, Datei 2 an der gewünschten Stelle zu öffnen, dh nachdem Sie cx 3 gedrückt haben, bewegen Sie den Cursor mit cx o, bevor Sie zur zweiten Datei navigieren.