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

1544 lines
55 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
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#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"
Add a GimpGroupLayer class (not used yet)
2009-08-04 05:24:46 +08:00
#include "gimpgrouplayer.h"
#include "gimpimage.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"
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"
#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 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
};
#define GET_PRIVATE(item) G_TYPE_INSTANCE_GET_PRIVATE (item, \
GIMP_TYPE_GROUP_LAYER, \
GimpGroupLayerPrivate)
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);
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_resize (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,
Bug 764024 - Allow to choose fill color when resizing layers and images Add a GimpFillType argument to GimpItem::resize() and fill type widgets to the canvas and layer resize dialogs. Fill the new parts of the drawable according to fill type in gimp_drawable_resize(). Make sure places that need the old behavior get GIMP_FILL_TRANSPARENT passed by hardcoding it in the GimpItem::resize() implemetations of channel, mask, selection etc.
2016-10-10 06:02:16 +08:00
GimpFillType fill_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
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 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,
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);
static void gimp_group_layer_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);
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);
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: 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,
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
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;
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;
layer_class->mode_changed = gimp_group_layer_mode_changed;
layer_class->excludes_backdrop_changed = gimp_group_layer_excludes_backdrop_changed;
layer_class->translate = gimp_group_layer_translate;
layer_class->scale = gimp_group_layer_scale;
layer_class->resize = gimp_group_layer_resize;
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;
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
g_type_class_add_private (klass, sizeof (GimpGroupLayerPrivate));
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);
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
}
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);
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: 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_group_layer_suspend_resize (group, FALSE);
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
/* don't push an undo here because undo will call us again */
gimp_group_layer_resume_resize (group, 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
}
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: 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
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
gint child_width;
gint child_height;
gint child_offset_x;
gint child_offset_y;
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);
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
child_width = ROUND (width_factor * gimp_item_get_width (child));
child_height = ROUND (height_factor * gimp_item_get_height (child));
child_offset_x = ROUND (width_factor * (gimp_item_get_offset_x (child) -
old_offset_x));
child_offset_y = ROUND (height_factor * (gimp_item_get_offset_y (child) -
old_offset_y));
child_offset_x += new_offset_x;
child_offset_y += new_offset_y;
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
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
if (child_width > 0 && child_height > 0)
{
gimp_item_scale (child,
child_width, child_height,
child_offset_x, child_offset_y,
interpolation_type, progress);
}
else if (gimp_item_is_attached (item))
{
gimp_image_remove_layer (gimp_item_get_image (item),
GIMP_LAYER (child),
TRUE, NULL);
}
else
{
app: move all GimpGroupLayer members to a private struct
2011-02-04 05:29:25 +08:00
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);
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_resize (GimpLayer *layer,
Bug 764024 - Allow to choose fill color when resizing layers and images Add a GimpFillType argument to GimpItem::resize() and fill type widgets to the canvas and layer resize dialogs. Fill the new parts of the drawable according to fill type in gimp_drawable_resize(). Make sure places that need the old behavior get GIMP_FILL_TRANSPARENT passed by hardcoding it in the GimpItem::resize() implemetations of channel, mask, selection etc.
2016-10-10 06:02:16 +08:00
GimpContext *context,
GimpFillType fill_type,
gint new_width,
gint new_height,
gint offset_x,
gint offset_y)
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
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;
gint x, y;
Implement GimpItem::resize() Resize all children, but only crop them (don't enlarge them, unlike when resizing normal layers).
2009-08-25 23:29: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
x = gimp_item_get_offset_x (GIMP_ITEM (group)) - offset_x;
y = gimp_item_get_offset_y (GIMP_ITEM (group)) - offset_y;
Implement GimpItem::resize() Resize all children, but only crop them (don't enlarge them, unlike when resizing normal layers).
2009-08-25 23:29: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
list = gimp_item_stack_get_item_iter (GIMP_ITEM_STACK (private->children));
Implement GimpItem::resize() Resize all children, but only crop them (don't enlarge them, unlike when resizing normal layers).
2009-08-25 23:29:29 +08:00
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;
Bug 764024 - Allow to choose fill color when resizing layers and images Add a GimpFillType argument to GimpItem::resize() and fill type widgets to the canvas and layer resize dialogs. Fill the new parts of the drawable according to fill type in gimp_drawable_resize(). Make sure places that need the old behavior get GIMP_FILL_TRANSPARENT passed by hardcoding it in the GimpItem::resize() implemetations of channel, mask, selection etc.
2016-10-10 06:02:16 +08:00
gimp_item_resize (child, context, fill_type,
Implement GimpItem::resize() Resize all children, but only crop them (don't enlarge them, unlike when resizing normal layers).
2009-08-25 23:29:29 +08:00
child_width, child_height,
child_offset_x, child_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
else if (gimp_item_is_attached (GIMP_ITEM (group)))
Implement GimpItem::resize() Resize all children, but only crop them (don't enlarge them, unlike when resizing normal layers).
2009-08-25 23:29: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
gimp_image_remove_layer (gimp_item_get_image (GIMP_ITEM (group)),
Implement GimpItem::resize() Resize all children, but only crop them (don't enlarge them, unlike when resizing normal layers).
2009-08-25 23:29:29 +08:00
GIMP_LAYER (child),
TRUE, NULL);
}
else
{
app: move all GimpGroupLayer members to a private struct
2011-02-04 05:29:25 +08:00
gimp_container_remove (private->children, GIMP_OBJECT (child));
Implement GimpItem::resize() Resize all children, but only crop them (don't enlarge them, unlike when resizing normal layers).
2009-08-25 23:29: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);
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: 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_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);
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:
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 gimp_image_get_format (image, GIMP_RGB, precision, TRUE);
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:
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 gimp_image_get_format (image, GIMP_GRAY, precision, TRUE);
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
}
g_assert_not_reached ();
return NULL;
}
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,
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)),
gimp_item_get_offset_y (GIMP_ITEM (group)));
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
gimp_group_layer_mode_changed (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
GimpGroupLayer *group = GIMP_GROUP_LAYER (layer);
GimpGroupLayerPrivate *private = GET_PRIVATE (layer);
gboolean pass_through;
pass_through = (gimp_layer_get_mode (layer) == GIMP_LAYER_MODE_PASS_THROUGH);
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
if (GIMP_LAYER_CLASS (parent_class)->mode_changed)
GIMP_LAYER_CLASS (parent_class)->mode_changed (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)
{
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);
}
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
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)
gimp_image_undo_push_group_layer_suspend (gimp_item_get_image (item),
NULL, group);
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;
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)
gimp_image_undo_push_group_layer_resume (gimp_item_get_image (item),
NULL, group);
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);
}
}
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: 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_get_excludes_backdrop (child))
{
gimp_layer_update_excludes_backdrop (GIMP_LAYER (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_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: 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_get_excludes_backdrop (child))
{
gimp_layer_update_excludes_backdrop (GIMP_LAYER (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_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
{
if (gimp_layer_get_excludes_backdrop (child))
gimp_layer_update_excludes_backdrop (GIMP_LAYER (group));
}
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
{
/* 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);
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;
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);
}
}
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
if (private->reallocate_projection ||
x != old_x ||
y != old_y ||
width != old_width ||
Fix automatic size updates of nested groups (again!) Make sure a group layer really emits all needed size change signals when children get added and removed, so the group layer above it can also update itself based on these signals. Spotted (again) by tobi.
2009-08-28 05:07:38 +08:00
height != 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: 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: 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
if (private->reallocate_projection ||
width != old_width ||
Fix automatic size updates of nested groups (again!) Make sure a group layer really emits all needed size change signals when children get added and removed, so the group layer above it can also update itself based on these signals. Spotted (again) by tobi.
2009-08-28 05:07:38 +08:00
height != 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: 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
GeglBuffer *buffer;
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: 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;
/* temporarily change the return values of gimp_viewable_get_size()
* so the projection allocates itself correctly
Fix automatic size updates of nested groups (again!) Make sure a group layer really emits all needed size change signals when children get added and removed, so the group layer above it can also update itself based on these signals. Spotted (again) by tobi.
2009-08-28 05:07:38 +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
private->reallocate_width = width;
private->reallocate_height = 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
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);
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 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
gimp_drawable_set_buffer_full (GIMP_DRAWABLE (group),
FALSE, NULL,
buffer,
x, y);
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 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
}
else
{
Fix typo in comment
2009-09-23 03:39:32 +08:00
/* invalidate the entire projection since the position of
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
* the children relative to each other might have changed
* in a way that happens to leave the group's width and
* height the same
*/
gimp_projectable_invalidate (GIMP_PROJECTABLE (group),
x, y, width, height);
app: fix update of group layers when size changes only trigger an offset change In gimp_group_layer_update_size(), when the new size happens to be the same as the old size, we need to call gimp_pickable_flush() on the group projection so it is ready to be used for rendering the image, just like in gimp_group_layer_stack_update().
2015-06-23 16:24:25 +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
gimp_group_layer_flush (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
}
}
}
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
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: 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
/* 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);
gimp_group_layer_flush (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: 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
}