gimp r27982 - in trunk: . app/core app/text app/xcf

[mitch svn gnome org]

Author: mitch
Date: Tue Feb  3 23:57:11 2009
New Revision: 27982
URL: http://svn.gnome.org/viewvc/gimp?rev=27982&view=rev

Log:
2009-02-04  Michael Natterer  <mitch gimp org>

	* app/core/Makefile.am
	* app/core/gimpdrawable-private.h: new file which contains struct
	GimpDrawablePrivate. Move some stuff from GimpDrawable here.

	* app/core/gimpdrawable.[ch]
	* app/core/gimpdrawable-shadow.c: changed accordingly.

	* app/text/gimptextlayer-xcf.c
	* app/xcf/xcf-load.c: include the private struct for these ugly
	corner cases.



Added:
   trunk/app/core/gimpdrawable-private.h
Modified:
   trunk/ChangeLog
   trunk/app/core/Makefile.am
   trunk/app/core/gimpdrawable-shadow.c
   trunk/app/core/gimpdrawable.c
   trunk/app/core/gimpdrawable.h
   trunk/app/text/gimptextlayer-xcf.c
   trunk/app/xcf/xcf-load.c

Modified: trunk/app/core/Makefile.am
==============================================================================
--- trunk/app/core/Makefile.am	(original)
+++ trunk/app/core/Makefile.am	Tue Feb  3 23:57:11 2009
@@ -148,6 +148,8 @@
 	gimpdrawable-posterize.h		\
 	gimpdrawable-preview.c			\
 	gimpdrawable-preview.h			\
+	gimpdrawable-private.c			\
+	gimpdrawable-private.h			\
 	gimpdrawable-process.c			\
 	gimpdrawable-process.h			\
 	gimpdrawable-shadow.c			\

Added: trunk/app/core/gimpdrawable-private.h
==============================================================================
--- (empty file)
+++ trunk/app/core/gimpdrawable-private.h	Tue Feb  3 23:57:11 2009
@@ -0,0 +1,35 @@
+/* GIMP - The GNU Image Manipulation Program
+ * Copyright (C) 1995 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 <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef __GIMP_DRAWABLE_PRIVATE_H__
+#define __GIMP_DRAWABLE_PRIVATE_H__
+
+struct _GimpDrawablePrivate
+{
+  TileManager *tiles;  /* tiles for drawable data */
+  TileManager *shadow; /* shadow buffer tiles     */
+
+  GeglNode    *source_node;
+  GeglNode    *tile_source_node;
+  GeglNode    *fs_opacity_node;
+  GeglNode    *fs_offset_node;
+  GeglNode    *fs_mode_node;
+
+  GeglNode    *mode_node;
+};
+
+#endif /* __GIMP_DRAWABLE_PRIVATE_H__ */

Modified: trunk/app/core/gimpdrawable-shadow.c
==============================================================================
--- trunk/app/core/gimpdrawable-shadow.c	(original)
+++ trunk/app/core/gimpdrawable-shadow.c	Tue Feb  3 23:57:11 2009
@@ -25,6 +25,7 @@
 #include "base/tile-manager.h"
 
 #include "gimpdrawable.h"
+#include "gimpdrawable-private.h"
 #include "gimpdrawable-shadow.h"
 
 
@@ -37,25 +38,25 @@
 
   item = GIMP_ITEM (drawable);
 
-  if (drawable->shadow)
+  if (drawable->private->shadow)
     {
-      if ((gimp_item_get_width  (item) != tile_manager_width  (drawable->shadow)) ||
-          (gimp_item_get_height (item) != tile_manager_height (drawable->shadow)) ||
-          (drawable->bytes         != tile_manager_bpp    (drawable->shadow)))
+      if ((gimp_item_get_width  (item) != tile_manager_width  (drawable->private->shadow)) ||
+          (gimp_item_get_height (item) != tile_manager_height (drawable->private->shadow)) ||
+          (drawable->bytes             != tile_manager_bpp    (drawable->private->shadow)))
         {
           gimp_drawable_free_shadow_tiles (drawable);
         }
       else
         {
-          return drawable->shadow;
+          return drawable->private->shadow;
         }
     }
 
