layout - two - vim split vertical

¿Cómo puedo intercambiar posiciones de dos archivos abiertos(en splits) en vim?

Question

Supongamos que tengo un diseño arbitrario de splits en vim.

____________________
| one | two |
| | |
| |______|
| | three|
| | |
|___________|______|

¿Hay alguna forma de intercambiar one y two y mantener el mismo diseño? Es simple en este ejemplo, pero estoy buscando una solución que ayude a diseños más complejos.

ACTUALIZAR:

Supongo que debería ser más claro. Mi ejemplo anterior fue una simplificación del caso de uso real. Con una instancia real:

¿Cómo podría intercambiar dos de esas divisiones, manteniendo el mismo diseño?

¡Actualizar! 3+ años después ...

¡Pongo la solución de sgriffin en un plugin Vim que puedes instalar fácilmente! Instálelo con su administrador de complementos favorito y pruébelo: WindowSwap.vim

Answer 1

A partir de esto:

____________________
| one | two |
| | |
| |______|
| | three|
| | |
|___________|______|

Haga que ''tres'' sea la ventana activa, luego emita el comando ctrl + w J. Esto mueve la ventana actual para llenar la parte inferior de la pantalla, dejándole con:

____________________
| one | two |
| | |
|___________|______|
| three |
| |
|__________________|

Ahora haga que ''uno'' o ''dos'' sea la ventana activa, luego ejecute el comando ctrl + w r . Esto ''rota'' las ventanas en la fila actual, dejándote con:

____________________
| two | one |
| | |
|___________|______|
| three |
| |
|__________________|

Ahora haga ''dos'' la ventana activa, y ejecute el comando ctrl + w H. Esto mueve la ventana actual para llenar la parte izquierda de la pantalla, dejándole con:

____________________
| two | one |
| | |
| |______|
| | three|
| | |
|___________|______|

Como puede ver, la maniobra es un poco aleatoria. Con 3 ventanas, es un poco como uno de esos rompecabezas de "juegos de fichas". No recomiendo probar esto si tiene 4 o más ventanas. Será mejor que las cierre y las abra de nuevo en las posiciones deseadas.

Hice un screencast demostrando cómo trabajar con ventanas divididas en Vim .

Answer 2

Eche un vistazo a :h ctrl-w_ctrl-x y / o :h ctrl-w_ctrl-r . Estos comandos le permiten intercambiar o rotar ventanas en el diseño actual.

Edición: En realidad, esto no funcionará en esta situación porque solo se intercambiará en la columna o fila actual. En su lugar, podría ir a cada una de las ventanas y seleccionar el búfer de destino, pero eso es bastante detallado.

Answer 3

El siguiente enfoque puede ser conveniente si las funciones no están disponibles por algún motivo (si no es su vim).

Use el comando :buffers para averiguar los ID de los buffers abiertos, navegue a la ventana deseada y use el comando como :b 5 para abrir un buffer (buffer 5 en este caso). Repetir dos veces y los contenidos de las ventanas se intercambian.

"Inventé" este método después de varios intentos de memorizar secuencias de ctrl-w-something incluso para diseños muy simples como uno-dos-tres en la pregunta original.

Answer 4

Enfoque similar marca-ventana-luego-intercambio-búfer, pero también le permite reutilizar el último intercambio.

function! MarkWindowSwap()
unlet! g:markedWin1
unlet! g:markedWin2
let g:markedWin1 = winnr()
endfunction
function! DoWindowSwap()
if exists(''g:markedWin1'')
if !exists(''g:markedWin2'')
let g:markedWin2 = winnr()
endif
let l:curWin = winnr()
let l:bufWin1 = winbufnr(g:markedWin1)
let l:bufWin2 = winbufnr(g:markedWin2)
exec g:markedWin2 . ''wincmd w''
exec '':b ''.l:bufWin1
exec g:markedWin1 . ''wincmd w''
exec '':b ''.l:bufWin2
exec l:curWin . ''wincmd w''
endif
endfunction
nnoremap ,v :call DoWindowSwap()<CR>
nnoremap ,z :call MarkWindowSwap()<CR>

Answer 5

Realmente genial, pero mi propuesta para el mapeo es usar ^ W ^ J en lugar de J (porque todos los HJKL ya tienen significados), además, también obtendré el nuevo búfer, porque para el momento en que quieras intercambiarte Probablemente no quiera continuar editando el búfer en el que se encuentra. Aquí va:

