general: Rework DnD handling

One recent development in GTK+ 4 is the split of GdkDragContext into
GdkDrag and GdkDrop classes, along with tons of semantic changes, such
as GtkWidget::drag-data-received no longer accepting coordinate
parameters, which requires stashing the ones received from
GtkWidget::drag-drop. Another thing is removal of GDK properties, which
breaks the current implementation of XDS. XDS and support for dropping
on the root window is thus removed. Integer DnD type info is no longer
supported, and one must use GdkContentFormats now, which works with
GTypes and mime type strings, so the code was changed to work with
strings.

26 files changed, 765 insertions, 1816 deletions

diff --git a/src/nautilus-canvas-container.c b/src/nautilus-canvas-container.c
index 8db2aeb93..58656be40 100644
--- a/src/nautilus-canvas-container.c
+++ b/src/nautilus-canvas-container.c
@@ -203,10 +203,8 @@ enum
     ICON_STRETCH_STARTED,
     ICON_STRETCH_ENDED,
     MOVE_COPY_ITEMS,
-    HANDLE_NETSCAPE_URL,
     HANDLE_URI_LIST,
     HANDLE_TEXT,
-    HANDLE_RAW,
     HANDLE_HOVER,
     SELECTION_CHANGED,
     ICON_ADDED,
@@ -3443,7 +3441,6 @@ static void
 clear_drag_state (NautilusCanvasContainer *container)
 {
     container->details->drag_icon = NULL;
-    container->details->drag_state = DRAG_STATE_INITIAL;
 }
 
 static void
