Como é que reordeno as janelas de tmux?

O comando swap-window é o mais próximo do que se pretende.

“Prefixo :” (isto é Ctrl+B, : por defeito) leva-o ao prompt de comando tmux. Aí entra:

swap-window -s 3 -t 1

para deixar a janela número 3 e a janela número 1 trocar as suas posições.

Para trocar a janela actual com a janela superior, faça:

swap-window -t 0

No caso improvável de não ter janela no índice 0, fazer:

move-window -t 0

(se o índice de base for 0, como é por defeito).

Pode ligar esse comando a uma chave (T de “top”, por exemplo), adicionando o seguinte ao seu ~/.tmux.conf:

bind-key T swap-window -t 0

Adicionando à resposta de Gareth, pode usar as seguintes teclas de ligação

bind-key -n C-S-Left swap-window -t -1
bind-key -n C-S-Right swap-window -t +1

Pressionando Ctrl+Shift+Esquerda (irá mover a janela actual para a esquerda. Da mesma forma, para a direita. Não há necessidade de utilizar o modificador (C-b).

Para a versão tmux 3.0, deverá utilizar as seguintes ligações de teclas

bind-key -n C-S-Left swap-window -t -1\; select-window -t -1
bind-key -n C-S-Right swap-window -t +1\; select-window -t +1

O tmux equivalente a :number 42 é :move-window -t 42.

Eu renumero janelas como esta:

Ctrl+b, ., 222

faria a actual janela tmux (todos os vidros) número 222.

Relativamente: Quando estou a baralhar coisas, tenho tendência a querer fazer

Ctrl+b :new-session -d -s "reading"

e a partir daí também posso usar Ctrl+b, ., reading para mover a janela actual (todos os vidros de uma só vez) para a sessão de leitura. Pode navegar entre sessões com Ctrl+b, s da forma como navegaria dentro da sessão usando Ctrl+b, w.

HTH

Pode implementar um comando equivalente ao screen‘s number usando um script de shell externo que escolhe entre swap-window e move-window. Pode ligá-lo a uma chave dessa forma:

bind < command-prompt -p index "run-shell '~/.tmux.number.sh %%'"

~/.tmux.number.sh:

#!/bin/bash
if [$# -ne 1 -o -z "$1"]; then
    exit 1
fi
if tmux list-windows | grep -q "^$1:"; then
    tmux swap-window -t $1
else
    tmux move-window -t $1
fi

Usando a janela de troca para passar para qualquer identificação: [mais próximo do ecrã :número]

# window movement / renumbering like in screen's :number
bind-key m command-prompt -p "move window to:" "swap-window -t '%%'"

[m para mover –> acerte o prefixo-m e introduza digamos 3 . .para renumerar a janela para 3]

Uma vez que a resposta de Ashish Ariga não funciona na versão 1.9a e abaixo. Eu uso < e > para trocar a janela à esquerda e à direita, respectivamente, adicionando a linha abaixo a .tmux.conf.

# swap window to left or right
bind-key -r < swap-window -t -1
bind-key -r > swap-window -t +1
```.

A solução mais simples de man, é utilizar as amarrações por defeito:

{ Swap the current pane with the previous pane.
} Swap the current pane with the next pane.

Para aqueles que utilizam byobu como embalagem para tmux, podem trocar a janela actual com a janela anterior ou seguinte:

Ctrl-Shift-F3
Ctrl-Shift-F4

A encadernação de chaves definida por byobu para estas chaves pode ser de interesse:

bind-key -n C-S-F3 swap-window -t :-1
bind-key -n C-S-F4 swap-window -t :+1

pode usar base-index para alterar o número inicial das suas janelas. se definir base-index para 1, então move-window -r renumerará todas as janelas começando em 1, libertando assim 0 para mover uma janela para a sua ranhura:

set base-index 1
move-window -r
move-window -t 0

quando terminar, poderá reiniciar base-index para 0 se quiser usar move-window -r mais tarde sem mover a sua janela para 0.

tmux-pain-control fornece ctrl-b > e ctrl-b < para mover a janela focada para a direita e para a esquerda, enrolando-se em torno.

A abordagem que utilizo combina um pouco da resposta de Ashish com a de piec; tenho a seta alt-esquerda e direita ligada a uma pequena e rápida chamada de concha que move a janela uma para a esquerda ou direita, a menos que seja a primeira ou última janela, respeitosamente. Fiz isto porque, quando se emite um swap +1 na última janela (ou swap -1 na primeira janela), ele continuará a trocar, em vez de voltar a girar como seria de esperar:

0:one 1:two 2:three 3:zero*

Torna-se

0:zero* 1:two 2:three 3:one

Em vez de

0:zero* 1:one 2:two 3:three

Assim, os comandos que utilizo param de funcionar quando a janela atinge o limite da lista:

bind-key -n M-Left run-shell 'tmux list-windows | head -n 1 | grep -q active || tmux swap-window -t -1'
bind-key -n M-Right run-shell 'tmux list-windows | tail -n 1 | grep -q active || tmux swap-window -t +1'

Isto pode ser facilmente combinado com base-index* e renumber-windows* para ter uma lista de janelas que começam com um número arbitrário e nunca tem quaisquer lacunas.

Se estiver a usar base-index 1 como eu e achar que nunca irá acima de 999 janelas, pode usar um pequeno truque para o fazer rolar correctamente, embora os comandos inchem um pouco:

set -g base-index 1
set -g renumber-windows on
bind-key -n M-Left run-shell 'if tmux list-windows | head -n 1 | grep -q active ; then tmux move-window -t 999 \; move-window -r \; refresh-client -S ; else tmux swap-window -t -1 ; fi'
bind-key -n M-Right run-shell 'if tmux list-windows | tail -n 1 | grep -q active ; then tmux move-window -t 0 \; move-window -r \; refresh-client -S ; else tmux swap-window -t +1 ; fi'

Isto funciona movendo temporariamente a última janela para o index-0 não utilizado e depois chamando move-window -r* para renumerá-los a partir de 1 novamente. Funciona de forma semelhante ao mover a primeira janela para o fim; ao escolher um número enorme que nunca usará, assegura que quando move-window -r dispara novamente, tudo será numerado como seria de esperar. Se estiver a pensar em refresh-client -S* , isso é necessário porque por vezes, enquanto a reordenação de move-window* funcionará correctamente, a barra de estado não será actualizada até que sejam feitas mais alterações. Ao forçar uma actualização apenas da barra de estado (-S), evita-se isto.

O único problema que posso encontrar com esta abordagem é que janela de troca* irá implicitamente alterar a última janela utilizada para aquela com a qual trocou. Assim, se estiver na janela #1, mudar para a janela quatro e movê-la para trás, verá que a sua última janela utilizada é a nova #4 (anteriormente #3) em vez da #1. Não parece haver uma forma de contornar isto.

Ambas as janelas swap-window -s 5 e swap-window -t 5 swap de corrente com a janela 5, mas com semântica diferente.

swap-window -s 5

• programa da janela 5 em vigor com número de vitória actual. & - número recente da janela permanece inalterado. & - repetir o mesmo comando irá voltar ao estado anterior.

swap-window -t 5

• programa actual em vigor com o número 5. & - anulação recente com o número da janela actual.

o number em swap-window -s number e -t number poderia ser ambos absoluto , eg, 5, e relativo* , eg, -1, +2.

P.S. abaixo está excerto da linha de status do tmux ilustrando o efeito do swap-window -s 5

recente: [0] 0:vim- 1:mpl 2:py2* 3:numpy 4:plot 5:mc

agora, depois do last-window:
[0] 0:vim* 1:mpl 2:py2- 3:numpy 4:plot 5:mc swapw -s 5

depois de [0] 0:mc* 1:mpl 2:py2- 3:numpy 4:plot 5:vim:
swapw -s 5

outro [0] 0:vim* 1:mpl 2:py2- 3:numpy 4:plot 5:mc:
last-window

outro [0] 0:vim- 1:mpl 2:py2* 3:numpy 4:plot 5:mc:
0x6&: 0x6&&: 0x6&

Da janela do tmux, tente o seguinte para trocar a janela 0 com 1:

$ tmux swap-window -d -s 0 -t 1

Primeiro, abra o comando tmux de imprensa e comunicado:

Ctrl + b

E para mudar a janela real para a janela direita (em ordem circular), basta fazer:

}

Para mudar a janela real para a esquerda:

{

• Não se esqueça de usar SHIFT quando premir } ou {.

Pelo que vale:

Eu pirateei este guião juntos para poder encomendar todas as janelas numa “TUI”. Enumera todas as suas janelas num ficheiro temporário, abre-o com o seu editor predefinido (supõe que tenha definido $EDITOR). Depois disto, pode reordenar as linhas e depois de guardar e fechar o ficheiro, as janelas são reordenadas em conformidade. (Isto é semelhante a encomendar commits ao fazer git rebase -i)

#!/bin/bash

# Usage: tmux-mv    
# Move your tmux windows around in an editor

tmpfile=$(mktemp)
tmux list-windows > $tmpfile
$EDITOR $tmpfile

# Move all windows to 50..x in the order you just specified
# Assumes you don't have 50 windows already(!)
cat $tmpfile | awk -F ":" '{ print " -s " $1 " -t 5" NR-1 }' |\
  xargs -I {} sh -c 'tmux move-window -d {}'

# Move them back down, retaining the order
tmux move-window -d -r
rm $tmpfile

Pode provavelmente ser melhorado em muitos, em particular:

NOTE : Poderá ser movido para outra janela depois de executar o comando. Um gif dele em acção (github)

Nenhuma das respostas aqui me satisfez, por isso escrevi um guião que (sort-of) imita o comportamento screen window-moving para tmux.

Detecta se o número da janela de destino é menor* que o número da janela mais pequena ou mais grande que o número da janela maior, e se assim for, empurra todas as outras janelas para a direita ou para a esquerda (respectivamente) e reconta-as de 1-N incrementalmente. Isto é feito com o comando move-window.

Se o número da janela for no meio os números mais pequenos/mais altos (ou seja, presumivelmente, corresponde a um número de janela existente), apenas os troca com o comando swap-window.

Aqui está o script:

#!/usr/bin/env bash
# Filename: ~/tmux-windowswap
# Function that provides improved window-swapping functionality for tmux
maxwin="$(tmux list-windows | cut -d: -f1 | sort -nr | head -n1)"
minwin="$(tmux list-windows | cut -d: -f1 | sort -n | head -n1)"
# Error checking
if [[-z $2]]; then
  echo "Error: No window specified."
elif [[! $2 =~ ^-?[0-9]+$ ]]; then
  echo "Error: Bad window number specified."
# Bigger than everything; slide it to the far right, then renumber
elif [[$2 -gt $maxwin]]; then
  i=0 # intialize
  tmux move-window -t:$(($maxwin+1))
  winlist="$(tmux list-windows | cut -d: -f1 | xargs)"
  for n in $winlist; do
    i=$(($i+1)) # increment
    tmux move-window -s:$n -t:$i
  done
# Smaller than everything; slide it to the far left, then renumber
elif [[$2 -lt $minwin]]; then
  tmux move-window -t:0
  winlist=($(tmux list-windows | cut -d: -f1 | xargs | rev))
  i=${#winlist[@]} # initialize; start at highest indexed window
  for n in ${winlist[@]}; do
    tmux move-window -s:$n -t:$i
    i=$(($i-1)) # decrement
  done
# In-between; just a simple swap
else
  tmux swap-window -t:$2
fi

Depois, basta adicionar esta simples encadernação de teclas ao seu .tmux.conf:

bind m command -p "Send window to:" "run -b '~/tmux-windowswap #I %1'"

Nota : Para imitar perfeitamente o comportamento de troca de janelas screen, acredito que quando se move uma janela para um existente* número de janela, esta deve ocupar o lugar dessa janela e todas as outras janelas são empurradas para o ** direito***. Seria bastante simples modificar este guião para o fazer.

Este é o método que eu utilizo. Ainda não se pode mover uma janela para um índice ocupado, mas pode-se mover uma para um índice mais alto (índice não utilizado) e reordenar no intervalo em que se encontrava o índice anterior.

Digamos que tem 3 janelas e quer adicionar uma quarta mas no local onde se encontrava anteriormente 3.

Antes de adicionar uma nova janela: Tmux prefixo então . abrirá o comando mover. Digite 4 e o índice de 3 tornar-se-á agora 4, depois basta adicionar outra janela e estará no índice 3 e a sua janela antiga ainda estará no índice 4.

Não há necessidade da linha de comando (que é Ctrl + b e depois :)

Basta mover as janelas com

Ctrl + b + :

depois introduzir o novo número de janela (livre) e premir Enter

Se agora houver número de janela livre, usar Ctrl + b + . para renumerar uma janela.

(Dica: nomeie as suas janelas com Ctrl + b + , se perder o rasto do qual é qual)