/* GTK - The GIMP Toolkit

 * Copyright (C) 1995-1999 Peter Mattis, Spencer Kimball and Josh MacDonald

 *

 * This library is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Lesser General Public

 * License as published by the Free Software Foundation; either

 * version 2 of the License, or (at your option) any later version.

 *

 * This library is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.	 See the GNU

 * Lesser General Public License for more details.

 *

 * You should have received a copy of the GNU Lesser General Public

 * License along with this library; if not, write to the

 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,

 * Boston, MA 02111-1307, USA.

 */

/*

 * Modified by the GTK+ Team and others 1997-2000.  See the AUTHORS

 * file for a list of people on the GTK+ Team.  See the ChangeLog

 * files for a list of changes.  These files are distributed with

 * GTK+ at ftp://ftp.gtk.org/pub/gtk/. 

 */

#include "config.h"

#include <stdlib.h>

#include <string.h>

#include "gdkconfig.h"

#include "gdk/gdkkeysyms.h"

#include "gtkdnd.h"

#include "gtkiconfactory.h"

#include "gtkicontheme.h"

#include "gtkimage.h"

#include "gtkinvisible.h"

#include "gtkmain.h"

#include "gtkplug.h"

#include "gtkstock.h"

#include "gtkwindow.h"

#include "gtkintl.h"

#include "gtkquartz.h"

#include "gtkalias.h"

#include "gdk/quartz/gdkquartz.h"

typedef struct _GtkDragSourceSite GtkDragSourceSite;

typedef struct _GtkDragSourceInfo GtkDragSourceInfo;

typedef struct _GtkDragDestSite GtkDragDestSite;

typedef struct _GtkDragDestInfo GtkDragDestInfo;

typedef struct _GtkDragFindData GtkDragFindData;

static void     gtk_drag_find_widget            (GtkWidget        *widget,

						 GtkDragFindData  *data);

static void     gtk_drag_dest_site_destroy      (gpointer          data);

static void     gtk_drag_dest_leave             (GtkWidget        *widget,

						 GdkDragContext   *context,

						 guint             time);

static GtkDragDestInfo *gtk_drag_get_dest_info  (GdkDragContext   *context,

						 gboolean          create);

static void gtk_drag_source_site_destroy        (gpointer           data);

static GtkDragSourceInfo *gtk_drag_get_source_info (GdkDragContext *context,

						    gboolean        create);

extern GdkDragContext *gdk_quartz_drag_source_context (); /* gdk/quartz/gdkdnd-quartz.c */

struct _GtkDragSourceSite 

{

  GdkModifierType    start_button_mask;

  GtkTargetList     *target_list;        /* Targets for drag data */

  GdkDragAction      actions;            /* Possible actions */

  /* Drag icon */

  GtkImageType icon_type;

  union

  {

    GtkImagePixmapData pixmap;

    GtkImagePixbufData pixbuf;

    GtkImageStockData stock;

    GtkImageIconNameData name;

  } icon_data;

  GdkBitmap *icon_mask;

  GdkColormap       *colormap;	         /* Colormap for drag icon */

  /* Stored button press information to detect drag beginning */

  gint               state;

  gint               x, y;

};

struct _GtkDragSourceInfo 

{

  GtkWidget         *source_widget;

  GtkWidget         *widget;

  GtkTargetList     *target_list; /* Targets for drag data */

  GdkDragAction      possible_actions; /* Actions allowed by source */

  GdkDragContext    *context;	  /* drag context */

  NSEvent           *nsevent;     /* what started it */

  gint hot_x, hot_y;		  /* Hot spot for drag */

  GdkPixbuf         *icon_pixbuf;

  gboolean           success;

  gboolean           delete;

};

struct _GtkDragDestSite 

{

  GtkDestDefaults    flags;

  GtkTargetList     *target_list;

  GdkDragAction      actions;

  guint              have_drag : 1;

  guint              track_motion : 1;

};

struct _GtkDragDestInfo 

{

  GtkWidget         *widget;	   /* Widget in which drag is in */

  GdkDragContext    *context;	   /* Drag context */

