Adding upstream version 2.10.22.upstream/2.10.22upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 935 insertions, 0 deletions

diff --git a/app/widgets/gimpselectiondata.c b/app/widgets/gimpselectiondata.c
new file mode 100644
index 0000000..b441cc5
--- /dev/null
+++ b/app/widgets/gimpselectiondata.c
@@ -0,0 +1,935 @@
+/* GIMP - The GNU Image Manipulation Program
+ * Copyright (C) 1995-1997 Spencer Kimball and Peter Mattis
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#include "config.h"
+
+#include <string.h>
+
+#include <gegl.h>
+#include <gtk/gtk.h>
+
+#include "libgimpcolor/gimpcolor.h"
+#include "libgimpconfig/gimpconfig.h"
+
+#include "widgets-types.h"
+
+#include "core/gimp.h"
+#include "core/gimp-utils.h"
+#include "core/gimpbrush.h"
+#include "core/gimpcontainer.h"
+#include "core/gimpcurve.h"
+#include "core/gimpdatafactory.h"
+#include "core/gimpgradient.h"
+#include "core/gimpimage.h"
+#include "core/gimpimagefile.h"
+#include "core/gimpitem.h"
+#include "core/gimppalette.h"
+#include "core/gimppattern.h"
+#include "core/gimptoolinfo.h"
+
+#include "text/gimpfont.h"
+
+#include "xcf/xcf.h"
+
+#include "gimpselectiondata.h"
+
+#include "gimp-log.h"
+#include "gimp-intl.h"
+
+
+/*  local function prototypes  */
+
+static const gchar * gimp_selection_data_get_name   (GtkSelectionData *selection,
+                                                     const gchar      *strfunc);
+static GimpObject  * gimp_selection_data_get_object (GtkSelectionData *selection,
+                                                     GimpContainer    *container,
+                                                     GimpObject       *additional);
+static gchar       * gimp_unescape_uri_string       (const char       *escaped,
+                                                     int               len,
+                                                     const char       *illegal_escaped_characters,
+                                                     gboolean          ascii_must_not_be_escaped);
+
+
+/*  public functions  */
+
+void
+gimp_selection_data_set_uri_list (GtkSelectionData *selection,
+                                  GList            *uri_list)
+{
+  GList *list;
+  gchar *vals = NULL;
+
+  g_return_if_fail (selection != NULL);
+  g_return_if_fail (uri_list != NULL);
+
+  for (list = uri_list; list; list = g_list_next (list))
+    {
+      if (vals)
+        {
+          gchar *tmp = g_strconcat (vals,
+                                    list->data,
+                                    list->next ? "\n" : NULL,
+                                    NULL);
+          g_free (vals);
+          vals = tmp;
+        }
+      else
+        {
+          vals = g_strconcat (list->data,
+                              list->next ? "\n" : NULL,
+                              NULL);
+        }
+    }
+
+  gtk_selection_data_set (selection,
+                          gtk_selection_data_get_target (selection),
+                          8, (guchar *) vals, strlen (vals));
+
+  g_free (vals);
+}
+
+GList *
+gimp_selection_data_get_uri_list (GtkSelectionData *selection)
+{
+  GList       *crap_list = NULL;
+  GList       *uri_list  = NULL;
+  GList       *list;
+  gint         length;
+  const gchar *data;
+  const gchar *buffer;
+
+  g_return_val_if_fail (selection != NULL, NULL);
+
+  length = gtk_selection_data_get_length (selection);
+
+  if (gtk_selection_data_get_format (selection) != 8 || length < 1)
+    {
+      g_warning ("Received invalid file data!");
+      return NULL;
+    }
+
+  data = buffer = (const gchar *) gtk_selection_data_get_data (selection);
+
+  GIMP_LOG (DND, "raw buffer >>%s<<", buffer);
+
+  {
+    gchar name_buffer[1024];
+
+    while (*buffer && (buffer - data < length))
+      {
+        gchar *name = name_buffer;
+        gint   len  = 0;
+
+        while (len < sizeof (name_buffer) && *buffer && *buffer != '\n')
+          {
+            *name++ = *buffer++;
+            len++;
+          }
+        if (len == 0)
+          break;
+
+        if (*(name - 1) == 0xd)   /* gmc uses RETURN+NEWLINE as delimiter */
+          len--;
+
+        if (len > 2)
+          crap_list = g_list_prepend (crap_list, g_strndup (name_buffer, len));
+
+        if (*buffer)
+          buffer++;
+      }
+  }
+
+  if (! crap_list)
+    return NULL;
+
+  /*  do various checks because file drag sources send all kinds of
+   *  arbitrary crap...
+   */
+  for (list = crap_list; list; list = g_list_next (list))
+    {
+      const gchar *dnd_crap = list->data;
+      gchar       *filename;
+      gchar       *hostname;
+      gchar       *uri   = NULL;
+      GError      *error = NULL;
+
+      GIMP_LOG (DND, "trying to convert \"%s\" to an uri", dnd_crap);
+
+      filename = g_filename_from_uri (dnd_crap, &hostname, NULL);
+
+      if (filename)
+        {
+          /*  if we got a correctly encoded "file:" uri...
+           *
+           *  (for GLib < 2.4.4, this is escaped UTF-8,
+           *   for GLib > 2.4.4, this is escaped local filename encoding)
+           */
+
+          uri = g_filename_to_uri (filename, hostname, NULL);
+
+          g_free (hostname);
+          g_free (filename);
+        }
+      else if (g_file_test (dnd_crap, G_FILE_TEST_EXISTS))
+        {
+          /*  ...else if we got a valid local filename...  */
+
+          uri = g_filename_to_uri (dnd_crap, NULL, NULL);
+        }
+      else
+        {
+          /*  ...otherwise do evil things...  */
+
+          const gchar *start = dnd_crap;
+
+          if (g_str_has_prefix (dnd_crap, "file://"))
+            {
+              start += strlen ("file://");
+            }
+          else if (g_str_has_prefix (dnd_crap, "file:"))
+            {
+              start += strlen ("file:");
+            }
+
+          if (start != dnd_crap)
+            {
+              /*  try if we got a "file:" uri in the wrong encoding...
+               *
+               *  (for GLib < 2.4.4, this is escaped local filename encoding,
+               *   for GLib > 2.4.4, this is escaped UTF-8)
+               */
+              gchar *unescaped_filename;
+
+              if (strstr (dnd_crap, "%"))
+                {
+                  gchar *local_filename;
+
+                  unescaped_filename = gimp_unescape_uri_string (start, -1,
+                                                                 "/", FALSE);
+
+                  /*  check if we got a drop from an application that
+                   *  encodes file: URIs as UTF-8 (apps linked against
+                   *  GLib < 2.4.4)
+                   */
+                  local_filename = g_filename_from_utf8 (unescaped_filename,
+                                                         -1, NULL, NULL,
+                                                         NULL);
+
+                  if (local_filename)
+                    {
+                      g_free (unescaped_filename);
+                      unescaped_filename = local_filename;
+                    }
+                }
+              else
+                {
+                  unescaped_filename = g_strdup (start);
+                }
+
+              uri = g_filename_to_uri (unescaped_filename, NULL, &error);
+
+              if (! uri)
+                {
+                  gchar *escaped_filename = g_strescape (unescaped_filename,
+                                                         NULL);
+
+                  g_message (_("The filename '%s' couldn't be converted to a "
+                               "valid URI:\n\n%s"),
+                             escaped_filename,
+                             error->message ?
+                             error->message : _("Invalid UTF-8"));
+                  g_free (escaped_filename);
+                  g_clear_error (&error);
+
+                  g_free (unescaped_filename);
+                  continue;
+                }
+
+              g_free (unescaped_filename);
+            }
+          else
+            {
+              /*  otherwise try the crap passed anyway, in case it's
+               *  a "http:" or whatever uri a plug-in might handle
+               */
+              uri = g_strdup (dnd_crap);
+            }
+        }
+
+      uri_list = g_list_prepend (uri_list, uri);
+    }
+
+  g_list_free_full (crap_list, (GDestroyNotify) g_free);
+
+  return uri_list;
+}
+
+void
+gimp_selection_data_set_color (GtkSelectionData *selection,
+                               const GimpRGB    *color)
+{
+  guint16  vals[4];
+  guchar   r, g, b, a;
+
+  g_return_if_fail (selection != NULL);
+  g_return_if_fail (color != NULL);
+
+  gimp_rgba_get_uchar (color, &r, &g, &b, &a);
+
+  vals[0] = r + (r << 8);
+  vals[1] = g + (g << 8);
+  vals[2] = b + (b << 8);
+  vals[3] = a + (a << 8);
+
+  gtk_selection_data_set (selection,
+                          gtk_selection_data_get_target (selection),
+                          16, (const guchar *) vals, 8);
+}
+
+gboolean
+gimp_selection_data_get_color (GtkSelectionData *selection,
+                               GimpRGB          *color)
+{
+  const guint16 *color_vals;
+
+  g_return_val_if_fail (selection != NULL, FALSE);
+  g_return_val_if_fail (color != NULL, FALSE);
+
+  if (gtk_selection_data_get_format (selection) != 16 ||
+      gtk_selection_data_get_length (selection) != 8)
+    {
+      g_warning ("Received invalid color data!");
+      return FALSE;
+    }
+
+  color_vals = (const guint16 *) gtk_selection_data_get_data (selection);
+
+  gimp_rgba_set_uchar (color,
+                       (guchar) (color_vals[0] >> 8),
+                       (guchar) (color_vals[1] >> 8),
+                       (guchar) (color_vals[2] >> 8),
+                       (guchar) (color_vals[3] >> 8));
+
+  return TRUE;
+}
+
+void
+gimp_selection_data_set_xcf (GtkSelectionData *selection,
+                             GimpImage        *image)
+{
+  GMemoryOutputStream *output;
+
+  g_return_if_fail (selection != NULL);
+  g_return_if_fail (GIMP_IS_IMAGE (image));
+
+  output = G_MEMORY_OUTPUT_STREAM (g_memory_output_stream_new_resizable ());
+
+  xcf_save_stream (image->gimp, image, G_OUTPUT_STREAM (output), NULL,
+                   NULL, NULL);
+
+  gtk_selection_data_set (selection,
+                          gtk_selection_data_get_target (selection),
+                          8,
+                          g_memory_output_stream_get_data (output),
+                          g_memory_output_stream_get_data_size (output));
+
+  g_object_unref (output);
+}
+
+GimpImage *
+gimp_selection_data_get_xcf (GtkSelectionData *selection,
+                             Gimp             *gimp)
+{
+  GInputStream *input;
+  GimpImage    *image;
+  gsize         length;
+  const guchar *data;
+  GError       *error = NULL;
+
+  g_return_val_if_fail (GIMP_IS_GIMP (gimp), NULL);
+  g_return_val_if_fail (selection != NULL, NULL);
+
+  length = gtk_selection_data_get_length (selection);
+
+  if (gtk_selection_data_get_format (selection) != 8 || length < 1)
+    {
+      g_warning ("Received invalid data stream!");
+      return NULL;
+    }
+
+  data = gtk_selection_data_get_data (selection);
+
+  input = g_memory_input_stream_new_from_data (data, length, NULL);
+
+  image = xcf_load_stream (gimp, input, NULL, NULL, &error);
+
+  if (image)
+    {
+      /*  don't keep clipboard images in the image list  */
+      gimp_container_remove (gimp->images, GIMP_OBJECT (image));
+    }
+  else
+    {
+      g_warning ("Received invalid XCF data: %s", error->message);
+      g_clear_error (&error);
+    }
+
+  g_object_unref (input);
+
+  return image;
+}
+
+void
+gimp_selection_data_set_stream (GtkSelectionData *selection,
+                                const guchar     *stream,
+                                gsize             stream_length)
+{
+  g_return_if_fail (selection != NULL);
+  g_return_if_fail (stream != NULL);
+  g_return_if_fail (stream_length > 0);
+
+  gtk_selection_data_set (selection,
+                          gtk_selection_data_get_target (selection),
+                          8, (guchar *) stream, stream_length);
+}
+
+const guchar *
+gimp_selection_data_get_stream (GtkSelectionData *selection,
+                                gsize            *stream_length)
+{
+  gint length;
+
+  g_return_val_if_fail (selection != NULL, NULL);
+  g_return_val_if_fail (stream_length != NULL, NULL);
+
+  length = gtk_selection_data_get_length (selection);
+
+  if (gtk_selection_data_get_format (selection) != 8 || length < 1)
+    {
+      g_warning ("Received invalid data stream!");
+      return NULL;
+    }
+
+  *stream_length = length;
+
+  return (const guchar *) gtk_selection_data_get_data (selection);
+}
+
+void
+gimp_selection_data_set_curve (GtkSelectionData *selection,
+                               GimpCurve        *curve)
+{
+  gchar *str;
+
+  g_return_if_fail (selection != NULL);
+  g_return_if_fail (GIMP_IS_CURVE (curve));
+
+  str = gimp_config_serialize_to_string (GIMP_CONFIG (curve), NULL);
+
+  gtk_selection_data_set (selection,
+                          gtk_selection_data_get_target (selection),
+                          8, (guchar *) str, strlen (str));
+
+  g_free (str);
+}
+
+GimpCurve *
+gimp_selection_data_get_curve (GtkSelectionData *selection)
+{
+  GimpCurve *curve;
+  gint       length;
+  GError    *error = NULL;
+
+  g_return_val_if_fail (selection != NULL, NULL);
+
+  length = gtk_selection_data_get_length (selection);
+
+  if (gtk_selection_data_get_format (selection) != 8 || length < 1)
+    {
+      g_warning ("Received invalid curve data!");
+      return NULL;
+    }
+
+  curve = GIMP_CURVE (gimp_curve_new ("pasted curve"));
+
+  if (! gimp_config_deserialize_string (GIMP_CONFIG (curve),
+                                        (const gchar *)
+                                        gtk_selection_data_get_data (selection),
+                                        length,
+                                        NULL,
+                                        &error))
+    {
+      g_warning ("Received invalid curve data: %s", error->message);
+      g_clear_error (&error);
+      g_object_unref (curve);
+      return NULL;
+    }
+
+  return curve;
+}
+
+void
+gimp_selection_data_set_image (GtkSelectionData *selection,
+                               GimpImage        *image)
+{
+  gchar *str;
+
+  g_return_if_fail (selection != NULL);
+  g_return_if_fail (GIMP_IS_IMAGE (image));
+
+  str = g_strdup_printf ("%d:%d", gimp_get_pid (), gimp_image_get_ID (image));
+
+  gtk_selection_data_set (selection,
+                          gtk_selection_data_get_target (selection),
+                          8, (guchar *) str, strlen (str));
+
+  g_free (str);
+}
+
+GimpImage *
+gimp_selection_data_get_image (GtkSelectionData *selection,
+                               Gimp             *gimp)
+{
+  const gchar *str;
+
+  g_return_val_if_fail (GIMP_IS_GIMP (gimp), NULL);
+  g_return_val_if_fail (selection != NULL, NULL);
+
+  str = gimp_selection_data_get_name (selection, G_STRFUNC);
+
+  if (str)
+    {
+      gint pid;
+      gint ID;
+
+      if (sscanf (str, "%i:%i", &pid, &ID) == 2 &&
+          pid == gimp_get_pid ())
+        {
+          return gimp_image_get_by_ID (gimp, ID);
+        }
+    }
+
+  return NULL;
+}
+
+void
+gimp_selection_data_set_component (GtkSelectionData *selection,
+                                   GimpImage        *image,
+                                   GimpChannelType   channel)
+{
+  gchar *str;
+
+  g_return_if_fail (selection != NULL);
+  g_return_if_fail (GIMP_IS_IMAGE (image));
+
+  str = g_strdup_printf ("%d:%d:%d", gimp_get_pid (), gimp_image_get_ID (image),
+                         (gint) channel);
+
+  gtk_selection_data_set (selection,
+                          gtk_selection_data_get_target (selection),
+                          8, (guchar *) str, strlen (str));
+
+  g_free (str);
+}
+
+GimpImage *
+gimp_selection_data_get_component (GtkSelectionData *selection,
+                                   Gimp             *gimp,
+                                   GimpChannelType  *channel)
+{
+  const gchar *str;
+
+  g_return_val_if_fail (GIMP_IS_GIMP (gimp), NULL);
+  g_return_val_if_fail (selection != NULL, NULL);
+
+  if (channel)
+    *channel = 0;
+
+  str = gimp_selection_data_get_name (selection, G_STRFUNC);
+
+  if (str)
+    {
+      gint pid;
+      gint ID;
+      gint ch;
+
+      if (sscanf (str, "%i:%i:%i", &pid, &ID, &ch) == 3 &&
+          pid == gimp_get_pid ())
+        {
+          GimpImage *image = gimp_image_get_by_ID (gimp, ID);
+
+          if (image && channel)
+            *channel = ch;
+
+          return image;
+        }
+    }
+
+  return NULL;
+}
+
+void
+gimp_selection_data_set_item (GtkSelectionData *selection,
+                              GimpItem         *item)
+{
+  gchar *str;
+
+  g_return_if_fail (selection != NULL);
+  g_return_if_fail (GIMP_IS_ITEM (item));
+
+  str = g_strdup_printf ("%d:%d", gimp_get_pid (), gimp_item_get_ID (item));
+
+  gtk_selection_data_set (selection,
+                          gtk_selection_data_get_target (selection),
+                          8, (guchar *) str, strlen (str));
+
+  g_free (str);
+}
+
+GimpItem *
+gimp_selection_data_get_item (GtkSelectionData *selection,
+                              Gimp             *gimp)
+{
+  const gchar *str;
+
+  g_return_val_if_fail (GIMP_IS_GIMP (gimp), NULL);
+  g_return_val_if_fail (selection != NULL, NULL);
+
+  str = gimp_selection_data_get_name (selection, G_STRFUNC);
+
+  if (str)
+    {
+      gint pid;
+      gint ID;
+
+      if (sscanf (str, "%i:%i", &pid, &ID) == 2 &&
+          pid == gimp_get_pid ())
+        {
+          return gimp_item_get_by_ID (gimp, ID);
+        }
+    }
+
+  return NULL;
+}
+
+void
+gimp_selection_data_set_object (GtkSelectionData *selection,
+                                GimpObject       *object)
+{
+  const gchar *name;
+
+  g_return_if_fail (selection != NULL);
+  g_return_if_fail (GIMP_IS_OBJECT (object));
+
+  name = gimp_object_get_name (object);
+
+  if (name)
+    {
+      gchar *str;
+
+      str = g_strdup_printf ("%d:%p:%s", gimp_get_pid (), object, name);
+
+      gtk_selection_data_set (selection,
+                              gtk_selection_data_get_target (selection),
+                              8, (guchar *) str, strlen (str));
+
+      g_free (str);
+    }
+}
+
+GimpBrush *
+gimp_selection_data_get_brush (GtkSelectionData *selection,
+                               Gimp             *gimp)
+{
+  g_return_val_if_fail (GIMP_IS_GIMP (gimp), NULL);
+  g_return_val_if_fail (selection != NULL, NULL);
+
+  return (GimpBrush *)
+    gimp_selection_data_get_object (selection,
+                                    gimp_data_factory_get_container (gimp->brush_factory),
+                                    GIMP_OBJECT (gimp_brush_get_standard (gimp_get_user_context (gimp))));
+}
+
+GimpPattern *
+gimp_selection_data_get_pattern (GtkSelectionData *selection,
+                                 Gimp             *gimp)
+{
+  g_return_val_if_fail (GIMP_IS_GIMP (gimp), NULL);
+  g_return_val_if_fail (selection != NULL, NULL);
+
+  return (GimpPattern *)
+    gimp_selection_data_get_object (selection,
+                                    gimp_data_factory_get_container (gimp->pattern_factory),
+                                    GIMP_OBJECT (gimp_pattern_get_standard (gimp_get_user_context (gimp))));
+}
+
+GimpGradient *
+gimp_selection_data_get_gradient (GtkSelectionData *selection,
+                                  Gimp             *gimp)
+{
+  g_return_val_if_fail (GIMP_IS_GIMP (gimp), NULL);
+  g_return_val_if_fail (selection != NULL, NULL);
+
+  return (GimpGradient *)
+    gimp_selection_data_get_object (selection,
+                                    gimp_data_factory_get_container (gimp->gradient_factory),
+                                    GIMP_OBJECT (gimp_gradient_get_standard (gimp_get_user_context (gimp))));
+}
+
+GimpPalette *
+gimp_selection_data_get_palette (GtkSelectionData *selection,
+                                 Gimp             *gimp)
+{
+  g_return_val_if_fail (GIMP_IS_GIMP (gimp), NULL);
+  g_return_val_if_fail (selection != NULL, NULL);
+
+  return (GimpPalette *)
+    gimp_selection_data_get_object (selection,
+                                    gimp_data_factory_get_container (gimp->palette_factory),
+                                    GIMP_OBJECT (gimp_palette_get_standard (gimp_get_user_context (gimp))));
+}
+
+GimpFont *
+gimp_selection_data_get_font (GtkSelectionData *selection,
+                              Gimp             *gimp)
+{
+  g_return_val_if_fail (GIMP_IS_GIMP (gimp), NULL);
+  g_return_val_if_fail (selection != NULL, NULL);
+
+  return (GimpFont *)
+    gimp_selection_data_get_object (selection,
+                                    gimp_data_factory_get_container (gimp->font_factory),
+                                    GIMP_OBJECT (gimp_font_get_standard ()));
+}
+
+GimpBuffer *
+gimp_selection_data_get_buffer (GtkSelectionData *selection,
+                                Gimp             *gimp)
+{
+  g_return_val_if_fail (GIMP_IS_GIMP (gimp), NULL);
+  g_return_val_if_fail (selection != NULL, NULL);
+
+  return (GimpBuffer *)
+    gimp_selection_data_get_object (selection,
+                                    gimp->named_buffers,
+                                    GIMP_OBJECT (gimp_get_clipboard_buffer (gimp)));
+}
+
+GimpImagefile *
+gimp_selection_data_get_imagefile (GtkSelectionData *selection,
+                                   Gimp             *gimp)
+{
+  g_return_val_if_fail (GIMP_IS_GIMP (gimp), NULL);
+  g_return_val_if_fail (selection != NULL, NULL);
+
+  return (GimpImagefile *) gimp_selection_data_get_object (selection,
+                                                           gimp->documents,
+                                                           NULL);
+}
+
+GimpTemplate *
+gimp_selection_data_get_template (GtkSelectionData *selection,
+                                  Gimp             *gimp)
+{
+  g_return_val_if_fail (GIMP_IS_GIMP (gimp), NULL);
+  g_return_val_if_fail (selection != NULL, NULL);
+
+  return (GimpTemplate *) gimp_selection_data_get_object (selection,
+                                                          gimp->templates,
+                                                          NULL);
+}
+
+GimpToolItem *
+gimp_selection_data_get_tool_item (GtkSelectionData *selection,
+                                   Gimp             *gimp)
+{
+  GimpToolItem *tool_item;
+
+  g_return_val_if_fail (GIMP_IS_GIMP (gimp), NULL);
+  g_return_val_if_fail (selection != NULL, NULL);
+
+  tool_item = (GimpToolItem *)
+    gimp_selection_data_get_object (selection,
+                                    gimp->tool_info_list,
+                                    GIMP_OBJECT (gimp_tool_info_get_standard (gimp)));
+
+  if (! tool_item)
+    {
+      tool_item = (GimpToolItem *)
+        gimp_selection_data_get_object (selection,
+                                        gimp->tool_item_list,
+                                        NULL);
+    }
+
+  return tool_item;
+}
+
+
+/*  private functions  */
+
+static const gchar *
+gimp_selection_data_get_name (GtkSelectionData *selection,
+                              const gchar      *strfunc)
+{
+  const gchar *name;
+
+  if (gtk_selection_data_get_format (selection) != 8 ||
+      gtk_selection_data_get_length (selection) < 1)
+    {
+      g_warning ("%s: received invalid selection data", strfunc);
+      return NULL;
+    }
+
+  name = (const gchar *) gtk_selection_data_get_data (selection);
+
+  if (! g_utf8_validate (name, -1, NULL))
+    {
+      g_warning ("%s: received invalid selection data "
+                 "(doesn't validate as UTF-8)", strfunc);
+      return NULL;
+    }
+
+  GIMP_LOG (DND, "name = '%s'", name);
+
+  return name;
+}
+
+static GimpObject *
+gimp_selection_data_get_object (GtkSelectionData *selection,
+                                GimpContainer    *container,
+                                GimpObject       *additional)
+{
+  const gchar *str;
+
+  str = gimp_selection_data_get_name (selection, G_STRFUNC);
+
+  if (str)
+    {
+      gint     pid;
+      gpointer object_addr;
+      gint     name_offset = 0;
+
+      if (sscanf (str, "%i:%p:%n", &pid, &object_addr, &name_offset) >= 2 &&
+          pid == gimp_get_pid () && name_offset > 0)
+        {
+          const gchar *name = str + name_offset;
+
+          GIMP_LOG (DND, "pid = %d, addr = %p, name = '%s'",
+                    pid, object_addr, name);
+
+          if (additional &&
+              strcmp (name, gimp_object_get_name (additional)) == 0 &&
+              object_addr == (gpointer) additional)
+            {
+              return additional;
+            }
+          else
+            {
+              GimpObject *object;
+
+              object = gimp_container_get_child_by_name (container, name);
+
+              if (object_addr == (gpointer) object)
+                return object;
+            }
+        }
+    }
+
+  return NULL;
+}
+
+/*  the next two functions are straight cut'n'paste from glib/glib/gconvert.c,
+ *  except that gimp_unescape_uri_string() does not try to UTF-8 validate
+ *  the unescaped result.
+ */
+static int
+unescape_character (const char *scanner)
+{
+  int first_digit;
+  int second_digit;
+
+  first_digit = g_ascii_xdigit_value (scanner[0]);
+  if (first_digit < 0)
+    return -1;
+
+  second_digit = g_ascii_xdigit_value (scanner[1]);
+  if (second_digit < 0)
+    return -1;
+
+  return (first_digit << 4) | second_digit;
+}
+
+static gchar *
+gimp_unescape_uri_string (const char *escaped,
+                          int         len,
+                          const char *illegal_escaped_characters,
+                          gboolean    ascii_must_not_be_escaped)
+{
+  const gchar *inp, *in_end;
+  gchar *out, *result;
+  int c;
+
+  if (escaped == NULL)
+    return NULL;
+
+  if (len < 0)
+    len = strlen (escaped);
+
+  result = g_malloc (len + 1);
+
+  out = result;
+  for (inp = escaped, in_end = escaped + len; inp < in_end; inp++)
+    {
+      c = *inp;
+
+      if (c == '%')
+        {
+          /* catch partial escape sequences past the end of the substring */
+          if (inp + 3 > in_end)
+            break;
+
+          c = unescape_character (inp + 1);
+
+          /* catch bad escape sequences and NUL characters */
+          if (c <= 0)
+            break;
+
+          /* catch escaped ASCII */
+          if (ascii_must_not_be_escaped && c <= 0x7F)
+            break;
+
+          /* catch other illegal escaped characters */
+          if (strchr (illegal_escaped_characters, c) != NULL)
+            break;
+
+          inp += 2;
+        }
+
+      *out++ = c;
+    }
+
+  gimp_assert (out - result <= len);
+  *out = '\0';
+
+  if (inp != in_end)
+    {
+      g_free (result);
+      return NULL;
+    }
+
+  return result;
+}