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

254 lines
8.6 KiB
C
Raw Normal View History

Add facility to compress multiple group layer resizings into one * app/core/gimpgrouplayer.[ch]: add gimp_group_layer_suspend_resize() and gimp_group_layer_resume_resize() and call them around functions where all a group's children are transformed (translated, resized etc). This way we go from the worst case of reallocating the group's projection tiles once for each child down to exactly one reallocation. * app/core/Makefile.am * app/core/core-enums.[ch] * app/core/core-types.h * app/core/gimpimage-undo-push.[ch] * app/core/gimpgrouplayerundo.[ch]: add new undo class GimpGroupLayerUndo which implements undos for suspend/resume of group layers and calls them in reverse order when undoing.
2009-09-07 19:04:55 +08:00
/* 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
Change the license URL from http://www.gnu.org/licenses/ to https://
2018-07-12 05:27:07 +08:00
* along with this program. If not, see <https://www.gnu.org/licenses/>.
Add facility to compress multiple group layer resizings into one * app/core/gimpgrouplayer.[ch]: add gimp_group_layer_suspend_resize() and gimp_group_layer_resume_resize() and call them around functions where all a group's children are transformed (translated, resized etc). This way we go from the worst case of reallocating the group's projection tiles once for each child down to exactly one reallocation. * app/core/Makefile.am * app/core/core-enums.[ch] * app/core/core-types.h * app/core/gimpimage-undo-push.[ch] * app/core/gimpgrouplayerundo.[ch]: add new undo class GimpGroupLayerUndo which implements undos for suspend/resume of group layers and calls them in reverse order when undoing.
2009-09-07 19:04:55 +08:00
*/
#include "config.h"
app,libgimp*: fix includes to follow our include policy - don't include <gdk-pixbuf/gdk-pixbuf.h> in headers in app/ - instead, include it in many .c files instead of <glib-object.h>, finally acknowledging the fact that app/ depends on gdk-pixbuf almost globally - fix up includes as if libgimpbase depended in GIO, which it soon will
2013-10-15 07:58:39 +08:00
#include <gdk-pixbuf/gdk-pixbuf.h>
Add facility to compress multiple group layer resizings into one * app/core/gimpgrouplayer.[ch]: add gimp_group_layer_suspend_resize() and gimp_group_layer_resume_resize() and call them around functions where all a group's children are transformed (translated, resized etc). This way we go from the worst case of reallocating the group's projection tiles once for each child down to exactly one reallocation. * app/core/Makefile.am * app/core/core-enums.[ch] * app/core/core-types.h * app/core/gimpimage-undo-push.[ch] * app/core/gimpgrouplayerundo.[ch]: add new undo class GimpGroupLayerUndo which implements undos for suspend/resume of group layers and calls them in reverse order when undoing.
2009-09-07 19:04:55 +08:00
#include <gegl.h>
#include "core-types.h"
Bug 51112 - Support layer masks on layer groups Add layer-mask support for group layers. Group-layer masks work similarly to ordinary-layer masks, with the following considerations: The group's mask size is the same as group's size (i.e., the bounding box of its children) at all times. When the group's size changes, the mask is cropped to the new size -- areas of the mask that fall outside of the new bounds are discarded and their data is lost (sans undo), and newly added areas are filled with black (and hence are transparent by default). The new gimp_group_layer_{suspend,resume}_mask() functions can be used to modify this behavior. Between the outermost pair of suspend/resume calls, the old mask data is remembered, and is used to fill the newly added areas while cropping the mask when the group is resized. We override GimpItem::{start,end}_move() for GimpLayer, to call these functions (suspend() in start_move(), and resume() in end_move()) for each of the layer's ancestors. As a result, while moving a layer, or a set of layers, atomically, such as while dragging with the move tool, or moving linked layers, the ancestors' mask data is not lost, and is only discarded at the end of the operation. This commit also takes care of properly handling undo for group- layer mask crops, properly invalidating the image when the group layer's mask is shown, and enabling the mask actions for group layers (obviously :).
2018-02-06 00:19:18 +08:00
#include "gimp-memsize.h"
Add facility to compress multiple group layer resizings into one * app/core/gimpgrouplayer.[ch]: add gimp_group_layer_suspend_resize() and gimp_group_layer_resume_resize() and call them around functions where all a group's children are transformed (translated, resized etc). This way we go from the worst case of reallocating the group's projection tiles once for each child down to exactly one reallocation. * app/core/Makefile.am * app/core/core-enums.[ch] * app/core/core-types.h * app/core/gimpimage-undo-push.[ch] * app/core/gimpgrouplayerundo.[ch]: add new undo class GimpGroupLayerUndo which implements undos for suspend/resume of group layers and calls them in reverse order when undoing.
2009-09-07 19:04:55 +08:00
#include "gimpimage.h"
#include "gimpgrouplayer.h"
#include "gimpgrouplayerundo.h"
Bug 51112 - Support layer masks on layer groups Add layer-mask support for group layers. Group-layer masks work similarly to ordinary-layer masks, with the following considerations: The group's mask size is the same as group's size (i.e., the bounding box of its children) at all times. When the group's size changes, the mask is cropped to the new size -- areas of the mask that fall outside of the new bounds are discarded and their data is lost (sans undo), and newly added areas are filled with black (and hence are transparent by default). The new gimp_group_layer_{suspend,resume}_mask() functions can be used to modify this behavior. Between the outermost pair of suspend/resume calls, the old mask data is remembered, and is used to fill the newly added areas while cropping the mask when the group is resized. We override GimpItem::{start,end}_move() for GimpLayer, to call these functions (suspend() in start_move(), and resume() in end_move()) for each of the layer's ancestors. As a result, while moving a layer, or a set of layers, atomically, such as while dragging with the move tool, or moving linked layers, the ancestors' mask data is not lost, and is only discarded at the end of the operation. This commit also takes care of properly handling undo for group- layer mask crops, properly invalidating the image when the group layer's mask is shown, and enabling the mask actions for group layers (obviously :).
2018-02-06 00:19:18 +08:00
static void gimp_group_layer_undo_constructed (GObject *object);
Add facility to compress multiple group layer resizings into one * app/core/gimpgrouplayer.[ch]: add gimp_group_layer_suspend_resize() and gimp_group_layer_resume_resize() and call them around functions where all a group's children are transformed (translated, resized etc). This way we go from the worst case of reallocating the group's projection tiles once for each child down to exactly one reallocation. * app/core/Makefile.am * app/core/core-enums.[ch] * app/core/core-types.h * app/core/gimpimage-undo-push.[ch] * app/core/gimpgrouplayerundo.[ch]: add new undo class GimpGroupLayerUndo which implements undos for suspend/resume of group layers and calls them in reverse order when undoing.
2009-09-07 19:04:55 +08:00
Bug 51112 - Support layer masks on layer groups Add layer-mask support for group layers. Group-layer masks work similarly to ordinary-layer masks, with the following considerations: The group's mask size is the same as group's size (i.e., the bounding box of its children) at all times. When the group's size changes, the mask is cropped to the new size -- areas of the mask that fall outside of the new bounds are discarded and their data is lost (sans undo), and newly added areas are filled with black (and hence are transparent by default). The new gimp_group_layer_{suspend,resume}_mask() functions can be used to modify this behavior. Between the outermost pair of suspend/resume calls, the old mask data is remembered, and is used to fill the newly added areas while cropping the mask when the group is resized. We override GimpItem::{start,end}_move() for GimpLayer, to call these functions (suspend() in start_move(), and resume() in end_move()) for each of the layer's ancestors. As a result, while moving a layer, or a set of layers, atomically, such as while dragging with the move tool, or moving linked layers, the ancestors' mask data is not lost, and is only discarded at the end of the operation. This commit also takes care of properly handling undo for group- layer mask crops, properly invalidating the image when the group layer's mask is shown, and enabling the mask actions for group layers (obviously :).
2018-02-06 00:19:18 +08:00
static gint64 gimp_group_layer_undo_get_memsize (GimpObject *object,
gint64 *gui_size);
static void gimp_group_layer_undo_pop (GimpUndo *undo,
GimpUndoMode undo_mode,
GimpUndoAccumulator *accum);
static void gimp_group_layer_undo_free (GimpUndo *undo,
GimpUndoMode undo_mode);
Add facility to compress multiple group layer resizings into one * app/core/gimpgrouplayer.[ch]: add gimp_group_layer_suspend_resize() and gimp_group_layer_resume_resize() and call them around functions where all a group's children are transformed (translated, resized etc). This way we go from the worst case of reallocating the group's projection tiles once for each child down to exactly one reallocation. * app/core/Makefile.am * app/core/core-enums.[ch] * app/core/core-types.h * app/core/gimpimage-undo-push.[ch] * app/core/gimpgrouplayerundo.[ch]: add new undo class GimpGroupLayerUndo which implements undos for suspend/resume of group layers and calls them in reverse order when undoing.
2009-09-07 19:04:55 +08:00
G_DEFINE_TYPE (GimpGroupLayerUndo, gimp_group_layer_undo, GIMP_TYPE_ITEM_UNDO)
#define parent_class gimp_group_layer_undo_parent_class
static void
gimp_group_layer_undo_class_init (GimpGroupLayerUndoClass *klass)
{
Bug 51112 - Support layer masks on layer groups Add layer-mask support for group layers. Group-layer masks work similarly to ordinary-layer masks, with the following considerations: The group's mask size is the same as group's size (i.e., the bounding box of its children) at all times. When the group's size changes, the mask is cropped to the new size -- areas of the mask that fall outside of the new bounds are discarded and their data is lost (sans undo), and newly added areas are filled with black (and hence are transparent by default). The new gimp_group_layer_{suspend,resume}_mask() functions can be used to modify this behavior. Between the outermost pair of suspend/resume calls, the old mask data is remembered, and is used to fill the newly added areas while cropping the mask when the group is resized. We override GimpItem::{start,end}_move() for GimpLayer, to call these functions (suspend() in start_move(), and resume() in end_move()) for each of the layer's ancestors. As a result, while moving a layer, or a set of layers, atomically, such as while dragging with the move tool, or moving linked layers, the ancestors' mask data is not lost, and is only discarded at the end of the operation. This commit also takes care of properly handling undo for group- layer mask crops, properly invalidating the image when the group layer's mask is shown, and enabling the mask actions for group layers (obviously :).
2018-02-06 00:19:18 +08:00
GObjectClass *object_class = G_OBJECT_CLASS (klass);
GimpObjectClass *gimp_object_class = GIMP_OBJECT_CLASS (klass);
GimpUndoClass *undo_class = GIMP_UNDO_CLASS (klass);
object_class->constructed = gimp_group_layer_undo_constructed;
Add facility to compress multiple group layer resizings into one * app/core/gimpgrouplayer.[ch]: add gimp_group_layer_suspend_resize() and gimp_group_layer_resume_resize() and call them around functions where all a group's children are transformed (translated, resized etc). This way we go from the worst case of reallocating the group's projection tiles once for each child down to exactly one reallocation. * app/core/Makefile.am * app/core/core-enums.[ch] * app/core/core-types.h * app/core/gimpimage-undo-push.[ch] * app/core/gimpgrouplayerundo.[ch]: add new undo class GimpGroupLayerUndo which implements undos for suspend/resume of group layers and calls them in reverse order when undoing.
2009-09-07 19:04:55 +08:00
Bug 51112 - Support layer masks on layer groups Add layer-mask support for group layers. Group-layer masks work similarly to ordinary-layer masks, with the following considerations: The group's mask size is the same as group's size (i.e., the bounding box of its children) at all times. When the group's size changes, the mask is cropped to the new size -- areas of the mask that fall outside of the new bounds are discarded and their data is lost (sans undo), and newly added areas are filled with black (and hence are transparent by default). The new gimp_group_layer_{suspend,resume}_mask() functions can be used to modify this behavior. Between the outermost pair of suspend/resume calls, the old mask data is remembered, and is used to fill the newly added areas while cropping the mask when the group is resized. We override GimpItem::{start,end}_move() for GimpLayer, to call these functions (suspend() in start_move(), and resume() in end_move()) for each of the layer's ancestors. As a result, while moving a layer, or a set of layers, atomically, such as while dragging with the move tool, or moving linked layers, the ancestors' mask data is not lost, and is only discarded at the end of the operation. This commit also takes care of properly handling undo for group- layer mask crops, properly invalidating the image when the group layer's mask is shown, and enabling the mask actions for group layers (obviously :).
2018-02-06 00:19:18 +08:00
gimp_object_class->get_memsize = gimp_group_layer_undo_get_memsize;
Add facility to compress multiple group layer resizings into one * app/core/gimpgrouplayer.[ch]: add gimp_group_layer_suspend_resize() and gimp_group_layer_resume_resize() and call them around functions where all a group's children are transformed (translated, resized etc). This way we go from the worst case of reallocating the group's projection tiles once for each child down to exactly one reallocation. * app/core/Makefile.am * app/core/core-enums.[ch] * app/core/core-types.h * app/core/gimpimage-undo-push.[ch] * app/core/gimpgrouplayerundo.[ch]: add new undo class GimpGroupLayerUndo which implements undos for suspend/resume of group layers and calls them in reverse order when undoing.
2009-09-07 19:04:55 +08:00
Bug 51112 - Support layer masks on layer groups Add layer-mask support for group layers. Group-layer masks work similarly to ordinary-layer masks, with the following considerations: The group's mask size is the same as group's size (i.e., the bounding box of its children) at all times. When the group's size changes, the mask is cropped to the new size -- areas of the mask that fall outside of the new bounds are discarded and their data is lost (sans undo), and newly added areas are filled with black (and hence are transparent by default). The new gimp_group_layer_{suspend,resume}_mask() functions can be used to modify this behavior. Between the outermost pair of suspend/resume calls, the old mask data is remembered, and is used to fill the newly added areas while cropping the mask when the group is resized. We override GimpItem::{start,end}_move() for GimpLayer, to call these functions (suspend() in start_move(), and resume() in end_move()) for each of the layer's ancestors. As a result, while moving a layer, or a set of layers, atomically, such as while dragging with the move tool, or moving linked layers, the ancestors' mask data is not lost, and is only discarded at the end of the operation. This commit also takes care of properly handling undo for group- layer mask crops, properly invalidating the image when the group layer's mask is shown, and enabling the mask actions for group layers (obviously :).
2018-02-06 00:19:18 +08:00
undo_class->pop = gimp_group_layer_undo_pop;
undo_class->free = gimp_group_layer_undo_free;
Add facility to compress multiple group layer resizings into one * app/core/gimpgrouplayer.[ch]: add gimp_group_layer_suspend_resize() and gimp_group_layer_resume_resize() and call them around functions where all a group's children are transformed (translated, resized etc). This way we go from the worst case of reallocating the group's projection tiles once for each child down to exactly one reallocation. * app/core/Makefile.am * app/core/core-enums.[ch] * app/core/core-types.h * app/core/gimpimage-undo-push.[ch] * app/core/gimpgrouplayerundo.[ch]: add new undo class GimpGroupLayerUndo which implements undos for suspend/resume of group layers and calls them in reverse order when undoing.
2009-09-07 19:04:55 +08:00
}
static void
gimp_group_layer_undo_init (GimpGroupLayerUndo *undo)
{
}
app: implement GObject::constructed() instead of ::constructor()
2011-01-13 05:53:58 +08:00
static void
gimp_group_layer_undo_constructed (GObject *object)
Add facility to compress multiple group layer resizings into one * app/core/gimpgrouplayer.[ch]: add gimp_group_layer_suspend_resize() and gimp_group_layer_resume_resize() and call them around functions where all a group's children are transformed (translated, resized etc). This way we go from the worst case of reallocating the group's projection tiles once for each child down to exactly one reallocation. * app/core/Makefile.am * app/core/core-enums.[ch] * app/core/core-types.h * app/core/gimpimage-undo-push.[ch] * app/core/gimpgrouplayerundo.[ch]: add new undo class GimpGroupLayerUndo which implements undos for suspend/resume of group layers and calls them in reverse order when undoing.
2009-09-07 19:04:55 +08:00
{
app: implement GObject::constructed() instead of ::constructor()
2011-01-13 05:53:58 +08:00
GimpGroupLayerUndo *group_layer_undo = GIMP_GROUP_LAYER_UNDO (object);
Fix undoing a group layer type conversion * app/core/gimpdrawable.[ch]: add "gboolean push_undo" to GimpDrawable::convert_type(). * app/core/gimpdrawable-convert.[ch]: same here for the gray and rgb conversion functions. * app/core/gimpchannel.c * app/core/gimplayer.c: pass FALSE when called from GimpItem::convert() because it can be called on unattached items only. * app/core/gimpimage-convert.c: pass TRUE. * app/core/core-enums.[ch] * app/core/gimpgrouplayerundo.[ch] * app/core/gimpimage-undo-push.[ch]: add GIMP_UNDO_GROUP_LAYER_CONVERT which simply calls gimp_drawable_convert_type() with the old type when undone/redone. * app/core/gimpgrouplayer.c: push a group layer convert undo so this can be properly undone/redone.
2009-09-14 01:24:19 +08:00
GimpGroupLayer *group;
Add facility to compress multiple group layer resizings into one * app/core/gimpgrouplayer.[ch]: add gimp_group_layer_suspend_resize() and gimp_group_layer_resume_resize() and call them around functions where all a group's children are transformed (translated, resized etc). This way we go from the worst case of reallocating the group's projection tiles once for each child down to exactly one reallocation. * app/core/Makefile.am * app/core/core-enums.[ch] * app/core/core-types.h * app/core/gimpimage-undo-push.[ch] * app/core/gimpgrouplayerundo.[ch]: add new undo class GimpGroupLayerUndo which implements undos for suspend/resume of group layers and calls them in reverse order when undoing.
2009-09-07 19:04:55 +08:00
Chain up unconditionally in GObject::constructed() It's supported since GLib 2.28.
2012-11-13 04:51:22 +08:00
G_OBJECT_CLASS (parent_class)->constructed (object);
Fix undoing a group layer type conversion * app/core/gimpdrawable.[ch]: add "gboolean push_undo" to GimpDrawable::convert_type(). * app/core/gimpdrawable-convert.[ch]: same here for the gray and rgb conversion functions. * app/core/gimpchannel.c * app/core/gimplayer.c: pass FALSE when called from GimpItem::convert() because it can be called on unattached items only. * app/core/gimpimage-convert.c: pass TRUE. * app/core/core-enums.[ch] * app/core/gimpgrouplayerundo.[ch] * app/core/gimpimage-undo-push.[ch]: add GIMP_UNDO_GROUP_LAYER_CONVERT which simply calls gimp_drawable_convert_type() with the old type when undone/redone. * app/core/gimpgrouplayer.c: push a group layer convert undo so this can be properly undone/redone.
2009-09-14 01:24:19 +08:00
app: all remaining g_assert() replaced by critical warning and return... ... in app/core. Continuing on my crusade against asserting and crashing GIMP.
2018-01-22 22:55:47 +08:00
g_return_if_fail (GIMP_IS_GROUP_LAYER (GIMP_ITEM_UNDO (object)->item));
Add facility to compress multiple group layer resizings into one * app/core/gimpgrouplayer.[ch]: add gimp_group_layer_suspend_resize() and gimp_group_layer_resume_resize() and call them around functions where all a group's children are transformed (translated, resized etc). This way we go from the worst case of reallocating the group's projection tiles once for each child down to exactly one reallocation. * app/core/Makefile.am * app/core/core-enums.[ch] * app/core/core-types.h * app/core/gimpimage-undo-push.[ch] * app/core/gimpgrouplayerundo.[ch]: add new undo class GimpGroupLayerUndo which implements undos for suspend/resume of group layers and calls them in reverse order when undoing.
2009-09-07 19:04:55 +08:00
Fix undoing a group layer type conversion * app/core/gimpdrawable.[ch]: add "gboolean push_undo" to GimpDrawable::convert_type(). * app/core/gimpdrawable-convert.[ch]: same here for the gray and rgb conversion functions. * app/core/gimpchannel.c * app/core/gimplayer.c: pass FALSE when called from GimpItem::convert() because it can be called on unattached items only. * app/core/gimpimage-convert.c: pass TRUE. * app/core/core-enums.[ch] * app/core/gimpgrouplayerundo.[ch] * app/core/gimpimage-undo-push.[ch]: add GIMP_UNDO_GROUP_LAYER_CONVERT which simply calls gimp_drawable_convert_type() with the old type when undone/redone. * app/core/gimpgrouplayer.c: push a group layer convert undo so this can be properly undone/redone.
2009-09-14 01:24:19 +08:00
group = GIMP_GROUP_LAYER (GIMP_ITEM_UNDO (object)->item);
switch (GIMP_UNDO (object)->undo_type)
{
Bug 51112 - Support layer masks on layer groups Add layer-mask support for group layers. Group-layer masks work similarly to ordinary-layer masks, with the following considerations: The group's mask size is the same as group's size (i.e., the bounding box of its children) at all times. When the group's size changes, the mask is cropped to the new size -- areas of the mask that fall outside of the new bounds are discarded and their data is lost (sans undo), and newly added areas are filled with black (and hence are transparent by default). The new gimp_group_layer_{suspend,resume}_mask() functions can be used to modify this behavior. Between the outermost pair of suspend/resume calls, the old mask data is remembered, and is used to fill the newly added areas while cropping the mask when the group is resized. We override GimpItem::{start,end}_move() for GimpLayer, to call these functions (suspend() in start_move(), and resume() in end_move()) for each of the layer's ancestors. As a result, while moving a layer, or a set of layers, atomically, such as while dragging with the move tool, or moving linked layers, the ancestors' mask data is not lost, and is only discarded at the end of the operation. This commit also takes care of properly handling undo for group- layer mask crops, properly invalidating the image when the group layer's mask is shown, and enabling the mask actions for group layers (obviously :).
2018-02-06 00:19:18 +08:00
case GIMP_UNDO_GROUP_LAYER_SUSPEND_RESIZE:
case GIMP_UNDO_GROUP_LAYER_RESUME_RESIZE:
case GIMP_UNDO_GROUP_LAYER_SUSPEND_MASK:
Bug 795410 - Deleting a layer group and then undoing the deletion ... ... raises a CRITICAL gimp_item_{start,end}_move() currently serves two different purposes: It is used by GimpLayer to suspend/resume mask resizing of the layer's ancestors; this is necessary whenever an operation on a layer might affect the size of its ancestors. It is also used by GimpGroupLayer to suspend/resume its own mask resizing; this, on the other hand, is only necessary before applying one of the transformation functions to the group, so that mask modification is handled by GimpLayer. In other words, the effects of gimp_item_{start,end}_move() on group layers are only necessary in a subset of the cases in which these functions are used. While in itself this isn't a problem, it does cause issues when removing a group layer: gimp_image_remove_layer() calls gimp_item_start_move() before removing the layer, and gimp_item_end_move() afterwards. While the former function is called while the layer is still attached to the image, the latter function is called after the layer is no longer attached. Since GimpGroupLayer pushes an undo step in response to these calls, only the call to start_move() results in an undo step, while the call to end_move() doesn't, resulting in an unbalanced GIMP_UNDO_GROUP_LAYER_START_MOVE undo step on the stack. This causes problems when undoing the operation. Add gimp_item_{start,end}_transform() functions, and corresponding GimpItem::{start,end}_transform() virtual functions, which are more specialized versions of gimp_item_{start,end}_move(), which should be used instead of the former before/after transforming an item; in other cases, such as when removing ot reordering an item, gimp_item_{start,end}_move() should still be used. The default implementation of GimpItem::{start,end}_transform() calls gimp_item_{start,end}_move(), respectively, so subclasses that override these functions don't have to do that themselves. In GimpGroupLayer, override GimpItem::{start,end}_transform(), instead of GimpItem::{start,end}_move(), for the same purpose of suspending mask resize. This avoids these functions from being called when removing a layer group, fixing the bug.
2018-04-22 15:39:40 +08:00
case GIMP_UNDO_GROUP_LAYER_START_TRANSFORM:
case GIMP_UNDO_GROUP_LAYER_END_TRANSFORM:
Bug 51112 - Support layer masks on layer groups Add layer-mask support for group layers. Group-layer masks work similarly to ordinary-layer masks, with the following considerations: The group's mask size is the same as group's size (i.e., the bounding box of its children) at all times. When the group's size changes, the mask is cropped to the new size -- areas of the mask that fall outside of the new bounds are discarded and their data is lost (sans undo), and newly added areas are filled with black (and hence are transparent by default). The new gimp_group_layer_{suspend,resume}_mask() functions can be used to modify this behavior. Between the outermost pair of suspend/resume calls, the old mask data is remembered, and is used to fill the newly added areas while cropping the mask when the group is resized. We override GimpItem::{start,end}_move() for GimpLayer, to call these functions (suspend() in start_move(), and resume() in end_move()) for each of the layer's ancestors. As a result, while moving a layer, or a set of layers, atomically, such as while dragging with the move tool, or moving linked layers, the ancestors' mask data is not lost, and is only discarded at the end of the operation. This commit also takes care of properly handling undo for group- layer mask crops, properly invalidating the image when the group layer's mask is shown, and enabling the mask actions for group layers (obviously :).
2018-02-06 00:19:18 +08:00
break;
case GIMP_UNDO_GROUP_LAYER_RESUME_MASK:
app: fix undo when resizing a group layer with a mask Override GimpItem::resize(), instead of GimpLayer::resize(), when resizing a group layer, so that GimpLayer doesn't try to resize the mask. Instead, the let the usual mask resizing logic in GimpGroupLayer handle that. Also, make sure that the mask is properly restored upon undo when group resizing is suspended outside of any mask-suspension block, which can happen when resizing the group.
2018-02-06 03:53:38 +08:00
group_layer_undo->mask_buffer =
_gimp_group_layer_get_suspended_mask(group,
&group_layer_undo->mask_bounds);
Bug 51112 - Support layer masks on layer groups Add layer-mask support for group layers. Group-layer masks work similarly to ordinary-layer masks, with the following considerations: The group's mask size is the same as group's size (i.e., the bounding box of its children) at all times. When the group's size changes, the mask is cropped to the new size -- areas of the mask that fall outside of the new bounds are discarded and their data is lost (sans undo), and newly added areas are filled with black (and hence are transparent by default). The new gimp_group_layer_{suspend,resume}_mask() functions can be used to modify this behavior. Between the outermost pair of suspend/resume calls, the old mask data is remembered, and is used to fill the newly added areas while cropping the mask when the group is resized. We override GimpItem::{start,end}_move() for GimpLayer, to call these functions (suspend() in start_move(), and resume() in end_move()) for each of the layer's ancestors. As a result, while moving a layer, or a set of layers, atomically, such as while dragging with the move tool, or moving linked layers, the ancestors' mask data is not lost, and is only discarded at the end of the operation. This commit also takes care of properly handling undo for group- layer mask crops, properly invalidating the image when the group layer's mask is shown, and enabling the mask actions for group layers (obviously :).
2018-02-06 00:19:18 +08:00
app: fix undo when resizing a group layer with a mask Override GimpItem::resize(), instead of GimpLayer::resize(), when resizing a group layer, so that GimpLayer doesn't try to resize the mask. Instead, the let the usual mask resizing logic in GimpGroupLayer handle that. Also, make sure that the mask is properly restored upon undo when group resizing is suspended outside of any mask-suspension block, which can happen when resizing the group.
2018-02-06 03:53:38 +08:00
if (group_layer_undo->mask_buffer)
g_object_ref (group_layer_undo->mask_buffer);
Fix undoing a group layer type conversion * app/core/gimpdrawable.[ch]: add "gboolean push_undo" to GimpDrawable::convert_type(). * app/core/gimpdrawable-convert.[ch]: same here for the gray and rgb conversion functions. * app/core/gimpchannel.c * app/core/gimplayer.c: pass FALSE when called from GimpItem::convert() because it can be called on unattached items only. * app/core/gimpimage-convert.c: pass TRUE. * app/core/core-enums.[ch] * app/core/gimpgrouplayerundo.[ch] * app/core/gimpimage-undo-push.[ch]: add GIMP_UNDO_GROUP_LAYER_CONVERT which simply calls gimp_drawable_convert_type() with the old type when undone/redone. * app/core/gimpgrouplayer.c: push a group layer convert undo so this can be properly undone/redone.
2009-09-14 01:24:19 +08:00
break;
case GIMP_UNDO_GROUP_LAYER_CONVERT:
app: use gimp_drawable_get_base_type() instead of GIMP_IMAGE_TYPE_BASE_TYPE()
2012-04-07 07:51:08 +08:00
group_layer_undo->prev_type = gimp_drawable_get_base_type (GIMP_DRAWABLE (group));
app: add "new_precision" argument to gimp_drawable_convert_type() for clarity and consistency with the "new_base_type" argument.
2012-04-25 18:09:45 +08:00
group_layer_undo->prev_precision = gimp_drawable_get_precision (GIMP_DRAWABLE (group));
app: add "gboolean new_has_alpha" to gimp_drawable_convert_type() making its external API "complete". Remove the redundant "new_base_type" and "new_precision" from the internal (vfunc) API (the Babl format has the same information).
2016-10-04 07:39:15 +08:00
group_layer_undo->prev_has_alpha = gimp_drawable_has_alpha (GIMP_DRAWABLE (group));
Fix undoing a group layer type conversion * app/core/gimpdrawable.[ch]: add "gboolean push_undo" to GimpDrawable::convert_type(). * app/core/gimpdrawable-convert.[ch]: same here for the gray and rgb conversion functions. * app/core/gimpchannel.c * app/core/gimplayer.c: pass FALSE when called from GimpItem::convert() because it can be called on unattached items only. * app/core/gimpimage-convert.c: pass TRUE. * app/core/core-enums.[ch] * app/core/gimpgrouplayerundo.[ch] * app/core/gimpimage-undo-push.[ch]: add GIMP_UNDO_GROUP_LAYER_CONVERT which simply calls gimp_drawable_convert_type() with the old type when undone/redone. * app/core/gimpgrouplayer.c: push a group layer convert undo so this can be properly undone/redone.
2009-09-14 01:24:19 +08:00
break;
default:
app: we should not have any g_assert*() code if possible. Replace all g_assert_not_reached() in app/core/ by g_return_if_reached() or g_return_val_if_reached(). GIMP may handle a lot of creative work, sometimes unsaved for hours. We should not just crash on purpose. g_assert*() could theoretically be turned off on a glib build, but this is nearly never done, and is not a solution either (actually it is probably even worse because the broken code would just continue on a forbidden path). It is much better to return with a warning on such forbidden code paths, allowing someone to report a bug without experiencing a crash and data loss. For now, I only took care of g_assert_not_reached() inside app/core. More g_assert*() code should be replaced. Note: assert are acceptable in plug-ins though, but not in the main executable, unless absolutely necessary (something happening so bad that crash is better than continuing).
2018-01-22 19:33:39 +08:00
g_return_if_reached ();
Fix undoing a group layer type conversion * app/core/gimpdrawable.[ch]: add "gboolean push_undo" to GimpDrawable::convert_type(). * app/core/gimpdrawable-convert.[ch]: same here for the gray and rgb conversion functions. * app/core/gimpchannel.c * app/core/gimplayer.c: pass FALSE when called from GimpItem::convert() because it can be called on unattached items only. * app/core/gimpimage-convert.c: pass TRUE. * app/core/core-enums.[ch] * app/core/gimpgrouplayerundo.[ch] * app/core/gimpimage-undo-push.[ch]: add GIMP_UNDO_GROUP_LAYER_CONVERT which simply calls gimp_drawable_convert_type() with the old type when undone/redone. * app/core/gimpgrouplayer.c: push a group layer convert undo so this can be properly undone/redone.
2009-09-14 01:24:19 +08:00
}
Add facility to compress multiple group layer resizings into one * app/core/gimpgrouplayer.[ch]: add gimp_group_layer_suspend_resize() and gimp_group_layer_resume_resize() and call them around functions where all a group's children are transformed (translated, resized etc). This way we go from the worst case of reallocating the group's projection tiles once for each child down to exactly one reallocation. * app/core/Makefile.am * app/core/core-enums.[ch] * app/core/core-types.h * app/core/gimpimage-undo-push.[ch] * app/core/gimpgrouplayerundo.[ch]: add new undo class GimpGroupLayerUndo which implements undos for suspend/resume of group layers and calls them in reverse order when undoing.
2009-09-07 19:04:55 +08:00
}
Bug 51112 - Support layer masks on layer groups Add layer-mask support for group layers. Group-layer masks work similarly to ordinary-layer masks, with the following considerations: The group's mask size is the same as group's size (i.e., the bounding box of its children) at all times. When the group's size changes, the mask is cropped to the new size -- areas of the mask that fall outside of the new bounds are discarded and their data is lost (sans undo), and newly added areas are filled with black (and hence are transparent by default). The new gimp_group_layer_{suspend,resume}_mask() functions can be used to modify this behavior. Between the outermost pair of suspend/resume calls, the old mask data is remembered, and is used to fill the newly added areas while cropping the mask when the group is resized. We override GimpItem::{start,end}_move() for GimpLayer, to call these functions (suspend() in start_move(), and resume() in end_move()) for each of the layer's ancestors. As a result, while moving a layer, or a set of layers, atomically, such as while dragging with the move tool, or moving linked layers, the ancestors' mask data is not lost, and is only discarded at the end of the operation. This commit also takes care of properly handling undo for group- layer mask crops, properly invalidating the image when the group layer's mask is shown, and enabling the mask actions for group layers (obviously :).
2018-02-06 00:19:18 +08:00
static gint64
gimp_group_layer_undo_get_memsize (GimpObject *object,
gint64 *gui_size)
{
GimpGroupLayerUndo *group_layer_undo = GIMP_GROUP_LAYER_UNDO (object);
gint64 memsize = 0;
app: fix undo when resizing a group layer with a mask Override GimpItem::resize(), instead of GimpLayer::resize(), when resizing a group layer, so that GimpLayer doesn't try to resize the mask. Instead, the let the usual mask resizing logic in GimpGroupLayer handle that. Also, make sure that the mask is properly restored upon undo when group resizing is suspended outside of any mask-suspension block, which can happen when resizing the group.
2018-02-06 03:53:38 +08:00
memsize += gimp_gegl_buffer_get_memsize (group_layer_undo->mask_buffer);
Bug 51112 - Support layer masks on layer groups Add layer-mask support for group layers. Group-layer masks work similarly to ordinary-layer masks, with the following considerations: The group's mask size is the same as group's size (i.e., the bounding box of its children) at all times. When the group's size changes, the mask is cropped to the new size -- areas of the mask that fall outside of the new bounds are discarded and their data is lost (sans undo), and newly added areas are filled with black (and hence are transparent by default). The new gimp_group_layer_{suspend,resume}_mask() functions can be used to modify this behavior. Between the outermost pair of suspend/resume calls, the old mask data is remembered, and is used to fill the newly added areas while cropping the mask when the group is resized. We override GimpItem::{start,end}_move() for GimpLayer, to call these functions (suspend() in start_move(), and resume() in end_move()) for each of the layer's ancestors. As a result, while moving a layer, or a set of layers, atomically, such as while dragging with the move tool, or moving linked layers, the ancestors' mask data is not lost, and is only discarded at the end of the operation. This commit also takes care of properly handling undo for group- layer mask crops, properly invalidating the image when the group layer's mask is shown, and enabling the mask actions for group layers (obviously :).
2018-02-06 00:19:18 +08:00
return memsize + GIMP_OBJECT_CLASS (parent_class)->get_memsize (object,
gui_size);
}
Add facility to compress multiple group layer resizings into one * app/core/gimpgrouplayer.[ch]: add gimp_group_layer_suspend_resize() and gimp_group_layer_resume_resize() and call them around functions where all a group's children are transformed (translated, resized etc). This way we go from the worst case of reallocating the group's projection tiles once for each child down to exactly one reallocation. * app/core/Makefile.am * app/core/core-enums.[ch] * app/core/core-types.h * app/core/gimpimage-undo-push.[ch] * app/core/gimpgrouplayerundo.[ch]: add new undo class GimpGroupLayerUndo which implements undos for suspend/resume of group layers and calls them in reverse order when undoing.
2009-09-07 19:04:55 +08:00
static void
gimp_group_layer_undo_pop (GimpUndo *undo,
Fix undoing a group layer type conversion * app/core/gimpdrawable.[ch]: add "gboolean push_undo" to GimpDrawable::convert_type(). * app/core/gimpdrawable-convert.[ch]: same here for the gray and rgb conversion functions. * app/core/gimpchannel.c * app/core/gimplayer.c: pass FALSE when called from GimpItem::convert() because it can be called on unattached items only. * app/core/gimpimage-convert.c: pass TRUE. * app/core/core-enums.[ch] * app/core/gimpgrouplayerundo.[ch] * app/core/gimpimage-undo-push.[ch]: add GIMP_UNDO_GROUP_LAYER_CONVERT which simply calls gimp_drawable_convert_type() with the old type when undone/redone. * app/core/gimpgrouplayer.c: push a group layer convert undo so this can be properly undone/redone.
2009-09-14 01:24:19 +08:00
GimpUndoMode undo_mode,
GimpUndoAccumulator *accum)
Add facility to compress multiple group layer resizings into one * app/core/gimpgrouplayer.[ch]: add gimp_group_layer_suspend_resize() and gimp_group_layer_resume_resize() and call them around functions where all a group's children are transformed (translated, resized etc). This way we go from the worst case of reallocating the group's projection tiles once for each child down to exactly one reallocation. * app/core/Makefile.am * app/core/core-enums.[ch] * app/core/core-types.h * app/core/gimpimage-undo-push.[ch] * app/core/gimpgrouplayerundo.[ch]: add new undo class GimpGroupLayerUndo which implements undos for suspend/resume of group layers and calls them in reverse order when undoing.
2009-09-07 19:04:55 +08:00
{
Fix undoing a group layer type conversion * app/core/gimpdrawable.[ch]: add "gboolean push_undo" to GimpDrawable::convert_type(). * app/core/gimpdrawable-convert.[ch]: same here for the gray and rgb conversion functions. * app/core/gimpchannel.c * app/core/gimplayer.c: pass FALSE when called from GimpItem::convert() because it can be called on unattached items only. * app/core/gimpimage-convert.c: pass TRUE. * app/core/core-enums.[ch] * app/core/gimpgrouplayerundo.[ch] * app/core/gimpimage-undo-push.[ch]: add GIMP_UNDO_GROUP_LAYER_CONVERT which simply calls gimp_drawable_convert_type() with the old type when undone/redone. * app/core/gimpgrouplayer.c: push a group layer convert undo so this can be properly undone/redone.
2009-09-14 01:24:19 +08:00
GimpGroupLayerUndo *group_layer_undo = GIMP_GROUP_LAYER_UNDO (undo);
GimpGroupLayer *group;
Add facility to compress multiple group layer resizings into one * app/core/gimpgrouplayer.[ch]: add gimp_group_layer_suspend_resize() and gimp_group_layer_resume_resize() and call them around functions where all a group's children are transformed (translated, resized etc). This way we go from the worst case of reallocating the group's projection tiles once for each child down to exactly one reallocation. * app/core/Makefile.am * app/core/core-enums.[ch] * app/core/core-types.h * app/core/gimpimage-undo-push.[ch] * app/core/gimpgrouplayerundo.[ch]: add new undo class GimpGroupLayerUndo which implements undos for suspend/resume of group layers and calls them in reverse order when undoing.
2009-09-07 19:04:55 +08:00
Fix undoing a group layer type conversion * app/core/gimpdrawable.[ch]: add "gboolean push_undo" to GimpDrawable::convert_type(). * app/core/gimpdrawable-convert.[ch]: same here for the gray and rgb conversion functions. * app/core/gimpchannel.c * app/core/gimplayer.c: pass FALSE when called from GimpItem::convert() because it can be called on unattached items only. * app/core/gimpimage-convert.c: pass TRUE. * app/core/core-enums.[ch] * app/core/gimpgrouplayerundo.[ch] * app/core/gimpimage-undo-push.[ch]: add GIMP_UNDO_GROUP_LAYER_CONVERT which simply calls gimp_drawable_convert_type() with the old type when undone/redone. * app/core/gimpgrouplayer.c: push a group layer convert undo so this can be properly undone/redone.
2009-09-14 01:24:19 +08:00
group = GIMP_GROUP_LAYER (GIMP_ITEM_UNDO (undo)->item);
Add facility to compress multiple group layer resizings into one * app/core/gimpgrouplayer.[ch]: add gimp_group_layer_suspend_resize() and gimp_group_layer_resume_resize() and call them around functions where all a group's children are transformed (translated, resized etc). This way we go from the worst case of reallocating the group's projection tiles once for each child down to exactly one reallocation. * app/core/Makefile.am * app/core/core-enums.[ch] * app/core/core-types.h * app/core/gimpimage-undo-push.[ch] * app/core/gimpgrouplayerundo.[ch]: add new undo class GimpGroupLayerUndo which implements undos for suspend/resume of group layers and calls them in reverse order when undoing.
2009-09-07 19:04:55 +08:00
Fix undoing a group layer type conversion * app/core/gimpdrawable.[ch]: add "gboolean push_undo" to GimpDrawable::convert_type(). * app/core/gimpdrawable-convert.[ch]: same here for the gray and rgb conversion functions. * app/core/gimpchannel.c * app/core/gimplayer.c: pass FALSE when called from GimpItem::convert() because it can be called on unattached items only. * app/core/gimpimage-convert.c: pass TRUE. * app/core/core-enums.[ch] * app/core/gimpgrouplayerundo.[ch] * app/core/gimpimage-undo-push.[ch]: add GIMP_UNDO_GROUP_LAYER_CONVERT which simply calls gimp_drawable_convert_type() with the old type when undone/redone. * app/core/gimpgrouplayer.c: push a group layer convert undo so this can be properly undone/redone.
2009-09-14 01:24:19 +08:00
GIMP_UNDO_CLASS (parent_class)->pop (undo, undo_mode, accum);
Add facility to compress multiple group layer resizings into one * app/core/gimpgrouplayer.[ch]: add gimp_group_layer_suspend_resize() and gimp_group_layer_resume_resize() and call them around functions where all a group's children are transformed (translated, resized etc). This way we go from the worst case of reallocating the group's projection tiles once for each child down to exactly one reallocation. * app/core/Makefile.am * app/core/core-enums.[ch] * app/core/core-types.h * app/core/gimpimage-undo-push.[ch] * app/core/gimpgrouplayerundo.[ch]: add new undo class GimpGroupLayerUndo which implements undos for suspend/resume of group layers and calls them in reverse order when undoing.
2009-09-07 19:04:55 +08:00
Fix undoing a group layer type conversion * app/core/gimpdrawable.[ch]: add "gboolean push_undo" to GimpDrawable::convert_type(). * app/core/gimpdrawable-convert.[ch]: same here for the gray and rgb conversion functions. * app/core/gimpchannel.c * app/core/gimplayer.c: pass FALSE when called from GimpItem::convert() because it can be called on unattached items only. * app/core/gimpimage-convert.c: pass TRUE. * app/core/core-enums.[ch] * app/core/gimpgrouplayerundo.[ch] * app/core/gimpimage-undo-push.[ch]: add GIMP_UNDO_GROUP_LAYER_CONVERT which simply calls gimp_drawable_convert_type() with the old type when undone/redone. * app/core/gimpgrouplayer.c: push a group layer convert undo so this can be properly undone/redone.
2009-09-14 01:24:19 +08:00
switch (undo->undo_type)
Add facility to compress multiple group layer resizings into one * app/core/gimpgrouplayer.[ch]: add gimp_group_layer_suspend_resize() and gimp_group_layer_resume_resize() and call them around functions where all a group's children are transformed (translated, resized etc). This way we go from the worst case of reallocating the group's projection tiles once for each child down to exactly one reallocation. * app/core/Makefile.am * app/core/core-enums.[ch] * app/core/core-types.h * app/core/gimpimage-undo-push.[ch] * app/core/gimpgrouplayerundo.[ch]: add new undo class GimpGroupLayerUndo which implements undos for suspend/resume of group layers and calls them in reverse order when undoing.
2009-09-07 19:04:55 +08:00
{
Bug 51112 - Support layer masks on layer groups Add layer-mask support for group layers. Group-layer masks work similarly to ordinary-layer masks, with the following considerations: The group's mask size is the same as group's size (i.e., the bounding box of its children) at all times. When the group's size changes, the mask is cropped to the new size -- areas of the mask that fall outside of the new bounds are discarded and their data is lost (sans undo), and newly added areas are filled with black (and hence are transparent by default). The new gimp_group_layer_{suspend,resume}_mask() functions can be used to modify this behavior. Between the outermost pair of suspend/resume calls, the old mask data is remembered, and is used to fill the newly added areas while cropping the mask when the group is resized. We override GimpItem::{start,end}_move() for GimpLayer, to call these functions (suspend() in start_move(), and resume() in end_move()) for each of the layer's ancestors. As a result, while moving a layer, or a set of layers, atomically, such as while dragging with the move tool, or moving linked layers, the ancestors' mask data is not lost, and is only discarded at the end of the operation. This commit also takes care of properly handling undo for group- layer mask crops, properly invalidating the image when the group layer's mask is shown, and enabling the mask actions for group layers (obviously :).
2018-02-06 00:19:18 +08:00
case GIMP_UNDO_GROUP_LAYER_SUSPEND_RESIZE:
case GIMP_UNDO_GROUP_LAYER_RESUME_RESIZE:
Fix undoing a group layer type conversion * app/core/gimpdrawable.[ch]: add "gboolean push_undo" to GimpDrawable::convert_type(). * app/core/gimpdrawable-convert.[ch]: same here for the gray and rgb conversion functions. * app/core/gimpchannel.c * app/core/gimplayer.c: pass FALSE when called from GimpItem::convert() because it can be called on unattached items only. * app/core/gimpimage-convert.c: pass TRUE. * app/core/core-enums.[ch] * app/core/gimpgrouplayerundo.[ch] * app/core/gimpimage-undo-push.[ch]: add GIMP_UNDO_GROUP_LAYER_CONVERT which simply calls gimp_drawable_convert_type() with the old type when undone/redone. * app/core/gimpgrouplayer.c: push a group layer convert undo so this can be properly undone/redone.
2009-09-14 01:24:19 +08:00
if ((undo_mode == GIMP_UNDO_MODE_UNDO &&
Bug 51112 - Support layer masks on layer groups Add layer-mask support for group layers. Group-layer masks work similarly to ordinary-layer masks, with the following considerations: The group's mask size is the same as group's size (i.e., the bounding box of its children) at all times. When the group's size changes, the mask is cropped to the new size -- areas of the mask that fall outside of the new bounds are discarded and their data is lost (sans undo), and newly added areas are filled with black (and hence are transparent by default). The new gimp_group_layer_{suspend,resume}_mask() functions can be used to modify this behavior. Between the outermost pair of suspend/resume calls, the old mask data is remembered, and is used to fill the newly added areas while cropping the mask when the group is resized. We override GimpItem::{start,end}_move() for GimpLayer, to call these functions (suspend() in start_move(), and resume() in end_move()) for each of the layer's ancestors. As a result, while moving a layer, or a set of layers, atomically, such as while dragging with the move tool, or moving linked layers, the ancestors' mask data is not lost, and is only discarded at the end of the operation. This commit also takes care of properly handling undo for group- layer mask crops, properly invalidating the image when the group layer's mask is shown, and enabling the mask actions for group layers (obviously :).
2018-02-06 00:19:18 +08:00
undo->undo_type == GIMP_UNDO_GROUP_LAYER_SUSPEND_RESIZE) ||
Fix undoing a group layer type conversion * app/core/gimpdrawable.[ch]: add "gboolean push_undo" to GimpDrawable::convert_type(). * app/core/gimpdrawable-convert.[ch]: same here for the gray and rgb conversion functions. * app/core/gimpchannel.c * app/core/gimplayer.c: pass FALSE when called from GimpItem::convert() because it can be called on unattached items only. * app/core/gimpimage-convert.c: pass TRUE. * app/core/core-enums.[ch] * app/core/gimpgrouplayerundo.[ch] * app/core/gimpimage-undo-push.[ch]: add GIMP_UNDO_GROUP_LAYER_CONVERT which simply calls gimp_drawable_convert_type() with the old type when undone/redone. * app/core/gimpgrouplayer.c: push a group layer convert undo so this can be properly undone/redone.
2009-09-14 01:24:19 +08:00
(undo_mode == GIMP_UNDO_MODE_REDO &&
Bug 51112 - Support layer masks on layer groups Add layer-mask support for group layers. Group-layer masks work similarly to ordinary-layer masks, with the following considerations: The group's mask size is the same as group's size (i.e., the bounding box of its children) at all times. When the group's size changes, the mask is cropped to the new size -- areas of the mask that fall outside of the new bounds are discarded and their data is lost (sans undo), and newly added areas are filled with black (and hence are transparent by default). The new gimp_group_layer_{suspend,resume}_mask() functions can be used to modify this behavior. Between the outermost pair of suspend/resume calls, the old mask data is remembered, and is used to fill the newly added areas while cropping the mask when the group is resized. We override GimpItem::{start,end}_move() for GimpLayer, to call these functions (suspend() in start_move(), and resume() in end_move()) for each of the layer's ancestors. As a result, while moving a layer, or a set of layers, atomically, such as while dragging with the move tool, or moving linked layers, the ancestors' mask data is not lost, and is only discarded at the end of the operation. This commit also takes care of properly handling undo for group- layer mask crops, properly invalidating the image when the group layer's mask is shown, and enabling the mask actions for group layers (obviously :).
2018-02-06 00:19:18 +08:00
undo->undo_type == GIMP_UNDO_GROUP_LAYER_RESUME_RESIZE))
Fix undoing a group layer type conversion * app/core/gimpdrawable.[ch]: add "gboolean push_undo" to GimpDrawable::convert_type(). * app/core/gimpdrawable-convert.[ch]: same here for the gray and rgb conversion functions. * app/core/gimpchannel.c * app/core/gimplayer.c: pass FALSE when called from GimpItem::convert() because it can be called on unattached items only. * app/core/gimpimage-convert.c: pass TRUE. * app/core/core-enums.[ch] * app/core/gimpgrouplayerundo.[ch] * app/core/gimpimage-undo-push.[ch]: add GIMP_UNDO_GROUP_LAYER_CONVERT which simply calls gimp_drawable_convert_type() with the old type when undone/redone. * app/core/gimpgrouplayer.c: push a group layer convert undo so this can be properly undone/redone.
2009-09-14 01:24:19 +08:00
{
/* resume group layer auto-resizing */
gimp_group_layer_resume_resize (group, FALSE);
}
else
{
/* suspend group layer auto-resizing */
gimp_group_layer_suspend_resize (group, FALSE);
app: fix undo when resizing a group layer with a mask Override GimpItem::resize(), instead of GimpLayer::resize(), when resizing a group layer, so that GimpLayer doesn't try to resize the mask. Instead, the let the usual mask resizing logic in GimpGroupLayer handle that. Also, make sure that the mask is properly restored upon undo when group resizing is suspended outside of any mask-suspension block, which can happen when resizing the group.
2018-02-06 03:53:38 +08:00
if (undo->undo_type == GIMP_UNDO_GROUP_LAYER_RESUME_RESIZE &&
group_layer_undo->mask_buffer)
{
GimpLayerMask *mask = gimp_layer_get_mask (GIMP_LAYER (group));
gimp_drawable_set_buffer_full (GIMP_DRAWABLE (mask),
FALSE, NULL,
group_layer_undo->mask_buffer,
app: in GimpDrawable::set_buffer(), take bounds rect instead of offset only In GimpDrawable::set_buffer(), and the corresponding gimp_drawable_set_buffer_full() function, take a bounds rectangle, which specifies both the drawable's new offset and its new size, instead of only taking the new offset. In gimp_drawable_real_set_buffer(), set the item size according to the rect dimensions, instead of the buffer dimensions. The rect's width/height may be 0, in which case the buffer's dimensions are used. Adapt the rest of the code. We do this in preparation for maintaining the drawable's bounding box separately from its logical bounds, allowing the drawable content to extend beyond its bounds.
2019-08-02 02:41:47 +08:00
&group_layer_undo->mask_bounds,
app: add "update" parameter to gimp_drawable_set_buffer_full() ... which specifies whether or not to update the drawable in response to the buffer change. Pass TRUE for "update" at all existing call sites, to keep the current behavior.
2018-08-04 00:58:03 +08:00
TRUE);
app: fix undo when resizing a group layer with a mask Override GimpItem::resize(), instead of GimpLayer::resize(), when resizing a group layer, so that GimpLayer doesn't try to resize the mask. Instead, the let the usual mask resizing logic in GimpGroupLayer handle that. Also, make sure that the mask is properly restored upon undo when group resizing is suspended outside of any mask-suspension block, which can happen when resizing the group.
2018-02-06 03:53:38 +08:00
}
Fix undoing a group layer type conversion * app/core/gimpdrawable.[ch]: add "gboolean push_undo" to GimpDrawable::convert_type(). * app/core/gimpdrawable-convert.[ch]: same here for the gray and rgb conversion functions. * app/core/gimpchannel.c * app/core/gimplayer.c: pass FALSE when called from GimpItem::convert() because it can be called on unattached items only. * app/core/gimpimage-convert.c: pass TRUE. * app/core/core-enums.[ch] * app/core/gimpgrouplayerundo.[ch] * app/core/gimpimage-undo-push.[ch]: add GIMP_UNDO_GROUP_LAYER_CONVERT which simply calls gimp_drawable_convert_type() with the old type when undone/redone. * app/core/gimpgrouplayer.c: push a group layer convert undo so this can be properly undone/redone.
2009-09-14 01:24:19 +08:00
}
break;
Bug 51112 - Support layer masks on layer groups Add layer-mask support for group layers. Group-layer masks work similarly to ordinary-layer masks, with the following considerations: The group's mask size is the same as group's size (i.e., the bounding box of its children) at all times. When the group's size changes, the mask is cropped to the new size -- areas of the mask that fall outside of the new bounds are discarded and their data is lost (sans undo), and newly added areas are filled with black (and hence are transparent by default). The new gimp_group_layer_{suspend,resume}_mask() functions can be used to modify this behavior. Between the outermost pair of suspend/resume calls, the old mask data is remembered, and is used to fill the newly added areas while cropping the mask when the group is resized. We override GimpItem::{start,end}_move() for GimpLayer, to call these functions (suspend() in start_move(), and resume() in end_move()) for each of the layer's ancestors. As a result, while moving a layer, or a set of layers, atomically, such as while dragging with the move tool, or moving linked layers, the ancestors' mask data is not lost, and is only discarded at the end of the operation. This commit also takes care of properly handling undo for group- layer mask crops, properly invalidating the image when the group layer's mask is shown, and enabling the mask actions for group layers (obviously :).
2018-02-06 00:19:18 +08:00
case GIMP_UNDO_GROUP_LAYER_SUSPEND_MASK:
case GIMP_UNDO_GROUP_LAYER_RESUME_MASK:
if ((undo_mode == GIMP_UNDO_MODE_UNDO &&
undo->undo_type == GIMP_UNDO_GROUP_LAYER_SUSPEND_MASK) ||
(undo_mode == GIMP_UNDO_MODE_REDO &&
undo->undo_type == GIMP_UNDO_GROUP_LAYER_RESUME_MASK))
{
/* resume group layer mask auto-resizing */
gimp_group_layer_resume_mask (group, FALSE);
}
else
{
/* suspend group layer mask auto-resizing */
gimp_group_layer_suspend_mask (group, FALSE);
if (undo->undo_type == GIMP_UNDO_GROUP_LAYER_RESUME_MASK &&
app: fix undo when resizing a group layer with a mask Override GimpItem::resize(), instead of GimpLayer::resize(), when resizing a group layer, so that GimpLayer doesn't try to resize the mask. Instead, the let the usual mask resizing logic in GimpGroupLayer handle that. Also, make sure that the mask is properly restored upon undo when group resizing is suspended outside of any mask-suspension block, which can happen when resizing the group.
2018-02-06 03:53:38 +08:00
group_layer_undo->mask_buffer)
Bug 51112 - Support layer masks on layer groups Add layer-mask support for group layers. Group-layer masks work similarly to ordinary-layer masks, with the following considerations: The group's mask size is the same as group's size (i.e., the bounding box of its children) at all times. When the group's size changes, the mask is cropped to the new size -- areas of the mask that fall outside of the new bounds are discarded and their data is lost (sans undo), and newly added areas are filled with black (and hence are transparent by default). The new gimp_group_layer_{suspend,resume}_mask() functions can be used to modify this behavior. Between the outermost pair of suspend/resume calls, the old mask data is remembered, and is used to fill the newly added areas while cropping the mask when the group is resized. We override GimpItem::{start,end}_move() for GimpLayer, to call these functions (suspend() in start_move(), and resume() in end_move()) for each of the layer's ancestors. As a result, while moving a layer, or a set of layers, atomically, such as while dragging with the move tool, or moving linked layers, the ancestors' mask data is not lost, and is only discarded at the end of the operation. This commit also takes care of properly handling undo for group- layer mask crops, properly invalidating the image when the group layer's mask is shown, and enabling the mask actions for group layers (obviously :).
2018-02-06 00:19:18 +08:00
{
_gimp_group_layer_set_suspended_mask (
group,
app: fix undo when resizing a group layer with a mask Override GimpItem::resize(), instead of GimpLayer::resize(), when resizing a group layer, so that GimpLayer doesn't try to resize the mask. Instead, the let the usual mask resizing logic in GimpGroupLayer handle that. Also, make sure that the mask is properly restored upon undo when group resizing is suspended outside of any mask-suspension block, which can happen when resizing the group.
2018-02-06 03:53:38 +08:00
group_layer_undo->mask_buffer,
&group_layer_undo->mask_bounds);
Bug 51112 - Support layer masks on layer groups Add layer-mask support for group layers. Group-layer masks work similarly to ordinary-layer masks, with the following considerations: The group's mask size is the same as group's size (i.e., the bounding box of its children) at all times. When the group's size changes, the mask is cropped to the new size -- areas of the mask that fall outside of the new bounds are discarded and their data is lost (sans undo), and newly added areas are filled with black (and hence are transparent by default). The new gimp_group_layer_{suspend,resume}_mask() functions can be used to modify this behavior. Between the outermost pair of suspend/resume calls, the old mask data is remembered, and is used to fill the newly added areas while cropping the mask when the group is resized. We override GimpItem::{start,end}_move() for GimpLayer, to call these functions (suspend() in start_move(), and resume() in end_move()) for each of the layer's ancestors. As a result, while moving a layer, or a set of layers, atomically, such as while dragging with the move tool, or moving linked layers, the ancestors' mask data is not lost, and is only discarded at the end of the operation. This commit also takes care of properly handling undo for group- layer mask crops, properly invalidating the image when the group layer's mask is shown, and enabling the mask actions for group layers (obviously :).
2018-02-06 00:19:18 +08:00
}
}
break;
Bug 795410 - Deleting a layer group and then undoing the deletion ... ... raises a CRITICAL gimp_item_{start,end}_move() currently serves two different purposes: It is used by GimpLayer to suspend/resume mask resizing of the layer's ancestors; this is necessary whenever an operation on a layer might affect the size of its ancestors. It is also used by GimpGroupLayer to suspend/resume its own mask resizing; this, on the other hand, is only necessary before applying one of the transformation functions to the group, so that mask modification is handled by GimpLayer. In other words, the effects of gimp_item_{start,end}_move() on group layers are only necessary in a subset of the cases in which these functions are used. While in itself this isn't a problem, it does cause issues when removing a group layer: gimp_image_remove_layer() calls gimp_item_start_move() before removing the layer, and gimp_item_end_move() afterwards. While the former function is called while the layer is still attached to the image, the latter function is called after the layer is no longer attached. Since GimpGroupLayer pushes an undo step in response to these calls, only the call to start_move() results in an undo step, while the call to end_move() doesn't, resulting in an unbalanced GIMP_UNDO_GROUP_LAYER_START_MOVE undo step on the stack. This causes problems when undoing the operation. Add gimp_item_{start,end}_transform() functions, and corresponding GimpItem::{start,end}_transform() virtual functions, which are more specialized versions of gimp_item_{start,end}_move(), which should be used instead of the former before/after transforming an item; in other cases, such as when removing ot reordering an item, gimp_item_{start,end}_move() should still be used. The default implementation of GimpItem::{start,end}_transform() calls gimp_item_{start,end}_move(), respectively, so subclasses that override these functions don't have to do that themselves. In GimpGroupLayer, override GimpItem::{start,end}_transform(), instead of GimpItem::{start,end}_move(), for the same purpose of suspending mask resize. This avoids these functions from being called when removing a layer group, fixing the bug.
2018-04-22 15:39:40 +08:00
case GIMP_UNDO_GROUP_LAYER_START_TRANSFORM:
case GIMP_UNDO_GROUP_LAYER_END_TRANSFORM:
app: fix layer-group mask cropping during move operation undo In gimp_group_layer_{start,end}_move(), push corresponding undo steps, which perform the opposite operation during undo, and make sure that mask-cropping is frozen during group-layer move operations. This fixed erroneous group-layer mask cropping when undoing/redoing a group-layer move operation multiple times.
2018-03-25 21:54:13 +08:00
if ((undo_mode == GIMP_UNDO_MODE_UNDO &&
Bug 795410 - Deleting a layer group and then undoing the deletion ... ... raises a CRITICAL gimp_item_{start,end}_move() currently serves two different purposes: It is used by GimpLayer to suspend/resume mask resizing of the layer's ancestors; this is necessary whenever an operation on a layer might affect the size of its ancestors. It is also used by GimpGroupLayer to suspend/resume its own mask resizing; this, on the other hand, is only necessary before applying one of the transformation functions to the group, so that mask modification is handled by GimpLayer. In other words, the effects of gimp_item_{start,end}_move() on group layers are only necessary in a subset of the cases in which these functions are used. While in itself this isn't a problem, it does cause issues when removing a group layer: gimp_image_remove_layer() calls gimp_item_start_move() before removing the layer, and gimp_item_end_move() afterwards. While the former function is called while the layer is still attached to the image, the latter function is called after the layer is no longer attached. Since GimpGroupLayer pushes an undo step in response to these calls, only the call to start_move() results in an undo step, while the call to end_move() doesn't, resulting in an unbalanced GIMP_UNDO_GROUP_LAYER_START_MOVE undo step on the stack. This causes problems when undoing the operation. Add gimp_item_{start,end}_transform() functions, and corresponding GimpItem::{start,end}_transform() virtual functions, which are more specialized versions of gimp_item_{start,end}_move(), which should be used instead of the former before/after transforming an item; in other cases, such as when removing ot reordering an item, gimp_item_{start,end}_move() should still be used. The default implementation of GimpItem::{start,end}_transform() calls gimp_item_{start,end}_move(), respectively, so subclasses that override these functions don't have to do that themselves. In GimpGroupLayer, override GimpItem::{start,end}_transform(), instead of GimpItem::{start,end}_move(), for the same purpose of suspending mask resize. This avoids these functions from being called when removing a layer group, fixing the bug.
2018-04-22 15:39:40 +08:00
undo->undo_type == GIMP_UNDO_GROUP_LAYER_START_TRANSFORM) ||
app: fix layer-group mask cropping during move operation undo In gimp_group_layer_{start,end}_move(), push corresponding undo steps, which perform the opposite operation during undo, and make sure that mask-cropping is frozen during group-layer move operations. This fixed erroneous group-layer mask cropping when undoing/redoing a group-layer move operation multiple times.
2018-03-25 21:54:13 +08:00
(undo_mode == GIMP_UNDO_MODE_REDO &&
Bug 795410 - Deleting a layer group and then undoing the deletion ... ... raises a CRITICAL gimp_item_{start,end}_move() currently serves two different purposes: It is used by GimpLayer to suspend/resume mask resizing of the layer's ancestors; this is necessary whenever an operation on a layer might affect the size of its ancestors. It is also used by GimpGroupLayer to suspend/resume its own mask resizing; this, on the other hand, is only necessary before applying one of the transformation functions to the group, so that mask modification is handled by GimpLayer. In other words, the effects of gimp_item_{start,end}_move() on group layers are only necessary in a subset of the cases in which these functions are used. While in itself this isn't a problem, it does cause issues when removing a group layer: gimp_image_remove_layer() calls gimp_item_start_move() before removing the layer, and gimp_item_end_move() afterwards. While the former function is called while the layer is still attached to the image, the latter function is called after the layer is no longer attached. Since GimpGroupLayer pushes an undo step in response to these calls, only the call to start_move() results in an undo step, while the call to end_move() doesn't, resulting in an unbalanced GIMP_UNDO_GROUP_LAYER_START_MOVE undo step on the stack. This causes problems when undoing the operation. Add gimp_item_{start,end}_transform() functions, and corresponding GimpItem::{start,end}_transform() virtual functions, which are more specialized versions of gimp_item_{start,end}_move(), which should be used instead of the former before/after transforming an item; in other cases, such as when removing ot reordering an item, gimp_item_{start,end}_move() should still be used. The default implementation of GimpItem::{start,end}_transform() calls gimp_item_{start,end}_move(), respectively, so subclasses that override these functions don't have to do that themselves. In GimpGroupLayer, override GimpItem::{start,end}_transform(), instead of GimpItem::{start,end}_move(), for the same purpose of suspending mask resize. This avoids these functions from being called when removing a layer group, fixing the bug.
2018-04-22 15:39:40 +08:00
undo->undo_type == GIMP_UNDO_GROUP_LAYER_END_TRANSFORM))
app: fix layer-group mask cropping during move operation undo In gimp_group_layer_{start,end}_move(), push corresponding undo steps, which perform the opposite operation during undo, and make sure that mask-cropping is frozen during group-layer move operations. This fixed erroneous group-layer mask cropping when undoing/redoing a group-layer move operation multiple times.
2018-03-25 21:54:13 +08:00
{
Bug 795410 - Deleting a layer group and then undoing the deletion ... ... raises a CRITICAL gimp_item_{start,end}_move() currently serves two different purposes: It is used by GimpLayer to suspend/resume mask resizing of the layer's ancestors; this is necessary whenever an operation on a layer might affect the size of its ancestors. It is also used by GimpGroupLayer to suspend/resume its own mask resizing; this, on the other hand, is only necessary before applying one of the transformation functions to the group, so that mask modification is handled by GimpLayer. In other words, the effects of gimp_item_{start,end}_move() on group layers are only necessary in a subset of the cases in which these functions are used. While in itself this isn't a problem, it does cause issues when removing a group layer: gimp_image_remove_layer() calls gimp_item_start_move() before removing the layer, and gimp_item_end_move() afterwards. While the former function is called while the layer is still attached to the image, the latter function is called after the layer is no longer attached. Since GimpGroupLayer pushes an undo step in response to these calls, only the call to start_move() results in an undo step, while the call to end_move() doesn't, resulting in an unbalanced GIMP_UNDO_GROUP_LAYER_START_MOVE undo step on the stack. This causes problems when undoing the operation. Add gimp_item_{start,end}_transform() functions, and corresponding GimpItem::{start,end}_transform() virtual functions, which are more specialized versions of gimp_item_{start,end}_move(), which should be used instead of the former before/after transforming an item; in other cases, such as when removing ot reordering an item, gimp_item_{start,end}_move() should still be used. The default implementation of GimpItem::{start,end}_transform() calls gimp_item_{start,end}_move(), respectively, so subclasses that override these functions don't have to do that themselves. In GimpGroupLayer, override GimpItem::{start,end}_transform(), instead of GimpItem::{start,end}_move(), for the same purpose of suspending mask resize. This avoids these functions from being called when removing a layer group, fixing the bug.
2018-04-22 15:39:40 +08:00
/* end group layer transform operation */
app: fix layer-group mask cropping during move operation undo In gimp_group_layer_{start,end}_move(), push corresponding undo steps, which perform the opposite operation during undo, and make sure that mask-cropping is frozen during group-layer move operations. This fixed erroneous group-layer mask cropping when undoing/redoing a group-layer move operation multiple times.
2018-03-25 21:54:13 +08:00
Bug 795410 - Deleting a layer group and then undoing the deletion ... ... raises a CRITICAL gimp_item_{start,end}_move() currently serves two different purposes: It is used by GimpLayer to suspend/resume mask resizing of the layer's ancestors; this is necessary whenever an operation on a layer might affect the size of its ancestors. It is also used by GimpGroupLayer to suspend/resume its own mask resizing; this, on the other hand, is only necessary before applying one of the transformation functions to the group, so that mask modification is handled by GimpLayer. In other words, the effects of gimp_item_{start,end}_move() on group layers are only necessary in a subset of the cases in which these functions are used. While in itself this isn't a problem, it does cause issues when removing a group layer: gimp_image_remove_layer() calls gimp_item_start_move() before removing the layer, and gimp_item_end_move() afterwards. While the former function is called while the layer is still attached to the image, the latter function is called after the layer is no longer attached. Since GimpGroupLayer pushes an undo step in response to these calls, only the call to start_move() results in an undo step, while the call to end_move() doesn't, resulting in an unbalanced GIMP_UNDO_GROUP_LAYER_START_MOVE undo step on the stack. This causes problems when undoing the operation. Add gimp_item_{start,end}_transform() functions, and corresponding GimpItem::{start,end}_transform() virtual functions, which are more specialized versions of gimp_item_{start,end}_move(), which should be used instead of the former before/after transforming an item; in other cases, such as when removing ot reordering an item, gimp_item_{start,end}_move() should still be used. The default implementation of GimpItem::{start,end}_transform() calls gimp_item_{start,end}_move(), respectively, so subclasses that override these functions don't have to do that themselves. In GimpGroupLayer, override GimpItem::{start,end}_transform(), instead of GimpItem::{start,end}_move(), for the same purpose of suspending mask resize. This avoids these functions from being called when removing a layer group, fixing the bug.
2018-04-22 15:39:40 +08:00
_gimp_group_layer_end_transform (group, FALSE);
app: fix layer-group mask cropping during move operation undo In gimp_group_layer_{start,end}_move(), push corresponding undo steps, which perform the opposite operation during undo, and make sure that mask-cropping is frozen during group-layer move operations. This fixed erroneous group-layer mask cropping when undoing/redoing a group-layer move operation multiple times.
2018-03-25 21:54:13 +08:00
}
else
{
Bug 795410 - Deleting a layer group and then undoing the deletion ... ... raises a CRITICAL gimp_item_{start,end}_move() currently serves two different purposes: It is used by GimpLayer to suspend/resume mask resizing of the layer's ancestors; this is necessary whenever an operation on a layer might affect the size of its ancestors. It is also used by GimpGroupLayer to suspend/resume its own mask resizing; this, on the other hand, is only necessary before applying one of the transformation functions to the group, so that mask modification is handled by GimpLayer. In other words, the effects of gimp_item_{start,end}_move() on group layers are only necessary in a subset of the cases in which these functions are used. While in itself this isn't a problem, it does cause issues when removing a group layer: gimp_image_remove_layer() calls gimp_item_start_move() before removing the layer, and gimp_item_end_move() afterwards. While the former function is called while the layer is still attached to the image, the latter function is called after the layer is no longer attached. Since GimpGroupLayer pushes an undo step in response to these calls, only the call to start_move() results in an undo step, while the call to end_move() doesn't, resulting in an unbalanced GIMP_UNDO_GROUP_LAYER_START_MOVE undo step on the stack. This causes problems when undoing the operation. Add gimp_item_{start,end}_transform() functions, and corresponding GimpItem::{start,end}_transform() virtual functions, which are more specialized versions of gimp_item_{start,end}_move(), which should be used instead of the former before/after transforming an item; in other cases, such as when removing ot reordering an item, gimp_item_{start,end}_move() should still be used. The default implementation of GimpItem::{start,end}_transform() calls gimp_item_{start,end}_move(), respectively, so subclasses that override these functions don't have to do that themselves. In GimpGroupLayer, override GimpItem::{start,end}_transform(), instead of GimpItem::{start,end}_move(), for the same purpose of suspending mask resize. This avoids these functions from being called when removing a layer group, fixing the bug.
2018-04-22 15:39:40 +08:00
/* start group layer transform operation */
app: fix layer-group mask cropping during move operation undo In gimp_group_layer_{start,end}_move(), push corresponding undo steps, which perform the opposite operation during undo, and make sure that mask-cropping is frozen during group-layer move operations. This fixed erroneous group-layer mask cropping when undoing/redoing a group-layer move operation multiple times.
2018-03-25 21:54:13 +08:00
Bug 795410 - Deleting a layer group and then undoing the deletion ... ... raises a CRITICAL gimp_item_{start,end}_move() currently serves two different purposes: It is used by GimpLayer to suspend/resume mask resizing of the layer's ancestors; this is necessary whenever an operation on a layer might affect the size of its ancestors. It is also used by GimpGroupLayer to suspend/resume its own mask resizing; this, on the other hand, is only necessary before applying one of the transformation functions to the group, so that mask modification is handled by GimpLayer. In other words, the effects of gimp_item_{start,end}_move() on group layers are only necessary in a subset of the cases in which these functions are used. While in itself this isn't a problem, it does cause issues when removing a group layer: gimp_image_remove_layer() calls gimp_item_start_move() before removing the layer, and gimp_item_end_move() afterwards. While the former function is called while the layer is still attached to the image, the latter function is called after the layer is no longer attached. Since GimpGroupLayer pushes an undo step in response to these calls, only the call to start_move() results in an undo step, while the call to end_move() doesn't, resulting in an unbalanced GIMP_UNDO_GROUP_LAYER_START_MOVE undo step on the stack. This causes problems when undoing the operation. Add gimp_item_{start,end}_transform() functions, and corresponding GimpItem::{start,end}_transform() virtual functions, which are more specialized versions of gimp_item_{start,end}_move(), which should be used instead of the former before/after transforming an item; in other cases, such as when removing ot reordering an item, gimp_item_{start,end}_move() should still be used. The default implementation of GimpItem::{start,end}_transform() calls gimp_item_{start,end}_move(), respectively, so subclasses that override these functions don't have to do that themselves. In GimpGroupLayer, override GimpItem::{start,end}_transform(), instead of GimpItem::{start,end}_move(), for the same purpose of suspending mask resize. This avoids these functions from being called when removing a layer group, fixing the bug.
2018-04-22 15:39:40 +08:00
_gimp_group_layer_start_transform (group, FALSE);
app: fix layer-group mask cropping during move operation undo In gimp_group_layer_{start,end}_move(), push corresponding undo steps, which perform the opposite operation during undo, and make sure that mask-cropping is frozen during group-layer move operations. This fixed erroneous group-layer mask cropping when undoing/redoing a group-layer move operation multiple times.
2018-03-25 21:54:13 +08:00
}
break;
Fix undoing a group layer type conversion * app/core/gimpdrawable.[ch]: add "gboolean push_undo" to GimpDrawable::convert_type(). * app/core/gimpdrawable-convert.[ch]: same here for the gray and rgb conversion functions. * app/core/gimpchannel.c * app/core/gimplayer.c: pass FALSE when called from GimpItem::convert() because it can be called on unattached items only. * app/core/gimpimage-convert.c: pass TRUE. * app/core/core-enums.[ch] * app/core/gimpgrouplayerundo.[ch] * app/core/gimpimage-undo-push.[ch]: add GIMP_UNDO_GROUP_LAYER_CONVERT which simply calls gimp_drawable_convert_type() with the old type when undone/redone. * app/core/gimpgrouplayer.c: push a group layer convert undo so this can be properly undone/redone.
2009-09-14 01:24:19 +08:00
case GIMP_UNDO_GROUP_LAYER_CONVERT:
{
GimpImageBaseType type;
app: add "new_precision" argument to gimp_drawable_convert_type() for clarity and consistency with the "new_base_type" argument.
2012-04-25 18:09:45 +08:00
GimpPrecision precision;
app: add "gboolean new_has_alpha" to gimp_drawable_convert_type() making its external API "complete". Remove the redundant "new_base_type" and "new_precision" from the internal (vfunc) API (the Babl format has the same information).
2016-10-04 07:39:15 +08:00
gboolean has_alpha;
app: add "new_precision" argument to gimp_drawable_convert_type() for clarity and consistency with the "new_base_type" argument.
2012-04-25 18:09:45 +08:00
type = gimp_drawable_get_base_type (GIMP_DRAWABLE (group));
precision = gimp_drawable_get_precision (GIMP_DRAWABLE (group));
app: add "gboolean new_has_alpha" to gimp_drawable_convert_type() making its external API "complete". Remove the redundant "new_base_type" and "new_precision" from the internal (vfunc) API (the Babl format has the same information).
2016-10-04 07:39:15 +08:00
has_alpha = gimp_drawable_has_alpha (GIMP_DRAWABLE (group));
Fix undoing a group layer type conversion * app/core/gimpdrawable.[ch]: add "gboolean push_undo" to GimpDrawable::convert_type(). * app/core/gimpdrawable-convert.[ch]: same here for the gray and rgb conversion functions. * app/core/gimpchannel.c * app/core/gimplayer.c: pass FALSE when called from GimpItem::convert() because it can be called on unattached items only. * app/core/gimpimage-convert.c: pass TRUE. * app/core/core-enums.[ch] * app/core/gimpgrouplayerundo.[ch] * app/core/gimpimage-undo-push.[ch]: add GIMP_UNDO_GROUP_LAYER_CONVERT which simply calls gimp_drawable_convert_type() with the old type when undone/redone. * app/core/gimpgrouplayer.c: push a group layer convert undo so this can be properly undone/redone.
2009-09-14 01:24:19 +08:00
app: remove gimpdrawable-convert.[ch] This can now be done in gimp_drawable_real_convert_type() with a few lines of GEGL buffer copying.
2012-04-12 00:50:57 +08:00
gimp_drawable_convert_type (GIMP_DRAWABLE (group),
gimp_item_get_image (GIMP_ITEM (group)),
app: add "new_precision" argument to gimp_drawable_convert_type() for clarity and consistency with the "new_base_type" argument.
2012-04-25 18:09:45 +08:00
group_layer_undo->prev_type,
group_layer_undo->prev_precision,
app: add "gboolean new_has_alpha" to gimp_drawable_convert_type() making its external API "complete". Remove the redundant "new_base_type" and "new_precision" from the internal (vfunc) API (the Babl format has the same information).
2016-10-04 07:39:15 +08:00
group_layer_undo->prev_has_alpha,
Issue #1954 - GIMP-2.99 color changes when converting between... ...linear and perceptual precision Under certain circumstances (e.g. the image has no color profile), GimpLayer's implementation of GimpDrawable::convert_type() didn't have enough information to do the right color space conversion. Intead of messing with stuff like "set profile in between doing a and b", simply add a "src_profile" parameter to GimpDrawable::convert_type() so the complete color space conversion information is available without relying on obscure states that could change in the future. Make sure all callers pass the right src_profile, particularly in gimp_image_convert_precision(), which also needed fixing.
2018-08-06 04:19:17 +08:00
NULL, NULL,
app: add "gboolean new_has_alpha" to gimp_drawable_convert_type() making its external API "complete". Remove the redundant "new_base_type" and "new_precision" from the internal (vfunc) API (the Babl format has the same information).
2016-10-04 07:39:15 +08:00
0, 0,
app: add progress reporting to gimp_drawable_convert_type() so it doesn't sit there appearing to do nothing while converting an image with profile to gamma/linear.
2015-10-22 04:22:30 +08:00
FALSE, NULL);
app: add "new_precision" argument to gimp_drawable_convert_type() for clarity and consistency with the "new_base_type" argument.
2012-04-25 18:09:45 +08:00
group_layer_undo->prev_type = type;
group_layer_undo->prev_precision = precision;
app: add "gboolean new_has_alpha" to gimp_drawable_convert_type() making its external API "complete". Remove the redundant "new_base_type" and "new_precision" from the internal (vfunc) API (the Babl format has the same information).
2016-10-04 07:39:15 +08:00
group_layer_undo->prev_has_alpha = has_alpha;
Fix undoing a group layer type conversion * app/core/gimpdrawable.[ch]: add "gboolean push_undo" to GimpDrawable::convert_type(). * app/core/gimpdrawable-convert.[ch]: same here for the gray and rgb conversion functions. * app/core/gimpchannel.c * app/core/gimplayer.c: pass FALSE when called from GimpItem::convert() because it can be called on unattached items only. * app/core/gimpimage-convert.c: pass TRUE. * app/core/core-enums.[ch] * app/core/gimpgrouplayerundo.[ch] * app/core/gimpimage-undo-push.[ch]: add GIMP_UNDO_GROUP_LAYER_CONVERT which simply calls gimp_drawable_convert_type() with the old type when undone/redone. * app/core/gimpgrouplayer.c: push a group layer convert undo so this can be properly undone/redone.
2009-09-14 01:24:19 +08:00
}
break;
default:
app: we should not have any g_assert*() code if possible. Replace all g_assert_not_reached() in app/core/ by g_return_if_reached() or g_return_val_if_reached(). GIMP may handle a lot of creative work, sometimes unsaved for hours. We should not just crash on purpose. g_assert*() could theoretically be turned off on a glib build, but this is nearly never done, and is not a solution either (actually it is probably even worse because the broken code would just continue on a forbidden path). It is much better to return with a warning on such forbidden code paths, allowing someone to report a bug without experiencing a crash and data loss. For now, I only took care of g_assert_not_reached() inside app/core. More g_assert*() code should be replaced. Note: assert are acceptable in plug-ins though, but not in the main executable, unless absolutely necessary (something happening so bad that crash is better than continuing).
2018-01-22 19:33:39 +08:00
g_return_if_reached ();
Add facility to compress multiple group layer resizings into one * app/core/gimpgrouplayer.[ch]: add gimp_group_layer_suspend_resize() and gimp_group_layer_resume_resize() and call them around functions where all a group's children are transformed (translated, resized etc). This way we go from the worst case of reallocating the group's projection tiles once for each child down to exactly one reallocation. * app/core/Makefile.am * app/core/core-enums.[ch] * app/core/core-types.h * app/core/gimpimage-undo-push.[ch] * app/core/gimpgrouplayerundo.[ch]: add new undo class GimpGroupLayerUndo which implements undos for suspend/resume of group layers and calls them in reverse order when undoing.
2009-09-07 19:04:55 +08:00
}
}
Bug 51112 - Support layer masks on layer groups Add layer-mask support for group layers. Group-layer masks work similarly to ordinary-layer masks, with the following considerations: The group's mask size is the same as group's size (i.e., the bounding box of its children) at all times. When the group's size changes, the mask is cropped to the new size -- areas of the mask that fall outside of the new bounds are discarded and their data is lost (sans undo), and newly added areas are filled with black (and hence are transparent by default). The new gimp_group_layer_{suspend,resume}_mask() functions can be used to modify this behavior. Between the outermost pair of suspend/resume calls, the old mask data is remembered, and is used to fill the newly added areas while cropping the mask when the group is resized. We override GimpItem::{start,end}_move() for GimpLayer, to call these functions (suspend() in start_move(), and resume() in end_move()) for each of the layer's ancestors. As a result, while moving a layer, or a set of layers, atomically, such as while dragging with the move tool, or moving linked layers, the ancestors' mask data is not lost, and is only discarded at the end of the operation. This commit also takes care of properly handling undo for group- layer mask crops, properly invalidating the image when the group layer's mask is shown, and enabling the mask actions for group layers (obviously :).
2018-02-06 00:19:18 +08:00
static void
gimp_group_layer_undo_free (GimpUndo *undo,
GimpUndoMode undo_mode)
{
GimpGroupLayerUndo *group_layer_undo = GIMP_GROUP_LAYER_UNDO (undo);
app: fix undo when resizing a group layer with a mask Override GimpItem::resize(), instead of GimpLayer::resize(), when resizing a group layer, so that GimpLayer doesn't try to resize the mask. Instead, the let the usual mask resizing logic in GimpGroupLayer handle that. Also, make sure that the mask is properly restored upon undo when group resizing is suspended outside of any mask-suspension block, which can happen when resizing the group.
2018-02-06 03:53:38 +08:00
g_clear_object (&group_layer_undo->mask_buffer);
Bug 51112 - Support layer masks on layer groups Add layer-mask support for group layers. Group-layer masks work similarly to ordinary-layer masks, with the following considerations: The group's mask size is the same as group's size (i.e., the bounding box of its children) at all times. When the group's size changes, the mask is cropped to the new size -- areas of the mask that fall outside of the new bounds are discarded and their data is lost (sans undo), and newly added areas are filled with black (and hence are transparent by default). The new gimp_group_layer_{suspend,resume}_mask() functions can be used to modify this behavior. Between the outermost pair of suspend/resume calls, the old mask data is remembered, and is used to fill the newly added areas while cropping the mask when the group is resized. We override GimpItem::{start,end}_move() for GimpLayer, to call these functions (suspend() in start_move(), and resume() in end_move()) for each of the layer's ancestors. As a result, while moving a layer, or a set of layers, atomically, such as while dragging with the move tool, or moving linked layers, the ancestors' mask data is not lost, and is only discarded at the end of the operation. This commit also takes care of properly handling undo for group- layer mask crops, properly invalidating the image when the group layer's mask is shown, and enabling the mask actions for group layers (obviously :).
2018-02-06 00:19:18 +08:00
GIMP_UNDO_CLASS (parent_class)->free (undo, undo_mode);
}