static void
gtk_gesture_long_press_update (GtkGesture *gesture,
GdkEventSequence *sequence)
{
GtkGestureLongPressPrivate *priv;
GtkWidget *widget;
gdouble x, y;
widget = gtk_event_controller_get_widget (GTK_EVENT_CONTROLLER (gesture));
priv = gtk_gesture_long_press_get_instance_private (GTK_GESTURE_LONG_PRESS (gesture));
gtk_gesture_get_point (gesture, sequence, &x, &y);
if (gtk_drag_check_threshold (widget, priv->initial_x, priv->initial_y, x, y))
{
if (priv->timeout_id)
{
g_source_remove (priv->timeout_id);
priv->timeout_id = 0;
g_signal_emit (gesture, signals[CANCELLED], 0);
}
priv->cancelled = TRUE;
_gtk_gesture_check (gesture);
}
}
static VALUE
rg_m_threshold_p(G_GNUC_UNUSED VALUE self, VALUE widget, VALUE start_x, VALUE start_y, VALUE current_x, VALUE current_y)
{
return CBOOL2RVAL(gtk_drag_check_threshold(RVAL2WIDGET(widget),
NUM2INT(start_x), NUM2INT(start_y),
NUM2INT(current_x), NUM2INT(current_y)));
}
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;
}
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;
}
static gboolean
etfci_maybe_start_drag (ETableFieldChooserItem *etfci,
gint x,
gint y)
{
GnomeCanvasItem *item;
if (!etfci->maybe_drag)
return FALSE;
item = GNOME_CANVAS_ITEM (etfci);
return gtk_drag_check_threshold (GTK_WIDGET (item->canvas), etfci->click_x, etfci->click_y, x, y);
}
static gboolean
motion_notify_cb (CeditNotebook *notebook,
GdkEventMotion *event,
gpointer data)
{
CeditNotebook *dest;
gint page_num;
gint result;
if (notebook->priv->drag_in_progress == FALSE)
{
if (notebook->priv->tab_drag_and_drop_enabled == FALSE)
return FALSE;
if (gtk_drag_check_threshold (GTK_WIDGET (notebook),
notebook->priv->x_start,
notebook->priv->y_start,
event->x_root,
event->y_root))
{
drag_start (notebook, event->time);
return TRUE;
}
return FALSE;
}
result = find_notebook_and_tab_at_pos ((gint)event->x_root,
(gint)event->y_root,
&dest,
&page_num);
if (result != NOT_IN_APP_WINDOWS)
{
if (dest != notebook)
{
move_current_tab_to_another_notebook (notebook,
dest,
event,
page_num);
}
else
{
g_return_val_if_fail (page_num >= -1, FALSE);
move_current_tab (notebook, page_num);
}
}
return FALSE;
}
static gboolean
gdl_dock_tablabel_motion_event (GtkWidget *widget,
GdkEventMotion *event)
{
GdlDockTablabel *tablabel;
GtkAllocation widget_allocation;
gboolean event_handled;
g_return_val_if_fail (widget != NULL, FALSE);
g_return_val_if_fail (GDL_IS_DOCK_TABLABEL (widget), FALSE);
g_return_val_if_fail (event != NULL, FALSE);
tablabel = GDL_DOCK_TABLABEL (widget);
event_handled = FALSE;
if (event->window != tablabel->event_window)
return FALSE;
if (tablabel->pre_drag) {
if (gtk_drag_check_threshold (widget,
tablabel->drag_start_event.x,
tablabel->drag_start_event.y,
event->x,
event->y)) {
tablabel->pre_drag = FALSE;
g_signal_emit (widget,
dock_tablabel_signals [BUTTON_PRESSED_HANDLE],
0,
&tablabel->drag_start_event);
event_handled = TRUE;
}
}
if (!event_handled) {
/* propagate the event to the parent's gdkwindow */
GdkEventMotion e;
e = *event;
e.window = gtk_widget_get_parent_window (widget);
gtk_widget_get_allocation (widget, &widget_allocation);
e.x += widget_allocation.x;
e.y += widget_allocation.y;
gdk_event_put ((GdkEvent *) &e);
};
return event_handled;
}
static gboolean
gth_image_rotator_motion_notify (GthImageViewerTool *base,
GdkEventMotion *event)
{
GthImageRotator *self = GTH_IMAGE_ROTATOR (base);
if (! self->priv->dragging
&& gtk_drag_check_threshold (GTK_WIDGET (self->priv->viewer),
self->priv->drag_p1.x,
self->priv->drag_p1.y,
self->priv->drag_p2.x,
self->priv->drag_p2.y))
{
GdkCursor *cursor;
self->priv->angle_before_dragging = self->priv->angle;
self->priv->dragging = TRUE;
cursor = gdk_cursor_new_from_name (gtk_widget_get_display (GTK_WIDGET (self->priv->viewer)), "grabbing");
gth_image_viewer_set_cursor (self->priv->viewer, cursor);
if (cursor != NULL)
g_object_unref (cursor);
}
if (self->priv->dragging) {
GdkPoint center;
double angle1;
double angle2;
double angle;
self->priv->drag_p2.x = event->x;
self->priv->drag_p2.y = event->y;
center.x = self->priv->center.x * self->priv->preview_zoom + self->priv->preview_image_area.x;
center.y = self->priv->center.y * self->priv->preview_zoom + self->priv->preview_image_area.y;
angle1 = get_angle (¢er, &self->priv->drag_p1);
angle2 = get_angle (¢er, &self->priv->drag_p2);
angle = self->priv->angle_before_dragging + (angle2 - angle1);
if (angle < - G_PI)
angle = G_2_PI + angle;
if (angle > + G_PI)
angle = angle - G_2_PI;
g_signal_emit (self, signals[ANGLE_CHANGED], 0, CLAMP (RAD_TO_DEG (angle), -180.0, 180));
}
return FALSE;
}
void GestureController::DragGesture::update(DragGesture* dragGesture, double x, double y, GtkGesture* gesture)
{
GdkEventSequence* sequence = gtk_gesture_single_get_current_sequence(GTK_GESTURE_SINGLE(gesture));
gtk_gesture_set_sequence_state(gesture, sequence, GTK_EVENT_SEQUENCE_CLAIMED);
GtkWidget* widget = gtk_event_controller_get_widget(GTK_EVENT_CONTROLLER(gesture));
if (!dragGesture->m_inDrag && gtk_drag_check_threshold(widget, dragGesture->m_start.x(), dragGesture->m_start.y(), dragGesture->m_start.x() + x, dragGesture->m_start.y() + y)) {
dragGesture->m_inDrag = true;
dragGesture->m_longPressTimeout.cancel();
}
if (dragGesture->m_inDrag)
dragGesture->handleDrag(gtk_gesture_get_last_event(gesture, sequence), x, y);
dragGesture->m_offset.set(x, y);
}
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 );
}
static gboolean
gul_gestures_motion_cb (GtkWidget *widget, GdkEventMotion *e,
GulGestures *as)
{
GulGesturesPrivate *p = as->priv;
if (p->autocancel_timeout)
{
if (gtk_drag_check_threshold (p->widget,
p->start_x, p->start_y,
e->x_root, e->y_root))
{
g_source_remove (p->autocancel_timeout);
p->autocancel_timeout = 0;
}
}
stroke_record (e->x_root, e->y_root);
return TRUE;
}
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;
}
int
clip_GTK_DRAGCHECKTHRESHOLD(ClipMachine * cm)
{
C_widget *cwid = _fetch_cw_arg(cm);
gint start_x = _clip_parni(cm, 2);
gint start_y = _clip_parni(cm, 3);
gint current_x = _clip_parni(cm, 4);
gint current_y = _clip_parni(cm, 5);
CHECKCWID(cwid, GTK_IS_WIDGET);
CHECKARG(2, NUMERIC_t);
CHECKARG(3, NUMERIC_t);
CHECKARG(5, NUMERIC_t);
CHECKARG(4, NUMERIC_t);
_clip_retl(cm, gtk_drag_check_threshold(GTK_WIDGET(cwid->widget),
start_x, start_y, current_x, current_y ));
return 0;
err:
return 1;
}
static void
released_cb (GtkGestureMultiPress *gesture,
gint n_press,
gdouble x,
gdouble y,
GtkIMContextWayland *context)
{
GtkInputHints hints;
if (!global->current)
return;
g_object_get (context, "input-hints", &hints, NULL);
if (n_press == 1 &&
(hints & GTK_INPUT_HINT_INHIBIT_OSK) == 0 &&
!gtk_drag_check_threshold (context->widget,
context->press_x,
context->press_y,
x, y))
{
enable_text_input (GTK_IM_CONTEXT_WAYLAND (context), TRUE);
}
}
static void
gstyle_color_widget_drag_gesture_update (GtkGestureDrag *gesture,
gdouble offset_x,
gdouble offset_y,
GstyleColorWidget *self)
{
GdkDragContext *context;
GdkEventSequence *sequence;
const GdkEvent *event;
gdouble start_x, start_y;
GtkAllocation allocation;
GstylePaletteWidgetDndLockFlags dnd_lock;
GtkWidget *container;
GdkDragAction drag_action;
gint button;
g_assert (GTK_IS_GESTURE (gesture));
g_assert (GSTYLE_IS_COLOR_WIDGET (self));
dnd_lock = get_palette_widget_dnd_lock (self);
if ((dnd_lock & GSTYLE_PALETTE_WIDGET_DND_LOCK_FLAGS_DRAG) != 0)
return;
button = gtk_gesture_single_get_current_button (GTK_GESTURE_SINGLE (gesture));
if (!gtk_drag_check_threshold (GTK_WIDGET (self), 0, 0, offset_x, offset_y) ||
button != GDK_BUTTON_PRIMARY)
return;
gtk_widget_get_allocation (GTK_WIDGET (self), &allocation);
self->dnd_color_widget = gstyle_color_widget_copy (self);
if (self->filter_func != NULL && GSTYLE_IS_COLOR (self->filtered_color))
gstyle_color_widget_set_color (self->dnd_color_widget, self->filtered_color);
self->dnd_window = gtk_window_new (GTK_WINDOW_POPUP);
gtk_widget_set_size_request (self->dnd_window, allocation.width, allocation.height);
gtk_window_set_screen (GTK_WINDOW (self->dnd_window), gtk_widget_get_screen (GTK_WIDGET (self)));
gtk_container_add (GTK_CONTAINER (self->dnd_window), GTK_WIDGET (self->dnd_color_widget));
gtk_widget_show_all (self->dnd_window);
gtk_widget_set_opacity (self->dnd_window, GSTYLE_COLOR_WIDGET_DRAG_ICON_OPACITY);
sequence = gtk_gesture_single_get_current_sequence (GTK_GESTURE_SINGLE (gesture));
gtk_gesture_drag_get_start_point (GTK_GESTURE_DRAG (gesture), &start_x, &start_y);
event = gtk_gesture_get_last_event (GTK_GESTURE (gesture), sequence);
container = gtk_widget_get_ancestor (GTK_WIDGET (self), GSTYLE_TYPE_PALETTE_WIDGET);
if (container != NULL && GSTYLE_IS_PALETTE_WIDGET (container))
drag_action = (GDK_ACTION_MOVE | GDK_ACTION_COPY);
else
drag_action = GDK_ACTION_COPY;
context = gtk_drag_begin_with_coordinates (GTK_WIDGET (self),
self->target_list,
drag_action,
button,
(GdkEvent*)event,
start_x, start_y);
gtk_drag_set_icon_widget (context, self->dnd_window, 0, 0);
}
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));
if (priv_data->motion_notify_handler) {
g_signal_handler_disconnect (widget, priv_data->motion_notify_handler);
priv_data->motion_notify_handler = 0;
}
if (priv_data->button_release_handler) {
g_signal_handler_disconnect (widget, priv_data->button_release_handler);
priv_data->button_release_handler = 0;
}
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))
{
gulong sig;
/* This is to disconnect the default signal handler for treeviews as
* it sometimes gives a warning. The default handler just sets the
* icon which we do as well in our callback so it is fine. */
sig = g_signal_connect (widget,
"drag-begin",
G_CALLBACK (egg_tree_multi_drag_begin),
NULL);
context = gtk_drag_begin (widget,
gtk_drag_source_get_target_list (widget),
di->source_actions,
priv_data->pressed_button,
(GdkEvent*)event);
g_signal_handler_disconnect (widget, sig);
set_context_data (context, path_list);
}
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 (! 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;
}
