28e1a379e6
They are unreliable because every type checking cast discards them, they are useless anyway, visual clutter, added inconsistently, and generally suck. Wanted to do this a long time ago, it was a bad idea in the first place.
717 lines
20 KiB
C
717 lines
20 KiB
C
/* 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/>.
|
|
*/
|
|
|
|
#include "config.h"
|
|
|
|
#include <gdk-pixbuf/gdk-pixbuf.h>
|
|
#include <gegl.h>
|
|
|
|
#include "core-types.h"
|
|
|
|
#include "config/gimpcoreconfig.h"
|
|
|
|
#include "gimp.h"
|
|
#include "gimp-utils.h"
|
|
#include "gimpdrawableundo.h"
|
|
#include "gimpimage.h"
|
|
#include "gimpimage-private.h"
|
|
#include "gimpimage-undo.h"
|
|
#include "gimpitem.h"
|
|
#include "gimplist.h"
|
|
#include "gimpundostack.h"
|
|
|
|
|
|
/* local function prototypes */
|
|
|
|
static void gimp_image_undo_pop_stack (GimpImage *image,
|
|
GimpUndoStack *undo_stack,
|
|
GimpUndoStack *redo_stack,
|
|
GimpUndoMode undo_mode);
|
|
static void gimp_image_undo_free_space (GimpImage *image);
|
|
static void gimp_image_undo_free_redo (GimpImage *image);
|
|
|
|
static GimpDirtyMask gimp_image_undo_dirty_from_type (GimpUndoType undo_type);
|
|
|
|
|
|
/* public functions */
|
|
|
|
gboolean
|
|
gimp_image_undo_is_enabled (GimpImage *image)
|
|
{
|
|
g_return_val_if_fail (GIMP_IS_IMAGE (image), FALSE);
|
|
|
|
return (GIMP_IMAGE_GET_PRIVATE (image)->undo_freeze_count == 0);
|
|
}
|
|
|
|
gboolean
|
|
gimp_image_undo_enable (GimpImage *image)
|
|
{
|
|
g_return_val_if_fail (GIMP_IS_IMAGE (image), FALSE);
|
|
|
|
/* Free all undo steps as they are now invalidated */
|
|
gimp_image_undo_free (image);
|
|
|
|
return gimp_image_undo_thaw (image);
|
|
}
|
|
|
|
gboolean
|
|
gimp_image_undo_disable (GimpImage *image)
|
|
{
|
|
g_return_val_if_fail (GIMP_IS_IMAGE (image), FALSE);
|
|
|
|
return gimp_image_undo_freeze (image);
|
|
}
|
|
|
|
gboolean
|
|
gimp_image_undo_freeze (GimpImage *image)
|
|
{
|
|
GimpImagePrivate *private;
|
|
|
|
g_return_val_if_fail (GIMP_IS_IMAGE (image), FALSE);
|
|
|
|
private = GIMP_IMAGE_GET_PRIVATE (image);
|
|
|
|
private->undo_freeze_count++;
|
|
|
|
if (private->undo_freeze_count == 1)
|
|
gimp_image_undo_event (image, GIMP_UNDO_EVENT_UNDO_FREEZE, NULL);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
gboolean
|
|
gimp_image_undo_thaw (GimpImage *image)
|
|
{
|
|
GimpImagePrivate *private;
|
|
|
|
g_return_val_if_fail (GIMP_IS_IMAGE (image), FALSE);
|
|
|
|
private = GIMP_IMAGE_GET_PRIVATE (image);
|
|
|
|
g_return_val_if_fail (private->undo_freeze_count > 0, FALSE);
|
|
|
|
private->undo_freeze_count--;
|
|
|
|
if (private->undo_freeze_count == 0)
|
|
gimp_image_undo_event (image, GIMP_UNDO_EVENT_UNDO_THAW, NULL);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
gboolean
|
|
gimp_image_undo (GimpImage *image)
|
|
{
|
|
GimpImagePrivate *private;
|
|
|
|
g_return_val_if_fail (GIMP_IS_IMAGE (image), FALSE);
|
|
|
|
private = GIMP_IMAGE_GET_PRIVATE (image);
|
|
|
|
g_return_val_if_fail (private->pushing_undo_group == GIMP_UNDO_GROUP_NONE,
|
|
FALSE);
|
|
|
|
gimp_image_undo_pop_stack (image,
|
|
private->undo_stack,
|
|
private->redo_stack,
|
|
GIMP_UNDO_MODE_UNDO);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
gboolean
|
|
gimp_image_redo (GimpImage *image)
|
|
{
|
|
GimpImagePrivate *private;
|
|
|
|
g_return_val_if_fail (GIMP_IS_IMAGE (image), FALSE);
|
|
|
|
private = GIMP_IMAGE_GET_PRIVATE (image);
|
|
|
|
g_return_val_if_fail (private->pushing_undo_group == GIMP_UNDO_GROUP_NONE,
|
|
FALSE);
|
|
|
|
gimp_image_undo_pop_stack (image,
|
|
private->redo_stack,
|
|
private->undo_stack,
|
|
GIMP_UNDO_MODE_REDO);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
/*
|
|
* this function continues to undo as long as it only sees certain
|
|
* undo types, in particular visibility changes.
|
|
*/
|
|
gboolean
|
|
gimp_image_strong_undo (GimpImage *image)
|
|
{
|
|
GimpImagePrivate *private;
|
|
GimpUndo *undo;
|
|
|
|
g_return_val_if_fail (GIMP_IS_IMAGE (image), FALSE);
|
|
|
|
private = GIMP_IMAGE_GET_PRIVATE (image);
|
|
|
|
g_return_val_if_fail (private->pushing_undo_group == GIMP_UNDO_GROUP_NONE,
|
|
FALSE);
|
|
|
|
undo = gimp_undo_stack_peek (private->undo_stack);
|
|
|
|
gimp_image_undo (image);
|
|
|
|
while (gimp_undo_is_weak (undo))
|
|
{
|
|
undo = gimp_undo_stack_peek (private->undo_stack);
|
|
if (gimp_undo_is_weak (undo))
|
|
gimp_image_undo (image);
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
/*
|
|
* this function continues to redo as long as it only sees certain
|
|
* undo types, in particular visibility changes. Note that the
|
|
* order of events is set up to make it exactly reverse
|
|
* gimp_image_strong_undo().
|
|
*/
|
|
gboolean
|
|
gimp_image_strong_redo (GimpImage *image)
|
|
{
|
|
GimpImagePrivate *private;
|
|
GimpUndo *undo;
|
|
|
|
g_return_val_if_fail (GIMP_IS_IMAGE (image), FALSE);
|
|
|
|
private = GIMP_IMAGE_GET_PRIVATE (image);
|
|
|
|
g_return_val_if_fail (private->pushing_undo_group == GIMP_UNDO_GROUP_NONE,
|
|
FALSE);
|
|
|
|
undo = gimp_undo_stack_peek (private->redo_stack);
|
|
|
|
gimp_image_redo (image);
|
|
|
|
while (gimp_undo_is_weak (undo))
|
|
{
|
|
undo = gimp_undo_stack_peek (private->redo_stack);
|
|
if (gimp_undo_is_weak (undo))
|
|
gimp_image_redo (image);
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
GimpUndoStack *
|
|
gimp_image_get_undo_stack (GimpImage *image)
|
|
{
|
|
g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);
|
|
|
|
return GIMP_IMAGE_GET_PRIVATE (image)->undo_stack;
|
|
}
|
|
|
|
GimpUndoStack *
|
|
gimp_image_get_redo_stack (GimpImage *image)
|
|
{
|
|
g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);
|
|
|
|
return GIMP_IMAGE_GET_PRIVATE (image)->redo_stack;
|
|
}
|
|
|
|
void
|
|
gimp_image_undo_free (GimpImage *image)
|
|
{
|
|
GimpImagePrivate *private;
|
|
|
|
g_return_if_fail (GIMP_IS_IMAGE (image));
|
|
|
|
private = GIMP_IMAGE_GET_PRIVATE (image);
|
|
|
|
/* Emit the UNDO_FREE event before actually freeing everything
|
|
* so the views can properly detach from the undo items
|
|
*/
|
|
gimp_image_undo_event (image, GIMP_UNDO_EVENT_UNDO_FREE, NULL);
|
|
|
|
gimp_undo_free (GIMP_UNDO (private->undo_stack), GIMP_UNDO_MODE_UNDO);
|
|
gimp_undo_free (GIMP_UNDO (private->redo_stack), GIMP_UNDO_MODE_REDO);
|
|
|
|
/* If the image was dirty, but could become clean by redo-ing
|
|
* some actions, then it should now become 'infinitely' dirty.
|
|
* This is because we've just nuked the actions that would allow
|
|
* the image to become clean again.
|
|
*/
|
|
if (private->dirty < 0)
|
|
private->dirty = 100000;
|
|
|
|
/* The same applies to the case where the image would become clean
|
|
* due to undo actions, but since user can't undo without an undo
|
|
* stack, that's not so much a problem.
|
|
*/
|
|
}
|
|
|
|
gint
|
|
gimp_image_get_undo_group_count (GimpImage *image)
|
|
{
|
|
g_return_val_if_fail (GIMP_IS_IMAGE (image), 0);
|
|
|
|
return GIMP_IMAGE_GET_PRIVATE (image)->group_count;
|
|
}
|
|
|
|
gboolean
|
|
gimp_image_undo_group_start (GimpImage *image,
|
|
GimpUndoType undo_type,
|
|
const gchar *name)
|
|
{
|
|
GimpImagePrivate *private;
|
|
GimpUndoStack *undo_group;
|
|
GimpDirtyMask dirty_mask;
|
|
|
|
g_return_val_if_fail (GIMP_IS_IMAGE (image), FALSE);
|
|
g_return_val_if_fail (undo_type > GIMP_UNDO_GROUP_FIRST &&
|
|
undo_type <= GIMP_UNDO_GROUP_LAST, FALSE);
|
|
|
|
private = GIMP_IMAGE_GET_PRIVATE (image);
|
|
|
|
if (! name)
|
|
name = gimp_undo_type_to_name (undo_type);
|
|
|
|
dirty_mask = gimp_image_undo_dirty_from_type (undo_type);
|
|
|
|
/* Notify listeners that the image will be modified */
|
|
if (private->group_count == 0 && dirty_mask != GIMP_DIRTY_NONE)
|
|
gimp_image_dirty (image, dirty_mask);
|
|
|
|
if (private->undo_freeze_count > 0)
|
|
return FALSE;
|
|
|
|
private->group_count++;
|
|
|
|
/* If we're already in a group...ignore */
|
|
if (private->group_count > 1)
|
|
return TRUE;
|
|
|
|
/* nuke the redo stack */
|
|
gimp_image_undo_free_redo (image);
|
|
|
|
undo_group = gimp_undo_stack_new (image);
|
|
|
|
gimp_object_set_name (GIMP_OBJECT (undo_group), name);
|
|
GIMP_UNDO (undo_group)->undo_type = undo_type;
|
|
GIMP_UNDO (undo_group)->dirty_mask = dirty_mask;
|
|
|
|
gimp_undo_stack_push_undo (private->undo_stack, GIMP_UNDO (undo_group));
|
|
|
|
private->pushing_undo_group = undo_type;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
gboolean
|
|
gimp_image_undo_group_end (GimpImage *image)
|
|
{
|
|
GimpImagePrivate *private;
|
|
|
|
g_return_val_if_fail (GIMP_IS_IMAGE (image), FALSE);
|
|
|
|
private = GIMP_IMAGE_GET_PRIVATE (image);
|
|
|
|
if (private->undo_freeze_count > 0)
|
|
return FALSE;
|
|
|
|
g_return_val_if_fail (private->group_count > 0, FALSE);
|
|
|
|
private->group_count--;
|
|
|
|
if (private->group_count == 0)
|
|
{
|
|
private->pushing_undo_group = GIMP_UNDO_GROUP_NONE;
|
|
|
|
/* Do it here, since undo_push doesn't emit this event while in
|
|
* the middle of a group
|
|
*/
|
|
gimp_image_undo_event (image, GIMP_UNDO_EVENT_UNDO_PUSHED,
|
|
gimp_undo_stack_peek (private->undo_stack));
|
|
|
|
gimp_image_undo_free_space (image);
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
GimpUndo *
|
|
gimp_image_undo_push (GimpImage *image,
|
|
GType object_type,
|
|
GimpUndoType undo_type,
|
|
const gchar *name,
|
|
GimpDirtyMask dirty_mask,
|
|
...)
|
|
{
|
|
GimpImagePrivate *private;
|
|
GParameter *params = NULL;
|
|
gint n_params = 0;
|
|
va_list args;
|
|
GimpUndo *undo;
|
|
|
|
g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);
|
|
g_return_val_if_fail (g_type_is_a (object_type, GIMP_TYPE_UNDO), NULL);
|
|
g_return_val_if_fail (undo_type > GIMP_UNDO_GROUP_LAST, NULL);
|
|
|
|
private = GIMP_IMAGE_GET_PRIVATE (image);
|
|
|
|
/* Does this undo dirty the image? If so, we always want to mark
|
|
* image dirty, even if we can't actually push the undo.
|
|
*/
|
|
if (dirty_mask != GIMP_DIRTY_NONE)
|
|
gimp_image_dirty (image, dirty_mask);
|
|
|
|
if (private->undo_freeze_count > 0)
|
|
return NULL;
|
|
|
|
if (! name)
|
|
name = gimp_undo_type_to_name (undo_type);
|
|
|
|
params = gimp_parameters_append (object_type, params, &n_params,
|
|
"name", name,
|
|
"image", image,
|
|
"undo-type", undo_type,
|
|
"dirty-mask", dirty_mask,
|
|
NULL);
|
|
|
|
va_start (args, dirty_mask);
|
|
params = gimp_parameters_append_valist (object_type, params, &n_params, args);
|
|
va_end (args);
|
|
|
|
undo = g_object_newv (object_type, n_params, params);
|
|
|
|
gimp_parameters_free (params, n_params);
|
|
|
|
/* nuke the redo stack */
|
|
gimp_image_undo_free_redo (image);
|
|
|
|
if (private->pushing_undo_group == GIMP_UNDO_GROUP_NONE)
|
|
{
|
|
gimp_undo_stack_push_undo (private->undo_stack, undo);
|
|
|
|
gimp_image_undo_event (image, GIMP_UNDO_EVENT_UNDO_PUSHED, undo);
|
|
|
|
gimp_image_undo_free_space (image);
|
|
|
|
/* freeing undo space may have freed the newly pushed undo */
|
|
if (gimp_undo_stack_peek (private->undo_stack) == undo)
|
|
return undo;
|
|
}
|
|
else
|
|
{
|
|
GimpUndoStack *undo_group;
|
|
|
|
undo_group = GIMP_UNDO_STACK (gimp_undo_stack_peek (private->undo_stack));
|
|
|
|
gimp_undo_stack_push_undo (undo_group, undo);
|
|
|
|
return undo;
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
GimpUndo *
|
|
gimp_image_undo_can_compress (GimpImage *image,
|
|
GType object_type,
|
|
GimpUndoType undo_type)
|
|
{
|
|
GimpImagePrivate *private;
|
|
|
|
g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);
|
|
|
|
private = GIMP_IMAGE_GET_PRIVATE (image);
|
|
|
|
if (gimp_image_is_dirty (image) &&
|
|
! gimp_undo_stack_peek (private->redo_stack))
|
|
{
|
|
GimpUndo *undo = gimp_undo_stack_peek (private->undo_stack);
|
|
|
|
if (undo && undo->undo_type == undo_type &&
|
|
g_type_is_a (G_TYPE_FROM_INSTANCE (undo), object_type))
|
|
{
|
|
return undo;
|
|
}
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
GimpUndo *
|
|
gimp_image_undo_get_fadeable (GimpImage *image)
|
|
{
|
|
GimpImagePrivate *private;
|
|
GimpUndo *undo;
|
|
|
|
g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);
|
|
|
|
private = GIMP_IMAGE_GET_PRIVATE (image);
|
|
|
|
undo = gimp_undo_stack_peek (private->undo_stack);
|
|
|
|
if (GIMP_IS_UNDO_STACK (undo) && undo->undo_type == GIMP_UNDO_GROUP_PAINT)
|
|
{
|
|
GimpUndoStack *stack = GIMP_UNDO_STACK (undo);
|
|
|
|
if (gimp_undo_stack_get_depth (stack) == 2)
|
|
{
|
|
undo = gimp_undo_stack_peek (stack);
|
|
}
|
|
}
|
|
|
|
if (GIMP_IS_DRAWABLE_UNDO (undo))
|
|
return undo;
|
|
|
|
return NULL;
|
|
}
|
|
|
|
|
|
/* private functions */
|
|
|
|
static void
|
|
gimp_image_undo_pop_stack (GimpImage *image,
|
|
GimpUndoStack *undo_stack,
|
|
GimpUndoStack *redo_stack,
|
|
GimpUndoMode undo_mode)
|
|
{
|
|
GimpUndo *undo;
|
|
GimpUndoAccumulator accum = { 0, };
|
|
|
|
g_object_freeze_notify (G_OBJECT (image));
|
|
|
|
undo = gimp_undo_stack_pop_undo (undo_stack, undo_mode, &accum);
|
|
|
|
if (undo)
|
|
{
|
|
if (GIMP_IS_UNDO_STACK (undo))
|
|
gimp_list_reverse (GIMP_LIST (GIMP_UNDO_STACK (undo)->undos));
|
|
|
|
gimp_undo_stack_push_undo (redo_stack, undo);
|
|
|
|
if (accum.mode_changed)
|
|
gimp_image_mode_changed (image);
|
|
|
|
if (accum.precision_changed)
|
|
gimp_image_precision_changed (image);
|
|
|
|
if (accum.size_changed)
|
|
gimp_image_size_changed_detailed (image,
|
|
accum.previous_origin_x,
|
|
accum.previous_origin_y,
|
|
accum.previous_width,
|
|
accum.previous_height);
|
|
|
|
if (accum.resolution_changed)
|
|
gimp_image_resolution_changed (image);
|
|
|
|
if (accum.unit_changed)
|
|
gimp_image_unit_changed (image);
|
|
|
|
/* let others know that we just popped an action */
|
|
gimp_image_undo_event (image,
|
|
(undo_mode == GIMP_UNDO_MODE_UNDO) ?
|
|
GIMP_UNDO_EVENT_UNDO : GIMP_UNDO_EVENT_REDO,
|
|
undo);
|
|
}
|
|
|
|
g_object_thaw_notify (G_OBJECT (image));
|
|
}
|
|
|
|
static void
|
|
gimp_image_undo_free_space (GimpImage *image)
|
|
{
|
|
GimpImagePrivate *private = GIMP_IMAGE_GET_PRIVATE (image);
|
|
GimpContainer *container;
|
|
gint min_undo_levels;
|
|
gint max_undo_levels;
|
|
gint64 undo_size;
|
|
|
|
container = private->undo_stack->undos;
|
|
|
|
min_undo_levels = image->gimp->config->levels_of_undo;
|
|
max_undo_levels = 1024; /* FIXME */
|
|
undo_size = image->gimp->config->undo_size;
|
|
|
|
#ifdef DEBUG_IMAGE_UNDO
|
|
g_printerr ("undo_steps: %d undo_bytes: %ld\n",
|
|
gimp_container_get_n_children (container),
|
|
(glong) gimp_object_get_memsize (GIMP_OBJECT (container), NULL));
|
|
#endif
|
|
|
|
/* keep at least min_undo_levels undo steps */
|
|
if (gimp_container_get_n_children (container) <= min_undo_levels)
|
|
return;
|
|
|
|
while ((gimp_object_get_memsize (GIMP_OBJECT (container), NULL) > undo_size) ||
|
|
(gimp_container_get_n_children (container) > max_undo_levels))
|
|
{
|
|
GimpUndo *freed = gimp_undo_stack_free_bottom (private->undo_stack,
|
|
GIMP_UNDO_MODE_UNDO);
|
|
|
|
#ifdef DEBUG_IMAGE_UNDO
|
|
g_printerr ("freed one step: undo_steps: %d undo_bytes: %ld\n",
|
|
gimp_container_get_n_children (container),
|
|
(glong) gimp_object_get_memsize (GIMP_OBJECT (container),
|
|
NULL));
|
|
#endif
|
|
|
|
gimp_image_undo_event (image, GIMP_UNDO_EVENT_UNDO_EXPIRED, freed);
|
|
|
|
g_object_unref (freed);
|
|
|
|
if (gimp_container_get_n_children (container) <= min_undo_levels)
|
|
return;
|
|
}
|
|
}
|
|
|
|
static void
|
|
gimp_image_undo_free_redo (GimpImage *image)
|
|
{
|
|
GimpImagePrivate *private = GIMP_IMAGE_GET_PRIVATE (image);
|
|
GimpContainer *container = private->redo_stack->undos;
|
|
|
|
#ifdef DEBUG_IMAGE_UNDO
|
|
g_printerr ("redo_steps: %d redo_bytes: %ld\n",
|
|
gimp_container_get_n_children (container),
|
|
(glong) gimp_object_get_memsize (GIMP_OBJECT (container), NULL));
|
|
#endif
|
|
|
|
if (gimp_container_is_empty (container))
|
|
return;
|
|
|
|
while (gimp_container_get_n_children (container) > 0)
|
|
{
|
|
GimpUndo *freed = gimp_undo_stack_free_bottom (private->redo_stack,
|
|
GIMP_UNDO_MODE_REDO);
|
|
|
|
#ifdef DEBUG_IMAGE_UNDO
|
|
g_printerr ("freed one step: redo_steps: %d redo_bytes: %ld\n",
|
|
gimp_container_get_n_children (container),
|
|
(glong )gimp_object_get_memsize (GIMP_OBJECT (container),
|
|
NULL));
|
|
#endif
|
|
|
|
gimp_image_undo_event (image, GIMP_UNDO_EVENT_REDO_EXPIRED, freed);
|
|
|
|
g_object_unref (freed);
|
|
}
|
|
|
|
/* We need to use <= here because the undo counter has already been
|
|
* incremented at this point.
|
|
*/
|
|
if (private->dirty <= 0)
|
|
{
|
|
/* If the image was dirty, but could become clean by redo-ing
|
|
* some actions, then it should now become 'infinitely' dirty.
|
|
* This is because we've just nuked the actions that would allow
|
|
* the image to become clean again.
|
|
*/
|
|
private->dirty = 100000;
|
|
}
|
|
}
|
|
|
|
static GimpDirtyMask
|
|
gimp_image_undo_dirty_from_type (GimpUndoType undo_type)
|
|
{
|
|
switch (undo_type)
|
|
{
|
|
case GIMP_UNDO_GROUP_IMAGE_SCALE:
|
|
case GIMP_UNDO_GROUP_IMAGE_RESIZE:
|
|
case GIMP_UNDO_GROUP_IMAGE_FLIP:
|
|
case GIMP_UNDO_GROUP_IMAGE_ROTATE:
|
|
case GIMP_UNDO_GROUP_IMAGE_CROP:
|
|
return GIMP_DIRTY_IMAGE | GIMP_DIRTY_IMAGE_SIZE;
|
|
|
|
case GIMP_UNDO_GROUP_IMAGE_CONVERT:
|
|
return GIMP_DIRTY_IMAGE | GIMP_DIRTY_DRAWABLE;
|
|
|
|
case GIMP_UNDO_GROUP_IMAGE_LAYERS_MERGE:
|
|
return GIMP_DIRTY_IMAGE_STRUCTURE | GIMP_DIRTY_DRAWABLE;
|
|
|
|
case GIMP_UNDO_GROUP_IMAGE_VECTORS_MERGE:
|
|
return GIMP_DIRTY_IMAGE_STRUCTURE | GIMP_DIRTY_VECTORS;
|
|
|
|
case GIMP_UNDO_GROUP_IMAGE_QUICK_MASK: /* FIXME */
|
|
return GIMP_DIRTY_IMAGE_STRUCTURE | GIMP_DIRTY_SELECTION;
|
|
|
|
case GIMP_UNDO_GROUP_IMAGE_GRID:
|
|
case GIMP_UNDO_GROUP_GUIDE:
|
|
return GIMP_DIRTY_IMAGE_META;
|
|
|
|
case GIMP_UNDO_GROUP_DRAWABLE:
|
|
case GIMP_UNDO_GROUP_DRAWABLE_MOD:
|
|
return GIMP_DIRTY_ITEM | GIMP_DIRTY_DRAWABLE;
|
|
|
|
case GIMP_UNDO_GROUP_MASK: /* FIXME */
|
|
return GIMP_DIRTY_SELECTION;
|
|
|
|
case GIMP_UNDO_GROUP_ITEM_VISIBILITY:
|
|
case GIMP_UNDO_GROUP_ITEM_LINKED:
|
|
case GIMP_UNDO_GROUP_ITEM_PROPERTIES:
|
|
return GIMP_DIRTY_ITEM_META;
|
|
|
|
case GIMP_UNDO_GROUP_ITEM_DISPLACE: /* FIXME */
|
|
return GIMP_DIRTY_ITEM | GIMP_DIRTY_DRAWABLE | GIMP_DIRTY_VECTORS;
|
|
|
|
case GIMP_UNDO_GROUP_ITEM_SCALE: /* FIXME */
|
|
case GIMP_UNDO_GROUP_ITEM_RESIZE: /* FIXME */
|
|
return GIMP_DIRTY_ITEM | GIMP_DIRTY_DRAWABLE | GIMP_DIRTY_VECTORS;
|
|
|
|
case GIMP_UNDO_GROUP_LAYER_ADD_MASK:
|
|
case GIMP_UNDO_GROUP_LAYER_APPLY_MASK:
|
|
return GIMP_DIRTY_IMAGE_STRUCTURE;
|
|
|
|
case GIMP_UNDO_GROUP_FS_TO_LAYER:
|
|
case GIMP_UNDO_GROUP_FS_FLOAT:
|
|
case GIMP_UNDO_GROUP_FS_ANCHOR:
|
|
return GIMP_DIRTY_IMAGE_STRUCTURE;
|
|
|
|
case GIMP_UNDO_GROUP_EDIT_PASTE:
|
|
return GIMP_DIRTY_IMAGE_STRUCTURE;
|
|
|
|
case GIMP_UNDO_GROUP_EDIT_CUT:
|
|
return GIMP_DIRTY_ITEM | GIMP_DIRTY_DRAWABLE;
|
|
|
|
case GIMP_UNDO_GROUP_TEXT:
|
|
return GIMP_DIRTY_ITEM | GIMP_DIRTY_DRAWABLE;
|
|
|
|
case GIMP_UNDO_GROUP_TRANSFORM: /* FIXME */
|
|
return GIMP_DIRTY_ITEM | GIMP_DIRTY_DRAWABLE | GIMP_DIRTY_VECTORS;
|
|
|
|
case GIMP_UNDO_GROUP_PAINT:
|
|
return GIMP_DIRTY_ITEM | GIMP_DIRTY_DRAWABLE;
|
|
|
|
case GIMP_UNDO_GROUP_PARASITE_ATTACH:
|
|
case GIMP_UNDO_GROUP_PARASITE_REMOVE:
|
|
return GIMP_DIRTY_IMAGE_META | GIMP_DIRTY_ITEM_META;
|
|
|
|
case GIMP_UNDO_GROUP_VECTORS_IMPORT:
|
|
return GIMP_DIRTY_IMAGE_STRUCTURE | GIMP_DIRTY_VECTORS;
|
|
|
|
case GIMP_UNDO_GROUP_MISC:
|
|
return GIMP_DIRTY_ALL;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return GIMP_DIRTY_ALL;
|
|
}
|