From 336d7761c8d318ec4bf775c1a5a455cfea5e72e7 Mon Sep 17 00:00:00 2001 From: Michael Natterer Date: Wed, 31 Jan 2007 19:13:12 +0000 Subject: [PATCH] app/core/Makefile.am app/core/core-types.h new undo class for 2007-01-31 Michael Natterer * app/core/Makefile.am * app/core/core-types.h * app/core/gimpdrawablemodundo.[ch]: new undo class for GIMP_UNDO_DRAWABLE_MOD. * app/core/gimpimage-undo-push.c: use it here. svn path=/trunk/; revision=21824 --- ChangeLog | 9 ++ app/core/Makefile.am | 2 + app/core/core-types.h | 1 + app/core/gimpdrawablemodundo.c | 151 +++++++++++++++++++++++++++++++++ app/core/gimpdrawablemodundo.h | 55 ++++++++++++ app/core/gimpimage-undo-push.c | 103 +++------------------- 6 files changed, 229 insertions(+), 92 deletions(-) create mode 100644 app/core/gimpdrawablemodundo.c create mode 100644 app/core/gimpdrawablemodundo.h diff --git a/ChangeLog b/ChangeLog index 6ad16a8039..c52970a599 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,3 +1,12 @@ +2007-01-31 Michael Natterer + + * app/core/Makefile.am + * app/core/core-types.h + * app/core/gimpdrawablemodundo.[ch]: new undo class for + GIMP_UNDO_DRAWABLE_MOD. + + * app/core/gimpimage-undo-push.c: use it here. + 2007-01-31 Michael Natterer * app/core/Makefile.am diff --git a/app/core/Makefile.am b/app/core/Makefile.am index 1212712f34..cf1f49619f 100644 --- a/app/core/Makefile.am +++ b/app/core/Makefile.am @@ -126,6 +126,8 @@ libappcore_a_sources = \ gimpdrawable-stroke.h \ gimpdrawable-transform.c \ gimpdrawable-transform.h \ + gimpdrawablemodundo.c \ + gimpdrawablemodundo.h \ gimpdrawableundo.c \ gimpdrawableundo.h \ gimpgradient.c \ diff --git a/app/core/core-types.h b/app/core/core-types.h index 468edb02a4..8f433e6c43 100644 --- a/app/core/core-types.h +++ b/app/core/core-types.h @@ -116,6 +116,7 @@ typedef struct _GimpItemPropUndo GimpItemPropUndo; typedef struct _GimpChannelUndo GimpChannelUndo; typedef struct _GimpChannelPropUndo GimpChannelPropUndo; typedef struct _GimpDrawableUndo GimpDrawableUndo; +typedef struct _GimpDrawableModUndo GimpDrawableModUndo; typedef struct _GimpLayerMaskUndo GimpLayerMaskUndo; typedef struct _GimpLayerMaskPropUndo GimpLayerMaskPropUndo; typedef struct _GimpLayerUndo GimpLayerUndo; diff --git a/app/core/gimpdrawablemodundo.c b/app/core/gimpdrawablemodundo.c new file mode 100644 index 0000000000..719bcbbc02 --- /dev/null +++ b/app/core/gimpdrawablemodundo.c @@ -0,0 +1,151 @@ +/* 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 2 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, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + +#include "config.h" + +#include + +#include "core-types.h" + +#include "base/tile-manager.h" + +#include "gimpimage.h" +#include "gimpdrawable.h" +#include "gimpdrawablemodundo.h" + + +static GObject * gimp_drawable_mod_undo_constructor (GType type, + guint n_params, + GObjectConstructParam *params); + +static gint64 gimp_drawable_mod_undo_get_memsize (GimpObject *object, + gint64 *gui_size); + +static void gimp_drawable_mod_undo_pop (GimpUndo *undo, + GimpUndoMode undo_mode, + GimpUndoAccumulator *accum); +static void gimp_drawable_mod_undo_free (GimpUndo *undo, + GimpUndoMode undo_mode); + + +G_DEFINE_TYPE (GimpDrawableModUndo, gimp_drawable_mod_undo, GIMP_TYPE_ITEM_UNDO) + +#define parent_class gimp_drawable_mod_undo_parent_class + + +static void +gimp_drawable_mod_undo_class_init (GimpDrawableModUndoClass *klass) +{ + GObjectClass *object_class = G_OBJECT_CLASS (klass); + GimpObjectClass *gimp_object_class = GIMP_OBJECT_CLASS (klass); + GimpUndoClass *undo_class = GIMP_UNDO_CLASS (klass); + + object_class->constructor = gimp_drawable_mod_undo_constructor; + + gimp_object_class->get_memsize = gimp_drawable_mod_undo_get_memsize; + + undo_class->pop = gimp_drawable_mod_undo_pop; + undo_class->free = gimp_drawable_mod_undo_free; +} + +static void +gimp_drawable_mod_undo_init (GimpDrawableModUndo *undo) +{ +} + +static GObject * +gimp_drawable_mod_undo_constructor (GType type, + guint n_params, + GObjectConstructParam *params) +{ + GObject *object; + GimpDrawableModUndo *drawable_mod_undo; + GimpDrawable *drawable; + + object = G_OBJECT_CLASS (parent_class)->constructor (type, n_params, params); + + drawable_mod_undo = GIMP_DRAWABLE_MOD_UNDO (object); + + g_assert (GIMP_IS_DRAWABLE (GIMP_ITEM_UNDO (object)->item)); + + drawable = GIMP_DRAWABLE (GIMP_ITEM_UNDO (object)->item); + + drawable_mod_undo->tiles = tile_manager_ref (drawable->tiles); + drawable_mod_undo->type = drawable->type; + drawable_mod_undo->offset_x = GIMP_ITEM (drawable)->offset_x; + drawable_mod_undo->offset_y = GIMP_ITEM (drawable)->offset_y; + + return object; +} + +static gint64 +gimp_drawable_mod_undo_get_memsize (GimpObject *object, + gint64 *gui_size) +{ + 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, + gui_size); +} + +static void +gimp_drawable_mod_undo_pop (GimpUndo *undo, + GimpUndoMode undo_mode, + GimpUndoAccumulator *accum) +{ + GimpDrawableModUndo *drawable_mod_undo = GIMP_DRAWABLE_MOD_UNDO (undo); + GimpDrawable *drawable = GIMP_DRAWABLE (GIMP_ITEM_UNDO (undo)->item); + TileManager *tiles; + GimpImageType type; + gint offset_x, offset_y; + + GIMP_UNDO_CLASS (parent_class)->pop (undo, undo_mode, accum); + + tiles = drawable_mod_undo->tiles; + type = drawable_mod_undo->type; + offset_x = drawable_mod_undo->offset_x; + offset_y = drawable_mod_undo->offset_y; + + drawable_mod_undo->tiles = tile_manager_ref (drawable->tiles); + drawable_mod_undo->type = drawable->type; + drawable_mod_undo->offset_x = GIMP_ITEM (drawable)->offset_x; + drawable_mod_undo->offset_y = GIMP_ITEM (drawable)->offset_y; + + gimp_drawable_set_tiles_full (drawable, FALSE, NULL, + tiles, type, offset_x, offset_y); + tile_manager_unref (tiles); +} + +static void +gimp_drawable_mod_undo_free (GimpUndo *undo, + GimpUndoMode undo_mode) +{ + GimpDrawableModUndo *drawable_mod_undo = GIMP_DRAWABLE_MOD_UNDO (undo); + + if (drawable_mod_undo->tiles) + { + tile_manager_unref (drawable_mod_undo->tiles); + drawable_mod_undo->tiles = NULL; + } + + GIMP_UNDO_CLASS (parent_class)->free (undo, undo_mode); +} diff --git a/app/core/gimpdrawablemodundo.h b/app/core/gimpdrawablemodundo.h new file mode 100644 index 0000000000..2823594d6d --- /dev/null +++ b/app/core/gimpdrawablemodundo.h @@ -0,0 +1,55 @@ +/* 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 2 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, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + +#ifndef __GIMP_DRAWABLE_UNDO_H__ +#define __GIMP_DRAWABLE_MOD_UNDO_H__ + + +#include "gimpitemundo.h" + + +#define GIMP_TYPE_DRAWABLE_MOD_UNDO (gimp_drawable_mod_undo_get_type ()) +#define GIMP_DRAWABLE_MOD_UNDO(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_DRAWABLE_MOD_UNDO, GimpDrawableModUndo)) +#define GIMP_DRAWABLE_MOD_UNDO_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_DRAWABLE_MOD_UNDO, GimpDrawableModUndoClass)) +#define GIMP_IS_DRAWABLE_MOD_UNDO(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GIMP_TYPE_DRAWABLE_MOD_UNDO)) +#define GIMP_IS_DRAWABLE_MOD_UNDO_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_DRAWABLE_MOD_UNDO)) +#define GIMP_DRAWABLE_MOD_UNDO_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GIMP_TYPE_DRAWABLE_MOD_UNDO, GimpDrawableModUndoClass)) + + +typedef struct _GimpDrawableModUndoClass GimpDrawableModUndoClass; + +struct _GimpDrawableModUndo +{ + GimpItemUndo parent_instance; + + TileManager *tiles; + GimpImageType type; + gint offset_x; + gint offset_y; +}; + +struct _GimpDrawableModUndoClass +{ + GimpItemUndoClass parent_class; +}; + + +GType gimp_drawable_mod_undo_get_type (void) G_GNUC_CONST; + + +#endif /* __GIMP_DRAWABLE_MOD_UNDO_H__ */ diff --git a/app/core/gimpimage-undo-push.c b/app/core/gimpimage-undo-push.c index d7e50d105a..441f815e06 100644 --- a/app/core/gimpimage-undo-push.c +++ b/app/core/gimpimage-undo-push.c @@ -31,6 +31,7 @@ #include "gimp-parasites.h" #include "gimpchannelpropundo.h" #include "gimpchannelundo.h" +#include "gimpdrawablemodundo.h" #include "gimpdrawableundo.h" #include "gimpgrid.h" #include "gimpguide.h" @@ -180,9 +181,9 @@ gimp_image_undo_push_sample_point (GimpImage *image, } -/*******************/ -/* Drawable Undo */ -/*******************/ +/********************/ +/* Drawable Undos */ +/********************/ GimpUndo * gimp_image_undo_push_drawable (GimpImage *image, @@ -230,104 +231,22 @@ gimp_image_undo_push_drawable (GimpImage *image, NULL); } - -/***********************/ -/* Drawable Mod Undo */ -/***********************/ - -typedef struct _DrawableModUndo DrawableModUndo; - -struct _DrawableModUndo -{ - TileManager *tiles; - GimpImageType type; - gint offset_x; - gint offset_y; -}; - -static gboolean undo_pop_drawable_mod (GimpUndo *undo, - GimpUndoMode undo_mode, - GimpUndoAccumulator *accum); -static void undo_free_drawable_mod (GimpUndo *undo, - GimpUndoMode undo_mode); - GimpUndo * gimp_image_undo_push_drawable_mod (GimpImage *image, const gchar *undo_desc, GimpDrawable *drawable) { - GimpUndo *new; - gint64 size; - g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL); g_return_val_if_fail (GIMP_IS_DRAWABLE (drawable), NULL); g_return_val_if_fail (gimp_item_is_attached (GIMP_ITEM (drawable)), NULL); - size = sizeof (DrawableModUndo) + tile_manager_get_memsize (drawable->tiles, - FALSE); - - if ((new = gimp_image_undo_push (image, GIMP_TYPE_ITEM_UNDO, - size, sizeof (DrawableModUndo), - GIMP_UNDO_DRAWABLE_MOD, undo_desc, - GIMP_DIRTY_ITEM | GIMP_DIRTY_DRAWABLE, - undo_pop_drawable_mod, - undo_free_drawable_mod, - "item", drawable, - NULL))) - { - DrawableModUndo *drawable_undo = new->data; - - drawable_undo->tiles = tile_manager_ref (drawable->tiles); - drawable_undo->type = drawable->type; - drawable_undo->offset_x = GIMP_ITEM (drawable)->offset_x; - drawable_undo->offset_y = GIMP_ITEM (drawable)->offset_y; - - return new; - } - - return NULL; -} - -static gboolean -undo_pop_drawable_mod (GimpUndo *undo, - GimpUndoMode undo_mode, - GimpUndoAccumulator *accum) -{ - DrawableModUndo *drawable_undo = undo->data; - GimpDrawable *drawable = GIMP_DRAWABLE (GIMP_ITEM_UNDO (undo)->item); - TileManager *tiles; - GimpImageType drawable_type; - gint offset_x, offset_y; - - undo->size -= tile_manager_get_memsize (drawable_undo->tiles, FALSE); - - tiles = drawable_undo->tiles; - drawable_type = drawable_undo->type; - offset_x = drawable_undo->offset_x; - offset_y = drawable_undo->offset_y; - - drawable_undo->tiles = tile_manager_ref (drawable->tiles); - drawable_undo->type = drawable->type; - drawable_undo->offset_x = GIMP_ITEM (drawable)->offset_x; - drawable_undo->offset_y = GIMP_ITEM (drawable)->offset_y; - - gimp_drawable_set_tiles_full (drawable, FALSE, NULL, - tiles, drawable_type, offset_x, offset_y); - tile_manager_unref (tiles); - - undo->size += tile_manager_get_memsize (drawable_undo->tiles, FALSE); - - return TRUE; -} - -static void -undo_free_drawable_mod (GimpUndo *undo, - GimpUndoMode undo_mode) -{ - DrawableModUndo *drawable_undo = undo->data; - - tile_manager_unref (drawable_undo->tiles); - g_free (drawable_undo); + return gimp_image_undo_push (image, GIMP_TYPE_DRAWABLE_MOD_UNDO, + 0, 0, + GIMP_UNDO_DRAWABLE_MOD, undo_desc, + GIMP_DIRTY_ITEM | GIMP_DIRTY_DRAWABLE, + NULL, NULL, + "item", drawable, + NULL); }