trunk/rdesktop/xclip.c

/* -*- c-basic-offset: 8 -*-
   rdesktop: A Remote Desktop Protocol client.
   Protocol services - Clipboard functions
   Copyright (C) Erik Forsberg <forsberg@cendio.se> 2003
   Copyright (C) Matthew Chapman 2003

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/

#include <X11/Xlib.h>
#include <X11/Xatom.h>
#include "rdesktop.h"

#define NUM_TARGETS 6

extern Display *g_display;
extern Window g_wnd;
extern Time g_last_gesturetime;

static Atom clipboard_atom, primary_atom, targets_atom, timestamp_atom;
static Atom rdesktop_clipboard_target_atom, rdesktop_clipboard_formats_atom, incr_atom;
static XSelectionRequestEvent selection_request;
static Atom targets[NUM_TARGETS];
static int have_primary = 0;
static int rdesktop_is_selection_owner = 0;

static int g_waiting_for_INCR = 0;
static uint8 *g_clip_buffer = 0;
static uint32 g_clip_buflen = 0;

/* Replace CR-LF to LF (well, rather removing all CR:s) This is done
   in-place. The length is updated. Handles embedded nulls */
static void
crlf2lf(uint8 * data, uint32 * length)
{
        uint8 *dst, *src;
        src = dst = data;
        while (src < data + *length)
        {
                if (*src != '\x0d')
                        *dst++ = *src;
                src++;
        }
        *length = dst - data;
}

/* Translate LF to CR-LF. To do this, we must allocate more memory.  
   The length is updated. */
static uint8 *
lf2crlf(uint8 * data, uint32 * length)
{
        uint8 *result, *p, *o;

        /* Worst case: Every char is LF */
        result = xmalloc(*length * 2);

        p = data;
        o = result;

        while (p < data + *length)
        {
                if (*p == '\x0a')
                        *o++ = '\x0d';
                *o++ = *p++;
        }
        *length = o - result;

        /* Convenience */
        *o++ = '\0';

        return result;
}


static void
xclip_provide_selection(XSelectionRequestEvent * req, Atom type, unsigned int format, uint8 * data,
                        uint32 length)
{
        XEvent xev;

        XChangeProperty(g_display, req->requestor, req->property,
                        type, format, PropModeReplace, data, length);

        xev.xselection.type = SelectionNotify;
        xev.xselection.serial = 0;
        xev.xselection.send_event = True;
        xev.xselection.requestor = req->requestor;
        xev.xselection.selection = req->selection;
        xev.xselection.target = req->target;
        xev.xselection.property = req->property;
        xev.xselection.time = req->time;
        XSendEvent(g_display, req->requestor, False, NoEventMask, &xev);
}

