In this article I will explain how one can serve data through the copy/paste mechanism from a C program using X11. There are many resources on the Web about the subject (this one and this one put me on tracks) but of those I've found none did actually worked out of the box. I hope this article will bring clarifications for those who wander on these strange roads...

Copy/paste can be handle in C programming through the Selection mechanism of the X Window System (X11). In short, it works as follow. The application serving data registers as the one holding the clipboard data, it listens for SelectionRequest events from other applications, and replies to them, either to let the requestor know what kind of data it serves, either to actually serve the requested data.

Here I will go through a demo which serves a dummy payload (some UTF-8 text) for a few seconds and then stops. It doesn't cover the "paste" operation, only the "copy" one (application uniquely serving data through the clipboard). I haven't pushed further because it's sufficient for my current needs, maybe I'll come back to it later. If you want to look by yourself, checking about the SelectionNotify events should put you on track.

First, to end automatically the app after a few seconds I spawn a thread which will update a flag controlling a loop in the main thread.

void* DelayedAction(void* arg) { // Wait 5 seconds for(int tick = 5; tick > 0; tick--) { printf("quit in %ds\n", tick); sleep(1); } // Set the flag to stop the main thread *(bool*)arg = true; // End the thread return NULL; } int main() { // Flag to control the termination of the demo bool flagEnd = false; // Create a separate thread for the delayed action pthread_t tid; int const ret = pthread_create(&tid, NULL, &DelayedAction, &flagEnd); assert(ret == 0); ...

C by itself doesn't have copy/paste functionalities, it is a service offered by the window manager. Hence we need to create an X window, even if we won't even display it. It's really just here to be able to communicate with the X11 server.

// Create a window to interact with the X11 server // It won't be displayed so a dummy empty one is enough Display* display = XOpenDisplay(NULL); Window window = XCreateSimpleWindow( display, DefaultRootWindow(display), 0, 0, 1, 1, 0, 0, 0);

For various application to be able to communicate they need some kind of common language. In X11 that's the role of an Atom. CLIPBOARD represents the clipboard, and TARGETS will be used to request the type of data. We need also one more for the actual type of data, and that's probably the trickiest part: how do you know in advance what the other application are expecting? I've choosen the one below through trial and error.

// Get the Atom for the clipboard (this is the id to refer to data // associated with the clipboard in the X11 server) Atom atomClipboard = XInternAtom(display , "CLIPBOARD", False); // Get the Atom for the request of types of targets we are responding to Atom atomTargets = XInternAtom(display , "TARGETS", False); // Get the Atom for the target to which this demo will respond Atom atomText = XInternAtom(display , "text/plain;charset=utf-8", False);

Note that you're free to choose whatever label you want for the last Atom, XInternAtom() will create it if it doesn't exist (that's the False flag at the end). So, if you're only interested in communicating with another application you're developping yourself you could very well use Atom atomDataType = XInternAtom(display , "my_own_weird_data_type", False); as long as you use the same label in both applications.

Next we inform the X11 server that we are the one responsible for the clipboard data. It will hold until the application ends, or a "copy" occurs in another application.

// Set ownership of the clipboard atom to the display, from there the // X11 server knows that if someone requests the content of the clipboard // atom it is 'display' which must process the request XSetSelectionOwner(display, atomClipboard, window, CurrentTime);

Next we start the main loop which processes events until the termination flag is raised or someone else takes the ownership of the clipboard data.

// Loop until we decide to stop delivering data through the clipboard or // someone else took the ownership of the clipboard while( flagEnd == false && XGetSelectionOwner(display, atomClipboard) == window ) {

The main loop checks the events and filters requests related to the clipboard.

// Check if there is a SelectionRequest event in the event queue XEvent event; bool hasSelectionRequest = XCheckTypedEvent(display, SelectionRequest, &event); if(hasSelectionRequest == true) { printf("recv evt %d\n", event.type); XSelectionRequestEvent request = event.xselectionrequest; // If the requested data are the clipboard data if (request.selection == atomClipboard) { printf("request for clipboard data\n");

To reply to those requests, we prepare a SelectionNotify event that will be sent back to the requestor.

// Prepare the reply event XSelectionEvent sendEvent = { .type = SelectionNotify, .serial = request.serial, .send_event = request.send_event, .display = request.display, .requestor = request.requestor, .selection = request.selection, .target = request.target, .property = request.property, .time = request.time, };

The reply event is completed with appropriate data. If we were requested the type of served data, we use the Atom defining that type. Note that here we can serve several types of data (just add them in the targets array).

// If the requestor has asked for the targets we are // responding to if (request.target == atomTargets) { // Send the list of available targets (here only atomText) Atom const targets[] = {atomText}; XChangeProperty( display, sendEvent.requestor, sendEvent.property, XA_ATOM, 32, PropModeReplace, (unsigned char*)targets, sizeof(targets) / sizeof(Atom));

If we were requested for one of the data type we serve, we set the actual data. Here I'm simply using a hardcoded value for demo. Note that the data can be anything you want, as long as the sender and receiver knows what to do about it. These are really just bytes moving from one process to another.

// Else, if the requestor asked for the atomText target } else if (request.target == atomText) { // Set the content of the reply event's property with the // clipboard data // 'format' specifies it's 8-bit data // Here I simply hardcode the data to be pasted char const* const clipboardData = "data in clipboard 日本語"; size_t const clipboardDataLen = strlen(clipboardData); int const format = 8; XChangeProperty( sendEvent.display, sendEvent.requestor, sendEvent.property, sendEvent.target, format, PropModeReplace, (unsigned char*)clipboardData, clipboardDataLen);

To help me identify what labels are used by other applications I also print those I don't recognize. A real application would probably ignore or throw an error here.

// Else, the target is not supported } else { // Print the name of the requested target char const* atomName = XGetAtomName( request.display, request.target); printf("unsupported target: %s\n", atomName); }

The reply event is now ready to be sent, and that's all for the main loop.

// Send the reply event back to the requestor XSendEvent(display, request.requestor, 0, 0, (XEvent*)&sendEvent); } } }

Finally, free the resources and return the success code.

// Free resources XDestroyWindow(display, window); XCloseDisplay(display); // Return success return 0; }

The full code is as follow:

#include <X11/Xlib.h> #include <X11/Xatom.h> #include <stdio.h> #include <string.h> #include <unistd.h> #include <assert.h> #include <pthread.h> void* DelayedAction(void* arg) { // Wait 5 seconds for(int tick = 5; tick > 0; tick--) { printf("quit in %ds\n", tick); sleep(1); } // Set the flag to stop the main thread *(bool*)arg = true; // End the thread return NULL; } int main() { // Flag to control the termination of the demo bool flagEnd = false; // Create a separate thread for the delayed action pthread_t tid; int const ret = pthread_create(&tid, NULL, &DelayedAction, &flagEnd); assert(ret == 0); // Create a window to interact with the X11 server // It won't be displayed so a dummy empty one is enough Display* display = XOpenDisplay(NULL); Window window = XCreateSimpleWindow( display, DefaultRootWindow(display), 0, 0, 1, 1, 0, 0, 0); // Get the Atom for the clipboard (this is the id to refer to data // associated with the clipboard in the X11 server) Atom atomClipboard = XInternAtom(display , "CLIPBOARD", False); // Get the Atom for the request of types of targets we are responding to Atom atomTargets = XInternAtom(display , "TARGETS", False); // Get the Atom for the target to which this demo will respond Atom atomText = XInternAtom(display , "text/plain;charset=utf-8", False); // Set ownership of the clipboard atom to the display, from there the // X11 server knows that if someone requests the content of the clipboard // atom it is 'display' which must process the request XSetSelectionOwner(display, atomClipboard, window, CurrentTime); // Loop until we decide to stop delivering data through the clipboard or // someone else took the ownership of the clipboard while( flagEnd == false && XGetSelectionOwner(display, atomClipboard) == window ) { // Check if there is a SelectionRequest event in the event queue XEvent event; bool hasSelectionRequest = XCheckTypedEvent(display, SelectionRequest, &event); if(hasSelectionRequest == true) { printf("recv evt %d\n", event.type); XSelectionRequestEvent request = event.xselectionrequest; // If the requested data are the clipboard data if (request.selection == atomClipboard) { printf("request for clipboard data\n"); // Prepare the reply event XSelectionEvent sendEvent = { .type = SelectionNotify, .serial = request.serial, .send_event = request.send_event, .display = request.display, .requestor = request.requestor, .selection = request.selection, .target = request.target, .property = request.property, .time = request.time, }; // If the requestor has asked for the targets we are // responding to if (request.target == atomTargets) { // Send the list of available targets (here only atomText) Atom const targets[] = {atomText}; XChangeProperty( display, sendEvent.requestor, sendEvent.property, XA_ATOM, 32, PropModeReplace, (unsigned char*)targets, sizeof(targets) / sizeof(Atom)); // Else, if the requestor asked for the atomText target } else if (request.target == atomText) { // Set the content of the reply event's property with the // clipboard data // 'format' specifies it's 8-bit data // Here I simply hardcode the data to be pasted char const* const clipboardData = "data in clipboard 日本語"; size_t const clipboardDataLen = strlen(clipboardData); int const format = 8; XChangeProperty( sendEvent.display, sendEvent.requestor, sendEvent.property, sendEvent.target, format, PropModeReplace, (unsigned char*)clipboardData, clipboardDataLen); // Else, the target is not supported } else { // Print the name of the requested target char const* atomName = XGetAtomName( request.display, request.target); printf("unsupported target: %s\n", atomName); } // Send the reply event back to the requestor XSendEvent(display, request.requestor, 0, 0, (XEvent*)&sendEvent); } } } // Free resources XDestroyWindow(display, window); XCloseDisplay(display); // Return success return 0; }

Compile with gcc -o main main.c -lX11.

Execute the application and try to paste in another one within the time limit, you should get the clipboardData. It works for me, on Linux, for Chrome, the Office suite, Nano, and Geany.