moving from https://github.com/perberos/mate-desktop-environment

1 files changed, 2123 insertions, 0 deletions

diff --git a/libcaja-private/caja-icon-dnd.c b/libcaja-private/caja-icon-dnd.c
new file mode 100644
index 00000000..b0e89942
--- /dev/null
+++ b/libcaja-private/caja-icon-dnd.c
@@ -0,0 +1,2123 @@
+/* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 8; tab-width: 8 -*- */
+
+/* caja-icon-dnd.c - Drag & drop handling for the icon container widget.
+
+   Copyright (C) 1999, 2000 Free Software Foundation
+   Copyright (C) 2000 Eazel, Inc.
+
+   The Mate Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Library General Public License as
+   published by the Free Software Foundation; either version 2 of the
+   License, or (at your option) any later version.
+
+   The Mate Library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Library General Public License for more details.
+
+   You should have received a copy of the GNU Library General Public
+   License along with the Mate Library; see the file COPYING.LIB.  If not,
+   write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+   Boston, MA 02111-1307, USA.
+
+   Authors: Ettore Perazzoli <[email protected]>,
+            Darin Adler <[email protected]>,
+	    Andy Hertzfeld <[email protected]>
+	    Pavel Cisler <[email protected]>
+
+
+   XDS support: Benedikt Meurer <[email protected]> (adapted by Amos Brocco <[email protected]>)
+
+*/
+
+
+#include <config.h>
+#include <math.h>
+#include "caja-icon-dnd.h"
+
+#include "caja-debug-log.h"
+#include "caja-file-dnd.h"
+#include "caja-icon-private.h"
+#include "caja-link.h"
+#include "caja-metadata.h"
+#include <eel/eel-background.h>
+#include <eel/eel-gdk-pixbuf-extensions.h>
+#include <eel/eel-glib-extensions.h>
+#include <eel/eel-mate-extensions.h>
+#include <eel/eel-graphic-effects.h>
+#include <eel/eel-gtk-extensions.h>
+#include <eel/eel-gtk-macros.h>
+#include <eel/eel-stock-dialogs.h>
+#include <eel/eel-string.h>
+#include <eel/eel-vfs-extensions.h>
+#include <gdk/gdkkeysyms.h>
+#include <gdk/gdkx.h>
+#include <gtk/gtk.h>
+#include <glib/gi18n.h>
+#include <eel/eel-canvas-rect-ellipse.h>
+#include <libcaja-private/caja-file-utilities.h>
+#include <libcaja-private/caja-file-changes-queue.h>
+#include <stdio.h>
+#include <string.h>
+
+static const GtkTargetEntry drag_types [] =
+{
+    { CAJA_ICON_DND_MATE_ICON_LIST_TYPE, 0, CAJA_ICON_DND_MATE_ICON_LIST },
+    { CAJA_ICON_DND_URI_LIST_TYPE, 0, CAJA_ICON_DND_URI_LIST },
+};
+
+static const GtkTargetEntry drop_types [] =
+{
+    { CAJA_ICON_DND_MATE_ICON_LIST_TYPE, 0, CAJA_ICON_DND_MATE_ICON_LIST },
+    /* prefer "_NETSCAPE_URL" over "text/uri-list" to satisfy web browsers. */
+    { CAJA_ICON_DND_NETSCAPE_URL_TYPE, 0, CAJA_ICON_DND_NETSCAPE_URL },
+    { CAJA_ICON_DND_URI_LIST_TYPE, 0, CAJA_ICON_DND_URI_LIST },
+    { CAJA_ICON_DND_COLOR_TYPE, 0, CAJA_ICON_DND_COLOR },
+    { CAJA_ICON_DND_BGIMAGE_TYPE, 0, CAJA_ICON_DND_BGIMAGE },
+    { CAJA_ICON_DND_KEYWORD_TYPE, 0, CAJA_ICON_DND_KEYWORD },
+    { CAJA_ICON_DND_RESET_BACKGROUND_TYPE,  0, CAJA_ICON_DND_RESET_BACKGROUND },
+    { CAJA_ICON_DND_XDNDDIRECTSAVE_TYPE, 0, CAJA_ICON_DND_XDNDDIRECTSAVE }, /* XDS Protocol Type */
+    { CAJA_ICON_DND_RAW_TYPE, 0, CAJA_ICON_DND_RAW },
+    /* Must be last: */
+    { CAJA_ICON_DND_ROOTWINDOW_DROP_TYPE,  0, CAJA_ICON_DND_ROOTWINDOW_DROP }
+};
+static void     stop_dnd_highlight         (GtkWidget      *widget);
+static void     dnd_highlight_queue_redraw (GtkWidget      *widget);
+
+static GtkTargetList *drop_types_list = NULL;
+static GtkTargetList *drop_types_list_root = NULL;
+
+static char * caja_icon_container_find_drop_target (CajaIconContainer *container,
+        GdkDragContext *context,
+        int x, int y, gboolean *icon_hit,
+        gboolean rewrite_desktop);
+
+static EelCanvasItem *
+create_selection_shadow (CajaIconContainer *container,
+                         GList *list)
+{
+    EelCanvasGroup *group;
+    EelCanvas *canvas;
+    GdkBitmap *stipple;
+    int max_x, max_y;
+    int min_x, min_y;
+    GList *p;
+    GtkAllocation allocation;
+
+    if (list == NULL)
+    {
+        return NULL;
+    }
+
+    /* if we're only dragging a single item, don't worry about the shadow */
+    if (list->next == NULL)
+    {
+        return NULL;
+    }
+
+    stipple = container->details->dnd_info->stipple;
+    g_return_val_if_fail (stipple != NULL, NULL);
+
+    canvas = EEL_CANVAS (container);
+    gtk_widget_get_allocation (GTK_WIDGET (container), &allocation);
+
+    /* Creating a big set of rectangles in the canvas can be expensive, so
+           we try to be smart and only create the maximum number of rectangles
+           that we will need, in the vertical/horizontal directions.  */
+
+    max_x = allocation.width;
+    min_x = -max_x;
+
+    max_y = allocation.height;
+    min_y = -max_y;
+
+    /* Create a group, so that it's easier to move all the items around at
+           once.  */
+    group = EEL_CANVAS_GROUP
+            (eel_canvas_item_new (EEL_CANVAS_GROUP (canvas->root),
+                                  eel_canvas_group_get_type (),
+                                  NULL));
+
+    for (p = list; p != NULL; p = p->next)
+    {
+        CajaDragSelectionItem *item;
+        int x1, y1, x2, y2;
+
+        item = p->data;
+
+        if (!item->got_icon_position)
+        {
+            continue;
+        }
+
+        x1 = item->icon_x;
+        y1 = item->icon_y;
+        x2 = x1 + item->icon_width;
+        y2 = y1 + item->icon_height;
+
+        if (x2 >= min_x && x1 <= max_x && y2 >= min_y && y1 <= max_y)
+            eel_canvas_item_new
+            (group,
+             eel_canvas_rect_get_type (),
+             "x1", (double) x1,
+             "y1", (double) y1,
+             "x2", (double) x2,
+             "y2", (double) y2,
+             "outline_color", "black",
+             "outline_stipple", stipple,
+             "width_pixels", 1,
+             NULL);
+    }
+
+    return EEL_CANVAS_ITEM (group);
+}
+
+/* Set the affine instead of the x and y position.
+ * Simple, and setting x and y was broken at one point.
+ */
+static void
+set_shadow_position (EelCanvasItem *shadow,
+                     double x, double y)
+{
+    eel_canvas_item_set (shadow,
+                         "x", x, "y", y,
+                         NULL);
+}
+
+
+/* Source-side handling of the drag. */
+
+/* iteration glue struct */
+typedef struct
+{
+    gpointer iterator_context;
+    CajaDragEachSelectedItemDataGet iteratee;
+    gpointer iteratee_data;
+} IconGetDataBinderContext;
+
+static void
+canvas_rect_world_to_widget (EelCanvas *canvas,
+                             EelDRect *world_rect,
+                             EelIRect *widget_rect)
+{
+    EelDRect window_rect;
+
+    eel_canvas_world_to_window (canvas,
+                                world_rect->x0, world_rect->y0,
+                                &window_rect.x0, &window_rect.y0);
+    eel_canvas_world_to_window (canvas,
+                                world_rect->x1, world_rect->y1,
+                                &window_rect.x1, &window_rect.y1);
+    widget_rect->x0 = (int) window_rect.x0 - gtk_adjustment_get_value (gtk_layout_get_hadjustment (GTK_LAYOUT (canvas)));
+    widget_rect->y0 = (int) window_rect.y0 - gtk_adjustment_get_value (gtk_layout_get_vadjustment (GTK_LAYOUT (canvas)));
+    widget_rect->x1 = (int) window_rect.x1 - gtk_adjustment_get_value (gtk_layout_get_hadjustment (GTK_LAYOUT (canvas)));
+    widget_rect->y1 = (int) window_rect.y1 - gtk_adjustment_get_value (gtk_layout_get_vadjustment (GTK_LAYOUT (canvas)));
+}
+
+static void
+canvas_widget_to_world (EelCanvas *canvas,
+                        double widget_x, double widget_y,
+                        double *world_x, double *world_y)
+{
+    eel_canvas_window_to_world (canvas,
+                                widget_x + gtk_adjustment_get_value (gtk_layout_get_hadjustment (GTK_LAYOUT (canvas))),
+                                widget_y + gtk_adjustment_get_value (gtk_layout_get_vadjustment (GTK_LAYOUT (canvas))),
+                                world_x, world_y);
+}
+
+static gboolean
+icon_get_data_binder (CajaIcon *icon, gpointer data)
+{
+    IconGetDataBinderContext *context;
+    EelDRect world_rect;
+    EelIRect widget_rect;
+    char *uri;
+    CajaIconContainer *container;
+
+    context = (IconGetDataBinderContext *)data;
+
+    g_assert (CAJA_IS_ICON_CONTAINER (context->iterator_context));
+
+    container = CAJA_ICON_CONTAINER (context->iterator_context);
+
+    world_rect = caja_icon_canvas_item_get_icon_rectangle (icon->item);
+
+    canvas_rect_world_to_widget (EEL_CANVAS (container), &world_rect, &widget_rect);
+
+    uri = caja_icon_container_get_icon_uri (container, icon);
+    if (uri == NULL)
+    {
+        g_warning ("no URI for one of the iterated icons");
+        return TRUE;
+    }
+
+    widget_rect = eel_irect_offset_by (widget_rect,
+                                       - container->details->dnd_info->drag_info.start_x,
+                                       - container->details->dnd_info->drag_info.start_y);
+
+    widget_rect = eel_irect_scale_by (widget_rect,
+                                      1 / EEL_CANVAS (container)->pixels_per_unit);
+
+    /* pass the uri, mouse-relative x/y and icon width/height */
+    context->iteratee (uri,
+                       (int) widget_rect.x0,
+                       (int) widget_rect.y0,
+                       widget_rect.x1 - widget_rect.x0,
+                       widget_rect.y1 - widget_rect.y0,
+                       context->iteratee_data);
+
+    g_free (uri);
+
+    return TRUE;
+}
+
+/* Iterate over each selected icon in a CajaIconContainer,
+ * calling each_function on each.
+ */
+static void
+caja_icon_container_each_selected_icon (CajaIconContainer *container,
+                                        gboolean (*each_function) (CajaIcon *, gpointer), gpointer data)
+{
+    GList *p;
+    CajaIcon *icon;
+
+    for (p = container->details->icons; p != NULL; p = p->next)
+    {
+        icon = p->data;
+        if (!icon->is_selected)
+        {
+            continue;
+        }
+        if (!each_function (icon, data))
+        {
+            return;
+        }
+    }
+}
+
+/* Adaptor function used with caja_icon_container_each_selected_icon
+ * to help iterate over all selected items, passing uris, x, y, w and h
+ * values to the iteratee
+ */
+static void
+each_icon_get_data_binder (CajaDragEachSelectedItemDataGet iteratee,
+                           gpointer iterator_context, gpointer data)
+{
+    IconGetDataBinderContext context;
+    CajaIconContainer *container;
+
+    g_assert (CAJA_IS_ICON_CONTAINER (iterator_context));
+    container = CAJA_ICON_CONTAINER (iterator_context);
+
+    context.iterator_context = iterator_context;
+    context.iteratee = iteratee;
+    context.iteratee_data = data;
+    caja_icon_container_each_selected_icon (container, icon_get_data_binder, &context);
+}
+
+/* Called when the data for drag&drop is needed */
+static void
+drag_data_get_callback (GtkWidget *widget,
+                        GdkDragContext *context,
+                        GtkSelectionData *selection_data,
+                        guint info,
+                        guint32 time,
+                        gpointer data)
+{
+    g_assert (widget != NULL);
+    g_assert (CAJA_IS_ICON_CONTAINER (widget));
+    g_return_if_fail (context != NULL);
+
+    /* Call common function from caja-drag that set's up
+     * the selection data in the right format. Pass it means to
+     * iterate all the selected icons.
+     */
+    caja_drag_drag_data_get (widget, context, selection_data,
+                             info, time, widget, each_icon_get_data_binder);
+}
+
+
+/* Target-side handling of the drag.  */
+
+static void
+caja_icon_container_position_shadow (CajaIconContainer *container,
+                                     int x, int y)
+{
+    EelCanvasItem *shadow;
+    double world_x, world_y;
+
+    shadow = container->details->dnd_info->shadow;
+    if (shadow == NULL)
+    {
+        return;
+    }
+
+    canvas_widget_to_world (EEL_CANVAS (container), x, y,
+                            &world_x, &world_y);
+
+    set_shadow_position (shadow, world_x, world_y);
+    eel_canvas_item_show (shadow);
+}
+
+static void
+caja_icon_container_dropped_icon_feedback (GtkWidget *widget,
+        GtkSelectionData *data,
+        int x, int y)
+{
+    CajaIconContainer *container;
+    CajaIconDndInfo *dnd_info;
+
+    container = CAJA_ICON_CONTAINER (widget);
+    dnd_info = container->details->dnd_info;
+
+    /* Delete old selection list. */
+    caja_drag_destroy_selection_list (dnd_info->drag_info.selection_list);
+    dnd_info->drag_info.selection_list = NULL;
+
+    /* Delete old shadow if any. */
+    if (dnd_info->shadow != NULL)
+    {
+        /* FIXME bugzilla.gnome.org 42484:
+         * Is a destroy really sufficient here? Who does the unref? */
+        gtk_object_destroy (GTK_OBJECT (dnd_info->shadow));
+    }
+
+    /* Build the selection list and the shadow. */
+    dnd_info->drag_info.selection_list = caja_drag_build_selection_list (data);
+    dnd_info->shadow = create_selection_shadow (container, dnd_info->drag_info.selection_list);
+    caja_icon_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 (CAJA_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)
+    {
+        caja_debug_log (FALSE, CAJA_DEBUG_LOG_DOMAIN_USER,
+                        "Invalid filename provided by XDS drag site");
+        g_free (prop_text);
+        return NULL;
+    }
+
+    return prop_text;
+}
+
+static void
+set_direct_save_uri (GtkWidget *widget, GdkDragContext *context, CajaDragInfo *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 = CAJA_ICON_DND_XDNDDIRECTSAVE;
+
+    uri = NULL;
+
+    filename = get_direct_save_filename (context);
+    drop_target = caja_icon_container_find_drop_target (CAJA_ICON_CONTAINER (widget),
+                  context, x, y, NULL, TRUE);
+
+    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_DRAWABLE (gdk_drag_context_get_source_window (context)),
+                             gdk_atom_intern (CAJA_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)
+{
+    GtkTargetList *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, CAJA_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, CAJA_ICON_DND_TEXT);
+    }
+
+    if (caja_icon_container_get_is_desktop (CAJA_ICON_CONTAINER (widget)))
+    {
+        list = drop_types_list_root;
+    }
+    else
+    {
+        list = drop_types_list;
+    }
+
+    target = gtk_drag_dest_find_target (widget, context, list);
+    if (target != GDK_NONE)
+    {
+        guint info;
+        CajaDragInfo *drag_info;
+        gboolean found;
+
+        drag_info = &(CAJA_ICON_CONTAINER (widget)->details->dnd_info->drag_info);
+
+        found = gtk_target_list_find (list, target, &info);
+        g_assert (found);
+
+        /* Don't get_data for destructive ops */
+        if ((info == CAJA_ICON_DND_ROOTWINDOW_DROP ||
+                info == CAJA_ICON_DND_XDNDDIRECTSAVE) &&
+                !drag_info->drop_occured)
+        {
+            /* 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 == CAJA_ICON_DND_XDNDDIRECTSAVE)
+            {
+                set_direct_save_uri (widget, context, drag_info, x, y);
+            }
+            gtk_drag_get_data (GTK_WIDGET (widget), context,
+                               target, time);
+        }
+    }
+}
+
+static void
+caja_icon_container_ensure_drag_data (CajaIconContainer *container,
+                                      GdkDragContext *context,
+                                      guint32 time)
+{
+    CajaIconDndInfo *dnd_info;
+
+    dnd_info = container->details->dnd_info;
+
+    if (!dnd_info->drag_info.got_drop_data_type)
+    {
+        get_data_on_first_target_we_support (GTK_WIDGET (container), context, time, 0, 0);
+    }
+}
+
+static void
+drag_end_callback (GtkWidget *widget,
+                   GdkDragContext *context,
+                   gpointer data)
+{
+    CajaIconContainer *container;
+    CajaIconDndInfo *dnd_info;
+
+    container = CAJA_ICON_CONTAINER (widget);
+    dnd_info = container->details->dnd_info;
+
+    caja_drag_destroy_selection_list (dnd_info->drag_info.selection_list);
+    dnd_info->drag_info.selection_list = NULL;
+}
+
+static CajaIcon *
+caja_icon_container_item_at (CajaIconContainer *container,
+                             int x, int y)
+{
+    GList *p;
+    int size;
+    EelDRect point;
+    EelIRect canvas_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
+     */
+
+    size = MAX (1, 1 + (1 / EEL_CANVAS (container)->pixels_per_unit));
+    point.x0 = x;
+    point.y0 = y;
+    point.x1 = x + size;
+    point.y1 = y + size;
+
+    for (p = container->details->icons; p != NULL; p = p->next)
+    {
+        CajaIcon *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 (caja_icon_canvas_item_hit_test_rectangle (icon->item, canvas_point))
+        {
+            return icon;
+        }
+    }
+
+    return NULL;
+}
+
+static char *
+get_container_uri (CajaIconContainer *container)
+{
+    char *uri;
+
+    /* get the URI associated with the container */
+    uri = NULL;
+    g_signal_emit_by_name (container, "get_container_uri", &uri);
+    return uri;
+}
+
+static gboolean
+caja_icon_container_selection_items_local (CajaIconContainer *container,
+        GList *items)
+{
+    char *container_uri_string;
+    gboolean result;
+
+    /* must have at least one item */
+    g_assert (items);
+
+    result = FALSE;
+
+    /* get the URI associated with the container */
+    container_uri_string = get_container_uri (container);
+
+    if (eel_uri_is_desktop (container_uri_string))
+    {
+        result = caja_drag_items_on_desktop (items);
+    }
+    else
+    {
+        result = caja_drag_items_local (container_uri_string, items);
+    }
+    g_free (container_uri_string);
+
+    return result;
+}
+
+static GdkDragAction
+get_background_drag_action (CajaIconContainer *container,
+                            GdkDragAction action)
+{
+    /* FIXME: This function is very FMDirectoryView specific, and
+     * should be moved out of caja-icon-dnd.c */
+    GdkDragAction valid_actions;
+
+    if (action == GDK_ACTION_ASK)
+    {
+        valid_actions = CAJA_DND_ACTION_SET_AS_FOLDER_BACKGROUND;
+        if (!eel_background_is_desktop (eel_get_widget_background (GTK_WIDGET (container))))
+        {
+            valid_actions |= CAJA_DND_ACTION_SET_AS_GLOBAL_BACKGROUND;
+        }
+
+        action = caja_drag_drop_background_ask
+                 (GTK_WIDGET (container), valid_actions);
+    }
+
+    return action;
+}
+
+static void
+receive_dropped_color (CajaIconContainer *container,
+                       int x, int y,
+                       GdkDragAction action,
+                       GtkSelectionData *data)
+{
+    action = get_background_drag_action (container, action);
+
+    if (action > 0)
+    {
+        char *uri;
+
+        uri = get_container_uri (container);
+        caja_debug_log (FALSE, CAJA_DEBUG_LOG_DOMAIN_USER,
+                        "dropped color on icon container displaying %s", uri);
+        g_free (uri);
+
+        eel_background_receive_dropped_color
+        (eel_get_widget_background (GTK_WIDGET (container)),
+         GTK_WIDGET (container),
+         action, x, y, data);
+    }
+}
+
+/* handle dropped tile images */
+static void
+receive_dropped_tile_image (CajaIconContainer *container, GdkDragAction action, GtkSelectionData *data)
+{
+    g_assert (data != NULL);
+
+    action = get_background_drag_action (container, action);
+
+    if (action > 0)
+    {
+        char *uri;
+
+        uri = get_container_uri (container);
+        caja_debug_log (FALSE, CAJA_DEBUG_LOG_DOMAIN_USER,
+                        "dropped tile image on icon container displaying %s", uri);
+        g_free (uri);
+
+        eel_background_receive_dropped_background_image
+        (eel_get_widget_background (GTK_WIDGET (container)),
+         action,
+         gtk_selection_data_get_data (data));
+    }
+}
+
+/* handle dropped keywords */
+static void
+receive_dropped_keyword (CajaIconContainer *container, const char *keyword, int x, int y)
+{
+    char *uri;
+    double world_x, world_y;
+
+    CajaIcon *drop_target_icon;
+    CajaFile *file;
+
+    g_assert (keyword != NULL);
+
+    /* find the item we hit with our drop, if any */
+    canvas_widget_to_world (EEL_CANVAS (container), x, y, &world_x, &world_y);
+    drop_target_icon = caja_icon_container_item_at (container, world_x, world_y);
+    if (drop_target_icon == NULL)
+    {
+        return;
+    }
+
+    /* FIXME bugzilla.gnome.org 42485:
+     * This does not belong in the icon code.
+     * It has to be in the file manager.
+     * The icon code has no right to deal with the file directly.
+     * But luckily there's no issue of not getting a file object,
+     * so we don't have to worry about async. issues here.
+     */
+    uri = caja_icon_container_get_icon_uri (container, drop_target_icon);
+
+    caja_debug_log (FALSE, CAJA_DEBUG_LOG_DOMAIN_USER,
+                    "dropped emblem '%s' on icon container URI: %s",
+                    keyword, uri);
+
+    file = caja_file_get_by_uri (uri);
+    g_free (uri);
+
+    caja_drag_file_receive_dropped_keyword (file, keyword);
+
+    caja_file_unref (file);
+    caja_icon_container_update_icon (container, drop_target_icon);
+}
+
+/* handle dropped url */
+static void
+receive_dropped_netscape_url (CajaIconContainer *container, const char *encoded_url, GdkDragContext *context, int x, int y)
+{
+    char *drop_target;
+
+    if (encoded_url == NULL)
+    {
+        return;
+    }
+
+    drop_target = caja_icon_container_find_drop_target (container, context, x, y, NULL, TRUE);
+
+    g_signal_emit_by_name (container, "handle_netscape_url",
+                           encoded_url,
+                           drop_target,
+                           gdk_drag_context_get_selected_action (context),
+                           x, y);
+
+    g_free (drop_target);
+}
+
+/* handle dropped uri list */
+static void
+receive_dropped_uri_list (CajaIconContainer *container, const char *uri_list, GdkDragContext *context, int x, int y)
+{
+    char *drop_target;
+
+    if (uri_list == NULL)
+    {
+        return;
+    }
+
+    drop_target = caja_icon_container_find_drop_target (container, context, x, y, NULL, TRUE);
+
+    g_signal_emit_by_name (container, "handle_uri_list",
+                           uri_list,
+                           drop_target,
+                           gdk_drag_context_get_selected_action (context),
+                           x, y);
+
+    g_free (drop_target);
+}
+
+/* handle dropped text */
+static void
+receive_dropped_text (CajaIconContainer *container, const char *text, GdkDragContext *context, int x, int y)
+{
+    char *drop_target;
+
+    if (text == NULL)
+    {
+        return;
+    }
+
+    drop_target = caja_icon_container_find_drop_target (container, context, x, y, NULL, TRUE);
+
+    g_signal_emit_by_name (container, "handle_text",
+                           text,
+                           drop_target,
+                           gdk_drag_context_get_selected_action (context),
+                           x, y);
+
+    g_free (drop_target);
+}
+
+/* handle dropped raw data */
+static void
+receive_dropped_raw (CajaIconContainer *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 = caja_icon_container_find_drop_target (container, context, x, y, NULL, TRUE);
+
+    g_signal_emit_by_name (container, "handle_raw",
+                           raw_data,
+                           length,
+                           drop_target,
+                           direct_save_uri,
+                           gdk_drag_context_get_selected_action (context),
+                           x, y);
+
+    g_free (drop_target);
+}
+
+static int
+auto_scroll_timeout_callback (gpointer data)
+{
+    CajaIconContainer *container;
+    GtkWidget *widget;
+    float x_scroll_delta, y_scroll_delta;
+    GdkRectangle exposed_area;
+    GtkAllocation allocation;
+
+    g_assert (CAJA_IS_ICON_CONTAINER (data));
+    widget = GTK_WIDGET (data);
+    container = CAJA_ICON_CONTAINER (widget);
+
+    if (container->details->dnd_info->drag_info.waiting_to_autoscroll
+            && container->details->dnd_info->drag_info.start_auto_scroll_in > eel_get_system_time())
+    {
+        /* not yet */
+        return TRUE;
+    }
+
+    container->details->dnd_info->drag_info.waiting_to_autoscroll = FALSE;
+
+    caja_drag_autoscroll_calculate_delta (widget, &x_scroll_delta, &y_scroll_delta);
+    if (x_scroll_delta == 0 && y_scroll_delta == 0)
+    {
+        /* no work */
+        return TRUE;
+    }
+
+    /* Clear the old dnd highlight frame */
+    dnd_highlight_queue_redraw (widget);
+
+    if (!caja_icon_container_scroll (container, (int)x_scroll_delta, (int)y_scroll_delta))
+    {
+        /* the scroll value got pinned to a min or max adjustment value,
+         * we ended up not scrolling
+         */
+        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);
+
+    return TRUE;
+}
+
+static void
+set_up_auto_scroll_if_needed (CajaIconContainer *container)
+{
+    caja_drag_autoscroll_start (&container->details->dnd_info->drag_info,
+                                GTK_WIDGET (container),
+                                auto_scroll_timeout_callback,
+                                container);
+}
+
+static void
+stop_auto_scroll (CajaIconContainer *container)
+{
+    caja_drag_autoscroll_stop (&container->details->dnd_info->drag_info);
+}
+
+static gboolean
+confirm_switch_to_manual_layout (CajaIconContainer *container)
+{
+#if 0
+    const char *message;
+    const char *detail;
+    GtkDialog *dialog;
+    int response;
+
+    /* FIXME bugzilla.gnome.org 40915: Use of the word "directory"
+     * makes this FMIconView specific. Move these messages into
+     * FMIconView so CajaIconContainer can be used for things
+     * that are not directories?
+     */
+    if (caja_icon_container_has_stored_icon_positions (container))
+    {
+        if (eel_g_list_exactly_one_item (container->details->dnd_info->drag_info.selection_list))
+        {
+            message = no_translate("Do you want to switch to manual layout and leave this item where you dropped it? "
+                                   "This will clobber the stored manual layout.");
+            detail = no_translate("This folder uses automatic layout.");
+        }
+        else
+        {
+            message = no_translate("Do you want to switch to manual layout and leave these items where you dropped them? "
+                                   "This will clobber the stored manual layout.");
+            detail = no_translate("This folder uses automatic layout.");
+        }
+    }
+    else
+    {
+        if (eel_g_list_exactly_one_item (container->details->dnd_info->drag_info.selection_list))
+        {
+            message = no_translate("Do you want to switch to manual layout and leave this item where you dropped it?");
+            detail = no_translate("This folder uses automatic layout.");
+        }
+        else
+        {
+            message = no_translate("Do you want to switch to manual layout and leave these items where you dropped them?");
+            detail = no_translate("This folder uses automatic layout.");
+
+        }
+    }
+
+    dialog = eel_show_yes_no_dialog (message, detail, _("Switch to Manual Layout?"),
+                                     GTK_STOCK_CANCEL,
+                                     GTK_WINDOW (gtk_widget_get_toplevel(GTK_WIDGET(container))));
+
+    response = gtk_dialog_run (dialog);
+    gtk_object_destroy (GTK_OBJECT (dialog));
+
+    return response == GTK_RESPONSE_YES;
+#else
+    return FALSE;
+#endif
+}
+
+static void
+handle_local_move (CajaIconContainer *container,
+                   double world_x, double world_y)
+{
+    GList *moved_icons, *p;
+    CajaDragSelectionItem *item;
+    CajaIcon *icon;
+    CajaFile *file;
+    char screen_string[32];
+    GdkScreen *screen;
+    time_t now;
+
+    if (container->details->auto_layout)
+    {
+        if (!confirm_switch_to_manual_layout (container))
+        {
+            return;
+        }
+        caja_icon_container_freeze_icon_positions (container);
+    }
+
+    time (&now);
+
+    /* Move and select the icons. */
+    moved_icons = NULL;
+    for (p = container->details->dnd_info->drag_info.selection_list; p != NULL; p = p->next)
+    {
+        item = p->data;
+
+        icon = caja_icon_container_get_icon_by_uri
+               (container, item->uri);
+
+        if (icon == NULL)
+        {
+            /* probably dragged from another screen.  Add it to
+             * this screen
+             */
+
+            file = caja_file_get_by_uri (item->uri);
+
+            screen = gtk_widget_get_screen (GTK_WIDGET (container));
+            g_snprintf (screen_string, sizeof (screen_string), "%d",
+                        gdk_screen_get_number (screen));
+            caja_file_set_metadata (file,
+                                    CAJA_METADATA_KEY_SCREEN,
+                                    NULL, screen_string);
+            caja_file_set_time_metadata (file,
+                                         CAJA_METADATA_KEY_ICON_POSITION_TIMESTAMP, now);
+
+            caja_icon_container_add (container, CAJA_ICON_CONTAINER_ICON_DATA (file));
+
+            icon = caja_icon_container_get_icon_by_uri
+                   (container, item->uri);
+        }
+
+        if (item->got_icon_position)
+        {
+            caja_icon_container_move_icon
+            (container, icon,
+             world_x + item->icon_x, world_y + item->icon_y,
+             icon->scale,
+             TRUE, TRUE, TRUE);
+        }
+        moved_icons = g_list_prepend (moved_icons, icon);
+    }
+    caja_icon_container_select_list_unselect_others
+    (container, moved_icons);
+    /* Might have been moved in a way that requires adjusting scroll region. */
+    caja_icon_container_update_scroll_region (container);
+    g_list_free (moved_icons);
+}
+
+static void
+handle_nonlocal_move (CajaIconContainer *container,
+                      GdkDragAction action,
+                      int x, int y,
+                      const char *target_uri,
+                      gboolean icon_hit)
+{
+    GList *source_uris, *p;
+    GArray *source_item_locations;
+    gboolean free_target_uri, is_rtl;
+    int index, item_x;
+    GtkAllocation allocation;
+
+    if (container->details->dnd_info->drag_info.selection_list == NULL)
+    {
+        return;
+    }
+
+    source_uris = NULL;
+    for (p = container->details->dnd_info->drag_info.selection_list; p != NULL; p = p->next)
+    {
+        /* do a shallow copy of all the uri strings of the copied files */
+        source_uris = g_list_prepend (source_uris, ((CajaDragSelectionItem *)p->data)->uri);
+    }
+    source_uris = g_list_reverse (source_uris);
+
+    is_rtl = caja_icon_container_is_layout_rtl (container);
+
+    source_item_locations = g_array_new (FALSE, TRUE, sizeof (GdkPoint));
+    if (!icon_hit)
+    {
+        /* Drop onto a container. Pass along the item points to allow placing
+         * the items in their same relative positions in the new container.
+         */
+        source_item_locations = g_array_set_size (source_item_locations,
+                                g_list_length (container->details->dnd_info->drag_info.selection_list));
+
+        for (index = 0, p = container->details->dnd_info->drag_info.selection_list;
+                p != NULL; index++, p = p->next)
+        {
+            item_x = ((CajaDragSelectionItem *)p->data)->icon_x;
+            if (is_rtl)
+                item_x = -item_x - ((CajaDragSelectionItem *)p->data)->icon_width;
+            g_array_index (source_item_locations, GdkPoint, index).x = item_x;
+            g_array_index (source_item_locations, GdkPoint, index).y =
+                ((CajaDragSelectionItem *)p->data)->icon_y;
+        }
+    }
+
+    free_target_uri = FALSE;
+    /* Rewrite internal desktop URIs to the normal target uri */
+    if (eel_uri_is_desktop (target_uri))
+    {
+        target_uri = caja_get_desktop_directory_uri ();
+        free_target_uri = TRUE;
+    }
+
+    if (is_rtl)
+    {
+        gtk_widget_get_allocation (GTK_WIDGET (container), &allocation);
+        x = CANVAS_WIDTH (container, allocation) - x;
+    }
+
+    /* start the copy */
+    g_signal_emit_by_name (container, "move_copy_items",
+                           source_uris,
+                           source_item_locations,
+                           target_uri,
+                           action,
+                           x, y);
+
+    if (free_target_uri)
+    {
+        g_free ((char *)target_uri);
+    }
+
+    g_list_free (source_uris);
+    g_array_free (source_item_locations, TRUE);
+}
+
+static char *
+caja_icon_container_find_drop_target (CajaIconContainer *container,
+                                      GdkDragContext *context,
+                                      int x, int y,
+                                      gboolean *icon_hit,
+                                      gboolean rewrite_desktop)
+{
+    CajaIcon *drop_target_icon;
+    double world_x, world_y;
+    CajaFile *file;
+    char *icon_uri;
+    char *container_uri;
+
+    if (icon_hit)
+    {
+        *icon_hit = FALSE;
+    }
+
+    if (!container->details->dnd_info->drag_info.got_drop_data_type)
+    {
+        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 icon view, not here. This file is not supposed to know
+     * that the target is a file.
+     */
+
+    /* Find the item we hit with our drop, if any */
+    drop_target_icon = caja_icon_container_item_at (container, world_x, world_y);
+    if (drop_target_icon != NULL)
+    {
+        icon_uri = caja_icon_container_get_icon_uri (container, drop_target_icon);
+        if (icon_uri != NULL)
+        {
+            file = caja_file_get_by_uri (icon_uri);
+
+            if (!caja_drag_can_accept_info (file,
+                                            container->details->dnd_info->drag_info.data_type,
+                                            container->details->dnd_info->drag_info.selection_list))
+            {
+                /* the item we dropped our selection on cannot accept the items,
+                 * do the same thing as if we just dropped the items on the canvas
+                 */
+                drop_target_icon = NULL;
+            }
+
+            g_free (icon_uri);
+            caja_file_unref (file);
+        }
+    }
+
+    if (drop_target_icon == NULL)
+    {
+        if (icon_hit)
+        {
+            *icon_hit = FALSE;
+        }
+
+        container_uri = get_container_uri (container);
+
+        if (rewrite_desktop &&
+                container_uri != NULL &&
+                eel_uri_is_desktop (container_uri))
+        {
+            g_free (container_uri);
+            container_uri = caja_get_desktop_directory_uri ();
+        }
+
+        return container_uri;
+    }
+
+    if (icon_hit)
+    {
+        *icon_hit = TRUE;
+    }
+    return caja_icon_container_get_icon_drop_target_uri (container, drop_target_icon);
+}
+
+static gboolean
+selection_is_image_file (GList *selection_list)
+{
+    const char *mime_type;
+    CajaDragSelectionItem *selected_item;
+    gboolean result;
+    GFile *location;
+    GFileInfo *info;
+
+    /* Make sure only one item is selected */
+    if (selection_list == NULL ||
+            selection_list->next != NULL)
+    {
+        return FALSE;
+    }
+
+    selected_item = selection_list->data;
+
+    mime_type = NULL;
+
+    location = g_file_new_for_uri (selected_item->uri);
+    info = g_file_query_info (location,
+                              G_FILE_ATTRIBUTE_STANDARD_CONTENT_TYPE,
+                              0, NULL, NULL);
+    if (info)
+    {
+        mime_type = g_file_info_get_content_type (info);
+    }
+
+    result = eel_istr_has_prefix (mime_type, "image/");
+
+    if (info)
+    {
+        g_object_unref (info);
+    }
+    g_object_unref (location);
+
+    return result;
+}
+
+
+static void
+caja_icon_container_receive_dropped_icons (CajaIconContainer *container,
+        GdkDragContext *context,
+        int x, int y)
+{
+    char *drop_target;
+    gboolean local_move_only;
+    double world_x, world_y;
+    gboolean icon_hit;
+    GdkDragAction action, real_action;
+    CajaDragSelectionItem *selected_item;
+
+    drop_target = NULL;
+
+    if (container->details->dnd_info->drag_info.selection_list == NULL)
+    {
+        return;
+    }
+
+    real_action = gdk_drag_context_get_selected_action (context);
+
+    if (real_action == GDK_ACTION_ASK)
+    {
+        /* FIXME bugzilla.gnome.org 42485: This belongs in FMDirectoryView, not here. */
+        /* Check for special case items in selection list */
+        if (caja_drag_selection_includes_special_link (container->details->dnd_info->drag_info.selection_list))
+        {
+            /* We only want to move the trash */
+            action = GDK_ACTION_MOVE;
+        }
+        else
+        {
+            action = GDK_ACTION_MOVE | GDK_ACTION_COPY | GDK_ACTION_LINK;
+
+            if (selection_is_image_file (container->details->dnd_info->drag_info.selection_list))
+            {
+                action |= CAJA_DND_ACTION_SET_AS_BACKGROUND;
+            }
+        }
+        real_action = caja_drag_drop_action_ask
+                      (GTK_WIDGET (container), action);
+    }
+
+    if (real_action == (GdkDragAction) CAJA_DND_ACTION_SET_AS_BACKGROUND)
+    {
+        selected_item = container->details->dnd_info->drag_info.selection_list->data;
+        eel_background_receive_dropped_background_image
+        (eel_get_widget_background (GTK_WIDGET (container)),
+         real_action,
+         selected_item->uri);
+        return;
+    }
+
+    if (real_action > 0)
+    {
+        eel_canvas_window_to_world (EEL_CANVAS (container),
+                                    x + gtk_adjustment_get_value (gtk_layout_get_hadjustment (GTK_LAYOUT (container))),
+                                    y + gtk_adjustment_get_value (gtk_layout_get_vadjustment (GTK_LAYOUT (container))),
+                                    &world_x, &world_y);
+
+        drop_target = caja_icon_container_find_drop_target (container,
+                      context, x, y, &icon_hit, FALSE);
+
+        local_move_only = FALSE;
+        if (!icon_hit && real_action == GDK_ACTION_MOVE)
+        {
+            /* we can just move the icon positions if the move ended up in
+             * the item's parent container
+             */
+            local_move_only = caja_icon_container_selection_items_local
+                              (container, container->details->dnd_info->drag_info.selection_list);
+        }
+
+        if (local_move_only)
+        {
+            handle_local_move (container, world_x, world_y);
+        }
+        else
+        {
+            handle_nonlocal_move (container, real_action, world_x, world_y, drop_target, icon_hit);
+        }
+    }
+
+    g_free (drop_target);
+    caja_drag_destroy_selection_list (container->details->dnd_info->drag_info.selection_list);
+    container->details->dnd_info->drag_info.selection_list = NULL;
+}
+
+static void
+caja_icon_container_get_drop_action (CajaIconContainer *container,
+                                     GdkDragContext *context,
+                                     int x, int y,
+                                     int *action)
+{
+    char *drop_target;
+    gboolean icon_hit;
+    CajaIcon *icon;
+    double world_x, world_y;
+
+    icon_hit = FALSE;
+    if (!container->details->dnd_info->drag_info.got_drop_data_type)
+    {
+        /* drag_data_received_callback didn't get called yet */
+        return;
+    }
+
+    /* find out if we're over an icon */
+    canvas_widget_to_world (EEL_CANVAS (container), x, y, &world_x, &world_y);
+
+    icon = caja_icon_container_item_at (container, world_x, world_y);
+
+    *action = 0;
+
+    /* case out on the type of object being dragged */
+    switch (container->details->dnd_info->drag_info.data_type)
+    {
+    case CAJA_ICON_DND_MATE_ICON_LIST:
+        if (container->details->dnd_info->drag_info.selection_list == NULL)
+        {
+            return;
+        }
+        drop_target = caja_icon_container_find_drop_target (container,
+                      context, x, y, &icon_hit, FALSE);
+        if (!drop_target)
+        {
+            return;
+        }
+        caja_drag_default_drop_action_for_icons (context, drop_target,
+                container->details->dnd_info->drag_info.selection_list,
+                action);
+        g_free (drop_target);
+        break;
+    case CAJA_ICON_DND_URI_LIST:
+        drop_target = caja_icon_container_find_drop_target (container,
+                      context, x, y, &icon_hit, FALSE);
+        *action = caja_drag_default_drop_action_for_uri_list (context, drop_target);
+
+        g_free (drop_target);
+        break;
+
+        /* handle emblems by setting the action if we're over an object */
+    case CAJA_ICON_DND_KEYWORD:
+        if (icon != NULL)
+        {
+            *action = gdk_drag_context_get_suggested_action (context);
+        }
+        break;
+
+    case CAJA_ICON_DND_NETSCAPE_URL:
+        *action = caja_drag_default_drop_action_for_netscape_url (context);
+        break;
+
+    case CAJA_ICON_DND_COLOR:
+    case CAJA_ICON_DND_BGIMAGE:
+    case CAJA_ICON_DND_RESET_BACKGROUND:
+    case CAJA_ICON_DND_ROOTWINDOW_DROP:
+        *action = gdk_drag_context_get_suggested_action (context);
+        break;
+
+    case CAJA_ICON_DND_TEXT:
+    case CAJA_ICON_DND_XDNDDIRECTSAVE:
+    case CAJA_ICON_DND_RAW:
+        *action = GDK_ACTION_COPY;
+        break;
+    }
+}
+
+static void
+set_drop_target (CajaIconContainer *container,
+                 CajaIcon *icon)
+{
+    CajaIcon *old_icon;
+
+    /* Check if current drop target changed, update icon drop
+     * higlight if needed.
+     */
+    old_icon = container->details->drop_target;
+    if (icon == old_icon)
+    {
+        return;
+    }
+
+    /* Remember the new drop target for the next round. */
+    container->details->drop_target = icon;
+    caja_icon_container_update_icon (container, old_icon);
+    caja_icon_container_update_icon (container, icon);
+}
+
+static void
+caja_icon_dnd_update_drop_target (CajaIconContainer *container,
+                                  GdkDragContext *context,
+                                  int x, int y)
+{
+    CajaIcon *icon;
+    CajaFile *file;
+    double world_x, world_y;
+    char *uri;
+
+    g_assert (CAJA_IS_ICON_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 = caja_icon_container_item_at (container, world_x, world_y);
+
+    /* FIXME bugzilla.gnome.org 42485:
+     * These "can_accept_items" tests need to be done by
+     * the icon view, not here. This file is not supposed to know
+     * that the target is a file.
+     */
+
+    /* Find if target icon accepts our drop. */
+    if (icon != NULL && (container->details->dnd_info->drag_info.data_type != CAJA_ICON_DND_KEYWORD))
+    {
+        uri = caja_icon_container_get_icon_uri (container, icon);
+        file = caja_file_get_by_uri (uri);
+        g_free (uri);
+
+        if (!caja_drag_can_accept_info (file,
+                                        container->details->dnd_info->drag_info.data_type,
+                                        container->details->dnd_info->drag_info.selection_list))
+        {
+            icon = NULL;
+        }
+
+        caja_file_unref (file);
+    }
+
+    set_drop_target (container, icon);
+}
+
+static void
+caja_icon_container_free_drag_data (CajaIconContainer *container)
+{
+    CajaIconDndInfo *dnd_info;
+
+    dnd_info = container->details->dnd_info;
+
+    dnd_info->drag_info.got_drop_data_type = FALSE;
+
+    if (dnd_info->shadow != NULL)
+    {
+        gtk_object_destroy (GTK_OBJECT (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;
+    }
+}
+
+static void
+drag_leave_callback (GtkWidget *widget,
+                     GdkDragContext *context,
+                     guint32 time,
+                     gpointer data)
+{
+    CajaIconDndInfo *dnd_info;
+
+    dnd_info = CAJA_ICON_CONTAINER (widget)->details->dnd_info;
+
+    if (dnd_info->shadow != NULL)
+        eel_canvas_item_hide (dnd_info->shadow);
+
+    stop_dnd_highlight (widget);
+
+    set_drop_target (CAJA_ICON_CONTAINER (widget), NULL);
+    stop_auto_scroll (CAJA_ICON_CONTAINER (widget));
+    caja_icon_container_free_drag_data(CAJA_ICON_CONTAINER (widget));
+}
+
+static void
+drag_begin_callback (GtkWidget      *widget,
+                     GdkDragContext *context,
+                     gpointer        data)
+{
+    CajaIconContainer *container;
+    GdkScreen *screen;
+    GdkColormap *colormap;
+    GdkPixmap *pixmap;
+    GdkBitmap *mask;
+    double x1, y1, x2, y2, winx, winy;
+    int x_offset, y_offset;
+    int start_x, start_y;
+    gboolean use_mask;
+
+    container = CAJA_ICON_CONTAINER (widget);
+
+    screen = gtk_widget_get_screen (widget);
+    colormap = NULL;
+    if (gdk_screen_is_composited (screen))
+    {
+        colormap = gdk_screen_get_rgba_colormap (screen);
+        if (colormap != NULL)
+        {
+            use_mask = FALSE;
+        }
+    }
+
+    /* Fall back on using the same colormap as the widget */
+    if (colormap == NULL)
+    {
+        colormap = gtk_widget_get_colormap (widget);
+        use_mask = TRUE;
+    }
+
+    start_x = container->details->dnd_info->drag_info.start_x + gtk_adjustment_get_value (gtk_layout_get_hadjustment (GTK_LAYOUT (container)));
+    start_y = container->details->dnd_info->drag_info.start_y + gtk_adjustment_get_value (gtk_layout_get_vadjustment (GTK_LAYOUT (container)));
+
+    /* create a pixmap and mask to drag with */
+    pixmap = caja_icon_canvas_item_get_image (container->details->drag_icon->item, &mask, colormap);
+
+    /* we want to drag semi-transparent pixbufs, but X is too slow dealing with
+    stippled masks, so we had to remove the code; this comment is left as a memorial
+    to it, with the hope that we get it back someday as X Windows improves */
+
+    /* compute the image's offset */
+    eel_canvas_item_get_bounds (EEL_CANVAS_ITEM (container->details->drag_icon->item),
+                                &x1, &y1, &x2, &y2);
+    eel_canvas_world_to_window (EEL_CANVAS (container),
+                                x1, y1,  &winx, &winy);
+    x_offset = start_x - winx;
+    y_offset = start_y - winy;
+
+    if (!use_mask && pixmap != NULL)
+    {
+        cairo_t *cr;
+
+        /* If composite works, make the icons partially transparent */
+        cr = gdk_cairo_create (pixmap);
+        cairo_set_operator (cr, CAIRO_OPERATOR_DEST_OUT);
+        cairo_set_source_rgba(cr, 1,0,0,0.35);
+        cairo_paint (cr);
+        cairo_destroy (cr);
+    }
+
+    gtk_drag_set_icon_pixmap (context,
+                              colormap,
+                              pixmap, (use_mask ? mask : NULL),
+                              x_offset, y_offset);
+}
+
+void
+caja_icon_dnd_begin_drag (CajaIconContainer *container,
+                          GdkDragAction actions,
+                          int button,
+                          GdkEventMotion *event,
+                          int                    start_x,
+                          int                    start_y)
+{
+    CajaIconDndInfo *dnd_info;
+    GdkDragContext *context;
+
+    g_return_if_fail (CAJA_IS_ICON_CONTAINER (container));
+    g_return_if_fail (event != NULL);
+
+    dnd_info = container->details->dnd_info;
+    g_return_if_fail (dnd_info != NULL);
+
+    /* Notice that the event is in bin_window coordinates, because of
+           the way the canvas handles events.
+    */
+    dnd_info->drag_info.start_x = start_x - gtk_adjustment_get_value (gtk_layout_get_hadjustment (GTK_LAYOUT (container)));
+    dnd_info->drag_info.start_y = start_y - gtk_adjustment_get_value (gtk_layout_get_vadjustment (GTK_LAYOUT (container)));
+
+    /* start the drag */
+    context = gtk_drag_begin (GTK_WIDGET (container),
+                              dnd_info->drag_info.target_list,
+                              actions,
+                              button,
+                              (GdkEvent *) event);
+}
+
+static gboolean
+drag_highlight_expose (GtkWidget      *widget,
+                       GdkEventExpose *event,
+                       gpointer        data)
+{
+    gint x, y, width, height;
+    GdkWindow *window;
+
+    x = gtk_adjustment_get_value (gtk_layout_get_hadjustment (GTK_LAYOUT (widget)));
+    y = gtk_adjustment_get_value (gtk_layout_get_vadjustment (GTK_LAYOUT (widget)));
+
+#if GTK_CHECK_VERSION(3, 0, 0)
+    width = gdk_window_get_width(GDK_WINDOW(gtk_widget_get_window(widget)));
+    height = gdk_window_get_height(GDK_WINDOW(gtk_widget_get_window(widget)));
+#else
+    gdk_drawable_get_size(gtk_widget_get_window(widget), &width, &height);
+#endif
+
+    window = gtk_layout_get_bin_window (GTK_LAYOUT (widget));
+
+    gtk_paint_shadow (gtk_widget_get_style (widget), window,
+                      GTK_STATE_NORMAL, GTK_SHADOW_OUT,
+                      NULL, widget, "dnd",
+                      x, y, width, height);
+
+    gdk_draw_rectangle (window,
+                        (gtk_widget_get_style(widget))->black_gc,
+                        FALSE,
+                        x, y, width - 1, height - 1);
+
+    return FALSE;
+}
+
+/* Queue a redraw of the dnd highlight rect */
+static void
+dnd_highlight_queue_redraw (GtkWidget *widget)
+{
+    CajaIconDndInfo *dnd_info;
+    int width, height;
+    GtkAllocation allocation;
+
+    dnd_info = CAJA_ICON_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)
+{
+    CajaIconDndInfo *dnd_info;
+    GtkWidget *toplevel;
+
+    dnd_info = CAJA_ICON_CONTAINER (widget)->details->dnd_info;
+
+    toplevel = gtk_widget_get_toplevel (widget);
+    if (toplevel != NULL &&
+            g_object_get_data (G_OBJECT (toplevel), "is_desktop_window"))
+    {
+        return;
+    }
+
+    if (!dnd_info->highlighted)
+    {
+        dnd_info->highlighted = TRUE;
+        g_signal_connect_after (widget, "expose_event",
+                                G_CALLBACK (drag_highlight_expose),
+                                NULL);
+        dnd_highlight_queue_redraw (widget);
+    }
+}
+
+static void
+stop_dnd_highlight (GtkWidget *widget)
+{
+    CajaIconDndInfo *dnd_info;
+
+    dnd_info = CAJA_ICON_CONTAINER (widget)->details->dnd_info;
+
+    if (dnd_info->highlighted)
+    {
+        g_signal_handlers_disconnect_by_func (widget,
+                                              drag_highlight_expose,
+                                              NULL);
+        dnd_highlight_queue_redraw (widget);
+        dnd_info->highlighted = FALSE;
+    }
+}
+
+static gboolean
+drag_motion_callback (GtkWidget *widget,
+                      GdkDragContext *context,
+                      int x, int y,
+                      guint32 time)
+{
+    int action;
+
+    caja_icon_container_ensure_drag_data (CAJA_ICON_CONTAINER (widget), context, time);
+    caja_icon_container_position_shadow (CAJA_ICON_CONTAINER (widget), x, y);
+    caja_icon_dnd_update_drop_target (CAJA_ICON_CONTAINER (widget), context, x, y);
+    set_up_auto_scroll_if_needed (CAJA_ICON_CONTAINER (widget));
+    /* Find out what the drop actions are based on our drag selection and
+     * the drop target.
+     */
+    action = 0;
+    caja_icon_container_get_drop_action (CAJA_ICON_CONTAINER (widget), context, x, y,
+                                         &action);
+    if (action != 0)
+    {
+        start_dnd_highlight (widget);
+    }
+
+    gdk_drag_status (context, action, time);
+
+    return TRUE;
+}
+
+static gboolean
+drag_drop_callback (GtkWidget *widget,
+                    GdkDragContext *context,
+                    int x,
+                    int y,
+                    guint32 time,
+                    gpointer data)
+{
+    CajaIconDndInfo *dnd_info;
+
+    dnd_info = CAJA_ICON_CONTAINER (widget)->details->dnd_info;
+
+    /* tell the drag_data_received callback that
+       the drop occured and that it can actually
+       process the actions.
+       make sure it is going to be called at least once.
+    */
+    dnd_info->drag_info.drop_occured = TRUE;
+
+    get_data_on_first_target_we_support (widget, context, time, x, y);
+
+    return TRUE;
+}
+
+void
+caja_icon_dnd_end_drag (CajaIconContainer *container)
+{
+    CajaIconDndInfo *dnd_info;
+
+    g_return_if_fail (CAJA_IS_ICON_CONTAINER (container));
+
+    dnd_info = container->details->dnd_info;
+    g_return_if_fail (dnd_info != NULL);
+    stop_auto_scroll (container);
+    /* Do nothing.
+     * Can that possibly be right?
+     */
+}
+
+/** this callback is called in 2 cases.
+    It is called upon drag_motion events to get the actual data
+    In that case, it just makes sure it gets the data.
+    It is called upon drop_drop events to execute the actual
+    actions on the received action. In that case, it actually first makes sure
+    that we have got the data then processes it.
+*/
+
+static void
+drag_data_received_callback (GtkWidget *widget,
+                             GdkDragContext *context,
+                             int x,
+                             int y,
+                             GtkSelectionData *data,
+                             guint info,
+                             guint32 time,
+                             gpointer user_data)
+{
+    CajaDragInfo *drag_info;
+    EelBackground *background;
+    char *tmp;
+    const char *tmp_raw;
+    int length;
+    gboolean success;
+
+    drag_info = &(CAJA_ICON_CONTAINER (widget)->details->dnd_info->drag_info);
+
+    drag_info->got_drop_data_type = TRUE;
+    drag_info->data_type = info;
+
+    switch (info)
+    {
+    case CAJA_ICON_DND_MATE_ICON_LIST:
+        caja_icon_container_dropped_icon_feedback (widget, data, x, y);
+        break;
+    case CAJA_ICON_DND_COLOR:
+    case CAJA_ICON_DND_BGIMAGE:
+    case CAJA_ICON_DND_KEYWORD:
+    case CAJA_ICON_DND_URI_LIST:
+    case CAJA_ICON_DND_TEXT:
+    case CAJA_ICON_DND_RESET_BACKGROUND:
+    case CAJA_ICON_DND_XDNDDIRECTSAVE:
+    case CAJA_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 CAJA_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 CAJA_ICON_DND_ROOTWINDOW_DROP:
+        /* Do nothing, this won't even happen, since we don't want to call get_data twice */
+        break;
+    }
+
+    /* this is the second use case of this callback.
+     * we have to do the actual work for the drop.
+     */
+    if (drag_info->drop_occured)
+    {
+
+        success = FALSE;
+        switch (info)
+        {
+        case CAJA_ICON_DND_MATE_ICON_LIST:
+            caja_icon_container_receive_dropped_icons
+            (CAJA_ICON_CONTAINER (widget),
+             context, x, y);
+            break;
+        case CAJA_ICON_DND_COLOR:
+            receive_dropped_color (CAJA_ICON_CONTAINER (widget),
+                                   x, y,
+                                   gdk_drag_context_get_selected_action (context),
+                                   data);
+            success = TRUE;
+            break;
+        case CAJA_ICON_DND_BGIMAGE:
+            receive_dropped_tile_image
+            (CAJA_ICON_CONTAINER (widget),
+             gdk_drag_context_get_selected_action (context),
+             data);
+            break;
+        case CAJA_ICON_DND_KEYWORD:
+            receive_dropped_keyword
+            (CAJA_ICON_CONTAINER (widget),
+             (char *) gtk_selection_data_get_data (data), x, y);
+            break;
+        case CAJA_ICON_DND_NETSCAPE_URL:
+            receive_dropped_netscape_url
+            (CAJA_ICON_CONTAINER (widget),
+             (char *) gtk_selection_data_get_data (data), context, x, y);
+            success = TRUE;
+            break;
+        case CAJA_ICON_DND_URI_LIST:
+            receive_dropped_uri_list
+            (CAJA_ICON_CONTAINER (widget),
+             (char *) gtk_selection_data_get_data (data), context, x, y);
+            success = TRUE;
+            break;
+        case CAJA_ICON_DND_TEXT:
+            tmp = gtk_selection_data_get_text (data);
+            receive_dropped_text
+            (CAJA_ICON_CONTAINER (widget),
+             (char *) tmp, context, x, y);
+            success = TRUE;
+            g_free (tmp);
+            break;
+        case CAJA_ICON_DND_RAW:
+            length = gtk_selection_data_get_length (data);
+            tmp_raw = gtk_selection_data_get_data (data);
+            receive_dropped_raw
+            (CAJA_ICON_CONTAINER (widget),
+             tmp_raw, length, drag_info->direct_save_uri,
+             context, x, y);
+            success = TRUE;
+            break;
+        case CAJA_ICON_DND_RESET_BACKGROUND:
+            background = eel_get_widget_background (widget);
+            if (background != NULL)
+            {
+                eel_background_reset (background);
+            }
+            gtk_drag_finish (context, FALSE, FALSE, time);
+            break;
+        case CAJA_ICON_DND_ROOTWINDOW_DROP:
+            /* Do nothing, everything is done by the sender */
+            break;
+        case CAJA_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 (CAJA_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)
+            {
+                GdkPoint p;
+                GFile *location;
+
+                location = g_file_new_for_uri (drag_info->direct_save_uri);
+
+                caja_file_changes_queue_file_added (location);
+                p.x = x;
+                p.y = y;
+                caja_file_changes_queue_schedule_position_set (
+                    location,
+                    p,
+                    gdk_screen_get_number (
+                        gtk_widget_get_screen (widget)));
+                g_object_unref (location);
+                caja_file_changes_consume_changes (TRUE);
+                success = TRUE;
+            }
+            break;
+        } /* CAJA_ICON_DND_XDNDDIRECTSAVE */
+        }
+        gtk_drag_finish (context, success, FALSE, time);
+
+        caja_icon_container_free_drag_data (CAJA_ICON_CONTAINER (widget));
+
+        set_drop_target (CAJA_ICON_CONTAINER (widget), NULL);
+
+        /* reinitialise it for the next dnd */
+        drag_info->drop_occured = FALSE;
+    }
+
+}
+
+void
+caja_icon_dnd_set_stipple (CajaIconContainer *container,
+                           GdkBitmap             *stipple)
+{
+    if (stipple != NULL)
+    {
+        g_object_ref (stipple);
+    }
+
+    if (container->details->dnd_info->stipple != NULL)
+    {
+        g_object_unref (container->details->dnd_info->stipple);
+    }
+
+    container->details->dnd_info->stipple = stipple;
+}
+
+void
+caja_icon_dnd_init (CajaIconContainer *container,
+                    GdkBitmap *stipple)
+{
+    GtkTargetList *targets;
+    int n_elements;
+
+    g_return_if_fail (container != NULL);
+    g_return_if_fail (CAJA_IS_ICON_CONTAINER (container));
+
+
+    container->details->dnd_info = g_new0 (CajaIconDndInfo, 1);
+    caja_drag_init (&container->details->dnd_info->drag_info,
+                    drag_types, G_N_ELEMENTS (drag_types), TRUE);
+
+    /* 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);
+    if (!caja_icon_container_get_is_desktop (container))
+    {
+        /* Don't set up rootwindow drop */
+        n_elements -= 1;
+    }
+    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, CAJA_ICON_DND_TEXT);
+
+
+    /* Messages for outgoing drag. */
+    g_signal_connect (container, "drag_begin",
+                      G_CALLBACK (drag_begin_callback), NULL);
+    g_signal_connect (container, "drag_data_get",
+                      G_CALLBACK (drag_data_get_callback), NULL);
+    g_signal_connect (container, "drag_end",
+                      G_CALLBACK (drag_end_callback), NULL);
+
+    /* Messages for incoming drag. */
+    g_signal_connect (container, "drag_data_received",
+                      G_CALLBACK (drag_data_received_callback), NULL);
+    g_signal_connect (container, "drag_motion",
+                      G_CALLBACK (drag_motion_callback), NULL);
+    g_signal_connect (container, "drag_drop",
+                      G_CALLBACK (drag_drop_callback), NULL);
+    g_signal_connect (container, "drag_leave",
+                      G_CALLBACK (drag_leave_callback), NULL);
+
+    if (stipple != NULL)
+    {
+        container->details->dnd_info->stipple = g_object_ref (stipple);
+    }
+}
+
+void
+caja_icon_dnd_fini (CajaIconContainer *container)
+{
+    g_return_if_fail (CAJA_IS_ICON_CONTAINER (container));
+
+    if (container->details->dnd_info != NULL)
+    {
+        stop_auto_scroll (container);
+
+        if (container->details->dnd_info->stipple != NULL)
+        {
+            g_object_unref (container->details->dnd_info->stipple);
+        }
+
+        caja_drag_finalize (&container->details->dnd_info->drag_info);
+        container->details->dnd_info = NULL;
+    }
+}