#ifndef MAKE_PROTO
void
xclip_handle_SelectionNotify(XSelectionEvent * event)
{
        unsigned long nitems, bytes_left;
        XWindowAttributes wa;
        Atom type, best_target, text_target;
        Atom *supported_targets;
        int res, i, format;
        uint8 *data;

        if (event->property == None)
                goto fail;

        DEBUG_CLIPBOARD(("xclip_handle_SelectionNotify: selection=%s, target=%s, property=%s\n",
                         XGetAtomName(g_display, event->selection),
                         XGetAtomName(g_display, event->target),
                         XGetAtomName(g_display, event->property)));

        if (event->property == None)
                goto fail;

        res = XGetWindowProperty(g_display, g_wnd, rdesktop_clipboard_target_atom,
                                 0, XMaxRequestSize(g_display), True, AnyPropertyType,
                                 &type, &format, &nitems, &bytes_left, &data);

        if (res != Success)
        {
                DEBUG_CLIPBOARD(("XGetWindowProperty failed!\n"));
                goto fail;
        }

        /* Negotiate target format */
        if (event->target == targets_atom)
        {
                /* FIXME: We should choose format here based on what the server wanted */
                best_target = XA_STRING;
                if (type != None)
                {
                        supported_targets = (Atom *) data;
                        text_target = XInternAtom(g_display, "TEXT", False);
                        for (i = 0; i < nitems; i++)
                        {
                                DEBUG_CLIPBOARD(("Target %d: %s\n", i,
                                                 XGetAtomName(g_display, supported_targets[i])));
                                if (supported_targets[i] == text_target)
                                {
                                        DEBUG_CLIPBOARD(("Other party supports TEXT, choosing that as best_target\n"));
                                        best_target = text_target;
                                        break;
                                }
                        }
                        XFree(data);
                }

                XConvertSelection(g_display, primary_atom, best_target,
                                  rdesktop_clipboard_target_atom, g_wnd, event->time);
                return;
        }

        if (type == incr_atom)
        {
                DEBUG_CLIPBOARD(("Received INCR.\n"));

                XGetWindowAttributes(g_display, g_wnd, &wa);
                if ((wa.your_event_mask | PropertyChangeMask) != wa.your_event_mask)
                {
                        XSelectInput(g_display, g_wnd, (wa.your_event_mask | PropertyChangeMask));
                }
                XDeleteProperty(g_display, g_wnd, type);
                XFree(data);
                g_waiting_for_INCR = 1;

                if ((XGetWindowProperty(g_display, g_wnd, rdesktop_clipboard_target_atom, 0,
                                        4096L, True, AnyPropertyType,
                                        &type, &format, &nitems, &bytes_left, &data) != Success))
                {
                        DEBUG_CLIPBOARD(("XGetWindowProperty failed.\n"));
                        goto fail;
                }
                else
                {
                        uint8 *translated_data;
                        uint32 length = nitems;

                        translated_data = lf2crlf(data, &length);

                        g_clip_buffer = (uint8 *) xmalloc(length);
                        strncpy((char *) g_clip_buffer, (char *) translated_data, length);
                        xfree(translated_data);
                        g_clip_buflen = length;

                        XFree(data);
                        return;
                }
        }

        /* Translate linebreaks, but only if not getting data from
           other rdesktop instance */
        if (event->target != rdesktop_clipboard_formats_atom)
        {
                uint8 *translated_data;
                uint32 length = nitems;

                DEBUG_CLIPBOARD(("Translating linebreaks before sending data\n"));
                translated_data = lf2crlf(data, &length);
                cliprdr_send_data(translated_data, length + 1);
                xfree(translated_data); /* Not the same thing as XFree! */
        }
        else
        {
                cliprdr_send_data(data, nitems + 1);
        }
        XFree(data);

        if (!rdesktop_is_selection_owner)
                cliprdr_send_simple_native_format_announce(CF_TEXT);
        return;

      fail:
        cliprdr_send_data(NULL, 0);
}

void
xclip_handle_SelectionRequest(XSelectionRequestEvent * event)
{
        unsigned long nitems, bytes_left;
        unsigned char *prop_return;
        uint32 *wanted_format;
        int format, res;
        Atom type;

        DEBUG_CLIPBOARD(("xclip_handle_SelectionRequest: selection=%s, target=%s, property=%s\n",
                         XGetAtomName(g_display, event->selection),
                         XGetAtomName(g_display, event->target),
                         XGetAtomName(g_display, event->property)));

        if (event->target == targets_atom)
        {
                xclip_provide_selection(event, XA_ATOM, 32, (uint8 *) & targets, NUM_TARGETS);
                return;
        }
        else if (event->target == timestamp_atom)
        {
                xclip_provide_selection(event, XA_INTEGER, 32, (uint8 *) & g_last_gesturetime, 1);
                return;
        }
        else if (event->target == rdesktop_clipboard_formats_atom)
        {
                res = XGetWindowProperty(g_display, event->requestor,
                                         rdesktop_clipboard_target_atom, 0, 1, True, XA_INTEGER,
                                         &type, &format, &nitems, &bytes_left, &prop_return);
                wanted_format = (uint32 *) prop_return;
                format = (res == Success) ? *wanted_format : CF_TEXT;
                /* FIXME: Need to free returned data? */
        }
        else
        {
                format = CF_TEXT;
        }

        cliprdr_send_data_request(format);
        selection_request = *event;
        /* wait for data */
}

void
xclip_handle_SelectionClear(void)
{
        DEBUG_CLIPBOARD(("xclip_handle_SelectionClear\n"));
        have_primary = 0;
        XDeleteProperty(g_display, DefaultRootWindow(g_display), rdesktop_clipboard_formats_atom);
        cliprdr_send_simple_native_format_announce(CF_TEXT);
}

