1 /* GIMP - The GNU Image Manipulation Program
2 * Copyright (C) 1995 Spencer Kimball and Peter Mattis
3 *
4 * This program is free software: you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License as published by
6 * the Free Software Foundation; either version 3 of the License, or
7 * (at your option) any later version.
8 *
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
13 *
14 * You should have received a copy of the GNU General Public License
15 * along with this program. If not, see <https://www.gnu.org/licenses/>.
16 */
17
18 #include "config.h"
19
20 #include <gdk-pixbuf/gdk-pixbuf.h>
21 #include <gegl.h>
22
23 #include "core-types.h"
24
25 #include "config/gimpcoreconfig.h"
26
27 #include "gimp.h"
28 #include "gimp-utils.h"
29 #include "gimpimage.h"
30 #include "gimpimage-private.h"
31 #include "gimpimage-undo.h"
32 #include "gimpitem.h"
33 #include "gimplist.h"
34 #include "gimpundostack.h"
35
36
37 /* local function prototypes */
38
39 static void gimp_image_undo_pop_stack (GimpImage *image,
40 GimpUndoStack *undo_stack,
41 GimpUndoStack *redo_stack,
42 GimpUndoMode undo_mode);
43 static void gimp_image_undo_free_space (GimpImage *image);
44 static void gimp_image_undo_free_redo (GimpImage *image);
45
46 static GimpDirtyMask gimp_image_undo_dirty_from_type (GimpUndoType undo_type);
47
48
49 /* public functions */
50
51 gboolean
gimp_image_undo_is_enabled(GimpImage * image)52 gimp_image_undo_is_enabled (GimpImage *image)
53 {
54 g_return_val_if_fail (GIMP_IS_IMAGE (image), FALSE);
55
56 return (GIMP_IMAGE_GET_PRIVATE (image)->undo_freeze_count == 0);
57 }
58
59 gboolean
gimp_image_undo_enable(GimpImage * image)60 gimp_image_undo_enable (GimpImage *image)
61 {
62 g_return_val_if_fail (GIMP_IS_IMAGE (image), FALSE);
63
64 /* Free all undo steps as they are now invalidated */
65 gimp_image_undo_free (image);
66
67 return gimp_image_undo_thaw (image);
68 }
69
70 gboolean
gimp_image_undo_disable(GimpImage * image)71 gimp_image_undo_disable (GimpImage *image)
72 {
73 g_return_val_if_fail (GIMP_IS_IMAGE (image), FALSE);
74
75 return gimp_image_undo_freeze (image);
76 }
77
78 gboolean
gimp_image_undo_freeze(GimpImage * image)79 gimp_image_undo_freeze (GimpImage *image)
80 {
81 GimpImagePrivate *private;
82
83 g_return_val_if_fail (GIMP_IS_IMAGE (image), FALSE);
84
85 private = GIMP_IMAGE_GET_PRIVATE (image);
86
87 private->undo_freeze_count++;
88
89 if (private->undo_freeze_count == 1)
90 gimp_image_undo_event (image, GIMP_UNDO_EVENT_UNDO_FREEZE, NULL);
91
92 return TRUE;
93 }
94
95 gboolean
gimp_image_undo_thaw(GimpImage * image)96 gimp_image_undo_thaw (GimpImage *image)
97 {
98 GimpImagePrivate *private;
99
100 g_return_val_if_fail (GIMP_IS_IMAGE (image), FALSE);
101
102 private = GIMP_IMAGE_GET_PRIVATE (image);
103
104 g_return_val_if_fail (private->undo_freeze_count > 0, FALSE);
105
106 private->undo_freeze_count--;
107
108 if (private->undo_freeze_count == 0)
109 gimp_image_undo_event (image, GIMP_UNDO_EVENT_UNDO_THAW, NULL);
110
111 return TRUE;
112 }
113
114 gboolean
gimp_image_undo(GimpImage * image)115 gimp_image_undo (GimpImage *image)
116 {
117 GimpImagePrivate *private;
118
119 g_return_val_if_fail (GIMP_IS_IMAGE (image), FALSE);
120
121 private = GIMP_IMAGE_GET_PRIVATE (image);
122
123 g_return_val_if_fail (private->pushing_undo_group == GIMP_UNDO_GROUP_NONE,
124 FALSE);
125
126 gimp_image_undo_pop_stack (image,
127 private->undo_stack,
128 private->redo_stack,
129 GIMP_UNDO_MODE_UNDO);
130
131 return TRUE;
132 }
133
134 gboolean
gimp_image_redo(GimpImage * image)135 gimp_image_redo (GimpImage *image)
136 {
137 GimpImagePrivate *private;
138
139 g_return_val_if_fail (GIMP_IS_IMAGE (image), FALSE);
140
141 private = GIMP_IMAGE_GET_PRIVATE (image);
142
143 g_return_val_if_fail (private->pushing_undo_group == GIMP_UNDO_GROUP_NONE,
144 FALSE);
145
146 gimp_image_undo_pop_stack (image,
147 private->redo_stack,
148 private->undo_stack,
149 GIMP_UNDO_MODE_REDO);
150
151 return TRUE;
152 }
153
154 /*
155 * this function continues to undo as long as it only sees certain
156 * undo types, in particular visibility changes.
157 */
158 gboolean
gimp_image_strong_undo(GimpImage * image)159 gimp_image_strong_undo (GimpImage *image)
160 {
161 GimpImagePrivate *private;
162 GimpUndo *undo;
163
164 g_return_val_if_fail (GIMP_IS_IMAGE (image), FALSE);
165
166 private = GIMP_IMAGE_GET_PRIVATE (image);
167
168 g_return_val_if_fail (private->pushing_undo_group == GIMP_UNDO_GROUP_NONE,
169 FALSE);
170
171 undo = gimp_undo_stack_peek (private->undo_stack);
172
173 gimp_image_undo (image);
174
175 while (gimp_undo_is_weak (undo))
176 {
177 undo = gimp_undo_stack_peek (private->undo_stack);
178 if (gimp_undo_is_weak (undo))
179 gimp_image_undo (image);
180 }
181
182 return TRUE;
183 }
184
185 /*
186 * this function continues to redo as long as it only sees certain
187 * undo types, in particular visibility changes. Note that the
188 * order of events is set up to make it exactly reverse
189 * gimp_image_strong_undo().
190 */
191 gboolean
gimp_image_strong_redo(GimpImage * image)192 gimp_image_strong_redo (GimpImage *image)
193 {
194 GimpImagePrivate *private;
195 GimpUndo *undo;
196
197 g_return_val_if_fail (GIMP_IS_IMAGE (image), FALSE);
198
199 private = GIMP_IMAGE_GET_PRIVATE (image);
200
201 g_return_val_if_fail (private->pushing_undo_group == GIMP_UNDO_GROUP_NONE,
202 FALSE);
203
204 undo = gimp_undo_stack_peek (private->redo_stack);
205
206 gimp_image_redo (image);
207
208 while (gimp_undo_is_weak (undo))
209 {
210 undo = gimp_undo_stack_peek (private->redo_stack);
211 if (gimp_undo_is_weak (undo))
212 gimp_image_redo (image);
213 }
214
215 return TRUE;
216 }
217
218 GimpUndoStack *
gimp_image_get_undo_stack(GimpImage * image)219 gimp_image_get_undo_stack (GimpImage *image)
220 {
221 g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);
222
223 return GIMP_IMAGE_GET_PRIVATE (image)->undo_stack;
224 }
225
226 GimpUndoStack *
gimp_image_get_redo_stack(GimpImage * image)227 gimp_image_get_redo_stack (GimpImage *image)
228 {
229 g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);
230
231 return GIMP_IMAGE_GET_PRIVATE (image)->redo_stack;
232 }
233
234 void
gimp_image_undo_free(GimpImage * image)235 gimp_image_undo_free (GimpImage *image)
236 {
237 GimpImagePrivate *private;
238
239 g_return_if_fail (GIMP_IS_IMAGE (image));
240
241 private = GIMP_IMAGE_GET_PRIVATE (image);
242
243 /* Emit the UNDO_FREE event before actually freeing everything
244 * so the views can properly detach from the undo items
245 */
246 gimp_image_undo_event (image, GIMP_UNDO_EVENT_UNDO_FREE, NULL);
247
248 gimp_undo_free (GIMP_UNDO (private->undo_stack), GIMP_UNDO_MODE_UNDO);
249 gimp_undo_free (GIMP_UNDO (private->redo_stack), GIMP_UNDO_MODE_REDO);
250
251 /* If the image was dirty, but could become clean by redo-ing
252 * some actions, then it should now become 'infinitely' dirty.
253 * This is because we've just nuked the actions that would allow
254 * the image to become clean again.
255 */
256 if (private->dirty < 0)
257 private->dirty = 100000;
258
259 /* The same applies to the case where the image would become clean
260 * due to undo actions, but since user can't undo without an undo
261 * stack, that's not so much a problem.
262 */
263 }
264
265 gint
gimp_image_get_undo_group_count(GimpImage * image)266 gimp_image_get_undo_group_count (GimpImage *image)
267 {
268 g_return_val_if_fail (GIMP_IS_IMAGE (image), 0);
269
270 return GIMP_IMAGE_GET_PRIVATE (image)->group_count;
271 }
272
273 gboolean
gimp_image_undo_group_start(GimpImage * image,GimpUndoType undo_type,const gchar * name)274 gimp_image_undo_group_start (GimpImage *image,
275 GimpUndoType undo_type,
276 const gchar *name)
277 {
278 GimpImagePrivate *private;
279 GimpUndoStack *undo_group;
280 GimpDirtyMask dirty_mask;
281
282 g_return_val_if_fail (GIMP_IS_IMAGE (image), FALSE);
283 g_return_val_if_fail (undo_type > GIMP_UNDO_GROUP_FIRST &&
284 undo_type <= GIMP_UNDO_GROUP_LAST, FALSE);
285
286 private = GIMP_IMAGE_GET_PRIVATE (image);
287
288 if (! name)
289 name = gimp_undo_type_to_name (undo_type);
290
291 dirty_mask = gimp_image_undo_dirty_from_type (undo_type);
292
293 /* Notify listeners that the image will be modified */
294 if (private->group_count == 0 && dirty_mask != GIMP_DIRTY_NONE)
295 gimp_image_dirty (image, dirty_mask);
296
297 if (private->undo_freeze_count > 0)
298 return FALSE;
299
300 private->group_count++;
301
302 /* If we're already in a group...ignore */
303 if (private->group_count > 1)
304 return TRUE;
305
306 /* nuke the redo stack */
307 gimp_image_undo_free_redo (image);
308
309 undo_group = gimp_undo_stack_new (image);
310
311 gimp_object_set_name (GIMP_OBJECT (undo_group), name);
312 GIMP_UNDO (undo_group)->undo_type = undo_type;
313 GIMP_UNDO (undo_group)->dirty_mask = dirty_mask;
314
315 gimp_undo_stack_push_undo (private->undo_stack, GIMP_UNDO (undo_group));
316
317 private->pushing_undo_group = undo_type;
318
319 return TRUE;
320 }
321
322 gboolean
gimp_image_undo_group_end(GimpImage * image)323 gimp_image_undo_group_end (GimpImage *image)
324 {
325 GimpImagePrivate *private;
326
327 g_return_val_if_fail (GIMP_IS_IMAGE (image), FALSE);
328
329 private = GIMP_IMAGE_GET_PRIVATE (image);
330
331 if (private->undo_freeze_count > 0)
332 return FALSE;
333
334 g_return_val_if_fail (private->group_count > 0, FALSE);
335
336 private->group_count--;
337
338 if (private->group_count == 0)
339 {
340 private->pushing_undo_group = GIMP_UNDO_GROUP_NONE;
341
342 /* Do it here, since undo_push doesn't emit this event while in
343 * the middle of a group
344 */
345 gimp_image_undo_event (image, GIMP_UNDO_EVENT_UNDO_PUSHED,
346 gimp_undo_stack_peek (private->undo_stack));
347
348 gimp_image_undo_free_space (image);
349 }
350
351 return TRUE;
352 }
353
354 GimpUndo *
gimp_image_undo_push(GimpImage * image,GType object_type,GimpUndoType undo_type,const gchar * name,GimpDirtyMask dirty_mask,...)355 gimp_image_undo_push (GimpImage *image,
356 GType object_type,
357 GimpUndoType undo_type,
358 const gchar *name,
359 GimpDirtyMask dirty_mask,
360 ...)
361 {
362 GimpImagePrivate *private;
363 gint n_properties = 0;
364 gchar **names = NULL;
365 GValue *values = NULL;
366 va_list args;
367 GimpUndo *undo;
368
369 g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);
370 g_return_val_if_fail (g_type_is_a (object_type, GIMP_TYPE_UNDO), NULL);
371 g_return_val_if_fail (undo_type > GIMP_UNDO_GROUP_LAST, NULL);
372
373 private = GIMP_IMAGE_GET_PRIVATE (image);
374
375 /* Does this undo dirty the image? If so, we always want to mark
376 * image dirty, even if we can't actually push the undo.
377 */
378 if (dirty_mask != GIMP_DIRTY_NONE)
379 gimp_image_dirty (image, dirty_mask);
380
381 if (private->undo_freeze_count > 0)
382 return NULL;
383
384 if (! name)
385 name = gimp_undo_type_to_name (undo_type);
386
387 names = gimp_properties_append (object_type,
388 &n_properties, names, &values,
389 "name", name,
390 "image", image,
391 "undo-type", undo_type,
392 "dirty-mask", dirty_mask,
393 NULL);
394
395 va_start (args, dirty_mask);
396 names = gimp_properties_append_valist (object_type,
397 &n_properties, names, &values,
398 args);
399 va_end (args);
400
401 undo = (GimpUndo *) g_object_new_with_properties (object_type,
402 n_properties,
403 (const gchar **) names,
404 (const GValue *) values);
405
406 gimp_properties_free (n_properties, names, values);
407
408 /* nuke the redo stack */
409 gimp_image_undo_free_redo (image);
410
411 if (private->pushing_undo_group == GIMP_UNDO_GROUP_NONE)
412 {
413 gimp_undo_stack_push_undo (private->undo_stack, undo);
414
415 gimp_image_undo_event (image, GIMP_UNDO_EVENT_UNDO_PUSHED, undo);
416
417 gimp_image_undo_free_space (image);
418
419 /* freeing undo space may have freed the newly pushed undo */
420 if (gimp_undo_stack_peek (private->undo_stack) == undo)
421 return undo;
422 }
423 else
424 {
425 GimpUndoStack *undo_group;
426
427 undo_group = GIMP_UNDO_STACK (gimp_undo_stack_peek (private->undo_stack));
428
429 gimp_undo_stack_push_undo (undo_group, undo);
430
431 return undo;
432 }
433
434 return NULL;
435 }
436
437 GimpUndo *
gimp_image_undo_can_compress(GimpImage * image,GType object_type,GimpUndoType undo_type)438 gimp_image_undo_can_compress (GimpImage *image,
439 GType object_type,
440 GimpUndoType undo_type)
441 {
442 GimpImagePrivate *private;
443
444 g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);
445
446 private = GIMP_IMAGE_GET_PRIVATE (image);
447
448 if (gimp_image_is_dirty (image) &&
449 ! gimp_undo_stack_peek (private->redo_stack))
450 {
451 GimpUndo *undo = gimp_undo_stack_peek (private->undo_stack);
452
453 if (undo && undo->undo_type == undo_type &&
454 g_type_is_a (G_TYPE_FROM_INSTANCE (undo), object_type))
455 {
456 return undo;
457 }
458 }
459
460 return NULL;
461 }
462
463
464 /* private functions */
465
466 static void
gimp_image_undo_pop_stack(GimpImage * image,GimpUndoStack * undo_stack,GimpUndoStack * redo_stack,GimpUndoMode undo_mode)467 gimp_image_undo_pop_stack (GimpImage *image,
468 GimpUndoStack *undo_stack,
469 GimpUndoStack *redo_stack,
470 GimpUndoMode undo_mode)
471 {
472 GimpUndo *undo;
473 GimpUndoAccumulator accum = { 0, };
474
475 g_object_freeze_notify (G_OBJECT (image));
476
477 undo = gimp_undo_stack_pop_undo (undo_stack, undo_mode, &accum);
478
479 if (undo)
480 {
481 if (GIMP_IS_UNDO_STACK (undo))
482 gimp_list_reverse (GIMP_LIST (GIMP_UNDO_STACK (undo)->undos));
483
484 gimp_undo_stack_push_undo (redo_stack, undo);
485
486 if (accum.mode_changed)
487 gimp_image_mode_changed (image);
488
489 if (accum.precision_changed)
490 gimp_image_precision_changed (image);
491
492 if (accum.size_changed)
493 gimp_image_size_changed_detailed (image,
494 accum.previous_origin_x,
495 accum.previous_origin_y,
496 accum.previous_width,
497 accum.previous_height);
498
499 if (accum.resolution_changed)
500 gimp_image_resolution_changed (image);
501
502 if (accum.unit_changed)
503 gimp_image_unit_changed (image);
504
505 /* let others know that we just popped an action */
506 gimp_image_undo_event (image,
507 (undo_mode == GIMP_UNDO_MODE_UNDO) ?
508 GIMP_UNDO_EVENT_UNDO : GIMP_UNDO_EVENT_REDO,
509 undo);
510 }
511
512 g_object_thaw_notify (G_OBJECT (image));
513 }
514
515 static void
gimp_image_undo_free_space(GimpImage * image)516 gimp_image_undo_free_space (GimpImage *image)
517 {
518 GimpImagePrivate *private = GIMP_IMAGE_GET_PRIVATE (image);
519 GimpContainer *container;
520 gint min_undo_levels;
521 gint max_undo_levels;
522 gint64 undo_size;
523
524 container = private->undo_stack->undos;
525
526 min_undo_levels = image->gimp->config->levels_of_undo;
527 max_undo_levels = 1024; /* FIXME */
528 undo_size = image->gimp->config->undo_size;
529
530 #ifdef DEBUG_IMAGE_UNDO
531 g_printerr ("undo_steps: %d undo_bytes: %ld\n",
532 gimp_container_get_n_children (container),
533 (glong) gimp_object_get_memsize (GIMP_OBJECT (container), NULL));
534 #endif
535
536 /* keep at least min_undo_levels undo steps */
537 if (gimp_container_get_n_children (container) <= min_undo_levels)
538 return;
539
540 while ((gimp_object_get_memsize (GIMP_OBJECT (container), NULL) > undo_size) ||
541 (gimp_container_get_n_children (container) > max_undo_levels))
542 {
543 GimpUndo *freed = gimp_undo_stack_free_bottom (private->undo_stack,
544 GIMP_UNDO_MODE_UNDO);
545
546 #ifdef DEBUG_IMAGE_UNDO
547 g_printerr ("freed one step: undo_steps: %d undo_bytes: %ld\n",
548 gimp_container_get_n_children (container),
549 (glong) gimp_object_get_memsize (GIMP_OBJECT (container),
550 NULL));
551 #endif
552
553 gimp_image_undo_event (image, GIMP_UNDO_EVENT_UNDO_EXPIRED, freed);
554
555 g_object_unref (freed);
556
557 if (gimp_container_get_n_children (container) <= min_undo_levels)
558 return;
559 }
560 }
561
562 static void
gimp_image_undo_free_redo(GimpImage * image)563 gimp_image_undo_free_redo (GimpImage *image)
564 {
565 GimpImagePrivate *private = GIMP_IMAGE_GET_PRIVATE (image);
566 GimpContainer *container = private->redo_stack->undos;
567
568 #ifdef DEBUG_IMAGE_UNDO
569 g_printerr ("redo_steps: %d redo_bytes: %ld\n",
570 gimp_container_get_n_children (container),
571 (glong) gimp_object_get_memsize (GIMP_OBJECT (container), NULL));
572 #endif
573
574 if (gimp_container_is_empty (container))
575 return;
576
577 while (gimp_container_get_n_children (container) > 0)
578 {
579 GimpUndo *freed = gimp_undo_stack_free_bottom (private->redo_stack,
580 GIMP_UNDO_MODE_REDO);
581
582 #ifdef DEBUG_IMAGE_UNDO
583 g_printerr ("freed one step: redo_steps: %d redo_bytes: %ld\n",
584 gimp_container_get_n_children (container),
585 (glong )gimp_object_get_memsize (GIMP_OBJECT (container),
586 NULL));
587 #endif
588
589 gimp_image_undo_event (image, GIMP_UNDO_EVENT_REDO_EXPIRED, freed);
590
591 g_object_unref (freed);
592 }
593
594 /* We need to use <= here because the undo counter has already been
595 * incremented at this point.
596 */
597 if (private->dirty <= 0)
598 {
599 /* If the image was dirty, but could become clean by redo-ing
600 * some actions, then it should now become 'infinitely' dirty.
601 * This is because we've just nuked the actions that would allow
602 * the image to become clean again.
603 */
604 private->dirty = 100000;
605 }
606 }
607
608 static GimpDirtyMask
gimp_image_undo_dirty_from_type(GimpUndoType undo_type)609 gimp_image_undo_dirty_from_type (GimpUndoType undo_type)
610 {
611 switch (undo_type)
612 {
613 case GIMP_UNDO_GROUP_IMAGE_SCALE:
614 case GIMP_UNDO_GROUP_IMAGE_RESIZE:
615 case GIMP_UNDO_GROUP_IMAGE_FLIP:
616 case GIMP_UNDO_GROUP_IMAGE_ROTATE:
617 case GIMP_UNDO_GROUP_IMAGE_TRANSFORM:
618 case GIMP_UNDO_GROUP_IMAGE_CROP:
619 return GIMP_DIRTY_IMAGE | GIMP_DIRTY_IMAGE_SIZE;
620
621 case GIMP_UNDO_GROUP_IMAGE_CONVERT:
622 return GIMP_DIRTY_IMAGE | GIMP_DIRTY_DRAWABLE;
623
624 case GIMP_UNDO_GROUP_IMAGE_LAYERS_MERGE:
625 return GIMP_DIRTY_IMAGE_STRUCTURE | GIMP_DIRTY_DRAWABLE;
626
627 case GIMP_UNDO_GROUP_IMAGE_VECTORS_MERGE:
628 return GIMP_DIRTY_IMAGE_STRUCTURE | GIMP_DIRTY_VECTORS;
629
630 case GIMP_UNDO_GROUP_IMAGE_QUICK_MASK: /* FIXME */
631 return GIMP_DIRTY_IMAGE_STRUCTURE | GIMP_DIRTY_SELECTION;
632
633 case GIMP_UNDO_GROUP_IMAGE_GRID:
634 case GIMP_UNDO_GROUP_GUIDE:
635 return GIMP_DIRTY_IMAGE_META;
636
637 case GIMP_UNDO_GROUP_DRAWABLE:
638 case GIMP_UNDO_GROUP_DRAWABLE_MOD:
639 return GIMP_DIRTY_ITEM | GIMP_DIRTY_DRAWABLE;
640
641 case GIMP_UNDO_GROUP_MASK: /* FIXME */
642 return GIMP_DIRTY_SELECTION;
643
644 case GIMP_UNDO_GROUP_ITEM_VISIBILITY:
645 case GIMP_UNDO_GROUP_ITEM_LINKED:
646 case GIMP_UNDO_GROUP_ITEM_PROPERTIES:
647 return GIMP_DIRTY_ITEM_META;
648
649 case GIMP_UNDO_GROUP_ITEM_DISPLACE: /* FIXME */
650 return GIMP_DIRTY_ITEM | GIMP_DIRTY_DRAWABLE | GIMP_DIRTY_VECTORS;
651
652 case GIMP_UNDO_GROUP_ITEM_SCALE: /* FIXME */
653 case GIMP_UNDO_GROUP_ITEM_RESIZE: /* FIXME */
654 return GIMP_DIRTY_ITEM | GIMP_DIRTY_DRAWABLE | GIMP_DIRTY_VECTORS;
655
656 case GIMP_UNDO_GROUP_LAYER_ADD_MASK:
657 case GIMP_UNDO_GROUP_LAYER_APPLY_MASK:
658 return GIMP_DIRTY_IMAGE_STRUCTURE;
659
660 case GIMP_UNDO_GROUP_FS_TO_LAYER:
661 case GIMP_UNDO_GROUP_FS_FLOAT:
662 case GIMP_UNDO_GROUP_FS_ANCHOR:
663 return GIMP_DIRTY_IMAGE_STRUCTURE;
664
665 case GIMP_UNDO_GROUP_EDIT_PASTE:
666 return GIMP_DIRTY_IMAGE_STRUCTURE;
667
668 case GIMP_UNDO_GROUP_EDIT_CUT:
669 return GIMP_DIRTY_ITEM | GIMP_DIRTY_DRAWABLE;
670
671 case GIMP_UNDO_GROUP_TEXT:
672 return GIMP_DIRTY_ITEM | GIMP_DIRTY_DRAWABLE;
673
674 case GIMP_UNDO_GROUP_TRANSFORM: /* FIXME */
675 return GIMP_DIRTY_ITEM | GIMP_DIRTY_DRAWABLE | GIMP_DIRTY_VECTORS;
676
677 case GIMP_UNDO_GROUP_PAINT:
678 return GIMP_DIRTY_ITEM | GIMP_DIRTY_DRAWABLE;
679
680 case GIMP_UNDO_GROUP_PARASITE_ATTACH:
681 case GIMP_UNDO_GROUP_PARASITE_REMOVE:
682 return GIMP_DIRTY_IMAGE_META | GIMP_DIRTY_ITEM_META;
683
684 case GIMP_UNDO_GROUP_VECTORS_IMPORT:
685 return GIMP_DIRTY_IMAGE_STRUCTURE | GIMP_DIRTY_VECTORS;
686
687 case GIMP_UNDO_GROUP_MISC:
688 return GIMP_DIRTY_ALL;
689
690 default:
691 break;
692 }
693
694 return GIMP_DIRTY_ALL;
695 }
696