dnrops
/
gimp
mirror of https://github.com/GNOME/gimp.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

app/base/temp-buf.c app/base/tile-manager.c accept NULL in all 

2007-11-16  Michael Natterer  <mitch@gimp.org>

	* app/base/temp-buf.c
	* app/base/tile-manager.c
	* app/core/gimpobject.c: accept NULL in all get_memsize() functions.

	* app/core/gimp-utils.[ch]: ditto. Added gimp_string_get_memsize().

	* app/core/gimp.c
	* app/core/gimpbrush.c
	* app/core/gimpbuffer.c
	* app/core/gimpcontainer.c
	* app/core/gimpcontext.c
	* app/core/gimpdata.c
	* app/core/gimpdrawable.c
	* app/core/gimpdrawablemodundo.c
	* app/core/gimpdrawableundo.c
	* app/core/gimpimage.c
	* app/core/gimpitempropundo.c
	* app/core/gimplayer.c
	* app/core/gimpmaskundo.c
	* app/core/gimppalette.c
	* app/core/gimpparasitelist.c
	* app/core/gimppattern.c
	* app/core/gimppreviewcache.c
	* app/core/gimpundo.c
	* app/core/gimpundostack.c
	* app/core/gimpviewable.c
	* app/pdb/gimpprocedure.c
	* app/plug-in/gimpplugindef.c
	* app/plug-in/gimppluginmanager.c
	* app/plug-in/gimppluginprocedure.c
	* app/text/gimptext.c
	* app/text/gimptextlayer.c
	* app/text/gimptextundo.c
	* app/vectors/gimpvectorsmodundo.c: simplify
	GimpObject::get_memsize() implementations accordingly.

	* app/core/gimpimageundo.c: ditto. Always keep around colormaps in
	chunks of GIMP_IMAGE_COLORMAP_SIZE to be coonsistent with the
	other colormap handling code.


svn path=/trunk/; revision=24174
This commit is contained in:
Michael Natterer 2007-11-16 18:19:30 +00:00 committed by Michael Natterer
parent b9973273dd
commit 036085fd9e
35 changed files with 229 additions and 288 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

42
ChangeLog
View File

@ -1,3 +1,45 @@
2007-11-16 Michael Natterer <mitch@gimp.org>
* app/base/temp-buf.c
* app/base/tile-manager.c
* app/core/gimpobject.c: accept NULL in all get_memsize() functions.
* app/core/gimp-utils.[ch]: ditto. Added gimp_string_get_memsize().
* app/core/gimp.c
* app/core/gimpbrush.c
* app/core/gimpbuffer.c
* app/core/gimpcontainer.c
* app/core/gimpcontext.c
* app/core/gimpdata.c
* app/core/gimpdrawable.c
* app/core/gimpdrawablemodundo.c
* app/core/gimpdrawableundo.c
* app/core/gimpimage.c
* app/core/gimpitempropundo.c
* app/core/gimplayer.c
* app/core/gimpmaskundo.c
* app/core/gimppalette.c
* app/core/gimpparasitelist.c
* app/core/gimppattern.c
* app/core/gimppreviewcache.c
* app/core/gimpundo.c
* app/core/gimpundostack.c
* app/core/gimpviewable.c
* app/pdb/gimpprocedure.c
* app/plug-in/gimpplugindef.c
* app/plug-in/gimppluginmanager.c
* app/plug-in/gimppluginprocedure.c
* app/text/gimptext.c
* app/text/gimptextlayer.c
* app/text/gimptextundo.c
* app/vectors/gimpvectorsmodundo.c: simplify
GimpObject::get_memsize() implementations accordingly.
* app/core/gimpimageundo.c: ditto. Always keep around colormaps in
chunks of GIMP_IMAGE_COLORMAP_SIZE to be coonsistent with the
other colormap handling code.
2007-11-16 Sven Neumann <sven@gimp.org>
* app/base/lut-funcs.c (equalize_lut_setup): make sure we don't

11
app/base/temp-buf.c
View File

@ -373,14 +373,11 @@ temp_buf_data_clear (TempBuf *temp_buf)
gsize
temp_buf_get_memsize (TempBuf *temp_buf)
{
gsize memsize = 0;
if (temp_buf)
return (sizeof (TempBuf) +
(gsize) temp_buf->bytes * temp_buf->width * temp_buf->height);
g_return_val_if_fail (temp_buf != NULL, 0);
memsize += (sizeof (TempBuf)
+ (gsize) temp_buf->bytes * temp_buf->width * temp_buf->height);
return memsize;
return 0;
}

3
app/base/tile-manager.c
View File

