void remmina_rdp_cliprdr_request_data(GtkClipboard *clipboard, GtkSelectionData *selection_data, guint info, RemminaProtocolWidget* gp)
{
GdkAtom target;
gpointer data;
RDP_CB_DATA_REQUEST_EVENT* event;
rfContext* rfi = GET_DATA(gp);
target = gtk_selection_data_get_target(selection_data);
rfi->format = remmina_rdp_cliprdr_get_format_from_gdkatom(target);
rfi->clipboard_queue = g_async_queue_new();
/* Request Clipboard data of the server */
event = (RDP_CB_DATA_REQUEST_EVENT*)
freerdp_event_new(CliprdrChannel_Class, CliprdrChannel_DataRequest, NULL, NULL);
event->format = rfi->format;
freerdp_channels_send_event(rfi->instance->context->channels, (wMessage*) event);
data = g_async_queue_timeout_pop(rfi->clipboard_queue, 1000000);
if (data != NULL)
{
if (info == CB_FORMAT_PNG || info == CB_FORMAT_DIB || info == CB_FORMAT_JPEG)
{
gtk_selection_data_set_pixbuf(selection_data, data);
g_object_unref(data);
}
else
{
gtk_selection_data_set_text(selection_data, data, -1);
}
}
}
static void
gimp_clipboard_send_buffer (GtkClipboard *clipboard,
GtkSelectionData *selection_data,
guint info,
Gimp *gimp)
{
GimpClipboard *gimp_clip = gimp_clipboard_get (gimp);
GdkPixbuf *pixbuf;
gimp_set_busy (gimp);
pixbuf = gimp_viewable_get_pixbuf (GIMP_VIEWABLE (gimp_clip->buffer),
gimp_get_user_context (gimp),
gimp_buffer_get_width (gimp_clip->buffer),
gimp_buffer_get_height (gimp_clip->buffer));
if (pixbuf)
{
if (gimp->be_verbose)
g_printerr ("clipboard: sending pixbuf data as '%s'\n",
gimp_clip->target_entries[info].target);
gtk_selection_data_set_pixbuf (selection_data, pixbuf);
}
else
{
g_warning ("%s: gimp_viewable_get_pixbuf() failed", G_STRFUNC);
}
gimp_unset_busy (gimp);
}
JNIEXPORT jboolean JNICALL
Java_org_gnome_gtk_GtkSelectionData_gtk_1selection_1data_1set_1pixbuf
(
JNIEnv* env,
jclass cls,
jlong _self,
jlong _pixbuf
)
{
gboolean result;
jboolean _result;
GtkSelectionData* self;
GdkPixbuf* pixbuf;
// convert parameter self
self = (GtkSelectionData*) _self;
// convert parameter pixbuf
pixbuf = (GdkPixbuf*) _pixbuf;
// call function
result = gtk_selection_data_set_pixbuf(self, pixbuf);
// cleanup parameter self
// cleanup parameter pixbuf
// translate return value to JNI type
_result = (jboolean) result;
// and finally
return _result;
}
void PasteboardHelper::fillSelectionData(GtkSelectionData* selectionData, guint info, DataObjectGtk* dataObject)
{
if (info == getIdForTargetType(TargetTypeText))
gtk_selection_data_set_text(selectionData, dataObject->text().utf8().data(), -1);
else if (info == getIdForTargetType(TargetTypeMarkup)) {
// Some Linux applications refuse to accept pasted markup unless it is
// prefixed by a content-type meta tag.
CString markup = (gMarkupPrefix + dataObject->markup()).utf8();
gtk_selection_data_set(selectionData, markupAtom, 8,
reinterpret_cast<const guchar*>(markup.data()), markup.length() + 1);
} else if (info == getIdForTargetType(TargetTypeURIList)) {
CString uriList = dataObject->uriList().utf8();
gtk_selection_data_set(selectionData, uriListAtom, 8,
reinterpret_cast<const guchar*>(uriList.data()), uriList.length() + 1);
} else if (info == getIdForTargetType(TargetTypeNetscapeURL) && dataObject->hasURL()) {
String url(dataObject->url());
String result(url);
result.append("\n");
if (dataObject->hasText())
result.append(dataObject->text());
else
result.append(url);
GOwnPtr<gchar> resultData(g_strdup(result.utf8().data()));
gtk_selection_data_set(selectionData, netscapeURLAtom, 8,
reinterpret_cast<const guchar*>(resultData.get()), strlen(resultData.get()) + 1);
} else if (info == getIdForTargetType(TargetTypeImage))
gtk_selection_data_set_pixbuf(selectionData, dataObject->image());
}
void
image_drag_data_get (GtkWidget *widget,
GdkDragContext *context,
GtkSelectionData *selection_data,
guint info,
guint time,
gpointer data)
{
GdkPixbuf *pixbuf;
const gchar *name;
switch (info)
{
case TARGET_IMAGE:
pixbuf = get_image_pixbuf (GTK_IMAGE (data));
gtk_selection_data_set_pixbuf (selection_data, pixbuf);
g_object_unref (pixbuf);
break;
case TARGET_TEXT:
if (gtk_image_get_storage_type (GTK_IMAGE (data)) == GTK_IMAGE_ICON_NAME)
gtk_image_get_icon_name (GTK_IMAGE (data), &name, NULL);
else
name = "Boo!";
gtk_selection_data_set_text (selection_data, name, -1);
break;
default:
g_assert_not_reached ();
}
}
static void set_image_data(GtkSelectionData *selection_data, jobject pixels)
{
GdkPixbuf *pixbuf = NULL;
mainEnv->CallVoidMethod(pixels, jPixelsAttachData, PTR_TO_JLONG(&pixbuf));
if (!EXCEPTION_OCCURED(mainEnv)) {
gtk_selection_data_set_pixbuf(selection_data, pixbuf);
}
g_object_unref(pixbuf);
}
void PasteboardHelper::fillSelectionData(GtkSelectionData* selectionData, guint info, DataObjectGtk* dataObject)
{
if (info == TargetTypeText)
gtk_selection_data_set_text(selectionData, dataObject->text().utf8().data(), -1);
else if (info == TargetTypeMarkup) {
// Some Linux applications refuse to accept pasted markup unless it is
// prefixed by a content-type meta tag.
CString markup = String(gMarkupPrefix + dataObject->markup()).utf8();
gtk_selection_data_set(selectionData, markupAtom, 8,
reinterpret_cast<const guchar*>(markup.data()), markup.length());
} else if (info == TargetTypeURIList) {
CString uriList = dataObject->uriList().utf8();
gtk_selection_data_set(selectionData, uriListAtom, 8,
reinterpret_cast<const guchar*>(uriList.data()), uriList.length());
} else if (info == TargetTypeNetscapeURL && dataObject->hasURL()) {
String url(dataObject->url());
String result(url);
result.append("\n");
if (dataObject->hasText())
result.append(dataObject->text());
else
result.append(url);
GUniquePtr<gchar> resultData(g_strdup(result.utf8().data()));
gtk_selection_data_set(selectionData, netscapeURLAtom, 8,
reinterpret_cast<const guchar*>(resultData.get()), strlen(resultData.get()));
} else if (info == TargetTypeImage)
gtk_selection_data_set_pixbuf(selectionData, dataObject->image());
else if (info == TargetTypeSmartPaste)
gtk_selection_data_set_text(selectionData, "", -1);
else if (info == TargetTypeUnknown) {
GVariantBuilder builder;
g_variant_builder_init(&builder, G_VARIANT_TYPE_ARRAY);
auto types = dataObject->unknownTypes();
auto end = types.end();
for (auto it = types.begin(); it != end; ++it) {
GUniquePtr<gchar> dictItem(g_strdup_printf("{'%s', '%s'}", it->key.utf8().data(), it->value.utf8().data()));
g_variant_builder_add_parsed(&builder, dictItem.get());
}
GRefPtr<GVariant> variant = g_variant_builder_end(&builder);
GUniquePtr<gchar> serializedVariant(g_variant_print(variant.get(), TRUE));
gtk_selection_data_set(selectionData, unknownAtom, 1, reinterpret_cast<const guchar*>(serializedVariant.get()), strlen(serializedVariant.get()));
}
}
void
drag_data_get (GtkWidget *widget,
GdkDragContext *context,
GtkSelectionData *selection_data,
guint info,
guint time,
gpointer data)
{
GtkWidget *image = GTK_WIDGET (data);
GdkPixbuf *pixbuf = gtk_image_get_pixbuf (GTK_IMAGE (image));
gtk_selection_data_set_pixbuf (selection_data, pixbuf);
}
void
drag_data_get (GtkWidget *widget,
GdkDragContext *context,
GtkSelectionData *selection_data,
guint info,
guint time,
gpointer data)
{
GdkPixbuf *pixbuf;
pixbuf = get_image_pixbuf (GTK_IMAGE (data));
gtk_selection_data_set_pixbuf (selection_data, pixbuf);
g_object_unref (pixbuf);
}
static gboolean
gtk_selection_data_set_surface (GtkSelectionData *selection_data,
cairo_surface_t *surface)
{
GdkPixbuf *pixbuf;
gboolean retval;
pixbuf = gdk_pixbuf_get_from_surface (surface,
0, 0,
cairo_image_surface_get_width (surface),
cairo_image_surface_get_height (surface));
retval = gtk_selection_data_set_pixbuf (selection_data, pixbuf);
g_object_unref (pixbuf);
return retval;
}
void callback_clipboard_get(GtkClipboard *clipboard,
GtkSelectionData *selection_data,
guint info, gpointer user_data)
{
struct XojSelectionData *sel = (struct XojSelectionData *)user_data;
switch (info) {
case TARGET_XOURNAL:
gtk_selection_data_set(selection_data,
gdk_atom_intern(XOURNAL_TARGET_ATOM, FALSE), 8, sel->xo_data, sel->xo_data_len);
break;
case TARGET_TEXT:
if (sel->text_data!=NULL)
gtk_selection_data_set_text(selection_data, sel->text_data, -1);
break;
case TARGET_PIXBUF:
if (sel->image_data!=NULL)
gtk_selection_data_set_pixbuf(selection_data, sel->image_data);
break;
}
}
void
nsClipboard::SelectionGetEvent(GtkClipboard *aClipboard,
GtkSelectionData *aSelectionData)
{
// Someone has asked us to hand them something. The first thing
// that we want to do is see if that something includes text. If
// it does, try to give it text/unicode after converting it to
// utf-8.
PRInt32 whichClipboard;
// which clipboard?
if (aSelectionData->selection == GDK_SELECTION_PRIMARY)
whichClipboard = kSelectionClipboard;
else if (aSelectionData->selection == GDK_SELECTION_CLIPBOARD)
whichClipboard = kGlobalClipboard;
else
return; // THAT AIN'T NO CLIPBOARD I EVER HEARD OF
nsCOMPtr<nsITransferable> trans = GetTransferable(whichClipboard);
if (!trans) {
// We have nothing to serve
#ifdef DEBUG_CLIPBOARD
printf("nsClipboard::SelectionGetEvent() - %s clipboard is empty!\n",
whichClipboard == kSelectionClipboard ? "Selection" : "Global");
#endif
return;
}
nsresult rv;
nsCOMPtr<nsISupports> item;
PRUint32 len;
// Check to see if the selection data includes any of the string
// types that we support.
if (aSelectionData->target == gdk_atom_intern ("STRING", FALSE) ||
aSelectionData->target == gdk_atom_intern ("TEXT", FALSE) ||
aSelectionData->target == gdk_atom_intern ("COMPOUND_TEXT", FALSE) ||
aSelectionData->target == gdk_atom_intern ("UTF8_STRING", FALSE)) {
// Try to convert our internal type into a text string. Get
// the transferable for this clipboard and try to get the
// text/unicode type for it.
rv = trans->GetTransferData("text/unicode", getter_AddRefs(item),
&len);
if (!item || NS_FAILED(rv))
return;
nsCOMPtr<nsISupportsString> wideString;
wideString = do_QueryInterface(item);
if (!wideString)
return;
nsAutoString ucs2string;
wideString->GetData(ucs2string);
char *utf8string = ToNewUTF8String(ucs2string);
if (!utf8string)
return;
gtk_selection_data_set_text (aSelectionData, utf8string,
strlen(utf8string));
nsMemory::Free(utf8string);
return;
}
// Check to see if the selection data is an image type
if (gtk_targets_include_image(&aSelectionData->target, 1, TRUE)) {
// Look through our transfer data for the image
static const char* const imageMimeTypes[] = {
kNativeImageMime, kPNGImageMime, kJPEGImageMime, kGIFImageMime };
nsCOMPtr<nsISupports> item;
PRUint32 len;
nsCOMPtr<nsISupportsInterfacePointer> ptrPrimitive;
for (PRUint32 i = 0; !ptrPrimitive && i < NS_ARRAY_LENGTH(imageMimeTypes); i++) {
rv = trans->GetTransferData(imageMimeTypes[i], getter_AddRefs(item), &len);
ptrPrimitive = do_QueryInterface(item);
}
if (!ptrPrimitive)
return;
nsCOMPtr<nsISupports> primitiveData;
ptrPrimitive->GetData(getter_AddRefs(primitiveData));
nsCOMPtr<imgIContainer> image(do_QueryInterface(primitiveData));
if (!image) // Not getting an image for an image mime type!?
return;
GdkPixbuf* pixbuf = nsImageToPixbuf::ImageToPixbuf(image);
if (!pixbuf)
return;
gtk_selection_data_set_pixbuf(aSelectionData, pixbuf);
g_object_unref(pixbuf);
return;
}
// Try to match up the selection data target to something our
// transferable provides.
gchar *target_name = gdk_atom_name(aSelectionData->target);
if (!target_name)
return;
rv = trans->GetTransferData(target_name, getter_AddRefs(item), &len);
// nothing found?
if (!item || NS_FAILED(rv)) {
g_free(target_name);
return;
}
void *primitive_data = nsnull;
nsPrimitiveHelpers::CreateDataFromPrimitive(target_name, item,
&primitive_data, len);
if (primitive_data) {
// Check to see if the selection data is text/html
if (aSelectionData->target == gdk_atom_intern (kHTMLMime, FALSE)) {
/*
* "text/html" can be encoded UCS2. It is recommended that
* documents transmitted as UCS2 always begin with a ZERO-WIDTH
* NON-BREAKING SPACE character (hexadecimal FEFF, also called
* Byte Order Mark (BOM)). Adding BOM can help other app to
* detect mozilla use UCS2 encoding when copy-paste.
*/
guchar *buffer = (guchar *)
nsMemory::Alloc((len * sizeof(guchar)) + sizeof(PRUnichar));
if (!buffer)
return;
PRUnichar prefix = 0xFEFF;
memcpy(buffer, &prefix, sizeof(prefix));
memcpy(buffer + sizeof(prefix), primitive_data, len);
nsMemory::Free((guchar *)primitive_data);
primitive_data = (guchar *)buffer;
len += sizeof(prefix);
}
gtk_selection_data_set(aSelectionData, aSelectionData->target,
8, /* 8 bits in a unit */
(const guchar *)primitive_data, len);
nsMemory::Free(primitive_data);
}
g_free(target_name);
}
void remmina_rdp_cliprdr_request_data(GtkClipboard *gtkClipboard, GtkSelectionData *selection_data, guint info, RemminaProtocolWidget* gp )
{
TRACE_CALL(__func__);
/* Called by GTK when someone press "Paste" on the client side.
* We ask to the server the data we need */
CLIPRDR_FORMAT_DATA_REQUEST* pFormatDataRequest;
rfClipboard* clipboard;
rfContext* rfi = GET_PLUGIN_DATA(gp);
RemminaPluginRdpEvent rdp_event = { 0 };
struct timespec to;
struct timeval tv;
int rc;
clipboard = &(rfi->clipboard);
if ( clipboard->srv_clip_data_wait != SCDW_NONE ) {
remmina_plugin_service->log_printf("[RDP] Cannot paste now, I’m transferring clipboard data from server. Try again later\n");
return;
}
clipboard->format = info;
/* Request Clipboard content from the server, the request is async */
pthread_mutex_lock(&clipboard->transfer_clip_mutex);
pFormatDataRequest = (CLIPRDR_FORMAT_DATA_REQUEST*)malloc(sizeof(CLIPRDR_FORMAT_DATA_REQUEST));
ZeroMemory(pFormatDataRequest, sizeof(CLIPRDR_FORMAT_DATA_REQUEST));
pFormatDataRequest->requestedFormatId = clipboard->format;
clipboard->srv_clip_data_wait = SCDW_BUSY_WAIT;
rdp_event.type = REMMINA_RDP_EVENT_TYPE_CLIPBOARD_SEND_CLIENT_FORMAT_DATA_REQUEST;
rdp_event.clipboard_formatdatarequest.pFormatDataRequest = pFormatDataRequest;
remmina_rdp_event_event_push(gp, &rdp_event);
/* Busy wait clibpoard data for CLIPBOARD_TRANSFER_WAIT_TIME seconds */
gettimeofday(&tv, NULL);
to.tv_sec = tv.tv_sec + CLIPBOARD_TRANSFER_WAIT_TIME;
to.tv_nsec = tv.tv_usec * 1000;
rc = pthread_cond_timedwait(&clipboard->transfer_clip_cond, &clipboard->transfer_clip_mutex, &to);
if ( rc == 0 ) {
/* Data has arrived without timeout */
if (clipboard->srv_data != NULL) {
if (info == CB_FORMAT_PNG || info == CF_DIB || info == CF_DIBV5 || info == CB_FORMAT_JPEG) {
gtk_selection_data_set_pixbuf(selection_data, clipboard->srv_data);
g_object_unref(clipboard->srv_data);
}else {
gtk_selection_data_set_text(selection_data, clipboard->srv_data, -1);
free(clipboard->srv_data);
}
}
clipboard->srv_clip_data_wait = SCDW_NONE;
} else {
clipboard->srv_clip_data_wait = SCDW_ASYNCWAIT;
if ( rc == ETIMEDOUT ) {
remmina_plugin_service->log_printf("[RDP] Clipboard data has not been transferred from the server in %d seconds. Try to paste later.\n",
CLIPBOARD_TRANSFER_WAIT_TIME);
}else {
remmina_plugin_service->log_printf("[RDP] internal error: pthread_cond_timedwait() returned %d\n", rc);
clipboard->srv_clip_data_wait = SCDW_NONE;
}
}
pthread_mutex_unlock(&clipboard->transfer_clip_mutex);
}