remove o arquivo anterior: // ao colar no terminal gnome

Question

Estou usando o Ubuntu 14.04, mas acho que isso pode ser visto em quase todas as versões do Ubuntu.

Quando eu copio um arquivo do nautilus usando Ctrl c e colo no gedit ele cola o texto como /home/urvish/.bash_history , o que é perfeito para mim. Mas quando eu colo no terminal usando Ctrl Deslocamento v ele vai como file:///home/urvish/.bash_history .

Existe alguma maneira de remover o anterior file:// ao colar? (Eu sei que posso fazê-lo manualmente, mas eu faço isso com muita frequência e sempre fazendo manualmente é o tempo necessário).

    

Answer 1

O que o gnome-terminal faz

A partir da leitura da documentação do Gtk, parece que há duas maneiras de um programa tratar o conteúdo da área de transferência - texto simples e lista de URIs para o arquivo. Por alguma razão, gnome-terminal decidiu que seria uma boa ideia diferenciar entre dois e, portanto, quando você copia um arquivo do Nautilus para gnome-terminal , o terminal recupera a lista de URI, enquanto outros programas - somente texto sem formatação. / p>

A edição automática da área de transferência seria um pouco problemática (embora ainda persista a ideia) - precisaríamos definir uma maneira de detectar onde você está tentando colar o conteúdo da área de transferência e executar um script persistente que edita o script em texto simples (efetivamente excluindo os URIs) impedirá que você copie arquivos de uma janela do Nautilus para outra.

Arrastar e soltar é provavelmente a solução mais simples. Mas desde que uma abordagem de script foi solicitada, tive a ideia de duas abordagens manuais. Uma conta com o recurso embutido do Nautilus de adicionar scripts ao menu do botão direito do mouse. O outro ao digitar um atalho específico antes colar no gnome-terminal.

Abordagem de script manual, versão 1

Esse script deve ser colocado na pasta ~/.local/share/nautilus/scripts e tornado executável via chmod +x ~/.local/share/nautilus/scripts/scriptname.sh ou clicando com o botão direito do mouse no arquivo e editando a guia Permissões nas propriedades. Efetivamente, permite que você copie o caminho para os arquivos selecionados como strings entre aspas e com file:// da parte removida.

Para usá-lo, selecione arquivos ou arquivos no Nautilus e clique com o botão direito do mouse. Selecione Scripts menu - > %código%.

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
from gi.repository import Gtk, Gdk
import sys
import os
import time
import subprocess
import signal
import urllib.parse
import threading

def autoquit(*args):
    subprocess.call(['zenity','--info'])
    time.sleep(1)
    Gtk.main_quit()

def main():

    uris = os.getenv("NAUTILUS_SCRIPT_SELECTED_URIS")
    new_text = " ".join([ "'" + urllib.parse.unquote(i).replace('file://','') + "'"
                          for i in uris.split()])

    clip = Gtk.Clipboard.get(Gdk.SELECTION_CLIPBOARD)
    if clip.set_text(new_text,-1):
        thread = threading.Thread(target=autoquit)
        thread.start()
    Gtk.main()

if __name__ == '__main__': 
    try:
        main()
    except Exception as e:
        subprocess.call(['zenity','--info','--text',str(e)])

Abordagem de script manual, versão 2

Esta abordagem baseia-se na ideia de executar o script python logo abaixo antes de colar em your_script_name.py . Você pode chamá-lo de gnome-terminal manualmente como comando ou vincular isso a um atalho de teclado. Assim, com o método de atalho, eu iria ligá-lo ao Ctrl Deslocar B (porque é B e V estão próximos no teclado), e cada vez Eu preciso colar do Nautilus, eu bati CtrlShift B para editar, então CtrlShift v para colar

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
from gi.repository import Gtk, Gdk
import subprocess
import urllib.parse
import signal
import sys

def unquote_uri(*args):
    uris = args[-2]
    new_text = " ".join([ "'" + str(urllib.parse.unquote(i).replace('file://','')) + "'"
                          for i in uris])
    print(new_text)
    args[-3].clear()
    args[-3].set_text(new_text,-1)
    Gtk.main_quit()

def main():
    cached = str()
    clip = Gtk.Clipboard.get(Gdk.SELECTION_CLIPBOARD)
    clip.request_uris(unquote_uri, None)
    signal.signal(signal.SIGINT,signal.SIG_DFL)
    Gtk.main()

if __name__ == '__main__': main()

Aviso: resposta ainda em desenvolvimento; conteúdo / ideias adicionais podem ser adicionados posteriormente

    

Answer 2

Estou um pouco atrasado para a festa, mas estou vendo esse problema no Linux Mint MATE (mate-terminal).

Parece que basta pegar o conteúdo da área de transferência e depois repassá-lo para a área de transferência novamente. Se este for o caso, então só precisamos nos preocupar em testar se o conteúdo da área de transferência inclui um ou mais caminhos de arquivo válidos e deixar o restante sem ser importado.

O seguinte irá soltar o prefixo file: // no Mint:

   

#!/usr/bin/env python

import os
import pyperclip
import time

class ClipboardWatcher():

    def __init__(self,latency):
        self.clipboard_last = pyperclip.paste()
        self.clipboard_now = None
        self.latency = latency

    def check_clipboard(self):

        # assume clipboard is space delimited list of valid paths
        as_list = self.clipboard_now.split()  
        valid_path = [ i for i in as_list if os.path.exists(i) ] 

        if len(as_list) == len(valid_path): # assumption true
            self.clipboard_now = " ".join(valid_path) 
            return True

        return False

    def run(self):
        while True:
            time.sleep(self.latency)  
            self.clipboard_now = pyperclip.paste()
            if self.clipboard_now != self.clipboard_last:                 
                if self.check_clipboard(): 
                    pyperclip.copy(self.clipboard_now)
                    print "Matched:", self.clipboard_now
            self.clipboard_last = self.clipboard_now

clippy = ClipboardWatcher(1)  # watch every n seconds
clippy.run()

Se você fosse implementar esse tipo de abordagem, provavelmente também desejaria daemonizá-lo. O módulo pyperclip pode ser obtido com:

sudo pip install pyperclip