void
xclip_handle_PropertyNotify(XPropertyEvent * event)
{
        unsigned long nitems, bytes_left;
        int format, res;
        XWindowAttributes wa;
        uint8 *data;
        Atom type;

        if (event->state == PropertyNewValue && g_waiting_for_INCR)
        {
                DEBUG_CLIPBOARD(("x_clip_handle_PropertyNotify: g_waiting_for_INCR != 0\n"));
                if ((XGetWindowProperty(g_display, g_wnd, rdesktop_clipboard_target_atom, 0,
                                        4096L, True, AnyPropertyType,
                                        &type, &format, &nitems, &bytes_left, &data) != Success))
                {
                        XFree(data);
                        return;
                }

                if (nitems == 0)
                {
                        XGetWindowAttributes(g_display, g_wnd, &wa);
                        XSelectInput(g_display, g_wnd, (wa.your_event_mask ^ PropertyChangeMask));
                        XFree(data);
                        g_waiting_for_INCR = 0;

                        if (g_clip_buflen > 0)
                        {
                                cliprdr_send_data(g_clip_buffer, g_clip_buflen + 1);

                                if (!rdesktop_is_selection_owner)
                                        cliprdr_send_simple_native_format_announce(CF_TEXT);

                                xfree(g_clip_buffer);
                                g_clip_buffer = 0;
                                g_clip_buflen = 0;
                        }
                }
                else
                {
                        uint8 *translated_data;
                        uint32 length = nitems;
                        uint8 *tmp;

                        DEBUG_CLIPBOARD(("Translating linebreaks before sending data\n"));
                        translated_data = lf2crlf(data, &length);

                        tmp = xmalloc(length + g_clip_buflen);
                        strncpy((char *) tmp, (char *) g_clip_buffer, g_clip_buflen);
                        xfree(g_clip_buffer);

                        strncpy((char *) (tmp + g_clip_buflen), (char *) translated_data, length);
                        xfree(translated_data);

                        g_clip_buffer = tmp;
                        g_clip_buflen += length;

                        XFree(data);
                        return;
                }
        }

        if (event->atom != rdesktop_clipboard_formats_atom)
                return;

        if (have_primary)       /* from us */
                return;

        if (event->state == PropertyNewValue)
        {
                res = XGetWindowProperty(g_display, DefaultRootWindow(g_display),
                                         rdesktop_clipboard_formats_atom, 0,
                                         XMaxRequestSize(g_display), False, XA_STRING, &type,
                                         &format, &nitems, &bytes_left, &data);

                if ((res == Success) && (nitems > 0))
                {
                        cliprdr_send_native_format_announce(data, nitems);
                        rdesktop_is_selection_owner = 1;
                        return;
                }
        }

        /* PropertyDelete, or XGetWindowProperty failed */
        cliprdr_send_simple_native_format_announce(CF_TEXT);
        rdesktop_is_selection_owner = 0;
}
#endif


void
ui_clip_format_announce(uint8 * data, uint32 length)
{
        XSetSelectionOwner(g_display, primary_atom, g_wnd, g_last_gesturetime);
        if (XGetSelectionOwner(g_display, primary_atom) != g_wnd)
        {
                warning("Failed to aquire ownership of PRIMARY clipboard\n");
                return;
        }

        have_primary = 1;
        XChangeProperty(g_display, DefaultRootWindow(g_display),
                        rdesktop_clipboard_formats_atom, XA_STRING, 8, PropModeReplace, data,
                        length);

        XSetSelectionOwner(g_display, clipboard_atom, g_wnd, g_last_gesturetime);
        if (XGetSelectionOwner(g_display, clipboard_atom) != g_wnd)
                warning("Failed to aquire ownership of CLIPBOARD clipboard\n");
}


void
ui_clip_handle_data(uint8 * data, uint32 length)
{
        if (selection_request.target != rdesktop_clipboard_formats_atom)
        {
                uint8 *firstnull;

                /* translate linebreaks */
                crlf2lf(data, &length);

                /* Only send data up to null byte, if any */
                firstnull = (uint8 *) strchr((char *) data, '\0');
                if (firstnull)
                {
                        length = firstnull - data + 1;
                }
        }

        xclip_provide_selection(&selection_request, XA_STRING, 8, data, length - 1);
}

