I am trying to copy (using python or a CL command which I then can call using python) a file to the clipboard to later paste it using STRG+V. As far as I understand it, files are not "moved" into the clipboard, but rather the clipboard holds the path and an argument/flag that tells the OS "this is a file". I am happy with a linux-specific answer, but a universal answer would be the cherry on top.
pyperclip
Is not a solution, because it doesn't allow to copy files, just strings.
xclip
Is not a solution, because it only copies text
xclip-copyfile
Is not a solution, because it only copies to the X clipboard, not the clipboard. While xclip offers the option -selection clipboard (but only copies text), xclip-copyfile has no such option.
Using find
find ${PWD} -name "*.pdf"| xclip -i -selection clipboard -t text/uri-list
is a command described here: https://askubuntu.com/questions/210413/what-is-the-command-line-equivalent-of-copying-a-file-to-clipboard#answer-210428
But I can't replicate copying files with it and therefore assume that it is not working for all files.
Configurations
The clipboard is part of the Window Management and not of the Linux operating system itself. Different configurations with different distributions behave differently and therefore require different variants. Meanwhile, Wayland is increasingly on the way to successively replace X, which means there are three configurations to consider:
Sending clipboard content
When saving to the clipboard, the system first only informs the receiver that data is available for the clipboard. Only on request, the actual data is sent. The program that sends the content to the clipboard must therefore not be terminated before the data has been transferred. Depending on the environment/configuration, it is also possible that the content of the clipboard is deleted as soon as the program is terminated.
How then does the xclip program already mentioned in the question work? It seems to terminate immediately after being called. But on closer inspection it doesn't, because it performs a fork, so that it is still present in the background (easily verifiable by looking at the source code or the command ps).
Format
Furthermore, different environments require the content in different ways. For example GNOME requires the list of files to be copied with the special target x-special/gnome-copied-files and a special formatting of the content, e.g. copy\nfile:///etc/group for the GNOME file manager Nautilus to perform the copy operation correctly.
Under KDE, on the other hand, there is then only one URI list with the target text/uri-list.
Determining the environment
The following example program works for Linuxmint 20.2 Cinnamon, Ubuntu 22.04 with Gnome and Kubuntu 22.04 with KDE. Other distributions / configurations may require some customization. Here it is advisable to simply copy a file in the appropriate file manager and then look at the clipboard contents with a program and then make appropriate adaptions to the script.
Based on the environment variables XDG_CURRENT_DESKTOP and WAYLAND_DISPLAY the following program tries to determine the environments.
If it is Wayland, wl-copy is used, otherwise xclip is used. The target and the content formatting is adapted accordingly. With subprocess.Popen the tool is started and the content is sent to stdin of the tool.
As soon as this is done, the program exits. Both wl-copy and xclip then create a fork, ensuring that the data is present in the clipboard.
import os
import subprocess
import sys
from pathlib import Path
gnome_desktops = ['X-Cinnamon', 'XFCE']
def is_gnome(desktop):
if desktop.endswith("GNOME") or desktop in gnome_desktops:
return True
return False
def target():
current_desktop = os.environ['XDG_CURRENT_DESKTOP']
if is_gnome(current_desktop):
return 'x-special/gnome-copied-files'
elif current_desktop == 'KDE':
return 'text/uri-list'
else:
sys.exit(f'unsupported desktop {current_desktop}')
def base_copy_cmd():
if 'WAYLAND_DISPLAY' in os.environ:
return 'wl-copy'
return 'xclip -i -selection clipboard'
def copy_clipboard_cmd():
return f"{base_copy_cmd()} -t '{target()}'"
def content(files_to_copy):
uris = '\n'.join([Path(f).as_uri() for f in files_to_copy])
current_desktop = os.environ['XDG_CURRENT_DESKTOP']
if is_gnome(current_desktop):
return f"copy\n{uris}".encode("utf-8")
return uris.encode("utf-8")
def copy_to_clipboard(files_to_copy):
copy_process = subprocess.Popen(copy_clipboard_cmd(), shell=True, stdin=subprocess.PIPE)
copy_process.stdin.write(content(files_to_copy))
copy_process.stdin.close()
copy_process.wait()
if __name__ == '__main__':
files = ['/etc/hosts', '/etc/group']
copy_to_clipboard(files)
As mentioned above for other environments simply copy a file in the native file manager and then inspect the current clipboard contents and make appropriate adjustments to the script.
Depending on the environment, xclip or wl-copy (install the package wl-clipboard with your package manager) must be there. Detailed information about wl-copy can be found here: https://github.com/bugaevc/wl-clipboard.
Inspect Clipboard
Finally, to be able to dump the current contents of the clipboard, here is a small script that does just that. So it is possible to see what other programs like the native file manager put into the clipboard. Usually many programs put several different representations targets of the same data into the clipboard.
import gi
gi.require_version("Gtk", "3.0")
from gi.repository import Gtk, Gdk
def on_activate(app):
win = Gtk.ApplicationWindow(application=app)
win.set_title("GTK Clipboard Util")
win.set_default_size(256, 192)
btn = Gtk.Button(label="Dump Clipboard")
btn.connect('clicked', dump)
box = Gtk.VBox()
win.add(box)
box.add(btn)
win.show_all()
def dump(button):
cb_targets = []
counter = 0
def print_content(clipboard, data):
print(data.get_data())
print()
print_next_target_and_content(clipboard)
def print_next_target_and_content(clipboard):
nonlocal counter
if counter < len(cb_targets):
target = cb_targets[counter]
print(target)
clipboard.request_contents(target, print_content)
counter += 1
def get_targets(clipboard, targets, n_targets):
nonlocal counter
nonlocal cb_targets
counter = 0
cb_targets = targets
print_next_target_and_content(clipboard)
gtk_clipboard = Gtk.Clipboard.get(Gdk.SELECTION_CLIPBOARD)
gtk_clipboard.request_targets(get_targets)
if __name__ == '__main__':
app = Gtk.Application(application_id='com.software7.clipboard.formats')
app.connect('activate', on_activate)
app.run(None)