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; }
void DragAndDropHandler::startDrag(Ref<SelectionData>&& selection, DragOperation dragOperation, RefPtr<ShareableBitmap>&& dragImage) { #if GTK_CHECK_VERSION(3, 16, 0) m_draggingSelectionData = WTFMove(selection); GRefPtr<GtkTargetList> targetList = PasteboardHelper::singleton().targetListForSelectionData(*m_draggingSelectionData); #else RefPtr<SelectionData> selectionData = WTFMove(selection); GRefPtr<GtkTargetList> targetList = PasteboardHelper::singleton().targetListForSelectionData(*selectionData); #endif GUniquePtr<GdkEvent> currentEvent(gtk_get_current_event()); GdkDragContext* context = gtk_drag_begin(m_page.viewWidget(), targetList.get(), dragOperationToGdkDragActions(dragOperation), GDK_BUTTON_PRIMARY, currentEvent.get()); #if GTK_CHECK_VERSION(3, 16, 0) // WebCore::EventHandler does not support more than one DnD operation at the same time for // a given page, so we should cancel any previous operation whose context we might have // stored, should we receive a new startDrag event before finishing a previous DnD operation. if (m_dragContext) gtk_drag_cancel(m_dragContext.get()); m_dragContext = context; #else // We don't have gtk_drag_cancel() in GTK+ < 3.16, so we use the old code. // See https://bugs.webkit.org/show_bug.cgi?id=138468 m_draggingSelectionDataMap.set(context, WTFMove(selectionData)); #endif if (dragImage) { RefPtr<cairo_surface_t> image(dragImage->createCairoSurface()); // Use the center of the drag image as hotspot. cairo_surface_set_device_offset(image.get(), -cairo_image_surface_get_width(image.get()) / 2, -cairo_image_surface_get_height(image.get()) / 2); gtk_drag_set_icon_surface(context, image.get()); } else gtk_drag_set_icon_default(context); }
static gint __gevasevh_group_selector_leave_notify_cb( GtkWidget *widget, GdkEventCrossing *event, GtkgEvasEvHGroupSelector* ev ) { /* printf("__gevasevh_group_selector_leave_notify_cb() w:%p event:%p ev:%p gevas:%p gwin:%d\n", widget, event, ev, GTK_WIDGET (ev->rect->gevas), GTK_WIDGET_NO_WINDOW(GTK_WIDGET (ev->rect->gevas)) ); */ if( ev->drag_targets && ev->drag_is_dragging ) { ev->drag_context = gtk_drag_begin (GTK_WIDGET (ev->rect->gevas), ev->drag_targets, GDK_ACTION_MOVE | GDK_ACTION_COPY, 1, (GdkEvent*)event); gtk_drag_set_icon_default (ev->drag_context); /* printf("__gevasevh_group_selector_leave_notify_cb() context:%p\n",ev->drag_context);*/ } return 0; }
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 egg_tree_multi_drag_begin (GtkWidget *tree, GdkDragContext *context, gpointer user_data) { gtk_drag_set_icon_default (context); g_signal_stop_emission_by_name (tree, "drag-begin"); }
void Ctrl::GtkDragBegin(GtkWidget *widget, GdkDragContext *context, gpointer user_data) { if(IsNull(dnd_icon)) gtk_drag_set_icon_default(context); else { ImageGdk m(dnd_icon); gtk_drag_set_icon_pixbuf(context, m, 0, 0); } LLOG("GtkDragBegin"); }
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; TreeViewDragInfo *di; di = get_info (GTK_TREE_VIEW (widget)); if (di == NULL) return FALSE; selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (widget)); stop_drag_check (widget); gtk_tree_selection_selected_foreach (selection, selection_foreach, &path_list); 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)) { context = gtk_drag_begin (widget, #if GTK_CHECK_VERSION (2, 14, 0) gtk_drag_source_get_target_list (widget), #else di->source_target_list, #endif di->source_actions, priv_data->pressed_button, (GdkEvent*)event); set_context_data (context, path_list); gtk_drag_set_icon_default (context); } else { path_list_free (path_list); } } return TRUE; }
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; }
int clip_GTK_DRAGSETICONDEFAULT(ClipMachine * cm) { C_object *ccontext = _fetch_co_arg(cm); if (!ccontext || ccontext->type != GDK_TYPE_DRAG_CONTEXT) goto err; gtk_drag_set_icon_default((GdkDragContext*)ccontext->object); return 0; err: return 1; }
static void mimeview_start_drag(GtkWidget *widget, gint button, GdkEvent *event, MimeView *mimeview) { GdkDragContext *context; MimeInfo *partinfo; g_return_if_fail(mimeview != NULL); partinfo = mimeview_get_selected_part(mimeview); if (partinfo->disposition == DISPOSITIONTYPE_INLINE) return; context = gtk_drag_begin(widget, mimeview->target_list, GDK_ACTION_COPY, button, event); gtk_drag_set_icon_default(context); }
static void on_drag_begin ( GtkWidget *src_widget, GdkDragContext *drag_context, FmDndSrc* ds ) { /* block default handler */ gtk_drag_set_icon_default( drag_context ); /* FIXME: set the icon to file icon later */ // gtk_drag_set_icon_pixbuf(); /* ask drag source to provide list of source files. */ g_signal_emit(ds, signals[DATA_GET], 0); }
void DragAndDropHandler::startDrag(const DragData& dragData, PassRefPtr<ShareableBitmap> dragImage) { RefPtr<DataObjectGtk> dataObject = adoptRef(dragData.platformData()); GRefPtr<GtkTargetList> targetList = adoptGRef(PasteboardHelper::defaultPasteboardHelper()->targetListForDataObject(dataObject.get())); GUniquePtr<GdkEvent> currentEvent(gtk_get_current_event()); GdkDragContext* context = gtk_drag_begin(m_page.viewWidget(), targetList.get(), dragOperationToGdkDragActions(dragData.draggingSourceOperationMask()), GDK_BUTTON_PRIMARY, currentEvent.get()); m_draggingDataObjects.set(context, dataObject.get()); if (dragImage) { RefPtr<cairo_surface_t> image(dragImage->createCairoSurface()); m_dragIcon.setImage(image.get()); m_dragIcon.useForDrag(context); } else gtk_drag_set_icon_default(context); }
static void mouse_click_cb(GtkWidget *widget, GdkEventButton *event, FileView *view) { if (event->button == 1) { /* Left Button: selection */ if (curr_view != view) { switch_views(); gtk_widget_grab_focus(view->clist); } } else if (event->button == 2) { /* Middle Button: Drag and Drop */ GtkTargetList *list; GdkDragContext *context; list = gtk_target_list_new(target_table, n_targets); context = gtk_drag_begin(curr_view->clist, list, GDK_ACTION_COPY | GDK_ACTION_MOVE | GDK_ACTION_LINK | GDK_ACTION_ASK, event->button, (GdkEvent *)event); gtk_drag_set_icon_default(context); } else if (event->button == 3) { /* Right Button: Menu */ if (cfg.windows_right_click && (view->tagged == NULL)) { /* if windows right click is enabled, we want to select the file */ gint xmouse,ymouse,row,column; GdkModifierType mask; gdk_window_get_pointer(GTK_CLIST(view->clist)->clist_window, &xmouse, &ymouse, &mask); gtk_clist_get_selection_info(GTK_CLIST(view->clist), xmouse, ymouse, &row, &column); /* don't screw up the current selection */ if (!clist_row_is_selected(view->clist, row)) gtk_clist_unselect_all(GTK_CLIST(view->clist)); focus_row(view, row, FALSE, FALSE, TRUE); } if (event->state & GDK_CONTROL_MASK) show_user_command_menu(event->button, event->time); else show_menu(event->button, event->time); } }
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); }
static gboolean rb_tree_dnd_motion_notify_event_cb (GtkWidget *widget, GdkEventMotion *event, gpointer data) { RbTreeDndData *priv_data; priv_data = g_object_get_data (G_OBJECT (widget), RB_TREE_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; selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (widget)); stop_drag_check (widget); gtk_tree_selection_selected_foreach (selection, selection_foreach, &path_list); path_list = g_list_reverse (path_list); model = gtk_tree_view_get_model (GTK_TREE_VIEW (widget)); if (rb_tree_drag_source_row_draggable (RB_TREE_DRAG_SOURCE (model), path_list)) { rb_debug ("drag begin"); context = gtk_drag_begin (widget, priv_data->source_target_list, priv_data->source_actions, priv_data->pressed_button, (GdkEvent*)event); set_context_data (context, path_list); gtk_drag_set_icon_default (context); } else { path_list_free (path_list); } } return TRUE; }
static gboolean on_motion_event( GtkWidget *widget, GdkEventMotion *event, EggTreeMultiDragSource *drag_source ) { 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, ( GtkTreeSelectionForeachFunc ) selection_foreach, &path_list ); 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 = v_get_target_list( drag_source ); GdkDragAction actions = v_get_drag_actions( drag_source ); context = gtk_drag_begin( widget, target_list, actions, priv_data->pressed_button, ( GdkEvent * ) event ); set_treeview_data( widget, path_list ); gtk_drag_set_icon_default( context ); v_free_target_list( drag_source, target_list ); } else { path_list_free( path_list ); } } return( TRUE ); }
void DragClient::startDrag(DragImageRef image, const IntPoint& dragImageOrigin, const IntPoint& eventPos, Clipboard* clipboard, Frame* frame, bool linkDrag) { WebKitWebView* webView = webkit_web_frame_get_web_view(kit(frame)); RefPtr<DataObjectGtk> dataObject = clipboard->pasteboard().dataObject(); GRefPtr<GtkTargetList> targetList = adoptGRef(PasteboardHelper::defaultPasteboardHelper()->targetListForDataObject(dataObject.get())); GOwnPtr<GdkEvent> currentEvent(gtk_get_current_event()); GdkDragContext* context = gtk_drag_begin(GTK_WIDGET(m_webView), targetList.get(), dragOperationToGdkDragActions(clipboard->sourceOperation()), 1, currentEvent.get()); webView->priv->dragAndDropHelper.startedDrag(context, dataObject.get()); // A drag starting should prevent a double-click from happening. This might // happen if a drag is followed very quickly by another click (like in the DRT). webView->priv->clickCounter.reset(); if (image) { m_dragIcon.setImage(image); m_dragIcon.useForDrag(context, IntPoint(eventPos - dragImageOrigin)); } else gtk_drag_set_icon_default(context); }
static gboolean motion_notify_cb (GtkWidget *widget, GdkEventMotion *event, EphyNodeView *view) { GdkDragContext *context; GList *ref_list; if (event->window != gtk_tree_view_get_bin_window (GTK_TREE_VIEW (widget))) { return FALSE; } if (view->priv->drag_button != 0) { if (gtk_drag_check_threshold (widget, view->priv->drag_x, view->priv->drag_y, event->x, event->y) && can_drag_selection (view)) { context = gtk_drag_begin (widget, view->priv->source_target_list, GDK_ACTION_ASK | GDK_ACTION_COPY | GDK_ACTION_LINK, view->priv->drag_button, (GdkEvent*)event); stop_drag_check (view); view->priv->drag_started = TRUE; ref_list = get_selection_refs (GTK_TREE_VIEW (widget)); g_object_set_data_full (G_OBJECT (context), "drag-info", ref_list, (GDestroyNotify)ref_list_free); gtk_drag_set_icon_default (context); } } return TRUE; }
static void mimeview_drag_begin(GtkWidget *widget, GdkDragContext *drag_context, MimeView *mimeview) { gchar *filename; gchar *bname = NULL; MimeInfo *partinfo; if (!mimeview->opened) return; if (!mimeview->messageview->file) return; partinfo = mimeview_get_selected_part(mimeview); if (!partinfo) return; filename = partinfo->filename ? partinfo->filename : partinfo->name; if (filename) { const gchar *bname_; bname_ = g_basename(filename); bname = conv_filename_from_utf8(bname_); subst_for_filename(bname); } if (!bname || *bname == '\0') filename = procmime_get_tmp_file_name(partinfo); else filename = g_strconcat(get_mime_tmp_dir(), G_DIR_SEPARATOR_S, bname, NULL); if (procmime_get_part(filename, mimeview->messageview->file, partinfo) < 0) { g_warning(_("Can't save the part of multipart message.")); } else mimeview->drag_file = encode_uri(filename); g_free(filename); gtk_drag_set_icon_default(drag_context); }
static VALUE rg_m_set_icon_default(VALUE self, VALUE context) { gtk_drag_set_icon_default(RVAL2DC(context)); return self; }
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 (! priv_data->pending_event) return FALSE; 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; GtkTreePath *tree_path; int cell_x; int cell_y; target_list = gtk_target_list_new (target_table, G_N_ELEMENTS (target_table)); context = gtk_drag_begin_with_coordinates (widget, target_list, GDK_ACTION_COPY, priv_data->pressed_button, (GdkEvent*) event, event->x, event->y); set_context_data (context, path_list); if (gtk_tree_view_get_path_at_pos (GTK_TREE_VIEW (widget), priv_data->x, priv_data->y, &tree_path, NULL, &cell_x, &cell_y)) { cairo_surface_t *drag_icon; drag_icon = gtk_tree_view_create_row_drag_icon (GTK_TREE_VIEW (widget), tree_path); if (path_list->next != NULL) { /* create a multi row drag icon */ const int icon_offset = DRAG_ICON_OFFSET; GdkRectangle icon_extents; cairo_surface_t *multi_drag_icon; cairo_t *cr; int n_icons, i, offset; n_icons = MIN (DRAG_ICON_MAX_ROWS, g_list_length (path_list)); _gtk_cairo_surface_extents (drag_icon, &icon_extents); multi_drag_icon = gdk_window_create_similar_surface (gtk_tree_view_get_bin_window (GTK_TREE_VIEW (widget)), CAIRO_CONTENT_COLOR_ALPHA, icon_extents.width + (icon_offset * (n_icons - 1)), icon_extents.height + (icon_offset * (n_icons - 1))); cr = cairo_create (multi_drag_icon); cairo_set_source_rgba (cr, 0.0, 0.0, 0.0, 0.0); cairo_rectangle(cr, 0, 0, icon_extents.width + icon_offset, icon_extents.height + icon_offset); cairo_fill (cr); offset = icon_offset * (n_icons - 1); for (i = 0; i < n_icons; i++) { cairo_set_source_surface (cr, drag_icon, -icon_extents.x + offset, -icon_extents.y + offset); cairo_rectangle (cr, offset, offset, icon_extents.width, icon_extents.height); cairo_fill (cr); offset -= icon_offset; } cairo_destroy (cr); cairo_surface_set_device_offset (multi_drag_icon, - (cell_x + 1), - (cell_y + 1)); gtk_drag_set_icon_surface (context, multi_drag_icon); cairo_surface_destroy (multi_drag_icon); } else { cairo_surface_set_device_offset (drag_icon, - (cell_x + 1), - (cell_y + 1)); gtk_drag_set_icon_surface (context, drag_icon); } cairo_surface_destroy (drag_icon); gtk_tree_path_free (tree_path); } else gtk_drag_set_icon_default (context); gtk_target_list_unref (target_list); } else { path_list_free (path_list); } } return TRUE; }