void
ui_clip_request_data(uint32 format)
{
        Window selectionowner;

        DEBUG_CLIPBOARD(("Request from server for format %d\n", format));

        if (rdesktop_is_selection_owner)
        {
                XChangeProperty(g_display, g_wnd, rdesktop_clipboard_target_atom,
                                XA_INTEGER, 32, PropModeReplace, (unsigned char *) &format, 1);

                XConvertSelection(g_display, primary_atom, rdesktop_clipboard_formats_atom,
                                  rdesktop_clipboard_target_atom, g_wnd, CurrentTime);
                return;
        }

        selectionowner = XGetSelectionOwner(g_display, primary_atom);
        if (selectionowner != None)
        {
                XConvertSelection(g_display, primary_atom, targets_atom,
                                  rdesktop_clipboard_target_atom, g_wnd, CurrentTime);
                return;
        }

        /* No PRIMARY, try CLIPBOARD */
        selectionowner = XGetSelectionOwner(g_display, clipboard_atom);
        if (selectionowner != None)
        {
                XConvertSelection(g_display, clipboard_atom, targets_atom,
                                  rdesktop_clipboard_target_atom, g_wnd, CurrentTime);
                return;
        }

        /* No data available */
        cliprdr_send_data(NULL, 0);
}

void
ui_clip_sync(void)
{
        cliprdr_send_simple_native_format_announce(CF_TEXT);
}