  guint              dropped : 1;     /* Set after we receive a drop */

  gint               drop_x, drop_y; /* Position of drop */

};

struct _GtkDragFindData 

{

  gint x;

  gint y;

  GdkDragContext *context;

  GtkDragDestInfo *info;

  gboolean found;

  gboolean toplevel;

  gboolean (*callback) (GtkWidget *widget, GdkDragContext *context,

			gint x, gint y, guint32 time);

  guint32 time;

};

@interface GtkDragSourceOwner : NSObject {

  GtkDragSourceInfo *info;

}

@end

@implementation GtkDragSourceOwner

-(void)pasteboard:(NSPasteboard *)sender provideDataForType:(NSString *)type

{

  guint target_info;

  GtkSelectionData selection_data;

  selection_data.selection = GDK_NONE;

  selection_data.data = NULL;

  selection_data.length = -1;

  selection_data.target = gdk_quartz_pasteboard_type_to_atom_libgtk_only (type);

  selection_data.display = gdk_display_get_default ();

  if (gtk_target_list_find (info->target_list, 

			    selection_data.target, 

			    &target_info)) 

    {

      g_signal_emit_by_name (info->widget, "drag-data-get",

			     info->context,

			     &selection_data,

			     target_info,

			     time);

      if (selection_data.length >= 0)

        _gtk_quartz_set_selection_data_for_pasteboard (sender, &selection_data);

      g_free (selection_data.data);

    }

}

- (id)initWithInfo:(GtkDragSourceInfo *)anInfo

{

  self = [super init];

  if (self) 

    {

      info = anInfo;

    }

  return self;

}

@end

void 

gtk_drag_get_data (GtkWidget      *widget,

		   GdkDragContext *context,

		   GdkAtom         target,

		   guint32         time)

{

  id <NSDraggingInfo> dragging_info;

  NSPasteboard *pasteboard;

  GtkSelectionData *selection_data;

  GtkDragDestInfo *info;

  GtkDragDestSite *site;

  dragging_info = gdk_quartz_drag_context_get_dragging_info_libgtk_only (context);

  pasteboard = [dragging_info draggingPasteboard];

  info = gtk_drag_get_dest_info (context, FALSE);

  site = g_object_get_data (G_OBJECT (widget), "gtk-drag-dest");

  selection_data = _gtk_quartz_get_selection_data_from_pasteboard (pasteboard,

								   target, 0);

  if (site && site->target_list)

    {

      guint target_info;

      if (gtk_target_list_find (site->target_list, 

				selection_data->target,

				&target_info))

	{

	  if (!(site->flags & GTK_DEST_DEFAULT_DROP) ||

	      selection_data->length >= 0)

	    g_signal_emit_by_name (widget,

				   "drag-data-received",

				   context, info->drop_x, info->drop_y,

				   selection_data,

				   target_info, time);

	}

    }

  else

    {

      g_signal_emit_by_name (widget,

			     "drag-data-received",

			     context, info->drop_x, info->drop_y,

			     selection_data,

			     0, time);

    }

  if (site && site->flags & GTK_DEST_DEFAULT_DROP)

    {

      gtk_drag_finish (context, 

		       (selection_data->length >= 0),

		       (context->action == GDK_ACTION_MOVE),

		       time);

    }      

}

void 

gtk_drag_finish (GdkDragContext *context,

		 gboolean        success,

		 gboolean        del,

		 guint32         time)

{

  GtkDragSourceInfo *info;

  GdkDragContext* source_context = gdk_quartz_drag_source_context ();

  if (source_context)

    {

      info = gtk_drag_get_source_info (source_context, FALSE);

      if (info)

        {

          info->success = success;

          info->delete = del;

        }

    }

}

static void

gtk_drag_dest_info_destroy (gpointer data)

{

  GtkDragDestInfo *info = data;

  g_free (info);

}

static GtkDragDestInfo *

gtk_drag_get_dest_info (GdkDragContext *context,

			gboolean        create)

