[gtk/dnd-gestures-2: 4/63] Add a GtkDragSource object
- From: Matthias Clasen <matthiasc src gnome org>
- To: commits-list gnome org
- Cc:
- Subject: [gtk/dnd-gestures-2: 4/63] Add a GtkDragSource object
- Date: Sat, 4 Jan 2020 03:11:30 +0000 (UTC)
commit 9da39764b8701f8f6fdb121131a9c18896de896b
Author: Matthias Clasen <mclasen redhat com>
Date: Mon Dec 30 14:12:08 2019 -0500
Add a GtkDragSource object
Add an explicit GtkDragSource object, and move the source-side
DND signals here. The object can be used on the spot, by calling
gtk_drag_source_drag_begin() yourself, or for static drag-source
configuration, by calling gtk_drag_source_attach(). In the latter
case, we set up and conect a drag gesture to trigger the drag_begin
call.
gtk/gtkdragsource.c | 752 +++++++++++++++++++++++++++++++++++++++++++++++++++-
gtk/gtkdragsource.h | 62 +++++
2 files changed, 813 insertions(+), 1 deletion(-)
---
diff --git a/gtk/gtkdragsource.c b/gtk/gtkdragsource.c
index 8cc461464e..5074ab944e 100644
--- a/gtk/gtkdragsource.c
+++ b/gtk/gtkdragsource.c
@@ -29,8 +29,16 @@
#include "gtkdnd.h"
#include "gtkdndprivate.h"
#include "gtkgesturedrag.h"
+#include "gtkgesturesingleprivate.h"
#include "gtkimagedefinitionprivate.h"
+#include "gtknative.h"
+#include "gtkwidgetprivate.h"
#include "gtkintl.h"
+#include "gtkstylecontext.h"
+#include "gtkimageprivate.h"
+#include "gtkdragiconprivate.h"
+#include "gtkprivate.h"
+#include "gtkmarshalers.h"
typedef struct _GtkDragSourceSite GtkDragSourceSite;
@@ -117,7 +125,7 @@ gtk_drag_source_site_destroy (gpointer data)
* gtk_drag_source_set: (method)
* @widget: a #GtkWidget
* @start_button_mask: the bitmask of buttons that can start the drag
- * @targets: (allow-none): the targets that the drag will support,
+ * @formats: (allow-none): the formats that the drag will support,
* may be %NULL
* @actions: the bitmask of possible actions for a drag from this widget
*
@@ -388,3 +396,745 @@ gtk_drag_source_set_icon_paintable (GtkWidget *widget,
site->image_def = gtk_image_definition_new_paintable (paintable);
}
+
+/**
+ * SECTION:gtkdragsource
+ * @Short_description: An object to initiate DND operations
+ * @Title: GtkDragSource
+ *
+ * GtkDragSource is an auxiliary object that is used to initiate
+ * Drag-And-Drop operations. It can be set up with the necessary
+ * ingredients for a DND operation ahead of time. This includes
+ * the source for the data that is being transferred, in the form
+ * of a #GdkContentProvider, the desired action, and the icon to
+ * use during the drag operation.
+ *
+ * GtkDragSource can be used in two ways:
+ * - for static drag-source configuration
+ * - for one-off drag operations
+ *
+ * To configure a widget as a permanent source for DND operations,
+ * set up the GtkDragSource, then call gtk_drag_source_attach().
+ * This sets up a drag gesture on the widget that will trigger
+ * DND actions.
+ *
+ * To initiate a on-off drag operation, set up the GtkDragSource,
+ * then call gtk_drag_source_drag_begin(). GTK keeps a reference
+ * on the drag source until the DND operation is done, so you
+ * can unref the source after calling drag_being().
+ *
+ * During the DND operation, GtkDragSource emits signals that
+ * can be used to obtain updates about the status of the operation,
+ * but it is not normally necessary to connect to any signals,
+ * except for one case: when the supported actions include
+ * %GDK_DRAG_MOVE, you need to listen for the
+ * #GtkDragSource::drag-data-deleted signal and delete the
+ * drag data after it has been transferred.
+ */
+
+struct _GtkDragSource
+{
+ GObject parent_instance;
+
+ GdkContentProvider *content;
+ GdkDragAction actions;
+
+ GtkWidget *icon_window;
+ GdkPaintable *paintable;
+ int hot_x;
+ int hot_y;
+
+ GtkGesture *gesture;
+ int start_button_mask;
+
+ GdkDrag *drag;
+ GtkWidget *widget;
+};
+
+struct _GtkDragSourceClass
+{
+ GObjectClass parent_class;
+};
+
+enum {
+ PROP_CONTENT = 1,
+ PROP_ACTIONS,
+ NUM_PROPERTIES
+};
+
+static GParamSpec *properties[NUM_PROPERTIES];
+
+enum {
+ DRAG_BEGIN,
+ DRAG_END,
+ DRAG_FAILED,
+ DRAG_DATA_DELETE,
+ NUM_SIGNALS
+};
+
+static guint signals[NUM_SIGNALS];
+
+G_DEFINE_TYPE (GtkDragSource, gtk_drag_source, G_TYPE_OBJECT);
+
+static void
+gtk_drag_source_init (GtkDragSource *source)
+{
+}
+
+static void
+gtk_drag_source_finalize (GObject *object)
+{
+ GtkDragSource *source = GTK_DRAG_SOURCE (object);
+
+ gtk_drag_source_detach (source);
+
+ g_clear_object (&source->content);
+ g_clear_object (&source->paintable);
+ g_clear_object (&source->icon_window);
+
+ G_OBJECT_CLASS (gtk_drag_source_parent_class)->finalize (object);
+}
+
+static void
+gtk_drag_source_set_property (GObject *object,
+ guint prop_id,
+ const GValue *value,
+ GParamSpec *pspec)
+{
+ GtkDragSource *source = GTK_DRAG_SOURCE (object);
+
+ switch (prop_id)
+ {
+ case PROP_CONTENT:
+ gtk_drag_source_set_content (source, g_value_get_object (value));
+ break;
+
+ case PROP_ACTIONS:
+ gtk_drag_source_set_actions (source, g_value_get_flags (value));
+ break;
+
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+ }
+}
+
+static void
+gtk_drag_source_get_property (GObject *object,
+ guint prop_id,
+ GValue *value,
+ GParamSpec *pspec)
+{
+ GtkDragSource *source = GTK_DRAG_SOURCE (object);
+
+ switch (prop_id)
+ {
+ case PROP_CONTENT:
+ g_value_set_object (value, gtk_drag_source_get_content (source));
+ break;
+
+ case PROP_ACTIONS:
+ g_value_set_flags (value, gtk_drag_source_get_actions (source));
+ break;
+
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+ }
+}
+
+static void
+gtk_drag_source_class_init (GtkDragSourceClass *class)
+{
+ GObjectClass *object_class = G_OBJECT_CLASS (class);
+
+ object_class->finalize = gtk_drag_source_finalize;
+ object_class->set_property = gtk_drag_source_set_property;
+ object_class->get_property = gtk_drag_source_get_property;
+
+ /**
+ * GtkDragSource:content:
+ *
+ * The data that is offered by drag operations from this source,
+ * in the form of a #GdkContentProvider.
+ */
+ properties[PROP_CONTENT] =
+ g_param_spec_object ("content",
+ P_("Content"),
+ P_("The content provider for the dragged data"),
+ GDK_TYPE_CONTENT_PROVIDER,
+ G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS | G_PARAM_EXPLICIT_NOTIFY);
+
+ /**
+ * GtkDragSource:actions:
+ *
+ * The actions that are supported by drag operations from the source.
+ *
+ * Note that you must handle the #GtkDragSource::drag-data-deleted signal
+ * if the actions include %GDK_ACTION_MOVE.
+ */
+ properties[PROP_ACTIONS] =
+ g_param_spec_flags ("actions",
+ P_("Actions"),
+ P_("Supported actions"),
+ GDK_TYPE_DRAG_ACTION, 0,
+ G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS | G_PARAM_EXPLICIT_NOTIFY);
+
+ g_object_class_install_properties (object_class, NUM_PROPERTIES, properties);
+
+ /**
+ * GtkDragSource::drag-begin:
+ * @source: the #GtkDragSource
+ *
+ * The ::drag-begin signal is emitted on the drag source when a drag
+ * is started. It can be used to e.g. set a custom drag icon with
+ * gtk_drag_source_set_icon(). But all of the setup can also be
+ * done before calling gtk_drag_source_drag_begin(), so this is not
+ * really necessary.
+ */
+ signals[DRAG_BEGIN] =
+ g_signal_new (I_("drag-begin"),
+ G_TYPE_FROM_CLASS (class),
+ G_SIGNAL_RUN_LAST,
+ 0,
+ NULL, NULL,
+ NULL,
+ G_TYPE_NONE, 0);
+
+ /**
+ * GtkDragSource::drag-end:
+ * @source: the #GtkDragSource
+ *
+ * The ::drag-end signal is emitted on the drag source when a drag is
+ * finished. A typical reason to connect to this signal is to undo
+ * things done in #GtkDragSource::drag-begin.
+ */
+ signals[DRAG_END] =
+ g_signal_new (I_("drag-end"),
+ G_TYPE_FROM_CLASS (class),
+ G_SIGNAL_RUN_LAST,
+ 0,
+ NULL, NULL,
+ NULL,
+ G_TYPE_NONE, 0);
+
+ /**
+ * GtkDragSource::drag-failed:
+ * @source: the #GtkDragSource
+ * @reason: information on why the drag failed
+ *
+ * The ::drag-failed signal is emitted on the drag source when a drag has
+ * failed. The signal handler may handle a failed drag operation based on
+ * the type of error. It should return %TRUE if the failure has been handled
+ * and the default "drag operation failed" should not be shown.
+ *
+ * Returns: %TRUE if the failed drag operation has been already handled
+ */
+ signals[DRAG_FAILED] =
+ g_signal_new (I_("drag-failed"),
+ G_TYPE_FROM_CLASS (class),
+ G_SIGNAL_RUN_LAST,
+ 0,
+ _gtk_boolean_handled_accumulator, NULL,
+ _gtk_marshal_BOOLEAN__ENUM,
+ G_TYPE_BOOLEAN, 1,
+ GDK_TYPE_DRAG_CANCEL_REASON);
+
+ /**
+ * GtkDragSource::drag-data-delete:
+ * @source: the #GtkDragSource
+ *
+ * The ::drag-data-delete signal is emitted on the drag source when a drag
+ * with the action %GDK_ACTION_MOVE is successfully completed. The signal
+ * handler is responsible for deleting the data that has been dropped. What
+ * "delete" means depends on the context of the drag operation.
+ */
+ signals[DRAG_DATA_DELETE] =
+ g_signal_new (I_("drag-data-delete"),
+ G_TYPE_FROM_CLASS (class),
+ G_SIGNAL_RUN_LAST,
+ 0,
+ NULL, NULL,
+ NULL,
+ G_TYPE_NONE, 0);
+}
+
+static void gtk_drag_source_dnd_finished_cb (GdkDrag *drag,
+ GtkDragSource *source);
+static void gtk_drag_source_drop_performed_cb (GdkDrag *drag,
+ GtkDragSource *source);
+static void gtk_drag_source_cancel_cb (GdkDrag *drag,
+ GdkDragCancelReason reason,
+ GtkDragSource *source);
+
+static void
+drag_end (GtkDragSource *source)
+{
+ g_signal_handlers_disconnect_by_func (source->drag, gtk_drag_source_drop_performed_cb, source);
+ g_signal_handlers_disconnect_by_func (source->drag, gtk_drag_source_dnd_finished_cb, source);
+ g_signal_handlers_disconnect_by_func (source->drag, gtk_drag_source_cancel_cb, source);
+
+ g_signal_emit (source, signals[DRAG_END], 0);
+
+ g_object_set_data (G_OBJECT (source->drag), I_("gtk-drag-source"), NULL);
+ g_clear_object (&source->drag);
+ source->widget = NULL;
+ g_object_unref (source);
+}
+
+static void
+gtk_drag_source_dnd_finished_cb (GdkDrag *drag,
+ GtkDragSource *source)
+{
+ if (gdk_drag_get_selected_action (drag) == GDK_ACTION_MOVE)
+ g_signal_emit (source, signals[DRAG_DATA_DELETE], 0);
+
+ drag_end (source);
+}
+
+static void
+gtk_drag_source_cancel_cb (GdkDrag *drag,
+ GdkDragCancelReason reason,
+ GtkDragSource *source)
+{
+ gboolean success = FALSE;
+
+ g_signal_emit (source, signals[DRAG_FAILED], 0, reason, &success);
+ drag_end (source);
+}
+
+static void
+gtk_drag_source_drop_performed_cb (GdkDrag *drag,
+ GtkDragSource *source)
+{
+ if (source->icon_window)
+ gtk_widget_hide (source->icon_window);
+}
+
+/**
+ * gtk_drag_source_drag_begin:
+ * @source: a #GtkDragSource
+ * @widget: the widget where the drag operation originates
+ * @device: the device that is driving the drag operation
+ * @x: start point X coordinate
+ * @y: start point Y xoordinate
+ *
+ * Starts a DND operation with @source.
+ *
+ * The start point coordinates are relative to @widget.
+ *
+ * GTK keeps a reference on @source for the duration of
+ * the DND operation, so it is safe to unref @source
+ * after this call.
+ */
+void
+gtk_drag_source_drag_begin (GtkDragSource *source,
+ GtkWidget *widget,
+ GdkDevice *device,
+ int x,
+ int y)
+{
+ GtkNative *native;
+ GdkSurface *surface;
+ double px, py;
+ int dx, dy;
+ GtkWidget *icon;
+
+ g_return_if_fail (GTK_IS_DRAG_SOURCE (source));
+ g_return_if_fail (GTK_IS_WIDGET (widget));
+ g_return_if_fail (GDK_IS_DEVICE (device));
+ g_return_if_fail (source->content != NULL);
+ g_return_if_fail (source->actions != 0);
+
+ if (gdk_device_get_source (device) == GDK_SOURCE_KEYBOARD)
+ device = gdk_device_get_associated_device (device);
+
+ native = gtk_widget_get_native (widget);
+ surface = gtk_native_get_surface (native);
+
+ gtk_widget_translate_coordinates (widget, GTK_WIDGET (native), x, y, &x, &y);
+ gdk_surface_get_device_position (surface, device, &px, &py, NULL);
+
+ dx = round (px) - x;
+ dy = round (py) - y;
+
+ source->drag = gdk_drag_begin (surface, device, source->content, source->actions, dx, dy);
+ if (source->drag == NULL)
+ {
+ g_print ("no drag :(\n");
+ return;
+ }
+
+ g_object_set_data (G_OBJECT (source->drag), I_("gtk-drag-source"), source);
+ source->widget = widget;
+
+ gtk_widget_reset_controllers (widget);
+
+ /* We hold a ref until ::drag-end is emitted */
+ g_object_ref (source);
+
+ g_signal_emit (source, signals[DRAG_BEGIN], 0);
+
+ if (!source->paintable)
+ {
+ GtkIconTheme *theme;
+
+ theme = gtk_icon_theme_get_for_display (gtk_widget_get_display (widget));
+ source->paintable = gtk_icon_theme_load_icon (theme, "text-x-generic", 32, 0, NULL);
+ source->hot_x = 0;
+ source->hot_y = 0;
+ }
+
+ gdk_drag_set_hotspot (source->drag, source->hot_x, source->hot_y);
+ source->icon_window = gtk_drag_icon_new ();
+ g_object_ref_sink (source->icon_window);
+ gtk_drag_icon_set_surface (GTK_DRAG_ICON (source->icon_window),
+ gdk_drag_get_drag_surface (source->drag));
+
+ icon = gtk_picture_new_for_paintable (source->paintable);
+ gtk_picture_set_can_shrink (GTK_PICTURE (icon), FALSE);
+ gtk_drag_icon_set_widget (GTK_DRAG_ICON (source->icon_window), icon);
+
+ gtk_widget_show (source->icon_window);
+
+ g_signal_connect (source->drag, "drop-performed",
+ G_CALLBACK (gtk_drag_source_drop_performed_cb), source);
+ g_signal_connect (source->drag, "dnd-finished",
+ G_CALLBACK (gtk_drag_source_dnd_finished_cb), source);
+ g_signal_connect (source->drag, "cancel",
+ G_CALLBACK (gtk_drag_source_cancel_cb), source);
+}
+
+/**
+ * gtk_drag_source_new:
+ * @content: (nullable): the #GdkContentProvider to use, or %NULL
+ * @actions: the actions to offer
+ *
+ * Creates a new #GtkDragSource object.
+ *
+ * Returns: the new #GtkDragSource
+ */
+GtkDragSource *
+gtk_drag_source_new (GdkContentProvider *content,
+ GdkDragAction actions)
+{
+ return g_object_new (GTK_TYPE_DRAG_SOURCE,
+ "content", content,
+ "actions", actions,
+ NULL);
+}
+
+/**
+ * gtk_drag_source_get_content:
+ * @source: a #GtkDragSource
+ *
+ * Gets the current content provider of a #GtkDragSource.
+ *
+ * Returns: the #GtkContentProvider of @source
+ */
+GdkContentProvider *
+gtk_drag_source_get_content (GtkDragSource *source)
+{
+ g_return_val_if_fail (GTK_IS_DRAG_SOURCE (source), NULL);
+
+ return source->content;
+}
+
+/**
+ * gtk_drag_source_set_content:
+ * @source: a #GtkDragSource
+ * @content: (nullable): a #GtkContntProvider, or %NULL
+ *
+ * Sets a content provider on a #GtkDragSource.
+ *
+ * When the data is requested in the cause of a
+ * DND operation, it will be obtained from the
+ * content provider.
+ */
+void
+gtk_drag_source_set_content (GtkDragSource *source,
+ GdkContentProvider *content)
+{
+ g_return_if_fail (GTK_IS_DRAG_SOURCE (source));
+
+ if (!g_set_object (&source->content, content))
+ return;
+
+ g_object_notify_by_pspec (G_OBJECT (source), properties[PROP_CONTENT]);
+}
+
+/**
+ * gtk_drag_source_get_actions:
+ * @source: a #GtkDragSource
+ *
+ * Gets the actions that are currently set on the #GtkDragSource.
+ *
+ * Returns: the actions set on @source
+ */
+GdkDragAction
+gtk_drag_source_get_actions (GtkDragSource *source)
+{
+ g_return_val_if_fail (GTK_IS_DRAG_SOURCE (source), 0);
+
+ return source->actions;
+}
+
+/**
+ * gtk_drag_source_set_actions:
+ * @source: a #GtkDragSource
+ * @actions: the actions to offer
+ *
+ * Sets the actions on the #GtkDragSource.
+ *
+ * During a DND operation, the actions are offered
+ * to potential drop targets.
+ */
+void
+gtk_drag_source_set_actions (GtkDragSource *source,
+ GdkDragAction actions)
+{
+ g_return_if_fail (GTK_IS_DRAG_SOURCE (source));
+
+ if (source->actions == actions)
+ return;
+
+ source->actions = actions;
+
+ g_object_notify_by_pspec (G_OBJECT (source), properties[PROP_ACTIONS]);
+}
+
+/**
+ * gtk_drag_source_set_icon:
+ * @source: a #GtkDragSource
+ * @paintable: (nullable): the #GtkPaintable to use as icon, or %NULL
+ * @hot_x: the hotspot X coordinate on the icon
+ * @hot_y: the hotspot Y coordinate on the icon
+ *
+ * Sets a paintable to use as icon during DND operations.
+ *
+ * The hotspot coordinates determine the point on the icon
+ * that gets aligned with the hotspot of the cursor.
+ *
+ * If @paintable is %NULL, a default icon is used.
+ */
+void
+gtk_drag_source_set_icon (GtkDragSource *source,
+ GdkPaintable *paintable,
+ int hot_x,
+ int hot_y)
+{
+ g_return_if_fail (GTK_IS_DRAG_SOURCE (source));
+
+ g_set_object (&source->paintable, paintable);
+
+ source->hot_x = hot_x;
+ source->hot_y = hot_y;
+}
+
+static void
+source_gesture_begin (GtkGesture *gesture,
+ GdkEventSequence *sequence,
+ GtkDragSource *source)
+{
+ guint button;
+
+ if (gtk_gesture_single_get_current_sequence (GTK_GESTURE_SINGLE (gesture)))
+ button = 1;
+ else
+ button = gtk_gesture_single_get_current_button (GTK_GESTURE_SINGLE (gesture));
+
+ g_assert (button >= 1);
+
+ if ((source->start_button_mask & (GDK_BUTTON1_MASK << (button - 1))) == 0)
+ gtk_gesture_set_state (gesture, GTK_EVENT_SEQUENCE_DENIED);
+}
+
+static void
+source_gesture_update (GtkGesture *gesture,
+ GdkEventSequence *sequence,
+ GtkDragSource *source)
+
+{
+ gdouble start_x, start_y, offset_x, offset_y;
+ GtkWidget *widget;
+
+ if (!gtk_gesture_is_recognized (gesture))
+ return;
+
+ widget = gtk_event_controller_get_widget (GTK_EVENT_CONTROLLER (gesture));
+
+ gtk_gesture_drag_get_start_point (GTK_GESTURE_DRAG (gesture), &start_x, &start_y);
+ gtk_gesture_drag_get_offset (GTK_GESTURE_DRAG (gesture), &offset_x, &offset_y);
+
+ if (gtk_drag_check_threshold (widget,
+ start_x, start_y,
+ start_x + offset_x, start_y + offset_y))
+ {
+ GdkDevice *device = gtk_gesture_get_device (gesture);
+
+ gtk_drag_source_drag_begin (source, widget, device, start_x, start_y);
+ }
+}
+
+static void
+gesture_removed (gpointer data)
+{
+ GtkDragSource *source = data;
+
+ /* if we get here, the widget we are attached to was destroyed,
+ * and removed our gesture.
+ *
+ * Clean up, and drop the ref we held for being attached.
+ */
+
+ source->gesture = NULL;
+ g_object_unref (source);
+}
+
+/**
+ * gtk_drag_source_attach:
+ * @source: (transfer full): a #GtkDragSource
+ * @widget: the widget to attach @source to
+ * @start_button_mask: mask determining which mouse buttons trigger
+ *
+ * Attaches the @source to a @widget by creating a drag gesture
+ * on @widget that will trigger DND operations with @source.
+ *
+ * The @start_button_mask determines which mouse buttons trigger
+ * a DND operation.
+ *
+ * To undo the effect of this call, use gtk_drag_source_detach().
+ */
+void
+gtk_drag_source_attach (GtkDragSource *source,
+ GtkWidget *widget,
+ GdkModifierType start_button_mask)
+{
+ g_return_if_fail (GTK_IS_DRAG_SOURCE (source));
+ g_return_if_fail (GTK_IS_WIDGET (widget));
+ g_return_if_fail (source->gesture == NULL);
+ g_return_if_fail (start_button_mask != 0);
+ g_return_if_fail ((start_button_mask & ~(GDK_BUTTON1_MASK |
+ GDK_BUTTON2_MASK |
+ GDK_BUTTON3_MASK |
+ GDK_BUTTON4_MASK |
+ GDK_BUTTON5_MASK)) == 0);
+
+ source->gesture = gtk_gesture_drag_new ();
+ gtk_event_controller_set_propagation_phase (GTK_EVENT_CONTROLLER (source->gesture),
+ GTK_PHASE_CAPTURE);
+ gtk_gesture_single_set_button (GTK_GESTURE_SINGLE (source->gesture), 0);
+ g_signal_connect (source->gesture, "begin",
+ G_CALLBACK (source_gesture_begin), source);
+ g_signal_connect (source->gesture, "update",
+ G_CALLBACK (source_gesture_update), source);
+ gtk_widget_add_controller (widget, GTK_EVENT_CONTROLLER (source->gesture));
+
+ source->start_button_mask = start_button_mask;
+
+ g_object_set_data_full (G_OBJECT (source->gesture), "gtk-drag-source",
+ source, gesture_removed);
+}
+
+/**
+ * gtk_drag_source_detach:
+ * @source: a #GtkDragSource
+ *
+ * Undoes the effect of a prior gtk_drag_source_attach() call.
+ */
+void
+gtk_drag_source_detach (GtkDragSource *source)
+{
+ g_return_if_fail (GTK_IS_DRAG_SOURCE (source));
+
+ if (source->gesture)
+ {
+ GtkWidget *widget;
+
+ g_object_ref (source);
+
+ g_object_set_data (G_OBJECT (source->gesture), "gtk-drag-source", NULL);
+ widget = gtk_event_controller_get_widget (GTK_EVENT_CONTROLLER (source->gesture));
+ gtk_widget_remove_controller (widget, GTK_EVENT_CONTROLLER (source->gesture));
+
+ g_object_unref (source);
+ }
+}
+
+/**
+ * gtk_drag_get_source:
+ * @drag: a #GdkDrag
+ *
+ * Obtains the #GtkDragSource from which a #GdkDrag originates.
+ *
+ * This function should rarely be needed. Once case where it can
+ * be used is together with gtk_drop_get_drag(), to determine
+ * whether a 'local' drag is coming from the same widget.
+ *
+ * Returns: (transfer none) (nullable): a #GtkDragSource, or %NULL
+ */
+GtkDragSource *
+gtk_drag_get_source (GdkDrag *drag)
+{
+ gpointer data;
+
+ g_return_val_if_fail (GDK_IS_DRAG (drag), NULL);
+
+ data = g_object_get_data (G_OBJECT (drag), I_("gtk-drag-source"));
+
+ if (data)
+ return GTK_DRAG_SOURCE (data);
+
+ return NULL;
+}
+
+/**
+ * gtk_drag_source_get_origin:
+ * @source: a #GtkDragSource
+ *
+ * Returns the widget that an ongoing drag is started from.
+ *
+ * Returns: (nullable): the origin of the current drag operation, or %NULL
+ */
+GtkWidget *
+gtk_drag_source_get_origin (GtkDragSource *source)
+{
+ g_return_val_if_fail (GTK_IS_DRAG_SOURCE (source), NULL);
+
+ return source->widget;
+}
+
+/**
+ * gtk_drag_source_get_drag:
+ * @source: a #GtkDragSource
+ *
+ * Returns the underlying #GtkDrag object for an ongoing drag.
+ *
+ * Returns: (nullable): the #GdkDrag of the current drag operation, or %NULL
+ */
+GdkDrag *
+gtk_drag_source_get_drag (GtkDragSource *source)
+{
+ g_return_val_if_fail (GTK_IS_DRAG_SOURCE (source), NULL);
+
+ return source->drag;
+}
+
+/**
+ * gtk_drag_source_drag_cancel:
+ * @source: a #GtkDragSource
+ *
+ * Cancels a currently ongoing drag operation.
+ */
+void
+gtk_drag_source_drag_cancel (GtkDragSource *source)
+{
+ g_return_if_fail (GTK_IS_DRAG_SOURCE (source));
+
+ if (source->drag)
+ {
+ gboolean success = FALSE;
+
+ g_signal_emit (source, signals[DRAG_FAILED], 0, GDK_DRAG_CANCEL_ERROR, &success);
+
+ gdk_drag_drop_done (source->drag, success);
+ }
+}
diff --git a/gtk/gtkdragsource.h b/gtk/gtkdragsource.h
index b77f46db74..22f8c31cd8 100644
--- a/gtk/gtkdragsource.h
+++ b/gtk/gtkdragsource.h
@@ -69,6 +69,68 @@ void gtk_drag_source_set_icon_paintable (GtkWidget *widget,
GdkPaintable *paintable);
+#define GTK_TYPE_DRAG_SOURCE (gtk_drag_source_get_type ())
+#define GTK_DRAG_SOURCE(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), GTK_TYPE_DRAG_SOURCE, GtkDragSource))
+#define GTK_DRAG_SOURCE_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), GTK_TYPE_DRAG_SOURCE,
GtkDragSourceClass))
+#define GTK_IS_DRAG_SOURCE(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), GTK_TYPE_DRAG_SOURCE))
+#define GTK_IS_DRAG_SOURCE_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), GTK_TYPE_DRAG_SOURCE))
+#define GTK_DRAG_SOURCE_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), GTK_TYPE_DRAG_SOURCE,
GtkDragSourceClass))
+
+typedef struct _GtkDragSource GtkDragSource;
+typedef struct _GtkDragSourceClass GtkDragSourceClass;
+
+GDK_AVAILABLE_IN_ALL
+GType gtk_drag_source_get_type (void) G_GNUC_CONST;
+
+GDK_AVAILABLE_IN_ALL
+GtkDragSource *gtk_drag_source_new (GdkContentProvider *content,
+ GdkDragAction actions);
+
+GDK_AVAILABLE_IN_ALL
+void gtk_drag_source_set_content (GtkDragSource *source,
+ GdkContentProvider *content);
+GDK_AVAILABLE_IN_ALL
+GdkContentProvider *gtk_drag_source_get_content (GtkDragSource *source);
+
+GDK_AVAILABLE_IN_ALL
+void gtk_drag_source_set_actions (GtkDragSource *source,
+ GdkDragAction actions);
+GDK_AVAILABLE_IN_ALL
+GdkDragAction gtk_drag_source_get_actions (GtkDragSource *source);
+
+GDK_AVAILABLE_IN_ALL
+void gtk_drag_source_set_icon (GtkDragSource *source,
+ GdkPaintable *paintable,
+ int hot_x,
+ int hot_y);
+GDK_AVAILABLE_IN_ALL
+void gtk_drag_source_drag_begin (GtkDragSource *source,
+ GtkWidget *widget,
+ GdkDevice *device,
+ int x,
+ int y);
+
+GDK_AVAILABLE_IN_ALL
+void gtk_drag_source_drag_cancel (GtkDragSource *sourcei);
+
+GDK_AVAILABLE_IN_ALL
+GtkDragSource * gtk_drag_get_source (GdkDrag *drag);
+
+GDK_AVAILABLE_IN_ALL
+GtkWidget * gtk_drag_source_get_origin (GtkDragSource *source);
+
+GDK_AVAILABLE_IN_ALL
+GdkDrag * gtk_drag_source_get_drag (GtkDragSource *source);
+
+GDK_AVAILABLE_IN_ALL
+void gtk_drag_source_attach (GtkDragSource *source,
+ GtkWidget *widget,
+ GdkModifierType start_button_mask);
+
+GDK_AVAILABLE_IN_ALL
+void gtk_drag_source_detach (GtkDragSource *source);
+
+
G_END_DECLS
#endif /* __GTK_DRAG_SOURCE_H__ */
[
Date Prev][
Date Next] [
Thread Prev][
Thread Next]
[
Thread Index]
[
Date Index]
[
Author Index]