function! MarkSwapAway()
" marked window number
let g:markedOldWinNum = winnr()
let g:markedOldBufNum = bufnr("%")
endfunction
function! DoWindowToss()
let newWinNum = winnr()
let newBufNum = bufnr("%")
" Switch focus to marked window
exe g:markedOldWinNum . "wincmd w"
" Load current buffer on marked window
exe ''hide buf'' newBufNum
" Switch focus to current window
exe newWinNum . "wincmd w"
" Load marked buffer on current window
exe ''hide buf'' g:markedOldBufNum
" …and come back to the new one
exe g:markedOldWinNum . "wincmd w"
endfunction
nnoremap <C-w><C-h> :call MarkSwapAway()<CR> <C-w>h :call DoWindowToss()<CR>
nnoremap <C-w><C-j> :call MarkSwapAway()<CR> <C-w>j :call DoWindowToss()<CR>
nnoremap <C-w><C-k> :call MarkSwapAway()<CR> <C-w>k :call DoWindowToss()<CR>
nnoremap <C-w><C-l> :call MarkSwapAway()<CR> <C-w>l :call DoWindowToss()<CR>

Answer 6

Sobre la base de la respuesta de @ sgriffin, aquí hay algo aún más cercano a lo que estás pidiendo:

function! MarkWindow()
let g:markedWinNum = winnr()
endfunction
function! SwapBufferWithMarkedWindow()
" Capture current window and buffer
let curWinNum = winnr()
let curBufNum = bufnr("%")
" Switch to marked window, mark buffer, and open current buffer
execute g:markedWinNum . "wincmd w"
let markedBufNum = bufnr("%")
execute "hide buf" curBufNum
" Switch back to current window and open marked buffer
execute curWinNum . "wincmd w"
execute "hide buf" markedBufNum
endfunction
function! CloseMarkedWindow()
" Capture current window
let curWinNum = winnr()
" Switch to marked window and close it, then switch back to current window
execute g:markedWinNum . "wincmd w"
execute "hide close"
execute "wincmd p"
endfunction
function! MoveWindowLeft()
call MarkWindow()
execute "wincmd h"
if winnr() == g:markedWinNum
execute "wincmd H"
else
let g:markedWinNum += 1
execute "wincmd s"
execute g:markedWinNum . "wincmd w"
execute "wincmd h"
call SwapBufferWithMarkedWindow()
call CloseMarkedWindow()
endif
endfunction
function! MoveWindowDown()
call MarkWindow()
execute "wincmd j"
if winnr() == g:markedWinNum
execute "wincmd J"
else
execute "wincmd v"
execute g:markedWinNum . "wincmd w"
execute "wincmd j"
call SwapBufferWithMarkedWindow()
call CloseMarkedWindow()
endif
endfunction
function! MoveWindowUp()
call MarkWindow()
execute "wincmd k"
if winnr() == g:markedWinNum
execute "wincmd K"
else
let g:markedWinNum += 1
execute "wincmd v"
execute g:markedWinNum . "wincmd w"
execute "wincmd k"
call SwapBufferWithMarkedWindow()
call CloseMarkedWindow()
endif
endfunction
function! MoveWindowRight()
call MarkWindow()
execute "wincmd l"
if winnr() == g:markedWinNum
execute "wincmd L"
else
execute "wincmd s"
execute g:markedWinNum . "wincmd w"
execute "wincmd l"
call SwapBufferWithMarkedWindow()
call CloseMarkedWindow()
endif
endfunction
nnoremap <silent> <Leader>wm :call MarkWindow()<CR>
nnoremap <silent> <Leader>ws :call SwapBufferWithMarkedWindow()<CR>
nnoremap <silent> <Leader>wh :call MoveWindowLeft()<CR>
nnoremap <silent> <Leader>wj :call MoveWindowDown()<CR>
nnoremap <silent> <Leader>wk :call MoveWindowUp()<CR>
nnoremap <silent> <Leader>wl :call MoveWindowRight()<CR>

Por favor, hágame saber si el comportamiento no coincide con sus expectativas.

Answer 7

También basado en la solución de sgriffin, vaya a la ventana que desea intercambiar, presione CTRL-w m , vaya a la ventana con la que desea intercambiar y presione CTRL-w m nuevamente.

