diff --git a/ChangeLog b/ChangeLog index 884f0d7eaa..7501ebc930 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,3 +1,30 @@ +2004-10-22 Michael Natterer + + * app/core/core-enums.[ch]: added new enum GimpStrokeMethod which + can be one of { LIBART, PAINT_CORE }. + + * app/core/Makefile.am + * app/core/core-types.h + * app/core/gimpstrokedesc.[ch]: new object which encapsulates + the params and setup logic for the different stroke methods. + + * app/core/gimpitem.[ch]: use it in GimpItem::stroke() and + in the gimp_item_stroke() wrapper. + + * app/core/gimpchannel.c (gimp_channel_stroke) + * app/core/gimpselection.c (gimp_selection_stroke) + * app/vectors/gimpvectors.c (gimp_vectors_stroke): changed accprdingly. + + * app/actions/select-commands.c + * app/actions/vectors-commands.c + * app/dialogs/stroke-dialog.c + * tools/pdbgen/pdb/edit.pdb + * tools/pdbgen/pdb/paths.pdb: use GimpStrokeDesc. Simplifies the + code quite a bit. + + * app/pdb/edit_cmds.c + * app/pdb/paths_cmds.c: regenerated. + 2004-10-22 Michael Natterer * app/widgets/gimppropwidgets.c: remember the param_spec with each diff --git a/app/actions/select-commands.c b/app/actions/select-commands.c index 5c025cbe88..d6793449d2 100644 --- a/app/actions/select-commands.c +++ b/app/actions/select-commands.c @@ -30,7 +30,7 @@ #include "core/gimpchannel-select.h" #include "core/gimpimage.h" #include "core/gimpselection.h" -#include "core/gimpstrokeoptions.h" +#include "core/gimpstrokedesc.h" #include "widgets/gimphelp-ids.h" #include "widgets/gimpdialogfactory.h" @@ -285,11 +285,10 @@ void select_stroke_last_vals_cmd_callback (GtkAction *action, gpointer data) { - GimpImage *image; - GimpDrawable *drawable; - GimpContext *context; - GimpObject *options; - gboolean libart_stroking; + GimpImage *image; + GimpDrawable *drawable; + GimpContext *context; + GimpStrokeDesc *desc; return_if_no_image (image, data); drawable = gimp_image_active_drawable (image); @@ -302,36 +301,17 @@ select_stroke_last_vals_cmd_callback (GtkAction *action, context = gimp_get_user_context (image->gimp); - options = g_object_get_data (G_OBJECT (context), "saved-stroke-options"); + desc = g_object_get_data (G_OBJECT (context), "saved-stroke-desc"); - if (options) - { - g_object_ref (options); - libart_stroking = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (options), - "libart-stroking")); - } + if (desc) + g_object_ref (desc); else - { - options = g_object_new (GIMP_TYPE_STROKE_OPTIONS, - "gimp", image->gimp, - NULL); - libart_stroking = TRUE; - } + desc = gimp_stroke_desc_new (image->gimp, context); - if (libart_stroking) - { - gimp_item_stroke (GIMP_ITEM (gimp_image_get_mask (image)), - drawable, context, options, FALSE); - } - else - { - gimp_item_stroke (GIMP_ITEM (gimp_image_get_mask (image)), - drawable, context, - g_object_get_data (G_OBJECT (options), - "gimp-paint-info"), FALSE); - } + gimp_item_stroke (GIMP_ITEM (gimp_image_get_mask (image)), + drawable, context, desc, FALSE); - g_object_unref (options); + g_object_unref (desc); gimp_image_flush (image); } diff --git a/app/actions/vectors-commands.c b/app/actions/vectors-commands.c index 0597676e02..c0038f176c 100644 --- a/app/actions/vectors-commands.c +++ b/app/actions/vectors-commands.c @@ -36,7 +36,7 @@ #include "core/gimpimage-undo.h" #include "core/gimpitemundo.h" #include "core/gimpprogress.h" -#include "core/gimpstrokeoptions.h" +#include "core/gimpstrokedesc.h" #include "core/gimptoolinfo.h" #include "pdb/procedural_db.h" @@ -371,12 +371,11 @@ void vectors_stroke_last_vals_cmd_callback (GtkAction *action, gpointer data) { - GimpImage *image; - GimpVectors *vectors; - GimpDrawable *drawable; - GimpContext *context; - GimpObject *options; - gboolean libart_stroking; + GimpImage *image; + GimpVectors *vectors; + GimpDrawable *drawable; + GimpContext *context; + GimpStrokeDesc *desc; return_if_no_vectors (image, vectors, data); drawable = gimp_image_active_drawable (image); @@ -389,36 +388,16 @@ vectors_stroke_last_vals_cmd_callback (GtkAction *action, context = gimp_get_user_context (image->gimp); - options = g_object_get_data (G_OBJECT (context), "saved-stroke-options"); + desc = g_object_get_data (G_OBJECT (context), "saved-stroke-desc"); - if (options) - { - g_object_ref (options); - libart_stroking = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (options), - "libart-stroking")); - } + if (desc) + g_object_ref (desc); else - { - options = g_object_new (GIMP_TYPE_STROKE_OPTIONS, - "gimp", image->gimp, - NULL); - libart_stroking = TRUE; - } + desc = gimp_stroke_desc_new (image->gimp, context); - if (libart_stroking) - { - gimp_item_stroke (GIMP_ITEM (vectors), - drawable, context, options, FALSE); - } - else - { - gimp_item_stroke (GIMP_ITEM (vectors), - drawable, context, - g_object_get_data (G_OBJECT (options), - "gimp-paint-info"), FALSE); - } + gimp_item_stroke (GIMP_ITEM (vectors), drawable, context, desc, FALSE); - g_object_unref (options); + g_object_unref (desc); gimp_image_flush (image); } diff --git a/app/core/Makefile.am b/app/core/Makefile.am index 0ec474b202..387beeeaf0 100644 --- a/app/core/Makefile.am +++ b/app/core/Makefile.am @@ -200,6 +200,8 @@ libappcore_a_sources = \ gimpscanconvert.h \ gimpselection.c \ gimpselection.h \ + gimpstrokedesc.c \ + gimpstrokedesc.h \ gimpstrokeoptions.c \ gimpstrokeoptions.h \ gimptemplate.c \ diff --git a/app/core/core-enums.c b/app/core/core-enums.c index aa73480116..626fdcc7f5 100644 --- a/app/core/core-enums.c +++ b/app/core/core-enums.c @@ -264,6 +264,24 @@ gimp_grid_style_get_type (void) return type; } +GType +gimp_stroke_method_get_type (void) +{ + static const GEnumValue values[] = + { + { GIMP_STROKE_METHOD_LIBART, N_("Stroke line"), "libart" }, + { GIMP_STROKE_METHOD_PAINT_CORE, N_("Stroke with a paint tool"), "paint-core" }, + { 0, NULL, NULL } + }; + + static GType type = 0; + + if (! type) + type = g_enum_register_static ("GimpStrokeMethod", values); + + return type; +} + GType gimp_stroke_style_get_type (void) { diff --git a/app/core/core-enums.h b/app/core/core-enums.h index 048488bad8..b80d22d7c7 100644 --- a/app/core/core-enums.h +++ b/app/core/core-enums.h @@ -211,6 +211,17 @@ typedef enum /*< pdb-skip >*/ } GimpGridStyle; +#define GIMP_TYPE_STROKE_METHOD (gimp_stroke_method_get_type ()) + +GType gimp_stroke_method_get_type (void) G_GNUC_CONST; + +typedef enum /*< pdb-skip >*/ +{ + GIMP_STROKE_METHOD_LIBART, /*< desc="Stroke line" >*/ + GIMP_STROKE_METHOD_PAINT_CORE /*< desc="Stroke with a paint tool" >*/ +} GimpStrokeMethod; + + #define GIMP_TYPE_STROKE_STYLE (gimp_stroke_style_get_type ()) GType gimp_stroke_style_get_type (void) G_GNUC_CONST; diff --git a/app/core/core-types.h b/app/core/core-types.h index 423183b5d0..3c66df1444 100644 --- a/app/core/core-types.h +++ b/app/core/core-types.h @@ -116,6 +116,7 @@ typedef struct _GimpImageMap GimpImageMap; typedef struct _GimpParasiteList GimpParasiteList; typedef struct _GimpPdbProgress GimpPdbProgress; typedef struct _GimpProjection GimpProjection; +typedef struct _GimpStrokeDesc GimpStrokeDesc; /* typedef struct _GimpTemplate GimpTemplate; in config-types.h */ diff --git a/app/core/gimpchannel.c b/app/core/gimpchannel.c index f8e1f82711..1b54ed50f5 100644 --- a/app/core/gimpchannel.c +++ b/app/core/gimpchannel.c @@ -52,7 +52,7 @@ #include "gimpmarshal.h" #include "gimppaintinfo.h" #include "gimpprojection.h" -#include "gimpstrokeoptions.h" +#include "gimpstrokedesc.h" #include "gimp-intl.h" @@ -119,7 +119,7 @@ static void gimp_channel_transform (GimpItem *item, static gboolean gimp_channel_stroke (GimpItem *item, GimpDrawable *drawable, GimpContext *context, - GimpObject *stroke_desc); + GimpStrokeDesc *stroke_desc); static void gimp_channel_invalidate_boundary (GimpDrawable *drawable); static void gimp_channel_get_active_components (const GimpDrawable *drawable, @@ -610,10 +610,10 @@ gimp_channel_transform (GimpItem *item, } static gboolean -gimp_channel_stroke (GimpItem *item, - GimpDrawable *drawable, - GimpContext *context, - GimpObject *stroke_desc) +gimp_channel_stroke (GimpItem *item, + GimpDrawable *drawable, + GimpContext *context, + GimpStrokeDesc *stroke_desc) { GimpChannel *channel = GIMP_CHANNEL (item); @@ -634,27 +634,33 @@ gimp_channel_stroke (GimpItem *item, gimp_item_offsets (GIMP_ITEM (channel), &offset_x, &offset_y); - if (GIMP_IS_STROKE_OPTIONS (stroke_desc)) + switch (stroke_desc->method) { + case GIMP_STROKE_METHOD_LIBART: gimp_drawable_stroke_boundary (drawable, - GIMP_STROKE_OPTIONS (stroke_desc), + stroke_desc->stroke_options, segs_in, n_segs_in, offset_x, offset_y); retval = TRUE; - } - else if (GIMP_IS_PAINT_OPTIONS (stroke_desc)) - { - GimpPaintOptions *paint_options = GIMP_PAINT_OPTIONS (stroke_desc); - GimpPaintCore *core; + break; - core = g_object_new (paint_options->paint_info->paint_type, NULL); + case GIMP_STROKE_METHOD_PAINT_CORE: + { + GimpPaintCore *core; - retval = gimp_paint_core_stroke_boundary (core, drawable, - paint_options, - segs_in, n_segs_in, - offset_x, offset_y); + core = g_object_new (stroke_desc->paint_info->paint_type, NULL); - g_object_unref (core); + retval = gimp_paint_core_stroke_boundary (core, drawable, + stroke_desc->paint_options, + segs_in, n_segs_in, + offset_x, offset_y); + + g_object_unref (core); + } + break; + + default: + g_return_val_if_reached (FALSE); } return retval; diff --git a/app/core/gimpitem.c b/app/core/gimpitem.c index c14cb93010..bfa26d2e7f 100644 --- a/app/core/gimpitem.c +++ b/app/core/gimpitem.c @@ -27,11 +27,6 @@ #include "core-types.h" -#include "config/gimpconfig.h" -#include "config/gimpcoreconfig.h" - -#include "paint/gimppaintoptions.h" - #include "gimp.h" #include "gimp-parasites.h" #include "gimpdrawable.h" @@ -42,10 +37,9 @@ #include "gimpitem-preview.h" #include "gimplist.h" #include "gimpmarshal.h" -#include "gimppaintinfo.h" #include "gimpparasitelist.h" #include "gimpprogress.h" -#include "gimpstrokeoptions.h" +#include "gimpstrokedesc.h" #include "gimp-intl.h" @@ -973,11 +967,11 @@ gimp_item_transform (GimpItem *item, } gboolean -gimp_item_stroke (GimpItem *item, - GimpDrawable *drawable, - GimpContext *context, - GimpObject *stroke_desc, - gboolean use_default_values) +gimp_item_stroke (GimpItem *item, + GimpDrawable *drawable, + GimpContext *context, + GimpStrokeDesc *stroke_desc, + gboolean use_default_values) { GimpItemClass *item_class; gboolean retval = FALSE; @@ -985,8 +979,7 @@ gimp_item_stroke (GimpItem *item, g_return_val_if_fail (GIMP_IS_ITEM (item), FALSE); g_return_val_if_fail (GIMP_IS_DRAWABLE (drawable), FALSE); g_return_val_if_fail (GIMP_IS_CONTEXT (context), FALSE); - g_return_val_if_fail (GIMP_IS_PAINT_INFO (stroke_desc) || - GIMP_IS_STROKE_OPTIONS (stroke_desc), FALSE); + g_return_val_if_fail (GIMP_IS_STROKE_DESC (stroke_desc), FALSE); item_class = GIMP_ITEM_GET_CLASS (item); @@ -994,66 +987,16 @@ gimp_item_stroke (GimpItem *item, { GimpImage *gimage = gimp_item_get_image (item); + gimp_stroke_desc_prepare (stroke_desc, context, use_default_values); + gimp_image_undo_group_start (gimage, GIMP_UNDO_GROUP_PAINT, item_class->stroke_desc); - if (GIMP_IS_STROKE_OPTIONS (stroke_desc)) - { - g_object_ref (stroke_desc); - } - else if (GIMP_IS_PAINT_INFO (stroke_desc)) - { - GimpPaintInfo *paint_info = GIMP_PAINT_INFO (stroke_desc); - GimpPaintOptions *paint_options; - - if (use_default_values) - { - paint_options = gimp_paint_options_new (paint_info); - - /* undefine the paint-relevant context properties and get them - * from the passed context - */ - gimp_context_define_properties (GIMP_CONTEXT (paint_options), - GIMP_CONTEXT_PAINT_PROPS_MASK, - FALSE); - gimp_context_set_parent (GIMP_CONTEXT (paint_options), context); - } - else - { - GimpCoreConfig *config = context->gimp->config; - GimpContextPropMask global_props = 0; - - paint_options = - gimp_config_duplicate (GIMP_CONFIG (paint_info->paint_options)); - - /* FG and BG are always shared between all tools */ - global_props |= GIMP_CONTEXT_FOREGROUND_MASK; - global_props |= GIMP_CONTEXT_BACKGROUND_MASK; - - if (config->global_brush) - global_props |= GIMP_CONTEXT_BRUSH_MASK; - if (config->global_pattern) - global_props |= GIMP_CONTEXT_PATTERN_MASK; - if (config->global_palette) - global_props |= GIMP_CONTEXT_PALETTE_MASK; - if (config->global_gradient) - global_props |= GIMP_CONTEXT_GRADIENT_MASK; - if (config->global_font) - global_props |= GIMP_CONTEXT_FONT_MASK; - - gimp_context_copy_properties (context, - GIMP_CONTEXT (paint_options), - global_props); - } - - stroke_desc = GIMP_OBJECT (paint_options); - } - retval = item_class->stroke (item, drawable, context, stroke_desc); - g_object_unref (stroke_desc); - gimp_image_undo_group_end (gimage); + + gimp_stroke_desc_finish (stroke_desc); } return retval; diff --git a/app/core/gimpitem.h b/app/core/gimpitem.h index 1846db3d81..e5deddc7cb 100644 --- a/app/core/gimpitem.h +++ b/app/core/gimpitem.h @@ -115,7 +115,7 @@ struct _GimpItemClass gboolean (* stroke) (GimpItem *item, GimpDrawable *drawable, GimpContext *context, - GimpObject *stroke_desc); + GimpStrokeDesc *stroke_desc); const gchar *default_name; const gchar *rename_desc; @@ -221,7 +221,7 @@ void gimp_item_transform (GimpItem *item, gboolean gimp_item_stroke (GimpItem *item, GimpDrawable *drawable, GimpContext *context, - GimpObject *stroke_desc, + GimpStrokeDesc *stroke_desc, gboolean use_default_values); gint gimp_item_get_ID (GimpItem *item); diff --git a/app/core/gimpselection.c b/app/core/gimpselection.c index 7882bedcab..07a66165c4 100644 --- a/app/core/gimpselection.c +++ b/app/core/gimpselection.c @@ -77,7 +77,7 @@ static void gimp_selection_rotate (GimpItem *item, static gboolean gimp_selection_stroke (GimpItem *item, GimpDrawable *drawable, GimpContext *context, - GimpObject *stroke_desc); + GimpStrokeDesc *stroke_desc); static void gimp_selection_invalidate_boundary (GimpDrawable *drawable); @@ -287,10 +287,10 @@ gimp_selection_rotate (GimpItem *item, } static gboolean -gimp_selection_stroke (GimpItem *item, - GimpDrawable *drawable, - GimpContext *context, - GimpObject *stroke_desc) +gimp_selection_stroke (GimpItem *item, + GimpDrawable *drawable, + GimpContext *context, + GimpStrokeDesc *stroke_desc) { GimpSelection *selection = GIMP_SELECTION (item); const BoundSeg *dummy_in; diff --git a/app/core/gimpstrokedesc.c b/app/core/gimpstrokedesc.c new file mode 100644 index 0000000000..d99edcb063 --- /dev/null +++ b/app/core/gimpstrokedesc.c @@ -0,0 +1,380 @@ +/* The GIMP -- an image manipulation program + * Copyright (C) 1995-1999 Spencer Kimball and Peter Mattis + * + * gimpstrokedesc.c + * Copyright (C) 2004 Michael Natterer + * + * 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 2 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, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + +#include "config.h" + +#include + +#include "libgimpbase/gimpbase.h" + +#include "core-types.h" + +#include "config/gimpconfig.h" +#include "config/gimpconfig-params.h" +#include "config/gimpconfig-utils.h" +#include "config/gimpcoreconfig.h" + +#include "core/gimp.h" +#include "core/gimpcontext.h" +#include "core/gimptoolinfo.h" + +#include "gimppaintinfo.h" +#include "gimpstrokedesc.h" +#include "gimpstrokeoptions.h" + +#include "paint/gimppaintoptions.h" + + +enum +{ + PROP_0, + PROP_GIMP, + PROP_METHOD, + PROP_STROKE_OPTIONS, + PROP_PAINT_INFO, + PROP_PAINT_OPTIONS +}; + + +static void gimp_stroke_desc_class_init (GimpStrokeDescClass *klass); + +static GObject * gimp_stroke_desc_constructor (GType type, + guint n_params, + GObjectConstructParam *params); +static void gimp_stroke_desc_finalize (GObject *object); +static void gimp_stroke_desc_set_property (GObject *object, + guint property_id, + const GValue *value, + GParamSpec *pspec); +static void gimp_stroke_desc_get_property (GObject *object, + guint property_id, + GValue *value, + GParamSpec *pspec); + + +static GimpObjectClass *parent_class = NULL; + + +GType +gimp_stroke_desc_get_type (void) +{ + static GType type = 0; + + if (! type) + { + static const GTypeInfo info = + { + sizeof (GimpStrokeDescClass), + (GBaseInitFunc) NULL, + (GBaseFinalizeFunc) NULL, + (GClassInitFunc) gimp_stroke_desc_class_init, + NULL, /* class_finalize */ + NULL, /* class_data */ + sizeof (GimpStrokeDesc), + 0, /* n_preallocs */ + NULL /* instance_init */ + }; + static const GInterfaceInfo config_iface_info = + { + NULL, /* ifact_init */ + NULL, /* iface_finalize */ + NULL /* iface_data */ + }; + + type = g_type_register_static (GIMP_TYPE_OBJECT, + "GimpStrokeDesc", + &info, 0); + + g_type_add_interface_static (type, GIMP_TYPE_CONFIG, + &config_iface_info); + } + + return type; +} + +static void +gimp_stroke_desc_class_init (GimpStrokeDescClass *klass) +{ + GObjectClass *object_class = G_OBJECT_CLASS (klass); + + parent_class = g_type_class_peek_parent (klass); + + object_class->constructor = gimp_stroke_desc_constructor; + object_class->finalize = gimp_stroke_desc_finalize; + object_class->set_property = gimp_stroke_desc_set_property; + object_class->get_property = gimp_stroke_desc_get_property; + + g_object_class_install_property (object_class, PROP_GIMP, + g_param_spec_object ("gimp", + NULL, NULL, + GIMP_TYPE_GIMP, + G_PARAM_READWRITE | + G_PARAM_CONSTRUCT_ONLY)); + + GIMP_CONFIG_INSTALL_PROP_ENUM (object_class, PROP_METHOD, + "method", NULL, + GIMP_TYPE_STROKE_METHOD, + GIMP_STROKE_METHOD_LIBART, + 0); + + GIMP_CONFIG_INSTALL_PROP_OBJECT (object_class, PROP_STROKE_OPTIONS, + "stroke-options", NULL, + GIMP_TYPE_STROKE_OPTIONS, + GIMP_PARAM_AGGREGATE); + GIMP_CONFIG_INSTALL_PROP_OBJECT (object_class, PROP_PAINT_INFO, + "paint-info", NULL, + GIMP_TYPE_PAINT_INFO, + 0); + GIMP_CONFIG_INSTALL_PROP_OBJECT (object_class, PROP_PAINT_OPTIONS, + "paint-options", NULL, + GIMP_TYPE_PAINT_OPTIONS, + 0); +} + +static GObject * +gimp_stroke_desc_constructor (GType type, + guint n_params, + GObjectConstructParam *params) +{ + GObject *object; + GimpStrokeDesc *desc; + + object = G_OBJECT_CLASS (parent_class)->constructor (type, n_params, params); + + desc = GIMP_STROKE_DESC (object); + + g_assert (GIMP_IS_GIMP (desc->gimp)); + + desc->stroke_options = g_object_new (GIMP_TYPE_STROKE_OPTIONS, + "gimp", desc->gimp, + NULL); + + return object; +} + +static void +gimp_stroke_desc_finalize (GObject *object) +{ + GimpStrokeDesc *desc = GIMP_STROKE_DESC (object); + + if (desc->stroke_options) + { + g_object_unref (desc->stroke_options); + desc->stroke_options = NULL; + } + + if (desc->paint_info) + { + g_object_unref (desc->paint_info); + desc->paint_info = NULL; + } + + if (desc->paint_options) + { + g_object_unref (desc->paint_options); + desc->paint_options = NULL; + } + + G_OBJECT_CLASS (parent_class)->finalize (object); +} + +static void +gimp_stroke_desc_set_property (GObject *object, + guint property_id, + const GValue *value, + GParamSpec *pspec) +{ + GimpStrokeDesc *desc = GIMP_STROKE_DESC (object); + + switch (property_id) + { + case PROP_GIMP: + desc->gimp = g_value_get_object (value); + break; + case PROP_METHOD: + desc->method = g_value_get_enum (value); + break; + case PROP_STROKE_OPTIONS: + if (g_value_get_object (value)) + gimp_config_sync (GIMP_CONFIG (g_value_get_object (value)), + GIMP_CONFIG (desc->stroke_options), 0); + break; + case PROP_PAINT_INFO: + if (desc->paint_info) + g_object_unref (desc->paint_info); + desc->paint_info = (GimpPaintInfo *) g_value_dup_object (value); + break; + case PROP_PAINT_OPTIONS: + if (desc->paint_options) + g_object_unref (desc->paint_options); + desc->paint_options = (GimpPaintOptions *) g_value_dup_object (value); + break; + + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); + break; + } +} + +static void +gimp_stroke_desc_get_property (GObject *object, + guint property_id, + GValue *value, + GParamSpec *pspec) +{ + GimpStrokeDesc *desc = GIMP_STROKE_DESC (object); + + switch (property_id) + { + case PROP_GIMP: + g_value_set_object (value, desc->gimp); + break; + case PROP_METHOD: + g_value_set_enum (value, desc->method); + break; + case PROP_STROKE_OPTIONS: + g_value_set_object (value, desc->stroke_options); + break; + case PROP_PAINT_INFO: + g_value_set_object (value, desc->paint_info); + break; + case PROP_PAINT_OPTIONS: + g_value_set_object (value, desc->paint_options); + break; + + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); + break; + } +} + + +/* public functions */ + +GimpStrokeDesc * +gimp_stroke_desc_new (Gimp *gimp, + GimpContext *context) +{ + GimpPaintInfo *paint_info = NULL; + GimpStrokeDesc *desc; + + g_return_val_if_fail (GIMP_IS_GIMP (gimp), NULL); + g_return_val_if_fail (context == NULL || GIMP_IS_CONTEXT (context), NULL); + + if (context) + { + GimpToolInfo *tool_info = gimp_context_get_tool (context); + + if (tool_info) + paint_info = tool_info->paint_info; + } + + desc = g_object_new (GIMP_TYPE_STROKE_DESC, + "gimp", gimp, + "paint-info", paint_info, + NULL); + + gimp_context_define_properties (GIMP_CONTEXT (desc->stroke_options), + GIMP_CONTEXT_FOREGROUND_MASK | + GIMP_CONTEXT_PATTERN_MASK, + FALSE); + + if (context) + gimp_context_set_parent (GIMP_CONTEXT (desc->stroke_options), context); + + return desc; +} + +void +gimp_stroke_desc_prepare (GimpStrokeDesc *desc, + GimpContext *context, + gboolean use_default_values) +{ + g_return_if_fail (GIMP_IS_STROKE_DESC (desc)); + g_return_if_fail (GIMP_IS_CONTEXT (context)); + + switch (desc->method) + { + case GIMP_STROKE_METHOD_LIBART: + break; + + case GIMP_STROKE_METHOD_PAINT_CORE: + { + GimpPaintInfo *paint_info = desc->paint_info; + GimpPaintOptions *paint_options; + + if (use_default_values) + { + paint_options = gimp_paint_options_new (paint_info); + + /* undefine the paint-relevant context properties and get them + * from the passed context + */ + gimp_context_define_properties (GIMP_CONTEXT (paint_options), + GIMP_CONTEXT_PAINT_PROPS_MASK, + FALSE); + gimp_context_set_parent (GIMP_CONTEXT (paint_options), context); + } + else + { + GimpCoreConfig *config = context->gimp->config; + GimpContextPropMask global_props = 0; + + paint_options = + gimp_config_duplicate (GIMP_CONFIG (paint_info->paint_options)); + + /* FG and BG are always shared between all tools */ + global_props |= GIMP_CONTEXT_FOREGROUND_MASK; + global_props |= GIMP_CONTEXT_BACKGROUND_MASK; + + if (config->global_brush) + global_props |= GIMP_CONTEXT_BRUSH_MASK; + if (config->global_pattern) + global_props |= GIMP_CONTEXT_PATTERN_MASK; + if (config->global_palette) + global_props |= GIMP_CONTEXT_PALETTE_MASK; + if (config->global_gradient) + global_props |= GIMP_CONTEXT_GRADIENT_MASK; + if (config->global_font) + global_props |= GIMP_CONTEXT_FONT_MASK; + + gimp_context_copy_properties (context, + GIMP_CONTEXT (paint_options), + global_props); + } + + g_object_set (desc, "paint-options", paint_options, NULL); + g_object_unref (paint_options); + } + break; + + default: + g_return_if_reached (); + } +} + +void +gimp_stroke_desc_finish (GimpStrokeDesc *desc) +{ + g_return_if_fail (GIMP_IS_STROKE_DESC (desc)); + + g_object_set (desc, "paint-options", NULL, NULL); +} diff --git a/app/core/gimpstrokedesc.h b/app/core/gimpstrokedesc.h new file mode 100644 index 0000000000..5af3361bb1 --- /dev/null +++ b/app/core/gimpstrokedesc.h @@ -0,0 +1,70 @@ +/* The GIMP -- an image manipulation program + * Copyright (C) 1995-1999 Spencer Kimball and Peter Mattis + * + * gimpstrokedesc.h + * Copyright (C) 2004 Michael Natterer + * + * 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 2 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, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + +#ifndef __GIMP_STROKE_DESC_H__ +#define __GIMP_STROKE_DESC_H__ + + +#include "gimpcontext.h" + + +#define GIMP_TYPE_STROKE_DESC (gimp_stroke_desc_get_type ()) +#define GIMP_STROKE_DESC(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_STROKE_DESC, GimpStrokeDesc)) +#define GIMP_STROKE_DESC_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_STROKE_DESC, GimpStrokeDescClass)) +#define GIMP_IS_STROKE_DESC(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GIMP_TYPE_STROKE_DESC)) +#define GIMP_IS_STROKE_DESC_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_STROKE_DESC)) +#define GIMP_STROKE_DESC_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GIMP_TYPE_STROKE_DESC, GimpStrokeDescClass)) + + +typedef struct _GimpStrokeDescClass GimpStrokeDescClass; + +struct _GimpStrokeDesc +{ + GimpObject parent_instance; + + Gimp *gimp; + + GimpStrokeMethod method; + + GimpStrokeOptions *stroke_options; + GimpPaintInfo *paint_info; + + GimpPaintOptions *paint_options; +}; + +struct _GimpStrokeDescClass +{ + GimpObjectClass parent_class; +}; + + +GType gimp_stroke_desc_get_type (void) G_GNUC_CONST; + +GimpStrokeDesc * gimp_stroke_desc_new (Gimp *gimp, + GimpContext *context); + +void gimp_stroke_desc_prepare (GimpStrokeDesc *desc, + GimpContext *context, + gboolean use_default_values); +void gimp_stroke_desc_finish (GimpStrokeDesc *desc); + + +#endif /* __GIMP_STROKE_DESC_H__ */ diff --git a/app/dialogs/stroke-dialog.c b/app/dialogs/stroke-dialog.c index d325bb575c..46f1a683b1 100644 --- a/app/dialogs/stroke-dialog.c +++ b/app/dialogs/stroke-dialog.c @@ -33,11 +33,13 @@ #include "core/gimpdrawable.h" #include "core/gimpimage.h" #include "core/gimppaintinfo.h" +#include "core/gimpstrokedesc.h" #include "core/gimpstrokeoptions.h" #include "core/gimptoolinfo.h" #include "widgets/gimpcontainercombobox.h" #include "widgets/gimpcontainerview.h" +#include "widgets/gimppropwidgets.h" #include "widgets/gimpviewabledialog.h" #include "widgets/gimpstrokeeditor.h" @@ -57,69 +59,43 @@ static void stroke_dialog_response (GtkWidget *widget, static void stroke_dialog_paint_info_selected (GimpContainerView *view, GimpViewable *viewable, gpointer insert_data, - GtkWidget *dialog); + GimpStrokeDesc *desc); /* public function */ - GtkWidget * stroke_dialog_new (GimpItem *item, const gchar *stock_id, const gchar *help_id, GtkWidget *parent) { - GimpContext *context; - GimpStrokeOptions *options; - GimpStrokeOptions *saved_options; - GimpImage *image; - GtkWidget *dialog; - GtkWidget *main_vbox; - GtkWidget *button; - GSList *group; - GtkWidget *frame; - GimpToolInfo *tool_info; - gboolean libart_stroking = TRUE; - + GimpContext *context; + GimpStrokeDesc *desc; + GimpStrokeDesc *saved_desc; + GimpImage *image; + GtkWidget *dialog; + GtkWidget *main_vbox; + GtkWidget *radio_box; + GtkWidget *libart_radio; + GtkWidget *paint_radio; + GSList *group; + GtkWidget *frame; g_return_val_if_fail (GIMP_IS_ITEM (item), NULL); g_return_val_if_fail (stock_id != NULL, NULL); g_return_val_if_fail (help_id != NULL, NULL); g_return_val_if_fail (parent == NULL || GTK_IS_WIDGET (parent), NULL); - image = gimp_item_get_image (item); - context = gimp_get_user_context (image->gimp); - tool_info = gimp_context_get_tool (context); + image = gimp_item_get_image (item); + context = gimp_get_user_context (image->gimp); - options = g_object_new (GIMP_TYPE_STROKE_OPTIONS, - "gimp", image->gimp, - NULL); - g_object_set_data (G_OBJECT (options), "libart-stroking", - GINT_TO_POINTER (libart_stroking)); - g_object_set_data (G_OBJECT (options), "gimp-paint-info", - gimp_context_get_tool (context)->paint_info); + desc = gimp_stroke_desc_new (context->gimp, context); - saved_options = g_object_get_data (G_OBJECT (context), - "saved-stroke-options"); - if (saved_options) - { - gimp_config_sync (GIMP_CONFIG (saved_options), GIMP_CONFIG (options), 0); - libart_stroking = GPOINTER_TO_INT (g_object_get_data - (G_OBJECT (saved_options), - "libart-stroking")); + saved_desc = g_object_get_data (G_OBJECT (context), "saved-stroke-desc"); - g_object_set_data (G_OBJECT (options), "libart-stroking", - GINT_TO_POINTER (libart_stroking)); - g_object_set_data (G_OBJECT (options), "gimp-paint-info", - g_object_get_data (G_OBJECT (saved_options), - "gimp-paint-info")); - } - - gimp_context_set_parent (GIMP_CONTEXT (options), context); - gimp_context_define_properties (GIMP_CONTEXT (options), - GIMP_CONTEXT_FOREGROUND_MASK | - GIMP_CONTEXT_PATTERN_MASK, - FALSE); + if (saved_desc) + gimp_config_sync (GIMP_CONFIG (saved_desc), GIMP_CONFIG (desc), 0); /* the dialog */ dialog = @@ -142,7 +118,7 @@ stroke_dialog_new (GimpItem *item, dialog); g_object_set_data (G_OBJECT (dialog), "gimp-item", item); - g_object_set_data_full (G_OBJECT (dialog), "gimp-stroke-options", options, + g_object_set_data_full (G_OBJECT (dialog), "gimp-stroke-desc", desc, (GDestroyNotify) g_object_unref); gtk_window_set_resizable (GTK_WINDOW (dialog), FALSE); @@ -152,6 +128,31 @@ stroke_dialog_new (GimpItem *item, gtk_container_add (GTK_CONTAINER (GTK_DIALOG (dialog)->vbox), main_vbox); gtk_widget_show (main_vbox); + radio_box = gimp_prop_enum_radio_box_new (G_OBJECT (desc), "method", -1, -1); + + group = gtk_radio_button_get_group (g_object_get_data (G_OBJECT (radio_box), + "radio-button")); + + libart_radio = g_object_ref (group->next->data); + gtk_container_remove (GTK_CONTAINER (radio_box), libart_radio); + + paint_radio = g_object_ref (group->data); + gtk_container_remove (GTK_CONTAINER (radio_box), paint_radio); + + gtk_widget_destroy (radio_box); + + { + PangoFontDescription *font_desc; + + font_desc = pango_font_description_new (); + pango_font_description_set_weight (font_desc, PANGO_WEIGHT_BOLD); + + gtk_widget_modify_font (GTK_BIN (libart_radio)->child, font_desc); + gtk_widget_modify_font (GTK_BIN (paint_radio)->child, font_desc); + + pango_font_description_free (font_desc); + } + /* the stroke frame */ @@ -159,28 +160,26 @@ stroke_dialog_new (GimpItem *item, gtk_box_pack_start (GTK_BOX (main_vbox), frame, FALSE, FALSE, 0); gtk_widget_show (frame); - button = gtk_radio_button_new_with_label (NULL, _("Stroke line")); - group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (button)); - gtk_frame_set_label_widget (GTK_FRAME (frame), button); - gtk_widget_show (button); + gtk_frame_set_label_widget (GTK_FRAME (frame), libart_radio); + g_object_unref (libart_radio); - g_signal_connect (button, "toggled", + g_signal_connect (libart_radio, "toggled", G_CALLBACK (gimp_toggle_button_sensitive_update), NULL); - g_object_set_data (G_OBJECT (dialog), "gimp-stroke-button", button); - { GtkWidget *stroke_editor; - stroke_editor = gimp_stroke_editor_new (options, image->yresolution); + stroke_editor = gimp_stroke_editor_new (desc->stroke_options, + image->yresolution); gtk_container_add (GTK_CONTAINER (frame), stroke_editor); gtk_widget_show (stroke_editor); - g_object_set_data (G_OBJECT (button), "set_sensitive", stroke_editor); + gtk_widget_set_sensitive (stroke_editor, + desc->method == GIMP_STROKE_METHOD_LIBART); + g_object_set_data (G_OBJECT (libart_radio), "set_sensitive", stroke_editor); } - gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), libart_stroking); /* the paint tool frame */ @@ -188,28 +187,25 @@ stroke_dialog_new (GimpItem *item, gtk_box_pack_start (GTK_BOX (main_vbox), frame, FALSE, FALSE, 0); gtk_widget_show (frame); - button = gtk_radio_button_new_with_label (group, - _("Stroke with a paint tool")); - group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (button)); - gtk_frame_set_label_widget (GTK_FRAME (frame), button); - gtk_widget_show (button); + gtk_frame_set_label_widget (GTK_FRAME (frame), paint_radio); + g_object_unref (paint_radio); - g_signal_connect (button, "toggled", + g_signal_connect (paint_radio, "toggled", G_CALLBACK (gimp_toggle_button_sensitive_update), NULL); { - GtkWidget *hbox; - GtkWidget *label; - GtkWidget *combo; - GimpPaintInfo *paint_info; + GtkWidget *hbox; + GtkWidget *label; + GtkWidget *combo; hbox = gtk_hbox_new (FALSE, 6); gtk_container_add (GTK_CONTAINER (frame), hbox); gtk_widget_show (hbox); - gtk_widget_set_sensitive (GTK_WIDGET (hbox), FALSE); - g_object_set_data (G_OBJECT (button), "set_sensitive", hbox); + gtk_widget_set_sensitive (hbox, + desc->method == GIMP_STROKE_METHOD_PAINT_CORE); + g_object_set_data (G_OBJECT (paint_radio), "set_sensitive", hbox); label = gtk_label_new (_("Paint Tool:")); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0); @@ -217,24 +213,19 @@ stroke_dialog_new (GimpItem *item, combo = gimp_container_combo_box_new (image->gimp->paint_info_list, NULL, 16, 0); + gimp_container_view_select_item (GIMP_CONTAINER_VIEW (combo), + GIMP_VIEWABLE (desc->paint_info)); gtk_box_pack_start (GTK_BOX (hbox), combo, TRUE, TRUE, 0); gtk_widget_show (combo); g_signal_connect (combo, "select_item", G_CALLBACK (stroke_dialog_paint_info_selected), - dialog); + desc); - paint_info = GIMP_PAINT_INFO (g_object_get_data (G_OBJECT (options), - "gimp-paint-info")); - gimp_container_view_select_item (GIMP_CONTAINER_VIEW (combo), - GIMP_VIEWABLE (paint_info)); - g_object_set_data (G_OBJECT (dialog), "gimp-tool-menu", combo); - g_object_set_data (G_OBJECT (dialog), "gimp-paint-info", paint_info); + g_object_set_data (G_OBJECT (dialog), "gimp-tool-menu", combo); } - gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), !libart_stroking); - return dialog; } @@ -246,13 +237,13 @@ stroke_dialog_response (GtkWidget *widget, gint response_id, GtkWidget *dialog) { - GimpContext *context; - GimpItem *item; - GtkWidget *button; - GimpImage *image; + GimpStrokeDesc *desc; + GimpItem *item; + GimpImage *image; + GimpContext *context; - item = g_object_get_data (G_OBJECT (dialog), "gimp-item"); - button = g_object_get_data (G_OBJECT (dialog), "gimp-stroke-button"); + item = g_object_get_data (G_OBJECT (dialog), "gimp-item"); + desc = g_object_get_data (G_OBJECT (dialog), "gimp-stroke-desc"); image = gimp_item_get_image (item); context = gimp_get_user_context (image->gimp); @@ -261,28 +252,22 @@ stroke_dialog_response (GtkWidget *widget, { case RESPONSE_RESET: { - GObject *options; - GtkWidget *combo; - GimpToolInfo *tool_info; + GimpToolInfo *tool_info = gimp_context_get_tool (context); + GtkWidget *combo = g_object_get_data (G_OBJECT (dialog), + "gimp-tool-menu");; - options = g_object_get_data (G_OBJECT (dialog), "gimp-stroke-options"); - combo = g_object_get_data (G_OBJECT (dialog), "gimp-tool-menu"); + gimp_config_reset (GIMP_CONFIG (desc)); - tool_info = gimp_context_get_tool (context); - - gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE); gimp_container_view_select_item (GIMP_CONTAINER_VIEW (combo), GIMP_VIEWABLE (tool_info->paint_info)); - gimp_config_reset (GIMP_CONFIG (options)); } break; case GTK_RESPONSE_OK: { - GimpDrawable *drawable; - GimpObject *options; - GObject *saved_options; + GimpDrawable *drawable; + GimpStrokeDesc *saved_desc; drawable = gimp_image_active_drawable (image); @@ -292,42 +277,21 @@ stroke_dialog_response (GtkWidget *widget, return; } - saved_options = g_object_get_data (G_OBJECT (context), - "saved-stroke-options"); - options = g_object_get_data (G_OBJECT (dialog), - "gimp-stroke-options"); + saved_desc = g_object_get_data (G_OBJECT (context), + "saved-stroke-desc"); - if (saved_options) - { - gimp_config_sync (GIMP_CONFIG (options), - GIMP_CONFIG (saved_options), 0); - } + if (saved_desc) + g_object_ref (saved_desc); else - { - g_object_set_data_full (G_OBJECT (context), - "saved-stroke-options", - g_object_ref (options), - (GDestroyNotify) g_object_unref); - saved_options = G_OBJECT (options); - } + saved_desc = gimp_stroke_desc_new (context->gimp, context); - g_object_set_data (saved_options, "gimp-paint-info", - g_object_get_data (G_OBJECT (dialog), - "gimp-paint-info")); + gimp_config_sync (GIMP_CONFIG (desc), GIMP_CONFIG (saved_desc), 0); - if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (button))) - { - g_object_set_data (saved_options, "libart-stroking", - GINT_TO_POINTER (TRUE)); - } - else - { - g_object_set_data (saved_options, "libart-stroking", - GINT_TO_POINTER (FALSE)); - options = g_object_get_data (G_OBJECT (dialog), "gimp-paint-info"); - } + g_object_set_data_full (G_OBJECT (context), "saved-stroke-desc", + saved_desc, + (GDestroyNotify) g_object_unref); - gimp_item_stroke (item, drawable, context, options, FALSE); + gimp_item_stroke (item, drawable, context, desc, FALSE); gimp_image_flush (image); } /* fallthrough */ @@ -342,7 +306,7 @@ static void stroke_dialog_paint_info_selected (GimpContainerView *view, GimpViewable *viewable, gpointer insert_data, - GtkWidget *dialog) + GimpStrokeDesc *desc) { - g_object_set_data (G_OBJECT (dialog), "gimp-paint-info", viewable); + g_object_set (desc, "paint-info", viewable, NULL); } diff --git a/app/pdb/edit_cmds.c b/app/pdb/edit_cmds.c index a41384ae6b..b5992b627c 100644 --- a/app/pdb/edit_cmds.c +++ b/app/pdb/edit_cmds.c @@ -29,14 +29,13 @@ #include "core/gimp-edit.h" #include "core/gimp.h" #include "core/gimpchannel.h" -#include "core/gimpcontext.h" #include "core/gimpdrawable-blend.h" #include "core/gimpdrawable-bucket-fill.h" #include "core/gimpdrawable.h" #include "core/gimpimage.h" #include "core/gimplayer.h" #include "core/gimpprogress.h" -#include "core/gimptoolinfo.h" +#include "core/gimpstrokedesc.h" #include "gimp-intl.h" static ProcRecord edit_cut_proc; @@ -729,17 +728,15 @@ edit_stroke_invoker (Gimp *gimp, if (success) { - GimpImage *gimage; - GimpToolInfo *tool_info; + GimpImage *gimage = gimp_item_get_image (GIMP_ITEM (drawable)); + GimpStrokeDesc *desc = gimp_stroke_desc_new (gimp, context); - gimage = gimp_item_get_image (GIMP_ITEM (drawable)); - - tool_info = gimp_context_get_tool (context); + g_object_set (desc, "method", GIMP_STROKE_METHOD_PAINT_CORE, NULL); success = gimp_item_stroke (GIMP_ITEM (gimp_image_get_mask (gimage)), - drawable, context, - GIMP_OBJECT (tool_info->paint_info), - TRUE /* use defaults, not tool option values */); + drawable, context, desc, TRUE); + + g_object_unref (desc); } return procedural_db_return_args (&edit_stroke_proc, success); diff --git a/app/pdb/paths_cmds.c b/app/pdb/paths_cmds.c index cecd55e8f5..5e4c6a73f9 100644 --- a/app/pdb/paths_cmds.c +++ b/app/pdb/paths_cmds.c @@ -29,10 +29,9 @@ #include "core/gimp.h" #include "core/gimpchannel-select.h" -#include "core/gimpcontext.h" #include "core/gimpimage.h" #include "core/gimplist.h" -#include "core/gimptoolinfo.h" +#include "core/gimpstrokedesc.h" #include "gimp-intl.h" #include "vectors/gimpanchor.h" #include "vectors/gimpbezierstroke.h" @@ -601,8 +600,6 @@ path_stroke_current_invoker (Gimp *gimp, { gboolean success = TRUE; GimpImage *gimage; - GimpVectors *vectors; - GimpDrawable *drawable; gimage = gimp_image_get_by_ID (gimp, args[0].value.pdb_int); if (! GIMP_IS_IMAGE (gimage)) @@ -610,16 +607,19 @@ path_stroke_current_invoker (Gimp *gimp, if (success) { - vectors = gimp_image_get_active_vectors (gimage); - drawable = gimp_image_active_drawable (gimage); + GimpVectors *vectors = gimp_image_get_active_vectors (gimage); + GimpDrawable *drawable = gimp_image_active_drawable (gimage); if (vectors && drawable) { - GimpToolInfo *tool_info = gimp_context_get_tool (context); + GimpStrokeDesc *desc = gimp_stroke_desc_new (gimp, context); - success = gimp_item_stroke (GIMP_ITEM (vectors), drawable, context, - GIMP_OBJECT (tool_info->paint_info), - TRUE /* use defaults, not tool option values */); + g_object_set (desc, "method", GIMP_STROKE_METHOD_PAINT_CORE, NULL); + + success = gimp_item_stroke (GIMP_ITEM (vectors), + drawable, context, desc, TRUE); + + g_object_unref (desc); } else success = FALSE; diff --git a/app/vectors/gimpvectors.c b/app/vectors/gimpvectors.c index 7930bb6d0d..2bc033a426 100644 --- a/app/vectors/gimpvectors.c +++ b/app/vectors/gimpvectors.c @@ -36,7 +36,7 @@ #include "core/gimpimage-undo-push.h" #include "core/gimpmarshal.h" #include "core/gimppaintinfo.h" -#include "core/gimpstrokeoptions.h" +#include "core/gimpstrokedesc.h" #include "paint/gimppaintcore-stroke.h" #include "paint/gimppaintoptions.h" @@ -113,7 +113,7 @@ static void gimp_vectors_transform (GimpItem *item, static gboolean gimp_vectors_stroke (GimpItem *item, GimpDrawable *drawable, GimpContext *context, - GimpObject *stroke_desc); + GimpStrokeDesc *stroke_desc); static void gimp_vectors_real_thaw (GimpVectors *vectors); static void gimp_vectors_real_stroke_add (GimpVectors *vectors, @@ -555,10 +555,10 @@ gimp_vectors_transform (GimpItem *item, } static gboolean -gimp_vectors_stroke (GimpItem *item, - GimpDrawable *drawable, - GimpContext *context, - GimpObject *stroke_desc) +gimp_vectors_stroke (GimpItem *item, + GimpDrawable *drawable, + GimpContext *context, + GimpStrokeDesc *stroke_desc) { GimpVectors *vectors = GIMP_VECTORS (item); gboolean retval = FALSE; @@ -569,25 +569,31 @@ gimp_vectors_stroke (GimpItem *item, return FALSE; } - if (GIMP_IS_STROKE_OPTIONS (stroke_desc)) + switch (stroke_desc->method) { + case GIMP_STROKE_METHOD_LIBART: gimp_drawable_stroke_vectors (drawable, - GIMP_STROKE_OPTIONS (stroke_desc), + stroke_desc->stroke_options, vectors); retval = TRUE; - } - else if (GIMP_IS_PAINT_OPTIONS (stroke_desc)) - { - GimpPaintOptions *paint_options = GIMP_PAINT_OPTIONS (stroke_desc); - GimpPaintCore *core; + break; - core = g_object_new (paint_options->paint_info->paint_type, NULL); + case GIMP_STROKE_METHOD_PAINT_CORE: + { + GimpPaintCore *core; - retval = gimp_paint_core_stroke_vectors (core, drawable, - paint_options, - vectors); + core = g_object_new (stroke_desc->paint_info->paint_type, NULL); - g_object_unref (core); + retval = gimp_paint_core_stroke_vectors (core, drawable, + stroke_desc->paint_options, + vectors); + + g_object_unref (core); + } + break; + + default: + g_return_val_if_reached (FALSE); } return retval; diff --git a/tools/pdbgen/pdb/edit.pdb b/tools/pdbgen/pdb/edit.pdb index 5211f540b7..64b59544f9 100644 --- a/tools/pdbgen/pdb/edit.pdb +++ b/tools/pdbgen/pdb/edit.pdb @@ -354,20 +354,18 @@ HELP &inargs('stroke to'); %invoke = ( - headers => [ qw("core/gimpcontext.h" "core/gimptoolinfo.h") ], + headers => [ qw("core/gimpstrokedesc.h") ], code => <<'CODE' { - GimpImage *gimage; - GimpToolInfo *tool_info; + GimpImage *gimage = gimp_item_get_image (GIMP_ITEM (drawable)); + GimpStrokeDesc *desc = gimp_stroke_desc_new (gimp, context); - gimage = gimp_item_get_image (GIMP_ITEM (drawable)); - - tool_info = gimp_context_get_tool (context); + g_object_set (desc, "method", GIMP_STROKE_METHOD_PAINT_CORE, NULL); success = gimp_item_stroke (GIMP_ITEM (gimp_image_get_mask (gimage)), - drawable, context, - GIMP_OBJECT (tool_info->paint_info), - TRUE /* use defaults, not tool option values */); + drawable, context, desc, TRUE); + + g_object_unref (desc); } CODE ); diff --git a/tools/pdbgen/pdb/paths.pdb b/tools/pdbgen/pdb/paths.pdb index 8fef5bd814..12ac41bf60 100644 --- a/tools/pdbgen/pdb/paths.pdb +++ b/tools/pdbgen/pdb/paths.pdb @@ -302,19 +302,22 @@ HELP stroke.'; %invoke = ( - vars => [ 'GimpVectors *vectors', 'GimpDrawable *drawable' ], + headers => [ qw("core/gimpstrokedesc.h") ], code => <<'CODE' { - vectors = gimp_image_get_active_vectors (gimage); - drawable = gimp_image_active_drawable (gimage); + GimpVectors *vectors = gimp_image_get_active_vectors (gimage); + GimpDrawable *drawable = gimp_image_active_drawable (gimage); if (vectors && drawable) { - GimpToolInfo *tool_info = gimp_context_get_tool (context); + GimpStrokeDesc *desc = gimp_stroke_desc_new (gimp, context); - success = gimp_item_stroke (GIMP_ITEM (vectors), drawable, context, - GIMP_OBJECT (tool_info->paint_info), - TRUE /* use defaults, not tool option values */); + g_object_set (desc, "method", GIMP_STROKE_METHOD_PAINT_CORE, NULL); + + success = gimp_item_stroke (GIMP_ITEM (vectors), + drawable, context, desc, TRUE); + + g_object_unref (desc); } else success = FALSE; @@ -703,8 +706,8 @@ HELP ); } -@headers = qw( "core/gimp.h" "core/gimpcontext.h" "core/gimplist.h" - "core/gimptoolinfo.h" "core/gimpchannel-select.h" +@headers = qw( "core/gimp.h" "core/gimplist.h" + "core/gimpchannel-select.h" "vectors/gimpanchor.h" "vectors/gimpbezierstroke.h" "vectors/gimpvectors.h" "vectors/gimpvectors-compat.h" "gimp-intl.h");