uLab
/
xrdp-proprietary
mirror of https://mirror.git.trinitydesktop.org/gitea/uLab/xrdp-proprietary
0
0
Fork 0
Code Issues Releases Wiki Activity

clipboard: added image support

Browse Source
master
Jay Sorg 12 years ago
parent da9d55f180
commit 68ef36cc02
2 changed files with 347 additions and 20 deletions
Show Stats Download Patch File Download Diff File

350
sesman/chansrv/clipboard.c
Unescape View File

@ -2,6 +2,7 @@
* xrdp: A Remote Desktop Protocol server. * xrdp: A Remote Desktop Protocol server.
* *
* Copyright (C) Jay Sorg 2009-2012 * Copyright (C) Jay Sorg 2009-2012
* Copyright (C) Laxmikant Rashinkar 2012
* *
* Licensed under the Apache License, Version 2.0 (the "License"); * Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
@ -19,6 +20,11 @@
for help see for help see
http://tronche.com/gui/x/icccm/sec-2.html#s-2 http://tronche.com/gui/x/icccm/sec-2.html#s-2
.../kde/kdebase/workspace/klipper/clipboardpoll.cpp .../kde/kdebase/workspace/klipper/clipboardpoll.cpp
Revision:
Aug 05, 2012:
Laxmikant Rashinkar (LK dot Rashinkar at gmail.com)
added clipboard support for BMP images
*/ */
#include <X11/Xlib.h> #include <X11/Xlib.h>
@ -31,6 +37,15 @@
#include "clipboard.h" #include "clipboard.h"
#include "xcommon.h" #include "xcommon.h"
static char g_bmp_image_header[] =
{
/* this is known to work */
//0x42, 0x4d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
/* THIS IS BEING SENT BY WIN2008 */
0x42, 0x4d, 0x16, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x36, 0x00, 0x00, 0x00
};
extern int g_cliprdr_chan_id; /* in chansrv.c */ extern int g_cliprdr_chan_id; /* in chansrv.c */
extern Display* g_display; /* in xcommon.c */ extern Display* g_display; /* in xcommon.c */
@ -52,6 +67,8 @@ static Atom g_primary_atom = 0;
static Atom g_secondary_atom = 0; static Atom g_secondary_atom = 0;
static Atom g_get_time_atom = 0; static Atom g_get_time_atom = 0;
static Atom g_utf8_atom = 0; static Atom g_utf8_atom = 0;
static Atom g_image_bmp_atom = 0;
static Window g_wnd = 0; static Window g_wnd = 0;
static int g_xfixes_event_base = 0; static int g_xfixes_event_base = 0;
@ -73,6 +90,20 @@ static int g_data_in_time = 0;
static int g_data_in_up_to_date = 0; static int g_data_in_up_to_date = 0;
static int g_got_format_announce = 0; static int g_got_format_announce = 0;
/* for image data */
static int g_want_image_data = 0;
static XSelectionRequestEvent g_saved_selection_req_event;
/* for clipboard INCR transfers */
static Atom g_incr_atom;
static Atom g_incr_atom_type;
static Atom g_incr_atom_target;
static char* g_incr_data;
static int g_incr_data_size;
static int g_incr_in_progress = 0;
static clipboard_format_id = CB_FORMAT_UNICODETEXT;
/*****************************************************************************/ /*****************************************************************************/
/* this is one way to get the current time from the x server */ /* this is one way to get the current time from the x server */
static Time APP_CC static Time APP_CC
@ -93,6 +124,17 @@ clipboard_get_server_time(void)
return xevent.xproperty.time; return xevent.xproperty.time;
} }
/*****************************************************************************/
/* returns time in miliseconds
this is like g_time2 in os_calls, but not miliseconds since machine was
up, something else
this is a time value similar to what the xserver uses */
static int APP_CC
clipboard_get_local_time(void)
{
return g_time3();
}
/*****************************************************************************/ /*****************************************************************************/
/* returns error */ /* returns error */
int APP_CC int APP_CC
@ -149,6 +191,10 @@ clipboard_init(void)
g_primary_atom = XInternAtom(g_display, "PRIMARY", False); g_primary_atom = XInternAtom(g_display, "PRIMARY", False);
g_secondary_atom = XInternAtom(g_display, "SECONDARY", False); g_secondary_atom = XInternAtom(g_display, "SECONDARY", False);
g_utf8_atom = XInternAtom(g_display, "UTF8_STRING", False); g_utf8_atom = XInternAtom(g_display, "UTF8_STRING", False);
g_image_bmp_atom = XInternAtom(g_display, "image/bmp", False);
g_incr_atom = XInternAtom(g_display, "INCR", False);
g_wnd = XCreateSimpleWindow(g_display, RootWindowOfScreen(g_screen), g_wnd = XCreateSimpleWindow(g_display, RootWindowOfScreen(g_screen),
0, 0, 4, 4, 0, 0, 0); 0, 0, 4, 4, 0, 0, 0);
input_mask = StructureNotifyMask | PropertyChangeMask; input_mask = StructureNotifyMask | PropertyChangeMask;
@ -233,7 +279,7 @@ clipboard_send_data_request(void)
out_uint16_le(s, 4); /* CLIPRDR_DATA_REQUEST */ out_uint16_le(s, 4); /* CLIPRDR_DATA_REQUEST */
out_uint16_le(s, 0); /* status */ out_uint16_le(s, 0); /* status */
out_uint32_le(s, 4); /* length */ out_uint32_le(s, 4); /* length */
out_uint32_le(s, 0x0d); out_uint32_le(s, clipboard_format_id);
s_mark_end(s); s_mark_end(s);
size = (int)(s->end - s->data); size = (int)(s->end - s->data);
LOGM((LOG_LEVEL_DEBUG,"clipboard_send_data_request: data out, sending " LOGM((LOG_LEVEL_DEBUG,"clipboard_send_data_request: data out, sending "
@ -266,21 +312,32 @@ clipboard_send_format_ack(void)
return rv; return rv;
} }
static char windows_native_format[] =
{
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
};
/*****************************************************************************/ /*****************************************************************************/
static int APP_CC static int APP_CC
clipboard_send_format_announce(void) clipboard_send_format_announce(tui32 format_id, char* format_name)
{ {
struct stream* s; struct stream* s;
int size; int size;
int rv; int rv;
unsigned char format_buf[32];
g_memset(format_buf, 0, 32);
g_snprintf(format_buf, 31, "Native");
make_stream(s); make_stream(s);
init_stream(s, 8192); init_stream(s, 8192);
out_uint16_le(s, 2); /* CLIPRDR_FORMAT_ANNOUNCE */ out_uint16_le(s, 2); /* CLIPRDR_FORMAT_ANNOUNCE */
out_uint16_le(s, 0); /* status */ out_uint16_le(s, 0); /* status */
out_uint32_le(s, 0x90); /* length */ out_uint32_le(s, 4 + sizeof(windows_native_format)); /* length */
out_uint32_le(s, 0x0d); /* extra 4 bytes ? */ out_uint32_le(s, format_id);
out_uint8s(s, 0x90); out_uint8p(s, windows_native_format, sizeof(windows_native_format));
s_mark_end(s); s_mark_end(s);
size = (int)(s->end - s->data); size = (int)(s->end - s->data);
LOGM((LOG_LEVEL_DEBUG,"clipboard_send_format_announce: data out, sending " LOGM((LOG_LEVEL_DEBUG,"clipboard_send_format_announce: data out, sending "
@ -320,6 +377,39 @@ clipboard_out_unicode(struct stream* s, char* text, int num_chars)
return index * 2; return index * 2;
} }
/*****************************************************************************/
static int APP_CC
clipboard_send_data_response_for_image(void)
{
struct stream* s;
int size;
int rv;
LOG(10, ("clipboard_send_data_response_for_image: g_last_clip_size %d\n",
g_last_clip_size));
make_stream(s);
init_stream(s, 64 + g_last_clip_size);
out_uint16_le(s, 5); /* CLIPRDR_DATA_RESPONSE */
out_uint16_le(s, 1); /* status */
out_uint32_le(s, g_last_clip_size); /* length */
/* insert image data */
if (g_last_clip_type == g_image_bmp_atom)
{
/* do not insert first header */
out_uint8p(s, g_last_clip_data + 14, g_last_clip_size - 14);
}
out_uint16_le(s, 0); /* nil for string */
out_uint32_le(s, 0);
out_uint32_le(s, 0);
out_uint32_le(s, 0);
s_mark_end(s);
size = (int)(s->end - s->data);
/* HANGING HERE WHEN IMAGE DATA IS TOO BIG!!!! */
rv = send_channel_data(g_cliprdr_chan_id, s->data, size);
free_stream(s);
return rv;
}
/*****************************************************************************/ /*****************************************************************************/
static int APP_CC static int APP_CC
clipboard_send_data_response(void) clipboard_send_data_response(void)
@ -333,6 +423,10 @@ clipboard_send_data_response(void)
num_chars = 0; num_chars = 0;
if (g_last_clip_data != 0) if (g_last_clip_data != 0)
{ {
if (g_last_clip_type == g_image_bmp_atom)
{
return clipboard_send_data_response_for_image();
}
if ((g_last_clip_type == XA_STRING) || (g_last_clip_type == g_utf8_atom)) if ((g_last_clip_type == XA_STRING) || (g_last_clip_type == g_utf8_atom))
{ {
num_chars = g_mbstowcs(0, g_last_clip_data, 0); num_chars = g_mbstowcs(0, g_last_clip_data, 0);
@ -467,6 +561,68 @@ clipboard_process_data_request(struct stream* s, int clip_msg_status,
return 0; return 0;
} }
/*****************************************************************************/
/* sent as a reply to CB_FORMAT_DATA_REQUEST; used to indicate whether
processing of the CB_FORMAT_DATA_REQUEST was successful; if processing
was successful, CB_FORMAT_DATA_RESPONSE includes contents of requested
clipboard data. */
static int APP_CC
clipboard_process_data_response_for_image(struct stream * s,
int clip_msg_status,
int clip_msg_len)
{
XSelectionRequestEvent* lxev = &g_saved_selection_req_event;
char* cptr;
char cdata;
int len;
int index;
int data_in_len;
LOGM((LOG_LEVEL_DEBUG, "clipboard_process_data_response_for_image: "
"CLIPRDR_DATA_RESPONSE_FOR_IMAGE"));
g_waiting_for_data_response = 0;
len = (int)(s->end - s->p);
if (len < 1)
{
return 0;
}
if (g_last_clip_type == g_image_bmp_atom)
{
/* space for inserting bmp image header */
len += 14;
cptr = (char*)g_malloc(len, 0);
if (cptr == 0)
{
return 0;
}
g_memcpy(cptr, g_bmp_image_header, 14);
index = 14;
}
else
{
return;
}
while (s_check(s))
{
in_uint8(s, cdata);
cptr[index++] = cdata;
}
if (len >= 0)
{
g_data_in = cptr;
g_data_in_size = len;
g_data_in_time = clipboard_get_local_time();
g_data_in_up_to_date = 1;
}
clipboard_provide_selection(lxev, lxev->target, 8, cptr, len);
return 0;
}
/*****************************************************************************/
/* sent as a reply to CB_FORMAT_DATA_REQUEST; used to indicate whether
processing of the CB_FORMAT_DATA_REQUEST was successful; if processing was
successful, CB_FORMAT_DATA_RESPONSE includes contents of requested
clipboard data. */
/*****************************************************************************/ /*****************************************************************************/
static int APP_CC static int APP_CC
clipboard_process_data_response(struct stream* s, int clip_msg_status, clipboard_process_data_response(struct stream* s, int clip_msg_status,
@ -479,6 +635,12 @@ clipboard_process_data_response(struct stream* s, int clip_msg_status,
int index; int index;
int data_in_len; int data_in_len;
if (g_want_image_data)
{
g_want_image_data = 0;
clipboard_process_data_response_for_image(s, clip_msg_status, clip_msg_len);
return 0;
}
LOGM((LOG_LEVEL_DEBUG,"clipboard_process_data_response: " LOGM((LOG_LEVEL_DEBUG,"clipboard_process_data_response: "
"CLIPRDR_DATA_RESPONSE")); "CLIPRDR_DATA_RESPONSE"));
g_waiting_for_data_response = 0; g_waiting_for_data_response = 0;
@ -581,19 +743,31 @@ clipboard_data_in(struct stream* s, int chan_id, int chan_flags, int length,
rv = 0; rv = 0;
switch (clip_msg_id) switch (clip_msg_id)
{ {
case 2: /* CLIPRDR_FORMAT_ANNOUNCE */ /* sent by client or server when its local system clipboard is */
/* updated with new clipboard data; contains Clipboard Format ID */
/* and name pairs of new Clipboard Formats on the clipboard. */
case CB_FORMAT_LIST: /* CLIPRDR_FORMAT_ANNOUNCE */
rv = clipboard_process_format_announce(ls, clip_msg_status, rv = clipboard_process_format_announce(ls, clip_msg_status,
clip_msg_len); clip_msg_len);
break; break;
case 3: /* CLIPRDR_FORMAT_ACK */ /* response to CB_FORMAT_LIST; used to indicate whether */
/* processing of the Format List PDU was successful */
case CB_FORMAT_LIST_RESPONSE: /* CLIPRDR_FORMAT_ACK */
rv = clipboard_prcoess_format_ack(ls, clip_msg_status, rv = clipboard_prcoess_format_ack(ls, clip_msg_status,
clip_msg_len); clip_msg_len);
break; break;
case 4: /* CLIPRDR_DATA_REQUEST */ /* sent by recipient of CB_FORMAT_LIST; used to request data for one */
/* of the formats that was listed in CB_FORMAT_LIST */
case CB_FORMAT_DATA_REQUEST: /* CLIPRDR_DATA_REQUEST */
rv = clipboard_process_data_request(ls, clip_msg_status, rv = clipboard_process_data_request(ls, clip_msg_status,
clip_msg_len); clip_msg_len);
break; break;
case 5: /* CLIPRDR_DATA_RESPONSE */ /* sent as a reply to CB_FORMAT_DATA_REQUEST; used to indicate */
/* whether processing of the CB_FORMAT_DATA_REQUEST was */
/* successful; if processing was successful, */
/* CB_FORMAT_DATA_RESPONSE includes contents of requested */
/* clipboard data. */
case CB_FORMAT_DATA_RESPONSE: /* CLIPRDR_DATA_RESPONSE */
rv = clipboard_process_data_response(ls, clip_msg_status, rv = clipboard_process_data_response(ls, clip_msg_status,
clip_msg_len); clip_msg_len);
break; break;
@ -668,6 +842,18 @@ clipboard_get_window_property(Window wnd, Atom prop, Atom* type, int* fmt,
/* XGetWindowProperty failed */ /* XGetWindowProperty failed */
return 1; return 1;
} }
if (ltype == g_incr_atom)
{
g_incr_in_progress = 1;
g_incr_atom_type = prop;
g_incr_data_size = 0;
g_free(g_incr_data);
g_incr_data = 0;
XDeleteProperty(g_display, g_wnd, prop);
return;
}
if (llen_after < 1) if (llen_after < 1)
{ {
/* no data, ok */ /* no data, ok */
@ -748,10 +934,13 @@ clipboard_event_selection_notify(XEvent* xevent)
int index; int index;
int convert_to_string; int convert_to_string;
int convert_to_utf8; int convert_to_utf8;
int convert_to_bmp_image;
int send_format_announce; int send_format_announce;
int atom; int atom;
int* atoms; int* atoms;
Atom type; Atom type;
tui32 format_id;
unsigned char format_name[32];
LOGM((LOG_LEVEL_DEBUG, "clipboard_event_selection_notify:")); LOGM((LOG_LEVEL_DEBUG, "clipboard_event_selection_notify:"));
data_size = 0; data_size = 0;
@ -764,6 +953,7 @@ clipboard_event_selection_notify(XEvent* xevent)
data = 0; data = 0;
type = 0; type = 0;
lxevent = (XSelectionEvent*)xevent; lxevent = (XSelectionEvent*)xevent;
g_memset(format_name, 0, 32);
if (lxevent->property == None) if (lxevent->property == None)
{ {
LOGM((LOG_LEVEL_ERROR, "clipboard_event_selection_notify: clip could " LOGM((LOG_LEVEL_ERROR, "clipboard_event_selection_notify: clip could "
@ -772,6 +962,13 @@ clipboard_event_selection_notify(XEvent* xevent)
} }
if (rv == 0) if (rv == 0)
{ {
/* we need this if the call below turns out to be a
clipboard INCR operation */
if (!g_incr_in_progress)
{
g_incr_atom_target = lxevent->target;
}
rv = clipboard_get_window_property(lxevent->requestor, lxevent->property, rv = clipboard_get_window_property(lxevent->requestor, lxevent->property,
&type, &fmt, &type, &fmt,
&n_items, &data, &data_size); &n_items, &data, &data_size);
@ -804,6 +1001,10 @@ clipboard_event_selection_notify(XEvent* xevent)
{ {
convert_to_string = 1; convert_to_string = 1;
} }
else if (atom == g_image_bmp_atom)
{
convert_to_bmp_image = 1;
}
} }
} }
else else
@ -818,6 +1019,7 @@ clipboard_event_selection_notify(XEvent* xevent)
LOGM((LOG_LEVEL_DEBUG,"clipboard_event_selection_notify: UTF8_STRING " LOGM((LOG_LEVEL_DEBUG,"clipboard_event_selection_notify: UTF8_STRING "
"data_size %d", data_size)); "data_size %d", data_size));
g_free(g_last_clip_data); g_free(g_last_clip_data);
g_last_clip_data = 0;
g_last_clip_size = data_size; g_last_clip_size = data_size;
g_last_clip_data = g_malloc(g_last_clip_size + 1, 0); g_last_clip_data = g_malloc(g_last_clip_size + 1, 0);
g_last_clip_type = g_utf8_atom; g_last_clip_type = g_utf8_atom;
@ -830,12 +1032,28 @@ clipboard_event_selection_notify(XEvent* xevent)
LOGM((LOG_LEVEL_DEBUG,"clipboard_event_selection_notify: XA_STRING " LOGM((LOG_LEVEL_DEBUG,"clipboard_event_selection_notify: XA_STRING "
"data_size %d", data_size)); "data_size %d", data_size));
g_free(g_last_clip_data); g_free(g_last_clip_data);
g_last_clip_data = 0;
g_last_clip_size = data_size; g_last_clip_size = data_size;
g_last_clip_data = g_malloc(g_last_clip_size + 1, 0); g_last_clip_data = g_malloc(g_last_clip_size + 1, 0);
g_last_clip_type = XA_STRING; g_last_clip_type = XA_STRING;
g_memcpy(g_last_clip_data, data, g_last_clip_size); g_memcpy(g_last_clip_data, data, g_last_clip_size);
g_last_clip_data[g_last_clip_size] = 0; g_last_clip_data[g_last_clip_size] = 0;
send_format_announce = 1; send_format_announce = 1;
format_id = CB_FORMAT_UNICODETEXT;
}
else if (lxevent->target == g_image_bmp_atom)
{
LOGM((LOG_LEVEL_DEBUG, "clipboard_event_selection_notify: image/bmp "
"data_size %d", data_size));
g_free(g_last_clip_data);
g_last_clip_data = 0;
g_last_clip_size = data_size;
g_last_clip_data = g_malloc(data_size, 0);
g_last_clip_type = g_image_bmp_atom;
g_memcpy(g_last_clip_data, data, data_size);
send_format_announce = 1;
format_id = CB_FORMAT_DIB;
g_strcpy(format_name, "image/bmp");
} }
else else
{ {
@ -859,9 +1077,14 @@ clipboard_event_selection_notify(XEvent* xevent)
XConvertSelection(g_display, g_clipboard_atom, XA_STRING, XConvertSelection(g_display, g_clipboard_atom, XA_STRING,
g_clip_property_atom, g_wnd, lxevent->time); g_clip_property_atom, g_wnd, lxevent->time);
} }
else if (convert_to_bmp_image)
{
XConvertSelection(g_display, g_clipboard_atom, g_image_bmp_atom,
g_clip_property_atom, g_wnd, lxevent->time);
}
if (send_format_announce) if (send_format_announce)
{ {
if (clipboard_send_format_announce() != 0) if (clipboard_send_format_announce(format_id, format_name) != 0)
{ {
rv = 4; rv = 4;
} }
@ -885,17 +1108,23 @@ clipboard_event_selection_notify(XEvent* xevent)
Atom property; Atom property;
Time time; Time time;
} XSelectionRequestEvent; */ } XSelectionRequestEvent; */
/*
* When XGetWindowProperty and XChangeProperty talk about "format 32" it
* doesn't mean a 32bit value, but actually a long. So 32 means 4 bytes on
* a 32bit machine and 8 bytes on a 64 machine
*/
static int APP_CC static int APP_CC
clipboard_event_selection_request(XEvent* xevent) clipboard_event_selection_request(XEvent* xevent)
{ {
//XEvent xev;
XSelectionRequestEvent* lxev; XSelectionRequestEvent* lxev;
tui32 ui32[8]; XEvent xev;
Atom atom_buf[10];
Atom type; Atom type;
int fmt; int fmt;
int n_items; int n_items;
int xdata_size; int xdata_size;
char* xdata; char* xdata;
int i;
lxev = (XSelectionRequestEvent*)xevent; lxev = (XSelectionRequestEvent*)xevent;
LOGM((LOG_LEVEL_DEBUG, "clipboard_event_selection_request: g_wnd %d, " LOGM((LOG_LEVEL_DEBUG, "clipboard_event_selection_request: g_wnd %d, "
@ -913,20 +1142,21 @@ clipboard_event_selection_request(XEvent* xevent)
/* requestor is asking what the selection can be converted to */ /* requestor is asking what the selection can be converted to */
LOGM((LOG_LEVEL_DEBUG, "clipboard_event_selection_request: " LOGM((LOG_LEVEL_DEBUG, "clipboard_event_selection_request: "
"g_targets_atom")); "g_targets_atom"));
ui32[0] = g_targets_atom; atom_buf[0] = g_targets_atom;
ui32[1] = g_timestamp_atom; atom_buf[1] = g_timestamp_atom;
ui32[2] = g_multiple_atom; atom_buf[2] = g_multiple_atom;
ui32[3] = XA_STRING; atom_buf[3] = XA_STRING;
ui32[4] = g_utf8_atom; atom_buf[4] = g_utf8_atom;
return clipboard_provide_selection(lxev, XA_ATOM, 32, (char*)ui32, 5); atom_buf[5] = g_image_bmp_atom;
return clipboard_provide_selection(lxev, XA_ATOM, 32, (char*)atom_buf, 6);
} }
else if (lxev->target == g_timestamp_atom) else if (lxev->target == g_timestamp_atom)
{ {
/* requestor is asking the time I got the selection */ /* requestor is asking the time I got the selection */
LOGM((LOG_LEVEL_DEBUG, "clipboard_event_selection_request: " LOGM((LOG_LEVEL_DEBUG, "clipboard_event_selection_request: "
"g_timestamp_atom")); "g_timestamp_atom"));
ui32[0] = g_selection_time; atom_buf[0] = g_selection_time;
return clipboard_provide_selection(lxev, XA_INTEGER, 32, (char*)ui32, 1); return clipboard_provide_selection(lxev, XA_INTEGER, 32, (char*)atom_buf, 1);
} }
else if (lxev->target == g_multiple_atom) else if (lxev->target == g_multiple_atom)
{ {
@ -950,6 +1180,7 @@ clipboard_event_selection_request(XEvent* xevent)
{ {
LOGM((LOG_LEVEL_DEBUG, "clipboard_event_selection_request: %s", LOGM((LOG_LEVEL_DEBUG, "clipboard_event_selection_request: %s",
XGetAtomName(g_display, lxev->target))); XGetAtomName(g_display, lxev->target)));
clipboard_format_id = CB_FORMAT_UNICODETEXT;
if (g_data_in_up_to_date) if (g_data_in_up_to_date)
{ {
return clipboard_provide_selection(lxev, lxev->target, 8, return clipboard_provide_selection(lxev, lxev->target, 8,
@ -1017,9 +1248,88 @@ clipboard_event_selection_clear(XEvent* xevent)
static int APP_CC static int APP_CC
clipboard_event_property_notify(XEvent* xevent) clipboard_event_property_notify(XEvent* xevent)
{ {
Atom actual_type_return;
int actual_format_return;
unsigned long nitems_returned;
unsigned long bytes_left;
unsigned char* data;
int rv;
int format_in_bytes;
int new_data_len;
char* cptr;
unsigned char format_name[32];
LOG(10, ("clipboard_check_wait_objs: PropertyNotify .window %d " LOG(10, ("clipboard_check_wait_objs: PropertyNotify .window %d "
".state %d .atom %d", xevent->xproperty.window, ".state %d .atom %d", xevent->xproperty.window,
xevent->xproperty.state, xevent->xproperty.atom)); xevent->xproperty.state, xevent->xproperty.atom));
if (g_incr_in_progress &&
(xevent->xproperty.atom == g_incr_atom_type) &&
(xevent->xproperty.state == PropertyNewValue))
{
rv = XGetWindowProperty(g_display, g_wnd, g_incr_atom_type, 0, 0, 0,
AnyPropertyType, &actual_type_return, &actual_format_return,
&nitems_returned, &bytes_left, (unsigned char **) &data);
if (data != 0)
{
XFree(data);
data = 0;
}
if (bytes_left <= 0)
{
g_memset(format_name, 0, 32);
/* clipboard INCR cycle has completed */
g_incr_in_progress = 0;
g_last_clip_size = g_incr_data_size;
g_last_clip_data = g_incr_data;
g_last_clip_type = g_incr_atom_target;
if (g_incr_atom_target == g_image_bmp_atom)
{
g_snprintf(format_name, 31, "image/bmp");
clipboard_send_format_announce(CB_FORMAT_DIB, format_name);
}
XDeleteProperty(g_display, g_wnd, g_incr_atom_type);
}
else
{
rv = XGetWindowProperty(g_display, g_wnd, g_incr_atom_type, 0, bytes_left, 0,
AnyPropertyType, &actual_type_return, &actual_format_return,
&nitems_returned, &bytes_left, (unsigned char **) &data);
format_in_bytes = actual_format_return / 8;
if (actual_format_return == 32 && sizeof(long) == 8)
{
/* on a 64 bit machine, actual_format_return of 32 implies long */
format_in_bytes = 8;
}
new_data_len = nitems_returned * format_in_bytes;
#if 1
g_free(g_incr_data);
cptr = (char *) g_malloc(g_incr_data_size + new_data_len, 0);
#else
cptr = (char *) realloc(g_incr_data, g_incr_data_size + new_data_len);
#endif
if (cptr == NULL)
{
/* cannot add any more data */
if (data != 0)
{
XFree(data);
data = 0;
}
XDeleteProperty(g_display, g_wnd, g_incr_atom_type);
return 0;
}
g_incr_data = cptr;
g_memcpy(g_incr_data + g_incr_data_size, data, new_data_len);
g_incr_data_size += new_data_len;
if (data)
{
XFree(data);
data = 0;
}
XDeleteProperty(g_display, g_wnd, g_incr_atom_type);
}
}
return 0; return 0;
} }

17
sesman/chansrv/clipboard.h
Unescape View File

@ -2,6 +2,7 @@
* xrdp: A Remote Desktop Protocol server. * xrdp: A Remote Desktop Protocol server.
* *
* Copyright (C) Jay Sorg 2009-2012 * Copyright (C) Jay Sorg 2009-2012
* Copyright (C) Laxmikant Rashinkar 2012
* *
* Licensed under the Apache License, Version 2.0 (the "License"); * Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
@ -22,6 +23,22 @@
#include "arch.h" #include "arch.h"
#include "parse.h" #include "parse.h"
#define CB_FORMAT_LIST 2
#define CB_FORMAT_LIST_RESPONSE 3
#define CB_FORMAT_DATA_REQUEST 4
#define CB_FORMAT_DATA_RESPONSE 5
/* Clipboard Formats */
#define CB_FORMAT_RAW 0x0000
#define CB_FORMAT_TEXT 0x0001
#define CB_FORMAT_DIB 0x0008
#define CB_FORMAT_UNICODETEXT 0x000D
#define CB_FORMAT_HTML 0xD010
#define CB_FORMAT_PNG 0xD011
#define CB_FORMAT_JPEG 0xD012
#define CB_FORMAT_GIF 0xD013
int APP_CC int APP_CC
clipboard_init(void); clipboard_init(void);
int APP_CC int APP_CC

Write Preview
Loading…
Cancel
Save