CTRL-w m es una opción mnemotécnica deficiente, por lo que si alguien encuentra una mejor, edítela.

Además, me gustaría recibir comentarios del script, también conocido como "Ventana marcada. Por favor, repita en target". Sin embargo, al ser un noob vimscript, no sé cómo hacerlo.

Todo lo dicho, el guión funciona bien como está

" <CTRL>-w m : mark first window
" <CTRL>-w m : swap with that window
let s:markedWinNum = -1
function! MarkWindowSwap()
let s:markedWinNum = winnr()
endfunction
function! DoWindowSwap()
"Mark destination
let curNum = winnr()
let curBuf = bufnr( "%" )
exe s:markedWinNum . "wincmd w"
"Switch to source and shuffle dest->source
let markedBuf = bufnr( "%" )
"Hide and open so that we aren''t prompted and keep history
exe ''hide buf'' curBuf
"Switch to dest and shuffle source->dest
exe curNum . "wincmd w"
"Hide and open so that we aren''t prompted and keep history
exe ''hide buf'' markedBuf
endfunction
function! WindowSwapping()
if s:markedWinNum == -1
call MarkWindowSwap()
else
call DoWindowSwap()
let s:markedWinNum = -1
endif
endfunction
nnoremap <C-w>m :call WindowSwapping()<CR>

Answer 8

También puedes usar un administrador de ventanas de mosaico como X-monad

Answer 9

Tengo una versión ligeramente mejorada de la solución de sgriffin, puedes cambiar ventanas sin usar dos comandos, pero con comandos intuitivos HJKL.

Así que aquí es cómo va:

function! MarkWindowSwap()
" marked window number
let g:markedWinNum = winnr()
let g:markedBufNum = bufnr("%")
endfunction
function! DoWindowSwap()
let curWinNum = winnr()
let curBufNum = bufnr("%")
" Switch focus to marked window
exe g:markedWinNum . "wincmd w"
" Load current buffer on marked window
exe ''hide buf'' curBufNum
" Switch focus to current window
exe curWinNum . "wincmd w"
" Load marked buffer on current window
exe ''hide buf'' g:markedBufNum
endfunction
nnoremap H :call MarkWindowSwap()<CR> <C-w>h :call DoWindowSwap()<CR>
nnoremap J :call MarkWindowSwap()<CR> <C-w>j :call DoWindowSwap()<CR>
nnoremap K :call MarkWindowSwap()<CR> <C-w>k :call DoWindowSwap()<CR>
nnoremap L :call MarkWindowSwap()<CR> <C-w>l :call DoWindowSwap()<CR>

Intente mover su ventana usando HJKL de capital en un nodo normal, es realmente genial :)

Answer 10

Todas las respuestas anteriores son excelentes, desafortunadamente, estas soluciones no funcionan bien en combinación con las ventanas QuickFix o LocationList (corrí en este problema al intentar que el búfer de mensajes de error de Ale funcionara con esto).

Solución

Por lo tanto, agregué una línea de código adicional para cerrar todas estas ventanas antes de hacer el intercambio.

exe '':windo if &buftype == "quickfix" || &buftype == "locationlist" | lclose | endif''

El código total se ve como;

" Making swapping windows easy
function! SwapWindowBuffers()
exe '':windo if &buftype == "quickfix" || &buftype == "locationlist" | lclose | endif''
if !exists("g:markedWinNum")
" set window marked for swap
let g:markedWinNum = winnr()
:echo "window marked for swap"
else
" mark destination
let curNum = winnr()
let curBuf = bufnr( "%" )
if g:markedWinNum == curNum
:echo "window unmarked for swap"
else
exe g:markedWinNum . "wincmd w"
" switch to source and shuffle dest->source
let markedBuf = bufnr( "%" )
" hide and open so that we aren''t prompted and keep history
exe ''hide buf'' curBuf
" switch to dest and shuffle source->dest
exe curNum . "wincmd w"
" hide and open so that we aren''t prompted and keep history
exe ''hide buf'' markedBuf
:echo "windows swapped"
endif
" unset window marked for swap
unlet g:markedWinNum
endif
endfunction
nmap <silent> <leader>mw :call SwapWindowBuffers()<CR>

Créditos para la función de intercambio a Brandon Orther

Por que se necesita

