Sto cercando di trovare un modo decente per copiare ciò che ho in un buffer tmux negli appunti. Ho provato un paio di cose diverse come

bind-key p select-pane -t 2 \; split-window 'xsel -i -b' \; paste-buffer

che mi avvicina abbastanza, tutto quello che devo fare è premere control-d dopo aver fatto prefisso-p.

Ho provato a risolverlo facendo

bind-key p select-pane -t 2 \; split-window 'xsel -i -b << HERE\; tmux paste-buffer\; echo HERE'

Ma questo non funziona. In effetti se lo associo a solo

bind-key p select-pane -t 2 \; split-window 'xsel -i -b << HERE'

non fa nulla, quindi presumo che a split-window non piaccia << in un comando shell.

Qualche idea?

Modifica: puoi saltare il select-pane -t 2se lo desideri, non è molto importante. Uso solo un layout specifico e il riquadro 2 è quello che preferisco dividere quando faccio qualcos'altro in modo che vada nei miei binding che coinvolgono le divisioni per impostazione predefinita.

Qui i documenti hanno bisogno di nuove righe. Ad esempio, in uno script di shell, è possibile scrivere

cat <<EOF >somefile; echo  done
file contents
EOF

Non credo che tmux ti permetta di inserire nuove linee, e anche se lo facesse, questo non sarebbe un buon approccio. Cosa succede se i dati stessi contengono HEREsolo su una linea (ad esempio perché stai copiando i tuoi .tmux.conf)?

Suggerisco di scrivere il contenuto del buffer in un file temporaneo. Non testato:

bind-key p save-buffer ~/.tmux-buffer \; run-shell "xsel -i -b <~/.tmux-buffer && rm ~/.tmux-buffer"

C'è una condizione di competizione se si utilizza questo comando in due istanze separate di tmux. Non so come risolverlo.

Questo dovrebbe funzionare:

# move x clipboard into tmux paste buffer
bind C-p run "tmux set-buffer \"$(xclip -o)\"; tmux paste-buffer"
# move tmux copy buffer into x clipboard
bind C-y run "tmux save-buffer - | xclip -i"

Una soluzione più semplice per Mac OS-X

Questo si basa sulla risposta di Alex e utilizza cose che al momento non esistevano.

Se stai usando l' homebrew (e se non lo sei, perché non lo sei?), Puoi semplicemente fare questo:

brew install reattach-to-user-namespace

Quindi nel tuo ~/.tmux.conf:

set-option -g default-command "reattach-to-user-namespace -l zsh" # or bash...
bind C-c run "tmux save-buffer - | reattach-to-user-namespace pbcopy"
bind C-v run "reattach-to-user-namespace pbpaste | tmux load-buffer - && tmux paste-buffer"

Per copiare il buffer da tmux (dovresti aver già copiato qualcosa usando tmux) nel Macboard, usa <tmux-key> Control-c. Ora sarà disponibile per Command-vopbpaste

Per incollare qualcosa dalla tastiera del Mac, utilizzare <tmux-key> Control-v.

Il copy-pipecomando è stato aggiunto dalla versione 1.8. Copia una selezione nel buffer tmux e la invia a un comando. Ora non è necessario un legame prefisso. Ecco un esempio:

bind -t vi-copy y copy-pipe "xclip"

# For OS X users:
bind -t vi-copy y copy-pipe "reattach-to-user-namespace pbcopy"

Ora, quando hai selezionato del testo copy-mode, ylo copierà nel buffer tmux e negli appunti del sistema operativo. Tuttavia, non aiuta se si desidera ottenere testo dagli Appunti nel buffer tmux.

Potresti provare il plugin tmux-yank . Consente di copiare direttamente negli appunti di sistema (OS X e Linux) e alcuni altri gadget come strappare l'attuale linea di shell.

Dopo aver provato una soluzione diversa, ecco la mia configurazione finale:

# move x clipboard into tmux paste buffer
bind C-p run "xclip -o | tmux load-buffer -
# move tmux copy buffer into x clipboard
bind C-y run "tmux save-buffer - | xclip -i -selection clipboard"

l'uso di save-buffer anziché show-buffer fornisce i dati reali senza i dati, come mostrato con le interruzioni di riga quando si è suddivisi.

Lo uso anche per iniziare la selezione / copia in modalità copia tmux:

bind-key -t vi-copy 'v' begin-selection
bind-key -t vi-copy 'y' copy-selection

Suppongo che potrebbe essere possibile unire la selezione della copia con il tasto 'y' E spostarla negli appunti x.

Ecco un tentativo di risposta esaustiva.

Prima un po 'di storia

