Cómo intercambiar los búferes en 2 windows emacs

Estoy usando emacs y encuentro que a veces tengo 2 archivos separados en 2 ventanas.

Por ejemplo: abro 1 archivo usando C-x C-f file1.c RET

y dividí el marco en dos ventanas: C-x 3

Luego abro otro archivo C-x C-f file2.c RET

Entonces tengo 2 archivos:

ventana 1 (izquierda) file1.c

ventana 2 (derecha) file2.c

Me pregunto si hay alguna combinación de teclas para intercambiar los archivos. Normalmente me gusta trabajar en la ventana izquierda cuando tengo 2 ventanas. Sé que puedo hacer fácilmente C-x opara mover el cursor a la ventana derecha.

Sin embargo, me pregunto si puedo intercambiar los archivos para que file2.cestén en la ventana izquierda y file1.cen la ventana derecha.

Yo uso buffer-move para esto. Ahora, si está trabajando en el búfer del lado izquierdo, llamar a 'buf-move-right' lo intercambiará con el de la derecha. Supongo que esto es lo que quieres.

La biblioteca de transposición de marcos proporciona un conjunto bastante completo de funciones para voltear o rotar las disposiciones de las ventanas en marcos.

M-x flop-frame RET hace lo que necesita esta pregunta en particular.

Los siguientes diagramas son del comentario en la biblioteca (y su página 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            |      |                 |       |
       +-------------------------+      +-----------------+-------+

En el archivo de NOTICIAS de Emacs 26.1 hay la siguiente entrada:

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

¿Cuál parece ofrecer una funcionalidad similar crux-transpose-windowspero también puede hacer algunas transposiciones de altura / ancho?

Si está usando Prelude , puede usar C-c s( prelude-swap-windows). De la documentación de Prelude:

C-c sejecuta el comando crux-swap-windows(que se encuentra en prelude-mode-map), que es un alias para crux-transpose-windowsen crux.el .

No tengo conocimiento de ninguna función incorporada que haga esto.

Sin embargo, no parece demasiado difícil conseguir algo de elisp para hacerlo. Sin embargo, el diablo está en los detalles.

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

En particular, es posible que esto no esté haciendo lo que desea con respecto a dónde termina el símbolo de intercalación. Sin embargo, primero tendrías que decir lo que quieras: p

Si tiene preludio, puede usar ace-window con S-w. Desde allí, puede hacer muchas cosas enumeradas en sus documentos. .

También puede comenzar llamando a ace-window y luego decidir cambiar la acción para eliminar o intercambiar, etc. De forma predeterminada, los enlaces son:

x - eliminar ventana

m - ventana de intercambio (mover)

c - ventana dividida equitativamente, ya sea vertical u horizontalmente

v - ventana dividida verticalmente

b - ventana dividida horizontalmente

n - seleccione la ventana anterior

...

Entonces seria S-w m

El siguiente fragmento de código puede cambiar de búfer.

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

Me las ingeniaría para abrir el archivo # 2 en la ubicación deseada, es decir, después de presionar cx 3, mueva el cursor con cx o antes de navegar al segundo archivo.