La razón por la que las funciones de intercambio no funcionan correctamente sin eliminar primero todas las ventanas de QuickFix (QF) y LocationList (LL) es porque si el principal del búfer QF / LL se oculta (y no se muestra en ninguna ventana), el QF Se quita la ventana / LL acoplada a ella. Esto no es un problema en sí mismo, pero cuando la ventana se oculta, todos los números de las ventanas se reasignan y el intercambio se desordena ya que el número guardado de la primera ventana marcada ya no existe (potencialmente).

Para poner esto en perspectiva:

Primera marca de ventana

____________________
| one | -> winnr = 1 marked first g:markedWinNum=1
| | -> bufnr = 1
|__________________|
| two (QF window | -> winnr = 2
| coupled to one |
|__________________|
| three | -> winnr = 3
| | -> bufnr = 2
|__________________|

Segunda marca de ventana

____________________
| one | -> winnr = 1 g:markedWinNum=1
| | -> bufnr = 1
|__________________|
| two (QF window | -> winnr = 2
| coupled to one) |
|__________________|
| three | -> winnr = 3 marked second curNum=3
| | -> bufnr = 2 curBuf=2
|__________________|

Primer interruptor de búfer, la ventana uno se llena con el búfer de la ventana tres. Por lo tanto, la ventana QF se elimina porque ya no tiene ninguna ventana principal. Esto reorganiza los números de las ventanas. Tenga en cuenta que curNum (el número de la segunda ventana seleccionada) apunta a una ventana que ya no existe.

____________________
| three | -> winnr = 1 g:markedWinNum=1
| | -> bufnr = 2
|__________________|
| three | -> winnr = 2 curNum=3
| | -> bufnr = 2 curBuf=2
|__________________|

Así que cuando se cambia el segundo búfer, intenta seleccionar la ventana de curNum, que ya no existe. Así que lo crea y cambia el búfer, lo que da como resultado que una ventana no deseada se abra aún.

____________________
| three | -> winnr = 1 g:markedWinNum=1
| | -> bufnr = 2
|__________________|
| three | -> winnr = 2
| | -> bufnr = 2
|__________________|
| one | -> winnr = 3 curNum=3
| | -> bufnr = 1 curBuf=2
|__________________|

Answer 11

Un poco tarde para el post, pero encontré esto buscando algo más. Hace un tiempo escribí dos funciones para marcar una ventana y luego intercambiar buffers entre ventanas. Esto parece ser lo que estás pidiendo.

Solo golpea estos en tu .vimrc y mapea las funciones como mejor te parezcan:

function! MarkWindowSwap()
let g:markedWinNum = winnr()
endfunction
function! DoWindowSwap()
"Mark destination
let curNum = winnr()
let curBuf = bufnr( "%" )
exe g:markedWinNum . "wincmd w"
"Switch to source and shuffle dest->source
let markedBuf = bufnr( "%" )
"Hide and open so that we aren''t prompted and keep history
exe ''hide buf'' curBuf
"Switch to dest and shuffle source->dest
exe curNum . "wincmd w"
"Hide and open so that we aren''t prompted and keep history
exe ''hide buf'' markedBuf
endfunction
nmap <silent> <leader>mw :call MarkWindowSwap()<CR>
nmap <silent> <leader>pw :call DoWindowSwap()<CR>

Para usar (asumiendo que su mapleader está configurado en /) usted debería:

1. Mover a la ventana para marcar para el intercambio a través del movimiento ctrl-w
2. Escriba / mw
3. Mueve a la ventana que quieres intercambiar.
4. Tipo / pw

Voila! Intercambiar buffers sin estropear el diseño de su ventana!

Answer 12

Randy''s razón en que CTRL-W x no quiere intercambiar ventanas que no estén en la misma columna / fila.

Descubrí que las CTRL-W HJKL son más útiles al manipular ventanas. Forzarán su ventana actual fuera de su ubicación actual y le indicarán que ocupe todo el borde indicado por la dirección de la tecla que presiona. Ver :help window-moving para :help window-moving para más detalles.

Para su ejemplo anterior, si comienza en la ventana "uno", esto hace lo que quiere:

CTRL-W K # moves window "one" to be topmost,
# stacking "one", "two", "three" top to bottom
CTRL-W j # moves cursor to window "two"
CTRL-W H # moves window "two" to be leftmost,
# leaving "one" and "three" split at right

Para su comodidad, puede asignar las secuencias que necesita a las asignaciones de teclas (consulte :help mapping ).