static void drag_data_get_cb (GtkWidget *widget, GdkDragContext *context, GtkSelectionData *data, guint info, guint time, gpointer user_data) { gint pos; pos = gtk_entry_get_current_icon_drag_source (GTK_ENTRY (widget)); if (pos == GTK_ENTRY_ICON_PRIMARY) { #if 0 gint start, end; if (gtk_editable_get_selection_bounds (GTK_EDITABLE (widget), &start, &end)) { gchar *str; str = gtk_editable_get_chars (GTK_EDITABLE (widget), start, end); gtk_selection_data_set_text (data, str, -1); g_free (str); } #else gtk_selection_data_set_text (data, "XXX", -1); #endif } }
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())); } }
static gboolean export_to_text (SeahorseKeyManagerStore *self, GtkSelectionData *selection_data) { guchar *output; gsize size; gboolean ret; guint count; g_return_val_if_fail (self->priv->drag_objects, FALSE); g_debug ("exporting to text"); count = seahorse_exportable_export_to_text_wait (self->priv->drag_objects, &output, &size, &self->priv->drag_error); /* TODO: Need to print status if only partially exported */ if (count > 0) { g_debug ("setting selection text"); gtk_selection_data_set_text (selection_data, (gchar *)output, (gint)size); ret = TRUE; } else if (self->priv->drag_error) { g_message ("error occurred on export: %s", self->priv->drag_error->message); ret = FALSE; } else { g_message ("no objects exported"); ret = FALSE; } g_free (output); return ret; }
static void icon_drag_data_get (GtkWidget *event_box, GdkDragContext *context, GtkSelectionData *selection_data, guint info, guint time_, GbWorkspacePaneGroup *group) { GbWorkspacePaneGroupPrivate *priv; GbWorkspacePane *pane; const gchar *uri; gchar **uris; g_return_if_fail(GTK_IS_EVENT_BOX(event_box)); g_return_if_fail(GB_IS_WORKSPACE_PANE_GROUP(group)); priv = group->priv; if ((pane = gb_workspace_pane_group_get_current_pane(group))) { if ((uri = gb_workspace_pane_get_uri(pane))) { gtk_selection_data_set_text(selection_data, uri, -1); uris = g_new0(gchar*, 2); uris[0] = g_strdup(uri); uris[1] = NULL; gtk_selection_data_set_uris(selection_data, uris); g_strfreev(uris); } }
static void dest_dnd_set_data(GtkWidget *view, GdkDragContext *context, GtkSelectionData *selection_data, guint info, guint time, gpointer data) { gchar *path = NULL; GList *list = NULL; GtkTreeModel *model; GtkTreeSelection *selection; GtkTreeIter iter; selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(view)); if (!gtk_tree_selection_get_selected(selection, &model, &iter)) return; gtk_tree_model_get(model, &iter, 1, &path, -1); if (!path) return; list = g_list_append(list, path); gchar **uris = uris_from_pathlist(list); gboolean ret = gtk_selection_data_set_uris(selection_data, uris); if (!ret) { char *str = g_strjoinv("\r\n", uris); ret = gtk_selection_data_set_text(selection_data, str, -1); g_free(str); } string_list_free(list); }
static void on_log_view_drag_data_get (GtkWidget *log_view, GdkDragContext *drag_context, GtkSelectionData *data, guint info, guint time, GitLogPane *self) { GtkTreeSelection *selection; GtkTreeIter iter; GitRevision *revision; gchar *sha; selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (log_view)); if (gtk_tree_selection_count_selected_rows (selection) > 0) { gtk_tree_selection_get_selected (selection, NULL, &iter); gtk_tree_model_get (GTK_TREE_MODEL (self->priv->log_model), &iter, 0, &revision, -1); sha = git_revision_get_sha (revision); gtk_selection_data_set_text (data, sha, -1); g_object_unref (revision); g_free (sha); } }
static void selection_handler( GtkWidget *WXUNUSED(widget), GtkSelectionData *selection_data, guint WXUNUSED(info), guint WXUNUSED(time), gpointer WXUNUSED(data) ) { if (!wxTheClipboard) return; if (!wxTheClipboard->m_data) return; wxDataObject *data = wxTheClipboard->m_data; wxDataFormat format( selection_data->target ); #ifdef __WXDEBUG__ wxLogTrace(TRACE_CLIPBOARD, _T("clipboard data in format %s, GtkSelectionData is target=%s type=%s selection=%s"), format.GetId().c_str(), wxString::FromAscii(gdk_atom_name(selection_data->target)).c_str(), wxString::FromAscii(gdk_atom_name(selection_data->type)).c_str(), wxString::FromAscii(gdk_atom_name(selection_data->selection)).c_str() ); #endif if (!data->IsSupportedFormat( format )) return; int size = data->GetDataSize( format ); if (size == 0) return; void *d = malloc(size); // Text data will be in UTF8 in Unicode mode. data->GetDataHere( selection_data->target, d ); #ifdef __WXGTK20__ // NB: GTK+ requires special treatment of UTF8_STRING data, the text // would show as UTF-8 data interpreted as latin1 (?) in other // GTK+ apps if we used gtk_selection_data_set() if (format == wxDataFormat(wxDF_UNICODETEXT)) { gtk_selection_data_set_text( selection_data, (const gchar*)d, size-1 ); } else #endif { gtk_selection_data_set( selection_data, GDK_SELECTION_TYPE_STRING, 8*sizeof(gchar), (unsigned char*) d, size-1 ); } free(d); }
static void clipboard_get_cb (GtkClipboard *clipboard, GtkSelectionData *selection_data, guint info, gpointer user_data_or_owner) { ClipboardData *clipboard_data = user_data_or_owner; GdkAtom targets[1]; int n_targets; targets[0] = gtk_selection_data_get_target (selection_data); n_targets = 1; if (gtk_targets_include_uri (targets, n_targets)) { gtk_selection_data_set_uris (selection_data, clipboard_data->uris); } else if (gtk_targets_include_text (targets, n_targets)) { char *str; gsize len; str = clipboard_data_convert_to_text (clipboard_data, FALSE, &len); gtk_selection_data_set_text (selection_data, str, len); g_free (str); } else if (gtk_selection_data_get_target (selection_data) == GNOME_COPIED_FILES) { char *str; gsize len; str = clipboard_data_convert_to_text (clipboard_data, TRUE, &len); gtk_selection_data_set (selection_data, GNOME_COPIED_FILES, 8, (guchar *) str, len); g_free (str); } }
/* Called when another application wants the contents of our selection */ static void selection_get(GtkClipboard *primary, GtkSelectionData *selection_data, guint info, gpointer data) { gchar *text; if (info == TARGET_URI_LIST) text = icon_create_uri_list(); else { GList *next; GString *str; str = g_string_new(NULL); for (next = icon_selection; next; next = next->next) { Icon *icon = (Icon *) next->data; g_string_append(str, icon->path); g_string_append_c(str, ' '); } text = str->str; g_string_free(str, FALSE); } gtk_selection_data_set_text(selection_data, text, strlen(text)); }
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 (); } }
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); } } }
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()); }
static void set_text_data(GtkSelectionData *selection_data, jstring data) { const char *text_data = mainEnv->GetStringUTFChars(data, NULL); guint ntext_data = strlen(text_data); gtk_selection_data_set_text(selection_data, text_data, ntext_data); mainEnv->ReleaseStringUTFChars(data, text_data); }
static void clipboard_get_contents_cb(GtkClipboard *clipboard, GtkSelectionData *selection_data, guint info, gpointer data) { PasteboardSelectionData* clipboardData = reinterpret_cast<PasteboardSelectionData*>(data); ASSERT(clipboardData); if ((gint)info == WEBKIT_WEB_VIEW_TARGET_INFO_HTML) { gtk_selection_data_set(selection_data, selection_data->target, 8, reinterpret_cast<const guchar*>(clipboardData->markup()), g_utf8_strlen(clipboardData->markup(), -1)); } else gtk_selection_data_set_text(selection_data, clipboardData->text(), -1); }
static void fillSelectionData(GtkSelectionData* selectionData, guint info, DataObjectGtk* dataObject) { if (info == WEBKIT_WEB_VIEW_TARGET_INFO_TEXT) gtk_selection_data_set_text(selectionData, dataObject->text().utf8().data(), -1); else if (info == WEBKIT_WEB_VIEW_TARGET_INFO_HTML) { GOwnPtr<gchar> markup(g_strdup(dataObject->markup().utf8().data())); gtk_selection_data_set(selectionData, selectionData->target, 8, reinterpret_cast<const guchar*>(markup.get()), strlen(markup.get())); } }
static void cb_browser_drag_data_get (GtkWidget * widget, GdkDragContext * dc, GtkSelectionData * data, guint info, guint timestamp, gpointer user_data) { if (info == DATA_COMPOSITION_DND_TARGET_TEXT_PLAIN) { gchar *full_paths = NULL; full_paths = xfburn_directory_browser_get_selection (XFBURN_DIRECTORY_BROWSER (widget)); gtk_selection_data_set_text (data, full_paths, -1); g_free (full_paths); } }
void caja_get_clipboard_callback (GtkClipboard *clipboard, GtkSelectionData *selection_data, guint info, gpointer user_data) { char **uris; GList *l; int i; CajaClipboardInfo *clipboard_info; GdkAtom target; clipboard_info = caja_clipboard_monitor_get_clipboard_info (caja_clipboard_monitor_get ()); target = gtk_selection_data_get_target (selection_data); if (gtk_targets_include_uri (&target, 1)) { uris = g_malloc ((g_list_length (clipboard_info->files) + 1) * sizeof (char *)); i = 0; for (l = clipboard_info->files; l != NULL; l = l->next) { uris[i] = caja_file_get_uri (l->data); i++; } uris[i] = NULL; gtk_selection_data_set_uris (selection_data, uris); g_strfreev (uris); } else if (gtk_targets_include_text (&target, 1)) { char *str; gsize len; str = convert_file_list_to_string (clipboard_info, TRUE, &len); gtk_selection_data_set_text (selection_data, str, len); g_free (str); } else if (target == copied_files_atom) { char *str; gsize len; str = convert_file_list_to_string (clipboard_info, FALSE, &len); gtk_selection_data_set (selection_data, copied_files_atom, 8, str, len); g_free (str); } }
static void karea_primary_get (GtkClipboard *clipboard, GtkSelectionData *selection_data, guint info, gpointer owner) { if (kselected.d[0] || kselected.d[1]) { gchar *string_utf = utf8_for_char (kselected); gtk_selection_data_set_text (selection_data, string_utf, -1); g_free (string_utf); } }
gboolean uri_selection_data_set_uris_from_filelist(GtkSelectionData *selection_data, GList *list) { gchar **uris = uris_from_filelist(list); gboolean ret = gtk_selection_data_set_uris(selection_data, uris); if (!ret) { char *str = g_strjoinv("\r\n", uris); ret = gtk_selection_data_set_text(selection_data, str, -1); g_free(str); } g_strfreev(uris); return ret; }
static void cm_tree_drag_data_get_cb(GtkWidget *widget, GdkDragContext *drag_context, GtkSelectionData *data, guint info, guint ltime, CookieManagerPage *cmp) { GtkTreeIter iter, iter_store; GtkTreeSelection *selection; GtkTreeModel *model; GList *rows; CookieManagerPagePrivate *priv = cmp->priv; selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(priv->treeview)); rows = gtk_tree_selection_get_selected_rows(selection, &model); if (cm_list_length(rows) != 1) { cm_free_selection_list(rows, (GFunc) gtk_tree_path_free); return; } /* get iter */ gtk_tree_model_get_iter(model, &iter, (GtkTreePath*) (g_list_nth_data(rows, 0))); gtk_tree_model_filter_convert_iter_to_child_iter( GTK_TREE_MODEL_FILTER(model), &iter_store, &iter); if (gtk_tree_store_iter_is_valid(priv->store, &iter_store)) { SoupCookie *cookie; gchar *name; const gchar *text; gtk_tree_model_get(model, &iter, COOKIE_MANAGER_COL_NAME, &name, COOKIE_MANAGER_COL_COOKIE, &cookie, -1); if (name != NULL) { GtkTreeIter parent; /* get the name of the parent item which should be a domain item */ if (cookie != NULL && gtk_tree_model_iter_parent(model, &parent, &iter)) { g_free(name); gtk_tree_model_get(model, &parent, COOKIE_MANAGER_COL_NAME, &name, -1); } text = cm_skip_leading_dot(name); gtk_selection_data_set_text(data, text, -1); } g_free(name); } }
static void _get_clipboard_callback (GtkClipboard* clipboard, GtkSelectionData* selection_data, guint info, gpointer user_data) { g_debug ("_get_clipboard_callback: begin"); GdkAtom target; target = gtk_selection_data_get_target (selection_data); // set to a URI string if (gtk_targets_include_uri (&target, 1)) { char **uris; uris = g_malloc ((clipboard_info.num + 1) * sizeof (char *)); int i = 0; for (i = 0; i < clipboard_info.num; i++) { uris[i] = g_file_get_uri (clipboard_info.file_list[i]); i++; } uris[i] = NULL; gtk_selection_data_set_uris (selection_data, uris); g_strfreev (uris); } // set to a UTF-8 encoded string else if (gtk_targets_include_text (&target, 1)) { char *str; gsize len; str = __convert_file_list_to_string (&clipboard_info, TRUE, &len); gtk_selection_data_set_text (selection_data, str, len); g_free (str); } //NOTE: cut or copy else if (target == copied_files_atom) { char *str; gsize len; str = __convert_file_list_to_string (&clipboard_info, FALSE, &len); gtk_selection_data_set (selection_data, copied_files_atom, 8, (const guchar*)str, len); g_free (str); } g_debug ("_get_clipboard_callback: end"); }
static void clip_get ( GtkClipboard *c, GtkSelectionData *selection_data, guint info, gpointer p ) { vik_clipboard_t *vc = p; if ( info == 0 ) { // Viking Data Type // g_print("clip_get: vc = %p, size = %d\n", vc, sizeof(*vc) + vc->len); gtk_selection_data_set ( selection_data, selection_data->target, 8, (void *)vc, sizeof(*vc) + vc->len ); } if ( info == 1 ) { // Should be a string, but make sure it's something if ( vc->text ) gtk_selection_data_set_text ( selection_data, vc->text, -1); // string text is null terminated } }
static void clipboard_get_contents_cb(GtkClipboard* clipboard, GtkSelectionData* selection_data, guint info, gpointer data) { WebKitWebView* webView = reinterpret_cast<WebKitWebView*>(data); Frame* frame = core(webView)->focusController()->focusedOrMainFrame(); PassRefPtr<Range> selectedRange = frame->selection()->toNormalizedRange(); if (static_cast<gint>(info) == WEBKIT_WEB_VIEW_TARGET_INFO_HTML) { String markup = createMarkup(selectedRange.get(), 0, AnnotateForInterchange); gtk_selection_data_set(selection_data, selection_data->target, 8, reinterpret_cast<const guchar*>(markup.utf8().data()), markup.utf8().length()); } else { String text = selectedRange->text(); gtk_selection_data_set_text(selection_data, text.utf8().data(), text.utf8().length()); } }
//! //! @brief To be written //! static void _kanjipadwindow_primary_candidates_get (GtkClipboard *clipboard, GtkSelectionData *selection_data, guint info, gpointer data) { GwKanjipadWindow *window; GwKanjipadWindowPrivate *priv; gchar *string_utf; window = GW_KANJIPADWINDOW (data); priv = window->priv; if (priv->kselected[0] || priv->kselected[1]) { string_utf = _kanjipadwindow_utf8_for_char (priv->kselected); gtk_selection_data_set_text (selection_data, string_utf, -1); g_free (string_utf); } }
/* sets the picked character as the selection when it gets a request */ static void charpick_selection_handler(GtkWidget *widget, GtkSelectionData *selection_data, guint info, guint time, gpointer data) { charpick_data *p_curr_data = data; gint num; gchar tmp[7]; num = g_unichar_to_utf8 (p_curr_data->selected_unichar, tmp); tmp[num] = '\0'; gtk_selection_data_set_text (selection_data, tmp, -1); return; }
JNIEXPORT jboolean JNICALL Java_org_gnome_gtk_GtkSelectionData_gtk_1selection_1data_1set_1text ( JNIEnv* env, jclass cls, jlong _self, jstring _str, jint _len ) { gboolean result; jboolean _result; GtkSelectionData* self; const gchar* str; gint len; // convert parameter self self = (GtkSelectionData*) _self; // convert parameter str str = (const gchar*) bindings_java_getString(env, _str); if (str == NULL) { return JNI_FALSE; // Java Exception already thrown } // convert parameter len len = (gint) _len; // call function result = gtk_selection_data_set_text(self, str, len); // cleanup parameter self // cleanup parameter str bindings_java_releaseString(str); // cleanup parameter len // translate return value to JNI type _result = (jboolean) result; // and finally return _result; }
static void gstyle_color_widget_on_drag_data_get (GtkWidget *widget, GdkDragContext *context, GtkSelectionData *data, guint info, guint time) { GstyleColorWidget *self = (GstyleColorWidget *)widget; GdkAtom target = gtk_selection_data_get_target (data); GstyleColor *color; guint16 data_rgba[4]; GdkRGBA rgba; g_assert (GSTYLE_IS_COLOR_WIDGET (self)); g_assert (GDK_IS_DRAG_CONTEXT (context)); if (self->filter_func != NULL && GSTYLE_IS_COLOR (self->filtered_color)) color = self->filtered_color; else color = self->color; if (target == gdk_atom_intern_static_string ("GSTYLE_COLOR_WIDGET")) gtk_selection_data_set (data, target, 8, (void*)&color, sizeof (gpointer)); else if (target == gdk_atom_intern_static_string ("application/x-color")) { gstyle_color_fill_rgba (color, &rgba); data_rgba[0] = (guint16) (rgba.red * 65535); data_rgba[1] = (guint16) (rgba.green * 65535); data_rgba[2] = (guint16) (rgba.blue * 65535); data_rgba[3] = (guint16) (rgba.alpha * 65535); gtk_selection_data_set (data, target, 16, (void*)&data_rgba, 8); } else if (gtk_targets_include_text (&target, 1)) { g_autofree gchar *name = NULL; name = gstyle_color_to_string (color, GSTYLE_COLOR_KIND_ORIGINAL); if (name == NULL) name = gstyle_color_to_string (color, GSTYLE_COLOR_KIND_RGB_HEX6); gtk_selection_data_set_text (data, name, -1); } }
static void bar_pane_exif_entry_dnd_get(GtkWidget *entry, GdkDragContext *context, GtkSelectionData *selection_data, guint info, guint time, gpointer data) { ExifEntry *ee = g_object_get_data(G_OBJECT(entry), "entry_data"); switch (info) { case TARGET_APP_EXIF_ENTRY: gtk_selection_data_set(selection_data, gtk_selection_data_get_target(selection_data), 8, (gpointer) &entry, sizeof(entry)); break; case TARGET_TEXT_PLAIN: default: gtk_selection_data_set_text(selection_data, ee->key, -1); break; } }
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; } }
static void gretl_clipboard_get (GtkClipboard *clip, GtkSelectionData *selection_data, guint info, gpointer p) { #if 1 || CLIPDEBUG fprintf(stderr, "gretl_clipboard_get: info = %d (%s)\n", (int) info, fmt_label(info)); #endif if (image_type(info)) { write_plot_for_copy(info); if (clipboard_buf == NULL) { return; } } else { if (clipboard_buf == NULL || *clipboard_buf == '\0') { return; } else if (info != TARGET_UTF8_STRING) { /* remove any Unicode minuses (??) */ strip_unicode_minus(clipboard_buf); } } if (info == TARGET_RTF) { gtk_selection_data_set(selection_data, GDK_SELECTION_TYPE_STRING, 8, (guchar *) clipboard_buf, strlen(clipboard_buf)); } else if (image_type(info)) { gtk_selection_data_set(selection_data, GDK_SELECTION_TYPE_STRING, 8, (guchar *) clipboard_buf, clipboard_bytes); } else { gtk_selection_data_set_text(selection_data, clipboard_buf, -1); } }