static void rb_tree_dnd_data_free (gpointer data) { RbTreeDndData *priv_data = data; if (priv_data->source_target_list != NULL) { gtk_target_list_unref (priv_data->source_target_list); } if (priv_data->dest_target_list != NULL) { gtk_target_list_unref (priv_data->dest_target_list); } g_free (priv_data); }
NS_IMETHODIMP nsDragService::InvokeDragSession(nsIDOMNode *aDOMNode, nsISupportsArray * aArrayTransferables, nsIScriptableRegion * aRegion, PRUint32 aActionType) { PR_LOG(sDragLm, PR_LOG_DEBUG, ("nsDragService::InvokeDragSession")); nsresult rv = nsBaseDragService::InvokeDragSession(aDOMNode, aArrayTransferables, aRegion, aActionType); NS_ENSURE_SUCCESS(rv, rv); // make sure that we have an array of transferables to use if (!aArrayTransferables) return NS_ERROR_INVALID_ARG; // set our reference to the transferables. this will also addref // the transferables since we're going to hang onto this beyond the // length of this call mSourceDataItems = aArrayTransferables; // get the list of items we offer for drags GtkTargetList *sourceList = 0; sourceList = GetSourceList(); if (sourceList) { // save our action type GdkDragAction action = GDK_ACTION_DEFAULT; if (aActionType & DRAGDROP_ACTION_COPY) action = (GdkDragAction)(action | GDK_ACTION_COPY); if (aActionType & DRAGDROP_ACTION_MOVE) action = (GdkDragAction)(action | GDK_ACTION_MOVE); if (aActionType & DRAGDROP_ACTION_LINK) action = (GdkDragAction)(action | GDK_ACTION_LINK); // Create a fake event for the drag so we can pass the time // (so to speak.) If we don't do this the drag can end as a // result of a button release that is actually _earlier_ than // CurrentTime. So we use the time on the last button press // event, as that will always be older than the button release // that ends any drag. GdkEvent event; memset(&event, 0, sizeof(GdkEvent)); event.type = GDK_BUTTON_PRESS; event.button.window = mHiddenWidget->window; event.button.time = nsWindow::mLastButtonPressTime; // start our drag. GdkDragContext *context = gtk_drag_begin(mHiddenWidget, sourceList, action, 1, &event); // make sure to set our default icon gtk_drag_set_icon_default(context); gtk_target_list_unref(sourceList); } return NS_OK; }
static void take_xconsole_ownership(GtkWidget *widget, gpointer data) { char *name, hostname[255]; GdkAtom atom; GtkClipboard *clipboard; GtkTargetList *target_list; GtkTargetEntry *targets; int n_targets; target_list = gtk_target_list_new(NULL, 0); gtk_target_list_add_text_targets(target_list, 0); targets = gtk_target_table_new_from_list (target_list, &n_targets); gtk_target_list_unref(target_list); memset(hostname, '\0', sizeof(hostname)); gethostname(hostname, sizeof(hostname) - 1); name = g_strdup_printf("MIT_CONSOLE_%s", hostname); atom = gdk_atom_intern(name, FALSE); clipboard = gtk_clipboard_get_for_display(gtk_widget_get_display(widget), atom); g_free(name); gtk_clipboard_set_with_owner(clipboard, targets, n_targets, clipboard_get, (GtkClipboardClearFunc)gtk_main_quit, G_OBJECT(widget)); }
void PasteboardHelperGtk::writeClipboardContents(GtkClipboard* clipboard, gpointer data) { DataObjectGtk* dataObject = DataObjectGtk::forClipboard(clipboard); GtkTargetList* list = targetListForDataObject(dataObject); int numberOfTargets; GtkTargetEntry* table = gtk_target_table_new_from_list(list, &numberOfTargets); if (numberOfTargets > 0 && table) { settingClipboardDataObject = dataObject; settingClipboardData = data; // Protect the web view from being destroyed before one of the clipboard callbacks // is called. Balanced in both getClipboardContentsCallback and // clearClipboardContentsCallback. WebKitWebView* webView = static_cast<WebKitWebView*>(data); g_object_ref(webView); gboolean succeeded = gtk_clipboard_set_with_data(clipboard, table, numberOfTargets, getClipboardContentsCallback, clearClipboardContentsCallback, data); if (!succeeded) g_object_unref(webView); settingClipboardDataObject = 0; settingClipboardData = 0; } else gtk_clipboard_clear(clipboard); if (table) gtk_target_table_free(table, numberOfTargets); gtk_target_list_unref(list); }
static void rb_playlist_source_drop_cb (GtkWidget *widget, GdkDragContext *context, gint x, gint y, GtkSelectionData *data, guint info, guint time, gpointer user_data) { RBPlaylistSource *source = RB_PLAYLIST_SOURCE (user_data); GtkTargetList *tlist; GdkAtom target; tlist = gtk_target_list_new (target_uri, G_N_ELEMENTS (target_uri)); target = gtk_drag_dest_find_target (widget, context, tlist); gtk_target_list_unref (tlist); if (target == GDK_NONE) return; rb_display_page_receive_drag (RB_DISPLAY_PAGE (source), data); gtk_drag_finish (context, TRUE, FALSE, time); }
static void test_pasting_markup(CopyAndPasteFixture* fixture, gconstpointer data) { fixture->info = (TestInfo*)data; currentFixture = fixture; GtkTargetList* targetList = gtk_target_list_new(0, 0); gtk_target_list_add(targetList, gdk_atom_intern("text/html", FALSE), 0, 0); int numberOfTargets = 1; GtkTargetEntry* targetTable = gtk_target_table_new_from_list(targetList, &numberOfTargets); gtk_clipboard_set_with_data(gtk_clipboard_get(GDK_SELECTION_CLIPBOARD), targetTable, numberOfTargets, pasting_test_get_data_callback, pasting_test_clear_data_callback, g_strdup(fixture->info->expectedContent)); gtk_target_list_unref(targetList); gtk_target_table_free(targetTable, numberOfTargets); g_signal_connect(fixture->window, "map-event", G_CALLBACK(map_event_cb), fixture); g_signal_connect(fixture->webView, "window-object-cleared", G_CALLBACK(window_object_cleared_callback), fixture); gtk_widget_show(fixture->window); gtk_widget_show(GTK_WIDGET(fixture->webView)); gtk_window_present(GTK_WINDOW(fixture->window)); g_main_loop_run(fixture->loop); }
void PasteboardHelper::writeClipboardContents(GtkClipboard* clipboard, SmartPasteInclusion includeSmartPaste, GClosure* callback) { DataObjectGtk* dataObject = DataObjectGtk::forClipboard(clipboard); GtkTargetList* list = targetListForDataObject(dataObject, includeSmartPaste); int numberOfTargets; GtkTargetEntry* table = gtk_target_table_new_from_list(list, &numberOfTargets); if (numberOfTargets > 0 && table) { settingClipboardDataObject = dataObject; if (gtk_clipboard_set_with_data(clipboard, table, numberOfTargets, getClipboardContentsCallback, clearClipboardContentsCallback, callback ? g_closure_ref(callback) : nullptr)) gtk_clipboard_set_can_store(clipboard, nullptr, 0); else { // When gtk_clipboard_set_with_data fails the callbacks are ignored, so we need to release the reference we were passing to clearClipboardContentsCallback. if (callback) g_closure_unref(callback); } settingClipboardDataObject = nullptr; } else gtk_clipboard_clear(clipboard); if (table) gtk_target_table_free(table, numberOfTargets); gtk_target_list_unref(list); }
static void _g_paste_clipboard_select_uris (GPasteClipboard *self, GPasteUrisItem *item) { g_return_if_fail (G_PASTE_IS_CLIPBOARD (self)); g_return_if_fail (G_PASTE_IS_URIS_ITEM (item)); GtkClipboard *real = self->priv->real; GtkTargetList *target_list = gtk_target_list_new (NULL, 0); _g_paste_clipboard_set_text (self, g_paste_item_get_value (G_PASTE_ITEM (item))); gtk_target_list_add_text_targets (target_list, 0); gtk_target_list_add_uri_targets (target_list, 0); gtk_target_list_add (target_list, g_paste_clipboard_copy_files_target, 0, 0); gint n_targets; GtkTargetEntry *targets = gtk_target_table_new_from_list (target_list, &n_targets); gtk_clipboard_set_with_owner (real, targets, n_targets, g_paste_clipboard_get_clipboard_data, g_paste_clipboard_clear_clipboard_data, g_object_ref (item)); gtk_clipboard_store (real); gtk_target_table_free (targets, n_targets); gtk_target_list_unref (target_list); }
void dnd_init (GtkWidget * w) { GtkTargetList *tlist; GtkTargetEntry *tgts; gint ntgts; tlist = gtk_target_list_new (NULL, 0); gtk_target_list_add_uri_targets (tlist, 0); gtk_target_list_add_text_targets (tlist, 0); tgts = gtk_target_table_new_from_list (tlist, &ntgts); gtk_drag_dest_set (w, GTK_DEST_DEFAULT_ALL, tgts, ntgts, GDK_ACTION_COPY | GDK_ACTION_MOVE); g_signal_connect (G_OBJECT (w), "drag_data_received", G_CALLBACK (drop_data_cb), NULL); gtk_target_table_free (tgts, ntgts); gtk_target_list_unref (tlist); /* set tooltip */ if (options.dnd_data.tooltip) { GtkWidget *box; box = gtk_dialog_get_content_area (GTK_DIALOG (w)); if (!options.data.no_markup) gtk_widget_set_tooltip_markup (box, options.data.dialog_text); else gtk_widget_set_tooltip_text (box, options.data.dialog_text); } }
/** * gtk_drag_dest_set_target_list: (method) * @widget: a #GtkWidget that’s a drag destination * @target_list: (allow-none): list of droppable targets, or %NULL for none * * Sets the target types that this widget can accept from drag-and-drop. * The widget must first be made into a drag destination with * gtk_drag_dest_set(). */ void gtk_drag_dest_set_target_list (GtkWidget *widget, GtkTargetList *target_list) { GtkDragDestSite *site; g_return_if_fail (GTK_IS_WIDGET (widget)); site = g_object_get_data (G_OBJECT (widget), I_("gtk-drag-dest")); if (!site) { g_warning ("Can't set a target list on a widget until you've called gtk_drag_dest_set() " "to make the widget into a drag destination"); return; } if (target_list) gtk_target_list_ref (target_list); if (site->target_list) gtk_target_list_unref (site->target_list); site->target_list = target_list; }
static gboolean _view_map_motion_notify_callback(GtkWidget *w, GdkEventMotion *e, dt_view_t *self) { dt_map_t *lib = (dt_map_t*)self->data; const int ts = 64; if(lib->start_drag && lib->selected_image > 0) { for(GSList *iter = lib->images; iter != NULL; iter = iter->next) { dt_map_image_t *entry = (dt_map_image_t*)iter->data; OsmGpsMapImage *image = entry->image; if(entry->imgid == lib->selected_image) { osm_gps_map_image_remove(lib->map, image); break; } } lib->start_drag = FALSE; GtkTargetList *targets = gtk_target_list_new(target_list_all, n_targets_all); dt_mipmap_buffer_t buf; dt_mipmap_size_t mip = dt_mipmap_cache_get_matching_size(darktable.mipmap_cache, ts, ts); dt_mipmap_cache_read_get(darktable.mipmap_cache, &buf, lib->selected_image, mip, DT_MIPMAP_BLOCKING); if(buf.buf) { uint8_t *scratchmem = dt_mipmap_cache_alloc_scratchmem(darktable.mipmap_cache); uint8_t *buf_decompressed = dt_mipmap_cache_decompress(&buf, scratchmem); uint8_t *rgbbuf = g_malloc((buf.width+2)*(buf.height+2)*3); memset(rgbbuf, 64, (buf.width+2)*(buf.height+2)*3); for(int i=1; i<=buf.height; i++) for(int j=1; j<=buf.width; j++) for(int k=0; k<3; k++) rgbbuf[(i*(buf.width+2)+j)*3+k] = buf_decompressed[((i-1)*buf.width+j-1)*4+2-k]; int w=ts, h=ts; if(buf.width < buf.height) w = (buf.width*ts)/buf.height; // portrait else h = (buf.height*ts)/buf.width; // landscape GdkPixbuf *source = gdk_pixbuf_new_from_data(rgbbuf, GDK_COLORSPACE_RGB, FALSE, 8, (buf.width+2), (buf.height+2), (buf.width+2)*3, NULL, NULL); GdkPixbuf *scaled = gdk_pixbuf_scale_simple(source, w, h, GDK_INTERP_HYPER); GdkDragContext * context = gtk_drag_begin(GTK_WIDGET(lib->map), targets, GDK_ACTION_COPY, 1, (GdkEvent*)e); gtk_drag_set_icon_pixbuf(context, scaled, 0, 0); if(source) g_object_unref(source); if(scaled) g_object_unref(scaled); g_free(rgbbuf); } dt_mipmap_cache_read_release(darktable.mipmap_cache, &buf); gtk_target_list_unref(targets); return TRUE; } return FALSE; }
/* * main entry point for cut and copy operations * cut : cut = TRUE; * copy: cut = FALSE; * * NOTE: every we cut or copy, we need to override * previous data in clipboard.so we acquire * clipboard every time we cut or copy. * _clipboard_owner_change_cb is used to clear * clipboard * 1. this is the only way we can set clipboard_info. * 2. this is the only way we can set clipboard_info_prev. * */ void init_fileops_clipboard (GFile* file_list[], guint num, gboolean cut) { g_debug ("init_fileops_clipboard:begin"); //set prev clipboard_info __clear_clipboard_info (&clipboard_info_prev); __copy_clipboard_info (&clipboard_info, &clipboard_info_prev); int j=0; for (j = 0; j < clipboard_info_prev.num; j++) { g_debug ("init_fileops prev: file_list[%d] = %s", j, g_file_get_uri (clipboard_info_prev.file_list[j])); } //we're the clipboard owner, cleanup clipboard_info __clear_clipboard_info (&clipboard_info); clipboard_info.file_list = (GFile**)g_malloc (num * sizeof (GFile*)); int i; for (i = 0; i < num; i++) { clipboard_info.file_list[i] = g_object_ref (file_list[i]); g_debug ("init_fileops %s: file_list[%d] = %s", cut? "cut": "paste", i, g_file_get_uri (file_list[i])); } clipboard_info.num = num; clipboard_info.cut = cut; GtkTargetList* target_list; GtkTargetEntry* targets; gint n_targets; if (copied_files_atom == GDK_NONE) copied_files_atom = gdk_atom_intern ("x-special/gnome-copied-files", FALSE); //TODO: request clipboard data before take ownership // so we can interoperate with nautilus. if (fileops_clipboard == NULL) { fileops_clipboard = gtk_clipboard_get (GDK_SELECTION_CLIPBOARD); g_signal_connect (fileops_clipboard, "owner-change", G_CALLBACK (_clipboard_owner_change_cb), NULL); } target_list = gtk_target_list_new (NULL, 0); gtk_target_list_add (target_list, copied_files_atom, 0, 0); gtk_target_list_add_uri_targets (target_list, 0); gtk_target_list_add_text_targets (target_list, 0); targets = gtk_target_table_new_from_list (target_list, &n_targets); gtk_clipboard_set_with_data (fileops_clipboard, targets, n_targets, _get_clipboard_callback, _clear_clipboard_callback, NULL); gtk_target_list_unref (target_list); gtk_target_table_free (targets, n_targets); g_debug ("init_fileops_clipboard:end"); }
void nautilus_drag_finalize (NautilusDragInfo *drag_info) { gtk_target_list_unref (drag_info->target_list); nautilus_drag_destroy_selection_list (drag_info->selection_list); g_free (drag_info); }
void athena_drag_finalize (AthenaDragInfo *drag_info) { gtk_target_list_unref (drag_info->target_list); athena_drag_destroy_selection_list (drag_info->selection_list); g_free (drag_info); }
void nautilus_drag_slot_proxy_init (GtkWidget *widget, NautilusFile *target_file, NautilusWindowSlot *target_slot) { NautilusDragSlotProxyInfo *drag_info; const GtkTargetEntry targets[] = { { NAUTILUS_ICON_DND_GNOME_ICON_LIST_TYPE, 0, NAUTILUS_ICON_DND_GNOME_ICON_LIST }, { NAUTILUS_ICON_DND_NETSCAPE_URL_TYPE, 0, NAUTILUS_ICON_DND_NETSCAPE_URL }, { NAUTILUS_ICON_DND_XDNDDIRECTSAVE_TYPE, 0, NAUTILUS_ICON_DND_XDNDDIRECTSAVE }, /* XDS Protocol Type */ { NAUTILUS_ICON_DND_RAW_TYPE, 0, NAUTILUS_ICON_DND_RAW } }; GtkTargetList *target_list; g_assert (GTK_IS_WIDGET (widget)); drag_info = g_slice_new0 (NautilusDragSlotProxyInfo); g_object_set_data_full (G_OBJECT (widget), "drag-slot-proxy-data", drag_info, drag_info_free); drag_info->is_notebook = (g_object_get_data (G_OBJECT (widget), "nautilus-notebook-tab") != NULL); if (target_file != NULL) drag_info->target_file = nautilus_file_ref (target_file); if (target_slot != NULL) drag_info->target_slot = g_object_ref (target_slot); drag_info->widget = widget; gtk_drag_dest_set (widget, 0, NULL, 0, GDK_ACTION_MOVE | GDK_ACTION_COPY | GDK_ACTION_LINK | GDK_ACTION_ASK); target_list = gtk_target_list_new (targets, G_N_ELEMENTS (targets)); gtk_target_list_add_uri_targets (target_list, NAUTILUS_ICON_DND_URI_LIST); gtk_target_list_add_text_targets (target_list, NAUTILUS_ICON_DND_TEXT); gtk_drag_dest_set_target_list (widget, target_list); gtk_target_list_unref (target_list); g_signal_connect (widget, "drag-motion", G_CALLBACK (slot_proxy_drag_motion), drag_info); g_signal_connect (widget, "drag-drop", G_CALLBACK (slot_proxy_drag_drop), drag_info); g_signal_connect (widget, "drag-data-received", G_CALLBACK (slot_proxy_drag_data_received), drag_info); g_signal_connect (widget, "drag-leave", G_CALLBACK (slot_proxy_drag_leave), drag_info); }
void ToIndex(GtkTargetList *target_list, Index<String>& ndx) { gint n; GtkTargetEntry *t = gtk_target_table_new_from_list(target_list, &n); for(int i = 0; i < n; i++) ndx.Add(t[i].target); gtk_target_table_free(t, n); gtk_target_list_unref(target_list); }
void nemo_drag_slot_proxy_init (GtkWidget *widget, NemoFile *target_file, NemoWindowSlot *target_slot) { NemoDragSlotProxyInfo *drag_info; const GtkTargetEntry targets[] = { { NEMO_ICON_DND_GNOME_ICON_LIST_TYPE, 0, NEMO_ICON_DND_GNOME_ICON_LIST }, { NEMO_ICON_DND_NETSCAPE_URL_TYPE, 0, NEMO_ICON_DND_NETSCAPE_URL } }; GtkTargetList *target_list; g_assert (GTK_IS_WIDGET (widget)); drag_info = g_slice_new0 (NemoDragSlotProxyInfo); g_object_set_data_full (G_OBJECT (widget), "drag-slot-proxy-data", drag_info, drag_info_free); drag_info->desktop_dnd_source_fs = NULL; drag_info->desktop_dnd_can_delete_source = FALSE; if (target_file != NULL) drag_info->target_file = g_object_ref (target_file); if (target_slot != NULL) drag_info->target_slot = g_object_ref (target_slot); gtk_drag_dest_set (widget, 0, NULL, 0, GDK_ACTION_MOVE | GDK_ACTION_COPY | GDK_ACTION_LINK | GDK_ACTION_ASK); target_list = gtk_target_list_new (targets, G_N_ELEMENTS (targets)); gtk_target_list_add_uri_targets (target_list, NEMO_ICON_DND_URI_LIST); gtk_drag_dest_set_target_list (widget, target_list); gtk_target_list_unref (target_list); g_signal_connect (widget, "drag-motion", G_CALLBACK (slot_proxy_drag_motion), drag_info); g_signal_connect (widget, "drag-drop", G_CALLBACK (slot_proxy_drag_drop), drag_info); g_signal_connect (widget, "drag-data-received", G_CALLBACK (slot_proxy_drag_data_received), drag_info); g_signal_connect (widget, "drag-leave", G_CALLBACK (slot_proxy_drag_leave), drag_info); }
static void ephy_node_view_finalize (GObject *object) { EphyNodeView *view = EPHY_NODE_VIEW (object); g_object_unref (G_OBJECT (view->priv->sortmodel)); g_object_unref (G_OBJECT (view->priv->filtermodel)); g_object_unref (G_OBJECT (view->priv->nodemodel)); if (view->priv->source_target_list) { gtk_target_list_unref (view->priv->source_target_list); } if (view->priv->drag_targets) { gtk_target_list_unref (view->priv->drag_targets); } G_OBJECT_CLASS (parent_class)->finalize (object); }
static gboolean egg_tree_multi_drag_motion_event (GtkWidget *widget, GdkEventMotion *event, gpointer data) { EggTreeMultiDndData *priv_data; priv_data = g_object_get_data (G_OBJECT (widget), EGG_TREE_MULTI_DND_STRING); if (gtk_drag_check_threshold (widget, priv_data->x, priv_data->y, event->x, event->y)) { GList *path_list = NULL; GtkTreeSelection *selection; GtkTreeModel *model; GdkDragContext *context; stop_drag_check (widget); selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (widget)); gtk_tree_selection_selected_foreach (selection, selection_foreach, &path_list); if (path_list == NULL) return FALSE; path_list = g_list_reverse (path_list); model = gtk_tree_view_get_model (GTK_TREE_VIEW (widget)); if (egg_tree_multi_drag_source_row_draggable (EGG_TREE_MULTI_DRAG_SOURCE (model), path_list)) { GtkTargetList *target_list = gtk_target_list_new (target_table, G_N_ELEMENTS (target_table)); context = gtk_drag_begin (widget, target_list, GDK_ACTION_COPY, priv_data->pressed_button, (GdkEvent*)event); set_context_data (context, path_list); gtk_drag_set_icon_default (context); gtk_target_list_unref (target_list); } else { path_list_free (path_list); } } return TRUE; }
static void v_free_target_list( EggTreeMultiDragSource *drag_source, GtkTargetList *list ) { EggTreeMultiDragSourceIface *iface = EGG_TREE_MULTI_DRAG_SOURCE_GET_IFACE( drag_source ); if( iface->free_target_list ){ iface->free_target_list( drag_source, list ); } else { gtk_target_list_unref( list ); } }
static void gtk_drag_dest_site_destroy (gpointer data) { GtkDragDestSite *site = data; if (site->proxy_window) g_object_unref (site->proxy_window); if (site->target_list) gtk_target_list_unref (site->target_list); g_slice_free (GtkDragDestSite, site); }
static void gevasevh_group_selector_destroy(GtkObject * object) { GtkgEvasEvHGroupSelector *ev; g_return_if_fail(object != NULL); g_return_if_fail(GTK_IS_GEVASEVH_GROUP_SELECTOR(object)); ev = GTK_GEVASEVH_GROUP_SELECTOR(object); gtk_target_list_unref(ev->drag_targets); /* Chain up */ if (GTK_OBJECT_CLASS(parent_class)->destroy) (*GTK_OBJECT_CLASS(parent_class)->destroy) (object); }
void nautilus_drag_slot_proxy_init (GtkWidget *widget, GFile *target_location, NautilusWindowSlot *target_slot) { NautilusDragSlotProxyInfo *drag_info; const GtkTargetEntry targets[] = { { NAUTILUS_ICON_DND_GNOME_ICON_LIST_TYPE, 0, NAUTILUS_ICON_DND_GNOME_ICON_LIST }, { NAUTILUS_ICON_DND_NETSCAPE_URL_TYPE, 0, NAUTILUS_ICON_DND_NETSCAPE_URL } }; GtkTargetList *target_list; g_assert (GTK_IS_WIDGET (widget)); drag_info = g_slice_new0 (NautilusDragSlotProxyInfo); g_object_set_data_full (G_OBJECT (widget), "drag-slot-proxy-data", drag_info, drag_info_free); if (target_location != NULL) drag_info->target_location = g_object_ref (target_location); if (target_slot != NULL) drag_info->target_slot = g_object_ref (target_slot); gtk_drag_dest_set (widget, 0, NULL, 0, GDK_ACTION_MOVE | GDK_ACTION_COPY | GDK_ACTION_LINK | GDK_ACTION_ASK); target_list = gtk_target_list_new (targets, G_N_ELEMENTS (targets)); gtk_target_list_add_uri_targets (target_list, NAUTILUS_ICON_DND_URI_LIST); gtk_drag_dest_set_target_list (widget, target_list); gtk_target_list_unref (target_list); g_signal_connect (widget, "drag-motion", G_CALLBACK (slot_proxy_drag_motion), drag_info); g_signal_connect (widget, "drag-drop", G_CALLBACK (slot_proxy_drag_drop), drag_info); g_signal_connect (widget, "drag-data-received", G_CALLBACK (slot_proxy_drag_data_received), drag_info); g_signal_connect (widget, "drag-leave", G_CALLBACK (slot_proxy_drag_leave), drag_info); }
/** * gtk_drag_dest_add_uri_targets: (method) * @widget: a #GtkWidget that’s a drag destination * * Add the URI targets supported by #GtkSelectionData to * the target list of the drag destination. The targets * are added with @info = 0. If you need another value, * use gtk_target_list_add_uri_targets() and * gtk_drag_dest_set_target_list(). * * Since: 2.6 */ void gtk_drag_dest_add_uri_targets (GtkWidget *widget) { GtkTargetList *target_list; target_list = gtk_drag_dest_get_target_list (widget); if (target_list) gtk_target_list_ref (target_list); else target_list = gtk_target_list_new (NULL, 0); gtk_target_list_add_uri_targets (target_list, 0); gtk_drag_dest_set_target_list (widget, target_list); gtk_target_list_unref (target_list); }
static void update_dest_target_list (GtkWidget *ebox) { GtkTargetList *target_list; target_list = gtk_target_list_new (NULL, 0); gtk_target_list_add_image_targets (target_list, TARGET_IMAGE, FALSE); gtk_target_list_add_text_targets (target_list, TARGET_TEXT); gtk_drag_dest_set_target_list (ebox, target_list); gtk_target_list_unref (target_list); }
int Ctrl::DoDragAndDrop(const char *fmts, const Image& sample, dword actions, const VectorMap<String, ClipData>& data) { LLOG("------------------------------"); LLOG("DoDragAndDrop " << fmts); TopWindow *w = GetTopWindow(); if(!w || !w->top) return DND_NONE; int gdk_actions = 0; if(actions & DND_MOVE) gdk_actions |= GDK_ACTION_MOVE; if(actions & DND_COPY) gdk_actions |= GDK_ACTION_COPY; GtkTargetList *list = CreateTargetList(data); dnd_fmts.Clear(); for(int i = 0; i < data.GetCount(); i++) AddFmt(list, data.GetKey(i), i); Vector<String> f = Split(fmts, ';'); for(int i = 0; i < f.GetCount(); i++) { AddFmt(list, f[i], data.GetCount() + i); dnd_fmts.Add(f[i]); } dnd_source_data = &data; dnd_result = DND_NONE; dnd_source = this; if(IsNull(sample)) dnd_icon = Null; else { Size sz = sample.GetSize(); if(sz.cx > 128) sz.cx = 128; if(sz.cy > 128) sz.cy = 128; sz += 2; ImageDraw iw(sz); iw.DrawRect(sz, White()); DrawFrame(iw, sz, Black()); iw.DrawImage(1, 1, sz.cx, sz.cy, sample); ImageBuffer b(128, 128); dnd_icon = iw; } gtk_drag_begin(w->top->window, list, GdkDragAction(gdk_actions), GetMouseLeft() ? 1 : GetMouseMiddle() ? 2 : 3, CurrentEvent.event); while(dnd_source && GetTopCtrls().GetCount()) ProcessEvents(); dnd_source_data = NULL; gtk_target_list_unref (list); LLOG("-------- DoDragAndDrop"); return dnd_result; }
static void update_source_target_list (GtkWidget *ebox, GtkWidget *image) { GtkTargetList *target_list; target_list = gtk_target_list_new (NULL, 0); gtk_target_list_add_image_targets (target_list, TARGET_IMAGE, FALSE); if (gtk_image_get_storage_type (GTK_IMAGE (image)) == GTK_IMAGE_ICON_NAME) gtk_target_list_add_text_targets (target_list, TARGET_TEXT); gtk_drag_source_set_target_list (ebox, target_list); gtk_target_list_unref (target_list); }
GtkTargetList * e_selectable_get_paste_target_list (ESelectable *selectable) { GtkTargetList *target_list; g_return_val_if_fail (E_IS_SELECTABLE (selectable), NULL); g_object_get (selectable, "paste-target-list", &target_list, NULL); /* We want to return a borrowed reference to the target * list, so undo the reference that g_object_get() added. */ gtk_target_list_unref (target_list); return target_list; }
void ptk_clipboard_cut_or_copy_files( const char* working_dir, GList* files, gboolean copy ) { GtkClipboard * clip = gtk_clipboard_get( GDK_SELECTION_CLIPBOARD ); GtkTargetList* target_list = gtk_target_list_new( NULL, 0 ); GList* target; gint i, n_targets; GtkTargetEntry* targets; GtkTargetPair* pair; GList *l; VFSFileInfo* file; char* file_path; GList* file_list = NULL; gtk_target_list_add_text_targets( target_list, 0 ); n_targets = g_list_length( target_list->list ) + 2; targets = g_new0( GtkTargetEntry, n_targets ); target = target_list->list; for ( i = 0; target; ++i, target = g_list_next( target ) ) { pair = ( GtkTargetPair* ) target->data; targets[ i ].target = gdk_atom_name ( pair->target ); } targets[ i ].target = "x-special/gnome-copied-files"; targets[ i + 1 ].target = "text/uri-list"; gtk_target_list_unref ( target_list ); for ( l = g_list_last( files ); l; l = l->prev ) //sfm was reverse order { file = ( VFSFileInfo* ) l->data; file_path = g_build_filename( working_dir, vfs_file_info_get_name( file ), NULL ); file_list = g_list_prepend( file_list, file_path ); } gtk_clipboard_set_with_data ( clip, targets, n_targets, clipboard_get_data, clipboard_clean_data, NULL ); g_free( targets ); clipboard_file_list = file_list; clipboard_action = copy ? GDK_ACTION_COPY : GDK_ACTION_MOVE; }
static gboolean on_drag_drop (GtkWidget *widget, GdkDragContext *context, gint x, gint y, guint time, gpointer data) { GtkTargetList *target_list = gtk_target_list_new (targets, n_targets); GdkAtom atom = gtk_drag_dest_find_target (widget, context, target_list); if (atom == GDK_NONE) return FALSE; gtk_drag_get_data (widget, context, atom, time); gtk_target_list_unref (target_list); return TRUE; }