From a1fd84119c06fe8be9542c4da31862c14723d773 Mon Sep 17 00:00:00 2001 From: Michael Natterer Date: Tue, 3 Feb 2009 23:57:11 +0000 Subject: [PATCH] app/core/Makefile.am new file which contains struct GimpDrawablePrivate. 2009-02-04 Michael Natterer * 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. svn path=/trunk/; revision=27982 --- ChangeLog | 13 +++ app/core/Makefile.am | 2 + app/core/gimpdrawable-private.h | 35 ++++++ app/core/gimpdrawable-shadow.c | 29 ++--- app/core/gimpdrawable.c | 181 +++++++++++++++++--------------- app/core/gimpdrawable.h | 16 +-- app/text/gimptextlayer-xcf.c | 7 +- app/xcf/xcf-load.c | 10 +- 8 files changed, 172 insertions(+), 121 deletions(-) create mode 100644 app/core/gimpdrawable-private.h diff --git a/ChangeLog b/ChangeLog index ece66fbb13..23d86fda82 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,3 +1,16 @@ +2009-02-04 Michael Natterer + + * 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. + 2009-02-02 Sven Neumann * app/display/gimpdisplayshell-title.c: reverted last change. It's diff --git a/app/core/Makefile.am b/app/core/Makefile.am index 6c19b37376..242678a8d2 100644 --- a/app/core/Makefile.am +++ b/app/core/Makefile.am @@ -148,6 +148,8 @@ libappcore_a_sources = \ gimpdrawable-posterize.h \ gimpdrawable-preview.c \ gimpdrawable-preview.h \ + gimpdrawable-private.c \ + gimpdrawable-private.h \ gimpdrawable-process.c \ gimpdrawable-process.h \ gimpdrawable-shadow.c \ diff --git a/app/core/gimpdrawable-private.h b/app/core/gimpdrawable-private.h new file mode 100644 index 0000000000..45259df969 --- /dev/null +++ b/app/core/gimpdrawable-private.h @@ -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 . + */ + +#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__ */ diff --git a/app/core/gimpdrawable-shadow.c b/app/core/gimpdrawable-shadow.c index 3a1ff05678..d17de46a2a 100644 --- a/app/core/gimpdrawable-shadow.c +++ b/app/core/gimpdrawable-shadow.c @@ -25,6 +25,7 @@ #include "base/tile-manager.h" #include "gimpdrawable.h" +#include "gimpdrawable-private.h" #include "gimpdrawable-shadow.h" @@ -37,25 +38,25 @@ gimp_drawable_get_shadow_tiles (GimpDrawable *drawable) 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 @@ gimp_drawable_free_shadow_tiles (GimpDrawable *drawable) { 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 @@ gimp_drawable_merge_shadow_tiles (GimpDrawable *drawable, 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 @@ gimp_drawable_merge_shadow_tiles (GimpDrawable *drawable, */ 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); diff --git a/app/core/gimpdrawable.c b/app/core/gimpdrawable.c index bdea5a2f82..472e2ab656 100644 --- a/app/core/gimpdrawable.c +++ b/app/core/gimpdrawable.c @@ -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 @@ gimp_drawable_class_init (GimpDrawableClass *klass) 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 @@ gimp_drawable_finalize (GObject *object) { 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 @@ gimp_drawable_get_memsize (GimpObject *object, 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_drawable_visibility_changed (GimpItem *item) ! (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 @@ gimp_drawable_real_update (GimpDrawable *drawable, 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 @@ gimp_drawable_real_estimate_memsize (const GimpDrawable *drawable, 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 @@ gimp_drawable_real_set_tiles (GimpDrawable *drawable, /* 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 @@ gimp_drawable_get_node (GimpItem *item) 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))) + 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->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 { @@ -913,107 +920,107 @@ gimp_drawable_sync_source_node (GimpDrawable *drawable, 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->private->source_node, + drawable->private->fs_opacity_node); + drawable->private->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->private->source_node, + drawable->private->fs_offset_node); + drawable->private->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_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 @@ gimp_drawable_configure (GimpDrawable *drawable, 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 @@ gimp_drawable_get_source_node (GimpDrawable *drawable) { 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 @@ gimp_drawable_get_mode_node (GimpDrawable *drawable) { 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 diff --git a/app/core/gimpdrawable.h b/app/core/gimpdrawable.h index 6589c6bc88..e89b4ec6cc 100644 --- a/app/core/gimpdrawable.h +++ b/app/core/gimpdrawable.h @@ -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 @@ struct _GimpDrawable /* Preview variables */ GSList *preview_cache; /* preview caches of the channel */ gboolean preview_valid; /* is the preview valid? */ + + GimpDrawablePrivate *private; }; struct _GimpDrawableClass diff --git a/app/text/gimptextlayer-xcf.c b/app/text/gimptextlayer-xcf.c index f547d630f7..bacff22ba9 100644 --- a/app/text/gimptextlayer-xcf.c +++ b/app/text/gimptextlayer-xcf.c @@ -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_text_layer_from_layer (GimpLayer *layer, 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_text_layer_from_layer (GimpLayer *layer, 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)); diff --git a/app/xcf/xcf-load.c b/app/xcf/xcf-load.c index d3ecd01ba8..a644d55ba1 100644 --- a/app/xcf/xcf-load.c +++ b/app/xcf/xcf-load.c @@ -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 @@ xcf_load_channel_props (XcfInfo *info, 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;