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

388 lines
11 KiB
C
Raw Normal View History

app: add a canvas group item which keeps around sub-items It can draw them all with one call to draw() and returns a union of their extents via get_extents().
2010-09-25 23:14:57 +08:00
/* GIMP - The GNU Image Manipulation Program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* gimpcanvasgroup.c
* Copyright (C) 2010 Michael Natterer <mitch@gimp.org>
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
Change the license URL from http://www.gnu.org/licenses/ to https://
2018-07-12 05:27:07 +08:00
* along with this program. If not, see <https://www.gnu.org/licenses/>.
app: add a canvas group item which keeps around sub-items It can draw them all with one call to draw() and returns a union of their extents via get_extents().
2010-09-25 23:14:57 +08:00
*/
#include "config.h"
#include <gegl.h>
#include <gtk/gtk.h>
#include "libgimpbase/gimpbase.h"
#include "libgimpmath/gimpmath.h"
#include "display-types.h"
#include "gimpcanvasgroup.h"
#include "gimpdisplayshell.h"
enum
{
app: add an infrastructure that allows to stroke multiple items at once In order to avoid visually overlapping lines: - GimpCanvasItem got a "suspend_stroking" API that allows to skip stroking and instead starts a new sub-path - GimpCanvasGroup got a "group_stroking" API that sets suspend_stroking on all its children and does one stroke after calling all items' draw().
2010-09-26 20:12:54 +08:00
PROP_0,
app: add group filling support to GimpCanvasItem and GimpCanvasGroup The code is almost identical to the group stroking feature.
2010-09-28 04:59:36 +08:00
PROP_GROUP_STROKING,
PROP_GROUP_FILLING
app: add a canvas group item which keeps around sub-items It can draw them all with one call to draw() and returns a union of their extents via get_extents().
2010-09-25 23:14:57 +08:00
};
struct _GimpCanvasGroupPrivate
{
Bug 735810 - performance shrinkage of Paths tool Use a GQueue instead of a GList in GimpCanvasGroup, so adding items takes constant time instead of O(n). Also, removing items was traversing the list twice. This should generally speed up tools with lots of canvas items. Also, add a private pointer to the instance struct instead of using a GET_PRIVATE() macro.
2016-01-24 07:54:48 +08:00
GQueue *items;
app: add an infrastructure that allows to stroke multiple items at once In order to avoid visually overlapping lines: - GimpCanvasItem got a "suspend_stroking" API that allows to skip stroking and instead starts a new sub-path - GimpCanvasGroup got a "group_stroking" API that sets suspend_stroking on all its children and does one stroke after calling all items' draw().
2010-09-26 20:12:54 +08:00
gboolean group_stroking;
app: add group filling support to GimpCanvasItem and GimpCanvasGroup The code is almost identical to the group stroking feature.
2010-09-28 04:59:36 +08:00
gboolean group_filling;
app: add a canvas group item which keeps around sub-items It can draw them all with one call to draw() and returns a union of their extents via get_extents().
2010-09-25 23:14:57 +08:00
};
/* local function prototypes */
app: properly remove the children when a GimpCanvasGroup gets destroyed Call gimp_canvas_group_remove_item() and don't just unref them, so their state gets restored and signals get disconnected. They may not be owned by the group, or have other external references.
2017-06-11 04:08:09 +08:00
static void gimp_canvas_group_finalize (GObject *object);
app: remove GimpDisplayShell parameters from all GimpCanvasItem vfuncs and get the shell from gimp_canvas_item_get_shell() if needed. Remove some cairo_translate() that didn't have any effect and were leftovers from a very early canvas item code.
2013-04-18 21:45:08 +08:00
static void gimp_canvas_group_set_property (GObject *object,
guint property_id,
const GValue *value,
GParamSpec *pspec);
static void gimp_canvas_group_get_property (GObject *object,
guint property_id,
GValue *value,
GParamSpec *pspec);
static void gimp_canvas_group_draw (GimpCanvasItem *item,
cairo_t *cr);
static cairo_region_t * gimp_canvas_group_get_extents (GimpCanvasItem *item);
static gboolean gimp_canvas_group_hit (GimpCanvasItem *item,
gdouble x,
gdouble y);
static void gimp_canvas_group_child_update (GimpCanvasItem *item,
cairo_region_t *region,
GimpCanvasGroup *group);
app: add a canvas group item which keeps around sub-items It can draw them all with one call to draw() and returns a union of their extents via get_extents().
2010-09-25 23:14:57 +08:00
app, libgimp*, modules: don't use g_type_class_add_private() ... ... and G_TYPE_INSTANCE_GET_PRIVATE() g_type_class_add_private() and G_TYPE_INSTANCE_GET_PRIVATE() were deprecated in GLib 2.58. Instead, use G_DEFINE_[ABSTRACT_]TYPE_WITH_PRIVATE(), and G_ADD_PRIVATE[_DYNAMIC](), and the implictly-defined foo_get_instance_private() functions, all of which are available in the GLib versions we depend on. This commit only covers types registered using one of the G_DEFINE_FOO() macros (i.e., most types), but not types with a custom registration function, of which we still have a few -- GLib currently only provides a (non-deprecated) public API for adding a private struct using the G_DEFINE_FOO() macros. Note that this commit was 99% auto-generated (because I'm not *that* crazy :), so if there are any style mismatches... we'll have to live with them for now.
2018-09-19 00:09:39 +08:00
G_DEFINE_TYPE_WITH_PRIVATE (GimpCanvasGroup, gimp_canvas_group,
GIMP_TYPE_CANVAS_ITEM)
app: add a canvas group item which keeps around sub-items It can draw them all with one call to draw() and returns a union of their extents via get_extents().
2010-09-25 23:14:57 +08:00
#define parent_class gimp_canvas_group_parent_class
static void
gimp_canvas_group_class_init (GimpCanvasGroupClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
GimpCanvasItemClass *item_class = GIMP_CANVAS_ITEM_CLASS (klass);
app: properly remove the children when a GimpCanvasGroup gets destroyed Call gimp_canvas_group_remove_item() and don't just unref them, so their state gets restored and signals get disconnected. They may not be owned by the group, or have other external references.
2017-06-11 04:08:09 +08:00
object_class->finalize = gimp_canvas_group_finalize;
app: add a canvas group item which keeps around sub-items It can draw them all with one call to draw() and returns a union of their extents via get_extents().
2010-09-25 23:14:57 +08:00
object_class->set_property = gimp_canvas_group_set_property;
object_class->get_property = gimp_canvas_group_get_property;
item_class->draw = gimp_canvas_group_draw;
item_class->get_extents = gimp_canvas_group_get_extents;
app: add virtual function gboolean GimpCanvasItem::hit() and implement it for GimpCanvasHandle and GimpCanvasGroup.
2011-03-29 00:54:02 +08:00
item_class->hit = gimp_canvas_group_hit;
app: add a canvas group item which keeps around sub-items It can draw them all with one call to draw() and returns a union of their extents via get_extents().
2010-09-25 23:14:57 +08:00
app: add an infrastructure that allows to stroke multiple items at once In order to avoid visually overlapping lines: - GimpCanvasItem got a "suspend_stroking" API that allows to skip stroking and instead starts a new sub-path - GimpCanvasGroup got a "group_stroking" API that sets suspend_stroking on all its children and does one stroke after calling all items' draw().
2010-09-26 20:12:54 +08:00
g_object_class_install_property (object_class, PROP_GROUP_STROKING,
g_param_spec_boolean ("group-stroking",
NULL, NULL,
FALSE,
GIMP_PARAM_READWRITE));
app: add group filling support to GimpCanvasItem and GimpCanvasGroup The code is almost identical to the group stroking feature.
2010-09-28 04:59:36 +08:00
g_object_class_install_property (object_class, PROP_GROUP_FILLING,
g_param_spec_boolean ("group-filling",
NULL, NULL,
FALSE,
GIMP_PARAM_READWRITE));
app: add a canvas group item which keeps around sub-items It can draw them all with one call to draw() and returns a union of their extents via get_extents().
2010-09-25 23:14:57 +08:00
}
static void
gimp_canvas_group_init (GimpCanvasGroup *group)
{
app, libgimp*, modules: don't use g_type_class_add_private() ... ... and G_TYPE_INSTANCE_GET_PRIVATE() g_type_class_add_private() and G_TYPE_INSTANCE_GET_PRIVATE() were deprecated in GLib 2.58. Instead, use G_DEFINE_[ABSTRACT_]TYPE_WITH_PRIVATE(), and G_ADD_PRIVATE[_DYNAMIC](), and the implictly-defined foo_get_instance_private() functions, all of which are available in the GLib versions we depend on. This commit only covers types registered using one of the G_DEFINE_FOO() macros (i.e., most types), but not types with a custom registration function, of which we still have a few -- GLib currently only provides a (non-deprecated) public API for adding a private struct using the G_DEFINE_FOO() macros. Note that this commit was 99% auto-generated (because I'm not *that* crazy :), so if there are any style mismatches... we'll have to live with them for now.
2018-09-19 00:09:39 +08:00
group->priv = gimp_canvas_group_get_instance_private (group);
Bug 735810 - performance shrinkage of Paths tool Use a GQueue instead of a GList in GimpCanvasGroup, so adding items takes constant time instead of O(n). Also, removing items was traversing the list twice. This should generally speed up tools with lots of canvas items. Also, add a private pointer to the instance struct instead of using a GET_PRIVATE() macro.
2016-01-24 07:54:48 +08:00
group->priv->items = g_queue_new ();
app: add a canvas group item which keeps around sub-items It can draw them all with one call to draw() and returns a union of their extents via get_extents().
2010-09-25 23:14:57 +08:00
}
static void
app: properly remove the children when a GimpCanvasGroup gets destroyed Call gimp_canvas_group_remove_item() and don't just unref them, so their state gets restored and signals get disconnected. They may not be owned by the group, or have other external references.
2017-06-11 04:08:09 +08:00
gimp_canvas_group_finalize (GObject *object)
app: add a canvas group item which keeps around sub-items It can draw them all with one call to draw() and returns a union of their extents via get_extents().
2010-09-25 23:14:57 +08:00
{
Bug 735810 - performance shrinkage of Paths tool Use a GQueue instead of a GList in GimpCanvasGroup, so adding items takes constant time instead of O(n). Also, removing items was traversing the list twice. This should generally speed up tools with lots of canvas items. Also, add a private pointer to the instance struct instead of using a GET_PRIVATE() macro.
2016-01-24 07:54:48 +08:00
GimpCanvasGroup *group = GIMP_CANVAS_GROUP (object);
app: properly remove the children when a GimpCanvasGroup gets destroyed Call gimp_canvas_group_remove_item() and don't just unref them, so their state gets restored and signals get disconnected. They may not be owned by the group, or have other external references.
2017-06-11 04:08:09 +08:00
GimpCanvasItem *item;
app: add a canvas group item which keeps around sub-items It can draw them all with one call to draw() and returns a union of their extents via get_extents().
2010-09-25 23:14:57 +08:00
app: properly remove the children when a GimpCanvasGroup gets destroyed Call gimp_canvas_group_remove_item() and don't just unref them, so their state gets restored and signals get disconnected. They may not be owned by the group, or have other external references.
2017-06-11 04:08:09 +08:00
while ((item = g_queue_peek_head (group->priv->items)))
gimp_canvas_group_remove_item (group, item);
g_queue_free (group->priv->items);
group->priv->items = NULL;
app: add a canvas group item which keeps around sub-items It can draw them all with one call to draw() and returns a union of their extents via get_extents().
2010-09-25 23:14:57 +08:00
app: properly remove the children when a GimpCanvasGroup gets destroyed Call gimp_canvas_group_remove_item() and don't just unref them, so their state gets restored and signals get disconnected. They may not be owned by the group, or have other external references.
2017-06-11 04:08:09 +08:00
G_OBJECT_CLASS (parent_class)->finalize (object);
app: add a canvas group item which keeps around sub-items It can draw them all with one call to draw() and returns a union of their extents via get_extents().
2010-09-25 23:14:57 +08:00
}
static void
gimp_canvas_group_set_property (GObject *object,
guint property_id,
const GValue *value,
GParamSpec *pspec)
{
Bug 735810 - performance shrinkage of Paths tool Use a GQueue instead of a GList in GimpCanvasGroup, so adding items takes constant time instead of O(n). Also, removing items was traversing the list twice. This should generally speed up tools with lots of canvas items. Also, add a private pointer to the instance struct instead of using a GET_PRIVATE() macro.
2016-01-24 07:54:48 +08:00
GimpCanvasGroup *group = GIMP_CANVAS_GROUP (object);
app: add a canvas group item which keeps around sub-items It can draw them all with one call to draw() and returns a union of their extents via get_extents().
2010-09-25 23:14:57 +08:00
switch (property_id)
{
app: add an infrastructure that allows to stroke multiple items at once In order to avoid visually overlapping lines: - GimpCanvasItem got a "suspend_stroking" API that allows to skip stroking and instead starts a new sub-path - GimpCanvasGroup got a "group_stroking" API that sets suspend_stroking on all its children and does one stroke after calling all items' draw().
2010-09-26 20:12:54 +08:00
case PROP_GROUP_STROKING:
Bug 735810 - performance shrinkage of Paths tool Use a GQueue instead of a GList in GimpCanvasGroup, so adding items takes constant time instead of O(n). Also, removing items was traversing the list twice. This should generally speed up tools with lots of canvas items. Also, add a private pointer to the instance struct instead of using a GET_PRIVATE() macro.
2016-01-24 07:54:48 +08:00
group->priv->group_stroking = g_value_get_boolean (value);
app: add an infrastructure that allows to stroke multiple items at once In order to avoid visually overlapping lines: - GimpCanvasItem got a "suspend_stroking" API that allows to skip stroking and instead starts a new sub-path - GimpCanvasGroup got a "group_stroking" API that sets suspend_stroking on all its children and does one stroke after calling all items' draw().
2010-09-26 20:12:54 +08:00
break;
app: add group filling support to GimpCanvasItem and GimpCanvasGroup The code is almost identical to the group stroking feature.
2010-09-28 04:59:36 +08:00
case PROP_GROUP_FILLING:
Bug 735810 - performance shrinkage of Paths tool Use a GQueue instead of a GList in GimpCanvasGroup, so adding items takes constant time instead of O(n). Also, removing items was traversing the list twice. This should generally speed up tools with lots of canvas items. Also, add a private pointer to the instance struct instead of using a GET_PRIVATE() macro.
2016-01-24 07:54:48 +08:00
group->priv->group_filling = g_value_get_boolean (value);
app: add group filling support to GimpCanvasItem and GimpCanvasGroup The code is almost identical to the group stroking feature.
2010-09-28 04:59:36 +08:00
break;
app: add an infrastructure that allows to stroke multiple items at once In order to avoid visually overlapping lines: - GimpCanvasItem got a "suspend_stroking" API that allows to skip stroking and instead starts a new sub-path - GimpCanvasGroup got a "group_stroking" API that sets suspend_stroking on all its children and does one stroke after calling all items' draw().
2010-09-26 20:12:54 +08:00
app: add a canvas group item which keeps around sub-items It can draw them all with one call to draw() and returns a union of their extents via get_extents().
2010-09-25 23:14:57 +08:00
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
break;
}
}
static void
gimp_canvas_group_get_property (GObject *object,
guint property_id,
GValue *value,
GParamSpec *pspec)
{
Bug 735810 - performance shrinkage of Paths tool Use a GQueue instead of a GList in GimpCanvasGroup, so adding items takes constant time instead of O(n). Also, removing items was traversing the list twice. This should generally speed up tools with lots of canvas items. Also, add a private pointer to the instance struct instead of using a GET_PRIVATE() macro.
2016-01-24 07:54:48 +08:00
GimpCanvasGroup *group = GIMP_CANVAS_GROUP (object);
app: add a canvas group item which keeps around sub-items It can draw them all with one call to draw() and returns a union of their extents via get_extents().
2010-09-25 23:14:57 +08:00
switch (property_id)
{
app: add an infrastructure that allows to stroke multiple items at once In order to avoid visually overlapping lines: - GimpCanvasItem got a "suspend_stroking" API that allows to skip stroking and instead starts a new sub-path - GimpCanvasGroup got a "group_stroking" API that sets suspend_stroking on all its children and does one stroke after calling all items' draw().
2010-09-26 20:12:54 +08:00
case PROP_GROUP_STROKING:
Bug 735810 - performance shrinkage of Paths tool Use a GQueue instead of a GList in GimpCanvasGroup, so adding items takes constant time instead of O(n). Also, removing items was traversing the list twice. This should generally speed up tools with lots of canvas items. Also, add a private pointer to the instance struct instead of using a GET_PRIVATE() macro.
2016-01-24 07:54:48 +08:00
g_value_set_boolean (value, group->priv->group_stroking);
app: add an infrastructure that allows to stroke multiple items at once In order to avoid visually overlapping lines: - GimpCanvasItem got a "suspend_stroking" API that allows to skip stroking and instead starts a new sub-path - GimpCanvasGroup got a "group_stroking" API that sets suspend_stroking on all its children and does one stroke after calling all items' draw().
2010-09-26 20:12:54 +08:00
break;
app: add group filling support to GimpCanvasItem and GimpCanvasGroup The code is almost identical to the group stroking feature.
2010-09-28 04:59:36 +08:00
case PROP_GROUP_FILLING:
Bug 735810 - performance shrinkage of Paths tool Use a GQueue instead of a GList in GimpCanvasGroup, so adding items takes constant time instead of O(n). Also, removing items was traversing the list twice. This should generally speed up tools with lots of canvas items. Also, add a private pointer to the instance struct instead of using a GET_PRIVATE() macro.
2016-01-24 07:54:48 +08:00
g_value_set_boolean (value, group->priv->group_filling);
app: add group filling support to GimpCanvasItem and GimpCanvasGroup The code is almost identical to the group stroking feature.
2010-09-28 04:59:36 +08:00
break;
app: add an infrastructure that allows to stroke multiple items at once In order to avoid visually overlapping lines: - GimpCanvasItem got a "suspend_stroking" API that allows to skip stroking and instead starts a new sub-path - GimpCanvasGroup got a "group_stroking" API that sets suspend_stroking on all its children and does one stroke after calling all items' draw().
2010-09-26 20:12:54 +08:00
app: add a canvas group item which keeps around sub-items It can draw them all with one call to draw() and returns a union of their extents via get_extents().
2010-09-25 23:14:57 +08:00
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
break;
}
}
static void
app: remove GimpDisplayShell parameters from all GimpCanvasItem vfuncs and get the shell from gimp_canvas_item_get_shell() if needed. Remove some cairo_translate() that didn't have any effect and were leftovers from a very early canvas item code.
2013-04-18 21:45:08 +08:00
gimp_canvas_group_draw (GimpCanvasItem *item,
cairo_t *cr)
app: add a canvas group item which keeps around sub-items It can draw them all with one call to draw() and returns a union of their extents via get_extents().
2010-09-25 23:14:57 +08:00
{
Bug 735810 - performance shrinkage of Paths tool Use a GQueue instead of a GList in GimpCanvasGroup, so adding items takes constant time instead of O(n). Also, removing items was traversing the list twice. This should generally speed up tools with lots of canvas items. Also, add a private pointer to the instance struct instead of using a GET_PRIVATE() macro.
2016-01-24 07:54:48 +08:00
GimpCanvasGroup *group = GIMP_CANVAS_GROUP (item);
GList *list;
app: add a canvas group item which keeps around sub-items It can draw them all with one call to draw() and returns a union of their extents via get_extents().
2010-09-25 23:14:57 +08:00
Bug 735810 - performance shrinkage of Paths tool Use a GQueue instead of a GList in GimpCanvasGroup, so adding items takes constant time instead of O(n). Also, removing items was traversing the list twice. This should generally speed up tools with lots of canvas items. Also, add a private pointer to the instance struct instead of using a GET_PRIVATE() macro.
2016-01-24 07:54:48 +08:00
for (list = group->priv->items->head; list; list = g_list_next (list))
app: add a canvas group item which keeps around sub-items It can draw them all with one call to draw() and returns a union of their extents via get_extents().
2010-09-25 23:14:57 +08:00
{
GimpCanvasItem *sub_item = list->data;
app: remove "shell" parameter from GimpCanvasItem's public APIs because each item has a shell now. Keep the parameter in the virtual functions though because that saves a lot of code in the subclasses.
2010-10-01 20:54:53 +08:00
gimp_canvas_item_draw (sub_item, cr);
app: add a canvas group item which keeps around sub-items It can draw them all with one call to draw() and returns a union of their extents via get_extents().
2010-09-25 23:14:57 +08:00
}
app: add an infrastructure that allows to stroke multiple items at once In order to avoid visually overlapping lines: - GimpCanvasItem got a "suspend_stroking" API that allows to skip stroking and instead starts a new sub-path - GimpCanvasGroup got a "group_stroking" API that sets suspend_stroking on all its children and does one stroke after calling all items' draw().
2010-09-26 20:12:54 +08:00
Bug 735810 - performance shrinkage of Paths tool Use a GQueue instead of a GList in GimpCanvasGroup, so adding items takes constant time instead of O(n). Also, removing items was traversing the list twice. This should generally speed up tools with lots of canvas items. Also, add a private pointer to the instance struct instead of using a GET_PRIVATE() macro.
2016-01-24 07:54:48 +08:00
if (group->priv->group_stroking)
app: remove "shell" parameter from GimpCanvasItem's public APIs because each item has a shell now. Keep the parameter in the virtual functions though because that saves a lot of code in the subclasses.
2010-10-01 20:54:53 +08:00
_gimp_canvas_item_stroke (item, cr);
app: add group filling support to GimpCanvasItem and GimpCanvasGroup The code is almost identical to the group stroking feature.
2010-09-28 04:59:36 +08:00
Bug 735810 - performance shrinkage of Paths tool Use a GQueue instead of a GList in GimpCanvasGroup, so adding items takes constant time instead of O(n). Also, removing items was traversing the list twice. This should generally speed up tools with lots of canvas items. Also, add a private pointer to the instance struct instead of using a GET_PRIVATE() macro.
2016-01-24 07:54:48 +08:00
if (group->priv->group_filling)
app: remove "shell" parameter from GimpCanvasItem's public APIs because each item has a shell now. Keep the parameter in the virtual functions though because that saves a lot of code in the subclasses.
2010-10-01 20:54:53 +08:00
_gimp_canvas_item_fill (item, cr);
app: add a canvas group item which keeps around sub-items It can draw them all with one call to draw() and returns a union of their extents via get_extents().
2010-09-25 23:14:57 +08:00
}
app: use cairo_region_t for canvas items if cairo >= 1.10 is available This is a gross hack that typedefs around between GdkRegion and cairo_region_t and has some evil #ifdefs. This is going to die immeditately once we can depend on cairo 1.10.
2010-10-19 01:59:13 +08:00
static cairo_region_t *
app: remove GimpDisplayShell parameters from all GimpCanvasItem vfuncs and get the shell from gimp_canvas_item_get_shell() if needed. Remove some cairo_translate() that didn't have any effect and were leftovers from a very early canvas item code.
2013-04-18 21:45:08 +08:00
gimp_canvas_group_get_extents (GimpCanvasItem *item)
app: add a canvas group item which keeps around sub-items It can draw them all with one call to draw() and returns a union of their extents via get_extents().
2010-09-25 23:14:57 +08:00
{
Bug 735810 - performance shrinkage of Paths tool Use a GQueue instead of a GList in GimpCanvasGroup, so adding items takes constant time instead of O(n). Also, removing items was traversing the list twice. This should generally speed up tools with lots of canvas items. Also, add a private pointer to the instance struct instead of using a GET_PRIVATE() macro.
2016-01-24 07:54:48 +08:00
GimpCanvasGroup *group = GIMP_CANVAS_GROUP (item);
cairo_region_t *region = NULL;
GList *list;
app: add a canvas group item which keeps around sub-items It can draw them all with one call to draw() and returns a union of their extents via get_extents().
2010-09-25 23:14:57 +08:00
Bug 735810 - performance shrinkage of Paths tool Use a GQueue instead of a GList in GimpCanvasGroup, so adding items takes constant time instead of O(n). Also, removing items was traversing the list twice. This should generally speed up tools with lots of canvas items. Also, add a private pointer to the instance struct instead of using a GET_PRIVATE() macro.
2016-01-24 07:54:48 +08:00
for (list = group->priv->items->head; list; list = g_list_next (list))
app: add a canvas group item which keeps around sub-items It can draw them all with one call to draw() and returns a union of their extents via get_extents().
2010-09-25 23:14:57 +08:00
{
GimpCanvasItem *sub_item = list->data;
app: use cairo_region_t for canvas items if cairo >= 1.10 is available This is a gross hack that typedefs around between GdkRegion and cairo_region_t and has some evil #ifdefs. This is going to die immeditately once we can depend on cairo 1.10.
2010-10-19 01:59:13 +08:00
cairo_region_t *sub_region = gimp_canvas_item_get_extents (sub_item);
app: add a canvas group item which keeps around sub-items It can draw them all with one call to draw() and returns a union of their extents via get_extents().
2010-09-25 23:14:57 +08:00
app: add group filling support to GimpCanvasItem and GimpCanvasGroup The code is almost identical to the group stroking feature.
2010-09-28 04:59:36 +08:00
if (! region)
app: add a canvas group item which keeps around sub-items It can draw them all with one call to draw() and returns a union of their extents via get_extents().
2010-09-25 23:14:57 +08:00
{
app: add group filling support to GimpCanvasItem and GimpCanvasGroup The code is almost identical to the group stroking feature.
2010-09-28 04:59:36 +08:00
region = sub_region;
app: add a canvas group item which keeps around sub-items It can draw them all with one call to draw() and returns a union of their extents via get_extents().
2010-09-25 23:14:57 +08:00
}
app: add group filling support to GimpCanvasItem and GimpCanvasGroup The code is almost identical to the group stroking feature.
2010-09-28 04:59:36 +08:00
else if (sub_region)
app: add a canvas group item which keeps around sub-items It can draw them all with one call to draw() and returns a union of their extents via get_extents().
2010-09-25 23:14:57 +08:00
{
app: use cairo_region_t for canvas items if cairo >= 1.10 is available This is a gross hack that typedefs around between GdkRegion and cairo_region_t and has some evil #ifdefs. This is going to die immeditately once we can depend on cairo 1.10.
2010-10-19 01:59:13 +08:00
cairo_region_union (region, sub_region);
cairo_region_destroy (sub_region);
app: add a canvas group item which keeps around sub-items It can draw them all with one call to draw() and returns a union of their extents via get_extents().
2010-09-25 23:14:57 +08:00
}
}
return region;
}
app: add virtual function gboolean GimpCanvasItem::hit() and implement it for GimpCanvasHandle and GimpCanvasGroup.
2011-03-29 00:54:02 +08:00
static gboolean
app: remove GimpDisplayShell parameters from all GimpCanvasItem vfuncs and get the shell from gimp_canvas_item_get_shell() if needed. Remove some cairo_translate() that didn't have any effect and were leftovers from a very early canvas item code.
2013-04-18 21:45:08 +08:00
gimp_canvas_group_hit (GimpCanvasItem *item,
gdouble x,
gdouble y)
app: add virtual function gboolean GimpCanvasItem::hit() and implement it for GimpCanvasHandle and GimpCanvasGroup.
2011-03-29 00:54:02 +08:00
{
Bug 735810 - performance shrinkage of Paths tool Use a GQueue instead of a GList in GimpCanvasGroup, so adding items takes constant time instead of O(n). Also, removing items was traversing the list twice. This should generally speed up tools with lots of canvas items. Also, add a private pointer to the instance struct instead of using a GET_PRIVATE() macro.
2016-01-24 07:54:48 +08:00
GimpCanvasGroup *group = GIMP_CANVAS_GROUP (item);
GList *list;
app: add virtual function gboolean GimpCanvasItem::hit() and implement it for GimpCanvasHandle and GimpCanvasGroup.
2011-03-29 00:54:02 +08:00
Bug 735810 - performance shrinkage of Paths tool Use a GQueue instead of a GList in GimpCanvasGroup, so adding items takes constant time instead of O(n). Also, removing items was traversing the list twice. This should generally speed up tools with lots of canvas items. Also, add a private pointer to the instance struct instead of using a GET_PRIVATE() macro.
2016-01-24 07:54:48 +08:00
for (list = group->priv->items->head; list; list = g_list_next (list))
app: add virtual function gboolean GimpCanvasItem::hit() and implement it for GimpCanvasHandle and GimpCanvasGroup.
2011-03-29 00:54:02 +08:00
{
if (gimp_canvas_item_hit (list->data, x, y))
return TRUE;
}
return FALSE;
}
app: add an "update" signal to GimpCanvasItem which gets emitted when the item wants to be redrawn: - Emit "update" it when any item property changes - Groups connect to their children and forward "update" for them - The shell connects to its group of canvas items and exposed the affected area - Remove gimp_display_shell_expose_item() - Move all the shell's item group code into gimpdisplayshell-items.c
2010-10-01 23:13:00 +08:00
static void
gimp_canvas_group_child_update (GimpCanvasItem *item,
app: use cairo_region_t for canvas items if cairo >= 1.10 is available This is a gross hack that typedefs around between GdkRegion and cairo_region_t and has some evil #ifdefs. This is going to die immeditately once we can depend on cairo 1.10.
2010-10-19 01:59:13 +08:00
cairo_region_t *region,
app: add an "update" signal to GimpCanvasItem which gets emitted when the item wants to be redrawn: - Emit "update" it when any item property changes - Groups connect to their children and forward "update" for them - The shell connects to its group of canvas items and exposed the affected area - Remove gimp_display_shell_expose_item() - Move all the shell's item group code into gimpdisplayshell-items.c
2010-10-01 23:13:00 +08:00
GimpCanvasGroup *group)
{
app: add a "visible" property and API to GimpCanvasItem and use it to set visibility of guides and sample points, so this reression is fixed. - return NULL extents for invisible items and never draw them - do nothing for invisible items in more places, like the group While hacking this, it turned out that it was a braino to collect an item's region before and after a change in dispatch_properties_changed(), so a new update had to be devised: - add a "change count" and new API begin_change()/end_change() - in begin_change(), remember the item's extents before the change - in end_change(), combine old and current extents and emit "update" - add some protected function to emit "update", and to figure if it makes sense at all to emit "update" on an item.
2010-10-02 02:41:27 +08:00
if (_gimp_canvas_item_needs_update (GIMP_CANVAS_ITEM (group)))
_gimp_canvas_item_update (GIMP_CANVAS_ITEM (group), region);
app: add an "update" signal to GimpCanvasItem which gets emitted when the item wants to be redrawn: - Emit "update" it when any item property changes - Groups connect to their children and forward "update" for them - The shell connects to its group of canvas items and exposed the affected area - Remove gimp_display_shell_expose_item() - Move all the shell's item group code into gimpdisplayshell-items.c
2010-10-01 23:13:00 +08:00
}
/* public functions */
app: add a canvas group item which keeps around sub-items It can draw them all with one call to draw() and returns a union of their extents via get_extents().
2010-09-25 23:14:57 +08:00
GimpCanvasItem *
app: add a "shell" property to GimpCanvasItem and pass it to all constructors. The GimpDisplayShell is needed because items are going to become more powerful soon.
2010-10-01 20:13:45 +08:00
gimp_canvas_group_new (GimpDisplayShell *shell)
app: add a canvas group item which keeps around sub-items It can draw them all with one call to draw() and returns a union of their extents via get_extents().
2010-09-25 23:14:57 +08:00
{
app: add a "shell" property to GimpCanvasItem and pass it to all constructors. The GimpDisplayShell is needed because items are going to become more powerful soon.
2010-10-01 20:13:45 +08:00
g_return_val_if_fail (GIMP_IS_DISPLAY_SHELL (shell), NULL);
return g_object_new (GIMP_TYPE_CANVAS_GROUP,
"shell", shell,
NULL);
app: add a canvas group item which keeps around sub-items It can draw them all with one call to draw() and returns a union of their extents via get_extents().
2010-09-25 23:14:57 +08:00
}
void
gimp_canvas_group_add_item (GimpCanvasGroup *group,
GimpCanvasItem *item)
{
g_return_if_fail (GIMP_IS_CANVAS_GROUP (group));
g_return_if_fail (GIMP_IS_CANVAS_ITEM (item));
g_return_if_fail (GIMP_CANVAS_ITEM (group) != item);
Bug 735810 - performance shrinkage of Paths tool Use a GQueue instead of a GList in GimpCanvasGroup, so adding items takes constant time instead of O(n). Also, removing items was traversing the list twice. This should generally speed up tools with lots of canvas items. Also, add a private pointer to the instance struct instead of using a GET_PRIVATE() macro.
2016-01-24 07:54:48 +08:00
if (group->priv->group_stroking)
app: add an infrastructure that allows to stroke multiple items at once In order to avoid visually overlapping lines: - GimpCanvasItem got a "suspend_stroking" API that allows to skip stroking and instead starts a new sub-path - GimpCanvasGroup got a "group_stroking" API that sets suspend_stroking on all its children and does one stroke after calling all items' draw().
2010-09-26 20:12:54 +08:00
gimp_canvas_item_suspend_stroking (item);
Bug 735810 - performance shrinkage of Paths tool Use a GQueue instead of a GList in GimpCanvasGroup, so adding items takes constant time instead of O(n). Also, removing items was traversing the list twice. This should generally speed up tools with lots of canvas items. Also, add a private pointer to the instance struct instead of using a GET_PRIVATE() macro.
2016-01-24 07:54:48 +08:00
if (group->priv->group_filling)
app: add group filling support to GimpCanvasItem and GimpCanvasGroup The code is almost identical to the group stroking feature.
2010-09-28 04:59:36 +08:00
gimp_canvas_item_suspend_filling (item);
Bug 735810 - performance shrinkage of Paths tool Use a GQueue instead of a GList in GimpCanvasGroup, so adding items takes constant time instead of O(n). Also, removing items was traversing the list twice. This should generally speed up tools with lots of canvas items. Also, add a private pointer to the instance struct instead of using a GET_PRIVATE() macro.
2016-01-24 07:54:48 +08:00
g_queue_push_tail (group->priv->items, g_object_ref (item));
app: add an "update" signal to GimpCanvasItem which gets emitted when the item wants to be redrawn: - Emit "update" it when any item property changes - Groups connect to their children and forward "update" for them - The shell connects to its group of canvas items and exposed the affected area - Remove gimp_display_shell_expose_item() - Move all the shell's item group code into gimpdisplayshell-items.c
2010-10-01 23:13:00 +08:00
app: add a "visible" property and API to GimpCanvasItem and use it to set visibility of guides and sample points, so this reression is fixed. - return NULL extents for invisible items and never draw them - do nothing for invisible items in more places, like the group While hacking this, it turned out that it was a braino to collect an item's region before and after a change in dispatch_properties_changed(), so a new update had to be devised: - add a "change count" and new API begin_change()/end_change() - in begin_change(), remember the item's extents before the change - in end_change(), combine old and current extents and emit "update" - add some protected function to emit "update", and to figure if it makes sense at all to emit "update" on an item.
2010-10-02 02:41:27 +08:00
if (_gimp_canvas_item_needs_update (GIMP_CANVAS_ITEM (group)))
app: add an "update" signal to GimpCanvasItem which gets emitted when the item wants to be redrawn: - Emit "update" it when any item property changes - Groups connect to their children and forward "update" for them - The shell connects to its group of canvas items and exposed the affected area - Remove gimp_display_shell_expose_item() - Move all the shell's item group code into gimpdisplayshell-items.c
2010-10-01 23:13:00 +08:00
{
app: use cairo_region_t for canvas items if cairo >= 1.10 is available This is a gross hack that typedefs around between GdkRegion and cairo_region_t and has some evil #ifdefs. This is going to die immeditately once we can depend on cairo 1.10.
2010-10-19 01:59:13 +08:00
cairo_region_t *region = gimp_canvas_item_get_extents (item);
app: add a "visible" property and API to GimpCanvasItem and use it to set visibility of guides and sample points, so this reression is fixed. - return NULL extents for invisible items and never draw them - do nothing for invisible items in more places, like the group While hacking this, it turned out that it was a braino to collect an item's region before and after a change in dispatch_properties_changed(), so a new update had to be devised: - add a "change count" and new API begin_change()/end_change() - in begin_change(), remember the item's extents before the change - in end_change(), combine old and current extents and emit "update" - add some protected function to emit "update", and to figure if it makes sense at all to emit "update" on an item.
2010-10-02 02:41:27 +08:00
if (region)
{
_gimp_canvas_item_update (GIMP_CANVAS_ITEM (group), region);
app: use cairo_region_t for canvas items if cairo >= 1.10 is available This is a gross hack that typedefs around between GdkRegion and cairo_region_t and has some evil #ifdefs. This is going to die immeditately once we can depend on cairo 1.10.
2010-10-19 01:59:13 +08:00
cairo_region_destroy (region);
app: add a "visible" property and API to GimpCanvasItem and use it to set visibility of guides and sample points, so this reression is fixed. - return NULL extents for invisible items and never draw them - do nothing for invisible items in more places, like the group While hacking this, it turned out that it was a braino to collect an item's region before and after a change in dispatch_properties_changed(), so a new update had to be devised: - add a "change count" and new API begin_change()/end_change() - in begin_change(), remember the item's extents before the change - in end_change(), combine old and current extents and emit "update" - add some protected function to emit "update", and to figure if it makes sense at all to emit "update" on an item.
2010-10-02 02:41:27 +08:00
}
app: add an "update" signal to GimpCanvasItem which gets emitted when the item wants to be redrawn: - Emit "update" it when any item property changes - Groups connect to their children and forward "update" for them - The shell connects to its group of canvas items and exposed the affected area - Remove gimp_display_shell_expose_item() - Move all the shell's item group code into gimpdisplayshell-items.c
2010-10-01 23:13:00 +08:00
}
g_signal_connect (item, "update",
G_CALLBACK (gimp_canvas_group_child_update),
group);
app: add a canvas group item which keeps around sub-items It can draw them all with one call to draw() and returns a union of their extents via get_extents().
2010-09-25 23:14:57 +08:00
}
app: add an infrastructure that allows to stroke multiple items at once In order to avoid visually overlapping lines: - GimpCanvasItem got a "suspend_stroking" API that allows to skip stroking and instead starts a new sub-path - GimpCanvasGroup got a "group_stroking" API that sets suspend_stroking on all its children and does one stroke after calling all items' draw().
2010-09-26 20:12:54 +08:00
void
gimp_canvas_group_remove_item (GimpCanvasGroup *group,
GimpCanvasItem *item)
{
Bug 735810 - performance shrinkage of Paths tool Use a GQueue instead of a GList in GimpCanvasGroup, so adding items takes constant time instead of O(n). Also, removing items was traversing the list twice. This should generally speed up tools with lots of canvas items. Also, add a private pointer to the instance struct instead of using a GET_PRIVATE() macro.
2016-01-24 07:54:48 +08:00
GList *list;
app: add an infrastructure that allows to stroke multiple items at once In order to avoid visually overlapping lines: - GimpCanvasItem got a "suspend_stroking" API that allows to skip stroking and instead starts a new sub-path - GimpCanvasGroup got a "group_stroking" API that sets suspend_stroking on all its children and does one stroke after calling all items' draw().
2010-09-26 20:12:54 +08:00
g_return_if_fail (GIMP_IS_CANVAS_GROUP (group));
g_return_if_fail (GIMP_IS_CANVAS_ITEM (item));
Bug 735810 - performance shrinkage of Paths tool Use a GQueue instead of a GList in GimpCanvasGroup, so adding items takes constant time instead of O(n). Also, removing items was traversing the list twice. This should generally speed up tools with lots of canvas items. Also, add a private pointer to the instance struct instead of using a GET_PRIVATE() macro.
2016-01-24 07:54:48 +08:00
list = g_queue_find (group->priv->items, item);
app: add an infrastructure that allows to stroke multiple items at once In order to avoid visually overlapping lines: - GimpCanvasItem got a "suspend_stroking" API that allows to skip stroking and instead starts a new sub-path - GimpCanvasGroup got a "group_stroking" API that sets suspend_stroking on all its children and does one stroke after calling all items' draw().
2010-09-26 20:12:54 +08:00
Bug 735810 - performance shrinkage of Paths tool Use a GQueue instead of a GList in GimpCanvasGroup, so adding items takes constant time instead of O(n). Also, removing items was traversing the list twice. This should generally speed up tools with lots of canvas items. Also, add a private pointer to the instance struct instead of using a GET_PRIVATE() macro.
2016-01-24 07:54:48 +08:00
g_return_if_fail (list != NULL);
app: add an infrastructure that allows to stroke multiple items at once In order to avoid visually overlapping lines: - GimpCanvasItem got a "suspend_stroking" API that allows to skip stroking and instead starts a new sub-path - GimpCanvasGroup got a "group_stroking" API that sets suspend_stroking on all its children and does one stroke after calling all items' draw().
2010-09-26 20:12:54 +08:00
Bug 735810 - performance shrinkage of Paths tool Use a GQueue instead of a GList in GimpCanvasGroup, so adding items takes constant time instead of O(n). Also, removing items was traversing the list twice. This should generally speed up tools with lots of canvas items. Also, add a private pointer to the instance struct instead of using a GET_PRIVATE() macro.
2016-01-24 07:54:48 +08:00
g_queue_delete_link (group->priv->items, list);
app: add an "update" signal to GimpCanvasItem which gets emitted when the item wants to be redrawn: - Emit "update" it when any item property changes - Groups connect to their children and forward "update" for them - The shell connects to its group of canvas items and exposed the affected area - Remove gimp_display_shell_expose_item() - Move all the shell's item group code into gimpdisplayshell-items.c
2010-10-01 23:13:00 +08:00
Bug 735810 - performance shrinkage of Paths tool Use a GQueue instead of a GList in GimpCanvasGroup, so adding items takes constant time instead of O(n). Also, removing items was traversing the list twice. This should generally speed up tools with lots of canvas items. Also, add a private pointer to the instance struct instead of using a GET_PRIVATE() macro.
2016-01-24 07:54:48 +08:00
if (group->priv->group_stroking)
app: manage the stroking/filling state of child items correctly in all cases It was correct only for the currently existing use cases.
2010-10-03 01:58:35 +08:00
gimp_canvas_item_resume_stroking (item);
Bug 735810 - performance shrinkage of Paths tool Use a GQueue instead of a GList in GimpCanvasGroup, so adding items takes constant time instead of O(n). Also, removing items was traversing the list twice. This should generally speed up tools with lots of canvas items. Also, add a private pointer to the instance struct instead of using a GET_PRIVATE() macro.
2016-01-24 07:54:48 +08:00
if (group->priv->group_filling)
app: manage the stroking/filling state of child items correctly in all cases It was correct only for the currently existing use cases.
2010-10-03 01:58:35 +08:00
gimp_canvas_item_resume_filling (item);
app: add a "visible" property and API to GimpCanvasItem and use it to set visibility of guides and sample points, so this reression is fixed. - return NULL extents for invisible items and never draw them - do nothing for invisible items in more places, like the group While hacking this, it turned out that it was a braino to collect an item's region before and after a change in dispatch_properties_changed(), so a new update had to be devised: - add a "change count" and new API begin_change()/end_change() - in begin_change(), remember the item's extents before the change - in end_change(), combine old and current extents and emit "update" - add some protected function to emit "update", and to figure if it makes sense at all to emit "update" on an item.
2010-10-02 02:41:27 +08:00
if (_gimp_canvas_item_needs_update (GIMP_CANVAS_ITEM (group)))
app: add an "update" signal to GimpCanvasItem which gets emitted when the item wants to be redrawn: - Emit "update" it when any item property changes - Groups connect to their children and forward "update" for them - The shell connects to its group of canvas items and exposed the affected area - Remove gimp_display_shell_expose_item() - Move all the shell's item group code into gimpdisplayshell-items.c
2010-10-01 23:13:00 +08:00
{
app: use cairo_region_t for canvas items if cairo >= 1.10 is available This is a gross hack that typedefs around between GdkRegion and cairo_region_t and has some evil #ifdefs. This is going to die immeditately once we can depend on cairo 1.10.
2010-10-19 01:59:13 +08:00
cairo_region_t *region = gimp_canvas_item_get_extents (item);
app: add a "visible" property and API to GimpCanvasItem and use it to set visibility of guides and sample points, so this reression is fixed. - return NULL extents for invisible items and never draw them - do nothing for invisible items in more places, like the group While hacking this, it turned out that it was a braino to collect an item's region before and after a change in dispatch_properties_changed(), so a new update had to be devised: - add a "change count" and new API begin_change()/end_change() - in begin_change(), remember the item's extents before the change - in end_change(), combine old and current extents and emit "update" - add some protected function to emit "update", and to figure if it makes sense at all to emit "update" on an item.
2010-10-02 02:41:27 +08:00
if (region)
{
_gimp_canvas_item_update (GIMP_CANVAS_ITEM (group), region);
app: use cairo_region_t for canvas items if cairo >= 1.10 is available This is a gross hack that typedefs around between GdkRegion and cairo_region_t and has some evil #ifdefs. This is going to die immeditately once we can depend on cairo 1.10.
2010-10-19 01:59:13 +08:00
cairo_region_destroy (region);
app: add a "visible" property and API to GimpCanvasItem and use it to set visibility of guides and sample points, so this reression is fixed. - return NULL extents for invisible items and never draw them - do nothing for invisible items in more places, like the group While hacking this, it turned out that it was a braino to collect an item's region before and after a change in dispatch_properties_changed(), so a new update had to be devised: - add a "change count" and new API begin_change()/end_change() - in begin_change(), remember the item's extents before the change - in end_change(), combine old and current extents and emit "update" - add some protected function to emit "update", and to figure if it makes sense at all to emit "update" on an item.
2010-10-02 02:41:27 +08:00
}
app: add an "update" signal to GimpCanvasItem which gets emitted when the item wants to be redrawn: - Emit "update" it when any item property changes - Groups connect to their children and forward "update" for them - The shell connects to its group of canvas items and exposed the affected area - Remove gimp_display_shell_expose_item() - Move all the shell's item group code into gimpdisplayshell-items.c
2010-10-01 23:13:00 +08:00
}
g_signal_handlers_disconnect_by_func (item,
gimp_canvas_group_child_update,
group);
app: add an infrastructure that allows to stroke multiple items at once In order to avoid visually overlapping lines: - GimpCanvasItem got a "suspend_stroking" API that allows to skip stroking and instead starts a new sub-path - GimpCanvasGroup got a "group_stroking" API that sets suspend_stroking on all its children and does one stroke after calling all items' draw().
2010-09-26 20:12:54 +08:00
g_object_unref (item);
}
void
gimp_canvas_group_set_group_stroking (GimpCanvasGroup *group,
gboolean group_stroking)
{
g_return_if_fail (GIMP_IS_CANVAS_GROUP (group));
Bug 735810 - performance shrinkage of Paths tool Use a GQueue instead of a GList in GimpCanvasGroup, so adding items takes constant time instead of O(n). Also, removing items was traversing the list twice. This should generally speed up tools with lots of canvas items. Also, add a private pointer to the instance struct instead of using a GET_PRIVATE() macro.
2016-01-24 07:54:48 +08:00
if (group->priv->group_stroking != group_stroking)
app: manage the stroking/filling state of child items correctly in all cases It was correct only for the currently existing use cases.
2010-10-03 01:58:35 +08:00
{
GList *list;
gimp_canvas_item_begin_change (GIMP_CANVAS_ITEM (group));
g_object_set (group,
"group-stroking", group_stroking ? TRUE : FALSE,
NULL);
Bug 735810 - performance shrinkage of Paths tool Use a GQueue instead of a GList in GimpCanvasGroup, so adding items takes constant time instead of O(n). Also, removing items was traversing the list twice. This should generally speed up tools with lots of canvas items. Also, add a private pointer to the instance struct instead of using a GET_PRIVATE() macro.
2016-01-24 07:54:48 +08:00
for (list = group->priv->items->head; list; list = g_list_next (list))
app: manage the stroking/filling state of child items correctly in all cases It was correct only for the currently existing use cases.
2010-10-03 01:58:35 +08:00
{
Bug 735810 - performance shrinkage of Paths tool Use a GQueue instead of a GList in GimpCanvasGroup, so adding items takes constant time instead of O(n). Also, removing items was traversing the list twice. This should generally speed up tools with lots of canvas items. Also, add a private pointer to the instance struct instead of using a GET_PRIVATE() macro.
2016-01-24 07:54:48 +08:00
if (group->priv->group_stroking)
app: manage the stroking/filling state of child items correctly in all cases It was correct only for the currently existing use cases.
2010-10-03 01:58:35 +08:00
gimp_canvas_item_suspend_stroking (list->data);
else
gimp_canvas_item_resume_stroking (list->data);
}
gimp_canvas_item_end_change (GIMP_CANVAS_ITEM (group));
}
app: add an infrastructure that allows to stroke multiple items at once In order to avoid visually overlapping lines: - GimpCanvasItem got a "suspend_stroking" API that allows to skip stroking and instead starts a new sub-path - GimpCanvasGroup got a "group_stroking" API that sets suspend_stroking on all its children and does one stroke after calling all items' draw().
2010-09-26 20:12:54 +08:00
}
app: add group filling support to GimpCanvasItem and GimpCanvasGroup The code is almost identical to the group stroking feature.
2010-09-28 04:59:36 +08:00
void
gimp_canvas_group_set_group_filling (GimpCanvasGroup *group,
gboolean group_filling)
{
g_return_if_fail (GIMP_IS_CANVAS_GROUP (group));
Bug 735810 - performance shrinkage of Paths tool Use a GQueue instead of a GList in GimpCanvasGroup, so adding items takes constant time instead of O(n). Also, removing items was traversing the list twice. This should generally speed up tools with lots of canvas items. Also, add a private pointer to the instance struct instead of using a GET_PRIVATE() macro.
2016-01-24 07:54:48 +08:00
if (group->priv->group_filling != group_filling)
app: manage the stroking/filling state of child items correctly in all cases It was correct only for the currently existing use cases.
2010-10-03 01:58:35 +08:00
{
GList *list;
gimp_canvas_item_begin_change (GIMP_CANVAS_ITEM (group));
g_object_set (group,
"group-filling", group_filling ? TRUE : FALSE,
NULL);
Bug 735810 - performance shrinkage of Paths tool Use a GQueue instead of a GList in GimpCanvasGroup, so adding items takes constant time instead of O(n). Also, removing items was traversing the list twice. This should generally speed up tools with lots of canvas items. Also, add a private pointer to the instance struct instead of using a GET_PRIVATE() macro.
2016-01-24 07:54:48 +08:00
for (list = group->priv->items->head; list; list = g_list_next (list))
app: manage the stroking/filling state of child items correctly in all cases It was correct only for the currently existing use cases.
2010-10-03 01:58:35 +08:00
{
Bug 735810 - performance shrinkage of Paths tool Use a GQueue instead of a GList in GimpCanvasGroup, so adding items takes constant time instead of O(n). Also, removing items was traversing the list twice. This should generally speed up tools with lots of canvas items. Also, add a private pointer to the instance struct instead of using a GET_PRIVATE() macro.
2016-01-24 07:54:48 +08:00
if (group->priv->group_filling)
app: manage the stroking/filling state of child items correctly in all cases It was correct only for the currently existing use cases.
2010-10-03 01:58:35 +08:00
gimp_canvas_item_suspend_filling (list->data);
else
gimp_canvas_item_resume_filling (list->data);
}
gimp_canvas_item_end_change (GIMP_CANVAS_ITEM (group));
}
app: add group filling support to GimpCanvasItem and GimpCanvasGroup The code is almost identical to the group stroking feature.
2010-09-28 04:59:36 +08:00
}