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

2192 lines
78 KiB
C
Raw Normal View History

Add a GimpGroupLayer class (not used yet)
2009-08-04 05:24:46 +08:00
/* GIMP - The GNU Image Manipulation Program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* GimpGroupLayer
* Copyright (C) 2009 Michael Natterer <mitch@gimp.org>
*
* 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 a GimpGroupLayer class (not used yet)
2009-08-04 05:24:46 +08:00
*/
#include "config.h"
#include <string.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 a GimpGroupLayer class (not used yet)
2009-08-04 05:24:46 +08:00
#include <gegl.h>
Automatically adjust the size of group layers Connect to size and offset of all children and resize/move the group layer accordingly.
2009-08-24 05:00:32 +08:00
#include "libgimpbase/gimpbase.h"
Fix gimp_group_layer_scale() to do the right thing Scale all children in relation to the group layer's old and new size and offset. The group itself will follow the childrens' sizes.
2009-08-25 20:26:26 +08:00
#include "libgimpmath/gimpmath.h"
Automatically adjust the size of group layers Connect to size and offset of all children and resize/move the group layer accordingly.
2009-08-24 05:00:32 +08:00
Add a GimpGroupLayer class (not used yet)
2009-08-04 05:24:46 +08:00
#include "core-types.h"
app: add a GimpCpmponentType parameter to GimpDrawable::estimate_memsize() so we can also estimate converting the drawable to other precisions.
2014-06-15 05:12:22 +08:00
#include "gegl/gimp-babl.h"
app: use gimp_gegl_buffer_copy() all over the place Replace all uses of gegl_buffer_copy() in app/ with gimp_gegl_buffer_copy(), added in the previous commit.
2018-05-24 22:21:21 +08:00
#include "gegl/gimp-gegl-loops.h"
app: add a GimpCpmponentType parameter to GimpDrawable::estimate_memsize() so we can also estimate converting the drawable to other precisions.
2014-06-15 05:12:22 +08:00
Add a GimpGroupLayer class (not used yet)
2009-08-04 05:24:46 +08:00
#include "gimpgrouplayer.h"
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
#include "gimpgrouplayerundo.h"
Add a GimpGroupLayer class (not used yet)
2009-08-04 05:24:46 +08:00
#include "gimpimage.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 "gimpimage-undo.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-undo-push.h"
app: add GimpLayerStack A subclass of GimpDrawableStack, for layer stacks. Invalidates the layers' backdrop as/when necessary, according to the value of their excludes_backdrop property. Make gimp_drawable_stack_update() protected, instead of private, so that we can use it in GimpLayerStack.
2017-05-09 04:02:37 +08:00
#include "gimplayerstack.h"
app: use GimpObjectQueue in lots of places Use GimpObjectQueue, added in the previous commit, in various instances where we perform an action on a set of objects. This improves progress reporting, by using a single progress for the entire operation, rather than reporting the progress of each object individually, and by taking the relative cost of each object into account, instead of assuming a uniform cost for all objects. In particular, this affects the various whole-image operations (i.e., transformations and color conversions), operations on linked items, and operations on layer groups. This also affects layers with masks, whose progress is now reported together instead of individually. Additionally, this commit fixes erroneous group-layer mask cropping during undo when resizing the image, by properly calling {start,end}_move() on all the resized layers before starting the operation, and when scaling the image, by only scaling top-level layers, and letting group layers scale their children themselves.
2018-03-25 22:18:46 +08:00
#include "gimpobjectqueue.h"
Add a projection to GimpGroupLayer so we finally have a *visible* layer tree Implement the GimpProjectable interface and keep a GimpProjection around that projects the GimpDrawableStack of our children. Propagate the childrens' "update" signals to our own "update" signal so our parent projection picks up all changes.
2009-08-24 22:03:21 +08:00
#include "gimppickable.h"
app: use GimpObjectQueue in lots of places Use GimpObjectQueue, added in the previous commit, in various instances where we perform an action on a set of objects. This improves progress reporting, by using a single progress for the entire operation, rather than reporting the progress of each object individually, and by taking the relative cost of each object into account, instead of assuming a uniform cost for all objects. In particular, this affects the various whole-image operations (i.e., transformations and color conversions), operations on linked items, and operations on layer groups. This also affects layers with masks, whose progress is now reported together instead of individually. Additionally, this commit fixes erroneous group-layer mask cropping during undo when resizing the image, by properly calling {start,end}_move() on all the resized layers before starting the operation, and when scaling the image, by only scaling top-level layers, and letting group layers scale their children themselves.
2018-03-25 22:18:46 +08:00
#include "gimpprogress.h"
Add a projection to GimpGroupLayer so we finally have a *visible* layer tree Implement the GimpProjectable interface and keep a GimpProjection around that projects the GimpDrawableStack of our children. Propagate the childrens' "update" signals to our own "update" signal so our parent projection picks up all changes.
2009-08-24 22:03:21 +08:00
#include "gimpprojectable.h"
#include "gimpprojection.h"
Add a GimpGroupLayer class (not used yet)
2009-08-04 05:24:46 +08:00
#include "gimp-intl.h"
app: move all GimpGroupLayer members to a private struct
2011-02-04 05:29:25 +08:00
typedef struct _GimpGroupLayerPrivate GimpGroupLayerPrivate;
struct _GimpGroupLayerPrivate
{
GimpContainer *children;
GimpProjection *projection;
app: implement pass-through mode in GimpGroupLayer Override GimpDrawable::get_source_node() for GimpGroupLayer. Use a node that contains both the drawable's buffer-source node, and the layer stack's graph node. Choose which one of these to connect to the source node's output based on the group's layer mode: the stack graph for pass-through mode, and the buffer-source node for all the rest. When in pass-through mode, connect the source node's input (which receives the backdrop) to the stack graph's input. Keep maintaining the projection in pass-through mode. ATM, the projection uses the same graph as the source node, so it's rendered against the group's backdrop -- we don't want that. The next few commits fix it. Update the group's drawable directly upon filter stack update in pass-though mode, because the group's graph doesn't go through the projection. TODO: if any of the group's children (or a child of a nested pass- through group, etc.) uses dst-atop/src-in, this needs special attention.
2017-04-22 06:04:49 +08:00
GeglNode *source_node;
GeglNode *parent_source_node;
app: move all GimpGroupLayer members to a private struct
2011-02-04 05:29:25 +08:00
GeglNode *graph;
GeglNode *offset_node;
gint suspend_resize;
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
gint suspend_mask;
GeglBuffer *suspended_mask_buffer;
GeglRectangle suspended_mask_bounds;
app: avoid re-rendering group layers upon translation When translating group layers, there's no need to re-render the group's projection -- we can simply update the group's offset (and offset node) directly, and redirect any layer-stack "update" signals to the group's drawable. This significantly improves performance when moving groups.
2018-08-04 01:10:37 +08:00
gint direct_update;
app: avoid re-rendering group layers upon resizing Make sure we don't unnecessarily update the group layer's drawable while flusing the group's projection during resizing, since we want to either update the entire drawable, or avoid any updates, when replacing the drawable's buffer. Note that explicitly supressing updates in this case should theoretically not be necessary, but the fact that the call to gimp_projectable_bounds_changed() can result in reconstructing the projection (see the FIXME comment in that function) makes it necessary in some cases nonetheless.
2018-08-04 02:01:28 +08:00
gint transforming;
Bug 616416: hidden layer groups appear again after an image change Introduced two virtual functions to a GimpViewable 'set_expanded' and 'get_expanded' and a PROP_GROUP_ITEM_FLAGS to load/save the expanded state of layer_groups and use them.
2011-09-26 03:57:20 +08:00
gboolean expanded;
app: flush group proj. switching from pass-through to non-pass-through When switching a group layer from pass-through mode to a non-pass- through mode, flush the projection synchrnously, to make sure that the projection's buffer gets properly invalidated at that point, and can be subsequently used as a source for the rest of the composition. Add a boolean 'pass_through' member to GimpGroupLayerPrivate, which indicates if the group is a pass-through group, and use it instead of checking the group's mode, so that we can detect that the group used to be a pass-through group when the mode changes, and to simplify the rest of the code.
2017-12-03 04:25:04 +08:00
gboolean pass_through;
app: fake the size of a gruop layer by overriding GimpViewable::get_size() instead of messing with GimpItem's width and height members.
2011-03-09 01:04:23 +08:00
/* hackish temp states to make the projection/tiles stuff work */
app: remove drawable->private->format, its buffer has a format already Also, make group layer type conversion much less hackish by using the same kind of temporary states that are used for reallocating its projection on size change.
2012-03-30 05:19:27 +08:00
const Babl *convert_format;
app: fake the size of a gruop layer by overriding GimpViewable::get_size() instead of messing with GimpItem's width and height members.
2011-03-09 01:04:23 +08:00
gboolean reallocate_projection;
gint reallocate_width;
gint reallocate_height;
app: move all GimpGroupLayer members to a private struct
2011-02-04 05:29:25 +08:00
};
app, libgimp*, modules: don't use g_type_class_add_private() ... ... and G_TYPE_INSTANCE_GET_PRIVATE() g_type_class_add_private() and G_TYPE_INSTANCE_GET_PRIVATE() were deprecated in GLib 2.58. Instead, use G_DEFINE_[ABSTRACT_]TYPE_WITH_PRIVATE(), and G_ADD_PRIVATE[_DYNAMIC](), and the implictly-defined foo_get_instance_private() functions, all of which are available in the GLib versions we depend on. This commit only covers types registered using one of the G_DEFINE_FOO() macros (i.e., most types), but not types with a custom registration function, of which we still have a few -- GLib currently only provides a (non-deprecated) public API for adding a private struct using the G_DEFINE_FOO() macros. Note that this commit was 99% auto-generated (because I'm not *that* crazy :), so if there are any style mismatches... we'll have to live with them for now.
2018-09-19 00:09:39 +08:00
#define GET_PRIVATE(item) ((GimpGroupLayerPrivate *) gimp_group_layer_get_instance_private ((GimpGroupLayer *) (item)))
app: move all GimpGroupLayer members to a private struct
2011-02-04 05:29:25 +08:00
Add a projection to GimpGroupLayer so we finally have a *visible* layer tree Implement the GimpProjectable interface and keep a GimpProjection around that projects the GimpDrawableStack of our children. Propagate the childrens' "update" signals to our own "update" signal so our parent projection picks up all changes.
2009-08-24 22:03:21 +08:00
static void gimp_projectable_iface_init (GimpProjectableInterface *iface);
Bug 612931 - Moving individual layer in layer group not possible with Move Tool in 'pick a layer' mode When using GimpPickable::get_opacity_at(), don't consider group layers as having content.
2011-08-20 21:01:46 +08:00
static void gimp_pickable_iface_init (GimpPickableInterface *iface);
Add a projection to GimpGroupLayer so we finally have a *visible* layer tree Implement the GimpProjectable interface and keep a GimpProjection around that projects the GimpDrawableStack of our children. Propagate the childrens' "update" signals to our own "update" signal so our parent projection picks up all changes.
2009-08-24 22:03:21 +08:00
app: move all GimpGroupLayer members to a private struct
2011-02-04 05:29:25 +08:00
static void gimp_group_layer_finalize (GObject *object);
Add a projection to GimpGroupLayer so we finally have a *visible* layer tree Implement the GimpProjectable interface and keep a GimpProjection around that projects the GimpDrawableStack of our children. Propagate the childrens' "update" signals to our own "update" signal so our parent projection picks up all changes.
2009-08-24 22:03:21 +08:00
static void gimp_group_layer_set_property (GObject *object,
guint property_id,
const GValue *value,
GParamSpec *pspec);
static void gimp_group_layer_get_property (GObject *object,
guint property_id,
GValue *value,
GParamSpec *pspec);
static gint64 gimp_group_layer_get_memsize (GimpObject *object,
gint64 *gui_size);
app: set group layer projection priority according to depth Set the priority of group-layer projections according to the group layer's depth, so that top-level groups have a priority of 1 (compared to a priority of 0 for the image projection), and nested groups have a priority one greater than their parent (in other words, shallower groups have higher priority than deeper groups, all of which have lower priority than the image.) This makes pass-through groups much faster, in particular.
2017-12-02 22:55:15 +08:00
static void gimp_group_layer_ancestry_changed (GimpViewable *viewable);
app: fake the size of a gruop layer by overriding GimpViewable::get_size() instead of messing with GimpItem's width and height members.
2011-03-09 01:04:23 +08:00
static gboolean gimp_group_layer_get_size (GimpViewable *viewable,
gint *width,
gint *height);
Add a projection to GimpGroupLayer so we finally have a *visible* layer tree Implement the GimpProjectable interface and keep a GimpProjection around that projects the GimpDrawableStack of our children. Propagate the childrens' "update" signals to our own "update" signal so our parent projection picks up all changes.
2009-08-24 22:03:21 +08:00
static GimpContainer * gimp_group_layer_get_children (GimpViewable *viewable);
Bug 616416: hidden layer groups appear again after an image change Introduced two virtual functions to a GimpViewable 'set_expanded' and 'get_expanded' and a PROP_GROUP_ITEM_FLAGS to load/save the expanded state of layer_groups and use them.
2011-09-26 03:57:20 +08:00
static gboolean gimp_group_layer_get_expanded (GimpViewable *viewable);
static void gimp_group_layer_set_expanded (GimpViewable *viewable,
gboolean expanded);
Add a projection to GimpGroupLayer so we finally have a *visible* layer tree Implement the GimpProjectable interface and keep a GimpProjection around that projects the GimpDrawableStack of our children. Propagate the childrens' "update" signals to our own "update" signal so our parent projection picks up all changes.
2009-08-24 22:03:21 +08:00
app: remove const qualifiers from all object parameters They are unreliable because every type checking cast discards them, they are useless anyway, visual clutter, added inconsistently, and generally suck. Wanted to do this a long time ago, it was a bad idea in the first place.
2016-05-20 05:51:44 +08:00
static gboolean gimp_group_layer_is_position_locked (GimpItem *item);
Add a projection to GimpGroupLayer so we finally have a *visible* layer tree Implement the GimpProjectable interface and keep a GimpProjection around that projects the GimpDrawableStack of our children. Propagate the childrens' "update" signals to our own "update" signal so our parent projection picks up all changes.
2009-08-24 22:03:21 +08:00
static GimpItem * gimp_group_layer_duplicate (GimpItem *item,
GType new_type);
Add naive and wrong version of GimpItem::convert() That code will fail badly when dropping layer groups between images of different types, but will at least work between two RGB images.
2009-08-25 20:23:42 +08:00
static void gimp_group_layer_convert (GimpItem *item,
app: add "gboolean convert_profile" to GimpDrawable::convert_type() also add "GType old_type" to GimpItem::convert() so implementations can do things depending on the type of the original item. In gimp_layer_convert(), if the original item is also a layer, and color management is not off (with a FIXME because this is the wrong check), pass convert_profile = TRUE to gimp_drawable_convert_type(). There is no color profile conversion anywhere behind this, this is just an API change commit.
2015-08-16 21:47:43 +08:00
GimpImage *dest_image,
GType old_type);
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
static void gimp_group_layer_start_transform (GimpItem *item,
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
gboolean push_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
static void gimp_group_layer_end_transform (GimpItem *item,
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
gboolean push_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
static void gimp_group_layer_resize (GimpItem *item,
GimpContext *context,
GimpFillType fill_type,
gint new_width,
gint new_height,
gint offset_x,
gint offset_y);
app: add virtual transform/type-conversion functions to GimpLayer The GimpLayer implementation of the GimpItem transform functions, and the GimpDrawable convert_type() function, apply their operation to both the layer and its mask. The subclasses of GimpLayer -- GimpGroupLayer and GimpTextLayer -- override some of these functions, providing their own logic for the layer part, and duplicating the mask part. Avoid this duplication by adding a set of virtual transform and type-conversion functions to GimpLayer. Have the GimpLayer implementaion of the corresponding GimpItem and GimpDrawable functions use these functions to apply the operation to the layer, while taking care of the mask themselves. Have GimpLayer's subclasses override the new virtual functions, instead of the GimpItem and GimpDrawable ones. Note that the existing implementation of convert_type() in GimpTextLayer neglected to convert the mask, hence text layer masks retained their old format after conversion. This issue is fixed as a side effect of this commit.
2017-06-17 08:15:56 +08:00
static gint64 gimp_group_layer_estimate_memsize (GimpDrawable *drawable,
GimpComponentType component_type,
gint width,
gint height);
static void gimp_group_layer_translate (GimpLayer *layer,
Implement GimpItem's transform methods Add implementations for GimpItem::translate(), scale(), resize(), flip(), rotate() and transform(). Simply transform all children, the group layer will automatically update itself. Also transform the layer mask.
2009-08-25 01:33:29 +08:00
gint offset_x,
app: add virtual transform/type-conversion functions to GimpLayer The GimpLayer implementation of the GimpItem transform functions, and the GimpDrawable convert_type() function, apply their operation to both the layer and its mask. The subclasses of GimpLayer -- GimpGroupLayer and GimpTextLayer -- override some of these functions, providing their own logic for the layer part, and duplicating the mask part. Avoid this duplication by adding a set of virtual transform and type-conversion functions to GimpLayer. Have the GimpLayer implementaion of the corresponding GimpItem and GimpDrawable functions use these functions to apply the operation to the layer, while taking care of the mask themselves. Have GimpLayer's subclasses override the new virtual functions, instead of the GimpItem and GimpDrawable ones. Note that the existing implementation of convert_type() in GimpTextLayer neglected to convert the mask, hence text layer masks retained their old format after conversion. This issue is fixed as a side effect of this commit.
2017-06-17 08:15:56 +08:00
gint offset_y);
static void gimp_group_layer_scale (GimpLayer *layer,
Implement GimpItem's transform methods Add implementations for GimpItem::translate(), scale(), resize(), flip(), rotate() and transform(). Simply transform all children, the group layer will automatically update itself. Also transform the layer mask.
2009-08-25 01:33:29 +08:00
gint new_width,
gint new_height,
gint new_offset_x,
gint new_offset_y,
GimpInterpolationType interp_type,
GimpProgress *progress);
app: add virtual transform/type-conversion functions to GimpLayer The GimpLayer implementation of the GimpItem transform functions, and the GimpDrawable convert_type() function, apply their operation to both the layer and its mask. The subclasses of GimpLayer -- GimpGroupLayer and GimpTextLayer -- override some of these functions, providing their own logic for the layer part, and duplicating the mask part. Avoid this duplication by adding a set of virtual transform and type-conversion functions to GimpLayer. Have the GimpLayer implementaion of the corresponding GimpItem and GimpDrawable functions use these functions to apply the operation to the layer, while taking care of the mask themselves. Have GimpLayer's subclasses override the new virtual functions, instead of the GimpItem and GimpDrawable ones. Note that the existing implementation of convert_type() in GimpTextLayer neglected to convert the mask, hence text layer masks retained their old format after conversion. This issue is fixed as a side effect of this commit.
2017-06-17 08:15:56 +08:00
static void gimp_group_layer_flip (GimpLayer *layer,
Implement GimpItem's transform methods Add implementations for GimpItem::translate(), scale(), resize(), flip(), rotate() and transform(). Simply transform all children, the group layer will automatically update itself. Also transform the layer mask.
2009-08-25 01:33:29 +08:00
GimpContext *context,
GimpOrientationType flip_type,
gdouble axis,
gboolean clip_result);
app: add virtual transform/type-conversion functions to GimpLayer The GimpLayer implementation of the GimpItem transform functions, and the GimpDrawable convert_type() function, apply their operation to both the layer and its mask. The subclasses of GimpLayer -- GimpGroupLayer and GimpTextLayer -- override some of these functions, providing their own logic for the layer part, and duplicating the mask part. Avoid this duplication by adding a set of virtual transform and type-conversion functions to GimpLayer. Have the GimpLayer implementaion of the corresponding GimpItem and GimpDrawable functions use these functions to apply the operation to the layer, while taking care of the mask themselves. Have GimpLayer's subclasses override the new virtual functions, instead of the GimpItem and GimpDrawable ones. Note that the existing implementation of convert_type() in GimpTextLayer neglected to convert the mask, hence text layer masks retained their old format after conversion. This issue is fixed as a side effect of this commit.
2017-06-17 08:15:56 +08:00
static void gimp_group_layer_rotate (GimpLayer *layer,
Implement GimpItem's transform methods Add implementations for GimpItem::translate(), scale(), resize(), flip(), rotate() and transform(). Simply transform all children, the group layer will automatically update itself. Also transform the layer mask.
2009-08-25 01:33:29 +08:00
GimpContext *context,
GimpRotationType rotate_type,
gdouble center_x,
gdouble center_y,
gboolean clip_result);
app: add virtual transform/type-conversion functions to GimpLayer The GimpLayer implementation of the GimpItem transform functions, and the GimpDrawable convert_type() function, apply their operation to both the layer and its mask. The subclasses of GimpLayer -- GimpGroupLayer and GimpTextLayer -- override some of these functions, providing their own logic for the layer part, and duplicating the mask part. Avoid this duplication by adding a set of virtual transform and type-conversion functions to GimpLayer. Have the GimpLayer implementaion of the corresponding GimpItem and GimpDrawable functions use these functions to apply the operation to the layer, while taking care of the mask themselves. Have GimpLayer's subclasses override the new virtual functions, instead of the GimpItem and GimpDrawable ones. Note that the existing implementation of convert_type() in GimpTextLayer neglected to convert the mask, hence text layer masks retained their old format after conversion. This issue is fixed as a side effect of this commit.
2017-06-17 08:15:56 +08:00
static void gimp_group_layer_transform (GimpLayer *layer,
Implement GimpItem's transform methods Add implementations for GimpItem::translate(), scale(), resize(), flip(), rotate() and transform(). Simply transform all children, the group layer will automatically update itself. Also transform the layer mask.
2009-08-25 01:33:29 +08:00
GimpContext *context,
const GimpMatrix3 *matrix,
GimpTransformDirection direction,
GimpInterpolationType interpolation_type,
GimpTransformResize clip_result,
app: add virtual transform/type-conversion functions to GimpLayer The GimpLayer implementation of the GimpItem transform functions, and the GimpDrawable convert_type() function, apply their operation to both the layer and its mask. The subclasses of GimpLayer -- GimpGroupLayer and GimpTextLayer -- override some of these functions, providing their own logic for the layer part, and duplicating the mask part. Avoid this duplication by adding a set of virtual transform and type-conversion functions to GimpLayer. Have the GimpLayer implementaion of the corresponding GimpItem and GimpDrawable functions use these functions to apply the operation to the layer, while taking care of the mask themselves. Have GimpLayer's subclasses override the new virtual functions, instead of the GimpItem and GimpDrawable ones. Note that the existing implementation of convert_type() in GimpTextLayer neglected to convert the mask, hence text layer masks retained their old format after conversion. This issue is fixed as a side effect of this commit.
2017-06-17 08:15:56 +08:00
GimpProgress *progress);
static void gimp_group_layer_convert_type (GimpLayer *layer,
Implement GimpDrawable::convert_type() Don't convert the pixels but reallocate the group's projection for the new type. This breaks badly on undo, don't bother to try yet...
2009-09-12 04:01:31 +08:00
GimpImage *dest_image,
app: add "const Babl *new_format" to GimpDrawable::convert_type() but only to the virtual function, not the public API. Implement it in GimpSelection and GimpLayerMask, and pass the correct mask format down to the parent class which does the actual conversion.
2012-10-14 04:56:32 +08:00
const Babl *new_format,
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
GimpColorProfile *src_profile,
app: change GimpDrawable::convert_type() to take a target profile instead of just a boolean "convert_profile". This takes the logic to figure the right target profile out of gimp_layer_convert_type(), it can't possibly know everything about how to convert anyway, and having the logic in the callers conveniently splits it up and distributes its parts to the places they belong. This commit should cause no behavor change and is just preparation for fixing bug 765176.
2016-04-29 06:42:42 +08:00
GimpColorProfile *dest_profile,
app, pdb: use GeglDitherMethod instead of simply an integer
2016-11-08 03:41:39 +08:00
GeglDitherMethod layer_dither_type,
GeglDitherMethod mask_dither_type,
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
gboolean push_undo,
GimpProgress *progress);
app: implement pass-through mode in GimpGroupLayer Override GimpDrawable::get_source_node() for GimpGroupLayer. Use a node that contains both the drawable's buffer-source node, and the layer stack's graph node. Choose which one of these to connect to the source node's output based on the group's layer mode: the stack graph for pass-through mode, and the buffer-source node for all the rest. When in pass-through mode, connect the source node's input (which receives the backdrop) to the stack graph's input. Keep maintaining the projection in pass-through mode. ATM, the projection uses the same graph as the source node, so it's rendered against the group's backdrop -- we don't want that. The next few commits fix it. Update the group's drawable directly upon filter stack update in pass-though mode, because the group's graph doesn't go through the projection. TODO: if any of the group's children (or a child of a nested pass- through group, etc.) uses dst-atop/src-in, this needs special attention.
2017-04-22 06:04:49 +08:00
static GeglNode * gimp_group_layer_get_source_node (GimpDrawable *drawable);
app: strength-reduce pass-through groups to normal groups Override GimpLayer::get_effective_mode() in GimpGroupLayer, to perform strength-reduction of pass-through groups to normal groups under certain conditions (see gimp_group_layer_get_effective_mode() for the logic.) The main motivation for this is the fact that Photoshop uses pass- through mode as the default mode for groups, resulting in many PSDs using pass-through groups generously and unnecessarily. Since pass-through groups are more expensive that normal groups, reducing them to normal groups when possible can make a big difference. Note that, while the results of the strength-reduced composition are theoretically equivalent, there may be small differences in practice due to numerical errors, especially when using low precision. This is unlikely to be an issue, but, just in case, allow disabling this optimization using the GIMP_NO_PASS_THROUGH_STRENGTH_REDUCTION environment variable.
2017-12-07 03:06:16 +08:00
static void gimp_group_layer_opacity_changed (GimpLayer *layer);
static void gimp_group_layer_effective_mode_changed (GimpLayer *layer);
app: handle excludes_backdrop in GimpGroupLayer When any of the children of a pass-through group excludes its backdrop, the group itself should exclude the backdrop too. Override get_excludes_backdrop() to follow this logic, and call update_excludes_backdrop() when this condition might change. Note that we always composite pass-through groups using src-over mode, so to actually hide the backdrop, we need to disconnect it from the group's mode node's input pad (and reconnect it, when the backdrop is no longer hidden).
2017-05-09 03:06:00 +08:00
static void
gimp_group_layer_excludes_backdrop_changed (GimpLayer *layer);
app: strength-reduce pass-through groups to normal groups Override GimpLayer::get_effective_mode() in GimpGroupLayer, to perform strength-reduction of pass-through groups to normal groups under certain conditions (see gimp_group_layer_get_effective_mode() for the logic.) The main motivation for this is the fact that Photoshop uses pass- through mode as the default mode for groups, resulting in many PSDs using pass-through groups generously and unnecessarily. Since pass-through groups are more expensive that normal groups, reducing them to normal groups when possible can make a big difference. Note that, while the results of the strength-reduced composition are theoretically equivalent, there may be small differences in practice due to numerical errors, especially when using low precision. This is unlikely to be an issue, but, just in case, allow disabling this optimization using the GIMP_NO_PASS_THROUGH_STRENGTH_REDUCTION environment variable.
2017-12-07 03:06:16 +08:00
static void gimp_group_layer_mask_changed (GimpLayer *layer);
static void gimp_group_layer_get_effective_mode (GimpLayer *layer,
GimpLayerMode *mode,
GimpLayerColorSpace *blend_space,
GimpLayerColorSpace *composite_space,
GimpLayerCompositeMode *composite_mode);
app: handle excludes_backdrop in GimpGroupLayer When any of the children of a pass-through group excludes its backdrop, the group itself should exclude the backdrop too. Override get_excludes_backdrop() to follow this logic, and call update_excludes_backdrop() when this condition might change. Note that we always composite pass-through groups using src-over mode, so to actually hide the backdrop, we need to disconnect it from the group's mode node's input pad (and reconnect it, when the backdrop is no longer hidden).
2017-05-09 03:06:00 +08:00
static gboolean
gimp_group_layer_get_excludes_backdrop (GimpLayer *layer);
Implement GimpDrawable::estimate_memsize() Add the scaled sizes of all children and of the projection so the scale dialog's size warning is correct again.
2009-08-28 01:43:45 +08:00
app: replace GimpProjectable::get_image_type() by ::get_format() and change semantics to returning the format it wants to be projected in, not its actual format.
2012-03-30 03:09:37 +08:00
static const Babl * gimp_group_layer_get_format (GimpProjectable *projectable);
Add a projection to GimpGroupLayer so we finally have a *visible* layer tree Implement the GimpProjectable interface and keep a GimpProjection around that projects the GimpDrawableStack of our children. Propagate the childrens' "update" signals to our own "update" signal so our parent projection picks up all changes.
2009-08-24 22:03:21 +08:00
static GeglNode * gimp_group_layer_get_graph (GimpProjectable *projectable);
app: implement {begin,end}_render() for GimpGroupLayer Use them to connect/disconnect the stack graph when the group is in pass-through mode.
2017-04-23 02:28:54 +08:00
static void gimp_group_layer_begin_render (GimpProjectable *projectable);
static void gimp_group_layer_end_render (GimpProjectable *projectable);
app: return double not int from GimpPickable::get_opacity_at() and fix GimpLayer's impl to honor the mask also for layers without alpha.
2012-04-21 22:05:49 +08:00
static gdouble gimp_group_layer_get_opacity_at (GimpPickable *pickable,
Bug 612931 - Moving individual layer in layer group not possible with Move Tool in 'pick a layer' mode When using GimpPickable::get_opacity_at(), don't consider group layers as having content.
2011-08-20 21:01:46 +08:00
gint x,
gint y);
Add a projection to GimpGroupLayer so we finally have a *visible* layer tree Implement the GimpProjectable interface and keep a GimpProjection around that projects the GimpDrawableStack of our children. Propagate the childrens' "update" signals to our own "update" signal so our parent projection picks up all changes.
2009-08-24 22:03:21 +08:00
static void gimp_group_layer_child_add (GimpContainer *container,
GimpLayer *child,
GimpGroupLayer *group);
static void gimp_group_layer_child_remove (GimpContainer *container,
GimpLayer *child,
GimpGroupLayer *group);
static void gimp_group_layer_child_move (GimpLayer *child,
GParamSpec *pspec,
GimpGroupLayer *group);
static void gimp_group_layer_child_resize (GimpLayer *child,
GimpGroupLayer *group);
app: add GimpFilter::active property; move ::visible to GimpItem Add an "active" property to GimpFilter, which replaces its "visible" property. The new property assumes the lower-level role "visible" had -- controlling whether the filter has any effect as part of its parent filter-stack. Add a "visible" property to GimpItem, separate from the "active" property, which assumes the higher-level role "visible" had -- controlling whether the item is considered "visible", as per the GUI. By default, the item's "visible" property is bound to the filter's "active" property, so that changes in visibility directly affect the filter's "activeness"; this binding can be controlled using the new gimp_item_bind_visible_to_active() function. This distinction is currently necessary for floating selections. Floating selection layers must not be active in their parent stack, regardless of their visibility, in particular, so that their mode node doesn't hide the entire backdrop when their composite mode excludes the backdrop (i.e., when it's dst-atop or src-in). Instead, their visibility should affect the activeness of the floating-selection filter of the drawable they're attached to. This is handled by the next commit.
2017-12-06 02:46:50 +08:00
static void gimp_group_layer_child_active_changed (GimpLayer *child,
app: handle excludes_backdrop in GimpGroupLayer When any of the children of a pass-through group excludes its backdrop, the group itself should exclude the backdrop too. Override get_excludes_backdrop() to follow this logic, and call update_excludes_backdrop() when this condition might change. Note that we always composite pass-through groups using src-over mode, so to actually hide the backdrop, we need to disconnect it from the group's mode node's input pad (and reconnect it, when the backdrop is no longer hidden).
2017-05-09 03:06:00 +08:00
GimpGroupLayer *group);
app: strength-reduce pass-through groups to normal groups Override GimpLayer::get_effective_mode() in GimpGroupLayer, to perform strength-reduction of pass-through groups to normal groups under certain conditions (see gimp_group_layer_get_effective_mode() for the logic.) The main motivation for this is the fact that Photoshop uses pass- through mode as the default mode for groups, resulting in many PSDs using pass-through groups generously and unnecessarily. Since pass-through groups are more expensive that normal groups, reducing them to normal groups when possible can make a big difference. Note that, while the results of the strength-reduced composition are theoretically equivalent, there may be small differences in practice due to numerical errors, especially when using low precision. This is unlikely to be an issue, but, just in case, allow disabling this optimization using the GIMP_NO_PASS_THROUGH_STRENGTH_REDUCTION environment variable.
2017-12-07 03:06:16 +08:00
static void
gimp_group_layer_child_effective_mode_changed (GimpLayer *child,
GimpGroupLayer *group);
app: handle excludes_backdrop in GimpGroupLayer When any of the children of a pass-through group excludes its backdrop, the group itself should exclude the backdrop too. Override get_excludes_backdrop() to follow this logic, and call update_excludes_backdrop() when this condition might change. Note that we always composite pass-through groups using src-over mode, so to actually hide the backdrop, we need to disconnect it from the group's mode node's input pad (and reconnect it, when the backdrop is no longer hidden).
2017-05-09 03:06:00 +08:00
static void
gimp_group_layer_child_excludes_backdrop_changed (GimpLayer *child,
GimpGroupLayer *group);
Add a projection to GimpGroupLayer so we finally have a *visible* layer tree Implement the GimpProjectable interface and keep a GimpProjection around that projects the GimpDrawableStack of our children. Propagate the childrens' "update" signals to our own "update" signal so our parent projection picks up all changes.
2009-08-24 22:03:21 +08:00
app: flush pass-through groups' projection asynchronously The source node of pass-through groups doesn't use the projection's buffer, hence there's no need to invalidate it synchronously, which is faster.
2017-12-02 23:15:39 +08:00
static void gimp_group_layer_flush (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
static void gimp_group_layer_update (GimpGroupLayer *group);
static void gimp_group_layer_update_size (GimpGroupLayer *group);
app: resize group-layer mask after moving the group We avoid resizing the mask as a result of changes in the group's bounding box while the group is being moved (i.e., translated, rotated, etc.), so that GimpLayer transforms the original mask, rather than a cropped mask. We still need to crop the mask after we're finished moving the group, however. This commit takes care of that.
2018-02-07 22:48:00 +08:00
static void gimp_group_layer_update_mask_size (GimpGroupLayer *group);
app: implement pass-through mode in GimpGroupLayer Override GimpDrawable::get_source_node() for GimpGroupLayer. Use a node that contains both the drawable's buffer-source node, and the layer stack's graph node. Choose which one of these to connect to the source node's output based on the group's layer mode: the stack graph for pass-through mode, and the buffer-source node for all the rest. When in pass-through mode, connect the source node's input (which receives the backdrop) to the stack graph's input. Keep maintaining the projection in pass-through mode. ATM, the projection uses the same graph as the source node, so it's rendered against the group's backdrop -- we don't want that. The next few commits fix it. Update the group's drawable directly upon filter stack update in pass-though mode, because the group's graph doesn't go through the projection. TODO: if any of the group's children (or a child of a nested pass- through group, etc.) uses dst-atop/src-in, this needs special attention.
2017-04-22 06:04:49 +08:00
static void gimp_group_layer_update_source_node (GimpGroupLayer *group);
app: handle excludes_backdrop in GimpGroupLayer When any of the children of a pass-through group excludes its backdrop, the group itself should exclude the backdrop too. Override get_excludes_backdrop() to follow this logic, and call update_excludes_backdrop() when this condition might change. Note that we always composite pass-through groups using src-over mode, so to actually hide the backdrop, we need to disconnect it from the group's mode node's input pad (and reconnect it, when the backdrop is no longer hidden).
2017-05-09 03:06:00 +08:00
static void gimp_group_layer_update_mode_node (GimpGroupLayer *group);
Add a projection to GimpGroupLayer so we finally have a *visible* layer tree Implement the GimpProjectable interface and keep a GimpProjection around that projects the GimpDrawableStack of our children. Propagate the childrens' "update" signals to our own "update" signal so our parent projection picks up all changes.
2009-08-24 22:03:21 +08:00
static void gimp_group_layer_stack_update (GimpDrawableStack *stack,
gint x,
gint y,
gint width,
gint height,
GimpGroupLayer *group);
static void gimp_group_layer_proj_update (GimpProjection *proj,
gboolean now,
gint x,
gint y,
gint width,
gint height,
GimpGroupLayer *group);
G_DEFINE_TYPE_WITH_CODE (GimpGroupLayer, gimp_group_layer, GIMP_TYPE_LAYER,
app, libgimp*, modules: don't use g_type_class_add_private() ... ... and G_TYPE_INSTANCE_GET_PRIVATE() g_type_class_add_private() and G_TYPE_INSTANCE_GET_PRIVATE() were deprecated in GLib 2.58. Instead, use G_DEFINE_[ABSTRACT_]TYPE_WITH_PRIVATE(), and G_ADD_PRIVATE[_DYNAMIC](), and the implictly-defined foo_get_instance_private() functions, all of which are available in the GLib versions we depend on. This commit only covers types registered using one of the G_DEFINE_FOO() macros (i.e., most types), but not types with a custom registration function, of which we still have a few -- GLib currently only provides a (non-deprecated) public API for adding a private struct using the G_DEFINE_FOO() macros. Note that this commit was 99% auto-generated (because I'm not *that* crazy :), so if there are any style mismatches... we'll have to live with them for now.
2018-09-19 00:09:39 +08:00
G_ADD_PRIVATE (GimpGroupLayer)
Add a projection to GimpGroupLayer so we finally have a *visible* layer tree Implement the GimpProjectable interface and keep a GimpProjection around that projects the GimpDrawableStack of our children. Propagate the childrens' "update" signals to our own "update" signal so our parent projection picks up all changes.
2009-08-24 22:03:21 +08:00
G_IMPLEMENT_INTERFACE (GIMP_TYPE_PROJECTABLE,
Bug 612931 - Moving individual layer in layer group not possible with Move Tool in 'pick a layer' mode When using GimpPickable::get_opacity_at(), don't consider group layers as having content.
2011-08-20 21:01:46 +08:00
gimp_projectable_iface_init)
G_IMPLEMENT_INTERFACE (GIMP_TYPE_PICKABLE,
gimp_pickable_iface_init))
Add a GimpGroupLayer class (not used yet)
2009-08-04 05:24:46 +08:00
#define parent_class gimp_group_layer_parent_class
app: strength-reduce pass-through groups to normal groups Override GimpLayer::get_effective_mode() in GimpGroupLayer, to perform strength-reduction of pass-through groups to normal groups under certain conditions (see gimp_group_layer_get_effective_mode() for the logic.) The main motivation for this is the fact that Photoshop uses pass- through mode as the default mode for groups, resulting in many PSDs using pass-through groups generously and unnecessarily. Since pass-through groups are more expensive that normal groups, reducing them to normal groups when possible can make a big difference. Note that, while the results of the strength-reduced composition are theoretically equivalent, there may be small differences in practice due to numerical errors, especially when using low precision. This is unlikely to be an issue, but, just in case, allow disabling this optimization using the GIMP_NO_PASS_THROUGH_STRENGTH_REDUCTION environment variable.
2017-12-07 03:06:16 +08:00
/* disable pass-through groups strength-reduction to normal groups.
* see gimp_group_layer_get_effective_mode().
*/
static gboolean no_pass_through_strength_reduction = FALSE;
Add a GimpGroupLayer class (not used yet)
2009-08-04 05:24:46 +08:00
static void
gimp_group_layer_class_init (GimpGroupLayerClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
GimpObjectClass *gimp_object_class = GIMP_OBJECT_CLASS (klass);
GimpViewableClass *viewable_class = GIMP_VIEWABLE_CLASS (klass);
GimpItemClass *item_class = GIMP_ITEM_CLASS (klass);
Implement GimpDrawable::estimate_memsize() Add the scaled sizes of all children and of the projection so the scale dialog's size warning is correct again.
2009-08-28 01:43:45 +08:00
GimpDrawableClass *drawable_class = GIMP_DRAWABLE_CLASS (klass);
app: add virtual transform/type-conversion functions to GimpLayer The GimpLayer implementation of the GimpItem transform functions, and the GimpDrawable convert_type() function, apply their operation to both the layer and its mask. The subclasses of GimpLayer -- GimpGroupLayer and GimpTextLayer -- override some of these functions, providing their own logic for the layer part, and duplicating the mask part. Avoid this duplication by adding a set of virtual transform and type-conversion functions to GimpLayer. Have the GimpLayer implementaion of the corresponding GimpItem and GimpDrawable functions use these functions to apply the operation to the layer, while taking care of the mask themselves. Have GimpLayer's subclasses override the new virtual functions, instead of the GimpItem and GimpDrawable ones. Note that the existing implementation of convert_type() in GimpTextLayer neglected to convert the mask, hence text layer masks retained their old format after conversion. This issue is fixed as a side effect of this commit.
2017-06-17 08:15:56 +08:00
GimpLayerClass *layer_class = GIMP_LAYER_CLASS (klass);
Add a GimpGroupLayer class (not used yet)
2009-08-04 05:24:46 +08:00
app: handle excludes_backdrop in GimpGroupLayer When any of the children of a pass-through group excludes its backdrop, the group itself should exclude the backdrop too. Override get_excludes_backdrop() to follow this logic, and call update_excludes_backdrop() when this condition might change. Note that we always composite pass-through groups using src-over mode, so to actually hide the backdrop, we need to disconnect it from the group's mode node's input pad (and reconnect it, when the backdrop is no longer hidden).
2017-05-09 03:06:00 +08:00
object_class->set_property = gimp_group_layer_set_property;
object_class->get_property = gimp_group_layer_get_property;
object_class->finalize = gimp_group_layer_finalize;
gimp_object_class->get_memsize = gimp_group_layer_get_memsize;
viewable_class->default_icon_name = "gimp-group-layer";
app: set group layer projection priority according to depth Set the priority of group-layer projections according to the group layer's depth, so that top-level groups have a priority of 1 (compared to a priority of 0 for the image projection), and nested groups have a priority one greater than their parent (in other words, shallower groups have higher priority than deeper groups, all of which have lower priority than the image.) This makes pass-through groups much faster, in particular.
2017-12-02 22:55:15 +08:00
viewable_class->ancestry_changed = gimp_group_layer_ancestry_changed;
app: handle excludes_backdrop in GimpGroupLayer When any of the children of a pass-through group excludes its backdrop, the group itself should exclude the backdrop too. Override get_excludes_backdrop() to follow this logic, and call update_excludes_backdrop() when this condition might change. Note that we always composite pass-through groups using src-over mode, so to actually hide the backdrop, we need to disconnect it from the group's mode node's input pad (and reconnect it, when the backdrop is no longer hidden).
2017-05-09 03:06:00 +08:00
viewable_class->get_size = gimp_group_layer_get_size;
viewable_class->get_children = gimp_group_layer_get_children;
viewable_class->set_expanded = gimp_group_layer_set_expanded;
viewable_class->get_expanded = gimp_group_layer_get_expanded;
item_class->is_position_locked = gimp_group_layer_is_position_locked;
item_class->duplicate = gimp_group_layer_duplicate;
item_class->convert = gimp_group_layer_convert;
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
item_class->start_transform = gimp_group_layer_start_transform;
item_class->end_transform = gimp_group_layer_end_transform;
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
item_class->resize = gimp_group_layer_resize;
app: handle excludes_backdrop in GimpGroupLayer When any of the children of a pass-through group excludes its backdrop, the group itself should exclude the backdrop too. Override get_excludes_backdrop() to follow this logic, and call update_excludes_backdrop() when this condition might change. Note that we always composite pass-through groups using src-over mode, so to actually hide the backdrop, we need to disconnect it from the group's mode node's input pad (and reconnect it, when the backdrop is no longer hidden).
2017-05-09 03:06:00 +08:00
item_class->default_name = _("Layer Group");
item_class->rename_desc = C_("undo-type", "Rename Layer Group");
item_class->translate_desc = C_("undo-type", "Move Layer Group");
item_class->scale_desc = C_("undo-type", "Scale Layer Group");
item_class->resize_desc = C_("undo-type", "Resize Layer Group");
item_class->flip_desc = C_("undo-type", "Flip Layer Group");
item_class->rotate_desc = C_("undo-type", "Rotate Layer Group");
item_class->transform_desc = C_("undo-type", "Transform Layer Group");
drawable_class->estimate_memsize = gimp_group_layer_estimate_memsize;
drawable_class->get_source_node = gimp_group_layer_get_source_node;
app: strength-reduce pass-through groups to normal groups Override GimpLayer::get_effective_mode() in GimpGroupLayer, to perform strength-reduction of pass-through groups to normal groups under certain conditions (see gimp_group_layer_get_effective_mode() for the logic.) The main motivation for this is the fact that Photoshop uses pass- through mode as the default mode for groups, resulting in many PSDs using pass-through groups generously and unnecessarily. Since pass-through groups are more expensive that normal groups, reducing them to normal groups when possible can make a big difference. Note that, while the results of the strength-reduced composition are theoretically equivalent, there may be small differences in practice due to numerical errors, especially when using low precision. This is unlikely to be an issue, but, just in case, allow disabling this optimization using the GIMP_NO_PASS_THROUGH_STRENGTH_REDUCTION environment variable.
2017-12-07 03:06:16 +08:00
layer_class->opacity_changed = gimp_group_layer_opacity_changed;
layer_class->effective_mode_changed = gimp_group_layer_effective_mode_changed;
app: handle excludes_backdrop in GimpGroupLayer When any of the children of a pass-through group excludes its backdrop, the group itself should exclude the backdrop too. Override get_excludes_backdrop() to follow this logic, and call update_excludes_backdrop() when this condition might change. Note that we always composite pass-through groups using src-over mode, so to actually hide the backdrop, we need to disconnect it from the group's mode node's input pad (and reconnect it, when the backdrop is no longer hidden).
2017-05-09 03:06:00 +08:00
layer_class->excludes_backdrop_changed = gimp_group_layer_excludes_backdrop_changed;
app: strength-reduce pass-through groups to normal groups Override GimpLayer::get_effective_mode() in GimpGroupLayer, to perform strength-reduction of pass-through groups to normal groups under certain conditions (see gimp_group_layer_get_effective_mode() for the logic.) The main motivation for this is the fact that Photoshop uses pass- through mode as the default mode for groups, resulting in many PSDs using pass-through groups generously and unnecessarily. Since pass-through groups are more expensive that normal groups, reducing them to normal groups when possible can make a big difference. Note that, while the results of the strength-reduced composition are theoretically equivalent, there may be small differences in practice due to numerical errors, especially when using low precision. This is unlikely to be an issue, but, just in case, allow disabling this optimization using the GIMP_NO_PASS_THROUGH_STRENGTH_REDUCTION environment variable.
2017-12-07 03:06:16 +08:00
layer_class->mask_changed = gimp_group_layer_mask_changed;
app: handle excludes_backdrop in GimpGroupLayer When any of the children of a pass-through group excludes its backdrop, the group itself should exclude the backdrop too. Override get_excludes_backdrop() to follow this logic, and call update_excludes_backdrop() when this condition might change. Note that we always composite pass-through groups using src-over mode, so to actually hide the backdrop, we need to disconnect it from the group's mode node's input pad (and reconnect it, when the backdrop is no longer hidden).
2017-05-09 03:06:00 +08:00
layer_class->translate = gimp_group_layer_translate;
layer_class->scale = gimp_group_layer_scale;
layer_class->flip = gimp_group_layer_flip;
layer_class->rotate = gimp_group_layer_rotate;
layer_class->transform = gimp_group_layer_transform;
layer_class->convert_type = gimp_group_layer_convert_type;
app: strength-reduce pass-through groups to normal groups Override GimpLayer::get_effective_mode() in GimpGroupLayer, to perform strength-reduction of pass-through groups to normal groups under certain conditions (see gimp_group_layer_get_effective_mode() for the logic.) The main motivation for this is the fact that Photoshop uses pass- through mode as the default mode for groups, resulting in many PSDs using pass-through groups generously and unnecessarily. Since pass-through groups are more expensive that normal groups, reducing them to normal groups when possible can make a big difference. Note that, while the results of the strength-reduced composition are theoretically equivalent, there may be small differences in practice due to numerical errors, especially when using low precision. This is unlikely to be an issue, but, just in case, allow disabling this optimization using the GIMP_NO_PASS_THROUGH_STRENGTH_REDUCTION environment variable.
2017-12-07 03:06:16 +08:00
layer_class->get_effective_mode = gimp_group_layer_get_effective_mode;
app: handle excludes_backdrop in GimpGroupLayer When any of the children of a pass-through group excludes its backdrop, the group itself should exclude the backdrop too. Override get_excludes_backdrop() to follow this logic, and call update_excludes_backdrop() when this condition might change. Note that we always composite pass-through groups using src-over mode, so to actually hide the backdrop, we need to disconnect it from the group's mode node's input pad (and reconnect it, when the backdrop is no longer hidden).
2017-05-09 03:06:00 +08:00
layer_class->get_excludes_backdrop = gimp_group_layer_get_excludes_backdrop;
app: move all GimpGroupLayer members to a private struct
2011-02-04 05:29:25 +08:00
app: strength-reduce pass-through groups to normal groups Override GimpLayer::get_effective_mode() in GimpGroupLayer, to perform strength-reduction of pass-through groups to normal groups under certain conditions (see gimp_group_layer_get_effective_mode() for the logic.) The main motivation for this is the fact that Photoshop uses pass- through mode as the default mode for groups, resulting in many PSDs using pass-through groups generously and unnecessarily. Since pass-through groups are more expensive that normal groups, reducing them to normal groups when possible can make a big difference. Note that, while the results of the strength-reduced composition are theoretically equivalent, there may be small differences in practice due to numerical errors, especially when using low precision. This is unlikely to be an issue, but, just in case, allow disabling this optimization using the GIMP_NO_PASS_THROUGH_STRENGTH_REDUCTION environment variable.
2017-12-07 03:06:16 +08:00
if (g_getenv ("GIMP_NO_PASS_THROUGH_STRENGTH_REDUCTION"))
no_pass_through_strength_reduction = TRUE;
Add a GimpGroupLayer class (not used yet)
2009-08-04 05:24:46 +08:00
}
Add a projection to GimpGroupLayer so we finally have a *visible* layer tree Implement the GimpProjectable interface and keep a GimpProjection around that projects the GimpDrawableStack of our children. Propagate the childrens' "update" signals to our own "update" signal so our parent projection picks up all changes.
2009-08-24 22:03:21 +08:00
static void
gimp_projectable_iface_init (GimpProjectableInterface *iface)
{
iface->get_image = (GimpImage * (*) (GimpProjectable *)) gimp_item_get_image;
app: replace GimpProjectable::get_image_type() by ::get_format() and change semantics to returning the format it wants to be projected in, not its actual format.
2012-03-30 03:09:37 +08:00
iface->get_format = gimp_group_layer_get_format;
Add a projection to GimpGroupLayer so we finally have a *visible* layer tree Implement the GimpProjectable interface and keep a GimpProjection around that projects the GimpDrawableStack of our children. Propagate the childrens' "update" signals to our own "update" signal so our parent projection picks up all changes.
2009-08-24 22:03:21 +08:00
iface->get_offset = (void (*) (GimpProjectable*, gint*, gint*)) gimp_item_get_offset;
iface->get_size = (void (*) (GimpProjectable*, gint*, gint*)) gimp_viewable_get_size;
iface->get_graph = gimp_group_layer_get_graph;
app: implement {begin,end}_render() for GimpGroupLayer Use them to connect/disconnect the stack graph when the group is in pass-through mode.
2017-04-23 02:28:54 +08:00
iface->begin_render = gimp_group_layer_begin_render;
iface->end_render = gimp_group_layer_end_render;
Add a projection to GimpGroupLayer so we finally have a *visible* layer tree Implement the GimpProjectable interface and keep a GimpProjection around that projects the GimpDrawableStack of our children. Propagate the childrens' "update" signals to our own "update" signal so our parent projection picks up all changes.
2009-08-24 22:03:21 +08:00
iface->invalidate_preview = (void (*) (GimpProjectable*)) gimp_viewable_invalidate_preview;
}
Bug 612931 - Moving individual layer in layer group not possible with Move Tool in 'pick a layer' mode When using GimpPickable::get_opacity_at(), don't consider group layers as having content.
2011-08-20 21:01:46 +08:00
static void
gimp_pickable_iface_init (GimpPickableInterface *iface)
{
iface->get_opacity_at = gimp_group_layer_get_opacity_at;
}
Add a GimpGroupLayer class (not used yet)
2009-08-04 05:24:46 +08:00
static void
Change local variable names from "layer" to "group"
2009-08-24 06:34:12 +08:00
gimp_group_layer_init (GimpGroupLayer *group)
Add a GimpGroupLayer class (not used yet)
2009-08-04 05:24:46 +08:00
{
app: move all GimpGroupLayer members to a private struct
2011-02-04 05:29:25 +08:00
GimpGroupLayerPrivate *private = GET_PRIVATE (group);
Automatically adjust the size of group layers Connect to size and offset of all children and resize/move the group layer accordingly.
2009-08-24 05:00:32 +08:00
app: add GimpLayerStack A subclass of GimpDrawableStack, for layer stacks. Invalidates the layers' backdrop as/when necessary, according to the value of their excludes_backdrop property. Make gimp_drawable_stack_update() protected, instead of private, so that we can use it in GimpLayerStack.
2017-05-09 04:02:37 +08:00
private->children = gimp_layer_stack_new (GIMP_TYPE_LAYER);
Bug 616416: hidden layer groups appear again after an image change Introduced two virtual functions to a GimpViewable 'set_expanded' and 'get_expanded' and a PROP_GROUP_ITEM_FLAGS to load/save the expanded state of layer_groups and use them.
2011-09-26 03:57:20 +08:00
private->expanded = TRUE;
app: move all GimpGroupLayer members to a private struct
2011-02-04 05:29:25 +08:00
g_signal_connect (private->children, "add",
Automatically adjust the size of group layers Connect to size and offset of all children and resize/move the group layer accordingly.
2009-08-24 05:00:32 +08:00
G_CALLBACK (gimp_group_layer_child_add),
Change local variable names from "layer" to "group"
2009-08-24 06:34:12 +08:00
group);
app: move all GimpGroupLayer members to a private struct
2011-02-04 05:29:25 +08:00
g_signal_connect (private->children, "remove",
Automatically adjust the size of group layers Connect to size and offset of all children and resize/move the group layer accordingly.
2009-08-24 05:00:32 +08:00
G_CALLBACK (gimp_group_layer_child_remove),
Change local variable names from "layer" to "group"
2009-08-24 06:34:12 +08:00
group);
Automatically adjust the size of group layers Connect to size and offset of all children and resize/move the group layer accordingly.
2009-08-24 05:00:32 +08:00
app: move all GimpGroupLayer members to a private struct
2011-02-04 05:29:25 +08:00
gimp_container_add_handler (private->children, "notify::offset-x",
Automatically adjust the size of group layers Connect to size and offset of all children and resize/move the group layer accordingly.
2009-08-24 05:00:32 +08:00
G_CALLBACK (gimp_group_layer_child_move),
Change local variable names from "layer" to "group"
2009-08-24 06:34:12 +08:00
group);
app: move all GimpGroupLayer members to a private struct
2011-02-04 05:29:25 +08:00
gimp_container_add_handler (private->children, "notify::offset-y",
Automatically adjust the size of group layers Connect to size and offset of all children and resize/move the group layer accordingly.
2009-08-24 05:00:32 +08:00
G_CALLBACK (gimp_group_layer_child_move),
Change local variable names from "layer" to "group"
2009-08-24 06:34:12 +08:00
group);
app: move all GimpGroupLayer members to a private struct
2011-02-04 05:29:25 +08:00
gimp_container_add_handler (private->children, "size-changed",
Automatically adjust the size of group layers Connect to size and offset of all children and resize/move the group layer accordingly.
2009-08-24 05:00:32 +08:00
G_CALLBACK (gimp_group_layer_child_resize),
Change local variable names from "layer" to "group"
2009-08-24 06:34:12 +08:00
group);
app: add GimpFilter::active property; move ::visible to GimpItem Add an "active" property to GimpFilter, which replaces its "visible" property. The new property assumes the lower-level role "visible" had -- controlling whether the filter has any effect as part of its parent filter-stack. Add a "visible" property to GimpItem, separate from the "active" property, which assumes the higher-level role "visible" had -- controlling whether the item is considered "visible", as per the GUI. By default, the item's "visible" property is bound to the filter's "active" property, so that changes in visibility directly affect the filter's "activeness"; this binding can be controlled using the new gimp_item_bind_visible_to_active() function. This distinction is currently necessary for floating selections. Floating selection layers must not be active in their parent stack, regardless of their visibility, in particular, so that their mode node doesn't hide the entire backdrop when their composite mode excludes the backdrop (i.e., when it's dst-atop or src-in). Instead, their visibility should affect the activeness of the floating-selection filter of the drawable they're attached to. This is handled by the next commit.
2017-12-06 02:46:50 +08:00
gimp_container_add_handler (private->children, "active-changed",
G_CALLBACK (gimp_group_layer_child_active_changed),
app: handle excludes_backdrop in GimpGroupLayer When any of the children of a pass-through group excludes its backdrop, the group itself should exclude the backdrop too. Override get_excludes_backdrop() to follow this logic, and call update_excludes_backdrop() when this condition might change. Note that we always composite pass-through groups using src-over mode, so to actually hide the backdrop, we need to disconnect it from the group's mode node's input pad (and reconnect it, when the backdrop is no longer hidden).
2017-05-09 03:06:00 +08:00
group);
app: strength-reduce pass-through groups to normal groups Override GimpLayer::get_effective_mode() in GimpGroupLayer, to perform strength-reduction of pass-through groups to normal groups under certain conditions (see gimp_group_layer_get_effective_mode() for the logic.) The main motivation for this is the fact that Photoshop uses pass- through mode as the default mode for groups, resulting in many PSDs using pass-through groups generously and unnecessarily. Since pass-through groups are more expensive that normal groups, reducing them to normal groups when possible can make a big difference. Note that, while the results of the strength-reduced composition are theoretically equivalent, there may be small differences in practice due to numerical errors, especially when using low precision. This is unlikely to be an issue, but, just in case, allow disabling this optimization using the GIMP_NO_PASS_THROUGH_STRENGTH_REDUCTION environment variable.
2017-12-07 03:06:16 +08:00
gimp_container_add_handler (private->children, "effective-mode-changed",
G_CALLBACK (gimp_group_layer_child_effective_mode_changed),
group);
app: handle excludes_backdrop in GimpGroupLayer When any of the children of a pass-through group excludes its backdrop, the group itself should exclude the backdrop too. Override get_excludes_backdrop() to follow this logic, and call update_excludes_backdrop() when this condition might change. Note that we always composite pass-through groups using src-over mode, so to actually hide the backdrop, we need to disconnect it from the group's mode node's input pad (and reconnect it, when the backdrop is no longer hidden).
2017-05-09 03:06:00 +08:00
gimp_container_add_handler (private->children, "excludes-backdrop-changed",
G_CALLBACK (gimp_group_layer_child_excludes_backdrop_changed),
group);
Add a projection to GimpGroupLayer so we finally have a *visible* layer tree Implement the GimpProjectable interface and keep a GimpProjection around that projects the GimpDrawableStack of our children. Propagate the childrens' "update" signals to our own "update" signal so our parent projection picks up all changes.
2009-08-24 22:03:21 +08:00
app: move all GimpGroupLayer members to a private struct
2011-02-04 05:29:25 +08:00
g_signal_connect (private->children, "update",
Add a projection to GimpGroupLayer so we finally have a *visible* layer tree Implement the GimpProjectable interface and keep a GimpProjection around that projects the GimpDrawableStack of our children. Propagate the childrens' "update" signals to our own "update" signal so our parent projection picks up all changes.
2009-08-24 22:03:21 +08:00
G_CALLBACK (gimp_group_layer_stack_update),
group);
app: move all GimpGroupLayer members to a private struct
2011-02-04 05:29:25 +08:00
private->projection = gimp_projection_new (GIMP_PROJECTABLE (group));
app: set group layer projection priority according to depth Set the priority of group-layer projections according to the group layer's depth, so that top-level groups have a priority of 1 (compared to a priority of 0 for the image projection), and nested groups have a priority one greater than their parent (in other words, shallower groups have higher priority than deeper groups, all of which have lower priority than the image.) This makes pass-through groups much faster, in particular.
2017-12-02 22:55:15 +08:00
gimp_projection_set_priority (private->projection, 1);
Add a projection to GimpGroupLayer so we finally have a *visible* layer tree Implement the GimpProjectable interface and keep a GimpProjection around that projects the GimpDrawableStack of our children. Propagate the childrens' "update" signals to our own "update" signal so our parent projection picks up all changes.
2009-08-24 22:03:21 +08:00
app: move all GimpGroupLayer members to a private struct
2011-02-04 05:29:25 +08:00
g_signal_connect (private->projection, "update",
Add a projection to GimpGroupLayer so we finally have a *visible* layer tree Implement the GimpProjectable interface and keep a GimpProjection around that projects the GimpDrawableStack of our children. Propagate the childrens' "update" signals to our own "update" signal so our parent projection picks up all changes.
2009-08-24 22:03:21 +08:00
G_CALLBACK (gimp_group_layer_proj_update),
group);
Add a GimpGroupLayer class (not used yet)
2009-08-04 05:24:46 +08:00
}
app: move all GimpGroupLayer members to a private struct
2011-02-04 05:29:25 +08:00
static void
gimp_group_layer_finalize (GObject *object)
{
GimpGroupLayerPrivate *private = GET_PRIVATE (object);
if (private->children)
{
g_signal_handlers_disconnect_by_func (private->children,
gimp_group_layer_child_add,
object);
g_signal_handlers_disconnect_by_func (private->children,
gimp_group_layer_child_remove,
object);
g_signal_handlers_disconnect_by_func (private->children,
gimp_group_layer_stack_update,
object);
app: use a lot of g_clear_object() and g_clear_pointer() More than 2000 lines of code less in app/, instead of if (instance->member) { g_object_unref/g_free/g_whatever (instance->member); instance->member = NULL; } we now simply use g_clear_object/pointer (&instance->member);
2017-07-16 00:38:01 +08:00
g_clear_object (&private->children);
app: move all GimpGroupLayer members to a private struct
2011-02-04 05:29:25 +08:00
}
app: use a lot of g_clear_object() and g_clear_pointer() More than 2000 lines of code less in app/, instead of if (instance->member) { g_object_unref/g_free/g_whatever (instance->member); instance->member = NULL; } we now simply use g_clear_object/pointer (&instance->member);
2017-07-16 00:38:01 +08:00
g_clear_object (&private->projection);
app: implement pass-through mode in GimpGroupLayer Override GimpDrawable::get_source_node() for GimpGroupLayer. Use a node that contains both the drawable's buffer-source node, and the layer stack's graph node. Choose which one of these to connect to the source node's output based on the group's layer mode: the stack graph for pass-through mode, and the buffer-source node for all the rest. When in pass-through mode, connect the source node's input (which receives the backdrop) to the stack graph's input. Keep maintaining the projection in pass-through mode. ATM, the projection uses the same graph as the source node, so it's rendered against the group's backdrop -- we don't want that. The next few commits fix it. Update the group's drawable directly upon filter stack update in pass-though mode, because the group's graph doesn't go through the projection. TODO: if any of the group's children (or a child of a nested pass- through group, etc.) uses dst-atop/src-in, this needs special attention.
2017-04-22 06:04:49 +08:00
g_clear_object (&private->source_node);
app: use a lot of g_clear_object() and g_clear_pointer() More than 2000 lines of code less in app/, instead of if (instance->member) { g_object_unref/g_free/g_whatever (instance->member); instance->member = NULL; } we now simply use g_clear_object/pointer (&instance->member);
2017-07-16 00:38:01 +08:00
g_clear_object (&private->graph);
app: move all GimpGroupLayer members to a private struct
2011-02-04 05:29:25 +08:00
G_OBJECT_CLASS (parent_class)->finalize (object);
}
Override the "lock-content" property to default to TRUE
2009-08-24 02:02:36 +08:00
static void
gimp_group_layer_set_property (GObject *object,
guint property_id,
const GValue *value,
GParamSpec *pspec)
{
switch (property_id)
{
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
break;
}
}
static void
gimp_group_layer_get_property (GObject *object,
guint property_id,
GValue *value,
GParamSpec *pspec)
{
switch (property_id)
{
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
break;
}
}
Add a GimpGroupLayer class (not used yet)
2009-08-04 05:24:46 +08:00
static gint64
gimp_group_layer_get_memsize (GimpObject *object,
gint64 *gui_size)
{
app: move all GimpGroupLayer members to a private struct
2011-02-04 05:29:25 +08:00
GimpGroupLayerPrivate *private = GET_PRIVATE (object);
gint64 memsize = 0;
Add a GimpGroupLayer class (not used yet)
2009-08-04 05:24:46 +08:00
app: move all GimpGroupLayer members to a private struct
2011-02-04 05:29:25 +08:00
memsize += gimp_object_get_memsize (GIMP_OBJECT (private->children), gui_size);
memsize += gimp_object_get_memsize (GIMP_OBJECT (private->projection), gui_size);
Add a GimpGroupLayer class (not used yet)
2009-08-04 05:24:46 +08:00
return memsize + GIMP_OBJECT_CLASS (parent_class)->get_memsize (object,
gui_size);
}
app: set group layer projection priority according to depth Set the priority of group-layer projections according to the group layer's depth, so that top-level groups have a priority of 1 (compared to a priority of 0 for the image projection), and nested groups have a priority one greater than their parent (in other words, shallower groups have higher priority than deeper groups, all of which have lower priority than the image.) This makes pass-through groups much faster, in particular.
2017-12-02 22:55:15 +08:00
static void
gimp_group_layer_ancestry_changed (GimpViewable *viewable)
{
GimpGroupLayerPrivate *private = GET_PRIVATE (viewable);
gimp_projection_set_priority (private->projection,
gimp_viewable_get_depth (viewable) + 1);
GIMP_VIEWABLE_CLASS (parent_class)->ancestry_changed (viewable);
}
app: fake the size of a gruop layer by overriding GimpViewable::get_size() instead of messing with GimpItem's width and height members.
2011-03-09 01:04:23 +08:00
static gboolean
gimp_group_layer_get_size (GimpViewable *viewable,
gint *width,
gint *height)
{
GimpGroupLayerPrivate *private = GET_PRIVATE (viewable);
if (private->reallocate_width != 0 &&
private->reallocate_height != 0)
{
*width = private->reallocate_width;
*height = private->reallocate_height;
return TRUE;
}
Bug 777017 - creating an empty layer group inside an existing... ...layer group cause a bug in the existing layer size Change gimp_group_layer_get_size() to return FALSE if there are no children (there is no content). In gimp_group_layer_update_size(), skip children where get_size() returns FALSE. Fixes bogus size calculation.
2017-01-16 03:58:32 +08:00
/* return the size only if there are children... */
if (gimp_item_stack_get_item_iter (GIMP_ITEM_STACK (private->children)))
return GIMP_VIEWABLE_CLASS (parent_class)->get_size (viewable,
width, height);
/* ...otherwise return "no content" */
return FALSE;
app: fake the size of a gruop layer by overriding GimpViewable::get_size() instead of messing with GimpItem's width and height members.
2011-03-09 01:04:23 +08:00
}
Add a GimpGroupLayer class (not used yet)
2009-08-04 05:24:46 +08:00
static GimpContainer *
gimp_group_layer_get_children (GimpViewable *viewable)
{
app: move all GimpGroupLayer members to a private struct
2011-02-04 05:29:25 +08:00
return GET_PRIVATE (viewable)->children;
Bug 616416: hidden layer groups appear again after an image change Introduced two virtual functions to a GimpViewable 'set_expanded' and 'get_expanded' and a PROP_GROUP_ITEM_FLAGS to load/save the expanded state of layer_groups and use them.
2011-09-26 03:57:20 +08:00
}
static gboolean
gimp_group_layer_get_expanded (GimpViewable *viewable)
{
GimpGroupLayer *group = GIMP_GROUP_LAYER (viewable);
return GET_PRIVATE (group)->expanded;
}
static void
gimp_group_layer_set_expanded (GimpViewable *viewable,
gboolean expanded)
{
app: respond to viewable expanded state changes in container views Add an "expanded-changed" signal to GimpViewable, which should be emitted by subclasses when the viewable's expanded state changes. Emit this signal when the expanded state of group layers changes. Respond to this signal in GimpContainerView, by calling a new expand_item() virtual function. Implement expand_item() in GimpContainerTreeView, expanding or collapsing the item as necessary.
2017-10-22 23:50:37 +08:00
GimpGroupLayerPrivate *private = GET_PRIVATE (viewable);
Bug 616416: hidden layer groups appear again after an image change Introduced two virtual functions to a GimpViewable 'set_expanded' and 'get_expanded' and a PROP_GROUP_ITEM_FLAGS to load/save the expanded state of layer_groups and use them.
2011-09-26 03:57:20 +08:00
app: respond to viewable expanded state changes in container views Add an "expanded-changed" signal to GimpViewable, which should be emitted by subclasses when the viewable's expanded state changes. Emit this signal when the expanded state of group layers changes. Respond to this signal in GimpContainerView, by calling a new expand_item() virtual function. Implement expand_item() in GimpContainerTreeView, expanding or collapsing the item as necessary.
2017-10-22 23:50:37 +08:00
if (private->expanded != expanded)
{
private->expanded = expanded;
gimp_viewable_expanded_changed (viewable);
}
Add a GimpGroupLayer class (not used yet)
2009-08-04 05:24:46 +08:00
}
Bug 674160 - Redesign of "Lock panel" Apply and heavily modify patch from remyDev which adds "lock position" to GimpItem, similar to "lock content". Lock position disables all sorts of translation and transform, from the GUI and the PDB. Cleaned up some aspects of the lock content code as well because a second instance of similar code always shows what went wrong the first time.
2012-11-09 18:17:25 +08:00
static gboolean
app: remove const qualifiers from all object parameters They are unreliable because every type checking cast discards them, they are useless anyway, visual clutter, added inconsistently, and generally suck. Wanted to do this a long time ago, it was a bad idea in the first place.
2016-05-20 05:51:44 +08:00
gimp_group_layer_is_position_locked (GimpItem *item)
Bug 674160 - Redesign of "Lock panel" Apply and heavily modify patch from remyDev which adds "lock position" to GimpItem, similar to "lock content". Lock position disables all sorts of translation and transform, from the GUI and the PDB. Cleaned up some aspects of the lock content code as well because a second instance of similar code always shows what went wrong the first time.
2012-11-09 18:17:25 +08:00
{
GimpGroupLayerPrivate *private = GET_PRIVATE (item);
GList *list;
for (list = gimp_item_stack_get_item_iter (GIMP_ITEM_STACK (private->children));
list;
list = g_list_next (list))
{
GimpItem *child = list->data;
if (gimp_item_is_position_locked (child))
return TRUE;
}
return GIMP_ITEM_CLASS (parent_class)->is_position_locked (item);
}
Add a GimpGroupLayer class (not used yet)
2009-08-04 05:24:46 +08:00
static GimpItem *
gimp_group_layer_duplicate (GimpItem *item,
GType new_type)
{
GimpItem *new_item;
Fix precondition check when duplicating group layers (gimp_group_layer_duplicate): change the allowed type of the duplicate from GIMP_TYPE_GROUP_LAYER to GIMP_TYPE_DRAWABLE. The former was simply a braino when copying and modifying the GimpLayer code.
2009-09-22 00:41:54 +08:00
g_return_val_if_fail (g_type_is_a (new_type, GIMP_TYPE_DRAWABLE), NULL);
Add a GimpGroupLayer class (not used yet)
2009-08-04 05:24:46 +08:00
new_item = GIMP_ITEM_CLASS (parent_class)->duplicate (item, new_type);
if (GIMP_IS_GROUP_LAYER (new_item))
{
app: move all GimpGroupLayer members to a private struct
2011-02-04 05:29:25 +08:00
GimpGroupLayerPrivate *private = GET_PRIVATE (item);
GimpGroupLayer *new_group = GIMP_GROUP_LAYER (new_item);
GimpGroupLayerPrivate *new_private = GET_PRIVATE (new_item);
gint position = 0;
GList *list;
Add a GimpGroupLayer class (not used yet)
2009-08-04 05:24:46 +08:00
Fix and optimize gimp_group_layer_duplicate() Make sure the duplicated group layer actually has a properly set up tile manager taken from its projection, and not just a dumb copy of the original group's tiles. Also optimizes away useless calls to gimp_group_layer_update_size().
2009-09-22 04:36:26 +08:00
gimp_group_layer_suspend_resize (new_group, FALSE);
app: move all GimpGroupLayer members to a private struct
2011-02-04 05:29:25 +08:00
for (list = gimp_item_stack_get_item_iter (GIMP_ITEM_STACK (private->children));
Add a GimpGroupLayer class (not used yet)
2009-08-04 05:24:46 +08:00
list;
Use gimp_item_stack_get_item_iter(stack) instead of GIMP_LIST(stack)->list
2009-08-27 18:26:14 +08:00
list = g_list_next (list))
Add a GimpGroupLayer class (not used yet)
2009-08-04 05:24:46 +08:00
{
Don't spoil the names of duplicated groups' children with "copy"s
2009-08-25 22:05:39 +08:00
GimpItem *child = list->data;
GimpItem *new_child;
GimpLayerMask *mask;
Add a GimpGroupLayer class (not used yet)
2009-08-04 05:24:46 +08:00
new_child = gimp_item_duplicate (child, G_TYPE_FROM_INSTANCE (child));
Don't spoil the names of duplicated groups' children with "copy"s
2009-08-25 22:05:39 +08:00
gimp_object_set_name (GIMP_OBJECT (new_child),
Remove GIMP_OBJECT() casts when calling gimp_object_get_name()
2009-09-01 04:47:18 +08:00
gimp_object_get_name (child));
Don't spoil the names of duplicated groups' children with "copy"s
2009-08-25 22:05:39 +08:00
mask = gimp_layer_get_mask (GIMP_LAYER (child));
if (mask)
{
GimpLayerMask *new_mask;
new_mask = gimp_layer_get_mask (GIMP_LAYER (new_child));
gimp_object_set_name (GIMP_OBJECT (new_mask),
Remove GIMP_OBJECT() casts when calling gimp_object_get_name()
2009-09-01 04:47:18 +08:00
gimp_object_get_name (mask));
Don't spoil the names of duplicated groups' children with "copy"s
2009-08-25 22:05:39 +08:00
}
Some group layer fixes - call new group layers "Group Layer" by default. - when duplicating, don't forget to set the duplicated childrens' parent viewable.
2009-08-04 06:14:53 +08:00
gimp_viewable_set_parent (GIMP_VIEWABLE (new_child),
Change local variable names from "layer" to "group"
2009-08-24 06:34:12 +08:00
GIMP_VIEWABLE (new_group));
Some group layer fixes - call new group layers "Group Layer" by default. - when duplicating, don't forget to set the duplicated childrens' parent viewable.
2009-08-04 06:14:53 +08:00
app: move all GimpGroupLayer members to a private struct
2011-02-04 05:29:25 +08:00
gimp_container_insert (new_private->children,
Add a GimpGroupLayer class (not used yet)
2009-08-04 05:24:46 +08:00
GIMP_OBJECT (new_child),
Use gimp_item_stack_get_item_iter(stack) instead of GIMP_LIST(stack)->list
2009-08-27 18:26:14 +08:00
position++);
Add a GimpGroupLayer class (not used yet)
2009-08-04 05:24:46 +08:00
}
Fix and optimize gimp_group_layer_duplicate() Make sure the duplicated group layer actually has a properly set up tile manager taken from its projection, and not just a dumb copy of the original group's tiles. Also optimizes away useless calls to gimp_group_layer_update_size().
2009-09-22 04:36:26 +08:00
app: fake the size of a gruop layer by overriding GimpViewable::get_size() instead of messing with GimpItem's width and height members.
2011-03-09 01:04:23 +08:00
/* force the projection to reallocate itself */
GET_PRIVATE (new_group)->reallocate_projection = TRUE;
Fix and optimize gimp_group_layer_duplicate() Make sure the duplicated group layer actually has a properly set up tile manager taken from its projection, and not just a dumb copy of the original group's tiles. Also optimizes away useless calls to gimp_group_layer_update_size().
2009-09-22 04:36:26 +08:00
gimp_group_layer_resume_resize (new_group, FALSE);
Add a GimpGroupLayer class (not used yet)
2009-08-04 05:24:46 +08:00
}
return new_item;
}
Add naive and wrong version of GimpItem::convert() That code will fail badly when dropping layer groups between images of different types, but will at least work between two RGB images.
2009-08-25 20:23:42 +08:00
static void
gimp_group_layer_convert (GimpItem *item,
app: add "gboolean convert_profile" to GimpDrawable::convert_type() also add "GType old_type" to GimpItem::convert() so implementations can do things depending on the type of the original item. In gimp_layer_convert(), if the original item is also a layer, and color management is not off (with a FIXME because this is the wrong check), pass convert_profile = TRUE to gimp_drawable_convert_type(). There is no color profile conversion anywhere behind this, this is just an API change commit.
2015-08-16 21:47:43 +08:00
GimpImage *dest_image,
GType old_type)
Add naive and wrong version of GimpItem::convert() That code will fail badly when dropping layer groups between images of different types, but will at least work between two RGB images.
2009-08-25 20:23:42 +08:00
{
app: move all GimpGroupLayer members to a private struct
2011-02-04 05:29:25 +08:00
GimpGroupLayerPrivate *private = GET_PRIVATE (item);
GList *list;
Add naive and wrong version of GimpItem::convert() That code will fail badly when dropping layer groups between images of different types, but will at least work between two RGB images.
2009-08-25 20:23:42 +08:00
app: move all GimpGroupLayer members to a private struct
2011-02-04 05:29:25 +08:00
for (list = gimp_item_stack_get_item_iter (GIMP_ITEM_STACK (private->children));
Add naive and wrong version of GimpItem::convert() That code will fail badly when dropping layer groups between images of different types, but will at least work between two RGB images.
2009-08-25 20:23:42 +08:00
list;
list = g_list_next (list))
{
GimpItem *child = list->data;
app: add "gboolean convert_profile" to GimpDrawable::convert_type() also add "GType old_type" to GimpItem::convert() so implementations can do things depending on the type of the original item. In gimp_layer_convert(), if the original item is also a layer, and color management is not off (with a FIXME because this is the wrong check), pass convert_profile = TRUE to gimp_drawable_convert_type(). There is no color profile conversion anywhere behind this, this is just an API change commit.
2015-08-16 21:47:43 +08:00
GIMP_ITEM_GET_CLASS (child)->convert (child, dest_image,
G_TYPE_FROM_INSTANCE (child));
Add naive and wrong version of GimpItem::convert() That code will fail badly when dropping layer groups between images of different types, but will at least work between two RGB images.
2009-08-25 20:23:42 +08:00
}
app: add "gboolean convert_profile" to GimpDrawable::convert_type() also add "GType old_type" to GimpItem::convert() so implementations can do things depending on the type of the original item. In gimp_layer_convert(), if the original item is also a layer, and color management is not off (with a FIXME because this is the wrong check), pass convert_profile = TRUE to gimp_drawable_convert_type(). There is no color profile conversion anywhere behind this, this is just an API change commit.
2015-08-16 21:47:43 +08:00
GIMP_ITEM_CLASS (parent_class)->convert (item, dest_image, old_type);
Add naive and wrong version of GimpItem::convert() That code will fail badly when dropping layer groups between images of different types, but will at least work between two RGB images.
2009-08-25 20:23:42 +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
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 (GimpItem *item,
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
gboolean push_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
_gimp_group_layer_start_transform (GIMP_GROUP_LAYER (item), push_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
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
if (GIMP_ITEM_CLASS (parent_class)->start_transform)
GIMP_ITEM_CLASS (parent_class)->start_transform (item, push_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
}
static void
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 (GimpItem *item,
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
gboolean push_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
if (GIMP_ITEM_CLASS (parent_class)->end_transform)
GIMP_ITEM_CLASS (parent_class)->end_transform (item, push_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
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 (GIMP_GROUP_LAYER (item), push_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
}
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
static void
gimp_group_layer_resize (GimpItem *item,
GimpContext *context,
GimpFillType fill_type,
gint new_width,
gint new_height,
gint offset_x,
gint offset_y)
{
GimpGroupLayer *group = GIMP_GROUP_LAYER (item);
GimpGroupLayerPrivate *private = GET_PRIVATE (item);
GList *list;
gint x, y;
/* we implement GimpItem::resize(), instead of GimpLayer::resize(), so that
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
* GimpLayer doesn't resize the mask. note that gimp_item_resize() calls
* gimp_item_{start,end}_move(), and not gimp_item_{start,end}_transform(),
* so that mask resizing is handled by gimp_group_layer_update_size().
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
*/
x = gimp_item_get_offset_x (item) - offset_x;
y = gimp_item_get_offset_y (item) - offset_y;
gimp_group_layer_suspend_resize (group, TRUE);
list = gimp_item_stack_get_item_iter (GIMP_ITEM_STACK (private->children));
while (list)
{
GimpItem *child = list->data;
gint child_width;
gint child_height;
gint child_x;
gint child_y;
list = g_list_next (list);
if (gimp_rectangle_intersect (x,
y,
new_width,
new_height,
gimp_item_get_offset_x (child),
gimp_item_get_offset_y (child),
gimp_item_get_width (child),
gimp_item_get_height (child),
&child_x,
&child_y,
&child_width,
&child_height))
{
gint child_offset_x = gimp_item_get_offset_x (child) - child_x;
gint child_offset_y = gimp_item_get_offset_y (child) - child_y;
gimp_item_resize (child, context, fill_type,
child_width, child_height,
child_offset_x, child_offset_y);
}
else if (gimp_item_is_attached (item))
{
gimp_image_remove_layer (gimp_item_get_image (item),
GIMP_LAYER (child),
TRUE, NULL);
}
else
{
gimp_container_remove (private->children, GIMP_OBJECT (child));
}
}
gimp_group_layer_resume_resize (group, TRUE);
}
app: add virtual transform/type-conversion functions to GimpLayer The GimpLayer implementation of the GimpItem transform functions, and the GimpDrawable convert_type() function, apply their operation to both the layer and its mask. The subclasses of GimpLayer -- GimpGroupLayer and GimpTextLayer -- override some of these functions, providing their own logic for the layer part, and duplicating the mask part. Avoid this duplication by adding a set of virtual transform and type-conversion functions to GimpLayer. Have the GimpLayer implementaion of the corresponding GimpItem and GimpDrawable functions use these functions to apply the operation to the layer, while taking care of the mask themselves. Have GimpLayer's subclasses override the new virtual functions, instead of the GimpItem and GimpDrawable ones. Note that the existing implementation of convert_type() in GimpTextLayer neglected to convert the mask, hence text layer masks retained their old format after conversion. This issue is fixed as a side effect of this commit.
2017-06-17 08:15:56 +08:00
static gint64
gimp_group_layer_estimate_memsize (GimpDrawable *drawable,
GimpComponentType component_type,
gint width,
gint height)
Implement GimpItem's transform methods Add implementations for GimpItem::translate(), scale(), resize(), flip(), rotate() and transform(). Simply transform all children, the group layer will automatically update itself. Also transform the layer mask.
2009-08-25 01:33:29 +08:00
{
app: add virtual transform/type-conversion functions to GimpLayer The GimpLayer implementation of the GimpItem transform functions, and the GimpDrawable convert_type() function, apply their operation to both the layer and its mask. The subclasses of GimpLayer -- GimpGroupLayer and GimpTextLayer -- override some of these functions, providing their own logic for the layer part, and duplicating the mask part. Avoid this duplication by adding a set of virtual transform and type-conversion functions to GimpLayer. Have the GimpLayer implementaion of the corresponding GimpItem and GimpDrawable functions use these functions to apply the operation to the layer, while taking care of the mask themselves. Have GimpLayer's subclasses override the new virtual functions, instead of the GimpItem and GimpDrawable ones. Note that the existing implementation of convert_type() in GimpTextLayer neglected to convert the mask, hence text layer masks retained their old format after conversion. This issue is fixed as a side effect of this commit.
2017-06-17 08:15:56 +08:00
GimpGroupLayerPrivate *private = GET_PRIVATE (drawable);
app: move all GimpGroupLayer members to a private struct
2011-02-04 05:29:25 +08:00
GList *list;
app: add virtual transform/type-conversion functions to GimpLayer The GimpLayer implementation of the GimpItem transform functions, and the GimpDrawable convert_type() function, apply their operation to both the layer and its mask. The subclasses of GimpLayer -- GimpGroupLayer and GimpTextLayer -- override some of these functions, providing their own logic for the layer part, and duplicating the mask part. Avoid this duplication by adding a set of virtual transform and type-conversion functions to GimpLayer. Have the GimpLayer implementaion of the corresponding GimpItem and GimpDrawable functions use these functions to apply the operation to the layer, while taking care of the mask themselves. Have GimpLayer's subclasses override the new virtual functions, instead of the GimpItem and GimpDrawable ones. Note that the existing implementation of convert_type() in GimpTextLayer neglected to convert the mask, hence text layer masks retained their old format after conversion. This issue is fixed as a side effect of this commit.
2017-06-17 08:15:56 +08:00
GimpImageBaseType base_type;
gint64 memsize = 0;
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: move all GimpGroupLayer members to a private struct
2011-02-04 05:29:25 +08:00
for (list = gimp_item_stack_get_item_iter (GIMP_ITEM_STACK (private->children));
Implement GimpItem's transform methods Add implementations for GimpItem::translate(), scale(), resize(), flip(), rotate() and transform(). Simply transform all children, the group layer will automatically update itself. Also transform the layer mask.
2009-08-25 01:33:29 +08:00
list;
list = g_list_next (list))
{
app: add virtual transform/type-conversion functions to GimpLayer The GimpLayer implementation of the GimpItem transform functions, and the GimpDrawable convert_type() function, apply their operation to both the layer and its mask. The subclasses of GimpLayer -- GimpGroupLayer and GimpTextLayer -- override some of these functions, providing their own logic for the layer part, and duplicating the mask part. Avoid this duplication by adding a set of virtual transform and type-conversion functions to GimpLayer. Have the GimpLayer implementaion of the corresponding GimpItem and GimpDrawable functions use these functions to apply the operation to the layer, while taking care of the mask themselves. Have GimpLayer's subclasses override the new virtual functions, instead of the GimpItem and GimpDrawable ones. Note that the existing implementation of convert_type() in GimpTextLayer neglected to convert the mask, hence text layer masks retained their old format after conversion. This issue is fixed as a side effect of this commit.
2017-06-17 08:15:56 +08:00
GimpDrawable *child = list->data;
gint child_width;
gint child_height;
Implement GimpItem's transform methods Add implementations for GimpItem::translate(), scale(), resize(), flip(), rotate() and transform(). Simply transform all children, the group layer will automatically update itself. Also transform the layer mask.
2009-08-25 01:33:29 +08:00
app: add virtual transform/type-conversion functions to GimpLayer The GimpLayer implementation of the GimpItem transform functions, and the GimpDrawable convert_type() function, apply their operation to both the layer and its mask. The subclasses of GimpLayer -- GimpGroupLayer and GimpTextLayer -- override some of these functions, providing their own logic for the layer part, and duplicating the mask part. Avoid this duplication by adding a set of virtual transform and type-conversion functions to GimpLayer. Have the GimpLayer implementaion of the corresponding GimpItem and GimpDrawable functions use these functions to apply the operation to the layer, while taking care of the mask themselves. Have GimpLayer's subclasses override the new virtual functions, instead of the GimpItem and GimpDrawable ones. Note that the existing implementation of convert_type() in GimpTextLayer neglected to convert the mask, hence text layer masks retained their old format after conversion. This issue is fixed as a side effect of this commit.
2017-06-17 08:15:56 +08:00
child_width = (gimp_item_get_width (GIMP_ITEM (child)) *
width /
gimp_item_get_width (GIMP_ITEM (drawable)));
child_height = (gimp_item_get_height (GIMP_ITEM (child)) *
height /
gimp_item_get_height (GIMP_ITEM (drawable)));
memsize += gimp_drawable_estimate_memsize (child,
component_type,
child_width,
child_height);
Implement GimpItem's transform methods Add implementations for GimpItem::translate(), scale(), resize(), flip(), rotate() and transform(). Simply transform all children, the group layer will automatically update itself. Also transform the layer mask.
2009-08-25 01:33:29 +08:00
}
app: add virtual transform/type-conversion functions to GimpLayer The GimpLayer implementation of the GimpItem transform functions, and the GimpDrawable convert_type() function, apply their operation to both the layer and its mask. The subclasses of GimpLayer -- GimpGroupLayer and GimpTextLayer -- override some of these functions, providing their own logic for the layer part, and duplicating the mask part. Avoid this duplication by adding a set of virtual transform and type-conversion functions to GimpLayer. Have the GimpLayer implementaion of the corresponding GimpItem and GimpDrawable functions use these functions to apply the operation to the layer, while taking care of the mask themselves. Have GimpLayer's subclasses override the new virtual functions, instead of the GimpItem and GimpDrawable ones. Note that the existing implementation of convert_type() in GimpTextLayer neglected to convert the mask, hence text layer masks retained their old format after conversion. This issue is fixed as a side effect of this commit.
2017-06-17 08:15:56 +08:00
base_type = gimp_drawable_get_base_type (drawable);
Implement GimpItem's transform methods Add implementations for GimpItem::translate(), scale(), resize(), flip(), rotate() and transform(). Simply transform all children, the group layer will automatically update itself. Also transform the layer mask.
2009-08-25 01:33:29 +08:00
app: add virtual transform/type-conversion functions to GimpLayer The GimpLayer implementation of the GimpItem transform functions, and the GimpDrawable convert_type() function, apply their operation to both the layer and its mask. The subclasses of GimpLayer -- GimpGroupLayer and GimpTextLayer -- override some of these functions, providing their own logic for the layer part, and duplicating the mask part. Avoid this duplication by adding a set of virtual transform and type-conversion functions to GimpLayer. Have the GimpLayer implementaion of the corresponding GimpItem and GimpDrawable functions use these functions to apply the operation to the layer, while taking care of the mask themselves. Have GimpLayer's subclasses override the new virtual functions, instead of the GimpItem and GimpDrawable ones. Note that the existing implementation of convert_type() in GimpTextLayer neglected to convert the mask, hence text layer masks retained their old format after conversion. This issue is fixed as a side effect of this commit.
2017-06-17 08:15:56 +08:00
memsize += gimp_projection_estimate_memsize (base_type, component_type,
width, height);
return memsize +
GIMP_DRAWABLE_CLASS (parent_class)->estimate_memsize (drawable,
component_type,
width, height);
}
static void
gimp_group_layer_translate (GimpLayer *layer,
gint offset_x,
gint offset_y)
{
GimpGroupLayer *group = GIMP_GROUP_LAYER (layer);
GimpGroupLayerPrivate *private = GET_PRIVATE (layer);
app: avoid re-rendering group layers upon translation When translating group layers, there's no need to re-render the group's projection -- we can simply update the group's offset (and offset node) directly, and redirect any layer-stack "update" signals to the group's drawable. This significantly improves performance when moving groups.
2018-08-04 01:10:37 +08:00
gint x, y;
app: add virtual transform/type-conversion functions to GimpLayer The GimpLayer implementation of the GimpItem transform functions, and the GimpDrawable convert_type() function, apply their operation to both the layer and its mask. The subclasses of GimpLayer -- GimpGroupLayer and GimpTextLayer -- override some of these functions, providing their own logic for the layer part, and duplicating the mask part. Avoid this duplication by adding a set of virtual transform and type-conversion functions to GimpLayer. Have the GimpLayer implementaion of the corresponding GimpItem and GimpDrawable functions use these functions to apply the operation to the layer, while taking care of the mask themselves. Have GimpLayer's subclasses override the new virtual functions, instead of the GimpItem and GimpDrawable ones. Note that the existing implementation of convert_type() in GimpTextLayer neglected to convert the mask, hence text layer masks retained their old format after conversion. This issue is fixed as a side effect of this commit.
2017-06-17 08:15:56 +08:00
GList *list;
Implement GimpItem's transform methods Add implementations for GimpItem::translate(), scale(), resize(), flip(), rotate() and transform(). Simply transform all children, the group layer will automatically update itself. Also transform the layer mask.
2009-08-25 01:33:29 +08:00
app: avoid re-rendering group layers upon translation When translating group layers, there's no need to re-render the group's projection -- we can simply update the group's offset (and offset node) directly, and redirect any layer-stack "update" signals to the group's drawable. This significantly improves performance when moving groups.
2018-08-04 01:10:37 +08:00
/* don't use gimp_group_layer_suspend_resize(), but rather increment
* private->suspend_resize directly, since we're translating the group layer
* here, rather than relying on gimp_group_layer_update_size() to do it.
*/
private->suspend_resize++;
/* redirect stack updates to the drawable, rather than to the projection */
private->direct_update++;
gimp_item_get_offset (GIMP_ITEM (group), &x, &y);
x += offset_x;
y += offset_y;
/* update the offset node */
if (private->offset_node)
gegl_node_set (private->offset_node,
"x", (gdouble) -x,
"y", (gdouble) -y,
NULL);
/* invalidate the selection boundary because of a layer modification */
gimp_drawable_invalidate_boundary (GIMP_DRAWABLE (layer));
/* update the group layer offset */
gimp_item_set_offset (GIMP_ITEM (group), x, y);
app: add virtual transform/type-conversion functions to GimpLayer The GimpLayer implementation of the GimpItem transform functions, and the GimpDrawable convert_type() function, apply their operation to both the layer and its mask. The subclasses of GimpLayer -- GimpGroupLayer and GimpTextLayer -- override some of these functions, providing their own logic for the layer part, and duplicating the mask part. Avoid this duplication by adding a set of virtual transform and type-conversion functions to GimpLayer. Have the GimpLayer implementaion of the corresponding GimpItem and GimpDrawable functions use these functions to apply the operation to the layer, while taking care of the mask themselves. Have GimpLayer's subclasses override the new virtual functions, instead of the GimpItem and GimpDrawable ones. Note that the existing implementation of convert_type() in GimpTextLayer neglected to convert the mask, hence text layer masks retained their old format after conversion. This issue is fixed as a side effect of this commit.
2017-06-17 08:15:56 +08:00
for (list = gimp_item_stack_get_item_iter (GIMP_ITEM_STACK (private->children));
list;
list = g_list_next (list))
{
GimpItem *child = list->data;
Implement GimpItem's transform methods Add implementations for GimpItem::translate(), scale(), resize(), flip(), rotate() and transform(). Simply transform all children, the group layer will automatically update itself. Also transform the layer mask.
2009-08-25 01:33:29 +08:00
app: add virtual transform/type-conversion functions to GimpLayer The GimpLayer implementation of the GimpItem transform functions, and the GimpDrawable convert_type() function, apply their operation to both the layer and its mask. The subclasses of GimpLayer -- GimpGroupLayer and GimpTextLayer -- override some of these functions, providing their own logic for the layer part, and duplicating the mask part. Avoid this duplication by adding a set of virtual transform and type-conversion functions to GimpLayer. Have the GimpLayer implementaion of the corresponding GimpItem and GimpDrawable functions use these functions to apply the operation to the layer, while taking care of the mask themselves. Have GimpLayer's subclasses override the new virtual functions, instead of the GimpItem and GimpDrawable ones. Note that the existing implementation of convert_type() in GimpTextLayer neglected to convert the mask, hence text layer masks retained their old format after conversion. This issue is fixed as a side effect of this commit.
2017-06-17 08:15:56 +08:00
/* don't push an undo here because undo will call us again */
gimp_item_translate (child, offset_x, offset_y, FALSE);
Implement GimpItem's transform methods Add implementations for GimpItem::translate(), scale(), resize(), flip(), rotate() and transform(). Simply transform all children, the group layer will automatically update itself. Also transform the layer mask.
2009-08-25 01:33:29 +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
app: avoid re-rendering group layers upon translation When translating group layers, there's no need to re-render the group's projection -- we can simply update the group's offset (and offset node) directly, and redirect any layer-stack "update" signals to the group's drawable. This significantly improves performance when moving groups.
2018-08-04 01:10:37 +08:00
/* redirect stack updates back to the projection */
private->direct_update--;
/* don't use gimp_group_layer_resume_resize(), but rather decrement
* private->suspend_resize directly, so that gimp_group_layer_update_size()
* isn't called.
*/
private->suspend_resize--;
Implement GimpItem's transform methods Add implementations for GimpItem::translate(), scale(), resize(), flip(), rotate() and transform(). Simply transform all children, the group layer will automatically update itself. Also transform the layer mask.
2009-08-25 01:33:29 +08:00
}
static void
app: add virtual transform/type-conversion functions to GimpLayer The GimpLayer implementation of the GimpItem transform functions, and the GimpDrawable convert_type() function, apply their operation to both the layer and its mask. The subclasses of GimpLayer -- GimpGroupLayer and GimpTextLayer -- override some of these functions, providing their own logic for the layer part, and duplicating the mask part. Avoid this duplication by adding a set of virtual transform and type-conversion functions to GimpLayer. Have the GimpLayer implementaion of the corresponding GimpItem and GimpDrawable functions use these functions to apply the operation to the layer, while taking care of the mask themselves. Have GimpLayer's subclasses override the new virtual functions, instead of the GimpItem and GimpDrawable ones. Note that the existing implementation of convert_type() in GimpTextLayer neglected to convert the mask, hence text layer masks retained their old format after conversion. This issue is fixed as a side effect of this commit.
2017-06-17 08:15:56 +08:00
gimp_group_layer_scale (GimpLayer *layer,
Implement GimpItem's transform methods Add implementations for GimpItem::translate(), scale(), resize(), flip(), rotate() and transform(). Simply transform all children, the group layer will automatically update itself. Also transform the layer mask.
2009-08-25 01:33:29 +08:00
gint new_width,
gint new_height,
gint new_offset_x,
gint new_offset_y,
GimpInterpolationType interpolation_type,
GimpProgress *progress)
{
app: add virtual transform/type-conversion functions to GimpLayer The GimpLayer implementation of the GimpItem transform functions, and the GimpDrawable convert_type() function, apply their operation to both the layer and its mask. The subclasses of GimpLayer -- GimpGroupLayer and GimpTextLayer -- override some of these functions, providing their own logic for the layer part, and duplicating the mask part. Avoid this duplication by adding a set of virtual transform and type-conversion functions to GimpLayer. Have the GimpLayer implementaion of the corresponding GimpItem and GimpDrawable functions use these functions to apply the operation to the layer, while taking care of the mask themselves. Have GimpLayer's subclasses override the new virtual functions, instead of the GimpItem and GimpDrawable ones. Note that the existing implementation of convert_type() in GimpTextLayer neglected to convert the mask, hence text layer masks retained their old format after conversion. This issue is fixed as a side effect of this commit.
2017-06-17 08:15:56 +08:00
GimpGroupLayer *group = GIMP_GROUP_LAYER (layer);
GimpGroupLayerPrivate *private = GET_PRIVATE (layer);
GimpItem *item = GIMP_ITEM (layer);
app: use GimpObjectQueue in lots of places Use GimpObjectQueue, added in the previous commit, in various instances where we perform an action on a set of objects. This improves progress reporting, by using a single progress for the entire operation, rather than reporting the progress of each object individually, and by taking the relative cost of each object into account, instead of assuming a uniform cost for all objects. In particular, this affects the various whole-image operations (i.e., transformations and color conversions), operations on linked items, and operations on layer groups. This also affects layers with masks, whose progress is now reported together instead of individually. Additionally, this commit fixes erroneous group-layer mask cropping during undo when resizing the image, by properly calling {start,end}_move() on all the resized layers before starting the operation, and when scaling the image, by only scaling top-level layers, and letting group layers scale their children themselves.
2018-03-25 22:18:46 +08:00
GimpObjectQueue *queue = NULL;
app: move all GimpGroupLayer members to a private struct
2011-02-04 05:29:25 +08:00
GList *list;
gdouble width_factor;
gdouble height_factor;
gint old_offset_x;
gint old_offset_y;
Fix gimp_group_layer_scale() to do the right thing Scale all children in relation to the group layer's old and new size and offset. The group itself will follow the childrens' sizes.
2009-08-25 20:26:26 +08:00
width_factor = (gdouble) new_width / (gdouble) gimp_item_get_width (item);
height_factor = (gdouble) new_height / (gdouble) gimp_item_get_height (item);
old_offset_x = gimp_item_get_offset_x (item);
old_offset_y = gimp_item_get_offset_y (item);
Implement GimpItem's transform methods Add implementations for GimpItem::translate(), scale(), resize(), flip(), rotate() and transform(). Simply transform all children, the group layer will automatically update itself. Also transform the layer mask.
2009-08-25 01:33:29 +08:00
app: use GimpObjectQueue in lots of places Use GimpObjectQueue, added in the previous commit, in various instances where we perform an action on a set of objects. This improves progress reporting, by using a single progress for the entire operation, rather than reporting the progress of each object individually, and by taking the relative cost of each object into account, instead of assuming a uniform cost for all objects. In particular, this affects the various whole-image operations (i.e., transformations and color conversions), operations on linked items, and operations on layer groups. This also affects layers with masks, whose progress is now reported together instead of individually. Additionally, this commit fixes erroneous group-layer mask cropping during undo when resizing the image, by properly calling {start,end}_move() on all the resized layers before starting the operation, and when scaling the image, by only scaling top-level layers, and letting group layers scale their children themselves.
2018-03-25 22:18:46 +08:00
if (progress)
{
queue = gimp_object_queue_new (progress);
progress = GIMP_PROGRESS (queue);
gimp_object_queue_push_container (queue, private->children);
}
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_group_layer_suspend_resize (group, TRUE);
app: move all GimpGroupLayer members to a private struct
2011-02-04 05:29:25 +08:00
list = gimp_item_stack_get_item_iter (GIMP_ITEM_STACK (private->children));
When scaling a group layer, remove children that are scaled away When a child's width or height becomes < 1, remove it rather than trying to scale it to impossible dimensions.
2009-08-27 17:53:47 +08:00
while (list)
Implement GimpItem's transform methods Add implementations for GimpItem::translate(), scale(), resize(), flip(), rotate() and transform(). Simply transform all children, the group layer will automatically update itself. Also transform the layer mask.
2009-08-25 01:33:29 +08:00
{
GimpItem *child = list->data;
Fix gimp_group_layer_scale() to do the right thing Scale all children in relation to the group layer's old and new size and offset. The group itself will follow the childrens' sizes.
2009-08-25 20:26:26 +08:00
When scaling a group layer, remove children that are scaled away When a child's width or height becomes < 1, remove it rather than trying to scale it to impossible dimensions.
2009-08-27 17:53:47 +08:00
list = g_list_next (list);
app: use GimpObjectQueue in lots of places Use GimpObjectQueue, added in the previous commit, in various instances where we perform an action on a set of objects. This improves progress reporting, by using a single progress for the entire operation, rather than reporting the progress of each object individually, and by taking the relative cost of each object into account, instead of assuming a uniform cost for all objects. In particular, this affects the various whole-image operations (i.e., transformations and color conversions), operations on linked items, and operations on layer groups. This also affects layers with masks, whose progress is now reported together instead of individually. Additionally, this commit fixes erroneous group-layer mask cropping during undo when resizing the image, by properly calling {start,end}_move() on all the resized layers before starting the operation, and when scaling the image, by only scaling top-level layers, and letting group layers scale their children themselves.
2018-03-25 22:18:46 +08:00
if (queue)
gimp_object_queue_pop (queue);
app: round layer bounds to global pixel grid when scaling image/group Add gimp_item_scale_by_factors_with_origin(), which is an extension of gimp_item_scale_by_factors(), taking the input/output points of origin for the transformation (both of which are (0, 0) in the case of gimp_item_scale_by_factors()). Implement gimp_item_scale_by_factors() in terms of the new function, and Use the new function when scaling group layers, instead of manually calculating the children boundaries, so that the behavior is uniform across whole-image scaling and group-layer scaling. The new function rounds all four edges of the boundary to the image-global pixel grid, instead of only rounding the top/left edges to the global grid, and the bottom/right edges to the item- local grid. This preserves layer-adjacency when scaling.
2018-03-25 23:20:14 +08:00
if (! gimp_item_scale_by_factors_with_origin (child,
width_factor, height_factor,
old_offset_x, old_offset_y,
new_offset_x, new_offset_y,
interpolation_type,
progress))
When scaling a group layer, remove children that are scaled away When a child's width or height becomes < 1, remove it rather than trying to scale it to impossible dimensions.
2009-08-27 17:53:47 +08:00
{
app: round layer bounds to global pixel grid when scaling image/group Add gimp_item_scale_by_factors_with_origin(), which is an extension of gimp_item_scale_by_factors(), taking the input/output points of origin for the transformation (both of which are (0, 0) in the case of gimp_item_scale_by_factors()). Implement gimp_item_scale_by_factors() in terms of the new function, and Use the new function when scaling group layers, instead of manually calculating the children boundaries, so that the behavior is uniform across whole-image scaling and group-layer scaling. The new function rounds all four edges of the boundary to the image-global pixel grid, instead of only rounding the top/left edges to the global grid, and the bottom/right edges to the item- local grid. This preserves layer-adjacency when scaling.
2018-03-25 23:20:14 +08:00
/* new width or height are 0; remove item */
if (gimp_item_is_attached (item))
{
gimp_image_remove_layer (gimp_item_get_image (item),
GIMP_LAYER (child),
TRUE, NULL);
}
else
{
gimp_container_remove (private->children, GIMP_OBJECT (child));
}
When scaling a group layer, remove children that are scaled away When a child's width or height becomes < 1, remove it rather than trying to scale it to impossible dimensions.
2009-08-27 17:53:47 +08:00
}
Implement GimpItem's transform methods Add implementations for GimpItem::translate(), scale(), resize(), flip(), rotate() and transform(). Simply transform all children, the group layer will automatically update itself. Also transform the layer mask.
2009-08-25 01:33:29 +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
gimp_group_layer_resume_resize (group, TRUE);
app: use GimpObjectQueue in lots of places Use GimpObjectQueue, added in the previous commit, in various instances where we perform an action on a set of objects. This improves progress reporting, by using a single progress for the entire operation, rather than reporting the progress of each object individually, and by taking the relative cost of each object into account, instead of assuming a uniform cost for all objects. In particular, this affects the various whole-image operations (i.e., transformations and color conversions), operations on linked items, and operations on layer groups. This also affects layers with masks, whose progress is now reported together instead of individually. Additionally, this commit fixes erroneous group-layer mask cropping during undo when resizing the image, by properly calling {start,end}_move() on all the resized layers before starting the operation, and when scaling the image, by only scaling top-level layers, and letting group layers scale their children themselves.
2018-03-25 22:18:46 +08:00
g_clear_object (&queue);
Implement GimpItem's transform methods Add implementations for GimpItem::translate(), scale(), resize(), flip(), rotate() and transform(). Simply transform all children, the group layer will automatically update itself. Also transform the layer mask.
2009-08-25 01:33:29 +08:00
}
static void
app: add virtual transform/type-conversion functions to GimpLayer The GimpLayer implementation of the GimpItem transform functions, and the GimpDrawable convert_type() function, apply their operation to both the layer and its mask. The subclasses of GimpLayer -- GimpGroupLayer and GimpTextLayer -- override some of these functions, providing their own logic for the layer part, and duplicating the mask part. Avoid this duplication by adding a set of virtual transform and type-conversion functions to GimpLayer. Have the GimpLayer implementaion of the corresponding GimpItem and GimpDrawable functions use these functions to apply the operation to the layer, while taking care of the mask themselves. Have GimpLayer's subclasses override the new virtual functions, instead of the GimpItem and GimpDrawable ones. Note that the existing implementation of convert_type() in GimpTextLayer neglected to convert the mask, hence text layer masks retained their old format after conversion. This issue is fixed as a side effect of this commit.
2017-06-17 08:15:56 +08:00
gimp_group_layer_flip (GimpLayer *layer,
Implement GimpItem's transform methods Add implementations for GimpItem::translate(), scale(), resize(), flip(), rotate() and transform(). Simply transform all children, the group layer will automatically update itself. Also transform the layer mask.
2009-08-25 01:33:29 +08:00
GimpContext *context,
GimpOrientationType flip_type,
gdouble axis,
gboolean clip_result)
{
app: add virtual transform/type-conversion functions to GimpLayer The GimpLayer implementation of the GimpItem transform functions, and the GimpDrawable convert_type() function, apply their operation to both the layer and its mask. The subclasses of GimpLayer -- GimpGroupLayer and GimpTextLayer -- override some of these functions, providing their own logic for the layer part, and duplicating the mask part. Avoid this duplication by adding a set of virtual transform and type-conversion functions to GimpLayer. Have the GimpLayer implementaion of the corresponding GimpItem and GimpDrawable functions use these functions to apply the operation to the layer, while taking care of the mask themselves. Have GimpLayer's subclasses override the new virtual functions, instead of the GimpItem and GimpDrawable ones. Note that the existing implementation of convert_type() in GimpTextLayer neglected to convert the mask, hence text layer masks retained their old format after conversion. This issue is fixed as a side effect of this commit.
2017-06-17 08:15:56 +08:00
GimpGroupLayer *group = GIMP_GROUP_LAYER (layer);
GimpGroupLayerPrivate *private = GET_PRIVATE (layer);
app: move all GimpGroupLayer members to a private struct
2011-02-04 05:29:25 +08:00
GList *list;
Implement GimpItem's transform methods Add implementations for GimpItem::translate(), scale(), resize(), flip(), rotate() and transform(). Simply transform all children, the group layer will automatically update itself. Also transform the layer mask.
2009-08-25 01:33:29 +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
gimp_group_layer_suspend_resize (group, TRUE);
app: move all GimpGroupLayer members to a private struct
2011-02-04 05:29:25 +08:00
for (list = gimp_item_stack_get_item_iter (GIMP_ITEM_STACK (private->children));
Implement GimpItem's transform methods Add implementations for GimpItem::translate(), scale(), resize(), flip(), rotate() and transform(). Simply transform all children, the group layer will automatically update itself. Also transform the layer mask.
2009-08-25 01:33:29 +08:00
list;
list = g_list_next (list))
{
GimpItem *child = list->data;
gimp_item_flip (child, context,
flip_type, axis, clip_result);
}
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_group_layer_resume_resize (group, TRUE);
Implement GimpItem's transform methods Add implementations for GimpItem::translate(), scale(), resize(), flip(), rotate() and transform(). Simply transform all children, the group layer will automatically update itself. Also transform the layer mask.
2009-08-25 01:33:29 +08:00
}
static void
app: add virtual transform/type-conversion functions to GimpLayer The GimpLayer implementation of the GimpItem transform functions, and the GimpDrawable convert_type() function, apply their operation to both the layer and its mask. The subclasses of GimpLayer -- GimpGroupLayer and GimpTextLayer -- override some of these functions, providing their own logic for the layer part, and duplicating the mask part. Avoid this duplication by adding a set of virtual transform and type-conversion functions to GimpLayer. Have the GimpLayer implementaion of the corresponding GimpItem and GimpDrawable functions use these functions to apply the operation to the layer, while taking care of the mask themselves. Have GimpLayer's subclasses override the new virtual functions, instead of the GimpItem and GimpDrawable ones. Note that the existing implementation of convert_type() in GimpTextLayer neglected to convert the mask, hence text layer masks retained their old format after conversion. This issue is fixed as a side effect of this commit.
2017-06-17 08:15:56 +08:00
gimp_group_layer_rotate (GimpLayer *layer,
Implement GimpItem's transform methods Add implementations for GimpItem::translate(), scale(), resize(), flip(), rotate() and transform(). Simply transform all children, the group layer will automatically update itself. Also transform the layer mask.
2009-08-25 01:33:29 +08:00
GimpContext *context,
GimpRotationType rotate_type,
gdouble center_x,
gdouble center_y,
gboolean clip_result)
{
app: add virtual transform/type-conversion functions to GimpLayer The GimpLayer implementation of the GimpItem transform functions, and the GimpDrawable convert_type() function, apply their operation to both the layer and its mask. The subclasses of GimpLayer -- GimpGroupLayer and GimpTextLayer -- override some of these functions, providing their own logic for the layer part, and duplicating the mask part. Avoid this duplication by adding a set of virtual transform and type-conversion functions to GimpLayer. Have the GimpLayer implementaion of the corresponding GimpItem and GimpDrawable functions use these functions to apply the operation to the layer, while taking care of the mask themselves. Have GimpLayer's subclasses override the new virtual functions, instead of the GimpItem and GimpDrawable ones. Note that the existing implementation of convert_type() in GimpTextLayer neglected to convert the mask, hence text layer masks retained their old format after conversion. This issue is fixed as a side effect of this commit.
2017-06-17 08:15:56 +08:00
GimpGroupLayer *group = GIMP_GROUP_LAYER (layer);
GimpGroupLayerPrivate *private = GET_PRIVATE (layer);
app: move all GimpGroupLayer members to a private struct
2011-02-04 05:29:25 +08:00
GList *list;
Implement GimpItem's transform methods Add implementations for GimpItem::translate(), scale(), resize(), flip(), rotate() and transform(). Simply transform all children, the group layer will automatically update itself. Also transform the layer mask.
2009-08-25 01:33:29 +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
gimp_group_layer_suspend_resize (group, TRUE);
app: move all GimpGroupLayer members to a private struct
2011-02-04 05:29:25 +08:00
for (list = gimp_item_stack_get_item_iter (GIMP_ITEM_STACK (private->children));
Implement GimpItem's transform methods Add implementations for GimpItem::translate(), scale(), resize(), flip(), rotate() and transform(). Simply transform all children, the group layer will automatically update itself. Also transform the layer mask.
2009-08-25 01:33:29 +08:00
list;
list = g_list_next (list))
{
GimpItem *child = list->data;
gimp_item_rotate (child, context,
rotate_type, center_x, center_y, clip_result);
}
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_group_layer_resume_resize (group, TRUE);
Implement GimpItem's transform methods Add implementations for GimpItem::translate(), scale(), resize(), flip(), rotate() and transform(). Simply transform all children, the group layer will automatically update itself. Also transform the layer mask.
2009-08-25 01:33:29 +08:00
}
static void
app: add virtual transform/type-conversion functions to GimpLayer The GimpLayer implementation of the GimpItem transform functions, and the GimpDrawable convert_type() function, apply their operation to both the layer and its mask. The subclasses of GimpLayer -- GimpGroupLayer and GimpTextLayer -- override some of these functions, providing their own logic for the layer part, and duplicating the mask part. Avoid this duplication by adding a set of virtual transform and type-conversion functions to GimpLayer. Have the GimpLayer implementaion of the corresponding GimpItem and GimpDrawable functions use these functions to apply the operation to the layer, while taking care of the mask themselves. Have GimpLayer's subclasses override the new virtual functions, instead of the GimpItem and GimpDrawable ones. Note that the existing implementation of convert_type() in GimpTextLayer neglected to convert the mask, hence text layer masks retained their old format after conversion. This issue is fixed as a side effect of this commit.
2017-06-17 08:15:56 +08:00
gimp_group_layer_transform (GimpLayer *layer,
Implement GimpItem's transform methods Add implementations for GimpItem::translate(), scale(), resize(), flip(), rotate() and transform(). Simply transform all children, the group layer will automatically update itself. Also transform the layer mask.
2009-08-25 01:33:29 +08:00
GimpContext *context,
const GimpMatrix3 *matrix,
GimpTransformDirection direction,
GimpInterpolationType interpolation_type,
GimpTransformResize clip_result,
GimpProgress *progress)
{
app: add virtual transform/type-conversion functions to GimpLayer The GimpLayer implementation of the GimpItem transform functions, and the GimpDrawable convert_type() function, apply their operation to both the layer and its mask. The subclasses of GimpLayer -- GimpGroupLayer and GimpTextLayer -- override some of these functions, providing their own logic for the layer part, and duplicating the mask part. Avoid this duplication by adding a set of virtual transform and type-conversion functions to GimpLayer. Have the GimpLayer implementaion of the corresponding GimpItem and GimpDrawable functions use these functions to apply the operation to the layer, while taking care of the mask themselves. Have GimpLayer's subclasses override the new virtual functions, instead of the GimpItem and GimpDrawable ones. Note that the existing implementation of convert_type() in GimpTextLayer neglected to convert the mask, hence text layer masks retained their old format after conversion. This issue is fixed as a side effect of this commit.
2017-06-17 08:15:56 +08:00
GimpGroupLayer *group = GIMP_GROUP_LAYER (layer);
GimpGroupLayerPrivate *private = GET_PRIVATE (layer);
app: use GimpObjectQueue in lots of places Use GimpObjectQueue, added in the previous commit, in various instances where we perform an action on a set of objects. This improves progress reporting, by using a single progress for the entire operation, rather than reporting the progress of each object individually, and by taking the relative cost of each object into account, instead of assuming a uniform cost for all objects. In particular, this affects the various whole-image operations (i.e., transformations and color conversions), operations on linked items, and operations on layer groups. This also affects layers with masks, whose progress is now reported together instead of individually. Additionally, this commit fixes erroneous group-layer mask cropping during undo when resizing the image, by properly calling {start,end}_move() on all the resized layers before starting the operation, and when scaling the image, by only scaling top-level layers, and letting group layers scale their children themselves.
2018-03-25 22:18:46 +08:00
GimpObjectQueue *queue = NULL;
app: move all GimpGroupLayer members to a private struct
2011-02-04 05:29:25 +08:00
GList *list;
Implement GimpItem's transform methods Add implementations for GimpItem::translate(), scale(), resize(), flip(), rotate() and transform(). Simply transform all children, the group layer will automatically update itself. Also transform the layer mask.
2009-08-25 01:33:29 +08:00
app: use GimpObjectQueue in lots of places Use GimpObjectQueue, added in the previous commit, in various instances where we perform an action on a set of objects. This improves progress reporting, by using a single progress for the entire operation, rather than reporting the progress of each object individually, and by taking the relative cost of each object into account, instead of assuming a uniform cost for all objects. In particular, this affects the various whole-image operations (i.e., transformations and color conversions), operations on linked items, and operations on layer groups. This also affects layers with masks, whose progress is now reported together instead of individually. Additionally, this commit fixes erroneous group-layer mask cropping during undo when resizing the image, by properly calling {start,end}_move() on all the resized layers before starting the operation, and when scaling the image, by only scaling top-level layers, and letting group layers scale their children themselves.
2018-03-25 22:18:46 +08:00
if (progress)
{
queue = gimp_object_queue_new (progress);
progress = GIMP_PROGRESS (queue);
gimp_object_queue_push_container (queue, private->children);
}
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_group_layer_suspend_resize (group, TRUE);
app: move all GimpGroupLayer members to a private struct
2011-02-04 05:29:25 +08:00
for (list = gimp_item_stack_get_item_iter (GIMP_ITEM_STACK (private->children));
Implement GimpItem's transform methods Add implementations for GimpItem::translate(), scale(), resize(), flip(), rotate() and transform(). Simply transform all children, the group layer will automatically update itself. Also transform the layer mask.
2009-08-25 01:33:29 +08:00
list;
list = g_list_next (list))
{
GimpItem *child = list->data;
app: use GimpObjectQueue in lots of places Use GimpObjectQueue, added in the previous commit, in various instances where we perform an action on a set of objects. This improves progress reporting, by using a single progress for the entire operation, rather than reporting the progress of each object individually, and by taking the relative cost of each object into account, instead of assuming a uniform cost for all objects. In particular, this affects the various whole-image operations (i.e., transformations and color conversions), operations on linked items, and operations on layer groups. This also affects layers with masks, whose progress is now reported together instead of individually. Additionally, this commit fixes erroneous group-layer mask cropping during undo when resizing the image, by properly calling {start,end}_move() on all the resized layers before starting the operation, and when scaling the image, by only scaling top-level layers, and letting group layers scale their children themselves.
2018-03-25 22:18:46 +08:00
if (queue)
gimp_object_queue_pop (queue);
Implement GimpItem's transform methods Add implementations for GimpItem::translate(), scale(), resize(), flip(), rotate() and transform(). Simply transform all children, the group layer will automatically update itself. Also transform the layer mask.
2009-08-25 01:33:29 +08:00
gimp_item_transform (child, context,
matrix, direction,
app, pdb, libgimp: Remove all traces of the supersampling recursion level from all transform APIs. This is no longer used since we use GEGL to transform, the value was only passed around and never used.
2013-05-31 07:15:32 +08:00
interpolation_type,
Implement GimpItem's transform methods Add implementations for GimpItem::translate(), scale(), resize(), flip(), rotate() and transform(). Simply transform all children, the group layer will automatically update itself. Also transform the layer mask.
2009-08-25 01:33:29 +08:00
clip_result, progress);
}
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_group_layer_resume_resize (group, TRUE);
app: use GimpObjectQueue in lots of places Use GimpObjectQueue, added in the previous commit, in various instances where we perform an action on a set of objects. This improves progress reporting, by using a single progress for the entire operation, rather than reporting the progress of each object individually, and by taking the relative cost of each object into account, instead of assuming a uniform cost for all objects. In particular, this affects the various whole-image operations (i.e., transformations and color conversions), operations on linked items, and operations on layer groups. This also affects layers with masks, whose progress is now reported together instead of individually. Additionally, this commit fixes erroneous group-layer mask cropping during undo when resizing the image, by properly calling {start,end}_move() on all the resized layers before starting the operation, and when scaling the image, by only scaling top-level layers, and letting group layers scale their children themselves.
2018-03-25 22:18:46 +08:00
g_clear_object (&queue);
Implement GimpItem's transform methods Add implementations for GimpItem::translate(), scale(), resize(), flip(), rotate() and transform(). Simply transform all children, the group layer will automatically update itself. Also transform the layer mask.
2009-08-25 01:33:29 +08:00
}
app: remove drawable->private->format, its buffer has a format already Also, make group layer type conversion much less hackish by using the same kind of temporary states that are used for reallocating its projection on size change.
2012-03-30 05:19:27 +08:00
static const Babl *
get_projection_format (GimpProjectable *projectable,
app: make group layer type conversion depend on less side conditions gimp_group_layer_convert_type() required the image's precision to be already set to the new value.
2012-09-29 02:58:40 +08:00
GimpImageBaseType base_type,
GimpPrecision precision)
app: remove drawable->private->format, its buffer has a format already Also, make group layer type conversion much less hackish by using the same kind of temporary states that are used for reallocating its projection on size change.
2012-03-30 05:19:27 +08:00
{
app: add a GimpPrecision enum that for now contains GIMP_PRECISION_U8 Add gimp_image_get_precision(), and a "precision" argument to gimp_babl_format(). Change code accordingly and do some more format related cleanups.
2012-04-22 23:07:35 +08:00
GimpImage *image = gimp_item_get_image (GIMP_ITEM (projectable));
app: remove drawable->private->format, its buffer has a format already Also, make group layer type conversion much less hackish by using the same kind of temporary states that are used for reallocating its projection on size change.
2012-03-30 05:19:27 +08:00
switch (base_type)
{
case GIMP_RGB:
case GIMP_INDEXED:
Initial space invasion commit in GIMP All babl formats now have a space equivalent to a color profile, determining the format's primaries and TRCs. This commit makes GIMP aware of this. libgimp: - enum GimpPrecision: rename GAMMA values to NON_LINEAR and keep GAMMA as deprecated aliases, add PERCEPTUAL values so we now have LINEAR, NON_LINEAR and PERCPTUAL for each encoding, matching the babl encoding variants RGB, R'G'B' and R~G~B~. - gimp_color_transform_can_gegl_copy() now returns TRUE if both profiles can return a babl space, increasing the amount of fast babl color conversions significantly. - TODO: no solution yet for getting libgimp drawable proxy buffers in the right format with space. plug-ins: - follow the GimpPrecision change. - TODO: everything else unchanged and partly broken or sub-optimal, like setting a new image's color profile too late. app: - add enum GimpTRCType { LINEAR, NON_LINEAR, PERCEPTUAL } as replacement for all "linear" booleans. - change gimp-babl functions to take babl spaces and GimpTRCType parameters and support all sorts of new perceptual ~ formats. - a lot of places changed in the early days of goat invasion didn't take advantage of gimp-babl utility functions and constructed formats manually. They all needed revisiting and many now use much simpler code calling gimp-babl API. - change gimp_babl_format_get_color_profile() to really extract a newly allocated color profile from the format, and add gimp_babl_get_builtin_color_profile() which does the same as gimp_babl_format_get_color_profile() did before. Visited all callers to decide whether they are looking for the format's actual profile, or for one of the builtin profiles, simplifying code that only needs builtin profiles. - drawables have a new get_space_api(), get_linear() is now get_trc(). - images now have a "layer space" and an API to get it, gimp_image_get_layer_format() returns formats in that space. - an image's layer space is created from the image's color profile, change gimpimage-color-profile to deal with that correctly - change many babl_format() calls to babl_format_with_space() and take the space from passed formats or drawables - add function gimp_layer_fix_format_space() which replaces the layer's buffer with one that has the image's layer format, but doesn't change pixel values - use gimp_layer_fix_format_space() to make sure layers loaded from XCF and created by plug-ins have the right space when added to the image, because it's impossible to always assign the right space upon layer creation - "assign color profile" and "discard color profile" now require use of gimp_layer_fix_format_space() too because the profile is now embedded in all formats via the space. Add gimp_image_assign_color_profile() which does all that and call it instead of a simple gimp_image_set_color_profile(), also from the PDB set-color-profile functions, which are essentially "assign" and "discard" calls. - generally, make sure a new image's color profile is set before adding layers to it, gimp_image_set_color_profile() is more than before considered know-what-you-are-doing API. - take special precaution in all places that call gimp_drawable_convert_type(), we now must pass a new_profile from all callers that convert layers within the same image (such as image_convert_type, image_convert_precision), because the layer's new space can't be determined from the image's layer format during the call. - change all "linear" properties to "trc", in all config objects like for levels and curves, in the histogram, in the widgets. This results in some GUI that now has three choices instead of two. TODO: we might want to reduce that back to two later. - keep "linear" boolean properties around as compat if needed for file pasring, but always convert the parsed parsed boolean to GimpTRCType. - TODO: the image's "enable color management" switch is currently broken, will fix that in another commit.
2018-07-21 20:23:01 +08:00
return gimp_image_get_format (image, GIMP_RGB, precision, TRUE,
gimp_image_get_layer_space (image));
app: remove drawable->private->format, its buffer has a format already Also, make group layer type conversion much less hackish by using the same kind of temporary states that are used for reallocating its projection on size change.
2012-03-30 05:19:27 +08:00
case GIMP_GRAY:
Initial space invasion commit in GIMP All babl formats now have a space equivalent to a color profile, determining the format's primaries and TRCs. This commit makes GIMP aware of this. libgimp: - enum GimpPrecision: rename GAMMA values to NON_LINEAR and keep GAMMA as deprecated aliases, add PERCEPTUAL values so we now have LINEAR, NON_LINEAR and PERCPTUAL for each encoding, matching the babl encoding variants RGB, R'G'B' and R~G~B~. - gimp_color_transform_can_gegl_copy() now returns TRUE if both profiles can return a babl space, increasing the amount of fast babl color conversions significantly. - TODO: no solution yet for getting libgimp drawable proxy buffers in the right format with space. plug-ins: - follow the GimpPrecision change. - TODO: everything else unchanged and partly broken or sub-optimal, like setting a new image's color profile too late. app: - add enum GimpTRCType { LINEAR, NON_LINEAR, PERCEPTUAL } as replacement for all "linear" booleans. - change gimp-babl functions to take babl spaces and GimpTRCType parameters and support all sorts of new perceptual ~ formats. - a lot of places changed in the early days of goat invasion didn't take advantage of gimp-babl utility functions and constructed formats manually. They all needed revisiting and many now use much simpler code calling gimp-babl API. - change gimp_babl_format_get_color_profile() to really extract a newly allocated color profile from the format, and add gimp_babl_get_builtin_color_profile() which does the same as gimp_babl_format_get_color_profile() did before. Visited all callers to decide whether they are looking for the format's actual profile, or for one of the builtin profiles, simplifying code that only needs builtin profiles. - drawables have a new get_space_api(), get_linear() is now get_trc(). - images now have a "layer space" and an API to get it, gimp_image_get_layer_format() returns formats in that space. - an image's layer space is created from the image's color profile, change gimpimage-color-profile to deal with that correctly - change many babl_format() calls to babl_format_with_space() and take the space from passed formats or drawables - add function gimp_layer_fix_format_space() which replaces the layer's buffer with one that has the image's layer format, but doesn't change pixel values - use gimp_layer_fix_format_space() to make sure layers loaded from XCF and created by plug-ins have the right space when added to the image, because it's impossible to always assign the right space upon layer creation - "assign color profile" and "discard color profile" now require use of gimp_layer_fix_format_space() too because the profile is now embedded in all formats via the space. Add gimp_image_assign_color_profile() which does all that and call it instead of a simple gimp_image_set_color_profile(), also from the PDB set-color-profile functions, which are essentially "assign" and "discard" calls. - generally, make sure a new image's color profile is set before adding layers to it, gimp_image_set_color_profile() is more than before considered know-what-you-are-doing API. - take special precaution in all places that call gimp_drawable_convert_type(), we now must pass a new_profile from all callers that convert layers within the same image (such as image_convert_type, image_convert_precision), because the layer's new space can't be determined from the image's layer format during the call. - change all "linear" properties to "trc", in all config objects like for levels and curves, in the histogram, in the widgets. This results in some GUI that now has three choices instead of two. TODO: we might want to reduce that back to two later. - keep "linear" boolean properties around as compat if needed for file pasring, but always convert the parsed parsed boolean to GimpTRCType. - TODO: the image's "enable color management" switch is currently broken, will fix that in another commit.
2018-07-21 20:23:01 +08:00
return gimp_image_get_format (image, GIMP_GRAY, precision, TRUE,
gimp_image_get_layer_space (image));
app: remove drawable->private->format, its buffer has a format already Also, make group layer type conversion much less hackish by using the same kind of temporary states that are used for reallocating its projection on size change.
2012-03-30 05:19:27 +08:00
}
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_val_if_reached (NULL);
app: remove drawable->private->format, its buffer has a format already Also, make group layer type conversion much less hackish by using the same kind of temporary states that are used for reallocating its projection on size change.
2012-03-30 05:19:27 +08:00
}
Implement GimpDrawable::convert_type() Don't convert the pixels but reallocate the group's projection for the new type. This breaks badly on undo, don't bother to try yet...
2009-09-12 04:01:31 +08:00
static void
app: add virtual transform/type-conversion functions to GimpLayer The GimpLayer implementation of the GimpItem transform functions, and the GimpDrawable convert_type() function, apply their operation to both the layer and its mask. The subclasses of GimpLayer -- GimpGroupLayer and GimpTextLayer -- override some of these functions, providing their own logic for the layer part, and duplicating the mask part. Avoid this duplication by adding a set of virtual transform and type-conversion functions to GimpLayer. Have the GimpLayer implementaion of the corresponding GimpItem and GimpDrawable functions use these functions to apply the operation to the layer, while taking care of the mask themselves. Have GimpLayer's subclasses override the new virtual functions, instead of the GimpItem and GimpDrawable ones. Note that the existing implementation of convert_type() in GimpTextLayer neglected to convert the mask, hence text layer masks retained their old format after conversion. This issue is fixed as a side effect of this commit.
2017-06-17 08:15:56 +08:00
gimp_group_layer_convert_type (GimpLayer *layer,
app, pdb: use GeglDitherMethod instead of simply an integer
2016-11-08 03:41:39 +08:00
GimpImage *dest_image,
const Babl *new_format,
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
GimpColorProfile *src_profile,
app, pdb: use GeglDitherMethod instead of simply an integer
2016-11-08 03:41:39 +08:00
GimpColorProfile *dest_profile,
GeglDitherMethod layer_dither_type,
GeglDitherMethod mask_dither_type,
gboolean push_undo,
GimpProgress *progress)
Implement GimpDrawable::convert_type() Don't convert the pixels but reallocate the group's projection for the new type. This breaks badly on undo, don't bother to try yet...
2009-09-12 04:01:31 +08:00
{
app: add virtual transform/type-conversion functions to GimpLayer The GimpLayer implementation of the GimpItem transform functions, and the GimpDrawable convert_type() function, apply their operation to both the layer and its mask. The subclasses of GimpLayer -- GimpGroupLayer and GimpTextLayer -- override some of these functions, providing their own logic for the layer part, and duplicating the mask part. Avoid this duplication by adding a set of virtual transform and type-conversion functions to GimpLayer. Have the GimpLayer implementaion of the corresponding GimpItem and GimpDrawable functions use these functions to apply the operation to the layer, while taking care of the mask themselves. Have GimpLayer's subclasses override the new virtual functions, instead of the GimpItem and GimpDrawable ones. Note that the existing implementation of convert_type() in GimpTextLayer neglected to convert the mask, hence text layer masks retained their old format after conversion. This issue is fixed as a side effect of this commit.
2017-06-17 08:15:56 +08:00
GimpGroupLayer *group = GIMP_GROUP_LAYER (layer);
GimpGroupLayerPrivate *private = GET_PRIVATE (layer);
app: port GimpGroupLayer to gimp_buffer_set_tiles_full()
2012-03-22 05:17:54 +08:00
GeglBuffer *buffer;
Implement GimpDrawable::convert_type() Don't convert the pixels but reallocate the group's projection for the new type. This breaks badly on undo, don't bother to try yet...
2009-09-12 04:01:31 +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
if (push_undo)
{
GimpImage *image = gimp_item_get_image (GIMP_ITEM (group));
gimp_image_undo_push_group_layer_convert (image, NULL, group);
}
Bug 787848 - Duplicate image crashes if there is an empty layer group An empty gorup layer has no extent, so we fake its extents to be at least 1x1 whenever its projection is being recreated, because we can't have a 0x0 buffer in a drawable. This safeguard was forgotten in gimp_group_layer_convert_type() which gets called on image duplicate.
2017-09-19 02:31:21 +08:00
/* Force allocation of a same-size projection, in case the group
* layer is empty
*/
private->reallocate_width = gimp_item_get_width (GIMP_ITEM (group));
private->reallocate_height = gimp_item_get_height (GIMP_ITEM (group));
app: remove drawable->private->format, its buffer has a format already Also, make group layer type conversion much less hackish by using the same kind of temporary states that are used for reallocating its projection on size change.
2012-03-30 05:19:27 +08:00
/* Need to temporarily set the projectable's format to the new
* values so the projection will create its tiles with the right
* depth
Implement GimpDrawable::convert_type() Don't convert the pixels but reallocate the group's projection for the new type. This breaks badly on undo, don't bother to try yet...
2009-09-12 04:01:31 +08:00
*/
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
private->convert_format =
app: add virtual transform/type-conversion functions to GimpLayer The GimpLayer implementation of the GimpItem transform functions, and the GimpDrawable convert_type() function, apply their operation to both the layer and its mask. The subclasses of GimpLayer -- GimpGroupLayer and GimpTextLayer -- override some of these functions, providing their own logic for the layer part, and duplicating the mask part. Avoid this duplication by adding a set of virtual transform and type-conversion functions to GimpLayer. Have the GimpLayer implementaion of the corresponding GimpItem and GimpDrawable functions use these functions to apply the operation to the layer, while taking care of the mask themselves. Have GimpLayer's subclasses override the new virtual functions, instead of the GimpItem and GimpDrawable ones. Note that the existing implementation of convert_type() in GimpTextLayer neglected to convert the mask, hence text layer masks retained their old format after conversion. This issue is fixed as a side effect of this commit.
2017-06-17 08:15:56 +08:00
get_projection_format (GIMP_PROJECTABLE (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
gimp_babl_format_get_base_type (new_format),
gimp_babl_format_get_precision (new_format));
app: add virtual transform/type-conversion functions to GimpLayer The GimpLayer implementation of the GimpItem transform functions, and the GimpDrawable convert_type() function, apply their operation to both the layer and its mask. The subclasses of GimpLayer -- GimpGroupLayer and GimpTextLayer -- override some of these functions, providing their own logic for the layer part, and duplicating the mask part. Avoid this duplication by adding a set of virtual transform and type-conversion functions to GimpLayer. Have the GimpLayer implementaion of the corresponding GimpItem and GimpDrawable functions use these functions to apply the operation to the layer, while taking care of the mask themselves. Have GimpLayer's subclasses override the new virtual functions, instead of the GimpItem and GimpDrawable ones. Note that the existing implementation of convert_type() in GimpTextLayer neglected to convert the mask, hence text layer masks retained their old format after conversion. This issue is fixed as a side effect of this commit.
2017-06-17 08:15:56 +08:00
gimp_projectable_structure_changed (GIMP_PROJECTABLE (group));
app: flush pass-through groups' projection asynchronously The source node of pass-through groups doesn't use the projection's buffer, hence there's no need to invalidate it synchronously, which is faster.
2017-12-02 23:15:39 +08:00
gimp_group_layer_flush (group);
Implement GimpDrawable::convert_type() Don't convert the pixels but reallocate the group's projection for the new type. This breaks badly on undo, don't bother to try yet...
2009-09-12 04:01:31 +08:00
app: remove drawable->private->format, its buffer has a format already Also, make group layer type conversion much less hackish by using the same kind of temporary states that are used for reallocating its projection on size change.
2012-03-30 05:19:27 +08:00
buffer = gimp_pickable_get_buffer (GIMP_PICKABLE (private->projection));
app: port GimpGroupLayer to gimp_buffer_set_tiles_full()
2012-03-22 05:17:54 +08:00
app: add virtual transform/type-conversion functions to GimpLayer The GimpLayer implementation of the GimpItem transform functions, and the GimpDrawable convert_type() function, apply their operation to both the layer and its mask. The subclasses of GimpLayer -- GimpGroupLayer and GimpTextLayer -- override some of these functions, providing their own logic for the layer part, and duplicating the mask part. Avoid this duplication by adding a set of virtual transform and type-conversion functions to GimpLayer. Have the GimpLayer implementaion of the corresponding GimpItem and GimpDrawable functions use these functions to apply the operation to the layer, while taking care of the mask themselves. Have GimpLayer's subclasses override the new virtual functions, instead of the GimpItem and GimpDrawable ones. Note that the existing implementation of convert_type() in GimpTextLayer neglected to convert the mask, hence text layer masks retained their old format after conversion. This issue is fixed as a side effect of this commit.
2017-06-17 08:15:56 +08:00
gimp_drawable_set_buffer_full (GIMP_DRAWABLE (group),
app: port GimpGroupLayer to gimp_buffer_set_tiles_full()
2012-03-22 05:17:54 +08:00
FALSE, NULL,
app: change GimpDrawable::set_tiles() to ::set_buffer() and remove the "type" argument, GeglBuffers have a format.
2012-03-22 06:37:16 +08:00
buffer,
app: add virtual transform/type-conversion functions to GimpLayer The GimpLayer implementation of the GimpItem transform functions, and the GimpDrawable convert_type() function, apply their operation to both the layer and its mask. The subclasses of GimpLayer -- GimpGroupLayer and GimpTextLayer -- override some of these functions, providing their own logic for the layer part, and duplicating the mask part. Avoid this duplication by adding a set of virtual transform and type-conversion functions to GimpLayer. Have the GimpLayer implementaion of the corresponding GimpItem and GimpDrawable functions use these functions to apply the operation to the layer, while taking care of the mask themselves. Have GimpLayer's subclasses override the new virtual functions, instead of the GimpItem and GimpDrawable ones. Note that the existing implementation of convert_type() in GimpTextLayer neglected to convert the mask, hence text layer masks retained their old format after conversion. This issue is fixed as a side effect of this commit.
2017-06-17 08:15:56 +08:00
gimp_item_get_offset_x (GIMP_ITEM (group)),
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
gimp_item_get_offset_y (GIMP_ITEM (group)),
TRUE);
app: port GimpGroupLayer to gimp_buffer_set_tiles_full()
2012-03-22 05:17:54 +08:00
app: remove drawable->private->format, its buffer has a format already Also, make group layer type conversion much less hackish by using the same kind of temporary states that are used for reallocating its projection on size change.
2012-03-30 05:19:27 +08:00
/* reset, the actual format is right now */
private->convert_format = NULL;
Bug 787848 - Duplicate image crashes if there is an empty layer group An empty gorup layer has no extent, so we fake its extents to be at least 1x1 whenever its projection is being recreated, because we can't have a 0x0 buffer in a drawable. This safeguard was forgotten in gimp_group_layer_convert_type() which gets called on image duplicate.
2017-09-19 02:31:21 +08:00
private->reallocate_width = 0;
private->reallocate_height = 0;
Implement GimpDrawable::convert_type() Don't convert the pixels but reallocate the group's projection for the new type. This breaks badly on undo, don't bother to try yet...
2009-09-12 04:01:31 +08:00
}
app: implement pass-through mode in GimpGroupLayer Override GimpDrawable::get_source_node() for GimpGroupLayer. Use a node that contains both the drawable's buffer-source node, and the layer stack's graph node. Choose which one of these to connect to the source node's output based on the group's layer mode: the stack graph for pass-through mode, and the buffer-source node for all the rest. When in pass-through mode, connect the source node's input (which receives the backdrop) to the stack graph's input. Keep maintaining the projection in pass-through mode. ATM, the projection uses the same graph as the source node, so it's rendered against the group's backdrop -- we don't want that. The next few commits fix it. Update the group's drawable directly upon filter stack update in pass-though mode, because the group's graph doesn't go through the projection. TODO: if any of the group's children (or a child of a nested pass- through group, etc.) uses dst-atop/src-in, this needs special attention.
2017-04-22 06:04:49 +08:00
static GeglNode *
gimp_group_layer_get_source_node (GimpDrawable *drawable)
{
GimpGroupLayerPrivate *private = GET_PRIVATE (drawable);
GeglNode *input;
g_warn_if_fail (private->source_node == NULL);
private->source_node = gegl_node_new ();
input = gegl_node_get_input_proxy (private->source_node, "input");
private->parent_source_node =
GIMP_DRAWABLE_CLASS (parent_class)->get_source_node (drawable);
gegl_node_add_child (private->source_node, private->parent_source_node);
g_object_unref (private->parent_source_node);
if (gegl_node_has_pad (private->parent_source_node, "input"))
{
gegl_node_connect_to (input, "output",
private->parent_source_node, "input");
}
/* make sure we have a graph */
(void) gimp_group_layer_get_graph (GIMP_PROJECTABLE (drawable));
gegl_node_add_child (private->source_node, private->graph);
gimp_group_layer_update_source_node (GIMP_GROUP_LAYER (drawable));
return g_object_ref (private->source_node);
}
static void
app: strength-reduce pass-through groups to normal groups Override GimpLayer::get_effective_mode() in GimpGroupLayer, to perform strength-reduction of pass-through groups to normal groups under certain conditions (see gimp_group_layer_get_effective_mode() for the logic.) The main motivation for this is the fact that Photoshop uses pass- through mode as the default mode for groups, resulting in many PSDs using pass-through groups generously and unnecessarily. Since pass-through groups are more expensive that normal groups, reducing them to normal groups when possible can make a big difference. Note that, while the results of the strength-reduced composition are theoretically equivalent, there may be small differences in practice due to numerical errors, especially when using low precision. This is unlikely to be an issue, but, just in case, allow disabling this optimization using the GIMP_NO_PASS_THROUGH_STRENGTH_REDUCTION environment variable.
2017-12-07 03:06:16 +08:00
gimp_group_layer_opacity_changed (GimpLayer *layer)
{
gimp_layer_update_effective_mode (layer);
if (GIMP_LAYER_CLASS (parent_class)->opacity_changed)
GIMP_LAYER_CLASS (parent_class)->opacity_changed (layer);
}
static void
gimp_group_layer_effective_mode_changed (GimpLayer *layer)
app: implement pass-through mode in GimpGroupLayer Override GimpDrawable::get_source_node() for GimpGroupLayer. Use a node that contains both the drawable's buffer-source node, and the layer stack's graph node. Choose which one of these to connect to the source node's output based on the group's layer mode: the stack graph for pass-through mode, and the buffer-source node for all the rest. When in pass-through mode, connect the source node's input (which receives the backdrop) to the stack graph's input. Keep maintaining the projection in pass-through mode. ATM, the projection uses the same graph as the source node, so it's rendered against the group's backdrop -- we don't want that. The next few commits fix it. Update the group's drawable directly upon filter stack update in pass-though mode, because the group's graph doesn't go through the projection. TODO: if any of the group's children (or a child of a nested pass- through group, etc.) uses dst-atop/src-in, this needs special attention.
2017-04-22 06:04:49 +08:00
{
app: flush group proj. switching from pass-through to non-pass-through When switching a group layer from pass-through mode to a non-pass- through mode, flush the projection synchrnously, to make sure that the projection's buffer gets properly invalidated at that point, and can be subsequently used as a source for the rest of the composition. Add a boolean 'pass_through' member to GimpGroupLayerPrivate, which indicates if the group is a pass-through group, and use it instead of checking the group's mode, so that we can detect that the group used to be a pass-through group when the mode changes, and to simplify the rest of the code.
2017-12-03 04:25:04 +08:00
GimpGroupLayer *group = GIMP_GROUP_LAYER (layer);
GimpGroupLayerPrivate *private = GET_PRIVATE (layer);
app: strength-reduce pass-through groups to normal groups Override GimpLayer::get_effective_mode() in GimpGroupLayer, to perform strength-reduction of pass-through groups to normal groups under certain conditions (see gimp_group_layer_get_effective_mode() for the logic.) The main motivation for this is the fact that Photoshop uses pass- through mode as the default mode for groups, resulting in many PSDs using pass-through groups generously and unnecessarily. Since pass-through groups are more expensive that normal groups, reducing them to normal groups when possible can make a big difference. Note that, while the results of the strength-reduced composition are theoretically equivalent, there may be small differences in practice due to numerical errors, especially when using low precision. This is unlikely to be an issue, but, just in case, allow disabling this optimization using the GIMP_NO_PASS_THROUGH_STRENGTH_REDUCTION environment variable.
2017-12-07 03:06:16 +08:00
GimpLayerMode mode;
app: flush group proj. switching from pass-through to non-pass-through When switching a group layer from pass-through mode to a non-pass- through mode, flush the projection synchrnously, to make sure that the projection's buffer gets properly invalidated at that point, and can be subsequently used as a source for the rest of the composition. Add a boolean 'pass_through' member to GimpGroupLayerPrivate, which indicates if the group is a pass-through group, and use it instead of checking the group's mode, so that we can detect that the group used to be a pass-through group when the mode changes, and to simplify the rest of the code.
2017-12-03 04:25:04 +08:00
gboolean pass_through;
app: strength-reduce pass-through groups to normal groups Override GimpLayer::get_effective_mode() in GimpGroupLayer, to perform strength-reduction of pass-through groups to normal groups under certain conditions (see gimp_group_layer_get_effective_mode() for the logic.) The main motivation for this is the fact that Photoshop uses pass- through mode as the default mode for groups, resulting in many PSDs using pass-through groups generously and unnecessarily. Since pass-through groups are more expensive that normal groups, reducing them to normal groups when possible can make a big difference. Note that, while the results of the strength-reduced composition are theoretically equivalent, there may be small differences in practice due to numerical errors, especially when using low precision. This is unlikely to be an issue, but, just in case, allow disabling this optimization using the GIMP_NO_PASS_THROUGH_STRENGTH_REDUCTION environment variable.
2017-12-07 03:06:16 +08:00
gimp_layer_get_effective_mode (layer, &mode, NULL, NULL, NULL);
pass_through = (mode == GIMP_LAYER_MODE_PASS_THROUGH);
app: flush group proj. switching from pass-through to non-pass-through When switching a group layer from pass-through mode to a non-pass- through mode, flush the projection synchrnously, to make sure that the projection's buffer gets properly invalidated at that point, and can be subsequently used as a source for the rest of the composition. Add a boolean 'pass_through' member to GimpGroupLayerPrivate, which indicates if the group is a pass-through group, and use it instead of checking the group's mode, so that we can detect that the group used to be a pass-through group when the mode changes, and to simplify the rest of the code.
2017-12-03 04:25:04 +08:00
if (private->pass_through && ! pass_through)
{
/* when switching from pass-through mode to a non-pass-through mode,
* flush the pickable in order to make sure the projection's buffer
* gets properly invalidated synchronously, so that it can be used
* as a source for the rest of the composition.
*/
gimp_pickable_flush (GIMP_PICKABLE (private->projection));
}
private->pass_through = pass_through;
app: implement pass-through mode in GimpGroupLayer Override GimpDrawable::get_source_node() for GimpGroupLayer. Use a node that contains both the drawable's buffer-source node, and the layer stack's graph node. Choose which one of these to connect to the source node's output based on the group's layer mode: the stack graph for pass-through mode, and the buffer-source node for all the rest. When in pass-through mode, connect the source node's input (which receives the backdrop) to the stack graph's input. Keep maintaining the projection in pass-through mode. ATM, the projection uses the same graph as the source node, so it's rendered against the group's backdrop -- we don't want that. The next few commits fix it. Update the group's drawable directly upon filter stack update in pass-though mode, because the group's graph doesn't go through the projection. TODO: if any of the group's children (or a child of a nested pass- through group, etc.) uses dst-atop/src-in, this needs special attention.
2017-04-22 06:04:49 +08:00
gimp_group_layer_update_source_node (group);
app: handle excludes_backdrop in GimpGroupLayer When any of the children of a pass-through group excludes its backdrop, the group itself should exclude the backdrop too. Override get_excludes_backdrop() to follow this logic, and call update_excludes_backdrop() when this condition might change. Note that we always composite pass-through groups using src-over mode, so to actually hide the backdrop, we need to disconnect it from the group's mode node's input pad (and reconnect it, when the backdrop is no longer hidden).
2017-05-09 03:06:00 +08:00
gimp_group_layer_update_mode_node (group);
app: implement pass-through mode in GimpGroupLayer Override GimpDrawable::get_source_node() for GimpGroupLayer. Use a node that contains both the drawable's buffer-source node, and the layer stack's graph node. Choose which one of these to connect to the source node's output based on the group's layer mode: the stack graph for pass-through mode, and the buffer-source node for all the rest. When in pass-through mode, connect the source node's input (which receives the backdrop) to the stack graph's input. Keep maintaining the projection in pass-through mode. ATM, the projection uses the same graph as the source node, so it's rendered against the group's backdrop -- we don't want that. The next few commits fix it. Update the group's drawable directly upon filter stack update in pass-though mode, because the group's graph doesn't go through the projection. TODO: if any of the group's children (or a child of a nested pass- through group, etc.) uses dst-atop/src-in, this needs special attention.
2017-04-22 06:04:49 +08:00
app: strength-reduce pass-through groups to normal groups Override GimpLayer::get_effective_mode() in GimpGroupLayer, to perform strength-reduction of pass-through groups to normal groups under certain conditions (see gimp_group_layer_get_effective_mode() for the logic.) The main motivation for this is the fact that Photoshop uses pass- through mode as the default mode for groups, resulting in many PSDs using pass-through groups generously and unnecessarily. Since pass-through groups are more expensive that normal groups, reducing them to normal groups when possible can make a big difference. Note that, while the results of the strength-reduced composition are theoretically equivalent, there may be small differences in practice due to numerical errors, especially when using low precision. This is unlikely to be an issue, but, just in case, allow disabling this optimization using the GIMP_NO_PASS_THROUGH_STRENGTH_REDUCTION environment variable.
2017-12-07 03:06:16 +08:00
if (GIMP_LAYER_CLASS (parent_class)->effective_mode_changed)
GIMP_LAYER_CLASS (parent_class)->effective_mode_changed (layer);
app: implement pass-through mode in GimpGroupLayer Override GimpDrawable::get_source_node() for GimpGroupLayer. Use a node that contains both the drawable's buffer-source node, and the layer stack's graph node. Choose which one of these to connect to the source node's output based on the group's layer mode: the stack graph for pass-through mode, and the buffer-source node for all the rest. When in pass-through mode, connect the source node's input (which receives the backdrop) to the stack graph's input. Keep maintaining the projection in pass-through mode. ATM, the projection uses the same graph as the source node, so it's rendered against the group's backdrop -- we don't want that. The next few commits fix it. Update the group's drawable directly upon filter stack update in pass-though mode, because the group's graph doesn't go through the projection. TODO: if any of the group's children (or a child of a nested pass- through group, etc.) uses dst-atop/src-in, this needs special attention.
2017-04-22 06:04:49 +08:00
}
app: handle excludes_backdrop in GimpGroupLayer When any of the children of a pass-through group excludes its backdrop, the group itself should exclude the backdrop too. Override get_excludes_backdrop() to follow this logic, and call update_excludes_backdrop() when this condition might change. Note that we always composite pass-through groups using src-over mode, so to actually hide the backdrop, we need to disconnect it from the group's mode node's input pad (and reconnect it, when the backdrop is no longer hidden).
2017-05-09 03:06:00 +08:00
static void
gimp_group_layer_excludes_backdrop_changed (GimpLayer *layer)
{
GimpGroupLayer *group = GIMP_GROUP_LAYER (layer);
gimp_group_layer_update_source_node (group);
gimp_group_layer_update_mode_node (group);
if (GIMP_LAYER_CLASS (parent_class)->excludes_backdrop_changed)
GIMP_LAYER_CLASS (parent_class)->excludes_backdrop_changed (layer);
}
app: strength-reduce pass-through groups to normal groups Override GimpLayer::get_effective_mode() in GimpGroupLayer, to perform strength-reduction of pass-through groups to normal groups under certain conditions (see gimp_group_layer_get_effective_mode() for the logic.) The main motivation for this is the fact that Photoshop uses pass- through mode as the default mode for groups, resulting in many PSDs using pass-through groups generously and unnecessarily. Since pass-through groups are more expensive that normal groups, reducing them to normal groups when possible can make a big difference. Note that, while the results of the strength-reduced composition are theoretically equivalent, there may be small differences in practice due to numerical errors, especially when using low precision. This is unlikely to be an issue, but, just in case, allow disabling this optimization using the GIMP_NO_PASS_THROUGH_STRENGTH_REDUCTION environment variable.
2017-12-07 03:06:16 +08:00
static void
gimp_group_layer_mask_changed (GimpLayer *layer)
{
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
g_warn_if_fail (GET_PRIVATE (layer)->suspend_mask == 0);
app: strength-reduce pass-through groups to normal groups Override GimpLayer::get_effective_mode() in GimpGroupLayer, to perform strength-reduction of pass-through groups to normal groups under certain conditions (see gimp_group_layer_get_effective_mode() for the logic.) The main motivation for this is the fact that Photoshop uses pass- through mode as the default mode for groups, resulting in many PSDs using pass-through groups generously and unnecessarily. Since pass-through groups are more expensive that normal groups, reducing them to normal groups when possible can make a big difference. Note that, while the results of the strength-reduced composition are theoretically equivalent, there may be small differences in practice due to numerical errors, especially when using low precision. This is unlikely to be an issue, but, just in case, allow disabling this optimization using the GIMP_NO_PASS_THROUGH_STRENGTH_REDUCTION environment variable.
2017-12-07 03:06:16 +08:00
gimp_layer_update_effective_mode (layer);
if (GIMP_LAYER_CLASS (parent_class)->mask_changed)
GIMP_LAYER_CLASS (parent_class)->mask_changed (layer);
}
static void
gimp_group_layer_get_effective_mode (GimpLayer *layer,
GimpLayerMode *mode,
GimpLayerColorSpace *blend_space,
GimpLayerColorSpace *composite_space,
GimpLayerCompositeMode *composite_mode)
{
GimpGroupLayerPrivate *private = GET_PRIVATE (layer);
/* try to strength-reduce pass-through groups to normal groups, which are
* cheaper.
*/
if (gimp_layer_get_mode (layer) == GIMP_LAYER_MODE_PASS_THROUGH &&
! no_pass_through_strength_reduction)
{
/* we perform the strength-reduction if:
*
* - the group has no active children;
*
* or,
*
* - the group has a single active child; or,
*
* - the effective mode of all the active children is normal, their
app, pdb, libgimp, plug-ins, menus: rename layer composite modes Our composite modes don't correspond directly to the Porter-Duff operators after which they're named, and these names aren't too descriptive anyway. Rename the composite modes as follows: Source Over => Union Source Atop => Clip to Backdrop Destination Atop => Clip to Layer Source In => Intersection Update relevant code, including UI text, enumerator names, function names, and action names.
2018-03-15 02:52:10 +08:00
* effective composite mode is UNION, and their effective blend and
* composite spaces are equal;
app: strength-reduce pass-through groups to normal groups Override GimpLayer::get_effective_mode() in GimpGroupLayer, to perform strength-reduction of pass-through groups to normal groups under certain conditions (see gimp_group_layer_get_effective_mode() for the logic.) The main motivation for this is the fact that Photoshop uses pass- through mode as the default mode for groups, resulting in many PSDs using pass-through groups generously and unnecessarily. Since pass-through groups are more expensive that normal groups, reducing them to normal groups when possible can make a big difference. Note that, while the results of the strength-reduced composition are theoretically equivalent, there may be small differences in practice due to numerical errors, especially when using low precision. This is unlikely to be an issue, but, just in case, allow disabling this optimization using the GIMP_NO_PASS_THROUGH_STRENGTH_REDUCTION environment variable.
2017-12-07 03:06:16 +08:00
*
* - and,
*
* - the group's opacity is 100%, and it has no mask; or,
*
* - the group's composite space equals the active children's
* composite space.
*/
GList *list;
gboolean reduce = TRUE;
gboolean first = TRUE;
*mode = GIMP_LAYER_MODE_NORMAL;
*blend_space = gimp_layer_get_real_blend_space (layer);
*composite_space = gimp_layer_get_real_composite_space (layer);
*composite_mode = gimp_layer_get_real_composite_mode (layer);
for (list = gimp_item_stack_get_item_iter (GIMP_ITEM_STACK (private->children));
list;
list = g_list_next (list))
{
GimpLayer *child = list->data;
if (! gimp_filter_get_active (GIMP_FILTER (child)))
continue;
if (first)
{
gimp_layer_get_effective_mode (child,
mode,
blend_space,
composite_space,
composite_mode);
if (*mode == GIMP_LAYER_MODE_NORMAL_LEGACY)
*mode = GIMP_LAYER_MODE_NORMAL;
first = FALSE;
}
else
{
GimpLayerMode other_mode;
GimpLayerColorSpace other_blend_space;
GimpLayerColorSpace other_composite_space;
GimpLayerCompositeMode other_composite_mode;
if (*mode != GIMP_LAYER_MODE_NORMAL ||
app, pdb, libgimp, plug-ins, menus: rename layer composite modes Our composite modes don't correspond directly to the Porter-Duff operators after which they're named, and these names aren't too descriptive anyway. Rename the composite modes as follows: Source Over => Union Source Atop => Clip to Backdrop Destination Atop => Clip to Layer Source In => Intersection Update relevant code, including UI text, enumerator names, function names, and action names.
2018-03-15 02:52:10 +08:00
*composite_mode != GIMP_LAYER_COMPOSITE_UNION)
app: strength-reduce pass-through groups to normal groups Override GimpLayer::get_effective_mode() in GimpGroupLayer, to perform strength-reduction of pass-through groups to normal groups under certain conditions (see gimp_group_layer_get_effective_mode() for the logic.) The main motivation for this is the fact that Photoshop uses pass- through mode as the default mode for groups, resulting in many PSDs using pass-through groups generously and unnecessarily. Since pass-through groups are more expensive that normal groups, reducing them to normal groups when possible can make a big difference. Note that, while the results of the strength-reduced composition are theoretically equivalent, there may be small differences in practice due to numerical errors, especially when using low precision. This is unlikely to be an issue, but, just in case, allow disabling this optimization using the GIMP_NO_PASS_THROUGH_STRENGTH_REDUCTION environment variable.
2017-12-07 03:06:16 +08:00
{
reduce = FALSE;
break;
}
gimp_layer_get_effective_mode (child,
&other_mode,
&other_blend_space,
&other_composite_space,
&other_composite_mode);
if (other_mode == GIMP_LAYER_MODE_NORMAL_LEGACY)
other_mode = GIMP_LAYER_MODE_NORMAL;
if (other_mode != *mode ||
other_blend_space != *blend_space ||
other_composite_space != *composite_space ||
other_composite_mode != *composite_mode)
{
reduce = FALSE;
break;
}
}
}
if (reduce)
{
if (first ||
(gimp_layer_get_opacity (layer) == GIMP_OPACITY_OPAQUE &&
! gimp_layer_get_mask (layer)) ||
*composite_space == gimp_layer_get_real_composite_space (layer))
{
/* strength reduction succeeded! */
return;
}
}
}
/* strength-reduction failed. chain up. */
GIMP_LAYER_CLASS (parent_class)->get_effective_mode (layer,
mode,
blend_space,
composite_space,
composite_mode);
}
app: handle excludes_backdrop in GimpGroupLayer When any of the children of a pass-through group excludes its backdrop, the group itself should exclude the backdrop too. Override get_excludes_backdrop() to follow this logic, and call update_excludes_backdrop() when this condition might change. Note that we always composite pass-through groups using src-over mode, so to actually hide the backdrop, we need to disconnect it from the group's mode node's input pad (and reconnect it, when the backdrop is no longer hidden).
2017-05-09 03:06:00 +08:00
static gboolean
gimp_group_layer_get_excludes_backdrop (GimpLayer *layer)
{
app: flush group proj. switching from pass-through to non-pass-through When switching a group layer from pass-through mode to a non-pass- through mode, flush the projection synchrnously, to make sure that the projection's buffer gets properly invalidated at that point, and can be subsequently used as a source for the rest of the composition. Add a boolean 'pass_through' member to GimpGroupLayerPrivate, which indicates if the group is a pass-through group, and use it instead of checking the group's mode, so that we can detect that the group used to be a pass-through group when the mode changes, and to simplify the rest of the code.
2017-12-03 04:25:04 +08:00
GimpGroupLayerPrivate *private = GET_PRIVATE (layer);
if (private->pass_through)
app: handle excludes_backdrop in GimpGroupLayer When any of the children of a pass-through group excludes its backdrop, the group itself should exclude the backdrop too. Override get_excludes_backdrop() to follow this logic, and call update_excludes_backdrop() when this condition might change. Note that we always composite pass-through groups using src-over mode, so to actually hide the backdrop, we need to disconnect it from the group's mode node's input pad (and reconnect it, when the backdrop is no longer hidden).
2017-05-09 03:06:00 +08:00
{
app: flush group proj. switching from pass-through to non-pass-through When switching a group layer from pass-through mode to a non-pass- through mode, flush the projection synchrnously, to make sure that the projection's buffer gets properly invalidated at that point, and can be subsequently used as a source for the rest of the composition. Add a boolean 'pass_through' member to GimpGroupLayerPrivate, which indicates if the group is a pass-through group, and use it instead of checking the group's mode, so that we can detect that the group used to be a pass-through group when the mode changes, and to simplify the rest of the code.
2017-12-03 04:25:04 +08:00
GList *list;
app: handle excludes_backdrop in GimpGroupLayer When any of the children of a pass-through group excludes its backdrop, the group itself should exclude the backdrop too. Override get_excludes_backdrop() to follow this logic, and call update_excludes_backdrop() when this condition might change. Note that we always composite pass-through groups using src-over mode, so to actually hide the backdrop, we need to disconnect it from the group's mode node's input pad (and reconnect it, when the backdrop is no longer hidden).
2017-05-09 03:06:00 +08:00
for (list = gimp_item_stack_get_item_iter (GIMP_ITEM_STACK (private->children));
list;
list = g_list_next (list))
{
app: add GimpFilter::active property; move ::visible to GimpItem Add an "active" property to GimpFilter, which replaces its "visible" property. The new property assumes the lower-level role "visible" had -- controlling whether the filter has any effect as part of its parent filter-stack. Add a "visible" property to GimpItem, separate from the "active" property, which assumes the higher-level role "visible" had -- controlling whether the item is considered "visible", as per the GUI. By default, the item's "visible" property is bound to the filter's "active" property, so that changes in visibility directly affect the filter's "activeness"; this binding can be controlled using the new gimp_item_bind_visible_to_active() function. This distinction is currently necessary for floating selections. Floating selection layers must not be active in their parent stack, regardless of their visibility, in particular, so that their mode node doesn't hide the entire backdrop when their composite mode excludes the backdrop (i.e., when it's dst-atop or src-in). Instead, their visibility should affect the activeness of the floating-selection filter of the drawable they're attached to. This is handled by the next commit.
2017-12-06 02:46:50 +08:00
GimpFilter *child = list->data;
app: handle excludes_backdrop in GimpGroupLayer When any of the children of a pass-through group excludes its backdrop, the group itself should exclude the backdrop too. Override get_excludes_backdrop() to follow this logic, and call update_excludes_backdrop() when this condition might change. Note that we always composite pass-through groups using src-over mode, so to actually hide the backdrop, we need to disconnect it from the group's mode node's input pad (and reconnect it, when the backdrop is no longer hidden).
2017-05-09 03:06:00 +08:00
app: add GimpFilter::active property; move ::visible to GimpItem Add an "active" property to GimpFilter, which replaces its "visible" property. The new property assumes the lower-level role "visible" had -- controlling whether the filter has any effect as part of its parent filter-stack. Add a "visible" property to GimpItem, separate from the "active" property, which assumes the higher-level role "visible" had -- controlling whether the item is considered "visible", as per the GUI. By default, the item's "visible" property is bound to the filter's "active" property, so that changes in visibility directly affect the filter's "activeness"; this binding can be controlled using the new gimp_item_bind_visible_to_active() function. This distinction is currently necessary for floating selections. Floating selection layers must not be active in their parent stack, regardless of their visibility, in particular, so that their mode node doesn't hide the entire backdrop when their composite mode excludes the backdrop (i.e., when it's dst-atop or src-in). Instead, their visibility should affect the activeness of the floating-selection filter of the drawable they're attached to. This is handled by the next commit.
2017-12-06 02:46:50 +08:00
if (gimp_filter_get_active (child) &&
app: handle excludes_backdrop in GimpGroupLayer When any of the children of a pass-through group excludes its backdrop, the group itself should exclude the backdrop too. Override get_excludes_backdrop() to follow this logic, and call update_excludes_backdrop() when this condition might change. Note that we always composite pass-through groups using src-over mode, so to actually hide the backdrop, we need to disconnect it from the group's mode node's input pad (and reconnect it, when the backdrop is no longer hidden).
2017-05-09 03:06:00 +08:00
gimp_layer_get_excludes_backdrop (GIMP_LAYER (child)))
return TRUE;
}
return FALSE;
}
else
return GIMP_LAYER_CLASS (parent_class)->get_excludes_backdrop (layer);
}
app: replace GimpProjectable::get_image_type() by ::get_format() and change semantics to returning the format it wants to be projected in, not its actual format.
2012-03-30 03:09:37 +08:00
static const Babl *
gimp_group_layer_get_format (GimpProjectable *projectable)
{
app: remove drawable->private->format, its buffer has a format already Also, make group layer type conversion much less hackish by using the same kind of temporary states that are used for reallocating its projection on size change.
2012-03-30 05:19:27 +08:00
GimpGroupLayerPrivate *private = GET_PRIVATE (projectable);
GimpImageBaseType base_type;
app: make group layer type conversion depend on less side conditions gimp_group_layer_convert_type() required the image's precision to be already set to the new value.
2012-09-29 02:58:40 +08:00
GimpPrecision precision;
app: replace GimpProjectable::get_image_type() by ::get_format() and change semantics to returning the format it wants to be projected in, not its actual format.
2012-03-30 03:09:37 +08:00
app: remove drawable->private->format, its buffer has a format already Also, make group layer type conversion much less hackish by using the same kind of temporary states that are used for reallocating its projection on size change.
2012-03-30 05:19:27 +08:00
if (private->convert_format)
return private->convert_format;
app: replace GimpProjectable::get_image_type() by ::get_format() and change semantics to returning the format it wants to be projected in, not its actual format.
2012-03-30 03:09:37 +08:00
app: use gimp_drawable_get_base_type() instead of GIMP_IMAGE_TYPE_BASE_TYPE()
2012-04-07 07:51:08 +08:00
base_type = gimp_drawable_get_base_type (GIMP_DRAWABLE (projectable));
app: make group layer type conversion depend on less side conditions gimp_group_layer_convert_type() required the image's precision to be already set to the new value.
2012-09-29 02:58:40 +08:00
precision = gimp_drawable_get_precision (GIMP_DRAWABLE (projectable));
app: replace GimpProjectable::get_image_type() by ::get_format() and change semantics to returning the format it wants to be projected in, not its actual format.
2012-03-30 03:09:37 +08:00
app: make group layer type conversion depend on less side conditions gimp_group_layer_convert_type() required the image's precision to be already set to the new value.
2012-09-29 02:58:40 +08:00
return get_projection_format (projectable, base_type, precision);
app: replace GimpProjectable::get_image_type() by ::get_format() and change semantics to returning the format it wants to be projected in, not its actual format.
2012-03-30 03:09:37 +08:00
}
Add a projection to GimpGroupLayer so we finally have a *visible* layer tree Implement the GimpProjectable interface and keep a GimpProjection around that projects the GimpDrawableStack of our children. Propagate the childrens' "update" signals to our own "update" signal so our parent projection picks up all changes.
2009-08-24 22:03:21 +08:00
static GeglNode *
gimp_group_layer_get_graph (GimpProjectable *projectable)
{
app: move all GimpGroupLayer members to a private struct
2011-02-04 05:29:25 +08:00
GimpGroupLayer *group = GIMP_GROUP_LAYER (projectable);
GimpGroupLayerPrivate *private = GET_PRIVATE (projectable);
app: implement pass-through mode in GimpGroupLayer Override GimpDrawable::get_source_node() for GimpGroupLayer. Use a node that contains both the drawable's buffer-source node, and the layer stack's graph node. Choose which one of these to connect to the source node's output based on the group's layer mode: the stack graph for pass-through mode, and the buffer-source node for all the rest. When in pass-through mode, connect the source node's input (which receives the backdrop) to the stack graph's input. Keep maintaining the projection in pass-through mode. ATM, the projection uses the same graph as the source node, so it's rendered against the group's backdrop -- we don't want that. The next few commits fix it. Update the group's drawable directly upon filter stack update in pass-though mode, because the group's graph doesn't go through the projection. TODO: if any of the group's children (or a child of a nested pass- through group, etc.) uses dst-atop/src-in, this needs special attention.
2017-04-22 06:04:49 +08:00
GeglNode *input;
app: move all GimpGroupLayer members to a private struct
2011-02-04 05:29:25 +08:00
GeglNode *layers_node;
GeglNode *output;
gint off_x;
gint off_y;
Fix the layer-offset of the group layer's projection graph Insert a gegl:translate node into the group layer's projection graph. Produces identical results as the legacy projection now, but is not yet switched on by checking View->Use Gegl.
2009-08-25 04:01:16 +08:00
app: move all GimpGroupLayer members to a private struct
2011-02-04 05:29:25 +08:00
if (private->graph)
return private->graph;
Fix the layer-offset of the group layer's projection graph Insert a gegl:translate node into the group layer's projection graph. Produces identical results as the legacy projection now, but is not yet switched on by checking View->Use Gegl.
2009-08-25 04:01:16 +08:00
app: move all GimpGroupLayer members to a private struct
2011-02-04 05:29:25 +08:00
private->graph = gegl_node_new ();
Fix the layer-offset of the group layer's projection graph Insert a gegl:translate node into the group layer's projection graph. Produces identical results as the legacy projection now, but is not yet switched on by checking View->Use Gegl.
2009-08-25 04:01:16 +08:00
app: implement pass-through mode in GimpGroupLayer Override GimpDrawable::get_source_node() for GimpGroupLayer. Use a node that contains both the drawable's buffer-source node, and the layer stack's graph node. Choose which one of these to connect to the source node's output based on the group's layer mode: the stack graph for pass-through mode, and the buffer-source node for all the rest. When in pass-through mode, connect the source node's input (which receives the backdrop) to the stack graph's input. Keep maintaining the projection in pass-through mode. ATM, the projection uses the same graph as the source node, so it's rendered against the group's backdrop -- we don't want that. The next few commits fix it. Update the group's drawable directly upon filter stack update in pass-though mode, because the group's graph doesn't go through the projection. TODO: if any of the group's children (or a child of a nested pass- through group, etc.) uses dst-atop/src-in, this needs special attention.
2017-04-22 06:04:49 +08:00
input = gegl_node_get_input_proxy (private->graph, "input");
Fix the layer-offset of the group layer's projection graph Insert a gegl:translate node into the group layer's projection graph. Produces identical results as the legacy projection now, but is not yet switched on by checking View->Use Gegl.
2009-08-25 04:01:16 +08:00
layers_node =
app: add new class GimpFilterStack factored out of GimpDrawableStack and make it the parent class of GimpItemStack. Which means we now have a generic stack of filters independent of any image items.
2013-04-11 10:12:10 +08:00
gimp_filter_stack_get_graph (GIMP_FILTER_STACK (private->children));
Fix the layer-offset of the group layer's projection graph Insert a gegl:translate node into the group layer's projection graph. Produces identical results as the legacy projection now, but is not yet switched on by checking View->Use Gegl.
2009-08-25 04:01:16 +08:00
app: move all GimpGroupLayer members to a private struct
2011-02-04 05:29:25 +08:00
gegl_node_add_child (private->graph, layers_node);
Add a projection to GimpGroupLayer so we finally have a *visible* layer tree Implement the GimpProjectable interface and keep a GimpProjection around that projects the GimpDrawableStack of our children. Propagate the childrens' "update" signals to our own "update" signal so our parent projection picks up all changes.
2009-08-24 22:03:21 +08:00
app: implement pass-through mode in GimpGroupLayer Override GimpDrawable::get_source_node() for GimpGroupLayer. Use a node that contains both the drawable's buffer-source node, and the layer stack's graph node. Choose which one of these to connect to the source node's output based on the group's layer mode: the stack graph for pass-through mode, and the buffer-source node for all the rest. When in pass-through mode, connect the source node's input (which receives the backdrop) to the stack graph's input. Keep maintaining the projection in pass-through mode. ATM, the projection uses the same graph as the source node, so it's rendered against the group's backdrop -- we don't want that. The next few commits fix it. Update the group's drawable directly upon filter stack update in pass-though mode, because the group's graph doesn't go through the projection. TODO: if any of the group's children (or a child of a nested pass- through group, etc.) uses dst-atop/src-in, this needs special attention.
2017-04-22 06:04:49 +08:00
gegl_node_connect_to (input, "output",
layers_node, "input");
Fix the layer-offset of the group layer's projection graph Insert a gegl:translate node into the group layer's projection graph. Produces identical results as the legacy projection now, but is not yet switched on by checking View->Use Gegl.
2009-08-25 04:01:16 +08:00
gimp_item_get_offset (GIMP_ITEM (group), &off_x, &off_y);
app: move all GimpGroupLayer members to a private struct
2011-02-04 05:29:25 +08:00
private->offset_node = gegl_node_new_child (private->graph,
"operation", "gegl:translate",
"x", (gdouble) -off_x,
"y", (gdouble) -off_y,
NULL);
Fix the layer-offset of the group layer's projection graph Insert a gegl:translate node into the group layer's projection graph. Produces identical results as the legacy projection now, but is not yet switched on by checking View->Use Gegl.
2009-08-25 04:01:16 +08:00
app: move all GimpGroupLayer members to a private struct
2011-02-04 05:29:25 +08:00
gegl_node_connect_to (layers_node, "output",
private->offset_node, "input");
Fix the layer-offset of the group layer's projection graph Insert a gegl:translate node into the group layer's projection graph. Produces identical results as the legacy projection now, but is not yet switched on by checking View->Use Gegl.
2009-08-25 04:01:16 +08:00
app: move all GimpGroupLayer members to a private struct
2011-02-04 05:29:25 +08:00
output = gegl_node_get_output_proxy (private->graph, "output");
Fix the layer-offset of the group layer's projection graph Insert a gegl:translate node into the group layer's projection graph. Produces identical results as the legacy projection now, but is not yet switched on by checking View->Use Gegl.
2009-08-25 04:01:16 +08:00
app: move all GimpGroupLayer members to a private struct
2011-02-04 05:29:25 +08:00
gegl_node_connect_to (private->offset_node, "output",
output, "input");
Fix the layer-offset of the group layer's projection graph Insert a gegl:translate node into the group layer's projection graph. Produces identical results as the legacy projection now, but is not yet switched on by checking View->Use Gegl.
2009-08-25 04:01:16 +08:00
app: move all GimpGroupLayer members to a private struct
2011-02-04 05:29:25 +08:00
return private->graph;
Add a projection to GimpGroupLayer so we finally have a *visible* layer tree Implement the GimpProjectable interface and keep a GimpProjection around that projects the GimpDrawableStack of our children. Propagate the childrens' "update" signals to our own "update" signal so our parent projection picks up all changes.
2009-08-24 22:03:21 +08:00
}
app: implement {begin,end}_render() for GimpGroupLayer Use them to connect/disconnect the stack graph when the group is in pass-through mode.
2017-04-23 02:28:54 +08:00
static void
gimp_group_layer_begin_render (GimpProjectable *projectable)
{
GimpGroupLayerPrivate *private = GET_PRIVATE (projectable);
if (private->source_node == NULL)
return;
app: flush group proj. switching from pass-through to non-pass-through When switching a group layer from pass-through mode to a non-pass- through mode, flush the projection synchrnously, to make sure that the projection's buffer gets properly invalidated at that point, and can be subsequently used as a source for the rest of the composition. Add a boolean 'pass_through' member to GimpGroupLayerPrivate, which indicates if the group is a pass-through group, and use it instead of checking the group's mode, so that we can detect that the group used to be a pass-through group when the mode changes, and to simplify the rest of the code.
2017-12-03 04:25:04 +08:00
if (private->pass_through)
gegl_node_disconnect (private->graph, "input");
app: implement {begin,end}_render() for GimpGroupLayer Use them to connect/disconnect the stack graph when the group is in pass-through mode.
2017-04-23 02:28:54 +08:00
}
static void
gimp_group_layer_end_render (GimpProjectable *projectable)
{
GimpGroupLayerPrivate *private = GET_PRIVATE (projectable);
if (private->source_node == NULL)
return;
app: flush group proj. switching from pass-through to non-pass-through When switching a group layer from pass-through mode to a non-pass- through mode, flush the projection synchrnously, to make sure that the projection's buffer gets properly invalidated at that point, and can be subsequently used as a source for the rest of the composition. Add a boolean 'pass_through' member to GimpGroupLayerPrivate, which indicates if the group is a pass-through group, and use it instead of checking the group's mode, so that we can detect that the group used to be a pass-through group when the mode changes, and to simplify the rest of the code.
2017-12-03 04:25:04 +08:00
if (private->pass_through)
app: implement {begin,end}_render() for GimpGroupLayer Use them to connect/disconnect the stack graph when the group is in pass-through mode.
2017-04-23 02:28:54 +08:00
{
GeglNode *input;
input = gegl_node_get_input_proxy (private->source_node, "input");
gegl_node_connect_to (input, "output",
private->graph, "input");
}
}
app: return double not int from GimpPickable::get_opacity_at() and fix GimpLayer's impl to honor the mask also for layers without alpha.
2012-04-21 22:05:49 +08:00
static gdouble
Bug 612931 - Moving individual layer in layer group not possible with Move Tool in 'pick a layer' mode When using GimpPickable::get_opacity_at(), don't consider group layers as having content.
2011-08-20 21:01:46 +08:00
gimp_group_layer_get_opacity_at (GimpPickable *pickable,
gint x,
gint y)
{
/* Only consider child layers as having content */
app: return double not int from GimpPickable::get_opacity_at() and fix GimpLayer's impl to honor the mask also for layers without alpha.
2012-04-21 22:05:49 +08:00
return GIMP_OPACITY_TRANSPARENT;
Bug 612931 - Moving individual layer in layer group not possible with Move Tool in 'pick a layer' mode When using GimpPickable::get_opacity_at(), don't consider group layers as having content.
2011-08-20 21:01:46 +08:00
}
Add a projection to GimpGroupLayer so we finally have a *visible* layer tree Implement the GimpProjectable interface and keep a GimpProjection around that projects the GimpDrawableStack of our children. Propagate the childrens' "update" signals to our own "update" signal so our parent projection picks up all changes.
2009-08-24 22:03:21 +08:00
/* public functions */
Add a GimpGroupLayer class (not used yet)
2009-08-04 05:24:46 +08:00
GimpLayer *
gimp_group_layer_new (GimpImage *image)
{
Change local variable names from "layer" to "group"
2009-08-24 06:34:12 +08:00
GimpGroupLayer *group;
app: use gimp_image_get_layer_format() instead of dealing with image_type
2012-04-07 06:46:59 +08:00
const Babl *format;
Add a GimpGroupLayer class (not used yet)
2009-08-04 05:24:46 +08:00
g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);
app: use gimp_image_get_layer_format() instead of dealing with image_type
2012-04-07 06:46:59 +08:00
format = gimp_image_get_layer_format (image, TRUE);
Add a GimpGroupLayer class (not used yet)
2009-08-04 05:24:46 +08:00
app: finally get rid of gimp_item_configure() and drawable_configure() and turn them into gimp_item_new() and gimp_drawable_new()
2011-02-01 19:47:24 +08:00
group = GIMP_GROUP_LAYER (gimp_drawable_new (GIMP_TYPE_GROUP_LAYER,
image, NULL,
0, 0, 1, 1,
app: use gimp_image_get_layer_format() instead of dealing with image_type
2012-04-07 06:46:59 +08:00
format));
Add a GimpGroupLayer class (not used yet)
2009-08-04 05:24:46 +08:00
app: use default new-layer mode for layer groups and text layers When creating a layer group, or a text layer, use the image's default new-layer mode, instead of always using (non-legacy) NORMAL.
2018-06-06 14:36:50 +08:00
gimp_layer_set_mode (GIMP_LAYER (group),
gimp_image_get_default_new_layer_mode (image),
FALSE);
Change local variable names from "layer" to "group"
2009-08-24 06:34:12 +08:00
return GIMP_LAYER (group);
Add a GimpGroupLayer class (not used yet)
2009-08-04 05:24:46 +08:00
}
Automatically adjust the size of group layers Connect to size and offset of all children and resize/move the group layer accordingly.
2009-08-24 05:00:32 +08:00
app: move all GimpGroupLayer members to a private struct
2011-02-04 05:29:25 +08:00
GimpProjection *
gimp_group_layer_get_projection (GimpGroupLayer *group)
{
g_return_val_if_fail (GIMP_IS_GROUP_LAYER (group), NULL);
return GET_PRIVATE (group)->projection;
}
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
void
gimp_group_layer_suspend_resize (GimpGroupLayer *group,
gboolean push_undo)
{
GimpItem *item;
g_return_if_fail (GIMP_IS_GROUP_LAYER (group));
item = GIMP_ITEM (group);
if (! gimp_item_is_attached (item))
push_undo = FALSE;
if (push_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
gimp_image_undo_push_group_layer_suspend_resize (gimp_item_get_image (item),
NULL, 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
app: move all GimpGroupLayer members to a private struct
2011-02-04 05:29:25 +08:00
GET_PRIVATE (group)->suspend_resize++;
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
}
void
gimp_group_layer_resume_resize (GimpGroupLayer *group,
gboolean push_undo)
{
app: move all GimpGroupLayer members to a private struct
2011-02-04 05:29:25 +08:00
GimpGroupLayerPrivate *private;
GimpItem *item;
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
GimpItem *mask = NULL;
GeglBuffer *mask_buffer;
GeglRectangle mask_bounds;
GimpUndo *undo;
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_return_if_fail (GIMP_IS_GROUP_LAYER (group));
app: move all GimpGroupLayer members to a private struct
2011-02-04 05:29:25 +08:00
private = GET_PRIVATE (group);
g_return_if_fail (private->suspend_resize > 0);
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
item = GIMP_ITEM (group);
if (! gimp_item_is_attached (item))
push_undo = FALSE;
if (push_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
{
undo =
gimp_image_undo_push_group_layer_resume_resize (gimp_item_get_image (item),
NULL, group);
/* if there were any {suspend,resume}_mask() calls during the time the
* group's size was suspended, the resume_mask() calls will not have seen
* any changes to the mask, and will therefore won't restore the mask
* during undo. if the group's bounding box did change while resize was
* suspended, and if there are no other {suspend,resume}_mask() blocks
* that will see the resized mask, we have to restore the mask during the
* resume_resize() undo.
*
* we ref the mask buffer here, and compare it to the mask buffer after
* updating the size.
*/
if (private->suspend_resize == 1 && private->suspend_mask == 0)
{
mask = GIMP_ITEM (gimp_layer_get_mask (GIMP_LAYER (group)));
if (mask)
{
mask_buffer =
g_object_ref (gimp_drawable_get_buffer (GIMP_DRAWABLE (mask)));
mask_bounds.x = gimp_item_get_offset_x (mask);
mask_bounds.y = gimp_item_get_offset_y (mask);
mask_bounds.width = gimp_item_get_width (mask);
mask_bounds.height = gimp_item_get_height (mask);
}
}
}
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: move all GimpGroupLayer members to a private struct
2011-02-04 05:29:25 +08:00
private->suspend_resize--;
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: move all GimpGroupLayer members to a private struct
2011-02-04 05:29:25 +08:00
if (private->suspend_resize == 0)
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_group_layer_update_size (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
if (mask)
{
/* if the mask changed, make sure it's restored during undo, as per
* the comment above.
*/
if (gimp_drawable_get_buffer (GIMP_DRAWABLE (mask)) != mask_buffer)
{
g_return_if_fail (undo != NULL);
GIMP_GROUP_LAYER_UNDO (undo)->mask_buffer = mask_buffer;
GIMP_GROUP_LAYER_UNDO (undo)->mask_bounds = mask_bounds;
}
else
{
g_object_unref (mask_buffer);
}
}
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
void
gimp_group_layer_suspend_mask (GimpGroupLayer *group,
gboolean push_undo)
{
GimpGroupLayerPrivate *private;
GimpItem *item;
g_return_if_fail (GIMP_IS_GROUP_LAYER (group));
private = GET_PRIVATE (group);
item = GIMP_ITEM (group);
app: avoid pushing undo for nested gimp_group_layer_{suspend,resume}_mask() ... in order not to overshoot the undo-stack estimated memory- usage. See comment in the code.
2018-04-22 15:36:27 +08:00
/* avoid pushing an undo step if this is a nested suspend_mask() call, since
* the value of 'push_undo' in nested calls should be the same as that passed
* to the outermost call, and only pushing an undo step for the outermost
* call in this case is enough. we can't support cases where the values of
* 'push_undo' in nested calls are different in a meaningful way, and
* avoiding undo steps for nested calls prevents us from storing multiple
* references to the suspend mask buffer on the undo stack. while storing
* multiple references to the buffer doesn't waste any memory (since all the
* references are to the same buffer), it does cause the undo stack memory-
* usage estimation to overshoot, potentially resulting in undo steps being
* dropped unnecessarily.
*/
if (! gimp_item_is_attached (item) || private->suspend_mask > 0)
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
push_undo = FALSE;
if (push_undo)
gimp_image_undo_push_group_layer_suspend_mask (gimp_item_get_image (item),
NULL, group);
if (private->suspend_mask == 0)
{
if (gimp_layer_get_mask (GIMP_LAYER (group)))
{
GimpItem *mask = GIMP_ITEM (gimp_layer_get_mask (GIMP_LAYER (group)));
private->suspended_mask_buffer =
g_object_ref (gimp_drawable_get_buffer (GIMP_DRAWABLE (mask)));
private->suspended_mask_bounds.x = gimp_item_get_offset_x (mask);
private->suspended_mask_bounds.y = gimp_item_get_offset_y (mask);
private->suspended_mask_bounds.width = gimp_item_get_width (mask);
private->suspended_mask_bounds.height = gimp_item_get_height (mask);
}
else
{
private->suspended_mask_buffer = NULL;
}
}
private->suspend_mask++;
}
void
gimp_group_layer_resume_mask (GimpGroupLayer *group,
gboolean push_undo)
{
GimpGroupLayerPrivate *private;
GimpItem *item;
g_return_if_fail (GIMP_IS_GROUP_LAYER (group));
private = GET_PRIVATE (group);
g_return_if_fail (private->suspend_mask > 0);
item = GIMP_ITEM (group);
app: avoid pushing undo for nested gimp_group_layer_{suspend,resume}_mask() ... in order not to overshoot the undo-stack estimated memory- usage. See comment in the code.
2018-04-22 15:36:27 +08:00
/* avoid pushing an undo step if this is a nested resume_mask() call. see
* the comment in gimp_group_layer_suspend_mask().
*/
if (! gimp_item_is_attached (item) || private->suspend_mask > 1)
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
push_undo = FALSE;
if (push_undo)
gimp_image_undo_push_group_layer_resume_mask (gimp_item_get_image (item),
NULL, group);
private->suspend_mask--;
if (private->suspend_mask == 0)
g_clear_object (&private->suspended_mask_buffer);
}
/* protected functions */
void
_gimp_group_layer_set_suspended_mask (GimpGroupLayer *group,
GeglBuffer *buffer,
const GeglRectangle *bounds)
{
GimpGroupLayerPrivate *private;
g_return_if_fail (GIMP_IS_GROUP_LAYER (group));
g_return_if_fail (buffer != NULL);
g_return_if_fail (bounds != NULL);
private = GET_PRIVATE (group);
g_return_if_fail (private->suspend_mask > 0);
g_object_ref (buffer);
g_clear_object (&private->suspended_mask_buffer);
private->suspended_mask_buffer = buffer;
private->suspended_mask_bounds = *bounds;
}
GeglBuffer *
_gimp_group_layer_get_suspended_mask (GimpGroupLayer *group,
GeglRectangle *bounds)
{
GimpGroupLayerPrivate *private;
GimpLayerMask *mask;
g_return_val_if_fail (GIMP_IS_GROUP_LAYER (group), NULL);
g_return_val_if_fail (bounds != NULL, NULL);
private = GET_PRIVATE (group);
mask = gimp_layer_get_mask (GIMP_LAYER (group));
g_return_val_if_fail (private->suspend_mask > 0, NULL);
if (mask &&
gimp_drawable_get_buffer (GIMP_DRAWABLE (mask)) !=
private->suspended_mask_buffer)
{
*bounds = private->suspended_mask_bounds;
return private->suspended_mask_buffer;
}
return NULL;
}
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
void
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 (GimpGroupLayer *group,
gboolean push_undo)
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
{
GimpGroupLayerPrivate *private;
GimpItem *item;
g_return_if_fail (GIMP_IS_GROUP_LAYER (group));
private = GET_PRIVATE (group);
item = GIMP_ITEM (group);
g_return_if_fail (private->suspend_mask == 0);
if (! gimp_item_is_attached (item))
push_undo = FALSE;
if (push_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
gimp_image_undo_push_group_layer_start_transform (gimp_item_get_image (item),
NULL, group);
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
private->transforming++;
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
}
void
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 (GimpGroupLayer *group,
gboolean push_undo)
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
{
GimpGroupLayerPrivate *private;
GimpItem *item;
g_return_if_fail (GIMP_IS_GROUP_LAYER (group));
private = GET_PRIVATE (group);
item = GIMP_ITEM (group);
g_return_if_fail (private->suspend_mask == 0);
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
g_return_if_fail (private->transforming > 0);
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 (! gimp_item_is_attached (item))
push_undo = FALSE;
if (push_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
gimp_image_undo_push_group_layer_end_transform (gimp_item_get_image (item),
NULL, group);
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
private->transforming--;
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
if (private->transforming == 0)
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
gimp_group_layer_update_mask_size (GIMP_GROUP_LAYER (item));
}
Automatically adjust the size of group layers Connect to size and offset of all children and resize/move the group layer accordingly.
2009-08-24 05:00:32 +08:00
/* private functions */
static void
gimp_group_layer_child_add (GimpContainer *container,
GimpLayer *child,
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
gimp_group_layer_update (group);
app: handle excludes_backdrop in GimpGroupLayer When any of the children of a pass-through group excludes its backdrop, the group itself should exclude the backdrop too. Override get_excludes_backdrop() to follow this logic, and call update_excludes_backdrop() when this condition might change. Note that we always composite pass-through groups using src-over mode, so to actually hide the backdrop, we need to disconnect it from the group's mode node's input pad (and reconnect it, when the backdrop is no longer hidden).
2017-05-09 03:06:00 +08:00
app: strength-reduce pass-through groups to normal groups Override GimpLayer::get_effective_mode() in GimpGroupLayer, to perform strength-reduction of pass-through groups to normal groups under certain conditions (see gimp_group_layer_get_effective_mode() for the logic.) The main motivation for this is the fact that Photoshop uses pass- through mode as the default mode for groups, resulting in many PSDs using pass-through groups generously and unnecessarily. Since pass-through groups are more expensive that normal groups, reducing them to normal groups when possible can make a big difference. Note that, while the results of the strength-reduced composition are theoretically equivalent, there may be small differences in practice due to numerical errors, especially when using low precision. This is unlikely to be an issue, but, just in case, allow disabling this optimization using the GIMP_NO_PASS_THROUGH_STRENGTH_REDUCTION environment variable.
2017-12-07 03:06:16 +08:00
if (gimp_filter_get_active (GIMP_FILTER (child)))
app: handle excludes_backdrop in GimpGroupLayer When any of the children of a pass-through group excludes its backdrop, the group itself should exclude the backdrop too. Override get_excludes_backdrop() to follow this logic, and call update_excludes_backdrop() when this condition might change. Note that we always composite pass-through groups using src-over mode, so to actually hide the backdrop, we need to disconnect it from the group's mode node's input pad (and reconnect it, when the backdrop is no longer hidden).
2017-05-09 03:06:00 +08:00
{
app: strength-reduce pass-through groups to normal groups Override GimpLayer::get_effective_mode() in GimpGroupLayer, to perform strength-reduction of pass-through groups to normal groups under certain conditions (see gimp_group_layer_get_effective_mode() for the logic.) The main motivation for this is the fact that Photoshop uses pass- through mode as the default mode for groups, resulting in many PSDs using pass-through groups generously and unnecessarily. Since pass-through groups are more expensive that normal groups, reducing them to normal groups when possible can make a big difference. Note that, while the results of the strength-reduced composition are theoretically equivalent, there may be small differences in practice due to numerical errors, especially when using low precision. This is unlikely to be an issue, but, just in case, allow disabling this optimization using the GIMP_NO_PASS_THROUGH_STRENGTH_REDUCTION environment variable.
2017-12-07 03:06:16 +08:00
gimp_layer_update_effective_mode (GIMP_LAYER (group));
if (gimp_layer_get_excludes_backdrop (child))
gimp_layer_update_excludes_backdrop (GIMP_LAYER (group));
app: handle excludes_backdrop in GimpGroupLayer When any of the children of a pass-through group excludes its backdrop, the group itself should exclude the backdrop too. Override get_excludes_backdrop() to follow this logic, and call update_excludes_backdrop() when this condition might change. Note that we always composite pass-through groups using src-over mode, so to actually hide the backdrop, we need to disconnect it from the group's mode node's input pad (and reconnect it, when the backdrop is no longer hidden).
2017-05-09 03:06:00 +08:00
}
Automatically adjust the size of group layers Connect to size and offset of all children and resize/move the group layer accordingly.
2009-08-24 05:00:32 +08:00
}
static void
gimp_group_layer_child_remove (GimpContainer *container,
GimpLayer *child,
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
gimp_group_layer_update (group);
app: handle excludes_backdrop in GimpGroupLayer When any of the children of a pass-through group excludes its backdrop, the group itself should exclude the backdrop too. Override get_excludes_backdrop() to follow this logic, and call update_excludes_backdrop() when this condition might change. Note that we always composite pass-through groups using src-over mode, so to actually hide the backdrop, we need to disconnect it from the group's mode node's input pad (and reconnect it, when the backdrop is no longer hidden).
2017-05-09 03:06:00 +08:00
app: strength-reduce pass-through groups to normal groups Override GimpLayer::get_effective_mode() in GimpGroupLayer, to perform strength-reduction of pass-through groups to normal groups under certain conditions (see gimp_group_layer_get_effective_mode() for the logic.) The main motivation for this is the fact that Photoshop uses pass- through mode as the default mode for groups, resulting in many PSDs using pass-through groups generously and unnecessarily. Since pass-through groups are more expensive that normal groups, reducing them to normal groups when possible can make a big difference. Note that, while the results of the strength-reduced composition are theoretically equivalent, there may be small differences in practice due to numerical errors, especially when using low precision. This is unlikely to be an issue, but, just in case, allow disabling this optimization using the GIMP_NO_PASS_THROUGH_STRENGTH_REDUCTION environment variable.
2017-12-07 03:06:16 +08:00
if (gimp_filter_get_active (GIMP_FILTER (child)))
app: handle excludes_backdrop in GimpGroupLayer When any of the children of a pass-through group excludes its backdrop, the group itself should exclude the backdrop too. Override get_excludes_backdrop() to follow this logic, and call update_excludes_backdrop() when this condition might change. Note that we always composite pass-through groups using src-over mode, so to actually hide the backdrop, we need to disconnect it from the group's mode node's input pad (and reconnect it, when the backdrop is no longer hidden).
2017-05-09 03:06:00 +08:00
{
app: strength-reduce pass-through groups to normal groups Override GimpLayer::get_effective_mode() in GimpGroupLayer, to perform strength-reduction of pass-through groups to normal groups under certain conditions (see gimp_group_layer_get_effective_mode() for the logic.) The main motivation for this is the fact that Photoshop uses pass- through mode as the default mode for groups, resulting in many PSDs using pass-through groups generously and unnecessarily. Since pass-through groups are more expensive that normal groups, reducing them to normal groups when possible can make a big difference. Note that, while the results of the strength-reduced composition are theoretically equivalent, there may be small differences in practice due to numerical errors, especially when using low precision. This is unlikely to be an issue, but, just in case, allow disabling this optimization using the GIMP_NO_PASS_THROUGH_STRENGTH_REDUCTION environment variable.
2017-12-07 03:06:16 +08:00
gimp_layer_update_effective_mode (GIMP_LAYER (group));
if (gimp_layer_get_excludes_backdrop (child))
gimp_layer_update_excludes_backdrop (GIMP_LAYER (group));
app: handle excludes_backdrop in GimpGroupLayer When any of the children of a pass-through group excludes its backdrop, the group itself should exclude the backdrop too. Override get_excludes_backdrop() to follow this logic, and call update_excludes_backdrop() when this condition might change. Note that we always composite pass-through groups using src-over mode, so to actually hide the backdrop, we need to disconnect it from the group's mode node's input pad (and reconnect it, when the backdrop is no longer hidden).
2017-05-09 03:06:00 +08:00
}
Automatically adjust the size of group layers Connect to size and offset of all children and resize/move the group layer accordingly.
2009-08-24 05:00:32 +08:00
}
static void
gimp_group_layer_child_move (GimpLayer *child,
GParamSpec *pspec,
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
gimp_group_layer_update (group);
Automatically adjust the size of group layers Connect to size and offset of all children and resize/move the group layer accordingly.
2009-08-24 05:00:32 +08:00
}
static void
gimp_group_layer_child_resize (GimpLayer *child,
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
gimp_group_layer_update (group);
}
app: handle excludes_backdrop in GimpGroupLayer When any of the children of a pass-through group excludes its backdrop, the group itself should exclude the backdrop too. Override get_excludes_backdrop() to follow this logic, and call update_excludes_backdrop() when this condition might change. Note that we always composite pass-through groups using src-over mode, so to actually hide the backdrop, we need to disconnect it from the group's mode node's input pad (and reconnect it, when the backdrop is no longer hidden).
2017-05-09 03:06:00 +08:00
static void
app: add GimpFilter::active property; move ::visible to GimpItem Add an "active" property to GimpFilter, which replaces its "visible" property. The new property assumes the lower-level role "visible" had -- controlling whether the filter has any effect as part of its parent filter-stack. Add a "visible" property to GimpItem, separate from the "active" property, which assumes the higher-level role "visible" had -- controlling whether the item is considered "visible", as per the GUI. By default, the item's "visible" property is bound to the filter's "active" property, so that changes in visibility directly affect the filter's "activeness"; this binding can be controlled using the new gimp_item_bind_visible_to_active() function. This distinction is currently necessary for floating selections. Floating selection layers must not be active in their parent stack, regardless of their visibility, in particular, so that their mode node doesn't hide the entire backdrop when their composite mode excludes the backdrop (i.e., when it's dst-atop or src-in). Instead, their visibility should affect the activeness of the floating-selection filter of the drawable they're attached to. This is handled by the next commit.
2017-12-06 02:46:50 +08:00
gimp_group_layer_child_active_changed (GimpLayer *child,
GimpGroupLayer *group)
app: handle excludes_backdrop in GimpGroupLayer When any of the children of a pass-through group excludes its backdrop, the group itself should exclude the backdrop too. Override get_excludes_backdrop() to follow this logic, and call update_excludes_backdrop() when this condition might change. Note that we always composite pass-through groups using src-over mode, so to actually hide the backdrop, we need to disconnect it from the group's mode node's input pad (and reconnect it, when the backdrop is no longer hidden).
2017-05-09 03:06:00 +08:00
{
app: strength-reduce pass-through groups to normal groups Override GimpLayer::get_effective_mode() in GimpGroupLayer, to perform strength-reduction of pass-through groups to normal groups under certain conditions (see gimp_group_layer_get_effective_mode() for the logic.) The main motivation for this is the fact that Photoshop uses pass- through mode as the default mode for groups, resulting in many PSDs using pass-through groups generously and unnecessarily. Since pass-through groups are more expensive that normal groups, reducing them to normal groups when possible can make a big difference. Note that, while the results of the strength-reduced composition are theoretically equivalent, there may be small differences in practice due to numerical errors, especially when using low precision. This is unlikely to be an issue, but, just in case, allow disabling this optimization using the GIMP_NO_PASS_THROUGH_STRENGTH_REDUCTION environment variable.
2017-12-07 03:06:16 +08:00
gimp_layer_update_effective_mode (GIMP_LAYER (group));
app: handle excludes_backdrop in GimpGroupLayer When any of the children of a pass-through group excludes its backdrop, the group itself should exclude the backdrop too. Override get_excludes_backdrop() to follow this logic, and call update_excludes_backdrop() when this condition might change. Note that we always composite pass-through groups using src-over mode, so to actually hide the backdrop, we need to disconnect it from the group's mode node's input pad (and reconnect it, when the backdrop is no longer hidden).
2017-05-09 03:06:00 +08:00
if (gimp_layer_get_excludes_backdrop (child))
gimp_layer_update_excludes_backdrop (GIMP_LAYER (group));
}
app: strength-reduce pass-through groups to normal groups Override GimpLayer::get_effective_mode() in GimpGroupLayer, to perform strength-reduction of pass-through groups to normal groups under certain conditions (see gimp_group_layer_get_effective_mode() for the logic.) The main motivation for this is the fact that Photoshop uses pass- through mode as the default mode for groups, resulting in many PSDs using pass-through groups generously and unnecessarily. Since pass-through groups are more expensive that normal groups, reducing them to normal groups when possible can make a big difference. Note that, while the results of the strength-reduced composition are theoretically equivalent, there may be small differences in practice due to numerical errors, especially when using low precision. This is unlikely to be an issue, but, just in case, allow disabling this optimization using the GIMP_NO_PASS_THROUGH_STRENGTH_REDUCTION environment variable.
2017-12-07 03:06:16 +08:00
static void
gimp_group_layer_child_effective_mode_changed (GimpLayer *child,
GimpGroupLayer *group)
{
if (gimp_filter_get_active (GIMP_FILTER (child)))
gimp_layer_update_effective_mode (GIMP_LAYER (group));
}
app: handle excludes_backdrop in GimpGroupLayer When any of the children of a pass-through group excludes its backdrop, the group itself should exclude the backdrop too. Override get_excludes_backdrop() to follow this logic, and call update_excludes_backdrop() when this condition might change. Note that we always composite pass-through groups using src-over mode, so to actually hide the backdrop, we need to disconnect it from the group's mode node's input pad (and reconnect it, when the backdrop is no longer hidden).
2017-05-09 03:06:00 +08:00
static void
gimp_group_layer_child_excludes_backdrop_changed (GimpLayer *child,
GimpGroupLayer *group)
{
app: add GimpFilter::active property; move ::visible to GimpItem Add an "active" property to GimpFilter, which replaces its "visible" property. The new property assumes the lower-level role "visible" had -- controlling whether the filter has any effect as part of its parent filter-stack. Add a "visible" property to GimpItem, separate from the "active" property, which assumes the higher-level role "visible" had -- controlling whether the item is considered "visible", as per the GUI. By default, the item's "visible" property is bound to the filter's "active" property, so that changes in visibility directly affect the filter's "activeness"; this binding can be controlled using the new gimp_item_bind_visible_to_active() function. This distinction is currently necessary for floating selections. Floating selection layers must not be active in their parent stack, regardless of their visibility, in particular, so that their mode node doesn't hide the entire backdrop when their composite mode excludes the backdrop (i.e., when it's dst-atop or src-in). Instead, their visibility should affect the activeness of the floating-selection filter of the drawable they're attached to. This is handled by the next commit.
2017-12-06 02:46:50 +08:00
if (gimp_filter_get_active (GIMP_FILTER (child)))
app: handle excludes_backdrop in GimpGroupLayer When any of the children of a pass-through group excludes its backdrop, the group itself should exclude the backdrop too. Override get_excludes_backdrop() to follow this logic, and call update_excludes_backdrop() when this condition might change. Note that we always composite pass-through groups using src-over mode, so to actually hide the backdrop, we need to disconnect it from the group's mode node's input pad (and reconnect it, when the backdrop is no longer hidden).
2017-05-09 03:06:00 +08:00
gimp_layer_update_excludes_backdrop (GIMP_LAYER (group));
}
app: flush pass-through groups' projection asynchronously The source node of pass-through groups doesn't use the projection's buffer, hence there's no need to invalidate it synchronously, which is faster.
2017-12-02 23:15:39 +08:00
static void
gimp_group_layer_flush (GimpGroupLayer *group)
{
app: flush group proj. switching from pass-through to non-pass-through When switching a group layer from pass-through mode to a non-pass- through mode, flush the projection synchrnously, to make sure that the projection's buffer gets properly invalidated at that point, and can be subsequently used as a source for the rest of the composition. Add a boolean 'pass_through' member to GimpGroupLayerPrivate, which indicates if the group is a pass-through group, and use it instead of checking the group's mode, so that we can detect that the group used to be a pass-through group when the mode changes, and to simplify the rest of the code.
2017-12-03 04:25:04 +08:00
GimpGroupLayerPrivate *private = GET_PRIVATE (group);
if (private->pass_through)
app: flush pass-through groups' projection asynchronously The source node of pass-through groups doesn't use the projection's buffer, hence there's no need to invalidate it synchronously, which is faster.
2017-12-02 23:15:39 +08:00
{
/* flush the projectable, not the pickable, because the source
* node of pass-through groups doesn't use the projection's
* buffer, hence there's no need to invalidate it synchronously.
*/
gimp_projectable_flush (GIMP_PROJECTABLE (group), TRUE);
}
else
{
app: stop idle projection rendering when flushing group layers In gimp_group_layer_flush(), stop any idle rendering, initiated when a new buffer is allocated, before flushing the group's pickable. Otherwise, the idle rendering is finished synchronously, which unnecessarily introduces a noticeable lag.
2018-08-04 01:40:07 +08:00
/* make sure we have a buffer, and stop any idle rendering, which is
* initiated when a new buffer is allocated. the call to
* gimp_pickable_flush() below causes any pending idle rendering to
* finish synchronously, so this needs to happen before.
*/
gimp_pickable_get_buffer (GIMP_PICKABLE (private->projection));
gimp_projection_stop_rendering (private->projection);
app: flush pass-through groups' projection asynchronously The source node of pass-through groups doesn't use the projection's buffer, hence there's no need to invalidate it synchronously, which is faster.
2017-12-02 23:15:39 +08:00
/* flush the pickable not the projectable because flushing the
* pickable will finish all invalidation on the projection so it
* can be used as source (note that it will still be constructed
* when the actual read happens, so this it not a performance
* problem)
*/
app: flush group proj. switching from pass-through to non-pass-through When switching a group layer from pass-through mode to a non-pass- through mode, flush the projection synchrnously, to make sure that the projection's buffer gets properly invalidated at that point, and can be subsequently used as a source for the rest of the composition. Add a boolean 'pass_through' member to GimpGroupLayerPrivate, which indicates if the group is a pass-through group, and use it instead of checking the group's mode, so that we can detect that the group used to be a pass-through group when the mode changes, and to simplify the rest of the code.
2017-12-03 04:25:04 +08:00
gimp_pickable_flush (GIMP_PICKABLE (private->projection));
app: flush pass-through groups' projection asynchronously The source node of pass-through groups doesn't use the projection's buffer, hence there's no need to invalidate it synchronously, which is faster.
2017-12-02 23:15:39 +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
static void
gimp_group_layer_update (GimpGroupLayer *group)
{
app: move all GimpGroupLayer members to a private struct
2011-02-04 05:29:25 +08:00
if (GET_PRIVATE (group)->suspend_resize == 0)
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_group_layer_update_size (group);
}
Automatically adjust the size of group layers Connect to size and offset of all children and resize/move the group layer accordingly.
2009-08-24 05:00:32 +08:00
}
static void
Change local variable names from "layer" to "group"
2009-08-24 06:34:12 +08:00
gimp_group_layer_update_size (GimpGroupLayer *group)
Automatically adjust the size of group layers Connect to size and offset of all children and resize/move the group layer accordingly.
2009-08-24 05:00:32 +08:00
{
app: move all GimpGroupLayer members to a private struct
2011-02-04 05:29:25 +08:00
GimpGroupLayerPrivate *private = GET_PRIVATE (group);
GimpItem *item = GIMP_ITEM (group);
app: resize group-layer mask after moving the group We avoid resizing the mask as a result of changes in the group's bounding box while the group is being moved (i.e., translated, rotated, etc.), so that GimpLayer transforms the original mask, rather than a cropped mask. We still need to crop the mask after we're finished moving the group, however. This commit takes care of that.
2018-02-07 22:48:00 +08:00
GimpLayer *layer = GIMP_LAYER (group);
GimpItem *mask = GIMP_ITEM (gimp_layer_get_mask (layer));
app: move all GimpGroupLayer members to a private struct
2011-02-04 05:29:25 +08:00
gint old_x = gimp_item_get_offset_x (item);
gint old_y = gimp_item_get_offset_y (item);
gint old_width = gimp_item_get_width (item);
gint old_height = gimp_item_get_height (item);
gint x = 0;
gint y = 0;
gint width = 1;
gint height = 1;
gboolean first = TRUE;
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
gboolean size_changed;
app: resize group-layer mask after moving the group We avoid resizing the mask as a result of changes in the group's bounding box while the group is being moved (i.e., translated, rotated, etc.), so that GimpLayer transforms the original mask, rather than a cropped mask. We still need to crop the mask after we're finished moving the group, however. This commit takes care of that.
2018-02-07 22:48:00 +08:00
gboolean resize_mask;
app: move all GimpGroupLayer members to a private struct
2011-02-04 05:29:25 +08:00
GList *list;
for (list = gimp_item_stack_get_item_iter (GIMP_ITEM_STACK (private->children));
Automatically adjust the size of group layers Connect to size and offset of all children and resize/move the group layer accordingly.
2009-08-24 05:00:32 +08:00
list;
list = g_list_next (list))
{
GimpItem *child = list->data;
Bug 777017 - creating an empty layer group inside an existing... ...layer group cause a bug in the existing layer size Change gimp_group_layer_get_size() to return FALSE if there are no children (there is no content). In gimp_group_layer_update_size(), skip children where get_size() returns FALSE. Fixes bogus size calculation.
2017-01-16 03:58:32 +08:00
gint child_width;
gint child_height;
if (! gimp_viewable_get_size (GIMP_VIEWABLE (child),
&child_width, &child_height))
{
/* ignore children without content (empty group layers);
* see bug 777017
*/
continue;
}
Automatically adjust the size of group layers Connect to size and offset of all children and resize/move the group layer accordingly.
2009-08-24 05:00:32 +08:00
if (first)
{
x = gimp_item_get_offset_x (child);
y = gimp_item_get_offset_y (child);
Bug 777017 - creating an empty layer group inside an existing... ...layer group cause a bug in the existing layer size Change gimp_group_layer_get_size() to return FALSE if there are no children (there is no content). In gimp_group_layer_update_size(), skip children where get_size() returns FALSE. Fixes bogus size calculation.
2017-01-16 03:58:32 +08:00
width = child_width;
height = child_height;
Automatically adjust the size of group layers Connect to size and offset of all children and resize/move the group layer accordingly.
2009-08-24 05:00:32 +08:00
first = FALSE;
}
else
{
gimp_rectangle_union (x, y, width, height,
gimp_item_get_offset_x (child),
gimp_item_get_offset_y (child),
Bug 777017 - creating an empty layer group inside an existing... ...layer group cause a bug in the existing layer size Change gimp_group_layer_get_size() to return FALSE if there are no children (there is no content). In gimp_group_layer_update_size(), skip children where get_size() returns FALSE. Fixes bogus size calculation.
2017-01-16 03:58:32 +08:00
child_width,
child_height,
Automatically adjust the size of group layers Connect to size and offset of all children and resize/move the group layer accordingly.
2009-08-24 05:00:32 +08:00
&x, &y, &width, &height);
}
}
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
size_changed = (x != old_x ||
y != old_y ||
width != old_width ||
height != old_height);
app: resize group-layer mask after moving the group We avoid resizing the mask as a result of changes in the group's bounding box while the group is being moved (i.e., translated, rotated, etc.), so that GimpLayer transforms the original mask, rather than a cropped mask. We still need to crop the mask after we're finished moving the group, however. This commit takes care of that.
2018-02-07 22:48:00 +08:00
resize_mask = mask && size_changed;
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
/* if we show the mask, invalidate the old mask area */
app: resize group-layer mask after moving the group We avoid resizing the mask as a result of changes in the group's bounding box while the group is being moved (i.e., translated, rotated, etc.), so that GimpLayer transforms the original mask, rather than a cropped mask. We still need to crop the mask after we're finished moving the group, however. This commit takes care of that.
2018-02-07 22:48:00 +08:00
if (resize_mask && gimp_layer_get_show_mask (layer))
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_drawable_update (GIMP_DRAWABLE (group),
gimp_item_get_offset_x (mask) - old_x,
gimp_item_get_offset_y (mask) - old_y,
gimp_item_get_width (mask),
gimp_item_get_height (mask));
}
if (private->reallocate_projection || size_changed)
Automatically adjust the size of group layers Connect to size and offset of all children and resize/move the group layer accordingly.
2009-08-24 05:00:32 +08:00
{
app: use gimp_projectable_bounds_changed() when resizing group layers In GimpGroupLayer, use gimp_projectable_bounds_changed() when updating the group layer's size, instead of reconstructing the projection, unless reallocation of the projection has been requested. This is more efficient, since it simply copies the content of the projection's old buffer to the new buffer, rather than re-rendering the graph.
2018-08-04 01:03:03 +08:00
GeglBuffer *buffer;
app: update group-layer item offset after updating offset node When the group's offset changes, update the item's offset *after* updating the group's offset node, so that the item's offset nodes and the group's offset node are in sync when the corresponding "notify" signals are emitted.
2017-11-25 01:21:42 +08:00
/* if the graph is already constructed, set the offset node's
* coordinates first, so the graph is in the right state when
* the projection is reallocated, see bug #730550.
Bug 730550 - Layers incorrectly positioned on screen gimp_group_layer_update_size(): update the group layer's offset node before reallocating the group's projection, or we might render the group projection's buffer with the old offsets.
2014-05-23 02:46:13 +08:00
*/
if (private->offset_node)
gegl_node_set (private->offset_node,
"x", (gdouble) -x,
"y", (gdouble) -y,
NULL);
app: flush pass-through groups' projection asynchronously The source node of pass-through groups doesn't use the projection's buffer, hence there's no need to invalidate it synchronously, which is faster.
2017-12-02 23:15:39 +08:00
/* update our offset *before* calling gimp_pickable_get_buffer(), so
app: update group-layer item offset after updating offset node When the group's offset changes, update the item's offset *after* updating the group's offset node, so that the item's offset nodes and the group's offset node are in sync when the corresponding "notify" signals are emitted.
2017-11-25 01:21:42 +08:00
* that if our graph isn't constructed yet, the offset node picks
* up the right coordinates in gimp_group_layer_get_graph().
*/
gimp_item_set_offset (item, x, y);
app: use gimp_projectable_bounds_changed() when resizing group layers In GimpGroupLayer, use gimp_projectable_bounds_changed() when updating the group layer's size, instead of reconstructing the projection, unless reallocation of the projection has been requested. This is more efficient, since it simply copies the content of the projection's old buffer to the new buffer, rather than re-rendering the graph.
2018-08-04 01:03:03 +08:00
/* temporarily change the return values of gimp_viewable_get_size()
* so the projection allocates itself correctly
*/
private->reallocate_width = width;
private->reallocate_height = height;
Automatically adjust the size of group layers Connect to size and offset of all children and resize/move the group layer accordingly.
2009-08-24 05:00:32 +08:00
app: use gimp_projectable_bounds_changed() when resizing group layers In GimpGroupLayer, use gimp_projectable_bounds_changed() when updating the group layer's size, instead of reconstructing the projection, unless reallocation of the projection has been requested. This is more efficient, since it simply copies the content of the projection's old buffer to the new buffer, rather than re-rendering the graph.
2018-08-04 01:03:03 +08:00
if (private->reallocate_projection)
{
app: fake the size of a gruop layer by overriding GimpViewable::get_size() instead of messing with GimpItem's width and height members.
2011-03-09 01:04:23 +08:00
private->reallocate_projection = FALSE;
Add a projection to GimpGroupLayer so we finally have a *visible* layer tree Implement the GimpProjectable interface and keep a GimpProjection around that projects the GimpDrawableStack of our children. Propagate the childrens' "update" signals to our own "update" signal so our parent projection picks up all changes.
2009-08-24 22:03:21 +08:00
gimp_projectable_structure_changed (GIMP_PROJECTABLE (group));
Automatically adjust the size of group layers Connect to size and offset of all children and resize/move the group layer accordingly.
2009-08-24 05:00:32 +08:00
}
else
{
app: use gimp_projectable_bounds_changed() when resizing group layers In GimpGroupLayer, use gimp_projectable_bounds_changed() when updating the group layer's size, instead of reconstructing the projection, unless reallocation of the projection has been requested. This is more efficient, since it simply copies the content of the projection's old buffer to the new buffer, rather than re-rendering the graph.
2018-08-04 01:03:03 +08:00
/* when there's no need to reallocate the projection, we call
* gimp_projectable_bounds_changed(), rather than structure_chaned(),
* so that the projection simply copies the old content over to the
* new buffer with an offset, rather than re-renders the graph.
gimp_group_layer_update_size(): remove bogus optimization The optimization here which would change only the group layer's offset if the extents of the union of its children has not changed is completely bogus. That case can only happen if one of the chldren was moved in a way that does not change the extents of all children's union, but this doesn't mean that the childrens' positions relative to each other have not changed. Instead, invalidate the entire projection to at least avoid constant reallocation of the tile pyramid. Found by group layer testing hero Tobias Jakobs. (will have to optimize real translations of the entire group (or of the only child in the group) differently)
2009-09-03 03:37:07 +08:00
*/
app: use gimp_projectable_bounds_changed() when resizing group layers In GimpGroupLayer, use gimp_projectable_bounds_changed() when updating the group layer's size, instead of reconstructing the projection, unless reallocation of the projection has been requested. This is more efficient, since it simply copies the content of the projection's old buffer to the new buffer, rather than re-rendering the graph.
2018-08-04 01:03:03 +08:00
gimp_projectable_bounds_changed (GIMP_PROJECTABLE (group),
old_x, old_y, old_width, old_height);
Automatically adjust the size of group layers Connect to size and offset of all children and resize/move the group layer accordingly.
2009-08-24 05:00:32 +08:00
}
app: use gimp_projectable_bounds_changed() when resizing group layers In GimpGroupLayer, use gimp_projectable_bounds_changed() when updating the group layer's size, instead of reconstructing the projection, unless reallocation of the projection has been requested. This is more efficient, since it simply copies the content of the projection's old buffer to the new buffer, rather than re-rendering the graph.
2018-08-04 01:03:03 +08:00
buffer = gimp_pickable_get_buffer (GIMP_PICKABLE (private->projection));
gimp_drawable_set_buffer_full (GIMP_DRAWABLE (group),
FALSE, NULL,
buffer,
x, y,
app: fix group layer drawable update during size change In gimp_group_layer_update_size(), never suspend drawable updates (and, in fact, remove the option to suspend drawable updates entirely,) and instead never update the drawable during the call to gimp_drawable_set_buffer_full(), and flush the group's projection *after* setting the drawable's buffer, so that any pending updates will happen after the group's buffer and size are up-to-date. This fixes some missed drawable updates.
2018-08-10 15:15:09 +08:00
FALSE /* don't update the drawable, the
* flush() below will take care of
* that.
*/);
gimp_group_layer_flush (group);
app: use gimp_projectable_bounds_changed() when resizing group layers In GimpGroupLayer, use gimp_projectable_bounds_changed() when updating the group layer's size, instead of reconstructing the projection, unless reallocation of the projection has been requested. This is more efficient, since it simply copies the content of the projection's old buffer to the new buffer, rather than re-rendering the graph.
2018-08-04 01:03:03 +08:00
/* reset, the actual size is correct now */
private->reallocate_width = 0;
private->reallocate_height = 0;
Automatically adjust the size of group layers Connect to size and offset of all children and resize/move the group layer accordingly.
2009-08-24 05:00:32 +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
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
/* resize the mask if not transforming (in which case, GimpLayer takes care
* of the mask)
app: resize group-layer mask after moving the group We avoid resizing the mask as a result of changes in the group's bounding box while the group is being moved (i.e., translated, rotated, etc.), so that GimpLayer transforms the original mask, rather than a cropped mask. We still need to crop the mask after we're finished moving the group, however. This commit takes care of that.
2018-02-07 22:48:00 +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
if (resize_mask && ! private->transforming)
app: resize group-layer mask after moving the group We avoid resizing the mask as a result of changes in the group's bounding box while the group is being moved (i.e., translated, rotated, etc.), so that GimpLayer transforms the original mask, rather than a cropped mask. We still need to crop the mask after we're finished moving the group, however. This commit takes care of that.
2018-02-07 22:48:00 +08:00
gimp_group_layer_update_mask_size (group);
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
/* if we show the mask, invalidate the new mask area */
app: resize group-layer mask after moving the group We avoid resizing the mask as a result of changes in the group's bounding box while the group is being moved (i.e., translated, rotated, etc.), so that GimpLayer transforms the original mask, rather than a cropped mask. We still need to crop the mask after we're finished moving the group, however. This commit takes care of that.
2018-02-07 22:48:00 +08:00
if (resize_mask && gimp_layer_get_show_mask (layer))
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_drawable_update (GIMP_DRAWABLE (group),
gimp_item_get_offset_x (mask) - x,
gimp_item_get_offset_y (mask) - y,
gimp_item_get_width (mask),
gimp_item_get_height (mask));
}
Automatically adjust the size of group layers Connect to size and offset of all children and resize/move the group layer accordingly.
2009-08-24 05:00:32 +08:00
}
Add a projection to GimpGroupLayer so we finally have a *visible* layer tree Implement the GimpProjectable interface and keep a GimpProjection around that projects the GimpDrawableStack of our children. Propagate the childrens' "update" signals to our own "update" signal so our parent projection picks up all changes.
2009-08-24 22:03:21 +08:00
app: resize group-layer mask after moving the group We avoid resizing the mask as a result of changes in the group's bounding box while the group is being moved (i.e., translated, rotated, etc.), so that GimpLayer transforms the original mask, rather than a cropped mask. We still need to crop the mask after we're finished moving the group, however. This commit takes care of that.
2018-02-07 22:48:00 +08:00
static void
gimp_group_layer_update_mask_size (GimpGroupLayer *group)
{
GimpGroupLayerPrivate *private = GET_PRIVATE (group);
GimpItem *item = GIMP_ITEM (group);
GimpItem *mask;
GeglBuffer *buffer;
GeglBuffer *mask_buffer;
GeglRectangle bounds;
GeglRectangle mask_bounds;
GeglRectangle copy_bounds;
gboolean intersect;
mask = GIMP_ITEM (gimp_layer_get_mask (GIMP_LAYER (group)));
if (! mask)
return;
bounds.x = gimp_item_get_offset_x (item);
bounds.y = gimp_item_get_offset_y (item);
bounds.width = gimp_item_get_width (item);
bounds.height = gimp_item_get_height (item);
mask_bounds.x = gimp_item_get_offset_x (mask);
mask_bounds.y = gimp_item_get_offset_y (mask);
mask_bounds.width = gimp_item_get_width (mask);
mask_bounds.height = gimp_item_get_height (mask);
if (gegl_rectangle_equal (&bounds, &mask_bounds))
return;
buffer = gegl_buffer_new (GEGL_RECTANGLE (0, 0, bounds.width, bounds.height),
gimp_drawable_get_format (GIMP_DRAWABLE (mask)));
if (private->suspended_mask_buffer)
{
/* copy the suspended mask into the new mask */
mask_buffer = private->suspended_mask_buffer;
mask_bounds = private->suspended_mask_bounds;
}
else
{
/* copy the old mask into the new mask */
mask_buffer = gimp_drawable_get_buffer (GIMP_DRAWABLE (mask));
}
intersect = gimp_rectangle_intersect (bounds.x,
bounds.y,
bounds.width,
bounds.height,
mask_bounds.x,
mask_bounds.y,
mask_bounds.width,
mask_bounds.height,
&copy_bounds.x,
&copy_bounds.y,
&copy_bounds.width,
&copy_bounds.height);
if (intersect)
{
app: use gimp_gegl_buffer_copy() all over the place Replace all uses of gegl_buffer_copy() in app/ with gimp_gegl_buffer_copy(), added in the previous commit.
2018-05-24 22:21:21 +08:00
gimp_gegl_buffer_copy (mask_buffer,
GEGL_RECTANGLE (copy_bounds.x - mask_bounds.x,
copy_bounds.y - mask_bounds.y,
copy_bounds.width,
copy_bounds.height),
GEGL_ABYSS_NONE,
buffer,
GEGL_RECTANGLE (copy_bounds.x - bounds.x,
copy_bounds.y - bounds.y,
copy_bounds.width,
copy_bounds.height));
app: resize group-layer mask after moving the group We avoid resizing the mask as a result of changes in the group's bounding box while the group is being moved (i.e., translated, rotated, etc.), so that GimpLayer transforms the original mask, rather than a cropped mask. We still need to crop the mask after we're finished moving the group, however. This commit takes care of that.
2018-02-07 22:48:00 +08:00
}
gimp_drawable_set_buffer_full (GIMP_DRAWABLE (mask),
FALSE, NULL,
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
buffer, bounds.x, bounds.y,
TRUE);
app: resize group-layer mask after moving the group We avoid resizing the mask as a result of changes in the group's bounding box while the group is being moved (i.e., translated, rotated, etc.), so that GimpLayer transforms the original mask, rather than a cropped mask. We still need to crop the mask after we're finished moving the group, however. This commit takes care of that.
2018-02-07 22:48:00 +08:00
g_object_unref (buffer);
}
app: implement pass-through mode in GimpGroupLayer Override GimpDrawable::get_source_node() for GimpGroupLayer. Use a node that contains both the drawable's buffer-source node, and the layer stack's graph node. Choose which one of these to connect to the source node's output based on the group's layer mode: the stack graph for pass-through mode, and the buffer-source node for all the rest. When in pass-through mode, connect the source node's input (which receives the backdrop) to the stack graph's input. Keep maintaining the projection in pass-through mode. ATM, the projection uses the same graph as the source node, so it's rendered against the group's backdrop -- we don't want that. The next few commits fix it. Update the group's drawable directly upon filter stack update in pass-though mode, because the group's graph doesn't go through the projection. TODO: if any of the group's children (or a child of a nested pass- through group, etc.) uses dst-atop/src-in, this needs special attention.
2017-04-22 06:04:49 +08:00
static void
gimp_group_layer_update_source_node (GimpGroupLayer *group)
{
GimpGroupLayerPrivate *private = GET_PRIVATE (group);
GeglNode *input;
GeglNode *output;
if (private->source_node == NULL)
return;
input = gegl_node_get_input_proxy (private->source_node, "input");
output = gegl_node_get_output_proxy (private->source_node, "output");
app: flush group proj. switching from pass-through to non-pass-through When switching a group layer from pass-through mode to a non-pass- through mode, flush the projection synchrnously, to make sure that the projection's buffer gets properly invalidated at that point, and can be subsequently used as a source for the rest of the composition. Add a boolean 'pass_through' member to GimpGroupLayerPrivate, which indicates if the group is a pass-through group, and use it instead of checking the group's mode, so that we can detect that the group used to be a pass-through group when the mode changes, and to simplify the rest of the code.
2017-12-03 04:25:04 +08:00
if (private->pass_through)
app: implement pass-through mode in GimpGroupLayer Override GimpDrawable::get_source_node() for GimpGroupLayer. Use a node that contains both the drawable's buffer-source node, and the layer stack's graph node. Choose which one of these to connect to the source node's output based on the group's layer mode: the stack graph for pass-through mode, and the buffer-source node for all the rest. When in pass-through mode, connect the source node's input (which receives the backdrop) to the stack graph's input. Keep maintaining the projection in pass-through mode. ATM, the projection uses the same graph as the source node, so it's rendered against the group's backdrop -- we don't want that. The next few commits fix it. Update the group's drawable directly upon filter stack update in pass-though mode, because the group's graph doesn't go through the projection. TODO: if any of the group's children (or a child of a nested pass- through group, etc.) uses dst-atop/src-in, this needs special attention.
2017-04-22 06:04:49 +08:00
{
gegl_node_connect_to (input, "output",
private->graph, "input");
gegl_node_connect_to (private->graph, "output",
output, "input");
}
else
{
gegl_node_disconnect (private->graph, "input");
gegl_node_connect_to (private->parent_source_node, "output",
output, "input");
}
}
app: handle excludes_backdrop in GimpGroupLayer When any of the children of a pass-through group excludes its backdrop, the group itself should exclude the backdrop too. Override get_excludes_backdrop() to follow this logic, and call update_excludes_backdrop() when this condition might change. Note that we always composite pass-through groups using src-over mode, so to actually hide the backdrop, we need to disconnect it from the group's mode node's input pad (and reconnect it, when the backdrop is no longer hidden).
2017-05-09 03:06:00 +08:00
static void
gimp_group_layer_update_mode_node (GimpGroupLayer *group)
{
app: flush group proj. switching from pass-through to non-pass-through When switching a group layer from pass-through mode to a non-pass- through mode, flush the projection synchrnously, to make sure that the projection's buffer gets properly invalidated at that point, and can be subsequently used as a source for the rest of the composition. Add a boolean 'pass_through' member to GimpGroupLayerPrivate, which indicates if the group is a pass-through group, and use it instead of checking the group's mode, so that we can detect that the group used to be a pass-through group when the mode changes, and to simplify the rest of the code.
2017-12-03 04:25:04 +08:00
GimpGroupLayerPrivate *private = GET_PRIVATE (group);
GeglNode *node;
GeglNode *input;
GeglNode *mode_node;
app: handle excludes_backdrop in GimpGroupLayer When any of the children of a pass-through group excludes its backdrop, the group itself should exclude the backdrop too. Override get_excludes_backdrop() to follow this logic, and call update_excludes_backdrop() when this condition might change. Note that we always composite pass-through groups using src-over mode, so to actually hide the backdrop, we need to disconnect it from the group's mode node's input pad (and reconnect it, when the backdrop is no longer hidden).
2017-05-09 03:06:00 +08:00
node = gimp_filter_get_node (GIMP_FILTER (group));
input = gegl_node_get_input_proxy (node, "input");
mode_node = gimp_drawable_get_mode_node (GIMP_DRAWABLE (group));
app: flush group proj. switching from pass-through to non-pass-through When switching a group layer from pass-through mode to a non-pass- through mode, flush the projection synchrnously, to make sure that the projection's buffer gets properly invalidated at that point, and can be subsequently used as a source for the rest of the composition. Add a boolean 'pass_through' member to GimpGroupLayerPrivate, which indicates if the group is a pass-through group, and use it instead of checking the group's mode, so that we can detect that the group used to be a pass-through group when the mode changes, and to simplify the rest of the code.
2017-12-03 04:25:04 +08:00
if (private->pass_through &&
app: handle excludes_backdrop in GimpGroupLayer When any of the children of a pass-through group excludes its backdrop, the group itself should exclude the backdrop too. Override get_excludes_backdrop() to follow this logic, and call update_excludes_backdrop() when this condition might change. Note that we always composite pass-through groups using src-over mode, so to actually hide the backdrop, we need to disconnect it from the group's mode node's input pad (and reconnect it, when the backdrop is no longer hidden).
2017-05-09 03:06:00 +08:00
gimp_layer_get_excludes_backdrop (GIMP_LAYER (group)))
{
gegl_node_disconnect (mode_node, "input");
}
else
{
gegl_node_connect_to (input, "output",
mode_node, "input");
}
}
Add a projection to GimpGroupLayer so we finally have a *visible* layer tree Implement the GimpProjectable interface and keep a GimpProjection around that projects the GimpDrawableStack of our children. Propagate the childrens' "update" signals to our own "update" signal so our parent projection picks up all changes.
2009-08-24 22:03:21 +08:00
static void
gimp_group_layer_stack_update (GimpDrawableStack *stack,
gint x,
gint y,
gint width,
gint height,
GimpGroupLayer *group)
{
app: flush group proj. switching from pass-through to non-pass-through When switching a group layer from pass-through mode to a non-pass- through mode, flush the projection synchrnously, to make sure that the projection's buffer gets properly invalidated at that point, and can be subsequently used as a source for the rest of the composition. Add a boolean 'pass_through' member to GimpGroupLayerPrivate, which indicates if the group is a pass-through group, and use it instead of checking the group's mode, so that we can detect that the group used to be a pass-through group when the mode changes, and to simplify the rest of the code.
2017-12-03 04:25:04 +08:00
GimpGroupLayerPrivate *private = GET_PRIVATE (group);
Change GimpProjectable::update to GimpProjectable:invalidate The only purpose of this change is to avoid having the "update" signal twice on GimpGroupLayer (from GimpDrawable and from GimpProjectable). Switch back to normal g_signal_connect() in the projection.
2009-08-26 19:06:55 +08:00
#if 0
g_printerr ("%s (%s) %d, %d (%d, %d)\n",
Remove GIMP_OBJECT() casts when calling gimp_object_get_name()
2009-09-01 04:47:18 +08:00
G_STRFUNC, gimp_object_get_name (group),
Change GimpProjectable::update to GimpProjectable:invalidate The only purpose of this change is to avoid having the "update" signal twice on GimpGroupLayer (from GimpDrawable and from GimpProjectable). Switch back to normal g_signal_connect() in the projection.
2009-08-26 19:06:55 +08:00
x, y, width, height);
#endif
app: avoid re-rendering group layers upon translation When translating group layers, there's no need to re-render the group's projection -- we can simply update the group's offset (and offset node) directly, and redirect any layer-stack "update" signals to the group's drawable. This significantly improves performance when moving groups.
2018-08-04 01:10:37 +08:00
if (! private->direct_update)
{
/* the layer stack's update signal speaks in image coordinates,
* pass to the projection as-is.
*/
gimp_projectable_invalidate (GIMP_PROJECTABLE (group),
x, y, width, height);
app: flush pass-through groups' projection asynchronously The source node of pass-through groups doesn't use the projection's buffer, hence there's no need to invalidate it synchronously, which is faster.
2017-12-02 23:15:39 +08:00
app: avoid re-rendering group layers upon translation When translating group layers, there's no need to re-render the group's projection -- we can simply update the group's offset (and offset node) directly, and redirect any layer-stack "update" signals to the group's drawable. This significantly improves performance when moving groups.
2018-08-04 01:10:37 +08:00
gimp_group_layer_flush (group);
}
app: flush pass-through groups' projection asynchronously The source node of pass-through groups doesn't use the projection's buffer, hence there's no need to invalidate it synchronously, which is faster.
2017-12-02 23:15:39 +08:00
app: avoid re-rendering group layers upon translation When translating group layers, there's no need to re-render the group's projection -- we can simply update the group's offset (and offset node) directly, and redirect any layer-stack "update" signals to the group's drawable. This significantly improves performance when moving groups.
2018-08-04 01:10:37 +08:00
if (private->direct_update || private->pass_through)
app: implement pass-through mode in GimpGroupLayer Override GimpDrawable::get_source_node() for GimpGroupLayer. Use a node that contains both the drawable's buffer-source node, and the layer stack's graph node. Choose which one of these to connect to the source node's output based on the group's layer mode: the stack graph for pass-through mode, and the buffer-source node for all the rest. When in pass-through mode, connect the source node's input (which receives the backdrop) to the stack graph's input. Keep maintaining the projection in pass-through mode. ATM, the projection uses the same graph as the source node, so it's rendered against the group's backdrop -- we don't want that. The next few commits fix it. Update the group's drawable directly upon filter stack update in pass-though mode, because the group's graph doesn't go through the projection. TODO: if any of the group's children (or a child of a nested pass- through group, etc.) uses dst-atop/src-in, this needs special attention.
2017-04-22 06:04:49 +08:00
{
/* the layer stack's update signal speaks in image coordinates,
* transform to layer coordinates when emitting our own update signal.
*/
gimp_drawable_update (GIMP_DRAWABLE (group),
x - gimp_item_get_offset_x (GIMP_ITEM (group)),
y - gimp_item_get_offset_y (GIMP_ITEM (group)),
width, height);
}
Add a projection to GimpGroupLayer so we finally have a *visible* layer tree Implement the GimpProjectable interface and keep a GimpProjection around that projects the GimpDrawableStack of our children. Propagate the childrens' "update" signals to our own "update" signal so our parent projection picks up all changes.
2009-08-24 22:03:21 +08:00
}
static void
gimp_group_layer_proj_update (GimpProjection *proj,
gboolean now,
gint x,
gint y,
gint width,
gint height,
GimpGroupLayer *group)
{
app: flush group proj. switching from pass-through to non-pass-through When switching a group layer from pass-through mode to a non-pass- through mode, flush the projection synchrnously, to make sure that the projection's buffer gets properly invalidated at that point, and can be subsequently used as a source for the rest of the composition. Add a boolean 'pass_through' member to GimpGroupLayerPrivate, which indicates if the group is a pass-through group, and use it instead of checking the group's mode, so that we can detect that the group used to be a pass-through group when the mode changes, and to simplify the rest of the code.
2017-12-03 04:25:04 +08:00
GimpGroupLayerPrivate *private = GET_PRIVATE (group);
Change GimpProjectable::update to GimpProjectable:invalidate The only purpose of this change is to avoid having the "update" signal twice on GimpGroupLayer (from GimpDrawable and from GimpProjectable). Switch back to normal g_signal_connect() in the projection.
2009-08-26 19:06:55 +08:00
#if 0
g_printerr ("%s (%s) %d, %d (%d, %d)\n",
Remove GIMP_OBJECT() casts when calling gimp_object_get_name()
2009-09-01 04:47:18 +08:00
G_STRFUNC, gimp_object_get_name (group),
Change GimpProjectable::update to GimpProjectable:invalidate The only purpose of this change is to avoid having the "update" signal twice on GimpGroupLayer (from GimpDrawable and from GimpProjectable). Switch back to normal g_signal_connect() in the projection.
2009-08-26 19:06:55 +08:00
x, y, width, height);
#endif
app: flush group proj. switching from pass-through to non-pass-through When switching a group layer from pass-through mode to a non-pass- through mode, flush the projection synchrnously, to make sure that the projection's buffer gets properly invalidated at that point, and can be subsequently used as a source for the rest of the composition. Add a boolean 'pass_through' member to GimpGroupLayerPrivate, which indicates if the group is a pass-through group, and use it instead of checking the group's mode, so that we can detect that the group used to be a pass-through group when the mode changes, and to simplify the rest of the code.
2017-12-03 04:25:04 +08:00
if (! private->pass_through)
app: implement pass-through mode in GimpGroupLayer Override GimpDrawable::get_source_node() for GimpGroupLayer. Use a node that contains both the drawable's buffer-source node, and the layer stack's graph node. Choose which one of these to connect to the source node's output based on the group's layer mode: the stack graph for pass-through mode, and the buffer-source node for all the rest. When in pass-through mode, connect the source node's input (which receives the backdrop) to the stack graph's input. Keep maintaining the projection in pass-through mode. ATM, the projection uses the same graph as the source node, so it's rendered against the group's backdrop -- we don't want that. The next few commits fix it. Update the group's drawable directly upon filter stack update in pass-though mode, because the group's graph doesn't go through the projection. TODO: if any of the group's children (or a child of a nested pass- through group, etc.) uses dst-atop/src-in, this needs special attention.
2017-04-22 06:04:49 +08:00
{
/* the projection speaks in image coordinates, transform to layer
* coordinates when emitting our own update signal.
*/
gimp_drawable_update (GIMP_DRAWABLE (group),
x - gimp_item_get_offset_x (GIMP_ITEM (group)),
y - gimp_item_get_offset_y (GIMP_ITEM (group)),
width, height);
}
Add a projection to GimpGroupLayer so we finally have a *visible* layer tree Implement the GimpProjectable interface and keep a GimpProjection around that projects the GimpDrawableStack of our children. Propagate the childrens' "update" signals to our own "update" signal so our parent projection picks up all changes.
2009-08-24 22:03:21 +08:00
}