uLab
/
xrdp-proprietary
mirror of https://mirror.git.trinitydesktop.org/gitea/uLab/xrdp-proprietary
0
0
Fork 0
Code Issues Releases Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '5e271a02ac'
${ noResults }
xrdp-proprietary/sesman/chansrv/clipboard.c

1816 lines
55 KiB
Raw Blame History

/**
* xrdp: A Remote Desktop Protocol server.
*
* Copyright (C) Jay Sorg 2009-2012
* Copyright (C) Laxmikant Rashinkar 2012
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/*
for help see
http://tronche.com/gui/x/icccm/sec-2.html#s-2
.../kde/kdebase/workspace/klipper/clipboardpoll.cpp
Revision:
Aug 05, 2012:
Laxmikant Rashinkar (LK dot Rashinkar at gmail.com)
added clipboard support for BMP images
*/
/*
TARGETS
MULTIPLE
image/tiff
image/jpeg
image/x-MS-bmp
image/x-bmp
image/bmp
image/png
SAVE_TARGETS
TIMESTAMP
wininfo - show window info
xlsatoms - dump atoms
*/
#include <X11/Xlib.h>
#include <X11/Xatom.h>
#include <X11/extensions/Xfixes.h>
#include "arch.h"
#include "parse.h"
#include "os_calls.h"
#include "chansrv.h"
#include "clipboard.h"
#include "xcommon.h"
#define LLOG_LEVEL 11
#define LLOGLN(_level, _args) \
do { if (_level < LLOG_LEVEL) { g_writeln _args ; } } while (0)
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 Display *g_display; /* in xcommon.c */
extern int g_x_socket; /* in xcommon.c */
extern tbus g_x_wait_obj; /* in xcommon.c */
extern Screen *g_screen; /* in xcommon.c */
extern int g_screen_num; /* in xcommon.c */
int g_clip_up = 0;
int g_waiting_for_data_response = 0;
int g_waiting_for_data_response_time = 0;
static Atom g_clipboard_atom = 0;
static Atom g_clip_property_atom = 0;
static Atom g_timestamp_atom = 0;
static Atom g_multiple_atom = 0;
static Atom g_targets_atom = 0;
static Atom g_primary_atom = 0;
static Atom g_secondary_atom = 0;
static Atom g_get_time_atom = 0;
static Atom g_utf8_atom = 0;
static Atom g_image_bmp_atom = 0;
static Atom g_file_atom1 = 0; /* text/uri-list */
static Atom g_file_atom2 = 0; /* x-special/gnome-copied-files */
static Window g_wnd = 0;
static int g_xfixes_event_base = 0;
static int g_last_clip_size = 0;
static char *g_last_clip_data = 0;
static Atom g_last_clip_type = 0;
static int g_in_file_copy = 0;
static int g_got_selection = 0; /* boolean */
static Time g_selection_time = 0;
static struct stream *g_ins = 0;
static XSelectionRequestEvent g_selection_request_event[16];
static int g_selection_request_event_count = 0;
static char *g_data_in = 0;
static int g_data_in_size = 0;
static int g_data_in_time = 0;
static int g_data_in_up_to_date = 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 = 0;
static int g_incr_data_size = 0;
static int g_incr_in_progress = 0;
static int g_clipboard_format_id = CB_FORMAT_UNICODETEXT;
static int g_cliprdr_version = 2;
static int g_cliprdr_flags = CB_USE_LONG_FORMAT_NAMES |
CB_STREAM_FILECLIP_ENABLED |
CB_FILECLIP_NO_FILE_PATHS;
/* last recieved CLIPRDR_FORMAT_LIST(CLIPRDR_FORMAT_ANNOUNCE) */
static int g_formatIds[16];
static int g_num_formatIds = 0;
/*****************************************************************************/
/* this is one way to get the current time from the x server */
static Time APP_CC
clipboard_get_server_time(void)
{
XEvent xevent;
unsigned char no_text[4];
/* append nothing */
no_text[0] = 0;
XChangeProperty(g_display, g_wnd, g_get_time_atom, XA_STRING, 8,
PropModeAppend, no_text, 0);
/* wait for PropertyNotify */
do
{
XMaskEvent(g_display, PropertyChangeMask, &xevent);
}
while (xevent.type != PropertyNotify);
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 */
int APP_CC
clipboard_init(void)
{
struct stream *s;
int size;
int rv;
int input_mask;
int dummy;
int ver_maj;
int ver_min;
Status st;
LOGM((LOG_LEVEL_DEBUG, "xrdp-chansrv: in clipboard_init"));
if (g_clip_up)
{
return 0;
}
xcommon_init();
clipboard_deinit();
rv = 0;
if (rv == 0)
{
g_clipboard_atom = XInternAtom(g_display, "CLIPBOARD", False);
if (g_clipboard_atom == None)
{
LOGM((LOG_LEVEL_ERROR, "clipboard_init: XInternAtom failed"));
rv = 3;
}
}
if (rv == 0)
{
if (!XFixesQueryExtension(g_display, &g_xfixes_event_base, &dummy))
{
LOGM((LOG_LEVEL_ERROR, "clipboard_init: no xfixes"));
rv = 5;
}
}
if (rv == 0)
{
LOGM((LOG_LEVEL_DEBUG, "clipboard_init: g_xfixes_event_base %d",
g_xfixes_event_base));
st = XFixesQueryVersion(g_display, &ver_maj, &ver_min);
LOGM((LOG_LEVEL_DEBUG, "clipboard_init st %d, maj %d min %d", st,
ver_maj, ver_min));
g_clip_property_atom = XInternAtom(g_display, "XRDP_CLIP_PROPERTY_ATOM",
False);
g_get_time_atom = XInternAtom(g_display, "XRDP_GET_TIME_ATOM",
False);
g_timestamp_atom = XInternAtom(g_display, "TIMESTAMP", False);
g_targets_atom = XInternAtom(g_display, "TARGETS", False);
g_multiple_atom = XInternAtom(g_display, "MULTIPLE", False);
g_primary_atom = XInternAtom(g_display, "PRIMARY", False);
g_secondary_atom = XInternAtom(g_display, "SECONDARY", False);
g_utf8_atom = XInternAtom(g_display, "UTF8_STRING", False);
g_image_bmp_atom = XInternAtom(g_display, "image/bmp", False);
g_file_atom1 = XInternAtom(g_display, "text/uri-list", False);
g_file_atom2 = XInternAtom(g_display, "x-special/gnome-copied-files", False);
g_incr_atom = XInternAtom(g_display, "INCR", False);
if (g_image_bmp_atom == None)
{
LOGM((LOG_LEVEL_ERROR, "clipboard_init: g_image_bmp_atom was "
"not allocated"));
}
g_wnd = XCreateSimpleWindow(g_display, RootWindowOfScreen(g_screen),
0, 0, 4, 4, 0, 0, 0);
input_mask = StructureNotifyMask | PropertyChangeMask;
XSelectInput(g_display, g_wnd, input_mask);
//XMapWindow(g_display, g_wnd);
XFixesSelectSelectionInput(g_display, g_wnd,
g_clipboard_atom,
XFixesSetSelectionOwnerNotifyMask |
XFixesSelectionWindowDestroyNotifyMask |
XFixesSelectionClientCloseNotifyMask);
}
make_stream(s);
if (rv == 0)
{
/* set clipboard caps first */
init_stream(s, 8192);
/* CLIPRDR_HEADER */
out_uint16_le(s, CB_CLIP_CAPS); /* msgType */
out_uint16_le(s, 0); /* msgFlags */
out_uint32_le(s, 16); /* dataLen */
out_uint16_le(s, 1); /* cCapabilitiesSets */
out_uint16_le(s, 0); /* pad1 */
/* CLIPRDR_GENERAL_CAPABILITY */
out_uint16_le(s, 1); /* capabilitySetType */
out_uint16_le(s, 12); /* lengthCapability */
out_uint32_le(s, g_cliprdr_version); /* version */
out_uint32_le(s, g_cliprdr_flags); /* generalFlags */
out_uint32_le(s, 0); /* extra 4 bytes ? */
s_mark_end(s);
size = (int)(s->end - s->data);
LOGM((LOG_LEVEL_DEBUG, "clipboard_init: data out, sending "
"CB_CLIP_CAPS (clip_msg_id = 1)"));
rv = send_channel_data(g_cliprdr_chan_id, s->data, size);
if (rv != 0)
{
LOGM((LOG_LEVEL_ERROR, "clipboard_init: send_channel_data failed "
"rv = %d", rv));
rv = 4;
}
}
if (rv == 0)
{
/* report clipboard ready */
init_stream(s, 8192);
out_uint16_le(s, CB_MONITOR_READY); /* msgType */
out_uint16_le(s, 0); /* msgFlags */
out_uint32_le(s, 0); /* dataLen */
out_uint32_le(s, 0); /* extra 4 bytes ? */
s_mark_end(s);
size = (int)(s->end - s->data);
LOGM((LOG_LEVEL_DEBUG, "clipboard_init: data out, sending "
"CB_MONITOR_READY (clip_msg_id = 1)"));
rv = send_channel_data(g_cliprdr_chan_id, s->data, size);
if (rv != 0)
{
LOGM((LOG_LEVEL_ERROR, "clipboard_init: send_channel_data failed "
"rv = %d", rv));
rv = 4;
}
}
free_stream(s);
if (rv == 0)
{
g_clip_up = 1;
make_stream(g_ins);
init_stream(g_ins, 8192);
}
else
{
LOGM((LOG_LEVEL_ERROR, "xrdp-chansrv: clipboard_init: error on exit"));
}
return rv;
}
/*****************************************************************************/
int APP_CC
clipboard_deinit(void)
{
if (g_wnd != 0)
{
XDestroyWindow(g_display, g_wnd);
g_wnd = 0;
}
g_free(g_last_clip_data);
g_last_clip_data = 0;
g_last_clip_size = 0;
free_stream(g_ins);
g_ins = 0;
g_clip_up = 0;
return 0;
}
/*****************************************************************************/
static int APP_CC
clipboard_send_data_request(void)
{
struct stream *s;
int size;
int rv;
LOGM((LOG_LEVEL_DEBUG, "clipboard_send_data_request:"));
if (!g_got_format_announce)
{
LOGM((LOG_LEVEL_ERROR, "clipboard_send_data_request: error, "
"no format announce"));
return 0;
}
g_got_format_announce = 0;
make_stream(s);
init_stream(s, 8192);
out_uint16_le(s, 4); /* CLIPRDR_DATA_REQUEST */
out_uint16_le(s, 0); /* status */
out_uint32_le(s, 4); /* length */
out_uint32_le(s, g_clipboard_format_id);
s_mark_end(s);
size = (int)(s->end - s->data);
LOGM((LOG_LEVEL_DEBUG, "clipboard_send_data_request: data out, sending "
"CLIPRDR_DATA_REQUEST (clip_msg_id = 4)"));
rv = send_channel_data(g_cliprdr_chan_id, s->data, size);
free_stream(s);
return rv;
}
/*****************************************************************************/
static int APP_CC
clipboard_send_format_ack(void)
{
struct stream *s;
int size;
int rv;
make_stream(s);
init_stream(s, 8192);
out_uint16_le(s, 3); /* CLIPRDR_FORMAT_ACK */
out_uint16_le(s, 1); /* status */
out_uint32_le(s, 0); /* length */
out_uint32_le(s, 0); /* extra 4 bytes ? */
s_mark_end(s);
size = (int)(s->end - s->data);
LOGM((LOG_LEVEL_DEBUG, "clipboard_send_format_ack: data out, sending "
"CLIPRDR_FORMAT_ACK (clip_msg_id = 3)"));
rv = send_channel_data(g_cliprdr_chan_id, s->data, size);
free_stream(s);
return rv;
}
/*****************************************************************************/
/* returns number of bytes written */
static int APP_CC
clipboard_out_unicode(struct stream *s, char *text, int num_chars)
{
int index;
int lnum_chars;
twchar *ltext;
if ((num_chars < 1) || (text == 0))
{
return 0;
}
lnum_chars = g_mbstowcs(0, text, num_chars);
if (lnum_chars < 0)
{
return 0;
}
ltext = (twchar *) g_malloc((num_chars + 1) * sizeof(twchar), 1);
g_mbstowcs(ltext, text, num_chars);
index = 0;
while (index < num_chars)
{
out_uint16_le(s, ltext[index]);
index++;
}
g_free(ltext);
return index * 2;
}
/*****************************************************************************/
/* returns number of bytes read */
static int APP_CC
clipboard_in_unicode(struct stream *s, char *text, int *num_chars)
{
int index;
twchar *ltext;
twchar chr;
if ((num_chars == 0) || (*num_chars < 1) || (text == 0))
{
return 0;
}
ltext = (twchar *) g_malloc(512 * sizeof(twchar), 1);
index = 0;
while (s_check_rem(s, 2))
{
in_uint16_le(s, chr);
if (index < 511)
{
ltext[index] = chr;
}
index++;
if (chr == 0)
{
break;
}
}
*num_chars = g_wcstombs(text, ltext, *num_chars);
g_free(ltext);
return index * 2;
}
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
clipboard_send_format_announce(tui32 format_id, char *format_name)
{
struct stream *s;
int size;
int rv;
char *holdp;
LLOGLN(10, ("clipboard_send_format_announce: format_id 0x%8.8x "
"format_name [%s]", format_id, format_name));
make_stream(s);
init_stream(s, 8192);
out_uint16_le(s, CB_FORMAT_LIST); /* CLIPRDR_FORMAT_ANNOUNCE */
out_uint16_le(s, 0); /* status */
holdp = s->p;
out_uint32_le(s, 0); /* set later */
if (g_cliprdr_flags & CB_USE_LONG_FORMAT_NAMES)
{
if (format_id == CB_FORMAT_FILE)
{
out_uint32_le(s, 0x0000c0bc);
clipboard_out_unicode(s, "FileGroupDescriptorW", 21);
out_uint32_le(s, 0x0000c0ba);
clipboard_out_unicode(s, "FileContents", 13);
out_uint32_le(s, 0x0000c0c1);
clipboard_out_unicode(s, "DropEffect", 11);
}
else if (format_id == CB_FORMAT_DIB)
{
out_uint32_le(s, 0x0000c004);
clipboard_out_unicode(s, "Native", 7);
out_uint32_le(s, 0x00000003);
clipboard_out_unicode(s, "", 1);
out_uint32_le(s, 0x00000008);
clipboard_out_unicode(s, "", 1);
out_uint32_le(s, 0x00000011);
clipboard_out_unicode(s, "", 1);
}
else
{
out_uint32_le(s, format_id);
clipboard_out_unicode(s, format_name, g_mbstowcs(0, format_name, 0) + 1);
}
}
else
{
out_uint32_le(s, format_id);
out_uint8p(s, windows_native_format, sizeof(windows_native_format));
}
size = (int)(s->p - holdp);
size -= 4;
holdp[0] = (size >> 0) & 0xff;
holdp[1] = (size >> 8) & 0xff;
holdp[2] = (size >> 16) & 0xff;
holdp[3] = (size >> 24) & 0xff;
out_uint8s(s, 4);
s_mark_end(s);
size = (int)(s->end - s->data);
g_hexdump(s->data, size);
LOGM((LOG_LEVEL_DEBUG, "clipboard_send_format_announce: data out, sending "
"CLIPRDR_FORMAT_ANNOUNCE (clip_msg_id = 2)"));
rv = send_channel_data(g_cliprdr_chan_id, s->data, size);
free_stream(s);
return rv;
}
/*****************************************************************************/
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
clipboard_send_data_response(void)
{
struct stream *s;
int size;
int rv;
int num_chars;
LOG(10, ("clipboard_send_data_response:"));
num_chars = 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))
{
num_chars = g_mbstowcs(0, g_last_clip_data, 0);
if (num_chars < 0)
{
LOGM((LOG_LEVEL_ERROR, "clipboard_send_data_response: bad string"));
num_chars = 0;
}
}
}
LOG(10, ("clipboard_send_data_response: g_last_clip_size %d "
"num_chars %d", g_last_clip_size, num_chars));
make_stream(s);
init_stream(s, 64 + num_chars * 2);
out_uint16_le(s, 5); /* CLIPRDR_DATA_RESPONSE */
out_uint16_le(s, 1); /* status */
out_uint32_le(s, num_chars * 2 + 2); /* length */
if (clipboard_out_unicode(s, g_last_clip_data, num_chars) != num_chars * 2)
{
LOGM((LOG_LEVEL_ERROR, "clipboard_send_data_response: error "
"clipboard_out_unicode didn't write right number of bytes"));
}
out_uint16_le(s, 0); /* nil for string */
out_uint32_le(s, 0);
s_mark_end(s);
size = (int)(s->end - s->data);
LOGM((LOG_LEVEL_DEBUG, "clipboard_send_data_response: data out, sending "
"CLIPRDR_DATA_RESPONSE (clip_msg_id = 5) size %d num_chars %d",
size, num_chars));
rv = send_channel_data(g_cliprdr_chan_id, s->data, size);
free_stream(s);
return rv;
}
/*****************************************************************************/
static int APP_CC
clipboard_set_selection_owner(void)
{
Window owner;
g_selection_time = clipboard_get_server_time();
XSetSelectionOwner(g_display, g_clipboard_atom, g_wnd, g_selection_time);
owner = XGetSelectionOwner(g_display, g_clipboard_atom);
if (owner != g_wnd)
{
g_got_selection = 0;
return 1;
}
g_got_selection = 1;
return 0;
}
/*****************************************************************************/
static int APP_CC
clipboard_provide_selection(XSelectionRequestEvent *req, Atom type, int format,
char *data, int length)
{
XEvent xev;
XChangeProperty(g_display, req->requestor, req->property,
type, format, PropModeReplace, (tui8 *)data, length);
g_memset(&xev, 0, sizeof(xev));
xev.xselection.type = SelectionNotify;
xev.xselection.send_event = True;
xev.xselection.display = req->display;
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);
return 0;
}
/*****************************************************************************/
static int APP_CC
clipboard_refuse_selection(XSelectionRequestEvent *req)
{
XEvent xev;
g_memset(&xev, 0, sizeof(xev));
xev.xselection.type = SelectionNotify;
xev.xselection.send_event = True;
xev.xselection.display = req->display;
xev.xselection.requestor = req->requestor;
xev.xselection.selection = req->selection;
xev.xselection.target = req->target;
xev.xselection.property = None;
xev.xselection.time = req->time;
XSendEvent(g_display, req->requestor, False, NoEventMask, &xev);
return 0;
}
/*****************************************************************************/
/* 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. */
static int APP_CC
clipboard_process_format_announce(struct stream *s, int clip_msg_status,
int clip_msg_len)
{
int formatId;
int count;
int bytes;
char desc[256];
char *holdp;
LOGM((LOG_LEVEL_DEBUG, "clipboard_process_format_announce: "
"CLIPRDR_FORMAT_ANNOUNCE"));
LLOGLN(10, ("clipboard_process_format_announce %d", clip_msg_len));
g_hexdump(s->p, s->end - s->p);
clipboard_send_format_ack();
g_got_format_announce = 1;
g_data_in_up_to_date = 0;
desc[0] = 0;
g_num_formatIds = 0;
while (clip_msg_len > 3)
{
in_uint32_le(s, formatId);
clip_msg_len -= 4;
if (g_cliprdr_flags & CB_USE_LONG_FORMAT_NAMES)
{
/* CLIPRDR_LONG_FORMAT_NAME */
count = 255;
bytes = clipboard_in_unicode(s, desc, &count);
clip_msg_len -= bytes;
}
else
{
/* CLIPRDR_SHORT_FORMAT_NAME */
/* 32 ASCII 8 characters or 16 Unicode characters */
count = 15;
holdp = s->p;
clipboard_in_unicode(s, desc, &count);
s->p = holdp + 32;
desc[15] = 0;
clip_msg_len -= 32;
}
LLOGLN(10, ("clipboard_process_format_announce: formatId 0x%8.8x "
"wszFormatName [%s] clip_msg_len %d", formatId, desc,
clip_msg_len));
g_formatIds[g_num_formatIds] = formatId;
g_num_formatIds++;
if (g_num_formatIds > 15)
{
LLOGLN(10, ("clipboard_process_format_announce: max formats"));
}
}
if (g_num_formatIds > 0)
{
if (clipboard_set_selection_owner() != 0)
{
LOGM((LOG_LEVEL_ERROR, "clipboard_process_format_announce: "
"XSetSelectionOwner failed"));
}
}
return 0;
}
/*****************************************************************************/
/* response to CB_FORMAT_LIST; used to indicate whether
processing of the Format List PDU was successful */
static int APP_CC
clipboard_prcoess_format_ack(struct stream *s, int clip_msg_status,
int clip_msg_len)
{
LOGM((LOG_LEVEL_DEBUG, "clipboard_prcoess_format_ack: CLIPRDR_FORMAT_ACK"));
LLOGLN(10, ("clipboard_prcoess_format_ack:"));
g_hexdump(s->p, s->end - s->p);
return 0;
}
/*****************************************************************************/
/* sent by recipient of CB_FORMAT_LIST; used to request data for one
of the formats that was listed in CB_FORMAT_LIST */
static int APP_CC
clipboard_process_data_request(struct stream *s, int clip_msg_status,
int clip_msg_len)
{
LOGM((LOG_LEVEL_DEBUG, "clipboard_process_data_request: "
"CLIPRDR_DATA_REQUEST"));
LLOGLN(10, ("clipboard_process_data_request:"));
g_hexdump(s->p, s->end - s->p);
clipboard_send_data_response();
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;
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 0;
}
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
clipboard_process_data_response(struct stream *s, int clip_msg_status,
int clip_msg_len)
{
XSelectionRequestEvent *lxev;
twchar *wtext;
twchar wchr;
int len;
int index;
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: "
"CLIPRDR_DATA_RESPONSE"));
g_waiting_for_data_response = 0;
len = (int)(s->end - s->p);
if (len < 1)
{
return 0;
}
//g_hexdump(s->p, len);
wtext = (twchar *) g_malloc(((len / 2) + 1) * sizeof(twchar), 0);
if (wtext == 0)
{
return 0;
}
index = 0;
while (s_check(s))
{
in_uint16_le(s, wchr);
wtext[index] = wchr;
if (wchr == 0)
{
break;
}
index++;
}
wtext[index] = 0;
g_free(g_data_in);
g_data_in = 0;
g_data_in_size = 0;
g_data_in_time = 0;
len = g_wcstombs(0, wtext, 0);
if (len >= 0)
{
g_data_in = (char *) g_malloc(len + 16, 0);
if (g_data_in == 0)
{
g_free(wtext);
return 0;
}
g_data_in_size = len;
g_wcstombs(g_data_in, wtext, len + 1);
g_data_in_time = xcommon_get_local_time();
g_data_in_up_to_date = 1;
}
if (g_data_in != 0)
{
data_in_len = g_strlen(g_data_in);
for (index = 0; index < g_selection_request_event_count; index++)
{
lxev = &(g_selection_request_event[index]);
clipboard_provide_selection(lxev, lxev->target, 8, g_data_in,
data_in_len);
LOGM((LOG_LEVEL_DEBUG, "clipboard_process_data_response: requestor %d "
"data_in_len %d", lxev->requestor, data_in_len));
}
}
g_selection_request_event_count = 0;
g_free(wtext);
return 0;
}
/*****************************************************************************/
static int APP_CC
clipboard_process_clip_caps(struct stream *s, int clip_msg_status,
int clip_msg_len)
{
int cCapabilitiesSets;
int capabilitySetType;
int lengthCapability;
int index;
int version;
int flags;
char *holdp;
LLOGLN(10, ("clipboard_process_clip_caps:"));
//g_hexdump(s->p, s->end - s->p);
in_uint16_le(s, cCapabilitiesSets);
in_uint8s(s, 2); /* pad */
for (index = 0; index < cCapabilitiesSets; index++)
{
holdp = s->p;
in_uint16_le(s, capabilitySetType);
in_uint16_le(s, lengthCapability);
switch (capabilitySetType)
{
case CB_CAPSTYPE_GENERAL:
in_uint32_le(s, version); /* version */
in_uint32_le(s, flags); /* generalFlags */
LLOGLN(0, ("clipboard_process_clip_caps: "
"g_cliprdr_version %d version %d "
"g_cliprdr_flags 0x%x flags 0x%x",
g_cliprdr_version, version,
g_cliprdr_flags, flags));
if (version < g_cliprdr_version)
{
g_cliprdr_version = version;
}
g_cliprdr_flags &= flags;
break;
default:
LLOGLN(0, ("clipboard_process_clip_caps: unknown "
"capabilitySetType %d", capabilitySetType));
break;
}
s->p = holdp + lengthCapability;
}
return 0;
}
/*****************************************************************************/
int APP_CC
clipboard_data_in(struct stream *s, int chan_id, int chan_flags, int length,
int total_length)
{
int clip_msg_id;
int clip_msg_len;
int clip_msg_status;
int rv;
struct stream *ls;
LOG(10, ("clipboard_data_in: chan_is %d "
"chan_flags %d length %d total_length %d",
chan_id, chan_flags, length, total_length));
LLOGLN(10, ("clipboard_data_in:"));
if ((chan_flags & 3) == 3)
{
ls = s;
}
else
{
if (chan_flags & 1)
{
init_stream(g_ins, total_length);
}
in_uint8a(s, g_ins->end, length);
g_ins->end += length;
if ((chan_flags & 2) == 0)
{
return 0;
}
ls = g_ins;
}
in_uint16_le(ls, clip_msg_id);
in_uint16_le(ls, clip_msg_status);
in_uint32_le(ls, clip_msg_len);
LOG(10, ("clipboard_data_in: clip_msg_id %d "
"clip_msg_status %d clip_msg_len %d",
clip_msg_id, clip_msg_status, clip_msg_len));
rv = 0;
LLOGLN(10, ("clipboard_data_in: %d", clip_msg_id));
switch (clip_msg_id)
{
/* 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,
clip_msg_len);
break;
/* 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,
clip_msg_len);
break;
/* 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,
clip_msg_len);
break;
/* 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,
clip_msg_len);
break;
case CB_CLIP_CAPS:
rv = clipboard_process_clip_caps(ls, clip_msg_status,
clip_msg_len);
break;
default:
LLOGLN(0, ("clipboard_data_in: unknown clip_msg_id %d", clip_msg_id));
LOGM((LOG_LEVEL_ERROR, "clipboard_data_in: unknown clip_msg_id %d",
clip_msg_id));
break;
}
XFlush(g_display);
return rv;
}
/*****************************************************************************/
/* this happens when a new app copies something to the clipboard
'CLIPBOARD' Atom
typedef struct
{
int type;
unsigned long serial;
Bool send_event;
Display *display;
Window window;
int subtype;
Window owner;
Atom selection;
Time timestamp;
Time selection_timestamp;
} XFixesSelectionNotifyEvent; */
static int APP_CC
clipboard_event_selection_owner_notify(XEvent *xevent)
{
XFixesSelectionNotifyEvent *lxevent;
LLOGLN(0, ("clipboard_event_selection_owner_notify:"));
lxevent = (XFixesSelectionNotifyEvent *)xevent;
LOGM((LOG_LEVEL_DEBUG, "clipboard_event_selection_owner_notify: "
"window %d subtype %d owner %d g_wnd %d",
lxevent->window, lxevent->subtype, lxevent->owner, g_wnd));
if (lxevent->owner == g_wnd)
{
LLOGLN(0, ("clipboard_event_selection_owner_notify: matches g_wnd"));
LOGM((LOG_LEVEL_DEBUG, "clipboard_event_selection_owner_notify: skipping, "
"onwer == g_wnd"));
g_got_selection = 1;
return 0;
}
g_got_selection = 0;
XConvertSelection(g_display, g_clipboard_atom, g_targets_atom,
g_clip_property_atom, g_wnd, lxevent->timestamp);
return 0;
}
/*****************************************************************************/
/* returns error
get a window property from wnd */
static int APP_CC
clipboard_get_window_property(Window wnd, Atom prop, Atom *type, int *fmt,
int *n_items, char **xdata, int *xdata_size)
{
int lfmt;
int lxdata_size;
unsigned long ln_items;
unsigned long llen_after;
tui8 *lxdata;
Atom ltype;
lxdata = 0;
ltype = 0;
XGetWindowProperty(g_display, g_wnd, prop, 0, 0, 0,
AnyPropertyType, &ltype, &lfmt, &ln_items,
&llen_after, &lxdata);
if (lxdata != 0)
{
XFree(lxdata);
}
if (ltype == 0)
{
/* XGetWindowProperty failed */
return 1;
}
if (ltype == g_incr_atom)
{
LOGM((LOG_LEVEL_DEBUG, "clipboard_event_property_notify: INCR start"));
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 0;
}
if (llen_after < 1)
{
/* no data, ok */
return 0;
}
lxdata = 0;
ltype = 0;
XGetWindowProperty(g_display, g_wnd, prop, 0, (llen_after + 3) / 4, 0,
AnyPropertyType, &ltype, &lfmt, &ln_items,
&llen_after, &lxdata);
if (ltype == 0)
{
/* XGetWindowProperty failed */
if (lxdata != 0)
{
XFree(lxdata);
}
return 1;
}
lxdata_size = (lfmt / 8) * ln_items;
if (lxdata_size < 1)
{
/* should not happen */
if (lxdata != 0)
{
XFree(lxdata);
}
return 2;
}
if (llen_after > 0)
{
/* should not happen */
if (lxdata != 0)
{
XFree(lxdata);
}
return 3;
}
if (xdata != 0)
{
*xdata = (char *) g_malloc(lxdata_size, 0);
g_memcpy(*xdata, lxdata, lxdata_size);
}
if (lxdata != 0)
{
XFree(lxdata);
}
if (xdata_size != 0)
{
*xdata_size = lxdata_size;
}
if (fmt != 0)
{
*fmt = (int)lfmt;
}
if (n_items != 0)
{
*n_items = (int)ln_items;
}
if (type != 0)
{
*type = ltype;
}
return 0;
}
/*****************************************************************************/
/* returns error
process the SelectionNotify X event, uses XSelectionEvent
typedef struct {
int type; // SelectionNotify
unsigned long serial; // # of last request processed by server
Bool send_event; // true if this came from a SendEvent request
Display *display; // Display the event was read from
Window requestor;
Atom selection;
Atom target;
Atom property; // atom or None
Time time;
} XSelectionEvent; */
static int APP_CC
clipboard_event_selection_notify(XEvent *xevent)
{
XSelectionEvent *lxevent;
char *data;
int data_size;
int n_items;
int fmt;
int rv;
int index;
int convert_to_string;
int convert_to_utf8;
int convert_to_bmp_image;
int convert_to_file;
int send_format_announce;
int atom;
Atom *atoms;
Atom type;
tui32 format_id;
char format_name[32];
LOGM((LOG_LEVEL_DEBUG, "clipboard_event_selection_notify:"));
data_size = 0;
n_items = 0;
fmt = 0;
convert_to_string = 0;
convert_to_utf8 = 0;
convert_to_bmp_image = 0;
convert_to_file = 0;
send_format_announce = 0;
format_id = 0;
rv = 0;
data = 0;
type = 0;
lxevent = (XSelectionEvent *)xevent;
g_memset(format_name, 0, 32);
if (lxevent->property == None)
{
LOGM((LOG_LEVEL_ERROR, "clipboard_event_selection_notify: clip could "
"not be converted"));
rv = 1;
}
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,
&type, &fmt,
&n_items, &data, &data_size);
if (rv != 0)
{
LOGM((LOG_LEVEL_ERROR, "clipboard_event_selection_notify: "
"clipboard_get_window_property failed error %d", rv));
}
XDeleteProperty(g_display, lxevent->requestor, lxevent->property);
}
if (rv == 0)
{
if (lxevent->selection == g_clipboard_atom)
{
if (lxevent->target == g_targets_atom)
{
/* on a 64 bit machine, actual_format_return of 32 implies long */
if ((type == XA_ATOM) && (fmt == 32))
{
atoms = (Atom *)data;
g_in_file_copy = 0;
for (index = 0; index < n_items; index++)
{
atom = atoms[index];
LOGM((LOG_LEVEL_DEBUG, "clipboard_event_selection_notify: %d %s %d",
atom, XGetAtomName(g_display, atom), XA_STRING));
LLOGLN(10, ("clipboard_event_selection_notify: 0x%x %s",
atom, XGetAtomName(g_display, atom)));
if (atom == g_utf8_atom)
{
convert_to_utf8 = 1;
}
else if (atom == XA_STRING)
{
convert_to_string = 1;
}
else if (atom == g_image_bmp_atom)
{
convert_to_bmp_image = 1;
}
else if ((atom == g_file_atom1) || (atom == g_file_atom2))
{
LLOGLN(10, ("clipboard_event_selection_notify: file"));
convert_to_file = 1;
}
else
{
LLOGLN(10, ("clipboard_event_selection_notify: unknown atom 0x%x", atom));
}
}
}
else
{
LOGM((LOG_LEVEL_ERROR, "clipboard_event_selection_notify: error, "
"target is 'TARGETS' and type[%d] or fmt[%d] not right, "
"should be type[%d], fmt[%d]", type, fmt, XA_ATOM, 32));
}
}
else if (lxevent->target == g_utf8_atom)
{
LLOGLN(10, ("here---------------------%d", g_in_file_copy));
LOGM((LOG_LEVEL_DEBUG, "clipboard_event_selection_notify: UTF8_STRING "
"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 = (char *) g_malloc(g_last_clip_size + 1, 0);
g_last_clip_type = g_utf8_atom;
g_memcpy(g_last_clip_data, data, g_last_clip_size);
g_last_clip_data[g_last_clip_size] = 0;
send_format_announce = 1;
if (g_in_file_copy)
{
format_id = CB_FORMAT_FILE;
g_strcpy(format_name, "FileGroupDescriptorW");
}
else
{
format_id = CB_FORMAT_UNICODETEXT;
}
}
else if (lxevent->target == XA_STRING)
{
LOGM((LOG_LEVEL_DEBUG, "clipboard_event_selection_notify: XA_STRING "
"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 = (char *) g_malloc(g_last_clip_size + 1, 0);
g_last_clip_type = XA_STRING;
g_memcpy(g_last_clip_data, data, g_last_clip_size);
g_last_clip_data[g_last_clip_size] = 0;
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 = (char *) 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
{
LOGM((LOG_LEVEL_ERROR, "clipboard_event_selection_notify: "
"unknown target"));
}
}
else
{
LOGM((LOG_LEVEL_ERROR, "clipboard_event_selection_notify: "
"unknown selection"));
}
}
if (convert_to_file)
{
LLOGLN(10, ("convert_to_file and convert_to_utf8 set"));
XConvertSelection(g_display, g_clipboard_atom, g_utf8_atom,
g_clip_property_atom, g_wnd, lxevent->time);
g_in_file_copy = 1;
}
else if (convert_to_utf8)
{
XConvertSelection(g_display, g_clipboard_atom, g_utf8_atom,
g_clip_property_atom, g_wnd, lxevent->time);
}
else if (convert_to_string)
{
XConvertSelection(g_display, g_clipboard_atom, XA_STRING,
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 (clipboard_send_format_announce(format_id, format_name) != 0)
{
rv = 4;
}
}
g_free(data);
return rv;
}
/*****************************************************************************/
/* returns error
process the SelectionRequest X event, uses XSelectionRequestEvent
typedef struct {
int type; // SelectionRequest
unsigned long serial; // # of last request processed by server
Bool send_event; // true if this came from a SendEvent request
Display *display; // Display the event was read from
Window owner;
Window requestor;
Atom selection;
Atom target;
Atom property;
Time time;
} 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
clipboard_event_selection_request(XEvent *xevent)
{
XSelectionRequestEvent *lxev;
XEvent xev;
Atom atom_buf[10];
Atom type;
int fmt;
int n_items;
int xdata_size;
char *xdata;
lxev = (XSelectionRequestEvent *)xevent;
LLOGLN(10, ("clipboard_event_selection_request: %p", lxev->property));
LOGM((LOG_LEVEL_DEBUG, "clipboard_event_selection_request: g_wnd %d, "
".requestor %d .owner %d .selection %d '%s' .target %d .property %d",
g_wnd, lxev->requestor, lxev->owner, lxev->selection,
XGetAtomName(g_display, lxev->selection),
lxev->target, lxev->property));
if (lxev->property == None)
{
LLOGLN(10, ("clipboard_event_selection_request: lxev->property "
"is None"));
LOGM((LOG_LEVEL_DEBUG, "clipboard_event_selection_request: "
"lxev->property is None"));
}
else if (lxev->target == g_targets_atom)
{
LLOGLN(10, ("clipboard_event_selection_request: g_targets_atom"));
/* requestor is asking what the selection can be converted to */
LOGM((LOG_LEVEL_DEBUG, "clipboard_event_selection_request: "
"g_targets_atom"));
atom_buf[0] = g_targets_atom;
atom_buf[1] = g_timestamp_atom;
atom_buf[2] = g_multiple_atom;
atom_buf[3] = XA_STRING;
atom_buf[4] = g_utf8_atom;
atom_buf[5] = g_image_bmp_atom;
atom_buf[6] = 0;
return clipboard_provide_selection(lxev, XA_ATOM, 32, (char *)atom_buf, 6);
}
else if (lxev->target == g_timestamp_atom)
{
/* requestor is asking the time I got the selection */
LOGM((LOG_LEVEL_DEBUG, "clipboard_event_selection_request: "
"g_timestamp_atom"));
atom_buf[0] = g_selection_time;
atom_buf[1] = 0;
return clipboard_provide_selection(lxev, XA_INTEGER, 32, (char *)atom_buf, 1);
}
else if (lxev->target == g_multiple_atom)
{
/* target, property pairs */
LOGM((LOG_LEVEL_DEBUG, "clipboard_event_selection_request: "
"g_multiple_atom"));
if (clipboard_get_window_property(xev.xselection.requestor,
xev.xselection.property,
&type, &fmt, &n_items, &xdata,
&xdata_size) == 0)
{
LOGM((LOG_LEVEL_DEBUG, "clipboard_event_selection_request: g_multiple_atom "
"n_items %d", n_items));
/* todo */
g_free(xdata);
}
}
else if ((lxev->target == XA_STRING) || (lxev->target == g_utf8_atom))
{
LOGM((LOG_LEVEL_DEBUG, "clipboard_event_selection_request: %s",
XGetAtomName(g_display, lxev->target)));
g_clipboard_format_id = CB_FORMAT_UNICODETEXT;
if (g_data_in_up_to_date)
{
return clipboard_provide_selection(lxev, lxev->target, 8,
g_data_in, g_strlen(g_data_in));
}
if (g_selection_request_event_count > 10)
{
LOGM((LOG_LEVEL_ERROR, "clipboard_event_selection_request: error, "
"too many requests"));
}
else
{
g_memcpy(&(g_selection_request_event[g_selection_request_event_count]),
lxev, sizeof(g_selection_request_event[0]));
if (g_selection_request_event_count == 0)
{
clipboard_send_data_request();
g_waiting_for_data_response = 1;
g_waiting_for_data_response_time = xcommon_get_local_time();
}
g_selection_request_event_count++;
return 0;
}
}
else if (lxev->target == g_image_bmp_atom)
{
g_memcpy(&g_saved_selection_req_event, lxev,
sizeof(g_saved_selection_req_event));
g_last_clip_type = g_image_bmp_atom;
g_want_image_data = 1;
g_clipboard_format_id = CB_FORMAT_DIB;
clipboard_send_data_request();
g_waiting_for_data_response = 1;
g_waiting_for_data_response_time = clipboard_get_local_time();
return 0;
}
else
{
LLOGLN(10, ("clipboard_event_selection_request: unknown "
"target %s", XGetAtomName(g_display, lxev->target)));
LOGM((LOG_LEVEL_ERROR, "clipboard_event_selection_request: unknown "
"target %s", XGetAtomName(g_display, lxev->target)));
}
clipboard_refuse_selection(lxev);
return 0;
}
/*****************************************************************************/
/* returns error
process the SelectionClear X event, uses XSelectionClearEvent
typedef struct {
int type; // SelectionClear
unsigned long serial; // # of last request processed by server
Bool send_event; // true if this came from a SendEvent request
Display *display; // Display the event was read from
Window window;
Atom selection;
Time time;
} XSelectionClearEvent; */
static int APP_CC
clipboard_event_selection_clear(XEvent *xevent)
{
LOGM((LOG_LEVEL_DEBUG, "clipboard_event_selection_clear:"));
return 0;
}
/*****************************************************************************/
/* returns error
typedef struct {
int type; // PropertyNotify
unsigned long serial; // # of last request processed by server
Bool send_event; // true if this came from a SendEvent request
Display *display; // Display the event was read from
Window window;
Atom atom;
Time time;
int state; // PropertyNewValue or PropertyDelete
} XPropertyEvent; */
static int APP_CC
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;
char format_name[32];
LOG(10, ("clipboard_check_wait_objs: PropertyNotify .window %d "
".state %d .atom %d", xevent->xproperty.window,
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)
{
LOGM((LOG_LEVEL_DEBUG, "clipboard_event_property_notify: INCR done"));
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_incr_data = 0;
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;
cptr = (char *) g_malloc(g_incr_data_size + new_data_len, 0);
g_memcpy(cptr, g_incr_data, g_incr_data_size);
g_free(g_incr_data);
if (cptr == NULL)
{
g_incr_data = 0;
/* cannot add any more data */
if (data != 0)
{
XFree(data);
}
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);
}
XDeleteProperty(g_display, g_wnd, g_incr_atom_type);
}
}
return 0;
}
/*****************************************************************************/
/* returns 0, event handled, 1 unhandled */
int APP_CC
clipboard_xevent(void *xevent)
{
XEvent *lxevent;
if (!g_clip_up)
{
return 1;
}
lxevent = (XEvent *)xevent;
switch (lxevent->type)
{
case SelectionNotify:
clipboard_event_selection_notify(lxevent);
break;
case SelectionRequest:
clipboard_event_selection_request(lxevent);
break;
case SelectionClear:
clipboard_event_selection_clear(lxevent);
break;
case MappingNotify:
break;
case PropertyNotify:
clipboard_event_property_notify(lxevent);
break;
case UnmapNotify:
LOG(0, ("chansrv::clipboard_xevent: got UnmapNotify"));
break;
case ClientMessage:
LOG(0, ("chansrv::clipboard_xevent: got ClientMessage"));
break;
default:
if (lxevent->type == g_xfixes_event_base +
XFixesSetSelectionOwnerNotify)
{
LLOGLN(0, ("clipboard_xevent: got XFixesSetSelectionOwnerNotify"));
clipboard_event_selection_owner_notify(lxevent);
break;
}
/* we didn't handle this message */
return 1;
}
return 0;
}
Reference in new issue View Git Blame Copy Permalink