void Ctrl::DndTargets(GdkDragContext *context) { static Index<String> text_targets; static Index<String> image_targets; ONCELOCK { GtkTargetList *target_list = gtk_target_list_new (NULL, 0); gtk_target_list_add_text_targets (target_list, 0); ToIndex(target_list, text_targets); GtkTargetList *target_list2 = gtk_target_list_new (NULL, 0); gtk_target_list_add_image_targets (target_list2, 0, TRUE); ToIndex(target_list2, image_targets); } dnd_targets.Clear(); dnd_text_target.Clear(); for(GList *list = gdk_drag_context_list_targets(context); list; list = g_list_next (list)) { String g = gdk_atom_name((GdkAtom)list->data); if(text_targets.Find(g) >= 0) { dnd_targets.Add("text"); if(dnd_text_target.IsEmpty()) dnd_text_target = g; } else if(image_targets.Find(g) >= 0) { dnd_targets.Add("image"); if(dnd_image_target.IsEmpty()) dnd_image_target = g; } else dnd_targets.Add(g); } }
/* FIXME bugzilla.gnome.org 47445: Needs to become a shared function */ static void get_data_on_first_target_we_support (GtkWidget *widget, GdkDragContext *context, guint32 time, int x, int y) { GtkTargetList *list; GdkAtom target; if (drop_types_list == NULL) { drop_types_list = gtk_target_list_new (drop_types, G_N_ELEMENTS (drop_types) - 1); gtk_target_list_add_text_targets (drop_types_list, NEMO_ICON_DND_TEXT); } if (drop_types_list_root == NULL) { drop_types_list_root = gtk_target_list_new (drop_types, G_N_ELEMENTS (drop_types)); gtk_target_list_add_text_targets (drop_types_list_root, NEMO_ICON_DND_TEXT); } if (nemo_icon_container_get_is_desktop (NEMO_ICON_CONTAINER (widget))) { list = drop_types_list_root; } else { list = drop_types_list; } target = gtk_drag_dest_find_target (widget, context, list); if (target != GDK_NONE) { guint info; NemoDragInfo *drag_info; gboolean found; drag_info = &(NEMO_ICON_CONTAINER (widget)->details->dnd_info->drag_info); found = gtk_target_list_find (list, target, &info); g_assert (found); /* Don't get_data for destructive ops */ if ((info == NEMO_ICON_DND_ROOTWINDOW_DROP || info == NEMO_ICON_DND_XDNDDIRECTSAVE) && !drag_info->drop_occured) { /* We can't call get_data here, because that would make the source execute the rootwin action or the direct save */ drag_info->got_drop_data_type = TRUE; drag_info->data_type = info; } else { if (info == NEMO_ICON_DND_XDNDDIRECTSAVE) { set_direct_save_uri (widget, context, drag_info, x, y); } gtk_drag_get_data (GTK_WIDGET (widget), context, target, time); } } }
/** * rb_tree_dnd_add_drag_source_support: * @tree_view: a #GtkTreeView that wants to be a drag source * @start_button_mask: a mask describing modifier keys to handle when dragging * @targets: an array of #GtkTargetEntry structures describing drag data types * @n_targets: the number of elements in @targets * @actions: a mask describing drag actions that are allowed from this source * * Adds event handlers to perform multi-row drag and drop operations from the * specified #GtkTreeView widget. The model backing the #GtkTreeView must * implement the #RbTreeDragSource interface. This should be called immediately * after the tree view is created. */ void rb_tree_dnd_add_drag_source_support (GtkTreeView *tree_view, GdkModifierType start_button_mask, const GtkTargetEntry *targets, gint n_targets, GdkDragAction actions) { RbTreeDndData *priv_data = NULL; g_return_if_fail (GTK_IS_TREE_VIEW (tree_view)); priv_data = init_rb_tree_dnd_data (GTK_WIDGET(tree_view)); if (!priv_data->button_press_event_handler) { priv_data->source_target_list = gtk_target_list_new (targets, n_targets); priv_data->source_actions = actions; priv_data->start_button_mask = start_button_mask; priv_data->button_press_event_handler = g_signal_connect (G_OBJECT (tree_view), "button_press_event", G_CALLBACK (rb_tree_dnd_button_press_event_cb), NULL); priv_data->drag_data_get_handler = g_signal_connect (G_OBJECT (tree_view), "drag_data_get", G_CALLBACK (rb_tree_dnd_drag_data_get_cb), NULL); priv_data->drag_data_delete_handler = g_signal_connect (G_OBJECT (tree_view), "drag_data_delete", G_CALLBACK (rb_tree_dnd_drag_data_delete_cb), NULL); } }
static GtkTargetList * get_target_list (void) { static GtkTargetEntry drop_types [] = { { "text/uri-list", 0, TARGET_URL }, { "x-url/http", 0, TARGET_NETSCAPE_URL }, { "x-url/ftp", 0, TARGET_NETSCAPE_URL }, { "_NETSCAPE_URL", 0, TARGET_NETSCAPE_URL }, { "application/x-panel-directory", 0, TARGET_DIRECTORY }, { "application/x-mate-panel-applet-iid", 0, TARGET_APPLET }, { "application/x-mate-panel-applet-internal", 0, TARGET_APPLET_INTERNAL }, { "application/x-panel-icon-internal", 0, TARGET_ICON_INTERNAL }, { "application/x-color", 0, TARGET_COLOR }, { "property/bgimage", 0, TARGET_BGIMAGE }, { "x-special/mate-reset-background", 0, TARGET_BACKGROUND_RESET }, }; static GtkTargetList *target_list = NULL; if (!target_list) { gint length = sizeof (drop_types) / sizeof (drop_types [0]); target_list = gtk_target_list_new (drop_types, length); } return target_list; }
static GtkTargetList * gnm_soi_get_target_list (SheetObject const *so) { SheetObjectImage *soi = SHEET_OBJECT_IMAGE (so); GtkTargetList *tl = gtk_target_list_new (NULL, 0); char *mime_str = go_image_format_to_mime (soi->type); GSList *mimes, *ptr; GdkPixbuf *pixbuf; mimes = go_strsplit_to_slist (mime_str, ','); for (ptr = mimes; ptr != NULL; ptr = ptr->next) { const char *mime = ptr->data; if (mime != NULL && *mime != '\0') gtk_target_list_add (tl, gdk_atom_intern (mime, FALSE), 0, 0); } g_free (mime_str); go_slist_free_custom (mimes, g_free); /* No need to eliminate duplicates. */ if ((pixbuf = soi_get_pixbuf (soi, 1.0)) != NULL) { gtk_target_list_add_image_targets (tl, 0, TRUE); g_object_unref (pixbuf); } return tl; }
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; }
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); }
/** * gtk_drag_dest_set: (method) * @widget: a #GtkWidget * @flags: which types of default drag behavior to use * @targets: (allow-none) (array length=n_targets): a pointer to an array of * #GtkTargetEntrys indicating the drop types that this @widget will * accept, or %NULL. Later you can access the list with * gtk_drag_dest_get_target_list() and gtk_drag_dest_find_target(). * @n_targets: the number of entries in @targets * @actions: a bitmask of possible actions for a drop onto this @widget. * * Sets a widget as a potential drop destination, and adds default behaviors. * * The default behaviors listed in @flags have an effect similar * to installing default handlers for the widget’s drag-and-drop signals * (#GtkWidget::drag-motion, #GtkWidget::drag-drop, ...). They all exist * for convenience. When passing #GTK_DEST_DEFAULT_ALL for instance it is * sufficient to connect to the widget’s #GtkWidget::drag-data-received * signal to get primitive, but consistent drag-and-drop support. * * Things become more complicated when you try to preview the dragged data, * as described in the documentation for #GtkWidget::drag-motion. The default * behaviors described by @flags make some assumptions, that can conflict * with your own signal handlers. For instance #GTK_DEST_DEFAULT_DROP causes * invokations of gdk_drag_status() in the context of #GtkWidget::drag-motion, * and invokations of gtk_drag_finish() in #GtkWidget::drag-data-received. * Especially the later is dramatic, when your own #GtkWidget::drag-motion * handler calls gtk_drag_get_data() to inspect the dragged data. * * There’s no way to set a default action here, you can use the * #GtkWidget::drag-motion callback for that. Here’s an example which selects * the action to use depending on whether the control key is pressed or not: * |[<!-- language="C" --> * static void * drag_motion (GtkWidget *widget, * GdkDragContext *context, * gint x, * gint y, * guint time) * { * GdkModifierType mask; * * gdk_window_get_pointer (gtk_widget_get_window (widget), * NULL, NULL, &mask); * if (mask & GDK_CONTROL_MASK) * gdk_drag_status (context, GDK_ACTION_COPY, time); * else * gdk_drag_status (context, GDK_ACTION_MOVE, time); * } * ]| */ void gtk_drag_dest_set (GtkWidget *widget, GtkDestDefaults flags, const GtkTargetEntry *targets, gint n_targets, GdkDragAction actions) { GtkDragDestSite *site; g_return_if_fail (GTK_IS_WIDGET (widget)); site = g_slice_new0 (GtkDragDestSite); site->flags = flags; site->have_drag = FALSE; if (targets) site->target_list = gtk_target_list_new (targets, n_targets); else site->target_list = NULL; site->actions = actions; site->do_proxy = FALSE; site->proxy_window = NULL; site->track_motion = FALSE; gtk_drag_dest_set_internal (widget, site); }
static void etfci_start_drag (ETableFieldChooserItem *etfci, GdkEvent *event, gdouble x, gdouble y) { GtkWidget *widget = GTK_WIDGET (GNOME_CANVAS_ITEM (etfci)->canvas); GtkTargetList *list; GdkDragContext *context; ETableCol *ecol; cairo_surface_t *cs; cairo_t *cr; gint drag_col; gint button_height; GtkTargetEntry etfci_drag_types[] = { { (gchar *) TARGET_ETABLE_COL_TYPE, 0, TARGET_ETABLE_COL_HEADER }, }; if (etfci->combined_header == NULL) return; drag_col = etfci_find_button (etfci, y); if (drag_col < 0 || drag_col > e_table_header_count (etfci->combined_header)) return; ecol = e_table_header_get_column (etfci->combined_header, drag_col); if (ecol->spec->disabled) return; etfci->drag_col = ecol->spec->model_col; etfci_drag_types[0].target = g_strdup_printf ( "%s-%s", etfci_drag_types[0].target, etfci->dnd_code); d (g_print ("etfci - %s\n", etfci_drag_types[0].target)); list = gtk_target_list_new (etfci_drag_types, G_N_ELEMENTS (etfci_drag_types)); context = gtk_drag_begin (widget, list, GDK_ACTION_MOVE, 1, event); g_free ((gpointer) etfci_drag_types[0].target); button_height = e_table_header_compute_height (ecol, widget); cs = cairo_image_surface_create ( CAIRO_FORMAT_ARGB32, etfci->width, button_height); cr = cairo_create (cs); e_table_header_draw_button ( cr, ecol, widget, 0, 0, etfci->width, button_height, etfci->width, button_height, E_TABLE_COL_ARROW_NONE); gtk_drag_set_icon_surface (context, cs); cairo_surface_destroy (cs); cairo_destroy (cr); etfci->maybe_drag = FALSE; }
GtkTargetList* PasteboardHelper::targetListForDataObject(DataObjectGtk* dataObject, SmartPasteInclusion shouldInludeSmartPaste) { GtkTargetList* list = gtk_target_list_new(nullptr, 0); if (dataObject->hasText()) gtk_target_list_add_text_targets(list, TargetTypeText); if (dataObject->hasMarkup()) gtk_target_list_add(list, markupAtom, 0, TargetTypeMarkup); if (dataObject->hasURIList()) { gtk_target_list_add_uri_targets(list, TargetTypeURIList); gtk_target_list_add(list, netscapeURLAtom, 0, TargetTypeNetscapeURL); } if (dataObject->hasImage()) gtk_target_list_add_image_targets(list, TargetTypeImage, TRUE); if (dataObject->hasUnknownTypeData()) gtk_target_list_add(list, unknownAtom, 0, TargetTypeUnknown); if (shouldInludeSmartPaste == IncludeSmartPaste) gtk_target_list_add(list, smartPasteAtom, 0, TargetTypeSmartPaste); return 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); }
/** * ephy_node_view_enable_drag_dest: * @view: the #EphyNodeView * @types: types allowed as #GtkTargetEntry * @n_types: count of @types * * Set the types of drag destination allowed by @view. * **/ void ephy_node_view_enable_drag_dest (EphyNodeView *view, const GtkTargetEntry *types, int n_types) { GtkWidget *treeview; g_return_if_fail (view != NULL); treeview = GTK_WIDGET (view); gtk_drag_dest_set (GTK_WIDGET (treeview), 0, types, n_types, GDK_ACTION_COPY); view->priv->drag_targets = gtk_target_list_new (types, n_types); g_signal_connect (treeview, "drag_data_received", G_CALLBACK (drag_data_received_cb), view); g_signal_connect (treeview, "drag_drop", G_CALLBACK (drag_drop_cb), view); g_signal_connect (treeview, "drag_motion", G_CALLBACK (drag_motion_cb), view); g_signal_connect (treeview, "drag_leave", G_CALLBACK (drag_leave_cb), view); }
/* * 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"); }
/** * ephy_node_view_enable_drag_source: * @view: an #EphyNodeView * @types: a #GtkTargetEntry for the @view * @n_types: length of @types * @base_drag_column_id: id of the column for ephy_tree_model_sort_set_base_drag_column_id * @extra_drag_column_id: id of the column for ephy_tree_model_sort_set_extra_drag_column_id * * Sets @view as a drag source. **/ void ephy_node_view_enable_drag_source (EphyNodeView *view, const GtkTargetEntry *types, int n_types, int base_drag_column_id, int extra_drag_column_id) { g_return_if_fail (view != NULL); view->priv->source_target_list = gtk_target_list_new (types, n_types); ephy_tree_model_sort_set_base_drag_column_id (EPHY_TREE_MODEL_SORT (view->priv->sortmodel), base_drag_column_id); ephy_tree_model_sort_set_extra_drag_column_id (EPHY_TREE_MODEL_SORT (view->priv->sortmodel), extra_drag_column_id); g_signal_connect_object (G_OBJECT (view), "button_release_event", G_CALLBACK (button_release_cb), view, 0); g_signal_connect_object (G_OBJECT (view), "motion_notify_event", G_CALLBACK (motion_notify_cb), view, 0); g_signal_connect_object (G_OBJECT (view), "drag_data_get", G_CALLBACK (drag_data_get_cb), view, 0); }
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); }
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)); }
static gint e_minicard_view_drag_begin (EAddressbookReflowAdapter *adapter, GdkEvent *event, EMinicardView *view) { GdkDragContext *context; GtkTargetList *target_list; GdkDragAction actions = GDK_ACTION_MOVE | GDK_ACTION_COPY; clear_drag_data (view); view->drag_list = e_minicard_view_get_card_list (view); target_list = gtk_target_list_new (drag_types, G_N_ELEMENTS (drag_types)); context = gtk_drag_begin ( GTK_WIDGET (GNOME_CANVAS_ITEM (view)->canvas), target_list, actions, 1/*XXX */, event); if (!view->canvas_drag_data_get_id) view->canvas_drag_data_get_id = g_signal_connect ( GNOME_CANVAS_ITEM (view)->canvas, "drag_data_get", G_CALLBACK (e_minicard_view_drag_data_get), view); gtk_drag_set_icon_default (context); return TRUE; }
static gboolean hand_display_motion (GtkWidget *hand, GdkEventMotion *event) { HandDisplay *handdisp = HAND_DISPLAY(hand); int card = which_card(handdisp, event->x, event->y); if (handdisp->drag && handdisp->cur_click >= 0 && handdisp->cur_click < 52 && gtk_drag_check_threshold (hand, handdisp->drag_x, handdisp->drag_y, event->x, event->y)) { if (! target_list) target_list = gtk_target_list_new (target_entry, 1); handdisp->cur_drag = handdisp->cur_click; gtk_drag_begin (hand, target_list, GDK_ACTION_COPY, 1, (GdkEvent *) event); } if (handdisp->cur_focus != card) { if (handdisp->cur_focus != -1) { redraw_card (hand, handdisp->cur_focus); g_signal_emit_by_name (handdisp, "card-leave", handdisp->cur_focus); } handdisp->cur_focus = card; if (card != -1) { redraw_card (hand, card); g_signal_emit_by_name (handdisp, "card-enter", card); } } gdk_window_get_pointer(gtk_widget_get_window (hand), NULL, NULL, NULL); /* request more pointer hints */ return FALSE; }
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); } }
GtkTargetList * pygtk_target_list_from_sequence(PyObject *py_targets) { gint n_targets, i; GtkTargetEntry *targets; GtkTargetList *target_list; if (!(py_targets = PySequence_Fast(py_targets, "target list must be a sequence"))) return NULL; n_targets = PySequence_Fast_GET_SIZE(py_targets); targets = g_new(GtkTargetEntry, n_targets); for (i = 0; i < n_targets; i++) { PyObject *item = PySequence_Fast_GET_ITEM(py_targets, i); if (!PyArg_ParseTuple(item, "sii", &targets[i].target, &targets[i].flags, &targets[i].info)) { PyErr_Clear(); PyErr_SetString(PyExc_TypeError, "target list items should be of form (string,int,int)"); g_free(targets); Py_DECREF(py_targets); return NULL; } } target_list = gtk_target_list_new(targets, n_targets); g_free(targets); Py_DECREF(py_targets); return target_list; }
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); }
static void gstyle_color_widget_init (GstyleColorWidget *self) { GtkStyleContext *context; GtkWidget *widget = GTK_WIDGET (self); gtk_widget_set_has_window (GTK_WIDGET (self), TRUE); self->label = GTK_LABEL (g_object_new (GTK_TYPE_LABEL, "ellipsize", PANGO_ELLIPSIZE_END, "visible", TRUE, "halign", GTK_ALIGN_CENTER, "valign", GTK_ALIGN_CENTER, NULL)); gtk_container_add (GTK_CONTAINER (self), GTK_WIDGET (self->label)); self->is_name_visible = TRUE; self->is_fallback_name_visible = TRUE; self->fallback_name_kind = GSTYLE_COLOR_KIND_RGB_HEX6; self->checkered_pattern = gstyle_utils_get_checkered_pattern (); gtk_widget_set_valign (widget, GTK_ALIGN_FILL); gtk_widget_set_halign (widget, GTK_ALIGN_FILL); gtk_widget_set_hexpand (widget, TRUE); gtk_widget_set_vexpand (widget, TRUE); context = gtk_widget_get_style_context (GTK_WIDGET (self)); self->default_provider = gstyle_css_provider_init_default (gtk_style_context_get_screen (context)); self->target_list = gtk_target_list_new (dnd_targets, G_N_ELEMENTS (dnd_targets)); gtk_target_list_add_text_targets (self->target_list, 0); gtk_drag_dest_set (widget, 0, NULL, 0, GDK_ACTION_MOVE); gtk_drag_dest_set_target_list (widget, self->target_list); gtk_drag_dest_set_track_motion (GTK_WIDGET (self), TRUE); update_container_parent_informations (self); self->multipress_gesture = gtk_gesture_multi_press_new (widget); gtk_gesture_single_set_button (GTK_GESTURE_SINGLE (self->multipress_gesture), 0); gtk_event_controller_set_propagation_phase (GTK_EVENT_CONTROLLER (self->multipress_gesture), GTK_PHASE_BUBBLE); g_signal_connect (self->multipress_gesture, "pressed", G_CALLBACK (gstyle_color_widget_multipress_gesture_pressed), widget); self->drag_gesture = gtk_gesture_drag_new (GTK_WIDGET (self)); g_signal_connect (self->drag_gesture, "drag-update", G_CALLBACK (gstyle_color_widget_drag_gesture_update), self); g_signal_connect_swapped (self, "key-press-event", G_CALLBACK (gstyle_color_widget_key_pressed_cb), self); gstyle_color_widget_actions_init (self); gtk_widget_set_can_focus (GTK_WIDGET (self), TRUE); }
void Ctrl::DndTargets(GdkDragContext *context) { static Index<String> text_targets; static Index<String> image_targets; static Index<String> files_targets; ONCELOCK { GtkTargetList *target_list = gtk_target_list_new (NULL, 0); gtk_target_list_add_text_targets(target_list, 0); ToIndex(target_list, text_targets); GtkTargetList *target_list2 = gtk_target_list_new (NULL, 0); gtk_target_list_add_image_targets(target_list2, 0, TRUE); ToIndex(target_list2, image_targets); GtkTargetList *target_list3 = gtk_target_list_new (NULL, 0); gtk_target_list_add_uri_targets(target_list3, 0); ToIndex(target_list3, files_targets); } dnd_targets.Clear(); dnd_text_target.Clear(); #if GTK_CHECK_VERSION(2,22,0) // No drag&drop support before 2.22, sorry... for(GList *list = gdk_drag_context_list_targets(context); list; list = g_list_next (list)) { String g = gdk_atom_name((GdkAtom)list->data); if(text_targets.Find(g) >= 0) { dnd_targets.Add("text"); if(dnd_text_target.IsEmpty()) dnd_text_target = g; } else if(image_targets.Find(g) >= 0) { dnd_targets.Add("image"); if(dnd_image_target.IsEmpty()) dnd_image_target = g; } else if(files_targets.Find(g) >= 0) { dnd_targets.Add("files"); if(dnd_files_target.IsEmpty()) dnd_files_target = g; } else dnd_targets.Add(g); } #endif }
JNIEXPORT void JNICALL Java_gnu_java_awt_dnd_peer_gtk_GtkDragSourceContextPeer_nativeStartDrag (JNIEnv *env, jobject obj, jobject img, jint x, jint y, jint act, jstring target) { void *ptr; const gchar *data; GtkTargetEntry tar[1]; GdkEvent *event; GdkPixbuf *image = NULL; GdkDragContext *context = NULL; GdkDragAction action = GDK_ACTION_DEFAULT; gdk_threads_enter (); ptr = NSA_GET_GLOBAL_REF (env, obj); data = (*env)->GetStringUTFChars (env, target, NULL); tar[0].target = (gchar *) data; event = gdk_event_new (GDK_ALL_EVENTS_MASK); switch (act) { case ACTION_COPY: action = GDK_ACTION_COPY; break; case ACTION_MOVE: action = GDK_ACTION_MOVE; break; case ACTION_COPY_OR_MOVE: action = GDK_ACTION_COPY | GDK_ACTION_MOVE; break; case ACTION_LINK: action = GDK_ACTION_LINK; break; default: action = GDK_ACTION_DEFAULT; } gtk_drag_highlight (widget); context = gtk_drag_begin (widget, gtk_target_list_new (tar, sizeof (tar) / sizeof (GtkTargetEntry)), action, GDK_BUTTON1_MASK | GDK_BUTTON2_MASK, event); if (img != NULL) { image = cp_gtk_image_get_pixbuf (env, img); gtk_drag_set_icon_pixbuf (context, image, x, y); } gdk_event_free (event); (*env)->ReleaseStringUTFChars (env, target, data); gdk_threads_leave (); }
gboolean receive_drag(GtkWidget *widget, GdkDragContext *drag_context, gint x, gint y, guint time, gpointer user_data) { GtkTargetList *TL = gtk_target_list_new(target_table,1); GdkAtom target = gtk_drag_dest_find_target(widget,drag_context,TL); GtkWidget *srcWidget = gtk_drag_get_source_widget(drag_context); if (target == GDK_NONE || srcWidget == NULL) return FALSE; gtk_drag_get_data(srcWidget,drag_context,target,time); gtk_widget_queue_draw(widget); return TRUE; }
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 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 GtkTargetList* targetListForDataObject(DataObjectGtk* dataObject) { GtkTargetList* list = gtk_target_list_new(0, 0); if (dataObject->hasText()) gtk_target_list_add_text_targets(list, WEBKIT_WEB_VIEW_TARGET_INFO_TEXT); if (dataObject->hasMarkup()) gtk_target_list_add(list, gdkMarkupAtom, 0, WEBKIT_WEB_VIEW_TARGET_INFO_HTML); return list; }
static VALUE rg_initialize(VALUE self, VALUE rbtargets) { long n; GtkTargetEntry *targets = RVAL2GTKTARGETENTRIES(rbtargets, &n); GtkTargetList *list = gtk_target_list_new(targets, n); g_free(targets); G_INITIALIZE(self, list); return Qnil; }
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); }