2006-12-10 05:33:38 +08:00
|
|
|
/* GIMP - The GNU Image Manipulation Program
|
2002-02-26 01:58:50 +08:00
|
|
|
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
|
|
|
|
|
*
|
2009-01-18 06:28:01 +08:00
|
|
|
* This program is free software: you can redistribute it and/or modify
|
2002-02-26 01:58:50 +08:00
|
|
|
* it under the terms of the GNU General Public License as published by
|
2009-01-18 06:28:01 +08:00
|
|
|
* the Free Software Foundation; either version 3 of the License, or
|
2002-02-26 01:58:50 +08:00
|
|
|
* (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
|
2018-07-12 05:27:07 +08:00
|
|
|
* along with this program. If not, see <https://www.gnu.org/licenses/>.
|
2002-02-26 01:58:50 +08:00
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
#ifndef __GIMP_ITEM_H__
|
|
|
|
|
#define __GIMP_ITEM_H__
|
|
|
|
|
|
|
|
|
|
|
2013-04-11 08:54:42 +08:00
|
|
|
#include "gimpfilter.h"
|
2002-02-26 01:58:50 +08:00
|
|
|
|
|
|
|
|
|
|
|
|
|
#define GIMP_TYPE_ITEM (gimp_item_get_type ())
|
|
|
|
|
#define GIMP_ITEM(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_ITEM, GimpItem))
|
|
|
|
|
#define GIMP_ITEM_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_ITEM, GimpItemClass))
|
|
|
|
|
#define GIMP_IS_ITEM(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GIMP_TYPE_ITEM))
|
|
|
|
|
#define GIMP_IS_ITEM_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_ITEM))
|
|
|
|
|
#define GIMP_ITEM_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GIMP_TYPE_ITEM, GimpItemClass))
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
typedef struct _GimpItemClass GimpItemClass;
|
|
|
|
|
|
|
|
|
|
struct _GimpItem
|
|
|
|
|
{
|
2013-04-11 08:54:42 +08:00
|
|
|
GimpFilter parent_instance;
|
2002-02-26 01:58:50 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
struct _GimpItemClass
|
|
|
|
|
{
|
2013-04-11 08:54:42 +08:00
|
|
|
GimpFilterClass parent_class;
|
2002-02-26 01:58:50 +08:00
|
|
|
|
2003-02-11 21:52:47 +08:00
|
|
|
/* signals */
|
2012-11-09 18:17:25 +08:00
|
|
|
void (* removed) (GimpItem *item);
|
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
|
|
|
void (* visibility_changed) (GimpItem *item);
|
2012-11-09 18:17:25 +08:00
|
|
|
void (* linked_changed) (GimpItem *item);
|
2016-10-29 22:50:13 +08:00
|
|
|
void (* color_tag_changed) (GimpItem *item);
|
2012-11-09 18:17:25 +08:00
|
|
|
void (* lock_content_changed) (GimpItem *item);
|
|
|
|
|
void (* lock_position_changed) (GimpItem *item);
|
2003-02-11 21:52:47 +08:00
|
|
|
|
|
|
|
|
/* virtual functions */
|
2011-02-03 02:40:20 +08:00
|
|
|
void (* unset_removed) (GimpItem *item);
|
2016-05-20 05:51:44 +08:00
|
|
|
gboolean (* is_attached) (GimpItem *item);
|
|
|
|
|
gboolean (* is_content_locked) (GimpItem *item);
|
|
|
|
|
gboolean (* is_position_locked) (GimpItem *item);
|
2010-02-06 23:17:23 +08:00
|
|
|
GimpItemTree * (* get_tree) (GimpItem *item);
|
2015-06-30 18:34:46 +08:00
|
|
|
gboolean (* bounds) (GimpItem *item,
|
|
|
|
|
gdouble *x,
|
|
|
|
|
gdouble *y,
|
|
|
|
|
gdouble *width,
|
|
|
|
|
gdouble *height);
|
2009-08-02 02:22:07 +08:00
|
|
|
GimpItem * (* duplicate) (GimpItem *item,
|
|
|
|
|
GType new_type);
|
|
|
|
|
void (* convert) (GimpItem *item,
|
2015-08-16 21:47:43 +08:00
|
|
|
GimpImage *dest_image,
|
|
|
|
|
GType old_type);
|
2009-08-02 02:22:07 +08:00
|
|
|
gboolean (* rename) (GimpItem *item,
|
|
|
|
|
const gchar *new_name,
|
|
|
|
|
const gchar *undo_desc,
|
|
|
|
|
GError **error);
|
app: add gimp_item_{start,end}_move()
Add gimp_item_{start,end}_move(), and corresponding
GimpItem::{start,end}_move() virtual functions, which should be
called before/after "moving" the item (i.e., translating, scaling,
resizing, flipping, rotating, or transforming the item). Moves
performed between the outermost pair of start/end calls are treated
atomically.
What exactly does "treated atomically" entail depends on the
subclasses -- GimpItem doesn't provide a default implementation for
these functions, so the current commit doesn't change any behavior.
The next commit, which adds layer-mask support for group layers,
uses the functions to avoid cropping the mask too early while a
child is moving.
GimpItem calls {start,end}_move() in the various "move" functions
(gimp_item_{translate,scale,...}(), before performing the actual
operation. Additionally we call the functions in the
gimp_image_item_list_foo() functions, for each participating item,
so that the items are moved as a unit. We call the functions in
the various gimp_image_remove_foo() functions, since removing an
item may affect the size of its ancestors, and is therefore akin to
moving. We also call the functions in GimpEditSelectionTool, so
that the move tool moves items atomically while dragging.
2018-02-05 23:59:28 +08:00
|
|
|
void (* start_move) (GimpItem *item,
|
|
|
|
|
gboolean push_undo);
|
|
|
|
|
void (* end_move) (GimpItem *item,
|
|
|
|
|
gboolean push_undo);
|
Bug 795410 - Deleting a layer group and then undoing the deletion ...
... raises a CRITICAL
gimp_item_{start,end}_move() currently serves two different
purposes: It is used by GimpLayer to suspend/resume mask resizing
of the layer's ancestors; this is necessary whenever an operation
on a layer might affect the size of its ancestors. It is also used
by GimpGroupLayer to suspend/resume its own mask resizing; this, on
the other hand, is only necessary before applying one of the
transformation functions to the group, so that mask modification is
handled by GimpLayer. In other words, the effects of
gimp_item_{start,end}_move() on group layers are only necessary in
a subset of the cases in which these functions are used.
While in itself this isn't a problem, it does cause issues when
removing a group layer: gimp_image_remove_layer() calls
gimp_item_start_move() before removing the layer, and
gimp_item_end_move() afterwards. While the former function is
called while the layer is still attached to the image, the latter
function is called after the layer is no longer attached. Since
GimpGroupLayer pushes an undo step in response to these calls, only
the call to start_move() results in an undo step, while the call to
end_move() doesn't, resulting in an unbalanced
GIMP_UNDO_GROUP_LAYER_START_MOVE undo step on the stack. This
causes problems when undoing the operation.
Add gimp_item_{start,end}_transform() functions, and corresponding
GimpItem::{start,end}_transform() virtual functions, which are more
specialized versions of gimp_item_{start,end}_move(), which should
be used instead of the former before/after transforming an item; in
other cases, such as when removing ot reordering an item,
gimp_item_{start,end}_move() should still be used. The default
implementation of GimpItem::{start,end}_transform() calls
gimp_item_{start,end}_move(), respectively, so subclasses that
override these functions don't have to do that themselves.
In GimpGroupLayer, override GimpItem::{start,end}_transform(),
instead of GimpItem::{start,end}_move(), for the same purpose of
suspending mask resize. This avoids these functions from being
called when removing a layer group, fixing the bug.
2018-04-22 15:39:40 +08:00
|
|
|
void (* start_transform) (GimpItem *item,
|
|
|
|
|
gboolean push_undo);
|
|
|
|
|
void (* end_transform) (GimpItem *item,
|
|
|
|
|
gboolean push_undo);
|
2009-08-02 02:22:07 +08:00
|
|
|
void (* translate) (GimpItem *item,
|
2018-04-23 07:08:54 +08:00
|
|
|
gdouble offset_x,
|
|
|
|
|
gdouble offset_y,
|
2009-08-02 02:22:07 +08:00
|
|
|
gboolean push_undo);
|
|
|
|
|
void (* scale) (GimpItem *item,
|
|
|
|
|
gint new_width,
|
|
|
|
|
gint new_height,
|
|
|
|
|
gint new_offset_x,
|
|
|
|
|
gint new_offset_y,
|
|
|
|
|
GimpInterpolationType interpolation_type,
|
|
|
|
|
GimpProgress *progress);
|
|
|
|
|
void (* resize) (GimpItem *item,
|
|
|
|
|
GimpContext *context,
|
2016-10-10 06:02:16 +08:00
|
|
|
GimpFillType fill_type,
|
2009-08-02 02:22:07 +08:00
|
|
|
gint new_width,
|
|
|
|
|
gint new_height,
|
|
|
|
|
gint offset_x,
|
|
|
|
|
gint offset_y);
|
|
|
|
|
void (* flip) (GimpItem *item,
|
|
|
|
|
GimpContext *context,
|
|
|
|
|
GimpOrientationType flip_type,
|
|
|
|
|
gdouble axis,
|
|
|
|
|
gboolean clip_result);
|
|
|
|
|
void (* rotate) (GimpItem *item,
|
|
|
|
|
GimpContext *context,
|
|
|
|
|
GimpRotationType rotate_type,
|
|
|
|
|
gdouble center_x,
|
|
|
|
|
gdouble center_y,
|
|
|
|
|
gboolean clip_result);
|
|
|
|
|
void (* transform) (GimpItem *item,
|
|
|
|
|
GimpContext *context,
|
|
|
|
|
const GimpMatrix3 *matrix,
|
|
|
|
|
GimpTransformDirection direction,
|
|
|
|
|
GimpInterpolationType interpolation_type,
|
|
|
|
|
GimpTransformResize clip_result,
|
|
|
|
|
GimpProgress *progress);
|
2019-08-10 02:38:53 +08:00
|
|
|
GimpTransformResize (* get_clip) (GimpItem *item,
|
|
|
|
|
GimpTransformResize clip_result);
|
2016-03-15 02:02:18 +08:00
|
|
|
gboolean (* fill) (GimpItem *item,
|
|
|
|
|
GimpDrawable *drawable,
|
|
|
|
|
GimpFillOptions *fill_options,
|
|
|
|
|
gboolean push_undo,
|
|
|
|
|
GimpProgress *progress,
|
|
|
|
|
GError **error);
|
2009-08-02 02:22:07 +08:00
|
|
|
gboolean (* stroke) (GimpItem *item,
|
|
|
|
|
GimpDrawable *drawable,
|
|
|
|
|
GimpStrokeOptions *stroke_options,
|
|
|
|
|
gboolean push_undo,
|
|
|
|
|
GimpProgress *progress,
|
|
|
|
|
GError **error);
|
2010-07-21 05:09:19 +08:00
|
|
|
void (* to_selection) (GimpItem *item,
|
|
|
|
|
GimpChannelOps op,
|
|
|
|
|
gboolean antialias,
|
|
|
|
|
gboolean feather,
|
|
|
|
|
gdouble feather_radius_x,
|
|
|
|
|
gdouble feather_radius_y);
|
2003-03-17 08:14:59 +08:00
|
|
|
|
|
|
|
|
const gchar *default_name;
|
|
|
|
|
const gchar *rename_desc;
|
2004-04-13 19:43:27 +08:00
|
|
|
const gchar *translate_desc;
|
|
|
|
|
const gchar *scale_desc;
|
|
|
|
|
const gchar *resize_desc;
|
|
|
|
|
const gchar *flip_desc;
|
|
|
|
|
const gchar *rotate_desc;
|
|
|
|
|
const gchar *transform_desc;
|
2010-07-21 05:09:19 +08:00
|
|
|
const gchar *to_selection_desc;
|
2016-03-15 02:02:18 +08:00
|
|
|
const gchar *fill_desc;
|
2004-04-15 22:41:36 +08:00
|
|
|
const gchar *stroke_desc;
|
2010-07-09 00:08:13 +08:00
|
|
|
|
|
|
|
|
const gchar *reorder_desc;
|
|
|
|
|
const gchar *raise_desc;
|
|
|
|
|
const gchar *raise_to_top_desc;
|
|
|
|
|
const gchar *lower_desc;
|
|
|
|
|
const gchar *lower_to_bottom_desc;
|
|
|
|
|
|
|
|
|
|
const gchar *raise_failed;
|
|
|
|
|
const gchar *lower_failed;
|
2002-02-26 01:58:50 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
2009-08-02 04:40:32 +08:00
|
|
|
GType gimp_item_get_type (void) G_GNUC_CONST;
|
|
|
|
|
|
2011-02-01 19:47:24 +08:00
|
|
|
GimpItem * gimp_item_new (GType type,
|
|
|
|
|
GimpImage *image,
|
|
|
|
|
const gchar *name,
|
|
|
|
|
gint offset_x,
|
|
|
|
|
gint offset_y,
|
|
|
|
|
gint width,
|
|
|
|
|
gint height);
|
|
|
|
|
|
2009-08-02 04:40:32 +08:00
|
|
|
void gimp_item_removed (GimpItem *item);
|
2016-05-20 05:51:44 +08:00
|
|
|
gboolean gimp_item_is_removed (GimpItem *item);
|
2011-01-31 04:57:45 +08:00
|
|
|
void gimp_item_unset_removed (GimpItem *item);
|
2009-08-02 04:40:32 +08:00
|
|
|
|
2016-05-20 05:51:44 +08:00
|
|
|
gboolean gimp_item_is_attached (GimpItem *item);
|
2009-08-02 04:40:32 +08:00
|
|
|
|
2016-05-20 05:51:44 +08:00
|
|
|
GimpItem * gimp_item_get_parent (GimpItem *item);
|
2010-02-07 19:03:07 +08:00
|
|
|
|
2010-02-06 23:17:23 +08:00
|
|
|
GimpItemTree * gimp_item_get_tree (GimpItem *item);
|
2009-08-02 04:40:32 +08:00
|
|
|
GimpContainer * gimp_item_get_container (GimpItem *item);
|
|
|
|
|
GList * gimp_item_get_container_iter (GimpItem *item);
|
|
|
|
|
gint gimp_item_get_index (GimpItem *item);
|
2009-08-31 02:56:39 +08:00
|
|
|
GList * gimp_item_get_path (GimpItem *item);
|
2009-08-02 04:40:32 +08:00
|
|
|
|
2015-06-30 18:34:46 +08:00
|
|
|
gboolean gimp_item_bounds (GimpItem *item,
|
|
|
|
|
gint *x,
|
|
|
|
|
gint *y,
|
|
|
|
|
gint *width,
|
|
|
|
|
gint *height);
|
|
|
|
|
gboolean gimp_item_bounds_f (GimpItem *item,
|
|
|
|
|
gdouble *x,
|
|
|
|
|
gdouble *y,
|
|
|
|
|
gdouble *width,
|
|
|
|
|
gdouble *height);
|
|
|
|
|
|
2009-08-02 04:40:32 +08:00
|
|
|
GimpItem * gimp_item_duplicate (GimpItem *item,
|
|
|
|
|
GType new_type);
|
|
|
|
|
GimpItem * gimp_item_convert (GimpItem *item,
|
|
|
|
|
GimpImage *dest_image,
|
|
|
|
|
GType new_type);
|
|
|
|
|
|
|
|
|
|
gboolean gimp_item_rename (GimpItem *item,
|
|
|
|
|
const gchar *new_name,
|
|
|
|
|
GError **error);
|
|
|
|
|
|
2016-05-20 05:51:44 +08:00
|
|
|
gint gimp_item_get_width (GimpItem *item);
|
|
|
|
|
gint gimp_item_get_height (GimpItem *item);
|
2009-08-26 19:00:13 +08:00
|
|
|
void gimp_item_set_size (GimpItem *item,
|
|
|
|
|
gint width,
|
|
|
|
|
gint height);
|
2009-08-02 04:40:32 +08:00
|
|
|
|
2016-05-20 05:51:44 +08:00
|
|
|
void gimp_item_get_offset (GimpItem *item,
|
2009-08-02 04:40:32 +08:00
|
|
|
gint *offset_x,
|
|
|
|
|
gint *offset_y);
|
|
|
|
|
void gimp_item_set_offset (GimpItem *item,
|
|
|
|
|
gint offset_x,
|
|
|
|
|
gint offset_y);
|
|
|
|
|
gint gimp_item_get_offset_x (GimpItem *item);
|
|
|
|
|
gint gimp_item_get_offset_y (GimpItem *item);
|
|
|
|
|
|
app: add gimp_item_{start,end}_move()
Add gimp_item_{start,end}_move(), and corresponding
GimpItem::{start,end}_move() virtual functions, which should be
called before/after "moving" the item (i.e., translating, scaling,
resizing, flipping, rotating, or transforming the item). Moves
performed between the outermost pair of start/end calls are treated
atomically.
What exactly does "treated atomically" entail depends on the
subclasses -- GimpItem doesn't provide a default implementation for
these functions, so the current commit doesn't change any behavior.
The next commit, which adds layer-mask support for group layers,
uses the functions to avoid cropping the mask too early while a
child is moving.
GimpItem calls {start,end}_move() in the various "move" functions
(gimp_item_{translate,scale,...}(), before performing the actual
operation. Additionally we call the functions in the
gimp_image_item_list_foo() functions, for each participating item,
so that the items are moved as a unit. We call the functions in
the various gimp_image_remove_foo() functions, since removing an
item may affect the size of its ancestors, and is therefore akin to
moving. We also call the functions in GimpEditSelectionTool, so
that the move tool moves items atomically while dragging.
2018-02-05 23:59:28 +08:00
|
|
|
void gimp_item_start_move (GimpItem *item,
|
|
|
|
|
gboolean push_undo);
|
|
|
|
|
void gimp_item_end_move (GimpItem *item,
|
|
|
|
|
gboolean push_undo);
|
|
|
|
|
|
Bug 795410 - Deleting a layer group and then undoing the deletion ...
... raises a CRITICAL
gimp_item_{start,end}_move() currently serves two different
purposes: It is used by GimpLayer to suspend/resume mask resizing
of the layer's ancestors; this is necessary whenever an operation
on a layer might affect the size of its ancestors. It is also used
by GimpGroupLayer to suspend/resume its own mask resizing; this, on
the other hand, is only necessary before applying one of the
transformation functions to the group, so that mask modification is
handled by GimpLayer. In other words, the effects of
gimp_item_{start,end}_move() on group layers are only necessary in
a subset of the cases in which these functions are used.
While in itself this isn't a problem, it does cause issues when
removing a group layer: gimp_image_remove_layer() calls
gimp_item_start_move() before removing the layer, and
gimp_item_end_move() afterwards. While the former function is
called while the layer is still attached to the image, the latter
function is called after the layer is no longer attached. Since
GimpGroupLayer pushes an undo step in response to these calls, only
the call to start_move() results in an undo step, while the call to
end_move() doesn't, resulting in an unbalanced
GIMP_UNDO_GROUP_LAYER_START_MOVE undo step on the stack. This
causes problems when undoing the operation.
Add gimp_item_{start,end}_transform() functions, and corresponding
GimpItem::{start,end}_transform() virtual functions, which are more
specialized versions of gimp_item_{start,end}_move(), which should
be used instead of the former before/after transforming an item; in
other cases, such as when removing ot reordering an item,
gimp_item_{start,end}_move() should still be used. The default
implementation of GimpItem::{start,end}_transform() calls
gimp_item_{start,end}_move(), respectively, so subclasses that
override these functions don't have to do that themselves.
In GimpGroupLayer, override GimpItem::{start,end}_transform(),
instead of GimpItem::{start,end}_move(), for the same purpose of
suspending mask resize. This avoids these functions from being
called when removing a layer group, fixing the bug.
2018-04-22 15:39:40 +08:00
|
|
|
void gimp_item_start_transform (GimpItem *item,
|
|
|
|
|
gboolean push_undo);
|
|
|
|
|
void gimp_item_end_transform (GimpItem *item,
|
|
|
|
|
gboolean push_undo);
|
|
|
|
|
|
2009-08-02 04:40:32 +08:00
|
|
|
void gimp_item_translate (GimpItem *item,
|
2018-04-23 07:08:54 +08:00
|
|
|
gdouble offset_x,
|
|
|
|
|
gdouble offset_y,
|
2009-08-02 04:40:32 +08:00
|
|
|
gboolean push_undo);
|
|
|
|
|
|
2016-05-20 05:51:44 +08:00
|
|
|
gboolean gimp_item_check_scaling (GimpItem *item,
|
2009-08-02 04:40:32 +08:00
|
|
|
gint new_width,
|
|
|
|
|
gint new_height);
|
|
|
|
|
void gimp_item_scale (GimpItem *item,
|
|
|
|
|
gint new_width,
|
|
|
|
|
gint new_height,
|
|
|
|
|
gint new_offset_x,
|
|
|
|
|
gint new_offset_y,
|
|
|
|
|
GimpInterpolationType interpolation,
|
|
|
|
|
GimpProgress *progress);
|
|
|
|
|
gboolean gimp_item_scale_by_factors (GimpItem *item,
|
|
|
|
|
gdouble w_factor,
|
|
|
|
|
gdouble h_factor,
|
|
|
|
|
GimpInterpolationType interpolation,
|
|
|
|
|
GimpProgress *progress);
|
2018-03-25 23:20:14 +08:00
|
|
|
gboolean
|
|
|
|
|
gimp_item_scale_by_factors_with_origin (GimpItem *item,
|
|
|
|
|
gdouble w_factor,
|
|
|
|
|
gdouble h_factor,
|
|
|
|
|
gint origin_x,
|
|
|
|
|
gint origin_y,
|
|
|
|
|
gint new_origin_x,
|
|
|
|
|
gint new_origin_y,
|
|
|
|
|
GimpInterpolationType interpolation,
|
|
|
|
|
GimpProgress *progress);
|
2009-08-02 04:40:32 +08:00
|
|
|
void gimp_item_scale_by_origin (GimpItem *item,
|
|
|
|
|
gint new_width,
|
|
|
|
|
gint new_height,
|
|
|
|
|
GimpInterpolationType interpolation,
|
|
|
|
|
GimpProgress *progress,
|
|
|
|
|
gboolean local_origin);
|
|
|
|
|
void gimp_item_resize (GimpItem *item,
|
|
|
|
|
GimpContext *context,
|
2016-10-10 06:02:16 +08:00
|
|
|
GimpFillType fill_type,
|
2009-08-02 04:40:32 +08:00
|
|
|
gint new_width,
|
|
|
|
|
gint new_height,
|
|
|
|
|
gint offset_x,
|
|
|
|
|
gint offset_y);
|
|
|
|
|
void gimp_item_resize_to_image (GimpItem *item);
|
|
|
|
|
|
|
|
|
|
void gimp_item_flip (GimpItem *item,
|
|
|
|
|
GimpContext *context,
|
|
|
|
|
GimpOrientationType flip_type,
|
|
|
|
|
gdouble axis,
|
2015-10-19 03:00:21 +08:00
|
|
|
gboolean clip_result);
|
2009-08-02 04:40:32 +08:00
|
|
|
void gimp_item_rotate (GimpItem *item,
|
|
|
|
|
GimpContext *context,
|
|
|
|
|
GimpRotationType rotate_type,
|
|
|
|
|
gdouble center_x,
|
|
|
|
|
gdouble center_y,
|
2015-10-19 03:00:21 +08:00
|
|
|
gboolean clip_result);
|
2009-08-02 04:40:32 +08:00
|
|
|
void gimp_item_transform (GimpItem *item,
|
|
|
|
|
GimpContext *context,
|
|
|
|
|
const GimpMatrix3 *matrix,
|
|
|
|
|
GimpTransformDirection direction,
|
|
|
|
|
GimpInterpolationType interpolation_type,
|
|
|
|
|
GimpTransformResize clip_result,
|
|
|
|
|
GimpProgress *progress);
|
2019-08-10 02:38:53 +08:00
|
|
|
GimpTransformResize gimp_item_get_clip (GimpItem *item,
|
|
|
|
|
GimpTransformResize clip_result);
|
2009-08-02 04:40:32 +08:00
|
|
|
|
2016-03-15 02:02:18 +08:00
|
|
|
gboolean gimp_item_fill (GimpItem *item,
|
|
|
|
|
GimpDrawable *drawable,
|
|
|
|
|
GimpFillOptions *fill_options,
|
|
|
|
|
gboolean push_undo,
|
|
|
|
|
GimpProgress *progress,
|
|
|
|
|
GError **error);
|
2009-08-02 04:40:32 +08:00
|
|
|
gboolean gimp_item_stroke (GimpItem *item,
|
|
|
|
|
GimpDrawable *drawable,
|
|
|
|
|
GimpContext *context,
|
|
|
|
|
GimpStrokeOptions *stroke_options,
|
2014-02-07 06:20:39 +08:00
|
|
|
GimpPaintOptions *paint_options,
|
2009-08-02 04:40:32 +08:00
|
|
|
gboolean push_undo,
|
|
|
|
|
GimpProgress *progress,
|
|
|
|
|
GError **error);
|
|
|
|
|
|
2010-07-21 05:09:19 +08:00
|
|
|
void gimp_item_to_selection (GimpItem *item,
|
|
|
|
|
GimpChannelOps op,
|
|
|
|
|
gboolean antialias,
|
|
|
|
|
gboolean feather,
|
|
|
|
|
gdouble feather_radius_x,
|
|
|
|
|
gdouble feather_radius_y);
|
|
|
|
|
|
2012-05-16 04:25:12 +08:00
|
|
|
void gimp_item_add_offset_node (GimpItem *item,
|
|
|
|
|
GeglNode *node);
|
|
|
|
|
void gimp_item_remove_offset_node (GimpItem *item,
|
|
|
|
|
GeglNode *node);
|
2009-08-02 04:40:32 +08:00
|
|
|
|
|
|
|
|
gint gimp_item_get_ID (GimpItem *item);
|
|
|
|
|
GimpItem * gimp_item_get_by_ID (Gimp *gimp,
|
|
|
|
|
gint id);
|
|
|
|
|
|
2016-05-20 05:51:44 +08:00
|
|
|
GimpTattoo gimp_item_get_tattoo (GimpItem *item);
|
2009-08-02 04:40:32 +08:00
|
|
|
void gimp_item_set_tattoo (GimpItem *item,
|
|
|
|
|
GimpTattoo tattoo);
|
|
|
|
|
|
2016-05-20 05:51:44 +08:00
|
|
|
GimpImage * gimp_item_get_image (GimpItem *item);
|
2009-08-02 04:40:32 +08:00
|
|
|
void gimp_item_set_image (GimpItem *item,
|
|
|
|
|
GimpImage *image);
|
|
|
|
|
|
2011-01-31 02:26:32 +08:00
|
|
|
void gimp_item_replace_item (GimpItem *item,
|
|
|
|
|
GimpItem *replace);
|
|
|
|
|
|
2011-02-01 06:51:18 +08:00
|
|
|
void gimp_item_set_parasites (GimpItem *item,
|
|
|
|
|
GimpParasiteList *parasites);
|
2016-05-20 05:51:44 +08:00
|
|
|
GimpParasiteList * gimp_item_get_parasites (GimpItem *item);
|
2011-02-01 06:51:18 +08:00
|
|
|
|
2014-03-22 07:11:15 +08:00
|
|
|
gboolean gimp_item_parasite_validate (GimpItem *item,
|
|
|
|
|
const GimpParasite *parasite,
|
|
|
|
|
GError **error);
|
2009-08-02 04:40:32 +08:00
|
|
|
void gimp_item_parasite_attach (GimpItem *item,
|
2011-01-31 03:40:43 +08:00
|
|
|
const GimpParasite *parasite,
|
|
|
|
|
gboolean push_undo);
|
2009-08-02 04:40:32 +08:00
|
|
|
void gimp_item_parasite_detach (GimpItem *item,
|
2011-01-31 03:40:43 +08:00
|
|
|
const gchar *name,
|
|
|
|
|
gboolean push_undo);
|
2016-05-20 05:51:44 +08:00
|
|
|
const GimpParasite * gimp_item_parasite_find (GimpItem *item,
|
2009-08-02 04:40:32 +08:00
|
|
|
const gchar *name);
|
2016-05-20 05:51:44 +08:00
|
|
|
gchar ** gimp_item_parasite_list (GimpItem *item,
|
2009-08-02 04:40:32 +08:00
|
|
|
gint *count);
|
|
|
|
|
|
|
|
|
|
void gimp_item_set_visible (GimpItem *item,
|
|
|
|
|
gboolean visible,
|
|
|
|
|
gboolean push_undo);
|
2016-05-20 05:51:44 +08:00
|
|
|
gboolean gimp_item_get_visible (GimpItem *item);
|
|
|
|
|
gboolean gimp_item_is_visible (GimpItem *item);
|
2009-08-02 04:40:32 +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
|
|
|
void gimp_item_bind_visible_to_active (GimpItem *item,
|
|
|
|
|
gboolean bind);
|
|
|
|
|
|
2009-08-02 04:40:32 +08:00
|
|
|
void gimp_item_set_linked (GimpItem *item,
|
|
|
|
|
gboolean linked,
|
|
|
|
|
gboolean push_undo);
|
2016-05-20 05:51:44 +08:00
|
|
|
gboolean gimp_item_get_linked (GimpItem *item);
|
2009-08-02 04:40:32 +08:00
|
|
|
|
2016-10-29 22:50:13 +08:00
|
|
|
void gimp_item_set_color_tag (GimpItem *item,
|
|
|
|
|
GimpColorTag color_tag,
|
|
|
|
|
gboolean push_undo);
|
|
|
|
|
GimpColorTag gimp_item_get_color_tag (GimpItem *item);
|
2017-12-08 05:42:54 +08:00
|
|
|
GimpColorTag gimp_item_get_merged_color_tag (GimpItem *item);
|
2016-10-29 22:50:13 +08:00
|
|
|
|
2009-08-19 19:37:41 +08:00
|
|
|
void gimp_item_set_lock_content (GimpItem *item,
|
|
|
|
|
gboolean lock_content,
|
|
|
|
|
gboolean push_undo);
|
2016-05-20 05:51:44 +08:00
|
|
|
gboolean gimp_item_get_lock_content (GimpItem *item);
|
|
|
|
|
gboolean gimp_item_can_lock_content (GimpItem *item);
|
|
|
|
|
gboolean gimp_item_is_content_locked (GimpItem *item);
|
2009-08-19 19:37:41 +08:00
|
|
|
|
2012-11-09 18:17:25 +08:00
|
|
|
void gimp_item_set_lock_position (GimpItem *item,
|
|
|
|
|
gboolean lock_position,
|
|
|
|
|
gboolean push_undo);
|
2016-05-20 05:51:44 +08:00
|
|
|
gboolean gimp_item_get_lock_position (GimpItem *item);
|
|
|
|
|
gboolean gimp_item_can_lock_position (GimpItem *item);
|
|
|
|
|
gboolean gimp_item_is_position_locked (GimpItem *item);
|
2012-11-09 18:17:25 +08:00
|
|
|
|
2010-09-08 03:28:00 +08:00
|
|
|
gboolean gimp_item_mask_bounds (GimpItem *item,
|
|
|
|
|
gint *x1,
|
|
|
|
|
gint *y1,
|
|
|
|
|
gint *x2,
|
|
|
|
|
gint *y2);
|
|
|
|
|
gboolean gimp_item_mask_intersect (GimpItem *item,
|
|
|
|
|
gint *x,
|
|
|
|
|
gint *y,
|
|
|
|
|
gint *width,
|
|
|
|
|
gint *height);
|
|
|
|
|
|
2009-08-02 04:40:32 +08:00
|
|
|
gboolean gimp_item_is_in_set (GimpItem *item,
|
|
|
|
|
GimpItemSet set);
|
2006-05-21 19:32:41 +08:00
|
|
|
|
2002-02-26 01:58:50 +08:00
|
|
|
|
|
|
|
|
#endif /* __GIMP_ITEM_H__ */
|