{

  GtkDragDestInfo *info;

  static GQuark info_quark = 0;

  if (!info_quark)

    info_quark = g_quark_from_static_string ("gtk-dest-info");

  info = g_object_get_qdata (G_OBJECT (context), info_quark);

  if (!info && create)

    {

      info = g_new (GtkDragDestInfo, 1);

      info->widget = NULL;

      info->context = context;

      info->dropped = FALSE;

      g_object_set_qdata_full (G_OBJECT (context), info_quark,

			       info, gtk_drag_dest_info_destroy);

    }

  return info;

}

static GQuark dest_info_quark = 0;

static GtkDragSourceInfo *

gtk_drag_get_source_info (GdkDragContext *context,

			  gboolean        create)

{

  GtkDragSourceInfo *info;

  if (!dest_info_quark)

    dest_info_quark = g_quark_from_static_string ("gtk-source-info");

  info = g_object_get_qdata (G_OBJECT (context), dest_info_quark);

  if (!info && create)

    {

      info = g_new0 (GtkDragSourceInfo, 1);

      info->context = context;

      g_object_set_qdata (G_OBJECT (context), dest_info_quark, info);

    }

  return info;

}

static void

gtk_drag_clear_source_info (GdkDragContext *context)

{

  g_object_set_qdata (G_OBJECT (context), dest_info_quark, NULL);

}

GtkWidget *

gtk_drag_get_source_widget (GdkDragContext *context)

{

  GtkDragSourceInfo *info;

  GdkDragContext* real_source_context = gdk_quartz_drag_source_context();

  if (!real_source_context)

    return NULL;

  info = gtk_drag_get_source_info (real_source_context, FALSE);

  if (!info)

     return NULL;

  return info->source_widget;

}

/*************************************************************

 * gtk_drag_highlight_expose:

 *     Callback for expose_event for highlighted widgets.

 *   arguments:

 *     widget:

 *     event:

 *     data:

 *   results:

 *************************************************************/

static gboolean

gtk_drag_highlight_expose (GtkWidget      *widget,

			   GdkEventExpose *event,

			   gpointer        data)

{

  gint x, y, width, height;

  if (gtk_widget_is_drawable (widget))

    {

      cairo_t *cr;

      if (!gtk_widget_get_has_window (widget))

	{

	  x = widget->allocation.x;

	  y = widget->allocation.y;

	  width = widget->allocation.width;

	  height = widget->allocation.height;

	}

      else

	{

	  x = 0;

	  y = 0;

	  width = gdk_window_get_width (widget->window);

	  height = gdk_window_get_height (widget->window);

	}

      gtk_paint_shadow (widget->style, widget->window,

		        GTK_STATE_NORMAL, GTK_SHADOW_OUT,

		        NULL, widget, "dnd",

			x, y, width, height);

      cr = gdk_cairo_create (widget->window);

      cairo_set_source_rgb (cr, 0.0, 0.0, 0.0); /* black */

      cairo_set_line_width (cr, 1.0);

      cairo_rectangle (cr,

		       x + 0.5, y + 0.5,

		       width - 1, height - 1);

      cairo_stroke (cr);

      cairo_destroy (cr);

    }

  return FALSE;

}

/*************************************************************

 * gtk_drag_highlight:

 *     Highlight the given widget in the default manner.

 *   arguments:

 *     widget:

 *   results:

 *************************************************************/

void 

gtk_drag_highlight (GtkWidget  *widget)

{

  g_return_if_fail (GTK_IS_WIDGET (widget));

  g_signal_connect_after (widget, "expose-event",

			  G_CALLBACK (gtk_drag_highlight_expose),

			  NULL);

  gtk_widget_queue_draw (widget);

}

/*************************************************************

 * gtk_drag_unhighlight:

 *     Refresh the given widget to remove the highlight.

 *   arguments:

 *     widget:

 *   results:

 *************************************************************/

void 

gtk_drag_unhighlight (GtkWidget *widget)

{

  g_return_if_fail (GTK_IS_WIDGET (widget));

  g_signal_handlers_disconnect_by_func (widget,

					gtk_drag_highlight_expose,

					NULL);

  gtk_widget_queue_draw (widget);

}

