Comment échanger les tampons dans 2 fenêtres emacs

J'utilise emacs, je trouve que parfois j'ai 2 fichiers séparés en 2 fenêtres.

Par exemple: j'ouvre 1 fichier en utilisant C-x C-f file1.c RET

et j'ai divisé le cadre en deux fenêtres: C-x 3

J'ouvre ensuite un autre fichier C-x C-f file2.c RET

J'ai donc 2 fichiers:

fenêtre 1 (gauche) file1.c

fenêtre 2 (droite) file2.c

Je me demande s'il existe une combinaison de touches pour échanger les fichiers? Normalement, j'aime travailler sur la fenêtre de gauche quand j'ai 2 fenêtres. Je sais que je peux facilement C-x odéplacer le curseur vers la fenêtre de droite.

Cependant, je me demande simplement si je peux échanger les fichiers de sorte que ce file2.csoit dans la fenêtre de gauche et file1.cdans la fenêtre de droite?

J'utilise buffer-move pour cela. Maintenant, si vous travaillez sur le tampon sur le côté gauche, appeler 'buf-move-right' l'échangera avec celui de droite. Je suppose que c'est ce que tu veux.

La bibliothèque de cadres de transposition fournit un ensemble assez complet de fonctions pour inverser ou faire pivoter les arrangements de fenêtre dans les cadres.

M-x flop-frame RET fait ce dont cette question particulière a besoin.

Les schémas suivants sont tirés du commentaire de la bibliothèque (et de sa page 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            |      |                 |       |
       +-------------------------+      +-----------------+-------+

Dans le fichier Emacs 26.1 NEWS, il y a l'entrée suivante:

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

Lequel semble offrir des fonctionnalités similaires à crux-transpose-windowsmais peut également effectuer des transpositions de hauteur / largeur?

Si vous utilisez Prelude, vous pouvez simplement utiliser C-c s( prelude-swap-windows). À partir de la documentation Prelude:

C-c sexécute la commande crux-swap-windows(dans prelude-mode-map), qui est un alias pour crux-transpose-windowsen crux.el .

Je ne connais aucune fonction intégrée faisant cela.

Cependant, il ne semble pas trop difficile de concocter un peu d'élisp pour le faire. Le diable est cependant dans les détails.

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

Notamment, cela peut ne pas faire ce que vous désirez par rapport à l'endroit où le curseur se termine. Cependant, vous devez d'abord dire ce que vous voulez: p

Si vous avez un prélude, vous pouvez utiliser ace-window avec S-w. À partir de là, vous pouvez faire de nombreuses choses répertoriées dans leurs documents .

Vous pouvez également commencer par appeler ace-window, puis décider de changer l'action pour supprimer ou échanger, etc. Par défaut, les liaisons sont:

x - fenêtre de suppression

m - fenêtre d'échange (déplacement)

c - diviser la fenêtre équitablement, verticalement ou horizontalement

v - diviser la fenêtre verticalement

b - fenêtre divisée horizontalement

n - sélectionnez la fenêtre précédente

...

Donc ce serait S-w m

L'extrait de code suivant peut faire basculer le tampon.

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

Je parviendrais à ouvrir le fichier n ° 2 à l'emplacement souhaité, c'est-à-dire après avoir appuyé sur cx 3, déplacez le curseur avec cx o avant de naviguer vers le deuxième fichier.