Added a modular client-message-filter mechanism, that is used for the DND

Sun Oct 18 18:16:39 1998  Owen Taylor  <otaylor@gtk.org>

	* gdk/gdk.c gdkprivate.h: Added a modular client-message-filter
	mechanism, that is used for the DND messages.

	  Removed all the old DND code.

	* gdk/gdkcolormap.c gdk/gdkcolormap.h: Add a function to
	get the visual of a given colormap.

	* gtk/gtkcolorsel.c: Conversion to new DND, drag
	a color-swatch.

	* gdk/gdk.h gdk/gdkdnd.c: The low-level
	X oriented portions of drag and drop protocols.
	Sending and receiving client messages, and navigating
	window trees.

	* gdk/gdkimage.c: added a gdk_flush() when destroying
	SHM images to hopefully make it more likely that
        X will gracefully handle the segment being destroyed.

	* gdk/gdkprivate.h gtk/gtkdebug.h: Add new
	DND debugging flags.

	* gtk/gtkeditable.[ch]: Updates for the selection handling
	changes.

	* gtk/gtkselection.[ch]: Added GtkTargetList, a
	refcounted data structure for keeping track of lists
	of GdkAtom + information. Removed selection_handler_add
	in favor of a "drag_data_get" signal.

	* gtk/gtkdnd.[ch] gtk/gtk.h: New files - highlevel (event loop
	dependent) parts of the DND protocols, display of drag icons,
	drag-under highlighting, and the "default handlers".

	* gtk/gtkinvisible.[ch]: New widget - InputOnly offscreen
	windows that are used for reliable pointer grabs and
	selection handling in the DND code.

	* gtk/testdnd.c: New test program for new DND. (Old
	DND tests in testgtk still need to be converted.)

	* gtk/testselection.c: Use the new selection API.

	* docs/dnd_internals: Start at describing how
	all the new code works inside.

	* docs/Changes-1.2.txt: New file describing source-incompatible
	changes in GTK+-1.2.

Sat Oct 17 22:50:34 1998  Owen Taylor  <otaylor@gtk.org>

	* gdk/gdkwindow.c (gdk_window_remove_filter): Free
	the right list node.

	* gdk/gdkwindow.c (gdk_window_init): Add gdk_root_parent
	to the XID table so we can receive events on it.

Wed Oct 14 12:57:40 1998  Owen Taylor  <otaylor@redhat.com>

	* gdk/gdk.c gdk/gdk.h (gdk_event_get_time): New function
	to get the timestamp from a generic event.

Fri Oct  9 13:16:04 1998  Owen Taylor  <otaylor@redhat.com>

	* gtk/gtkwidget.c (gtk_widget_add_events): Added function
	that safely adds additional events to a widget's event
	mask, even if the widget has previously been realized.
	(We can do this, but not remove events from the event
	 mask).

Fri Oct  2 17:35:35 1998  Owen Taylor  <otaylor@redhat.com>

	* gdk/gdkproperty.c (gdk_property_get): Allow type == 0,
	for AnyPropertyType.

Fri Oct  2 10:32:21 1998  Owen Taylor  <otaylor@redhat.com>

	* gdk/gdkproperty.c (gdk_atom_intern): Add client-local
	hashing.

Thu Sep 24 20:33:54 1998  Owen Taylor  <otaylor@redhat.com>

	* gdk/gdk.c (gdk_event_send_clientmessage_toall): serial
	isn't a timestamp.

Thu Sep 17 14:23:03 1998  Owen Taylor  <otaylor@redhat.com>

	* gdk/gdk.c (gdk_event_translate): Removed printing
	of unknown window lookup warnings. (Made it
	a GDK_NOTE) - they happen in many circumstances.

15 files changed, 6310 insertions, 2310 deletions

diff --git a/gdk/gdk.c b/gdk/gdk.c
index 867dadef6..ca0d47504 100644
--- a/gdk/gdk.c
+++ b/gdk/gdk.c
@@ -116,13 +116,6 @@ static Bool	 gdk_event_get_type	(Display      *display,
 static void	 gdk_synthesize_click	(GdkEvent     *event, 
 					 gint	       nclicks);
 
-static void	 gdk_dnd_drag_begin	(GdkWindow    *initial_window);
-static void	 gdk_dnd_drag_enter	(Window	       dest);
-static void	 gdk_dnd_drag_leave	(Window	       dest);
-static void	 gdk_dnd_drag_end	(Window	       dest,
-					 GdkPoint      coords);
-static GdkAtom	 gdk_dnd_check_types	(GdkWindow    *window,
-					 XEvent	      *xevent);
 #ifdef DEBUG_DND
 static void	 gdk_print_atom		(GdkAtom       anatom);
 #endif
@@ -163,6 +156,10 @@ static gint   gdk_im_open		(XrmDatabase db,
 static void   gdk_im_close		(void);
 static void   gdk_ic_cleanup		(void);
 
+GdkFilterReturn gdk_wm_protocols_filter (GdkXEvent *xev,
+					 GdkEvent  *event,
+					 gpointer   data);
+
 #endif /* USE_XIM */
 
 /* Private variable declarations
@@ -217,6 +214,8 @@ static GdkWindowPrivate *xgrab_window = NULL;	    /* Window that currently holds
 						     *	x pointer grab
 						     */
 
+static GList *client_filters;	                    /* Filters for client messages */
+
 #ifdef USE_XIM
 static gint xim_using;				/* using XIM Protocol if TRUE */
 static GdkIM xim_im;				/* global IM */
@@ -549,14 +548,6 @@ gdk_init (int	 *argc,
   gdk_wm_window_protocols[1] = gdk_wm_take_focus;
   gdk_selection_property = XInternAtom (gdk_display, "GDK_SELECTION", False);
   
-  gdk_dnd.gdk_XdeEnter = gdk_atom_intern("_XDE_ENTER", FALSE);
-  gdk_dnd.gdk_XdeLeave = gdk_atom_intern("_XDE_LEAVE", FALSE);
-  gdk_dnd.gdk_XdeRequest = gdk_atom_intern("_XDE_REQUEST", FALSE);
-  gdk_dnd.gdk_XdeDataAvailable = gdk_atom_intern("_XDE_DATA_AVAILABLE", FALSE);
-  gdk_dnd.gdk_XdeTypelist = gdk_atom_intern("_XDE_TYPELIST", FALSE);
-  gdk_dnd.c->gdk_cursor_dragdefault = XCreateFontCursor(gdk_display, XC_bogosity);
-  gdk_dnd.c->gdk_cursor_dragok = XCreateFontCursor(gdk_display, XC_heart);
-  
   XGetKeyboardControl (gdk_display, &keyboard_state);
   autorepeat = keyboard_state.global_auto_repeat;
   
@@ -577,6 +568,10 @@ gdk_init (int	 *argc,
   gdk_window_init ();
   gdk_image_init ();
   gdk_input_init ();
+  gdk_dnd_init ();
+
+  gdk_add_client_message_filter (gdk_wm_protocols, 
+				 gdk_wm_protocols_filter, NULL);
   
 #ifdef USE_XIM
   /* initialize XIM Protocol variables */
@@ -928,13 +923,15 @@ gdk_event_copy (GdkEvent *event)
 	gdk_window_ref (event->crossing.subwindow);
       break;
       
-    case GDK_DROP_DATA_AVAIL:
-      new_event->dropdataavailable.data_type = g_strdup (event->dropdataavailable.data_type);
-      new_event->dropdataavailable.data = g_malloc (event->dropdataavailable.data_numbytes);
-      memcpy (new_event->dropdataavailable.data,
-	      event->dropdataavailable.data, 
-	      event->dropdataavailable.data_numbytes);
+    case GDK_DRAG_ENTER:
+    case GDK_DRAG_LEAVE:
+    case GDK_DRAG_MOTION:
+    case GDK_DRAG_STATUS:
+    case GDK_DROP_START:
+    case GDK_DROP_FINISHED:
+      gdk_drag_context_ref (event->dnd.context);
       break;
+
       
     default:
       break;
@@ -983,14 +980,15 @@ gdk_event_free (GdkEvent *event)
 	gdk_window_unref (event->crossing.subwindow);
       break;
       
-    case GDK_DROP_DATA_AVAIL:
-      g_free (event->dropdataavailable.data_type);
-      g_free (event->dropdataavailable.data);
-      break;
-      
-    case GDK_DRAG_REQUEST:
-      g_free (event->dragrequest.data_type);
+    case GDK_DRAG_ENTER:
+    case GDK_DRAG_LEAVE:
+    case GDK_DRAG_MOTION:
+    case GDK_DRAG_STATUS:
+    case GDK_DROP_START:
+    case GDK_DROP_FINISHED:
+      gdk_drag_context_unref (event->dnd.context);
       break;
+
       
     default:
       break;
@@ -1019,6 +1017,60 @@ gdk_event_free (GdkEvent *event)
  *--------------------------------------------------------------
  */
 
+/*
+ *--------------------------------------------------------------
+ * gdk_event_get_time:
+ *    Get the timestamp from an event.
+ *   arguments:
+ *     event:
+ *   results:
+ *    The event's time stamp, if it has one, otherwise
+ *    GDK_CURRENT_TIME.
+ *--------------------------------------------------------------
+ */
+
+guint32
+gdk_event_get_time (GdkEvent *event)
+{
+  if (event)
+    switch (event->type)
+      {
+      case GDK_MOTION_NOTIFY:
+	return event->motion.time;
+      case GDK_BUTTON_PRESS:
+      case GDK_2BUTTON_PRESS:
+      case GDK_3BUTTON_PRESS:
+      case GDK_BUTTON_RELEASE:
+	return event->button.time;
+      case GDK_KEY_PRESS:
+      case GDK_KEY_RELEASE:
+	return event->key.time;
+      case GDK_ENTER_NOTIFY:
+      case GDK_LEAVE_NOTIFY:
+	return event->crossing.time;
+      case GDK_PROPERTY_NOTIFY:
+	return event->property.time;
+      case GDK_SELECTION_CLEAR:
+      case GDK_SELECTION_REQUEST:
+      case GDK_SELECTION_NOTIFY:
+	return event->selection.time;
+      case GDK_PROXIMITY_IN:
+      case GDK_PROXIMITY_OUT:
+	return event->proximity.time;
+      case GDK_DRAG_ENTER:
+      case GDK_DRAG_LEAVE:
+      case GDK_DRAG_MOTION:
+      case GDK_DRAG_STATUS:
+      case GDK_DROP_START:
+      case GDK_DROP_FINISHED:
+	return event->dnd.time;
+      default:			/* use current time */
+	break;
+      }
+  
+  return GDK_CURRENT_TIME;
+}
+
 void
 gdk_set_show_events (int show_events)
 {
@@ -1773,6 +1825,20 @@ gdk_event_apply_filters (XEvent *xevent,
   return GDK_FILTER_CONTINUE;
 }
 
+void 
+gdk_add_client_message_filter (GdkAtom       message_type,
+			       GdkFilterFunc func,
+			       gpointer      data)
+{
+  GdkClientFilter *filter = g_new (GdkClientFilter, 1);
+
+  filter->type = message_type;
+  filter->function = func;
+  filter->data = data;
+  
+  client_filters = g_list_prepend (client_filters, filter);
+}
+
 static gint
 gdk_event_translate (GdkEvent *event,
 		     XEvent   *xevent)
@@ -1793,15 +1859,9 @@ gdk_event_translate (GdkEvent *event,
   
   return_val = FALSE;
   
-  /* We need to play catch-up with the dnd motion events */
-  if(gdk_dnd.drag_really && xevent->type == MotionNotify)
-    while (XCheckTypedEvent(xevent->xany.display,MotionNotify,xevent));
-  
   /* Find the GdkWindow that this event occurred in.
-   * All events occur in some GdkWindow (otherwise, why
-   *  would we be receiving them). It really is an error
-   *  to receive an event for which we cannot find the
-   *  corresponding GdkWindow. We handle events with window=None
+   * 
+   * We handle events with window=None
    *  specially - they are generated by XFree86's XInput under
    *  some circumstances.
    */
@@ -1822,15 +1882,20 @@ gdk_event_translate (GdkEvent *event,
   
   if (window != NULL)
     gdk_window_ref (window);
-  else if (gdk_null_window_warnings)
-    {
-      /* Special purpose programs that
-       * get events for other windows may
-       * want to disable this
-       */
-      g_warning ("xwindow(%#lx) lookup reveals NULL", xevent->xany.window);
-    }
+#ifdef USE_XIM
+  else if (XFilterEvent(xevent, None)) /* for xlib XIM handling */
+    return FALSE;
+#endif
+  else
+    GDK_NOTE (EVENTS, 
+      g_message ("Got event for unknown window: %#lx\n", xevent->xany.window));
+  
+  event->any.window = window;
+  event->any.send_event = xevent->xany.send_event;
   
+  if (window_private && window_private->destroyed)
+    return FALSE;
+
   /* Check for filters for this window */
   
   {
@@ -1845,7 +1910,7 @@ gdk_event_translate (GdkEvent *event,
 	return (result == GDK_FILTER_TRANSLATE) ? TRUE : FALSE;
       }
   }
-  
+
   /* We do a "manual" conversion of the XEvent to a
    *  GdkEvent. The structures are mostly the same so
    *  the conversion is fairly straightforward. We also
@@ -2031,44 +2096,7 @@ gdk_event_translate (GdkEvent *event,
 	  button_number[1] = -1;
 	  button_number[0] = event->button.button;
 	}
-      if(window_private
-	 && window_private->dnd_drag_enabled
-	 && !gdk_dnd.drag_perhaps
-	 && event->button.button == 1
-	 && !gdk_dnd.drag_really)
-	{
-	  gdk_dnd.drag_perhaps = 1;
-	  gdk_dnd.dnd_drag_start.x = xevent->xbutton.x_root;
-	  gdk_dnd.dnd_drag_start.y = xevent->xbutton.y_root;
-	  gdk_dnd.real_sw = window_private;
-	  
-	  if(gdk_dnd.drag_startwindows)
-	    {
-	      g_free(gdk_dnd.drag_startwindows);
-	      gdk_dnd.drag_startwindows = NULL;
-	    }
-	  gdk_dnd.drag_numwindows = gdk_dnd.drag_really = 0;
-	  gdk_dnd.dnd_grabbed = FALSE;
-	  
-	  {
-	    /* Set motion mask for first DnD'd window, since it
-	       will be the one that is actually dragged */
-	    XWindowAttributes dnd_winattr;
-	    XSetWindowAttributes dnd_setwinattr;
-	    
-	    /* We need to get motion events while the button is down, so
-	       we can know whether to really start dragging or not... */
-	    XGetWindowAttributes(gdk_display, (Window)window_private->xwindow,
-				 &dnd_winattr);
-	    
-	    window_private->dnd_drag_savedeventmask = dnd_winattr.your_event_mask;
-	    dnd_setwinattr.event_mask = 
-	      window_private->dnd_drag_eventmask = ButtonMotionMask | ButtonPressMask | ButtonReleaseMask |
-	      EnterWindowMask | LeaveWindowMask | ExposureMask;
-	    XChangeWindowAttributes(gdk_display, window_private->xwindow,
-				    CWEventMask, &dnd_setwinattr);
-	  }
-	}
+
       return_val = window_private && !window_private->destroyed;
       break;
       
@@ -2102,66 +2130,18 @@ gdk_event_translate (GdkEvent *event,
       event->button.source = GDK_SOURCE_MOUSE;
       event->button.deviceid = GDK_CORE_POINTER;
       
-      gdk_dnd.last_drop_time = xevent->xbutton.time;
-      if(gdk_dnd.drag_perhaps)
-	{
-	  {
-	    XSetWindowAttributes attrs;
-	    /* Reset event mask to pre-drag value, assuming event_mask
-	       doesn't change during drag */
-	    attrs.event_mask = gdk_dnd.real_sw->dnd_drag_savedeventmask;
-	    XChangeWindowAttributes(gdk_display, gdk_dnd.real_sw->xwindow,
-				    CWEventMask, &attrs);
-	  }
-	  
-	  if (gdk_dnd.dnd_grabbed) 
-	    {
-	      gdk_dnd_display_drag_cursor(-2,
-					  -2,
-					  FALSE, TRUE);
-	      XUngrabPointer(gdk_display, CurrentTime);
-	      gdk_dnd.dnd_grabbed = FALSE;
-	    }
-	  
-	  if(gdk_dnd.drag_really)
-	    {
-	      GdkPoint foo;
-	      foo.x = xevent->xbutton.x_root;
-	      foo.y = xevent->xbutton.y_root;
-	      
-	      if(gdk_dnd.dnd_drag_target != None)
-		gdk_dnd_drag_end(gdk_dnd.dnd_drag_target, foo);
-	      gdk_dnd.drag_really = 0;
-	      
-	      gdk_dnd.drag_numwindows = 0;
-	      if(gdk_dnd.drag_startwindows)
-		{
-		  g_free(gdk_dnd.drag_startwindows);
-		  gdk_dnd.drag_startwindows = NULL;
-		}
-	      
-	      gdk_dnd.real_sw = NULL;
-	    }
-	  
-	  gdk_dnd.drag_perhaps = 0;
-	  gdk_dnd.dnd_drag_start.x = gdk_dnd.dnd_drag_start.y = 0;
-	  gdk_dnd.dnd_drag_dropzone.x = gdk_dnd.dnd_drag_dropzone.y = 0;
-	  gdk_dnd.dnd_drag_dropzone.width = gdk_dnd.dnd_drag_dropzone.height = 0;
-	  gdk_dnd.dnd_drag_curwin = None;
-	  return_val = window_private?TRUE:FALSE;
-	} else
-	  return_val = window_private && !window_private->destroyed;
+      return_val = window_private && !window_private->destroyed;
+
       break;
       
     case MotionNotify:
       /* Print debugging info.
        */
       GDK_NOTE (EVENTS,
-		g_message ("motion notify:\t\twindow: %ld  x,y: %d %d  hint: %s d:%d r%d",
+		g_message ("motion notify:\t\twindow: %ld  x,y: %d %d  hint: %s", 
 			   xevent->xmotion.window - base_id,
 			   xevent->xmotion.x, xevent->xmotion.y,
-			   (xevent->xmotion.is_hint) ? "true" : "false",
-			   gdk_dnd.drag_perhaps, gdk_dnd.drag_really));
+			   (xevent->xmotion.is_hint) ? "true" : "false"));
       
       if (window_private &&
 	  (window_private->extension_events != 0) &&
@@ -2183,114 +2163,7 @@ gdk_event_translate (GdkEvent *event,
       event->motion.source = GDK_SOURCE_MOUSE;
       event->motion.deviceid = GDK_CORE_POINTER;
       
-#define IS_IN_ZONE(cx, cy) (cx >= gdk_dnd.dnd_drag_dropzone.x \
-     && cy >= gdk_dnd.dnd_drag_dropzone.y \
-     && cx < (gdk_dnd.dnd_drag_dropzone.x + gdk_dnd.dnd_drag_dropzone.width) \
-     && cy < (gdk_dnd.dnd_drag_dropzone.y + gdk_dnd.dnd_drag_dropzone.height))
-      
-      if(gdk_dnd.drag_perhaps && gdk_dnd.drag_really
-	 /* && event->motion.is_hint */ /* HINTME */)
-	{
-	  /* First, we have to find what window the motion was in... */
-	  /* XXX there has to be a better way to do this, perhaps with
-	     XTranslateCoordinates or XQueryTree - I don't know how,
-	     and this sort of works */
-	  static Window lastwin = None, curwin = None;
-#if 0
-	  Window twin;
-#endif
-	  Window childwin = gdk_root_window;
-	  int x, y, ox, oy;
-	  
-	  /* Interlude - display cursor for the drag ASAP */
-	  gdk_dnd_display_drag_cursor(xevent->xmotion.x_root,
-				      xevent->xmotion.y_root,
-				      gdk_dnd.dnd_drag_target?TRUE:FALSE,
-				      FALSE);
-	  
-	  lastwin = curwin;
-	  curwin = gdk_root_window;
-	  ox = x = xevent->xmotion.x_root;
-	  oy = y = xevent->xmotion.y_root;
-#if 1
-	  curwin = gdk_window_xid_at_coords(xevent->xmotion.x_root,
-					    xevent->xmotion.y_root,
-					    gdk_dnd.c->xids,TRUE);
-	  XTranslateCoordinates(gdk_display, gdk_root_window, curwin,
-				x, y, &x, &y, &childwin);
-#else
-	  while(childwin != None)
-	    {
-	      ox = x; oy = y;
-	      curwin = childwin;
-	      XTranslateCoordinates(gdk_display, curwin, curwin,
-				    x, y, &x, &y, &childwin);
-	      if(childwin != None) 
-		{
-		  XTranslateCoordinates(gdk_display, curwin, childwin,
-					x, y, &x, &y, &twin);
-		}
-	    }
-#endif
-	  GDK_NOTE (DND,
-		    g_message("Drag is now in window %#lx, lastwin was %#lx, ddc = %#lx",
-			      curwin, lastwin, gdk_dnd.dnd_drag_curwin));
-	  if(curwin != gdk_dnd.dnd_drag_curwin && curwin != lastwin)
-	    {
-	      /* We have left one window and entered another
-		 (do leave & enter bits) */
-	      if(gdk_dnd.dnd_drag_curwin != None)
-		gdk_dnd_drag_leave(gdk_dnd.dnd_drag_curwin);
-	      gdk_dnd.dnd_drag_curwin = curwin;
-	      gdk_dnd_drag_enter(gdk_dnd.dnd_drag_curwin);
-	      gdk_dnd.dnd_drag_dropzone.x = gdk_dnd.dnd_drag_dropzone.y = 0;
-	      gdk_dnd.dnd_drag_dropzone.width = gdk_dnd.dnd_drag_dropzone.height = 0;
-	      gdk_dnd.dnd_drag_target = None;
-	      GDK_NOTE (DND,
-			g_message("curwin = %#lx, lastwin = %#lx, dnd_drag_curwin = %#lx",
-				  curwin, lastwin, gdk_dnd.dnd_drag_curwin));
-	      
-	      gdk_dnd_display_drag_cursor(xevent->xmotion.x_root,
-					  xevent->xmotion.y_root,
-					  FALSE, TRUE);
-	    }
-	  else if(gdk_dnd.dnd_drag_dropzone.width > 0
-		  && gdk_dnd.dnd_drag_dropzone.height > 0
-		  && curwin == gdk_dnd.dnd_drag_curwin)
-	    {
-	      /* Handle all that dropzone stuff - thanks John ;-) */
-	      if (gdk_dnd.dnd_drag_target != None)
-		{
-		  gboolean in_zone = IS_IN_ZONE(xevent->xmotion.x_root,
-						xevent->xmotion.y_root);
-		  gboolean old_in_zone = IS_IN_ZONE(gdk_dnd.dnd_drag_oldpos.x, 
-						    gdk_dnd.dnd_drag_oldpos.y);
-		  
-		  if (!in_zone && old_in_zone)
-		    {
-		      /* We were in the drop zone and moved out */
-		      gdk_dnd.dnd_drag_target = None;
-		      gdk_dnd_drag_leave(curwin);
-		      gdk_dnd_display_drag_cursor(xevent->xmotion.x_root,
-						  xevent->xmotion.y_root,
-						  FALSE, TRUE);
-		    }
-		  else if (!in_zone && !old_in_zone)
-		    {
-		      /* We were outside drop zone but in the window
-			 - have to send enter events */
-		      gdk_dnd_drag_enter(curwin);
-		      gdk_dnd.dnd_drag_curwin = curwin;
-		      gdk_dnd.dnd_drag_dropzone.x = gdk_dnd.dnd_drag_dropzone.y = 0;
-		      gdk_dnd.dnd_drag_target = None;
-		    }
-		}
-	    } /* else
-		 dnd_drag_curwin = None; */
-	  return_val = FALSE;
-	}
-      else
-	return_val = window_private && !window_private->destroyed;
+      return_val = window_private && !window_private->destroyed;
       break;
       
     case EnterNotify:
@@ -2366,35 +2239,7 @@ gdk_event_translate (GdkEvent *event,
       
       event->crossing.focus = xevent->xcrossing.focus;
       event->crossing.state = xevent->xcrossing.state;
-      
-#ifdef G_ENABLE_DEBUG
-      if ((gdk_debug_flags & GDK_DEBUG_DND) & gdk_dnd.drag_perhaps)
-	{
-	  g_message("We may[%d] have a drag into %#lx = %#lx",
-		    gdk_dnd.drag_really,
-		    xevent->xcrossing.window, gdk_dnd.real_sw->xwindow);
-	}
-#endif /* G_ENABLE_DEBUG */
-      
-      if (gdk_dnd.drag_perhaps && gdk_dnd.drag_really && 
-	  (xevent->xcrossing.window == gdk_dnd.real_sw->xwindow))
-	{
-#if 0
-	  gdk_dnd.drag_really = 0;
-	  
-	  GDK_NOTE (DND, g_message("Ungrabbed"));
-	  
-	  gdk_dnd.drag_numwindows = 0;
-	  g_free(gdk_dnd.drag_startwindows);
-	  gdk_dnd.drag_startwindows = NULL;
-	  /* We don't want to ungrab the pointer here, or we'll
-	   * start getting spurious enter/leave events */
-#endif
-#if 0
-	  XChangeActivePointerGrab (gdk_display, 0, None, CurrentTime);
-#endif
-	}
-      
+  
       return_val = window_private && !window_private->destroyed;
       break;
       
@@ -2465,37 +2310,6 @@ gdk_event_translate (GdkEvent *event,
       event->crossing.focus = xevent->xcrossing.focus;
       event->crossing.state = xevent->xcrossing.state;
       
-#ifdef G_ENABLE_DEBUG
-      if ((gdk_debug_flags & GDK_DEBUG_DND) & gdk_dnd.drag_perhaps)
-	{
-	  g_message("We may[%d] have a drag out of %#lx = %#lx",
-		    gdk_dnd.drag_really,
-		    xevent->xcrossing.window, gdk_dnd.real_sw->xwindow);
-	}
-#endif /* G_ENABLE_DEBUG */
-      if (gdk_dnd.drag_perhaps && !gdk_dnd.drag_really &&
-	  (xevent->xcrossing.window == gdk_dnd.real_sw->xwindow))
-	{
-	  gboolean xgpret;
-	  gdk_dnd_drag_addwindow((GdkWindow *) gdk_dnd.real_sw);
-	  gdk_dnd_drag_begin((GdkWindow *) gdk_dnd.real_sw);
-	  xgpret = 
-	    XGrabPointer(gdk_display, gdk_dnd.real_sw->xwindow, False,
-			 ButtonMotionMask | PointerMotionMask |
-			 /* PointerMotionHintMask | */ /* HINTME */
-			 ButtonPressMask | ButtonReleaseMask,
-			 GrabModeAsync, GrabModeAsync, None,
-			 None, CurrentTime);
-#ifdef G_ENABLE_DEBUG
-	  GDK_NOTE(DND, g_message("xgpret = %d", xgpret));
-#endif
-	  gdk_dnd.dnd_grabbed = TRUE;
-	  gdk_dnd.drag_really = 1;
-	  gdk_dnd_display_drag_cursor(xevent->xmotion.x_root,
-				      xevent->xmotion.y_root,
-				      FALSE, TRUE);
-	}
-      
       return_val = window_private && !window_private->destroyed;
       break;
       
@@ -2852,231 +2666,50 @@ gdk_event_translate (GdkEvent *event,
       break;
       
     case ClientMessage:
-      /* Print debugging info.
-       */
-      GDK_NOTE (EVENTS,
-		g_message ("client message:\twindow: %ld",
-			   xevent->xclient.window - base_id));
-      
-      /* Client messages are the means of the window manager
-       *  communicating with a program. We'll first check to
-       *  see if this is really the window manager talking
-       *  to us.
-       */
-      if (xevent->xclient.message_type == gdk_wm_protocols)
-	{
-	  if ((Atom) xevent->xclient.data.l[0] == gdk_wm_delete_window)
-	    {
-	      /* The delete window request specifies a window
-	       *  to delete. We don't actually destroy the
-	       *  window because "it is only a request". (The
-	       *  window might contain vital data that the
-	       *  program does not want destroyed). Instead
-	       *  the event is passed along to the program,
-	       *  which should then destroy the window.
-	       */
-	      
-	      /* Print debugging info.
-	       */
-	      GDK_NOTE (EVENTS,
-			g_message ("delete window:\t\twindow: %ld",
-				   xevent->xclient.window - base_id));
-	      
-	      event->any.type = GDK_DELETE;
-	      event->any.window = window;
-	      
-	      return_val = window_private && !window_private->destroyed;
-	    }
-	  else if ((Atom) xevent->xclient.data.l[0] == gdk_wm_take_focus)
-	    {
-	    }
-	}
-      else if (xevent->xclient.message_type == gdk_dnd.gdk_XdeEnter)
-	{
-	  Atom reptype = 0;
-	  
-	  event->dropenter.u.allflags = xevent->xclient.data.l[1];
-	  
-	  GDK_NOTE (DND, g_message ("GDK_DROP_ENTER [%d][%d]",
-				    window_private->dnd_drop_enabled, event->dropenter.u.flags.sendreply));
-	  return_val = FALSE;
-	  
-	  /* Now figure out if we really want this drop...
-	   * If someone is trying funky clipboard stuff, ignore 
-	   */
-	  if (window_private
-	      && window_private->dnd_drop_enabled
-	      && event->dropenter.u.flags.sendreply
-	      && (reptype = gdk_dnd_check_types (window, xevent)))
-	    {
-	      XEvent replyev;
-	      
-	      replyev.xclient.type = ClientMessage;
-	      replyev.xclient.window = xevent->xclient.data.l[0];
-	      replyev.xclient.format = 32;
-	      replyev.xclient.message_type = gdk_dnd.gdk_XdeRequest;
-	      replyev.xclient.data.l[0] = window_private->xwindow;
-	      
-	      event->dragrequest.u.allflags = 0;
-	      event->dragrequest.u.flags.protocol_version =
-		DND_PROTOCOL_VERSION;
-	      event->dragrequest.u.flags.willaccept = 1;
-	      event->dragrequest.u.flags.delete_data =
-		(window_private->dnd_drop_destructive_op) ? 1 : 0;
-	      
-	      replyev.xclient.data.l[1] = event->dragrequest.u.allflags;
-	      replyev.xclient.data.l[2] = replyev.xclient.data.l[3] = 0;
-	      replyev.xclient.data.l[4] = reptype;
-	      
-	      if (!gdk_send_xevent (replyev.xclient.window, False, 
-				    NoEventMask, &replyev))
-		GDK_NOTE (DND, g_message("Sending XdeRequest to %#lx failed",
-					 replyev.xclient.window));
-	      
-	      event->any.type = GDK_DROP_ENTER;
-	      event->any.window = window;
-	      event->dropenter.requestor = replyev.xclient.window;
-	      event->dropenter.u.allflags = xevent->xclient.data.l[1];
-	      
-	      GDK_NOTE (DND, g_message("We sent a GDK_DROP_ENTER on to Gtk"));
-	      return_val = TRUE;
-	    }
-	}
-      else if (xevent->xclient.message_type == gdk_dnd.gdk_XdeLeave)
-	{
-#ifdef G_ENABLE_DEBUG	  
-	  if (gdk_debug_flags & (GDK_DEBUG_EVENTS | GDK_DEBUG_DND))
-	    g_message ("GDK_DROP_LEAVE");
-#endif	  
-	  
-	  if (window_private && window_private->dnd_drop_enabled)
-	    {
-	      event->dropleave.type = GDK_DROP_LEAVE;
-	      event->dropleave.window = window;
-	      event->dropleave.requestor = xevent->xclient.data.l[0];
-	      event->dropleave.u.allflags = xevent->xclient.data.l[1];
-	      return_val = TRUE;
-	    }
-	  else
+      {
+	GList *tmp_list;
+	GdkFilterReturn result = GDK_FILTER_CONTINUE;
+
+	/* Print debugging info.
+	 */
+	GDK_NOTE (EVENTS,
+		  g_message ("client message:\twindow: %ld",
+			     xevent->xclient.window - base_id));
+	
+	tmp_list = client_filters;
+	while (tmp_list)
+	  {
+	    GdkClientFilter *filter = tmp_list->data;
+	    if (filter->type == xevent->xclient.message_type)
+	      {
+		result = (*filter->function) (xevent, event, filter->data);
+		break;
+	      }
+	    
+	    tmp_list = tmp_list->next;
+	  }
+
+	switch (result)
+	  {
+	  case GDK_FILTER_REMOVE:
 	    return_val = FALSE;
-	}
-      else if (xevent->xclient.message_type == gdk_dnd.gdk_XdeRequest)
-	{
-	  /* 
-	   * make sure to only handle requests from the window the cursor is
-	   * over 
-	   */
-#ifdef G_ENABLE_DEBUG	  
-	  if (gdk_debug_flags & (GDK_DEBUG_EVENTS | GDK_DEBUG_DND))
-	    g_message ("GDK_DRAG_REQUEST");
-#endif	  
-	  event->dragrequest.u.allflags = xevent->xclient.data.l[1];
-	  return_val = FALSE;
-	  
-	  if (window && gdk_dnd.drag_really &&
-	      xevent->xclient.data.l[0] == gdk_dnd.dnd_drag_curwin &&
-	      event->dragrequest.u.flags.sendreply == 0)
-	    {
-	      /* Got request - do we need to ask user? */
-	      if (!event->dragrequest.u.flags.willaccept
-		  && event->dragrequest.u.flags.senddata)
-		{
-		  /* Yes we do :) */
-		  event->dragrequest.type = GDK_DRAG_REQUEST;
-		  event->dragrequest.window = window;
-		  event->dragrequest.requestor = xevent->xclient.data.l[0];
-		  event->dragrequest.isdrop = 0;
-		  event->dragrequest.drop_coords.x =
-		    event->dragrequest.drop_coords.y = 0;
-		  return_val = TRUE;
-		}
-	      else if (event->dragrequest.u.flags.willaccept)
-		{
-		  window_private->dnd_drag_destructive_op =
-		    event->dragrequest.u.flags.delete_data;
-		  window_private->dnd_drag_accepted = 1;
-		  window_private->dnd_drag_data_type =
-		    xevent->xclient.data.l[4];
-		  
-		  gdk_dnd.dnd_drag_target = gdk_dnd.dnd_drag_curwin;
-		  gdk_dnd_display_drag_cursor(-1, -1, TRUE, TRUE);
-		}
-	      gdk_dnd.dnd_drag_dropzone.x = xevent->xclient.data.l[2] & 65535;
-	      gdk_dnd.dnd_drag_dropzone.y =
-		(xevent->xclient.data.l[2] >> 16) & 65535;
-	      gdk_dnd.dnd_drag_dropzone.width = xevent->xclient.data.l[3] & 65535;
-	      gdk_dnd.dnd_drag_dropzone.height =
-		(xevent->xclient.data.l[3] >> 16) & 65535;
-	    }
-	}
-      else if(xevent->xclient.message_type == gdk_dnd.gdk_XdeDataAvailable)
-	{
-	  gint tmp_int; Atom tmp_atom;
-	  gulong tmp_long;
-	  guchar *tmp_charptr;
-	  
-#ifdef G_ENABLE_DEBUG	  
-	  if (gdk_debug_flags & (GDK_DEBUG_EVENTS | GDK_DEBUG_DND))
-	    g_message("GDK_DROP_DATA_AVAIL");
-#endif	  
-	  event->dropdataavailable.u.allflags = xevent->xclient.data.l[1];
-	  event->dropdataavailable.timestamp = xevent->xclient.data.l[4];
-	  event->dropdataavailable.coords.x =
-	    xevent->xclient.data.l[3] & 0xffff;
-	  event->dropdataavailable.coords.y =
-	    (xevent->xclient.data.l[3] >> 16) & 0xffff;
-	  if(window
-	     /* No preview of data ATM */
-	     && event->dropdataavailable.u.flags.isdrop)
-	    {
-	      event->dropdataavailable.type = GDK_DROP_DATA_AVAIL;
-	      event->dropdataavailable.window = window;
-	      event->dropdataavailable.requestor = xevent->xclient.data.l[0];
-	      event->dropdataavailable.data_type =
-		gdk_atom_name(xevent->xclient.data.l[2]);
-	      if(XGetWindowProperty (gdk_display,
-				     event->dropdataavailable.requestor,
-				     xevent->xclient.data.l[2],
-				     0, LONG_MAX - 1,
-				     False, XA_PRIMARY, &tmp_atom,
-				     &tmp_int,
-				     &event->dropdataavailable.data_numbytes,
-				     &tmp_long,
-				     &tmp_charptr)
-		 != Success)
-		{
-		  g_warning("XGetWindowProperty on %#x may have failed\n",
-			    event->dropdataavailable.requestor);
-		  event->dropdataavailable.data = NULL;
-		}
-	      else
-		{
-		  GDK_NOTE (DND, g_message("XGetWindowProperty got us %ld bytes",
-					   event->dropdataavailable.data_numbytes));
-		  event->dropdataavailable.data =
-		    g_malloc (event->dropdataavailable.data_numbytes);
-		  memcpy (event->dropdataavailable.data,
-			  tmp_charptr, event->dropdataavailable.data_numbytes);
-		  XFree(tmp_charptr);
-		  return_val = TRUE;
-		}
-	      return_val = TRUE;
-	    }
-	}
-      else
-	{
-	  /* Send unknown ClientMessage's on to Gtk for it to use */
-	  event->client.type = GDK_CLIENT_EVENT;
-	  event->client.window = window;
-	  event->client.message_type = xevent->xclient.message_type;
-	  event->client.data_format = xevent->xclient.format;
-	  memcpy(&event->client.data, &xevent->xclient.data,
-		 sizeof(event->client.data));
-	  if(window)
+	    break;
+	  case GDK_FILTER_TRANSLATE:
 	    return_val = TRUE;
-	  else	
-	    return_val = FALSE;
-	}
+	    break;
+	  case GDK_FILTER_CONTINUE:
+	    /* Send unknown ClientMessage's on to Gtk for it to use */
+	    event->client.type = GDK_CLIENT_EVENT;
+	    event->client.window = window;
+	    event->client.message_type = xevent->xclient.message_type;
+	    event->client.data_format = xevent->xclient.format;
+	    memcpy(&event->client.data, &xevent->xclient.data,
+		   sizeof(event->client.data));
+	    
+	    return_val = (window != NULL);
+	  }
+      }
+      
       if(window_private)
 	return_val = return_val && !window_private->destroyed;
       break;
@@ -3129,6 +2762,38 @@ gdk_event_translate (GdkEvent *event,
   return return_val;
 }
 
+GdkFilterReturn
+gdk_wm_protocols_filter (GdkXEvent *xev,
+		     GdkEvent  *event,
+		     gpointer data)
+{
+  XEvent *xevent = (XEvent *)xev;
+
+  if ((Atom) xevent->xclient.data.l[0] == gdk_wm_delete_window)
+    {
+  /* The delete window request specifies a window
+   *  to delete. We don't actually destroy the
+   *  window because "it is only a request". (The
+   *  window might contain vital data that the
+   *  program does not want destroyed). Instead
+   *  the event is passed along to the program,
+   *  which should then destroy the window.
+   */
+      GDK_NOTE (EVENTS,
+		g_message ("delete window:\t\twindow: %ld",
+			   xevent->xclient.window - base_id));
+      
+      event->any.type = GDK_DELETE;
+
+      return GDK_FILTER_TRANSLATE;
+    }
+  else if ((Atom) xevent->xclient.data.l[0] == gdk_wm_take_focus)
+    {
+    }
+
+  return GDK_FILTER_REMOVE;
+}
+
 #if 0
 static Bool
 gdk_event_get_type (Display  *display,
@@ -3344,67 +3009,6 @@ gdk_signal (int sig_num)
 #endif /* !G_ENABLE_DEBUG */
 }
 
-static void
-gdk_dnd_drag_begin (GdkWindow *initial_window)
-{
-  GdkEvent tev;
-  
-  GDK_NOTE(DND, g_message("------- STARTING DRAG from %p", initial_window));
-  
-  tev.type = GDK_DRAG_BEGIN;
-  tev.dragbegin.window = initial_window;
-  tev.dragbegin.u.allflags = 0;
-  tev.dragbegin.u.flags.protocol_version = DND_PROTOCOL_VERSION;
-  
-  gdk_event_put (&tev);
-}
-
-static void
-gdk_dnd_drag_enter (Window dest)
-{
-  XEvent sev;
-  GdkEventDropEnter tev;
-  int i;
-  GdkWindowPrivate *wp;
-  
-  sev.xclient.type = ClientMessage;
-  sev.xclient.format = 32;
-  sev.xclient.message_type = gdk_dnd.gdk_XdeEnter;
-  sev.xclient.window = dest;
-  
-  tev.u.allflags = 0;
-  tev.u.flags.protocol_version = DND_PROTOCOL_VERSION;
-  tev.u.flags.sendreply = 1;
-  for (i = 0; i < gdk_dnd.drag_numwindows; i++)
-    {
-      wp = (GdkWindowPrivate *) gdk_dnd.drag_startwindows[i];
-      if (wp->dnd_drag_data_numtypesavail)
-	{
-	  sev.xclient.data.l[0] = wp->xwindow;
-	  tev.u.flags.extended_typelist = (wp->dnd_drag_data_numtypesavail > 3)?1:0;
-	  sev.xclient.data.l[1] = tev.u.allflags;
-	  sev.xclient.data.l[2] = wp->dnd_drag_data_typesavail[0];
-	  if (wp->dnd_drag_data_numtypesavail > 1)
-	    {
-	      sev.xclient.data.l[3] = wp->dnd_drag_data_typesavail[1];
-	      if (wp->dnd_drag_data_numtypesavail > 2)
-		{
-		  sev.xclient.data.l[4] = wp->dnd_drag_data_typesavail[2];
-		}
-	      else
-		sev.xclient.data.l[4] = None;
-	    }
-	  else
-	    sev.xclient.data.l[3] = sev.xclient.data.l[4] = None;
-	  if (!gdk_send_xevent (dest, False, StructureNotifyMask, &sev))
-	    GDK_NOTE (DND, g_message("Sending XdeEnter to %#lx failed",
-				     dest));
-	}
-      
-    }
-}
-
-
 #ifdef USE_XIM
 
 /* The following routines duplicate functionality in Xlib to
@@ -4051,145 +3655,58 @@ _g_mbtowc (wchar_t *wstr, const char *str, size_t len)
 
 #endif /* X_LOCALE */
 
-static void
-gdk_dnd_drag_leave (Window dest)
-{
-  XEvent sev;
-  GdkEventDropLeave tev;
-  int i;
-  GdkWindowPrivate *wp;
-  
-  tev.u.allflags = 0;
-  
-  tev.u.flags.protocol_version = DND_PROTOCOL_VERSION;
-  sev.xclient.type = ClientMessage;
-  sev.xclient.window = dest;
-  sev.xclient.format = 32;
-  sev.xclient.message_type = gdk_dnd.gdk_XdeLeave;
-  sev.xclient.data.l[1] = tev.u.allflags;
-  for (i = 0; i < gdk_dnd.drag_numwindows; i++)
-    {
-      wp = (GdkWindowPrivate *) gdk_dnd.drag_startwindows[i];
-      sev.xclient.data.l[0] = wp->xwindow;
-      if (!gdk_send_xevent (dest, False, StructureNotifyMask, &sev))
-	GDK_NOTE (DND, g_message("Sending XdeLeave to %#lx failed",
-				 dest));
-      wp->dnd_drag_accepted = 0;
-    }
-}
-
 /* 
- * when a drop occurs, we go through the list of windows being dragged and
- * tell them that it has occurred, so that they can set things up and reply
- * to 'dest' window 
+ * used for debugging only 
  */
+#ifdef DEBUG_DND
 static void
-gdk_dnd_drag_end (Window     dest, 
-		  GdkPoint   coords)
+gdk_print_atom (GdkAtom anatom)
 {
-  GdkWindowPrivate *wp;
-  GdkEvent tev;
-  int i;
-  
-  tev.dragrequest.type = GDK_DRAG_REQUEST;
-  tev.dragrequest.drop_coords = coords;
-  tev.dragrequest.requestor = dest;
-  tev.dragrequest.u.allflags = 0;
-  tev.dragrequest.u.flags.protocol_version = DND_PROTOCOL_VERSION;
-  tev.dragrequest.isdrop = 1;
-  
-  for (i = 0; i < gdk_dnd.drag_numwindows; i++)
-    {
-      wp = (GdkWindowPrivate *) gdk_dnd.drag_startwindows[i];
-      if (wp->dnd_drag_accepted)
-	{
-	  tev.dragrequest.window = (GdkWindow *) wp;
-	  tev.dragrequest.u.flags.delete_data = wp->dnd_drag_destructive_op;
-	  tev.dragrequest.timestamp = gdk_dnd.last_drop_time;
-	  tev.dragrequest.data_type = 
-	    gdk_atom_name(wp->dnd_drag_data_type);
-	  
-	  gdk_event_put(&tev);
-	}
-    }
+  gchar *tmpstr = NULL;
+  tmpstr = (anatom!=None)?gdk_atom_name(anatom):"(none)";
+  g_message("Atom %lu has name %s", anatom, tmpstr);
+  if(tmpstr)
+    g_free(tmpstr);
 }
+#endif
 
-static GdkAtom
-gdk_dnd_check_types (GdkWindow	 *window, 
-		     XEvent	 *xevent)
+#ifdef WE_HAVE_MOTIF_DROPS_DONE
+static GdkWindow *
+gdk_drop_get_real_window (GdkWindow   *w, 
+			  guint16     *x, 
+			  guint16     *y)
 {
-  GdkWindowPrivate *wp = (GdkWindowPrivate *) window;
-  int i, j;
-  GdkEventDropEnter event;
+  GdkWindow *retval = w;
+  GdkWindowPrivate *awin;
+  GList *children;
+  gint16 myx = *x, myy = *y;
   
-  g_return_val_if_fail(window != NULL, 0);
-  g_return_val_if_fail(xevent != NULL, 0);
-  g_return_val_if_fail(xevent->type == ClientMessage, 0);
-  g_return_val_if_fail(xevent->xclient.message_type == gdk_dnd.gdk_XdeEnter, 0);
+  g_return_val_if_fail (w != NULL && x != NULL && y != NULL, NULL);
   
-  if(wp->dnd_drop_data_numtypesavail <= 0 ||
-     !wp->dnd_drop_data_typesavail)
-    return 0;
+  myx = *x; 
+  myy = *y;
   
-  for (i = 2; i <= 4; i++)
+ descend:
+  for (children = gdk_window_get_children(retval); 
+       children && children->next;
+       children = children->next)
     {
-      for (j = 0; j < wp->dnd_drop_data_numtypesavail; j++)
+      awin = (GdkWindowPrivate *) children->data;
+      if ((myx >= awin->x) && (myy >= awin->y)
+	  && (myx < (awin->x + awin->width))
+	  && (myy < (awin->y + awin->height)))
 	{
-	  if (xevent->xclient.data.l[i] == wp->dnd_drop_data_typesavail[j])
-	    return xevent->xclient.data.l[i];
+	  retval = (GdkWindow *) awin;
+	  myx -= awin->x;
+	  myy -= awin->y;
+	  goto descend;
 	}
     }
   
-  /* Now we get the extended type list if it's available */
-  event.u.allflags = xevent->xclient.data.l[1];
-  if (event.u.flags.extended_typelist)
-    {
-      Atom *exttypes, realtype;
-      gulong nitems, nbar;
-      gint realfmt;
-      
-      if (XGetWindowProperty(gdk_display, xevent->xclient.data.l[0],
-			     gdk_dnd.gdk_XdeTypelist, 0L, LONG_MAX - 1,
-			     False, AnyPropertyType, &realtype, &realfmt,
-			     &nitems, &nbar, (unsigned char **) &exttypes)
-	  != Success)
-	return 0;
-      
-      if (realfmt != (sizeof(Atom) * 8))
-	{
-	  g_warning("XdeTypelist property had format of %d instead of the expected %ld, on window %#lx\n",
-		    realfmt, (glong)sizeof(Atom) * 8, xevent->xclient.data.l[0]);
-	  return 0;
-	}
-      
-      for (i = 0; i <= nitems; i++)
-	{
-	  for (j = 0; j < wp->dnd_drop_data_numtypesavail; j++)
-	    {
-	      if (exttypes[i] == wp->dnd_drop_data_typesavail[j])
-		{
-		  XFree (exttypes);
-		  return exttypes[i];
-		}
-	    }
-	}
-      XFree (exttypes);
-    }
-  return 0;
-}
-
-/* 
- * used for debugging only 
- */
-#ifdef DEBUG_DND
-static void
-gdk_print_atom (GdkAtom anatom)
-{
-  gchar *tmpstr = NULL;
-  tmpstr = (anatom!=None)?gdk_atom_name(anatom):"(none)";
-  g_message("Atom %lu has name %s", anatom, tmpstr);
-  if(tmpstr)
-    g_free(tmpstr);
+  *x = myx; 
+  *y = myy;
+  
+  return retval;
 }
 #endif
 
@@ -4199,7 +3716,7 @@ gdk_print_atom (GdkAtom anatom)
 static Window 
 getchildren (Display	 *dpy, 
 	     Window	  win, 
-	     Atom	  WM_STATE)
+	     Atom	  wm_state_atom)
 {
   Window root, parent, *children, inf = 0;
   Atom type = None;
@@ -4213,7 +3730,7 @@ getchildren (Display	 *dpy,
   
   for (i = 0; !inf && (i < nchildren); i++)
     {
-      XGetWindowProperty (dpy, children[i], WM_STATE, 0, 0, False,
+      XGetWindowProperty (dpy, children[i], wm_state_atom, 0, 0, False,
 			  AnyPropertyType, &type, &format, &nitems,
 			  &after, &data);
       if (type != 0)
@@ -4222,7 +3739,7 @@ getchildren (Display	 *dpy,
     }
   
   for (i = 0; !inf && (i < nchildren); i++)
-    inf = getchildren (dpy, children[i], WM_STATE);
+    inf = getchildren (dpy, children[i], wm_state_atom);
   
   if (children != None)
     XFree ((char *) children);
@@ -4239,7 +3756,7 @@ Window
 gdk_get_client_window (Display	*dpy, 
 		       Window	 win)
 {
-  Atom WM_STATE;
+  static Atom wm_state_atom = None;
   Atom type = None;
   int format;
   unsigned long nitems, after;
@@ -4249,15 +3766,18 @@ gdk_get_client_window (Display	*dpy,
   if (win == 0)
     return DefaultRootWindow(dpy);
   
-  if ((WM_STATE = XInternAtom (dpy, "WM_STATE", True)) == 0)
+  if ((wm_state_atom = XInternAtom (dpy, "WM_STATE", True)) == 0)
     return win;
-  
-  XGetWindowProperty (dpy, win, WM_STATE, 0, 0, False, AnyPropertyType,
+
+  XGetWindowProperty (dpy, win, wm_state_atom, 0, 0, False, AnyPropertyType,
 		      &type, &format, &nitems, &after, &data);
   if (type)
-    return win;
+    {
+      XFree (data);
+      return win;
+    }
   
-  inf = getchildren (dpy, win, WM_STATE);
+  inf = getchildren (dpy, win, wm_state_atom);
   
   if (inf == 0)
     return win;
@@ -4265,46 +3785,6 @@ gdk_get_client_window (Display	*dpy,
     return inf;
 }
 
-#ifdef WE_HAVE_MOTIF_DROPS_DONE
-static GdkWindow *
-gdk_drop_get_real_window (GdkWindow   *w, 
-			  guint16     *x, 
-			  guint16     *y)
-{
-  GdkWindow *retval = w;
-  GdkWindowPrivate *awin;
-  GList *children;
-  gint16 myx = *x, myy = *y;
-  
-  g_return_val_if_fail (w != NULL && x != NULL && y != NULL, NULL);
-  
-  myx = *x; 
-  myy = *y;
-  
- descend:
-  for (children = gdk_window_get_children(retval); 
-       children && children->next;
-       children = children->next)
-    {
-      awin = (GdkWindowPrivate *) children->data;
-      if ((myx >= awin->x) && (myy >= awin->y)
-	  && (myx < (awin->x + awin->width))
-	  && (myy < (awin->y + awin->height)))
-	{
-	  retval = (GdkWindow *) awin;
-	  myx -= awin->x;
-	  myy -= awin->y;
-	  goto descend;
-	}
-    }
-  
-  *x = myx; 
-  *y = myy;
-  
-  return retval;
-}
-#endif
-
 /* Sends a ClientMessage to all toplevel client windows */
 void
 gdk_event_send_clientmessage_toall (GdkEvent *event)
@@ -4320,7 +3800,6 @@ gdk_event_send_clientmessage_toall (GdkEvent *event)
   sev.xclient.type = ClientMessage;
   sev.xclient.display = gdk_display;
   sev.xclient.format = event->client.data_format;
-  sev.xclient.serial = CurrentTime;
   memcpy(&sev.xclient.data, &event->client.data, sizeof(sev.xclient.data));
   sev.xclient.message_type = event->client.message_type;
   
@@ -4352,13 +3831,14 @@ gdk_send_xevent (Window window, gboolean propagate, glong event_mask,
 		 XEvent *event_send)
 {
   Status result;
+  gint old_warnings = gdk_error_warnings;
   
   gdk_error_code = 0;
   
   gdk_error_warnings = 0;
   result = XSendEvent (gdk_display, window, propagate, event_mask, event_send);
   XSync (gdk_display, False);
-  gdk_error_warnings = 1;
+  gdk_error_warnings = old_warnings;
   
   return result && (gdk_error_code != -1);
 }
diff --git a/gdk/gdk.h b/gdk/gdk.h
index 6ee99665a..1d188c78a 100644
--- a/gdk/gdk.h
+++ b/gdk/gdk.h
@@ -40,8 +40,9 @@ GdkEvent *gdk_event_get	 (void);
 GdkEvent *gdk_event_get_graphics_expose (GdkWindow *window);
 void gdk_event_put	 (GdkEvent     *event);
 
-GdkEvent *gdk_event_copy (GdkEvent *event);
-void	  gdk_event_free (GdkEvent *event);
+GdkEvent *gdk_event_copy     (GdkEvent *event);
+void	  gdk_event_free     (GdkEvent *event);
+guint32   gdk_event_get_time (GdkEvent *event);
 
 void gdk_set_show_events (gint	show_events);
 void gdk_set_use_xshm	 (gint	use_xshm);
@@ -196,51 +197,61 @@ void gdk_window_shape_combine_mask (GdkWindow	    *window,
 				    gint	     offset_x,
 				    gint	     offset_y);
 
-/* 
- * Drag & Drop
- * Algorithm (drop source):
- * A window being dragged will be sent a GDK_DRAG_BEGIN message.
- * It will then do gdk_dnd_drag_addwindow() for any other windows that are to be
- * dragged.
- * When we get a DROP_ENTER incoming, we send it on to the window in question.
- * That window needs to use gdk_dnd_drop_enter_reply() to indicate the state of
- * things (it must call that even if it's not going to accept the drop)
- *
- * These two turn on/off drag or drop, and if enabling it also
- * sets the list of types supported. The list of types passed in
- * should be in order of decreasing preference.
- */
-void gdk_window_dnd_drag_set (GdkWindow	 *window,
-			      guint8	  drag_enable,
-			      gchar	**typelist,
-			      guint	  numtypes);
-
-/* 
- *XXX todo: add a GDK_DROP_ENTER which can look at actual data
- */
-void gdk_window_dnd_drop_set (GdkWindow	 *window,
-			      guint8	  drop_enable,
-			      gchar	**typelist,
-			      guint	  numtypes,
-			      guint8	  destructive_op);
-
-/* 
- * This is used by the GDK_DRAG_BEGIN handler. An example of usage would be a
- * file manager where multiple icons were selected and the drag began.
- * The icon that the drag actually began on would gdk_dnd_drag_addwindow
- * for all the other icons that were being dragged... 
+/*
+ * The following function adds a global filter for all client
+ * messages of type message_type
  */
-void gdk_dnd_drag_addwindow  (GdkWindow	 *window);
-void gdk_window_dnd_data_set (GdkWindow	 *window,
-			      GdkEvent	 *event,
-			      gpointer	  data,
-			      gulong	  data_numbytes);
-void gdk_dnd_set_drag_cursors(GdkCursor *default_cursor,
-			      GdkCursor *goahead_cursor);
-void gdk_dnd_set_drag_shape(GdkWindow *default_pixmapwin,
-			    GdkPoint *default_hotspot,
-			    GdkWindow *goahead_pixmapwin,
-			    GdkPoint *goahead_hotspot);
+void gdk_add_client_message_filter (GdkAtom       message_type,
+				    GdkFilterFunc func,
+				    gpointer      data);
+
+/* Drag and Drop */
+
+GdkDragContext * gdk_drag_context_new        (void);
+void             gdk_drag_context_ref        (GdkDragContext *context);
+void             gdk_drag_context_unref      (GdkDragContext *context);
+
+/* Destination side */
+
+void             gdk_drag_status        (GdkDragContext   *context,
+				         GdkDragAction     action,
+					 guint32           time);
+void             gdk_drop_reply         (GdkDragContext   *context,
+					 gboolean          ok,
+					 guint32           time);
+void             gdk_drop_finish        (GdkDragContext   *context,
+					 gboolean          success,
+					 guint32           time);
+GdkAtom          gdk_drag_get_selection (GdkDragContext   *context);
+
+/* Source side */
+
+GdkDragContext * gdk_drag_begin      (GdkWindow      *window,
+				      GList          *targets,
+				      GdkDragAction   actions);
+gboolean         gdk_drag_get_protocol (guint32          xid,
+					GdkDragProtocol *protocol);
+void             gdk_drag_find_window (GdkDragContext   *context,
+				       GdkWindow       *drag_window,
+			 	       gint             x_root,
+				       gint             y_root,
+				       GdkWindow      **dest_window,
+				       GdkDragProtocol *protocol);
+gboolean        gdk_drag_motion      (GdkDragContext *context,
+				      GdkWindow      *dest_window,
+				      GdkDragProtocol protocol,
+				      gint            x_root, 
+				      gint            y_root,
+				      GdkDragAction   action,
+				      guint32         time);
+void            gdk_drag_drop        (GdkDragContext *context,
+				      guint32         time);
+void            gdk_drag_abort       (GdkDragContext *context,
+				      guint32         time);
+
+GdkAtom       gdk_drag_get_selection (GdkDragContext *context);
+
+/* GdkWindow */
 
 void	      gdk_window_set_hints	 (GdkWindow	  *window,
 					  gint		   x,
@@ -309,6 +320,8 @@ void	      gdk_window_set_functions	 (GdkWindow	  *window,
 					  GdkWMFunction	   functions);
 GList *       gdk_window_get_toplevels   (void);
 
+void          gdk_window_register_dnd    (GdkWindow       *window);
+
 void          gdk_drawable_set_data      (GdkDrawable     *drawable,
 					  const gchar     *key,
 					  gpointer	   data,
@@ -477,14 +490,24 @@ gboolean gdk_colormap_alloc_color (GdkColormap *colormap,
 void     gdk_colormap_free_colors (GdkColormap *colormap,
 				   GdkColor    *colors,
 				   gint         ncolors);
-     
-void gdk_colors_store	 (GdkColormap	*colormap,
-			  GdkColor	*colors,
-			  gint		 ncolors);
 
+GdkVisual *gdk_colormap_get_visual (GdkColormap *colormap);
+     
 GdkColor *gdk_color_copy (GdkColor *color);
 void      gdk_color_free (GdkColor *color);
 
+gint gdk_color_parse	 (const gchar	*spec,
+			  GdkColor	*color);
+guint gdk_color_hash     (const GdkColor *colora,
+			  const GdkColor *colorb);
+gint gdk_color_equal	 (const GdkColor *colora,
+			  const GdkColor *colorb);
+
+
+/* The following functions are deprecated */
+void gdk_colors_store	 (GdkColormap	*colormap,
+			  GdkColor	*colors,
+			  gint		 ncolors);
 gint gdk_colors_alloc	 (GdkColormap	*colormap,
 			  gint		 contiguous,
 			  gulong	*planes,
@@ -499,16 +522,10 @@ gint gdk_color_white	 (GdkColormap	*colormap,
 			  GdkColor	*color);
 gint gdk_color_black	 (GdkColormap	*colormap,
 			  GdkColor	*color);
-gint gdk_color_parse	 (const gchar	*spec,
-			  GdkColor	*color);
 gint gdk_color_alloc	 (GdkColormap	*colormap,
 			  GdkColor	*color);
 gint gdk_color_change	 (GdkColormap	*colormap,
 			  GdkColor	*color);
-guint gdk_color_hash     (const GdkColor *colora,
-			  const GdkColor *colorb);
-gint gdk_color_equal	 (const GdkColor *colora,
-			  const GdkColor *colorb);
 
 
 /* Fonts
diff --git a/gdk/gdkcolor.c b/gdk/gdkcolor.c
index 36b6c8593..f84f57025 100644
--- a/gdk/gdkcolor.c
+++ b/gdk/gdkcolor.c
@@ -179,6 +179,18 @@ gdk_colormap_unref (GdkColormap *cmap)
     gdk_colormap_real_destroy (cmap);
 }
 
+GdkVisual *
+gdk_colormap_get_visual (GdkColormap *colormap)
+{
+  GdkColormapPrivate *private;
+
+  g_return_val_if_fail (colormap != NULL, NULL);
+  
+  private = (GdkColormapPrivate *)colormap;
+
+  return private->visual;
+}
+     
 #define MIN_SYNC_TIME 2
 
 void
diff --git a/gdk/gdkdnd.c b/gdk/gdkdnd.c
index 331aad7ef..67720ad6b 100644
--- a/gdk/gdkdnd.c
+++ b/gdk/gdkdnd.c
@@ -20,157 +20,2853 @@
 #include <X11/Xatom.h>
 #include <string.h>
 #include "gdkx.h"
+#include "gdk/gdkprivate.h"
 #include "gdk.h"
 
-/* Nothing much here now, but we have to make a start some time ;-) */
+typedef struct _GdkDragContextPrivate GdkDragContextPrivate;
 
-void
-gdk_dnd_set_drag_cursors(GdkCursor *default_cursor, GdkCursor *goahead_cursor)
+typedef enum {
+  GDK_DRAG_STATUS_DRAG,
+  GDK_DRAG_STATUS_MOTION_WAIT,
+  GDK_DRAG_STATUS_ACTION_WAIT,
+  GDK_DRAG_STATUS_DROP
+} GtkDragStatus;
+
+typedef struct {
+  guint32 xid;
+  gint x, y, width, height;
+  gboolean mapped;
+} GdkCacheChild;
+
+typedef struct {
+  GList *children;
+  GHashTable *child_hash;
+  guint old_event_mask;
+} GdkWindowCache;
+
+/* Structure that holds information about a drag in progress.
+ * this is used on both source and destination sides.
+ */
+struct _GdkDragContextPrivate {
+  GdkDragContext context;
+
+  GdkAtom motif_selection;
+  GdkAtom xdnd_selection;
+  guint   ref_count;
+
+  guint16 last_x;		/* Coordinates from last event */
+  guint16 last_y;
+  GdkDragAction old_action;	/* The last action we sent to the source */
+
+  Window  dest_xid;
+  guint xdnd_targets_set : 1;   /* Whether we've already set XdndTypeList */
+  guint motif_targets_set : 1;  /* Whether we've already set motif initiator info */
+  guint drag_status : 4;	/* current status of drag */
+
+  GdkWindowCache *window_cache;
+};
+
+GdkDragContext *current_dest_drag = NULL;
+
+/* Forward declarations */
+
+static void gdk_window_cache_destroy (GdkWindowCache *cache);
+
+static void     motif_read_target_table (void);
+static GdkFilterReturn motif_dnd_filter (GdkXEvent *xev,
+					 GdkEvent  *event,
+					 gpointer   data);
+
+static GdkFilterReturn xdnd_enter_filter (GdkXEvent *xev,
+					  GdkEvent  *event,
+					  gpointer   data);
+
+static GdkFilterReturn xdnd_leave_filter (GdkXEvent *xev,
+					  GdkEvent  *event,
+					  gpointer   data);
+
+static GdkFilterReturn xdnd_position_filter (GdkXEvent *xev,
+					     GdkEvent  *event,
+					     gpointer   data);
+
+static GdkFilterReturn xdnd_status_filter (GdkXEvent *xev,
+					   GdkEvent  *event,
+					   gpointer   data);
+
+static GdkFilterReturn xdnd_finished_filter (GdkXEvent *xev,
+					    GdkEvent  *event,
+					    gpointer   data);
+
+static GdkFilterReturn xdnd_drop_filter (GdkXEvent *xev,
+					 GdkEvent  *event,
+					 gpointer   data);
+
+/* Drag Contexts */
+
+static GList *contexts;
+
+GdkDragContext *
+gdk_drag_context_new        (void)
+{
+  GdkDragContextPrivate *result;
+
+  result = g_new0 (GdkDragContextPrivate, 1);
+
+  result->ref_count = 1;
+
+  contexts = g_list_prepend (contexts, result);
+
+  return (GdkDragContext *)result;
+}
+
+void            
+gdk_drag_context_ref (GdkDragContext *context)
+{
+  ((GdkDragContextPrivate *)context)->ref_count++;
+}
+
+void            
+gdk_drag_context_unref (GdkDragContext *context)
+{
+  GdkDragContextPrivate *private = (GdkDragContextPrivate *)context;
+  private->ref_count--;
+  
+  if (private->ref_count == 0)
+    {
+      g_dataset_destroy (private);
+      
+      g_list_free (context->targets);
+
+      if (context->source_window)
+	gdk_window_unref (context->source_window);
+
+      if (context->dest_window)
+	gdk_window_unref (context->dest_window);
+
+      if (private->window_cache)
+	gdk_window_cache_destroy (private->window_cache);
+
+      contexts = g_list_remove (contexts, private);
+      g_free (private);
+    }
+}
+
+static GdkDragContext *
+gdk_drag_context_find (gboolean is_source,
+		       Window   source_xid,
+		       Window   dest_xid)
+{
+  GList *tmp_list = contexts;
+
+  while (tmp_list)
+    {
+      GdkDragContext *context = (GdkDragContext *)tmp_list->data;
+
+      if ((!context->is_source == !is_source) &&
+	  ((source_xid == None) || (context->source_window &&
+	    (GDK_WINDOW_XWINDOW (context->source_window) == source_xid))) &&
+	  ((dest_xid == None) || (context->dest_window &&
+	    (GDK_WINDOW_XWINDOW (context->dest_window) == dest_xid))))
+	return context;
+      
+      tmp_list = tmp_list->next;
+    }
+  
+  return NULL;
+}
+
+/* Utility functions */
+
+static void
+gdk_window_cache_add (GdkWindowCache *cache,
+		      guint32 xid,
+		      gint x, gint y, gint width, gint height, 
+		      gboolean mapped)
+{
+  GdkCacheChild *child = g_new (GdkCacheChild, 1);
+
+  child->xid = xid;
+  child->x = x;
+  child->y = y;
+  child->width = width;
+  child->height = height;
+  child->mapped = mapped;
+
+  cache->children = g_list_prepend (cache->children, child);
+  g_hash_table_insert (cache->child_hash, GUINT_TO_POINTER (xid), 
+		       cache->children);
+}
+
+static GdkFilterReturn
+gdk_window_cache_filter (GdkXEvent *xev,
+			 GdkEvent  *event,
+			 gpointer   data)
+{
+  XEvent *xevent = (XEvent *)xev;
+  GdkWindowCache *cache = data;
+
+  switch (xevent->type)
+    {
+    case CirculateNotify:
+      break;
+    case ConfigureNotify:
+      {
+	XConfigureEvent *xce = &xevent->xconfigure;
+	GList *node;
+
+	node = g_hash_table_lookup (cache->child_hash, 
+				    GUINT_TO_POINTER (xce->window));
+	if (node) 
+	  {
+	    GdkCacheChild *child = node->data;
+	    child->x = xce->x; 
+	    child->y = xce->y;
+	    child->width = xce->width; 
+	    child->height = xce->height;
+	    if (xce->above == None && (node->next))
+	      {
+		GList *last = g_list_last (cache->children);
+		cache->children = g_list_remove_link (cache->children, node);
+		last->next = node;
+		node->next = NULL;
+		node->prev = last;
+	      }
+	    else
+	      {
+		GList *above_node = g_hash_table_lookup (cache->child_hash, 
+							 GUINT_TO_POINTER (xce->above));
+		if (above_node && node->prev != above_node)
+		  {
+		    cache->children = g_list_remove_link (cache->children, node);
+		    node->next = above_node->next;
+		    node->prev = above_node;
+		    above_node->next = node;
+		  }
+	      }
+	  }
+	break;
+      }
+    case CreateNotify:
+      {
+	XCreateWindowEvent *xcwe = &xevent->xcreatewindow;
+	if (!g_hash_table_lookup (cache->child_hash, 
+				  GUINT_TO_POINTER (xcwe->window))) 
+	  gdk_window_cache_add (cache, xcwe->window, 
+				xcwe->x, xcwe->y, xcwe->width, xcwe->height,
+				FALSE);
+	break;
+      }
+    case DestroyNotify:
+      {
+	XDestroyWindowEvent *xdwe = &xevent->xdestroywindow;
+	GList *node;
+
+	node = g_hash_table_lookup (cache->child_hash, 
+				    GUINT_TO_POINTER (xdwe->window));
+	if (node) 
+	  {
+	    g_hash_table_remove (cache->child_hash,
+				 GUINT_TO_POINTER (xdwe->window));
+	    cache->children = g_list_remove_link (cache->children, node);
+	    g_free (node->data);
+	    g_list_free_1 (node);
+	  }
+	break;
+      }
+    case MapNotify:
+      {
+	XMapEvent *xme = &xevent->xmap;
+	GList *node;
+
+	node = g_hash_table_lookup (cache->child_hash, 
+				    GUINT_TO_POINTER (xme->window));
+	if (node) 
+	  {
+	    GdkCacheChild *child = node->data;
+	    child->mapped = TRUE;
+	  }
+	break;
+      }
+    case ReparentNotify:
+      break;
+    case UnmapNotify:
+      {
+	XMapEvent *xume = &xevent->xmap;
+	GList *node;
+
+	node = g_hash_table_lookup (cache->child_hash, 
+				    GUINT_TO_POINTER (xume->window));
+	if (node) 
+	  {
+	    GdkCacheChild *child = node->data;
+	    child->mapped = FALSE;
+	  }
+	break;
+      }
+    default:
+      return GDK_FILTER_CONTINUE;
+    }
+  return GDK_FILTER_REMOVE;
+}
+
+static GdkWindowCache *
+gdk_window_cache_new (void)
+{
+  XWindowAttributes xwa;
+  Window root, parent, *children;
+  unsigned int nchildren;
+  int i;
+  
+  gint old_warnings = gdk_error_warnings;
+  
+  GdkWindowCache *result = g_new (GdkWindowCache, 1);
+
+  result->children = NULL;
+  result->child_hash = g_hash_table_new (g_direct_hash, NULL);
+
+  XGetWindowAttributes (gdk_display, gdk_root_window, &xwa);
+  result->old_event_mask = xwa.your_event_mask;
+  XSelectInput (gdk_display, gdk_root_window,
+		result->old_event_mask | SubstructureNotifyMask);
+  gdk_window_add_filter ((GdkWindow *)&gdk_root_parent, 
+			 gdk_window_cache_filter, result);
+  
+  gdk_error_code = 0;
+  gdk_error_warnings = 0;
+
+  if (XQueryTree(gdk_display, gdk_root_window, 
+		 &root, &parent, &children, &nchildren) == 0)
+    return result;
+  
+  for (i = 0; i < nchildren ; i++)
+    {
+      XGetWindowAttributes (gdk_display, children[i], &xwa);
+
+      gdk_window_cache_add (result, children[i],
+			    xwa.x, xwa.y, xwa.width, xwa.height,
+			    xwa.map_state != IsUnmapped);
+
+      if (gdk_error_code != 0)
+	gdk_error_code = 0;
+      else
+	{
+	  gdk_window_cache_add (result, children[i],
+				xwa.x, xwa.y, xwa.width, xwa.height,
+				(xwa.map_state != IsUnmapped));
+	}
+    }
+
+  XFree (children);
+
+  gdk_error_warnings = old_warnings;
+
+  return result;
+}
+
+static void
+gdk_window_cache_destroy (GdkWindowCache *cache)
+{
+  XSelectInput (gdk_display, gdk_root_window, cache->old_event_mask);
+  gdk_window_remove_filter ((GdkWindow *)&gdk_root_parent, 
+			    gdk_window_cache_filter, cache);
+
+  g_list_foreach (cache->children, (GFunc)g_free, NULL);
+  g_list_free (cache->children);
+  g_hash_table_destroy (cache->child_hash);
+}
+
+static Window
+get_client_window_at_coords_recurse (Window  win,
+				     gint    x_root,
+				     gint    y_root)
+{
+  Window child;
+  Atom type = None;
+  int format;
+  unsigned long nitems, after;
+  unsigned char *data;
+  int dest_x, dest_y;
+  
+  static Atom wm_state_atom = None;
+
+  if (!wm_state_atom)
+    wm_state_atom = gdk_atom_intern ("WM_STATE", FALSE);
+    
+  XGetWindowProperty (gdk_display, win, 
+		      wm_state_atom, 0, 0, False, AnyPropertyType,
+		      &type, &format, &nitems, &after, &data);
+  
+  if (gdk_error_code != 0)
+    {
+      gdk_error_code = 0;
+      return None;
+    }
+
+  if (type != None)
+    {
+      XFree (data);
+      return win;
+    }
+
+  XTranslateCoordinates (gdk_display, gdk_root_window, win,
+			 x_root, y_root, &dest_x, &dest_y, &child);
+
+  if (gdk_error_code != 0)
+    {
+      gdk_error_code = 0;
+      return None;
+    }
+
+  if (child)
+    return get_client_window_at_coords_recurse (child, x_root, y_root);
+  else
+    return None;
+}
+
+Window 
+get_client_window_at_coords (GdkWindowCache *cache,
+			     Window  ignore,
+			     gint    x_root,
+			     gint    y_root)
 {
-  gdk_dnd.c->gdk_cursor_dragdefault =
-    ((GdkCursorPrivate *)default_cursor)->xcursor;
-  gdk_dnd.c->gdk_cursor_dragok = ((GdkCursorPrivate *)goahead_cursor)->xcursor;
+  GList *tmp_list;
+  Window retval = None;
+
+  gint old_warnings = gdk_error_warnings;
   
-  if(gdk_dnd.dnd_grabbed)
+  gdk_error_code = 0;
+  gdk_error_warnings = 0;
+
+  tmp_list = cache->children;
+
+  while (tmp_list && !retval)
     {
-      if(gdk_dnd.c->drag_pm_default)
-	/* We were displaying pixmaps for the drag */
+      GdkCacheChild *child = tmp_list->data;
+
+      if ((child->xid != ignore) && (child->mapped))
 	{
-	  gdk_window_hide(gdk_dnd.c->drag_pm_default);
-	  gdk_window_unref(gdk_dnd.c->drag_pm_default);
-	  if(gdk_dnd.c->drag_pm_ok)
+	  if ((x_root >= child->x) && (x_root < child->x + child->width) &&
+	      (y_root >= child->y) && (y_root < child->y + child->height))
 	    {
-	      gdk_window_hide(gdk_dnd.c->drag_pm_ok);
-	      gdk_window_unref(gdk_dnd.c->drag_pm_ok);
+	      retval = get_client_window_at_coords_recurse (child->xid,
+							    x_root, y_root);
+	      if (!retval)
+		retval = child->xid;
 	    }
-	  gdk_dnd.c->drag_pm_default = gdk_dnd.c->drag_pm_ok = NULL;
-	  g_list_free(gdk_dnd.c->xids);
-	  gdk_dnd.c->xids = NULL;
+	  
 	}
-      gdk_dnd_display_drag_cursor(-1, -1,
-				  gdk_dnd.dnd_drag_target?TRUE:FALSE,
-				  TRUE);
+      tmp_list = tmp_list->next;
     }
+
+  gdk_error_warnings = old_warnings;
+  if (retval)
+    return retval;
+  else
+    return gdk_root_window;
 }
 
-void
-gdk_dnd_set_drag_shape(GdkWindow *default_pixmapwin,
-		       GdkPoint *default_hotspot,
-		       GdkWindow *goahead_pixmapwin,
-		       GdkPoint *goahead_hotspot)
+#if 0
+static Window
+get_client_window_at_coords_recurse (Window  win,
+				     gint    x_root,
+				     gint    y_root)
 {
-  g_return_if_fail(default_pixmapwin != NULL);
+  Window child;
+  Atom type = None;
+  int format;
+  unsigned long nitems, after;
+  unsigned char *data;
+  int dest_x, dest_y;
   
-  g_list_free(gdk_dnd.c->xids); gdk_dnd.c->xids = NULL;
-  if(gdk_dnd.c->drag_pm_default)
+  static Atom wm_state_atom = None;
+
+  if (!wm_state_atom)
+    wm_state_atom = gdk_atom_intern ("WM_STATE", FALSE);
+    
+  XGetWindowProperty (gdk_display, win, 
+		      wm_state_atom, 0, 0, False, AnyPropertyType,
+		      &type, &format, &nitems, &after, &data);
+  
+  if (gdk_error_code != 0)
+    {
+      gdk_error_code = 0;
+      return None;
+    }
+
+  if (type != None)
     {
-      gdk_window_hide(gdk_dnd.c->drag_pm_default);
-      gdk_window_unref(gdk_dnd.c->drag_pm_default);
+      XFree (data);
+      return win;
     }
-  if(gdk_dnd.c->drag_pm_ok)
+
+  XTranslateCoordinates (gdk_display, gdk_root_window, win,
+			 x_root, y_root, &dest_x, &dest_y, &child);
+
+  if (gdk_error_code != 0)
     {
-      gdk_window_hide(gdk_dnd.c->drag_pm_ok);
-      gdk_window_unref(gdk_dnd.c->drag_pm_ok);
+      gdk_error_code = 0;
+      return None;
     }
+
+  if (child)
+    return get_client_window_at_coords_recurse (child, x_root, y_root);
+  else
+    return None;
+}
+
+Window 
+get_client_window_at_coords (Window  ignore,
+			     gint    x_root,
+			     gint    y_root)
+{
+  Window root, parent, *children;
+  unsigned int nchildren;
+  int i;
+  Window retval = None;
+  
+  gint old_warnings = gdk_error_warnings;
   
-  gdk_dnd.c->drag_pm_ok = NULL;
+  gdk_error_code = 0;
+  gdk_error_warnings = 0;
+
+  if (XQueryTree(gdk_display, gdk_root_window, 
+		 &root, &parent, &children, &nchildren) == 0)
+    return 0;
   
-  gdk_window_ref(default_pixmapwin);
-  gdk_dnd.c->drag_pm_default = default_pixmapwin;
-  gdk_dnd.c->default_hotspot = *default_hotspot;
-  gdk_dnd.c->xids = g_list_append(gdk_dnd.c->xids, GUINT_TO_POINTER (((GdkWindowPrivate *)default_pixmapwin)->xwindow));
-  if(goahead_pixmapwin)
+  for (i = nchildren - 1; (i >= 0) && (retval == None); i--)
+    {
+      if (children[i] != ignore)
+	{
+	  XWindowAttributes xwa;
+
+	  XGetWindowAttributes (gdk_display, children[i], &xwa);
+
+	  if (gdk_error_code != 0)
+	    gdk_error_code = 0;
+	  else if ((xwa.map_state == IsViewable) &&
+		   (x_root >= xwa.x) && (x_root < xwa.x + (gint)xwa.width) &&
+		   (y_root >= xwa.y) && (y_root < xwa.y + (gint)xwa.height))
+	    {
+	      retval = get_client_window_at_coords_recurse (children[i],
+							    x_root, y_root);
+	      if (!retval)
+		retval = children[i];
+	    }
+	}
+    }
+
+  XFree (children);
+
+  gdk_error_warnings = old_warnings;
+  if (retval)
+    return retval;
+  else
+    return gdk_root_window;
+}
+#endif
+
+/*************************************************************
+ ***************************** MOTIF *************************
+ *************************************************************/
+
+/* values used in the message type for Motif DND */
+enum {
+    XmTOP_LEVEL_ENTER,
+    XmTOP_LEVEL_LEAVE,
+    XmDRAG_MOTION,
+    XmDROP_SITE_ENTER,
+    XmDROP_SITE_LEAVE,
+    XmDROP_START,
+    XmDROP_FINISH,
+    XmDRAG_DROP_FINISH,
+    XmOPERATION_CHANGED
+};
+
+/* Values used to specify type of protocol to use */
+enum {
+    XmDRAG_NONE,
+    XmDRAG_DROP_ONLY,
+    XmDRAG_PREFER_PREREGISTER,
+    XmDRAG_PREREGISTER,
+    XmDRAG_PREFER_DYNAMIC,
+    XmDRAG_DYNAMIC,
+    XmDRAG_PREFER_RECEIVER
+};
+
+/* Operation codes */
+enum {
+  XmDROP_NOOP,
+  XmDROP_MOVE = 0x01,
+  XmDROP_COPY = 0x02,
+  XmDROP_LINK = 0x04
+};
+
+/* Drop site status */
+enum {
+  XmNO_DROP_SITE = 0x01,
+  XmDROP_SITE_INVALID = 0x02,
+  XmDROP_SITE_VALID = 0x03
+};
+
+/* completion status */
+enum {
+  XmDROP,
+  XmDROP_HELP,
+  XmDROP_CANCEL,
+  XmDROP_INTERRUPT
+};
+
+/* Static data for MOTIF DND */
+static GList **motif_target_lists = NULL;
+static gint motif_n_target_lists = -1;
+
+/* Byte swapping routines. The motif specification leaves it
+ * up to us to save a few bytes in the client messages
+ */
+static gchar local_byte_order = '\0';
+
+#ifdef G_ENABLE_DEBUG
+static void
+print_target_list (GList *targets)
+{
+  while (targets)
+    {
+      gchar *name = gdk_atom_name (GPOINTER_TO_INT (targets->data));
+      g_message ("\t%s", name);
+      g_free (name);
+      targets = targets->next;
+    }
+}
+#endif /* G_ENABLE_DEBUG */
+
+static void
+init_byte_order (void)
+{
+  guint32 myint = 0x01020304;
+  local_byte_order = (*(gchar *)&myint == 1) ? 'B' : 'l';
+}
+
+static guint16
+card16_to_host (guint16 x, gchar byte_order) {
+  if (byte_order == local_byte_order)
+    return x;
+  else
+    return (x << 8) | (x >> 8);
+}
+
+static guint32
+card32_to_host (guint32 x, gchar byte_order) {
+  if (byte_order == local_byte_order)
+    return x;
+  else
+    return (x << 24) | ((x & 0xff00) << 8) | ((x & 0xff0000) >> 8) | (x >> 24);
+}
+
+
+/***** Dest side ***********/
+
+/* Property placed on source windows */
+typedef struct _MotifDragInitiatorInfo {
+  guint8 byte_order;
+  guint8 protocol_version;
+  guint16 targets_index;
+  guint32 selection_atom;
+} MotifDragInitiatorInfo;
+
+/* Header for target table on the drag window */
+typedef struct _MotifTargetTableHeader {
+  guchar byte_order;
+  guchar protocol_version;
+  guint16 n_lists;
+  guint32 total_size;
+} MotifTargetTableHeader;
+
+/* Property placed on target windows */
+typedef struct _MotifDragReceiverInfo {
+  guint8 byte_order;
+  guint8 protocol_version;
+  guint8 protocol_style;
+  guint8 pad;
+  guint32 proxy_window;
+  guint16 num_drop_sites;
+  guint16 padding;
+  guint32 total_size;
+} MotifDragReceiverInfo;
+
+static Window motif_drag_window = None;
+static GdkWindow *motif_drag_gdk_window = NULL;
+
+static GdkAtom motif_drag_targets_atom = GDK_NONE;
+static GdkAtom motif_drag_receiver_info_atom = GDK_NONE;
+
+/* Target table handling */
+
+GdkFilterReturn
+motif_drag_window_filter (GdkXEvent *xevent,
+			  GdkEvent  *event,
+			  gpointer data)
+{
+  XEvent *xev = (XEvent *)xevent;
+
+  switch (xev->xany.type)
     {
-      gdk_window_ref(goahead_pixmapwin);
-      gdk_dnd.c->xids = g_list_append(gdk_dnd.c->xids, GUINT_TO_POINTER (((GdkWindowPrivate *)goahead_pixmapwin)->xwindow));
-      gdk_dnd.c->drag_pm_ok = goahead_pixmapwin;
-      gdk_dnd.c->ok_hotspot = *goahead_hotspot;
+    case DestroyNotify:
+      motif_drag_window = None;
+      motif_drag_gdk_window = NULL;
+      break;
+    case PropertyNotify:
+      if (motif_target_lists &&
+	  motif_drag_targets_atom &&
+	  (xev->xproperty.atom == motif_drag_targets_atom))
+	motif_read_target_table();
+      break;
     }
+  return GDK_FILTER_REMOVE;
+}
+
+static GdkAtom motif_drag_window_atom = GDK_NONE;
+
+static Window
+motif_lookup_drag_window (Display *display)
+{
+  Window retval = None;
+  gulong bytes_after, nitems;
+  GdkAtom type;
+  gint format;
+  guchar *data;
+
+  XGetWindowProperty (gdk_display, gdk_root_window, motif_drag_window_atom,
+		      0, sizeof(Window)/4, FALSE,
+		      XA_WINDOW, &type, &format, &nitems, &bytes_after,
+		      &data);
   
-  if(gdk_dnd.dnd_grabbed)
+  if ((format == 8*sizeof(Window)) && (nitems == 1) && (bytes_after == 0))
     {
-      gdk_dnd_display_drag_cursor(-1, -1,
-				  gdk_dnd.dnd_drag_target?TRUE:FALSE,
-				  TRUE);
-      XChangeActivePointerGrab (gdk_display,
-				ButtonMotionMask |
-				ButtonPressMask |
-				ButtonReleaseMask |
-				EnterWindowMask | LeaveWindowMask,
-				None,
-				CurrentTime);      
+      retval = *(Window *)data;
+      GDK_NOTE(DND, 
+	       g_message ("Found drag window %#lx\n", motif_drag_window));
     }
+
+  if (type != None)
+    XFree (data);
+
+  return retval;
 }
 
-void
-gdk_dnd_display_drag_cursor(gint x, gint y, gboolean drag_ok,
-			    gboolean change_made)
+/* Finds the window where global Motif drag information is stored.
+ * If it doesn't exist and 'create' is TRUE, create one.
+ */
+Window 
+motif_find_drag_window (gboolean create)
+{
+  if (!motif_drag_window)
+    {
+      if (!motif_drag_window_atom)
+	motif_drag_window_atom = gdk_atom_intern ("_MOTIF_DRAG_WINDOW", TRUE);
+
+      motif_drag_window = motif_lookup_drag_window (gdk_display);
+      
+      if (!motif_drag_window && create)
+	{
+	  /* Create a persistant window. (Copied from LessTif) */
+	  
+	  Display *display;
+	  XSetWindowAttributes attr;
+	  display = XOpenDisplay (NULL);
+	  XSetCloseDownMode (display, RetainPermanent);
+
+	  XGrabServer (display);
+	  
+	  motif_drag_window = motif_lookup_drag_window (display);
+
+	  if (!motif_drag_window)
+	    {
+	      attr.override_redirect = True;
+	      attr.event_mask = PropertyChangeMask;
+	      
+	      motif_drag_window = 
+		XCreateWindow(display, DefaultRootWindow(display),
+			      -100, -100, 10, 10, 0, 0,
+			      InputOnly, CopyFromParent,
+			      (CWOverrideRedirect | CWEventMask), &attr);
+	      
+	      GDK_NOTE (DND,
+			g_message ("Created drag window %#lx\n", motif_drag_window));
+	      
+	      XChangeProperty (display, gdk_root_window,
+			       motif_drag_window_atom, XA_WINDOW,
+			       32, PropModeReplace,
+			       (guchar *)&motif_drag_window_atom, 1);
+
+	    }
+	  XUngrabServer (display);
+	  XCloseDisplay (display);
+	}
+
+      /* There is a miniscule race condition here if the drag window
+       * gets destroyed exactly now.
+       */
+      if (motif_drag_window)
+	{
+	  motif_drag_gdk_window = gdk_window_foreign_new (motif_drag_window);
+	  gdk_window_add_filter (motif_drag_gdk_window,
+				 motif_drag_window_filter,
+				 NULL);
+	}
+    }
+
+  return motif_drag_window;
+}
+
+static void 
+motif_read_target_table (void)
 {
-  if(!gdk_dnd.dnd_grabbed)
-    return;
+  gulong bytes_after, nitems;
+  GdkAtom type;
+  gint format;
+  gint i, j;
+
+  if (!motif_drag_targets_atom)
+    motif_drag_targets_atom = gdk_atom_intern ("_MOTIF_DRAG_TARGETS", FALSE);
+
+  if (motif_target_lists)
+    {
+      for (i=0; i<motif_n_target_lists; i++)
+	g_list_free (motif_target_lists[i]);
+      
+      g_free (motif_target_lists);
+      motif_target_lists = NULL;
+      motif_n_target_lists = 0;
+    }
+
+  if (motif_find_drag_window (FALSE))
+    {
+      MotifTargetTableHeader *header = NULL;
+      guchar *target_bytes = NULL;
+      guchar *p;
+      gboolean success = FALSE;
+
+      XGetWindowProperty (gdk_display, motif_drag_window, 
+			  motif_drag_targets_atom,
+			  0, (sizeof(MotifTargetTableHeader)+3)/4, FALSE,
+			  motif_drag_targets_atom, 
+			  &type, &format, &nitems, &bytes_after,
+			  (guchar **)&header);
+
+      if ((format != 8) || (nitems < sizeof (MotifTargetTableHeader)))
+	goto error;
+
+      header->n_lists = card16_to_host (header->n_lists, header->byte_order);
+      header->total_size = card32_to_host (header->total_size, header->byte_order);
+
+      XGetWindowProperty (gdk_display, motif_drag_window, motif_drag_targets_atom,
+			  (sizeof(MotifTargetTableHeader)+3)/4, 
+			  (header->total_size - sizeof(MotifTargetTableHeader) + 3)/4,
+			  FALSE,
+			  motif_drag_targets_atom, &type, &format, &nitems, 
+			  &bytes_after, &target_bytes);
+      
+      if ((format != 8) || (bytes_after != 0) || 
+	  (nitems != header->total_size - sizeof(MotifTargetTableHeader)))
+	  goto error;
+
+      motif_n_target_lists = header->n_lists;
+      motif_target_lists = g_new0 (GList *, motif_n_target_lists);
+
+      p = target_bytes;
+      for (i=0; i<header->n_lists; i++)
+	{
+	  gint n_targets;
+	  guint32 *targets;
+	  
+	  if (p + sizeof(guint16) - target_bytes > nitems)
+	    goto error;
+
+	  n_targets = card16_to_host (*(gushort *)p, header->byte_order);
+	  targets = (guint32 *)(p + sizeof(guint16));
+
+	  p +=  sizeof(guint16) + n_targets * sizeof(guint32);
+	  if (p - target_bytes > nitems)
+	    goto error;
+
+	  for (j=0; j<n_targets; j++)
+	    motif_target_lists[i] = 
+	      g_list_prepend (motif_target_lists[i],
+			      GUINT_TO_POINTER (card32_to_host (targets[j], 
+								header->byte_order)));
+
+	  motif_target_lists[i] = g_list_reverse (motif_target_lists[i]);
+	}
+
+      success = TRUE;
+      
+    error:
+      if (header)
+	XFree (header);
+      
+      if (target_bytes)
+	XFree (target_bytes);
+
+      if (!success)
+	{
+	  if (motif_target_lists)
+	    {
+	      g_free (motif_target_lists);
+	      motif_target_lists = NULL;
+	      motif_n_target_lists = 0;
+	    }
+	  g_warning ("Error reading Motif target table\n");
+	}
+    }
+}
+
+static gint
+targets_sort_func (gconstpointer a, gconstpointer b)
+{
+  return (GPOINTER_TO_UINT (a) < GPOINTER_TO_UINT (b)) ?
+    -1 : ((GPOINTER_TO_UINT (a) > GPOINTER_TO_UINT (b)) ? 1 : 0);
+}
+
+/* Check if given (sorted) list is in the targets table */
+static gboolean
+motif_target_table_check (GList *sorted)
+{
+  GList *tmp_list1, *tmp_list2;
+  gint i;
+
+  for (i=0; i<motif_n_target_lists; i++)
+    {
+      tmp_list1 = motif_target_lists[i];
+      tmp_list2 = sorted;
+      
+      while (tmp_list1 && tmp_list2)
+	{
+	  if (tmp_list1->data != tmp_list2->data)
+	    break;
+
+	  tmp_list1 = tmp_list1->next;
+	  tmp_list2 = tmp_list2->next;
+	}
+      if (!tmp_list1 && !tmp_list2)	/* Found it */
+	return i;
+    }
+
+  return -1;
+}
+
+static gint
+motif_add_to_target_table (GList *targets)
+{
+  GList *sorted = NULL;
+  gint index = -1;
+  gint i;
+  GList *tmp_list;
+  
+  /* make a sorted copy of the list */
   
-  if(gdk_dnd.c->drag_pm_default)
+  while (targets)
+    {
+      sorted = g_list_insert_sorted (sorted, targets->data, targets_sort_func);
+      targets = targets->next;
+    }
+
+  /* First check if it is their already */
+
+  if (motif_target_lists)
+    index = motif_target_table_check (sorted);
+
+  /* We need to grab the server while doing this, to ensure
+   * atomiticity. Ugh
+   */
+
+  if (index < 0)
     {
-      /* We're doing pixmaps here... */
-      GdkWindow *mypix, *opix;
-      GdkPoint *myhotspot;
-      gint itmp;
-      guint masktmp;
-      Window wtmp;
+      /* We need to make sure that it exists _before_ we grab the
+       * server, since we can't open a new connection after we
+       * grab the server. 
+       */
+      motif_find_drag_window (TRUE);
+
+      XGrabServer(gdk_display);
+      motif_read_target_table();
+    
+      /* Check again, in case it was added in the meantime */
       
-      if(x == -2 && y == -2) /* Hide the cursors */
+      if (motif_target_lists)
+	index =  motif_target_table_check (sorted);
+
+      if (index < 0)
 	{
-	  gdk_window_hide(gdk_dnd.c->drag_pm_ok);
-	  gdk_window_hide(gdk_dnd.c->drag_pm_default);
-	  GDK_NOTE(DND, g_message("Hiding both drag cursors\n"));
-	  return;
+	  guint32 total_size = 0;
+	  guchar *data;
+	  guchar *p;
+	  guint16 *p16;
+	  guint32 *p32;
+	  MotifTargetTableHeader *header;
+	  
+	  if (!motif_target_lists)
+	    {
+	      motif_target_lists = g_new (GList *, 1);
+	      motif_n_target_lists = 1;
+	    }
+	  else
+	    {
+	      motif_n_target_lists++;
+	      motif_target_lists = g_realloc (motif_target_lists,
+					      sizeof(GList *) * motif_n_target_lists);
+	    }
+	  motif_target_lists[motif_n_target_lists - 1] = sorted;
+	  sorted = NULL;
+	  index = motif_n_target_lists - 1;
+
+	  total_size = sizeof (MotifTargetTableHeader);
+	  for (i = 0; i < motif_n_target_lists ; i++)
+	    total_size += sizeof(guint16) + sizeof(guint32) * g_list_length (motif_target_lists[i]);
+
+	  data = g_malloc (total_size);
+
+	  header = (MotifTargetTableHeader *)data;
+	  p = data + sizeof(MotifTargetTableHeader);
+
+	  header->byte_order = local_byte_order;
+	  header->protocol_version = 0;
+	  header->n_lists = motif_n_target_lists;
+	  header->total_size = total_size;
+
+	  for (i = 0; i < motif_n_target_lists ; i++)
+	    {
+	      guint16 count = 0;
+	      
+	      p16 = (guint16 *)p;
+	      p += sizeof(guint16);
+	      p32 = (guint32 *)p;
+	      tmp_list = motif_target_lists[i];
+	      while (tmp_list)
+		{
+		  *p32++ = GPOINTER_TO_UINT (tmp_list->data);
+		  tmp_list = tmp_list->next;
+		  count++;
+		}
+	      *p16 = count;
+	      p = (guchar *)p32;
+	    }
+
+	  XChangeProperty (gdk_display, motif_drag_window,
+			   motif_drag_targets_atom,
+			   motif_drag_targets_atom,
+			   8, PropModeReplace,
+			   data, total_size);
 	}
+      XUngrabServer(gdk_display);
+    }
+
+  g_list_free (sorted);
+  return index;
+}
+
+/* Translate flags */
+
+static void
+motif_dnd_translate_flags (GdkDragContext *context, guint16 flags)
+{
+  guint recommended_op = flags & 0x000f;
+  guint possible_ops = (flags & 0x0f0) >> 4;
+  
+  switch (recommended_op)
+    {
+    case XmDROP_MOVE:
+      context->suggested_action = GDK_ACTION_MOVE;
+      break;
+    case XmDROP_COPY:
+      context->suggested_action = GDK_ACTION_COPY;
+      break;
+    case XmDROP_LINK:
+      context->suggested_action = GDK_ACTION_LINK;
+      break;
+    default:
+      context->suggested_action = GDK_ACTION_COPY;
+      break;
+    }
+
+  context->actions = 0;
+  if (possible_ops & XmDROP_MOVE)
+    context->actions |= GDK_ACTION_MOVE;
+  if (possible_ops & XmDROP_COPY)
+    context->actions |= GDK_ACTION_COPY;
+  if (possible_ops & XmDROP_LINK)
+    context->actions |= GDK_ACTION_LINK;
+}
+
+static guint16
+motif_dnd_get_flags (GdkDragContext *context)
+{
+  guint16 flags = 0;
+  
+  switch (context->suggested_action)
+    {
+    case GDK_ACTION_MOVE:
+      flags = XmDROP_MOVE;
+      break;
+    case GDK_ACTION_COPY:
+      flags = XmDROP_COPY;
+      break;
+    case GDK_ACTION_LINK:
+      flags = XmDROP_LINK;
+      break;
+    default:
+      flags = XmDROP_NOOP;
+      break;
+    }
+  
+  if (context->actions & GDK_ACTION_MOVE)
+    flags |= XmDROP_MOVE << 8;
+  if (context->actions & GDK_ACTION_COPY)
+    flags |= XmDROP_COPY << 8;
+  if (context->actions & GDK_ACTION_LINK)
+    flags |= XmDROP_LINK << 8;
+
+  return flags;
+}
+
+/* Source Side */
+
+static void
+motif_set_targets (GdkDragContext *context)
+{
+  GdkDragContextPrivate *private = (GdkDragContextPrivate *)context;
+  MotifDragInitiatorInfo info;
+  gint i;
+  static GdkAtom motif_drag_initiator_info = GDK_NONE;
+
+  if (!motif_drag_initiator_info)
+    motif_drag_initiator_info = gdk_atom_intern ("_MOTIF_DRAG_INITIATOR_INFO", FALSE);
+
+  info.byte_order = local_byte_order;
+  info.protocol_version = 0;
+  
+  info.targets_index = motif_add_to_target_table (context->targets);
+
+  for (i=0; ; i++)
+    {
+      gchar buf[20];
+      g_snprintf(buf, 20, "_GDK_SELECTION_%d", i);
       
-      if(x == -1 && y == -1) /* We're supposed to find it out for ourselves */
-	XQueryPointer(gdk_display, gdk_root_window,
-		      &wtmp, &wtmp, &x, &y, &itmp, &itmp, &masktmp);
+      private->motif_selection = gdk_atom_intern (buf, FALSE);
+      if (!XGetSelectionOwner (gdk_display, private->motif_selection))
+	break;
+    }
+
+  info.selection_atom = private->motif_selection;
+
+  XChangeProperty (GDK_WINDOW_XDISPLAY (context->source_window),
+		   GDK_WINDOW_XWINDOW (context->source_window),
+		   private->motif_selection,
+		   motif_drag_initiator_info, 8, PropModeReplace,
+		   (guchar *)&info, sizeof (info));
+
+  private->motif_targets_set = 1;
+}
+
+gboolean
+motif_check_dest (Window win)
+{
+  gboolean retval = FALSE;
+  MotifDragReceiverInfo *info;
+  Atom type = None;
+  int format;
+  unsigned long nitems, after;
+
+  if (!motif_drag_receiver_info_atom)
+    motif_drag_receiver_info_atom = gdk_atom_intern ("_MOTIF_DRAG_RECEIVER_INFO", FALSE);
+  
+  XGetWindowProperty (gdk_display, win, 
+		      motif_drag_receiver_info_atom, 
+		      0, (sizeof(*info)+3)/4, False, AnyPropertyType,
+		      &type, &format, &nitems, &after, 
+		      (guchar **)&info);
+  
+  if (type != None)
+    {
+      if ((format == 8) && (nitems == sizeof(*info)))
+	{
+	  if ((info->protocol_version == 0) &&
+	      ((info->protocol_style == XmDRAG_PREFER_PREREGISTER) ||
+	       (info->protocol_style == XmDRAG_PREFER_DYNAMIC) ||
+	       (info->protocol_style == XmDRAG_DYNAMIC)))
+	    retval = TRUE;
+	}
+      else
+	{
+	  GDK_NOTE (DND, 
+		    g_warning ("Invalid Motif drag receiver property on window %ld\n", win));
+	}
+
+      XFree (info);
+    }
+
+  return retval;
+  
+}
+
+static void
+motif_send_enter (GdkDragContext  *context,
+		  guint32          time)
+{
+  XEvent xev;
+  GdkDragContextPrivate *private = (GdkDragContextPrivate *)context;
+
+  xev.xclient.type = ClientMessage;
+  xev.xclient.message_type = gdk_atom_intern ("_MOTIF_DRAG_AND_DROP_MESSAGE", FALSE);
+  xev.xclient.format = 8;
+  xev.xclient.window = GDK_WINDOW_XWINDOW (context->dest_window);
+
+  xev.xclient.data.b[0] = XmTOP_LEVEL_ENTER;
+  xev.xclient.data.b[1] = local_byte_order;
+  xev.xclient.data.s[1] = 0;
+  xev.xclient.data.l[1] = time;
+  xev.xclient.data.l[2] = GDK_WINDOW_XWINDOW (context->source_window);
+
+  if (!private->motif_targets_set)
+    motif_set_targets (context);
+
+  xev.xclient.data.l[3] = private->motif_selection;
+
+  if (!gdk_send_xevent (GDK_WINDOW_XWINDOW (context->dest_window),
+			FALSE, 0, &xev))
+    GDK_NOTE (DND, 
+	      g_message ("Send event to %lx failed",
+			 GDK_WINDOW_XWINDOW (context->dest_window)));
+}
+
+static void
+motif_send_leave (GdkDragContext  *context,
+		  guint32          time)
+{
+  XEvent xev;
+
+  xev.xclient.type = ClientMessage;
+  xev.xclient.message_type = gdk_atom_intern ("_MOTIF_DRAG_AND_DROP_MESSAGE", FALSE);
+  xev.xclient.format = 8;
+  xev.xclient.window = GDK_WINDOW_XWINDOW (context->dest_window);
+
+  xev.xclient.data.b[0] = XmTOP_LEVEL_LEAVE;
+  xev.xclient.data.b[1] = local_byte_order;
+  xev.xclient.data.s[1] = 0;
+  xev.xclient.data.l[1] = time;
+  xev.xclient.data.l[2] = GDK_WINDOW_XWINDOW (context->source_window);
+  xev.xclient.data.l[3] = 0;
+
+  if (!gdk_send_xevent (GDK_WINDOW_XWINDOW (context->dest_window),
+			FALSE, 0, &xev))
+    GDK_NOTE (DND, 
+	      g_message ("Send event to %lx failed",
+			 GDK_WINDOW_XWINDOW (context->dest_window)));
+}
+
+static gboolean
+motif_send_motion (GdkDragContext  *context,
+		    gint            x_root, 
+		    gint            y_root,
+		    GdkDragAction   action,
+		    guint32         time)
+{
+  gboolean retval;
+  XEvent xev;
+  GdkDragContextPrivate *private = (GdkDragContextPrivate *)context;
+
+  xev.xclient.type = ClientMessage;
+  xev.xclient.message_type = gdk_atom_intern ("_MOTIF_DRAG_AND_DROP_MESSAGE", FALSE);
+  xev.xclient.format = 8;
+  xev.xclient.window = GDK_WINDOW_XWINDOW (context->dest_window);
+
+  xev.xclient.data.b[1] = local_byte_order;
+  xev.xclient.data.s[1] = motif_dnd_get_flags (context);
+  xev.xclient.data.l[1] = time;
+
+  if (context->suggested_action != private->old_action)
+    {
+      xev.xclient.data.b[0] = XmOPERATION_CHANGED;
+
+      private->drag_status = GDK_DRAG_STATUS_ACTION_WAIT;
+      retval = TRUE;
+    }
+  else
+    {
+      xev.xclient.data.b[0] = XmDRAG_MOTION;
+
+      xev.xclient.data.s[4] = x_root;
+      xev.xclient.data.s[5] = y_root;
       
-      if(drag_ok)
+      private->drag_status = GDK_DRAG_STATUS_MOTION_WAIT;
+      retval = FALSE;
+    }
+
+  if (!gdk_send_xevent (GDK_WINDOW_XWINDOW (context->dest_window),
+			FALSE, 0, &xev))
+    GDK_NOTE (DND, 
+	      g_message ("Send event to %lx failed",
+			 GDK_WINDOW_XWINDOW (context->dest_window)));
+
+  return retval;
+}
+
+static void
+motif_send_drop (GdkDragContext *context, guint32 time)
+{
+  XEvent xev;
+  GdkDragContextPrivate *private = (GdkDragContextPrivate *)context;
+
+  xev.xclient.type = ClientMessage;
+  xev.xclient.message_type = gdk_atom_intern ("_MOTIF_DRAG_AND_DROP_MESSAGE", FALSE);
+  xev.xclient.format = 8;
+  xev.xclient.window = GDK_WINDOW_XWINDOW (context->dest_window);
+
+  xev.xclient.data.b[0] = XmDROP_START;
+  xev.xclient.data.b[1] = local_byte_order;
+  xev.xclient.data.s[1] = motif_dnd_get_flags (context);
+  xev.xclient.data.l[1] = time;
+
+  xev.xclient.data.s[4] = private->last_x;
+  xev.xclient.data.s[5] = private->last_y;
+
+  xev.xclient.data.l[3] = private->motif_selection;
+  xev.xclient.data.l[4] = GDK_WINDOW_XWINDOW (context->source_window);
+
+  if (!gdk_send_xevent (GDK_WINDOW_XWINDOW (context->dest_window),
+			FALSE, 0, &xev))
+    GDK_NOTE (DND, 
+	      g_message ("Send event to %lx failed",
+			 GDK_WINDOW_XWINDOW (context->dest_window)));
+}
+
+/* Target Side */
+
+static gboolean
+motif_read_initiator_info (Window source_window, 
+			   Atom atom,
+			   GList  **targets,
+			   GdkAtom *selection)
+{
+  GList *tmp_list;
+  static GdkAtom motif_drag_initiator_info = GDK_NONE;
+  GdkAtom type;
+  gint format;
+  gulong nitems;
+  gulong bytes_after;
+
+  MotifDragInitiatorInfo *initiator_info;
+
+  if (!motif_drag_initiator_info)
+    motif_drag_initiator_info = gdk_atom_intern ("_MOTIF_DRAG_INITIATOR_INFO", FALSE);
+
+  XGetWindowProperty (gdk_display, source_window, atom,
+		      0, sizeof(*initiator_info), FALSE,
+		      motif_drag_initiator_info, 
+		      &type, &format, &nitems, &bytes_after,
+		      (guchar **)&initiator_info);
+
+  if ((format != 8) || (nitems != sizeof (MotifDragInitiatorInfo)) || (bytes_after != 0))
+    {
+      g_warning ("Error reading initiator info\n");
+      return FALSE;
+    }
+
+  motif_read_target_table ();
+
+  if (initiator_info->targets_index >= motif_n_target_lists)
+    {
+      g_warning ("Invalid target index in TOP_LEVEL_ENTER MESSAGE");
+      XFree (initiator_info);
+      return GDK_FILTER_REMOVE;
+    }
+
+  tmp_list = g_list_last (motif_target_lists[initiator_info->targets_index]);
+
+  *targets = NULL;
+  while (tmp_list)
+    {
+      *targets = g_list_prepend (*targets,
+				 tmp_list->data);
+      tmp_list = tmp_list->prev;
+    }
+
+#ifdef G_ENABLE_DEBUG
+  if (gdk_debug_flags & GDK_DEBUG_DND)
+    print_target_list (*targets);
+#endif /* G_ENABLE_DEBUG */
+
+  *selection = initiator_info->selection_atom;
+
+  XFree (initiator_info);
+
+  return TRUE;
+}
+
+static GdkDragContext *
+motif_drag_context_new (GdkWindow *dest_window,
+			guint32    timestamp,
+			guint32    source_window,
+			guint32    atom)
+{
+  GdkDragContext *new_context;
+  GdkDragContextPrivate *private;
+
+  /* FIXME, current_dest_drag really shouldn't be NULL'd
+   * if we error below.
+   */
+  if (current_dest_drag != NULL)
+    {
+      if (timestamp >= current_dest_drag->start_time)
 	{
-	  GDK_NOTE(DND, g_message("Switching to drag_ok cursor\n"));
-	  mypix = gdk_dnd.c->drag_pm_ok;
-	  opix = gdk_dnd.c->drag_pm_default;
-	  myhotspot = &gdk_dnd.c->ok_hotspot;
+	  gdk_drag_context_unref (current_dest_drag);
+	  current_dest_drag = NULL;
 	}
       else
+	return NULL;
+    }
+
+  new_context = gdk_drag_context_new ();
+  private = (GdkDragContextPrivate *)new_context;
+
+  new_context->protocol = GDK_DRAG_PROTO_MOTIF;
+  new_context->is_source = FALSE;
+
+  new_context->source_window = gdk_window_lookup (source_window);
+  if (new_context->source_window)
+    gdk_window_ref (new_context->source_window);
+  else
+    {
+      new_context->source_window = gdk_window_foreign_new (source_window);
+      if (!new_context->source_window)
 	{
-	  GDK_NOTE(DND, g_message("Switching to drag_default cursor\n"));
-	  mypix = gdk_dnd.c->drag_pm_default;
-	  opix = gdk_dnd.c->drag_pm_ok;
-	  myhotspot = &gdk_dnd.c->default_hotspot;
+	  gdk_drag_context_unref (new_context);
+	  return NULL;
 	}
-      gdk_window_move(mypix, x - myhotspot->x, y - myhotspot->y);
-      if(change_made)
+    }
+
+  new_context->dest_window = dest_window;
+  gdk_window_ref (dest_window);
+  new_context->start_time = timestamp;
+
+  if (!motif_read_initiator_info(source_window,
+				 atom,
+				 &new_context->targets,
+				 &private->motif_selection))
+    {
+      gdk_drag_context_unref (new_context);
+      return NULL;
+    }
+
+  return new_context;
+}
+
+/*
+ * The MOTIF drag protocol has no real provisions for distinguishing
+ * multiple simultaneous drops. If the sources grab the pointer
+ * when doing drags, that shouldn't happen, in any case. If it
+ * does, we can't do much except hope for the best.
+ */
+
+static GdkFilterReturn
+motif_top_level_enter (GdkEvent *event,
+		       guint16   flags, 
+		       guint32   timestamp, 
+		       guint32   source_window, 
+		       guint32   atom)
+{
+  GdkDragContext *new_context;
+
+  GDK_NOTE(DND, g_message ("Motif DND top level enter: flags: %#4x time: %d source_widow: %#4x atom: %d",
+			   flags, timestamp, source_window, atom));
+
+  new_context = motif_drag_context_new (event->any.window, timestamp, source_window, atom);
+  if (!new_context)
+    return GDK_FILTER_REMOVE;
+
+  event->dnd.type = GDK_DRAG_ENTER;
+  event->dnd.context = new_context;
+  gdk_drag_context_ref (new_context);
+
+  current_dest_drag = new_context;
+
+  return GDK_FILTER_TRANSLATE;
+}
+
+GdkFilterReturn
+motif_top_level_leave (GdkEvent *event,
+		       guint16   flags, 
+		       guint32   timestamp)
+{
+  GDK_NOTE(DND, g_message ("Motif DND top level leave: flags: %#4x time: %d",
+			   flags, timestamp));
+
+  if ((current_dest_drag != NULL) &&
+      (current_dest_drag->protocol == GDK_DRAG_PROTO_MOTIF) &&
+      (timestamp >= current_dest_drag->start_time))
+    {
+      event->dnd.type = GDK_DRAG_LEAVE;
+      /* Pass ownership of context to the event */
+      event->dnd.context = current_dest_drag;
+
+      current_dest_drag = NULL;
+
+      return GDK_FILTER_TRANSLATE;
+    }
+  else
+    return GDK_FILTER_REMOVE;
+}
+
+GdkFilterReturn
+motif_motion (GdkEvent *event,
+	      guint16   flags, 
+	      guint32   timestamp,
+	      gint16    x_root,
+	      gint16    y_root)
+{
+  GdkDragContextPrivate *private;
+
+  GDK_NOTE(DND, g_message ("Motif DND motion: flags: %#4x time: %d (%d, %d)",
+			   flags, timestamp, x_root, y_root));
+
+  if ((current_dest_drag != NULL) &&
+      (current_dest_drag->protocol == GDK_DRAG_PROTO_MOTIF) &&
+      (timestamp >= current_dest_drag->start_time))
+    {
+      private = (GdkDragContextPrivate *)current_dest_drag;
+
+      event->dnd.type = GDK_DRAG_MOTION;
+      event->dnd.context = current_dest_drag;
+      gdk_drag_context_ref (current_dest_drag);
+
+      event->dnd.time = timestamp;
+
+      motif_dnd_translate_flags (current_dest_drag, flags);
+
+      event->dnd.x_root = x_root;
+      event->dnd.y_root = y_root;
+
+      private->last_x = x_root;
+      private->last_y = y_root;
+
+      private->drag_status = GDK_DRAG_STATUS_MOTION_WAIT;
+
+      return GDK_FILTER_TRANSLATE;
+    }
+
+  return GDK_FILTER_REMOVE;
+}
+
+GdkFilterReturn
+motif_operation_changed (GdkEvent *event,
+			 guint16   flags, 
+			 guint32   timestamp)
+{
+  GdkDragContextPrivate *private;
+
+  GDK_NOTE(DND, g_message ("Motif DND operation changed: flags: %#4x time: %d",
+			   flags, timestamp));
+
+  if ((current_dest_drag != NULL) &&
+      (current_dest_drag->protocol == GDK_DRAG_PROTO_MOTIF) &&
+      (timestamp >= current_dest_drag->start_time))
+    {
+      event->dnd.type = GDK_DRAG_MOTION;
+      event->dnd.send_event = FALSE;
+      event->dnd.context = current_dest_drag;
+      gdk_drag_context_ref (current_dest_drag);
+
+      event->dnd.time = timestamp;
+      private = (GdkDragContextPrivate *)current_dest_drag;
+
+      motif_dnd_translate_flags (current_dest_drag, flags);
+
+      event->dnd.x_root = private->last_x;
+      event->dnd.y_root = private->last_y;
+
+      private->drag_status = GDK_DRAG_STATUS_ACTION_WAIT;
+
+      return GDK_FILTER_TRANSLATE;
+    }
+
+  return GDK_FILTER_REMOVE;
+}
+
+GdkFilterReturn
+motif_drop_start (GdkEvent *event,
+		  guint16   flags,
+		  guint32   timestamp,
+		  guint32   source_window,
+		  guint32   atom,
+		  gint16    x_root,
+		  gint16    y_root)
+{
+  GdkDragContext *new_context;
+
+
+  GDK_NOTE(DND, g_message ("Motif DND drop start: flags: %#4x time: %d (%d, %d) source_widow: %#4x atom: %d",
+			   flags, timestamp, x_root, y_root, source_window, atom));
+
+  new_context = motif_drag_context_new (event->any.window, timestamp, source_window, atom);
+  if (!new_context)
+    return GDK_FILTER_REMOVE;
+
+  motif_dnd_translate_flags (new_context, flags);
+
+  event->dnd.type = GDK_DROP_START;
+  event->dnd.context = new_context;
+  event->dnd.time = timestamp;
+  event->dnd.x_root = x_root;
+  event->dnd.y_root = y_root;
+
+  gdk_drag_context_ref (new_context);
+  current_dest_drag = new_context;
+
+  return GDK_FILTER_TRANSLATE;
+}  
+
+GdkFilterReturn
+motif_drag_status (GdkEvent *event,
+		   guint16   flags,
+		   guint32   timestamp)
+{
+  GdkDragContext *context;
+  
+  GDK_NOTE (DND, 
+	    g_message ("Motif status message: flags %x", flags));
+
+  context = gdk_drag_context_find (TRUE, 
+				   GDK_WINDOW_XWINDOW (event->any.window), 
+				   None);
+
+  if (context)
+    {
+      GdkDragContextPrivate *private = (GdkDragContextPrivate *)context;
+      if (private->drag_status == GDK_DRAG_STATUS_MOTION_WAIT)
+	private->drag_status = GDK_DRAG_STATUS_DRAG;
+      
+      event->dnd.type = GDK_DRAG_STATUS;
+      event->dnd.send_event = FALSE;
+      event->dnd.context = context;
+      gdk_drag_context_ref (context);
+
+      event->dnd.time = timestamp;
+
+      if ((flags & 0x00f0) >> 4 == XmDROP_SITE_VALID)
+	{
+	  switch (flags & 0x000f)
+	    {
+	    case XmDROP_NOOP:
+	      context->action = 0;
+	      break;
+	    case XmDROP_MOVE:
+		context->action = GDK_ACTION_MOVE;
+		break;
+	    case XmDROP_COPY:
+	      context->action = GDK_ACTION_COPY;
+	      break;
+	    case XmDROP_LINK:
+	      context->action = GDK_ACTION_LINK;
+	      break;
+	    }
+	}
+      else
+	context->action = 0;
+
+      return GDK_FILTER_TRANSLATE;
+    }
+  return GDK_FILTER_REMOVE;
+}
+
+GdkFilterReturn
+motif_dnd_filter (GdkXEvent *xev,
+		  GdkEvent  *event,
+		  gpointer data)
+{
+  XEvent *xevent = (XEvent *)xev;
+  XClientMessageEvent *xce = &xevent->xclient;
+
+  guint8 reason;
+  gchar byte_order;
+  guint16 flags;
+  guint32 timestamp;
+  guint32 source_window;
+  GdkAtom atom;
+  gint16 x_root, y_root;
+  gboolean is_reply;
+  
+  /* First read some fields common to all Motif DND messages */
+
+  reason = xce->data.b[0];
+  byte_order = xce->data.b[1];
+  flags = card16_to_host (xce->data.s[1], byte_order);
+  timestamp = card32_to_host (xce->data.l[1], byte_order);
+
+  is_reply = ((reason & 0x80) != 0);
+
+  switch (reason & 0x7f)
+    {
+    case XmTOP_LEVEL_ENTER:
+      source_window = card32_to_host (xce->data.l[2], byte_order);
+      atom = card32_to_host (xce->data.l[3], byte_order);
+      return motif_top_level_enter (event, flags, timestamp, source_window, atom);
+    case XmTOP_LEVEL_LEAVE:
+      return motif_top_level_leave (event, flags, timestamp);
+
+    case XmDRAG_MOTION:
+      x_root = card16_to_host (xce->data.s[4], byte_order);
+      y_root = card16_to_host (xce->data.s[5], byte_order);
+      
+      if (!is_reply)
+	return motif_motion (event, flags, timestamp, x_root, y_root);
+      else
+	return motif_drag_status (event, flags, timestamp);
+
+    case XmDROP_SITE_ENTER:
+      return motif_drag_status (event, flags, timestamp);
+
+    case XmDROP_SITE_LEAVE:
+      return motif_drag_status (event,
+				XmNO_DROP_SITE << 8 | XmDROP_NOOP, 
+				timestamp);
+    case XmDROP_START:
+      x_root = card16_to_host (xce->data.s[4], byte_order);
+      y_root = card16_to_host (xce->data.s[5], byte_order);
+      atom = card32_to_host (xce->data.l[3], byte_order);
+      source_window = card32_to_host (xce->data.l[4], byte_order);
+
+      if (!is_reply)
+	return motif_drop_start (event, flags, timestamp, source_window, atom, x_root, y_root);
+      
+     break;
+    case XmOPERATION_CHANGED:
+      if (!is_reply)
+	return motif_operation_changed (event, flags, timestamp);
+      else
+	return motif_drag_status (event, flags, timestamp);
+
+      break;
+      /* To the best of my knowledge, these next two messages are 
+       * not part of the protocol, though they are defined in
+       * the header files.
+       */
+    case XmDROP_FINISH:
+    case XmDRAG_DROP_FINISH:
+      break;
+    }
+
+  return GDK_FILTER_REMOVE;
+}
+
+/*************************************************************
+ ***************************** XDND **************************
+ *************************************************************/
+
+/* Utility functions */
+
+static struct {
+  gchar *name;
+  GdkAtom atom;
+  GdkDragAction action;
+} xdnd_actions_table[] = {
+    { "XdndActionCopy",    GDK_NONE, GDK_ACTION_COPY },
+    { "XdndActionMove",    GDK_NONE, GDK_ACTION_MOVE },
+    { "XdndActionLink",    GDK_NONE, GDK_ACTION_LINK },
+    { "XdndActionAsk",     GDK_NONE, GDK_ACTION_ASK  },
+    { "XdndActionPrivate", GDK_NONE, GDK_ACTION_COPY },
+  };
+
+static const gint xdnd_n_actions = sizeof(xdnd_actions_table) / sizeof(xdnd_actions_table[0]);
+static gboolean xdnd_actions_initialized = FALSE;
+
+static void
+xdnd_initialize_actions (void)
+{
+  gint i;
+  
+  xdnd_actions_initialized = TRUE;
+  for (i=0; i < xdnd_n_actions; i++)
+    xdnd_actions_table[i].atom = gdk_atom_intern (xdnd_actions_table[i].name, FALSE);
+}
+
+static GdkDragAction
+xdnd_action_from_atom (GdkAtom atom)
+{
+  gint i;
+
+  if (!xdnd_actions_initialized)
+    xdnd_initialize_actions();
+
+  for (i=0; i<xdnd_n_actions; i++)
+    if (atom == xdnd_actions_table[i].atom)
+      return xdnd_actions_table[i].action;
+
+  return 0;
+}
+
+static GdkAtom
+xdnd_action_to_atom (GdkDragAction action)
+{
+  gint i;
+
+  if (!xdnd_actions_initialized)
+    xdnd_initialize_actions();
+
+  for (i=0; i<xdnd_n_actions; i++)
+    if (action == xdnd_actions_table[i].action)
+      return xdnd_actions_table[i].atom;
+
+  return GDK_NONE;
+}
+
+static GdkAtom xdnd_aware_atom = GDK_NONE;
+
+/* Source side */
+
+static GdkFilterReturn 
+xdnd_status_filter (GdkXEvent *xev,
+		    GdkEvent  *event,
+		    gpointer   data)
+{
+  XEvent *xevent = (XEvent *)xev;
+  guint32 dest_window = xevent->xclient.data.l[0];
+  guint32 flags = xevent->xclient.data.l[1];
+  GdkAtom action = xevent->xclient.data.l[4];
+  GdkDragContext *context;
+  
+  GDK_NOTE (DND, 
+	    g_message ("XdndStatus: dest_window: %#x  action: %ld",
+		       dest_window, action));
+
+  
+  context = gdk_drag_context_find (TRUE, xevent->xclient.window, dest_window);
+  if (context)
+    {
+      GdkDragContextPrivate *private = (GdkDragContextPrivate *)context;
+      if (private->drag_status == GDK_DRAG_STATUS_MOTION_WAIT)
+	private->drag_status = GDK_DRAG_STATUS_DRAG;
+      
+      event->dnd.send_event = FALSE;
+      event->dnd.type = GDK_DRAG_STATUS;
+      event->dnd.context = context;
+      gdk_drag_context_ref (context);
+
+      event->dnd.time = GDK_CURRENT_TIME; /* FIXME? */
+      if (!(action != 0) != !(flags & 1))
+	{
+	  GDK_NOTE (DND,
+		    g_warning ("Received status event with flags not corresponding to action!\n"));
+	  action = 0;
+	}
+
+      context->action = xdnd_action_from_atom (action);
+
+      return GDK_FILTER_TRANSLATE;
+    }
+
+  return GDK_FILTER_REMOVE;
+}
+
+static GdkFilterReturn 
+xdnd_finished_filter (GdkXEvent *xev,
+		      GdkEvent  *event,
+		      gpointer   data)
+{
+  XEvent *xevent = (XEvent *)xev;
+  guint32 dest_window = xevent->xclient.data.l[0];
+  GdkDragContext *context;
+  
+  GDK_NOTE (DND, 
+	    g_message ("XdndFinished: dest_window: %#x", dest_window));
+
+  context = gdk_drag_context_find (TRUE, xevent->xclient.window, dest_window);
+  if (context)
+    {
+      event->dnd.type = GDK_DROP_FINISHED;
+      event->dnd.context = context;
+      gdk_drag_context_ref (context);
+
+      return GDK_FILTER_TRANSLATE;
+    }
+
+  return GDK_FILTER_REMOVE;
+}
+
+static void
+xdnd_set_targets (GdkDragContext *context)
+{
+  GdkDragContextPrivate *private = (GdkDragContextPrivate *)context;
+  GdkAtom *typelist;
+  GList *tmp_list = context->targets;
+  gint i;
+  gint n_targets = g_list_length (context->targets);
+
+  typelist = g_new (GdkAtom, n_targets);
+  i = 0;
+  while (tmp_list)
+    {
+      typelist[i] = GPOINTER_TO_INT (tmp_list->data);
+      tmp_list = tmp_list->next;
+      i++;
+    }
+
+  XChangeProperty (GDK_WINDOW_XDISPLAY (context->source_window),
+		   GDK_WINDOW_XWINDOW (context->source_window),
+		   gdk_atom_intern ("XdndTypeList", FALSE),
+		   XA_ATOM, 32, PropModeReplace,
+		   (guchar *)typelist, n_targets);
+
+  private->xdnd_targets_set = 1;
+}
+
+static void
+xdnd_send_enter (GdkDragContext *context)
+{
+  XEvent xev;
+  GdkDragContextPrivate *private = (GdkDragContextPrivate *)context;
+
+  xev.xclient.type = ClientMessage;
+  xev.xclient.message_type = gdk_atom_intern ("XdndEnter", FALSE);
+  xev.xclient.format = 32;
+  xev.xclient.window = GDK_WINDOW_XWINDOW (context->dest_window);
+  xev.xclient.data.l[0] = GDK_WINDOW_XWINDOW (context->source_window);
+  xev.xclient.data.l[1] = (3 << 24); /* version */
+  xev.xclient.data.l[2] = 0;
+  xev.xclient.data.l[3] = 0;
+  xev.xclient.data.l[4] = 0;
+
+  if (!private->xdnd_selection)
+    private->xdnd_selection = gdk_atom_intern ("XdndSelection", FALSE);
+
+  if (g_list_length (context->targets) > 3)
+    {
+      if (!private->xdnd_targets_set)
+	xdnd_set_targets (context);
+      xev.xclient.data.l[1] |= 1;
+    }
+  else
+    {
+      GList *tmp_list = context->targets;
+      gint i = 2;
+
+      while (tmp_list)
+	{
+	  xev.xclient.data.l[i] = GPOINTER_TO_INT (tmp_list->data);
+	  tmp_list = tmp_list->next;
+	  i++;
+	}
+    }
+
+  if (!gdk_send_xevent (GDK_WINDOW_XWINDOW (context->dest_window),
+			FALSE, 0, &xev))
+    {
+      GDK_NOTE (DND, 
+		g_message ("Send event to %lx failed",
+			   GDK_WINDOW_XWINDOW (context->dest_window)));
+      gdk_window_unref (context->dest_window);
+      context->dest_window = NULL;
+    }
+}
+
+static void
+xdnd_send_leave (GdkDragContext *context)
+{
+  XEvent xev;
+
+  xev.xclient.type = ClientMessage;
+  xev.xclient.message_type = gdk_atom_intern ("XdndLeave", FALSE);
+  xev.xclient.format = 32;
+  xev.xclient.window = GDK_WINDOW_XWINDOW (context->dest_window);
+  xev.xclient.data.l[0] = GDK_WINDOW_XWINDOW (context->source_window);
+  xev.xclient.data.l[1] = 0;
+  xev.xclient.data.l[2] = 0;
+  xev.xclient.data.l[3] = 0;
+  xev.xclient.data.l[4] = 0;
+
+  if (!gdk_send_xevent (GDK_WINDOW_XWINDOW (context->dest_window),
+			FALSE, 0, &xev))
+    {
+      GDK_NOTE (DND, 
+		g_message ("Send event to %lx failed",
+			   GDK_WINDOW_XWINDOW (context->dest_window)));
+      gdk_window_unref (context->dest_window);
+      context->dest_window = NULL;
+    }
+}
+
+static void
+xdnd_send_drop (GdkDragContext *context, guint32 time)
+{
+  XEvent xev;
+
+  xev.xclient.type = ClientMessage;
+  xev.xclient.message_type = gdk_atom_intern ("XdndDrop", FALSE);
+  xev.xclient.format = 32;
+  xev.xclient.window = GDK_WINDOW_XWINDOW (context->dest_window);
+  xev.xclient.data.l[0] = GDK_WINDOW_XWINDOW (context->source_window);
+  xev.xclient.data.l[1] = 0;
+  xev.xclient.data.l[2] = time;
+  xev.xclient.data.l[3] = 0;
+  xev.xclient.data.l[4] = 0;
+
+  if (!gdk_send_xevent (GDK_WINDOW_XWINDOW (context->dest_window),
+			FALSE, 0, &xev))
+    {
+      GDK_NOTE (DND, 
+		g_message ("Send event to %lx failed",
+			   GDK_WINDOW_XWINDOW (context->dest_window)));
+      gdk_window_unref (context->dest_window);
+      context->dest_window = NULL;
+    }
+}
+
+static void
+xdnd_send_motion (GdkDragContext *context,
+		  gint            x_root, 
+		  gint            y_root,
+		  GdkDragAction   action,
+		  guint32         time)
+{
+  GdkDragContextPrivate *private = (GdkDragContextPrivate *)context;
+  XEvent xev;
+
+  xev.xclient.type = ClientMessage;
+  xev.xclient.message_type = gdk_atom_intern ("XdndPosition", FALSE);
+  xev.xclient.format = 32;
+  xev.xclient.window = GDK_WINDOW_XWINDOW (context->dest_window);
+  xev.xclient.data.l[0] = GDK_WINDOW_XWINDOW (context->source_window);
+  xev.xclient.data.l[1] = 0;
+  xev.xclient.data.l[2] = (x_root << 16) | y_root;
+  xev.xclient.data.l[3] = time;
+  xev.xclient.data.l[4] = xdnd_action_to_atom (action);
+
+  if (!gdk_send_xevent (GDK_WINDOW_XWINDOW (context->dest_window),
+			FALSE, 0, &xev))
+    {
+      GDK_NOTE (DND, 
+		g_message ("Send event to %lx failed",
+			   GDK_WINDOW_XWINDOW (context->dest_window)));
+      gdk_window_unref (context->dest_window);
+      context->dest_window = NULL;
+    }
+  private->drag_status = GDK_DRAG_STATUS_MOTION_WAIT;
+}
+
+static gboolean
+xdnd_check_dest (Window win)
+{
+  gboolean retval = FALSE;
+  Atom type = None;
+  int format;
+  unsigned long nitems, after;
+  GdkAtom *version;
+
+  if (!xdnd_aware_atom)
+    xdnd_aware_atom = gdk_atom_intern ("XdndAware", FALSE);
+
+  XGetWindowProperty (gdk_display, win, 
+		      xdnd_aware_atom, 0, 
+		      1, False, AnyPropertyType,
+		      &type, &format, &nitems, &after, 
+		      (guchar **)&version);
+  
+  if (type != None)
+    {
+      if ((format == 32) && (nitems == 1))
+	{
+	  if (*version == 3)
+	    retval = TRUE;
+	}
+      else
+	GDK_NOTE (DND, 
+		  g_warning ("Invalid XdndAware property on window %ld\n", win));
+
+      XFree (version);
+    }
+
+  return retval;
+}
+
+/* Target side */
+
+static GdkFilterReturn 
+xdnd_enter_filter (GdkXEvent *xev,
+		   GdkEvent  *event,
+		   gpointer   data)
+{
+  XEvent *xevent = (XEvent *)xev;
+  GdkDragContext *new_context;
+  gint i;
+  
+  guint32 source_window = xevent->xclient.data.l[0];
+  gboolean get_types = ((xevent->xclient.data.l[1] & 1) != 0);
+  gint version = (xevent->xclient.data.l[1] & 0xff000000) >> 24;
+  
+  GDK_NOTE (DND, 
+	    g_message ("XdndEnter: source_window: %#x, version: %#x",
+		       source_window, version));
+
+  if (version != 3)
+    {
+      /* Old source ignore */
+      GDK_NOTE (DND, g_message ("Ignored old XdndEnter message"));
+      return GDK_FILTER_REMOVE;
+    }
+  
+  if (current_dest_drag != NULL)
+    {
+      gdk_drag_context_unref (current_dest_drag);
+      current_dest_drag = NULL;
+    }
+
+  new_context = gdk_drag_context_new ();
+  new_context->protocol = GDK_DRAG_PROTO_XDND;
+  new_context->is_source = FALSE;
+
+  new_context->source_window = gdk_window_lookup (source_window);
+  if (new_context->source_window)
+    gdk_window_ref (new_context->source_window);
+  else
+    {
+      new_context->source_window = gdk_window_foreign_new (source_window);
+      if (!new_context->source_window)
+	{
+	  gdk_drag_context_unref (new_context);
+	  return GDK_FILTER_REMOVE;
+	}
+    }
+  new_context->dest_window = event->any.window;
+  gdk_window_ref (new_context->dest_window);
+
+  new_context->targets = NULL;
+  if (get_types)
+    {
+      Atom type;
+      int format;
+      gulong nitems, after;
+      Atom *data;
+
+      XGetWindowProperty (GDK_WINDOW_XDISPLAY (event->any.window), 
+			  source_window, 
+			  gdk_atom_intern ("XdndTypeList", FALSE), 0, 65536,
+			  False, XA_ATOM, &type, &format, &nitems,
+			  &after, (guchar **)&data);
+
+      if ((format != 32) || (type != XA_ATOM))
+	{
+	  gdk_drag_context_unref (new_context);
+	  return GDK_FILTER_REMOVE;
+	}
+
+      for (i=0; i<nitems; i++)
+	new_context->targets = g_list_append (new_context->targets,
+					      GUINT_TO_POINTER (data[i]));
+
+      XFree(data);
+    }
+  else
+    {
+      for (i=0; i<3; i++)
+	if (xevent->xclient.data.l[2+i])
+	  new_context->targets = g_list_append (new_context->targets,
+						GUINT_TO_POINTER (xevent->xclient.data.l[2+i]));
+    }
+
+#ifdef G_ENABLE_DEBUG
+  if (gdk_debug_flags & GDK_DEBUG_DND)
+    print_target_list (new_context->targets);
+#endif /* G_ENABLE_DEBUG */
+
+  event->dnd.type = GDK_DRAG_ENTER;
+  event->dnd.context = new_context;
+  gdk_drag_context_ref (new_context);
+
+  current_dest_drag = new_context;
+  ((GdkDragContextPrivate *)new_context)->xdnd_selection = 
+    gdk_atom_intern ("XdndSelection", FALSE);
+
+  return GDK_FILTER_TRANSLATE;
+}
+
+static GdkFilterReturn 
+xdnd_leave_filter (GdkXEvent *xev,
+		   GdkEvent  *event,
+		   gpointer   data)
+{
+  XEvent *xevent = (XEvent *)xev;
+  guint32 source_window = xevent->xclient.data.l[0];
+  
+  GDK_NOTE (DND, 
+	    g_message ("XdndLeave: source_window: %#x",
+		       source_window));
+
+  if ((current_dest_drag != NULL) &&
+      (current_dest_drag->protocol == GDK_DRAG_PROTO_XDND) &&
+      (GDK_WINDOW_XWINDOW (current_dest_drag->source_window) == source_window))
+    {
+      event->dnd.type = GDK_DRAG_LEAVE;
+      /* Pass ownership of context to the event */
+      event->dnd.context = current_dest_drag;
+
+      current_dest_drag = NULL;
+
+      return GDK_FILTER_TRANSLATE;
+    }
+  else
+    return GDK_FILTER_REMOVE;
+}
+
+static GdkFilterReturn 
+xdnd_position_filter (GdkXEvent *xev,
+		      GdkEvent  *event,
+		      gpointer   data)
+{
+  XEvent *xevent = (XEvent *)xev;
+  guint32 source_window = xevent->xclient.data.l[0];
+  gint16 x_root = xevent->xclient.data.l[2] >> 16;
+  gint16 y_root = xevent->xclient.data.l[2] & 0xffff;
+  guint32 time = xevent->xclient.data.l[3];
+  GdkAtom action = xevent->xclient.data.l[4];
+  
+  GDK_NOTE (DND, 
+	    g_message ("XdndPosition: source_window: %#x  position: (%d, %d)  time: %d  action: %ld",
+		       source_window, x_root, y_root, time, action));
+
+  
+  if ((current_dest_drag != NULL) &&
+      (current_dest_drag->protocol == GDK_DRAG_PROTO_XDND) &&
+      (GDK_WINDOW_XWINDOW (current_dest_drag->source_window) == source_window))
+    {
+      event->dnd.type = GDK_DRAG_MOTION;
+      event->dnd.context = current_dest_drag;
+      gdk_drag_context_ref (current_dest_drag);
+
+      event->dnd.time = time;
+
+      current_dest_drag->suggested_action = xdnd_action_from_atom (action);
+
+      event->dnd.x_root = x_root;
+      event->dnd.y_root = y_root;
+
+      ((GdkDragContextPrivate *)current_dest_drag)->last_x = x_root;
+      ((GdkDragContextPrivate *)current_dest_drag)->last_y = y_root;
+      
+      return GDK_FILTER_TRANSLATE;
+    }
+
+  return GDK_FILTER_REMOVE;
+}
+
+static GdkFilterReturn 
+xdnd_drop_filter (GdkXEvent *xev,
+		  GdkEvent  *event,
+		  gpointer   data)
+{
+  XEvent *xevent = (XEvent *)xev;
+  guint32 source_window = xevent->xclient.data.l[0];
+  guint32 time = xevent->xclient.data.l[2];
+  
+  GDK_NOTE (DND, 
+	    g_message ("XdndDrop: source_window: %#x  time: %d",
+		       source_window, time));
+
+  if ((current_dest_drag != NULL) &&
+      (current_dest_drag->protocol == GDK_DRAG_PROTO_XDND) &&
+      (GDK_WINDOW_XWINDOW (current_dest_drag->source_window) == source_window))
+    {
+      GdkDragContextPrivate *private;
+      private = (GdkDragContextPrivate *)current_dest_drag;
+
+      event->dnd.type = GDK_DROP_START;
+
+      event->dnd.context = current_dest_drag;
+      gdk_drag_context_ref (current_dest_drag);
+
+      event->dnd.time = time;
+      event->dnd.x_root = private->last_x;
+      event->dnd.y_root = private->last_y;
+      
+      return GDK_FILTER_TRANSLATE;
+    }
+
+  return GDK_FILTER_REMOVE;
+}
+
+/*************************************************************
+ ************************** Public API ***********************
+ *************************************************************/
+
+void
+gdk_dnd_init (void)
+{
+  init_byte_order();
+
+  gdk_add_client_message_filter (
+	gdk_atom_intern ("_MOTIF_DRAG_AND_DROP_MESSAGE", FALSE),
+	motif_dnd_filter, NULL);
+  gdk_add_client_message_filter (
+	gdk_atom_intern ("XdndEnter", FALSE),
+	xdnd_enter_filter, NULL);
+  gdk_add_client_message_filter (
+	gdk_atom_intern ("XdndLeave", FALSE),
+	xdnd_leave_filter, NULL);
+  gdk_add_client_message_filter (
+	gdk_atom_intern ("XdndPosition", FALSE),
+	xdnd_position_filter, NULL);
+  gdk_add_client_message_filter (
+	gdk_atom_intern ("XdndStatus", FALSE),
+	xdnd_status_filter, NULL);
+  gdk_add_client_message_filter (
+	gdk_atom_intern ("XdndFinished", FALSE),
+	xdnd_finished_filter, NULL);
+  gdk_add_client_message_filter (
+	gdk_atom_intern ("XdndDrop", FALSE),
+	xdnd_drop_filter, NULL);
+}		      
+
+/* Source side */
+
+static void
+gdk_drag_do_leave (GdkDragContext *context, guint32 time)
+{
+  if (context->dest_window)
+    {
+      switch (context->protocol)
+	{
+	case GDK_DRAG_PROTO_MOTIF:
+	  motif_send_leave (context, time);
+	  break;
+	case GDK_DRAG_PROTO_XDND:
+	  xdnd_send_leave (context);
+	  break;
+	case GDK_DRAG_PROTO_ROOTWIN:
+	  break;
+	}
+
+      gdk_window_unref (context->dest_window);
+      context->dest_window = NULL;
+    }
+}
+
+GdkDragContext * 
+gdk_drag_begin (GdkWindow     *window,
+		GList         *targets,
+		GdkDragAction  actions)
+{
+  GList *tmp_list;
+  GdkDragContext *new_context;
+  
+  g_return_val_if_fail (window != NULL, NULL);
+
+  new_context = gdk_drag_context_new ();
+  new_context->is_source = TRUE;
+  new_context->source_window = window;
+  gdk_window_ref (window);
+
+  tmp_list = g_list_last (targets);
+  new_context->targets = NULL;
+  while (tmp_list)
+    {
+      new_context->targets = g_list_prepend (new_context->targets,
+					     tmp_list->data);
+      tmp_list = tmp_list->prev;
+    }
+
+  new_context->actions = actions;
+
+  return new_context;
+}
+
+gboolean         
+gdk_drag_get_protocol (guint32          xid,
+		       GdkDragProtocol *protocol)
+{
+  if (xdnd_check_dest (xid))
+    {
+      *protocol = GDK_DRAG_PROTO_XDND;
+      GDK_NOTE (DND, g_message ("Entering dnd window %#x\n", xid));
+      return TRUE;
+    }
+  else if (motif_check_dest (xid))
+    {
+      *protocol = GDK_DRAG_PROTO_MOTIF;
+      GDK_NOTE (DND, g_message ("Entering motif window %#x\n", xid));
+      return TRUE;
+    }
+  else
+    {
+      /* Check if this is a root window */
+
+      gboolean rootwin = FALSE;
+      gint old_warnings = gdk_error_warnings;
+      Atom type = None;
+      int format;
+      unsigned long nitems, after;
+      unsigned char *data;
+
+      if (xid == gdk_root_window)
+	rootwin = TRUE;
+
+      if (!rootwin)
+	{
+	  gdk_error_code = 0;
+	  
+	  XGetWindowProperty (gdk_display, xid,
+			      gdk_atom_intern ("ENLIGHTENMENT_DESKTOP", FALSE),
+			      0, 0, False, AnyPropertyType,
+			      &type, &format, &nitems, &after, &data);
+	  if ((gdk_error_code == 0) && type != None)
+	    {
+	      XFree (data);
+	      rootwin = TRUE;
+	    }
+	}
+
+      /* Until I find out what window manager the next one is for,
+       * I'm leaving it commented out. It's supported in the
+       * xscreensaver sources, though.
+       */
+#if 0
+      if (!rootwin)
 	{
-	  GDK_NOTE(DND, g_message("Cursors switched, hide & show\n"));
-	  gdk_window_hide(opix);
+	  gdk_error_code = 0;
+	  
+	  XGetWindowProperty (gdk_display, win,
+			      gdk_atom_intern ("__SWM_VROOT", FALSE),
+			      0, 0, False, AnyPropertyType,
+			      &type, &format, &nitems, &data);
+	  if ((gdk_error_code == 0) && type != None)
+	    rootwin = TRUE;
+	}
+#endif      
+
+      gdk_error_warnings = old_warnings;
+
+      if (rootwin)
+	{
+	  *protocol = GDK_DRAG_PROTO_ROOTWIN;
+	  return TRUE;
 	}
-      gdk_window_move(mypix, x - myhotspot->x, y - myhotspot->y);
-      if (change_made)
-        {
-	  gdk_window_show(mypix); /* There ought to be a way to know if
-				     a window is already mapped etc. */
-	}      
     }
-  else if(change_made)
+
+  return FALSE;
+}
+
+void
+gdk_drag_find_window (GdkDragContext  *context,
+		      GdkWindow       *drag_window,
+		      gint             x_root,
+		      gint             y_root,
+		      GdkWindow      **dest_window,
+		      GdkDragProtocol *protocol)
+{
+  GdkDragContextPrivate *private = (GdkDragContextPrivate *)context;
+  Window dest;
+
+  if (!private->window_cache)
+    private->window_cache = gdk_window_cache_new();
+
+  dest = get_client_window_at_coords (private->window_cache,
+				      drag_window ? 
+				      GDK_WINDOW_XWINDOW (drag_window) : GDK_NONE,
+				      x_root, y_root);
+
+  if (private->dest_xid != dest)
     {
-      Cursor c;
-      /* Move cursors around */
-      if(drag_ok)
-	c = gdk_dnd.c->gdk_cursor_dragok;
+      private->dest_xid = dest;
+
+      /* Check if new destination accepts drags, and which protocol */
+
+      if (gdk_drag_get_protocol (dest, protocol))
+	{
+	  *dest_window = gdk_window_lookup (dest);
+	  if (*dest_window)
+	    gdk_window_ref (*dest_window);
+	  else
+	    *dest_window = gdk_window_foreign_new (dest);
+	}
       else
-	c = gdk_dnd.c->gdk_cursor_dragdefault;
-      XChangeActivePointerGrab (gdk_display,
-				ButtonMotionMask |
-				ButtonPressMask |
-				ButtonReleaseMask |
-				EnterWindowMask | LeaveWindowMask,
-				c,
-				CurrentTime);
+	*dest_window = NULL;
+    }
+  else
+    {
+      *dest_window = context->dest_window;
+      if (*dest_window)
+	gdk_window_ref (*dest_window);
+      *protocol = context->protocol;
     }
 }
+
+gboolean        
+gdk_drag_motion (GdkDragContext *context,
+		 GdkWindow      *dest_window,
+		 GdkDragProtocol protocol,
+		 gint            x_root, 
+		 gint            y_root,
+		 GdkDragAction   action,
+		 guint32         time)
+{
+  GdkDragContextPrivate *private = (GdkDragContextPrivate *)context;
+
+  if (context->dest_window != dest_window)
+    {
+      GdkEvent temp_event;
+
+      /* Send a leave to the last destination */
+      gdk_drag_do_leave (context, time);
+      private->drag_status = GDK_DRAG_STATUS_DRAG;
+
+      /* Check if new destination accepts drags, and which protocol */
+
+      if (dest_window)
+	{
+	  context->dest_window = dest_window;
+	  gdk_window_ref (context->dest_window);
+	  context->protocol = protocol;
+
+	  switch (protocol)
+	    {
+	    case GDK_DRAG_PROTO_MOTIF:
+	      motif_send_enter (context, time);
+	      break;
+
+	    case GDK_DRAG_PROTO_XDND:
+	      xdnd_send_enter (context);
+	      break;
+
+	    case GDK_DRAG_PROTO_ROOTWIN:
+	      break;
+	    }
+	  private->old_action = action;
+	  context->suggested_action = action;
+	}
+      else
+	{
+	  context->dest_window = NULL;
+	  context->action = 0;
+	}
+
+      /* Push a status event, to let the client know that
+       * the drag changed 
+       */
+
+      temp_event.dnd.type = GDK_DRAG_STATUS;
+      temp_event.dnd.window = context->source_window;
+      /* We use this to signal a synthetic status. Perhaps
+       * we should use an extra field...
+       */
+      temp_event.dnd.send_event = TRUE;
+
+      temp_event.dnd.context = context;
+      temp_event.dnd.time = time;
+
+      gdk_event_put (&temp_event);
+    }
+  else
+    {
+      private->old_action = context->suggested_action;
+      context->suggested_action = action;
+    }
+
+  /* Send a drag-motion event */
+
+  private->last_x = x_root;
+  private->last_y = y_root;
+      
+  if (context->dest_window)
+    {
+      if (private->drag_status == GDK_DRAG_STATUS_DRAG)
+	{
+	  switch (context->protocol)
+	    {
+	    case GDK_DRAG_PROTO_MOTIF:
+	      motif_send_motion (context, x_root, y_root, action, time);
+	      break;
+	      
+	    case GDK_DRAG_PROTO_XDND:
+	      xdnd_send_motion (context, x_root, y_root, action, time);
+	      break;
+
+	    case GDK_DRAG_PROTO_ROOTWIN:
+	      {
+		GdkEvent temp_event;
+
+		if (g_list_find (context->targets,
+				 GUINT_TO_POINTER (gdk_atom_intern ("application/x-rootwin-drop", FALSE))))
+		  context->action = context->suggested_action;
+		else
+		  context->action = 0;
+
+		temp_event.dnd.type = GDK_DRAG_STATUS;
+		temp_event.dnd.window = context->source_window;
+		temp_event.dnd.send_event = FALSE;
+		temp_event.dnd.context = context;
+		temp_event.dnd.time = time;
+
+		gdk_event_put (&temp_event);
+	      }
+	      break;
+	    }
+	}
+      else
+	return TRUE;
+    }
+
+  return FALSE;
+}
+
+void
+gdk_drag_drop (GdkDragContext *context,
+	       guint32         time)
+{
+  if (context->dest_window)
+    {
+      switch (context->protocol)
+	{
+	case GDK_DRAG_PROTO_MOTIF:
+	  motif_send_leave (context, time);
+	  motif_send_drop (context, time);
+	  break;
+	  
+	case GDK_DRAG_PROTO_XDND:
+	  xdnd_send_drop (context, time);
+	  break;
+
+	case GDK_DRAG_PROTO_ROOTWIN:
+	  g_warning ("Drops for GDK_DRAG_PROTO_ROOTWIN must be handled internally");
+	  break;
+	}
+    }
+}
+
+void
+gdk_drag_abort (GdkDragContext *context,
+		guint32         time)
+{
+  gdk_drag_do_leave (context, time);
+}
+
+/* Destination side */
+
+void             
+gdk_drag_status (GdkDragContext   *context,
+		 GdkDragAction     action,
+		 guint32           time)
+{
+  GdkDragContextPrivate *private;
+  XEvent xev;
+
+  g_return_if_fail (context != 0);
+
+  private = (GdkDragContextPrivate *)context;
+
+  context->action = action;
+  
+  if (context->protocol == GDK_DRAG_PROTO_MOTIF)
+    {
+      xev.xclient.type = ClientMessage;
+      xev.xclient.message_type = gdk_atom_intern ("_MOTIF_DRAG_AND_DROP_MESSAGE", FALSE);
+      xev.xclient.format = 8;
+      xev.xclient.window = GDK_WINDOW_XWINDOW (context->source_window);
+
+      if (private->drag_status == GDK_DRAG_STATUS_ACTION_WAIT)
+	{
+	  xev.xclient.data.b[0] = XmOPERATION_CHANGED | 0x80;
+	}
+      else
+	{
+	  if ((action != 0) != (private->old_action != 0))
+	    {
+	      if (action != 0)
+		xev.xclient.data.b[0] = XmDROP_SITE_ENTER | 0x80;
+	      else
+		xev.xclient.data.b[0] = XmDROP_SITE_LEAVE | 0x80;
+	    }
+	  else
+	    xev.xclient.data.b[0] = XmDRAG_MOTION | 0x80;
+	}
+
+      xev.xclient.data.b[1] = local_byte_order;
+
+      switch (action)
+	{
+	case GDK_ACTION_MOVE:
+	  xev.xclient.data.s[1] = XmDROP_MOVE;
+	  break;
+	case GDK_ACTION_COPY:
+	  xev.xclient.data.s[1] = XmDROP_COPY;
+	  break;
+	case GDK_ACTION_LINK:
+	  xev.xclient.data.s[1] = XmDROP_LINK;
+	  break;
+	default:
+	  xev.xclient.data.s[1] = XmDROP_NOOP;
+	  break;
+	}
+
+      if (action)
+	xev.xclient.data.s[1] |= (XmDROP_SITE_VALID << 4);
+      else
+	xev.xclient.data.s[1] |= (XmNO_DROP_SITE << 4);
+
+      xev.xclient.data.l[1] = time;
+      xev.xclient.data.s[4] = private->last_x;
+      xev.xclient.data.s[5] = private->last_y;
+
+      if (!gdk_send_xevent (GDK_WINDOW_XWINDOW (context->source_window),
+		       FALSE, 0, &xev))
+	GDK_NOTE (DND, 
+		  g_message ("Send event to %lx failed",
+			     GDK_WINDOW_XWINDOW (context->source_window)));
+    }
+  else if (context->protocol == GDK_DRAG_PROTO_XDND)
+    {
+      xev.xclient.type = ClientMessage;
+      xev.xclient.message_type = gdk_atom_intern ("XdndStatus", FALSE);
+      xev.xclient.format = 32;
+      xev.xclient.window = GDK_WINDOW_XWINDOW (context->source_window);
+
+      xev.xclient.data.l[0] = GDK_WINDOW_XWINDOW (context->dest_window);
+      xev.xclient.data.l[1] = (action != 0) ? (2 | 1) : 0;
+      xev.xclient.data.l[2] = 0;
+      xev.xclient.data.l[3] = 0;
+      xev.xclient.data.l[4] = xdnd_action_to_atom (action);
+
+      if (!gdk_send_xevent (GDK_WINDOW_XWINDOW (context->source_window),
+		       FALSE, 0, &xev))
+	GDK_NOTE (DND, 
+		  g_message ("Send event to %lx failed",
+			     GDK_WINDOW_XWINDOW (context->source_window)));
+    }
+
+  private->old_action = action;
+}
+
+void 
+gdk_drop_reply (GdkDragContext   *context,
+		gboolean          ok,
+		guint32           time)
+{
+  GdkDragContextPrivate *private;
+
+  g_return_if_fail (context != 0);
+
+  private = (GdkDragContextPrivate *)context;
+  
+  if (context->protocol == GDK_DRAG_PROTO_MOTIF)
+    {
+      XEvent xev;
+
+      xev.xclient.type = ClientMessage;
+      xev.xclient.message_type = gdk_atom_intern ("_MOTIF_DRAG_AND_DROP_MESSAGE", FALSE);
+      xev.xclient.format = 8;
+
+      xev.xclient.data.b[0] = XmDROP_START | 0x80;
+      xev.xclient.data.b[1] = local_byte_order;
+      if (ok)
+	xev.xclient.data.s[2] = XmDROP_COPY | 
+	                        (XmDROP_SITE_VALID << 4) |
+	                        (XmDROP_NOOP << 8) |
+	                        (XmDROP << 12);
+      else
+	xev.xclient.data.s[2] = XmDROP_NOOP | 
+	                        (XmNO_DROP_SITE << 4) |
+	                        (XmDROP_NOOP << 8) |
+	                        (XmDROP_CANCEL << 12);
+      xev.xclient.data.s[2] = private->last_x;
+      xev.xclient.data.s[3] = private->last_y;
+      
+      gdk_send_xevent (GDK_WINDOW_XWINDOW (context->source_window),
+		       FALSE, 0, &xev);
+    }
+}
+
+void             
+gdk_drop_finish (GdkDragContext   *context,
+		 gboolean          success,
+		 guint32           time)
+{
+  if (context->protocol == GDK_DRAG_PROTO_XDND)
+    {
+      XEvent xev;
+
+      xev.xclient.type = ClientMessage;
+      xev.xclient.message_type = gdk_atom_intern ("XdndFinished", FALSE);
+      xev.xclient.format = 32;
+      xev.xclient.window = GDK_WINDOW_XWINDOW (context->source_window);
+
+      xev.xclient.data.l[0] = GDK_WINDOW_XWINDOW (context->dest_window);
+      xev.xclient.data.l[1] = 0;
+      xev.xclient.data.l[2] = 0;
+      xev.xclient.data.l[3] = 0;
+      xev.xclient.data.l[4] = 0;
+
+      if (!gdk_send_xevent (GDK_WINDOW_XWINDOW (context->source_window),
+		       FALSE, 0, &xev))
+	GDK_NOTE (DND, 
+		  g_message ("Send event to %lx failed",
+			     GDK_WINDOW_XWINDOW (context->source_window)));
+    }
+}
+
+
+void            
+gdk_window_register_dnd (GdkWindow      *window)
+{
+  static guint32 xdnd_version = 3;
+  
+  MotifDragReceiverInfo info;
+
+  /* Set Motif drag receiver information property */
+
+  if (!motif_drag_receiver_info_atom)
+    motif_drag_receiver_info_atom = gdk_atom_intern ("_MOTIF_DRAG_RECEIVER_INFO", FALSE);
+
+  info.byte_order = local_byte_order;
+  info.protocol_version = 0;
+  info.protocol_style = XmDRAG_DYNAMIC;
+  info.proxy_window = GDK_NONE;
+  info.num_drop_sites = 0;
+  info.total_size = sizeof(info);
+
+  XChangeProperty (gdk_display, GDK_WINDOW_XWINDOW (window),
+		   motif_drag_receiver_info_atom,
+		   motif_drag_receiver_info_atom,
+		   8, PropModeReplace,
+		   (guchar *)&info,
+		   sizeof (info));
+
+  /* Set XdndAware */
+
+  if (!xdnd_aware_atom)
+    xdnd_aware_atom = gdk_atom_intern ("XdndAware", FALSE);
+
+  /* The property needs to be of type XA_ATOM, not XA_INTEGER. Blech */
+  XChangeProperty (GDK_WINDOW_XDISPLAY (window), 
+		   GDK_WINDOW_XWINDOW (window),
+		   xdnd_aware_atom, XA_ATOM,
+		   32, PropModeReplace,
+		   (guchar *)&xdnd_version,
+		   sizeof (xdnd_version));
+}
+
+/*************************************************************
+ * gdk_drag_get_selection:
+ *     Returns the selection atom for the current source window
+ *   arguments:
+ *     
+ *   results:
+ *************************************************************/
+
+GdkAtom       
+gdk_drag_get_selection (GdkDragContext *context)
+{
+  g_return_val_if_fail (context != NULL, GDK_NONE);
+
+  if (context->protocol == GDK_DRAG_PROTO_MOTIF)
+    return ((GdkDragContextPrivate *)context)->motif_selection;
+  else if (context->protocol == GDK_DRAG_PROTO_XDND)
+    return ((GdkDragContextPrivate *)context)->xdnd_selection;
+  else 
+    return GDK_NONE;
+}
+
diff --git a/gdk/gdkimage.c b/gdk/gdkimage.c
index 5c7a5de5c..4d009f9f4 100644
--- a/gdk/gdkimage.c
+++ b/gdk/gdkimage.c
@@ -409,6 +409,8 @@ gdk_image_destroy (GdkImage *image)
 
     case GDK_IMAGE_SHARED:
 #ifdef USE_SHM
+      gdk_flush();
+
       XShmDetach (private->xdisplay, private->x_shm_info);
       XDestroyImage (private->ximage);
 
diff --git a/gdk/gdkprivate.h b/gdk/gdkprivate.h
index 9ed85a466..781db81b1 100644
--- a/gdk/gdkprivate.h
+++ b/gdk/gdkprivate.h
@@ -46,6 +46,7 @@ typedef struct _GdkVisualPrivate       GdkVisualPrivate;
 typedef struct _GdkFontPrivate	       GdkFontPrivate;
 typedef struct _GdkCursorPrivate       GdkCursorPrivate;
 typedef struct _GdkEventFilter	       GdkEventFilter;
+typedef struct _GdkClientFilter	       GdkClientFilter;
 typedef struct _GdkColorContextPrivate GdkColorContextPrivate;
 typedef struct _GdkRegionPrivate       GdkRegionPrivate;
 
@@ -193,6 +194,12 @@ struct _GdkEventFilter {
   gpointer data;
 };
 
+struct _GdkClientFilter {
+  GdkAtom       type;
+  GdkFilterFunc function;
+  gpointer      data;
+};
+
 #ifdef USE_XIM
 
 struct _GdkICPrivate
@@ -228,6 +235,7 @@ typedef enum {
 
 void gdk_window_init (void);
 void gdk_visual_init (void);
+void gdk_dnd_init    (void);
 
 void gdk_image_init  (void);
 void gdk_image_exit (void);
diff --git a/gdk/gdkproperty.c b/gdk/gdkproperty.c
index 38665ca0c..5b18ba71e 100644
--- a/gdk/gdkproperty.c
+++ b/gdk/gdkproperty.c
@@ -22,12 +22,21 @@
 #include "gdk.h"
 #include "gdkprivate.h"
 
-
 GdkAtom
 gdk_atom_intern (const gchar *atom_name,
 		 gint         only_if_exists)
 {
-  return XInternAtom (gdk_display, atom_name, only_if_exists);
+  GdkAtom retval;
+  static GHashTable *atom_hash = NULL;
+  
+  if (!atom_hash)
+    atom_hash = g_hash_table_new (g_str_hash, g_str_equal);
+
+  retval = GPOINTER_TO_UINT (g_hash_table_lookup (atom_hash, atom_name));
+  if (!retval)
+    retval = XInternAtom (gdk_display, atom_name, only_if_exists);
+
+  return retval;
 }
 
 gchar *
@@ -35,14 +44,16 @@ gdk_atom_name (GdkAtom atom)
 {
   gchar *t;
   gchar *name;
+  gint old_error_warnings;
 
   /* If this atom doesn't exist, we'll die with an X error unless
      we take precautions */
 
+  old_error_warnings = gdk_error_warnings;
   gdk_error_warnings = 0;
   gdk_error_code = 0;
   t = XGetAtomName (gdk_display, atom);
-  gdk_error_warnings = 1;
+  gdk_error_warnings = old_error_warnings;
 
   if (gdk_error_code == -1)
     {
@@ -115,7 +126,7 @@ gdk_property_get (GdkWindow   *window,
   if (actual_format_type)
     *actual_format_type = ret_format;
 
-  if (ret_prop_type != type)
+  if ((type != AnyPropertyType) && (ret_prop_type != type))
     {
       gchar *rn, *pn;
 
diff --git a/gdk/gdktypes.h b/gdk/gdktypes.h
index 67f9fb353..5970840e9 100644
--- a/gdk/gdktypes.h
+++ b/gdk/gdktypes.h
@@ -60,6 +60,7 @@ typedef struct _GdkFont		      GdkFont;
 typedef struct _GdkCursor	      GdkCursor;
 typedef struct _GdkColorContextDither GdkColorContextDither;
 typedef struct _GdkColorContext	      GdkColorContext;
+typedef struct _GdkDragContext        GdkDragContext;
 
 typedef struct _GdkEventAny	    GdkEventAny;
 typedef struct _GdkEventExpose	    GdkEventExpose;
@@ -74,14 +75,12 @@ typedef struct _GdkEventConfigure   GdkEventConfigure;
 typedef struct _GdkEventProperty    GdkEventProperty;
 typedef struct _GdkEventSelection   GdkEventSelection;
 typedef struct _GdkEventProximity   GdkEventProximity;
-typedef struct _GdkEventOther	    GdkEventOther;
-typedef struct _GdkEventDragBegin   GdkEventDragBegin;
-typedef struct _GdkEventDragRequest GdkEventDragRequest;
-typedef struct _GdkEventDropEnter   GdkEventDropEnter;
-typedef struct _GdkEventDropDataAvailable GdkEventDropDataAvailable;
-typedef struct _GdkEventDropLeave   GdkEventDropLeave;
 typedef struct _GdkEventClient	    GdkEventClient;
+
+typedef struct _GdkEventDND         GdkEventDND;
+
 typedef union  _GdkEvent	    GdkEvent;
+
 typedef struct _GdkDeviceKey	    GdkDeviceKey;
 typedef struct _GdkDeviceInfo	    GdkDeviceInfo;
 typedef struct _GdkTimeCoord	    GdkTimeCoord;
@@ -380,15 +379,15 @@ typedef enum
   GDK_SELECTION_NOTIFY	= 19,
   GDK_PROXIMITY_IN	= 20,
   GDK_PROXIMITY_OUT	= 21,
-  GDK_DRAG_BEGIN	= 22,
-  GDK_DRAG_REQUEST	= 23,
-  GDK_DROP_ENTER	= 24,
-  GDK_DROP_LEAVE	= 25,
-  GDK_DROP_DATA_AVAIL	= 26,
-  GDK_CLIENT_EVENT	= 27,
-  GDK_VISIBILITY_NOTIFY = 28,
-  GDK_NO_EXPOSE		= 29,
-  GDK_OTHER_EVENT	= 9999	/* Deprecated, use filters instead */
+  GDK_DRAG_ENTER        = 22,
+  GDK_DRAG_LEAVE        = 23,
+  GDK_DRAG_MOTION       = 24,
+  GDK_DRAG_STATUS       = 25,
+  GDK_DROP_START        = 26,
+  GDK_DROP_FINISHED     = 27,
+  GDK_CLIENT_EVENT	= 28,
+  GDK_VISIBILITY_NOTIFY = 29,
+  GDK_NO_EXPOSE		= 30,
 } GdkEventType;
 
 /* Event masks. (Used to select what types of events a window
@@ -539,24 +538,6 @@ typedef enum
   GDK_PROP_MODE_APPEND
 } GdkPropMode;
 
-/* These definitions are for version 1 of the OffiX D&D protocol,
-   taken from <OffiX/DragAndDropTypes.h> */
-typedef enum
-{
-  GDK_DNDTYPE_NOTDND = -1,
-  GDK_DNDTYPE_UNKNOWN = 0,
-  GDK_DNDTYPE_RAWDATA = 1,
-  GDK_DNDTYPE_FILE = 2,
-  GDK_DNDTYPE_FILES = 3,
-  GDK_DNDTYPE_TEXT = 4,
-  GDK_DNDTYPE_DIR = 5,
-  GDK_DNDTYPE_LINK = 6,
-  GDK_DNDTYPE_EXE = 7,
-  GDK_DNDTYPE_URL = 8,
-  GDK_DNDTYPE_MIME = 9,
-  GDK_DNDTYPE_END = 10
-} GdkDndType;
-
 /* Enums for XInput support */
 
 typedef enum
@@ -697,6 +678,22 @@ typedef enum
   GDK_OVERLAP_RECTANGLE_PART
 } GdkOverlapType;
 
+typedef enum {
+  GDK_ACTION_DEFAULT = 1 << 0,
+  GDK_ACTION_COPY    = 1 << 1,
+  GDK_ACTION_MOVE    = 1 << 2,
+  GDK_ACTION_LINK    = 1 << 3,
+  GDK_ACTION_PRIVATE = 1 << 4,
+  GDK_ACTION_ASK     = 1 << 5
+} GdkDragAction;
+
+typedef enum {
+  GDK_DRAG_PROTO_MOTIF,
+  GDK_DRAG_PROTO_XDND,
+  GDK_DRAG_PROTO_ROOTWIN	/* A root window with nobody claiming
+				 * drags */
+} GdkDragProtocol;
+
 /* The color type.
  *   A color consists of red, green and blue values in the
  *    range 0-65535 and a pixel value. The pixel value is highly
@@ -938,6 +935,25 @@ struct _GdkTimeCoord
   gdouble ytilt;
 };
 
+/* Structure that holds information about a drag in progress.
+ * this is used on both source and destination sides.
+ */
+struct _GdkDragContext {
+  GdkDragProtocol protocol;
+  
+  gboolean is_source;
+  
+  GdkWindow *source_window;
+  GdkWindow *dest_window;
+
+  GList *targets;
+  GdkDragAction actions;
+  GdkDragAction suggested_action;
+  GdkDragAction action; 
+
+  guint32 start_time;
+};
+
 /* Event filtering */
 
 typedef void GdkXEvent;	  /* Can be cast to XEvent */
@@ -1096,100 +1112,6 @@ struct _GdkEventProximity
   guint32 deviceid;
 };
 
-struct _GdkEventDragRequest
-{
-  GdkEventType type;
-  GdkWindow *window;
-  gint8 send_event;
-  guint32 requestor;
-  union {
-    struct {
-      guint protocol_version:4;
-      guint sendreply:1;
-      guint willaccept:1;
-      guint delete_data:1; /* Do *not* delete if link is sent, only
-			      if data is sent */
-      guint senddata:1;
-      guint reserved:22;
-    } flags;
-    glong allflags;
-  } u;
-  guint8 isdrop; /* This gdk event can be generated by a couple of
-		    X events - this lets the app know whether the
-		    drop really occurred or we just set the data */
-
-  GdkPoint drop_coords;
-  gchar *data_type;
-  guint32 timestamp;
-};
-
-struct _GdkEventDragBegin
-{
-  GdkEventType type;
-  GdkWindow *window;
-  gint8 send_event;
-  union {
-    struct {
-      guint protocol_version:4;
-      guint reserved:28;
-    } flags;
-    glong allflags;
-  } u;
-};
-
-struct _GdkEventDropEnter
-{
-  GdkEventType type;
-  GdkWindow *window;
-  gint8 send_event;
-  guint32 requestor;
-  union {
-    struct {
-      guint protocol_version:4;
-      guint sendreply:1;
-      guint extended_typelist:1;
-      guint reserved:26;
-    } flags;
-    glong allflags;
-  } u;
-};
-
-struct _GdkEventDropLeave
-{
-  GdkEventType type;
-  GdkWindow *window;
-  gint8 send_event;
-  guint32 requestor;
-  union {
-    struct {
-      guint protocol_version:4;
-      guint reserved:28;
-    } flags;
-    glong allflags;
-  } u;
-};
-
-struct _GdkEventDropDataAvailable
-{
-  GdkEventType type;
-  GdkWindow *window;
-  gint8 send_event;
-  guint32 requestor;
-  union {
-    struct {
-      guint protocol_version:4;
-      guint isdrop:1;
-      guint reserved:25;
-    } flags;
-    glong allflags;
-  } u;
-  gchar *data_type; /* MIME type */
-  gulong data_numbytes;
-  gpointer data;
-  guint32 timestamp;
-  GdkPoint coords;
-};
-
 struct _GdkEventClient
 {
   GdkEventType type;
@@ -1204,12 +1126,16 @@ struct _GdkEventClient
   } data;
 };
 
-struct _GdkEventOther
-{
+/* Event types for DND */
+
+struct _GdkEventDND {
   GdkEventType type;
   GdkWindow *window;
   gint8 send_event;
-  GdkXEvent *xevent;
+  GdkDragContext *context;
+
+  guint32 time;
+  gshort x_root, y_root;
 };
 
 union _GdkEvent
@@ -1228,13 +1154,8 @@ union _GdkEvent
   GdkEventProperty	    property;
   GdkEventSelection	    selection;
   GdkEventProximity	    proximity;
-  GdkEventDragBegin	    dragbegin;
-  GdkEventDragRequest	    dragrequest;
-  GdkEventDropEnter	    dropenter;
-  GdkEventDropLeave	    dropleave;
-  GdkEventDropDataAvailable dropdataavailable;
   GdkEventClient	    client;
-  GdkEventOther		    other;
+  GdkEventDND               dnd;
 };
 
 struct _GdkRegion
diff --git a/gdk/gdkwindow.c b/gdk/gdkwindow.c
index 7c2d9b099..3df6ac8ac 100644
--- a/gdk/gdkwindow.c
+++ b/gdk/gdkwindow.c
@@ -216,6 +216,9 @@ gdk_window_init (void)
   gdk_root_parent.height = height;
   gdk_root_parent.children = NULL;
   gdk_root_parent.colormap = NULL;
+  gdk_root_parent.ref_count = 1;
+
+  gdk_xid_table_insert (&gdk_root_window, &gdk_root_parent);
 }
 
 GdkWindow*
@@ -703,11 +706,15 @@ gdk_window_unref (GdkWindow *window)
   if (private->ref_count == 0)
     {
       if (!private->destroyed)
-	g_warning ("losing last reference to undestroyed window\n");
+	{
+	  if (private->window_type == GDK_WINDOW_FOREIGN)
+	    gdk_xid_table_remove (private->xwindow);
+	  else
+	    g_warning ("losing last reference to undestroyed window\n");
+	}
       g_dataset_destroy (window);
       g_free (window);
     }
-
 }
 
 void
@@ -1681,188 +1688,6 @@ gdk_window_shape_combine_mask (GdkWindow *window,
 #endif /* HAVE_SHAPE_EXT */
 }
 
-void
-gdk_dnd_drag_addwindow (GdkWindow *window)
-{
-  GdkWindowPrivate *window_private;
-  
-  g_return_if_fail (window != NULL);
-  
-  window_private = (GdkWindowPrivate *) window;
-  if (window_private->destroyed)
-    return;
-  
-  if (window_private->dnd_drag_enabled == 1 && gdk_dnd.drag_really == 0)
-    {
-      gdk_dnd.drag_numwindows++;
-      gdk_dnd.drag_startwindows = g_realloc (gdk_dnd.drag_startwindows,
-					     gdk_dnd.drag_numwindows
-					     * sizeof(GdkWindow *));
-      gdk_dnd.drag_startwindows[gdk_dnd.drag_numwindows - 1] = window;
-      window_private->dnd_drag_accepted = 0;
-    } 
-  else
-    g_warning ("dnd_really is 1 or drag is not enabled! can't addwindow\n");
-}
-
-void
-gdk_window_dnd_drag_set (GdkWindow   *window,
-			 guint8       drag_enable,
-			 gchar      **typelist,
-			 guint        numtypes)
-{
-  GdkWindowPrivate *window_private;
-  int i, wasset = 0;
-  
-  g_return_if_fail (window != NULL);
-  window_private = (GdkWindowPrivate *) window;
-  if (window_private->destroyed)
-    return;
-  
-  window_private->dnd_drag_enabled = drag_enable ? 1 : 0;
-  
-  if (drag_enable)
-    {
-      g_return_if_fail(typelist != NULL);
-      
-      if (window_private->dnd_drag_data_numtypesavail > 3)
-	wasset = 1;
-      window_private->dnd_drag_data_numtypesavail = numtypes;
-      
-      window_private->dnd_drag_data_typesavail =
-	g_realloc (window_private->dnd_drag_data_typesavail,
-		   (numtypes + 1) * sizeof (GdkAtom));
-      
-      for (i = 0; i < numtypes; i++)
-	{
-	  /* Allow blanket use of ALL to get anything... */
-	  if (strcmp (typelist[i], "ALL"))
-	    window_private->dnd_drag_data_typesavail[i] =
-	      gdk_atom_intern (typelist[i], FALSE);
-	  else
-	    window_private->dnd_drag_data_typesavail[i] = None;
-	}
-      
-      /* 
-       * set our extended type list if we need to 
-       */
-      if (numtypes > 3)
-	gdk_property_change(window, gdk_dnd.gdk_XdeTypelist,
-			    XA_PRIMARY, 32, GDK_PROP_MODE_REPLACE,
-			    (guchar *)(window_private->dnd_drag_data_typesavail
-			     + (sizeof(GdkAtom) * 3)),
-			    (numtypes - 3) * sizeof(GdkAtom));
-      else if (wasset)
-	gdk_property_delete (window, gdk_dnd.gdk_XdeTypelist);
-    }
-  else
-    {
-      g_free (window_private->dnd_drag_data_typesavail);
-      window_private->dnd_drag_data_typesavail = NULL;
-      window_private->dnd_drag_data_numtypesavail = 0;
-    }
-}
-
-void
-gdk_window_dnd_drop_set (GdkWindow   *window,
-			 guint8       drop_enable,
-			 gchar      **typelist,
-			 guint        numtypes,
-			 guint8       destructive_op)
-{
-  GdkWindowPrivate *window_private;
-  int i;
-  
-  g_return_if_fail (window != NULL);
-  window_private = (GdkWindowPrivate *) window;
-  if (window_private->destroyed)
-    return;
-  
-  window_private->dnd_drop_enabled = drop_enable ? 1 : 0;
-  if (drop_enable)
-    {
-      g_return_if_fail(typelist != NULL);
-      
-      window_private->dnd_drop_data_numtypesavail = numtypes;
-      
-      window_private->dnd_drop_data_typesavail =
-	g_realloc (window_private->dnd_drop_data_typesavail,
-		   (numtypes + 1) * sizeof (GdkAtom));
-      
-      for (i = 0; i < numtypes; i++)
-	window_private->dnd_drop_data_typesavail[i] =
-	  gdk_atom_intern (typelist[i], FALSE);
-      
-      window_private->dnd_drop_destructive_op = destructive_op;
-    }
-}
-
-/* 
- * This is used to reply to a GDK_DRAG_REQUEST event
- * (which may be generated by XdeRequest or a confirmed drop... 
- */
-void
-gdk_window_dnd_data_set (GdkWindow       *window,
-			 GdkEvent        *event,
-			 gpointer         data,
-			 gulong           data_numbytes)
-{
-  GdkWindowPrivate *window_private;
-  XEvent sev;
-  GdkEventDropDataAvailable tmp_ev;
-  gchar *tmp;
-  
-  g_return_if_fail (window != NULL);
-  g_return_if_fail (event != NULL);
-  g_return_if_fail (data != NULL);
-  g_return_if_fail (data_numbytes > 0);
-  g_return_if_fail (event->type == GDK_DRAG_REQUEST);
-
-  window_private = (GdkWindowPrivate *) window;
-  g_return_if_fail (window_private->dnd_drag_accepted != 0);    
-  if (window_private->destroyed)
-    return;
-  
-  /* We set the property on our window... */
-  gdk_property_change (window, window_private->dnd_drag_data_type,
-		       XA_PRIMARY, 8, GDK_PROP_MODE_REPLACE, data,
-		       data_numbytes);
-  tmp = gdk_atom_name(window_private->dnd_drag_data_type);
-#ifdef DEBUG_DND
-  g_message("DnD type %s on window %ld\n", tmp, window_private->xwindow);
-#endif
-  g_free(tmp);
-  
-  /* 
-   * Then we send the event to tell the receiving window that the
-   * drop has happened 
-   */
-  tmp_ev.u.allflags = 0;
-  tmp_ev.u.flags.protocol_version = DND_PROTOCOL_VERSION;
-  tmp_ev.u.flags.isdrop = event->dragrequest.isdrop;
-  
-  sev.xclient.type = ClientMessage;
-  sev.xclient.format = 32;
-  sev.xclient.window = event->dragrequest.requestor;
-  sev.xclient.message_type = gdk_dnd.gdk_XdeDataAvailable;
-  sev.xclient.data.l[0] = window_private->xwindow;
-  sev.xclient.data.l[1] = tmp_ev.u.allflags;
-  sev.xclient.data.l[2] = window_private->dnd_drag_data_type;
-
-  if (event->dragrequest.isdrop)
-    sev.xclient.data.l[3] = event->dragrequest.drop_coords.x +
-      (event->dragrequest.drop_coords.y << 16);
-  else
-    sev.xclient.data.l[3] = 0;
-
-  sev.xclient.data.l[4] = event->dragrequest.timestamp;
-
-  if (!gdk_send_xevent (event->dragrequest.requestor, False,
-		       StructureNotifyMask, &sev))
-    GDK_NOTE (DND, g_message("Sending XdeDataAvailable to %#x failed\n",
-			     event->dragrequest.requestor));
-}
-
 void          
 gdk_window_add_filter     (GdkWindow     *window,
 			   GdkFilterFunc  function,
@@ -1905,7 +1730,7 @@ gdk_window_remove_filter  (GdkWindow     *window,
 			   gpointer       data)
 {
   GdkWindowPrivate *private;
-  GList *tmp_list;
+  GList *tmp_list, *node;
   GdkEventFilter *filter;
 
   private = (GdkWindowPrivate*) window;
@@ -1918,15 +1743,16 @@ gdk_window_remove_filter  (GdkWindow     *window,
   while (tmp_list)
     {
       filter = (GdkEventFilter *)tmp_list->data;
+      node = tmp_list;
       tmp_list = tmp_list->next;
 
       if ((filter->function == function) && (filter->data == data))
 	{
 	  if(private)
-	    private->filters = g_list_remove_link (private->filters, tmp_list);
+	    private->filters = g_list_remove_link (private->filters, node);
 	  else
 	    gdk_default_filters = g_list_remove_link (gdk_default_filters, tmp_list);
-	  g_list_free_1 (tmp_list);
+	  g_list_free_1 (node);
 	  g_free (filter);
 	  
 	  return;
diff --git a/gdk/x11/gdkcolor-x11.c b/gdk/x11/gdkcolor-x11.c
index 36b6c8593..f84f57025 100644
--- a/gdk/x11/gdkcolor-x11.c
+++ b/gdk/x11/gdkcolor-x11.c
@@ -179,6 +179,18 @@ gdk_colormap_unref (GdkColormap *cmap)
     gdk_colormap_real_destroy (cmap);
 }
 
+GdkVisual *
+gdk_colormap_get_visual (GdkColormap *colormap)
+{
+  GdkColormapPrivate *private;
+
+  g_return_val_if_fail (colormap != NULL, NULL);
+  
+  private = (GdkColormapPrivate *)colormap;
+
+  return private->visual;
+}
+     
 #define MIN_SYNC_TIME 2
 
 void
diff --git a/gdk/x11/gdkdnd-x11.c b/gdk/x11/gdkdnd-x11.c
index 331aad7ef..67720ad6b 100644
--- a/gdk/x11/gdkdnd-x11.c
+++ b/gdk/x11/gdkdnd-x11.c
@@ -20,157 +20,2853 @@
 #include <X11/Xatom.h>
 #include <string.h>
 #include "gdkx.h"
+#include "gdk/gdkprivate.h"
 #include "gdk.h"
 
-/* Nothing much here now, but we have to make a start some time ;-) */
+typedef struct _GdkDragContextPrivate GdkDragContextPrivate;
 
-void
-gdk_dnd_set_drag_cursors(GdkCursor *default_cursor, GdkCursor *goahead_cursor)
+typedef enum {
+  GDK_DRAG_STATUS_DRAG,
+  GDK_DRAG_STATUS_MOTION_WAIT,
+  GDK_DRAG_STATUS_ACTION_WAIT,
+  GDK_DRAG_STATUS_DROP
+} GtkDragStatus;
+
+typedef struct {
+  guint32 xid;
+  gint x, y, width, height;
+  gboolean mapped;
+} GdkCacheChild;
+
+typedef struct {
+  GList *children;
+  GHashTable *child_hash;
+  guint old_event_mask;
+} GdkWindowCache;
+
+/* Structure that holds information about a drag in progress.
+ * this is used on both source and destination sides.
+ */
+struct _GdkDragContextPrivate {
+  GdkDragContext context;
+
+  GdkAtom motif_selection;
+  GdkAtom xdnd_selection;
+  guint   ref_count;
+
+  guint16 last_x;		/* Coordinates from last event */
+  guint16 last_y;
+  GdkDragAction old_action;	/* The last action we sent to the source */
+
+  Window  dest_xid;
+  guint xdnd_targets_set : 1;   /* Whether we've already set XdndTypeList */
+  guint motif_targets_set : 1;  /* Whether we've already set motif initiator info */
+  guint drag_status : 4;	/* current status of drag */
+
+  GdkWindowCache *window_cache;
+};
+
+GdkDragContext *current_dest_drag = NULL;
+
+/* Forward declarations */
+
+static void gdk_window_cache_destroy (GdkWindowCache *cache);
+
+static void     motif_read_target_table (void);
+static GdkFilterReturn motif_dnd_filter (GdkXEvent *xev,
+					 GdkEvent  *event,
+					 gpointer   data);
+
+static GdkFilterReturn xdnd_enter_filter (GdkXEvent *xev,
+					  GdkEvent  *event,
+					  gpointer   data);
+
+static GdkFilterReturn xdnd_leave_filter (GdkXEvent *xev,
+					  GdkEvent  *event,
+					  gpointer   data);
+
+static GdkFilterReturn xdnd_position_filter (GdkXEvent *xev,
+					     GdkEvent  *event,
+					     gpointer   data);
+
+static GdkFilterReturn xdnd_status_filter (GdkXEvent *xev,
+					   GdkEvent  *event,
+					   gpointer   data);
+
+static GdkFilterReturn xdnd_finished_filter (GdkXEvent *xev,
+					    GdkEvent  *event,
+					    gpointer   data);
+
+static GdkFilterReturn xdnd_drop_filter (GdkXEvent *xev,
+					 GdkEvent  *event,
+					 gpointer   data);
+
+/* Drag Contexts */
+
+static GList *contexts;
+
+GdkDragContext *
+gdk_drag_context_new        (void)
+{
+  GdkDragContextPrivate *result;
+
+  result = g_new0 (GdkDragContextPrivate, 1);
+
+  result->ref_count = 1;
+
+  contexts = g_list_prepend (contexts, result);
+
+  return (GdkDragContext *)result;
+}
+
+void            
+gdk_drag_context_ref (GdkDragContext *context)
+{
+  ((GdkDragContextPrivate *)context)->ref_count++;
+}
+
+void            
+gdk_drag_context_unref (GdkDragContext *context)
+{
+  GdkDragContextPrivate *private = (GdkDragContextPrivate *)context;
+  private->ref_count--;
+  
+  if (private->ref_count == 0)
+    {
+      g_dataset_destroy (private);
+      
+      g_list_free (context->targets);
+
+      if (context->source_window)
+	gdk_window_unref (context->source_window);
+
+      if (context->dest_window)
+	gdk_window_unref (context->dest_window);
+
+      if (private->window_cache)
+	gdk_window_cache_destroy (private->window_cache);
+
+      contexts = g_list_remove (contexts, private);
+      g_free (private);
+    }
+}
+
+static GdkDragContext *
+gdk_drag_context_find (gboolean is_source,
+		       Window   source_xid,
+		       Window   dest_xid)
+{
+  GList *tmp_list = contexts;
+
+  while (tmp_list)
+    {
+      GdkDragContext *context = (GdkDragContext *)tmp_list->data;
+
+      if ((!context->is_source == !is_source) &&
+	  ((source_xid == None) || (context->source_window &&
+	    (GDK_WINDOW_XWINDOW (context->source_window) == source_xid))) &&
+	  ((dest_xid == None) || (context->dest_window &&
+	    (GDK_WINDOW_XWINDOW (context->dest_window) == dest_xid))))
+	return context;
+      
+      tmp_list = tmp_list->next;
+    }
+  
+  return NULL;
+}
+
+/* Utility functions */
+
+static void
+gdk_window_cache_add (GdkWindowCache *cache,
+		      guint32 xid,
+		      gint x, gint y, gint width, gint height, 
+		      gboolean mapped)
+{
+  GdkCacheChild *child = g_new (GdkCacheChild, 1);
+
+  child->xid = xid;
+  child->x = x;
+  child->y = y;
+  child->width = width;
+  child->height = height;
+  child->mapped = mapped;
+
+  cache->children = g_list_prepend (cache->children, child);
+  g_hash_table_insert (cache->child_hash, GUINT_TO_POINTER (xid), 
+		       cache->children);
+}
+
+static GdkFilterReturn
+gdk_window_cache_filter (GdkXEvent *xev,
+			 GdkEvent  *event,
+			 gpointer   data)
+{
+  XEvent *xevent = (XEvent *)xev;
+  GdkWindowCache *cache = data;
+
+  switch (xevent->type)
+    {
+    case CirculateNotify:
+      break;
+    case ConfigureNotify:
+      {
+	XConfigureEvent *xce = &xevent->xconfigure;
+	GList *node;
+
+	node = g_hash_table_lookup (cache->child_hash, 
+				    GUINT_TO_POINTER (xce->window));
+	if (node) 
+	  {
+	    GdkCacheChild *child = node->data;
+	    child->x = xce->x; 
+	    child->y = xce->y;
+	    child->width = xce->width; 
+	    child->height = xce->height;
+	    if (xce->above == None && (node->next))
+	      {
+		GList *last = g_list_last (cache->children);
+		cache->children = g_list_remove_link (cache->children, node);
+		last->next = node;
+		node->next = NULL;
+		node->prev = last;
+	      }
+	    else
+	      {
+		GList *above_node = g_hash_table_lookup (cache->child_hash, 
+							 GUINT_TO_POINTER (xce->above));
+		if (above_node && node->prev != above_node)
+		  {
+		    cache->children = g_list_remove_link (cache->children, node);
+		    node->next = above_node->next;
+		    node->prev = above_node;
+		    above_node->next = node;
+		  }
+	      }
+	  }
+	break;
+      }
+    case CreateNotify:
+      {
+	XCreateWindowEvent *xcwe = &xevent->xcreatewindow;
+	if (!g_hash_table_lookup (cache->child_hash, 
+				  GUINT_TO_POINTER (xcwe->window))) 
+	  gdk_window_cache_add (cache, xcwe->window, 
+				xcwe->x, xcwe->y, xcwe->width, xcwe->height,
+				FALSE);
+	break;
+      }
+    case DestroyNotify:
+      {
+	XDestroyWindowEvent *xdwe = &xevent->xdestroywindow;
+	GList *node;
+
+	node = g_hash_table_lookup (cache->child_hash, 
+				    GUINT_TO_POINTER (xdwe->window));
+	if (node) 
+	  {
+	    g_hash_table_remove (cache->child_hash,
+				 GUINT_TO_POINTER (xdwe->window));
+	    cache->children = g_list_remove_link (cache->children, node);
+	    g_free (node->data);
+	    g_list_free_1 (node);
+	  }
+	break;
+      }
+    case MapNotify:
+      {
+	XMapEvent *xme = &xevent->xmap;
+	GList *node;
+
+	node = g_hash_table_lookup (cache->child_hash, 
+				    GUINT_TO_POINTER (xme->window));
+	if (node) 
+	  {
+	    GdkCacheChild *child = node->data;
+	    child->mapped = TRUE;
+	  }
+	break;
+      }
+    case ReparentNotify:
+      break;
+    case UnmapNotify:
+      {
+	XMapEvent *xume = &xevent->xmap;
+	GList *node;
+
+	node = g_hash_table_lookup (cache->child_hash, 
+				    GUINT_TO_POINTER (xume->window));
+	if (node) 
+	  {
+	    GdkCacheChild *child = node->data;
+	    child->mapped = FALSE;
+	  }
+	break;
+      }
+    default:
+      return GDK_FILTER_CONTINUE;
+    }
+  return GDK_FILTER_REMOVE;
+}
+
+static GdkWindowCache *
+gdk_window_cache_new (void)
+{
+  XWindowAttributes xwa;
+  Window root, parent, *children;
+  unsigned int nchildren;
+  int i;
+  
+  gint old_warnings = gdk_error_warnings;
+  
+  GdkWindowCache *result = g_new (GdkWindowCache, 1);
+
+  result->children = NULL;
+  result->child_hash = g_hash_table_new (g_direct_hash, NULL);
+
+  XGetWindowAttributes (gdk_display, gdk_root_window, &xwa);
+  result->old_event_mask = xwa.your_event_mask;
+  XSelectInput (gdk_display, gdk_root_window,
+		result->old_event_mask | SubstructureNotifyMask);
+  gdk_window_add_filter ((GdkWindow *)&gdk_root_parent, 
+			 gdk_window_cache_filter, result);
+  
+  gdk_error_code = 0;
+  gdk_error_warnings = 0;
+
+  if (XQueryTree(gdk_display, gdk_root_window, 
+		 &root, &parent, &children, &nchildren) == 0)
+    return result;
+  
+  for (i = 0; i < nchildren ; i++)
+    {
+      XGetWindowAttributes (gdk_display, children[i], &xwa);
+
+      gdk_window_cache_add (result, children[i],
+			    xwa.x, xwa.y, xwa.width, xwa.height,
+			    xwa.map_state != IsUnmapped);
+
+      if (gdk_error_code != 0)
+	gdk_error_code = 0;
+      else
+	{
+	  gdk_window_cache_add (result, children[i],
+				xwa.x, xwa.y, xwa.width, xwa.height,
+				(xwa.map_state != IsUnmapped));
+	}
+    }
+
+  XFree (children);
+
+  gdk_error_warnings = old_warnings;
+
+  return result;
+}
+
+static void
+gdk_window_cache_destroy (GdkWindowCache *cache)
+{
+  XSelectInput (gdk_display, gdk_root_window, cache->old_event_mask);
+  gdk_window_remove_filter ((GdkWindow *)&gdk_root_parent, 
+			    gdk_window_cache_filter, cache);
+
+  g_list_foreach (cache->children, (GFunc)g_free, NULL);
+  g_list_free (cache->children);
+  g_hash_table_destroy (cache->child_hash);
+}
+
+static Window
+get_client_window_at_coords_recurse (Window  win,
+				     gint    x_root,
+				     gint    y_root)
+{
+  Window child;
+  Atom type = None;
+  int format;
+  unsigned long nitems, after;
+  unsigned char *data;
+  int dest_x, dest_y;
+  
+  static Atom wm_state_atom = None;
+
+  if (!wm_state_atom)
+    wm_state_atom = gdk_atom_intern ("WM_STATE", FALSE);
+    
+  XGetWindowProperty (gdk_display, win, 
+		      wm_state_atom, 0, 0, False, AnyPropertyType,
+		      &type, &format, &nitems, &after, &data);
+  
+  if (gdk_error_code != 0)
+    {
+      gdk_error_code = 0;
+      return None;
+    }
+
+  if (type != None)
+    {
+      XFree (data);
+      return win;
+    }
+
+  XTranslateCoordinates (gdk_display, gdk_root_window, win,
+			 x_root, y_root, &dest_x, &dest_y, &child);
+
+  if (gdk_error_code != 0)
+    {
+      gdk_error_code = 0;
+      return None;
+    }
+
+  if (child)
+    return get_client_window_at_coords_recurse (child, x_root, y_root);
+  else
+    return None;
+}
+
+Window 
+get_client_window_at_coords (GdkWindowCache *cache,
+			     Window  ignore,
+			     gint    x_root,
+			     gint    y_root)
 {
-  gdk_dnd.c->gdk_cursor_dragdefault =
-    ((GdkCursorPrivate *)default_cursor)->xcursor;
-  gdk_dnd.c->gdk_cursor_dragok = ((GdkCursorPrivate *)goahead_cursor)->xcursor;
+  GList *tmp_list;
+  Window retval = None;
+
+  gint old_warnings = gdk_error_warnings;
   
-  if(gdk_dnd.dnd_grabbed)
+  gdk_error_code = 0;
+  gdk_error_warnings = 0;
+
+  tmp_list = cache->children;
+
+  while (tmp_list && !retval)
     {
-      if(gdk_dnd.c->drag_pm_default)
-	/* We were displaying pixmaps for the drag */
+      GdkCacheChild *child = tmp_list->data;
+
+      if ((child->xid != ignore) && (child->mapped))
 	{
-	  gdk_window_hide(gdk_dnd.c->drag_pm_default);
-	  gdk_window_unref(gdk_dnd.c->drag_pm_default);
-	  if(gdk_dnd.c->drag_pm_ok)
+	  if ((x_root >= child->x) && (x_root < child->x + child->width) &&
+	      (y_root >= child->y) && (y_root < child->y + child->height))
 	    {
-	      gdk_window_hide(gdk_dnd.c->drag_pm_ok);
-	      gdk_window_unref(gdk_dnd.c->drag_pm_ok);
+	      retval = get_client_window_at_coords_recurse (child->xid,
+							    x_root, y_root);
+	      if (!retval)
+		retval = child->xid;
 	    }
-	  gdk_dnd.c->drag_pm_default = gdk_dnd.c->drag_pm_ok = NULL;
-	  g_list_free(gdk_dnd.c->xids);
-	  gdk_dnd.c->xids = NULL;
+	  
 	}
-      gdk_dnd_display_drag_cursor(-1, -1,
-				  gdk_dnd.dnd_drag_target?TRUE:FALSE,
-				  TRUE);
+      tmp_list = tmp_list->next;
     }
+
+  gdk_error_warnings = old_warnings;
+  if (retval)
+    return retval;
+  else
+    return gdk_root_window;
 }
 
-void
-gdk_dnd_set_drag_shape(GdkWindow *default_pixmapwin,
-		       GdkPoint *default_hotspot,
-		       GdkWindow *goahead_pixmapwin,
-		       GdkPoint *goahead_hotspot)
+#if 0
+static Window
+get_client_window_at_coords_recurse (Window  win,
+				     gint    x_root,
+				     gint    y_root)
 {
-  g_return_if_fail(default_pixmapwin != NULL);
+  Window child;
+  Atom type = None;
+  int format;
+  unsigned long nitems, after;
+  unsigned char *data;
+  int dest_x, dest_y;
   
-  g_list_free(gdk_dnd.c->xids); gdk_dnd.c->xids = NULL;
-  if(gdk_dnd.c->drag_pm_default)
+  static Atom wm_state_atom = None;
+
+  if (!wm_state_atom)
+    wm_state_atom = gdk_atom_intern ("WM_STATE", FALSE);
+    
+  XGetWindowProperty (gdk_display, win, 
+		      wm_state_atom, 0, 0, False, AnyPropertyType,
+		      &type, &format, &nitems, &after, &data);
+  
+  if (gdk_error_code != 0)
+    {
+      gdk_error_code = 0;
+      return None;
+    }
+
+  if (type != None)
     {
-      gdk_window_hide(gdk_dnd.c->drag_pm_default);
-      gdk_window_unref(gdk_dnd.c->drag_pm_default);
+      XFree (data);
+      return win;
     }
-  if(gdk_dnd.c->drag_pm_ok)
+
+  XTranslateCoordinates (gdk_display, gdk_root_window, win,
+			 x_root, y_root, &dest_x, &dest_y, &child);
+
+  if (gdk_error_code != 0)
     {
-      gdk_window_hide(gdk_dnd.c->drag_pm_ok);
-      gdk_window_unref(gdk_dnd.c->drag_pm_ok);
+      gdk_error_code = 0;
+      return None;
     }
+
+  if (child)
+    return get_client_window_at_coords_recurse (child, x_root, y_root);
+  else
+    return None;
+}
+
+Window 
+get_client_window_at_coords (Window  ignore,
+			     gint    x_root,
+			     gint    y_root)
+{
+  Window root, parent, *children;
+  unsigned int nchildren;
+  int i;
+  Window retval = None;
+  
+  gint old_warnings = gdk_error_warnings;
   
-  gdk_dnd.c->drag_pm_ok = NULL;
+  gdk_error_code = 0;
+  gdk_error_warnings = 0;
+
+  if (XQueryTree(gdk_display, gdk_root_window, 
+		 &root, &parent, &children, &nchildren) == 0)
+    return 0;
   
-  gdk_window_ref(default_pixmapwin);
-  gdk_dnd.c->drag_pm_default = default_pixmapwin;
-  gdk_dnd.c->default_hotspot = *default_hotspot;
-  gdk_dnd.c->xids = g_list_append(gdk_dnd.c->xids, GUINT_TO_POINTER (((GdkWindowPrivate *)default_pixmapwin)->xwindow));
-  if(goahead_pixmapwin)
+  for (i = nchildren - 1; (i >= 0) && (retval == None); i--)
+    {
+      if (children[i] != ignore)
+	{
+	  XWindowAttributes xwa;
+
+	  XGetWindowAttributes (gdk_display, children[i], &xwa);
+
+	  if (gdk_error_code != 0)
+	    gdk_error_code = 0;
+	  else if ((xwa.map_state == IsViewable) &&
+		   (x_root >= xwa.x) && (x_root < xwa.x + (gint)xwa.width) &&
+		   (y_root >= xwa.y) && (y_root < xwa.y + (gint)xwa.height))
+	    {
+	      retval = get_client_window_at_coords_recurse (children[i],
+							    x_root, y_root);
+	      if (!retval)
+		retval = children[i];
+	    }
+	}
+    }
+
+  XFree (children);
+
+  gdk_error_warnings = old_warnings;
+  if (retval)
+    return retval;
+  else
+    return gdk_root_window;
+}
+#endif
+
+/*************************************************************
+ ***************************** MOTIF *************************
+ *************************************************************/
+
+/* values used in the message type for Motif DND */
+enum {
+    XmTOP_LEVEL_ENTER,
+    XmTOP_LEVEL_LEAVE,
+    XmDRAG_MOTION,
+    XmDROP_SITE_ENTER,
+    XmDROP_SITE_LEAVE,
+    XmDROP_START,
+    XmDROP_FINISH,
+    XmDRAG_DROP_FINISH,
+    XmOPERATION_CHANGED
+};
+
+/* Values used to specify type of protocol to use */
+enum {
+    XmDRAG_NONE,
+    XmDRAG_DROP_ONLY,
+    XmDRAG_PREFER_PREREGISTER,
+    XmDRAG_PREREGISTER,
+    XmDRAG_PREFER_DYNAMIC,
+    XmDRAG_DYNAMIC,
+    XmDRAG_PREFER_RECEIVER
+};
+
+/* Operation codes */
+enum {
+  XmDROP_NOOP,
+  XmDROP_MOVE = 0x01,
+  XmDROP_COPY = 0x02,
+  XmDROP_LINK = 0x04
+};
+
+/* Drop site status */
+enum {
+  XmNO_DROP_SITE = 0x01,
+  XmDROP_SITE_INVALID = 0x02,
+  XmDROP_SITE_VALID = 0x03
+};
+
+/* completion status */
+enum {
+  XmDROP,
+  XmDROP_HELP,
+  XmDROP_CANCEL,
+  XmDROP_INTERRUPT
+};
+
+/* Static data for MOTIF DND */
+static GList **motif_target_lists = NULL;
+static gint motif_n_target_lists = -1;
+
+/* Byte swapping routines. The motif specification leaves it
+ * up to us to save a few bytes in the client messages
+ */
+static gchar local_byte_order = '\0';
+
+#ifdef G_ENABLE_DEBUG
+static void
+print_target_list (GList *targets)
+{
+  while (targets)
+    {
+      gchar *name = gdk_atom_name (GPOINTER_TO_INT (targets->data));
+      g_message ("\t%s", name);
+      g_free (name);
+      targets = targets->next;
+    }
+}
+#endif /* G_ENABLE_DEBUG */
+
+static void
+init_byte_order (void)
+{
+  guint32 myint = 0x01020304;
+  local_byte_order = (*(gchar *)&myint == 1) ? 'B' : 'l';
+}
+
+static guint16
+card16_to_host (guint16 x, gchar byte_order) {
+  if (byte_order == local_byte_order)
+    return x;
+  else
+    return (x << 8) | (x >> 8);
+}
+
+static guint32
+card32_to_host (guint32 x, gchar byte_order) {
+  if (byte_order == local_byte_order)
+    return x;
+  else
+    return (x << 24) | ((x & 0xff00) << 8) | ((x & 0xff0000) >> 8) | (x >> 24);
+}
+
+
+/***** Dest side ***********/
+
+/* Property placed on source windows */
+typedef struct _MotifDragInitiatorInfo {
+  guint8 byte_order;
+  guint8 protocol_version;
+  guint16 targets_index;
+  guint32 selection_atom;
+} MotifDragInitiatorInfo;
+
+/* Header for target table on the drag window */
+typedef struct _MotifTargetTableHeader {
+  guchar byte_order;
+  guchar protocol_version;
+  guint16 n_lists;
+  guint32 total_size;
+} MotifTargetTableHeader;
+
+/* Property placed on target windows */
+typedef struct _MotifDragReceiverInfo {
+  guint8 byte_order;
+  guint8 protocol_version;
+  guint8 protocol_style;
+  guint8 pad;
+  guint32 proxy_window;
+  guint16 num_drop_sites;
+  guint16 padding;
+  guint32 total_size;
+} MotifDragReceiverInfo;
+
+static Window motif_drag_window = None;
+static GdkWindow *motif_drag_gdk_window = NULL;
+
+static GdkAtom motif_drag_targets_atom = GDK_NONE;
+static GdkAtom motif_drag_receiver_info_atom = GDK_NONE;
+
+/* Target table handling */
+
+GdkFilterReturn
+motif_drag_window_filter (GdkXEvent *xevent,
+			  GdkEvent  *event,
+			  gpointer data)
+{
+  XEvent *xev = (XEvent *)xevent;
+
+  switch (xev->xany.type)
     {
-      gdk_window_ref(goahead_pixmapwin);
-      gdk_dnd.c->xids = g_list_append(gdk_dnd.c->xids, GUINT_TO_POINTER (((GdkWindowPrivate *)goahead_pixmapwin)->xwindow));
-      gdk_dnd.c->drag_pm_ok = goahead_pixmapwin;
-      gdk_dnd.c->ok_hotspot = *goahead_hotspot;
+    case DestroyNotify:
+      motif_drag_window = None;
+      motif_drag_gdk_window = NULL;
+      break;
+    case PropertyNotify:
+      if (motif_target_lists &&
+	  motif_drag_targets_atom &&
+	  (xev->xproperty.atom == motif_drag_targets_atom))
+	motif_read_target_table();
+      break;
     }
+  return GDK_FILTER_REMOVE;
+}
+
+static GdkAtom motif_drag_window_atom = GDK_NONE;
+
+static Window
+motif_lookup_drag_window (Display *display)
+{
+  Window retval = None;
+  gulong bytes_after, nitems;
+  GdkAtom type;
+  gint format;
+  guchar *data;
+
+  XGetWindowProperty (gdk_display, gdk_root_window, motif_drag_window_atom,
+		      0, sizeof(Window)/4, FALSE,
+		      XA_WINDOW, &type, &format, &nitems, &bytes_after,
+		      &data);
   
-  if(gdk_dnd.dnd_grabbed)
+  if ((format == 8*sizeof(Window)) && (nitems == 1) && (bytes_after == 0))
     {
-      gdk_dnd_display_drag_cursor(-1, -1,
-				  gdk_dnd.dnd_drag_target?TRUE:FALSE,
-				  TRUE);
-      XChangeActivePointerGrab (gdk_display,
-				ButtonMotionMask |
-				ButtonPressMask |
-				ButtonReleaseMask |
-				EnterWindowMask | LeaveWindowMask,
-				None,
-				CurrentTime);      
+      retval = *(Window *)data;
+      GDK_NOTE(DND, 
+	       g_message ("Found drag window %#lx\n", motif_drag_window));
     }
+
+  if (type != None)
+    XFree (data);
+
+  return retval;
 }
 
-void
-gdk_dnd_display_drag_cursor(gint x, gint y, gboolean drag_ok,
-			    gboolean change_made)
+/* Finds the window where global Motif drag information is stored.
+ * If it doesn't exist and 'create' is TRUE, create one.
+ */
+Window 
+motif_find_drag_window (gboolean create)
+{
+  if (!motif_drag_window)
+    {
+      if (!motif_drag_window_atom)
+	motif_drag_window_atom = gdk_atom_intern ("_MOTIF_DRAG_WINDOW", TRUE);
+
+      motif_drag_window = motif_lookup_drag_window (gdk_display);
+      
+      if (!motif_drag_window && create)
+	{
+	  /* Create a persistant window. (Copied from LessTif) */
+	  
+	  Display *display;
+	  XSetWindowAttributes attr;
+	  display = XOpenDisplay (NULL);
+	  XSetCloseDownMode (display, RetainPermanent);
+
+	  XGrabServer (display);
+	  
+	  motif_drag_window = motif_lookup_drag_window (display);
+
+	  if (!motif_drag_window)
+	    {
+	      attr.override_redirect = True;
+	      attr.event_mask = PropertyChangeMask;
+	      
+	      motif_drag_window = 
+		XCreateWindow(display, DefaultRootWindow(display),
+			      -100, -100, 10, 10, 0, 0,
+			      InputOnly, CopyFromParent,
+			      (CWOverrideRedirect | CWEventMask), &attr);
+	      
+	      GDK_NOTE (DND,
+			g_message ("Created drag window %#lx\n", motif_drag_window));
+	      
+	      XChangeProperty (display, gdk_root_window,
+			       motif_drag_window_atom, XA_WINDOW,
+			       32, PropModeReplace,
+			       (guchar *)&motif_drag_window_atom, 1);
+
+	    }
+	  XUngrabServer (display);
+	  XCloseDisplay (display);
+	}
+
+      /* There is a miniscule race condition here if the drag window
+       * gets destroyed exactly now.
+       */
+      if (motif_drag_window)
+	{
+	  motif_drag_gdk_window = gdk_window_foreign_new (motif_drag_window);
+	  gdk_window_add_filter (motif_drag_gdk_window,
+				 motif_drag_window_filter,
+				 NULL);
+	}
+    }
+
+  return motif_drag_window;
+}
+
+static void 
+motif_read_target_table (void)
 {
-  if(!gdk_dnd.dnd_grabbed)
-    return;
+  gulong bytes_after, nitems;
+  GdkAtom type;
+  gint format;
+  gint i, j;
+
+  if (!motif_drag_targets_atom)
+    motif_drag_targets_atom = gdk_atom_intern ("_MOTIF_DRAG_TARGETS", FALSE);
+
+  if (motif_target_lists)
+    {
+      for (i=0; i<motif_n_target_lists; i++)
+	g_list_free (motif_target_lists[i]);
+      
+      g_free (motif_target_lists);
+      motif_target_lists = NULL;
+      motif_n_target_lists = 0;
+    }
+
+  if (motif_find_drag_window (FALSE))
+    {
+      MotifTargetTableHeader *header = NULL;
+      guchar *target_bytes = NULL;
+      guchar *p;
+      gboolean success = FALSE;
+
+      XGetWindowProperty (gdk_display, motif_drag_window, 
+			  motif_drag_targets_atom,
+			  0, (sizeof(MotifTargetTableHeader)+3)/4, FALSE,
+			  motif_drag_targets_atom, 
+			  &type, &format, &nitems, &bytes_after,
+			  (guchar **)&header);
+
+      if ((format != 8) || (nitems < sizeof (MotifTargetTableHeader)))
+	goto error;
+
+      header->n_lists = card16_to_host (header->n_lists, header->byte_order);
+      header->total_size = card32_to_host (header->total_size, header->byte_order);
+
+      XGetWindowProperty (gdk_display, motif_drag_window, motif_drag_targets_atom,
+			  (sizeof(MotifTargetTableHeader)+3)/4, 
+			  (header->total_size - sizeof(MotifTargetTableHeader) + 3)/4,
+			  FALSE,
+			  motif_drag_targets_atom, &type, &format, &nitems, 
+			  &bytes_after, &target_bytes);
+      
+      if ((format != 8) || (bytes_after != 0) || 
+	  (nitems != header->total_size - sizeof(MotifTargetTableHeader)))
+	  goto error;
+
+      motif_n_target_lists = header->n_lists;
+      motif_target_lists = g_new0 (GList *, motif_n_target_lists);
+
+      p = target_bytes;
+      for (i=0; i<header->n_lists; i++)
+	{
+	  gint n_targets;
+	  guint32 *targets;
+	  
+	  if (p + sizeof(guint16) - target_bytes > nitems)
+	    goto error;
+
+	  n_targets = card16_to_host (*(gushort *)p, header->byte_order);
+	  targets = (guint32 *)(p + sizeof(guint16));
+
+	  p +=  sizeof(guint16) + n_targets * sizeof(guint32);
+	  if (p - target_bytes > nitems)
+	    goto error;
+
+	  for (j=0; j<n_targets; j++)
+	    motif_target_lists[i] = 
+	      g_list_prepend (motif_target_lists[i],
+			      GUINT_TO_POINTER (card32_to_host (targets[j], 
+								header->byte_order)));
+
+	  motif_target_lists[i] = g_list_reverse (motif_target_lists[i]);
+	}
+
+      success = TRUE;
+      
+    error:
+      if (header)
+	XFree (header);
+      
+      if (target_bytes)
+	XFree (target_bytes);
+
+      if (!success)
+	{
+	  if (motif_target_lists)
+	    {
+	      g_free (motif_target_lists);
+	      motif_target_lists = NULL;
+	      motif_n_target_lists = 0;
+	    }
+	  g_warning ("Error reading Motif target table\n");
+	}
+    }
+}
+
+static gint
+targets_sort_func (gconstpointer a, gconstpointer b)
+{
+  return (GPOINTER_TO_UINT (a) < GPOINTER_TO_UINT (b)) ?
+    -1 : ((GPOINTER_TO_UINT (a) > GPOINTER_TO_UINT (b)) ? 1 : 0);
+}
+
+/* Check if given (sorted) list is in the targets table */
+static gboolean
+motif_target_table_check (GList *sorted)
+{
+  GList *tmp_list1, *tmp_list2;
+  gint i;
+
+  for (i=0; i<motif_n_target_lists; i++)
+    {
+      tmp_list1 = motif_target_lists[i];
+      tmp_list2 = sorted;
+      
+      while (tmp_list1 && tmp_list2)
+	{
+	  if (tmp_list1->data != tmp_list2->data)
+	    break;
+
+	  tmp_list1 = tmp_list1->next;
+	  tmp_list2 = tmp_list2->next;
+	}
+      if (!tmp_list1 && !tmp_list2)	/* Found it */
+	return i;
+    }
+
+  return -1;
+}
+
+static gint
+motif_add_to_target_table (GList *targets)
+{
+  GList *sorted = NULL;
+  gint index = -1;
+  gint i;
+  GList *tmp_list;
+  
+  /* make a sorted copy of the list */
   
-  if(gdk_dnd.c->drag_pm_default)
+  while (targets)
+    {
+      sorted = g_list_insert_sorted (sorted, targets->data, targets_sort_func);
+      targets = targets->next;
+    }
+
+  /* First check if it is their already */
+
+  if (motif_target_lists)
+    index = motif_target_table_check (sorted);
+
+  /* We need to grab the server while doing this, to ensure
+   * atomiticity. Ugh
+   */
+
+  if (index < 0)
     {
-      /* We're doing pixmaps here... */
-      GdkWindow *mypix, *opix;
-      GdkPoint *myhotspot;
-      gint itmp;
-      guint masktmp;
-      Window wtmp;
+      /* We need to make sure that it exists _before_ we grab the
+       * server, since we can't open a new connection after we
+       * grab the server. 
+       */
+      motif_find_drag_window (TRUE);
+
+      XGrabServer(gdk_display);
+      motif_read_target_table();
+    
+      /* Check again, in case it was added in the meantime */
       
-      if(x == -2 && y == -2) /* Hide the cursors */
+      if (motif_target_lists)
+	index =  motif_target_table_check (sorted);
+
+      if (index < 0)
 	{
-	  gdk_window_hide(gdk_dnd.c->drag_pm_ok);
-	  gdk_window_hide(gdk_dnd.c->drag_pm_default);
-	  GDK_NOTE(DND, g_message("Hiding both drag cursors\n"));
-	  return;
+	  guint32 total_size = 0;
+	  guchar *data;
+	  guchar *p;
+	  guint16 *p16;
+	  guint32 *p32;
+	  MotifTargetTableHeader *header;
+	  
+	  if (!motif_target_lists)
+	    {
+	      motif_target_lists = g_new (GList *, 1);
+	      motif_n_target_lists = 1;
+	    }
+	  else
+	    {
+	      motif_n_target_lists++;
+	      motif_target_lists = g_realloc (motif_target_lists,
+					      sizeof(GList *) * motif_n_target_lists);
+	    }
+	  motif_target_lists[motif_n_target_lists - 1] = sorted;
+	  sorted = NULL;
+	  index = motif_n_target_lists - 1;
+
+	  total_size = sizeof (MotifTargetTableHeader);
+	  for (i = 0; i < motif_n_target_lists ; i++)
+	    total_size += sizeof(guint16) + sizeof(guint32) * g_list_length (motif_target_lists[i]);
+
+	  data = g_malloc (total_size);
+
+	  header = (MotifTargetTableHeader *)data;
+	  p = data + sizeof(MotifTargetTableHeader);
+
+	  header->byte_order = local_byte_order;
+	  header->protocol_version = 0;
+	  header->n_lists = motif_n_target_lists;
+	  header->total_size = total_size;
+
+	  for (i = 0; i < motif_n_target_lists ; i++)
+	    {
+	      guint16 count = 0;
+	      
+	      p16 = (guint16 *)p;
+	      p += sizeof(guint16);
+	      p32 = (guint32 *)p;
+	      tmp_list = motif_target_lists[i];
+	      while (tmp_list)
+		{
+		  *p32++ = GPOINTER_TO_UINT (tmp_list->data);
+		  tmp_list = tmp_list->next;
+		  count++;
+		}
+	      *p16 = count;
+	      p = (guchar *)p32;
+	    }
+
+	  XChangeProperty (gdk_display, motif_drag_window,
+			   motif_drag_targets_atom,
+			   motif_drag_targets_atom,
+			   8, PropModeReplace,
+			   data, total_size);
 	}
+      XUngrabServer(gdk_display);
+    }
+
+  g_list_free (sorted);
+  return index;
+}
+
+/* Translate flags */
+
+static void
+motif_dnd_translate_flags (GdkDragContext *context, guint16 flags)
+{
+  guint recommended_op = flags & 0x000f;
+  guint possible_ops = (flags & 0x0f0) >> 4;
+  
+  switch (recommended_op)
+    {
+    case XmDROP_MOVE:
+      context->suggested_action = GDK_ACTION_MOVE;
+      break;
+    case XmDROP_COPY:
+      context->suggested_action = GDK_ACTION_COPY;
+      break;
+    case XmDROP_LINK:
+      context->suggested_action = GDK_ACTION_LINK;
+      break;
+    default:
+      context->suggested_action = GDK_ACTION_COPY;
+      break;
+    }
+
+  context->actions = 0;
+  if (possible_ops & XmDROP_MOVE)
+    context->actions |= GDK_ACTION_MOVE;
+  if (possible_ops & XmDROP_COPY)
+    context->actions |= GDK_ACTION_COPY;
+  if (possible_ops & XmDROP_LINK)
+    context->actions |= GDK_ACTION_LINK;
+}
+
+static guint16
+motif_dnd_get_flags (GdkDragContext *context)
+{
+  guint16 flags = 0;
+  
+  switch (context->suggested_action)
+    {
+    case GDK_ACTION_MOVE:
+      flags = XmDROP_MOVE;
+      break;
+    case GDK_ACTION_COPY:
+      flags = XmDROP_COPY;
+      break;
+    case GDK_ACTION_LINK:
+      flags = XmDROP_LINK;
+      break;
+    default:
+      flags = XmDROP_NOOP;
+      break;
+    }
+  
+  if (context->actions & GDK_ACTION_MOVE)
+    flags |= XmDROP_MOVE << 8;
+  if (context->actions & GDK_ACTION_COPY)
+    flags |= XmDROP_COPY << 8;
+  if (context->actions & GDK_ACTION_LINK)
+    flags |= XmDROP_LINK << 8;
+
+  return flags;
+}
+
+/* Source Side */
+
+static void
+motif_set_targets (GdkDragContext *context)
+{
+  GdkDragContextPrivate *private = (GdkDragContextPrivate *)context;
+  MotifDragInitiatorInfo info;
+  gint i;
+  static GdkAtom motif_drag_initiator_info = GDK_NONE;
+
+  if (!motif_drag_initiator_info)
+    motif_drag_initiator_info = gdk_atom_intern ("_MOTIF_DRAG_INITIATOR_INFO", FALSE);
+
+  info.byte_order = local_byte_order;
+  info.protocol_version = 0;
+  
+  info.targets_index = motif_add_to_target_table (context->targets);
+
+  for (i=0; ; i++)
+    {
+      gchar buf[20];
+      g_snprintf(buf, 20, "_GDK_SELECTION_%d", i);
       
-      if(x == -1 && y == -1) /* We're supposed to find it out for ourselves */
-	XQueryPointer(gdk_display, gdk_root_window,
-		      &wtmp, &wtmp, &x, &y, &itmp, &itmp, &masktmp);
+      private->motif_selection = gdk_atom_intern (buf, FALSE);
+      if (!XGetSelectionOwner (gdk_display, private->motif_selection))
+	break;
+    }
+
+  info.selection_atom = private->motif_selection;
+
+  XChangeProperty (GDK_WINDOW_XDISPLAY (context->source_window),
+		   GDK_WINDOW_XWINDOW (context->source_window),
+		   private->motif_selection,
+		   motif_drag_initiator_info, 8, PropModeReplace,
+		   (guchar *)&info, sizeof (info));
+
+  private->motif_targets_set = 1;
+}
+
+gboolean
+motif_check_dest (Window win)
+{
+  gboolean retval = FALSE;
+  MotifDragReceiverInfo *info;
+  Atom type = None;
+  int format;
+  unsigned long nitems, after;
+
+  if (!motif_drag_receiver_info_atom)
+    motif_drag_receiver_info_atom = gdk_atom_intern ("_MOTIF_DRAG_RECEIVER_INFO", FALSE);
+  
+  XGetWindowProperty (gdk_display, win, 
+		      motif_drag_receiver_info_atom, 
+		      0, (sizeof(*info)+3)/4, False, AnyPropertyType,
+		      &type, &format, &nitems, &after, 
+		      (guchar **)&info);
+  
+  if (type != None)
+    {
+      if ((format == 8) && (nitems == sizeof(*info)))
+	{
+	  if ((info->protocol_version == 0) &&
+	      ((info->protocol_style == XmDRAG_PREFER_PREREGISTER) ||
+	       (info->protocol_style == XmDRAG_PREFER_DYNAMIC) ||
+	       (info->protocol_style == XmDRAG_DYNAMIC)))
+	    retval = TRUE;
+	}
+      else
+	{
+	  GDK_NOTE (DND, 
+		    g_warning ("Invalid Motif drag receiver property on window %ld\n", win));
+	}
+
+      XFree (info);
+    }
+
+  return retval;
+  
+}
+
+static void
+motif_send_enter (GdkDragContext  *context,
+		  guint32          time)
+{
+  XEvent xev;
+  GdkDragContextPrivate *private = (GdkDragContextPrivate *)context;
+
+  xev.xclient.type = ClientMessage;
+  xev.xclient.message_type = gdk_atom_intern ("_MOTIF_DRAG_AND_DROP_MESSAGE", FALSE);
+  xev.xclient.format = 8;
+  xev.xclient.window = GDK_WINDOW_XWINDOW (context->dest_window);
+
+  xev.xclient.data.b[0] = XmTOP_LEVEL_ENTER;
+  xev.xclient.data.b[1] = local_byte_order;
+  xev.xclient.data.s[1] = 0;
+  xev.xclient.data.l[1] = time;
+  xev.xclient.data.l[2] = GDK_WINDOW_XWINDOW (context->source_window);
+
+  if (!private->motif_targets_set)
+    motif_set_targets (context);
+
+  xev.xclient.data.l[3] = private->motif_selection;
+
+  if (!gdk_send_xevent (GDK_WINDOW_XWINDOW (context->dest_window),
+			FALSE, 0, &xev))
+    GDK_NOTE (DND, 
+	      g_message ("Send event to %lx failed",
+			 GDK_WINDOW_XWINDOW (context->dest_window)));
+}
+
+static void
+motif_send_leave (GdkDragContext  *context,
+		  guint32          time)
+{
+  XEvent xev;
+
+  xev.xclient.type = ClientMessage;
+  xev.xclient.message_type = gdk_atom_intern ("_MOTIF_DRAG_AND_DROP_MESSAGE", FALSE);
+  xev.xclient.format = 8;
+  xev.xclient.window = GDK_WINDOW_XWINDOW (context->dest_window);
+
+  xev.xclient.data.b[0] = XmTOP_LEVEL_LEAVE;
+  xev.xclient.data.b[1] = local_byte_order;
+  xev.xclient.data.s[1] = 0;
+  xev.xclient.data.l[1] = time;
+  xev.xclient.data.l[2] = GDK_WINDOW_XWINDOW (context->source_window);
+  xev.xclient.data.l[3] = 0;
+
+  if (!gdk_send_xevent (GDK_WINDOW_XWINDOW (context->dest_window),
+			FALSE, 0, &xev))
+    GDK_NOTE (DND, 
+	      g_message ("Send event to %lx failed",
+			 GDK_WINDOW_XWINDOW (context->dest_window)));
+}
+
+static gboolean
+motif_send_motion (GdkDragContext  *context,
+		    gint            x_root, 
+		    gint            y_root,
+		    GdkDragAction   action,
+		    guint32         time)
+{
+  gboolean retval;
+  XEvent xev;
+  GdkDragContextPrivate *private = (GdkDragContextPrivate *)context;
+
+  xev.xclient.type = ClientMessage;
+  xev.xclient.message_type = gdk_atom_intern ("_MOTIF_DRAG_AND_DROP_MESSAGE", FALSE);
+  xev.xclient.format = 8;
+  xev.xclient.window = GDK_WINDOW_XWINDOW (context->dest_window);
+
+  xev.xclient.data.b[1] = local_byte_order;
+  xev.xclient.data.s[1] = motif_dnd_get_flags (context);
+  xev.xclient.data.l[1] = time;
+
+  if (context->suggested_action != private->old_action)
+    {
+      xev.xclient.data.b[0] = XmOPERATION_CHANGED;
+
+      private->drag_status = GDK_DRAG_STATUS_ACTION_WAIT;
+      retval = TRUE;
+    }
+  else
+    {
+      xev.xclient.data.b[0] = XmDRAG_MOTION;
+
+      xev.xclient.data.s[4] = x_root;
+      xev.xclient.data.s[5] = y_root;
       
-      if(drag_ok)
+      private->drag_status = GDK_DRAG_STATUS_MOTION_WAIT;
+      retval = FALSE;
+    }
+
+  if (!gdk_send_xevent (GDK_WINDOW_XWINDOW (context->dest_window),
+			FALSE, 0, &xev))
+    GDK_NOTE (DND, 
+	      g_message ("Send event to %lx failed",
+			 GDK_WINDOW_XWINDOW (context->dest_window)));
+
+  return retval;
+}
+
+static void
+motif_send_drop (GdkDragContext *context, guint32 time)
+{
+  XEvent xev;
+  GdkDragContextPrivate *private = (GdkDragContextPrivate *)context;
+
+  xev.xclient.type = ClientMessage;
+  xev.xclient.message_type = gdk_atom_intern ("_MOTIF_DRAG_AND_DROP_MESSAGE", FALSE);
+  xev.xclient.format = 8;
+  xev.xclient.window = GDK_WINDOW_XWINDOW (context->dest_window);
+
+  xev.xclient.data.b[0] = XmDROP_START;
+  xev.xclient.data.b[1] = local_byte_order;
+  xev.xclient.data.s[1] = motif_dnd_get_flags (context);
+  xev.xclient.data.l[1] = time;
+
+  xev.xclient.data.s[4] = private->last_x;
+  xev.xclient.data.s[5] = private->last_y;
+
+  xev.xclient.data.l[3] = private->motif_selection;
+  xev.xclient.data.l[4] = GDK_WINDOW_XWINDOW (context->source_window);
+
+  if (!gdk_send_xevent (GDK_WINDOW_XWINDOW (context->dest_window),
+			FALSE, 0, &xev))
+    GDK_NOTE (DND, 
+	      g_message ("Send event to %lx failed",
+			 GDK_WINDOW_XWINDOW (context->dest_window)));
+}
+
+/* Target Side */
+
+static gboolean
+motif_read_initiator_info (Window source_window, 
+			   Atom atom,
+			   GList  **targets,
+			   GdkAtom *selection)
+{
+  GList *tmp_list;
+  static GdkAtom motif_drag_initiator_info = GDK_NONE;
+  GdkAtom type;
+  gint format;
+  gulong nitems;
+  gulong bytes_after;
+
+  MotifDragInitiatorInfo *initiator_info;
+
+  if (!motif_drag_initiator_info)
+    motif_drag_initiator_info = gdk_atom_intern ("_MOTIF_DRAG_INITIATOR_INFO", FALSE);
+
+  XGetWindowProperty (gdk_display, source_window, atom,
+		      0, sizeof(*initiator_info), FALSE,
+		      motif_drag_initiator_info, 
+		      &type, &format, &nitems, &bytes_after,
+		      (guchar **)&initiator_info);
+
+  if ((format != 8) || (nitems != sizeof (MotifDragInitiatorInfo)) || (bytes_after != 0))
+    {
+      g_warning ("Error reading initiator info\n");
+      return FALSE;
+    }
+
+  motif_read_target_table ();
+
+  if (initiator_info->targets_index >= motif_n_target_lists)
+    {
+      g_warning ("Invalid target index in TOP_LEVEL_ENTER MESSAGE");
+      XFree (initiator_info);
+      return GDK_FILTER_REMOVE;
+    }
+
+  tmp_list = g_list_last (motif_target_lists[initiator_info->targets_index]);
+
+  *targets = NULL;
+  while (tmp_list)
+    {
+      *targets = g_list_prepend (*targets,
+				 tmp_list->data);
+      tmp_list = tmp_list->prev;
+    }
+
+#ifdef G_ENABLE_DEBUG
+  if (gdk_debug_flags & GDK_DEBUG_DND)
+    print_target_list (*targets);
+#endif /* G_ENABLE_DEBUG */
+
+  *selection = initiator_info->selection_atom;
+
+  XFree (initiator_info);
+
+  return TRUE;
+}
+
+static GdkDragContext *
+motif_drag_context_new (GdkWindow *dest_window,
+			guint32    timestamp,
+			guint32    source_window,
+			guint32    atom)
+{
+  GdkDragContext *new_context;
+  GdkDragContextPrivate *private;
+
+  /* FIXME, current_dest_drag really shouldn't be NULL'd
+   * if we error below.
+   */
+  if (current_dest_drag != NULL)
+    {
+      if (timestamp >= current_dest_drag->start_time)
 	{
-	  GDK_NOTE(DND, g_message("Switching to drag_ok cursor\n"));
-	  mypix = gdk_dnd.c->drag_pm_ok;
-	  opix = gdk_dnd.c->drag_pm_default;
-	  myhotspot = &gdk_dnd.c->ok_hotspot;
+	  gdk_drag_context_unref (current_dest_drag);
+	  current_dest_drag = NULL;
 	}
       else
+	return NULL;
+    }
+
+  new_context = gdk_drag_context_new ();
+  private = (GdkDragContextPrivate *)new_context;
+
+  new_context->protocol = GDK_DRAG_PROTO_MOTIF;
+  new_context->is_source = FALSE;
+
+  new_context->source_window = gdk_window_lookup (source_window);
+  if (new_context->source_window)
+    gdk_window_ref (new_context->source_window);
+  else
+    {
+      new_context->source_window = gdk_window_foreign_new (source_window);
+      if (!new_context->source_window)
 	{
-	  GDK_NOTE(DND, g_message("Switching to drag_default cursor\n"));
-	  mypix = gdk_dnd.c->drag_pm_default;
-	  opix = gdk_dnd.c->drag_pm_ok;
-	  myhotspot = &gdk_dnd.c->default_hotspot;
+	  gdk_drag_context_unref (new_context);
+	  return NULL;
 	}
-      gdk_window_move(mypix, x - myhotspot->x, y - myhotspot->y);
-      if(change_made)
+    }
+
+  new_context->dest_window = dest_window;
+  gdk_window_ref (dest_window);
+  new_context->start_time = timestamp;
+
+  if (!motif_read_initiator_info(source_window,
+				 atom,
+				 &new_context->targets,
+				 &private->motif_selection))
+    {
+      gdk_drag_context_unref (new_context);
+      return NULL;
+    }
+
+  return new_context;
+}
+
+/*
+ * The MOTIF drag protocol has no real provisions for distinguishing
+ * multiple simultaneous drops. If the sources grab the pointer
+ * when doing drags, that shouldn't happen, in any case. If it
+ * does, we can't do much except hope for the best.
+ */
+
+static GdkFilterReturn
+motif_top_level_enter (GdkEvent *event,
+		       guint16   flags, 
+		       guint32   timestamp, 
+		       guint32   source_window, 
+		       guint32   atom)
+{
+  GdkDragContext *new_context;
+
+  GDK_NOTE(DND, g_message ("Motif DND top level enter: flags: %#4x time: %d source_widow: %#4x atom: %d",
+			   flags, timestamp, source_window, atom));
+
+  new_context = motif_drag_context_new (event->any.window, timestamp, source_window, atom);
+  if (!new_context)
+    return GDK_FILTER_REMOVE;
+
+  event->dnd.type = GDK_DRAG_ENTER;
+  event->dnd.context = new_context;
+  gdk_drag_context_ref (new_context);
+
+  current_dest_drag = new_context;
+
+  return GDK_FILTER_TRANSLATE;
+}
+
+GdkFilterReturn
+motif_top_level_leave (GdkEvent *event,
+		       guint16   flags, 
+		       guint32   timestamp)
+{
+  GDK_NOTE(DND, g_message ("Motif DND top level leave: flags: %#4x time: %d",
+			   flags, timestamp));
+
+  if ((current_dest_drag != NULL) &&
+      (current_dest_drag->protocol == GDK_DRAG_PROTO_MOTIF) &&
+      (timestamp >= current_dest_drag->start_time))
+    {
+      event->dnd.type = GDK_DRAG_LEAVE;
+      /* Pass ownership of context to the event */
+      event->dnd.context = current_dest_drag;
+
+      current_dest_drag = NULL;
+
+      return GDK_FILTER_TRANSLATE;
+    }
+  else
+    return GDK_FILTER_REMOVE;
+}
+
+GdkFilterReturn
+motif_motion (GdkEvent *event,
+	      guint16   flags, 
+	      guint32   timestamp,
+	      gint16    x_root,
+	      gint16    y_root)
+{
+  GdkDragContextPrivate *private;
+
+  GDK_NOTE(DND, g_message ("Motif DND motion: flags: %#4x time: %d (%d, %d)",
+			   flags, timestamp, x_root, y_root));
+
+  if ((current_dest_drag != NULL) &&
+      (current_dest_drag->protocol == GDK_DRAG_PROTO_MOTIF) &&
+      (timestamp >= current_dest_drag->start_time))
+    {
+      private = (GdkDragContextPrivate *)current_dest_drag;
+
+      event->dnd.type = GDK_DRAG_MOTION;
+      event->dnd.context = current_dest_drag;
+      gdk_drag_context_ref (current_dest_drag);
+
+      event->dnd.time = timestamp;
+
+      motif_dnd_translate_flags (current_dest_drag, flags);
+
+      event->dnd.x_root = x_root;
+      event->dnd.y_root = y_root;
+
+      private->last_x = x_root;
+      private->last_y = y_root;
+
+      private->drag_status = GDK_DRAG_STATUS_MOTION_WAIT;
+
+      return GDK_FILTER_TRANSLATE;
+    }
+
+  return GDK_FILTER_REMOVE;
+}
+
+GdkFilterReturn
+motif_operation_changed (GdkEvent *event,
+			 guint16   flags, 
+			 guint32   timestamp)
+{
+  GdkDragContextPrivate *private;
+
+  GDK_NOTE(DND, g_message ("Motif DND operation changed: flags: %#4x time: %d",
+			   flags, timestamp));
+
+  if ((current_dest_drag != NULL) &&
+      (current_dest_drag->protocol == GDK_DRAG_PROTO_MOTIF) &&
+      (timestamp >= current_dest_drag->start_time))
+    {
+      event->dnd.type = GDK_DRAG_MOTION;
+      event->dnd.send_event = FALSE;
+      event->dnd.context = current_dest_drag;
+      gdk_drag_context_ref (current_dest_drag);
+
+      event->dnd.time = timestamp;
+      private = (GdkDragContextPrivate *)current_dest_drag;
+
+      motif_dnd_translate_flags (current_dest_drag, flags);
+
+      event->dnd.x_root = private->last_x;
+      event->dnd.y_root = private->last_y;
+
+      private->drag_status = GDK_DRAG_STATUS_ACTION_WAIT;
+
+      return GDK_FILTER_TRANSLATE;
+    }
+
+  return GDK_FILTER_REMOVE;
+}
+
+GdkFilterReturn
+motif_drop_start (GdkEvent *event,
+		  guint16   flags,
+		  guint32   timestamp,
+		  guint32   source_window,
+		  guint32   atom,
+		  gint16    x_root,
+		  gint16    y_root)
+{
+  GdkDragContext *new_context;
+
+
+  GDK_NOTE(DND, g_message ("Motif DND drop start: flags: %#4x time: %d (%d, %d) source_widow: %#4x atom: %d",
+			   flags, timestamp, x_root, y_root, source_window, atom));
+
+  new_context = motif_drag_context_new (event->any.window, timestamp, source_window, atom);
+  if (!new_context)
+    return GDK_FILTER_REMOVE;
+
+  motif_dnd_translate_flags (new_context, flags);
+
+  event->dnd.type = GDK_DROP_START;
+  event->dnd.context = new_context;
+  event->dnd.time = timestamp;
+  event->dnd.x_root = x_root;
+  event->dnd.y_root = y_root;
+
+  gdk_drag_context_ref (new_context);
+  current_dest_drag = new_context;
+
+  return GDK_FILTER_TRANSLATE;
+}  
+
+GdkFilterReturn
+motif_drag_status (GdkEvent *event,
+		   guint16   flags,
+		   guint32   timestamp)
+{
+  GdkDragContext *context;
+  
+  GDK_NOTE (DND, 
+	    g_message ("Motif status message: flags %x", flags));
+
+  context = gdk_drag_context_find (TRUE, 
+				   GDK_WINDOW_XWINDOW (event->any.window), 
+				   None);
+
+  if (context)
+    {
+      GdkDragContextPrivate *private = (GdkDragContextPrivate *)context;
+      if (private->drag_status == GDK_DRAG_STATUS_MOTION_WAIT)
+	private->drag_status = GDK_DRAG_STATUS_DRAG;
+      
+      event->dnd.type = GDK_DRAG_STATUS;
+      event->dnd.send_event = FALSE;
+      event->dnd.context = context;
+      gdk_drag_context_ref (context);
+
+      event->dnd.time = timestamp;
+
+      if ((flags & 0x00f0) >> 4 == XmDROP_SITE_VALID)
+	{
+	  switch (flags & 0x000f)
+	    {
+	    case XmDROP_NOOP:
+	      context->action = 0;
+	      break;
+	    case XmDROP_MOVE:
+		context->action = GDK_ACTION_MOVE;
+		break;
+	    case XmDROP_COPY:
+	      context->action = GDK_ACTION_COPY;
+	      break;
+	    case XmDROP_LINK:
+	      context->action = GDK_ACTION_LINK;
+	      break;
+	    }
+	}
+      else
+	context->action = 0;
+
+      return GDK_FILTER_TRANSLATE;
+    }
+  return GDK_FILTER_REMOVE;
+}
+
+GdkFilterReturn
+motif_dnd_filter (GdkXEvent *xev,
+		  GdkEvent  *event,
+		  gpointer data)
+{
+  XEvent *xevent = (XEvent *)xev;
+  XClientMessageEvent *xce = &xevent->xclient;
+
+  guint8 reason;
+  gchar byte_order;
+  guint16 flags;
+  guint32 timestamp;
+  guint32 source_window;
+  GdkAtom atom;
+  gint16 x_root, y_root;
+  gboolean is_reply;
+  
+  /* First read some fields common to all Motif DND messages */
+
+  reason = xce->data.b[0];
+  byte_order = xce->data.b[1];
+  flags = card16_to_host (xce->data.s[1], byte_order);
+  timestamp = card32_to_host (xce->data.l[1], byte_order);
+
+  is_reply = ((reason & 0x80) != 0);
+
+  switch (reason & 0x7f)
+    {
+    case XmTOP_LEVEL_ENTER:
+      source_window = card32_to_host (xce->data.l[2], byte_order);
+      atom = card32_to_host (xce->data.l[3], byte_order);
+      return motif_top_level_enter (event, flags, timestamp, source_window, atom);
+    case XmTOP_LEVEL_LEAVE:
+      return motif_top_level_leave (event, flags, timestamp);
+
+    case XmDRAG_MOTION:
+      x_root = card16_to_host (xce->data.s[4], byte_order);
+      y_root = card16_to_host (xce->data.s[5], byte_order);
+      
+      if (!is_reply)
+	return motif_motion (event, flags, timestamp, x_root, y_root);
+      else
+	return motif_drag_status (event, flags, timestamp);
+
+    case XmDROP_SITE_ENTER:
+      return motif_drag_status (event, flags, timestamp);
+
+    case XmDROP_SITE_LEAVE:
+      return motif_drag_status (event,
+				XmNO_DROP_SITE << 8 | XmDROP_NOOP, 
+				timestamp);
+    case XmDROP_START:
+      x_root = card16_to_host (xce->data.s[4], byte_order);
+      y_root = card16_to_host (xce->data.s[5], byte_order);
+      atom = card32_to_host (xce->data.l[3], byte_order);
+      source_window = card32_to_host (xce->data.l[4], byte_order);
+
+      if (!is_reply)
+	return motif_drop_start (event, flags, timestamp, source_window, atom, x_root, y_root);
+      
+     break;
+    case XmOPERATION_CHANGED:
+      if (!is_reply)
+	return motif_operation_changed (event, flags, timestamp);
+      else
+	return motif_drag_status (event, flags, timestamp);
+
+      break;
+      /* To the best of my knowledge, these next two messages are 
+       * not part of the protocol, though they are defined in
+       * the header files.
+       */
+    case XmDROP_FINISH:
+    case XmDRAG_DROP_FINISH:
+      break;
+    }
+
+  return GDK_FILTER_REMOVE;
+}
+
+/*************************************************************
+ ***************************** XDND **************************
+ *************************************************************/
+
+/* Utility functions */
+
+static struct {
+  gchar *name;
+  GdkAtom atom;
+  GdkDragAction action;
+} xdnd_actions_table[] = {
+    { "XdndActionCopy",    GDK_NONE, GDK_ACTION_COPY },
+    { "XdndActionMove",    GDK_NONE, GDK_ACTION_MOVE },
+    { "XdndActionLink",    GDK_NONE, GDK_ACTION_LINK },
+    { "XdndActionAsk",     GDK_NONE, GDK_ACTION_ASK  },
+    { "XdndActionPrivate", GDK_NONE, GDK_ACTION_COPY },
+  };
+
+static const gint xdnd_n_actions = sizeof(xdnd_actions_table) / sizeof(xdnd_actions_table[0]);
+static gboolean xdnd_actions_initialized = FALSE;
+
+static void
+xdnd_initialize_actions (void)
+{
+  gint i;
+  
+  xdnd_actions_initialized = TRUE;
+  for (i=0; i < xdnd_n_actions; i++)
+    xdnd_actions_table[i].atom = gdk_atom_intern (xdnd_actions_table[i].name, FALSE);
+}
+
+static GdkDragAction
+xdnd_action_from_atom (GdkAtom atom)
+{
+  gint i;
+
+  if (!xdnd_actions_initialized)
+    xdnd_initialize_actions();
+
+  for (i=0; i<xdnd_n_actions; i++)
+    if (atom == xdnd_actions_table[i].atom)
+      return xdnd_actions_table[i].action;
+
+  return 0;
+}
+
+static GdkAtom
+xdnd_action_to_atom (GdkDragAction action)
+{
+  gint i;
+
+  if (!xdnd_actions_initialized)
+    xdnd_initialize_actions();
+
+  for (i=0; i<xdnd_n_actions; i++)
+    if (action == xdnd_actions_table[i].action)
+      return xdnd_actions_table[i].atom;
+
+  return GDK_NONE;
+}
+
+static GdkAtom xdnd_aware_atom = GDK_NONE;
+
+/* Source side */
+
+static GdkFilterReturn 
+xdnd_status_filter (GdkXEvent *xev,
+		    GdkEvent  *event,
+		    gpointer   data)
+{
+  XEvent *xevent = (XEvent *)xev;
+  guint32 dest_window = xevent->xclient.data.l[0];
+  guint32 flags = xevent->xclient.data.l[1];
+  GdkAtom action = xevent->xclient.data.l[4];
+  GdkDragContext *context;
+  
+  GDK_NOTE (DND, 
+	    g_message ("XdndStatus: dest_window: %#x  action: %ld",
+		       dest_window, action));
+
+  
+  context = gdk_drag_context_find (TRUE, xevent->xclient.window, dest_window);
+  if (context)
+    {
+      GdkDragContextPrivate *private = (GdkDragContextPrivate *)context;
+      if (private->drag_status == GDK_DRAG_STATUS_MOTION_WAIT)
+	private->drag_status = GDK_DRAG_STATUS_DRAG;
+      
+      event->dnd.send_event = FALSE;
+      event->dnd.type = GDK_DRAG_STATUS;
+      event->dnd.context = context;
+      gdk_drag_context_ref (context);
+
+      event->dnd.time = GDK_CURRENT_TIME; /* FIXME? */
+      if (!(action != 0) != !(flags & 1))
+	{
+	  GDK_NOTE (DND,
+		    g_warning ("Received status event with flags not corresponding to action!\n"));
+	  action = 0;
+	}
+
+      context->action = xdnd_action_from_atom (action);
+
+      return GDK_FILTER_TRANSLATE;
+    }
+
+  return GDK_FILTER_REMOVE;
+}
+
+static GdkFilterReturn 
+xdnd_finished_filter (GdkXEvent *xev,
+		      GdkEvent  *event,
+		      gpointer   data)
+{
+  XEvent *xevent = (XEvent *)xev;
+  guint32 dest_window = xevent->xclient.data.l[0];
+  GdkDragContext *context;
+  
+  GDK_NOTE (DND, 
+	    g_message ("XdndFinished: dest_window: %#x", dest_window));
+
+  context = gdk_drag_context_find (TRUE, xevent->xclient.window, dest_window);
+  if (context)
+    {
+      event->dnd.type = GDK_DROP_FINISHED;
+      event->dnd.context = context;
+      gdk_drag_context_ref (context);
+
+      return GDK_FILTER_TRANSLATE;
+    }
+
+  return GDK_FILTER_REMOVE;
+}
+
+static void
+xdnd_set_targets (GdkDragContext *context)
+{
+  GdkDragContextPrivate *private = (GdkDragContextPrivate *)context;
+  GdkAtom *typelist;
+  GList *tmp_list = context->targets;
+  gint i;
+  gint n_targets = g_list_length (context->targets);
+
+  typelist = g_new (GdkAtom, n_targets);
+  i = 0;
+  while (tmp_list)
+    {
+      typelist[i] = GPOINTER_TO_INT (tmp_list->data);
+      tmp_list = tmp_list->next;
+      i++;
+    }
+
+  XChangeProperty (GDK_WINDOW_XDISPLAY (context->source_window),
+		   GDK_WINDOW_XWINDOW (context->source_window),
+		   gdk_atom_intern ("XdndTypeList", FALSE),
+		   XA_ATOM, 32, PropModeReplace,
+		   (guchar *)typelist, n_targets);
+
+  private->xdnd_targets_set = 1;
+}
+
+static void
+xdnd_send_enter (GdkDragContext *context)
+{
+  XEvent xev;
+  GdkDragContextPrivate *private = (GdkDragContextPrivate *)context;
+
+  xev.xclient.type = ClientMessage;
+  xev.xclient.message_type = gdk_atom_intern ("XdndEnter", FALSE);
+  xev.xclient.format = 32;
+  xev.xclient.window = GDK_WINDOW_XWINDOW (context->dest_window);
+  xev.xclient.data.l[0] = GDK_WINDOW_XWINDOW (context->source_window);
+  xev.xclient.data.l[1] = (3 << 24); /* version */
+  xev.xclient.data.l[2] = 0;
+  xev.xclient.data.l[3] = 0;
+  xev.xclient.data.l[4] = 0;
+
+  if (!private->xdnd_selection)
+    private->xdnd_selection = gdk_atom_intern ("XdndSelection", FALSE);
+
+  if (g_list_length (context->targets) > 3)
+    {
+      if (!private->xdnd_targets_set)
+	xdnd_set_targets (context);
+      xev.xclient.data.l[1] |= 1;
+    }
+  else
+    {
+      GList *tmp_list = context->targets;
+      gint i = 2;
+
+      while (tmp_list)
+	{
+	  xev.xclient.data.l[i] = GPOINTER_TO_INT (tmp_list->data);
+	  tmp_list = tmp_list->next;
+	  i++;
+	}
+    }
+
+  if (!gdk_send_xevent (GDK_WINDOW_XWINDOW (context->dest_window),
+			FALSE, 0, &xev))
+    {
+      GDK_NOTE (DND, 
+		g_message ("Send event to %lx failed",
+			   GDK_WINDOW_XWINDOW (context->dest_window)));
+      gdk_window_unref (context->dest_window);
+      context->dest_window = NULL;
+    }
+}
+
+static void
+xdnd_send_leave (GdkDragContext *context)
+{
+  XEvent xev;
+
+  xev.xclient.type = ClientMessage;
+  xev.xclient.message_type = gdk_atom_intern ("XdndLeave", FALSE);
+  xev.xclient.format = 32;
+  xev.xclient.window = GDK_WINDOW_XWINDOW (context->dest_window);
+  xev.xclient.data.l[0] = GDK_WINDOW_XWINDOW (context->source_window);
+  xev.xclient.data.l[1] = 0;
+  xev.xclient.data.l[2] = 0;
+  xev.xclient.data.l[3] = 0;
+  xev.xclient.data.l[4] = 0;
+
+  if (!gdk_send_xevent (GDK_WINDOW_XWINDOW (context->dest_window),
+			FALSE, 0, &xev))
+    {
+      GDK_NOTE (DND, 
+		g_message ("Send event to %lx failed",
+			   GDK_WINDOW_XWINDOW (context->dest_window)));
+      gdk_window_unref (context->dest_window);
+      context->dest_window = NULL;
+    }
+}
+
+static void
+xdnd_send_drop (GdkDragContext *context, guint32 time)
+{
+  XEvent xev;
+
+  xev.xclient.type = ClientMessage;
+  xev.xclient.message_type = gdk_atom_intern ("XdndDrop", FALSE);
+  xev.xclient.format = 32;
+  xev.xclient.window = GDK_WINDOW_XWINDOW (context->dest_window);
+  xev.xclient.data.l[0] = GDK_WINDOW_XWINDOW (context->source_window);
+  xev.xclient.data.l[1] = 0;
+  xev.xclient.data.l[2] = time;
+  xev.xclient.data.l[3] = 0;
+  xev.xclient.data.l[4] = 0;
+
+  if (!gdk_send_xevent (GDK_WINDOW_XWINDOW (context->dest_window),
+			FALSE, 0, &xev))
+    {
+      GDK_NOTE (DND, 
+		g_message ("Send event to %lx failed",
+			   GDK_WINDOW_XWINDOW (context->dest_window)));
+      gdk_window_unref (context->dest_window);
+      context->dest_window = NULL;
+    }
+}
+
+static void
+xdnd_send_motion (GdkDragContext *context,
+		  gint            x_root, 
+		  gint            y_root,
+		  GdkDragAction   action,
+		  guint32         time)
+{
+  GdkDragContextPrivate *private = (GdkDragContextPrivate *)context;
+  XEvent xev;
+
+  xev.xclient.type = ClientMessage;
+  xev.xclient.message_type = gdk_atom_intern ("XdndPosition", FALSE);
+  xev.xclient.format = 32;
+  xev.xclient.window = GDK_WINDOW_XWINDOW (context->dest_window);
+  xev.xclient.data.l[0] = GDK_WINDOW_XWINDOW (context->source_window);
+  xev.xclient.data.l[1] = 0;
+  xev.xclient.data.l[2] = (x_root << 16) | y_root;
+  xev.xclient.data.l[3] = time;
+  xev.xclient.data.l[4] = xdnd_action_to_atom (action);
+
+  if (!gdk_send_xevent (GDK_WINDOW_XWINDOW (context->dest_window),
+			FALSE, 0, &xev))
+    {
+      GDK_NOTE (DND, 
+		g_message ("Send event to %lx failed",
+			   GDK_WINDOW_XWINDOW (context->dest_window)));
+      gdk_window_unref (context->dest_window);
+      context->dest_window = NULL;
+    }
+  private->drag_status = GDK_DRAG_STATUS_MOTION_WAIT;
+}
+
+static gboolean
+xdnd_check_dest (Window win)
+{
+  gboolean retval = FALSE;
+  Atom type = None;
+  int format;
+  unsigned long nitems, after;
+  GdkAtom *version;
+
+  if (!xdnd_aware_atom)
+    xdnd_aware_atom = gdk_atom_intern ("XdndAware", FALSE);
+
+  XGetWindowProperty (gdk_display, win, 
+		      xdnd_aware_atom, 0, 
+		      1, False, AnyPropertyType,
+		      &type, &format, &nitems, &after, 
+		      (guchar **)&version);
+  
+  if (type != None)
+    {
+      if ((format == 32) && (nitems == 1))
+	{
+	  if (*version == 3)
+	    retval = TRUE;
+	}
+      else
+	GDK_NOTE (DND, 
+		  g_warning ("Invalid XdndAware property on window %ld\n", win));
+
+      XFree (version);
+    }
+
+  return retval;
+}
+
+/* Target side */
+
+static GdkFilterReturn 
+xdnd_enter_filter (GdkXEvent *xev,
+		   GdkEvent  *event,
+		   gpointer   data)
+{
+  XEvent *xevent = (XEvent *)xev;
+  GdkDragContext *new_context;
+  gint i;
+  
+  guint32 source_window = xevent->xclient.data.l[0];
+  gboolean get_types = ((xevent->xclient.data.l[1] & 1) != 0);
+  gint version = (xevent->xclient.data.l[1] & 0xff000000) >> 24;
+  
+  GDK_NOTE (DND, 
+	    g_message ("XdndEnter: source_window: %#x, version: %#x",
+		       source_window, version));
+
+  if (version != 3)
+    {
+      /* Old source ignore */
+      GDK_NOTE (DND, g_message ("Ignored old XdndEnter message"));
+      return GDK_FILTER_REMOVE;
+    }
+  
+  if (current_dest_drag != NULL)
+    {
+      gdk_drag_context_unref (current_dest_drag);
+      current_dest_drag = NULL;
+    }
+
+  new_context = gdk_drag_context_new ();
+  new_context->protocol = GDK_DRAG_PROTO_XDND;
+  new_context->is_source = FALSE;
+
+  new_context->source_window = gdk_window_lookup (source_window);
+  if (new_context->source_window)
+    gdk_window_ref (new_context->source_window);
+  else
+    {
+      new_context->source_window = gdk_window_foreign_new (source_window);
+      if (!new_context->source_window)
+	{
+	  gdk_drag_context_unref (new_context);
+	  return GDK_FILTER_REMOVE;
+	}
+    }
+  new_context->dest_window = event->any.window;
+  gdk_window_ref (new_context->dest_window);
+
+  new_context->targets = NULL;
+  if (get_types)
+    {
+      Atom type;
+      int format;
+      gulong nitems, after;
+      Atom *data;
+
+      XGetWindowProperty (GDK_WINDOW_XDISPLAY (event->any.window), 
+			  source_window, 
+			  gdk_atom_intern ("XdndTypeList", FALSE), 0, 65536,
+			  False, XA_ATOM, &type, &format, &nitems,
+			  &after, (guchar **)&data);
+
+      if ((format != 32) || (type != XA_ATOM))
+	{
+	  gdk_drag_context_unref (new_context);
+	  return GDK_FILTER_REMOVE;
+	}
+
+      for (i=0; i<nitems; i++)
+	new_context->targets = g_list_append (new_context->targets,
+					      GUINT_TO_POINTER (data[i]));
+
+      XFree(data);
+    }
+  else
+    {
+      for (i=0; i<3; i++)
+	if (xevent->xclient.data.l[2+i])
+	  new_context->targets = g_list_append (new_context->targets,
+						GUINT_TO_POINTER (xevent->xclient.data.l[2+i]));
+    }
+
+#ifdef G_ENABLE_DEBUG
+  if (gdk_debug_flags & GDK_DEBUG_DND)
+    print_target_list (new_context->targets);
+#endif /* G_ENABLE_DEBUG */
+
+  event->dnd.type = GDK_DRAG_ENTER;
+  event->dnd.context = new_context;
+  gdk_drag_context_ref (new_context);
+
+  current_dest_drag = new_context;
+  ((GdkDragContextPrivate *)new_context)->xdnd_selection = 
+    gdk_atom_intern ("XdndSelection", FALSE);
+
+  return GDK_FILTER_TRANSLATE;
+}
+
+static GdkFilterReturn 
+xdnd_leave_filter (GdkXEvent *xev,
+		   GdkEvent  *event,
+		   gpointer   data)
+{
+  XEvent *xevent = (XEvent *)xev;
+  guint32 source_window = xevent->xclient.data.l[0];
+  
+  GDK_NOTE (DND, 
+	    g_message ("XdndLeave: source_window: %#x",
+		       source_window));
+
+  if ((current_dest_drag != NULL) &&
+      (current_dest_drag->protocol == GDK_DRAG_PROTO_XDND) &&
+      (GDK_WINDOW_XWINDOW (current_dest_drag->source_window) == source_window))
+    {
+      event->dnd.type = GDK_DRAG_LEAVE;
+      /* Pass ownership of context to the event */
+      event->dnd.context = current_dest_drag;
+
+      current_dest_drag = NULL;
+
+      return GDK_FILTER_TRANSLATE;
+    }
+  else
+    return GDK_FILTER_REMOVE;
+}
+
+static GdkFilterReturn 
+xdnd_position_filter (GdkXEvent *xev,
+		      GdkEvent  *event,
+		      gpointer   data)
+{
+  XEvent *xevent = (XEvent *)xev;
+  guint32 source_window = xevent->xclient.data.l[0];
+  gint16 x_root = xevent->xclient.data.l[2] >> 16;
+  gint16 y_root = xevent->xclient.data.l[2] & 0xffff;
+  guint32 time = xevent->xclient.data.l[3];
+  GdkAtom action = xevent->xclient.data.l[4];
+  
+  GDK_NOTE (DND, 
+	    g_message ("XdndPosition: source_window: %#x  position: (%d, %d)  time: %d  action: %ld",
+		       source_window, x_root, y_root, time, action));
+
+  
+  if ((current_dest_drag != NULL) &&
+      (current_dest_drag->protocol == GDK_DRAG_PROTO_XDND) &&
+      (GDK_WINDOW_XWINDOW (current_dest_drag->source_window) == source_window))
+    {
+      event->dnd.type = GDK_DRAG_MOTION;
+      event->dnd.context = current_dest_drag;
+      gdk_drag_context_ref (current_dest_drag);
+
+      event->dnd.time = time;
+
+      current_dest_drag->suggested_action = xdnd_action_from_atom (action);
+
+      event->dnd.x_root = x_root;
+      event->dnd.y_root = y_root;
+
+      ((GdkDragContextPrivate *)current_dest_drag)->last_x = x_root;
+      ((GdkDragContextPrivate *)current_dest_drag)->last_y = y_root;
+      
+      return GDK_FILTER_TRANSLATE;
+    }
+
+  return GDK_FILTER_REMOVE;
+}
+
+static GdkFilterReturn 
+xdnd_drop_filter (GdkXEvent *xev,
+		  GdkEvent  *event,
+		  gpointer   data)
+{
+  XEvent *xevent = (XEvent *)xev;
+  guint32 source_window = xevent->xclient.data.l[0];
+  guint32 time = xevent->xclient.data.l[2];
+  
+  GDK_NOTE (DND, 
+	    g_message ("XdndDrop: source_window: %#x  time: %d",
+		       source_window, time));
+
+  if ((current_dest_drag != NULL) &&
+      (current_dest_drag->protocol == GDK_DRAG_PROTO_XDND) &&
+      (GDK_WINDOW_XWINDOW (current_dest_drag->source_window) == source_window))
+    {
+      GdkDragContextPrivate *private;
+      private = (GdkDragContextPrivate *)current_dest_drag;
+
+      event->dnd.type = GDK_DROP_START;
+
+      event->dnd.context = current_dest_drag;
+      gdk_drag_context_ref (current_dest_drag);
+
+      event->dnd.time = time;
+      event->dnd.x_root = private->last_x;
+      event->dnd.y_root = private->last_y;
+      
+      return GDK_FILTER_TRANSLATE;
+    }
+
+  return GDK_FILTER_REMOVE;
+}
+
+/*************************************************************
+ ************************** Public API ***********************
+ *************************************************************/
+
+void
+gdk_dnd_init (void)
+{
+  init_byte_order();
+
+  gdk_add_client_message_filter (
+	gdk_atom_intern ("_MOTIF_DRAG_AND_DROP_MESSAGE", FALSE),
+	motif_dnd_filter, NULL);
+  gdk_add_client_message_filter (
+	gdk_atom_intern ("XdndEnter", FALSE),
+	xdnd_enter_filter, NULL);
+  gdk_add_client_message_filter (
+	gdk_atom_intern ("XdndLeave", FALSE),
+	xdnd_leave_filter, NULL);
+  gdk_add_client_message_filter (
+	gdk_atom_intern ("XdndPosition", FALSE),
+	xdnd_position_filter, NULL);
+  gdk_add_client_message_filter (
+	gdk_atom_intern ("XdndStatus", FALSE),
+	xdnd_status_filter, NULL);
+  gdk_add_client_message_filter (
+	gdk_atom_intern ("XdndFinished", FALSE),
+	xdnd_finished_filter, NULL);
+  gdk_add_client_message_filter (
+	gdk_atom_intern ("XdndDrop", FALSE),
+	xdnd_drop_filter, NULL);
+}		      
+
+/* Source side */
+
+static void
+gdk_drag_do_leave (GdkDragContext *context, guint32 time)
+{
+  if (context->dest_window)
+    {
+      switch (context->protocol)
+	{
+	case GDK_DRAG_PROTO_MOTIF:
+	  motif_send_leave (context, time);
+	  break;
+	case GDK_DRAG_PROTO_XDND:
+	  xdnd_send_leave (context);
+	  break;
+	case GDK_DRAG_PROTO_ROOTWIN:
+	  break;
+	}
+
+      gdk_window_unref (context->dest_window);
+      context->dest_window = NULL;
+    }
+}
+
+GdkDragContext * 
+gdk_drag_begin (GdkWindow     *window,
+		GList         *targets,
+		GdkDragAction  actions)
+{
+  GList *tmp_list;
+  GdkDragContext *new_context;
+  
+  g_return_val_if_fail (window != NULL, NULL);
+
+  new_context = gdk_drag_context_new ();
+  new_context->is_source = TRUE;
+  new_context->source_window = window;
+  gdk_window_ref (window);
+
+  tmp_list = g_list_last (targets);
+  new_context->targets = NULL;
+  while (tmp_list)
+    {
+      new_context->targets = g_list_prepend (new_context->targets,
+					     tmp_list->data);
+      tmp_list = tmp_list->prev;
+    }
+
+  new_context->actions = actions;
+
+  return new_context;
+}
+
+gboolean         
+gdk_drag_get_protocol (guint32          xid,
+		       GdkDragProtocol *protocol)
+{
+  if (xdnd_check_dest (xid))
+    {
+      *protocol = GDK_DRAG_PROTO_XDND;
+      GDK_NOTE (DND, g_message ("Entering dnd window %#x\n", xid));
+      return TRUE;
+    }
+  else if (motif_check_dest (xid))
+    {
+      *protocol = GDK_DRAG_PROTO_MOTIF;
+      GDK_NOTE (DND, g_message ("Entering motif window %#x\n", xid));
+      return TRUE;
+    }
+  else
+    {
+      /* Check if this is a root window */
+
+      gboolean rootwin = FALSE;
+      gint old_warnings = gdk_error_warnings;
+      Atom type = None;
+      int format;
+      unsigned long nitems, after;
+      unsigned char *data;
+
+      if (xid == gdk_root_window)
+	rootwin = TRUE;
+
+      if (!rootwin)
+	{
+	  gdk_error_code = 0;
+	  
+	  XGetWindowProperty (gdk_display, xid,
+			      gdk_atom_intern ("ENLIGHTENMENT_DESKTOP", FALSE),
+			      0, 0, False, AnyPropertyType,
+			      &type, &format, &nitems, &after, &data);
+	  if ((gdk_error_code == 0) && type != None)
+	    {
+	      XFree (data);
+	      rootwin = TRUE;
+	    }
+	}
+
+      /* Until I find out what window manager the next one is for,
+       * I'm leaving it commented out. It's supported in the
+       * xscreensaver sources, though.
+       */
+#if 0
+      if (!rootwin)
 	{
-	  GDK_NOTE(DND, g_message("Cursors switched, hide & show\n"));
-	  gdk_window_hide(opix);
+	  gdk_error_code = 0;
+	  
+	  XGetWindowProperty (gdk_display, win,
+			      gdk_atom_intern ("__SWM_VROOT", FALSE),
+			      0, 0, False, AnyPropertyType,
+			      &type, &format, &nitems, &data);
+	  if ((gdk_error_code == 0) && type != None)
+	    rootwin = TRUE;
+	}
+#endif      
+
+      gdk_error_warnings = old_warnings;
+
+      if (rootwin)
+	{
+	  *protocol = GDK_DRAG_PROTO_ROOTWIN;
+	  return TRUE;
 	}
-      gdk_window_move(mypix, x - myhotspot->x, y - myhotspot->y);
-      if (change_made)
-        {
-	  gdk_window_show(mypix); /* There ought to be a way to know if
-				     a window is already mapped etc. */
-	}      
     }
-  else if(change_made)
+
+  return FALSE;
+}
+
+void
+gdk_drag_find_window (GdkDragContext  *context,
+		      GdkWindow       *drag_window,
+		      gint             x_root,
+		      gint             y_root,
+		      GdkWindow      **dest_window,
+		      GdkDragProtocol *protocol)
+{
+  GdkDragContextPrivate *private = (GdkDragContextPrivate *)context;
+  Window dest;
+
+  if (!private->window_cache)
+    private->window_cache = gdk_window_cache_new();
+
+  dest = get_client_window_at_coords (private->window_cache,
+				      drag_window ? 
+				      GDK_WINDOW_XWINDOW (drag_window) : GDK_NONE,
+				      x_root, y_root);
+
+  if (private->dest_xid != dest)
     {
-      Cursor c;
-      /* Move cursors around */
-      if(drag_ok)
-	c = gdk_dnd.c->gdk_cursor_dragok;
+      private->dest_xid = dest;
+
+      /* Check if new destination accepts drags, and which protocol */
+
+      if (gdk_drag_get_protocol (dest, protocol))
+	{
+	  *dest_window = gdk_window_lookup (dest);
+	  if (*dest_window)
+	    gdk_window_ref (*dest_window);
+	  else
+	    *dest_window = gdk_window_foreign_new (dest);
+	}
       else
-	c = gdk_dnd.c->gdk_cursor_dragdefault;
-      XChangeActivePointerGrab (gdk_display,
-				ButtonMotionMask |
-				ButtonPressMask |
-				ButtonReleaseMask |
-				EnterWindowMask | LeaveWindowMask,
-				c,
-				CurrentTime);
+	*dest_window = NULL;
+    }
+  else
+    {
+      *dest_window = context->dest_window;
+      if (*dest_window)
+	gdk_window_ref (*dest_window);
+      *protocol = context->protocol;
     }
 }
+
+gboolean        
+gdk_drag_motion (GdkDragContext *context,
+		 GdkWindow      *dest_window,
+		 GdkDragProtocol protocol,
+		 gint            x_root, 
+		 gint            y_root,
+		 GdkDragAction   action,
+		 guint32         time)
+{
+  GdkDragContextPrivate *private = (GdkDragContextPrivate *)context;
+
+  if (context->dest_window != dest_window)
+    {
+      GdkEvent temp_event;
+
+      /* Send a leave to the last destination */
+      gdk_drag_do_leave (context, time);
+      private->drag_status = GDK_DRAG_STATUS_DRAG;
+
+      /* Check if new destination accepts drags, and which protocol */
+
+      if (dest_window)
+	{
+	  context->dest_window = dest_window;
+	  gdk_window_ref (context->dest_window);
+	  context->protocol = protocol;
+
+	  switch (protocol)
+	    {
+	    case GDK_DRAG_PROTO_MOTIF:
+	      motif_send_enter (context, time);
+	      break;
+
+	    case GDK_DRAG_PROTO_XDND:
+	      xdnd_send_enter (context);
+	      break;
+
+	    case GDK_DRAG_PROTO_ROOTWIN:
+	      break;
+	    }
+	  private->old_action = action;
+	  context->suggested_action = action;
+	}
+      else
+	{
+	  context->dest_window = NULL;
+	  context->action = 0;
+	}
+
+      /* Push a status event, to let the client know that
+       * the drag changed 
+       */
+
+      temp_event.dnd.type = GDK_DRAG_STATUS;
+      temp_event.dnd.window = context->source_window;
+      /* We use this to signal a synthetic status. Perhaps
+       * we should use an extra field...
+       */
+      temp_event.dnd.send_event = TRUE;
+
+      temp_event.dnd.context = context;
+      temp_event.dnd.time = time;
+
+      gdk_event_put (&temp_event);
+    }
+  else
+    {
+      private->old_action = context->suggested_action;
+      context->suggested_action = action;
+    }
+
+  /* Send a drag-motion event */
+
+  private->last_x = x_root;
+  private->last_y = y_root;
+      
+  if (context->dest_window)
+    {
+      if (private->drag_status == GDK_DRAG_STATUS_DRAG)
+	{
+	  switch (context->protocol)
+	    {
+	    case GDK_DRAG_PROTO_MOTIF:
+	      motif_send_motion (context, x_root, y_root, action, time);
+	      break;
+	      
+	    case GDK_DRAG_PROTO_XDND:
+	      xdnd_send_motion (context, x_root, y_root, action, time);
+	      break;
+
+	    case GDK_DRAG_PROTO_ROOTWIN:
+	      {
+		GdkEvent temp_event;
+
+		if (g_list_find (context->targets,
+				 GUINT_TO_POINTER (gdk_atom_intern ("application/x-rootwin-drop", FALSE))))
+		  context->action = context->suggested_action;
+		else
+		  context->action = 0;
+
+		temp_event.dnd.type = GDK_DRAG_STATUS;
+		temp_event.dnd.window = context->source_window;
+		temp_event.dnd.send_event = FALSE;
+		temp_event.dnd.context = context;
+		temp_event.dnd.time = time;
+
+		gdk_event_put (&temp_event);
+	      }
+	      break;
+	    }
+	}
+      else
+	return TRUE;
+    }
+
+  return FALSE;
+}
+
+void
+gdk_drag_drop (GdkDragContext *context,
+	       guint32         time)
+{
+  if (context->dest_window)
+    {
+      switch (context->protocol)
+	{
+	case GDK_DRAG_PROTO_MOTIF:
+	  motif_send_leave (context, time);
+	  motif_send_drop (context, time);
+	  break;
+	  
+	case GDK_DRAG_PROTO_XDND:
+	  xdnd_send_drop (context, time);
+	  break;
+
+	case GDK_DRAG_PROTO_ROOTWIN:
+	  g_warning ("Drops for GDK_DRAG_PROTO_ROOTWIN must be handled internally");
+	  break;
+	}
+    }
+}
+
+void
+gdk_drag_abort (GdkDragContext *context,
+		guint32         time)
+{
+  gdk_drag_do_leave (context, time);
+}
+
+/* Destination side */
+
+void             
+gdk_drag_status (GdkDragContext   *context,
+		 GdkDragAction     action,
+		 guint32           time)
+{
+  GdkDragContextPrivate *private;
+  XEvent xev;
+
+  g_return_if_fail (context != 0);
+
+  private = (GdkDragContextPrivate *)context;
+
+  context->action = action;
+  
+  if (context->protocol == GDK_DRAG_PROTO_MOTIF)
+    {
+      xev.xclient.type = ClientMessage;
+      xev.xclient.message_type = gdk_atom_intern ("_MOTIF_DRAG_AND_DROP_MESSAGE", FALSE);
+      xev.xclient.format = 8;
+      xev.xclient.window = GDK_WINDOW_XWINDOW (context->source_window);
+
+      if (private->drag_status == GDK_DRAG_STATUS_ACTION_WAIT)
+	{
+	  xev.xclient.data.b[0] = XmOPERATION_CHANGED | 0x80;
+	}
+      else
+	{
+	  if ((action != 0) != (private->old_action != 0))
+	    {
+	      if (action != 0)
+		xev.xclient.data.b[0] = XmDROP_SITE_ENTER | 0x80;
+	      else
+		xev.xclient.data.b[0] = XmDROP_SITE_LEAVE | 0x80;
+	    }
+	  else
+	    xev.xclient.data.b[0] = XmDRAG_MOTION | 0x80;
+	}
+
+      xev.xclient.data.b[1] = local_byte_order;
+
+      switch (action)
+	{
+	case GDK_ACTION_MOVE:
+	  xev.xclient.data.s[1] = XmDROP_MOVE;
+	  break;
+	case GDK_ACTION_COPY:
+	  xev.xclient.data.s[1] = XmDROP_COPY;
+	  break;
+	case GDK_ACTION_LINK:
+	  xev.xclient.data.s[1] = XmDROP_LINK;
+	  break;
+	default:
+	  xev.xclient.data.s[1] = XmDROP_NOOP;
+	  break;
+	}
+
+      if (action)
+	xev.xclient.data.s[1] |= (XmDROP_SITE_VALID << 4);
+      else
+	xev.xclient.data.s[1] |= (XmNO_DROP_SITE << 4);
+
+      xev.xclient.data.l[1] = time;
+      xev.xclient.data.s[4] = private->last_x;
+      xev.xclient.data.s[5] = private->last_y;
+
+      if (!gdk_send_xevent (GDK_WINDOW_XWINDOW (context->source_window),
+		       FALSE, 0, &xev))
+	GDK_NOTE (DND, 
+		  g_message ("Send event to %lx failed",
+			     GDK_WINDOW_XWINDOW (context->source_window)));
+    }
+  else if (context->protocol == GDK_DRAG_PROTO_XDND)
+    {
+      xev.xclient.type = ClientMessage;
+      xev.xclient.message_type = gdk_atom_intern ("XdndStatus", FALSE);
+      xev.xclient.format = 32;
+      xev.xclient.window = GDK_WINDOW_XWINDOW (context->source_window);
+
+      xev.xclient.data.l[0] = GDK_WINDOW_XWINDOW (context->dest_window);
+      xev.xclient.data.l[1] = (action != 0) ? (2 | 1) : 0;
+      xev.xclient.data.l[2] = 0;
+      xev.xclient.data.l[3] = 0;
+      xev.xclient.data.l[4] = xdnd_action_to_atom (action);
+
+      if (!gdk_send_xevent (GDK_WINDOW_XWINDOW (context->source_window),
+		       FALSE, 0, &xev))
+	GDK_NOTE (DND, 
+		  g_message ("Send event to %lx failed",
+			     GDK_WINDOW_XWINDOW (context->source_window)));
+    }
+
+  private->old_action = action;
+}
+
+void 
+gdk_drop_reply (GdkDragContext   *context,
+		gboolean          ok,
+		guint32           time)
+{
+  GdkDragContextPrivate *private;
+
+  g_return_if_fail (context != 0);
+
+  private = (GdkDragContextPrivate *)context;
+  
+  if (context->protocol == GDK_DRAG_PROTO_MOTIF)
+    {
+      XEvent xev;
+
+      xev.xclient.type = ClientMessage;
+      xev.xclient.message_type = gdk_atom_intern ("_MOTIF_DRAG_AND_DROP_MESSAGE", FALSE);
+      xev.xclient.format = 8;
+
+      xev.xclient.data.b[0] = XmDROP_START | 0x80;
+      xev.xclient.data.b[1] = local_byte_order;
+      if (ok)
+	xev.xclient.data.s[2] = XmDROP_COPY | 
+	                        (XmDROP_SITE_VALID << 4) |
+	                        (XmDROP_NOOP << 8) |
+	                        (XmDROP << 12);
+      else
+	xev.xclient.data.s[2] = XmDROP_NOOP | 
+	                        (XmNO_DROP_SITE << 4) |
+	                        (XmDROP_NOOP << 8) |
+	                        (XmDROP_CANCEL << 12);
+      xev.xclient.data.s[2] = private->last_x;
+      xev.xclient.data.s[3] = private->last_y;
+      
+      gdk_send_xevent (GDK_WINDOW_XWINDOW (context->source_window),
+		       FALSE, 0, &xev);
+    }
+}
+
+void             
+gdk_drop_finish (GdkDragContext   *context,
+		 gboolean          success,
+		 guint32           time)
+{
+  if (context->protocol == GDK_DRAG_PROTO_XDND)
+    {
+      XEvent xev;
+
+      xev.xclient.type = ClientMessage;
+      xev.xclient.message_type = gdk_atom_intern ("XdndFinished", FALSE);
+      xev.xclient.format = 32;
+      xev.xclient.window = GDK_WINDOW_XWINDOW (context->source_window);
+
+      xev.xclient.data.l[0] = GDK_WINDOW_XWINDOW (context->dest_window);
+      xev.xclient.data.l[1] = 0;
+      xev.xclient.data.l[2] = 0;
+      xev.xclient.data.l[3] = 0;
+      xev.xclient.data.l[4] = 0;
+
+      if (!gdk_send_xevent (GDK_WINDOW_XWINDOW (context->source_window),
+		       FALSE, 0, &xev))
+	GDK_NOTE (DND, 
+		  g_message ("Send event to %lx failed",
+			     GDK_WINDOW_XWINDOW (context->source_window)));
+    }
+}
+
+
+void            
+gdk_window_register_dnd (GdkWindow      *window)
+{
+  static guint32 xdnd_version = 3;
+  
+  MotifDragReceiverInfo info;
+
+  /* Set Motif drag receiver information property */
+
+  if (!motif_drag_receiver_info_atom)
+    motif_drag_receiver_info_atom = gdk_atom_intern ("_MOTIF_DRAG_RECEIVER_INFO", FALSE);
+
+  info.byte_order = local_byte_order;
+  info.protocol_version = 0;
+  info.protocol_style = XmDRAG_DYNAMIC;
+  info.proxy_window = GDK_NONE;
+  info.num_drop_sites = 0;
+  info.total_size = sizeof(info);
+
+  XChangeProperty (gdk_display, GDK_WINDOW_XWINDOW (window),
+		   motif_drag_receiver_info_atom,
+		   motif_drag_receiver_info_atom,
+		   8, PropModeReplace,
+		   (guchar *)&info,
+		   sizeof (info));
+
+  /* Set XdndAware */
+
+  if (!xdnd_aware_atom)
+    xdnd_aware_atom = gdk_atom_intern ("XdndAware", FALSE);
+
+  /* The property needs to be of type XA_ATOM, not XA_INTEGER. Blech */
+  XChangeProperty (GDK_WINDOW_XDISPLAY (window), 
+		   GDK_WINDOW_XWINDOW (window),
+		   xdnd_aware_atom, XA_ATOM,
+		   32, PropModeReplace,
+		   (guchar *)&xdnd_version,
+		   sizeof (xdnd_version));
+}
+
+/*************************************************************
+ * gdk_drag_get_selection:
+ *     Returns the selection atom for the current source window
+ *   arguments:
+ *     
+ *   results:
+ *************************************************************/
+
+GdkAtom       
+gdk_drag_get_selection (GdkDragContext *context)
+{
+  g_return_val_if_fail (context != NULL, GDK_NONE);
+
+  if (context->protocol == GDK_DRAG_PROTO_MOTIF)
+    return ((GdkDragContextPrivate *)context)->motif_selection;
+  else if (context->protocol == GDK_DRAG_PROTO_XDND)
+    return ((GdkDragContextPrivate *)context)->xdnd_selection;
+  else 
+    return GDK_NONE;
+}
+
diff --git a/gdk/x11/gdkimage-x11.c b/gdk/x11/gdkimage-x11.c
index 5c7a5de5c..4d009f9f4 100644
--- a/gdk/x11/gdkimage-x11.c
+++ b/gdk/x11/gdkimage-x11.c
@@ -409,6 +409,8 @@ gdk_image_destroy (GdkImage *image)
 
     case GDK_IMAGE_SHARED:
 #ifdef USE_SHM
+      gdk_flush();
+
       XShmDetach (private->xdisplay, private->x_shm_info);
       XDestroyImage (private->ximage);
 
diff --git a/gdk/x11/gdkmain-x11.c b/gdk/x11/gdkmain-x11.c
index 867dadef6..ca0d47504 100644
--- a/gdk/x11/gdkmain-x11.c
+++ b/gdk/x11/gdkmain-x11.c
@@ -116,13 +116,6 @@ static Bool	 gdk_event_get_type	(Display      *display,
 static void	 gdk_synthesize_click	(GdkEvent     *event, 
 					 gint	       nclicks);
 
-static void	 gdk_dnd_drag_begin	(GdkWindow    *initial_window);
-static void	 gdk_dnd_drag_enter	(Window	       dest);
-static void	 gdk_dnd_drag_leave	(Window	       dest);
-static void	 gdk_dnd_drag_end	(Window	       dest,
-					 GdkPoint      coords);
-static GdkAtom	 gdk_dnd_check_types	(GdkWindow    *window,
-					 XEvent	      *xevent);
 #ifdef DEBUG_DND
 static void	 gdk_print_atom		(GdkAtom       anatom);
 #endif
@@ -163,6 +156,10 @@ static gint   gdk_im_open		(XrmDatabase db,
 static void   gdk_im_close		(void);
 static void   gdk_ic_cleanup		(void);
 
+GdkFilterReturn gdk_wm_protocols_filter (GdkXEvent *xev,
+					 GdkEvent  *event,
+					 gpointer   data);
+
 #endif /* USE_XIM */
 
 /* Private variable declarations
@@ -217,6 +214,8 @@ static GdkWindowPrivate *xgrab_window = NULL;	    /* Window that currently holds
 						     *	x pointer grab
 						     */
 
+static GList *client_filters;	                    /* Filters for client messages */
+
 #ifdef USE_XIM
 static gint xim_using;				/* using XIM Protocol if TRUE */
 static GdkIM xim_im;				/* global IM */
@@ -549,14 +548,6 @@ gdk_init (int	 *argc,
   gdk_wm_window_protocols[1] = gdk_wm_take_focus;
   gdk_selection_property = XInternAtom (gdk_display, "GDK_SELECTION", False);
   
-  gdk_dnd.gdk_XdeEnter = gdk_atom_intern("_XDE_ENTER", FALSE);
-  gdk_dnd.gdk_XdeLeave = gdk_atom_intern("_XDE_LEAVE", FALSE);
-  gdk_dnd.gdk_XdeRequest = gdk_atom_intern("_XDE_REQUEST", FALSE);
-  gdk_dnd.gdk_XdeDataAvailable = gdk_atom_intern("_XDE_DATA_AVAILABLE", FALSE);
-  gdk_dnd.gdk_XdeTypelist = gdk_atom_intern("_XDE_TYPELIST", FALSE);
-  gdk_dnd.c->gdk_cursor_dragdefault = XCreateFontCursor(gdk_display, XC_bogosity);
-  gdk_dnd.c->gdk_cursor_dragok = XCreateFontCursor(gdk_display, XC_heart);
-  
   XGetKeyboardControl (gdk_display, &keyboard_state);
   autorepeat = keyboard_state.global_auto_repeat;
   
@@ -577,6 +568,10 @@ gdk_init (int	 *argc,
   gdk_window_init ();
   gdk_image_init ();
   gdk_input_init ();
+  gdk_dnd_init ();
+
+  gdk_add_client_message_filter (gdk_wm_protocols, 
+				 gdk_wm_protocols_filter, NULL);
   
 #ifdef USE_XIM
   /* initialize XIM Protocol variables */
@@ -928,13 +923,15 @@ gdk_event_copy (GdkEvent *event)
 	gdk_window_ref (event->crossing.subwindow);
       break;
       
-    case GDK_DROP_DATA_AVAIL:
-      new_event->dropdataavailable.data_type = g_strdup (event->dropdataavailable.data_type);
-      new_event->dropdataavailable.data = g_malloc (event->dropdataavailable.data_numbytes);
-      memcpy (new_event->dropdataavailable.data,
-	      event->dropdataavailable.data, 
-	      event->dropdataavailable.data_numbytes);
+    case GDK_DRAG_ENTER:
+    case GDK_DRAG_LEAVE:
+    case GDK_DRAG_MOTION:
+    case GDK_DRAG_STATUS:
+    case GDK_DROP_START:
+    case GDK_DROP_FINISHED:
+      gdk_drag_context_ref (event->dnd.context);
       break;
+
       
     default:
       break;
@@ -983,14 +980,15 @@ gdk_event_free (GdkEvent *event)
 	gdk_window_unref (event->crossing.subwindow);
       break;
       
-    case GDK_DROP_DATA_AVAIL:
-      g_free (event->dropdataavailable.data_type);
-      g_free (event->dropdataavailable.data);
-      break;
-      
-    case GDK_DRAG_REQUEST:
-      g_free (event->dragrequest.data_type);
+    case GDK_DRAG_ENTER:
+    case GDK_DRAG_LEAVE:
+    case GDK_DRAG_MOTION:
+    case GDK_DRAG_STATUS:
+    case GDK_DROP_START:
+    case GDK_DROP_FINISHED:
+      gdk_drag_context_unref (event->dnd.context);
       break;
+
       
     default:
       break;
@@ -1019,6 +1017,60 @@ gdk_event_free (GdkEvent *event)
  *--------------------------------------------------------------
  */
 
+/*
+ *--------------------------------------------------------------
+ * gdk_event_get_time:
+ *    Get the timestamp from an event.
+ *   arguments:
+ *     event:
+ *   results:
+ *    The event's time stamp, if it has one, otherwise
+ *    GDK_CURRENT_TIME.
+ *--------------------------------------------------------------
+ */
+
+guint32
+gdk_event_get_time (GdkEvent *event)
+{
+  if (event)
+    switch (event->type)
+      {
+      case GDK_MOTION_NOTIFY:
+	return event->motion.time;
+      case GDK_BUTTON_PRESS:
+      case GDK_2BUTTON_PRESS:
+      case GDK_3BUTTON_PRESS:
+      case GDK_BUTTON_RELEASE:
+	return event->button.time;
+      case GDK_KEY_PRESS:
+      case GDK_KEY_RELEASE:
+	return event->key.time;
+      case GDK_ENTER_NOTIFY:
+      case GDK_LEAVE_NOTIFY:
+	return event->crossing.time;
+      case GDK_PROPERTY_NOTIFY:
+	return event->property.time;
+      case GDK_SELECTION_CLEAR:
+      case GDK_SELECTION_REQUEST:
+      case GDK_SELECTION_NOTIFY:
+	return event->selection.time;
+      case GDK_PROXIMITY_IN:
+      case GDK_PROXIMITY_OUT:
+	return event->proximity.time;
+      case GDK_DRAG_ENTER:
+      case GDK_DRAG_LEAVE:
+      case GDK_DRAG_MOTION:
+      case GDK_DRAG_STATUS:
+      case GDK_DROP_START:
+      case GDK_DROP_FINISHED:
+	return event->dnd.time;
+      default:			/* use current time */
+	break;
+      }
+  
+  return GDK_CURRENT_TIME;
+}
+
 void
 gdk_set_show_events (int show_events)
 {
@@ -1773,6 +1825,20 @@ gdk_event_apply_filters (XEvent *xevent,
   return GDK_FILTER_CONTINUE;
 }
 
+void 
+gdk_add_client_message_filter (GdkAtom       message_type,
+			       GdkFilterFunc func,
+			       gpointer      data)
+{
+  GdkClientFilter *filter = g_new (GdkClientFilter, 1);
+
+  filter->type = message_type;
+  filter->function = func;
+  filter->data = data;
+  
+  client_filters = g_list_prepend (client_filters, filter);
+}
+
 static gint
 gdk_event_translate (GdkEvent *event,
 		     XEvent   *xevent)
@@ -1793,15 +1859,9 @@ gdk_event_translate (GdkEvent *event,
   
   return_val = FALSE;
   
-  /* We need to play catch-up with the dnd motion events */
-  if(gdk_dnd.drag_really && xevent->type == MotionNotify)
-    while (XCheckTypedEvent(xevent->xany.display,MotionNotify,xevent));
-  
   /* Find the GdkWindow that this event occurred in.
-   * All events occur in some GdkWindow (otherwise, why
-   *  would we be receiving them). It really is an error
-   *  to receive an event for which we cannot find the
-   *  corresponding GdkWindow. We handle events with window=None
+   * 
+   * We handle events with window=None
    *  specially - they are generated by XFree86's XInput under
    *  some circumstances.
    */
@@ -1822,15 +1882,20 @@ gdk_event_translate (GdkEvent *event,
   
   if (window != NULL)
     gdk_window_ref (window);
-  else if (gdk_null_window_warnings)
-    {
-      /* Special purpose programs that
-       * get events for other windows may
-       * want to disable this
-       */
-      g_warning ("xwindow(%#lx) lookup reveals NULL", xevent->xany.window);
-    }
+#ifdef USE_XIM
+  else if (XFilterEvent(xevent, None)) /* for xlib XIM handling */
+    return FALSE;
+#endif
+  else
+    GDK_NOTE (EVENTS, 
+      g_message ("Got event for unknown window: %#lx\n", xevent->xany.window));
+  
+  event->any.window = window;
+  event->any.send_event = xevent->xany.send_event;
   
+  if (window_private && window_private->destroyed)
+    return FALSE;
+
   /* Check for filters for this window */
   
   {
@@ -1845,7 +1910,7 @@ gdk_event_translate (GdkEvent *event,
 	return (result == GDK_FILTER_TRANSLATE) ? TRUE : FALSE;
       }
   }
-  
+
   /* We do a "manual" conversion of the XEvent to a
    *  GdkEvent. The structures are mostly the same so
    *  the conversion is fairly straightforward. We also
@@ -2031,44 +2096,7 @@ gdk_event_translate (GdkEvent *event,
 	  button_number[1] = -1;
 	  button_number[0] = event->button.button;
 	}
-      if(window_private
-	 && window_private->dnd_drag_enabled
-	 && !gdk_dnd.drag_perhaps
-	 && event->button.button == 1
-	 && !gdk_dnd.drag_really)
-	{
-	  gdk_dnd.drag_perhaps = 1;
-	  gdk_dnd.dnd_drag_start.x = xevent->xbutton.x_root;
-	  gdk_dnd.dnd_drag_start.y = xevent->xbutton.y_root;
-	  gdk_dnd.real_sw = window_private;
-	  
-	  if(gdk_dnd.drag_startwindows)
-	    {
-	      g_free(gdk_dnd.drag_startwindows);
-	      gdk_dnd.drag_startwindows = NULL;
-	    }
-	  gdk_dnd.drag_numwindows = gdk_dnd.drag_really = 0;
-	  gdk_dnd.dnd_grabbed = FALSE;
-	  
-	  {
-	    /* Set motion mask for first DnD'd window, since it
-	       will be the one that is actually dragged */
-	    XWindowAttributes dnd_winattr;
-	    XSetWindowAttributes dnd_setwinattr;
-	    
-	    /* We need to get motion events while the button is down, so
-	       we can know whether to really start dragging or not... */
-	    XGetWindowAttributes(gdk_display, (Window)window_private->xwindow,
-				 &dnd_winattr);
-	    
-	    window_private->dnd_drag_savedeventmask = dnd_winattr.your_event_mask;
-	    dnd_setwinattr.event_mask = 
-	      window_private->dnd_drag_eventmask = ButtonMotionMask | ButtonPressMask | ButtonReleaseMask |
-	      EnterWindowMask | LeaveWindowMask | ExposureMask;
-	    XChangeWindowAttributes(gdk_display, window_private->xwindow,
-				    CWEventMask, &dnd_setwinattr);
-	  }
-	}
+
       return_val = window_private && !window_private->destroyed;
       break;
       
@@ -2102,66 +2130,18 @@ gdk_event_translate (GdkEvent *event,
       event->button.source = GDK_SOURCE_MOUSE;
       event->button.deviceid = GDK_CORE_POINTER;
       
-      gdk_dnd.last_drop_time = xevent->xbutton.time;
-      if(gdk_dnd.drag_perhaps)
-	{
-	  {
-	    XSetWindowAttributes attrs;
-	    /* Reset event mask to pre-drag value, assuming event_mask
-	       doesn't change during drag */
-	    attrs.event_mask = gdk_dnd.real_sw->dnd_drag_savedeventmask;
-	    XChangeWindowAttributes(gdk_display, gdk_dnd.real_sw->xwindow,
-				    CWEventMask, &attrs);
-	  }
-	  
-	  if (gdk_dnd.dnd_grabbed) 
-	    {
-	      gdk_dnd_display_drag_cursor(-2,
-					  -2,
-					  FALSE, TRUE);
-	      XUngrabPointer(gdk_display, CurrentTime);
-	      gdk_dnd.dnd_grabbed = FALSE;
-	    }
-	  
-	  if(gdk_dnd.drag_really)
-	    {
-	      GdkPoint foo;
-	      foo.x = xevent->xbutton.x_root;
-	      foo.y = xevent->xbutton.y_root;
-	      
-	      if(gdk_dnd.dnd_drag_target != None)
-		gdk_dnd_drag_end(gdk_dnd.dnd_drag_target, foo);
-	      gdk_dnd.drag_really = 0;
-	      
-	      gdk_dnd.drag_numwindows = 0;
-	      if(gdk_dnd.drag_startwindows)
-		{
-		  g_free(gdk_dnd.drag_startwindows);
-		  gdk_dnd.drag_startwindows = NULL;
-		}
-	      
-	      gdk_dnd.real_sw = NULL;
-	    }
-	  
-	  gdk_dnd.drag_perhaps = 0;
-	  gdk_dnd.dnd_drag_start.x = gdk_dnd.dnd_drag_start.y = 0;
-	  gdk_dnd.dnd_drag_dropzone.x = gdk_dnd.dnd_drag_dropzone.y = 0;
-	  gdk_dnd.dnd_drag_dropzone.width = gdk_dnd.dnd_drag_dropzone.height = 0;
-	  gdk_dnd.dnd_drag_curwin = None;
-	  return_val = window_private?TRUE:FALSE;
-	} else
-	  return_val = window_private && !window_private->destroyed;
+      return_val = window_private && !window_private->destroyed;
+
       break;
       
     case MotionNotify:
       /* Print debugging info.
        */
       GDK_NOTE (EVENTS,
-		g_message ("motion notify:\t\twindow: %ld  x,y: %d %d  hint: %s d:%d r%d",
+		g_message ("motion notify:\t\twindow: %ld  x,y: %d %d  hint: %s", 
 			   xevent->xmotion.window - base_id,
 			   xevent->xmotion.x, xevent->xmotion.y,
-			   (xevent->xmotion.is_hint) ? "true" : "false",
-			   gdk_dnd.drag_perhaps, gdk_dnd.drag_really));
+			   (xevent->xmotion.is_hint) ? "true" : "false"));
       
       if (window_private &&
 	  (window_private->extension_events != 0) &&
@@ -2183,114 +2163,7 @@ gdk_event_translate (GdkEvent *event,
       event->motion.source = GDK_SOURCE_MOUSE;
       event->motion.deviceid = GDK_CORE_POINTER;
       
-#define IS_IN_ZONE(cx, cy) (cx >= gdk_dnd.dnd_drag_dropzone.x \
-     && cy >= gdk_dnd.dnd_drag_dropzone.y \
-     && cx < (gdk_dnd.dnd_drag_dropzone.x + gdk_dnd.dnd_drag_dropzone.width) \
-     && cy < (gdk_dnd.dnd_drag_dropzone.y + gdk_dnd.dnd_drag_dropzone.height))
-      
-      if(gdk_dnd.drag_perhaps && gdk_dnd.drag_really
-	 /* && event->motion.is_hint */ /* HINTME */)
-	{
-	  /* First, we have to find what window the motion was in... */
-	  /* XXX there has to be a better way to do this, perhaps with
-	     XTranslateCoordinates or XQueryTree - I don't know how,
-	     and this sort of works */
-	  static Window lastwin = None, curwin = None;
-#if 0
-	  Window twin;
-#endif
-	  Window childwin = gdk_root_window;
-	  int x, y, ox, oy;
-	  
-	  /* Interlude - display cursor for the drag ASAP */
-	  gdk_dnd_display_drag_cursor(xevent->xmotion.x_root,
-				      xevent->xmotion.y_root,
-				      gdk_dnd.dnd_drag_target?TRUE:FALSE,
-				      FALSE);
-	  
-	  lastwin = curwin;
-	  curwin = gdk_root_window;
-	  ox = x = xevent->xmotion.x_root;
-	  oy = y = xevent->xmotion.y_root;
-#if 1
-	  curwin = gdk_window_xid_at_coords(xevent->xmotion.x_root,
-					    xevent->xmotion.y_root,
-					    gdk_dnd.c->xids,TRUE);
-	  XTranslateCoordinates(gdk_display, gdk_root_window, curwin,
-				x, y, &x, &y, &childwin);
-#else
-	  while(childwin != None)
-	    {
-	      ox = x; oy = y;
-	      curwin = childwin;
-	      XTranslateCoordinates(gdk_display, curwin, curwin,
-				    x, y, &x, &y, &childwin);
-	      if(childwin != None) 
-		{
-		  XTranslateCoordinates(gdk_display, curwin, childwin,
-					x, y, &x, &y, &twin);
-		}
-	    }
-#endif
-	  GDK_NOTE (DND,
-		    g_message("Drag is now in window %#lx, lastwin was %#lx, ddc = %#lx",
-			      curwin, lastwin, gdk_dnd.dnd_drag_curwin));
-	  if(curwin != gdk_dnd.dnd_drag_curwin && curwin != lastwin)
-	    {
-	      /* We have left one window and entered another
-		 (do leave & enter bits) */
-	      if(gdk_dnd.dnd_drag_curwin != None)
-		gdk_dnd_drag_leave(gdk_dnd.dnd_drag_curwin);
-	      gdk_dnd.dnd_drag_curwin = curwin;
-	      gdk_dnd_drag_enter(gdk_dnd.dnd_drag_curwin);
-	      gdk_dnd.dnd_drag_dropzone.x = gdk_dnd.dnd_drag_dropzone.y = 0;
-	      gdk_dnd.dnd_drag_dropzone.width = gdk_dnd.dnd_drag_dropzone.height = 0;
-	      gdk_dnd.dnd_drag_target = None;
-	      GDK_NOTE (DND,
-			g_message("curwin = %#lx, lastwin = %#lx, dnd_drag_curwin = %#lx",
-				  curwin, lastwin, gdk_dnd.dnd_drag_curwin));
-	      
-	      gdk_dnd_display_drag_cursor(xevent->xmotion.x_root,
-					  xevent->xmotion.y_root,
-					  FALSE, TRUE);
-	    }
-	  else if(gdk_dnd.dnd_drag_dropzone.width > 0
-		  && gdk_dnd.dnd_drag_dropzone.height > 0
-		  && curwin == gdk_dnd.dnd_drag_curwin)
-	    {
-	      /* Handle all that dropzone stuff - thanks John ;-) */
-	      if (gdk_dnd.dnd_drag_target != None)
-		{
-		  gboolean in_zone = IS_IN_ZONE(xevent->xmotion.x_root,
-						xevent->xmotion.y_root);
-		  gboolean old_in_zone = IS_IN_ZONE(gdk_dnd.dnd_drag_oldpos.x, 
-						    gdk_dnd.dnd_drag_oldpos.y);
-		  
-		  if (!in_zone && old_in_zone)
-		    {
-		      /* We were in the drop zone and moved out */
-		      gdk_dnd.dnd_drag_target = None;
-		      gdk_dnd_drag_leave(curwin);
-		      gdk_dnd_display_drag_cursor(xevent->xmotion.x_root,
-						  xevent->xmotion.y_root,
-						  FALSE, TRUE);
-		    }
-		  else if (!in_zone && !old_in_zone)
-		    {
-		      /* We were outside drop zone but in the window
-			 - have to send enter events */
-		      gdk_dnd_drag_enter(curwin);
-		      gdk_dnd.dnd_drag_curwin = curwin;
-		      gdk_dnd.dnd_drag_dropzone.x = gdk_dnd.dnd_drag_dropzone.y = 0;
-		      gdk_dnd.dnd_drag_target = None;
-		    }
-		}
-	    } /* else
-		 dnd_drag_curwin = None; */
-	  return_val = FALSE;
-	}
-      else
-	return_val = window_private && !window_private->destroyed;
+      return_val = window_private && !window_private->destroyed;
       break;
       
     case EnterNotify:
@@ -2366,35 +2239,7 @@ gdk_event_translate (GdkEvent *event,
       
       event->crossing.focus = xevent->xcrossing.focus;
       event->crossing.state = xevent->xcrossing.state;
-      
-#ifdef G_ENABLE_DEBUG
-      if ((gdk_debug_flags & GDK_DEBUG_DND) & gdk_dnd.drag_perhaps)
-	{
-	  g_message("We may[%d] have a drag into %#lx = %#lx",
-		    gdk_dnd.drag_really,
-		    xevent->xcrossing.window, gdk_dnd.real_sw->xwindow);
-	}
-#endif /* G_ENABLE_DEBUG */
-      
-      if (gdk_dnd.drag_perhaps && gdk_dnd.drag_really && 
-	  (xevent->xcrossing.window == gdk_dnd.real_sw->xwindow))
-	{
-#if 0
-	  gdk_dnd.drag_really = 0;
-	  
-	  GDK_NOTE (DND, g_message("Ungrabbed"));
-	  
-	  gdk_dnd.drag_numwindows = 0;
-	  g_free(gdk_dnd.drag_startwindows);
-	  gdk_dnd.drag_startwindows = NULL;
-	  /* We don't want to ungrab the pointer here, or we'll
-	   * start getting spurious enter/leave events */
-#endif
-#if 0
-	  XChangeActivePointerGrab (gdk_display, 0, None, CurrentTime);
-#endif
-	}
-      
+  
       return_val = window_private && !window_private->destroyed;
       break;
       
@@ -2465,37 +2310,6 @@ gdk_event_translate (GdkEvent *event,
       event->crossing.focus = xevent->xcrossing.focus;
       event->crossing.state = xevent->xcrossing.state;
       
-#ifdef G_ENABLE_DEBUG
-      if ((gdk_debug_flags & GDK_DEBUG_DND) & gdk_dnd.drag_perhaps)
-	{
-	  g_message("We may[%d] have a drag out of %#lx = %#lx",
-		    gdk_dnd.drag_really,
-		    xevent->xcrossing.window, gdk_dnd.real_sw->xwindow);
-	}
-#endif /* G_ENABLE_DEBUG */
-      if (gdk_dnd.drag_perhaps && !gdk_dnd.drag_really &&
-	  (xevent->xcrossing.window == gdk_dnd.real_sw->xwindow))
-	{
-	  gboolean xgpret;
-	  gdk_dnd_drag_addwindow((GdkWindow *) gdk_dnd.real_sw);
-	  gdk_dnd_drag_begin((GdkWindow *) gdk_dnd.real_sw);
-	  xgpret = 
-	    XGrabPointer(gdk_display, gdk_dnd.real_sw->xwindow, False,
-			 ButtonMotionMask | PointerMotionMask |
-			 /* PointerMotionHintMask | */ /* HINTME */
-			 ButtonPressMask | ButtonReleaseMask,
-			 GrabModeAsync, GrabModeAsync, None,
-			 None, CurrentTime);
-#ifdef G_ENABLE_DEBUG
-	  GDK_NOTE(DND, g_message("xgpret = %d", xgpret));
-#endif
-	  gdk_dnd.dnd_grabbed = TRUE;
-	  gdk_dnd.drag_really = 1;
-	  gdk_dnd_display_drag_cursor(xevent->xmotion.x_root,
-				      xevent->xmotion.y_root,
-				      FALSE, TRUE);
-	}
-      
       return_val = window_private && !window_private->destroyed;
       break;
       
@@ -2852,231 +2666,50 @@ gdk_event_translate (GdkEvent *event,
       break;
       
     case ClientMessage:
-      /* Print debugging info.
-       */
-      GDK_NOTE (EVENTS,
-		g_message ("client message:\twindow: %ld",
-			   xevent->xclient.window - base_id));
-      
-      /* Client messages are the means of the window manager
-       *  communicating with a program. We'll first check to
-       *  see if this is really the window manager talking
-       *  to us.
-       */
-      if (xevent->xclient.message_type == gdk_wm_protocols)
-	{
-	  if ((Atom) xevent->xclient.data.l[0] == gdk_wm_delete_window)
-	    {
-	      /* The delete window request specifies a window
-	       *  to delete. We don't actually destroy the
-	       *  window because "it is only a request". (The
-	       *  window might contain vital data that the
-	       *  program does not want destroyed). Instead
-	       *  the event is passed along to the program,
-	       *  which should then destroy the window.
-	       */
-	      
-	      /* Print debugging info.
-	       */
-	      GDK_NOTE (EVENTS,
-			g_message ("delete window:\t\twindow: %ld",
-				   xevent->xclient.window - base_id));
-	      
-	      event->any.type = GDK_DELETE;
-	      event->any.window = window;
-	      
-	      return_val = window_private && !window_private->destroyed;
-	    }
-	  else if ((Atom) xevent->xclient.data.l[0] == gdk_wm_take_focus)
-	    {
-	    }
-	}
-      else if (xevent->xclient.message_type == gdk_dnd.gdk_XdeEnter)
-	{
-	  Atom reptype = 0;
-	  
-	  event->dropenter.u.allflags = xevent->xclient.data.l[1];
-	  
-	  GDK_NOTE (DND, g_message ("GDK_DROP_ENTER [%d][%d]",
-				    window_private->dnd_drop_enabled, event->dropenter.u.flags.sendreply));
-	  return_val = FALSE;
-	  
-	  /* Now figure out if we really want this drop...
-	   * If someone is trying funky clipboard stuff, ignore 
-	   */
-	  if (window_private
-	      && window_private->dnd_drop_enabled
-	      && event->dropenter.u.flags.sendreply
-	      && (reptype = gdk_dnd_check_types (window, xevent)))
-	    {
-	      XEvent replyev;
-	      
-	      replyev.xclient.type = ClientMessage;
-	      replyev.xclient.window = xevent->xclient.data.l[0];
-	      replyev.xclient.format = 32;
-	      replyev.xclient.message_type = gdk_dnd.gdk_XdeRequest;
-	      replyev.xclient.data.l[0] = window_private->xwindow;
-	      
-	      event->dragrequest.u.allflags = 0;
-	      event->dragrequest.u.flags.protocol_version =
-		DND_PROTOCOL_VERSION;
-	      event->dragrequest.u.flags.willaccept = 1;
-	      event->dragrequest.u.flags.delete_data =
-		(window_private->dnd_drop_destructive_op) ? 1 : 0;
-	      
-	      replyev.xclient.data.l[1] = event->dragrequest.u.allflags;
-	      replyev.xclient.data.l[2] = replyev.xclient.data.l[3] = 0;
-	      replyev.xclient.data.l[4] = reptype;
-	      
-	      if (!gdk_send_xevent (replyev.xclient.window, False, 
-				    NoEventMask, &replyev))
-		GDK_NOTE (DND, g_message("Sending XdeRequest to %#lx failed",
-					 replyev.xclient.window));
-	      
-	      event->any.type = GDK_DROP_ENTER;
-	      event->any.window = window;
-	      event->dropenter.requestor = replyev.xclient.window;
-	      event->dropenter.u.allflags = xevent->xclient.data.l[1];
-	      
-	      GDK_NOTE (DND, g_message("We sent a GDK_DROP_ENTER on to Gtk"));
-	      return_val = TRUE;
-	    }
-	}
-      else if (xevent->xclient.message_type == gdk_dnd.gdk_XdeLeave)
-	{
-#ifdef G_ENABLE_DEBUG	  
-	  if (gdk_debug_flags & (GDK_DEBUG_EVENTS | GDK_DEBUG_DND))
-	    g_message ("GDK_DROP_LEAVE");
-#endif	  
-	  
-	  if (window_private && window_private->dnd_drop_enabled)
-	    {
-	      event->dropleave.type = GDK_DROP_LEAVE;
-	      event->dropleave.window = window;
-	      event->dropleave.requestor = xevent->xclient.data.l[0];
-	      event->dropleave.u.allflags = xevent->xclient.data.l[1];
-	      return_val = TRUE;
-	    }
-	  else
+      {
+	GList *tmp_list;
+	GdkFilterReturn result = GDK_FILTER_CONTINUE;
+
+	/* Print debugging info.
+	 */
+	GDK_NOTE (EVENTS,
+		  g_message ("client message:\twindow: %ld",
+			     xevent->xclient.window - base_id));
+	
+	tmp_list = client_filters;
+	while (tmp_list)
+	  {
+	    GdkClientFilter *filter = tmp_list->data;
+	    if (filter->type == xevent->xclient.message_type)
+	      {
+		result = (*filter->function) (xevent, event, filter->data);
+		break;
+	      }
+	    
+	    tmp_list = tmp_list->next;
+	  }
+
+	switch (result)
+	  {
+	  case GDK_FILTER_REMOVE:
 	    return_val = FALSE;
-	}
-      else if (xevent->xclient.message_type == gdk_dnd.gdk_XdeRequest)
-	{
-	  /* 
-	   * make sure to only handle requests from the window the cursor is
-	   * over 
-	   */
-#ifdef G_ENABLE_DEBUG	  
-	  if (gdk_debug_flags & (GDK_DEBUG_EVENTS | GDK_DEBUG_DND))
-	    g_message ("GDK_DRAG_REQUEST");
-#endif	  
-	  event->dragrequest.u.allflags = xevent->xclient.data.l[1];
-	  return_val = FALSE;
-	  
-	  if (window && gdk_dnd.drag_really &&
-	      xevent->xclient.data.l[0] == gdk_dnd.dnd_drag_curwin &&
-	      event->dragrequest.u.flags.sendreply == 0)
-	    {
-	      /* Got request - do we need to ask user? */
-	      if (!event->dragrequest.u.flags.willaccept
-		  && event->dragrequest.u.flags.senddata)
-		{
-		  /* Yes we do :) */
-		  event->dragrequest.type = GDK_DRAG_REQUEST;
-		  event->dragrequest.window = window;
-		  event->dragrequest.requestor = xevent->xclient.data.l[0];
-		  event->dragrequest.isdrop = 0;
-		  event->dragrequest.drop_coords.x =
-		    event->dragrequest.drop_coords.y = 0;
-		  return_val = TRUE;
-		}
-	      else if (event->dragrequest.u.flags.willaccept)
-		{
-		  window_private->dnd_drag_destructive_op =
-		    event->dragrequest.u.flags.delete_data;
-		  window_private->dnd_drag_accepted = 1;
-		  window_private->dnd_drag_data_type =
-		    xevent->xclient.data.l[4];
-		  
-		  gdk_dnd.dnd_drag_target = gdk_dnd.dnd_drag_curwin;
-		  gdk_dnd_display_drag_cursor(-1, -1, TRUE, TRUE);
-		}
-	      gdk_dnd.dnd_drag_dropzone.x = xevent->xclient.data.l[2] & 65535;
-	      gdk_dnd.dnd_drag_dropzone.y =
-		(xevent->xclient.data.l[2] >> 16) & 65535;
-	      gdk_dnd.dnd_drag_dropzone.width = xevent->xclient.data.l[3] & 65535;
-	      gdk_dnd.dnd_drag_dropzone.height =
-		(xevent->xclient.data.l[3] >> 16) & 65535;
-	    }
-	}
-      else if(xevent->xclient.message_type == gdk_dnd.gdk_XdeDataAvailable)
-	{
-	  gint tmp_int; Atom tmp_atom;
-	  gulong tmp_long;
-	  guchar *tmp_charptr;
-	  
-#ifdef G_ENABLE_DEBUG	  
-	  if (gdk_debug_flags & (GDK_DEBUG_EVENTS | GDK_DEBUG_DND))
-	    g_message("GDK_DROP_DATA_AVAIL");
-#endif	  
-	  event->dropdataavailable.u.allflags = xevent->xclient.data.l[1];
-	  event->dropdataavailable.timestamp = xevent->xclient.data.l[4];
-	  event->dropdataavailable.coords.x =
-	    xevent->xclient.data.l[3] & 0xffff;
-	  event->dropdataavailable.coords.y =
-	    (xevent->xclient.data.l[3] >> 16) & 0xffff;
-	  if(window
-	     /* No preview of data ATM */
-	     && event->dropdataavailable.u.flags.isdrop)
-	    {
-	      event->dropdataavailable.type = GDK_DROP_DATA_AVAIL;
-	      event->dropdataavailable.window = window;
-	      event->dropdataavailable.requestor = xevent->xclient.data.l[0];
-	      event->dropdataavailable.data_type =
-		gdk_atom_name(xevent->xclient.data.l[2]);
-	      if(XGetWindowProperty (gdk_display,
-				     event->dropdataavailable.requestor,
-				     xevent->xclient.data.l[2],
-				     0, LONG_MAX - 1,
-				     False, XA_PRIMARY, &tmp_atom,
-				     &tmp_int,
-				     &event->dropdataavailable.data_numbytes,
-				     &tmp_long,
-				     &tmp_charptr)
-		 != Success)
-		{
-		  g_warning("XGetWindowProperty on %#x may have failed\n",
-			    event->dropdataavailable.requestor);
-		  event->dropdataavailable.data = NULL;
-		}
-	      else
-		{
-		  GDK_NOTE (DND, g_message("XGetWindowProperty got us %ld bytes",
-					   event->dropdataavailable.data_numbytes));
-		  event->dropdataavailable.data =
-		    g_malloc (event->dropdataavailable.data_numbytes);
-		  memcpy (event->dropdataavailable.data,
-			  tmp_charptr, event->dropdataavailable.data_numbytes);
-		  XFree(tmp_charptr);
-		  return_val = TRUE;
-		}
-	      return_val = TRUE;
-	    }
-	}
-      else
-	{
-	  /* Send unknown ClientMessage's on to Gtk for it to use */
-	  event->client.type = GDK_CLIENT_EVENT;
-	  event->client.window = window;
-	  event->client.message_type = xevent->xclient.message_type;
-	  event->client.data_format = xevent->xclient.format;
-	  memcpy(&event->client.data, &xevent->xclient.data,
-		 sizeof(event->client.data));
-	  if(window)
+	    break;
+	  case GDK_FILTER_TRANSLATE:
 	    return_val = TRUE;
-	  else	
-	    return_val = FALSE;
-	}
+	    break;
+	  case GDK_FILTER_CONTINUE:
+	    /* Send unknown ClientMessage's on to Gtk for it to use */
+	    event->client.type = GDK_CLIENT_EVENT;
+	    event->client.window = window;
+	    event->client.message_type = xevent->xclient.message_type;
+	    event->client.data_format = xevent->xclient.format;
+	    memcpy(&event->client.data, &xevent->xclient.data,
+		   sizeof(event->client.data));
+	    
+	    return_val = (window != NULL);
+	  }
+      }
+      
       if(window_private)
 	return_val = return_val && !window_private->destroyed;
       break;
@@ -3129,6 +2762,38 @@ gdk_event_translate (GdkEvent *event,
   return return_val;
 }
 
+GdkFilterReturn
+gdk_wm_protocols_filter (GdkXEvent *xev,
+		     GdkEvent  *event,
+		     gpointer data)
+{
+  XEvent *xevent = (XEvent *)xev;
+
+  if ((Atom) xevent->xclient.data.l[0] == gdk_wm_delete_window)
+    {
+  /* The delete window request specifies a window
+   *  to delete. We don't actually destroy the
+   *  window because "it is only a request". (The
+   *  window might contain vital data that the
+   *  program does not want destroyed). Instead
+   *  the event is passed along to the program,
+   *  which should then destroy the window.
+   */
+      GDK_NOTE (EVENTS,
+		g_message ("delete window:\t\twindow: %ld",
+			   xevent->xclient.window - base_id));
+      
+      event->any.type = GDK_DELETE;
+
+      return GDK_FILTER_TRANSLATE;
+    }
+  else if ((Atom) xevent->xclient.data.l[0] == gdk_wm_take_focus)
+    {
+    }
+
+  return GDK_FILTER_REMOVE;
+}
+
 #if 0
 static Bool
 gdk_event_get_type (Display  *display,
@@ -3344,67 +3009,6 @@ gdk_signal (int sig_num)
 #endif /* !G_ENABLE_DEBUG */
 }
 
-static void
-gdk_dnd_drag_begin (GdkWindow *initial_window)
-{
-  GdkEvent tev;
-  
-  GDK_NOTE(DND, g_message("------- STARTING DRAG from %p", initial_window));
-  
-  tev.type = GDK_DRAG_BEGIN;
-  tev.dragbegin.window = initial_window;
-  tev.dragbegin.u.allflags = 0;
-  tev.dragbegin.u.flags.protocol_version = DND_PROTOCOL_VERSION;
-  
-  gdk_event_put (&tev);
-}
-
-static void
-gdk_dnd_drag_enter (Window dest)
-{
-  XEvent sev;
-  GdkEventDropEnter tev;
-  int i;
-  GdkWindowPrivate *wp;
-  
-  sev.xclient.type = ClientMessage;
-  sev.xclient.format = 32;
-  sev.xclient.message_type = gdk_dnd.gdk_XdeEnter;
-  sev.xclient.window = dest;
-  
-  tev.u.allflags = 0;
-  tev.u.flags.protocol_version = DND_PROTOCOL_VERSION;
-  tev.u.flags.sendreply = 1;
-  for (i = 0; i < gdk_dnd.drag_numwindows; i++)
-    {
-      wp = (GdkWindowPrivate *) gdk_dnd.drag_startwindows[i];
-      if (wp->dnd_drag_data_numtypesavail)
-	{
-	  sev.xclient.data.l[0] = wp->xwindow;
-	  tev.u.flags.extended_typelist = (wp->dnd_drag_data_numtypesavail > 3)?1:0;
-	  sev.xclient.data.l[1] = tev.u.allflags;
-	  sev.xclient.data.l[2] = wp->dnd_drag_data_typesavail[0];
-	  if (wp->dnd_drag_data_numtypesavail > 1)
-	    {
-	      sev.xclient.data.l[3] = wp->dnd_drag_data_typesavail[1];
-	      if (wp->dnd_drag_data_numtypesavail > 2)
-		{
-		  sev.xclient.data.l[4] = wp->dnd_drag_data_typesavail[2];
-		}
-	      else
-		sev.xclient.data.l[4] = None;
-	    }
-	  else
-	    sev.xclient.data.l[3] = sev.xclient.data.l[4] = None;
-	  if (!gdk_send_xevent (dest, False, StructureNotifyMask, &sev))
-	    GDK_NOTE (DND, g_message("Sending XdeEnter to %#lx failed",
-				     dest));
-	}
-      
-    }
-}
-
-
 #ifdef USE_XIM
 
 /* The following routines duplicate functionality in Xlib to
@@ -4051,145 +3655,58 @@ _g_mbtowc (wchar_t *wstr, const char *str, size_t len)
 
 #endif /* X_LOCALE */
 
-static void
-gdk_dnd_drag_leave (Window dest)
-{
-  XEvent sev;
-  GdkEventDropLeave tev;
-  int i;
-  GdkWindowPrivate *wp;
-  
-  tev.u.allflags = 0;
-  
-  tev.u.flags.protocol_version = DND_PROTOCOL_VERSION;
-  sev.xclient.type = ClientMessage;
-  sev.xclient.window = dest;
-  sev.xclient.format = 32;
-  sev.xclient.message_type = gdk_dnd.gdk_XdeLeave;
-  sev.xclient.data.l[1] = tev.u.allflags;
-  for (i = 0; i < gdk_dnd.drag_numwindows; i++)
-    {
-      wp = (GdkWindowPrivate *) gdk_dnd.drag_startwindows[i];
-      sev.xclient.data.l[0] = wp->xwindow;
-      if (!gdk_send_xevent (dest, False, StructureNotifyMask, &sev))
-	GDK_NOTE (DND, g_message("Sending XdeLeave to %#lx failed",
-				 dest));
-      wp->dnd_drag_accepted = 0;
-    }
-}
-
 /* 
- * when a drop occurs, we go through the list of windows being dragged and
- * tell them that it has occurred, so that they can set things up and reply
- * to 'dest' window 
+ * used for debugging only 
  */
+#ifdef DEBUG_DND
 static void
-gdk_dnd_drag_end (Window     dest, 
-		  GdkPoint   coords)
+gdk_print_atom (GdkAtom anatom)
 {
-  GdkWindowPrivate *wp;
-  GdkEvent tev;
-  int i;
-  
-  tev.dragrequest.type = GDK_DRAG_REQUEST;
-  tev.dragrequest.drop_coords = coords;
-  tev.dragrequest.requestor = dest;
-  tev.dragrequest.u.allflags = 0;
-  tev.dragrequest.u.flags.protocol_version = DND_PROTOCOL_VERSION;
-  tev.dragrequest.isdrop = 1;
-  
-  for (i = 0; i < gdk_dnd.drag_numwindows; i++)
-    {
-      wp = (GdkWindowPrivate *) gdk_dnd.drag_startwindows[i];
-      if (wp->dnd_drag_accepted)
-	{
-	  tev.dragrequest.window = (GdkWindow *) wp;
-	  tev.dragrequest.u.flags.delete_data = wp->dnd_drag_destructive_op;
-	  tev.dragrequest.timestamp = gdk_dnd.last_drop_time;
-	  tev.dragrequest.data_type = 
-	    gdk_atom_name(wp->dnd_drag_data_type);
-	  
-	  gdk_event_put(&tev);
-	}
-    }
+  gchar *tmpstr = NULL;
+  tmpstr = (anatom!=None)?gdk_atom_name(anatom):"(none)";
+  g_message("Atom %lu has name %s", anatom, tmpstr);
+  if(tmpstr)
+    g_free(tmpstr);
 }
+#endif
 
-static GdkAtom
-gdk_dnd_check_types (GdkWindow	 *window, 
-		     XEvent	 *xevent)
+#ifdef WE_HAVE_MOTIF_DROPS_DONE
+static GdkWindow *
+gdk_drop_get_real_window (GdkWindow   *w, 
+			  guint16     *x, 
+			  guint16     *y)
 {
-  GdkWindowPrivate *wp = (GdkWindowPrivate *) window;
-  int i, j;
-  GdkEventDropEnter event;
+  GdkWindow *retval = w;
+  GdkWindowPrivate *awin;
+  GList *children;
+  gint16 myx = *x, myy = *y;
   
-  g_return_val_if_fail(window != NULL, 0);
-  g_return_val_if_fail(xevent != NULL, 0);
-  g_return_val_if_fail(xevent->type == ClientMessage, 0);
-  g_return_val_if_fail(xevent->xclient.message_type == gdk_dnd.gdk_XdeEnter, 0);
+  g_return_val_if_fail (w != NULL && x != NULL && y != NULL, NULL);
   
-  if(wp->dnd_drop_data_numtypesavail <= 0 ||
-     !wp->dnd_drop_data_typesavail)
-    return 0;
+  myx = *x; 
+  myy = *y;
   
-  for (i = 2; i <= 4; i++)
+ descend:
+  for (children = gdk_window_get_children(retval); 
+       children && children->next;
+       children = children->next)
     {
-      for (j = 0; j < wp->dnd_drop_data_numtypesavail; j++)
+      awin = (GdkWindowPrivate *) children->data;
+      if ((myx >= awin->x) && (myy >= awin->y)
+	  && (myx < (awin->x + awin->width))
+	  && (myy < (awin->y + awin->height)))
 	{
-	  if (xevent->xclient.data.l[i] == wp->dnd_drop_data_typesavail[j])
-	    return xevent->xclient.data.l[i];
+	  retval = (GdkWindow *) awin;
+	  myx -= awin->x;
+	  myy -= awin->y;
+	  goto descend;
 	}
     }
   
-  /* Now we get the extended type list if it's available */
-  event.u.allflags = xevent->xclient.data.l[1];
-  if (event.u.flags.extended_typelist)
-    {
-      Atom *exttypes, realtype;
-      gulong nitems, nbar;
-      gint realfmt;
-      
-      if (XGetWindowProperty(gdk_display, xevent->xclient.data.l[0],
-			     gdk_dnd.gdk_XdeTypelist, 0L, LONG_MAX - 1,
-			     False, AnyPropertyType, &realtype, &realfmt,
-			     &nitems, &nbar, (unsigned char **) &exttypes)
-	  != Success)
-	return 0;
-      
-      if (realfmt != (sizeof(Atom) * 8))
-	{
-	  g_warning("XdeTypelist property had format of %d instead of the expected %ld, on window %#lx\n",
-		    realfmt, (glong)sizeof(Atom) * 8, xevent->xclient.data.l[0]);
-	  return 0;
-	}
-      
-      for (i = 0; i <= nitems; i++)
-	{
-	  for (j = 0; j < wp->dnd_drop_data_numtypesavail; j++)
-	    {
-	      if (exttypes[i] == wp->dnd_drop_data_typesavail[j])
-		{
-		  XFree (exttypes);
-		  return exttypes[i];
-		}
-	    }
-	}
-      XFree (exttypes);
-    }
-  return 0;
-}
-
-/* 
- * used for debugging only 
- */
-#ifdef DEBUG_DND
-static void
-gdk_print_atom (GdkAtom anatom)
-{
-  gchar *tmpstr = NULL;
-  tmpstr = (anatom!=None)?gdk_atom_name(anatom):"(none)";
-  g_message("Atom %lu has name %s", anatom, tmpstr);
-  if(tmpstr)
-    g_free(tmpstr);
+  *x = myx; 
+  *y = myy;
+  
+  return retval;
 }
 #endif
 
@@ -4199,7 +3716,7 @@ gdk_print_atom (GdkAtom anatom)
 static Window 
 getchildren (Display	 *dpy, 
 	     Window	  win, 
-	     Atom	  WM_STATE)
+	     Atom	  wm_state_atom)
 {
   Window root, parent, *children, inf = 0;
   Atom type = None;
@@ -4213,7 +3730,7 @@ getchildren (Display	 *dpy,
   
   for (i = 0; !inf && (i < nchildren); i++)
     {
-      XGetWindowProperty (dpy, children[i], WM_STATE, 0, 0, False,
+      XGetWindowProperty (dpy, children[i], wm_state_atom, 0, 0, False,
 			  AnyPropertyType, &type, &format, &nitems,
 			  &after, &data);
       if (type != 0)
@@ -4222,7 +3739,7 @@ getchildren (Display	 *dpy,
     }
   
   for (i = 0; !inf && (i < nchildren); i++)
-    inf = getchildren (dpy, children[i], WM_STATE);
+    inf = getchildren (dpy, children[i], wm_state_atom);
   
   if (children != None)
     XFree ((char *) children);
@@ -4239,7 +3756,7 @@ Window
 gdk_get_client_window (Display	*dpy, 
 		       Window	 win)
 {
-  Atom WM_STATE;
+  static Atom wm_state_atom = None;
   Atom type = None;
   int format;
   unsigned long nitems, after;
@@ -4249,15 +3766,18 @@ gdk_get_client_window (Display	*dpy,
   if (win == 0)
     return DefaultRootWindow(dpy);
   
-  if ((WM_STATE = XInternAtom (dpy, "WM_STATE", True)) == 0)
+  if ((wm_state_atom = XInternAtom (dpy, "WM_STATE", True)) == 0)
     return win;
-  
-  XGetWindowProperty (dpy, win, WM_STATE, 0, 0, False, AnyPropertyType,
+
+  XGetWindowProperty (dpy, win, wm_state_atom, 0, 0, False, AnyPropertyType,
 		      &type, &format, &nitems, &after, &data);
   if (type)
-    return win;
+    {
+      XFree (data);
+      return win;
+    }
   
-  inf = getchildren (dpy, win, WM_STATE);
+  inf = getchildren (dpy, win, wm_state_atom);
   
   if (inf == 0)
     return win;
@@ -4265,46 +3785,6 @@ gdk_get_client_window (Display	*dpy,
     return inf;
 }
 
-#ifdef WE_HAVE_MOTIF_DROPS_DONE
-static GdkWindow *
-gdk_drop_get_real_window (GdkWindow   *w, 
-			  guint16     *x, 
-			  guint16     *y)
-{
-  GdkWindow *retval = w;
-  GdkWindowPrivate *awin;
-  GList *children;
-  gint16 myx = *x, myy = *y;
-  
-  g_return_val_if_fail (w != NULL && x != NULL && y != NULL, NULL);
-  
-  myx = *x; 
-  myy = *y;
-  
- descend:
-  for (children = gdk_window_get_children(retval); 
-       children && children->next;
-       children = children->next)
-    {
-      awin = (GdkWindowPrivate *) children->data;
-      if ((myx >= awin->x) && (myy >= awin->y)
-	  && (myx < (awin->x + awin->width))
-	  && (myy < (awin->y + awin->height)))
-	{
-	  retval = (GdkWindow *) awin;
-	  myx -= awin->x;
-	  myy -= awin->y;
-	  goto descend;
-	}
-    }
-  
-  *x = myx; 
-  *y = myy;
-  
-  return retval;
-}
-#endif
-
 /* Sends a ClientMessage to all toplevel client windows */
 void
 gdk_event_send_clientmessage_toall (GdkEvent *event)
@@ -4320,7 +3800,6 @@ gdk_event_send_clientmessage_toall (GdkEvent *event)
   sev.xclient.type = ClientMessage;
   sev.xclient.display = gdk_display;
   sev.xclient.format = event->client.data_format;
-  sev.xclient.serial = CurrentTime;
   memcpy(&sev.xclient.data, &event->client.data, sizeof(sev.xclient.data));
   sev.xclient.message_type = event->client.message_type;
   
@@ -4352,13 +3831,14 @@ gdk_send_xevent (Window window, gboolean propagate, glong event_mask,
 		 XEvent *event_send)
 {
   Status result;
+  gint old_warnings = gdk_error_warnings;
   
   gdk_error_code = 0;
   
   gdk_error_warnings = 0;
   result = XSendEvent (gdk_display, window, propagate, event_mask, event_send);
   XSync (gdk_display, False);
-  gdk_error_warnings = 1;
+  gdk_error_warnings = old_warnings;
   
   return result && (gdk_error_code != -1);
 }
diff --git a/gdk/x11/gdkproperty-x11.c b/gdk/x11/gdkproperty-x11.c
index 38665ca0c..5b18ba71e 100644
--- a/gdk/x11/gdkproperty-x11.c
+++ b/gdk/x11/gdkproperty-x11.c
@@ -22,12 +22,21 @@
 #include "gdk.h"
 #include "gdkprivate.h"
 
-
 GdkAtom
 gdk_atom_intern (const gchar *atom_name,
 		 gint         only_if_exists)
 {
-  return XInternAtom (gdk_display, atom_name, only_if_exists);
+  GdkAtom retval;
+  static GHashTable *atom_hash = NULL;
+  
+  if (!atom_hash)
+    atom_hash = g_hash_table_new (g_str_hash, g_str_equal);
+
+  retval = GPOINTER_TO_UINT (g_hash_table_lookup (atom_hash, atom_name));
+  if (!retval)
+    retval = XInternAtom (gdk_display, atom_name, only_if_exists);
+
+  return retval;
 }
 
 gchar *
@@ -35,14 +44,16 @@ gdk_atom_name (GdkAtom atom)
 {
   gchar *t;
   gchar *name;
+  gint old_error_warnings;
 
   /* If this atom doesn't exist, we'll die with an X error unless
      we take precautions */
 
+  old_error_warnings = gdk_error_warnings;
   gdk_error_warnings = 0;
   gdk_error_code = 0;
   t = XGetAtomName (gdk_display, atom);
-  gdk_error_warnings = 1;
+  gdk_error_warnings = old_error_warnings;
 
   if (gdk_error_code == -1)
     {
@@ -115,7 +126,7 @@ gdk_property_get (GdkWindow   *window,
   if (actual_format_type)
     *actual_format_type = ret_format;
 
-  if (ret_prop_type != type)
+  if ((type != AnyPropertyType) && (ret_prop_type != type))
     {
       gchar *rn, *pn;
 
diff --git a/gdk/x11/gdkwindow-x11.c b/gdk/x11/gdkwindow-x11.c
index 7c2d9b099..3df6ac8ac 100644
--- a/gdk/x11/gdkwindow-x11.c
+++ b/gdk/x11/gdkwindow-x11.c
@@ -216,6 +216,9 @@ gdk_window_init (void)
   gdk_root_parent.height = height;
   gdk_root_parent.children = NULL;
   gdk_root_parent.colormap = NULL;
+  gdk_root_parent.ref_count = 1;
+
+  gdk_xid_table_insert (&gdk_root_window, &gdk_root_parent);
 }
 
 GdkWindow*
@@ -703,11 +706,15 @@ gdk_window_unref (GdkWindow *window)
   if (private->ref_count == 0)
     {
       if (!private->destroyed)
-	g_warning ("losing last reference to undestroyed window\n");
+	{
+	  if (private->window_type == GDK_WINDOW_FOREIGN)
+	    gdk_xid_table_remove (private->xwindow);
+	  else
+	    g_warning ("losing last reference to undestroyed window\n");
+	}
       g_dataset_destroy (window);
       g_free (window);
     }
-
 }
 
 void
@@ -1681,188 +1688,6 @@ gdk_window_shape_combine_mask (GdkWindow *window,
 #endif /* HAVE_SHAPE_EXT */
 }
 
-void
-gdk_dnd_drag_addwindow (GdkWindow *window)
-{
-  GdkWindowPrivate *window_private;
-  
-  g_return_if_fail (window != NULL);
-  
-  window_private = (GdkWindowPrivate *) window;
-  if (window_private->destroyed)
-    return;
-  
-  if (window_private->dnd_drag_enabled == 1 && gdk_dnd.drag_really == 0)
-    {
-      gdk_dnd.drag_numwindows++;
-      gdk_dnd.drag_startwindows = g_realloc (gdk_dnd.drag_startwindows,
-					     gdk_dnd.drag_numwindows
-					     * sizeof(GdkWindow *));
-      gdk_dnd.drag_startwindows[gdk_dnd.drag_numwindows - 1] = window;
-      window_private->dnd_drag_accepted = 0;
-    } 
-  else
-    g_warning ("dnd_really is 1 or drag is not enabled! can't addwindow\n");
-}
-
-void
-gdk_window_dnd_drag_set (GdkWindow   *window,
-			 guint8       drag_enable,
-			 gchar      **typelist,
-			 guint        numtypes)
-{
-  GdkWindowPrivate *window_private;
-  int i, wasset = 0;
-  
-  g_return_if_fail (window != NULL);
-  window_private = (GdkWindowPrivate *) window;
-  if (window_private->destroyed)
-    return;
-  
-  window_private->dnd_drag_enabled = drag_enable ? 1 : 0;
-  
-  if (drag_enable)
-    {
-      g_return_if_fail(typelist != NULL);
-      
-      if (window_private->dnd_drag_data_numtypesavail > 3)
-	wasset = 1;
-      window_private->dnd_drag_data_numtypesavail = numtypes;
-      
-      window_private->dnd_drag_data_typesavail =
-	g_realloc (window_private->dnd_drag_data_typesavail,
-		   (numtypes + 1) * sizeof (GdkAtom));
-      
-      for (i = 0; i < numtypes; i++)
-	{
-	  /* Allow blanket use of ALL to get anything... */
-	  if (strcmp (typelist[i], "ALL"))
-	    window_private->dnd_drag_data_typesavail[i] =
-	      gdk_atom_intern (typelist[i], FALSE);
-	  else
-	    window_private->dnd_drag_data_typesavail[i] = None;
-	}
-      
-      /* 
-       * set our extended type list if we need to 
-       */
-      if (numtypes > 3)
-	gdk_property_change(window, gdk_dnd.gdk_XdeTypelist,
-			    XA_PRIMARY, 32, GDK_PROP_MODE_REPLACE,
-			    (guchar *)(window_private->dnd_drag_data_typesavail
-			     + (sizeof(GdkAtom) * 3)),
-			    (numtypes - 3) * sizeof(GdkAtom));
-      else if (wasset)
-	gdk_property_delete (window, gdk_dnd.gdk_XdeTypelist);
-    }
-  else
-    {
-      g_free (window_private->dnd_drag_data_typesavail);
-      window_private->dnd_drag_data_typesavail = NULL;
-      window_private->dnd_drag_data_numtypesavail = 0;
-    }
-}
-
-void
-gdk_window_dnd_drop_set (GdkWindow   *window,
-			 guint8       drop_enable,
-			 gchar      **typelist,
-			 guint        numtypes,
-			 guint8       destructive_op)
-{
-  GdkWindowPrivate *window_private;
-  int i;
-  
-  g_return_if_fail (window != NULL);
-  window_private = (GdkWindowPrivate *) window;
-  if (window_private->destroyed)
-    return;
-  
-  window_private->dnd_drop_enabled = drop_enable ? 1 : 0;
-  if (drop_enable)
-    {
-      g_return_if_fail(typelist != NULL);
-      
-      window_private->dnd_drop_data_numtypesavail = numtypes;
-      
-      window_private->dnd_drop_data_typesavail =
-	g_realloc (window_private->dnd_drop_data_typesavail,
-		   (numtypes + 1) * sizeof (GdkAtom));
-      
-      for (i = 0; i < numtypes; i++)
-	window_private->dnd_drop_data_typesavail[i] =
-	  gdk_atom_intern (typelist[i], FALSE);
-      
-      window_private->dnd_drop_destructive_op = destructive_op;
-    }
-}
-
-/* 
- * This is used to reply to a GDK_DRAG_REQUEST event
- * (which may be generated by XdeRequest or a confirmed drop... 
- */
-void
-gdk_window_dnd_data_set (GdkWindow       *window,
-			 GdkEvent        *event,
-			 gpointer         data,
-			 gulong           data_numbytes)
-{
-  GdkWindowPrivate *window_private;
-  XEvent sev;
-  GdkEventDropDataAvailable tmp_ev;
-  gchar *tmp;
-  
-  g_return_if_fail (window != NULL);
-  g_return_if_fail (event != NULL);
-  g_return_if_fail (data != NULL);
-  g_return_if_fail (data_numbytes > 0);
-  g_return_if_fail (event->type == GDK_DRAG_REQUEST);
-
-  window_private = (GdkWindowPrivate *) window;
-  g_return_if_fail (window_private->dnd_drag_accepted != 0);    
-  if (window_private->destroyed)
-    return;
-  
-  /* We set the property on our window... */
-  gdk_property_change (window, window_private->dnd_drag_data_type,
-		       XA_PRIMARY, 8, GDK_PROP_MODE_REPLACE, data,
-		       data_numbytes);
-  tmp = gdk_atom_name(window_private->dnd_drag_data_type);
-#ifdef DEBUG_DND
-  g_message("DnD type %s on window %ld\n", tmp, window_private->xwindow);
-#endif
-  g_free(tmp);
-  
-  /* 
-   * Then we send the event to tell the receiving window that the
-   * drop has happened 
-   */
-  tmp_ev.u.allflags = 0;
-  tmp_ev.u.flags.protocol_version = DND_PROTOCOL_VERSION;
-  tmp_ev.u.flags.isdrop = event->dragrequest.isdrop;
-  
-  sev.xclient.type = ClientMessage;
-  sev.xclient.format = 32;
-  sev.xclient.window = event->dragrequest.requestor;
-  sev.xclient.message_type = gdk_dnd.gdk_XdeDataAvailable;
-  sev.xclient.data.l[0] = window_private->xwindow;
-  sev.xclient.data.l[1] = tmp_ev.u.allflags;
-  sev.xclient.data.l[2] = window_private->dnd_drag_data_type;
-
-  if (event->dragrequest.isdrop)
-    sev.xclient.data.l[3] = event->dragrequest.drop_coords.x +
-      (event->dragrequest.drop_coords.y << 16);
-  else
-    sev.xclient.data.l[3] = 0;
-
-  sev.xclient.data.l[4] = event->dragrequest.timestamp;
-
-  if (!gdk_send_xevent (event->dragrequest.requestor, False,
-		       StructureNotifyMask, &sev))
-    GDK_NOTE (DND, g_message("Sending XdeDataAvailable to %#x failed\n",
-			     event->dragrequest.requestor));
-}
-
 void          
 gdk_window_add_filter     (GdkWindow     *window,
 			   GdkFilterFunc  function,
@@ -1905,7 +1730,7 @@ gdk_window_remove_filter  (GdkWindow     *window,
 			   gpointer       data)
 {
   GdkWindowPrivate *private;
-  GList *tmp_list;
+  GList *tmp_list, *node;
   GdkEventFilter *filter;
 
   private = (GdkWindowPrivate*) window;
@@ -1918,15 +1743,16 @@ gdk_window_remove_filter  (GdkWindow     *window,
   while (tmp_list)
     {
       filter = (GdkEventFilter *)tmp_list->data;
+      node = tmp_list;
       tmp_list = tmp_list->next;
 
       if ((filter->function == function) && (filter->data == data))
 	{
 	  if(private)
-	    private->filters = g_list_remove_link (private->filters, tmp_list);
+	    private->filters = g_list_remove_link (private->filters, node);
 	  else
 	    gdk_default_filters = g_list_remove_link (gdk_default_filters, tmp_list);
-	  g_list_free_1 (tmp_list);
+	  g_list_free_1 (node);
 	  g_free (filter);
 	  
 	  return;