static NSWindow *

get_toplevel_nswindow (GtkWidget *widget)

{

  GtkWidget *toplevel = gtk_widget_get_toplevel (widget);

  if (gtk_widget_is_toplevel (toplevel) && toplevel->window)

    return [gdk_quartz_window_get_nsview (toplevel->window) window];

  else

    return NULL;

}

static void

register_types (GtkWidget *widget, GtkDragDestSite *site)

{

  if (site->target_list)

    {

      NSWindow *nswindow = get_toplevel_nswindow (widget);

      NSSet *types;

      NSAutoreleasePool *pool;

      if (!nswindow)

	return;

      pool = [[NSAutoreleasePool alloc] init];

      types = _gtk_quartz_target_list_to_pasteboard_types (site->target_list);

      [nswindow registerForDraggedTypes:[types allObjects]];

      [types release];

      [pool release];

    }

}

static void

gtk_drag_dest_realized (GtkWidget *widget, 

			gpointer   user_data)

{

  GtkDragDestSite *site = user_data;

  register_types (widget, site);

}

static void

gtk_drag_dest_hierarchy_changed (GtkWidget *widget,

				 GtkWidget *previous_toplevel,

				 gpointer   user_data)

{

  GtkDragDestSite *site = user_data;

  register_types (widget, site);

}

static void

gtk_drag_dest_site_destroy (gpointer data)

{

  GtkDragDestSite *site = data;

  if (site->target_list)

    gtk_target_list_unref (site->target_list);

  g_free (site);

}

void 

gtk_drag_dest_set (GtkWidget            *widget,

		   GtkDestDefaults       flags,

		   const GtkTargetEntry *targets,

		   gint                  n_targets,

		   GdkDragAction         actions)

{

  GtkDragDestSite *old_site, *site;

  g_return_if_fail (GTK_IS_WIDGET (widget));

  old_site = g_object_get_data (G_OBJECT (widget), "gtk-drag-dest");

  site = g_new (GtkDragDestSite, 1);

  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;

  if (old_site)

    site->track_motion = old_site->track_motion;

  else

    site->track_motion = FALSE;

  gtk_drag_dest_unset (widget);

  if (gtk_widget_get_realized (widget))

    gtk_drag_dest_realized (widget, site);

  g_signal_connect (widget, "realize",

		    G_CALLBACK (gtk_drag_dest_realized), site);

  g_signal_connect (widget, "hierarchy-changed",

		    G_CALLBACK (gtk_drag_dest_hierarchy_changed), site);

  g_object_set_data_full (G_OBJECT (widget), I_("gtk-drag-dest"),

			  site, gtk_drag_dest_site_destroy);

}

void 

gtk_drag_dest_set_proxy (GtkWidget      *widget,

			 GdkWindow      *proxy_window,

			 GdkDragProtocol protocol,

			 gboolean        use_coordinates)

{

  g_warning ("gtk_drag_dest_set_proxy is not supported on Mac OS X.");

}

void 

gtk_drag_dest_unset (GtkWidget *widget)

{

  GtkDragDestSite *old_site;

  g_return_if_fail (GTK_IS_WIDGET (widget));

  old_site = g_object_get_data (G_OBJECT (widget), "gtk-drag-dest");

  if (old_site)

    {

      g_signal_handlers_disconnect_by_func (widget,

                                            gtk_drag_dest_realized,

                                            old_site);

      g_signal_handlers_disconnect_by_func (widget,

                                            gtk_drag_dest_hierarchy_changed,

                                            old_site);

    }

  g_object_set_data (G_OBJECT (widget), I_("gtk-drag-dest"), NULL);

}

GtkTargetList*

gtk_drag_dest_get_target_list (GtkWidget *widget)

{

  GtkDragDestSite *site;

  g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL);

  site = g_object_get_data (G_OBJECT (widget), "gtk-drag-dest");

  return site ? site->target_list : NULL;  

}

void

gtk_drag_dest_set_target_list (GtkWidget      *widget,

                               GtkTargetList  *target_list)