@ -569,7 +569,8 @@ tile_manager_get_memsize (const TileManager *tm,
/* the tile manager itself */
gint64 memsize = sizeof (TileManager);
g_return_val_if_fail (tm != NULL, 0);
if (! tm)
return 0;
/* the array of tiles */
memsize += (gint64) tm->ntile_rows * tm->ntile_cols * (sizeof (Tile) +

86
app/core/gimp-utils.c
View File

@ -59,38 +59,38 @@
gint64
gimp_g_type_instance_get_memsize (GTypeInstance *instance)
{
if (instance)
{
GTypeQuery type_query;
gint64 memsize = 0;
g_return_val_if_fail (instance != NULL, 0);
g_type_query (G_TYPE_FROM_INSTANCE (instance), &type_query);
memsize += type_query.instance_size;
return type_query.instance_size;
}
return memsize;
return 0;
}
gint64
gimp_g_object_get_memsize (GObject *object)
{
gint64 memsize = 0;
if (object)
return gimp_g_type_instance_get_memsize ((GTypeInstance *) object);
g_return_val_if_fail (G_IS_OBJECT (object), 0);
return memsize + gimp_g_type_instance_get_memsize ((GTypeInstance *) object);
return 0;
}
gint64
gimp_g_hash_table_get_memsize (GHashTable *hash,
gint64 data_size)
{
g_return_val_if_fail (hash != NULL, 0);
if (hash)
return (2 * sizeof (gint) +
5 * sizeof (gpointer) +
g_hash_table_size (hash) * (3 * sizeof (gpointer) + data_size));
return 0;
}
typedef struct
@ -118,9 +118,11 @@ gimp_g_hash_table_get_memsize_foreach (GHashTable *hash,
{
HashMemsize memsize;
g_return_val_if_fail (hash != NULL, 0);
g_return_val_if_fail (func != NULL, 0);
if (! hash)
return 0;
memsize.func = func;
memsize.memsize = 0;
memsize.gui_size = 0;
@ -182,14 +184,14 @@ gimp_g_list_get_memsize_foreach (GList *list,
gint64
gimp_g_value_get_memsize (GValue *value)
{
gint64 memsize = sizeof (GValue);
gint64 memsize = 0;
if (! value)
return 0;
if (G_VALUE_HOLDS_STRING (value))
{
const gchar *str = g_value_get_string (value);
if (str)
memsize += strlen (str) + 1;
memsize += gimp_string_get_memsize (g_value_get_string (value));
}
else if (G_VALUE_HOLDS_BOXED (value))
{
@ -203,11 +205,8 @@ gimp_g_value_get_memsize (GValue *value)
}
else if (GIMP_VALUE_HOLDS_PARASITE (value))
{
GimpParasite *parasite = g_value_get_boxed (value);
if (parasite)
memsize += (sizeof (GimpParasite) + parasite->size +
parasite->name ? (strlen (parasite->name) + 1) : 0);
memsize += gimp_parasite_get_memsize (g_value_get_boxed (value),
NULL);
}
else if (GIMP_VALUE_HOLDS_ARRAY (value) ||
GIMP_VALUE_HOLDS_INT8_ARRAY (value) ||
@ -237,7 +236,7 @@ gimp_g_value_get_memsize (GValue *value)
memsize += array->length * sizeof (gchar *);
for (i = 0; i < array->length; i++)
memsize += strlen (tmp[i]) + 1;
memsize += gimp_string_get_memsize (tmp[i]);
}
}
}
@ -253,51 +252,48 @@ gimp_g_value_get_memsize (GValue *value)
G_STRFUNC, G_VALUE_TYPE_NAME (value));
}
return memsize;
return memsize + sizeof (GValue);
}
gint64
gimp_g_param_spec_get_memsize (GParamSpec *pspec)
{
const gchar *str;
gint64 memsize = 0;
if (! pspec)
return 0;
if (! (pspec->flags & G_PARAM_STATIC_NAME))
{
str = g_param_spec_get_name (pspec);
if (str)
memsize += strlen (str) + 1;
}
memsize += gimp_string_get_memsize (g_param_spec_get_name (pspec));
if (! (pspec->flags & G_PARAM_STATIC_NICK))
{
str = g_param_spec_get_nick (pspec);
if (str)
memsize += strlen (str) + 1;
}
memsize += gimp_string_get_memsize (g_param_spec_get_nick (pspec));
if (! (pspec->flags & G_PARAM_STATIC_BLURB))
{
str = g_param_spec_get_blurb (pspec);
if (str)
memsize += strlen (str) + 1;
}
memsize += gimp_string_get_memsize (g_param_spec_get_blurb (pspec));
return memsize + gimp_g_type_instance_get_memsize ((GTypeInstance *) pspec);
}
gint64
gimp_string_get_memsize (const gchar *string)
{
if (string)
return strlen (string) + 1;
return 0;
}
gint64
gimp_parasite_get_memsize (GimpParasite *parasite,
gint64 *gui_size)
{
gint64 memsize = 0;
if (parasite)
memsize += (sizeof (GimpParasite) +
strlen (parasite->name) + 1 +
return (sizeof (GimpParasite) +
gimp_string_get_memsize (parasite->name) +
parasite->size);
return memsize;
return 0;
}

1
app/core/gimp-utils.h
View File

@ -40,6 +40,7 @@ gint64 gimp_g_list_get_memsize_foreach (GList *slist,
gint64 gimp_g_value_get_memsize (GValue *value);
gint64 gimp_g_param_spec_get_memsize (GParamSpec *pspec);
gint64 gimp_string_get_memsize (const gchar *string);
gint64 gimp_parasite_get_memsize (GimpParasite *parasite,
gint64 *gui_size);

56
app/core/gimp.c
View File

@ -438,49 +438,49 @@ gimp_get_memsize (GimpObject *object,
gui_size);
memsize += gimp_g_object_get_memsize (G_OBJECT (gimp->module_db));
memsize += gimp_g_object_get_memsize (G_OBJECT (gimp->plug_in_manager));
memsize += gimp_object_get_memsize (GIMP_OBJECT (gimp->plug_in_manager),
gui_size);
memsize += gimp_g_hash_table_get_memsize (gimp->image_table, 0);
memsize += gimp_g_hash_table_get_memsize (gimp->item_table, 0);
memsize += gimp_object_get_memsize (GIMP_OBJECT (gimp->displays), gui_size);
if (gimp->global_buffer)
memsize += gimp_object_get_memsize (GIMP_OBJECT (gimp->global_buffer),
gui_size);
memsize += (gimp_object_get_memsize (GIMP_OBJECT (gimp->named_buffers),
gui_size) +
gimp_object_get_memsize (GIMP_OBJECT (gimp->fonts),
gui_size) +
gimp_object_get_memsize (GIMP_OBJECT (gimp->brush_factory),
gui_size) +
gimp_object_get_memsize (GIMP_OBJECT (gimp->pattern_factory),
gui_size) +
gimp_object_get_memsize (GIMP_OBJECT (gimp->gradient_factory),
gui_size) +
gimp_object_get_memsize (GIMP_OBJECT (gimp->palette_factory),
gui_size));
memsize += gimp_object_get_memsize (GIMP_OBJECT (gimp->named_buffers),
gui_size);
memsize += gimp_object_get_memsize (GIMP_OBJECT (gimp->fonts),
gui_size);
memsize += gimp_object_get_memsize (GIMP_OBJECT (gimp->brush_factory),
gui_size);
memsize += gimp_object_get_memsize (GIMP_OBJECT (gimp->pattern_factory),
gui_size);
memsize += gimp_object_get_memsize (GIMP_OBJECT (gimp->gradient_factory),
gui_size);
memsize += gimp_object_get_memsize (GIMP_OBJECT (gimp->palette_factory),
gui_size);
memsize += gimp_object_get_memsize (GIMP_OBJECT (gimp->pdb), gui_size);
memsize += (gimp_object_get_memsize (GIMP_OBJECT (gimp->tool_info_list),
gui_size) +
gimp_object_get_memsize (GIMP_OBJECT (gimp->standard_tool_info),
gui_size) +
gimp_object_get_memsize (GIMP_OBJECT (gimp->documents),
gui_size) +
gimp_object_get_memsize (GIMP_OBJECT (gimp->templates),
gui_size) +
gimp_object_get_memsize (GIMP_OBJECT (gimp->image_new_last_template),
gui_size));
memsize += gimp_object_get_memsize (GIMP_OBJECT (gimp->tool_info_list),
gui_size);
memsize += gimp_object_get_memsize (GIMP_OBJECT (gimp->standard_tool_info),
gui_size);
memsize += gimp_object_get_memsize (GIMP_OBJECT (gimp->documents),
gui_size);
memsize += gimp_object_get_memsize (GIMP_OBJECT (gimp->templates),
gui_size);
memsize += gimp_object_get_memsize (GIMP_OBJECT (gimp->image_new_last_template),
gui_size);
memsize += gimp_g_list_get_memsize (gimp->context_list, 0);
memsize += (gimp_object_get_memsize (GIMP_OBJECT (gimp->default_context),
gui_size) +
gimp_object_get_memsize (GIMP_OBJECT (gimp->user_context),
gui_size));
memsize += gimp_object_get_memsize (GIMP_OBJECT (gimp->default_context),
gui_size);
memsize += gimp_object_get_memsize (GIMP_OBJECT (gimp->user_context),
gui_size);
return memsize + GIMP_OBJECT_CLASS (parent_class)->get_memsize (object,
gui_size);

3
app/core/gimpbrush.c
View File

@ -211,10 +211,7 @@ gimp_brush_get_memsize (GimpObject *object,
GimpBrush *brush = GIMP_BRUSH (object);
gint64 memsize = 0;
if (brush->mask)
memsize += temp_buf_get_memsize (brush->mask);
if (brush->pixmap)
memsize += temp_buf_get_memsize (brush->pixmap);
return memsize + GIMP_OBJECT_CLASS (parent_class)->get_memsize (object,

1
app/core/gimpbuffer.c
View File

@ -113,7 +113,6 @@ gimp_buffer_get_memsize (GimpObject *object,
GimpBuffer *buffer = GIMP_BUFFER (object);
gint64 memsize = 0;
if (buffer->tiles)
memsize += tile_manager_get_memsize (buffer->tiles, FALSE);
return memsize + GIMP_OBJECT_CLASS (parent_class)->get_memsize (object,

5
app/core/gimpcontainer.c
View File

@ -21,8 +21,6 @@
#include "config.h"
#include <string.h>
#include <glib-object.h>
#include "libgimpconfig/gimpconfig.h"
@ -30,6 +28,7 @@
#include "core-types.h"
#include "gimp.h"
#include "gimp-utils.h"
#include "gimpcontainer.h"
#include "gimpmarshal.h"
@ -298,7 +297,7 @@ gimp_container_get_memsize (GimpObject *object,
memsize += (sizeof (GList) +
sizeof (GimpContainerHandler) +
strlen (handler->signame) + 1);
gimp_string_get_memsize (handler->signame));
}
return memsize + GIMP_OBJECT_CLASS (parent_class)->get_memsize (object,

38
app/core/gimpcontext.c
View File

@ -21,8 +21,6 @@
#include "config.h"
#include <string.h>
#include <glib-object.h>
#include "libgimpbase/gimpbase.h"
@ -34,6 +32,7 @@
#include "config/gimpcoreconfig.h"
#include "gimp.h"
#include "gimp-utils.h"
#include "gimpbrush.h"
#include "gimpbuffer.h"
#include "gimpcontainer.h"
@ -1090,32 +1089,15 @@ gimp_context_get_memsize (GimpObject *object,
GimpContext *context = GIMP_CONTEXT (object);
gint64 memsize = 0;
if (context->tool_name)
memsize += strlen (context->tool_name) + 1;
if (context->paint_name)
memsize += strlen (context->paint_name) + 1;
if (context->brush_name)
memsize += strlen (context->brush_name) + 1;
if (context->pattern_name)
memsize += strlen (context->pattern_name) + 1;
if (context->palette_name)
memsize += strlen (context->palette_name) + 1;
if (context->font_name)
memsize += strlen (context->font_name) + 1;
if (context->buffer_name)
memsize += strlen (context->buffer_name) + 1;
if (context->imagefile_name)
memsize += strlen (context->imagefile_name) + 1;
if (context->template_name)
memsize += strlen (context->template_name) + 1;
memsize += gimp_string_get_memsize (context->tool_name);
memsize += gimp_string_get_memsize (context->paint_name);
memsize += gimp_string_get_memsize (context->brush_name);
memsize += gimp_string_get_memsize (context->pattern_name);
memsize += gimp_string_get_memsize (context->palette_name);
memsize += gimp_string_get_memsize (context->font_name);
memsize += gimp_string_get_memsize (context->buffer_name);
memsize += gimp_string_get_memsize (context->imagefile_name);
memsize += gimp_string_get_memsize (context->template_name);
return memsize + GIMP_OBJECT_CLASS (parent_class)->get_memsize (object,
gui_size);

4
app/core/gimpdata.c
View File

@ -39,6 +39,7 @@
#include "core-types.h"
#include "gimp-utils.h"
#include "gimpdata.h"
#include "gimpmarshal.h"
@ -297,8 +298,7 @@ gimp_data_get_memsize (GimpObject *object,
GimpData *data = GIMP_DATA (object);
gint64 memsize = 0;
if (data->filename)
memsize += strlen (data->filename) + 1;
memsize += gimp_string_get_memsize (data->filename);
return memsize + GIMP_OBJECT_CLASS (parent_class)->get_memsize (object,
gui_size);

2
app/core/gimpdrawable.c
View File

@ -262,10 +262,8 @@ gimp_drawable_get_memsize (GimpObject *object,
GimpDrawable *drawable = GIMP_DRAWABLE (object);
gint64 memsize = 0;
if (drawable->tiles)
memsize += tile_manager_get_memsize (drawable->tiles, FALSE);
if (drawable->preview_cache)
*gui_size += gimp_preview_cache_get_memsize (drawable->preview_cache);
return memsize + GIMP_OBJECT_CLASS (parent_class)->get_memsize (object,

1
app/core/gimpdrawablemodundo.c
View File

@ -100,7 +100,6 @@ gimp_drawable_mod_undo_get_memsize (GimpObject *object,
GimpDrawableModUndo *drawable_mod_undo = GIMP_DRAWABLE_MOD_UNDO (object);
gint64 memsize = 0;
if (drawable_mod_undo->tiles)
memsize += tile_manager_get_memsize (drawable_mod_undo->tiles, FALSE);
return memsize + GIMP_OBJECT_CLASS (parent_class)->get_memsize (object,

1
app/core/gimpdrawableundo.c
View File

@ -222,7 +222,6 @@ gimp_drawable_undo_get_memsize (GimpObject *object,
GimpDrawableUndo *drawable_undo = GIMP_DRAWABLE_UNDO (object);
gint64 memsize = 0;
if (drawable_undo->tiles)
memsize += tile_manager_get_memsize (drawable_undo->tiles,
drawable_undo->sparse);

5
app/core/gimpimage.c
View File

@ -986,16 +986,13 @@ gimp_image_get_memsize (GimpObject *object,
if (image->cmap)
memsize += GIMP_IMAGE_COLORMAP_SIZE;
if (image->shadow)
memsize += tile_manager_get_memsize (image->shadow, FALSE);
if (image->projection)
memsize += gimp_object_get_memsize (GIMP_OBJECT (image->projection),
gui_size);
memsize += gimp_g_list_get_memsize (image->guides, sizeof (GimpGuide));
if (image->grid)
memsize += gimp_object_get_memsize (GIMP_OBJECT (image->grid), gui_size);
memsize += gimp_g_list_get_memsize (image->sample_points,
@ -1010,7 +1007,6 @@ gimp_image_get_memsize (GimpObject *object,
memsize += gimp_g_slist_get_memsize (image->layer_stack, 0);
if (image->selection_mask)
memsize += gimp_object_get_memsize (GIMP_OBJECT (image->selection_mask),
gui_size);
@ -1022,7 +1018,6 @@ gimp_image_get_memsize (GimpObject *object,
memsize += gimp_object_get_memsize (GIMP_OBJECT (image->redo_stack),
gui_size);
if (image->preview)
*gui_size += temp_buf_get_memsize (image->preview);
return memsize + GIMP_OBJECT_CLASS (parent_class)->get_memsize (object,

18
app/core/gimpimageundo.c
View File

@ -28,6 +28,7 @@
#include "core-types.h"
#include "gimp-utils.h"
#include "gimpdrawable.h"
#include "gimpgrid.h"
#include "gimpimage.h"
@ -146,7 +147,7 @@ gimp_image_undo_constructor (GType type,
case GIMP_UNDO_IMAGE_COLORMAP:
image_undo->num_colors = gimp_image_get_colormap_size (image);
image_undo->colormap = g_memdup (gimp_image_get_colormap (image),
image_undo->num_colors * 3);
GIMP_IMAGE_COLORMAP_SIZE);
break;
case GIMP_UNDO_PARASITE_ATTACH:
@ -223,19 +224,12 @@ gimp_image_undo_get_memsize (GimpObject *object,
gint64 memsize = 0;
if (image_undo->colormap)
memsize += image_undo->num_colors * 3;
memsize += GIMP_IMAGE_COLORMAP_SIZE;
if (image_undo->grid)
memsize += gimp_object_get_memsize (GIMP_OBJECT (image_undo->grid),
gui_size);
if (image_undo->parasite_name)
memsize += strlen (image_undo->parasite_name) + 1;
if (image_undo->parasite)
memsize += (sizeof (GimpParasite) +
strlen (image_undo->parasite->name) + 1 +
image_undo->parasite->size);
memsize += gimp_string_get_memsize (image_undo->parasite_name);
memsize += gimp_parasite_get_memsize (image_undo->parasite, gui_size);
return memsize + GIMP_OBJECT_CLASS (parent_class)->get_memsize (object,
gui_size);
@ -344,7 +338,7 @@ gimp_image_undo_pop (GimpUndo *undo,
num_colors = gimp_image_get_colormap_size (image);
colormap = g_memdup (gimp_image_get_colormap (image),
num_colors * 3);
GIMP_IMAGE_COLORMAP_SIZE);
gimp_image_set_colormap (image,
image_undo->colormap, image_undo->num_colors,

16
app/core/gimpitempropundo.c
View File

@ -18,14 +18,13 @@
#include "config.h"
#include <string.h>
#include <glib-object.h>
#include "libgimpbase/gimpbase.h"
#include "core-types.h"
#include "gimp-utils.h"
#include "gimpitem.h"
#include "gimpitempropundo.h"
#include "gimpparasitelist.h"
@ -191,16 +190,9 @@ gimp_item_prop_undo_get_memsize (GimpObject *object,
GimpItemPropUndo *item_prop_undo = GIMP_ITEM_PROP_UNDO (object);
gint64 memsize = 0;
if (item_prop_undo->name)
memsize += strlen (item_prop_undo->name) + 1;
if (item_prop_undo->parasite_name)
memsize += strlen (item_prop_undo->parasite_name) + 1;
if (item_prop_undo->parasite)
memsize += (sizeof (GimpParasite) +
strlen (item_prop_undo->parasite->name) + 1 +
item_prop_undo->parasite->size);
memsize += gimp_string_get_memsize (item_prop_undo->name);
memsize += gimp_string_get_memsize (item_prop_undo->parasite_name);
memsize += gimp_parasite_get_memsize (item_prop_undo->parasite, NULL);
return memsize + GIMP_OBJECT_CLASS (parent_class)->get_memsize (object,
gui_size);

3
app/core/gimplayer.c
View File

@ -411,12 +411,9 @@ gimp_layer_get_memsize (GimpObject *object,
GimpLayer *layer = GIMP_LAYER (object);
gint64 memsize = 0;
if (layer->mask)
memsize += gimp_object_get_memsize (GIMP_OBJECT (layer->mask), gui_size);
if (layer->fs.backing_store)
*gui_size += tile_manager_get_memsize (layer->fs.backing_store, FALSE);
*gui_size += layer->fs.num_segs * sizeof (BoundSeg);
return memsize + GIMP_OBJECT_CLASS (parent_class)->get_memsize (object,

1
app/core/gimpmaskundo.c
View File

@ -116,7 +116,6 @@ gimp_mask_undo_get_memsize (GimpObject *object,
GimpMaskUndo *mask_undo = GIMP_MASK_UNDO (object);
gint64 memsize = 0;
if (mask_undo->tiles)
memsize += tile_manager_get_memsize (mask_undo->tiles, FALSE);
return memsize + GIMP_OBJECT_CLASS (parent_class)->get_memsize (object,

14
app/core/gimpobject.c
View File

@ -388,7 +388,15 @@ gimp_object_get_memsize (GimpObject *object,
gint64 my_size = 0;
gint64 my_gui_size = 0;
g_return_val_if_fail (GIMP_IS_OBJECT (object), 0);
g_return_val_if_fail (object == NULL || GIMP_IS_OBJECT (object), 0);
if (! object)
{
if (gui_size)
*gui_size = 0;
return 0;
}
#ifdef DEBUG_MEMSIZE
if (gimp_debug_memsize)
@ -461,8 +469,8 @@ gimp_object_real_get_memsize (GimpObject *object,
{
gint64 memsize = 0;
if (object->name && ! object->static_name)
memsize += strlen (object->name) + 1;
if (! object->static_name)
memsize += gimp_string_get_memsize (object->name);
return memsize + gimp_g_object_get_memsize ((GObject *) object);
}

3
app/core/gimppalette.c
View File

@ -503,8 +503,7 @@ gimp_palette_entry_get_memsize (GimpPaletteEntry *entry,
{
gint64 memsize = sizeof (GimpPaletteEntry);
if (entry->name)
memsize += strlen (entry->name) + 1;
memsize += gimp_string_get_memsize (entry->name);
return memsize;
}

1
app/core/gimpparasitelist.c
View File

@ -156,7 +156,6 @@ gimp_parasite_list_get_memsize (GimpObject *object,
GimpParasiteList *list = GIMP_PARASITE_LIST (object);
gint64 memsize = 0;
if (list->table)
memsize += gimp_g_hash_table_get_memsize_foreach (list->table,
(GimpMemsizeFunc)
gimp_parasite_get_memsize,

1
app/core/gimppattern.c
View File

@ -105,7 +105,6 @@ gimp_pattern_get_memsize (GimpObject *object,
GimpPattern *pattern = GIMP_PATTERN (object);
gint64 memsize = 0;
if (pattern->mask)
memsize += temp_buf_get_memsize (pattern->mask);
return memsize + GIMP_OBJECT_CLASS (parent_class)->get_memsize (object,

3
app/core/gimppreviewcache.c
View File

@ -283,7 +283,8 @@ gimp_preview_cache_get_memsize (GSList *cache)
GSList *list;
gsize memsize = 0;
g_return_val_if_fail (cache != NULL, 0);
if (! cache)
return 0;
for (list = cache; list; list = list->next)
memsize += sizeof (GSList) + temp_buf_get_memsize ((TempBuf *) list->data);

1
app/core/gimpundo.c
View File

@ -280,7 +280,6 @@ gimp_undo_get_memsize (GimpObject *object,
GimpUndo *undo = GIMP_UNDO (object);
gint64 memsize = 0;
if (undo->preview)
*gui_size += temp_buf_get_memsize (undo->preview);
return memsize + GIMP_OBJECT_CLASS (parent_class)->get_memsize (object,

1
app/core/gimpundostack.c
View File

@ -87,7 +87,6 @@ gimp_undo_stack_get_memsize (GimpObject *object,
GimpUndoStack *stack = GIMP_UNDO_STACK (object);
gint64 memsize = 0;
if (stack->undos)
memsize += gimp_object_get_memsize (GIMP_OBJECT (stack->undos), gui_size);
return memsize + GIMP_OBJECT_CLASS (parent_class)->get_memsize (object,

1
app/core/gimpviewable.c
View File

@ -249,7 +249,6 @@ gimp_viewable_get_memsize (GimpObject *object,
temp_buf = g_object_get_qdata (G_OBJECT (object), quark_preview_temp_buf);
pixbuf = g_object_get_qdata (G_OBJECT (object), quark_preview_pixbuf);
if (temp_buf)
*gui_size += temp_buf_get_memsize (temp_buf);
if (pixbuf)

28
app/pdb/gimpprocedure.c
View File

@ -19,7 +19,6 @@
#include "config.h"
#include <stdarg.h>
#include <string.h>
#include <sys/types.h>
#include <glib-object.h>
@ -135,26 +134,13 @@ gimp_procedure_get_memsize (GimpObject *object,
if (! procedure->static_strings)
{
if (procedure->original_name)
memsize += strlen (procedure->original_name) + 1;
if (procedure->blurb)
memsize += strlen (procedure->blurb) + 1;
if (procedure->help)
memsize += strlen (procedure->help) + 1;
if (procedure->author)
memsize += strlen (procedure->author) + 1;
if (procedure->copyright)
memsize += strlen (procedure->copyright) + 1;
if (procedure->date)
memsize += strlen (procedure->date) + 1;
if (procedure->deprecated)
memsize += strlen (procedure->deprecated) + 1;
memsize += gimp_string_get_memsize (procedure->original_name);
memsize += gimp_string_get_memsize (procedure->blurb);
memsize += gimp_string_get_memsize (procedure->help);
memsize += gimp_string_get_memsize (procedure->author);
memsize += gimp_string_get_memsize (procedure->copyright);
memsize += gimp_string_get_memsize (procedure->date);
memsize += gimp_string_get_memsize (procedure->deprecated);
}
memsize += procedure->num_args * sizeof (GParamSpec *);

21
app/plug-in/gimpplugindef.c
View File

@ -20,8 +20,6 @@
#include "config.h"
#include <string.h>
#include <glib-object.h>
#include "plug-in-types.h"
@ -83,20 +81,11 @@ gimp_plug_in_def_get_memsize (GimpObject *object,
GimpPlugInDef *plug_in_def = GIMP_PLUG_IN_DEF (object);
gint64 memsize = 0;
if (plug_in_def->prog)
memsize += strlen (plug_in_def->prog) + 1;
if (plug_in_def->locale_domain_name)
memsize += strlen (plug_in_def->locale_domain_name) + 1;
if (plug_in_def->locale_domain_path)
memsize += strlen (plug_in_def->locale_domain_path) + 1;
if (plug_in_def->help_domain_name)
memsize += strlen (plug_in_def->help_domain_name) + 1;
if (plug_in_def->help_domain_uri)
memsize += strlen (plug_in_def->help_domain_uri) + 1;
memsize += gimp_string_get_memsize (plug_in_def->prog);
memsize += gimp_string_get_memsize (plug_in_def->locale_domain_name);
memsize += gimp_string_get_memsize (plug_in_def->locale_domain_path);
memsize += gimp_string_get_memsize (plug_in_def->help_domain_name);
memsize += gimp_string_get_memsize (plug_in_def->help_domain_uri);
memsize += gimp_g_slist_get_memsize (plug_in_def->procedures, 0);

2
app/plug-in/gimppluginmanager.c
View File

@ -257,7 +257,7 @@ gimp_plug_in_manager_get_memsize (GimpObject *object,
(GimpMemsizeFunc)
gimp_object_get_memsize,
gui_size);
memsize += gimp_g_slist_get_memsize (manager->plug_in_stack, 0 /* FIXME */);
memsize += gimp_g_slist_get_memsize (manager->plug_in_stack, 0);
memsize += gimp_g_slist_get_memsize (manager->history, 0);
memsize += 0; /* FIXME manager->shm */

38
app/plug-in/gimppluginprocedure.c
View File

@ -30,6 +30,7 @@
#include "plug-in-types.h"
#include "core/gimp.h"
#include "core/gimp-utils.h"
#include "core/gimpmarshal.h"
#include "core/gimpparamspecs.h"
@ -157,21 +158,17 @@ gimp_plug_in_procedure_get_memsize (GimpObject *object,
GList *list;
GSList *slist;
if (proc->prog)
memsize += strlen (proc->prog) + 1;
if (proc->menu_label)
memsize += strlen (proc->menu_label) + 1;
memsize += gimp_string_get_memsize (proc->prog);
memsize += gimp_string_get_memsize (proc->menu_label);
for (list = proc->menu_paths; list; list = g_list_next (list))
memsize += sizeof (GList) + strlen (list->data) + 1;
memsize += sizeof (GList) + gimp_string_get_memsize (list->data);
switch (proc->icon_type)
{
case GIMP_ICON_TYPE_STOCK_ID:
case GIMP_ICON_TYPE_IMAGE_FILE:
if (proc->icon_data)
memsize += strlen ((gchar *) proc->icon_data) + 1;
memsize += gimp_string_get_memsize ((gchar *) proc->icon_data);
break;
case GIMP_ICON_TYPE_INLINE_PIXBUF:
@ -179,29 +176,20 @@ gimp_plug_in_procedure_get_memsize (GimpObject *object,
break;
}
if (proc->extensions)
memsize += strlen (proc->extensions) + 1;
if (proc->prefixes)
memsize += strlen (proc->prefixes) + 1;
if (proc->magics)
memsize += strlen (proc->magics) + 1;
if (proc->mime_type)
memsize += strlen (proc->mime_type) + 1;
if (proc->thumb_loader)
memsize += strlen (proc->thumb_loader) + 1;
memsize += gimp_string_get_memsize (proc->extensions);
memsize += gimp_string_get_memsize (proc->prefixes);
memsize += gimp_string_get_memsize (proc->magics);
memsize += gimp_string_get_memsize (proc->mime_type);
memsize += gimp_string_get_memsize (proc->thumb_loader);
for (slist = proc->extensions_list; slist; slist = g_slist_next (slist))
memsize += sizeof (GSList) + strlen (slist->data) + 1;
memsize += sizeof (GSList) + gimp_string_get_memsize (slist->data);
for (slist = proc->prefixes_list; slist; slist = g_slist_next (slist))
memsize += sizeof (GSList) + strlen (slist->data) + 1;
memsize += sizeof (GSList) + gimp_string_get_memsize (slist->data);
for (slist = proc->magics_list; slist; slist = g_slist_next (slist))
memsize += sizeof (GSList) + strlen (slist->data) + 1;
memsize += sizeof (GSList) + gimp_string_get_memsize (slist->data);
return memsize + GIMP_OBJECT_CLASS (parent_class)->get_memsize (object,
gui_size);

11
app/text/gimptext.c
View File

@ -464,14 +464,9 @@ gimp_text_get_memsize (GimpObject *object,
GimpText *text = GIMP_TEXT (object);
gint64 memsize = 0;
if (text->text)
memsize += strlen (text->text) + 1;
if (text->font)
memsize += strlen (text->font) + 1;
if (text->language)
memsize += strlen (text->language) + 1;
memsize += gimp_string_get_memsize (text->text);
memsize += gimp_string_get_memsize (text->font);
memsize += gimp_string_get_memsize (text->language);
return memsize + GIMP_OBJECT_CLASS (parent_class)->get_memsize (object,
gui_size);

5
app/text/gimptextlayer.c
View File

@ -226,12 +226,9 @@ static gint64
gimp_text_layer_get_memsize (GimpObject *object,
gint64 *gui_size)
{
GimpTextLayer *text_layer;
GimpTextLayer *text_layer = GIMP_TEXT_LAYER (object);
gint64 memsize = 0;
text_layer = GIMP_TEXT_LAYER (object);
if (text_layer->text)
memsize += gimp_object_get_memsize (GIMP_OBJECT (text_layer->text),
gui_size);

3
app/text/gimptextundo.c
View File

@ -189,10 +189,7 @@ gimp_text_undo_get_memsize (GimpObject *object,
GimpTextUndo *undo = GIMP_TEXT_UNDO (object);
gint64 memsize = 0;
if (undo->value)
memsize += gimp_g_value_get_memsize (undo->value);
if (undo->text)
memsize += gimp_object_get_memsize (GIMP_OBJECT (undo->text), NULL);
return memsize + GIMP_OBJECT_CLASS (parent_class)->get_memsize (object,

1
app/vectors/gimpvectorsmodundo.c
View File

@ -97,7 +97,6 @@ gimp_vectors_mod_undo_get_memsize (GimpObject *object,
GimpVectorsModUndo *vectors_mod_undo = GIMP_VECTORS_MOD_UNDO (object);
gint64 memsize = 0;
if (vectors_mod_undo->vectors)
memsize += gimp_object_get_memsize (GIMP_OBJECT (vectors_mod_undo->vectors),
gui_size);