Quando questa domanda è stata posta per la prima volta (giugno 2011), copiare il testo da Tmux negli Appunti doveva essere un processo in due passaggi, prima copiare il testo selezionato nel buffer di Tmux, quindi copiare il testo dal buffer di Tmux negli Appunti di sistema.

In 1.8 (marzo 2013) è copy-pipestato aggiunto il comando che consente di copiare il testo selezionato direttamente negli Appunti di sistema (o altra destinazione).

Quindi in 2.4 (aprile 2017) le tabelle chiave sono state modificate in modo significativo rendendo obsolete molte delle risposte in questa pagina.

Rispondere alla domanda originale

Linux :

bind-key C-y run-shell "tmux save-buffer - | xclip -i -r > /dev/null" \; display-message "Copied tmux buffer to selection"
bind-key C-Y run-shell "tmux save-buffer - | xclip -i -r -selection clipboard > /dev/null" \; display-message "Copied tmux buffer to clipboard"
bind-key C-p run-shell "xclip -o | tmux load-buffer - ; tmux paste-buffer"

Mac :

Se stai usando homebrew , dovresti installarlo reattach-to-user-namespaceeseguendo il seguente comando in un terminale:

brew install reattach-to-user-namespace

Quindi nel tuo ~ / .tmux.conf:

bind-key C-y run-shell "tmux save-buffer - | reattach-to-user-namespace pbcopy" \; display-message "Copied tmux buffer to clipboard"
bind-key C-p run-shell "reattach-to-user-namespace pbpaste | tmux load-buffer - ; tmux paste-buffer"

Il metodo più breve (copia e incolla una selezione direttamente da e negli appunti per tmux> 2.4)

Nota: ci sono due versioni per Linux perché Linux ha un blocco appunti principale e secondario (noto anche come selezione).

Linux :

bind-key -T copy-mode-vi y send-keys -X copy-pipe "xclip -r" \; display-message "Copied to selection"
bind-key -T copy-mode-vi Y send-keys -X copy-pipe "xclip -r -selection clipboard" \; display-message "Copied to clipboard"
bind-key C-p run-shell "xclip -o | tmux load-buffer - && tmux paste-buffer"

Mac :

bind-key -T copy-mode-vi y send-keys -X copy-pipe "reattach-to-user-namespace pbcopy" \; display-message "Copied to clipboard"

Personalizzare questi comandi

• Se non vuoi che il comando ti dica cosa ha fatto nella riga di stato, rimuovi semplicemente display-message(e anche quello \;che lo precede).

• Se stai usando la modalità di copia in stile Emacs invece di vi, sostituisci qualsiasi istanza di copy-mode-vicon justcopy-mode

• Se usi Linux e vuoi usarlo xselinvece di xclipsostituirlo xclip -rcon xsel -i -pe xclip -oconxsel -o -p

• L' -ra xclip -rè facoltativo, esso rimuove l'ultima riga. È utile per copiare i comandi, quindi quando li incolli non verranno immediatamente eseguiti.

• Se si esegue il tunneling su SSH, è necessario consultare https://unix.stackexchange.com/a/354581/14252

Riferimenti:

• https://stackoverflow.com/a/21190234/175830
  • Senza > /dev/nullcopiare il buffer di tmux negli Appunti, tmux non risponderà alle scorciatoie
• https://unix.stackexchange.com/a/70798/14252
  • Personalizzazioni per Mac

Non mi piace avere i tasti in più, quindi volevo qualcosa di più ambizioso. Accedere alla modalità di copia con [, evidenziare il testo giusto, quindi premere] per copiare il testo negli Appunti.

Inoltre, a tmux piace includere le nuove linee nelle espressioni che avvolgono (e stranamente quelle nuove linee sono nel posto sbagliato ! Non sono dove l'espressione è avvolta sullo schermo). Quindi volevo che C-] copiasse l'espressione rimuovendo le nuove righe.

Su tmux 1.6 ho provato questo:

bind [ copy-mode
bind -t vi-copy ] run "tmux send-keys Enter; tmux show-buffer | xclip -i -selection clipboard;"
bind -t vi-copy C-] run "tmux send-keys Enter; tmux show-buffer | perl -pe 's/\n//' | xclip -i -selection clipboard;"

ma ciò non ha funzionato perché tmux non sembra felice di associare cose complesse alla tabella vi-copy. Quindi ho finito per fare questo invece:

bind [ copy-mode \;                                                        \
    bind -n ] run                                                          \
    "tmux send-keys Enter;                                                 \
     tmux show-buffer | xclip -i -selection clipboard;                     \
     tmux unbind -n C-];                                                   \
     tmux unbind -n ]" \;                                                  \
    bind -n C-] run                                                        \
    "tmux send-keys Enter;                                                 \
     tmux show-buffer | perl -pe 's/\n//' | xclip -i -selection clipboard; \
     tmux unbind -n C-];                                                   \
     tmux unbind -n ]"

