Získání tmux ke zkopírování vyrovnávací paměti do schránky

To by mělo fungovat:

# 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"

Jednodušší řešení pro Mac OS-X

To staví na Alexově odpovědi a používá věci, které v té době neexistovaly.

Pokud používáte homebrew (a pokud nejste, proč ne?), Můžete to udělat jen takto:

brew install reattach-to-user-namespace

Pak ve vašem ~/.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"

Chcete-li zkopírovat vyrovnávací paměť z tmuxu (měli jste již něco zkopírovat pomocí tmuxu) na Macboard, použijte <tmux-key> Control-c. Nyní bude k dispozici pro uživatele Command-v nebo pbpaste

Chcete-li něco vložit z lepicí plochy Mac, použijte <tmux-key> Control-v.

The copy-pipe příkaz byl přidán od verze 1.8. Zkopíruje výběr do vyrovnávací paměti tmux a odešle jej do příkazu. Nyní není potřeba předponové vazby. Zde je příklad:

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

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

Nyní, když máte vybraný text v copy-mode, y zkopíruje tento text do vyrovnávací paměti tmux a do schránky OS. Nepomůže to však, pokud chcete získat text ze schránky do vyrovnávací paměti tmux.

Můžete zkusit tmux-yank plugin . Umožňuje kopírování přímo do systémové schránky (OS X a Linux) a některé další dobroty, jako je vytržení aktuální řady Shell.

Zde je pokus o komplexní odpověď.

Nejprve trochu historie

Když byla tato otázka poprvé položena (červen 2011), mělo by být kopírování textu z Tmuxu do schránky provedeno ve dvou krocích, nejprve zkopírujte vybraný text do Tmuxova vyrovnávací paměti a poté zkopírujte text z Tmuxova vyrovnávací paměti do systémové schránky.

V 1.8 (březen 2013) byl přidán příkaz copy-pipe, Který umožňuje kopírovat vybraný text přímo do systémové schránky (nebo jiného cíle).

Poté v 2.4 (duben 2017) byly klíčové tabulky výrazně změněny, takže mnoho odpovědí na této stránce zastaralo.

Odpověď na původní otázku

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 :

Pokud používáte homebrew , měli byste nainstalovat reattach-to-user-namespace Spuštěním následujícího příkazu v terminálu:

brew install reattach-to-user-namespace

Pak ve vašem ~/.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"

Kratší metoda (zkopírujte a vložte výběr přímo ze schránky a do schránky pro tmux> 2.4)

Poznámka: Existují dvě verze pro Linux, protože Linux má primární a sekundární schránku (známou také jako výběr).

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"

Přizpůsobení těchto příkazů

• Pokud nechcete, aby vám příkaz řekl, co se stalo ve stavovém řádku, odstraňte display-message (Stejně jako \;, Který předchází).

• Pokud používáte režim kopírování ve stylu Emacs místo vi, nahraďte libovolnou instanci copy-mode-vi Pouhým copy-mode

• Pokud používáte Linux a chcete použít xsel místo xclip nahraďte xclip -r Za xsel -i -p A xclip -o Za xsel -o -p

• -r V xclip -r Je volitelný, odstraní poslední nový řádek. Je to užitečné pro kopírování příkazů, a když je vložíte, nebudou okamžitě provedeny.

• Pokud tunelujete přes SSH, měli byste se poradit s https://unix.stackexchange.com/a/354581/14252

Odkazy:

• https://stackoverflow.com/a/21190234/1758
  • Pokud > /dev/null Zkopírování vyrovnávací paměti tmux do schránky způsobí, že tmux nebude reagovat na zkratky
• https://unix.stackexchange.com/a/70798/14252
  • Mac přizpůsobení

Po vyzkoušení jiného řešení je zde moje poslední nastavení:

# 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"

použití save-buffer namísto show-buffer dává reálná data bez dat, jak je ukázáno se zalomením řádku, když jste v rozdělení.

Používám také k zahájení výběru/kopírování v režimu kopírování tmux:

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

Myslím, že by bylo možné sloučit výběr kopie s klávesou „y“ a přesunout ji do schránky x.

Nelíbí se mi další stisknutí kláves, takže jsem chtěl něco ambicióznějšího. Do režimu kopírování zadejte [ zvýrazněte správný text a poté stisknutím] zkopírujte text do schránky.

Tmux také rád zahrnuje nové řádky do výrazů, které zalamují (a podivně ty nové řádky jsou na špatném místě! Nejsou tam, kde je výraz zabalený na obrazovce). Takže jsem chtěl, aby C-] zkopíroval výraz, který odstraní nové řádky.

Na tmux 1.6 jsem to zkusil:

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;"

ale to nefungovalo, protože tmux se nezdá šťastný, že by svázal složité věci s tabulkou vi-copy. Tak jsem to místo toho nakonec udělal:

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 ]"

To vede k podivným věcem (] nebo C-] budou při příštím použití zábavné, ale pouze jednou), pokud opustíte režim kopírování jiným způsobem kromě] nebo C-]. To by se dalo opravit několika dalšími vazbami, které si představuji, ale to dělá to, co chci většinu času.

Řešení pro Mac OS X. Postupujte podle těchto 2 kroků:

1. Použijte zástupné řešení Chrisa Johnsena: https://github.com/ChrisJohnsen/tmux-MacOSX-pasteboard

2. Přidejte tento kód do vaší konfigurace tmux (~/.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'"

Toto je moje poněkud zdlouhavá odpověď, která by měla vyřešit dva hlavní problémy s používáním xclip ke zkopírování vyrovnávací paměti ze vzdálené (ssh) tmux relace:

1. Neodpovídající xclip

Pro mě @ Grauwolfovo odpověď s xclip nefungovalo (vykreslení tmuxového panelu zcela nereaguje). Zjistil jsem, proč na Tmuxová stránka Arch wiki :

xclip může být také použit pro tento účel, na rozdíl od xsel funguje lépe pro tisk surového bitstream, který neodpovídá aktuálnímu národnímu prostředí. Přesto je hezčí použít xsel místo xclip, protože xclip nezavře STDOUT poté, co přečte z tmuxova bufferu. Tmux jako takový neví, že úloha kopírování byla dokončena, a nadále čeká na ukončení xclip, čímž způsobí, že tmux nebude reagovat. Řešení je přesměrovat STDOUT xclip na/dev/null

Vazba by tedy měla být:

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

Nyní to bude fungovat, pokud je vaše relace tmux lokální.

2. xclip nelze připojit k X

Pokud používáte tmux přes ssh -X , existuje velká šance, že to nebude fungovat přímo.

Je to proto, že proměnná Shell $DISPLAY musí být správně nastaveno.

Kompletní řešení

Takže pro mě je kompletním pracovním řešením vložení následujících řádků do mého ~/.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

Pro vložení z primárního:

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

Nechápu, proč $DISPLAY není správně nastaven při sourcingu .tmux.conf, proto to musím extrahovat pomocí tmux show-env a sed.

Pokud máte tmux> = 1,8, můžete tento příkaz upravit pomocí 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'

Trochu upravená varianta přijaté odpovědi, kterou jsem uvařil.

Také raději používám systémovou schránku (Ctrl-C, Ctrl-V) kromě výchozí schránky xclip primary (tu, kterou dostanete s výběrem myši a prostředním kliknutím myši). Pro výběr systémové schránky musíte složit -selection clipboard argument k xclip.

Také při kopírování vyrovnávací paměti do schránky se mi líbí možnost vybrat, kterou vyrovnávací paměť chcete kopírovat. To se provádí pomocí choose-buffer a pak předání vyrovnávací paměti argumentu save-buffer použitím -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"

PDATE: Nějak s tmux 1,8 a dvěma mými instalacemi openSUSE 12.2 vidím zablokování, když tmux run-Shell je vyvoláno s xclip čtení ze stdin přes potrubí. Místo toho jsem se rozhodl zkusit xsel a zdá se, že to funguje. Toto jsou ekvivalentní vazby kláves pomocí xsel. Také jsem použil && pro zřetězení příkazů vložených pro větší robustnost.

# 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"

Na Arch Wiki existuje řešení pomocí 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

Mnoho z těchto odpovědí nefungovalo pro můj Ubuntu 14.04 na zsh as-is. Nejste si jisti, jestli s tím měl můj Shell něco společného, ​​ale tady je moje pracovní verze použití tato strategie pro kopírování a tato strategie pro vložení.

    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" 

Několik poznámek:

• pro copy-pipe jsem potřeboval specifikovat svou schránku pomocí -sel clip -i. Tato linka kombinuje vyrovnávací paměť typu yank to tmux a odešle ji do xclip.
• abych to skutečně vložil, musel jsem znovu určit, která schránka s -sel clip -o

Teď to skvěle funguje pro mé nastavení vim/zsh/tmux.

Snažím se přijít na slušný způsob, jak zkopírovat to, co mám ve vyrovnávací paměti tmux do své schránky. Vyzkoušel jsem několik různých věcí jako

Pro vazby stylu emacs existuje několik různých možností. (Vi-styl by měl být podobný?) Typická vazba pro provádění "výběru kopií" v emacs je M-w, takže by bylo velmi výhodné mít stejnou vazbu v tmux.

1 - Byl by ideální, ale nefunguje (kvůli omezení 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 - Kompromis, který mi dobře vyhovuje: Přijměte použití jiného keybindingu pro emacs-copy v tmux. Použijte například C-M-w. (Tato vazba bude definována „globálně“ - nejen v režimu kopírování - ale užitečná pouze v režimu kopírování)

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

A vylepšená verze odpovědi @Leif by mohla být:

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\""

Tímto způsobem neexistují žádné důsledky, pokud opustíte režim kopírování jiným způsobem kromě], výše uvedený kód je zabalen do tundle/tmux-yank tmux plugin pro kopírování textu tmux do systémové schránky, zacílí tmux> = 1,6 v OS X a Linux.

Na OS-X s verzí tmux 2.2 nebo novější bude fungovat následující:

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

Používám copyq správce víceřádkové schránky. (Funguje s Windows, OSX, Linux.)

• Přidejte následující řádky do ~/.tmux.conf:

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

• cygwin požadavky copyq.exe umístění v ~/.bashrc:

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