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); } }
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); }
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; }
/* * 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 PasteboardHelper::initializeTargetList() { gtk_target_list_add_text_targets(m_targetList, getIdForTargetType(TargetTypeText)); gtk_target_list_add(m_targetList, markupAtom, 0, getIdForTargetType(TargetTypeMarkup)); gtk_target_list_add_uri_targets(m_targetList, getIdForTargetType(TargetTypeURIList)); gtk_target_list_add(m_targetList, netscapeURLAtom, 0, getIdForTargetType(TargetTypeNetscapeURL)); gtk_target_list_add_image_targets(m_targetList, getIdForTargetType(TargetTypeImage), TRUE); }
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 ide_editor_frame_init (IdeEditorFrame *self) { g_autoptr(GSettings) settings = NULL; g_autoptr(GSettings) insight_settings = NULL; GtkTargetList *target_list; gtk_widget_init_template (GTK_WIDGET (self)); ide_editor_frame_actions_init (self); settings = g_settings_new ("org.gnome.builder.editor"); g_settings_bind (settings, "draw-spaces", self->source_view, "draw-spaces", G_SETTINGS_BIND_DEFAULT); g_settings_bind (settings, "font-name", self->source_view, "font-name", G_SETTINGS_BIND_GET); g_settings_bind (settings, "highlight-current-line", self->source_view, "highlight-current-line", G_SETTINGS_BIND_GET); g_settings_bind (settings, "overscroll", self->source_view, "overscroll", G_SETTINGS_BIND_GET); g_settings_bind (settings, "scroll-offset", self->source_view, "scroll-offset", G_SETTINGS_BIND_GET); g_settings_bind (settings, "show-grid-lines", self->source_view, "show-grid-lines", G_SETTINGS_BIND_GET); g_settings_bind (settings, "show-line-changes", self->source_view, "show-line-changes", G_SETTINGS_BIND_GET); g_settings_bind (settings, "show-line-numbers", self->source_view, "show-line-numbers", G_SETTINGS_BIND_GET); g_settings_bind (settings, "smart-backspace", self->source_view, "smart-backspace", G_SETTINGS_BIND_GET); g_settings_bind_with_mapping (settings, "smart-home-end", self->source_view, "smart-home-end", G_SETTINGS_BIND_GET, get_smart_home_end, NULL, NULL, NULL); g_settings_bind (settings, "show-map", self, "show-map", G_SETTINGS_BIND_GET); g_settings_bind (settings, "auto-hide-map", self, "auto-hide-map", G_SETTINGS_BIND_GET); g_signal_connect_object (settings, "changed::keybindings", G_CALLBACK (keybindings_changed), self, 0); insight_settings = g_settings_new ("org.gnome.builder.code-insight"); g_settings_bind (insight_settings, "word-completion", self->source_view, "enable-word-completion", G_SETTINGS_BIND_GET); g_signal_connect_object (self->source_view, "notify::overwrite", G_CALLBACK (ide_editor_frame_update_ruler), self, G_CONNECT_SWAPPED); g_signal_connect_object (self->source_view, "notify::mode-display-name", G_CALLBACK (ide_editor_frame_update_ruler), self, G_CONNECT_SWAPPED); /* * we want to rubberbanding search until enter has been pressed or next/previous actions * have been activated. */ g_object_bind_property (self->search_revealer, "visible", self->source_view, "rubberband-search", G_BINDING_SYNC_CREATE); /* * Drag and drop support */ target_list = gtk_drag_dest_get_target_list (GTK_WIDGET (self->source_view)); if (target_list) gtk_target_list_add_uri_targets (target_list, TARGET_URI_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); }
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); }
PasteboardHelper::PasteboardHelper() : m_targetList(adoptGRef(gtk_target_list_new(nullptr, 0))) { textPlainAtom = gdk_atom_intern_static_string("text/plain;charset=utf-8"); markupAtom = gdk_atom_intern_static_string("text/html"); netscapeURLAtom = gdk_atom_intern_static_string("_NETSCAPE_URL"); uriListAtom = gdk_atom_intern_static_string("text/uri-list"); smartPasteAtom = gdk_atom_intern_static_string("application/vnd.webkitgtk.smartpaste"); unknownAtom = gdk_atom_intern_static_string("application/vnd.webkitgtk.unknown"); gtk_target_list_add_text_targets(m_targetList.get(), PasteboardHelper::TargetTypeText); gtk_target_list_add(m_targetList.get(), markupAtom, 0, PasteboardHelper::TargetTypeMarkup); gtk_target_list_add_uri_targets(m_targetList.get(), PasteboardHelper::TargetTypeURIList); gtk_target_list_add(m_targetList.get(), netscapeURLAtom, 0, PasteboardHelper::TargetTypeNetscapeURL); gtk_target_list_add_image_targets(m_targetList.get(), PasteboardHelper::TargetTypeImage, TRUE); gtk_target_list_add(m_targetList.get(), unknownAtom, 0, PasteboardHelper::TargetTypeUnknown); }
void DragClient::startDrag(DragImageRef image, const IntPoint& dragImageOrigin, const IntPoint& eventPos, Clipboard*, Frame* frame, bool linkDrag) { Element* targetElement = frame->document()->elementFromPoint(m_startPos.x(), m_startPos.y()); bool imageDrag = false; if (targetElement) imageDrag = targetElement->renderer()->isImage(); GdkAtom textHtml = gdk_atom_intern_static_string("text/html"); GdkAtom netscapeUrl = gdk_atom_intern_static_string("_NETSCAPE_URL"); GtkTargetList* targetList = gtk_target_list_new(NULL, 0); gtk_target_list_add(targetList, textHtml, 0, WEBKIT_WEB_VIEW_TARGET_INFO_HTML); gtk_target_list_add_text_targets(targetList, WEBKIT_WEB_VIEW_TARGET_INFO_TEXT); if (linkDrag || imageDrag) { gtk_target_list_add(targetList, netscapeUrl, 0, WEBKIT_WEB_VIEW_TARGET_INFO_NETSCAPE_URL); gtk_target_list_add_uri_targets(targetList, WEBKIT_WEB_VIEW_TARGET_INFO_URI_LIST); } if (imageDrag) gtk_target_list_add_image_targets(targetList, WEBKIT_WEB_VIEW_TARGET_INFO_IMAGE, false); GdkDragAction dragAction = GDK_ACTION_COPY; if (linkDrag) { dragAction = GDK_ACTION_LINK; if (imageDrag) dragAction = (GdkDragAction)(dragAction | GDK_ACTION_COPY); } GdkEvent* event = gdk_event_new(GDK_BUTTON_PRESS); reinterpret_cast<GdkEventButton*>(event)->window = gtk_widget_get_window(GTK_WIDGET(m_webView)); reinterpret_cast<GdkEventButton*>(event)->time = GDK_CURRENT_TIME; GdkDragContext* context = gtk_drag_begin(GTK_WIDGET(m_webView), targetList, dragAction, 1, event); g_object_ref(context); if (image) gtk_drag_set_icon_pixbuf(context, image, eventPos.x() - dragImageOrigin.x(), eventPos.y() - dragImageOrigin.y()); else gtk_drag_set_icon_default(context); gtk_target_list_unref(targetList); }
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 }
GtkTargetList* PasteboardHelper::targetListForDataObject(DataObjectGtk* dataObject) { GtkTargetList* list = gtk_target_list_new(0, 0); if (dataObject->hasText()) gtk_target_list_add_text_targets(list, getIdForTargetType(TargetTypeText)); if (dataObject->hasMarkup()) gtk_target_list_add(list, markupAtom, 0, getIdForTargetType(TargetTypeMarkup)); if (dataObject->hasURIList()) { gtk_target_list_add_uri_targets(list, getIdForTargetType(TargetTypeURIList)); gtk_target_list_add(list, netscapeURLAtom, 0, getIdForTargetType(TargetTypeNetscapeURL)); } if (dataObject->hasImage()) gtk_target_list_add_image_targets(list, getIdForTargetType(TargetTypeImage), TRUE); return list; }
static void _gth_browser_clipboard_copy_or_cut (GthBrowser *browser, GList *file_list, gboolean cut) { ClipboardData *data; GtkTargetList *target_list; GtkTargetEntry *targets; int n_targets; GList *scan; int i; data = g_new0 (ClipboardData, 1); data->cut = cut; data->n_uris = g_list_length (file_list); data->uris = g_new (char *, data->n_uris + 1); for (scan = file_list, i = 0; scan; scan = scan->next, i++) { GthFileData *file_data = scan->data; data->uris[i] = g_file_get_uri (file_data->file); } data->uris[data->n_uris] = NULL; target_list = gtk_target_list_new (NULL, 0); gtk_target_list_add (target_list, GNOME_COPIED_FILES, 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 (gtk_clipboard_get_for_display (gtk_widget_get_display (GTK_WIDGET (browser)), GDK_SELECTION_CLIPBOARD), targets, n_targets, clipboard_get_cb, clipboard_clear_cb, data); gtk_target_list_unref (target_list); gtk_target_table_free (targets, n_targets); }
void SetupClipboardContentTypes() { GtkTargetList* list = gtk_target_list_new(NULL, 0); // TODO: Support for images if (!this->text && !this->uris) return; if (this->text) gtk_target_list_add_text_targets(list, ClipboardPrivate::TEXT_DATA); if (this->uris) gtk_target_list_add_uri_targets(list, ClipboardPrivate::URI_LIST_DATA); int size = 0; GtkTargetEntry* table = gtk_target_table_new_from_list(list, &size); if (table) { // gtk_clipboard_set_with_data may try to clear our clipboard when we // call it, so we turn on a flag here which prevents our clipboard data // from being freed during this call. this->preserve = true; GtkClipboard* clipboard = GetClipboard(); if (gtk_clipboard_set_with_data(clipboard, table, size, GetClipboardData, ClearClipboardData, NULL)) { this->ownClipboard = true; gtk_clipboard_set_can_store(clipboard, NULL, 0); } this->preserve = false; gtk_target_table_free(table, size); } gtk_target_list_unref(list); }
static VALUE rg_add_uri_targets(VALUE self, VALUE info) { gtk_target_list_add_uri_targets(_SELF(self), NUM2UINT(info)); return self; }