Adding upstream version 2.10.34.upstream/2.10.34upstream

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

1 files changed, 877 insertions, 0 deletions

diff --git a/app/core/gimpimageproxy.c b/app/core/gimpimageproxy.c
new file mode 100644
index 0000000..6007d6c
--- /dev/null
+++ b/app/core/gimpimageproxy.c
@@ -0,0 +1,877 @@
+/* GIMP - The GNU Image Manipulation Program
+ * Copyright (C) 1995 Spencer Kimball and Peter Mattis
+ *
+ * gimpimageproxy.c
+ * Copyright (C) 2019 Ell
+ *
+ * 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 <cairo.h>
+#include <gdk-pixbuf/gdk-pixbuf.h>
+#include <gegl.h>
+
+#include "libgimpcolor/gimpcolor.h"
+
+#include "core-types.h"
+
+#include "gegl/gimp-babl.h"
+#include "gegl/gimp-gegl-loops.h"
+
+#include "gimpimage.h"
+#include "gimpimage-color-profile.h"
+#include "gimpimage-preview.h"
+#include "gimpimageproxy.h"
+#include "gimppickable.h"
+#include "gimpprojectable.h"
+#include "gimptempbuf.h"
+
+
+enum
+{
+  PROP_0,
+  PROP_IMAGE,
+  PROP_SHOW_ALL,
+  PROP_BUFFER
+};
+
+
+struct _GimpImageProxyPrivate
+{
+  GimpImage     *image;
+  gboolean       show_all;
+
+  GeglRectangle  bounding_box;
+  gboolean       frozen;
+};
+
+
+/*  local function prototypes  */
+
+static void               gimp_image_proxy_pickable_iface_init      (GimpPickableInterface      *iface);
+static void               gimp_image_proxy_color_managed_iface_init (GimpColorManagedInterface  *iface);
+
+static void               gimp_image_proxy_finalize                 (GObject                    *object);
+static void               gimp_image_proxy_set_property             (GObject                    *object,
+                                                                     guint                       property_id,
+                                                                     const GValue               *value,
+                                                                     GParamSpec                 *pspec);
+static void               gimp_image_proxy_get_property             (GObject                    *object,
+                                                                     guint                       property_id,
+                                                                     GValue                     *value,
+                                                                     GParamSpec                 *pspec);
+
+static gboolean           gimp_image_proxy_get_size                 (GimpViewable               *viewable,
+                                                                     gint                       *width,
+                                                                     gint                       *height);
+static void               gimp_image_proxy_get_preview_size         (GimpViewable               *viewable,
+                                                                     gint                        size,
+                                                                     gboolean                    is_popup,
+                                                                     gboolean                    dot_for_dot,
+                                                                     gint                       *width,
+                                                                     gint                       *height);
+static gboolean           gimp_image_proxy_get_popup_size           (GimpViewable               *viewable,
+                                                                     gint                        width,
+                                                                     gint                        height,
+                                                                     gboolean                    dot_for_dot,
+                                                                     gint                       *popup_width,
+                                                                     gint                       *popup_height);
+static GimpTempBuf      * gimp_image_proxy_get_new_preview          (GimpViewable               *viewable,
+                                                                     GimpContext                *context,
+                                                                     gint                        width,
+                                                                     gint                        height);
+static GdkPixbuf        * gimp_image_proxy_get_new_pixbuf           (GimpViewable               *viewable,
+                                                                     GimpContext                *context,
+                                                                     gint                        width,
+                                                                     gint                        height);
+static gchar            * gimp_image_proxy_get_description          (GimpViewable               *viewable,
+                                                                     gchar                     **tooltip);
+
+static void               gimp_image_proxy_flush                    (GimpPickable               *pickable);
+static const Babl       * gimp_image_proxy_get_format               (GimpPickable               *pickable);
+static const Babl       * gimp_image_proxy_get_format_with_alpha    (GimpPickable               *pickable);
+static GeglBuffer       * gimp_image_proxy_get_buffer               (GimpPickable               *pickable);
+static gboolean           gimp_image_proxy_get_pixel_at             (GimpPickable               *pickable,
+                                                                     gint                        x,
+                                                                     gint                        y,
+                                                                     const Babl                 *format,
+                                                                     gpointer                    pixel);
+static gdouble            gimp_image_proxy_get_opacity_at           (GimpPickable               *pickable,
+                                                                     gint                        x,
+                                                                     gint                        y);
+static void               gimp_image_proxy_get_pixel_average        (GimpPickable               *pickable,
+                                                                     const GeglRectangle        *rect,
+                                                                     const Babl                 *format,
+                                                                     gpointer                    pixel);
+static void               gimp_image_proxy_pixel_to_srgb            (GimpPickable               *pickable,
+                                                                     const Babl                 *format,
+                                                                     gpointer                    pixel,
+                                                                     GimpRGB                    *color);
+static void               gimp_image_proxy_srgb_to_pixel            (GimpPickable               *pickable,
+                                                                     const GimpRGB              *color,
+                                                                     const Babl                 *format,
+                                                                     gpointer                    pixel);
+
+static const guint8     * gimp_image_proxy_get_icc_profile          (GimpColorManaged           *managed,
+                                                                     gsize                      *len);
+static GimpColorProfile * gimp_image_proxy_get_color_profile        (GimpColorManaged           *managed);
+static void               gimp_image_proxy_profile_changed          (GimpColorManaged           *managed);
+
+static void               gimp_image_proxy_image_frozen_notify      (GimpImage                  *image,
+                                                                     const GParamSpec           *pspec,
+                                                                     GimpImageProxy             *image_proxy);
+static void               gimp_image_proxy_image_invalidate_preview (GimpImage                  *image,
+                                                                     GimpImageProxy             *image_proxy);
+static void               gimp_image_proxy_image_size_changed       (GimpImage                  *image,
+                                                                     GimpImageProxy             *image_proxy);
+static void               gimp_image_proxy_image_bounds_changed     (GimpImage                  *image,
+                                                                     gint                        old_x,
+                                                                     gint                        old_y,
+                                                                     GimpImageProxy             *image_proxy);
+static void               gimp_image_proxy_image_profile_changed    (GimpImage                  *image,
+                                                                     GimpImageProxy             *image_proxy);
+
+static void               gimp_image_proxy_set_image                (GimpImageProxy             *image_proxy,
+                                                                     GimpImage                  *image);
+static GimpPickable     * gimp_image_proxy_get_pickable             (GimpImageProxy             *image_proxy);
+static void               gimp_image_proxy_update_bounding_box      (GimpImageProxy             *image_proxy);
+static void               gimp_image_proxy_update_frozen            (GimpImageProxy             *image_proxy);
+
+
+G_DEFINE_TYPE_WITH_CODE (GimpImageProxy, gimp_image_proxy, GIMP_TYPE_VIEWABLE,
+                         G_ADD_PRIVATE (GimpImageProxy)
+                         G_IMPLEMENT_INTERFACE (GIMP_TYPE_PICKABLE,
+                                                gimp_image_proxy_pickable_iface_init)
+                         G_IMPLEMENT_INTERFACE (GIMP_TYPE_COLOR_MANAGED,
+                                                gimp_image_proxy_color_managed_iface_init))
+
+#define parent_class gimp_image_proxy_parent_class
+
+
+/*  private functions  */
+
+
+static void
+gimp_image_proxy_class_init (GimpImageProxyClass *klass)
+{
+  GObjectClass      *object_class   = G_OBJECT_CLASS (klass);
+  GimpViewableClass *viewable_class = GIMP_VIEWABLE_CLASS (klass);
+
+  object_class->finalize            = gimp_image_proxy_finalize;
+  object_class->set_property        = gimp_image_proxy_set_property;
+  object_class->get_property        = gimp_image_proxy_get_property;
+
+  viewable_class->default_icon_name = "gimp-image";
+  viewable_class->get_size          = gimp_image_proxy_get_size;
+  viewable_class->get_preview_size  = gimp_image_proxy_get_preview_size;
+  viewable_class->get_popup_size    = gimp_image_proxy_get_popup_size;
+  viewable_class->get_new_preview   = gimp_image_proxy_get_new_preview;
+  viewable_class->get_new_pixbuf    = gimp_image_proxy_get_new_pixbuf;
+  viewable_class->get_description   = gimp_image_proxy_get_description;
+
+  g_object_class_install_property (object_class, PROP_IMAGE,
+                                   g_param_spec_object ("image",
+                                                        NULL, NULL,
+                                                        GIMP_TYPE_IMAGE,
+                                                        GIMP_PARAM_READWRITE |
+                                                        G_PARAM_CONSTRUCT_ONLY));
+
+  g_object_class_install_property (object_class, PROP_SHOW_ALL,
+                                   g_param_spec_boolean ("show-all",
+                                                         NULL, NULL,
+                                                         FALSE,
+                                                         GIMP_PARAM_READWRITE |
+                                                         G_PARAM_CONSTRUCT));
+
+  g_object_class_override_property (object_class, PROP_BUFFER, "buffer");
+}
+
+static void
+gimp_image_proxy_pickable_iface_init (GimpPickableInterface *iface)
+{
+  iface->flush                 = gimp_image_proxy_flush;
+  iface->get_image             = (gpointer) gimp_image_proxy_get_image;
+  iface->get_format            = gimp_image_proxy_get_format;
+  iface->get_format_with_alpha = gimp_image_proxy_get_format_with_alpha;
+  iface->get_buffer            = gimp_image_proxy_get_buffer;
+  iface->get_pixel_at          = gimp_image_proxy_get_pixel_at;
+  iface->get_opacity_at        = gimp_image_proxy_get_opacity_at;
+  iface->get_pixel_average     = gimp_image_proxy_get_pixel_average;
+  iface->pixel_to_srgb         = gimp_image_proxy_pixel_to_srgb;
+  iface->srgb_to_pixel         = gimp_image_proxy_srgb_to_pixel;
+}
+
+static void
+gimp_image_proxy_color_managed_iface_init (GimpColorManagedInterface *iface)
+{
+  iface->get_icc_profile   = gimp_image_proxy_get_icc_profile;
+  iface->get_color_profile = gimp_image_proxy_get_color_profile;
+  iface->profile_changed   = gimp_image_proxy_profile_changed;
+}
+
+static void
+gimp_image_proxy_init (GimpImageProxy *image_proxy)
+{
+  image_proxy->priv = gimp_image_proxy_get_instance_private (image_proxy);
+}
+
+static void
+gimp_image_proxy_finalize (GObject *object)
+{
+  GimpImageProxy *image_proxy = GIMP_IMAGE_PROXY (object);
+
+  gimp_image_proxy_set_image (image_proxy, NULL);
+
+  G_OBJECT_CLASS (parent_class)->finalize (object);
+}
+
+static void
+gimp_image_proxy_set_property (GObject      *object,
+                               guint         property_id,
+                               const GValue *value,
+                               GParamSpec   *pspec)
+{
+  GimpImageProxy *image_proxy = GIMP_IMAGE_PROXY (object);
+
+  switch (property_id)
+    {
+    case PROP_IMAGE:
+      gimp_image_proxy_set_image (image_proxy,
+                                  g_value_get_object (value));
+      break;
+
+    case PROP_SHOW_ALL:
+      gimp_image_proxy_set_show_all (image_proxy,
+                                     g_value_get_boolean (value));
+      break;
+
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+      break;
+    }
+}
+
+static void
+gimp_image_proxy_get_property (GObject    *object,
+                               guint       property_id,
+                               GValue     *value,
+                               GParamSpec *pspec)
+{
+  GimpImageProxy *image_proxy = GIMP_IMAGE_PROXY (object);
+
+  switch (property_id)
+    {
+    case PROP_IMAGE:
+      g_value_set_object (value,
+                          gimp_image_proxy_get_image (image_proxy));
+      break;
+
+    case PROP_SHOW_ALL:
+      g_value_set_boolean (value,
+                           gimp_image_proxy_get_show_all (image_proxy));
+      break;
+
+    case PROP_BUFFER:
+      g_value_set_object (value,
+                          gimp_pickable_get_buffer (
+                            GIMP_PICKABLE (image_proxy)));
+      break;
+
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+      break;
+    }
+}
+
+static gboolean
+gimp_image_proxy_get_size (GimpViewable *viewable,
+                           gint         *width,
+                           gint         *height)
+{
+  GimpImageProxy *image_proxy = GIMP_IMAGE_PROXY (viewable);
+
+  *width  = image_proxy->priv->bounding_box.width;
+  *height = image_proxy->priv->bounding_box.height;
+
+  return TRUE;
+}
+
+static void
+gimp_image_proxy_get_preview_size (GimpViewable *viewable,
+                                   gint          size,
+                                   gboolean      is_popup,
+                                   gboolean      dot_for_dot,
+                                   gint         *width,
+                                   gint         *height)
+{
+  GimpImageProxy *image_proxy = GIMP_IMAGE_PROXY (viewable);
+  GimpImage      *image       = image_proxy->priv->image;
+  gdouble         xres;
+  gdouble         yres;
+  gint            viewable_width;
+  gint            viewable_height;
+
+  gimp_image_get_resolution (image, &xres, &yres);
+
+  gimp_viewable_get_size (viewable, &viewable_width, &viewable_height);
+
+  gimp_viewable_calc_preview_size (viewable_width,
+                                   viewable_height,
+                                   size,
+                                   size,
+                                   dot_for_dot,
+                                   xres,
+                                   yres,
+                                   width,
+                                   height,
+                                   NULL);
+}
+
+static gboolean
+gimp_image_proxy_get_popup_size (GimpViewable *viewable,
+                                 gint          width,
+                                 gint          height,
+                                 gboolean      dot_for_dot,
+                                 gint         *popup_width,
+                                 gint         *popup_height)
+{
+  gint viewable_width;
+  gint viewable_height;
+
+  gimp_viewable_get_size (viewable, &viewable_width, &viewable_height);
+
+  if (viewable_width > width || viewable_height > height)
+    {
+      gboolean scaling_up;
+
+      gimp_viewable_calc_preview_size (viewable_width,
+                                       viewable_height,
+                                       width  * 2,
+                                       height * 2,
+                                       dot_for_dot, 1.0, 1.0,
+                                       popup_width,
+                                       popup_height,
+                                       &scaling_up);
+
+      if (scaling_up)
+        {
+          *popup_width  = viewable_width;
+          *popup_height = viewable_height;
+        }
+
+      return TRUE;
+    }
+
+  return FALSE;
+}
+
+static GimpTempBuf *
+gimp_image_proxy_get_new_preview (GimpViewable *viewable,
+                                  GimpContext  *context,
+                                  gint          width,
+                                  gint          height)
+{
+  GimpImageProxy *image_proxy = GIMP_IMAGE_PROXY (viewable);
+  GimpImage      *image       = image_proxy->priv->image;
+  GimpPickable   *pickable;
+  const Babl     *format;
+  GeglRectangle   bounding_box;
+  GimpTempBuf    *buf;
+  gdouble         scale_x;
+  gdouble         scale_y;
+  gdouble         scale;
+
+  pickable     = gimp_image_proxy_get_pickable     (image_proxy);
+  bounding_box = gimp_image_proxy_get_bounding_box (image_proxy);
+
+  scale_x = (gdouble) width  / (gdouble) bounding_box.width;
+  scale_y = (gdouble) height / (gdouble) bounding_box.height;
+
+  scale   = MIN (scale_x, scale_y);
+
+  format = gimp_image_get_preview_format (image);
+
+  buf = gimp_temp_buf_new (width, height, format);
+
+  gegl_buffer_get (gimp_pickable_get_buffer (pickable),
+                   GEGL_RECTANGLE (bounding_box.x * scale,
+                                   bounding_box.y * scale,
+                                   width,
+                                   height),
+                   scale,
+                   gimp_temp_buf_get_format (buf),
+                   gimp_temp_buf_get_data (buf),
+                   GEGL_AUTO_ROWSTRIDE, GEGL_ABYSS_CLAMP);
+
+  return buf;
+}
+
+static GdkPixbuf *
+gimp_image_proxy_get_new_pixbuf (GimpViewable *viewable,
+                                 GimpContext  *context,
+                                 gint          width,
+                                 gint          height)
+{
+  GimpImageProxy     *image_proxy = GIMP_IMAGE_PROXY (viewable);
+  GimpImage          *image       = image_proxy->priv->image;
+  GimpPickable       *pickable;
+  GeglRectangle       bounding_box;
+  GdkPixbuf          *pixbuf;
+  gdouble             scale_x;
+  gdouble             scale_y;
+  gdouble             scale;
+  GimpColorTransform *transform;
+
+  pickable     = gimp_image_proxy_get_pickable     (image_proxy);
+  bounding_box = gimp_image_proxy_get_bounding_box (image_proxy);
+
+  scale_x = (gdouble) width  / (gdouble) bounding_box.width;
+  scale_y = (gdouble) height / (gdouble) bounding_box.height;
+
+  scale   = MIN (scale_x, scale_y);
+
+  pixbuf = gdk_pixbuf_new (GDK_COLORSPACE_RGB, TRUE, 8,
+                           width, height);
+
+  transform = gimp_image_get_color_transform_to_srgb_u8 (image);
+
+  if (transform)
+    {
+      GimpTempBuf *temp_buf;
+      GeglBuffer  *src_buf;
+      GeglBuffer  *dest_buf;
+
+      temp_buf = gimp_temp_buf_new (width, height,
+                                    gimp_pickable_get_format (pickable));
+
+      gegl_buffer_get (gimp_pickable_get_buffer (pickable),
+                       GEGL_RECTANGLE (bounding_box.x * scale,
+                                       bounding_box.y * scale,
+                                       width,
+                                       height),
+                       scale,
+                       gimp_temp_buf_get_format (temp_buf),
+                       gimp_temp_buf_get_data (temp_buf),
+                       GEGL_AUTO_ROWSTRIDE, GEGL_ABYSS_CLAMP);
+
+      src_buf  = gimp_temp_buf_create_buffer (temp_buf);
+      dest_buf = gimp_pixbuf_create_buffer (pixbuf);
+
+      gimp_temp_buf_unref (temp_buf);
+
+      gimp_color_transform_process_buffer (transform,
+                                           src_buf,
+                                           GEGL_RECTANGLE (0, 0,
+                                                           width, height),
+                                           dest_buf,
+                                           GEGL_RECTANGLE (0, 0, 0, 0));
+
+      g_object_unref (src_buf);
+      g_object_unref (dest_buf);
+    }
+  else
+    {
+      gegl_buffer_get (gimp_pickable_get_buffer (pickable),
+                       GEGL_RECTANGLE (bounding_box.x * scale,
+                                       bounding_box.y * scale,
+                                       width,
+                                       height),
+                       scale,
+                       gimp_pixbuf_get_format (pixbuf),
+                       gdk_pixbuf_get_pixels (pixbuf),
+                       gdk_pixbuf_get_rowstride (pixbuf),
+                       GEGL_ABYSS_CLAMP);
+    }
+
+  return pixbuf;
+}
+
+static gchar *
+gimp_image_proxy_get_description (GimpViewable  *viewable,
+                                  gchar        **tooltip)
+{
+  GimpImageProxy *image_proxy = GIMP_IMAGE_PROXY (viewable);
+  GimpImage      *image       = image_proxy->priv->image;
+
+  if (tooltip)
+    *tooltip = g_strdup (gimp_image_get_display_path (image));
+
+  return g_strdup_printf ("%s-%d",
+                          gimp_image_get_display_name (image),
+                          gimp_image_get_ID (image));
+}
+
+static void
+gimp_image_proxy_flush (GimpPickable *pickable)
+{
+  GimpImageProxy *image_proxy = GIMP_IMAGE_PROXY (pickable);
+  GimpPickable   *proxy_pickable;
+
+  proxy_pickable = gimp_image_proxy_get_pickable (image_proxy);
+
+  gimp_pickable_flush (proxy_pickable);
+}
+
+static const Babl *
+gimp_image_proxy_get_format (GimpPickable *pickable)
+{
+  GimpImageProxy *image_proxy = GIMP_IMAGE_PROXY (pickable);
+  GimpPickable   *proxy_pickable;
+
+  proxy_pickable = gimp_image_proxy_get_pickable (image_proxy);
+
+  return gimp_pickable_get_format (proxy_pickable);
+}
+
+static const Babl *
+gimp_image_proxy_get_format_with_alpha (GimpPickable *pickable)
+{
+  GimpImageProxy *image_proxy = GIMP_IMAGE_PROXY (pickable);
+  GimpPickable   *proxy_pickable;
+
+  proxy_pickable = gimp_image_proxy_get_pickable (image_proxy);
+
+  return gimp_pickable_get_format_with_alpha (proxy_pickable);
+}
+
+static GeglBuffer *
+gimp_image_proxy_get_buffer (GimpPickable *pickable)
+{
+  GimpImageProxy *image_proxy = GIMP_IMAGE_PROXY (pickable);
+  GimpPickable   *proxy_pickable;
+
+  proxy_pickable = gimp_image_proxy_get_pickable (image_proxy);
+
+  return gimp_pickable_get_buffer (proxy_pickable);
+}
+
+static gboolean
+gimp_image_proxy_get_pixel_at (GimpPickable *pickable,
+                               gint          x,
+                               gint          y,
+                               const Babl   *format,
+                               gpointer      pixel)
+{
+  GimpImageProxy *image_proxy = GIMP_IMAGE_PROXY (pickable);
+  GimpPickable   *proxy_pickable;
+
+  proxy_pickable = gimp_image_proxy_get_pickable (image_proxy);
+
+  return gimp_pickable_get_pixel_at (proxy_pickable, x, y, format, pixel);
+}
+
+static gdouble
+gimp_image_proxy_get_opacity_at (GimpPickable *pickable,
+                                 gint          x,
+                                 gint          y)
+{
+  GimpImageProxy *image_proxy = GIMP_IMAGE_PROXY (pickable);
+  GimpPickable   *proxy_pickable;
+
+  proxy_pickable = gimp_image_proxy_get_pickable (image_proxy);
+
+  return gimp_pickable_get_opacity_at (proxy_pickable, x, y);
+}
+
+static void
+gimp_image_proxy_get_pixel_average (GimpPickable        *pickable,
+                                    const GeglRectangle *rect,
+                                    const Babl          *format,
+                                    gpointer             pixel)
+{
+  GimpImageProxy *image_proxy = GIMP_IMAGE_PROXY (pickable);
+  GimpPickable   *proxy_pickable;
+
+  proxy_pickable = gimp_image_proxy_get_pickable (image_proxy);
+
+  gimp_pickable_get_pixel_average (proxy_pickable, rect, format, pixel);
+}
+
+static void
+gimp_image_proxy_pixel_to_srgb (GimpPickable *pickable,
+                                const Babl   *format,
+                                gpointer      pixel,
+                                GimpRGB      *color)
+{
+  GimpImageProxy *image_proxy = GIMP_IMAGE_PROXY (pickable);
+  GimpPickable   *proxy_pickable;
+
+  proxy_pickable = gimp_image_proxy_get_pickable (image_proxy);
+
+  gimp_pickable_pixel_to_srgb (proxy_pickable, format, pixel, color);
+}
+
+static void
+gimp_image_proxy_srgb_to_pixel (GimpPickable  *pickable,
+                                const GimpRGB *color,
+                                const Babl    *format,
+                                gpointer       pixel)
+{
+  GimpImageProxy *image_proxy = GIMP_IMAGE_PROXY (pickable);
+  GimpPickable   *proxy_pickable;
+
+  proxy_pickable = gimp_image_proxy_get_pickable (image_proxy);
+
+  gimp_pickable_srgb_to_pixel (proxy_pickable, color, format, pixel);
+}
+
+static const guint8 *
+gimp_image_proxy_get_icc_profile (GimpColorManaged *managed,
+                                  gsize            *len)
+{
+  GimpImageProxy *image_proxy = GIMP_IMAGE_PROXY (managed);
+
+  return gimp_color_managed_get_icc_profile (
+    GIMP_COLOR_MANAGED (image_proxy->priv->image),
+    len);
+}
+
+static GimpColorProfile *
+gimp_image_proxy_get_color_profile (GimpColorManaged *managed)
+{
+  GimpImageProxy *image_proxy = GIMP_IMAGE_PROXY (managed);
+
+  return gimp_color_managed_get_color_profile (
+    GIMP_COLOR_MANAGED (image_proxy->priv->image));
+}
+
+static void
+gimp_image_proxy_profile_changed (GimpColorManaged *managed)
+{
+  gimp_viewable_invalidate_preview (GIMP_VIEWABLE (managed));
+}
+
+static void
+gimp_image_proxy_image_frozen_notify (GimpImage        *image,
+                                      const GParamSpec *pspec,
+                                      GimpImageProxy   *image_proxy)
+{
+  gimp_image_proxy_update_frozen (image_proxy);
+}
+
+static void
+gimp_image_proxy_image_invalidate_preview (GimpImage      *image,
+                                           GimpImageProxy *image_proxy)
+{
+  gimp_viewable_invalidate_preview (GIMP_VIEWABLE (image_proxy));
+}
+
+static void
+gimp_image_proxy_image_size_changed (GimpImage      *image,
+                                     GimpImageProxy *image_proxy)
+{
+  gimp_image_proxy_update_bounding_box (image_proxy);
+}
+
+static void
+gimp_image_proxy_image_bounds_changed (GimpImage      *image,
+                                       gint            old_x,
+                                       gint            old_y,
+                                       GimpImageProxy *image_proxy)
+{
+  gimp_image_proxy_update_bounding_box (image_proxy);
+}
+
+static void
+gimp_image_proxy_image_profile_changed (GimpImage      *image,
+                                        GimpImageProxy *image_proxy)
+{
+  gimp_color_managed_profile_changed (GIMP_COLOR_MANAGED (image_proxy));
+}
+
+static void
+gimp_image_proxy_set_image (GimpImageProxy *image_proxy,
+                            GimpImage      *image)
+{
+  if (image_proxy->priv->image)
+    {
+      g_signal_handlers_disconnect_by_func (
+        image_proxy->priv->image,
+        gimp_image_proxy_image_frozen_notify,
+        image_proxy);
+      g_signal_handlers_disconnect_by_func (
+        image_proxy->priv->image,
+        gimp_image_proxy_image_invalidate_preview,
+        image_proxy);
+      g_signal_handlers_disconnect_by_func (
+        image_proxy->priv->image,
+        gimp_image_proxy_image_size_changed,
+        image_proxy);
+      g_signal_handlers_disconnect_by_func (
+        image_proxy->priv->image,
+        gimp_image_proxy_image_bounds_changed,
+        image_proxy);
+      g_signal_handlers_disconnect_by_func (
+        image_proxy->priv->image,
+        gimp_image_proxy_image_profile_changed,
+        image_proxy);
+
+      g_object_unref (image_proxy->priv->image);
+    }
+
+  image_proxy->priv->image = image;
+
+  if (image_proxy->priv->image)
+    {
+      g_object_ref (image_proxy->priv->image);
+
+      g_signal_connect (
+        image_proxy->priv->image, "notify::frozen",
+        G_CALLBACK (gimp_image_proxy_image_frozen_notify),
+        image_proxy);
+      g_signal_connect (
+        image_proxy->priv->image, "invalidate-preview",
+        G_CALLBACK (gimp_image_proxy_image_invalidate_preview),
+        image_proxy);
+      g_signal_connect (
+        image_proxy->priv->image, "size-changed",
+        G_CALLBACK (gimp_image_proxy_image_size_changed),
+        image_proxy);
+      g_signal_connect (
+        image_proxy->priv->image, "bounds-changed",
+        G_CALLBACK (gimp_image_proxy_image_bounds_changed),
+        image_proxy);
+      g_signal_connect (
+        image_proxy->priv->image, "profile-changed",
+        G_CALLBACK (gimp_image_proxy_image_profile_changed),
+        image_proxy);
+
+      gimp_image_proxy_update_bounding_box (image_proxy);
+      gimp_image_proxy_update_frozen (image_proxy);
+
+      gimp_viewable_invalidate_preview (GIMP_VIEWABLE (image_proxy));
+    }
+}
+
+static GimpPickable *
+gimp_image_proxy_get_pickable (GimpImageProxy *image_proxy)
+{
+  GimpImage *image = image_proxy->priv->image;
+
+  if (! image_proxy->priv->show_all)
+    return GIMP_PICKABLE (image);
+  else
+    return GIMP_PICKABLE (gimp_image_get_projection (image));
+}
+
+static void
+gimp_image_proxy_update_bounding_box (GimpImageProxy *image_proxy)
+{
+  GimpImage     *image = image_proxy->priv->image;
+  GeglRectangle  bounding_box;
+
+  if (gimp_viewable_preview_is_frozen (GIMP_VIEWABLE (image_proxy)))
+    return;
+
+  if (! image_proxy->priv->show_all)
+    {
+      bounding_box.x      = 0;
+      bounding_box.y      = 0;
+      bounding_box.width  = gimp_image_get_width  (image);
+      bounding_box.height = gimp_image_get_height (image);
+    }
+  else
+    {
+      bounding_box = gimp_projectable_get_bounding_box (
+        GIMP_PROJECTABLE (image));
+    }
+
+  if (! gegl_rectangle_equal (&bounding_box,
+                              &image_proxy->priv->bounding_box))
+    {
+      image_proxy->priv->bounding_box = bounding_box;
+
+      gimp_viewable_size_changed (GIMP_VIEWABLE (image_proxy));
+    }
+}
+
+static void
+gimp_image_proxy_update_frozen (GimpImageProxy *image_proxy)
+{
+  gboolean frozen;
+
+  frozen = gimp_viewable_preview_is_frozen (
+    GIMP_VIEWABLE (image_proxy->priv->image));
+
+  if (frozen != image_proxy->priv->frozen)
+    {
+      image_proxy->priv->frozen = frozen;
+
+      if (frozen)
+        {
+          gimp_viewable_preview_freeze (GIMP_VIEWABLE (image_proxy));
+        }
+      else
+        {
+          gimp_viewable_preview_thaw (GIMP_VIEWABLE (image_proxy));
+
+          gimp_image_proxy_update_bounding_box (image_proxy);
+        }
+    }
+}
+
+
+/*  public functions  */
+
+
+GimpImageProxy *
+gimp_image_proxy_new (GimpImage *image)
+{
+  g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);
+
+  return g_object_new (GIMP_TYPE_IMAGE_PROXY,
+                       "image", image,
+                       NULL);
+}
+
+GimpImage *
+gimp_image_proxy_get_image (GimpImageProxy *image_proxy)
+{
+  g_return_val_if_fail (GIMP_IS_IMAGE_PROXY (image_proxy), NULL);
+
+  return image_proxy->priv->image;
+}
+
+void
+gimp_image_proxy_set_show_all (GimpImageProxy *image_proxy,
+                               gboolean        show_all)
+{
+  g_return_if_fail (GIMP_IS_IMAGE_PROXY (image_proxy));
+
+  if (show_all != image_proxy->priv->show_all)
+    {
+      image_proxy->priv->show_all = show_all;
+
+      gimp_image_proxy_update_bounding_box (image_proxy);
+    }
+}
+
+gboolean
+gimp_image_proxy_get_show_all (GimpImageProxy *image_proxy)
+{
+  g_return_val_if_fail (GIMP_IS_IMAGE_PROXY (image_proxy), FALSE);
+
+  return image_proxy->priv->show_all;
+}
+
+GeglRectangle
+gimp_image_proxy_get_bounding_box (GimpImageProxy *image_proxy)
+{
+  g_return_val_if_fail (GIMP_IS_IMAGE_PROXY (image_proxy),
+                        *GEGL_RECTANGLE (0, 0, 0, 0));
+
+  return image_proxy->priv->bounding_box;
+}