-  drawable->shadow = tile_manager_new (gimp_item_get_width  (item),
-                                       gimp_item_get_height (item),
-                                       drawable->bytes);
+  drawable->private->shadow = tile_manager_new (gimp_item_get_width  (item),
+                                                gimp_item_get_height (item),
+                                                drawable->bytes);
 
-  return drawable->shadow;
+  return drawable->private->shadow;
 }
 
 void
@@ -63,10 +64,10 @@
 {
   g_return_if_fail (GIMP_IS_DRAWABLE (drawable));
 
-  if (drawable->shadow)
+  if (drawable->private->shadow)
     {
-      tile_manager_unref (drawable->shadow);
-      drawable->shadow = NULL;
+      tile_manager_unref (drawable->private->shadow);
+      drawable->private->shadow = NULL;
     }
 }
 
@@ -80,7 +81,7 @@
 
   g_return_if_fail (GIMP_IS_DRAWABLE (drawable));
   g_return_if_fail (gimp_item_is_attached (GIMP_ITEM (drawable)));
-  g_return_if_fail (drawable->shadow != NULL);
+  g_return_if_fail (drawable->private->shadow != NULL);
 
   /*  A useful optimization here is to limit the update to the
    *  extents of the selection mask, as it cannot extend beyond
@@ -88,7 +89,7 @@
    */
   if (gimp_drawable_mask_intersect (drawable, &x, &y, &width, &height))
     {
-      TileManager *tiles = tile_manager_ref (drawable->shadow);
+      TileManager *tiles = tile_manager_ref (drawable->private->shadow);
       PixelRegion  shadowPR;
 
       pixel_region_init (&shadowPR, tiles, x, y, width, height, FALSE);

Modified: trunk/app/core/gimpdrawable.c
==============================================================================
--- trunk/app/core/gimpdrawable.c	(original)
+++ trunk/app/core/gimpdrawable.c	Tue Feb  3 23:57:11 2009
@@ -36,6 +36,7 @@
 #include "gimpcontext.h"
 #include "gimpdrawable-combine.h"
 #include "gimpdrawable-preview.h"
+#include "gimpdrawable-private.h"
 #include "gimpdrawable-shadow.h"
 #include "gimpdrawable-transform.h"
 #include "gimpimage.h"
@@ -225,13 +226,17 @@
   klass->set_tiles                   = gimp_drawable_real_set_tiles;
   klass->push_undo                   = gimp_drawable_real_push_undo;
   klass->swap_pixels                 = gimp_drawable_real_swap_pixels;
+
+  g_type_class_add_private (klass, sizeof (GimpDrawablePrivate));
 }
 
 static void
 gimp_drawable_init (GimpDrawable *drawable)
 {
-  drawable->tiles         = NULL;
-  drawable->shadow        = NULL;
+  drawable->private       = G_TYPE_INSTANCE_GET_PRIVATE (drawable,
+                                                         GIMP_TYPE_DRAWABLE,
+                                                         GimpDrawablePrivate);
+
   drawable->bytes         = 0;
   drawable->type          = -1;
   drawable->has_alpha     = FALSE;
@@ -256,21 +261,21 @@
 {
   GimpDrawable *drawable = GIMP_DRAWABLE (object);
 
-  if (drawable->fs_opacity_node)
+  if (drawable->private->fs_opacity_node)
     gimp_drawable_sync_source_node (drawable, TRUE);
 
-  if (drawable->tiles)
+  if (drawable->private->tiles)
     {
-      tile_manager_unref (drawable->tiles);
-      drawable->tiles = NULL;
+      tile_manager_unref (drawable->private->tiles);
+      drawable->private->tiles = NULL;
     }
 
   gimp_drawable_free_shadow_tiles (drawable);
 
-  if (drawable->source_node)
+  if (drawable->private->source_node)
     {
-      g_object_unref (drawable->source_node);
-      drawable->source_node = NULL;
+      g_object_unref (drawable->private->source_node);
+      drawable->private->source_node = NULL;
     }
 
   if (drawable->preview_cache)
@@ -288,7 +293,7 @@
 
   memsize += tile_manager_get_memsize (gimp_drawable_get_tiles (drawable),
                                        FALSE);
-  memsize += tile_manager_get_memsize (drawable->shadow, FALSE);
+  memsize += tile_manager_get_memsize (drawable->private->shadow, FALSE);
 
   *gui_size += gimp_preview_cache_get_memsize (drawable->preview_cache);
 
@@ -352,14 +357,14 @@
           ! (GIMP_IS_LAYER (item) &&
              gimp_layer_is_floating_sel (GIMP_LAYER (item))))
         {
-          gegl_node_connect_to (input,               "output",
-                                drawable->mode_node, "input");
-          gegl_node_connect_to (drawable->mode_node, "output",
-                                output,              "input");
+          gegl_node_connect_to (input,                        "output",
+                                drawable->private->mode_node, "input");
+          gegl_node_connect_to (drawable->private->mode_node, "output",
+                                output,                       "input");
         }
       else
         {
-          gegl_node_disconnect (drawable->mode_node, "input");
+          gegl_node_disconnect (drawable->private->mode_node, "input");
 
           gegl_node_connect_to (input,  "output",
                                 output, "input");
@@ -681,12 +686,12 @@
                            gint          width,
                            gint          height)
 {
-  if (drawable->tile_source_node)
+  if (drawable->private->tile_source_node)
     {
       GObject       *operation;
       GeglRectangle  rect;
 
-      g_object_get (drawable->tile_source_node,
+      g_object_get (drawable->private->tile_source_node,
                     "gegl-operation", &operation,
                     NULL);
 
@@ -714,17 +719,17 @@
 static TileManager *
 gimp_drawable_real_get_tiles (GimpDrawable *drawable)
 {
-  return drawable->tiles;
+  return drawable->private->tiles;
 }
 
 static void
 gimp_drawable_update_tile_source_node (GimpDrawable *drawable)
 {
-  if (! drawable->tile_source_node)
+  if (! drawable->private->tile_source_node)
     return;
 
-  gegl_node_set (drawable->tile_source_node,
-                 "tile-manager", drawable->tiles,
+  gegl_node_set (drawable->private->tile_source_node,
+                 "tile-manager", drawable->private->tiles,
                  NULL);
 }
 
@@ -755,13 +760,13 @@
   /*  ref new before unrefing old, they might be the same  */
   tile_manager_ref (tiles);
 
-  if (drawable->tiles)
-    tile_manager_unref (drawable->tiles);
+  if (drawable->private->tiles)
+    tile_manager_unref (drawable->private->tiles);
 
-  drawable->tiles     = tiles;
-  drawable->type      = type;
-  drawable->bytes     = tile_manager_bpp (tiles);
-  drawable->has_alpha = GIMP_IMAGE_TYPE_HAS_ALPHA (type);
+  drawable->private->tiles = tiles;
+  drawable->type           = type;
+  drawable->bytes          = tile_manager_bpp (tiles);
+  drawable->has_alpha      = GIMP_IMAGE_TYPE_HAS_ALPHA (type);
 
   gimp_item_set_offset (item, offset_x, offset_y);
 
@@ -790,19 +795,21 @@
 
   node = GIMP_ITEM_CLASS (parent_class)->get_node (item);
 
-  drawable->mode_node = gegl_node_new_child (node,
-                                             "operation", "gegl:normal",
-                                             NULL);
+  drawable->private->mode_node = gegl_node_new_child (node,
+                                                      "operation", "gegl:normal",
+                                                      NULL);
 
   input  = gegl_node_get_input_proxy  (node, "input");
   output = gegl_node_get_output_proxy (node, "output");
 
-  if (gimp_item_get_visible (GIMP_ITEM (drawable)))
-    {
-      gegl_node_connect_to (input,               "output",
-                            drawable->mode_node, "input");
-      gegl_node_connect_to (drawable->mode_node, "output",
-                            output,              "input");
+  if (gimp_item_get_visible (GIMP_ITEM (drawable)) &&
+      ! (GIMP_IS_LAYER (drawable) &&
+         gimp_layer_is_floating_sel (GIMP_LAYER (drawable))))
+    {
+      gegl_node_connect_to (input,                        "output",
+                            drawable->private->mode_node, "input");
+      gegl_node_connect_to (drawable->private->mode_node, "output",
+                            output,                       "input");
     }
   else
     {
@@ -913,107 +920,107 @@
   GimpLayer *fs    = gimp_image_get_floating_selection (image);
   GeglNode  *output;
 
-  if (! drawable->source_node)
+  if (! drawable->private->source_node)
     return;
 
-  output = gegl_node_get_output_proxy (drawable->source_node, "output");
+  output = gegl_node_get_output_proxy (drawable->private->source_node, "output");
 
   if (gimp_drawable_has_floating_sel (drawable) && ! detach_fs)
     {
       gint off_x, off_y;
       gint fs_off_x, fs_off_y;
 
-      if (! drawable->fs_opacity_node)
+      if (! drawable->private->fs_opacity_node)
         {
           GeglNode *fs_source;
 
           fs_source = gimp_drawable_get_source_node (GIMP_DRAWABLE (fs));
-          gegl_node_add_child (drawable->source_node, fs_source);
+          gegl_node_add_child (drawable->private->source_node, fs_source);
 
-          drawable->fs_opacity_node =
-            gegl_node_new_child (drawable->source_node,
+          drawable->private->fs_opacity_node =
+            gegl_node_new_child (drawable->private->source_node,
                                  "operation", "gegl:opacity",
                                  NULL);
 
-          gegl_node_connect_to (fs_source,                 "output",
-                                drawable->fs_opacity_node, "input");
+          gegl_node_connect_to (fs_source,                          "output",
+                                drawable->private->fs_opacity_node, "input");
 
-          drawable->fs_offset_node =
-            gegl_node_new_child (drawable->source_node,
+          drawable->private->fs_offset_node =
+            gegl_node_new_child (drawable->private->source_node,
                                  "operation", "gegl:translate",
                                  NULL);
 
-          gegl_node_connect_to (drawable->fs_opacity_node, "output",
-                                drawable->fs_offset_node,  "input");
+          gegl_node_connect_to (drawable->private->fs_opacity_node, "output",
+                                drawable->private->fs_offset_node,  "input");
 
-          drawable->fs_mode_node =
-            gegl_node_new_child (drawable->source_node,
+          drawable->private->fs_mode_node =
+            gegl_node_new_child (drawable->private->source_node,
                                  "operation", "gimp:point-layer-mode",
                                  NULL);
 
-          gegl_node_connect_to (drawable->tile_source_node, "output",
-                                drawable->fs_mode_node,     "input");
-          gegl_node_connect_to (drawable->fs_offset_node,   "output",
-                                drawable->fs_mode_node,     "aux");
+          gegl_node_connect_to (drawable->private->tile_source_node, "output",
+                                drawable->private->fs_mode_node,     "input");
+          gegl_node_connect_to (drawable->private->fs_offset_node,   "output",
+                                drawable->private->fs_mode_node,     "aux");
 
-          gegl_node_connect_to (drawable->fs_mode_node, "output",
-                                output,                 "input");
+          gegl_node_connect_to (drawable->private->fs_mode_node, "output",
+                                output,                          "input");
 
           g_signal_connect (fs, "notify",
                             G_CALLBACK (gimp_drawable_fs_notify),
                             drawable);
         }
 
-      gegl_node_set (drawable->fs_opacity_node,
+      gegl_node_set (drawable->private->fs_opacity_node,
                      "value", gimp_layer_get_opacity (fs),
                      NULL);
 
       gimp_item_get_offset (GIMP_ITEM (drawable), &off_x, &off_y);
       gimp_item_get_offset (GIMP_ITEM (fs), &fs_off_x, &fs_off_y);
 
-      gegl_node_set (drawable->fs_offset_node,
+      gegl_node_set (drawable->private->fs_offset_node,
                      "x", (gdouble) (fs_off_x - off_x),
                      "y", (gdouble) (fs_off_y - off_y),
                      NULL);
 
-      gegl_node_set (drawable->fs_mode_node,
+      gegl_node_set (drawable->private->fs_mode_node,
                      "blend-mode", gimp_layer_get_mode (fs),
                      NULL);
     }
   else
     {
-      if (drawable->fs_opacity_node)
+      if (drawable->private->fs_opacity_node)
         {
           GeglNode *fs_source;
 
-          gegl_node_disconnect (drawable->fs_opacity_node, "input");
-          gegl_node_disconnect (drawable->fs_offset_node, "input");
-          gegl_node_disconnect (drawable->fs_mode_node, "input");
-          gegl_node_disconnect (drawable->fs_mode_node, "aux");
+          gegl_node_disconnect (drawable->private->fs_opacity_node, "input");
+          gegl_node_disconnect (drawable->private->fs_offset_node, "input");
+          gegl_node_disconnect (drawable->private->fs_mode_node, "input");
+          gegl_node_disconnect (drawable->private->fs_mode_node, "aux");
 
           fs_source = gimp_drawable_get_source_node (GIMP_DRAWABLE (fs));
-          gegl_node_remove_child (drawable->source_node,
+          gegl_node_remove_child (drawable->private->source_node,
                                   fs_source);
 
-          gegl_node_remove_child (drawable->source_node,
-                                  drawable->fs_opacity_node);
-          drawable->fs_opacity_node = NULL;
-
-          gegl_node_remove_child (drawable->source_node,
-                                  drawable->fs_offset_node);
-          drawable->fs_offset_node = NULL;
-
-          gegl_node_remove_child (drawable->source_node,
-                                  drawable->fs_mode_node);
-          drawable->fs_mode_node = NULL;
+          gegl_node_remove_child (drawable->private->source_node,
+                                  drawable->private->fs_opacity_node);
+          drawable->private->fs_opacity_node = NULL;
+
+          gegl_node_remove_child (drawable->private->source_node,
+                                  drawable->private->fs_offset_node);
+          drawable->private->fs_offset_node = NULL;
+
+          gegl_node_remove_child (drawable->private->source_node,
+                                  drawable->private->fs_mode_node);
+          drawable->private->fs_mode_node = NULL;
 
           g_signal_handlers_disconnect_by_func (fs,
                                                 gimp_drawable_fs_notify,
                                                 drawable);
         }
 
-      gegl_node_connect_to (drawable->tile_source_node, "output",
-                            output,                     "input");
+      gegl_node_connect_to (drawable->private->tile_source_node, "output",
+                            output,                              "input");
     }
 }
 
@@ -1067,10 +1074,10 @@
   drawable->bytes     = GIMP_IMAGE_TYPE_BYTES (type);
   drawable->has_alpha = GIMP_IMAGE_TYPE_HAS_ALPHA (type);
 
-  if (drawable->tiles)
-    tile_manager_unref (drawable->tiles);
+  if (drawable->private->tiles)
+    tile_manager_unref (drawable->private->tiles);
 
-  drawable->tiles = tile_manager_new (width, height, drawable->bytes);
+  drawable->private->tiles = tile_manager_new (width, height, drawable->bytes);
 
   /*  preview variables  */
   drawable->preview_cache = NULL;
@@ -1377,21 +1384,21 @@
 {
   g_return_val_if_fail (GIMP_IS_DRAWABLE (drawable), NULL);
 
-  if (drawable->source_node)
-    return drawable->source_node;
+  if (drawable->private->source_node)
+    return drawable->private->source_node;
 
-  drawable->source_node = gegl_node_new ();
+  drawable->private->source_node = gegl_node_new ();
 
-  drawable->tile_source_node =
-    gegl_node_new_child (drawable->source_node,
+  drawable->private->tile_source_node =
+    gegl_node_new_child (drawable->private->source_node,
                          "operation",    "gimp:tilemanager-source",
-                         "tile-manager", drawable->tiles,
+                         "tile-manager", drawable->private->tiles,
                          "linear",       TRUE,
                          NULL);
 
   gimp_drawable_sync_source_node (drawable, FALSE);
 
-  return drawable->source_node;
+  return drawable->private->source_node;
 }
 
 GeglNode *
@@ -1399,10 +1406,10 @@
 {
   g_return_val_if_fail (GIMP_IS_DRAWABLE (drawable), NULL);
 
-  if (! drawable->mode_node)
+  if (! drawable->private->mode_node)
     gimp_drawable_get_node (GIMP_ITEM (drawable));
 
-  return drawable->mode_node;
+  return drawable->private->mode_node;
 }
 
 void

Modified: trunk/app/core/gimpdrawable.h
==============================================================================
--- trunk/app/core/gimpdrawable.h	(original)
+++ trunk/app/core/gimpdrawable.h	Tue Feb  3 23:57:11 2009
@@ -30,23 +30,13 @@
 #define GIMP_DRAWABLE_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), GIMP_TYPE_DRAWABLE, GimpDrawableClass))
 
 
-typedef struct _GimpDrawableClass GimpDrawableClass;
+typedef struct _GimpDrawablePrivate GimpDrawablePrivate;
+typedef struct _GimpDrawableClass   GimpDrawableClass;
 
 struct _GimpDrawable
 {
   GimpItem       parent_instance;
 
-  TileManager   *tiles;              /* tiles for drawable data        */
-  TileManager   *shadow;             /* shadow buffer tiles            */
-
-  GeglNode      *source_node;
-  GeglNode      *tile_source_node;
-  GeglNode      *fs_opacity_node;
-  GeglNode      *fs_offset_node;
-  GeglNode      *fs_mode_node;
-
-  GeglNode      *mode_node;
-
   gint           bytes;              /* bytes per pixel                */
   GimpImageType  type;               /* type of drawable               */
   gboolean       has_alpha;          /* drawable has alpha             */
@@ -54,6 +44,8 @@
   /*  Preview variables  */
   GSList        *preview_cache;      /* preview caches of the channel  */
   gboolean       preview_valid;      /* is the preview valid?          */
+
+  GimpDrawablePrivate *private;
 };
 
 struct _GimpDrawableClass

Modified: trunk/app/text/gimptextlayer-xcf.c
==============================================================================
--- trunk/app/text/gimptextlayer-xcf.c	(original)
+++ trunk/app/text/gimptextlayer-xcf.c	Tue Feb  3 23:57:11 2009
@@ -25,6 +25,7 @@
 #include "text-types.h"
 
 #include "core/gimp.h"
+#include "core/gimpdrawable-private.h" /* eek */
 #include "core/gimpimage.h"
 #include "core/gimpparasitelist.h"
 
@@ -190,7 +191,7 @@
   gimp_object_set_name (GIMP_OBJECT (text_layer),
                         gimp_object_get_name (GIMP_OBJECT (layer)));
 
-  item->ID    = gimp_item_get_ID (GIMP_ITEM (layer));
+  item->ID = gimp_item_get_ID (GIMP_ITEM (layer));
 
   /* Set image before tatoo so that the explicitly set tatoo overrides
    * the one implicitly set when setting the image
@@ -215,8 +216,8 @@
   gimp_item_set_visible (item, gimp_item_get_visible (GIMP_ITEM (layer)), FALSE);
   gimp_item_set_linked  (item, gimp_item_get_linked  (GIMP_ITEM (layer)), FALSE);
 
-  drawable->tiles = gimp_drawable_get_tiles (GIMP_DRAWABLE (layer));
-  GIMP_DRAWABLE (layer)->tiles = NULL;
+  drawable->private->tiles = gimp_drawable_get_tiles (GIMP_DRAWABLE (layer));
+  GIMP_DRAWABLE (layer)->private->tiles = NULL;
 
   drawable->bytes     = gimp_drawable_bytes (GIMP_DRAWABLE (layer));
   drawable->type      = gimp_drawable_type (GIMP_DRAWABLE (layer));

Modified: trunk/app/xcf/xcf-load.c
==============================================================================
--- trunk/app/xcf/xcf-load.c	(original)
+++ trunk/app/xcf/xcf-load.c	Tue Feb  3 23:57:11 2009
@@ -35,7 +35,7 @@
 
 #include "core/gimp.h"
 #include "core/gimpcontainer.h"
-#include "core/gimpdrawable.h"
+#include "core/gimpdrawable-private.h" /* eek */
 #include "core/gimpgrid.h"
 #include "core/gimpimage.h"
 #include "core/gimpimage-colormap.h"
@@ -801,10 +801,10 @@
                                   gimp_item_get_height (GIMP_ITEM (*channel)));
             g_object_ref_sink (mask);
 
-            tile_manager_unref (GIMP_DRAWABLE (mask)->tiles);
-            GIMP_DRAWABLE (mask)->tiles =
-              GIMP_DRAWABLE (*channel)->tiles;
-            GIMP_DRAWABLE (*channel)->tiles = NULL;
+            tile_manager_unref (GIMP_DRAWABLE (mask)->private->tiles);
+            GIMP_DRAWABLE (mask)->private->tiles =
+              GIMP_DRAWABLE (*channel)->private->tiles;
+            GIMP_DRAWABLE (*channel)->private->tiles = NULL;
             g_object_unref (*channel);
             *channel = mask;
             (*channel)->boundary_known = FALSE;