@@ -3479,17 +3476,14 @@ on_multi_press_gesture_released (GtkGestureMultiPress *gesture,
     {
         details->drag_button = 0;
 
-        if (details->drag_state == DRAG_STATE_MOVE_OR_COPY)
+        if (!details->drag_started)
         {
-            if (!details->drag_started)
-            {
-                nautilus_canvas_container_did_not_drag (container, event);
-            }
-            else
-            {
-                nautilus_canvas_dnd_end_drag (container);
-                DEBUG ("Ending drag from canvas container");
-            }
+            nautilus_canvas_container_did_not_drag (container, event);
+        }
+        else
+        {
+            nautilus_canvas_dnd_end_drag (container);
+            DEBUG ("Ending drag from canvas container");
         }
 
         clear_drag_state (container);
@@ -3507,7 +3501,6 @@ on_event_controller_motion_motion (GtkEventControllerMotion *controller,
     GtkWidget *widget;
     NautilusCanvasContainer *container;
     NautilusCanvasContainerDetails *details;
-    GdkDragAction actions;
 
     widget = gtk_event_controller_get_widget (GTK_EVENT_CONTROLLER (controller));
     container = NAUTILUS_CANVAS_CONTAINER (widget);
@@ -3518,11 +3511,6 @@ on_event_controller_motion_motion (GtkEventControllerMotion *controller,
         return;
     }
 
-    if (details->drag_state != DRAG_STATE_MOVE_OR_COPY)
-    {
-        return;
-    }
-
     if (details->drag_started)
     {
         return;
@@ -3536,11 +3524,9 @@ on_event_controller_motion_motion (GtkEventControllerMotion *controller,
     }
 
     details->drag_started = TRUE;
-    details->drag_state = DRAG_STATE_MOVE_OR_COPY;
 
-    actions = GDK_ACTION_COPY | GDK_ACTION_MOVE | GDK_ACTION_LINK | GDK_ACTION_ASK;
-
-    nautilus_canvas_dnd_begin_drag (container, actions, details->drag_x, details->drag_y);
+    nautilus_canvas_dnd_begin_drag (container, GDK_ACTION_ALL | GDK_ACTION_ASK,
+                                    details->drag_x, details->drag_y);
 
     DEBUG ("Beginning drag from canvas container");
 }
@@ -3870,18 +3856,6 @@ nautilus_canvas_container_class_init (NautilusCanvasContainerClass *class)
                         G_TYPE_POINTER,
                         G_TYPE_POINTER,
                         GDK_TYPE_DRAG_ACTION);
-    signals[HANDLE_NETSCAPE_URL]
-        = g_signal_new ("handle-netscape-url",
-                        G_TYPE_FROM_CLASS (class),
-                        G_SIGNAL_RUN_LAST,
-                        G_STRUCT_OFFSET (NautilusCanvasContainerClass,
-                                         handle_netscape_url),
-                        NULL, NULL,
-                        g_cclosure_marshal_generic,
-                        G_TYPE_NONE, 3,
-                        G_TYPE_STRING,
-                        G_TYPE_STRING,
-                        GDK_TYPE_DRAG_ACTION);
     signals[HANDLE_URI_LIST]
         = g_signal_new ("handle-uri-list",
                         G_TYPE_FROM_CLASS (class),
@@ -3906,20 +3880,6 @@ nautilus_canvas_container_class_init (NautilusCanvasContainerClass *class)
                         G_TYPE_STRING,
                         G_TYPE_STRING,
                         GDK_TYPE_DRAG_ACTION);
-    signals[HANDLE_RAW]
-        = g_signal_new ("handle-raw",
-                        G_TYPE_FROM_CLASS (class),
-                        G_SIGNAL_RUN_LAST,
-                        G_STRUCT_OFFSET (NautilusCanvasContainerClass,
-                                         handle_raw),
-                        NULL, NULL,
-                        g_cclosure_marshal_generic,
-                        G_TYPE_NONE, 5,
-                        G_TYPE_POINTER,
-                        G_TYPE_INT,
-                        G_TYPE_STRING,
-                        G_TYPE_STRING,
-                        GDK_TYPE_DRAG_ACTION);
     signals[HANDLE_HOVER] =
         g_signal_new ("handle-hover",
                       G_TYPE_FROM_CLASS (class),
@@ -4274,7 +4234,6 @@ handle_canvas_button_press (NautilusCanvasContainer *container,
 
         eel_event_get_coords (event, &details->drag_x, &details->drag_y);
 
-        details->drag_state = DRAG_STATE_MOVE_OR_COPY;
         details->drag_started = FALSE;
     }
 
diff --git a/src/nautilus-canvas-container.h b/src/nautilus-canvas-container.h
index bd8de5caf..6393c59e4 100644
--- a/src/nautilus-canvas-container.h
+++ b/src/nautilus-canvas-container.h
@@ -93,12 +93,6 @@ typedef struct {
 						   GdkDragAction action,
 						   int x,
 						   int y);
-	void	     (* handle_netscape_url)	  (NautilusCanvasContainer *container,
-						   const char *url,
-						   const char *target_uri,
-						   GdkDragAction action,
-						   int x,
-						   int y);
 	void	     (* handle_uri_list)    	  (NautilusCanvasContainer *container,
 						   const char *uri_list,
 						   const char *target_uri,
diff --git a/src/nautilus-canvas-dnd.c b/src/nautilus-canvas-dnd.c
index ef83c443f..456e949ff 100644
--- a/src/nautilus-canvas-dnd.c
+++ b/src/nautilus-canvas-dnd.c
@@ -57,32 +57,21 @@
 #define DEBUG_FLAG NAUTILUS_DEBUG_CANVAS_CONTAINER
 #include "nautilus-debug.h"
 
-static const GtkTargetEntry drag_types [] =
+static const char *drag_types[] =
 {
-    { NAUTILUS_ICON_DND_GNOME_ICON_LIST_TYPE, 0, NAUTILUS_ICON_DND_GNOME_ICON_LIST },
-    { NAUTILUS_ICON_DND_URI_LIST_TYPE, 0, NAUTILUS_ICON_DND_URI_LIST },
+    NAUTILUS_ICON_DND_GNOME_ICON_LIST_TYPE,
 };
 
-static const GtkTargetEntry drop_types [] =
+static const char *drop_types[] =
 {
-    { NAUTILUS_ICON_DND_GNOME_ICON_LIST_TYPE, 0, NAUTILUS_ICON_DND_GNOME_ICON_LIST },
-    /* prefer "_NETSCAPE_URL" over "text/uri-list" to satisfy web browsers. */
-    { NAUTILUS_ICON_DND_NETSCAPE_URL_TYPE, 0, NAUTILUS_ICON_DND_NETSCAPE_URL },
-    /* prefer XDS over "text/uri-list" */
-    { NAUTILUS_ICON_DND_XDNDDIRECTSAVE_TYPE, 0, NAUTILUS_ICON_DND_XDNDDIRECTSAVE },     /* XDS Protocol Type */
-    { NAUTILUS_ICON_DND_URI_LIST_TYPE, 0, NAUTILUS_ICON_DND_URI_LIST },
-    { NAUTILUS_ICON_DND_RAW_TYPE, 0, NAUTILUS_ICON_DND_RAW },
-    /* Must be last: */
-    { NAUTILUS_ICON_DND_ROOTWINDOW_DROP_TYPE, 0, NAUTILUS_ICON_DND_ROOTWINDOW_DROP }
+    NAUTILUS_ICON_DND_GNOME_ICON_LIST_TYPE,
 };
-static void     stop_dnd_highlight (GtkWidget *widget);
-static void     dnd_highlight_queue_redraw (GtkWidget *widget);
+static void stop_dnd_highlight (GtkWidget *widget);
 
-static GtkTargetList *drop_types_list = NULL;
-static GtkTargetList *drop_types_list_root = NULL;
+static GdkContentFormats *drop_types_list;
 
 static char *nautilus_canvas_container_find_drop_target (NautilusCanvasContainer *container,
-                                                         GdkDragContext          *context,
+                                                         GdkDrop                 *drop,
                                                          int                      x,
                                                          int                      y,
                                                          gboolean                *icon_hit);
@@ -325,10 +314,8 @@ each_icon_get_data_binder (NautilusDragEachSelectedItemDataGet iteratee,
 /* Called when the data for drag&drop is needed */
 static void
 drag_data_get_callback (GtkWidget        *widget,
-                        GdkDragContext   *context,
+                        GdkDrag          *context,
                         GtkSelectionData *selection_data,
-                        guint             info,
-                        guint32           time,
                         gpointer          data)
 {
     NautilusDragInfo *drag_info;
@@ -342,7 +329,7 @@ drag_data_get_callback (GtkWidget        *widget,
      * iterate all the selected icons.
      */
     drag_info = &(NAUTILUS_CANVAS_CONTAINER (widget)->details->dnd_info->drag_info);
-    nautilus_drag_drag_data_get_from_cache (drag_info->selection_cache, context, selection_data, info, time);
+    nautilus_drag_drag_data_get_from_cache (drag_info->selection_cache, selection_data);
 }
 
 
@@ -425,163 +412,50 @@ nautilus_canvas_container_dropped_canvas_feedback (GtkWidget        *widget,
     nautilus_canvas_container_position_shadow (container, x, y);
 }
 
-static char *
-get_direct_save_filename (GdkDragContext *context)
-{
-    guchar *prop_text;
-    gint prop_len;
-
-    if (!gdk_property_get (gdk_drag_context_get_source_window (context), gdk_atom_intern (NAUTILUS_ICON_DND_XDNDDIRECTSAVE_TYPE, FALSE),
-                           gdk_atom_intern ("text/plain", FALSE), 0, 1024, FALSE, NULL, NULL,
-                           &prop_len, &prop_text))
-    {
-        return NULL;
-    }
-
-    /* Zero-terminate the string */
-    prop_text = g_realloc (prop_text, prop_len + 1);
-    prop_text[prop_len] = '\0';
-
-    /* Verify that the file name provided by the source is valid */
-    if (*prop_text == '\0' ||
-        strchr ((const gchar *) prop_text, G_DIR_SEPARATOR) != NULL)
-    {
-        DEBUG ("Invalid filename provided by XDS drag site");
-        g_free (prop_text);
-        return NULL;
-    }
-
-    return (gchar *) prop_text;
-}
-
-static void
-set_direct_save_uri (GtkWidget        *widget,
-                     GdkDragContext   *context,
-                     NautilusDragInfo *drag_info,
-                     int               x,
-                     int               y)
-{
-    GFile *base, *child;
-    char *filename, *drop_target;
-    gchar *uri;
-
-    drag_info->got_drop_data_type = TRUE;
-    drag_info->data_type = NAUTILUS_ICON_DND_XDNDDIRECTSAVE;
-
-    uri = NULL;
-
-    filename = get_direct_save_filename (context);
-    drop_target = nautilus_canvas_container_find_drop_target (NAUTILUS_CANVAS_CONTAINER (widget),
-                                                              context, x, y, NULL);
-
-    if (drop_target && eel_uri_is_trash (drop_target))
-    {
-        g_free (drop_target);
-        drop_target = NULL;         /* Cannot save to trash ...*/
-    }
-
-    if (filename != NULL && drop_target != NULL)
-    {
-        /* Resolve relative path */
-        base = g_file_new_for_uri (drop_target);
-        child = g_file_get_child (base, filename);
-        uri = g_file_get_uri (child);
-        g_object_unref (base);
-        g_object_unref (child);
-
-        /* Change the uri property */
-        gdk_property_change (gdk_drag_context_get_source_window (context),
-                             gdk_atom_intern (NAUTILUS_ICON_DND_XDNDDIRECTSAVE_TYPE, FALSE),
-                             gdk_atom_intern ("text/plain", FALSE), 8,
-                             GDK_PROP_MODE_REPLACE, (const guchar *) uri,
-                             strlen (uri));
-
-        drag_info->direct_save_uri = uri;
-    }
-
-    g_free (filename);
-    g_free (drop_target);
-}
-
 /* FIXME bugzilla.gnome.org 47445: Needs to become a shared function */
 static void
-get_data_on_first_target_we_support (GtkWidget      *widget,
-                                     GdkDragContext *context,
-                                     guint32         time,
-                                     int             x,
-                                     int             y)
+get_data_on_first_target_we_support (GtkWidget *widget,
+                                     GdkDrop   *drop,
+                                     int        x,
+                                     int        y)
 {
-    GtkTargetList *list;
+    GdkContentFormats *list;
     GdkAtom target;
 
     if (drop_types_list == NULL)
     {
-        drop_types_list = gtk_target_list_new (drop_types,
-                                               G_N_ELEMENTS (drop_types) - 1);
-        gtk_target_list_add_text_targets (drop_types_list, NAUTILUS_ICON_DND_TEXT);
-    }
-    if (drop_types_list_root == NULL)
-    {
-        drop_types_list_root = gtk_target_list_new (drop_types,
-                                                    G_N_ELEMENTS (drop_types));
-        gtk_target_list_add_text_targets (drop_types_list_root, NAUTILUS_ICON_DND_TEXT);
+        drop_types_list = gdk_content_formats_new (drop_types, G_N_ELEMENTS (drop_types));
+        drop_types_list = gtk_content_formats_add_text_targets (drop_types_list);
+        drop_types_list = gtk_content_formats_add_uri_targets (drop_types_list);
     }
 
     list = drop_types_list;
-
-    target = gtk_drag_dest_find_target (widget, context, list);
-    if (target != GDK_NONE)
+    target = gtk_drag_dest_find_target (widget, drop, list);
+    if (target != NULL)
     {
-        guint info;
-        NautilusDragInfo *drag_info;
         gboolean found;
 
-        drag_info = &(NAUTILUS_CANVAS_CONTAINER (widget)->details->dnd_info->drag_info);
-
-        found = gtk_target_list_find (list, target, &info);
+        found = gdk_content_formats_contain_mime_type (list, target);
         g_assert (found);
 
-        /* Don't get_data for destructive ops */
-        if ((info == NAUTILUS_ICON_DND_ROOTWINDOW_DROP ||
-             info == NAUTILUS_ICON_DND_XDNDDIRECTSAVE) &&
-            !drag_info->drop_occurred)
-        {
-            /* We can't call get_data here, because that would
-             *  make the source execute the rootwin action or the direct save */
-            drag_info->got_drop_data_type = TRUE;
-            drag_info->data_type = info;
-        }
-        else
-        {
-            if (info == NAUTILUS_ICON_DND_XDNDDIRECTSAVE)
-            {
-                set_direct_save_uri (widget, context, drag_info, x, y);
-            }
-            gtk_drag_get_data (GTK_WIDGET (widget), context,
-                               target, time);
-        }
+        gtk_drag_get_data (GTK_WIDGET (widget), drop, target);
     }
 }
 
 static void
 nautilus_canvas_container_ensure_drag_data (NautilusCanvasContainer *container,
-                                            GdkDragContext          *context,
-                                            guint32                  time)
+                                            GdkDrop                 *drop)
 {
-    NautilusCanvasDndInfo *dnd_info;
-
-    dnd_info = container->details->dnd_info;
-
-    if (!dnd_info->drag_info.got_drop_data_type)
+    if (container->details->dnd_info->drag_info.selection_data == NULL)
     {
-        get_data_on_first_target_we_support (GTK_WIDGET (container), context, time, 0, 0);
+        get_data_on_first_target_we_support (GTK_WIDGET (container), drop, 0, 0);
     }
 }
 
 static void
-drag_end_callback (GtkWidget      *widget,
-                   GdkDragContext *context,
-                   gpointer        data)
+drag_end_callback (GtkWidget *widget,
+                   GdkDrag   *context,
+                   gpointer   data)
 {
     NautilusCanvasContainer *container;
     NautilusCanvasDndInfo *dnd_info;
@@ -609,8 +483,7 @@ nautilus_canvas_container_item_at (NautilusCanvasContainer *container,
 {
     GList *p;
     int size;
-    EelDRect point;
-    EelIRect canvas_point;
+    EelIRect point;
 
     /* build the hit-test rectangle. Base the size on the scale factor to ensure that it is
      * non-empty even at the smallest scale factor
@@ -627,17 +500,7 @@ nautilus_canvas_container_item_at (NautilusCanvasContainer *container,
         NautilusCanvasIcon *icon;
         icon = p->data;
 
-        eel_canvas_w2c (EEL_CANVAS (container),
-                        point.x0,
-                        point.y0,
-                        &canvas_point.x0,
-                        &canvas_point.y0);
-        eel_canvas_w2c (EEL_CANVAS (container),
-                        point.x1,
-                        point.y1,
-                        &canvas_point.x1,
-                        &canvas_point.y1);
-        if (nautilus_canvas_item_hit_test_rectangle (icon->item, canvas_point))
+        if (nautilus_canvas_item_hit_test_rectangle (icon->item, point))
         {
             return icon;
         }
@@ -677,36 +540,11 @@ nautilus_canvas_container_selection_items_local (NautilusCanvasContainer *contai
     return result;
 }
 
-/* handle dropped url */
-static void
-receive_dropped_netscape_url (NautilusCanvasContainer *container,
-                              const char              *encoded_url,
-                              GdkDragContext          *context,
-                              int                      x,
-                              int                      y)
-{
-    char *drop_target;
-
-    if (encoded_url == NULL)
-    {
-        return;
-    }
-
-    drop_target = nautilus_canvas_container_find_drop_target (container, context, x, y, NULL);
-
-    g_signal_emit_by_name (container, "handle-netscape-url",
-                           encoded_url,
-                           drop_target,
-                           gdk_drag_context_get_selected_action (context));
-
-    g_free (drop_target);
-}
-
 /* handle dropped uri list */
 static void
 receive_dropped_uri_list (NautilusCanvasContainer *container,
                           const char              *uri_list,
-                          GdkDragContext          *context,
+                          GdkDrop                 *drop,
                           int                      x,
                           int                      y)
 {
@@ -717,12 +555,12 @@ receive_dropped_uri_list (NautilusCanvasContainer *container,
         return;
     }
 
-    drop_target = nautilus_canvas_container_find_drop_target (container, context, x, y, NULL);
+    drop_target = nautilus_canvas_container_find_drop_target (container, drop, x, y, NULL);
 
     g_signal_emit_by_name (container, "handle-uri-list",
                            uri_list,
                            drop_target,
-                           gdk_drag_context_get_selected_action (context));
+                           gdk_drop_get_actions (drop));
 
     g_free (drop_target);
 }
@@ -731,7 +569,7 @@ receive_dropped_uri_list (NautilusCanvasContainer *container,
 static void
 receive_dropped_text (NautilusCanvasContainer *container,
                       const char              *text,
-                      GdkDragContext          *context,
+                      GdkDrop                 *drop,
                       int                      x,
                       int                      y)
 {
@@ -742,41 +580,12 @@ receive_dropped_text (NautilusCanvasContainer *container,
         return;
     }
 
-    drop_target = nautilus_canvas_container_find_drop_target (container, context, x, y, NULL);
+    drop_target = nautilus_canvas_container_find_drop_target (container, drop, x, y, NULL);
 
     g_signal_emit_by_name (container, "handle-text",
                            text,
                            drop_target,
-                           gdk_drag_context_get_selected_action (context));
-
-    g_free (drop_target);
-}
-
-/* handle dropped raw data */
-static void
-receive_dropped_raw (NautilusCanvasContainer *container,
-                     const char              *raw_data,
-                     int                      length,
-                     const char              *direct_save_uri,
-                     GdkDragContext          *context,
-                     int                      x,
-                     int                      y)
-{
-    char *drop_target;
-
-    if (raw_data == NULL)
-    {
-        return;
-    }
-
-    drop_target = nautilus_canvas_container_find_drop_target (container, context, x, y, NULL);
-
-    g_signal_emit_by_name (container, "handle-raw",
-                           raw_data,
-                           length,
-                           drop_target,
-                           direct_save_uri,
-                           gdk_drag_context_get_selected_action (context));
+                           gdk_drop_get_actions (drop));
 
     g_free (drop_target);
 }
@@ -787,8 +596,6 @@ auto_scroll_timeout_callback (gpointer data)
     NautilusCanvasContainer *container;
     GtkWidget *widget;
     float x_scroll_delta, y_scroll_delta;
-    GdkRectangle exposed_area;
-    GtkAllocation allocation;
 
     g_assert (NAUTILUS_IS_CANVAS_CONTAINER (data));
     widget = GTK_WIDGET (data);
@@ -811,7 +618,7 @@ auto_scroll_timeout_callback (gpointer data)
     }
 
     /* Clear the old dnd highlight frame */
-    dnd_highlight_queue_redraw (widget);
+    gtk_widget_queue_draw (widget);
 
     if (!nautilus_canvas_container_scroll (container, (int) x_scroll_delta, (int) y_scroll_delta))
     {
@@ -821,50 +628,11 @@ auto_scroll_timeout_callback (gpointer data)
         return TRUE;
     }
 
-    /* Make sure the dnd highlight frame is redrawn */
-    dnd_highlight_queue_redraw (widget);
-
     /* update cached drag start offsets */
     container->details->dnd_info->drag_info.start_x -= x_scroll_delta;
     container->details->dnd_info->drag_info.start_y -= y_scroll_delta;
 
-    /* Due to a glitch in GtkLayout, whe need to do an explicit draw of the exposed
-     * area.
-     * Calculate the size of the area we need to draw
-     */
-    gtk_widget_get_allocation (widget, &allocation);
-    exposed_area.x = allocation.x;
-    exposed_area.y = allocation.y;
-    exposed_area.width = allocation.width;
-    exposed_area.height = allocation.height;
-
-    if (x_scroll_delta > 0)
-    {
-        exposed_area.x = exposed_area.width - x_scroll_delta;
-    }
-    else if (x_scroll_delta < 0)
-    {
-        exposed_area.width = -x_scroll_delta;
-    }
-
-    if (y_scroll_delta > 0)
-    {
-        exposed_area.y = exposed_area.height - y_scroll_delta;
-    }
-    else if (y_scroll_delta < 0)
-    {
-        exposed_area.height = -y_scroll_delta;
-    }
-
-    /* offset it to 0, 0 */
-    exposed_area.x -= allocation.x;
-    exposed_area.y -= allocation.y;
-
-    gtk_widget_queue_draw_area (widget,
-                                exposed_area.x,
-                                exposed_area.y,
-                                exposed_area.width,
-                                exposed_area.height);
+    gtk_widget_queue_draw (widget);
 
     return TRUE;
 }
@@ -924,15 +692,12 @@ handle_nonlocal_move (NautilusCanvasContainer *container,
 
 static char *
 nautilus_canvas_container_find_drop_target (NautilusCanvasContainer *container,
-                                            GdkDragContext          *context,
+                                            GdkDrop                 *drop,
                                             int                      x,
                                             int                      y,
                                             gboolean                *icon_hit)
 {
     NautilusCanvasIcon *drop_target_icon;
-    double world_x, world_y;
-    NautilusFile *file;
-    char *icon_uri;
     char *container_uri;
 
     if (icon_hit)
@@ -940,13 +705,11 @@ nautilus_canvas_container_find_drop_target (NautilusCanvasContainer *container,
         *icon_hit = FALSE;
     }
 
-    if (!container->details->dnd_info->drag_info.got_drop_data_type)
+    if (container->details->dnd_info->drag_info.selection_data == NULL)
     {
         return NULL;
     }
 
-    canvas_widget_to_world (EEL_CANVAS (container), x, y, &world_x, &world_y);
-
     /* FIXME bugzilla.gnome.org 42485:
      * These "can_accept_items" tests need to be done by
      * the canvas view, not here. This file is not supposed to know
@@ -954,16 +717,20 @@ nautilus_canvas_container_find_drop_target (NautilusCanvasContainer *container,
      */
 
     /* Find the item we hit with our drop, if any */
-    drop_target_icon = nautilus_canvas_container_item_at (container, world_x, world_y);
+    drop_target_icon = nautilus_canvas_container_item_at (container, x, y);
     if (drop_target_icon != NULL)
     {
+        g_autofree char *icon_uri = NULL;
+
         icon_uri = nautilus_canvas_container_get_icon_uri (container, drop_target_icon);
         if (icon_uri != NULL)
         {
+            g_autoptr (NautilusFile) file = NULL;
+
             file = nautilus_file_get_by_uri (icon_uri);
 
-            if (!nautilus_drag_can_accept_info (file,
-                                                container->details->dnd_info->drag_info.data_type,
+            if (!nautilus_drag_can_accept_data (file,
+                                                drop,
                                                 container->details->dnd_info->drag_info.selection_list))
             {
                 /* the item we dropped our selection on cannot accept the items,
@@ -971,9 +738,6 @@ nautilus_canvas_container_find_drop_target (NautilusCanvasContainer *container,
                  */
                 drop_target_icon = NULL;
             }
-
-            g_free (icon_uri);
-            nautilus_file_unref (file);
         }
     }
 
@@ -988,16 +752,16 @@ nautilus_canvas_container_find_drop_target (NautilusCanvasContainer *container,
 
         if (container_uri != NULL)
         {
+            g_autoptr (NautilusFile) file = NULL;
             gboolean can;
+
             file = nautilus_file_get_by_uri (container_uri);
-            can = nautilus_drag_can_accept_info (file,
-                                                 container->details->dnd_info->drag_info.data_type,
+            can = nautilus_drag_can_accept_data (file,
+                                                 drop,
                                                  container->details->dnd_info->drag_info.selection_list);
-            g_object_unref (file);
             if (!can)
             {
-                g_free (container_uri);
-                container_uri = NULL;
+                g_clear_pointer (&container_uri, g_free);
             }
         }
 
@@ -1013,7 +777,7 @@ nautilus_canvas_container_find_drop_target (NautilusCanvasContainer *container,
 
 static void
 nautilus_canvas_container_receive_dropped_icons (NautilusCanvasContainer *container,
-                                                 GdkDragContext          *context,
+                                                 GdkDrop                 *drop,
                                                  int                      x,
                                                  int                      y)
 {
@@ -1030,11 +794,11 @@ nautilus_canvas_container_receive_dropped_icons (NautilusCanvasContainer *contai
         return;
     }
 
-    real_action = gdk_drag_context_get_selected_action (context);
+    real_action = gdk_drop_get_actions (drop);
 
-    if (real_action == GDK_ACTION_ASK)
+    if (!gdk_drag_action_is_unique (real_action))
     {
-        action = GDK_ACTION_MOVE | GDK_ACTION_COPY | GDK_ACTION_LINK;
+        action = GDK_ACTION_ALL;
         real_action = nautilus_drag_drop_action_ask (GTK_WIDGET (container), action);
     }
 
@@ -1046,7 +810,7 @@ nautilus_canvas_container_receive_dropped_icons (NautilusCanvasContainer *contai
                                     &world_x, &world_y);
 
         drop_target = nautilus_canvas_container_find_drop_target (container,
-                                                                  context, x, y, &icon_hit);
+                                                                  drop, x, y, &icon_hit);
 
         local_move_only = FALSE;
         if (!icon_hit && real_action == GDK_ACTION_MOVE)
@@ -1069,84 +833,62 @@ nautilus_canvas_container_receive_dropped_icons (NautilusCanvasContainer *contai
 }
 
 NautilusDragInfo *
-nautilus_canvas_dnd_get_drag_source_data (NautilusCanvasContainer *container,
-                                          GdkDragContext          *context)
+nautilus_canvas_dnd_get_drag_source_data (NautilusCanvasContainer *container)
 {
     return container->details->dnd_source_info;
 }
 
-static void
-nautilus_canvas_container_get_drop_action (NautilusCanvasContainer *container,
-                                           GdkDragContext          *context,
-                                           int                      x,
-                                           int                      y,
-                                           int                     *action)
+static GdkDragAction
+nautilus_canvas_container_get_drop_actions (NautilusCanvasContainer *container,
+                                            GdkDrop                 *drop,
+                                            int                      x,
+                                            int                      y)
 {
-    char *drop_target;
+    GtkSelectionData *data;
+    g_autofree char *drop_target = NULL;
     gboolean icon_hit;
     double world_x, world_y;
+    GdkAtom target;
 
-    icon_hit = FALSE;
-    if (!container->details->dnd_info->drag_info.got_drop_data_type)
+    if (container->details->dnd_info->drag_info.selection_data == NULL)
     {
         /* drag_data_received_callback didn't get called yet */
-        return;
+        return 0;
     }
 
+    data = container->details->dnd_info->drag_info.selection_data;
+    icon_hit = FALSE;
+
     /* find out if we're over an canvas */
     canvas_widget_to_world (EEL_CANVAS (container), x, y, &world_x, &world_y);
-    *action = 0;
 
     drop_target = nautilus_canvas_container_find_drop_target (container,
-                                                              context, x, y, &icon_hit);
+                                                              drop, x, y, &icon_hit);
     if (drop_target == NULL)
     {
-        return;
+        return 0;
     }
 
-    /* case out on the type of object being dragged */
-    switch (container->details->dnd_info->drag_info.data_type)
-    {
-        case NAUTILUS_ICON_DND_GNOME_ICON_LIST:
-        {
-            if (container->details->dnd_info->drag_info.selection_list != NULL)
-            {
-                nautilus_drag_default_drop_action_for_icons (context, drop_target,
-                                                             container->details->dnd_info->drag_info.selection_list,
-                                                             0,
-                                                             action);
-            }
-        }
-        break;
-
-        case NAUTILUS_ICON_DND_URI_LIST:
-        {
-            *action = nautilus_drag_default_drop_action_for_uri_list (context, drop_target);
-        }
-        break;
-
-        case NAUTILUS_ICON_DND_NETSCAPE_URL:
-        {
-            *action = nautilus_drag_default_drop_action_for_netscape_url (context);
-        }
-        break;
-
-        case NAUTILUS_ICON_DND_ROOTWINDOW_DROP:
-        {
-            *action = gdk_drag_context_get_suggested_action (context);
-        }
-        break;
+    target = gtk_selection_data_get_target (data);
 
-        case NAUTILUS_ICON_DND_TEXT:
-        case NAUTILUS_ICON_DND_XDNDDIRECTSAVE:
-        case NAUTILUS_ICON_DND_RAW:
+    if (target == g_intern_static_string (NAUTILUS_ICON_DND_GNOME_ICON_LIST_TYPE))
+    {
+        if (container->details->dnd_info->drag_info.selection_list != NULL)
         {
-            *action = GDK_ACTION_COPY;
+            return nautilus_get_drop_actions_for_icons (drop_target,
+                                                        container->details->dnd_info->drag_info.selection_list);
         }
-        break;
+    }
+    else if (gtk_selection_data_targets_include_uri (data))
+    {
+        return nautilus_get_drop_actions_for_uri (drop_target);
+    }
+    else if (gtk_selection_data_targets_include_text (data))
+    {
+        return GDK_ACTION_COPY;
     }
 
-    g_free (drop_target);
+    return 0;
 }
 
 static void
@@ -1172,21 +914,16 @@ set_drop_target (NautilusCanvasContainer *container,
 
 static void
 nautilus_canvas_dnd_update_drop_target (NautilusCanvasContainer *container,
-                                        GdkDragContext          *context,
+                                        GdkDrop                 *drop,
                                         int                      x,
                                         int                      y)
 {
     NautilusCanvasIcon *icon;
-    NautilusFile *file;
-    double world_x, world_y;
-    char *uri;
 
     g_assert (NAUTILUS_IS_CANVAS_CONTAINER (container));
 
-    canvas_widget_to_world (EEL_CANVAS (container), x, y, &world_x, &world_y);
-
     /* Find the item we hit with our drop, if any. */
-    icon = nautilus_canvas_container_item_at (container, world_x, world_y);
+    icon = nautilus_canvas_container_item_at (container, x, y);
 
     /* FIXME bugzilla.gnome.org 42485:
      * These "can_accept_items" tests need to be done by
@@ -1197,18 +934,18 @@ nautilus_canvas_dnd_update_drop_target (NautilusCanvasContainer *container,
     /* Find if target canvas accepts our drop. */
     if (icon != NULL)
     {
+        g_autofree char *uri = NULL;
+        g_autoptr (NautilusFile) file = NULL;
+
         uri = nautilus_canvas_container_get_icon_uri (container, icon);
         file = nautilus_file_get_by_uri (uri);
-        g_free (uri);
 
-        if (!nautilus_drag_can_accept_info (file,
-                                            container->details->dnd_info->drag_info.data_type,
+        if (!nautilus_drag_can_accept_data (file,
+                                            drop,
                                             container->details->dnd_info->drag_info.selection_list))
         {
             icon = NULL;
         }
-
-        nautilus_file_unref (file);
     }
 
     set_drop_target (container, icon);
@@ -1231,37 +968,17 @@ nautilus_canvas_container_free_drag_data (NautilusCanvasContainer *container)
 
     dnd_info = container->details->dnd_info;
 
-    dnd_info->drag_info.got_drop_data_type = FALSE;
-
-    if (dnd_info->shadow != NULL)
-    {
-        eel_canvas_item_destroy (dnd_info->shadow);
-        dnd_info->shadow = NULL;
-    }
-
-    if (dnd_info->drag_info.selection_data != NULL)
-    {
-        gtk_selection_data_free (dnd_info->drag_info.selection_data);
-        dnd_info->drag_info.selection_data = NULL;
-    }
-
-    if (dnd_info->drag_info.direct_save_uri != NULL)
-    {
-        g_free (dnd_info->drag_info.direct_save_uri);
-        dnd_info->drag_info.direct_save_uri = NULL;
-    }
-
-    g_free (dnd_info->target_uri);
-    dnd_info->target_uri = NULL;
+    g_clear_pointer (&dnd_info->shadow, eel_canvas_item_destroy);
+    g_clear_pointer (&dnd_info->drag_info.selection_data, gtk_selection_data_free);
+    g_clear_pointer (&dnd_info->target_uri, g_free);
 
     remove_hover_timer (dnd_info);
 }
 
 static void
-drag_leave_callback (GtkWidget      *widget,
-                     GdkDragContext *context,
-                     guint32         time,
-                     gpointer        data)
+drag_leave_callback (GtkWidget *widget,
+                     GdkDrop   *drop,
+                     gpointer   data)
 {
     NautilusCanvasDndInfo *dnd_info;
 
@@ -1280,29 +997,26 @@ drag_leave_callback (GtkWidget      *widget,
 }
 
 static void
-drag_begin_callback (GtkWidget      *widget,
-                     GdkDragContext *context,
-                     gpointer        data)
+drag_begin_callback (GtkWidget *widget,
+                     GdkDrag   *context,
+                     gpointer   data)
 {
     NautilusCanvasContainer *container;
     NautilusDragInfo *drag_info;
-    NautilusWindow *window;
-    cairo_surface_t *surface;
+    g_autoptr (GdkPaintable) paintable = NULL;
     double x1, y1, x2, y2, winx, winy;
     int x_offset, y_offset;
     int start_x, start_y;
     GList *dragged_files;
 
     container = NAUTILUS_CANVAS_CONTAINER (widget);
-    window = NAUTILUS_WINDOW (gtk_widget_get_toplevel (GTK_WIDGET (container)));
 
     start_x = container->details->dnd_info->drag_info.start_x +
               gtk_adjustment_get_value (gtk_scrollable_get_hadjustment (GTK_SCROLLABLE (container)));
     start_y = container->details->dnd_info->drag_info.start_y +
               gtk_adjustment_get_value (gtk_scrollable_get_vadjustment (GTK_SCROLLABLE (container)));
 
-    /* create a pixmap and mask to drag with */
-    surface = nautilus_canvas_item_get_drag_surface (container->details->drag_icon->item);
+    paintable = nautilus_canvas_item_get_drag_paintable (container->details->drag_icon->item);
 
     /* compute the image's offset */
     eel_canvas_item_get_bounds (EEL_CANVAS_ITEM (container->details->drag_icon->item),
@@ -1312,9 +1026,7 @@ drag_begin_callback (GtkWidget      *widget,
     x_offset = start_x - winx;
     y_offset = start_y - winy;
 
-    cairo_surface_set_device_offset (surface, -x_offset, -y_offset);
-    gtk_drag_set_icon_surface (context, surface);
-    cairo_surface_destroy (surface);
+    gtk_drag_set_icon_paintable (context, paintable, x_offset, y_offset);
 
     /* cache the data at the beginning since the view may change */
     drag_info = &(container->details->dnd_info->drag_info);
@@ -1327,6 +1039,12 @@ drag_begin_callback (GtkWidget      *widget,
     dragged_files = nautilus_drag_file_list_from_selection_list (drag_info->selection_cache);
     if (nautilus_file_list_are_all_folders (dragged_files))
     {
+        GtkWidget *toplevel;
+        NautilusWindow *window;
+
+        toplevel = gtk_widget_get_toplevel (widget);
+        window = NAUTILUS_WINDOW (toplevel);
+
         nautilus_window_start_dnd (window, context);
     }
     g_list_free_full (dragged_files, g_object_unref);
@@ -1335,8 +1053,6 @@ drag_begin_callback (GtkWidget      *widget,
 void
 nautilus_canvas_dnd_begin_drag (NautilusCanvasContainer *container,
                                 GdkDragAction            actions,
-                                int                      button,
-                                GdkEventMotion          *event,
                                 int                      start_x,
                                 int                      start_y)
 {
@@ -1344,7 +1060,6 @@ nautilus_canvas_dnd_begin_drag (NautilusCanvasContainer *container,
     NautilusDragInfo *dnd_source_info;
 
     g_return_if_fail (NAUTILUS_IS_CANVAS_CONTAINER (container));
-    g_return_if_fail (event != NULL);
 
     dnd_info = container->details->dnd_info;
     container->details->dnd_source_info = g_new0 (NautilusDragInfo, 1);
@@ -1361,13 +1076,12 @@ nautilus_canvas_dnd_begin_drag (NautilusCanvasContainer *container,
 
     dnd_source_info->source_actions = actions;
     /* start the drag */
-    gtk_drag_begin_with_coordinates (GTK_WIDGET (container),
-                                     dnd_info->drag_info.target_list,
-                                     actions,
-                                     button,
-                                     (GdkEvent *) event,
-                                     dnd_info->drag_info.start_x,
-                                     dnd_info->drag_info.start_y);
+    gtk_drag_begin (GTK_WIDGET (container),
+                    NULL,
+                    dnd_info->drag_info.formats,
+                    actions,
+                    dnd_info->drag_info.start_x,
+                    dnd_info->drag_info.start_y);
 }
 
 static gboolean
@@ -1376,12 +1090,12 @@ drag_highlight_draw (GtkWidget *widget,
                      gpointer   user_data)
 {
     gint width, height;
-    GdkWindow *window;
+    GdkSurface *surface;
     GtkStyleContext *style;
 
-    window = gtk_widget_get_window (widget);
-    width = gdk_window_get_width (window);
-    height = gdk_window_get_height (window);
+    surface = gtk_widget_get_surface (widget);
+    width = gdk_surface_get_width (surface);
+    height = gdk_surface_get_height (surface);
 
     style = gtk_widget_get_style_context (widget);
 
@@ -1389,51 +1103,13 @@ drag_highlight_draw (GtkWidget *widget,
     gtk_style_context_add_class (style, GTK_STYLE_CLASS_DND);
     gtk_style_context_set_state (style, GTK_STATE_FLAG_FOCUSED);
 
-    gtk_render_frame (style,
-                      cr,
-                      0, 0, width, height);
+    gtk_render_frame (style, cr, 0, 0, width, height);
 
     gtk_style_context_restore (style);
 
     return FALSE;
 }
 
-/* Queue a redraw of the dnd highlight rect */
-static void
-dnd_highlight_queue_redraw (GtkWidget *widget)
-{
-    NautilusCanvasDndInfo *dnd_info;
-    int width, height;
-    GtkAllocation allocation;
-
-    dnd_info = NAUTILUS_CANVAS_CONTAINER (widget)->details->dnd_info;
-
-    if (!dnd_info->highlighted)
-    {
-        return;
-    }
-
-    gtk_widget_get_allocation (widget, &allocation);
-    width = allocation.width;
-    height = allocation.height;
-
-    /* we don't know how wide the shadow is exactly,
-     * so we expose a 10-pixel wide border
-     */
-    gtk_widget_queue_draw_area (widget,
-                                0, 0,
-                                width, 10);
-    gtk_widget_queue_draw_area (widget,
-                                0, 0,
-                                10, height);
-    gtk_widget_queue_draw_area (widget,
-                                0, height - 10,
-                                width, 10);
-    gtk_widget_queue_draw_area (widget,
-                                width - 10, 0,
-                                10, height);
-}
-
 static void
 start_dnd_highlight (GtkWidget *widget)
 {
@@ -1447,7 +1123,7 @@ start_dnd_highlight (GtkWidget *widget)
         g_signal_connect_after (widget, "draw",
                                 G_CALLBACK (drag_highlight_draw),
                                 NULL);
-        dnd_highlight_queue_redraw (widget);
+        gtk_widget_queue_draw (widget);
     }
 }
 
@@ -1463,7 +1139,7 @@ stop_dnd_highlight (GtkWidget *widget)
         g_signal_handlers_disconnect_by_func (widget,
                                               drag_highlight_draw,
                                               NULL);
-        dnd_highlight_queue_redraw (widget);
+        gtk_widget_queue_draw (widget);
         dnd_info->highlighted = FALSE;
     }
 }
@@ -1480,7 +1156,7 @@ hover_timer (gpointer user_data)
 
     g_signal_emit_by_name (container, "handle-hover", dnd_info->target_uri);
 
-    return FALSE;
+    return G_SOURCE_REMOVE;
 }
 
 static void
@@ -1509,58 +1185,54 @@ check_hover_timer (NautilusCanvasContainer *container,
     if (uri != NULL)
     {
         dnd_info->target_uri = g_strdup (uri);
-        dnd_info->hover_id =
-            gdk_threads_add_timeout (timeout,
-                                     hover_timer,
-                                     container);
+        dnd_info->hover_id = g_timeout_add (timeout, hover_timer, container);
     }
 }
 
 static gboolean
-drag_motion_callback (GtkWidget      *widget,
-                      GdkDragContext *context,
-                      int             x,
-                      int             y,
-                      guint32         time)
+drag_motion_callback (GtkWidget *widget,
+                      GdkDrop   *drop,
+                      int        x,
+                      int        y)
 {
-    int action;
+    NautilusCanvasContainer *container;
+    GdkDragAction action;
 
-    nautilus_canvas_container_ensure_drag_data (NAUTILUS_CANVAS_CONTAINER (widget), context, time);
-    nautilus_canvas_container_position_shadow (NAUTILUS_CANVAS_CONTAINER (widget), x, y);
-    nautilus_canvas_dnd_update_drop_target (NAUTILUS_CANVAS_CONTAINER (widget), context, x, y);
-    set_up_auto_scroll_if_needed (NAUTILUS_CANVAS_CONTAINER (widget));
+    container = NAUTILUS_CANVAS_CONTAINER (widget);
+
+    nautilus_canvas_container_ensure_drag_data (container, drop);
+    nautilus_canvas_container_position_shadow (container, x, y);
+    nautilus_canvas_dnd_update_drop_target (container, drop, x, y);
+    set_up_auto_scroll_if_needed (container);
     /* Find out what the drop actions are based on our drag selection and
      * the drop target.
      */
-    action = 0;
-    nautilus_canvas_container_get_drop_action (NAUTILUS_CANVAS_CONTAINER (widget), context, x, y,
-                                               &action);
+    action = nautilus_canvas_container_get_drop_actions (container, drop, x, y);
     if (action != 0)
     {
-        char *uri;
-        uri = nautilus_canvas_container_find_drop_target (NAUTILUS_CANVAS_CONTAINER (widget),
-                                                          context, x, y, NULL);
-        check_hover_timer (NAUTILUS_CANVAS_CONTAINER (widget), uri);
-        g_free (uri);
+        g_autofree char *uri = NULL;
+
+        uri = nautilus_canvas_container_find_drop_target (container, drop, x, y, NULL);
+
+        check_hover_timer (container, uri);
         start_dnd_highlight (widget);
     }
     else
     {
-        remove_hover_timer (NAUTILUS_CANVAS_CONTAINER (widget)->details->dnd_info);
+        remove_hover_timer (container->details->dnd_info);
     }
 
-    gdk_drag_status (context, action, time);
+    gdk_drop_status (drop, action);
 
     return TRUE;
 }
 
 static gboolean
-drag_drop_callback (GtkWidget      *widget,
-                    GdkDragContext *context,
-                    int             x,
-                    int             y,
-                    guint32         time,
-                    gpointer        data)
+drag_drop_callback (GtkWidget *widget,
+                    GdkDrop   *drop,
+                    int        x,
+                    int        y,
+                    gpointer   data)
 {
     NautilusCanvasDndInfo *dnd_info;
 
@@ -1572,8 +1244,10 @@ drag_drop_callback (GtkWidget      *widget,
      *  make sure it is going to be called at least once.
      */
     dnd_info->drag_info.drop_occurred = TRUE;
+    dnd_info->drop_x = x;
+    dnd_info->drop_y = y;
 
-    get_data_on_first_target_we_support (widget, context, time, x, y);
+    get_data_on_first_target_we_support (widget, drop, x, y);
 
     return TRUE;
 }
@@ -1603,63 +1277,30 @@ nautilus_canvas_dnd_end_drag (NautilusCanvasContainer *container)
 
 static void
 drag_data_received_callback (GtkWidget        *widget,
-                             GdkDragContext   *context,
-                             int               x,
-                             int               y,
+                             GdkDrop          *drop,
                              GtkSelectionData *data,
-                             guint             info,
-                             guint32           time,
                              gpointer          user_data)
 {
+    NautilusCanvasContainer *container;
+    NautilusCanvasDndInfo *dnd_info;
     NautilusDragInfo *drag_info;
-    guchar *tmp;
-    const guchar *tmp_raw;
-    int length;
-    gboolean success;
+    GdkContentFormats *formats;
 
-    drag_info = &(NAUTILUS_CANVAS_CONTAINER (widget)->details->dnd_info->drag_info);
+    container = NAUTILUS_CANVAS_CONTAINER (widget);
+    dnd_info = container->details->dnd_info;
+    drag_info = &dnd_info->drag_info;
+    formats = gdk_drop_get_formats (drop);
 
-    drag_info->got_drop_data_type = TRUE;
-    drag_info->data_type = info;
+    g_clear_pointer (&drag_info->selection_data, gtk_selection_data_free);
+    drag_info->selection_data = gtk_selection_data_copy (data);
 
-    switch (info)
+    if (gdk_content_formats_contain_mime_type (formats,
+                                               NAUTILUS_ICON_DND_GNOME_ICON_LIST_TYPE))
     {
-        case NAUTILUS_ICON_DND_GNOME_ICON_LIST:
-        {
-            nautilus_canvas_container_dropped_canvas_feedback (widget, data, x, y);
-        }
-        break;
-
-        case NAUTILUS_ICON_DND_URI_LIST:
-        case NAUTILUS_ICON_DND_TEXT:
-        case NAUTILUS_ICON_DND_XDNDDIRECTSAVE:
-        case NAUTILUS_ICON_DND_RAW:
-        {
-            /* Save the data so we can do the actual work on drop. */
-            if (drag_info->selection_data != NULL)
-            {
-                gtk_selection_data_free (drag_info->selection_data);
-            }
-            drag_info->selection_data = gtk_selection_data_copy (data);
-        }
-        break;
-
-        /* Netscape keeps sending us the data, even though we accept the first drag */
-        case NAUTILUS_ICON_DND_NETSCAPE_URL:
-        {
-            if (drag_info->selection_data != NULL)
-            {
-                gtk_selection_data_free (drag_info->selection_data);
-                drag_info->selection_data = gtk_selection_data_copy (data);
-            }
-        }
-        break;
-
-        case NAUTILUS_ICON_DND_ROOTWINDOW_DROP:
-        {
-            /* Do nothing, this won't even happen, since we don't want to call get_data twice */
-        }
-        break;
+        nautilus_canvas_container_dropped_canvas_feedback (widget,
+                                                           data,
+                                                           dnd_info->drop_x,
+                                                           dnd_info->drop_y);
     }
 
     /* this is the second use case of this callback.
@@ -1667,106 +1308,53 @@ drag_data_received_callback (GtkWidget        *widget,
      */
     if (drag_info->drop_occurred)
     {
-        success = FALSE;
-        switch (info)
-        {
-            case NAUTILUS_ICON_DND_GNOME_ICON_LIST:
-            {
-                nautilus_canvas_container_receive_dropped_icons
-                    (NAUTILUS_CANVAS_CONTAINER (widget),
-                    context, x, y);
-            }
-            break;
+        gboolean success;
+        GdkDragAction action;
 
-            case NAUTILUS_ICON_DND_NETSCAPE_URL:
-            {
-                receive_dropped_netscape_url
-                    (NAUTILUS_CANVAS_CONTAINER (widget),
-                    (char *) gtk_selection_data_get_data (data), context, x, y);
-                success = TRUE;
-            }
-            break;
-
-            case NAUTILUS_ICON_DND_URI_LIST:
-            {
-                receive_dropped_uri_list
-                    (NAUTILUS_CANVAS_CONTAINER (widget),
-                    (char *) gtk_selection_data_get_data (data), context, x, y);
-                success = TRUE;
-            }
-            break;
+        success = FALSE;
+        action = 0;
 
-            case NAUTILUS_ICON_DND_TEXT:
-            {
-                tmp = gtk_selection_data_get_text (data);
-                receive_dropped_text
-                    (NAUTILUS_CANVAS_CONTAINER (widget),
-                    (char *) tmp, context, x, y);
-                success = TRUE;
-                g_free (tmp);
-            }
-            break;
+        if (gtk_selection_data_targets_include_text (data))
+        {
+            g_autofree unsigned char *text = NULL;
 
-            case NAUTILUS_ICON_DND_RAW:
-            {
-                length = gtk_selection_data_get_length (data);
-                tmp_raw = gtk_selection_data_get_data (data);
-                receive_dropped_raw
-                    (NAUTILUS_CANVAS_CONTAINER (widget),
-                    (const gchar *) tmp_raw, length, drag_info->direct_save_uri,
-                    context, x, y);
-                success = TRUE;
-            }
-            break;
+            text = gtk_selection_data_get_text (data);
 
-            case NAUTILUS_ICON_DND_ROOTWINDOW_DROP:
-            {
-                /* Do nothing, everything is done by the sender */
-            }
-            break;
+            receive_dropped_text (container,
+                                  (char *) text,
+                                  drop,
+                                  dnd_info->drop_x,
+                                  dnd_info->drop_y);
+            success = TRUE;
+        }
+        else if (gtk_selection_data_targets_include_uri (data))
+        {
+            receive_dropped_uri_list (container,
+                                      (char *) gtk_selection_data_get_data (data),
+                                      drop,
+                                      dnd_info->drop_x,
+                                      dnd_info->drop_y);
+            success = TRUE;
+        }
+        else if (gdk_content_formats_contain_mime_type (formats,
+                                                        NAUTILUS_ICON_DND_GNOME_ICON_LIST_TYPE))
+        {
+            nautilus_canvas_container_receive_dropped_icons (container,
+                                                             drop,
+                                                             dnd_info->drop_x,
+                                                             dnd_info->drop_y);
+        }
 
-            case NAUTILUS_ICON_DND_XDNDDIRECTSAVE:
-            {
-                const guchar *selection_data;
-                gint selection_length;
-                gint selection_format;
-
-                selection_data = gtk_selection_data_get_data (drag_info->selection_data);
-                selection_length = gtk_selection_data_get_length (drag_info->selection_data);
-                selection_format = gtk_selection_data_get_format (drag_info->selection_data);
-
-                if (selection_format == 8 &&
-                    selection_length == 1 &&
-                    selection_data[0] == 'F')
-                {
-                    gtk_drag_get_data (widget, context,
-                                       gdk_atom_intern (NAUTILUS_ICON_DND_RAW_TYPE,
-                                                        FALSE),
-                                       time);
-                    return;
-                }
-                else if (selection_format == 8 &&
-                         selection_length == 1 &&
-                         selection_data[0] == 'F' &&
-                         drag_info->direct_save_uri != NULL)
-                {
-                    GFile *location;
-
-                    location = g_file_new_for_uri (drag_info->direct_save_uri);
-
-                    nautilus_file_changes_queue_file_added (location);
-                    g_object_unref (location);
-                    nautilus_file_changes_consume_changes (TRUE);
-                    success = TRUE;
-                }
-            }     /* NAUTILUS_ICON_DND_XDNDDIRECTSAVE */
-            break;
+        if (success)
+        {
+            action = gdk_drop_get_actions (drop);
         }
-        gtk_drag_finish (context, success, FALSE, time);
 
-        nautilus_canvas_container_free_drag_data (NAUTILUS_CANVAS_CONTAINER (widget));
+        gdk_drop_finish (drop, action);
+
+        nautilus_canvas_container_free_drag_data (container);
 
-        set_drop_target (NAUTILUS_CANVAS_CONTAINER (widget), NULL);
+        set_drop_target (container, NULL);
 
         /* reinitialise it for the next dnd */
         drag_info->drop_occurred = FALSE;
@@ -1776,29 +1364,30 @@ drag_data_received_callback (GtkWidget        *widget,
 void
 nautilus_canvas_dnd_init (NautilusCanvasContainer *container)
 {
-    GtkTargetList *targets;
-    int n_elements;
+    NautilusCanvasDndInfo *dnd_info;
+    g_autoptr (GdkContentFormats) targets = NULL;
 
     g_return_if_fail (container != NULL);
     g_return_if_fail (NAUTILUS_IS_CANVAS_CONTAINER (container));
 
-
     container->details->dnd_info = g_new0 (NautilusCanvasDndInfo, 1);
-    nautilus_drag_init (&container->details->dnd_info->drag_info,
-                        drag_types, G_N_ELEMENTS (drag_types), TRUE);
+
+    dnd_info = container->details->dnd_info;
+
+    dnd_info->drag_info.formats = gdk_content_formats_new (drag_types, G_N_ELEMENTS (drag_types));
+    dnd_info->drag_info.formats = gtk_content_formats_add_uri_targets (dnd_info->drag_info.formats);
 
     /* Set up the widget as a drag destination.
      * (But not a source, as drags starting from this widget will be
      * implemented by dealing with events manually.)
      */
-    n_elements = G_N_ELEMENTS (drop_types) - 1;
+    targets = gdk_content_formats_new (drop_types, G_N_ELEMENTS (drop_types));
+    targets = gtk_content_formats_add_uri_targets (targets);
+
     gtk_drag_dest_set (GTK_WIDGET (container),
                        0,
-                       drop_types, n_elements,
-                       GDK_ACTION_COPY | GDK_ACTION_MOVE | GDK_ACTION_LINK | GDK_ACTION_ASK);
-
-    targets = gtk_drag_dest_get_target_list (GTK_WIDGET (container));
-    gtk_target_list_add_text_targets (targets, NAUTILUS_ICON_DND_TEXT);
+                       targets,
+                       GDK_ACTION_ALL);
 
 
     /* Messages for outgoing drag. */
diff --git a/src/nautilus-canvas-dnd.h b/src/nautilus-canvas-dnd.h
index 0e8b980e3..b200ba26a 100644
--- a/src/nautilus-canvas-dnd.h
+++ b/src/nautilus-canvas-dnd.h
@@ -39,6 +39,9 @@ typedef struct {
 	/* Shadow for the icons being dragged.  */
 	EelCanvasItem *shadow;
 	guint hover_id;
+
+        int drop_x;
+        int drop_y;
 } NautilusCanvasDndInfo;
 
 
@@ -46,11 +49,8 @@ void   nautilus_canvas_dnd_init                  (NautilusCanvasContainer *conta
 void   nautilus_canvas_dnd_fini                  (NautilusCanvasContainer *container);
 void   nautilus_canvas_dnd_begin_drag            (NautilusCanvasContainer *container,
 						  GdkDragAction          actions,
-						  gint                   button,
-						  GdkEventMotion        *event,
 						  int                    start_x,
 						  int                    start_y);
 void   nautilus_canvas_dnd_end_drag              (NautilusCanvasContainer *container);
 
-NautilusDragInfo* nautilus_canvas_dnd_get_drag_source_data (NautilusCanvasContainer *container,
-                                                            GdkDragContext          *context);
+NautilusDragInfo* nautilus_canvas_dnd_get_drag_source_data (NautilusCanvasContainer *container);
diff --git a/src/nautilus-canvas-private.h b/src/nautilus-canvas-private.h
index 009aefc41..57624e1bc 100644
--- a/src/nautilus-canvas-private.h
+++ b/src/nautilus-canvas-private.h
@@ -152,7 +152,6 @@ struct NautilusCanvasContainerDetails {
 	NautilusCanvasIcon *drag_icon;
 	gdouble drag_x;
     gdouble drag_y;
-	DragState drag_state;
 	gboolean drag_started;
 
 	gboolean icon_selected_on_button_down;
diff --git a/src/nautilus-canvas-view.c b/src/nautilus-canvas-view.c
index 86e153637..a0e076c64 100644
--- a/src/nautilus-canvas-view.c
+++ b/src/nautilus-canvas-view.c
@@ -1370,11 +1370,11 @@ static void
 canvas_view_handle_uri_list (NautilusCanvasContainer *container,
                              const char              *item_uris,
                              const char              *target_uri,
-                             GdkDragAction            action,
+                             GdkDragAction            actions,
                              NautilusCanvasView      *view)
 {
     nautilus_files_view_handle_uri_list_drop (NAUTILUS_FILES_VIEW (view),
-                                              item_uris, target_uri, action);
+                                              item_uris, target_uri, actions);
 }
 
 /* Handles an URL received from Mozilla */
@@ -1401,19 +1401,6 @@ canvas_view_handle_text (NautilusCanvasContainer *container,
 }
 
 static void
-canvas_view_handle_raw (NautilusCanvasContainer *container,
-                        const char              *raw_data,
-                        int                      length,
-                        const char              *target_uri,
-                        const char              *direct_save_uri,
-                        GdkDragAction            action,
-                        NautilusCanvasView      *view)
-{
-    nautilus_files_view_handle_raw_drop (NAUTILUS_FILES_VIEW (view),
-                                         raw_data, length, target_uri, direct_save_uri, action);
-}
-
-static void
 canvas_view_handle_hover (NautilusCanvasContainer *container,
                           const char              *target_uri,
                           NautilusCanvasView      *view)
@@ -1573,8 +1560,6 @@ nautilus_canvas_view_init (NautilusCanvasView *canvas_view)
                              G_CALLBACK (canvas_view_handle_netscape_url), canvas_view, 0);
     g_signal_connect_object (canvas_container, "handle-text",
                              G_CALLBACK (canvas_view_handle_text), canvas_view, 0);
-    g_signal_connect_object (canvas_container, "handle-raw",
-                             G_CALLBACK (canvas_view_handle_raw), canvas_view, 0);
     g_signal_connect_object (canvas_container, "handle-hover",
                              G_CALLBACK (canvas_view_handle_hover), canvas_view, 0);
 
diff --git a/src/nautilus-dnd.c b/src/nautilus-dnd.c
index c8607cc89..24f1ecacf 100644
--- a/src/nautilus-dnd.c
+++ b/src/nautilus-dnd.c
@@ -33,7 +33,7 @@
 #include <glib/gi18n.h>
 #include "nautilus-file-utilities.h"
 #include "nautilus-canvas-dnd.h"
-#include <src/nautilus-list-view-dnd.h>
+#include "nautilus-list-view-dnd.h"
 #include <stdio.h>
 #include <string.h>
 
@@ -57,28 +57,10 @@
 #define MAX_AUTOSCROLL_DELTA 50
 
 void
-nautilus_drag_init (NautilusDragInfo     *drag_info,
-                    const GtkTargetEntry *drag_types,
-                    int                   drag_type_count,
-                    gboolean              add_text_targets)
-{
-    drag_info->target_list = gtk_target_list_new (drag_types,
-                                                  drag_type_count);
-
-    if (add_text_targets)
-    {
-        gtk_target_list_add_text_targets (drag_info->target_list,
-                                          NAUTILUS_ICON_DND_TEXT);
-    }
-
-    drag_info->drop_occurred = FALSE;
-    drag_info->need_to_destroy = FALSE;
-}
-
-void
 nautilus_drag_finalize (NautilusDragInfo *drag_info)
 {
-    gtk_target_list_unref (drag_info->target_list);
+    g_clear_pointer (&drag_info->formats, gdk_content_formats_unref);
+
     nautilus_drag_destroy_selection_list (drag_info->selection_list);
     nautilus_drag_destroy_selection_list (drag_info->selection_cache);
 
@@ -163,8 +145,34 @@ nautilus_drag_file_list_from_selection_list (const GList *selection_list)
     return g_list_reverse (file_list);
 }
 
+gboolean
+nautilus_content_formats_include_text (GdkContentFormats *formats)
+{
+    g_autoptr (GdkContentFormats) text_formats = NULL;
+
+    g_return_val_if_fail (formats != NULL, FALSE);
+
+    text_formats = gdk_content_formats_new (NULL, 0);
+    text_formats = gtk_content_formats_add_text_targets (text_formats);
+
+    return gdk_content_formats_match (formats, text_formats);
+}
+
+gboolean
+nautilus_content_formats_include_uri (GdkContentFormats *formats)
+{
+    g_autoptr (GdkContentFormats) uri_formats = NULL;
+
+    g_return_val_if_fail (formats != NULL, FALSE);
+
+    uri_formats = gdk_content_formats_new (NULL, 0);
+    uri_formats = gtk_content_formats_add_uri_targets (uri_formats);
+
+    return gdk_content_formats_match (formats, uri_formats);
+}
+
 GList *
-nautilus_drag_uri_list_from_array (const char **uris)
+nautilus_drag_uri_list_from_array (GStrv uris)
 {
     GList *uri_list;
     int i;
@@ -331,25 +339,6 @@ nautilus_drag_items_local (const char  *target_uri_string,
                                               ((NautilusDragSelectionItem *) selection_list->data)->uri);
 }
 
-GdkDragAction
-nautilus_drag_default_drop_action_for_netscape_url (GdkDragContext *context)
-{
-    /* Mozilla defaults to copy, but unless thats the
-     *  only allowed thing (enforced by ctrl) we want to LINK */
-    if (gdk_drag_context_get_suggested_action (context) == GDK_ACTION_COPY &&
-        gdk_drag_context_get_actions (context) != GDK_ACTION_COPY)
-    {
-        return GDK_ACTION_LINK;
-    }
-    else if (gdk_drag_context_get_suggested_action (context) == GDK_ACTION_MOVE)
-    {
-        /* Don't support move */
-        return GDK_ACTION_COPY;
-    }
-
-    return gdk_drag_context_get_suggested_action (context);
-}
-
 static gboolean
 check_same_fs (NautilusFile *file1,
                NautilusFile *file2)
@@ -396,7 +385,7 @@ source_is_deletable (GFile *file)
 }
 
 NautilusDragInfo *
-nautilus_drag_get_source_data (GdkDragContext *context)
+nautilus_drag_get_source_data (GdkDrag *context)
 {
     GtkWidget *source_widget;
     NautilusDragInfo *source_data;
@@ -409,8 +398,7 @@ nautilus_drag_get_source_data (GdkDragContext *context)
 
     if (NAUTILUS_IS_CANVAS_CONTAINER (source_widget))
     {
-        source_data = nautilus_canvas_dnd_get_drag_source_data (NAUTILUS_CANVAS_CONTAINER (source_widget),
-                                                                context);
+        source_data = nautilus_canvas_dnd_get_drag_source_data (NAUTILUS_CANVAS_CONTAINER (source_widget));
     }
     else if (GTK_IS_TREE_VIEW (source_widget))
     {
@@ -423,8 +411,7 @@ nautilus_drag_get_source_data (GdkDragContext *context)
         view = nautilus_window_slot_get_current_view (active_slot);
         if (NAUTILUS_IS_LIST_VIEW (view))
         {
-            source_data = nautilus_list_view_dnd_get_drag_source_data (NAUTILUS_LIST_VIEW (view),
-                                                                       context);
+            source_data = nautilus_list_view_dnd_get_drag_source_data (NAUTILUS_LIST_VIEW (view));
         }
         else
         {
@@ -442,93 +429,49 @@ nautilus_drag_get_source_data (GdkDragContext *context)
     return source_data;
 }
 
-void
-nautilus_drag_default_drop_action_for_icons (GdkDragContext *context,
-                                             const char     *target_uri_string,
-                                             const GList    *items,
-                                             guint32         source_actions,
-                                             int            *action)
+GdkDragAction
+nautilus_get_drop_actions_for_icons (const char  *target_uri,
+                                     const GList *items)
 {
     gboolean same_fs;
     gboolean target_is_source_parent;
     gboolean source_deletable;
     const char *dropped_uri;
-    GFile *target, *dropped, *dropped_directory;
-    GdkDragAction actions;
-    NautilusFile *dropped_file, *target_file;
-
-    if (target_uri_string == NULL)
-    {
-        *action = 0;
-        return;
-    }
+    g_autoptr (GFile) target = NULL;
+    g_autoptr (GFile) dropped = NULL;
+    g_autoptr (GFile) dropped_directory = NULL;
+    NautilusFile *dropped_file;
+    g_autoptr (NautilusFile) target_file = NULL;
 
-    /* this is needed because of how dnd works. The actions at the time drag-begin
-     * is done are not set, because they are first set on drag-motion. However,
-     * for our use case, which is validation with the sidebar for dnd feedback
-     * when the dnd doesn't have as a destination the sidebar itself, we need
-     * a way to know the actions at drag-begin time. Either canvas view or
-     * list view know them when starting the drag, but asking for them here
-     * would be breaking the current model too much. So instead we rely on the
-     * caller, which will ask if appropiate to those objects about the actions
-     * available, instead of relying solely on the context here. */
-    if (source_actions)
+    if (items == NULL)
     {
-        actions = source_actions & (GDK_ACTION_MOVE | GDK_ACTION_COPY);
-    }
-    else
-    {
-        actions = gdk_drag_context_get_actions (context) & (GDK_ACTION_MOVE | GDK_ACTION_COPY);
-    }
-    if (actions == 0)
-    {
-        /* We can't use copy or move, just go with the suggested action. */
-        *action = gdk_drag_context_get_suggested_action (context);
-        return;
-    }
-
-    if (gdk_drag_context_get_suggested_action (context) == GDK_ACTION_ASK)
-    {
-        /* Don't override ask */
-        *action = gdk_drag_context_get_suggested_action (context);
-        return;
+        return 0;
     }
 
     dropped_uri = ((NautilusDragSelectionItem *) items->data)->uri;
     dropped_file = ((NautilusDragSelectionItem *) items->data)->file;
-    target_file = nautilus_file_get_by_uri (target_uri_string);
+    target_file = nautilus_file_get_by_uri (target_uri);
 
     /*
      * Check for trash URI.  We do a find_directory for any Trash directory.
      * Passing 0 permissions as gnome-vfs would override the permissions
      * passed with 700 while creating .Trash directory
      */
-    if (eel_uri_is_trash (target_uri_string))
+    if (eel_uri_is_trash (target_uri))
     {
-        /* Only move to Trash */
-        if (actions & GDK_ACTION_MOVE)
-        {
-            *action = GDK_ACTION_MOVE;
-        }
-        nautilus_file_unref (target_file);
-        return;
+        return GDK_ACTION_MOVE;
     }
     else if (target_file != NULL && nautilus_file_is_archive (target_file))
     {
-        *action = GDK_ACTION_COPY;
-
-        nautilus_file_unref (target_file);
-        return;
+        return GDK_ACTION_COPY;
     }
     else
     {
-        target = g_file_new_for_uri (target_uri_string);
+        target = g_file_new_for_uri (target_uri);
     }
 
     same_fs = check_same_fs (target_file, dropped_file);
 
-    nautilus_file_unref (target_file);
-
     /* Compare the first dropped uri with the target uri for same fs match. */
     dropped = g_file_new_for_uri (dropped_uri);
     dropped_directory = g_file_get_parent (dropped);
@@ -540,51 +483,33 @@ nautilus_drag_default_drop_action_for_icons (GdkDragContext *context,
          *  as this is then just a move of a mountpoint to another
          *  position in the dir */
         target_is_source_parent = g_file_equal (dropped_directory, target);
-        g_object_unref (dropped_directory);
     }
     source_deletable = source_is_deletable (dropped);
 
-    if ((same_fs && source_deletable) || target_is_source_parent ||
-        g_file_has_uri_scheme (dropped, "trash"))
+    if ((same_fs && source_deletable) || target_is_source_parent || eel_uri_is_trash (dropped_uri))
     {
-        if (actions & GDK_ACTION_MOVE)
-        {
-            *action = GDK_ACTION_MOVE;
-        }
-        else
-        {
-            *action = gdk_drag_context_get_suggested_action (context);
-        }
+        return GDK_ACTION_ALL | GDK_ACTION_ASK;
     }
     else
     {
-        if (actions & GDK_ACTION_COPY)
-        {
-            *action = GDK_ACTION_COPY;
-        }
-        else
-        {
-            *action = gdk_drag_context_get_suggested_action (context);
-        }
+        return GDK_ACTION_COPY | GDK_ACTION_LINK | GDK_ACTION_ASK;
     }
-
-    g_object_unref (target);
-    g_object_unref (dropped);
 }
 
 GdkDragAction
-nautilus_drag_default_drop_action_for_uri_list (GdkDragContext *context,
-                                                const char     *target_uri_string)
+nautilus_get_drop_actions_for_uri (const char *target_uri_string)
 {
-    if (eel_uri_is_trash (target_uri_string) && (gdk_drag_context_get_actions (context) & GDK_ACTION_MOVE))
-    {
-        /* Only move to Trash */
-        return GDK_ACTION_MOVE;
-    }
-    else
+    GdkDragAction actions;
+
+    actions = GDK_ACTION_ALL;
+
+    if (!eel_uri_is_trash (target_uri_string))
     {
-        return gdk_drag_context_get_suggested_action (context);
+        /* Only allow moving to trash */
+        actions &= ~GDK_ACTION_MOVE;
     }
+
+    return actions;
 }
 
 /* Encode a "x-special/gnome-icon-list" selection.
@@ -666,11 +591,9 @@ nautilus_drag_create_selection_cache (gpointer                             conta
  * Returns FALSE if it doesn't handle drag data */
 gboolean
 nautilus_drag_drag_data_get_from_cache (GList            *cache,
-                                        GdkDragContext   *context,
-                                        GtkSelectionData *selection_data,
-                                        guint             info,
-                                        guint32           time)
+                                        GtkSelectionData *selection_data)
 {
+    GdkAtom target;
     GList *l;
     GString *result;
     NautilusDragEachSelectedItemDataGet func;
@@ -680,23 +603,20 @@ nautilus_drag_drag_data_get_from_cache (GList            *cache,
         return FALSE;
     }
 
-    switch (info)
-    {
-        case NAUTILUS_ICON_DND_GNOME_ICON_LIST:
-        {
-            func = add_one_gnome_icon;
-        }
-        break;
-
-        case NAUTILUS_ICON_DND_URI_LIST:
-        case NAUTILUS_ICON_DND_TEXT:
-        {
-            func = add_one_uri;
-        }
-        break;
+    target = gtk_selection_data_get_target (selection_data);
 
-        default:
-            return FALSE;
+    if (target == g_intern_static_string (NAUTILUS_ICON_DND_GNOME_ICON_LIST_TYPE))
+    {
+        func = add_one_gnome_icon;
+    }
+    else if (gtk_selection_data_targets_include_uri (selection_data) ||
+             gtk_selection_data_targets_include_text (selection_data))
+    {
+        func = add_one_uri;
+    }
+    else
+    {
+        return FALSE;
     }
 
     result = g_string_new (NULL);
@@ -708,7 +628,7 @@ nautilus_drag_drag_data_get_from_cache (GList            *cache,
     }
 
     gtk_selection_data_set (selection_data,
-                            gtk_selection_data_get_target (selection_data),
+                            target,
                             8, (guchar *) result->str, result->len);
     g_string_free (result, TRUE);
 
diff --git a/src/nautilus-dnd.h b/src/nautilus-dnd.h
index 6e101b529..3916a6d8d 100644
--- a/src/nautilus-dnd.h
+++ b/src/nautilus-dnd.h
@@ -28,22 +28,15 @@
 #include "nautilus-file.h"
 
 /* Drag & Drop target names. */
-#define NAUTILUS_ICON_DND_GNOME_ICON_LIST_TYPE	"x-special/gnome-icon-list"
-#define NAUTILUS_ICON_DND_URI_LIST_TYPE		"text/uri-list"
-#define NAUTILUS_ICON_DND_NETSCAPE_URL_TYPE	"_NETSCAPE_URL"
-#define NAUTILUS_ICON_DND_ROOTWINDOW_DROP_TYPE	"application/x-rootwindow-drop"
-#define NAUTILUS_ICON_DND_XDNDDIRECTSAVE_TYPE	"XdndDirectSave0" /* XDS Protocol Type */
-#define NAUTILUS_ICON_DND_RAW_TYPE	"application/octet-stream"
+#define NAUTILUS_ICON_DND_GNOME_ICON_LIST_TYPE "x-special/gnome-icon-list"
+
 
 /* drag&drop-related information. */
 typedef struct {
-	GtkTargetList *target_list;
+    GdkContentFormats *formats;
 
 	/* Stuff saved at "receive data" time needed later in the drag. */
-	gboolean got_drop_data_type;
-	NautilusIconDndTargetType data_type;
 	GtkSelectionData *selection_data;
-	char *direct_save_uri;
 
 	/* Start of the drag, in window coordinates. */
 	int start_x, start_y;
@@ -73,10 +66,10 @@ typedef struct {
 	gboolean waiting_to_autoscroll;
 	gint64 start_auto_scroll_in;
 
-        /* source context actions. Used for peek the actions using a GdkDragContext
+        /* source context actions. Used for peek the actions using a GdkDrop
          * source at drag-begin time when they are not available yet (they become
          * available at drag-motion time) */
-        guint32 source_actions;
+        GdkDragAction source_actions;
 
 } NautilusDragInfo;
 
@@ -87,10 +80,6 @@ typedef void		(* NautilusDragEachSelectedItemIterator)	(NautilusDragEachSelected
 								 gpointer iterator_context, 
 								 gpointer data);
 
-void			    nautilus_drag_init				(NautilusDragInfo		      *drag_info,
-									 const GtkTargetEntry		      *drag_types,
-									 int				       drag_type_count,
-									 gboolean			       add_text_targets);
 void			    nautilus_drag_finalize			(NautilusDragInfo		      *drag_info);
 NautilusDragSelectionItem  *nautilus_drag_selection_item_new		(void);
 void			    nautilus_drag_destroy_selection_list	(GList				      *selection_list);
@@ -98,27 +87,19 @@ GList			   *nautilus_drag_build_selection_list		(GtkSelectionData		      *data);
 
 GList *			    nautilus_drag_uri_list_from_selection_list	(const GList			      *selection_list);
 
-GList *			    nautilus_drag_uri_list_from_array		(const char			     **uris);
+GList *			    nautilus_drag_uri_list_from_array		(GStrv                                 uris);
 
 gboolean		    nautilus_drag_items_local			(const char			      *target_uri,
 									 const GList			      *selection_list);
 gboolean		    nautilus_drag_uris_local			(const char			      *target_uri,
 									 const GList			      *source_uri_list);
-void			    nautilus_drag_default_drop_action_for_icons (GdkDragContext			      *context,
-									 const char			      *target_uri,
-									 const GList			      *items,
-                                                                         guint32                               source_actions,
-									 int				      *action);
-GdkDragAction		    nautilus_drag_default_drop_action_for_netscape_url (GdkDragContext			     *context);
-GdkDragAction		    nautilus_drag_default_drop_action_for_uri_list     (GdkDragContext			     *context,
-										const char			     *target_uri_string);
+GdkDragAction               nautilus_get_drop_actions_for_icons         (const char                           *target_uri,
+                                                                         const GList                          *items);
+GdkDragAction               nautilus_get_drop_actions_for_uri           (const char                           *uri);
 GList			   *nautilus_drag_create_selection_cache	(gpointer			       container_context,
 									 NautilusDragEachSelectedItemIterator  each_selected_item_iterator);
 gboolean		    nautilus_drag_drag_data_get_from_cache	(GList				      *cache,
-									 GdkDragContext			      *context,
-									 GtkSelectionData		      *selection_data,
-									 guint				       info,
-									 guint32			       time);
+									 GtkSelectionData		      *selection_data);
 int			    nautilus_drag_modifier_based_action		(int				       default_action,
 									 int				       non_default_action);
 
@@ -135,6 +116,10 @@ void			    nautilus_drag_autoscroll_start		(NautilusDragInfo		      *drag_info,
 									 gpointer			       user_data);
 void			    nautilus_drag_autoscroll_stop		(NautilusDragInfo		      *drag_info);
 
-NautilusDragInfo *          nautilus_drag_get_source_data                 (GdkDragContext                     *context);
+NautilusDragInfo *          nautilus_drag_get_source_data                 (GdkDrag                            *context);
 
 GList *                     nautilus_drag_file_list_from_selection_list   (const GList                        *selection_list);
+
+
+gboolean                    nautilus_content_formats_include_text         (GdkContentFormats                  *formats);
+gboolean                    nautilus_content_formats_include_uri          (GdkContentFormats                  *formats);
diff --git a/src/nautilus-file.c b/src/nautilus-file.c
index e9dbcc450..93078ae00 100644
--- a/src/nautilus-file.c
+++ b/src/nautilus-file.c
@@ -54,6 +54,7 @@
 
 #include "nautilus-directory-notify.h"
 #include "nautilus-directory-private.h"
+#include "nautilus-dnd.h"
 #include "nautilus-enums.h"
 #include "nautilus-file-operations.h"
 #include "nautilus-file-private.h"
@@ -5342,6 +5343,20 @@ nautilus_file_get_icon_pixbuf (NautilusFile          *file,
     return pixbuf;
 }
 
+GdkTexture *
+nautilus_file_get_icon_texture (NautilusFile          *file,
+                                int                    size,
+                                gboolean               force_size,
+                                int                    scale,
+                                NautilusFileIconFlags  flags)
+{
+    g_autoptr (GdkPixbuf) pixbuf = NULL;
+
+    pixbuf = nautilus_file_get_icon_pixbuf (file, size, force_size, scale, flags);
+
+    return gdk_texture_new_for_pixbuf (pixbuf);
+}
+
 gboolean
 nautilus_file_get_date (NautilusFile     *file,
                         NautilusDateType  date_type,
@@ -9340,39 +9355,33 @@ nautilus_drag_can_accept_items (NautilusFile *drop_target_item,
 }
 
 gboolean
-nautilus_drag_can_accept_info (NautilusFile              *drop_target_item,
-                               NautilusIconDndTargetType  drag_type,
-                               const GList               *items)
+nautilus_drag_can_accept_data (NautilusFile *drop_target_item,
+                               GdkDrop      *drop,
+                               const GList  *items)
 {
-    switch (drag_type)
-    {
-        case NAUTILUS_ICON_DND_GNOME_ICON_LIST:
-        {
-            return nautilus_drag_can_accept_items (drop_target_item, items);
-        }
+    GdkContentFormats *formats;
 
-        case NAUTILUS_ICON_DND_URI_LIST:
-        case NAUTILUS_ICON_DND_NETSCAPE_URL:
-        case NAUTILUS_ICON_DND_TEXT:
-        {
-            return nautilus_drag_can_accept_files (drop_target_item);
-        }
+    formats = gdk_drop_get_formats (drop);
 
-        case NAUTILUS_ICON_DND_XDNDDIRECTSAVE:
-        case NAUTILUS_ICON_DND_RAW:
-        {
-            return nautilus_drag_can_accept_files (drop_target_item);             /* Check if we can accept files at this location */
-        }
+    if (gdk_content_formats_contain_mime_type (formats, NAUTILUS_ICON_DND_GNOME_ICON_LIST_TYPE))
+    {
+        return nautilus_drag_can_accept_items (drop_target_item, items);
+    }
+    else
+    {
+        GdkContentFormats *text_formats;
+
+        text_formats = gdk_content_formats_new (NULL, 0);
+        text_formats = gtk_content_formats_add_text_targets (text_formats);
+        text_formats = gtk_content_formats_add_uri_targets (text_formats);
 
-        case NAUTILUS_ICON_DND_ROOTWINDOW_DROP:
+        if (gdk_content_formats_match (formats, text_formats))
         {
-            return FALSE;
+            return nautilus_drag_can_accept_files (drop_target_item);
         }
-
-        default:
-            g_assert_not_reached ();
-            return FALSE;
     }
+
+    g_return_val_if_reached (FALSE);
 }
 
 static gboolean
diff --git a/src/nautilus-file.h b/src/nautilus-file.h
index 2164808ca..82de25ddb 100644
--- a/src/nautilus-file.h
+++ b/src/nautilus-file.h
@@ -91,17 +91,6 @@ typedef enum {
 	NAUTILUS_FILE_ICON_FLAGS_USE_ONE_EMBLEM = (1<<7)
 } NautilusFileIconFlags;	
 
-/* Standard Drag & Drop types. */
-typedef enum {
-	NAUTILUS_ICON_DND_GNOME_ICON_LIST,
-	NAUTILUS_ICON_DND_URI_LIST,
-	NAUTILUS_ICON_DND_NETSCAPE_URL,
-	NAUTILUS_ICON_DND_TEXT,
-	NAUTILUS_ICON_DND_XDNDDIRECTSAVE,
-	NAUTILUS_ICON_DND_RAW,
-	NAUTILUS_ICON_DND_ROOTWINDOW_DROP
-} NautilusIconDndTargetType;
-
 /* Item of the drag selection list */
 typedef struct {
 	NautilusFile *file;
@@ -476,6 +465,11 @@ GdkPixbuf *             nautilus_file_get_icon_pixbuf                   (Nautilu
 									 gboolean                        force_size,
 									 int                             scale,
 									 NautilusFileIconFlags           flags);
+GdkTexture             *nautilus_file_get_icon_texture                  (NautilusFile                   *file,
+                                                                         int                             size,
+                                                                         gboolean                        force_size,
+                                                                         int                             scale,
+                                                                         NautilusFileIconFlags           flags);
 
 /* Whether the file should open inside a view */
 gboolean                nautilus_file_opens_in_view                     (NautilusFile                   *file);
@@ -509,8 +503,8 @@ gboolean                nautilus_drag_can_accept_item                   (Nautilu
 gboolean                nautilus_drag_can_accept_items                  (NautilusFile                   *drop_target_item,
                                                                          const GList                    *items);
 
-gboolean                nautilus_drag_can_accept_info                   (NautilusFile                   *drop_target_item,
-                                                                         NautilusIconDndTargetType       drag_type,
+gboolean                nautilus_drag_can_accept_data                   (NautilusFile                   *drop_target_item,
+                                                                         GdkDrop                        *drop,
                                                                          const GList                    *items);
 
 /* Debugging */
diff --git a/src/nautilus-files-view-dnd.c b/src/nautilus-files-view-dnd.c
index 784d35a0e..9355e47f7 100644
--- a/src/nautilus-files-view-dnd.c
+++ b/src/nautilus-files-view-dnd.c
@@ -115,7 +115,7 @@ void
 nautilus_files_view_handle_uri_list_drop (NautilusFilesView *view,
                                           const char        *item_uris,
                                           const char        *target_uri,
-                                          GdkDragAction      action)
+                                          GdkDragAction      actions)
 {
     gchar **uri_list;
     GList *real_uri_list = NULL;
@@ -135,12 +135,10 @@ nautilus_files_view_handle_uri_list_drop (NautilusFilesView *view,
         g_assert (container_uri != NULL);
     }
 
-    if (action == GDK_ACTION_ASK)
+    if (actions == GDK_ACTION_ASK || !gdk_drag_action_is_unique (actions))
     {
-        action = nautilus_drag_drop_action_ask
-                     (GTK_WIDGET (view),
-                     GDK_ACTION_MOVE | GDK_ACTION_COPY | GDK_ACTION_LINK);
-        if (action == 0)
+        actions = nautilus_drag_drop_action_ask (GTK_WIDGET (view), GDK_ACTION_ALL);
+        if (actions == 0)
         {
             g_free (container_uri);
             return;
@@ -149,10 +147,9 @@ nautilus_files_view_handle_uri_list_drop (NautilusFilesView *view,
 
     /* We don't support GDK_ACTION_ASK or GDK_ACTION_PRIVATE
      * and we don't support combinations either. */
-    if ((action != GDK_ACTION_DEFAULT) &&
-        (action != GDK_ACTION_COPY) &&
-        (action != GDK_ACTION_MOVE) &&
-        (action != GDK_ACTION_LINK))
+    if (actions != GDK_ACTION_COPY &&
+        actions != GDK_ACTION_MOVE &&
+        actions != GDK_ACTION_LINK)
     {
         show_dialog (_("Drag and drop is not supported."),
                      _("An invalid drag type was used."),
@@ -182,7 +179,7 @@ nautilus_files_view_handle_uri_list_drop (NautilusFilesView *view,
 
     nautilus_files_view_move_copy_items (view, real_uri_list,
                                          real_target_uri,
-                                         action);
+                                         actions);
 
     g_list_free_full (real_uri_list, g_free);
 
@@ -302,53 +299,6 @@ nautilus_files_view_handle_text_drop (NautilusFilesView *view,
 }
 
 void
-nautilus_files_view_handle_raw_drop (NautilusFilesView *view,
-                                     const char        *raw_data,
-                                     int                length,
-                                     const char        *target_uri,
-                                     const char        *direct_save_uri,
-                                     GdkDragAction      action)
-{
-    char *container_uri, *filename;
-    GFile *direct_save_full;
-
-    if (raw_data == NULL)
-    {
-        return;
-    }
-
-    g_return_if_fail (action == GDK_ACTION_COPY);
-
-    container_uri = NULL;
-    if (target_uri == NULL)
-    {
-        container_uri = nautilus_files_view_get_backing_uri (view);
-        g_assert (container_uri != NULL);
-    }
-
-    filename = NULL;
-    if (direct_save_uri != NULL)
-    {
-        direct_save_full = g_file_new_for_uri (direct_save_uri);
-        filename = g_file_get_basename (direct_save_full);
-    }
-    if (filename == NULL)
-    {
-        /* Translator: This is the filename used for when you dnd raw
-         * data to a directory, if the source didn't supply a name.
-         */
-        filename = g_strdup (_("dropped data"));
-    }
-
-    nautilus_files_view_new_file_with_initial_contents (
-        view, target_uri != NULL ? target_uri : container_uri,
-        filename, raw_data, length);
-
-    g_free (container_uri);
-    g_free (filename);
-}
-
-void
 nautilus_files_view_drop_proxy_received_uris (NautilusFilesView *view,
                                               GList             *source_uri_list,
                                               const char        *target_uri,
@@ -363,11 +313,9 @@ nautilus_files_view_drop_proxy_received_uris (NautilusFilesView *view,
         g_assert (container_uri != NULL);
     }
 
-    if (action == GDK_ACTION_ASK)
+    if (!gdk_drag_action_is_unique (action))
     {
-        action = nautilus_drag_drop_action_ask
-                     (GTK_WIDGET (view),
-                     GDK_ACTION_MOVE | GDK_ACTION_COPY | GDK_ACTION_LINK);
+        action = nautilus_drag_drop_action_ask (GTK_WIDGET (view), GDK_ACTION_ALL);
         if (action == 0)
         {
             return;
diff --git a/src/nautilus-files-view-dnd.h b/src/nautilus-files-view-dnd.h
index a566a7c69..55d30f4a4 100644
--- a/src/nautilus-files-view-dnd.h
+++ b/src/nautilus-files-view-dnd.h
@@ -31,17 +31,11 @@
 void nautilus_files_view_handle_uri_list_drop     (NautilusFilesView *view,
                                                    const char        *item_uris,
                                                    const char        *target_uri,
-                                                   GdkDragAction      action);
+                                                   GdkDragAction      actions);
 void nautilus_files_view_handle_text_drop         (NautilusFilesView *view,
                                                    const char        *text,
                                                    const char        *target_uri,
                                                    GdkDragAction      action);
-void nautilus_files_view_handle_raw_drop          (NautilusFilesView *view,
-                                                   const char        *raw_data,
-                                                   int                length,
-                                                   const char        *target_uri,
-                                                   const char        *direct_save_uri,
-                                                   GdkDragAction      action);
 void nautilus_files_view_handle_hover             (NautilusFilesView *view,
                                                    const char        *target_uri);
 void nautilus_files_view_handle_netscape_url_drop (NautilusFilesView *view,
diff --git a/src/nautilus-files-view.c b/src/nautilus-files-view.c
index 052be84e9..45f2aec6a 100644
--- a/src/nautilus-files-view.c
+++ b/src/nautilus-files-view.c
@@ -2613,7 +2613,7 @@ handle_clipboard_data (NautilusFilesView *view,
 
         uri = g_file_get_uri (l->data);
 
-        item_uris = g_list_prepend (uri);
+        item_uris = g_list_prepend (item_uris, uri);
     }
 
     item_uris = g_list_reverse (item_uris);
@@ -6132,7 +6132,7 @@ action_move_to (GSimpleAction *action,
 }
 
 static void
-action_paste_files_into (GSimpleAction *action,
+action_paste_files_into (GSimpleAction *simple,
                          GVariant      *state,
                          gpointer       user_data)
 {
@@ -7219,7 +7219,6 @@ update_actions_state_from_clipboard (NautilusFilesView *view)
     gboolean selection_contains_starred;
     GAction *action;
 
-    view = NAUTILUS_FILES_VIEW (user_data);
     priv = nautilus_files_view_get_instance_private (view);
     if (priv->slot == NULL || !priv->active)
     {
@@ -7307,7 +7306,6 @@ real_update_actions_state (NautilusFilesView *view)
     gboolean show_star;
     gboolean show_unstar;
     gchar *uri;
-    GdkContentFormats *formats;
 
     priv = nautilus_files_view_get_instance_private (view);
 
diff --git a/src/nautilus-files-view.h b/src/nautilus-files-view.h
index 954101bd6..db304b802 100644
--- a/src/nautilus-files-view.h
+++ b/src/nautilus-files-view.h
@@ -295,7 +295,7 @@ char *            nautilus_files_view_get_backing_uri            (NautilusFilesV
 void              nautilus_files_view_move_copy_items            (NautilusFilesView      *view,
                                                                   const GList            *item_uris,
                                                                   const char             *target_uri,
-                                                                  int                     copy_action);
+                                                                  GdkDragAction           copy_action);
 void              nautilus_files_view_new_file_with_initial_contents (NautilusFilesView  *view,
                                                                       const char         *parent_uri,
                                                                       const char         *filename,
diff --git a/src/nautilus-list-model.c b/src/nautilus-list-model.c
index e700669e7..5763d1b3b 100644
--- a/src/nautilus-list-model.c
+++ b/src/nautilus-list-model.c
@@ -105,10 +105,9 @@ G_DEFINE_TYPE_WITH_CODE (NautilusListModel, nautilus_list_model, G_TYPE_OBJECT,
                                                 nautilus_list_model_sortable_init)
                          G_ADD_PRIVATE (NautilusListModel));
 
-static const GtkTargetEntry drag_types [] =
+static const char *drag_types[] =
 {
-    { NAUTILUS_ICON_DND_GNOME_ICON_LIST_TYPE, 0, NAUTILUS_ICON_DND_GNOME_ICON_LIST },
-    { NAUTILUS_ICON_DND_URI_LIST_TYPE, 0, NAUTILUS_ICON_DND_URI_LIST },
+    NAUTILUS_ICON_DND_GNOME_ICON_LIST_TYPE,
 };
 
 static void
@@ -341,11 +340,10 @@ nautilus_list_model_get_value (GtkTreeModel *tree_model,
     FileEntry *file_entry;
     NautilusFile *file;
     char *str;
-    GdkPixbuf *icon, *rendered_icon;
+    GdkTexture *texture;
     int icon_size, icon_scale;
     NautilusListZoomLevel zoom_level;
     NautilusFileIconFlags flags;
-    cairo_surface_t *surface;
 
     model = NAUTILUS_LIST_MODEL (tree_model);
     priv = nautilus_list_model_get_instance_private (model);
@@ -379,7 +377,7 @@ nautilus_list_model_get_value (GtkTreeModel *tree_model,
         case NAUTILUS_LIST_MODEL_LARGE_ICON_COLUMN:
         case NAUTILUS_LIST_MODEL_LARGER_ICON_COLUMN:
         {
-            g_value_init (value, CAIRO_GOBJECT_TYPE_SURFACE);
+            g_value_init (value, GDK_TYPE_TEXTURE);
 
             if (file != NULL)
             {
@@ -413,12 +411,15 @@ nautilus_list_model_get_value (GtkTreeModel *tree_model,
                     }
                 }
 
-                icon = nautilus_file_get_icon_pixbuf (file, icon_size, TRUE, icon_scale, flags);
+                texture = nautilus_file_get_icon_texture (file, icon_size, TRUE, icon_scale, flags);
 
                 if (priv->highlight_files != NULL &&
                     g_list_find_custom (priv->highlight_files,
                                         file, (GCompareFunc) nautilus_file_compare_location))
                 {
+#if 0
+                    GdkPixbuf *rendered_icon;
+
                     rendered_icon = eel_create_spotlight_pixbuf (icon);
 
                     if (rendered_icon != NULL)
@@ -426,11 +427,10 @@ nautilus_list_model_get_value (GtkTreeModel *tree_model,
                         g_object_unref (icon);
                         icon = rendered_icon;
                     }
+#endif
                 }
 
-                surface = gdk_cairo_surface_create_from_pixbuf (icon, icon_scale, NULL);
-                g_value_take_boxed (value, surface);
-                g_object_unref (icon);
+                g_value_take_object (value, texture);
             }
         }
         break;
@@ -1614,15 +1614,16 @@ nautilus_list_model_get_drag_view (NautilusListModel *model,
     return priv->drag_view;
 }
 
-GtkTargetList *
-nautilus_list_model_get_drag_target_list ()
+GdkContentFormats *
+nautilus_list_model_get_drag_targets (void)
 {
-    GtkTargetList *target_list;
+    GdkContentFormats *targets;
 
-    target_list = gtk_target_list_new (drag_types, G_N_ELEMENTS (drag_types));
-    gtk_target_list_add_text_targets (target_list, NAUTILUS_ICON_DND_TEXT);
+    targets = gdk_content_formats_new (drag_types, G_N_ELEMENTS (drag_types));
+    targets = gtk_content_formats_add_text_targets (targets);
+    targets = gtk_content_formats_add_uri_targets (targets);
 
-    return target_list;
+    return targets;
 }
 
 int
diff --git a/src/nautilus-list-model.h b/src/nautilus-list-model.h
index ba771b8c2..ad816172c 100644
--- a/src/nautilus-list-model.h
+++ b/src/nautilus-list-model.h
@@ -96,7 +96,7 @@ GtkTreeView *     nautilus_list_model_get_drag_view (NautilusListModel *model,
 						     int *drag_begin_x,
 						     int *drag_begin_y);
 
-GtkTargetList *   nautilus_list_model_get_drag_target_list (void);
+GdkContentFormats *nautilus_list_model_get_drag_targets (void);
 
 int               nautilus_list_model_compare_func (NautilusListModel *model,
 						    NautilusFile *file1,
@@ -110,4 +110,4 @@ void              nautilus_list_model_subdirectory_done_loading (NautilusListMod
 								 NautilusDirectory *directory);
 
 void              nautilus_list_model_set_highlight_for_files (NautilusListModel *model,
-							       GList *files);
\ No newline at end of file
+							       GList *files);
diff --git a/src/nautilus-list-view-dnd.c b/src/nautilus-list-view-dnd.c
index 21910060f..b27eaa364 100644
--- a/src/nautilus-list-view-dnd.c
+++ b/src/nautilus-list-view-dnd.c
@@ -21,17 +21,15 @@
 #include "nautilus-list-view-dnd.h"
 #include "nautilus-list-view-private.h"
 
-static GtkTargetList *source_target_list = NULL;
+static GdkContentFormats *source_targets;
 
 static void
 drag_info_data_free (NautilusListView *list_view);
 
 static void
 drag_data_get_callback (GtkWidget        *widget,
-                        GdkDragContext   *context,
+                        GdkDrag          *context,
                         GtkSelectionData *selection_data,
-                        guint             info,
-                        guint             time,
                         gpointer          user_data)
 {
     GtkTreeView *tree_view;
@@ -55,16 +53,16 @@ drag_data_get_callback (GtkWidget        *widget,
     }
 
     nautilus_drag_drag_data_get_from_cache (list_view->details->drag_source_info->selection_cache,
-                                            context, selection_data, info, time);
+                                            selection_data);
 }
 
-static cairo_surface_t *
-get_drag_surface (NautilusListView *view)
+static GdkTexture *
+get_drag_texture (NautilusListView *view)
 {
     GtkTreeModel *model;
     GtkTreePath *path;
     GtkTreeIter iter;
-    cairo_surface_t *ret;
+    GdkTexture *ret;
     GdkRectangle cell_area;
 
     ret = NULL;
@@ -164,19 +162,18 @@ each_item_get_data_binder (NautilusDragEachSelectedItemDataGet iteratee,
 
 static void
 drag_begin_callback (GtkWidget        *widget,
-                     GdkDragContext   *context,
+                     GdkDrag          *context,
                      NautilusListView *view)
 {
-    cairo_surface_t *surface;
+    g_autoptr (GdkTexture) texture = NULL;
     NautilusWindow *window;
     GList *dragged_files;
 
     window = nautilus_files_view_get_window (NAUTILUS_FILES_VIEW (view));
-    surface = get_drag_surface (view);
-    if (surface)
+    texture = get_drag_texture (view);
+    if (texture != NULL)
     {
-        gtk_drag_set_icon_surface (context, surface);
-        cairo_surface_destroy (surface);
+        gtk_drag_set_icon_paintable (context, GDK_PAINTABLE (texture), 0, 0);
     }
     else
     {
@@ -199,7 +196,7 @@ drag_begin_callback (GtkWidget        *widget,
 
 static void
 drag_end_callback (GtkWidget        *widget,
-                   GdkDragContext   *context,
+                   GdkDrag          *context,
                    NautilusListView *list_view)
 {
     NautilusWindow *window;
@@ -226,8 +223,7 @@ drag_info_data_free (NautilusListView *list_view)
 }
 
 NautilusDragInfo *
-nautilus_list_view_dnd_get_drag_source_data (NautilusListView *list_view,
-                                             GdkDragContext   *context)
+nautilus_list_view_dnd_get_drag_source_data (NautilusListView *list_view)
 {
     GtkTreeView *tree_view;
     GtkTreeModel *model;
@@ -279,9 +275,9 @@ nautilus_list_view_dnd_drag_begin (NautilusListView *list_view,
         return;
     }
 
-    if (!source_target_list)
+    if (source_targets == NULL)
     {
-        source_target_list = nautilus_list_model_get_drag_target_list ();
+        source_targets = nautilus_list_model_get_drag_targets ();
     }
 
     if (gtk_drag_check_threshold (GTK_WIDGET (list_view->details->tree_view),
@@ -290,16 +286,16 @@ nautilus_list_view_dnd_drag_begin (NautilusListView *list_view,
                                   list_view->details->drag_x + offset_x,
                                   list_view->details->drag_y + offset_y))
     {
-        guint32 actions;
+        GdkDragAction actions;
+
+        actions = GDK_ACTION_ALL | GDK_ACTION_ASK;
 
-        actions = GDK_ACTION_MOVE | GDK_ACTION_COPY | GDK_ACTION_LINK | GDK_ACTION_ASK;
         list_view->details->drag_source_info->source_actions = actions;
-        gtk_drag_begin_with_coordinates (GTK_WIDGET (list_view->details->tree_view),
-                                         source_target_list,
-                                         actions,
-                                         list_view->details->drag_button,
-                                         (GdkEvent *) event,
-                                         -1,
-                                         -1);
+        gtk_drag_begin (GTK_WIDGET (list_view->details->tree_view),
+                                    NULL,
+                                    source_targets,
+                                    actions,
+                                    list_view->details->drag_x,
+                                    list_view->details->drag_y);
     }
 }
diff --git a/src/nautilus-list-view-dnd.h b/src/nautilus-list-view-dnd.h
index 03e102ed3..4c5d85bb6 100644
--- a/src/nautilus-list-view-dnd.h
+++ b/src/nautilus-list-view-dnd.h
@@ -30,5 +30,4 @@ void nautilus_list_view_dnd_drag_begin (NautilusListView *list_view,
                                         gdouble           offset_y,
                                         const GdkEvent   *event);
 NautilusDragInfo *
-nautilus_list_view_dnd_get_drag_source_data (NautilusListView *list_view,
-                                             GdkDragContext   *context);
+nautilus_list_view_dnd_get_drag_source_data (NautilusListView *list_view);
diff --git a/src/nautilus-list-view.c b/src/nautilus-list-view.c
index 0d8c3a001..a3acf9765 100644
--- a/src/nautilus-list-view.c
+++ b/src/nautilus-list-view.c
@@ -1296,36 +1296,22 @@ static void
 list_view_handle_uri_list (NautilusTreeViewDragDest *dest,
                            const char               *item_uris,
                            const char               *target_uri,
-                           GdkDragAction             action,
+                           GdkDragAction             actions,
                            NautilusListView         *view)
 {
     nautilus_files_view_handle_uri_list_drop (NAUTILUS_FILES_VIEW (view),
-                                              item_uris, target_uri, action);
+                                              item_uris, target_uri, actions);
 }
 
 static void
 list_view_handle_text (NautilusTreeViewDragDest *dest,
                        const char               *text,
                        const char               *target_uri,
-                       GdkDragAction             action,
+                       GdkDragAction             actions,
                        NautilusListView         *view)
 {
     nautilus_files_view_handle_text_drop (NAUTILUS_FILES_VIEW (view),
-                                          text, target_uri, action);
-}
-
-static void
-list_view_handle_raw (NautilusTreeViewDragDest *dest,
-                      const char               *raw_data,
-                      int                       length,
-                      const char               *target_uri,
-                      const char               *direct_save_uri,
-                      GdkDragAction             action,
-                      NautilusListView         *view)
-{
-    nautilus_files_view_handle_raw_drop (NAUTILUS_FILES_VIEW (view),
-                                         raw_data, length, target_uri, direct_save_uri,
-                                         action);
+                                          text, target_uri, actions);
 }
 
 static void
@@ -1340,7 +1326,7 @@ static void
 move_copy_items_callback (NautilusTreeViewDragDest *dest,
                           GList                    *item_uris,
                           const char               *target_uri,
-                          guint                     action,
+                          guint                     actions,
                           gpointer                  user_data)
 {
     NautilusFilesView *view;
@@ -2081,8 +2067,6 @@ create_and_set_up_tree_view (NautilusListView *view)
                              G_CALLBACK (list_view_handle_uri_list), view, 0);
     g_signal_connect_object (view->details->drag_dest, "handle-text",
                              G_CALLBACK (list_view_handle_text), view, 0);
-    g_signal_connect_object (view->details->drag_dest, "handle-raw",
-                             G_CALLBACK (list_view_handle_raw), view, 0);
     g_signal_connect_object (view->details->drag_dest, "handle-hover",
                              G_CALLBACK (list_view_handle_hover), view, 0);
 
@@ -2249,7 +2233,7 @@ create_and_set_up_tree_view (NautilusListView *view)
             gtk_tree_view_column_pack_start (view->details->file_name_column, cell, FALSE);
             gtk_tree_view_column_set_attributes (view->details->file_name_column,
                                                  cell,
-                                                 "surface", nautilus_list_model_get_column_id_from_zoom_level (view->details->zoom_level),
+                                                 "texture", nautilus_list_model_get_column_id_from_zoom_level (view->details->zoom_level),
                                                  NULL);
 
             cell = gtk_cell_renderer_text_new ();
@@ -3446,7 +3430,7 @@ nautilus_list_view_set_zoom_level (NautilusListView      *view,
     column = nautilus_list_model_get_column_id_from_zoom_level (new_level);
     gtk_tree_view_column_set_attributes (view->details->file_name_column,
                                          GTK_CELL_RENDERER (view->details->pixbuf_cell),
-                                         "surface", column,
+                                         "texture", column,
                                          NULL);
     set_up_pixbuf_size (view);
 }
diff --git a/src/nautilus-location-entry.c b/src/nautilus-location-entry.c
index ab1dcb207..4b586f6ef 100644
--- a/src/nautilus-location-entry.c
+++ b/src/nautilus-location-entry.c
@@ -53,18 +53,6 @@ enum
     NAUTILUS_DND_NTARGETS
 };
 
-static const GtkTargetEntry drag_types [] =
-{
-    { NAUTILUS_DND_URI_LIST_TYPE, 0, NAUTILUS_DND_URI_LIST },
-    { NAUTILUS_DND_TEXT_PLAIN_TYPE, 0, NAUTILUS_DND_TEXT_PLAIN },
-};
-
-static const GtkTargetEntry drop_types [] =
-{
-    { NAUTILUS_DND_URI_LIST_TYPE, 0, NAUTILUS_DND_URI_LIST },
-    { NAUTILUS_DND_TEXT_PLAIN_TYPE, 0, NAUTILUS_DND_TEXT_PLAIN },
-};
-
 typedef struct _NautilusLocationEntryPrivate
 {
     char *current_directory;
@@ -225,12 +213,8 @@ nautilus_location_entry_set_location (NautilusLocationEntry *entry,
 
 static void
 drag_data_received_callback (GtkWidget        *widget,
-                             GdkDragContext   *context,
-                             int               x,
-                             int               y,
+                             GdkDrop          *drop,
                              GtkSelectionData *data,
-                             guint             info,
-                             guint32           time,
                              gpointer          callback_data)
 {
     char **names;
@@ -250,7 +234,7 @@ drag_data_received_callback (GtkWidget        *widget,
     if (names == NULL || *names == NULL)
     {
         g_warning ("No D&D URI's");
-        gtk_drag_finish (context, FALSE, FALSE, time);
+        gdk_drop_finish (drop, 0);
         return;
     }
 
@@ -286,7 +270,7 @@ drag_data_received_callback (GtkWidget        *widget,
 
         if (!new_windows_for_extras)
         {
-            gtk_drag_finish (context, FALSE, FALSE, time);
+            gdk_drop_finish (drop, 0);
             return;
         }
     }
@@ -311,20 +295,18 @@ drag_data_received_callback (GtkWidget        *widget,
 
     g_strfreev (names);
 
-    gtk_drag_finish (context, TRUE, FALSE, time);
+    gdk_drop_finish (drop, gdk_drop_get_actions (drop));
 }
 
 static void
 drag_data_get_callback (GtkWidget        *widget,
-                        GdkDragContext   *context,
+                        GdkDrag          *context,
                         GtkSelectionData *selection_data,
-                        guint             info,
-                        guint32           time,
                         gpointer          callback_data)
 {
     NautilusLocationEntry *self;
-    GFile *location;
-    gchar *uri;
+    g_autoptr (GFile) location = NULL;
+    g_autofree char *uri = NULL;
 
     g_assert (selection_data != NULL);
     self = callback_data;
@@ -332,23 +314,16 @@ drag_data_get_callback (GtkWidget        *widget,
     location = nautilus_location_entry_get_location (self);
     uri = g_file_get_uri (location);
 
-    switch (info)
+    if (!gtk_selection_data_targets_include_text (selection_data) &&
+        !gtk_selection_data_targets_include_uri (selection_data))
     {
-        case NAUTILUS_DND_URI_LIST:
-        case NAUTILUS_DND_TEXT_PLAIN:
-        {
-            gtk_selection_data_set (selection_data,
-                                    gtk_selection_data_get_target (selection_data),
-                                    8, (guchar *) uri,
-                                    strlen (uri));
-        }
-        break;
-
-        default:
-            g_assert_not_reached ();
+        return;
     }
-    g_free (uri);
-    g_object_unref (location);
+
+    gtk_selection_data_set (selection_data,
+                            gtk_selection_data_get_target (selection_data),
+                            8, (guchar *) uri,
+                            strlen (uri));
 }
 
 /* routine that performs the tab expansion.  Extract the directory name and
@@ -862,7 +837,7 @@ static void
 nautilus_location_entry_init (NautilusLocationEntry *entry)
 {
     NautilusLocationEntryPrivate *priv;
-    GtkTargetList *targetlist;
+    g_autoptr (GdkContentFormats) targets = NULL;
 
     priv = nautilus_location_entry_get_instance_private (entry);
 
@@ -871,9 +846,10 @@ nautilus_location_entry_init (NautilusLocationEntry *entry)
 
     gtk_entry_set_icon_from_icon_name (GTK_ENTRY (entry), GTK_ENTRY_ICON_PRIMARY, "folder-symbolic");
     gtk_entry_set_icon_activatable (GTK_ENTRY (entry), GTK_ENTRY_ICON_PRIMARY, FALSE);
-    targetlist = gtk_target_list_new (drag_types, G_N_ELEMENTS (drag_types));
-    gtk_entry_set_icon_drag_source (GTK_ENTRY (entry), GTK_ENTRY_ICON_PRIMARY, targetlist, GDK_ACTION_COPY | GDK_ACTION_MOVE | GDK_ACTION_LINK);
-    gtk_target_list_unref (targetlist);
+    targets = gdk_content_formats_new (NULL, 0);
+    targets = gtk_content_formats_add_text_targets (targets);
+    targets = gtk_content_formats_add_uri_targets (targets);
+    gtk_entry_set_icon_drag_source (GTK_ENTRY (entry), GTK_ENTRY_ICON_PRIMARY, targets, GDK_ACTION_COPY | GDK_ACTION_MOVE | GDK_ACTION_LINK);
 
     nautilus_location_entry_set_secondary_action (entry,
                                                   NAUTILUS_LOCATION_ENTRY_ACTION_CLEAR);
@@ -897,7 +873,7 @@ nautilus_location_entry_init (NautilusLocationEntry *entry)
     /* Drag dest. */
     gtk_drag_dest_set (GTK_WIDGET (entry),
                        GTK_DEST_DEFAULT_ALL,
-                       drop_types, G_N_ELEMENTS (drop_types),
+                       targets,
                        GDK_ACTION_COPY | GDK_ACTION_MOVE | GDK_ACTION_LINK);
     g_signal_connect (entry, "drag-data-received",
                       G_CALLBACK (drag_data_received_callback), NULL);
diff --git a/src/nautilus-properties-window.c b/src/nautilus-properties-window.c
index d04d1f801..fa55fca20 100644
--- a/src/nautilus-properties-window.c
+++ b/src/nautilus-properties-window.c
@@ -36,6 +36,7 @@
 #define GNOME_DESKTOP_USE_UNSTABLE_API
 #include "gnome-desktop/gnome-desktop-thumbnail.h"
 
+#include "nautilus-dnd.h"
 #include "nautilus-enums.h"
 #include "nautilus-error-reporting.h"
 #include "nautilus-file-operations.h"
@@ -158,12 +159,6 @@ enum
     TARGET_GNOME_URI_LIST,
 };
 
-static const GtkTargetEntry target_table[] =
-{
-    { "text/uri-list", 0, TARGET_URI_LIST },
-    { "x-special/gnome-icon-list", 0, TARGET_GNOME_URI_LIST },
-};
-
 #define DIRECTORY_CONTENTS_UPDATE_INTERVAL      200 /* milliseconds */
 #define FILES_UPDATE_INTERVAL                   200 /* milliseconds */
 
@@ -459,12 +454,9 @@ reset_icon (NautilusPropertiesWindow *properties_window)
 
 static void
 nautilus_properties_window_drag_data_received (GtkWidget        *widget,
-                                               GdkDragContext   *context,
-                                               int               x,
-                                               int               y,
+                                               GdkDrop          *drop,
                                                GtkSelectionData *selection_data,
-                                               guint             info,
-                                               guint             time)
+                                               gpointer          user_data)
 {
     char **uris;
     gboolean exactly_one;
@@ -532,13 +524,22 @@ create_image_widget (NautilusPropertiesWindow *window,
     button = NULL;
     if (is_customizable)
     {
+        static const char *mime_types[] =
+        {
+            NAUTILUS_ICON_DND_GNOME_ICON_LIST_TYPE,
+        };
+        g_autoptr (GdkContentFormats) targets = NULL;
+
+        targets = gdk_content_formats_new (mime_types, G_N_ELEMENTS (mime_types));
+        targets = gtk_content_formats_add_uri_targets (targets);
+
         button = gtk_button_new ();
         gtk_container_add (GTK_CONTAINER (button), image);
 
         /* prepare the image to receive dropped objects to assign custom images */
         gtk_drag_dest_set (GTK_WIDGET (image),
                            GTK_DEST_DEFAULT_MOTION | GTK_DEST_DEFAULT_HIGHLIGHT | GTK_DEST_DEFAULT_DROP,
-                           target_table, G_N_ELEMENTS (target_table),
+                           targets,
                            GDK_ACTION_COPY | GDK_ACTION_MOVE);
 
         g_signal_connect (image, "drag-data-received",
diff --git a/src/nautilus-tree-view-drag-dest.c b/src/nautilus-tree-view-drag-dest.c
index 567e2ffb9..aa796a177 100644
--- a/src/nautilus-tree-view-drag-dest.c
+++ b/src/nautilus-tree-view-drag-dest.c
@@ -59,8 +59,10 @@ struct _NautilusTreeViewDragDestDetails
     guint scroll_id;
     guint expand_id;
 
-    char *direct_save_uri;
     char *target_uri;
+
+    double drop_x;
+    double drop_y;
 };
 
 enum
@@ -68,10 +70,8 @@ enum
     GET_ROOT_URI,
     GET_FILE_FOR_PATH,
     MOVE_COPY_ITEMS,
-    HANDLE_NETSCAPE_URL,
     HANDLE_URI_LIST,
     HANDLE_TEXT,
-    HANDLE_RAW,
     HANDLE_HOVER,
     LAST_SIGNAL
 };
@@ -81,14 +81,9 @@ static guint signals[LAST_SIGNAL];
 G_DEFINE_TYPE (NautilusTreeViewDragDest, nautilus_tree_view_drag_dest,
                G_TYPE_OBJECT);
 
-static const GtkTargetEntry drag_types [] =
+static const char *drag_types[] =
 {
-    { NAUTILUS_ICON_DND_GNOME_ICON_LIST_TYPE, 0, NAUTILUS_ICON_DND_GNOME_ICON_LIST },
-    /* prefer "_NETSCAPE_URL" over "text/uri-list" to satisfy web browsers. */
-    { NAUTILUS_ICON_DND_NETSCAPE_URL_TYPE, 0, NAUTILUS_ICON_DND_NETSCAPE_URL },
-    { NAUTILUS_ICON_DND_URI_LIST_TYPE, 0, NAUTILUS_ICON_DND_URI_LIST },
-    { NAUTILUS_ICON_DND_XDNDDIRECTSAVE_TYPE, 0, NAUTILUS_ICON_DND_XDNDDIRECTSAVE },     /* XDS Protocol Type */
-    { NAUTILUS_ICON_DND_RAW_TYPE, 0, NAUTILUS_ICON_DND_RAW }
+    NAUTILUS_ICON_DND_GNOME_ICON_LIST_TYPE,
 };
 
 
@@ -241,17 +236,14 @@ set_drag_dest_row (NautilusTreeViewDragDest *dest,
     if (path)
     {
         set_widget_highlight (dest, FALSE);
-        gtk_tree_view_set_drag_dest_row
-            (dest->details->tree_view,
-            path,
-            GTK_TREE_VIEW_DROP_INTO_OR_BEFORE);
+        gtk_tree_view_set_drag_dest_row (dest->details->tree_view,
+                                         path,
+                                         GTK_TREE_VIEW_DROP_INTO_OR_BEFORE);
     }
     else
     {
         set_widget_highlight (dest, TRUE);
-        gtk_tree_view_set_drag_dest_row (dest->details->tree_view,
-                                         NULL,
-                                         0);
+        gtk_tree_view_set_drag_dest_row (dest->details->tree_view, NULL, 0);
     }
 }
 
@@ -259,35 +251,24 @@ static void
 clear_drag_dest_row (NautilusTreeViewDragDest *dest)
 {
     gtk_tree_view_set_drag_dest_row (dest->details->tree_view, NULL, 0);
-    set_widget_highlight (dest, FALSE);
 }
 
 static gboolean
 get_drag_data (NautilusTreeViewDragDest *dest,
-               GdkDragContext           *context,
-               guint32                   time)
+               GdkDrop                  *drop)
 {
     GdkAtom target;
 
     target = gtk_drag_dest_find_target (GTK_WIDGET (dest->details->tree_view),
-                                        context,
+                                        drop,
                                         NULL);
 
-    if (target == GDK_NONE)
+    if (target == NULL)
     {
         return FALSE;
     }
 
-    if (target == gdk_atom_intern (NAUTILUS_ICON_DND_XDNDDIRECTSAVE_TYPE, FALSE) &&
-        !dest->details->drop_occurred)
-    {
-        dest->details->drag_type = NAUTILUS_ICON_DND_XDNDDIRECTSAVE;
-        dest->details->have_drag_data = TRUE;
-        return TRUE;
-    }
-
-    gtk_drag_get_data (GTK_WIDGET (dest->details->tree_view),
-                       context, target, time);
+    gtk_drag_get_data (GTK_WIDGET (dest->details->tree_view), drop, target);
 
     return TRUE;
 }
@@ -319,9 +300,6 @@ free_drag_data (NautilusTreeViewDragDest *dest)
         dest->details->drag_list = NULL;
     }
 
-    g_free (dest->details->direct_save_uri);
-    dest->details->direct_save_uri = NULL;
-
     g_free (dest->details->target_uri);
     dest->details->target_uri = NULL;
 
@@ -439,7 +417,8 @@ file_for_path (NautilusTreeViewDragDest *dest,
 
 static char *
 get_drop_target_uri_for_path (NautilusTreeViewDragDest *dest,
-                              GtkTreePath              *path)
+                              GtkTreePath              *path,
+                              GdkDrop                  *drop)
 {
     NautilusFile *file;
     char *target = NULL;
@@ -450,8 +429,8 @@ get_drop_target_uri_for_path (NautilusTreeViewDragDest *dest,
     {
         return NULL;
     }
-    can = nautilus_drag_can_accept_info (file,
-                                         dest->details->drag_type,
+    can = nautilus_drag_can_accept_data (file,
+                                         drop,
                                          dest->details->drag_list);
     if (can)
     {
@@ -466,7 +445,8 @@ static void
 check_hover_expand_timer (NautilusTreeViewDragDest *dest,
                           GtkTreePath              *path,
                           GtkTreePath              *drop_path,
-                          GtkTreePath              *old_drop_path)
+                          GtkTreePath              *old_drop_path,
+                          GdkDrop                  *drop)
 {
     gboolean use_tree = g_settings_get_boolean (nautilus_list_view_preferences,
                                                 NAUTILUS_PREFERENCES_LIST_VIEW_USE_TREE);
@@ -478,7 +458,7 @@ check_hover_expand_timer (NautilusTreeViewDragDest *dest,
     else
     {
         char *uri;
-        uri = get_drop_target_uri_for_path (dest, path);
+        uri = get_drop_target_uri_for_path (dest, path, drop);
         check_hover_timer (dest, uri);
         g_free (uri);
     }
@@ -486,7 +466,8 @@ check_hover_expand_timer (NautilusTreeViewDragDest *dest,
 
 static GtkTreePath *
 get_drop_path (NautilusTreeViewDragDest *dest,
-               GtkTreePath              *path)
+               GtkTreePath              *path,
+               GdkDrop                  *drop)
 {
     NautilusFile *file;
     GtkTreePath *ret;
@@ -501,8 +482,8 @@ get_drop_path (NautilusTreeViewDragDest *dest,
 
     /* Go up the tree until we find a file that can accept a drop */
     while (file == NULL /* dummy row */ ||
-           !nautilus_drag_can_accept_info (file,
-                                           dest->details->drag_type,
+           !nautilus_drag_can_accept_data (file,
+                                           drop,
                                            dest->details->drag_list))
     {
         if (gtk_tree_path_get_depth (ret) == 1)
@@ -524,107 +505,76 @@ get_drop_path (NautilusTreeViewDragDest *dest,
     return ret;
 }
 
-static guint
-get_drop_action (NautilusTreeViewDragDest *dest,
-                 GdkDragContext           *context,
-                 GtkTreePath              *path)
+static GdkDragAction
+get_drop_actions (NautilusTreeViewDragDest *dest,
+                  GdkDrop                  *drop,
+                  GtkTreePath              *path)
 {
-    char *drop_target;
-    int action;
+    GdkContentFormats *formats;
+    g_autofree char *drop_target = NULL;
+    GdkDragAction actions = 0;
 
-    if (!dest->details->have_drag_data ||
-        (dest->details->drag_type == NAUTILUS_ICON_DND_GNOME_ICON_LIST &&
-         dest->details->drag_list == NULL))
+    formats = gdk_drop_get_formats (drop);
+    if (gdk_content_formats_contain_mime_type (formats, NAUTILUS_ICON_DND_GNOME_ICON_LIST_TYPE) &&
+        dest->details->drag_list == NULL)
     {
         return 0;
     }
-
-    drop_target = get_drop_target_uri_for_path (dest, path);
+    drop_target = get_drop_target_uri_for_path (dest, path, drop);
     if (drop_target == NULL)
     {
         return 0;
     }
 
-    action = 0;
-    switch (dest->details->drag_type)
+    if (gdk_content_formats_contain_mime_type (formats, NAUTILUS_ICON_DND_GNOME_ICON_LIST_TYPE))
     {
-        case NAUTILUS_ICON_DND_GNOME_ICON_LIST:
-        {
-            nautilus_drag_default_drop_action_for_icons
-                (context,
-                drop_target,
-                dest->details->drag_list,
-                0,
-                &action);
-        }
-        break;
-
-        case NAUTILUS_ICON_DND_NETSCAPE_URL:
-        {
-            action = nautilus_drag_default_drop_action_for_netscape_url (context);
-        }
-        break;
-
-        case NAUTILUS_ICON_DND_URI_LIST:
-        {
-            action = gdk_drag_context_get_suggested_action (context);
-        }
-        break;
-
-        case NAUTILUS_ICON_DND_TEXT:
-        case NAUTILUS_ICON_DND_RAW:
-        case NAUTILUS_ICON_DND_XDNDDIRECTSAVE:
-        {
-            action = GDK_ACTION_COPY;
-        }
-        break;
+        actions = nautilus_get_drop_actions_for_icons (drop_target,
+                                                       dest->details->drag_list);
+    }
+    else if (nautilus_content_formats_include_text (formats) ||
+             nautilus_content_formats_include_uri (formats))
+    {
+        actions = GDK_ACTION_COPY;
     }
 
-    g_free (drop_target);
-
-    return action;
+    return actions;
 }
 
 static gboolean
-drag_motion_callback (GtkWidget      *widget,
-                      GdkDragContext *context,
-                      int             x,
-                      int             y,
-                      guint32         time,
-                      gpointer        data)
+drag_motion_callback (GtkWidget *widget,
+                      GdkDrop   *drop,
+                      int        x,
+                      int        y,
+                      gpointer   data)
 {
     NautilusTreeViewDragDest *dest;
+    GdkDragAction actions;
     GtkTreePath *path;
     GtkTreePath *drop_path, *old_drop_path;
     GtkTreeViewDropPosition pos;
     GdkSurface *surface;
-    guint action;
-    gboolean res = TRUE;
 
     dest = NAUTILUS_TREE_VIEW_DRAG_DEST (data);
+    actions = 0;
 
-    gtk_tree_view_get_dest_row_at_pos (GTK_TREE_VIEW (widget),
-                                       x, y, &path, &pos);
-    if (pos == GTK_TREE_VIEW_DROP_BEFORE ||
-        pos == GTK_TREE_VIEW_DROP_AFTER)
+    gtk_tree_view_get_dest_row_at_pos (GTK_TREE_VIEW (widget), x, y, &path, &pos);
+
+    if (pos == GTK_TREE_VIEW_DROP_BEFORE || pos == GTK_TREE_VIEW_DROP_AFTER)
     {
         gtk_tree_path_free (path);
         path = NULL;
     }
 
-    if (!dest->details->have_drag_data)
-    {
-        res = get_drag_data (dest, context, time);
-    }
+    dest->details->drop_x = x;
+    dest->details->drop_y = y;
 
-    if (!res)
+    if (!dest->details->have_drag_data && !get_drag_data (dest, drop))
     {
         return FALSE;
     }
 
-    drop_path = get_drop_path (dest, path);
+    drop_path = get_drop_path (dest, path, drop);
 
-    action = 0;
     surface = gtk_widget_get_surface (widget);
     if (surface != NULL)
     {
@@ -633,17 +583,17 @@ drag_motion_callback (GtkWidget      *widget,
         if (surface_y <= y)
         {
             /* ignore drags on the header */
-            action = get_drop_action (dest, context, drop_path);
+            actions = get_drop_actions (dest, drop, drop_path);
         }
     }
 
     gtk_tree_view_get_drag_dest_row (GTK_TREE_VIEW (widget), &old_drop_path,
                                      NULL);
 
-    if (action)
+    if (actions != 0)
     {
         set_drag_dest_row (dest, drop_path);
-        check_hover_expand_timer (dest, path, drop_path, old_drop_path);
+        check_hover_expand_timer (dest, path, drop_path, old_drop_path, drop);
     }
     else
     {
@@ -675,16 +625,15 @@ drag_motion_callback (GtkWidget      *widget,
                            dest->details->tree_view);
     }
 
-    gdk_drag_status (context, action, time);
+    gdk_drop_status (drop, actions);
 
     return TRUE;
 }
 
 static void
-drag_leave_callback (GtkWidget      *widget,
-                     GdkDragContext *context,
-                     guint32         time,
-                     gpointer        data)
+drag_leave_callback (GtkWidget *widget,
+                     GdkDrop   *drop,
+                     gpointer   data)
 {
     NautilusTreeViewDragDest *dest;
 
@@ -699,6 +648,7 @@ drag_leave_callback (GtkWidget      *widget,
 
 static char *
 get_drop_target_uri_at_pos (NautilusTreeViewDragDest *dest,
+                            GdkDrop                  *drop,
                             int                       x,
                             int                       y)
 {
@@ -716,9 +666,9 @@ get_drop_target_uri_at_pos (NautilusTreeViewDragDest *dest,
         path = NULL;
     }
 
-    drop_path = get_drop_path (dest, path);
+    drop_path = get_drop_path (dest, path, drop);
 
-    drop_target = get_drop_target_uri_for_path (dest, drop_path);
+    drop_target = get_drop_target_uri_for_path (dest, drop_path, drop);
 
     if (path != NULL)
     {
@@ -735,40 +685,41 @@ get_drop_target_uri_at_pos (NautilusTreeViewDragDest *dest,
 
 static void
 receive_uris (NautilusTreeViewDragDest *dest,
-              GdkDragContext           *context,
+              GdkDrop                  *drop,
               GList                    *source_uris,
               int                       x,
               int                       y)
 {
+    GdkContentFormats *formats;
     char *drop_target;
-    GdkDragAction action, real_action;
+    GdkDragAction actions;
 
-    drop_target = get_drop_target_uri_at_pos (dest, x, y);
+    formats = gdk_drop_get_formats (drop);
+    drop_target = get_drop_target_uri_at_pos (dest, drop, x, y);
     g_assert (drop_target != NULL);
 
-    real_action = gdk_drag_context_get_selected_action (context);
-
-    if (real_action == GDK_ACTION_ASK)
+    actions = gdk_drop_get_actions (drop);
+    if (!gdk_drag_action_is_unique (actions))
     {
-        action = GDK_ACTION_MOVE | GDK_ACTION_COPY | GDK_ACTION_LINK;
-        real_action = nautilus_drag_drop_action_ask (GTK_WIDGET (dest->details->tree_view), action);
+        actions = GDK_ACTION_MOVE | GDK_ACTION_COPY | GDK_ACTION_LINK;
+        actions = nautilus_drag_drop_action_ask (GTK_WIDGET (dest->details->tree_view), actions);
     }
 
     /* We only want to copy external uris */
-    if (dest->details->drag_type == NAUTILUS_ICON_DND_URI_LIST)
+    if (nautilus_content_formats_include_uri (formats) &&
+        !gdk_content_formats_contain_mime_type (formats, NAUTILUS_ICON_DND_GNOME_ICON_LIST_TYPE))
     {
-        real_action = GDK_ACTION_COPY;
+        actions = GDK_ACTION_COPY;
     }
 
-    if (real_action > 0)
+    if (actions != 0)
     {
-        if (!nautilus_drag_uris_local (drop_target, source_uris)
-            || real_action != GDK_ACTION_MOVE)
+        if (!nautilus_drag_uris_local (drop_target, source_uris) || actions != GDK_ACTION_MOVE)
         {
             g_signal_emit (dest, signals[MOVE_COPY_ITEMS], 0,
                            source_uris,
                            drop_target,
-                           real_action,
+                           actions,
                            x, y);
         }
     }
@@ -778,7 +729,7 @@ receive_uris (NautilusTreeViewDragDest *dest,
 
 static void
 receive_dropped_icons (NautilusTreeViewDragDest *dest,
-                       GdkDragContext           *context,
+                       GdkDrop                  *drop,
                        int                       x,
                        int                       y)
 {
@@ -801,14 +752,14 @@ receive_dropped_icons (NautilusTreeViewDragDest *dest,
 
     source_uris = g_list_reverse (source_uris);
 
-    receive_uris (dest, context, source_uris, x, y);
+    receive_uris (dest, drop, source_uris, x, y);
 
     g_list_free (source_uris);
 }
 
 static void
 receive_dropped_uri_list (NautilusTreeViewDragDest *dest,
-                          GdkDragContext           *context,
+                          GdkDrop                  *drop,
                           int                       x,
                           int                       y)
 {
@@ -819,13 +770,13 @@ receive_dropped_uri_list (NautilusTreeViewDragDest *dest,
         return;
     }
 
-    drop_target = get_drop_target_uri_at_pos (dest, x, y);
+    drop_target = get_drop_target_uri_at_pos (dest, drop, x, y);
     g_assert (drop_target != NULL);
 
     g_signal_emit (dest, signals[HANDLE_URI_LIST], 0,
                    (char *) gtk_selection_data_get_data (dest->details->drag_data),
                    drop_target,
-                   gdk_drag_context_get_selected_action (context),
+                   gdk_drop_get_actions (drop),
                    x, y);
 
     g_free (drop_target);
@@ -833,7 +784,7 @@ receive_dropped_uri_list (NautilusTreeViewDragDest *dest,
 
 static void
 receive_dropped_text (NautilusTreeViewDragDest *dest,
-                      GdkDragContext           *context,
+                      GdkDrop                  *drop,
                       int                       x,
                       int                       y)
 {
@@ -845,199 +796,70 @@ receive_dropped_text (NautilusTreeViewDragDest *dest,
         return;
     }
 
-    drop_target = get_drop_target_uri_at_pos (dest, x, y);
+    drop_target = get_drop_target_uri_at_pos (dest, drop, x, y);
     g_assert (drop_target != NULL);
 
     text = gtk_selection_data_get_text (dest->details->drag_data);
     g_signal_emit (dest, signals[HANDLE_TEXT], 0,
                    (char *) text, drop_target,
-                   gdk_drag_context_get_selected_action (context),
+                   gdk_drop_get_actions (drop),
                    x, y);
 
     g_free (text);
     g_free (drop_target);
 }
 
-static void
-receive_dropped_raw (NautilusTreeViewDragDest *dest,
-                     const char               *raw_data,
-                     int                       length,
-                     GdkDragContext           *context,
-                     int                       x,
-                     int                       y)
-{
-    char *drop_target;
-
-    if (!dest->details->drag_data)
-    {
-        return;
-    }
-
-    drop_target = get_drop_target_uri_at_pos (dest, x, y);
-    g_assert (drop_target != NULL);
-
-    g_signal_emit (dest, signals[HANDLE_RAW], 0,
-                   raw_data, length, drop_target,
-                   dest->details->direct_save_uri,
-                   gdk_drag_context_get_selected_action (context));
-
-    g_free (drop_target);
-}
-
-static void
-receive_dropped_netscape_url (NautilusTreeViewDragDest *dest,
-                              GdkDragContext           *context,
-                              int                       x,
-                              int                       y)
-{
-    char *drop_target;
-
-    if (!dest->details->drag_data)
-    {
-        return;
-    }
-
-    drop_target = get_drop_target_uri_at_pos (dest, x, y);
-    g_assert (drop_target != NULL);
-
-    g_signal_emit (dest, signals[HANDLE_NETSCAPE_URL], 0,
-                   (char *) gtk_selection_data_get_data (dest->details->drag_data),
-                   drop_target,
-                   gdk_drag_context_get_selected_action (context),
-                   x, y);
-
-    g_free (drop_target);
-}
-
-static gboolean
-receive_xds (NautilusTreeViewDragDest *dest,
-             GtkWidget                *widget,
-             guint32                   time,
-             GdkDragContext           *context,
-             int                       x,
-             int                       y)
-{
-    GFile *location;
-    const guchar *selection_data;
-    gint selection_format;
-    gint selection_length;
-
-    selection_data = gtk_selection_data_get_data (dest->details->drag_data);
-    selection_format = gtk_selection_data_get_format (dest->details->drag_data);
-    selection_length = gtk_selection_data_get_length (dest->details->drag_data);
-
-    if (selection_format == 8
-        && selection_length == 1
-        && selection_data[0] == 'F')
-    {
-        gtk_drag_get_data (widget, context,
-                           gdk_atom_intern (NAUTILUS_ICON_DND_RAW_TYPE,
-                                            FALSE),
-                           time);
-        return FALSE;
-    }
-    else if (selection_format == 8
-             && selection_length == 1
-             && selection_data[0] == 'S')
-    {
-        g_assert (dest->details->direct_save_uri != NULL);
-        location = g_file_new_for_uri (dest->details->direct_save_uri);
-
-        nautilus_file_changes_queue_file_added (location);
-        nautilus_file_changes_consume_changes (TRUE);
-
-        g_object_unref (location);
-    }
-    return TRUE;
-}
-
-
 static gboolean
 drag_data_received_callback (GtkWidget        *widget,
-                             GdkDragContext   *context,
-                             int               x,
-                             int               y,
+                             GdkDrop          *drop,
                              GtkSelectionData *selection_data,
-                             guint             info,
-                             guint32           time,
                              gpointer          data)
 {
     NautilusTreeViewDragDest *dest;
-    const gchar *tmp;
-    int length;
-    gboolean success, finished;
+    gboolean finished;
 
     dest = NAUTILUS_TREE_VIEW_DRAG_DEST (data);
 
     if (!dest->details->have_drag_data)
     {
+        GdkContentFormats *formats;
+
+        formats = gdk_drop_get_formats (drop);
+
         dest->details->have_drag_data = TRUE;
-        dest->details->drag_type = info;
-        dest->details->drag_data =
-            gtk_selection_data_copy (selection_data);
-        if (info == NAUTILUS_ICON_DND_GNOME_ICON_LIST)
+        dest->details->drag_data = gtk_selection_data_copy (selection_data);
+
+        if (gdk_content_formats_contain_mime_type (formats, NAUTILUS_ICON_DND_GNOME_ICON_LIST_TYPE))
         {
-            dest->details->drag_list =
-                nautilus_drag_build_selection_list (selection_data);
+            dest->details->drag_list = nautilus_drag_build_selection_list (selection_data);
         }
     }
 
     if (dest->details->drop_occurred)
     {
-        success = FALSE;
-        finished = TRUE;
-        switch (info)
-        {
-            case NAUTILUS_ICON_DND_GNOME_ICON_LIST:
-            {
-                receive_dropped_icons (dest, context, x, y);
-                success = TRUE;
-            }
-            break;
-
-            case NAUTILUS_ICON_DND_NETSCAPE_URL:
-            {
-                receive_dropped_netscape_url (dest, context, x, y);
-                success = TRUE;
-            }
-            break;
-
-            case NAUTILUS_ICON_DND_URI_LIST:
-            {
-                receive_dropped_uri_list (dest, context, x, y);
-                success = TRUE;
-            }
-            break;
-
-            case NAUTILUS_ICON_DND_TEXT:
-            {
-                receive_dropped_text (dest, context, x, y);
-                success = TRUE;
-            }
-            break;
+        GdkContentFormats *formats;
 
-            case NAUTILUS_ICON_DND_RAW:
-            {
-                length = gtk_selection_data_get_length (selection_data);
-                tmp = (const gchar *) gtk_selection_data_get_data (selection_data);
-                receive_dropped_raw (dest, tmp, length, context, x, y);
-                success = TRUE;
-            }
-            break;
+        formats = gdk_drop_get_formats (drop);
+        finished = TRUE;
 
-            case NAUTILUS_ICON_DND_XDNDDIRECTSAVE:
-            {
-                finished = receive_xds (dest, widget, time, context, x, y);
-                success = TRUE;
-            }
-            break;
+        if (gdk_content_formats_contain_mime_type (formats, NAUTILUS_ICON_DND_GNOME_ICON_LIST_TYPE))
+        {
+            receive_dropped_icons (dest, drop, dest->details->drop_x, dest->details->drop_y);
+        }
+        else if (nautilus_content_formats_include_uri (formats))
+        {
+            receive_dropped_uri_list (dest, drop, dest->details->drop_x, dest->details->drop_y);
+        }
+        else if (nautilus_content_formats_include_text (formats))
+        {
+            receive_dropped_text (dest, drop, dest->details->drop_x, dest->details->drop_y);
         }
 
         if (finished)
         {
             dest->details->drop_occurred = FALSE;
             free_drag_data (dest);
-            gtk_drag_finish (context, success, FALSE, time);
+            gdk_drop_finish (drop, gdk_drop_get_actions (drop));
         }
     }
 
@@ -1049,124 +871,29 @@ drag_data_received_callback (GtkWidget        *widget,
     return TRUE;
 }
 
-static char *
-get_direct_save_filename (GdkDragContext *context)
-{
-    guchar *prop_text;
-    gint prop_len;
-
-    if (!gdk_property_get (gdk_drag_context_get_source_window (context), gdk_atom_intern (NAUTILUS_ICON_DND_XDNDDIRECTSAVE_TYPE, FALSE),
-                           gdk_atom_intern ("text/plain", FALSE), 0, 1024, FALSE, NULL, NULL,
-                           &prop_len, &prop_text))
-    {
-        return NULL;
-    }
-
-    /* Zero-terminate the string */
-    prop_text = g_realloc (prop_text, prop_len + 1);
-    prop_text[prop_len] = '\0';
-
-    /* Verify that the file name provided by the source is valid */
-    if (*prop_text == '\0' ||
-        strchr ((const gchar *) prop_text, G_DIR_SEPARATOR) != NULL)
-    {
-        DEBUG ("Invalid filename provided by XDS drag site");
-        g_free (prop_text);
-        return NULL;
-    }
-
-    return (gchar *) prop_text;
-}
-
 static gboolean
-set_direct_save_uri (NautilusTreeViewDragDest *dest,
-                     GdkDragContext           *context,
-                     int                       x,
-                     int                       y)
-{
-    GFile *base, *child;
-    char *drop_uri;
-    char *filename, *uri;
-
-    g_assert (dest->details->direct_save_uri == NULL);
-
-    uri = NULL;
-
-    drop_uri = get_drop_target_uri_at_pos (dest, x, y);
-    if (drop_uri != NULL)
-    {
-        filename = get_direct_save_filename (context);
-        if (filename != NULL)
-        {
-            /* Resolve relative path */
-            base = g_file_new_for_uri (drop_uri);
-            child = g_file_get_child (base, filename);
-            uri = g_file_get_uri (child);
-
-            g_object_unref (base);
-            g_object_unref (child);
-
-            /* Change the property */
-            gdk_property_change (gdk_drag_context_get_source_window (context),
-                                 gdk_atom_intern (NAUTILUS_ICON_DND_XDNDDIRECTSAVE_TYPE, FALSE),
-                                 gdk_atom_intern ("text/plain", FALSE), 8,
-                                 GDK_PROP_MODE_REPLACE, (const guchar *) uri,
-                                 strlen (uri));
-
-            dest->details->direct_save_uri = uri;
-        }
-        else
-        {
-            DEBUG ("Invalid filename provided by XDS drag site");
-        }
-    }
-    else
-    {
-        DEBUG ("Could not retrieve XDS drop destination");
-    }
-
-    return uri != NULL;
-}
-
-static gboolean
-drag_drop_callback (GtkWidget      *widget,
-                    GdkDragContext *context,
-                    int             x,
-                    int             y,
-                    guint32         time,
-                    gpointer        data)
+drag_drop_callback (GtkWidget *widget,
+                    GdkDrop   *drop,
+                    int        x,
+                    int        y,
+                    gpointer   data)
 {
     NautilusTreeViewDragDest *dest;
-    guint info;
     GdkAtom target;
 
     dest = NAUTILUS_TREE_VIEW_DRAG_DEST (data);
 
-    target = gtk_drag_dest_find_target (GTK_WIDGET (dest->details->tree_view),
-                                        context,
-                                        NULL);
-    if (target == GDK_NONE)
+    target = gtk_drag_dest_find_target (GTK_WIDGET (dest->details->tree_view), drop, NULL);
+    if (target == NULL)
     {
         return FALSE;
     }
 
-    info = dest->details->drag_type;
-
-    if (info == NAUTILUS_ICON_DND_XDNDDIRECTSAVE)
-    {
-        /* We need to set this or get_drop_path will fail, and it
-         *  was unset by drag_leave_callback */
-        dest->details->have_drag_data = TRUE;
-        if (!set_direct_save_uri (dest, context, x, y))
-        {
-            return FALSE;
-        }
-        dest->details->have_drag_data = FALSE;
-    }
-
     dest->details->drop_occurred = TRUE;
+    dest->details->drop_x = x;
+    dest->details->drop_y = y;
 
-    get_drag_data (dest, context, time);
+    get_drag_data (dest, drop);
     remove_scroll_timeout (dest);
     clear_drag_dest_row (dest);
 
@@ -1267,18 +994,6 @@ nautilus_tree_view_drag_dest_class_init (NautilusTreeViewDragDestClass *class)
                       G_TYPE_POINTER,
                       G_TYPE_STRING,
                       GDK_TYPE_DRAG_ACTION);
-    signals[HANDLE_NETSCAPE_URL] =
-        g_signal_new ("handle-netscape-url",
-                      G_TYPE_FROM_CLASS (class),
-                      G_SIGNAL_RUN_LAST,
-                      G_STRUCT_OFFSET (NautilusTreeViewDragDestClass,
-                                       handle_netscape_url),
-                      NULL, NULL,
-                      g_cclosure_marshal_generic,
-                      G_TYPE_NONE, 3,
-                      G_TYPE_STRING,
-                      G_TYPE_STRING,
-                      GDK_TYPE_DRAG_ACTION);
     signals[HANDLE_URI_LIST] =
         g_signal_new ("handle-uri-list",
                       G_TYPE_FROM_CLASS (class),
@@ -1303,20 +1018,6 @@ nautilus_tree_view_drag_dest_class_init (NautilusTreeViewDragDestClass *class)
                       G_TYPE_STRING,
                       G_TYPE_STRING,
                       GDK_TYPE_DRAG_ACTION);
-    signals[HANDLE_RAW] =
-        g_signal_new ("handle-raw",
-                      G_TYPE_FROM_CLASS (class),
-                      G_SIGNAL_RUN_LAST,
-                      G_STRUCT_OFFSET (NautilusTreeViewDragDestClass,
-                                       handle_raw),
-                      NULL, NULL,
-                      g_cclosure_marshal_generic,
-                      G_TYPE_NONE, 5,
-                      G_TYPE_POINTER,
-                      G_TYPE_INT,
-                      G_TYPE_STRING,
-                      G_TYPE_STRING,
-                      GDK_TYPE_DRAG_ACTION);
     signals[HANDLE_HOVER] =
         g_signal_new ("handle-hover",
                       G_TYPE_FROM_CLASS (class),
@@ -1334,9 +1035,12 @@ nautilus_tree_view_drag_dest_class_init (NautilusTreeViewDragDestClass *class)
 NautilusTreeViewDragDest *
 nautilus_tree_view_drag_dest_new (GtkTreeView *tree_view)
 {
+    g_autoptr (GdkContentFormats) formats = NULL;
     NautilusTreeViewDragDest *dest;
-    GtkTargetList *targets;
 
+    formats = gdk_content_formats_new (drag_types, G_N_ELEMENTS (drag_types));
+    formats = gtk_content_formats_add_text_targets (formats);
+    formats = gtk_content_formats_add_uri_targets (formats);
     dest = g_object_new (NAUTILUS_TYPE_TREE_VIEW_DRAG_DEST, NULL);
 
     dest->details->tree_view = tree_view;
@@ -1344,11 +1048,8 @@ nautilus_tree_view_drag_dest_new (GtkTreeView *tree_view)
                        tree_view_weak_notify, dest);
 
     gtk_drag_dest_set (GTK_WIDGET (tree_view),
-                       0, drag_types, G_N_ELEMENTS (drag_types),
-                       GDK_ACTION_MOVE | GDK_ACTION_COPY | GDK_ACTION_LINK | GDK_ACTION_ASK);
-
-    targets = gtk_drag_dest_get_target_list (GTK_WIDGET (tree_view));
-    gtk_target_list_add_text_targets (targets, NAUTILUS_ICON_DND_TEXT);
+                       0, formats,
+                       GDK_ACTION_ALL);
 
     g_signal_connect_object (tree_view,
                              "drag-motion",
diff --git a/src/nautilus-tree-view-drag-dest.h b/src/nautilus-tree-view-drag-dest.h
index b2134c681..9ca626153 100644
--- a/src/nautilus-tree-view-drag-dest.h
+++ b/src/nautilus-tree-view-drag-dest.h
@@ -60,12 +60,6 @@ struct _NautilusTreeViewDragDestClass {
 				 GdkDragAction action,
 				 int x,
 				 int y);
-	void (* handle_netscape_url) (NautilusTreeViewDragDest *dest,
-				 const char *url,
-				 const char *target_uri,
-				 GdkDragAction action,
-				 int x,
-				 int y);
 	void (* handle_uri_list) (NautilusTreeViewDragDest *dest,
 				  const char *uri_list,
 				  const char *target_uri,
@@ -78,14 +72,6 @@ struct _NautilusTreeViewDragDestClass {
 				  GdkDragAction action,
 				  int x,
 				  int y);
-	void (* handle_raw)    (NautilusTreeViewDragDest *dest,
-				  char *raw_data,
-				  int length,
-				  const char *target_uri,
-				  const char *direct_save_uri,
-				  GdkDragAction action,
-				  int x,
-				  int y);
 	void (* handle_hover)   (NautilusTreeViewDragDest *dest,
 				 const char *target_uri);
 };
@@ -93,4 +79,4 @@ struct _NautilusTreeViewDragDestClass {
 GType                     nautilus_tree_view_drag_dest_get_type (void);
 NautilusTreeViewDragDest *nautilus_tree_view_drag_dest_new      (GtkTreeView *tree_view);
 
-G_END_DECLS
\ No newline at end of file
+G_END_DECLS
diff --git a/src/nautilus-window-slot-dnd.c b/src/nautilus-window-slot-dnd.c
index 96c5d9cc8..033961622 100644
--- a/src/nautilus-window-slot-dnd.c
+++ b/src/nautilus-window-slot-dnd.c
@@ -32,17 +32,12 @@
 
 typedef struct
 {
-    gboolean have_data;
-    gboolean have_valid_data;
-
     gboolean drop_occurred;
 
-    unsigned int info;
     union
     {
         GList *selection_list;
         GList *uri_list;
-        GtkSelectionData *selection_data;
     } data;
 
     NautilusFile *target_file;
@@ -51,6 +46,8 @@ typedef struct
 
     gboolean is_notebook;
     guint switch_location_timer;
+
+    GdkDragAction pending_actions;
 } NautilusDragSlotProxyInfo;
 
 static void
@@ -150,130 +147,33 @@ slot_proxy_remove_switch_location_timer (NautilusDragSlotProxyInfo *drag_info)
 }
 
 static gboolean
-slot_proxy_drag_motion (GtkWidget      *widget,
-                        GdkDragContext *context,
-                        int             x,
-                        int             y,
-                        unsigned int    time,
-                        gpointer        user_data)
+slot_proxy_drag_motion (GtkWidget *widget,
+                        GdkDrop   *drop,
+                        int        x,
+                        int        y,
+                        gpointer   user_data)
 {
     NautilusDragSlotProxyInfo *drag_info;
-    NautilusWindowSlot *target_slot;
-    GtkWidget *window;
-    GdkAtom target;
-    int action;
-    char *target_uri;
-    GFile *location;
-    gboolean valid_text_drag;
-    gboolean valid_xds_drag;
 
     drag_info = user_data;
 
-    action = 0;
-    valid_text_drag = FALSE;
-    valid_xds_drag = FALSE;
-
-    if (gtk_drag_get_source_widget (context) == widget)
-    {
-        goto out;
-    }
-
-    window = gtk_widget_get_toplevel (widget);
-    g_assert (NAUTILUS_IS_WINDOW (window));
-
-    if (!drag_info->have_data)
+    if (drag_info->pending_actions == 0)
     {
-        target = gtk_drag_dest_find_target (widget, context, NULL);
+        GdkAtom target;
 
-        if (target == GDK_NONE)
+        target = gtk_drag_dest_find_target (widget, drop, NULL);
+        if (target == NULL)
         {
-            goto out;
+            gdk_drop_status (drop, 0);
         }
 
-        gtk_drag_get_data (widget, context, target, time);
-    }
-
-    target_uri = NULL;
-    if (drag_info->target_file != NULL)
-    {
-        target_uri = nautilus_file_get_uri (drag_info->target_file);
+        gtk_drag_get_data (widget, drop, target);
     }
     else
     {
-        if (drag_info->target_slot != NULL)
-        {
-            target_slot = drag_info->target_slot;
-        }
-        else
-        {
-            target_slot = nautilus_window_get_active_slot (NAUTILUS_WINDOW (window));
-        }
-
-        if (target_slot != NULL)
-        {
-            location = nautilus_window_slot_get_location (target_slot);
-            target_uri = g_file_get_uri (location);
-        }
+        gdk_drop_status (drop, drag_info->pending_actions);
     }
 
-    if (target_uri != NULL)
-    {
-        NautilusFile *file;
-        NautilusDirectory *directory;
-        gboolean can;
-        file = nautilus_file_get_existing_by_uri (target_uri);
-        directory = nautilus_directory_get_for_file (file);
-        can = nautilus_file_can_write (file) && nautilus_directory_is_editable (directory);
-        nautilus_directory_unref (directory);
-        g_object_unref (file);
-        if (!can)
-        {
-            action = 0;
-            goto out;
-        }
-    }
-
-    if (drag_info->have_data &&
-        drag_info->have_valid_data)
-    {
-        if (drag_info->info == NAUTILUS_ICON_DND_GNOME_ICON_LIST)
-        {
-            nautilus_drag_default_drop_action_for_icons (context, target_uri,
-                                                         drag_info->data.selection_list,
-                                                         0,
-                                                         &action);
-        }
-        else if (drag_info->info == NAUTILUS_ICON_DND_URI_LIST)
-        {
-            action = nautilus_drag_default_drop_action_for_uri_list (context, target_uri);
-        }
-        else if (drag_info->info == NAUTILUS_ICON_DND_TEXT)
-        {
-            valid_text_drag = TRUE;
-        }
-        else if (drag_info->info == NAUTILUS_ICON_DND_XDNDDIRECTSAVE ||
-                 drag_info->info == NAUTILUS_ICON_DND_RAW)
-        {
-            valid_xds_drag = TRUE;
-        }
-    }
-
-    g_free (target_uri);
-
-out:
-    if (action != 0 || valid_text_drag || valid_xds_drag)
-    {
-        gtk_drag_highlight (widget);
-        slot_proxy_check_switch_location_timer (drag_info, widget);
-    }
-    else
-    {
-        gtk_drag_unhighlight (widget);
-        slot_proxy_remove_switch_location_timer (drag_info);
-    }
-
-    gdk_drag_status (context, action, time);
-
     return TRUE;
 }
 
@@ -289,72 +189,61 @@ drag_info_free (gpointer user_data)
 }
 
 static void
-drag_info_clear (NautilusDragSlotProxyInfo *drag_info)
+drag_info_clear (NautilusDragSlotProxyInfo *drag_info,
+                 GdkDrop                   *drop)
 {
-    slot_proxy_remove_switch_location_timer (drag_info);
+    GdkContentFormats *formats;
 
-    if (!drag_info->have_data)
-    {
-        goto out;
-    }
+    formats = gdk_drop_get_formats (drop);
 
-    if (drag_info->info == NAUTILUS_ICON_DND_GNOME_ICON_LIST)
-    {
-        nautilus_drag_destroy_selection_list (drag_info->data.selection_list);
-    }
-    else if (drag_info->info == NAUTILUS_ICON_DND_URI_LIST)
+    slot_proxy_remove_switch_location_timer (drag_info);
+
+    if (gdk_content_formats_contain_mime_type (formats, NAUTILUS_ICON_DND_GNOME_ICON_LIST_TYPE))
     {
-        g_list_free (drag_info->data.uri_list);
+        g_clear_pointer (&drag_info->data.selection_list, nautilus_drag_destroy_selection_list);
     }
-    else if (drag_info->info == NAUTILUS_ICON_DND_TEXT ||
-             drag_info->info == NAUTILUS_ICON_DND_XDNDDIRECTSAVE ||
-             drag_info->info == NAUTILUS_ICON_DND_RAW)
+    else if (nautilus_content_formats_include_uri (formats))
     {
-        if (drag_info->data.selection_data != NULL)
-        {
-            gtk_selection_data_free (drag_info->data.selection_data);
-        }
+        g_clear_pointer (&drag_info->data.uri_list, g_list_free);
     }
 
-out:
-    drag_info->have_data = FALSE;
-    drag_info->have_valid_data = FALSE;
-
     drag_info->drop_occurred = FALSE;
+    drag_info->pending_actions = 0;
 }
 
 static void
-slot_proxy_drag_leave (GtkWidget      *widget,
-                       GdkDragContext *context,
-                       unsigned int    time,
-                       gpointer        user_data)
+slot_proxy_drag_leave (GtkWidget *widget,
+                       GdkDrop   *drop,
+                       gpointer   user_data)
 {
     NautilusDragSlotProxyInfo *drag_info;
 
     drag_info = user_data;
 
     gtk_drag_unhighlight (widget);
-    drag_info_clear (drag_info);
+
+    if (!drag_info->drop_occurred)
+    {
+        drag_info_clear (drag_info, drop);
+    }
 }
 
 static gboolean
-slot_proxy_drag_drop (GtkWidget      *widget,
-                      GdkDragContext *context,
-                      int             x,
-                      int             y,
-                      unsigned int    time,
-                      gpointer        user_data)
+slot_proxy_drag_drop (GtkWidget    *widget,
+                      GdkDrop      *drop,
+                      int           x,
+                      int           y,
+                      gpointer      user_data)
 {
     GdkAtom target;
     NautilusDragSlotProxyInfo *drag_info;
 
     drag_info = user_data;
-    g_assert (!drag_info->have_data);
 
     drag_info->drop_occurred = TRUE;
 
-    target = gtk_drag_dest_find_target (widget, context, NULL);
-    gtk_drag_get_data (widget, context, target, time);
+    target = gtk_drag_dest_find_target (widget, drop, NULL);
+    gtk_drag_get_data (widget, drop, target);
 
     return TRUE;
 }
@@ -362,25 +251,16 @@ slot_proxy_drag_drop (GtkWidget      *widget,
 
 static void
 slot_proxy_handle_drop (GtkWidget                 *widget,
-                        GdkDragContext            *context,
-                        unsigned int               time,
+                        GdkDrop                   *drop,
                         NautilusDragSlotProxyInfo *drag_info)
 {
+    GdkContentFormats *formats;
     GtkWidget *window;
     NautilusWindowSlot *target_slot;
     NautilusFilesView *target_view;
-    char *target_uri;
-    GList *uri_list;
-    GFile *location;
-
-    if (!drag_info->have_data ||
-        !drag_info->have_valid_data)
-    {
-        gtk_drag_finish (context, FALSE, FALSE, time);
-        drag_info_clear (drag_info);
-        return;
-    }
+    g_autofree char *target_uri = NULL;
 
+    formats = gdk_drop_get_formats (drop);
     window = gtk_widget_get_toplevel (widget);
     g_assert (NAUTILUS_IS_WINDOW (window));
 
@@ -393,13 +273,14 @@ slot_proxy_handle_drop (GtkWidget                 *widget,
         target_slot = nautilus_window_get_active_slot (NAUTILUS_WINDOW (window));
     }
 
-    target_uri = NULL;
     if (drag_info->target_file != NULL)
     {
         target_uri = nautilus_file_get_uri (drag_info->target_file);
     }
     else if (target_slot != NULL)
     {
+        GFile *location;
+
         location = nautilus_window_slot_get_location (target_slot);
         target_uri = g_file_get_uri (location);
     }
@@ -419,88 +300,145 @@ slot_proxy_handle_drop (GtkWidget                 *widget,
 
     if (target_slot != NULL && target_view != NULL)
     {
-        if (drag_info->info == NAUTILUS_ICON_DND_GNOME_ICON_LIST)
+        if (gdk_content_formats_contain_mime_type (formats, NAUTILUS_ICON_DND_GNOME_ICON_LIST_TYPE))
         {
+            GList *uri_list;
+
             uri_list = nautilus_drag_uri_list_from_selection_list (drag_info->data.selection_list);
             g_assert (uri_list != NULL);
 
             nautilus_files_view_drop_proxy_received_uris (target_view,
                                                           uri_list,
                                                           target_uri,
-                                                          gdk_drag_context_get_selected_action (context));
+                                                          gdk_drop_get_actions (drop));
             g_list_free_full (uri_list, g_free);
         }
-        else if (drag_info->info == NAUTILUS_ICON_DND_URI_LIST)
+        else if (nautilus_content_formats_include_uri (formats))
         {
             nautilus_files_view_drop_proxy_received_uris (target_view,
                                                           drag_info->data.uri_list,
                                                           target_uri,
-                                                          gdk_drag_context_get_selected_action (context));
+                                                          gdk_drop_get_actions (drop));
         }
 
-        gtk_drag_finish (context, TRUE, FALSE, time);
+        gdk_drop_finish (drop, gdk_drop_get_actions (drop));
     }
     else
     {
-        gtk_drag_finish (context, FALSE, FALSE, time);
+        gdk_drop_finish (drop, 0);
+    }
+
+    drag_info_clear (drag_info, drop);
+}
+
+static char *
+get_target_uri (GtkWidget                 *widget,
+                NautilusDragSlotProxyInfo *drag_info)
+{
+    if (drag_info->target_file != NULL)
+    {
+        return nautilus_file_get_uri (drag_info->target_file);
     }
+    else
+    {
+        NautilusWindowSlot *target_slot;
+
+        if (drag_info->target_slot != NULL)
+        {
+            target_slot = drag_info->target_slot;
+        }
+        else
+        {
+            GtkWidget *window;
 
-    g_free (target_uri);
+            window = gtk_widget_get_toplevel (widget);
+            target_slot = nautilus_window_get_active_slot (NAUTILUS_WINDOW (window));
+        }
+
+        if (target_slot != NULL)
+        {
+            GFile *location;
+
+            location = nautilus_window_slot_get_location (target_slot);
 
-    drag_info_clear (drag_info);
+            return g_file_get_uri (location);
+        }
+    }
+
+    return NULL;
 }
 
 static void
 slot_proxy_drag_data_received (GtkWidget        *widget,
-                               GdkDragContext   *context,
-                               int               x,
-                               int               y,
+                               GdkDrop          *drop,
                                GtkSelectionData *data,
-                               unsigned int      info,
-                               unsigned int      time,
                                gpointer          user_data)
 {
     NautilusDragSlotProxyInfo *drag_info;
-    char **uris;
+    GdkContentFormats *formats;
+    g_autofree char *target_uri = NULL;
+    GdkDragAction actions;
 
     drag_info = user_data;
+    formats = gdk_drop_get_formats (drop);
+    target_uri = get_target_uri (widget, drag_info);
+    actions = 0;
 
-    g_assert (!drag_info->have_data);
-
-    drag_info->have_data = TRUE;
-    drag_info->info = info;
-
-    if (gtk_selection_data_get_length (data) < 0)
-    {
-        drag_info->have_valid_data = FALSE;
-        return;
-    }
-
-    if (info == NAUTILUS_ICON_DND_GNOME_ICON_LIST)
+    if (gdk_content_formats_contain_mime_type (formats, NAUTILUS_ICON_DND_GNOME_ICON_LIST_TYPE))
     {
         drag_info->data.selection_list = nautilus_drag_build_selection_list (data);
 
-        drag_info->have_valid_data = drag_info->data.selection_list != NULL;
+        actions = nautilus_get_drop_actions_for_icons (target_uri, drag_info->data.selection_list);
     }
-    else if (info == NAUTILUS_ICON_DND_URI_LIST)
+    else if (nautilus_content_formats_include_uri (formats))
     {
+        g_auto (GStrv) uris = NULL;
+
         uris = gtk_selection_data_get_uris (data);
-        drag_info->data.uri_list = nautilus_drag_uri_list_from_array ((const char **) uris);
-        g_strfreev (uris);
+        drag_info->data.uri_list = nautilus_drag_uri_list_from_array (uris);
 
-        drag_info->have_valid_data = drag_info->data.uri_list != NULL;
+        actions = nautilus_get_drop_actions_for_uri (target_uri);
     }
-    else if (info == NAUTILUS_ICON_DND_TEXT ||
-             info == NAUTILUS_ICON_DND_XDNDDIRECTSAVE ||
-             info == NAUTILUS_ICON_DND_RAW)
+    else if (nautilus_content_formats_include_text (formats))
     {
-        drag_info->data.selection_data = gtk_selection_data_copy (data);
-        drag_info->have_valid_data = drag_info->data.selection_data != NULL;
+        actions = GDK_ACTION_COPY;
     }
 
     if (drag_info->drop_occurred)
     {
-        slot_proxy_handle_drop (widget, context, time, drag_info);
+        slot_proxy_handle_drop (widget, drop, drag_info);
+    }
+    else
+    {
+        if (target_uri != NULL)
+        {
+            g_autoptr (NautilusFile) file = NULL;
+            g_autoptr (NautilusDirectory) directory = NULL;
+            gboolean can;
+
+            file = nautilus_file_get_existing_by_uri (target_uri);
+            directory = nautilus_directory_get_for_file (file);
+            can = nautilus_file_can_write (file) && nautilus_directory_is_editable (directory);
+            if (!can)
+            {
+                actions = 0;
+            }
+        }
+
+        if (actions != 0)
+        {
+            gtk_drag_highlight (widget);
+            slot_proxy_check_switch_location_timer (drag_info, widget);
+        }
+        else
+        {
+            gtk_drag_unhighlight (widget);
+            slot_proxy_remove_switch_location_timer (drag_info);
+        }
+
+        drag_info->pending_actions = actions;
+
+        gdk_drop_status (drop, actions);
     }
 }
 
@@ -511,13 +449,11 @@ nautilus_drag_slot_proxy_init (GtkWidget          *widget,
 {
     NautilusDragSlotProxyInfo *drag_info;
 
-    const GtkTargetEntry targets[] =
+    const char *drop_types[] =
     {
-        { NAUTILUS_ICON_DND_GNOME_ICON_LIST_TYPE, 0, NAUTILUS_ICON_DND_GNOME_ICON_LIST },
-        { NAUTILUS_ICON_DND_XDNDDIRECTSAVE_TYPE, 0, NAUTILUS_ICON_DND_XDNDDIRECTSAVE }, /* XDS Protocol Type */
-        { NAUTILUS_ICON_DND_RAW_TYPE, 0, NAUTILUS_ICON_DND_RAW }
+        NAUTILUS_ICON_DND_GNOME_ICON_LIST_TYPE,
     };
-    GtkTargetList *target_list;
+    g_autoptr (GdkContentFormats) targets = NULL;
 
     g_assert (GTK_IS_WIDGET (widget));
 
@@ -541,17 +477,16 @@ nautilus_drag_slot_proxy_init (GtkWidget          *widget,
     drag_info->widget = widget;
 
     gtk_drag_dest_set (widget, 0,
-                       NULL, 0,
+                       NULL,
                        GDK_ACTION_MOVE |
                        GDK_ACTION_COPY |
                        GDK_ACTION_LINK |
                        GDK_ACTION_ASK);
 
-    target_list = gtk_target_list_new (targets, G_N_ELEMENTS (targets));
-    gtk_target_list_add_uri_targets (target_list, NAUTILUS_ICON_DND_URI_LIST);
-    gtk_target_list_add_text_targets (target_list, NAUTILUS_ICON_DND_TEXT);
-    gtk_drag_dest_set_target_list (widget, target_list);
-    gtk_target_list_unref (target_list);
+    targets = gdk_content_formats_new (drop_types, G_N_ELEMENTS (drop_types));
+    targets = gtk_content_formats_add_uri_targets (targets);
+    targets = gtk_content_formats_add_text_targets (targets);
+    gtk_drag_dest_set_target_list (widget, targets);
 
     g_signal_connect (widget, "drag-motion",
                       G_CALLBACK (slot_proxy_drag_motion),
diff --git a/src/nautilus-window.c b/src/nautilus-window.c
index 4d88678ed..1d9459594 100644
--- a/src/nautilus-window.c
+++ b/src/nautilus-window.c
@@ -1010,7 +1010,7 @@ build_selection_list_from_gfile_list (GList *gfile_list)
 
 void
 nautilus_window_start_dnd (NautilusWindow *window,
-                           GdkDragContext *context)
+                           GdkDrag        *drag)
 {
     NautilusGtkPlacesSidebar *sidebar;
 
@@ -1018,12 +1018,12 @@ nautilus_window_start_dnd (NautilusWindow *window,
 
     sidebar = NAUTILUS_GTK_PLACES_SIDEBAR (window->places_sidebar);
 
-    nautilus_gtk_places_sidebar_set_drop_targets_visible (sidebar, TRUE, context);
+    nautilus_gtk_places_sidebar_set_drop_targets_visible (sidebar, TRUE, drag);
 }
 
 void
 nautilus_window_end_dnd (NautilusWindow *window,
-                         GdkDragContext *context)
+                         GdkDrag        *drag)
 {
     NautilusGtkPlacesSidebar *sidebar;
 
@@ -1031,33 +1031,31 @@ nautilus_window_end_dnd (NautilusWindow *window,
 
     sidebar = NAUTILUS_GTK_PLACES_SIDEBAR (window->places_sidebar);
 
-    nautilus_gtk_places_sidebar_set_drop_targets_visible (sidebar, FALSE, context);
+    nautilus_gtk_places_sidebar_set_drop_targets_visible (sidebar, FALSE, drag);
 }
 
 /* Callback used when the places sidebar needs to know the drag action to suggest */
 static GdkDragAction
 places_sidebar_drag_action_requested_cb (NautilusGtkPlacesSidebar *sidebar,
-                                         GdkDragContext           *context,
+                                         GdkDrag                  *drag,
                                          GFile                    *dest_file,
                                          GList                    *source_file_list,
                                          gpointer                  user_data)
 {
-    GList *items;
-    char *uri;
-    int action = 0;
+    GdkDragAction actions;
     NautilusDragInfo *info;
-    guint32 source_actions;
+    GList *items;
+    g_autofree char *uri = NULL;
 
-    info = nautilus_drag_get_source_data (context);
+    actions = 0;
+    info = nautilus_drag_get_source_data (drag);
     if (info != NULL)
     {
         items = info->selection_cache;
-        source_actions = info->source_actions;
     }
     else
     {
         items = build_selection_list_from_gfile_list (source_file_list);
-        source_actions = 0;
     }
     uri = g_file_get_uri (dest_file);
 
@@ -1066,7 +1064,7 @@ places_sidebar_drag_action_requested_cb (NautilusGtkPlacesSidebar *sidebar,
         goto out;
     }
 
-    nautilus_drag_default_drop_action_for_icons (context, uri, items, source_actions, &action);
+    actions = nautilus_get_drop_actions_for_icons (uri, items);
 
 out:
     if (info == NULL)
@@ -1074,9 +1072,7 @@ out:
         nautilus_drag_destroy_selection_list (items);
     }
 
-    g_free (uri);
-
-    return action;
+    return actions;
 }
 
 /* Callback used when the places sidebar needs us to pop up a menu with possible drag actions */
diff --git a/src/nautilus-window.h b/src/nautilus-window.h
index 7639d8607..d74720401 100644
--- a/src/nautilus-window.h
+++ b/src/nautilus-window.h
@@ -95,9 +95,9 @@ void nautilus_window_show_operation_notification (NautilusWindow *window,
                                                   gchar          *main_label,
                                                   GFile          *folder_to_open);
 void nautilus_window_start_dnd (NautilusWindow *window,
-                                GdkDragContext *context);
+                                GdkDrag        *context);
 void nautilus_window_end_dnd (NautilusWindow *window,
-                              GdkDragContext *context);
+                              GdkDrag        *context);
 
 void nautilus_window_search (NautilusWindow *window,
                              NautilusQuery  *query);