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 _view_map_dnd_get_callback(GtkWidget *widget, GdkDragContext *context, GtkSelectionData *selection_data, guint target_type, guint time, dt_view_t *self) { dt_map_t *lib = (dt_map_t*)self->data; g_assert (selection_data != NULL); int imgid = lib->selected_image; switch (target_type) { case DND_TARGET_IMGID: gtk_selection_data_set(selection_data, selection_data-> target, _DWORD, (guchar*) &imgid, sizeof(imgid)); break; default: // return the location of the file as a last resort case DND_TARGET_URI: { gchar pathname[DT_MAX_PATH_LEN] = {0}; dt_image_full_path(imgid, pathname, DT_MAX_PATH_LEN); gchar *uri = g_strdup_printf("file://%s", pathname); // TODO: should we add the host? gtk_selection_data_set(selection_data, selection_data-> target, _BYTE, (guchar*) uri, strlen(uri)); g_free(uri); break; } } }
/* * handles request for selection from other apps */ gboolean selection_handle(GtkWidget *widget, GtkSelectionData *selection_data, guint info, guint time_stamp, gpointer data) { static gchar *converted = NULL; begin_func("selection_handle"); if (converted != NULL) { g_free(converted); } if (selected) { converted = from_utf8(selected->content); gtk_selection_data_set(selection_data, GDK_SELECTION_TYPE_STRING, 8, (guchar *) converted, strlen(converted)); } else { gtk_selection_data_set(selection_data, GDK_SELECTION_TYPE_STRING, 8, (guchar *)"", 0); } return_val(TRUE); }
static void drag_data_get_handl(GtkWidget *widget, GdkDragContext *context, GtkSelectionData *sel_data, guint info, guint time, gpointer data) { guint i = GPOINTER_TO_UINT(data); g_print("\nGet data...\n"); switch(i) { case 0: gtk_selection_data_set(sel_data, gtk_selection_data_get_target (sel_data), 8, (guchar *)"Candidate 0", 11); break; case 1: gtk_selection_data_set(sel_data, gtk_selection_data_get_target (sel_data), 8, (guchar *)"Candidate 1", 11); break; case 2: gtk_selection_data_set(sel_data, gtk_selection_data_get_target (sel_data), 8, (guchar *)"Candidate 2", 11); break; default: break; } }
static void _lib_filmstrip_dnd_get_callback(GtkWidget *widget, GdkDragContext *context, GtkSelectionData *selection_data, guint target_type, guint time, gpointer user_data) { dt_lib_module_t *self = (dt_lib_module_t *)user_data; dt_lib_filmstrip_t *strip = (dt_lib_filmstrip_t *)self->data; g_assert(selection_data != NULL); int mouse_over_id = strip->mouse_over_id; int count = dt_collection_get_selected_count(NULL); switch(target_type) { case DND_TARGET_IMGID: { int id = ((count == 1) ? mouse_over_id : -1); gtk_selection_data_set(selection_data, gtk_selection_data_get_target(selection_data), _DWORD, (guchar *)&id, sizeof(id)); break; } default: // return the location of the file as a last resort case DND_TARGET_URI: // TODO: add all images from the selection { if(count == 1) { gchar pathname[PATH_MAX] = { 0 }; gboolean from_cache = TRUE; dt_image_full_path(mouse_over_id, pathname, sizeof(pathname), &from_cache); gchar *uri = g_strdup_printf("file://%s", pathname); // TODO: should we add the host? gtk_selection_data_set(selection_data, gtk_selection_data_get_target(selection_data), _BYTE, (guchar *)uri, strlen(uri)); g_free(uri); } else { sqlite3_stmt *stmt; GList *images = NULL; DT_DEBUG_SQLITE3_PREPARE_V2(dt_database_get(darktable.db), "SELECT imgid FROM main.selected_images", -1, &stmt, NULL); while(sqlite3_step(stmt) == SQLITE_ROW) { int id = sqlite3_column_int(stmt, 0); gchar pathname[PATH_MAX] = { 0 }; gboolean from_cache = TRUE; dt_image_full_path(id, pathname, sizeof(pathname), &from_cache); gchar *uri = g_strdup_printf("file://%s", pathname); // TODO: should we add the host? images = g_list_append(images, uri); } sqlite3_finalize(stmt); gchar *uri_list = dt_util_glist_to_str("\r\n", images); g_list_free_full(images, g_free); gtk_selection_data_set(selection_data, gtk_selection_data_get_target(selection_data), _BYTE, (guchar *)uri_list, strlen(uri_list)); g_free(uri_list); } break; } } }
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 void xfdesktop_clipboard_manager_get_callback (GtkClipboard *clipboard, GtkSelectionData *selection_data, guint target_info, gpointer user_data) { XfdesktopClipboardManager *manager = XFDESKTOP_CLIPBOARD_MANAGER (user_data); GList *file_list = NULL; gchar *string_list; gchar *data; g_return_if_fail (GTK_IS_CLIPBOARD (clipboard)); g_return_if_fail (XFDESKTOP_IS_CLIPBOARD_MANAGER (manager)); g_return_if_fail (manager->clipboard == clipboard); /* determine the file list from the icon list */ file_list = xfdesktop_file_utils_file_icon_list_to_file_list (manager->files); /* determine the string representation of the file list */ string_list = xfdesktop_file_utils_file_list_to_string (file_list); switch (target_info) { case TARGET_GNOME_COPIED_FILES: data = g_strconcat (manager->files_cutted ? "cut\n" : "copy\n", string_list, NULL); gtk_selection_data_set (selection_data, gtk_selection_data_get_target(selection_data), 8, (guchar *) data, strlen (data)); g_free (data); break; case TARGET_UTF8_STRING: gtk_selection_data_set (selection_data, gtk_selection_data_get_target(selection_data), 8, (guchar *) string_list, strlen (string_list)); break; default: g_assert_not_reached (); } /* cleanup */ xfdesktop_file_utils_file_list_free (file_list); g_free (string_list); }
void browser_drag_data_get(GtkWidget * widget, GdkDragContext * drag_context, GtkSelectionData * data, guint info, guint time, gpointer user_data) { gtk_selection_data_set(data, gtk_selection_data_get_target(data), 8, (const guchar *) "store\0", 6); }
static void drag_data_get (GtkWidget *widget, GdkDragContext *context, GtkSelectionData *selection, guint info, guint time_) { EmpathyPersonaView *self = EMPATHY_PERSONA_VIEW (widget); FolksPersona *persona; const gchar *persona_uid; if (info != DND_DRAG_TYPE_PERSONA_ID) return; persona = empathy_persona_view_dup_selected (self); if (persona == NULL) return; persona_uid = folks_persona_get_uid (persona); gtk_selection_data_set (selection, gdk_atom_intern ("text/x-persona-id", FALSE), 8, (guchar *) persona_uid, strlen (persona_uid) + 1); g_object_unref (persona); }
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); } }
static void _lib_keywords_drag_data_get_callback(GtkWidget *w, GdkDragContext *dctx, GtkSelectionData *data, guint info, guint time, gpointer user_data) { dt_lib_module_t *self = (dt_lib_module_t *)user_data; dt_lib_keywords_t *d = (dt_lib_keywords_t*)self->data; /* get iter of item to drag to ssetup drag data */ GtkTreeIter iter; GtkTreeModel *model = NULL; GtkTreeSelection *s = gtk_tree_view_get_selection(d->view); if (gtk_tree_selection_get_selected(s,&model,&iter)) { /* get tree path as string out of iter into selection data */ GtkTreePath *path = NULL; path = gtk_tree_model_get_path(model,&iter); gchar *sp = gtk_tree_path_to_string(path); gtk_selection_data_set(data,data->target, 8, (const guchar *)sp, strlen(sp)); } }
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 tb_editor_drag_data_get_cb(GtkWidget *widget, GdkDragContext *context, GtkSelectionData *data, guint info, guint ltime, TBEditorWidget *tbw) { GtkTreeIter iter; GtkTreeSelection *selection; GtkTreeModel *model; GdkAtom atom; gchar *name; selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(widget)); if (! gtk_tree_selection_get_selected(selection, &model, &iter)) return; gtk_tree_model_get(model, &iter, TB_EDITOR_COL_ACTION, &name, -1); if (name == NULL || *name == '\0') { g_free(name); return; } atom = gdk_atom_intern(tb_editor_dnd_targets[0].target, FALSE); gtk_selection_data_set(data, atom, 8, (guchar*) name, strlen(name)); g_free(name); tbw->drag_source = widget; }
/* Common function for drag_data_get_callback calls. * Returns FALSE if it doesn't handle drag data */ gboolean nautilus_drag_drag_data_get (GtkWidget *widget, GdkDragContext *context, GtkSelectionData *selection_data, guint info, guint32 time, gpointer container_context, NautilusDragEachSelectedItemIterator each_selected_item_iterator) { GString *result; switch (info) { case NAUTILUS_ICON_DND_GNOME_ICON_LIST: result = g_string_new (NULL); (* each_selected_item_iterator) (add_one_gnome_icon, container_context, result); break; case NAUTILUS_ICON_DND_URI_LIST: case NAUTILUS_ICON_DND_TEXT: result = g_string_new (NULL); (* each_selected_item_iterator) (add_one_uri, container_context, result); break; default: return FALSE; } gtk_selection_data_set (selection_data, selection_data->target, 8, result->str, result->len); return TRUE; }
static void drag_data_get_cb (GtkWidget *widget, GdkDragContext *context, GtkSelectionData *selection_data, guint info, guint32 time, EggToolbarEditor *editor) { GtkAction *action; const char *target; action = GTK_ACTION (g_object_get_data (G_OBJECT (widget), "egg-action")); if (action) { target = gtk_action_get_name (action); } else { target = "separator"; } gtk_selection_data_set (selection_data, selection_data->target, 8, (const guchar *)target, strlen (target)); }
static void drag_data_get_cb (GtkWidget *widget, GdkDragContext *context, GtkSelectionData *selection_data, guint info, guint time, Launcher *launcher) { char *location; g_return_if_fail (launcher != NULL); location = launcher->location; if (info == TARGET_URI_LIST) { char *uri[2]; uri[0] = panel_launcher_get_uri (location); uri[1] = NULL; gtk_selection_data_set_uris (selection_data, uri); g_free (uri[0]); } else if (info == TARGET_ICON_INTERNAL) gtk_selection_data_set (selection_data, gtk_selection_data_get_target (selection_data), 8, (unsigned char *) location, strlen (location)); }
static void gmdb_sql_dnd_dataget_cb( GtkWidget *w, GdkDragContext *dc, GtkSelectionData *selection_data, guint info, guint t, GladeXML *xml) { gchar tablename[256]; //gchar *tablename = "Orders"; gchar *name; GtkTreeSelection *select; GtkTreeStore *store; GtkTreeView *tree; GtkTreeIter iter2; tree = (GtkTreeView *) glade_xml_get_widget(xml, "sql_treeview"); select = gtk_tree_view_get_selection(GTK_TREE_VIEW (tree)); store = (GtkTreeStore *) gtk_tree_view_get_model(tree); gtk_tree_selection_get_selected (select, NULL, &iter2); gtk_tree_model_get (GTK_TREE_MODEL(store), &iter2, 0, &name, -1); strcpy(tablename,name); g_free(name); //strcpy(tablename, "Shippers"); gtk_selection_data_set( selection_data, GDK_SELECTION_TYPE_STRING, 8, /* 8 bits per character. */ (guchar*)tablename, strlen(tablename)); }
static void clipboard_get_clipboard_data (GtkClipboard *clip, GtkSelectionData *sel, guint info, gpointer user_data) { clipboard_data_context_t *clip_ctx = (clipboard_data_context_t *)user_data; GdkAtom target = gtk_selection_data_get_target (sel); GString *uri_list = g_string_sized_new (clip_ctx->num_tracks * 256); guchar *buf = NULL; gint buf_len = 0; if (info == TARGET_SAMEWIDGET) { buf = (guchar *)clip_ctx; buf_len = sizeof (clipboard_data_context_t); } else if (info == GNOME_COPIED_FILES) { g_string_append (uri_list, clip_ctx->cut ? "cut\n" : "copy\n"); clipboard_write_gnome_uri_list (clip_ctx, uri_list); buf = (guchar *)uri_list->str; buf_len = uri_list->len + 1; } else /* text/uri-list format */ { clipboard_write_uri_list (clip_ctx, uri_list); buf = (guchar *)uri_list->str; buf_len = uri_list->len + 1; } gtk_selection_data_set (sel, target, 8, buf, buf_len); g_string_free (uri_list, TRUE); }
static void clipboard_get_cb (GtkClipboard *clipboard, GtkSelectionData *selection_data, guint info, gpointer data) { GString *string = NULL; switch (info) { case SELECT_FMT_TEXT: string = clip_to_text (); break; case SELECT_FMT_HTML: string = clip_to_html (); break; default: g_assert_not_reached (); } gtk_selection_data_set (selection_data, selection_data->target, 8, (const guchar *) string->str, string->len); g_string_free (string, TRUE); }
static void info_window_dnd_data_set(GtkWidget *widget, GdkDragContext *context, GtkSelectionData *selection_data, guint info, guint time, gpointer data) { InfoData *id = data; const gchar *path; path = image_get_path(id->image); if (path) { gchar *text; gint len; GList *list; gint plain_text; switch (info) { case TARGET_URI_LIST: plain_text = FALSE; break; case TARGET_TEXT_PLAIN: default: plain_text = TRUE; break; } list = g_list_append(NULL, (gchar *)path); text = uri_text_from_list(list, &len, plain_text); g_list_free(list); gtk_selection_data_set(selection_data, selection_data->target, 8, (guchar *)text, len); g_free(text); } }
static void drag_data_get_cb(GtkWidget *widget, GdkDragContext *ctx, GtkSelectionData *data, guint info, guint time, AccountsWindow *dialog) { if (data->target == gdk_atom_intern("PURPLE_ACCOUNT", FALSE)) { GtkTreeRowReference *ref; GtkTreePath *source_row; GtkTreeIter iter; PurpleAccount *account = NULL; GValue val = {0}; ref = g_object_get_data(G_OBJECT(ctx), "gtk-tree-view-source-row"); source_row = gtk_tree_row_reference_get_path(ref); if (source_row == NULL) return; gtk_tree_model_get_iter(GTK_TREE_MODEL(dialog->model), &iter, source_row); gtk_tree_model_get_value(GTK_TREE_MODEL(dialog->model), &iter, COLUMN_DATA, &val); dialog->drag_iter = iter; account = g_value_get_pointer(&val); gtk_selection_data_set(data, gdk_atom_intern("PURPLE_ACCOUNT", FALSE), 8, (void *)&account, sizeof(account)); gtk_tree_path_free(source_row); } }
static void drag_data_get_callback (GtkWidget *widget, GdkDragContext *context, GtkSelectionData *selection_data, guint info, guint32 time, gpointer callback_data) { NemoLocationBar *self; GFile *location; gchar *uri; g_assert (selection_data != NULL); self = callback_data; location = nemo_location_bar_get_location (self); uri = g_file_get_uri (location); switch (info) { case NEMO_DND_URI_LIST: case NEMO_DND_TEXT_PLAIN: gtk_selection_data_set (selection_data, gtk_selection_data_get_target (selection_data), 8, (guchar *) uri, strlen (uri)); break; default: g_assert_not_reached (); } g_free (uri); g_object_unref (location); }
static void drag_data_get_callback (GtkWidget *widget, GdkDragContext *context, GtkSelectionData *selection_data, guint info, guint32 time, gpointer callback_data) { AthenaLocationBar *self; char *entry_text; g_assert (selection_data != NULL); self = callback_data; entry_text = athena_location_bar_get_location (self); switch (info) { case ATHENA_DND_URI_LIST: case ATHENA_DND_TEXT_PLAIN: gtk_selection_data_set (selection_data, gtk_selection_data_get_target (selection_data), 8, (guchar *) entry_text, strlen (entry_text)); break; default: g_assert_not_reached (); } g_free (entry_text); }
static void drag_data_get_cb (GtkWidget *widget, GdkDragContext *context, GtkSelectionData *selection_data, guint info, guint32 time, EggEditableToolbar *etoolbar) { EggToolbarsModel *model; const char *name; char *data; g_return_if_fail (EGG_IS_EDITABLE_TOOLBAR (etoolbar)); model = egg_editable_toolbar_get_model (etoolbar); name = g_object_get_data (G_OBJECT (widget), EGG_ITEM_NAME); if (name == NULL) { name = g_object_get_data (G_OBJECT (gtk_widget_get_parent (widget)), EGG_ITEM_NAME); g_return_if_fail (name != NULL); } data = egg_toolbars_model_get_data (model, gtk_selection_data_get_target (selection_data), name); if (data != NULL) { gtk_selection_data_set (selection_data, gtk_selection_data_get_target (selection_data), 8, (unsigned char *)data, strlen (data)); g_free (data); } }
static void mimeview_drag_data_get(GtkWidget *widget, GdkDragContext *drag_context, GtkSelectionData *selection_data, guint info, guint time, MimeView *mimeview) { gchar *filename, *uriname; MimeInfo *partinfo; if (!mimeview->opened) return; if (!mimeview->file) return; partinfo = mimeview_get_selected_part(mimeview); if (!partinfo) return; filename = g_basename(get_part_name(partinfo)); if (*filename == '\0') return; filename = g_strconcat(get_mime_tmp_dir(), G_DIR_SEPARATOR_S, filename, NULL); if (procmime_get_part(filename, partinfo) < 0) alertpanel_error (_("Can't save the part of multipart message.")); uriname = g_strconcat("file://", filename, NULL); gtk_selection_data_set(selection_data, selection_data->target, 8, uriname, strlen(uriname)); g_free(uriname); g_free(filename); }
void selection_get (GtkWidget *widget, GtkSelectionData *selection_data, guint info, guint time, gpointer data) { guchar *buffer; gint len; GdkAtom type = GDK_NONE; if (!selection_string) { buffer = NULL; len = 0; } else { buffer = (guchar *)selection_string->str; len = selection_string->len; } switch (info) { case COMPOUND_TEXT: case TEXT: type = seltypes[COMPOUND_TEXT]; case STRING: type = seltypes[STRING]; } gtk_selection_data_set (selection_data, type, 8, buffer, len); }
static gboolean selection_set_compound_text (GtkSelectionData *selection_data, const gchar *str, gint len) { gboolean result = FALSE; #ifdef GDK_WINDOWING_X11 gchar *tmp; guchar *text; GdkAtom encoding; gint format; gint new_length; if (GDK_IS_X11_DISPLAY (selection_data->display)) { tmp = g_strndup (str, len); if (gdk_x11_display_utf8_to_compound_text (selection_data->display, tmp, &encoding, &format, &text, &new_length)) { gtk_selection_data_set (selection_data, encoding, format, text, new_length); gdk_x11_free_compound_text (text); result = TRUE; } g_free (tmp); } #endif return result; }
/* This is called automatically when a drag is initiated * It build a URI list of the selected filenames to set as the drag data */ static void clist_drag_data_get(GtkWidget *widget, GdkDragContext *context, GtkSelectionData *data, guint info_arg, guint time, FileView *view) { FileInfo *info; GList *base, *tmp; GString *uri_list = g_string_sized_new(PATH_MAX); disable_refresh(); base = tmp = get_selection(view); for (; tmp != NULL; tmp = tmp->next) { info = tmp->data; g_string_sprintfa(uri_list, "file:%s/%s\r\n", view->dir, info->filename); } gtk_selection_data_set(data, data->target, 8, uri_list->str, uri_list->len); g_string_free(uri_list, TRUE); g_list_free(base); reenable_refresh(); }
static void on_drag_data_get ( GtkWidget *src_widget, GdkDragContext *drag_context, GtkSelectionData *sel_data, guint info, guint time, FmDndSrc* ds ) { GdkAtom type; /* Don't call the default handler */ g_signal_stop_emission_by_name( src_widget, "drag-data-get" ); drag_context->actions = GDK_ACTION_MOVE | GDK_ACTION_COPY | GDK_ACTION_LINK; type = gdk_atom_intern_static_string(fm_default_dnd_src_targets[info].target); switch( info ) { case FM_DND_SRC_TARGET_FM_LIST: /* just store the pointer in GtkSelection since this is used * within the same app. */ gtk_selection_data_set(sel_data, type, 8, &ds->files, sizeof(gpointer)); break; case FM_DND_SRC_TARGET_URI_LIST: { gchar* uri; GString* uri_list = g_string_sized_new( 8192 ); GList* l; FmFileInfo* file; char* full_path; for( l = fm_list_peek_head_link(ds->files); l; l=l->next ) { file = (FmFileInfo*)l->data; uri = fm_path_to_uri(file->path); g_string_append( uri_list, uri ); g_free( uri ); g_string_append( uri_list, "\r\n" ); } gtk_selection_data_set ( sel_data, type, 8, ( guchar* ) uri_list->str, uri_list->len + 1 ); g_string_free( uri_list, TRUE ); } break; } }
static void set_jstring_data(GtkSelectionData *selection_data, GdkAtom target, jstring data) { const char *text_data = mainEnv->GetStringUTFChars(data, NULL); guint ntext_data = strlen(text_data); //XXX is target == type ?? gtk_selection_data_set(selection_data, target, 8, (const guchar *)text_data, ntext_data); mainEnv->ReleaseStringUTFChars(data, text_data); }