Come scambiare i buffer in 2 windows emacs

Sto usando emacs, trovo che a volte ho 2 file separati in 2 finestre.

Ad esempio: apro 1 file usando C-x C-f file1.c RET

e ho diviso la cornice in due finestre: C-x 3

Quindi apro un altro file C-x C-f file2.c RET

Quindi ho 2 file:

finestra 1 (sinistra) file1.c

finestra 2 (destra) file2.c

Mi chiedo se esiste una combinazione di tasti per scambiare i file? Normalmente mi piace lavorare sulla finestra di sinistra quando ho 2 finestre. So che posso facilmente C-x ospostare il cursore nella finestra di destra.

Tuttavia, mi chiedo solo se posso scambiare i file in modo che file2.csiano nella finestra di sinistra e file1.cnella finestra di destra?

Uso il movimento del buffer per questo. Ora se stai lavorando sul buffer sul lato sinistro, chiamando 'buf-move-right' lo scambierà con quello a destra. Immagino sia quello che vuoi.

La libreria Transpose-frame fornisce un insieme piuttosto completo di funzioni per capovolgere o ruotare le disposizioni delle finestre in frame.

M-x flop-frame RET fa ciò di cui ha bisogno questa particolare domanda.

I seguenti diagrammi sono tratti dal commento nella libreria (e dalla sua pagina EmacsWiki):

‘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            |      |                 |       |
       +-------------------------+      +-----------------+-------+

Nel file Emacs 26.1 NEWS c'è la seguente voce:

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

Quale sembra offrire funzionalità simili crux-transpose-windowsma può anche eseguire alcune trasposizioni altezza / larghezza?

Se stai usando Prelude puoi semplicemente usare C-c s( prelude-swap-windows). Dalla documentazione di Prelude:

C-c sesegue il comando crux-swap-windows(trovato in prelude-mode-map), che è un alias per crux-transpose-windowsin crux.el .

Non sono a conoscenza di alcuna funzione incorporata che lo faccia.

Tuttavia, non sembra troppo difficile preparare qualche elisp per farlo. Il diavolo è però nei dettagli.

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

In particolare, questo potrebbe non fare ciò che desideri rispetto a dove finisce il cursore. Tuttavia, devi prima dire quello che vuoi: p

Se hai preludio, puoi usare asso-finestra con S-w. Da lì puoi fare molte cose elencate nei loro documenti .

Puoi anche iniziare chiamando ace-window e poi decidere di cambiare l'azione per eliminare o scambiare ecc. Per impostazione predefinita le associazioni sono:

x - elimina la finestra

m - finestra di scambio (spostamento)

c - divide la finestra in modo equo, verticalmente o orizzontalmente

v - finestra divisa verticalmente

b - finestra divisa orizzontalmente

n - seleziona la finestra precedente

...

Così sarebbe S-w m

Il seguente frammento di codice può cambiare il buffer.

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

Riuscirei ad aprire il file # 2 nella posizione desiderata, cioè dopo aver premuto cx 3, sposta il cursore con cx o prima di navigare al secondo file.