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); }