{

  GtkDragDestSite *site;

  g_return_if_fail (GTK_IS_WIDGET (widget));

  site = g_object_get_data (G_OBJECT (widget), "gtk-drag-dest");

  if (!site)

    {

      g_warning ("Can't set a target list on a widget until you've called gtk_drag_dest_set() "

                 "to make the widget into a drag destination");

      return;

    }

  if (target_list)

    gtk_target_list_ref (target_list);

  if (site->target_list)

    gtk_target_list_unref (site->target_list);

  site->target_list = target_list;

  register_types (widget, site);

}

void

gtk_drag_dest_add_text_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_text_targets (target_list, 0);

  gtk_drag_dest_set_target_list (widget, target_list);

  gtk_target_list_unref (target_list);

}

void

gtk_drag_dest_add_image_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_image_targets (target_list, 0, FALSE);

  gtk_drag_dest_set_target_list (widget, target_list);

  gtk_target_list_unref (target_list);

}

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);

}

static void

prepend_and_ref_widget (GtkWidget *widget,

			gpointer   data)

{

  GSList **slist_p = data;

  *slist_p = g_slist_prepend (*slist_p, g_object_ref (widget));

}

static void

gtk_drag_find_widget (GtkWidget       *widget,

		      GtkDragFindData *data)

{

  GtkAllocation new_allocation;

  gint allocation_to_window_x = 0;

  gint allocation_to_window_y = 0;

  gint x_offset = 0;

  gint y_offset = 0;

  if (data->found || !gtk_widget_get_mapped (widget) || !gtk_widget_get_sensitive (widget))

    return;

  /* Note that in the following code, we only count the

   * position as being inside a WINDOW widget if it is inside

   * widget->window; points that are outside of widget->window

   * but within the allocation are not counted. This is consistent

   * with the way we highlight drag targets.

   *

   * data->x,y are relative to widget->parent->window (if

   * widget is not a toplevel, widget->window otherwise).

   * We compute the allocation of widget in the same coordinates,

   * clipping to widget->window, and all intermediate

   * windows. If data->x,y is inside that, then we translate

   * our coordinates to be relative to widget->window and

   * recurse.

   */  

  new_allocation = widget->allocation;

  if (widget->parent)

    {

      gint tx, ty;

      GdkWindow *window = widget->window;

      /* Compute the offset from allocation-relative to

       * window-relative coordinates.

       */

      allocation_to_window_x = widget->allocation.x;

      allocation_to_window_y = widget->allocation.y;

      if (gtk_widget_get_has_window (widget))

	{

	  /* The allocation is relative to the parent window for

	   * window widgets, not to widget->window.

	   */

          gdk_window_get_position (window, &tx, &ty;;

          allocation_to_window_x -= tx;

          allocation_to_window_y -= ty;

	}

      new_allocation.x = 0 + allocation_to_window_x;

      new_allocation.y = 0 + allocation_to_window_y;

      while (window && window != widget->parent->window)

	{

	  GdkRectangle window_rect = { 0, 0, 0, 0 };

	  window_rect.width = gdk_window_get_width (window);

	  window_rect.height = gdk_window_get_height (window);

	  gdk_rectangle_intersect (&new_allocation, &window_rect, &new_allocation);

	  gdk_window_get_position (window, &tx, &ty;;

	  new_allocation.x += tx;

	  x_offset += tx;

	  new_allocation.y += ty;

	  y_offset += ty;

	  window = gdk_window_get_parent (window);

	}

      if (!window)		/* Window and widget heirarchies didn't match. */

	return;

    }

  if (data->toplevel ||

      ((data->x >= new_allocation.x) && (data->y >= new_allocation.y) &&

       (data->x < new_allocation.x + new_allocation.width) && 

       (data->y < new_allocation.y + new_allocation.height)))

    {

      /* First, check if the drag is in a valid drop site in

       * one of our children 

       */

      if (GTK_IS_CONTAINER (widget))

	{

	  GtkDragFindData new_data = *data;

	  GSList *children = NULL;

	  GSList *tmp_list;

	  new_data.x -= x_offset;

	  new_data.y -= y_offset;

	  new_data.found = FALSE;

	  new_data.toplevel = FALSE;

	  /* need to reference children temporarily in case the

	   * ::drag-motion/::drag-drop callbacks change the widget hierarchy.

	   */

	  gtk_container_forall (GTK_CONTAINER (widget), prepend_and_ref_widget, &children);

	  for (tmp_list = children; tmp_list; tmp_list = tmp_list->next)

	    {

	      if (!new_data.found && gtk_widget_is_drawable (tmp_list->data))

		gtk_drag_find_widget (tmp_list->data, &new_data);

	      g_object_unref (tmp_list->data);

	    }

	  g_slist_free (children);

	  data->found = new_data.found;

	}

      /* If not, and this widget is registered as a drop site, check to

       * emit "drag-motion" to check if we are actually in

       * a drop site.

       */

      if (!data->found &&

	  g_object_get_data (G_OBJECT (widget), "gtk-drag-dest"))

	{

	  data->found = data->callback (widget,

					data->context,

					data->x - x_offset - allocation_to_window_x,

					data->y - y_offset - allocation_to_window_y,

					data->time);

	  /* If so, send a "drag-leave" to the last widget */

	  if (data->found)

	    {

	      if (data->info->widget && data->info->widget != widget)

		{

		  gtk_drag_dest_leave (data->info->widget, data->context, data->time);

		}

	      data->info->widget = widget;

	    }

	}

    }

}

static void  

gtk_drag_dest_leave (GtkWidget      *widget,

		     GdkDragContext *context,

		     guint           time)

{

  GtkDragDestSite *site;

  site = g_object_get_data (G_OBJECT (widget), "gtk-drag-dest");

  g_return_if_fail (site != NULL);

  if ((site->flags & GTK_DEST_DEFAULT_HIGHLIGHT) && site->have_drag)

    gtk_drag_unhighlight (widget);

  if (!(site->flags & GTK_DEST_DEFAULT_MOTION) || site->have_drag ||

      site->track_motion)

    g_signal_emit_by_name (widget, "drag-leave", context, time);

  site->have_drag = FALSE;

}

static gboolean

gtk_drag_dest_motion (GtkWidget	     *widget,

		      GdkDragContext *context,

		      gint            x,

		      gint            y,

		      guint           time)

{

  GtkDragDestSite *site;

  GdkDragAction action = 0;

  gboolean retval;

  site = g_object_get_data (G_OBJECT (widget), "gtk-drag-dest");

  g_return_val_if_fail (site != NULL, FALSE);

  if (site->track_motion || site->flags & GTK_DEST_DEFAULT_MOTION)

    {

      if (context->suggested_action & site->actions)

	action = context->suggested_action;

      if (action && gtk_drag_dest_find_target (widget, context, NULL))

	{

	  if (!site->have_drag)

	    {

	      site->have_drag = TRUE;

	      if (site->flags & GTK_DEST_DEFAULT_HIGHLIGHT)

		gtk_drag_highlight (widget);

	    }

	  gdk_drag_status (context, action, time);

	}

      else

	{

	  gdk_drag_status (context, 0, time);

	  if (!site->track_motion)

	    return TRUE;

	}

    }

  g_signal_emit_by_name (widget, "drag-motion",

			 context, x, y, time, &retval);

  return (site->flags & GTK_DEST_DEFAULT_MOTION) ? TRUE : retval;

}

static gboolean

gtk_drag_dest_drop (GtkWidget	     *widget,

		    GdkDragContext   *context,

		    gint              x,

		    gint              y,

		    guint             time)

{

  GtkDragDestSite *site;

  GtkDragDestInfo *info;

  gboolean retval;

  site = g_object_get_data (G_OBJECT (widget), "gtk-drag-dest");

  g_return_val_if_fail (site != NULL, FALSE);

  info = gtk_drag_get_dest_info (context, FALSE);

  g_return_val_if_fail (info != NULL, FALSE);

  info->drop_x = x;

  info->drop_y = y;