Questo porta a cose strane (] o C-] funzionerà in modo divertente la prossima volta che le usi, ma solo una volta) se esci dalla modalità di copia in un altro modo oltre a] o C-]. Questo potrebbe essere risolto con alcuni altri collegamenti che immagino, ma questo fa quello che voglio la maggior parte del tempo.

C'è una soluzione su Arch Wiki usando xclip:

# move tmux copy buffer into x clipboard
bind-key C-y save-buffer /tmp/tmux-buffer \; run-shell "cat /tmp/tmux-buffer | xclip"

https://wiki.archlinux.org/index.php/Tmux

Una soluzione per Mac OS X. Segui questi 2 passaggi:

1. Usa la soluzione alternativa a Chris Johnsen: https://github.com/ChrisJohnsen/tmux-MacOSX-pasteboard

2. Aggiungi questo codice al tuo tmux config (~ / .tmux.conf)

# paste clipboard into tmux buffer
bind v run-shell "reattach-to-user-namespace -l zsh -c 'tmux set-buffer \\"$(pbpaste)\\"; tmux paste-buffer'"
# put tmux buffer into x clipboard
bind y run-shell "reattach-to-user-namespace -l zsh -c 'tmux show-buffer | pbcopy'"

Una variante leggermente modificata della risposta accettata, che ho preparato.

Preferisco anche usare gli Appunti di sistema (Ctrl-C, Ctrl-V) oltre agli primaryAppunti predefiniti di xclip (quello che si ottiene con la selezione del mouse e il clic centrale del mouse). Per scegliere gli appunti di sistema è necessario passare l' -selection clipboardargomento xclip.

Inoltre, durante la copia di un buffer negli Appunti, mi piace la possibilità di scegliere quale buffer voglio copiare. Viene fatto usando choose-buffere quindi passando il buffer dell'argomento save-bufferall'utilizzo -b %%.

# Copy into clipboard
bind C-c choose-buffer "run \"tmux save-buffer -b %% - | xclip -i -selection clipboard\""
# Paste from clipboard
bind C-v run "xclip -o -selection clipboard | tmux load-buffer - ; tmux paste-buffer"
# Copy into primary
bind C-y choose-buffer "run \"tmux save-buffer -b %% - | xclip -i \""
# Paste from primary
bind C-p run "xclip -o | tmux load-buffer - ; tmux paste-buffer"

AGGIORNAMENTO: In qualche modo con tmux 1.8 e due delle mie installazioni di openSUSE 12.2, vedo un blocco quando tmux run-shellviene invocato con la xcliplettura di stdin su una pipe. Ho invece deciso di xselprovare e che sembra funzionare. Queste sono le associazioni di tasti equivalenti che usano xsel. Ho anche usato &&per incatenare i comandi in incolla per una maggiore robustezza.

# Copy into clipboard
bind C-c choose-buffer "run \"tmux save-buffer -b '%%' - | xsel -i -b\""
# Paste from clipboard
bind C-v run "xsel -o -b | tmux load-buffer - && tmux paste-buffer"
# Copy into primary
bind C-y choose-buffer "run \"tmux save-buffer -b '%%' - | xsel -i\""
# Paste from primary
bind C-p run "xsel -o | tmux load-buffer - && tmux paste-buffer"

Questa è la mia risposta piuttosto lunga che dovrebbe risolvere due problemi principali con l'uso di xclip per copiare il buffer da una sessione tmux remota (ssh):

1. Xclip non rispondente

Per me la risposta di @ Grauwolf con xclipnon ha funzionato (rende il riquadro di tmux totalmente irresponsabile). Ho scoperto perché nella pagina Tmux della wiki di Arch :

xclip potrebbe anche essere usato a tale scopo, a differenza di xsel funziona meglio sulla stampa di bitstream grezzi che non si adattano alla locale corrente. Tuttavia, è meglio usare xsel invece di xclip, perché xclip non chiude STDOUT dopo aver letto dal buffer di tmux. Di conseguenza, tmux non sa che l'attività di copia è stata completata e continua ad attendere la chiusura di xclip, rendendo quindi tmux non rispondente. Una soluzione alternativa è reindirizzare STDOUT di xclip su / dev / null

Quindi l'associazione dovrebbe essere:

bind-key C-y run "tmux save-buffer - | xclip -i -sel clip > /dev/null"

Ora funzionerà se la tua sessione tmux è locale.

2. xclip non è in grado di connettersi a X

Se stai usando tmux su ssh -X , ci sono grandi probabilità che questo non funzioni direttamente.