void
xclip_init(void)
{
        if (!cliprdr_init())
                return;

        primary_atom = XInternAtom(g_display, "PRIMARY", False);
        clipboard_atom = XInternAtom(g_display, "CLIPBOARD", False);
        targets_atom = XInternAtom(g_display, "TARGETS", False);
        timestamp_atom = XInternAtom(g_display, "TIMESTAMP", False);
        rdesktop_clipboard_target_atom =
                XInternAtom(g_display, "_RDESKTOP_CLIPBOARD_TARGET", False);
        incr_atom = XInternAtom(g_display, "INCR", False);
        targets[0] = targets_atom;
        targets[1] = XInternAtom(g_display, "TEXT", False);
        targets[2] = XInternAtom(g_display, "STRING", False);
        targets[3] = XInternAtom(g_display, "text/unicode", False);
        targets[4] = XInternAtom(g_display, "TIMESTAMP", False);
        targets[5] = XA_STRING;

        /* rdesktop sets _RDESKTOP_CLIPBOARD_FORMATS on the root window when acquiring the clipboard.
           Other interested rdesktops can use this to notify their server of the available formats. */
        rdesktop_clipboard_formats_atom =
                XInternAtom(g_display, "_RDESKTOP_CLIPBOARD_FORMATS", False);
        XSelectInput(g_display, DefaultRootWindow(g_display), PropertyChangeMask);
}
1	matthewc	432	/* -- c-basic-offset: 8 --
2			rdesktop: A Remote Desktop Protocol client.
3			Protocol services - Clipboard functions
4			Copyright (C) Erik Forsberg <forsberg@cendio.se> 2003
5			Copyright (C) Matthew Chapman 2003
6
7			This program is free software; you can redistribute it and/or modify
8			it under the terms of the GNU General Public License as published by
9			the Free Software Foundation; either version 2 of the License, or
10			(at your option) any later version.
11
12			This program is distributed in the hope that it will be useful,
13			but WITHOUT ANY WARRANTY; without even the implied warranty of
14			MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15			GNU General Public License for more details.
16
17			You should have received a copy of the GNU General Public License
18			along with this program; if not, write to the Free Software
19			Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
20			*/
21
22			#include <X11/Xlib.h>
23			#include <X11/Xatom.h>
24			#include "rdesktop.h"
25
26			#define NUM_TARGETS 6
27
28	jsorg71	450	extern Display *g_display;
29			extern Window g_wnd;
30			extern Time g_last_gesturetime;
31	matthewc	432
32			static Atom clipboard_atom, primary_atom, targets_atom, timestamp_atom;
33			static Atom rdesktop_clipboard_target_atom, rdesktop_clipboard_formats_atom, incr_atom;
34			static XSelectionRequestEvent selection_request;
35			static Atom targets[NUM_TARGETS];
36			static int have_primary = 0;
37			static int rdesktop_is_selection_owner = 0;
38
39	astrand	913	static int g_waiting_for_INCR = 0;
40			static uint8 *g_clip_buffer = 0;
41			static uint32 g_clip_buflen = 0;
42	astrand	551
43			/* Replace CR-LF to LF (well, rather removing all CR:s) This is done
44			in-place. The length is updated. Handles embedded nulls */
45	matthewc	432	static void
46	astrand	551	crlf2lf(uint8 * data, uint32 * length)
47			{
48			uint8 dst, src;
49			src = dst = data;
50			while (src < data + *length)
51			{
52			if (*src != '\x0d')
53			dst++ = src;
54			src++;
55			}
56			*length = dst - data;
57			}
58
59			/* Translate LF to CR-LF. To do this, we must allocate more memory.
60			The length is updated. */
61			static uint8 *
62			lf2crlf(uint8 * data, uint32 * length)
63			{
64			uint8 result, p, *o;
65
66			/* Worst case: Every char is LF */
67			result = xmalloc(length 2);
68
69			p = data;
70			o = result;
71
72			while (p < data + *length)
73			{
74			if (*p == '\x0a')
75			*o++ = '\x0d';
76			o++ = p++;
77			}
78			*length = o - result;
79
80			/* Convenience */
81			*o++ = '\0';
82
83			return result;
84			}
85
86
87			static void
88	astrand	435	xclip_provide_selection(XSelectionRequestEvent * req, Atom type, unsigned int format, uint8 * data,
89			uint32 length)
90	matthewc	432	{
91			XEvent xev;
92
93	jsorg71	450	XChangeProperty(g_display, req->requestor, req->property,
94	matthewc	432	type, format, PropModeReplace, data, length);
95
96			xev.xselection.type = SelectionNotify;
97			xev.xselection.serial = 0;
98			xev.xselection.send_event = True;
99			xev.xselection.requestor = req->requestor;
100			xev.xselection.selection = req->selection;
101			xev.xselection.target = req->target;
102			xev.xselection.property = req->property;
103			xev.xselection.time = req->time;
104	jsorg71	450	XSendEvent(g_display, req->requestor, False, NoEventMask, &xev);
105	matthewc	432	}
106
107	astrand	942	#ifndef MAKE_PROTO
108	astrand	462	void
109	matthewc	432	xclip_handle_SelectionNotify(XSelectionEvent * event)
110			{
111			unsigned long nitems, bytes_left;
112	astrand	913	XWindowAttributes wa;
113	matthewc	432	Atom type, best_target, text_target;
114			Atom *supported_targets;
115			int res, i, format;
116			uint8 *data;
117
118			if (event->property == None)
119			goto fail;
120
121			DEBUG_CLIPBOARD(("xclip_handle_SelectionNotify: selection=%s, target=%s, property=%s\n",
122	jsorg71	450	XGetAtomName(g_display, event->selection),
123			XGetAtomName(g_display, event->target),
124			XGetAtomName(g_display, event->property)));
125	matthewc	432
126			if (event->property == None)
127			goto fail;
128
129	jsorg71	450	res = XGetWindowProperty(g_display, g_wnd, rdesktop_clipboard_target_atom,
130			0, XMaxRequestSize(g_display), True, AnyPropertyType,
131	matthewc	432	&type, &format, &nitems, &bytes_left, &data);
132
133			if (res != Success)
134			{
135			DEBUG_CLIPBOARD(("XGetWindowProperty failed!\n"));
136			goto fail;
137			}
138
139	astrand	551	/* Negotiate target format */
140	matthewc	432	if (event->target == targets_atom)
141			{
142			/* FIXME: We should choose format here based on what the server wanted */
143			best_target = XA_STRING;
144			if (type != None)
145			{
146			supported_targets = (Atom *) data;
147	jsorg71	450	text_target = XInternAtom(g_display, "TEXT", False);
148	matthewc	432	for (i = 0; i < nitems; i++)
149			{
150	astrand	435	DEBUG_CLIPBOARD(("Target %d: %s\n", i,
151	jsorg71	450	XGetAtomName(g_display, supported_targets[i])));
152	matthewc	432	if (supported_targets[i] == text_target)
153			{
154			DEBUG_CLIPBOARD(("Other party supports TEXT, choosing that as best_target\n"));
155			best_target = text_target;
156	astrand	551	break;
157	matthewc	432	}
158			}
159			XFree(data);
160			}
161
162	jsorg71	450	XConvertSelection(g_display, primary_atom, best_target,
163			rdesktop_clipboard_target_atom, g_wnd, event->time);
164	matthewc	432	return;
165			}
166
167			if (type == incr_atom)
168			{
169	astrand	913	DEBUG_CLIPBOARD(("Received INCR.\n"));
170
171			XGetWindowAttributes(g_display, g_wnd, &wa);
172			if ((wa.your_event_mask \| PropertyChangeMask) != wa.your_event_mask)
173			{
174			XSelectInput(g_display, g_wnd, (wa.your_event_mask \| PropertyChangeMask));
175			}
176			XDeleteProperty(g_display, g_wnd, type);
177			XFree(data);
178			g_waiting_for_INCR = 1;
179
180			if ((XGetWindowProperty(g_display, g_wnd, rdesktop_clipboard_target_atom, 0,
181			4096L, True, AnyPropertyType,
182			&type, &format, &nitems, &bytes_left, &data) != Success))
183			{
184			DEBUG_CLIPBOARD(("XGetWindowProperty failed.\n"));
185			goto fail;
186			}
187			else
188			{
189			uint8 *translated_data;
190			uint32 length = nitems;
191
192			translated_data = lf2crlf(data, &length);
193
194			g_clip_buffer = (uint8 *) xmalloc(length);
195	astrand	941	strncpy((char ) g_clip_buffer, (char ) translated_data, length);
196	astrand	913	xfree(translated_data);
197			g_clip_buflen = length;
198
199			XFree(data);
200			return;
201			}
202	matthewc	432	}
203
204	astrand	551	/* Translate linebreaks, but only if not getting data from
205			other rdesktop instance */
206			if (event->target != rdesktop_clipboard_formats_atom)
207			{
208			uint8 *translated_data;
209			uint32 length = nitems;
210
211			DEBUG_CLIPBOARD(("Translating linebreaks before sending data\n"));
212			translated_data = lf2crlf(data, &length);
213			cliprdr_send_data(translated_data, length + 1);
214			xfree(translated_data); /* Not the same thing as XFree! */
215			}
216			else
217			{
218			cliprdr_send_data(data, nitems + 1);
219			}
220	matthewc	432	XFree(data);
221
222			if (!rdesktop_is_selection_owner)
223	forsberg	1025	cliprdr_send_simple_native_format_announce(CF_TEXT);
224	matthewc	432	return;
225
226	astrand	435	fail:
227	matthewc	432	cliprdr_send_data(NULL, 0);
228			}
229
230	astrand	462	void
231	astrand	435	xclip_handle_SelectionRequest(XSelectionRequestEvent * event)
232	matthewc	432	{
233			unsigned long nitems, bytes_left;
234	astrand	465	unsigned char *prop_return;
235	matthewc	432	uint32 *wanted_format;
236			int format, res;
237			Atom type;
238
239			DEBUG_CLIPBOARD(("xclip_handle_SelectionRequest: selection=%s, target=%s, property=%s\n",
240	jsorg71	450	XGetAtomName(g_display, event->selection),
241			XGetAtomName(g_display, event->target),
242			XGetAtomName(g_display, event->property)));
243	matthewc	432
244			if (event->target == targets_atom)
245			{
246	astrand	435	xclip_provide_selection(event, XA_ATOM, 32, (uint8 *) & targets, NUM_TARGETS);
247	matthewc	432	return;
248			}
249			else if (event->target == timestamp_atom)
250			{
251	jsorg71	450	xclip_provide_selection(event, XA_INTEGER, 32, (uint8 *) & g_last_gesturetime, 1);
252	matthewc	432	return;
253			}
254			else if (event->target == rdesktop_clipboard_formats_atom)
255			{
256	jsorg71	450	res = XGetWindowProperty(g_display, event->requestor,
257	astrand	435	rdesktop_clipboard_target_atom, 0, 1, True, XA_INTEGER,
258	astrand	468	&type, &format, &nitems, &bytes_left, &prop_return);
259	astrand	465	wanted_format = (uint32 *) prop_return;
260	matthewc	432	format = (res == Success) ? *wanted_format : CF_TEXT;
261	astrand	465	/* FIXME: Need to free returned data? */
262	matthewc	432	}
263			else
264			{
265			format = CF_TEXT;
266			}
267
268			cliprdr_send_data_request(format);
269			selection_request = *event;
270			/* wait for data */
271			}
272
273	astrand	462	void
274	matthewc	432	xclip_handle_SelectionClear(void)
275			{
276			DEBUG_CLIPBOARD(("xclip_handle_SelectionClear\n"));
277			have_primary = 0;
278	jsorg71	450	XDeleteProperty(g_display, DefaultRootWindow(g_display), rdesktop_clipboard_formats_atom);
279	forsberg	1025	cliprdr_send_simple_native_format_announce(CF_TEXT);
280	matthewc	432	}
281
282	astrand	462	void
283	astrand	435	xclip_handle_PropertyNotify(XPropertyEvent * event)
284	matthewc	432	{
285			unsigned long nitems, bytes_left;
286			int format, res;
287	astrand	913	XWindowAttributes wa;
288	matthewc	432	uint8 *data;
289			Atom type;
290
291	astrand	913	if (event->state == PropertyNewValue && g_waiting_for_INCR)
292			{
293			DEBUG_CLIPBOARD(("x_clip_handle_PropertyNotify: g_waiting_for_INCR != 0\n"));
294			if ((XGetWindowProperty(g_display, g_wnd, rdesktop_clipboard_target_atom, 0,
295			4096L, True, AnyPropertyType,
296			&type, &format, &nitems, &bytes_left, &data) != Success))
297			{
298			XFree(data);
299			return;
300			}
301
302			if (nitems == 0)
303			{
304			XGetWindowAttributes(g_display, g_wnd, &wa);
305			XSelectInput(g_display, g_wnd, (wa.your_event_mask ^ PropertyChangeMask));
306			XFree(data);
307			g_waiting_for_INCR = 0;
308
309			if (g_clip_buflen > 0)
310			{
311			cliprdr_send_data(g_clip_buffer, g_clip_buflen + 1);
312
313			if (!rdesktop_is_selection_owner)
314	forsberg	1025	cliprdr_send_simple_native_format_announce(CF_TEXT);
315	astrand	913
316			xfree(g_clip_buffer);
317			g_clip_buffer = 0;
318			g_clip_buflen = 0;
319			}
320			}
321			else
322			{
323			uint8 *translated_data;
324			uint32 length = nitems;
325	stargo	940	uint8 *tmp;
326	astrand	913
327			DEBUG_CLIPBOARD(("Translating linebreaks before sending data\n"));
328			translated_data = lf2crlf(data, &length);
329
330	stargo	940	tmp = xmalloc(length + g_clip_buflen);
331	astrand	941	strncpy((char ) tmp, (char ) g_clip_buffer, g_clip_buflen);
332	astrand	913	xfree(g_clip_buffer);
333
334	astrand	941	strncpy((char ) (tmp + g_clip_buflen), (char ) translated_data, length);
335	astrand	913	xfree(translated_data);
336
337			g_clip_buffer = tmp;
338			g_clip_buflen += length;
339
340			XFree(data);
341			return;
342			}
343			}
344
345	matthewc	432	if (event->atom != rdesktop_clipboard_formats_atom)
346			return;
347
348	astrand	435	if (have_primary) /* from us */
349	matthewc	432	return;
350
351			if (event->state == PropertyNewValue)
352			{
353	jsorg71	450	res = XGetWindowProperty(g_display, DefaultRootWindow(g_display),
354	astrand	435	rdesktop_clipboard_formats_atom, 0,
355	astrand	456	XMaxRequestSize(g_display), False, XA_STRING, &type,
356			&format, &nitems, &bytes_left, &data);
357	matthewc	432
358			if ((res == Success) && (nitems > 0))
359			{
360			cliprdr_send_native_format_announce(data, nitems);
361			rdesktop_is_selection_owner = 1;
362			return;
363			}
364			}
365
366			/* PropertyDelete, or XGetWindowProperty failed */
367	forsberg	1025	cliprdr_send_simple_native_format_announce(CF_TEXT);
368	matthewc	432	rdesktop_is_selection_owner = 0;
369			}
370	astrand	942	#endif
371	matthewc	432
372
373			void
374	astrand	542	ui_clip_format_announce(uint8 * data, uint32 length)
375	matthewc	432	{
376	jsorg71	450	XSetSelectionOwner(g_display, primary_atom, g_wnd, g_last_gesturetime);
377			if (XGetSelectionOwner(g_display, primary_atom) != g_wnd)
378	matthewc	432	{
379			warning("Failed to aquire ownership of PRIMARY clipboard\n");
380			return;
381			}
382
383			have_primary = 1;
384	jsorg71	450	XChangeProperty(g_display, DefaultRootWindow(g_display),
385	astrand	435	rdesktop_clipboard_formats_atom, XA_STRING, 8, PropModeReplace, data,
386			length);
387	matthewc	432
388	jsorg71	450	XSetSelectionOwner(g_display, clipboard_atom, g_wnd, g_last_gesturetime);
389			if (XGetSelectionOwner(g_display, clipboard_atom) != g_wnd)
390	matthewc	432	warning("Failed to aquire ownership of CLIPBOARD clipboard\n");
391			}
392
393
394			void
395	astrand	542	ui_clip_handle_data(uint8 * data, uint32 length)
396	matthewc	432	{
397	astrand	551	if (selection_request.target != rdesktop_clipboard_formats_atom)
398			{
399			uint8 *firstnull;
400
401			/* translate linebreaks */
402			crlf2lf(data, &length);
403
404			/* Only send data up to null byte, if any */
405	astrand	608	firstnull = (uint8 ) strchr((char ) data, '\0');
406	astrand	551	if (firstnull)
407			{
408			length = firstnull - data + 1;
409			}
410			}
411
412	astrand	435	xclip_provide_selection(&selection_request, XA_STRING, 8, data, length - 1);
413	matthewc	432	}
414
415			void
416			ui_clip_request_data(uint32 format)
417			{
418			Window selectionowner;
419
420			DEBUG_CLIPBOARD(("Request from server for format %d\n", format));
421
422			if (rdesktop_is_selection_owner)
423			{
424	jsorg71	450	XChangeProperty(g_display, g_wnd, rdesktop_clipboard_target_atom,
425	matthewc	432	XA_INTEGER, 32, PropModeReplace, (unsigned char *) &format, 1);
426
427	jsorg71	450	XConvertSelection(g_display, primary_atom, rdesktop_clipboard_formats_atom,
428			rdesktop_clipboard_target_atom, g_wnd, CurrentTime);
429	matthewc	432	return;
430			}
431
432	jsorg71	450	selectionowner = XGetSelectionOwner(g_display, primary_atom);
433	matthewc	432	if (selectionowner != None)
434			{
435	jsorg71	450	XConvertSelection(g_display, primary_atom, targets_atom,
436			rdesktop_clipboard_target_atom, g_wnd, CurrentTime);
437	matthewc	432	return;
438			}
439
440			/* No PRIMARY, try CLIPBOARD */
441	jsorg71	450	selectionowner = XGetSelectionOwner(g_display, clipboard_atom);
442	matthewc	432	if (selectionowner != None)
443			{
444	jsorg71	450	XConvertSelection(g_display, clipboard_atom, targets_atom,
445			rdesktop_clipboard_target_atom, g_wnd, CurrentTime);
446	matthewc	432	return;
447			}
448
449			/* No data available */
450			cliprdr_send_data(NULL, 0);
451			}
452
453			void
454			ui_clip_sync(void)
455			{
456	forsberg	1025	cliprdr_send_simple_native_format_announce(CF_TEXT);
457	matthewc	432	}
458
459
460			void
461			xclip_init(void)
462			{
463			if (!cliprdr_init())
464			return;
465
466	jsorg71	450	primary_atom = XInternAtom(g_display, "PRIMARY", False);
467			clipboard_atom = XInternAtom(g_display, "CLIPBOARD", False);
468			targets_atom = XInternAtom(g_display, "TARGETS", False);
469			timestamp_atom = XInternAtom(g_display, "TIMESTAMP", False);
470	astrand	456	rdesktop_clipboard_target_atom =
471			XInternAtom(g_display, "_RDESKTOP_CLIPBOARD_TARGET", False);
472	jsorg71	450	incr_atom = XInternAtom(g_display, "INCR", False);
473	matthewc	432	targets[0] = targets_atom;
474	jsorg71	450	targets[1] = XInternAtom(g_display, "TEXT", False);
475	forsberg	707	targets[2] = XInternAtom(g_display, "STRING", False);
476	jsorg71	450	targets[3] = XInternAtom(g_display, "text/unicode", False);
477			targets[4] = XInternAtom(g_display, "TIMESTAMP", False);
478	matthewc	432	targets[5] = XA_STRING;
479
480			/* rdesktop sets _RDESKTOP_CLIPBOARD_FORMATS on the root window when acquiring the clipboard.
481			Other interested rdesktops can use this to notify their server of the available formats. */
482	astrand	435	rdesktop_clipboard_formats_atom =
483	jsorg71	450	XInternAtom(g_display, "_RDESKTOP_CLIPBOARD_FORMATS", False);
484			XSelectInput(g_display, DefaultRootWindow(g_display), PropertyChangeMask);
485	matthewc	432	}