Questo perché la variabile di shell $DISPLAYdeve essere impostata correttamente.

Soluzione completa

Quindi per me, la soluzione di lavoro completa è quella di inserire le seguenti righe nel mio ~/.tmux.conf:

set-option -g update-environment "DISPLAY"
bind-key C-y run "export DISPLAY=`tmux show-env | sed -n 's/^DISPLAY=//p'`; tmux save-buffer - | xclip -i -selection clipboard >/dev/null"
# Or more concise:
bind-key C-y run "tmux save-buffer - | xclip -i -selection clipboard -d `tmux show-env | sed -n 's/^DISPLAY=//p'` >/dev/null

Per incollare dal primario:

bind-key C-p run "xclip -d `tmux show-env | sed -n s/^DISPLAY=//p` -o | tmux load-buffer - && tmux paste-buffer"

Non capisco perfettamente perché $DISPLAYnon sia impostato correttamente durante l'approvvigionamento .tmux.conf, quindi è per questo che devo estrarlo con tmux show-enve sed.

Se hai tmux> = 1.8, puoi adattare questo comando con copy-pipe:

bind-key -t vi-copy y copy-pipe 'xclip -in -selection clipboard -d `tmux show-env | sed -n s/^DISPLAY=//p` >/dev/null'

Sto cercando di trovare un modo decente per copiare ciò che ho in un buffer tmux negli appunti. Ho provato un paio di cose diverse come

Per i bind di stile emacs ci sono alcune opzioni diverse. (Lo stile Vi dovrebbe essere simile?) Il legame tipico per fare "selezione-copia" in emacs è Mw, quindi sarebbe molto conveniente avere lo stesso legame in tmux.

1 - Sarebbe l'ideale, ma non funziona (a causa della limitazione di tmux?)

unbind-key -t emacs-copy M-w
bind-key -t emacs-copy M-w copy-selection\; \
  run-shell "tmux save-buffer - | xsel --input --clipboard"

2 - Compromesso che funziona bene per me : accetta di usare una diversa associazione di tasti per emacs-copy in tmux. Utilizzare ad esempio CMw. (Questa associazione che sarà definita "a livello globale" - non solo in modalità copia - ma utile solo in modalità copia)

bind-key -n C-M-w send-keys M-w\; \
 run-shell "tmux save-buffer - | xsel --input --clipboard" 

Molte di queste risposte non hanno funzionato per Ubuntu 14.04 su zsh così com'è. Non sono sicuro che la mia shell abbia qualcosa a che fare con esso, ma ecco la mia versione funzionante dell'utilizzo di questa strategia per la copia e questa strategia per incollare.

    bind-key -t vi-copy 'v' begin-selection
    bind-key -t vi-copy 'y' copy-pipe "xclip -sel clip -i"
    bind-key ] run-shell "xclip -sel clip -o | tmux load-buffer - ; tmux paste-buffer" 

Alcune note:

• per copy-pipe, dovevo specificare i miei appunti con -sel clip -i. Quella linea combina il buffer yank to tmux e lo invia a xclip.
• per effettivamente incollarlo, avevo bisogno di specificare nuovamente con quale appunti -sel clip -o

Funziona magnificamente ora per la mia configurazione di vim / zsh / tmux.

E la versione migliorata della risposta @Leif potrebbe essere:

tmux bind-key '[' run "tmux copy-mode;
tmux bind-key -n ']' run \"tmux send-keys Enter; tmux save-buffer - | xclip -i -selection clipboard;
tmux unbind-key -n ']'\";
tmux bind-key -n q run \"tmux unbind -n ']'; tmux send-keys q\";
tmux bind-key -n C-c run \"tmux unbind -n ']'; tmux send-keys C-c\""

In questo modo non ci sono conseguenze se si esce dalla modalità di copia in un altro modo oltre], il codice sopra è racchiuso in tundle / tmux-yank un plugin tmux per copiare il testo di tmux negli appunti di sistema, si rivolge a tmux> = 1.6 su OS X e Linux.

Su OS-X con tmux versione 2.2 o successive funzionerà:

bind-key -t emacs-copy MouseDragEnd1Pane copy-pipe "pbcopy"
bind-key -t vi-copy MouseDragEnd1Pane copy-pipe "pbcopy"

Uso copyqun gestore di appunti multilinea. (Funziona con Windows, OSX, Linux.)

• Aggiungi le seguenti righe in ~/.tmux.conf:

  set-window-option -g mode-keys vi
  bind C-y run 'out=`tmux save-buffer - ` && copyq add "$out"'
  

• cygwinrichiede copyq.exeposizione in ~/.bashrc:

  export PATH="$PATH:/cygdrive/c/Program Files (x86)/CopyQ"