From e8df68fb650c0335ad02c7e7b73ae44ff764f7c0 Mon Sep 17 00:00:00 2001 From: Alx Sa Date: Fri, 12 Jul 2024 06:16:25 +0000 Subject: [PATCH] libgimp, app, pdb: Rename GimpVectors to GimpPath This commit renames the GimpVectors object to GimpPath in both app/core and in libgimp. It also renames the files to gimppath.[ch] and updates the relevant build and translation files. There are still outstanding gimp_vectors_* () functions on the app side that need to be renamed in a subsequent commit. --- app/actions/layers-commands.c | 16 +- app/actions/vectors-commands.c | 28 +- app/core/core-enums.h | 4 +- app/core/gimpchannel-combine.c | 6 +- app/core/gimpchannel-select.c | 6 +- app/core/gimpchannel-select.h | 2 +- app/core/gimpdrawable-fill.c | 6 +- app/core/gimpdrawable-fill.h | 2 +- app/core/gimpdrawable-stroke.c | 6 +- app/core/gimpdrawable-stroke.h | 2 +- app/core/gimpimage-duplicate.c | 14 +- app/core/gimpimage-item-list.c | 4 +- app/core/gimpimage-merge.c | 18 +- app/core/gimpimage-merge.h | 2 +- app/core/gimpimage-pick-item.c | 14 +- app/core/gimpimage-pick-item.h | 2 +- app/core/gimpimage-rotate.c | 6 +- app/core/gimpimage-snap.c | 6 +- app/core/gimpimage-transform.c | 6 +- app/core/gimpimage-undo-push.c | 22 +- app/core/gimpimage-undo-push.h | 8 +- app/core/gimpimage.c | 62 ++-- app/core/gimpimage.h | 10 +- app/core/gimpitemlist.c | 10 +- app/core/gimpparamspecs.c | 2 +- app/dialogs/vectors-options-dialog.c | 8 +- app/dialogs/vectors-options-dialog.h | 4 +- app/display/gimpcanvasitem-utils.c | 14 +- app/display/gimpcanvasitem-utils.h | 6 +- app/display/gimpdisplayshell-dnd.c | 6 +- app/display/gimpdisplayshell-handlers.c | 24 +- app/display/gimptoolpath.c | 28 +- app/display/gimptoolpath.h | 2 +- app/gimpcore.def | 126 +++---- app/paint/gimppaintcore-stroke.c | 10 +- app/paint/gimppaintcore-stroke.h | 2 +- app/pdb/gimppdb-utils.c | 6 +- app/pdb/gimppdb-utils.h | 2 +- app/pdb/gimpprocedure.c | 2 +- app/pdb/image-cmds.c | 84 ++--- app/pdb/item-cmds.c | 4 +- app/pdb/path-cmds.c | 322 +++++++++--------- app/plug-in/gimpgpparams.c | 2 +- app/tests/test-xcf.c | 6 +- app/text/gimptext-vectors.c | 10 +- app/text/gimptext-vectors.h | 4 +- app/tools/gimpalignoptions.c | 4 +- app/tools/gimpaligntool.c | 8 +- app/tools/gimpaligntool.h | 2 +- app/tools/gimpmovetool.c | 2 +- app/tools/gimptexttool.c | 6 +- app/tools/gimptools-utils.c | 4 +- app/tools/gimptransformgridtool.c | 6 +- app/tools/gimptransformtool.c | 4 +- app/tools/gimpvectortool.c | 14 +- app/tools/gimpvectortool.h | 4 +- app/vectors/{gimpvectors.c => gimppath.c} | 274 +++++++-------- app/vectors/{gimpvectors.h => gimppath.h} | 108 +++--- app/vectors/gimpvectors-compat.c | 16 +- app/vectors/gimpvectors-compat.h | 4 +- app/vectors/gimpvectors-export.c | 20 +- app/vectors/gimpvectors-import.c | 20 +- app/vectors/gimpvectors-import.h | 4 +- app/vectors/gimpvectors-preview.c | 6 +- app/vectors/gimpvectors-warp.c | 24 +- app/vectors/gimpvectors-warp.h | 14 +- app/vectors/gimpvectorsmodundo.c | 20 +- app/vectors/gimpvectorsmodundo.h | 2 +- app/vectors/gimpvectorspropundo.c | 8 +- app/vectors/gimpvectorsundo.c | 8 +- app/vectors/gimpvectorsundo.h | 2 +- app/vectors/meson.build | 2 +- app/vectors/vectors-types.h | 2 +- app/widgets/gimpdnd.c | 8 +- app/widgets/gimpdnd.h | 4 +- app/widgets/gimpitemtreeview.c | 2 +- app/widgets/gimpvectorstreeview.c | 12 +- app/widgets/gimpviewrenderer-utils.c | 4 +- app/widgets/gimpviewrenderervectors.c | 4 +- app/xcf/xcf-load.c | 70 ++-- app/xcf/xcf-save.c | 44 +-- libgimp/gimp.c | 2 +- libgimp/gimp.def | 8 +- libgimp/gimp.h | 2 +- libgimp/gimpgpparams-body.c | 12 +- libgimp/gimpimage.c | 34 +- libgimp/gimpimage_pdb.c | 52 +-- libgimp/gimpimage_pdb.h | 16 +- libgimp/gimpparamspecs-body.c | 44 +-- libgimp/gimpparamspecs.h | 28 +- libgimp/{gimpvectors.c => gimppath.c} | 36 +- libgimp/{gimpvectors.h => gimppath.h} | 14 +- libgimp/gimppath_pdb.c | 246 ++++++------- libgimp/gimppath_pdb.h | 52 +-- libgimp/gimpplugin.c | 2 +- libgimp/gimpprocedure-params.c | 12 +- libgimp/gimpprocedure-params.h | 6 +- libgimp/gimptypes.h | 2 +- libgimp/meson.build | 4 +- libgimpconfig/gimpconfig-params.c | 2 +- pdb/app.pl | 16 +- pdb/groups/image.pdb | 20 +- pdb/groups/item.pdb | 4 +- pdb/groups/path.pdb | 64 ++-- pdb/pdb.pl | 28 +- plug-ins/common/file-svg.c | 4 +- plug-ins/file-psd/psd-image-res-load.c | 26 +- .../script-fu/libscriptfu/scheme-wrapper.c | 8 +- .../script-fu/libscriptfu/script-fu-script.c | 4 +- .../selection-to-path/selection-to-path.c | 2 +- po/POTFILES.in | 2 +- 111 files changed, 1212 insertions(+), 1212 deletions(-) rename app/vectors/{gimpvectors.c => gimppath.c} (82%) rename app/vectors/{gimpvectors.h => gimppath.h} (57%) rename libgimp/{gimpvectors.c => gimppath.c} (55%) rename libgimp/{gimpvectors.h => gimppath.h} (78%) diff --git a/app/actions/layers-commands.c b/app/actions/layers-commands.c index 18f568257a..55aeb88ae9 100644 --- a/app/actions/layers-commands.c +++ b/app/actions/layers-commands.c @@ -61,8 +61,8 @@ #include "text/gimptext-vectors.h" #include "text/gimptextlayer.h" +#include "vectors/gimppath.h" #include "vectors/gimpstroke.h" -#include "vectors/gimpvectors.h" #include "vectors/gimpvectors-warp.h" #include "widgets/gimpaction.h" @@ -1052,8 +1052,8 @@ layers_text_to_vectors_cmd_callback (GimpAction *action, if (GIMP_IS_TEXT_LAYER (layer)) { - GimpVectors *path; - gint x, y; + GimpPath *path; + gint x, y; path = gimp_text_vectors_new (image, GIMP_TEXT_LAYER (layer)->text); @@ -1077,7 +1077,7 @@ layers_text_along_vectors_cmd_callback (GimpAction *action, GList *layers; GList *paths; GimpLayer *layer; - GimpVectors *vectors; + GimpPath *vectors; return_if_no_layers (image, layers, data); return_if_no_vectors_list (image, paths, data); @@ -1088,10 +1088,10 @@ layers_text_along_vectors_cmd_callback (GimpAction *action, vectors = paths->data; if (GIMP_IS_TEXT_LAYER (layer)) { - gdouble box_width; - gdouble box_height; - GimpVectors *new_vectors; - gdouble offset; + gdouble box_width; + gdouble box_height; + GimpPath *new_vectors; + gdouble offset; box_width = gimp_item_get_width (GIMP_ITEM (layer)); box_height = gimp_item_get_height (GIMP_ITEM (layer)); diff --git a/app/actions/vectors-commands.c b/app/actions/vectors-commands.c index 1ec5e1119b..befac2a345 100644 --- a/app/actions/vectors-commands.c +++ b/app/actions/vectors-commands.c @@ -44,7 +44,7 @@ #include "pdb/gimppdb.h" #include "pdb/gimpprocedure.h" -#include "vectors/gimpvectors.h" +#include "vectors/gimppath.h" #include "vectors/gimpvectors-export.h" #include "vectors/gimpvectors-import.h" @@ -73,7 +73,7 @@ static void vectors_new_callback (GtkWidget *dialog, GimpImage *image, - GimpVectors *vectors, + GimpPath *vectors, GimpContext *context, const gchar *vectors_name, gboolean vectors_visible, @@ -84,7 +84,7 @@ static void vectors_new_callback (GtkWidget *dialog, gpointer user_data); static void vectors_edit_attributes_callback (GtkWidget *dialog, GimpImage *image, - GimpVectors *vectors, + GimpPath *vectors, GimpContext *context, const gchar *vectors_name, gboolean vectors_visible, @@ -148,7 +148,7 @@ vectors_edit_attributes_cmd_callback (GimpAction *action, { GimpImage *image; GList *paths; - GimpVectors *vectors; + GimpPath *vectors; GtkWidget *widget; GtkWidget *dialog; return_if_no_vectors_list (image, paths, data); @@ -238,7 +238,7 @@ vectors_new_last_vals_cmd_callback (GimpAction *action, gpointer data) { GimpImage *image; - GimpVectors *vectors; + GimpPath *vectors; GimpDialogConfig *config; return_if_no_image (image, data); @@ -423,10 +423,10 @@ vectors_duplicate_cmd_callback (GimpAction *action, _("Duplicate Paths")); for (iter = paths; iter; iter = iter->next) { - GimpVectors *new_path; + GimpPath *new_path; - new_path = GIMP_VECTORS (gimp_item_duplicate (iter->data, - G_TYPE_FROM_INSTANCE (iter->data))); + new_path = GIMP_PATH (gimp_item_duplicate (iter->data, + G_TYPE_FROM_INSTANCE (iter->data))); /* use the actual parent here, not GIMP_IMAGE_ACTIVE_PARENT because * the latter would add a duplicated group inside itself instead of * above it @@ -820,7 +820,7 @@ vectors_color_tag_cmd_callback (GimpAction *action, static void vectors_new_callback (GtkWidget *dialog, GimpImage *image, - GimpVectors *vectors, + GimpPath *vectors, GimpContext *context, const gchar *vectors_name, gboolean vectors_visible, @@ -853,7 +853,7 @@ vectors_new_callback (GtkWidget *dialog, static void vectors_edit_attributes_callback (GtkWidget *dialog, GimpImage *image, - GimpVectors *vectors, + GimpPath *vectors, GimpContext *context, const gchar *vectors_name, gboolean vectors_visible, @@ -1006,7 +1006,7 @@ vectors_select_cmd_callback (GimpAction *action, for (iter = vectors; iter || run_once; iter = iter ? iter->next : NULL) { - GimpVectors *new_vec; + GimpPath *new_vec; GimpContainer *container; if (iter) @@ -1018,9 +1018,9 @@ vectors_select_cmd_callback (GimpAction *action, container = gimp_image_get_paths (image); run_once = FALSE; } - new_vec = (GimpVectors *) action_select_object (select_type, - container, - iter ? iter->data : NULL); + new_vec = (GimpPath *) action_select_object (select_type, + container, + iter ? iter->data : NULL); if (new_vec) new_vectors = g_list_prepend (new_vectors, new_vec); } diff --git a/app/core/core-enums.h b/app/core/core-enums.h index 09f6e34c90..bbc10db1e6 100644 --- a/app/core/core-enums.h +++ b/app/core/core-enums.h @@ -781,11 +781,11 @@ typedef enum /*< pdb-skip, skip >*/ { GIMP_ITEM_TYPE_LAYERS = 1 << 0, GIMP_ITEM_TYPE_CHANNELS = 1 << 1, - GIMP_ITEM_TYPE_VECTORS = 1 << 2, + GIMP_ITEM_TYPE_PATHS = 1 << 2, GIMP_ITEM_TYPE_ALL = (GIMP_ITEM_TYPE_LAYERS | GIMP_ITEM_TYPE_CHANNELS | - GIMP_ITEM_TYPE_VECTORS) + GIMP_ITEM_TYPE_PATHS) } GimpItemTypeMask; diff --git a/app/core/gimpchannel-combine.c b/app/core/gimpchannel-combine.c index b31bf4468d..9be0a3866f 100644 --- a/app/core/gimpchannel-combine.c +++ b/app/core/gimpchannel-combine.c @@ -37,7 +37,7 @@ #include "gimpimage-new.h" #include "gimplayer.h" -#include "vectors/gimpvectors.h" +#include "vectors/gimppath.h" typedef struct @@ -492,7 +492,7 @@ gimp_channel_combine_buffer (GimpChannel *mask, * their opacity, mode, visibility, etc. properties within the image * (similar as if a "merge visible" had been applied to the image then * the resulting layer used alone). - * If @items contain channels or vectors, they will be added as a set + * If @items contain channels or paths, they will be added as a set * (i.e. as a single item which is an union of other items). E.g. an * combine in GIMP_CHANNEL_OP_INTERSECT mode does not intersect all * @items with each other and @channel. It first adds-alike all @items @@ -518,7 +518,7 @@ gimp_channel_combine_items (GimpChannel *mask, { g_return_if_fail (GIMP_IS_LAYER (iter->data) || GIMP_IS_CHANNEL (iter->data) || - GIMP_IS_VECTORS (iter->data)); + GIMP_IS_PATH (iter->data)); if (items_image == NULL) items_image = gimp_item_get_image (iter->data); diff --git a/app/core/gimpchannel-select.c b/app/core/gimpchannel-select.c index 79fd7792ea..93b228c83f 100644 --- a/app/core/gimpchannel-select.c +++ b/app/core/gimpchannel-select.c @@ -43,8 +43,8 @@ #include "gimppickable-contiguous-region.h" #include "gimpscanconvert.h" +#include "vectors/gimppath.h" #include "vectors/gimpstroke.h" -#include "vectors/gimpvectors.h" #include "gimp-intl.h" @@ -281,7 +281,7 @@ gimp_channel_select_polygon (GimpChannel *channel, void gimp_channel_select_vectors (GimpChannel *channel, const gchar *undo_desc, - GimpVectors *vectors, + GimpPath *vectors, GimpChannelOps op, gboolean antialias, gboolean feather, @@ -294,7 +294,7 @@ gimp_channel_select_vectors (GimpChannel *channel, g_return_if_fail (GIMP_IS_CHANNEL (channel)); g_return_if_fail (gimp_item_is_attached (GIMP_ITEM (channel))); g_return_if_fail (undo_desc != NULL); - g_return_if_fail (GIMP_IS_VECTORS (vectors)); + g_return_if_fail (GIMP_IS_PATH (vectors)); bezier = gimp_vectors_get_bezier (vectors); diff --git a/app/core/gimpchannel-select.h b/app/core/gimpchannel-select.h index 967fb3763e..b4e4bf645a 100644 --- a/app/core/gimpchannel-select.h +++ b/app/core/gimpchannel-select.h @@ -81,7 +81,7 @@ void gimp_channel_select_polygon (GimpChannel *channel, gboolean push_undo); void gimp_channel_select_vectors (GimpChannel *channel, const gchar *undo_desc, - GimpVectors *vectors, + GimpPath *vectors, GimpChannelOps op, gboolean antialias, gboolean feather, diff --git a/app/core/gimpdrawable-fill.c b/app/core/gimpdrawable-fill.c index 01997c4e5b..087e094337 100644 --- a/app/core/gimpdrawable-fill.c +++ b/app/core/gimpdrawable-fill.c @@ -43,7 +43,7 @@ #include "gimppickable.h" #include "gimpscanconvert.h" -#include "vectors/gimpvectors.h" +#include "vectors/gimppath.h" #include "gimp-intl.h" @@ -179,7 +179,7 @@ gimp_drawable_fill_boundary (GimpDrawable *drawable, gboolean gimp_drawable_fill_vectors (GimpDrawable *drawable, GimpFillOptions *options, - GimpVectors *vectors, + GimpPath *vectors, gboolean push_undo, GError **error) { @@ -188,7 +188,7 @@ gimp_drawable_fill_vectors (GimpDrawable *drawable, g_return_val_if_fail (GIMP_IS_DRAWABLE (drawable), FALSE); g_return_val_if_fail (gimp_item_is_attached (GIMP_ITEM (drawable)), FALSE); g_return_val_if_fail (GIMP_IS_FILL_OPTIONS (options), FALSE); - g_return_val_if_fail (GIMP_IS_VECTORS (vectors), FALSE); + g_return_val_if_fail (GIMP_IS_PATH (vectors), FALSE); g_return_val_if_fail (gimp_fill_options_get_style (options) != GIMP_FILL_STYLE_PATTERN || gimp_context_get_pattern (GIMP_CONTEXT (options)) != NULL, diff --git a/app/core/gimpdrawable-fill.h b/app/core/gimpdrawable-fill.h index 8b955b0f76..fd75f477e9 100644 --- a/app/core/gimpdrawable-fill.h +++ b/app/core/gimpdrawable-fill.h @@ -47,7 +47,7 @@ void gimp_drawable_fill_boundary (GimpDrawable *drawable, gboolean gimp_drawable_fill_vectors (GimpDrawable *drawable, GimpFillOptions *options, - GimpVectors *vectors, + GimpPath *vectors, gboolean push_undo, GError **error); diff --git a/app/core/gimpdrawable-stroke.c b/app/core/gimpdrawable-stroke.c index 5b35d51e44..9da63405f9 100644 --- a/app/core/gimpdrawable-stroke.c +++ b/app/core/gimpdrawable-stroke.c @@ -36,7 +36,7 @@ #include "gimpscanconvert.h" #include "gimpstrokeoptions.h" -#include "vectors/gimpvectors.h" +#include "vectors/gimppath.h" #include "gimp-intl.h" @@ -76,7 +76,7 @@ gimp_drawable_stroke_boundary (GimpDrawable *drawable, gboolean gimp_drawable_stroke_vectors (GimpDrawable *drawable, GimpStrokeOptions *options, - GimpVectors *vectors, + GimpPath *vectors, gboolean push_undo, GError **error) { @@ -85,7 +85,7 @@ gimp_drawable_stroke_vectors (GimpDrawable *drawable, g_return_val_if_fail (GIMP_IS_DRAWABLE (drawable), FALSE); g_return_val_if_fail (gimp_item_is_attached (GIMP_ITEM (drawable)), FALSE); g_return_val_if_fail (GIMP_IS_STROKE_OPTIONS (options), FALSE); - g_return_val_if_fail (GIMP_IS_VECTORS (vectors), FALSE); + g_return_val_if_fail (GIMP_IS_PATH (vectors), FALSE); g_return_val_if_fail (gimp_fill_options_get_style (GIMP_FILL_OPTIONS (options)) != GIMP_FILL_STYLE_PATTERN || gimp_context_get_pattern (GIMP_CONTEXT (options)) != NULL, diff --git a/app/core/gimpdrawable-stroke.h b/app/core/gimpdrawable-stroke.h index 5f16e5b935..0c73d58ce2 100644 --- a/app/core/gimpdrawable-stroke.h +++ b/app/core/gimpdrawable-stroke.h @@ -32,7 +32,7 @@ void gimp_drawable_stroke_boundary (GimpDrawable *drawable, gboolean gimp_drawable_stroke_vectors (GimpDrawable *drawable, GimpStrokeOptions *options, - GimpVectors *vectors, + GimpPath *vectors, gboolean push_undo, GError **error); diff --git a/app/core/gimpimage-duplicate.c b/app/core/gimpimage-duplicate.c index faae6f15f8..8f49d98c0d 100644 --- a/app/core/gimpimage-duplicate.c +++ b/app/core/gimpimage-duplicate.c @@ -26,7 +26,7 @@ #include "gegl/gimp-gegl-loops.h" -#include "vectors/gimpvectors.h" +#include "vectors/gimppath.h" #include "gimp.h" #include "gimpchannel.h" @@ -127,7 +127,7 @@ gimp_image_duplicate (GimpImage *image) /* Copy the channels */ active_channels = gimp_image_duplicate_channels (image, new_image); - /* Copy any vectors */ + /* Copy any path */ active_path = gimp_image_duplicate_paths (image, new_image); /* Copy floating layer */ @@ -136,7 +136,7 @@ gimp_image_duplicate (GimpImage *image) /* Copy the selection mask */ gimp_image_duplicate_mask (image, new_image); - /* Set active layer, active channel, active vectors */ + /* Set active layer, active channel, active path */ if (active_layers) gimp_image_set_selected_layers (new_image, active_layers); @@ -351,11 +351,11 @@ gimp_image_duplicate_paths (GimpImage *image, list; list = g_list_next (list)) { - GimpVectors *path = list->data; - GimpVectors *new_path; + GimpPath *path = list->data; + GimpPath *new_path; - new_path = GIMP_VECTORS (gimp_image_duplicate_item (GIMP_ITEM (path), - new_image)); + new_path = GIMP_PATH (gimp_image_duplicate_item (GIMP_ITEM (path), + new_image)); if (g_list_find (selected_path, path)) new_selected_path = g_list_prepend (new_selected_path, new_path); diff --git a/app/core/gimpimage-item-list.c b/app/core/gimpimage-item-list.c index c64437b0a3..bbd2d8736b 100644 --- a/app/core/gimpimage-item-list.c +++ b/app/core/gimpimage-item-list.c @@ -34,7 +34,7 @@ #include "gimpobjectqueue.h" #include "gimpprogress.h" -#include "vectors/gimpvectors.h" +#include "vectors/gimppath.h" #include "gimp-intl.h" @@ -342,7 +342,7 @@ gimp_image_item_list_get_list (GimpImage *image, g_list_free (all_items); } - if (type & GIMP_ITEM_TYPE_VECTORS) + if (type & GIMP_ITEM_TYPE_PATHS) { all_items = gimp_image_get_path_list (image); diff --git a/app/core/gimpimage-merge.c b/app/core/gimpimage-merge.c index 032b59310b..95ef531003 100644 --- a/app/core/gimpimage-merge.c +++ b/app/core/gimpimage-merge.c @@ -32,7 +32,7 @@ #include "gegl/gimp-gegl-nodes.h" #include "gegl/gimp-gegl-utils.h" -#include "vectors/gimpvectors.h" +#include "vectors/gimppath.h" #include "gimp.h" #include "gimpcontext.h" @@ -468,13 +468,13 @@ gimp_image_merge_group_layer (GimpImage *image, /* merging paths */ -GimpVectors * +GimpPath * gimp_image_merge_visible_paths (GimpImage *image, GError **error) { GList *list; GList *merge_list = NULL; - GimpVectors *path; + GimpPath *path; g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL); g_return_val_if_fail (error == NULL || *error == NULL, NULL); @@ -493,22 +493,22 @@ gimp_image_merge_visible_paths (GimpImage *image, if (merge_list && merge_list->next) { - GimpVectors *target_path; - gchar *name; - gint pos; + GimpPath *target_path; + gchar *name; + gint pos; gimp_set_busy (image->gimp); gimp_image_undo_group_start (image, GIMP_UNDO_GROUP_IMAGE_VECTORS_MERGE, C_("undo-type", "Merge Visible Paths")); - path = GIMP_VECTORS (merge_list->data); + path = GIMP_PATH (merge_list->data); name = g_strdup (gimp_object_get_name (path)); pos = gimp_item_get_index (GIMP_ITEM (path)); - target_path = GIMP_VECTORS (gimp_item_duplicate (GIMP_ITEM (path), - GIMP_TYPE_VECTORS)); + target_path = GIMP_PATH (gimp_item_duplicate (GIMP_ITEM (path), + GIMP_TYPE_PATH)); gimp_image_remove_path (image, path, TRUE, NULL); for (list = g_list_next (merge_list); diff --git a/app/core/gimpimage-merge.h b/app/core/gimpimage-merge.h index 982f34e6c3..6b87a3dc5a 100644 --- a/app/core/gimpimage-merge.h +++ b/app/core/gimpimage-merge.h @@ -39,7 +39,7 @@ GimpLayer * gimp_image_flatten (GimpImage *image, GimpProgress *progress, GError **error); -GimpVectors * gimp_image_merge_visible_paths (GimpImage *image, +GimpPath * gimp_image_merge_visible_paths (GimpImage *image, GError **error); diff --git a/app/core/gimpimage-pick-item.c b/app/core/gimpimage-pick-item.c index 5ab451c2f7..2b94676268 100644 --- a/app/core/gimpimage-pick-item.c +++ b/app/core/gimpimage-pick-item.c @@ -34,8 +34,8 @@ #include "text/gimptextlayer.h" +#include "vectors/gimppath.h" #include "vectors/gimpstroke.h" -#include "vectors/gimpvectors.h" GimpLayer * @@ -185,17 +185,17 @@ gimp_image_pick_text_layer (GimpImage *image, return NULL; } -GimpVectors * +GimpPath * gimp_image_pick_path (GimpImage *image, gdouble x, gdouble y, gdouble epsilon_x, gdouble epsilon_y) { - GimpVectors *ret = NULL; - GList *all_path; - GList *list; - gdouble mindist = G_MAXDOUBLE; + GimpPath *ret = NULL; + GList *all_path; + GList *list; + gdouble mindist = G_MAXDOUBLE; g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL); @@ -203,7 +203,7 @@ gimp_image_pick_path (GimpImage *image, for (list = all_path; list; list = g_list_next (list)) { - GimpVectors *vectors = list->data; + GimpPath *vectors = list->data; if (gimp_item_is_visible (GIMP_ITEM (vectors))) { diff --git a/app/core/gimpimage-pick-item.h b/app/core/gimpimage-pick-item.h index 978eddf259..cbe608bb40 100644 --- a/app/core/gimpimage-pick-item.h +++ b/app/core/gimpimage-pick-item.h @@ -30,7 +30,7 @@ GimpTextLayer * gimp_image_pick_text_layer (GimpImage *image, gint x, gint y); -GimpVectors * gimp_image_pick_path (GimpImage *image, +GimpPath * gimp_image_pick_path (GimpImage *image, gdouble x, gdouble y, gdouble epsilon_x, diff --git a/app/core/gimpimage-rotate.c b/app/core/gimpimage-rotate.c index 19f6c5cdbd..614394bbfd 100644 --- a/app/core/gimpimage-rotate.c +++ b/app/core/gimpimage-rotate.c @@ -25,7 +25,7 @@ #include "config/gimpdialogconfig.h" -#include "vectors/gimpvectors.h" +#include "vectors/gimppath.h" #include "gimp.h" #include "gimpcontainer.h" @@ -132,7 +132,7 @@ gimp_image_rotate (GimpImage *image, gimp_image_undo_group_start (image, GIMP_UNDO_GROUP_IMAGE_ROTATE, NULL); - /* Rotate all layers, channels (including selection mask), and vectors */ + /* Rotate all layers, channels (including selection mask), and path */ while ((item = gimp_object_queue_pop (queue))) { gint off_x; @@ -150,7 +150,7 @@ gimp_image_rotate (GimpImage *image, { gimp_item_set_offset (item, 0, 0); - if (GIMP_IS_VECTORS (item)) + if (GIMP_IS_PATH (item)) { gimp_item_set_size (item, new_image_width, new_image_height); diff --git a/app/core/gimpimage-snap.c b/app/core/gimpimage-snap.c index 36fcdadcba..35499ea75f 100644 --- a/app/core/gimpimage-snap.c +++ b/app/core/gimpimage-snap.c @@ -33,8 +33,8 @@ #include "gimpimage-guides.h" #include "gimpimage-snap.h" +#include "vectors/gimppath.h" #include "vectors/gimpstroke.h" -#include "vectors/gimpvectors.h" #include "gimp-intl.h" @@ -728,7 +728,7 @@ gimp_image_snap_point (GimpImage *image, for (iter = selected_path; iter; iter = iter->next) { - GimpVectors *vectors = iter->data; + GimpPath *vectors = iter->data; while ((stroke = gimp_vectors_stroke_get_next (vectors, stroke))) { @@ -977,7 +977,7 @@ gimp_image_snap_rectangle (GimpImage *image, for (iter = selected_path; iter; iter = iter->next) { - GimpVectors *vectors = iter->data; + GimpPath *vectors = iter->data; while ((stroke = gimp_vectors_stroke_get_next (vectors, stroke))) { diff --git a/app/core/gimpimage-transform.c b/app/core/gimpimage-transform.c index 6d2102537c..6ef25e739f 100644 --- a/app/core/gimpimage-transform.c +++ b/app/core/gimpimage-transform.c @@ -27,7 +27,7 @@ #include "core-types.h" -#include "vectors/gimpvectors.h" +#include "vectors/gimppath.h" #include "gimp.h" #include "gimp-transform-resize.h" @@ -279,7 +279,7 @@ gimp_image_transform (GimpImage *image, gimp_image_undo_group_start (image, GIMP_UNDO_GROUP_IMAGE_TRANSFORM, NULL); - /* Transform all layers, channels (including selection mask), and vectors */ + /* Transform all layers, channels (including selection mask), and path */ while ((item = gimp_object_queue_pop (queue))) { GimpTransformResize clip = GIMP_TRANSFORM_RESIZE_ADJUST; @@ -293,7 +293,7 @@ gimp_image_transform (GimpImage *image, interpolation_type, clip, progress); - if (GIMP_IS_VECTORS (item)) + if (GIMP_IS_PATH (item)) gimp_item_set_size (item, new_bounds.width, new_bounds.height); } diff --git a/app/core/gimpimage-undo-push.c b/app/core/gimpimage-undo-push.c index 7166d22e37..ae02d9fa3a 100644 --- a/app/core/gimpimage-undo-push.c +++ b/app/core/gimpimage-undo-push.c @@ -56,7 +56,7 @@ #include "text/gimptextlayer.h" #include "text/gimptextundo.h" -#include "vectors/gimpvectors.h" +#include "vectors/gimppath.h" #include "vectors/gimpvectorsmodundo.h" #include "vectors/gimpvectorspropundo.h" #include "vectors/gimpvectorsundo.h" @@ -1011,17 +1011,17 @@ gimp_image_undo_push_channel_color (GimpImage *image, GimpUndo * gimp_image_undo_push_path_add (GimpImage *image, const gchar *undo_desc, - GimpVectors *path, + GimpPath *path, GList *prev_paths) { GList *iter; g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL); - g_return_val_if_fail (GIMP_IS_VECTORS (path), NULL); + g_return_val_if_fail (GIMP_IS_PATH (path), NULL); g_return_val_if_fail (! gimp_item_is_attached (GIMP_ITEM (path)), NULL); for (iter = prev_paths; iter; iter = iter->next) - g_return_val_if_fail (GIMP_IS_VECTORS (iter->data), NULL); + g_return_val_if_fail (GIMP_IS_PATH (iter->data), NULL); return gimp_image_undo_push (image, GIMP_TYPE_VECTORS_UNDO, GIMP_UNDO_VECTORS_ADD, undo_desc, @@ -1034,21 +1034,21 @@ gimp_image_undo_push_path_add (GimpImage *image, GimpUndo * gimp_image_undo_push_path_remove (GimpImage *image, const gchar *undo_desc, - GimpVectors *path, - GimpVectors *prev_parent, + GimpPath *path, + GimpPath *prev_parent, gint prev_position, GList *prev_paths) { GList *iter; g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL); - g_return_val_if_fail (GIMP_IS_VECTORS (path), NULL); + g_return_val_if_fail (GIMP_IS_PATH (path), NULL); g_return_val_if_fail (gimp_item_is_attached (GIMP_ITEM (path)), NULL); - g_return_val_if_fail (prev_parent == NULL || GIMP_IS_VECTORS (prev_parent), + g_return_val_if_fail (prev_parent == NULL || GIMP_IS_PATH (prev_parent), NULL); for (iter = prev_paths; iter; iter = iter->next) - g_return_val_if_fail (GIMP_IS_VECTORS (iter->data), NULL); + g_return_val_if_fail (GIMP_IS_PATH (iter->data), NULL); return gimp_image_undo_push (image, GIMP_TYPE_VECTORS_UNDO, GIMP_UNDO_VECTORS_REMOVE, undo_desc, @@ -1063,10 +1063,10 @@ gimp_image_undo_push_path_remove (GimpImage *image, GimpUndo * gimp_image_undo_push_path_mod (GimpImage *image, const gchar *undo_desc, - GimpVectors *path) + GimpPath *path) { g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL); - g_return_val_if_fail (GIMP_IS_VECTORS (path), NULL); + g_return_val_if_fail (GIMP_IS_PATH (path), NULL); g_return_val_if_fail (gimp_item_is_attached (GIMP_ITEM (path)), NULL); return gimp_image_undo_push (image, GIMP_TYPE_VECTORS_MOD_UNDO, diff --git a/app/core/gimpimage-undo-push.h b/app/core/gimpimage-undo-push.h index bfbdebaefd..c08b5fa7e4 100644 --- a/app/core/gimpimage-undo-push.h +++ b/app/core/gimpimage-undo-push.h @@ -250,17 +250,17 @@ GimpUndo * gimp_image_undo_push_channel_color (GimpImage *image, GimpUndo * gimp_image_undo_push_path_add (GimpImage *image, const gchar *undo_desc, - GimpVectors *path, + GimpPath *path, GList *prev_paths); GimpUndo * gimp_image_undo_push_path_remove (GimpImage *image, const gchar *undo_desc, - GimpVectors *path, - GimpVectors *prev_parent, + GimpPath *path, + GimpPath *prev_parent, gint prev_position, GList *prev_paths); GimpUndo * gimp_image_undo_push_path_mod (GimpImage *image, const gchar *undo_desc, - GimpVectors *path); + GimpPath *path); /* floating selection undos */ diff --git a/app/core/gimpimage.c b/app/core/gimpimage.c index b22edae0c6..be371daf0a 100644 --- a/app/core/gimpimage.c +++ b/app/core/gimpimage.c @@ -85,7 +85,7 @@ #include "text/gimptextlayer.h" -#include "vectors/gimpvectors.h" +#include "vectors/gimppath.h" #include "gimp-log.h" #include "gimp-intl.h" @@ -798,7 +798,7 @@ gimp_image_init (GimpImage *image) GIMP_TYPE_CHANNEL); private->vectors = gimp_item_tree_new (image, GIMP_TYPE_ITEM_STACK, - GIMP_TYPE_VECTORS); + GIMP_TYPE_PATH); private->layer_stack = NULL; private->stored_layer_sets = NULL; @@ -2967,7 +2967,7 @@ gimp_image_get_xcf_version (GimpImage *image, items = gimp_image_get_path_list (image); for (list = items; list; list = g_list_next (list)) { - GimpVectors *vectors = GIMP_VECTORS (list->data); + GimpPath *vectors = GIMP_PATH (list->data); if (gimp_item_get_color_tag (GIMP_ITEM (vectors)) != GIMP_COLOR_TAG_NONE) { @@ -4512,7 +4512,7 @@ gimp_image_get_projection (GimpImage *image) } -/* layers / channels / vectors */ +/* layers / channels / path */ GimpItemTree * gimp_image_get_layer_tree (GimpImage *image) @@ -4671,7 +4671,7 @@ gimp_image_get_path_list (GimpImage *image) } -/* active drawable, layer, channel, vectors */ +/* active drawable, layer, channel, path */ void gimp_image_unset_selected_channels (GimpImage *image) @@ -4944,7 +4944,7 @@ gimp_image_set_selected_paths (GimpImage *image, for (iter = paths; iter; iter = iter->next) { - g_return_if_fail (GIMP_IS_VECTORS (iter->data)); + g_return_if_fail (GIMP_IS_PATH (iter->data)); g_return_if_fail (gimp_item_is_attached (GIMP_ITEM (iter->data)) && gimp_item_get_image (GIMP_ITEM (iter->data)) == image); } @@ -4983,7 +4983,7 @@ gimp_image_get_channel_by_tattoo (GimpImage *image, return GIMP_CHANNEL (gimp_item_stack_get_item_by_tattoo (stack, tattoo)); } -GimpVectors * +GimpPath * gimp_image_get_path_by_tattoo (GimpImage *image, GimpTattoo tattoo) { @@ -4993,11 +4993,11 @@ gimp_image_get_path_by_tattoo (GimpImage *image, stack = GIMP_ITEM_STACK (gimp_image_get_paths (image)); - return GIMP_VECTORS (gimp_item_stack_get_item_by_tattoo (stack, tattoo)); + return GIMP_PATH (gimp_item_stack_get_item_by_tattoo (stack, tattoo)); } -/* layer, channel, vectors by name */ +/* layer, channel, path by name */ GimpLayer * gimp_image_get_layer_by_name (GimpImage *image, @@ -5027,7 +5027,7 @@ gimp_image_get_channel_by_name (GimpImage *image, return GIMP_CHANNEL (gimp_item_tree_get_item_by_name (tree, name)); } -GimpVectors * +GimpPath * gimp_image_get_path_by_name (GimpImage *image, const gchar *name) { @@ -5038,7 +5038,7 @@ gimp_image_get_path_by_name (GimpImage *image, tree = gimp_image_get_path_tree (image); - return GIMP_VECTORS (gimp_item_tree_get_item_by_name (tree, name)); + return GIMP_PATH (gimp_item_tree_get_item_by_name (tree, name)); } @@ -5447,7 +5447,7 @@ gimp_image_store_item_set (GimpImage *image, stored_sets = &private->stored_layer_sets; else if (item_type == GIMP_TYPE_CHANNEL) stored_sets = &private->stored_channel_sets; - else if (item_type == GIMP_TYPE_VECTORS) + else if (item_type == GIMP_TYPE_PATH) stored_sets = &private->stored_vectors_sets; else g_return_if_reached (); @@ -5508,7 +5508,7 @@ gimp_image_unlink_item_set (GimpImage *image, stored_sets = &private->stored_layer_sets; else if (item_type == GIMP_TYPE_CHANNEL) stored_sets = &private->stored_channel_sets; - else if (item_type == GIMP_TYPE_VECTORS) + else if (item_type == GIMP_TYPE_PATH) stored_sets = &private->stored_vectors_sets; else g_return_val_if_reached (FALSE); @@ -5547,7 +5547,7 @@ gimp_image_get_stored_item_sets (GimpImage *image, return private->stored_layer_sets; else if (item_type == GIMP_TYPE_CHANNEL) return private->stored_channel_sets; - else if (item_type == GIMP_TYPE_VECTORS) + else if (item_type == GIMP_TYPE_PATH) return private->stored_vectors_sets; g_return_val_if_reached (FALSE); @@ -5581,7 +5581,7 @@ gimp_image_select_item_set (GimpImage *image, gimp_image_set_selected_layers (image, items); else if (item_type == GIMP_TYPE_CHANNEL) gimp_image_set_selected_channels (image, items); - else if (item_type == GIMP_TYPE_VECTORS) + else if (item_type == GIMP_TYPE_PATH) gimp_image_set_selected_paths (image, items); else g_return_if_reached (); @@ -5621,7 +5621,7 @@ gimp_image_add_item_set (GimpImage *image, selected = gimp_image_get_selected_layers (image); else if (item_type == GIMP_TYPE_CHANNEL) selected = gimp_image_get_selected_channels (image); - else if (item_type == GIMP_TYPE_VECTORS) + else if (item_type == GIMP_TYPE_PATH) selected = gimp_image_get_selected_paths (image); else g_return_if_reached (); @@ -5637,7 +5637,7 @@ gimp_image_add_item_set (GimpImage *image, gimp_image_set_selected_layers (image, selected); else if (item_type == GIMP_TYPE_CHANNEL) gimp_image_set_selected_channels (image, selected); - else if (item_type == GIMP_TYPE_VECTORS) + else if (item_type == GIMP_TYPE_PATH) gimp_image_set_selected_paths (image, items); g_list_free (selected); @@ -5679,7 +5679,7 @@ gimp_image_remove_item_set (GimpImage *image, selected = gimp_image_get_selected_layers (image); else if (item_type == GIMP_TYPE_CHANNEL) selected = gimp_image_get_selected_channels (image); - else if (item_type == GIMP_TYPE_VECTORS) + else if (item_type == GIMP_TYPE_PATH) selected = gimp_image_get_selected_paths (image); else g_return_if_reached (); @@ -5697,7 +5697,7 @@ gimp_image_remove_item_set (GimpImage *image, gimp_image_set_selected_layers (image, selected); else if (item_type == GIMP_TYPE_CHANNEL) gimp_image_set_selected_channels (image, selected); - else if (item_type == GIMP_TYPE_VECTORS) + else if (item_type == GIMP_TYPE_PATH) gimp_image_set_selected_paths (image, items); g_list_free (selected); @@ -5741,7 +5741,7 @@ gimp_image_intersect_item_set (GimpImage *image, selected = gimp_image_get_selected_layers (image); else if (item_type == GIMP_TYPE_CHANNEL) selected = gimp_image_get_selected_channels (image); - else if (item_type == GIMP_TYPE_VECTORS) + else if (item_type == GIMP_TYPE_PATH) selected = gimp_image_get_selected_paths (image); else g_return_if_reached (); @@ -5763,7 +5763,7 @@ gimp_image_intersect_item_set (GimpImage *image, gimp_image_set_selected_layers (image, selected); else if (item_type == GIMP_TYPE_CHANNEL) gimp_image_set_selected_channels (image, selected); - else if (item_type == GIMP_TYPE_VECTORS) + else if (item_type == GIMP_TYPE_PATH) gimp_image_set_selected_paths (image, items); g_list_free (selected); @@ -5890,11 +5890,11 @@ gimp_image_remove_channel (GimpImage *image, /* path */ gboolean -gimp_image_add_path (GimpImage *image, - GimpVectors *path, - GimpVectors *parent, - gint position, - gboolean push_undo) +gimp_image_add_path (GimpImage *image, + GimpPath *path, + GimpPath *parent, + gint position, + gboolean push_undo) { GimpImagePrivate *private; GList *list = NULL; @@ -5930,16 +5930,16 @@ gimp_image_add_path (GimpImage *image, } void -gimp_image_remove_path (GimpImage *image, - GimpVectors *path, - gboolean push_undo, - GList *new_selected) +gimp_image_remove_path (GimpImage *image, + GimpPath *path, + gboolean push_undo, + GList *new_selected) { GimpImagePrivate *private; GList *selected_path; g_return_if_fail (GIMP_IS_IMAGE (image)); - g_return_if_fail (GIMP_IS_VECTORS (path)); + g_return_if_fail (GIMP_IS_PATH (path)); g_return_if_fail (gimp_item_is_attached (GIMP_ITEM (path))); g_return_if_fail (gimp_item_get_image (GIMP_ITEM (path)) == image); diff --git a/app/core/gimpimage.h b/app/core/gimpimage.h index 124a3eaae3..fc8841d750 100644 --- a/app/core/gimpimage.h +++ b/app/core/gimpimage.h @@ -394,14 +394,14 @@ GimpLayer * gimp_image_get_layer_by_tattoo (GimpImage *image, GimpTattoo tattoo); GimpChannel * gimp_image_get_channel_by_tattoo (GimpImage *image, GimpTattoo tattoo); -GimpVectors * gimp_image_get_path_by_tattoo (GimpImage *image, +GimpPath * gimp_image_get_path_by_tattoo (GimpImage *image, GimpTattoo tattoo); GimpLayer * gimp_image_get_layer_by_name (GimpImage *image, const gchar *name); GimpChannel * gimp_image_get_channel_by_name (GimpImage *image, const gchar *name); -GimpVectors * gimp_image_get_path_by_name (GimpImage *image, +GimpPath * gimp_image_get_path_by_name (GimpImage *image, const gchar *name); gboolean gimp_image_reorder_item (GimpImage *image, @@ -467,12 +467,12 @@ void gimp_image_remove_channel (GimpImage *image, GList *new_selected); gboolean gimp_image_add_path (GimpImage *image, - GimpVectors *path, - GimpVectors *parent, + GimpPath *path, + GimpPath *parent, gint position, gboolean push_undo); void gimp_image_remove_path (GimpImage *image, - GimpVectors *path, + GimpPath *path, gboolean push_undo, GList *new_selected); diff --git a/app/core/gimpitemlist.c b/app/core/gimpitemlist.c index ccc57aa601..e40ed3c7db 100644 --- a/app/core/gimpitemlist.c +++ b/app/core/gimpitemlist.c @@ -36,7 +36,7 @@ #include "gimplayer.h" #include "gimpmarshal.h" -#include "vectors/gimpvectors.h" +#include "vectors/gimppath.h" #include "gimp-intl.h" @@ -187,7 +187,7 @@ gimp_item_list_constructed (GObject *object) gimp_assert (GIMP_IS_IMAGE (set->p->image)); gimp_assert (set->p->item_type == GIMP_TYPE_LAYER || - set->p->item_type == GIMP_TYPE_VECTORS || + set->p->item_type == GIMP_TYPE_PATH || set->p->item_type == GIMP_TYPE_CHANNEL); if (! set->p->is_pattern) @@ -196,7 +196,7 @@ gimp_item_list_constructed (GObject *object) if (set->p->item_type == GIMP_TYPE_LAYER) container = gimp_image_get_layers (set->p->image); - else if (set->p->item_type == GIMP_TYPE_VECTORS) + else if (set->p->item_type == GIMP_TYPE_PATH) container = gimp_image_get_paths (set->p->image); else container = gimp_image_get_channels (set->p->image); @@ -220,7 +220,7 @@ gimp_item_list_dispose (GObject *object) if (set->p->item_type == GIMP_TYPE_LAYER) container = gimp_image_get_layers (set->p->image); - else if (set->p->item_type == GIMP_TYPE_VECTORS) + else if (set->p->item_type == GIMP_TYPE_PATH) container = gimp_image_get_paths (set->p->image); else container = gimp_image_get_channels (set->p->image); @@ -349,7 +349,7 @@ gimp_item_list_named_new (GimpImage *image, { if (item_type == GIMP_TYPE_LAYER) items = gimp_image_get_selected_layers (image); - else if (item_type == GIMP_TYPE_VECTORS) + else if (item_type == GIMP_TYPE_PATH) items = gimp_image_get_selected_paths (image); else if (item_type == GIMP_TYPE_CHANNEL) items = gimp_image_get_selected_channels (image); diff --git a/app/core/gimpparamspecs.c b/app/core/gimpparamspecs.c index 5f155a3d86..6d96c7cdc3 100644 --- a/app/core/gimpparamspecs.c +++ b/app/core/gimpparamspecs.c @@ -40,7 +40,7 @@ #include "text/gimpfont.h" #include "text/gimptextlayer.h" -#include "vectors/gimpvectors.h" +#include "vectors/gimppath.h" /* diff --git a/app/dialogs/vectors-options-dialog.c b/app/dialogs/vectors-options-dialog.c index a464469fdc..21a008ca90 100644 --- a/app/dialogs/vectors-options-dialog.c +++ b/app/dialogs/vectors-options-dialog.c @@ -27,7 +27,7 @@ #include "core/gimpcontext.h" #include "core/gimpimage.h" -#include "vectors/gimpvectors.h" +#include "vectors/gimppath.h" #include "item-options-dialog.h" #include "vectors-options-dialog.h" @@ -64,7 +64,7 @@ static void vectors_options_dialog_callback (GtkWidget *dialog, GtkWidget * vectors_options_dialog_new (GimpImage *image, - GimpVectors *vectors, + GimpPath *vectors, GimpContext *context, GtkWidget *parent, const gchar *title, @@ -85,7 +85,7 @@ vectors_options_dialog_new (GimpImage *image, GtkWidget *dialog; g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL); - g_return_val_if_fail (vectors == NULL || GIMP_IS_VECTORS (vectors), NULL); + g_return_val_if_fail (vectors == NULL || GIMP_IS_PATH (vectors), NULL); g_return_val_if_fail (GIMP_IS_CONTEXT (context), NULL); g_return_val_if_fail (GTK_IS_WIDGET (parent), NULL); g_return_val_if_fail (title != NULL, NULL); @@ -149,7 +149,7 @@ vectors_options_dialog_callback (GtkWidget *dialog, private->callback (dialog, image, - GIMP_VECTORS (item), + GIMP_PATH (item), context, item_name, item_visible, diff --git a/app/dialogs/vectors-options-dialog.h b/app/dialogs/vectors-options-dialog.h index 572a25e825..137c628c5b 100644 --- a/app/dialogs/vectors-options-dialog.h +++ b/app/dialogs/vectors-options-dialog.h @@ -21,7 +21,7 @@ typedef void (* GimpVectorsOptionsCallback) (GtkWidget *dialog, GimpImage *image, - GimpVectors *vectors, + GimpPath *vectors, GimpContext *context, const gchar *vectors_name, gboolean vectors_visible, @@ -33,7 +33,7 @@ typedef void (* GimpVectorsOptionsCallback) (GtkWidget *dialog, GtkWidget * vectors_options_dialog_new (GimpImage *image, - GimpVectors *vectors, + GimpPath *vectors, GimpContext *context, GtkWidget *parent, const gchar *title, diff --git a/app/display/gimpcanvasitem-utils.c b/app/display/gimpcanvasitem-utils.c index 60b9fcd3a6..6b47b785a8 100644 --- a/app/display/gimpcanvasitem-utils.c +++ b/app/display/gimpcanvasitem-utils.c @@ -31,7 +31,7 @@ #include "vectors/gimpanchor.h" #include "vectors/gimpbezierstroke.h" -#include "vectors/gimpvectors.h" +#include "vectors/gimppath.h" #include "gimpcanvasitem.h" #include "gimpcanvasitem-utils.h" @@ -105,7 +105,7 @@ gimp_canvas_item_on_handle (GimpCanvasItem *item, gboolean gimp_canvas_item_on_vectors_handle (GimpCanvasItem *item, - GimpVectors *vectors, + GimpPath *vectors, const GimpCoords *coord, gint width, gint height, @@ -123,7 +123,7 @@ gimp_canvas_item_on_vectors_handle (GimpCanvasItem *item, gdouble mindist = -1; g_return_val_if_fail (GIMP_IS_CANVAS_ITEM (item), FALSE); - g_return_val_if_fail (GIMP_IS_VECTORS (vectors), FALSE); + g_return_val_if_fail (GIMP_IS_PATH (vectors), FALSE); g_return_val_if_fail (coord != NULL, FALSE); if (ret_anchor) *ret_anchor = NULL; @@ -221,7 +221,7 @@ gimp_canvas_item_on_vectors_handle (GimpCanvasItem *item, gboolean gimp_canvas_item_on_vectors_curve (GimpCanvasItem *item, - GimpVectors *vectors, + GimpPath *vectors, const GimpCoords *coord, gint width, gint height, @@ -239,7 +239,7 @@ gimp_canvas_item_on_vectors_curve (GimpCanvasItem *item, gdouble min_dist, cur_dist, cur_pos; g_return_val_if_fail (GIMP_IS_CANVAS_ITEM (item), FALSE); - g_return_val_if_fail (GIMP_IS_VECTORS (vectors), FALSE); + g_return_val_if_fail (GIMP_IS_PATH (vectors), FALSE); g_return_val_if_fail (coord != NULL, FALSE); if (ret_coords) *ret_coords = *coord; @@ -297,7 +297,7 @@ gimp_canvas_item_on_path (GimpCanvasItem *item, GimpAnchor **ret_segment_start, GimpAnchor **ret_segment_end, GimpStroke **ret_stroke, - GimpVectors **ret_path) + GimpPath **ret_path) { GimpDisplayShell *shell; GimpImage *image; @@ -321,7 +321,7 @@ gimp_canvas_item_on_path (GimpCanvasItem *item, for (list = all_path; list; list = g_list_next (list)) { - GimpVectors *vectors = list->data; + GimpPath *vectors = list->data; if (! gimp_item_get_visible (GIMP_ITEM (vectors))) continue; diff --git a/app/display/gimpcanvasitem-utils.h b/app/display/gimpcanvasitem-utils.h index 3e153a8537..0812e7de33 100644 --- a/app/display/gimpcanvasitem-utils.h +++ b/app/display/gimpcanvasitem-utils.h @@ -33,7 +33,7 @@ gboolean gimp_canvas_item_on_handle (GimpCanvasItem *item, GimpHandleAnchor anchor); gboolean gimp_canvas_item_on_vectors_handle (GimpCanvasItem *item, - GimpVectors *vectors, + GimpPath *vectors, const GimpCoords *coord, gint width, gint height, @@ -42,7 +42,7 @@ gboolean gimp_canvas_item_on_vectors_handle (GimpCanvasItem *item, GimpAnchor **ret_anchor, GimpStroke **ret_stroke); gboolean gimp_canvas_item_on_vectors_curve (GimpCanvasItem *item, - GimpVectors *vectors, + GimpPath *vectors, const GimpCoords *coord, gint width, gint height, @@ -60,7 +60,7 @@ gboolean gimp_canvas_item_on_path (GimpCanvasItem *item, GimpAnchor **ret_segment_start, GimpAnchor **ret_segment_end, GimpStroke **ret_stroke, - GimpVectors **ret_path); + GimpPath **ret_path); void gimp_canvas_item_shift_to_north_west (GimpHandleAnchor anchor, gdouble x, diff --git a/app/display/gimpdisplayshell-dnd.c b/app/display/gimpdisplayshell-dnd.c index 60d615c414..f5b9d45f3a 100644 --- a/app/display/gimpdisplayshell-dnd.c +++ b/app/display/gimpdisplayshell-dnd.c @@ -46,7 +46,7 @@ #include "text/gimptext.h" #include "text/gimptextlayer.h" -#include "vectors/gimpvectors.h" +#include "vectors/gimppath.h" #include "vectors/gimpvectors-import.h" #include "widgets/gimpdnd.h" @@ -127,7 +127,7 @@ gimp_display_shell_dnd_init (GimpDisplayShell *shell) gimp_dnd_viewable_dest_add (shell->canvas, GIMP_TYPE_CHANNEL, gimp_display_shell_drop_drawable, shell); - gimp_dnd_viewable_dest_add (shell->canvas, GIMP_TYPE_VECTORS, + gimp_dnd_viewable_dest_add (shell->canvas, GIMP_TYPE_PATH, gimp_display_shell_drop_path, shell); gimp_dnd_viewable_dest_add (shell->canvas, GIMP_TYPE_PATTERN, @@ -285,7 +285,7 @@ gimp_display_shell_drop_path (GtkWidget *widget, if (new_item) { - GimpVectors *new_path = GIMP_VECTORS (new_item); + GimpPath *new_path = GIMP_PATH (new_item); gimp_image_undo_group_start (image, GIMP_UNDO_GROUP_EDIT_PASTE, _("Drop New Path")); diff --git a/app/display/gimpdisplayshell-handlers.c b/app/display/gimpdisplayshell-handlers.c index 4b9d68e100..266a500c9c 100644 --- a/app/display/gimpdisplayshell-handlers.c +++ b/app/display/gimpdisplayshell-handlers.c @@ -44,7 +44,7 @@ #include "core/gimpsamplepoint.h" #include "core/gimptreehandler.h" -#include "vectors/gimpvectors.h" +#include "vectors/gimppath.h" #include "widgets/gimpwidgets-utils.h" @@ -139,17 +139,17 @@ static void gimp_display_shell_exported_handler (GimpImage *i static void gimp_display_shell_active_paths_handler (GimpImage *image, GimpDisplayShell *shell); -static void gimp_display_shell_path_freeze_handler (GimpVectors *path, +static void gimp_display_shell_path_freeze_handler (GimpPath *path, GimpDisplayShell *shell); -static void gimp_display_shell_path_thaw_handler (GimpVectors *path, +static void gimp_display_shell_path_thaw_handler (GimpPath *path, GimpDisplayShell *shell); -static void gimp_display_shell_path_visible_handler (GimpVectors *path, +static void gimp_display_shell_path_visible_handler (GimpPath *path, GimpDisplayShell *shell); static void gimp_display_shell_path_add_handler (GimpContainer *container, - GimpVectors *path, + GimpPath *path, GimpDisplayShell *shell); static void gimp_display_shell_path_remove_handler (GimpContainer *container, - GimpVectors *path, + GimpPath *path, GimpDisplayShell *shell); static void gimp_display_shell_check_notify_handler (GObject *config, @@ -974,7 +974,7 @@ gimp_display_shell_active_paths_handler (GimpImage *image, list; list = g_list_next (list)) { - GimpVectors *path = list->data; + GimpPath *path = list->data; GimpCanvasItem *item; item = gimp_canvas_proxy_group_get_item (group, path); @@ -985,14 +985,14 @@ gimp_display_shell_active_paths_handler (GimpImage *image, } static void -gimp_display_shell_path_freeze_handler (GimpVectors *path, +gimp_display_shell_path_freeze_handler (GimpPath *path, GimpDisplayShell *shell) { /* do nothing */ } static void -gimp_display_shell_path_thaw_handler (GimpVectors *path, +gimp_display_shell_path_thaw_handler (GimpPath *path, GimpDisplayShell *shell) { GimpCanvasProxyGroup *group = GIMP_CANVAS_PROXY_GROUP (shell->vectors); @@ -1004,7 +1004,7 @@ gimp_display_shell_path_thaw_handler (GimpVectors *path, } static void -gimp_display_shell_path_visible_handler (GimpVectors *path, +gimp_display_shell_path_visible_handler (GimpPath *path, GimpDisplayShell *shell) { GimpCanvasProxyGroup *group = GIMP_CANVAS_PROXY_GROUP (shell->vectors); @@ -1018,7 +1018,7 @@ gimp_display_shell_path_visible_handler (GimpVectors *path, static void gimp_display_shell_path_add_handler (GimpContainer *container, - GimpVectors *path, + GimpPath *path, GimpDisplayShell *shell) { GimpCanvasProxyGroup *group = GIMP_CANVAS_PROXY_GROUP (shell->vectors); @@ -1038,7 +1038,7 @@ gimp_display_shell_path_add_handler (GimpContainer *container, static void gimp_display_shell_path_remove_handler (GimpContainer *container, - GimpVectors *path, + GimpPath *path, GimpDisplayShell *shell) { GimpCanvasProxyGroup *group = GIMP_CANVAS_PROXY_GROUP (shell->vectors); diff --git a/app/display/gimptoolpath.c b/app/display/gimptoolpath.c index 2886947921..dacdcd0120 100644 --- a/app/display/gimptoolpath.c +++ b/app/display/gimptoolpath.c @@ -38,7 +38,7 @@ #include "vectors/gimpanchor.h" #include "vectors/gimpbezierstroke.h" -#include "vectors/gimpvectors.h" +#include "vectors/gimppath.h" #include "widgets/gimpdialogfactory.h" #include "widgets/gimpdockcontainer.h" @@ -103,7 +103,7 @@ enum struct _GimpToolPathPrivate { - GimpVectors *vectors; /* the current Vector data */ + GimpPath *vectors; /* the current Path data */ GimpVectorMode edit_mode; gboolean polygonal; @@ -197,11 +197,11 @@ static void gimp_tool_path_begin_change (GimpToolPath *path, static void gimp_tool_path_end_change (GimpToolPath *path, gboolean success); -static void gimp_tool_path_vectors_visible (GimpVectors *vectors, +static void gimp_tool_path_vectors_visible (GimpPath *vectors, GimpToolPath *path); -static void gimp_tool_path_vectors_freeze (GimpVectors *vectors, +static void gimp_tool_path_vectors_freeze (GimpPath *vectors, GimpToolPath *path); -static void gimp_tool_path_vectors_thaw (GimpVectors *vectors, +static void gimp_tool_path_vectors_thaw (GimpPath *vectors, GimpToolPath *path); static void gimp_tool_path_verify_state (GimpToolPath *path); @@ -271,7 +271,7 @@ gimp_tool_path_class_init (GimpToolPathClass *klass) g_object_class_install_property (object_class, PROP_VECTORS, g_param_spec_object ("vectors", NULL, NULL, - GIMP_TYPE_VECTORS, + GIMP_TYPE_PATH, GIMP_PARAM_READWRITE | G_PARAM_CONSTRUCT)); @@ -389,7 +389,7 @@ gimp_tool_path_changed (GimpToolWidget *widget) { GimpToolPath *path = GIMP_TOOL_PATH (widget); GimpToolPathPrivate *private = path->private; - GimpVectors *vectors = private->vectors; + GimpPath *vectors = private->vectors; if (private->items) { @@ -591,7 +591,7 @@ gimp_tool_path_button_press (GimpToolWidget *widget, if (private->function == VECTORS_SELECT_VECTOR) { - GimpVectors *vectors; + GimpPath *vectors; if (gimp_canvas_item_on_path (private->path, coords, @@ -612,7 +612,7 @@ gimp_tool_path_button_press (GimpToolWidget *widget, { GimpDisplayShell *shell = gimp_tool_widget_get_shell (widget); GimpImage *image = gimp_display_get_image (shell->display); - GimpVectors *vectors; + GimpPath *vectors; vectors = gimp_vectors_new (image, _("Unnamed")); g_object_ref_sink (vectors); @@ -1733,7 +1733,7 @@ gimp_tool_path_end_change (GimpToolPath *path, } static void -gimp_tool_path_vectors_visible (GimpVectors *vectors, +gimp_tool_path_vectors_visible (GimpPath *vectors, GimpToolPath *path) { GimpToolPathPrivate *private = path->private; @@ -1743,13 +1743,13 @@ gimp_tool_path_vectors_visible (GimpVectors *vectors, } static void -gimp_tool_path_vectors_freeze (GimpVectors *vectors, +gimp_tool_path_vectors_freeze (GimpPath *vectors, GimpToolPath *path) { } static void -gimp_tool_path_vectors_thaw (GimpVectors *vectors, +gimp_tool_path_vectors_thaw (GimpPath *vectors, GimpToolPath *path) { /* Ok, the vector might have changed externally (e.g. Undo) we need @@ -1937,12 +1937,12 @@ gimp_tool_path_new (GimpDisplayShell *shell) void gimp_tool_path_set_vectors (GimpToolPath *path, - GimpVectors *vectors) + GimpPath *vectors) { GimpToolPathPrivate *private; g_return_if_fail (GIMP_IS_TOOL_PATH (path)); - g_return_if_fail (vectors == NULL || GIMP_IS_VECTORS (vectors)); + g_return_if_fail (vectors == NULL || GIMP_IS_PATH (vectors)); private = path->private; diff --git a/app/display/gimptoolpath.h b/app/display/gimptoolpath.h index 268f116086..a7847c00a5 100644 --- a/app/display/gimptoolpath.h +++ b/app/display/gimptoolpath.h @@ -62,7 +62,7 @@ GType gimp_tool_path_get_type (void) G_GNUC_CONST; GimpToolWidget * gimp_tool_path_new (GimpDisplayShell *shell); void gimp_tool_path_set_vectors (GimpToolPath *path, - GimpVectors *vectors); + GimpPath *vectors); void gimp_tool_path_get_popup_state (GimpToolPath *path, gboolean *on_handle, diff --git a/app/gimpcore.def b/app/gimpcore.def index ac37d1a983..cafbf8d019 100644 --- a/app/gimpcore.def +++ b/app/gimpcore.def @@ -486,6 +486,7 @@ EXPORTS gimp_parameters_append gimp_parameters_append_valist gimp_parameters_free + gimp_path_get_type gimp_pattern_get_standard gimp_pattern_get_type gimp_pencil_options_get_type @@ -574,7 +575,6 @@ EXPORTS gimp_vectors_export_file gimp_vectors_export_string gimp_vectors_freeze - gimp_vectors_get_type gimp_vectors_import_buffer gimp_vectors_import_file gimp_vectors_new @@ -897,65 +897,65 @@ gimp_gegl_init gimp_image_get_guides gimp_image_get_sample_points gimp_plug_in_manager_get_menu_branches -desaturate_region -file_utils_filename_is_uri -get_pid -gimp_brightness_contrast_config_get_type -gimp_brightness_contrast_config_set_node -gimp_brightness_contrast_config_to_levels_config -gimp_buffer_get_tiles -gimp_color_balance_config_get_type -gimp_color_balance_config_reset_range -gimp_color_balance_config_to_cruft -gimp_colorize_config_get_type -gimp_colorize_config_to_cruft -gimp_container_get_first_child -gimp_context_display_changed -gimp_curve_get_curve_type -gimp_curve_get_n_points -gimp_curve_get_n_samples -gimp_curve_get_point -gimp_curve_map_value -gimp_curves_config_get_type -gimp_curves_config_load_cruft -gimp_curves_config_save_cruft -gimp_curves_config_to_cruft -gimp_desaturate_config_get_type -gimp_display_options_no_image_get_type -gimp_histogram_duplicate -gimp_histogram_ref -gimp_histogram_unref -gimp_hue_saturation_config_get_type -gimp_hue_saturation_config_reset_range -gimp_hue_saturation_config_to_cruft -gimp_image_get_projection -gimp_image_map_config_compare -gimp_image_map_config_get_type -gimp_imagefile_set_mime_type -gimp_is_restored -gimp_item_is_attached -gimp_layer_new_from_tiles -gimp_levels_config_adjust_by_colors -gimp_levels_config_get_type -gimp_levels_config_load_cruft -gimp_levels_config_reset_channel -gimp_levels_config_save_cruft -gimp_levels_config_stretch -gimp_levels_config_to_cruft -gimp_levels_config_to_curves_config -gimp_list_set_sort_func -gimp_marshal_BOOLEAN__STRING -gimp_marshal_VOID__DOUBLE -gimp_marshal_VOID__DOUBLE_DOUBLE_DOUBLE_DOUBLE -gimp_operation_hue_saturation_map -gimp_operation_levels_map_input -gimp_perspective_clone_set_transform -gimp_posterize_config_get_type -gimp_recent_list_load -gimp_scan_convert_compose_value -gimp_stroke_options_take_dash_pattern -gimp_threshold_config_get_type -gimp_threshold_config_to_cruft -gimp_tool_info_build_options_filename -gimp_use_gegl -gimp_vectors_make_bezier +desaturate_region +file_utils_filename_is_uri +get_pid +gimp_brightness_contrast_config_get_type +gimp_brightness_contrast_config_set_node +gimp_brightness_contrast_config_to_levels_config +gimp_buffer_get_tiles +gimp_color_balance_config_get_type +gimp_color_balance_config_reset_range +gimp_color_balance_config_to_cruft +gimp_colorize_config_get_type +gimp_colorize_config_to_cruft +gimp_container_get_first_child +gimp_context_display_changed +gimp_curve_get_curve_type +gimp_curve_get_n_points +gimp_curve_get_n_samples +gimp_curve_get_point +gimp_curve_map_value +gimp_curves_config_get_type +gimp_curves_config_load_cruft +gimp_curves_config_save_cruft +gimp_curves_config_to_cruft +gimp_desaturate_config_get_type +gimp_display_options_no_image_get_type +gimp_histogram_duplicate +gimp_histogram_ref +gimp_histogram_unref +gimp_hue_saturation_config_get_type +gimp_hue_saturation_config_reset_range +gimp_hue_saturation_config_to_cruft +gimp_image_get_projection +gimp_image_map_config_compare +gimp_image_map_config_get_type +gimp_imagefile_set_mime_type +gimp_is_restored +gimp_item_is_attached +gimp_layer_new_from_tiles +gimp_levels_config_adjust_by_colors +gimp_levels_config_get_type +gimp_levels_config_load_cruft +gimp_levels_config_reset_channel +gimp_levels_config_save_cruft +gimp_levels_config_stretch +gimp_levels_config_to_cruft +gimp_levels_config_to_curves_config +gimp_list_set_sort_func +gimp_marshal_BOOLEAN__STRING +gimp_marshal_VOID__DOUBLE +gimp_marshal_VOID__DOUBLE_DOUBLE_DOUBLE_DOUBLE +gimp_operation_hue_saturation_map +gimp_operation_levels_map_input +gimp_perspective_clone_set_transform +gimp_posterize_config_get_type +gimp_recent_list_load +gimp_scan_convert_compose_value +gimp_stroke_options_take_dash_pattern +gimp_threshold_config_get_type +gimp_threshold_config_to_cruft +gimp_tool_info_build_options_filename +gimp_use_gegl +gimp_vectors_make_bezier diff --git a/app/paint/gimppaintcore-stroke.c b/app/paint/gimppaintcore-stroke.c index fc9dcb33c7..2958785abf 100644 --- a/app/paint/gimppaintcore-stroke.c +++ b/app/paint/gimppaintcore-stroke.c @@ -29,8 +29,8 @@ #include "core/gimperror.h" #include "core/gimpcoords.h" +#include "vectors/gimppath.h" #include "vectors/gimpstroke.h" -#include "vectors/gimpvectors.h" #include "gimppaintcore.h" #include "gimppaintcore-stroke.h" @@ -234,7 +234,7 @@ gimp_paint_core_stroke_vectors (GimpPaintCore *core, GimpDrawable *drawable, GimpPaintOptions *paint_options, gboolean emulate_dynamics, - GimpVectors *vectors, + GimpPath *path, gboolean push_undo, GError **error) { @@ -248,14 +248,14 @@ gimp_paint_core_stroke_vectors (GimpPaintCore *core, g_return_val_if_fail (GIMP_IS_DRAWABLE (drawable), FALSE); g_return_val_if_fail (gimp_item_is_attached (GIMP_ITEM (drawable)), FALSE); g_return_val_if_fail (GIMP_IS_PAINT_OPTIONS (paint_options), FALSE); - g_return_val_if_fail (GIMP_IS_VECTORS (vectors), FALSE); + g_return_val_if_fail (GIMP_IS_PATH (path), FALSE); g_return_val_if_fail (error == NULL || *error == NULL, FALSE); - gimp_item_get_offset (GIMP_ITEM (vectors), &off_x, &off_y); + gimp_item_get_offset (GIMP_ITEM (path), &off_x, &off_y); drawables = g_list_prepend (NULL, drawable); - for (stroke = vectors->strokes->head; + for (stroke = path->strokes->head; stroke; stroke = stroke->next) { diff --git a/app/paint/gimppaintcore-stroke.h b/app/paint/gimppaintcore-stroke.h index e52b83996b..0506f80791 100644 --- a/app/paint/gimppaintcore-stroke.h +++ b/app/paint/gimppaintcore-stroke.h @@ -40,7 +40,7 @@ gboolean gimp_paint_core_stroke_vectors (GimpPaintCore *core, GimpDrawable *drawable, GimpPaintOptions *paint_options, gboolean emulate_dynamics, - GimpVectors *vectors, + GimpPath *path, gboolean push_undo, GError **error); diff --git a/app/pdb/gimppdb-utils.c b/app/pdb/gimppdb-utils.c index 873e6b55b3..98b6ab3a09 100644 --- a/app/pdb/gimppdb-utils.c +++ b/app/pdb/gimppdb-utils.c @@ -46,7 +46,7 @@ #include "text/gimptextlayer.h" #include "text/gimpfont.h" -#include "vectors/gimpvectors.h" +#include "vectors/gimppath.h" #include "gimppdb-utils.h" #include "gimppdberror.h" @@ -789,14 +789,14 @@ gimp_pdb_image_get_sample_point (GimpImage *image, } GimpStroke * -gimp_pdb_get_path_stroke (GimpVectors *path, +gimp_pdb_get_path_stroke (GimpPath *path, gint stroke_id, GimpPDBItemModify modify, GError **error) { GimpStroke *stroke = NULL; - g_return_val_if_fail (GIMP_IS_VECTORS (path), NULL); + g_return_val_if_fail (GIMP_IS_PATH (path), NULL); g_return_val_if_fail (error == NULL || *error == NULL, NULL); if (! gimp_pdb_item_is_not_group (GIMP_ITEM (path), error)) diff --git a/app/pdb/gimppdb-utils.h b/app/pdb/gimppdb-utils.h index 3958d0229a..824edb467d 100644 --- a/app/pdb/gimppdb-utils.h +++ b/app/pdb/gimppdb-utils.h @@ -102,7 +102,7 @@ GimpSamplePoint * gimp_pdb_image_get_sample_point (GimpImage *image, gint sample_point_id, GError **error); -GimpStroke * gimp_pdb_get_path_stroke (GimpVectors *path, +GimpStroke * gimp_pdb_get_path_stroke (GimpPath *path, gint stroke_id, GimpPDBItemModify modify, GError **error); diff --git a/app/pdb/gimpprocedure.c b/app/pdb/gimpprocedure.c index fd1b8954c8..fa3de0d252 100644 --- a/app/pdb/gimpprocedure.c +++ b/app/pdb/gimpprocedure.c @@ -35,7 +35,7 @@ #include "core/gimpparamspecs.h" #include "core/gimpprogress.h" -#include "vectors/gimpvectors.h" +#include "vectors/gimppath.h" #include "gimppdbcontext.h" #include "gimppdberror.h" diff --git a/app/pdb/image-cmds.c b/app/pdb/image-cmds.c index 25da0a5200..56753a768e 100644 --- a/app/pdb/image-cmds.c +++ b/app/pdb/image-cmds.c @@ -61,7 +61,7 @@ #include "plug-in/gimpplugin-cleanup.h" #include "plug-in/gimpplugin.h" #include "plug-in/gimppluginmanager.h" -#include "vectors/gimpvectors.h" +#include "vectors/gimppath.h" #include "gimppdb.h" #include "gimppdberror.h" @@ -520,7 +520,7 @@ image_get_paths_invoker (GimpProcedure *procedure, GimpValueArray *return_vals; GimpImage *image; gint num_paths = 0; - GimpVectors **paths = NULL; + GimpPath **paths = NULL; image = g_value_get_object (gimp_value_array_index (args, 0)); @@ -534,7 +534,7 @@ image_get_paths_invoker (GimpProcedure *procedure, { gint i; - paths = g_new (GimpVectors *, num_paths); + paths = g_new (GimpPath *, num_paths); for (i = 0; i < num_paths; i++, list = g_list_next (list)) paths[i] = g_object_ref (list->data); @@ -547,7 +547,7 @@ image_get_paths_invoker (GimpProcedure *procedure, if (success) { g_value_set_int (gimp_value_array_index (return_vals, 1), num_paths); - gimp_value_take_object_array (gimp_value_array_index (return_vals, 2), GIMP_TYPE_VECTORS, (GObject **) paths, num_paths); + gimp_value_take_object_array (gimp_value_array_index (return_vals, 2), GIMP_TYPE_PATH, (GObject **) paths, num_paths); } return return_vals; @@ -1045,8 +1045,8 @@ image_insert_path_invoker (GimpProcedure *procedure, { gboolean success = TRUE; GimpImage *image; - GimpVectors *path; - GimpVectors *parent; + GimpPath *path; + GimpPath *parent; gint position; image = g_value_get_object (gimp_value_array_index (args, 0)); @@ -1087,7 +1087,7 @@ image_remove_path_invoker (GimpProcedure *procedure, { gboolean success = TRUE; GimpImage *image; - GimpVectors *path; + GimpPath *path; image = g_value_get_object (gimp_value_array_index (args, 0)); path = g_value_get_object (gimp_value_array_index (args, 1)); @@ -1913,7 +1913,7 @@ image_get_selected_paths_invoker (GimpProcedure *procedure, GimpValueArray *return_vals; GimpImage *image; gint num_paths = 0; - GimpVectors **paths = NULL; + GimpPath **paths = NULL; image = g_value_get_object (gimp_value_array_index (args, 0)); @@ -1927,7 +1927,7 @@ image_get_selected_paths_invoker (GimpProcedure *procedure, { gint i; - paths = g_new (GimpVectors *, num_paths); + paths = g_new (GimpPath *, num_paths); for (i = 0; i < num_paths; i++, list = g_list_next (list)) paths[i] = g_object_ref (list->data); @@ -1940,7 +1940,7 @@ image_get_selected_paths_invoker (GimpProcedure *procedure, if (success) { g_value_set_int (gimp_value_array_index (return_vals, 1), num_paths); - gimp_value_take_object_array (gimp_value_array_index (return_vals, 2), GIMP_TYPE_VECTORS, (GObject **) paths, num_paths); + gimp_value_take_object_array (gimp_value_array_index (return_vals, 2), GIMP_TYPE_PATH, (GObject **) paths, num_paths); } return return_vals; @@ -1957,11 +1957,11 @@ image_set_selected_paths_invoker (GimpProcedure *procedure, gboolean success = TRUE; GimpImage *image; gint num_paths; - const GimpVectors **paths; + const GimpPath **paths; image = g_value_get_object (gimp_value_array_index (args, 0)); num_paths = g_value_get_int (gimp_value_array_index (args, 1)); - paths = (const GimpVectors **) gimp_value_get_object_array (gimp_value_array_index (args, 2)); + paths = (const GimpPath **) gimp_value_get_object_array (gimp_value_array_index (args, 2)); if (success) { @@ -2650,7 +2650,7 @@ image_get_path_by_tattoo_invoker (GimpProcedure *procedure, GimpValueArray *return_vals; GimpImage *image; guint tattoo; - GimpVectors *path = NULL; + GimpPath *path = NULL; image = g_value_get_object (gimp_value_array_index (args, 0)); tattoo = g_value_get_uint (gimp_value_array_index (args, 1)); @@ -2743,7 +2743,7 @@ image_get_path_by_name_invoker (GimpProcedure *procedure, GimpValueArray *return_vals; GimpImage *image; const gchar *name; - GimpVectors *path = NULL; + GimpPath *path = NULL; image = g_value_get_object (gimp_value_array_index (args, 0)); name = g_value_get_string (gimp_value_array_index (args, 1)); @@ -3381,7 +3381,7 @@ register_image_procs (GimpPDB *pdb) gimp_param_spec_object_array ("paths", "paths", "The list of paths contained in the image.", - GIMP_TYPE_VECTORS, + GIMP_TYPE_PATH, GIMP_PARAM_READWRITE)); gimp_pdb_register_procedure (pdb, procedure); g_object_unref (procedure); @@ -3843,17 +3843,17 @@ register_image_procs (GimpPDB *pdb) FALSE, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_vectors ("path", - "path", - "The path", - FALSE, - GIMP_PARAM_READWRITE)); + gimp_param_spec_path ("path", + "path", + "The path", + FALSE, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_vectors ("parent", - "parent", - "The parent path", - TRUE, - GIMP_PARAM_READWRITE)); + gimp_param_spec_path ("parent", + "parent", + "The parent path", + TRUE, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, g_param_spec_int ("position", "position", @@ -3884,11 +3884,11 @@ register_image_procs (GimpPDB *pdb) FALSE, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_vectors ("path", - "path", - "The path object", - FALSE, - GIMP_PARAM_READWRITE)); + gimp_param_spec_path ("path", + "path", + "The path object", + FALSE, + GIMP_PARAM_READWRITE)); gimp_pdb_register_procedure (pdb, procedure); g_object_unref (procedure); @@ -4673,7 +4673,7 @@ register_image_procs (GimpPDB *pdb) gimp_param_spec_object_array ("paths", "paths", "The list of selected paths in the image.", - GIMP_TYPE_VECTORS, + GIMP_TYPE_PATH, GIMP_PARAM_READWRITE)); gimp_pdb_register_procedure (pdb, procedure); g_object_unref (procedure); @@ -4708,7 +4708,7 @@ register_image_procs (GimpPDB *pdb) gimp_param_spec_object_array ("paths", "paths", "The list of paths to select", - GIMP_TYPE_VECTORS, + GIMP_TYPE_PATH, GIMP_PARAM_READWRITE | GIMP_PARAM_NO_VALIDATE)); gimp_pdb_register_procedure (pdb, procedure); g_object_unref (procedure); @@ -5385,11 +5385,11 @@ register_image_procs (GimpPDB *pdb) 1, G_MAXUINT32, 1, GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, - gimp_param_spec_vectors ("path", - "path", - "The path with the specified tattoo", - FALSE, - GIMP_PARAM_READWRITE)); + gimp_param_spec_path ("path", + "path", + "The path with the specified tattoo", + FALSE, + GIMP_PARAM_READWRITE)); gimp_pdb_register_procedure (pdb, procedure); g_object_unref (procedure); @@ -5493,11 +5493,11 @@ register_image_procs (GimpPDB *pdb) NULL, GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, - gimp_param_spec_vectors ("path", - "path", - "The path with the specified name", - FALSE, - GIMP_PARAM_READWRITE)); + gimp_param_spec_path ("path", + "path", + "The path with the specified name", + FALSE, + GIMP_PARAM_READWRITE)); gimp_pdb_register_procedure (pdb, procedure); g_object_unref (procedure); diff --git a/app/pdb/item-cmds.c b/app/pdb/item-cmds.c index d9fe0b165d..337e1e5a8f 100644 --- a/app/pdb/item-cmds.c +++ b/app/pdb/item-cmds.c @@ -39,7 +39,7 @@ #include "core/gimpparamspecs.h" #include "core/gimpselection.h" #include "text/gimptextlayer.h" -#include "vectors/gimpvectors.h" +#include "vectors/gimppath.h" #include "gimppdb.h" #include "gimppdb-utils.h" @@ -293,7 +293,7 @@ item_id_is_path_invoker (GimpProcedure *procedure, { GimpItem *item = gimp_item_get_by_id (gimp, item_id); - path = (GIMP_IS_VECTORS (item) && + path = (GIMP_IS_PATH (item) && ! gimp_item_is_removed (item)); } diff --git a/app/pdb/path-cmds.c b/app/pdb/path-cmds.c index 89446c36bd..85a720f002 100644 --- a/app/pdb/path-cmds.c +++ b/app/pdb/path-cmds.c @@ -40,10 +40,10 @@ #include "text/gimptextlayer.h" #include "vectors/gimpanchor.h" #include "vectors/gimpbezierstroke.h" +#include "vectors/gimppath.h" #include "vectors/gimpstroke-new.h" #include "vectors/gimpvectors-export.h" #include "vectors/gimpvectors-import.h" -#include "vectors/gimpvectors.h" #include "gimppdb.h" #include "gimppdb-utils.h" @@ -65,7 +65,7 @@ path_new_invoker (GimpProcedure *procedure, GimpValueArray *return_vals; GimpImage *image; const gchar *name; - GimpVectors *path = NULL; + GimpPath *path = NULL; image = g_value_get_object (gimp_value_array_index (args, 0)); name = g_value_get_string (gimp_value_array_index (args, 1)); @@ -96,7 +96,7 @@ path_new_from_text_layer_invoker (GimpProcedure *procedure, GimpValueArray *return_vals; GimpImage *image; GimpLayer *layer; - GimpVectors *path = NULL; + GimpPath *path = NULL; image = g_value_get_object (gimp_value_array_index (args, 0)); layer = g_value_get_object (gimp_value_array_index (args, 1)); @@ -138,15 +138,15 @@ path_copy_invoker (GimpProcedure *procedure, { gboolean success = TRUE; GimpValueArray *return_vals; - GimpVectors *path; - GimpVectors *path_copy = NULL; + GimpPath *path; + GimpPath *path_copy = NULL; path = g_value_get_object (gimp_value_array_index (args, 0)); if (success) { - path_copy = GIMP_VECTORS (gimp_item_duplicate (GIMP_ITEM (path), - G_TYPE_FROM_INSTANCE (path))); + path_copy = GIMP_PATH (gimp_item_duplicate (GIMP_ITEM (path), + G_TYPE_FROM_INSTANCE (path))); if (! path_copy) success = FALSE; @@ -171,7 +171,7 @@ path_get_strokes_invoker (GimpProcedure *procedure, { gboolean success = TRUE; GimpValueArray *return_vals; - GimpVectors *path; + GimpPath *path; gint num_strokes = 0; gint32 *stroke_ids = NULL; @@ -220,7 +220,7 @@ path_stroke_get_length_invoker (GimpProcedure *procedure, { gboolean success = TRUE; GimpValueArray *return_vals; - GimpVectors *path; + GimpPath *path; gint stroke_id; gdouble precision; gdouble length = 0.0; @@ -258,7 +258,7 @@ path_stroke_get_point_at_dist_invoker (GimpProcedure *procedure, { gboolean success = TRUE; GimpValueArray *return_vals; - GimpVectors *path; + GimpPath *path; gint stroke_id; gdouble dist; gdouble precision; @@ -312,7 +312,7 @@ path_remove_stroke_invoker (GimpProcedure *procedure, GError **error) { gboolean success = TRUE; - GimpVectors *path; + GimpPath *path; gint stroke_id; path = g_value_get_object (gimp_value_array_index (args, 0)); @@ -349,7 +349,7 @@ path_stroke_close_invoker (GimpProcedure *procedure, GError **error) { gboolean success = TRUE; - GimpVectors *path; + GimpPath *path; gint stroke_id; path = g_value_get_object (gimp_value_array_index (args, 0)); @@ -388,7 +388,7 @@ path_stroke_reverse_invoker (GimpProcedure *procedure, GError **error) { gboolean success = TRUE; - GimpVectors *path; + GimpPath *path; gint stroke_id; path = g_value_get_object (gimp_value_array_index (args, 0)); @@ -427,7 +427,7 @@ path_stroke_translate_invoker (GimpProcedure *procedure, GError **error) { gboolean success = TRUE; - GimpVectors *path; + GimpPath *path; gint stroke_id; gdouble off_x; gdouble off_y; @@ -472,7 +472,7 @@ path_stroke_scale_invoker (GimpProcedure *procedure, GError **error) { gboolean success = TRUE; - GimpVectors *path; + GimpPath *path; gint stroke_id; gdouble scale_x; gdouble scale_y; @@ -517,7 +517,7 @@ path_stroke_rotate_invoker (GimpProcedure *procedure, GError **error) { gboolean success = TRUE; - GimpVectors *path; + GimpPath *path; gint stroke_id; gdouble center_x; gdouble center_y; @@ -564,7 +564,7 @@ path_stroke_flip_invoker (GimpProcedure *procedure, GError **error) { gboolean success = TRUE; - GimpVectors *path; + GimpPath *path; gint stroke_id; gint flip_type; gdouble axis; @@ -609,7 +609,7 @@ path_stroke_flip_free_invoker (GimpProcedure *procedure, GError **error) { gboolean success = TRUE; - GimpVectors *path; + GimpPath *path; gint stroke_id; gdouble x1; gdouble y1; @@ -659,7 +659,7 @@ path_stroke_get_points_invoker (GimpProcedure *procedure, { gboolean success = TRUE; GimpValueArray *return_vals; - GimpVectors *path; + GimpPath *path; gint stroke_id; gint type = 0; gint num_points = 0; @@ -727,7 +727,7 @@ path_stroke_new_from_points_invoker (GimpProcedure *procedure, { gboolean success = TRUE; GimpValueArray *return_vals; - GimpVectors *path; + GimpPath *path; gint type; gint num_points; const gdouble *controlpoints; @@ -799,7 +799,7 @@ path_stroke_interpolate_invoker (GimpProcedure *procedure, { gboolean success = TRUE; GimpValueArray *return_vals; - GimpVectors *path; + GimpPath *path; gint stroke_id; gdouble precision; gint num_coords = 0; @@ -864,7 +864,7 @@ path_bezier_stroke_new_moveto_invoker (GimpProcedure *procedure, { gboolean success = TRUE; GimpValueArray *return_vals; - GimpVectors *path; + GimpPath *path; gdouble x0; gdouble y0; gint stroke_id = 0; @@ -919,7 +919,7 @@ path_bezier_stroke_lineto_invoker (GimpProcedure *procedure, GError **error) { gboolean success = TRUE; - GimpVectors *path; + GimpPath *path; gint stroke_id; gdouble x0; gdouble y0; @@ -967,7 +967,7 @@ path_bezier_stroke_conicto_invoker (GimpProcedure *procedure, GError **error) { gboolean success = TRUE; - GimpVectors *path; + GimpPath *path; gint stroke_id; gdouble x0; gdouble y0; @@ -1023,7 +1023,7 @@ path_bezier_stroke_cubicto_invoker (GimpProcedure *procedure, GError **error) { gboolean success = TRUE; - GimpVectors *path; + GimpPath *path; gint stroke_id; gdouble x0; gdouble y0; @@ -1088,7 +1088,7 @@ path_bezier_stroke_new_ellipse_invoker (GimpProcedure *procedure, { gboolean success = TRUE; GimpValueArray *return_vals; - GimpVectors *path; + GimpPath *path; gdouble x0; gdouble y0; gdouble radius_x; @@ -1155,7 +1155,7 @@ path_import_from_file_invoker (GimpProcedure *procedure, gboolean merge; gboolean scale; gint num_paths = 0; - GimpVectors **path = NULL; + GimpPath **path = NULL; image = g_value_get_object (gimp_value_array_index (args, 0)); file = g_value_get_object (gimp_value_array_index (args, 1)); @@ -1180,7 +1180,7 @@ path_import_from_file_invoker (GimpProcedure *procedure, GList *list; gint i; - path = g_new (GimpVectors *, num_paths); + path = g_new (GimpPath *, num_paths); for (i = 0, list = path_list; i < num_paths; @@ -1200,7 +1200,7 @@ path_import_from_file_invoker (GimpProcedure *procedure, if (success) { g_value_set_int (gimp_value_array_index (return_vals, 1), num_paths); - gimp_value_take_object_array (gimp_value_array_index (return_vals, 2), GIMP_TYPE_VECTORS, (GObject **) path, num_paths); + gimp_value_take_object_array (gimp_value_array_index (return_vals, 2), GIMP_TYPE_PATH, (GObject **) path, num_paths); } return return_vals; @@ -1222,7 +1222,7 @@ path_import_from_string_invoker (GimpProcedure *procedure, gboolean merge; gboolean scale; gint num_paths = 0; - GimpVectors **path = NULL; + GimpPath **path = NULL; image = g_value_get_object (gimp_value_array_index (args, 0)); string = g_value_get_string (gimp_value_array_index (args, 1)); @@ -1248,7 +1248,7 @@ path_import_from_string_invoker (GimpProcedure *procedure, GList *list; gint i; - path = g_new (GimpVectors *, num_paths); + path = g_new (GimpPath *, num_paths); for (i = 0, list = path_list; i < num_paths; @@ -1268,7 +1268,7 @@ path_import_from_string_invoker (GimpProcedure *procedure, if (success) { g_value_set_int (gimp_value_array_index (return_vals, 1), num_paths); - gimp_value_take_object_array (gimp_value_array_index (return_vals, 2), GIMP_TYPE_VECTORS, (GObject **) path, num_paths); + gimp_value_take_object_array (gimp_value_array_index (return_vals, 2), GIMP_TYPE_PATH, (GObject **) path, num_paths); } return return_vals; @@ -1285,7 +1285,7 @@ path_export_to_file_invoker (GimpProcedure *procedure, gboolean success = TRUE; GimpImage *image; GFile *file; - GimpVectors *path; + GimpPath *path; image = g_value_get_object (gimp_value_array_index (args, 0)); file = g_value_get_object (gimp_value_array_index (args, 1)); @@ -1318,7 +1318,7 @@ path_export_to_string_invoker (GimpProcedure *procedure, gboolean success = TRUE; GimpValueArray *return_vals; GimpImage *image; - GimpVectors *path; + GimpPath *path; gchar *string = NULL; image = g_value_get_object (gimp_value_array_index (args, 0)); @@ -1379,11 +1379,11 @@ register_path_procs (GimpPDB *pdb) NULL, GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, - gimp_param_spec_vectors ("path", - "path", - "the current path object, 0 if no path exists in the image.", - FALSE, - GIMP_PARAM_READWRITE)); + gimp_param_spec_path ("path", + "path", + "the current path object, 0 if no path exists in the image.", + FALSE, + GIMP_PARAM_READWRITE)); gimp_pdb_register_procedure (pdb, procedure); g_object_unref (procedure); @@ -1414,11 +1414,11 @@ register_path_procs (GimpPDB *pdb) FALSE, GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, - gimp_param_spec_vectors ("path", - "path", - "The path of the text layer.", - FALSE, - GIMP_PARAM_READWRITE)); + gimp_param_spec_path ("path", + "path", + "The path of the text layer.", + FALSE, + GIMP_PARAM_READWRITE)); gimp_pdb_register_procedure (pdb, procedure); g_object_unref (procedure); @@ -1437,17 +1437,17 @@ register_path_procs (GimpPDB *pdb) "Barak Itkin", "2008"); gimp_procedure_add_argument (procedure, - gimp_param_spec_vectors ("path", - "path", - "The path object to copy", - FALSE, - GIMP_PARAM_READWRITE)); + gimp_param_spec_path ("path", + "path", + "The path object to copy", + FALSE, + GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, - gimp_param_spec_vectors ("path-copy", - "path copy", - "The newly copied path object", - FALSE, - GIMP_PARAM_READWRITE)); + gimp_param_spec_path ("path-copy", + "path copy", + "The newly copied path object", + FALSE, + GIMP_PARAM_READWRITE)); gimp_pdb_register_procedure (pdb, procedure); g_object_unref (procedure); @@ -1466,11 +1466,11 @@ register_path_procs (GimpPDB *pdb) "Simon Budig", "2005"); gimp_procedure_add_argument (procedure, - gimp_param_spec_vectors ("path", - "path", - "The path object", - FALSE, - GIMP_PARAM_READWRITE)); + gimp_param_spec_path ("path", + "path", + "The path object", + FALSE, + GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, g_param_spec_int ("num-strokes", "num strokes", @@ -1500,11 +1500,11 @@ register_path_procs (GimpPDB *pdb) "Simon Budig", "2005"); gimp_procedure_add_argument (procedure, - gimp_param_spec_vectors ("path", - "path", - "The path object", - FALSE, - GIMP_PARAM_READWRITE)); + gimp_param_spec_path ("path", + "path", + "The path object", + FALSE, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, g_param_spec_int ("stroke-id", "stroke id", @@ -1541,11 +1541,11 @@ register_path_procs (GimpPDB *pdb) "Simon Budig", "2005"); gimp_procedure_add_argument (procedure, - gimp_param_spec_vectors ("path", - "path", - "The path object", - FALSE, - GIMP_PARAM_READWRITE)); + gimp_param_spec_path ("path", + "path", + "The path object", + FALSE, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, g_param_spec_int ("stroke-id", "stroke id", @@ -1606,11 +1606,11 @@ register_path_procs (GimpPDB *pdb) "Simon Budig", "2005"); gimp_procedure_add_argument (procedure, - gimp_param_spec_vectors ("path", - "path", - "The path object", - FALSE, - GIMP_PARAM_READWRITE)); + gimp_param_spec_path ("path", + "path", + "The path object", + FALSE, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, g_param_spec_int ("stroke-id", "stroke id", @@ -1635,11 +1635,11 @@ register_path_procs (GimpPDB *pdb) "Simon Budig", "2005"); gimp_procedure_add_argument (procedure, - gimp_param_spec_vectors ("path", - "path", - "The path object", - FALSE, - GIMP_PARAM_READWRITE)); + gimp_param_spec_path ("path", + "path", + "The path object", + FALSE, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, g_param_spec_int ("stroke-id", "stroke id", @@ -1664,11 +1664,11 @@ register_path_procs (GimpPDB *pdb) "Simon Budig", "2020"); gimp_procedure_add_argument (procedure, - gimp_param_spec_vectors ("path", - "path", - "The path object", - FALSE, - GIMP_PARAM_READWRITE)); + gimp_param_spec_path ("path", + "path", + "The path object", + FALSE, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, g_param_spec_int ("stroke-id", "stroke id", @@ -1693,11 +1693,11 @@ register_path_procs (GimpPDB *pdb) "Simon Budig", "2005"); gimp_procedure_add_argument (procedure, - gimp_param_spec_vectors ("path", - "path", - "The path object", - FALSE, - GIMP_PARAM_READWRITE)); + gimp_param_spec_path ("path", + "path", + "The path object", + FALSE, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, g_param_spec_int ("stroke-id", "stroke id", @@ -1734,11 +1734,11 @@ register_path_procs (GimpPDB *pdb) "Simon Budig", "2005"); gimp_procedure_add_argument (procedure, - gimp_param_spec_vectors ("path", - "path", - "The path object", - FALSE, - GIMP_PARAM_READWRITE)); + gimp_param_spec_path ("path", + "path", + "The path object", + FALSE, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, g_param_spec_int ("stroke-id", "stroke id", @@ -1775,11 +1775,11 @@ register_path_procs (GimpPDB *pdb) "Jo\xc3\xa3o S. O. Bueno", "2006"); gimp_procedure_add_argument (procedure, - gimp_param_spec_vectors ("path", - "path", - "The path object", - FALSE, - GIMP_PARAM_READWRITE)); + gimp_param_spec_path ("path", + "path", + "The path object", + FALSE, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, g_param_spec_int ("stroke-id", "stroke id", @@ -1822,11 +1822,11 @@ register_path_procs (GimpPDB *pdb) "Jo\xc3\xa3o S. O. Bueno", "2006"); gimp_procedure_add_argument (procedure, - gimp_param_spec_vectors ("path", - "path", - "The path object", - FALSE, - GIMP_PARAM_READWRITE)); + gimp_param_spec_path ("path", + "path", + "The path object", + FALSE, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, g_param_spec_int ("stroke-id", "stroke id", @@ -1866,11 +1866,11 @@ register_path_procs (GimpPDB *pdb) "Jo\xc3\xa3o S. O. Bueno", "2006"); gimp_procedure_add_argument (procedure, - gimp_param_spec_vectors ("path", - "path", - "The path object", - FALSE, - GIMP_PARAM_READWRITE)); + gimp_param_spec_path ("path", + "path", + "The path object", + FALSE, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, g_param_spec_int ("stroke-id", "stroke id", @@ -1919,11 +1919,11 @@ register_path_procs (GimpPDB *pdb) "Simon Budig", "2006"); gimp_procedure_add_argument (procedure, - gimp_param_spec_vectors ("path", - "path", - "The path object", - FALSE, - GIMP_PARAM_READWRITE)); + gimp_param_spec_path ("path", + "path", + "The path object", + FALSE, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, g_param_spec_int ("stroke-id", "stroke id", @@ -1972,11 +1972,11 @@ register_path_procs (GimpPDB *pdb) "Simon Budig", "2006"); gimp_procedure_add_argument (procedure, - gimp_param_spec_vectors ("path", - "path", - "The path object", - FALSE, - GIMP_PARAM_READWRITE)); + gimp_param_spec_path ("path", + "path", + "The path object", + FALSE, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, g_param_spec_enum ("type", "type", @@ -2025,11 +2025,11 @@ register_path_procs (GimpPDB *pdb) "Simon Budig", "2005"); gimp_procedure_add_argument (procedure, - gimp_param_spec_vectors ("path", - "path", - "The path object", - FALSE, - GIMP_PARAM_READWRITE)); + gimp_param_spec_path ("path", + "path", + "The path object", + FALSE, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, g_param_spec_int ("stroke-id", "stroke id", @@ -2077,11 +2077,11 @@ register_path_procs (GimpPDB *pdb) "Simon Budig", "2005"); gimp_procedure_add_argument (procedure, - gimp_param_spec_vectors ("path", - "path", - "The path object", - FALSE, - GIMP_PARAM_READWRITE)); + gimp_param_spec_path ("path", + "path", + "The path object", + FALSE, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, g_param_spec_double ("x0", "x0", @@ -2118,11 +2118,11 @@ register_path_procs (GimpPDB *pdb) "Simon Budig", "2005"); gimp_procedure_add_argument (procedure, - gimp_param_spec_vectors ("path", - "path", - "The path object", - FALSE, - GIMP_PARAM_READWRITE)); + gimp_param_spec_path ("path", + "path", + "The path object", + FALSE, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, g_param_spec_int ("stroke-id", "stroke id", @@ -2159,11 +2159,11 @@ register_path_procs (GimpPDB *pdb) "Simon Budig", "2005"); gimp_procedure_add_argument (procedure, - gimp_param_spec_vectors ("path", - "path", - "The path object", - FALSE, - GIMP_PARAM_READWRITE)); + gimp_param_spec_path ("path", + "path", + "The path object", + FALSE, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, g_param_spec_int ("stroke-id", "stroke id", @@ -2212,11 +2212,11 @@ register_path_procs (GimpPDB *pdb) "Simon Budig", "2005"); gimp_procedure_add_argument (procedure, - gimp_param_spec_vectors ("path", - "path", - "The path object", - FALSE, - GIMP_PARAM_READWRITE)); + gimp_param_spec_path ("path", + "path", + "The path object", + FALSE, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, g_param_spec_int ("stroke-id", "stroke id", @@ -2277,11 +2277,11 @@ register_path_procs (GimpPDB *pdb) "Simon Budig", "2005"); gimp_procedure_add_argument (procedure, - gimp_param_spec_vectors ("path", - "path", - "The path object", - FALSE, - GIMP_PARAM_READWRITE)); + gimp_param_spec_path ("path", + "path", + "The path object", + FALSE, + GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, g_param_spec_double ("x0", "x0", @@ -2369,7 +2369,7 @@ register_path_procs (GimpPDB *pdb) gimp_param_spec_object_array ("path", "path", "The list of newly created path", - GIMP_TYPE_VECTORS, + GIMP_TYPE_PATH, GIMP_PARAM_READWRITE)); gimp_pdb_register_procedure (pdb, procedure); g_object_unref (procedure); @@ -2429,7 +2429,7 @@ register_path_procs (GimpPDB *pdb) gimp_param_spec_object_array ("path", "path", "The list of newly created path", - GIMP_TYPE_VECTORS, + GIMP_TYPE_PATH, GIMP_PARAM_READWRITE)); gimp_pdb_register_procedure (pdb, procedure); g_object_unref (procedure); @@ -2461,11 +2461,11 @@ register_path_procs (GimpPDB *pdb) G_TYPE_FILE, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_vectors ("path", - "path", - "The path object to export, or %NULL for all in the image", - TRUE, - GIMP_PARAM_READWRITE | GIMP_PARAM_NO_VALIDATE)); + gimp_param_spec_path ("path", + "path", + "The path object to export, or %NULL for all in the image", + TRUE, + GIMP_PARAM_READWRITE | GIMP_PARAM_NO_VALIDATE)); gimp_pdb_register_procedure (pdb, procedure); g_object_unref (procedure); @@ -2490,11 +2490,11 @@ register_path_procs (GimpPDB *pdb) FALSE, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_vectors ("path", - "path", - "The path object to export, or %NULL for all in the image", - TRUE, - GIMP_PARAM_READWRITE | GIMP_PARAM_NO_VALIDATE)); + gimp_param_spec_path ("path", + "path", + "The path object to export, or %NULL for all in the image", + TRUE, + GIMP_PARAM_READWRITE | GIMP_PARAM_NO_VALIDATE)); gimp_procedure_add_return_value (procedure, gimp_param_spec_string ("string", "string", diff --git a/app/plug-in/gimpgpparams.c b/app/plug-in/gimpgpparams.c index 6e85616ec5..3dd74d39b3 100644 --- a/app/plug-in/gimpgpparams.c +++ b/app/plug-in/gimpgpparams.c @@ -49,7 +49,7 @@ #include "pdb/gimppdb-utils.h" -#include "vectors/gimpvectors.h" +#include "vectors/gimppath.h" #include "libgimp/gimpgpparams.h" diff --git a/app/tests/test-xcf.c b/app/tests/test-xcf.c index 3903a02f55..133efe2cbc 100644 --- a/app/tests/test-xcf.c +++ b/app/tests/test-xcf.c @@ -57,7 +57,7 @@ #include "vectors/gimpanchor.h" #include "vectors/gimpbezierstroke.h" -#include "vectors/gimpvectors.h" +#include "vectors/gimppath.h" #include "plug-in/gimppluginmanager-file.h" @@ -381,7 +381,7 @@ gimp_create_mainimage (Gimp *gimp, GimpChannel *channel = NULL; GeglColor *channel_color = gegl_color_new (NULL); GimpChannel *selection = NULL; - GimpVectors *vectors = NULL; + GimpPath *vectors = NULL; GimpCoords vectors1_coords[] = GIMP_MAINIMAGE_VECTORS1_COORDS; GimpCoords vectors2_coords[] = GIMP_MAINIMAGE_VECTORS2_COORDS; GimpStroke *stroke = NULL; @@ -687,7 +687,7 @@ gimp_assert_vectors (GimpImage *image, gsize coords_size, gboolean visible) { - GimpVectors *vectors = NULL; + GimpPath *vectors = NULL; GimpStroke *stroke = NULL; GArray *control_points = NULL; gboolean closed = FALSE; diff --git a/app/text/gimptext-vectors.c b/app/text/gimptext-vectors.c index b6414cb507..8fb22bf245 100644 --- a/app/text/gimptext-vectors.c +++ b/app/text/gimptext-vectors.c @@ -29,9 +29,9 @@ #include "core/gimp.h" #include "core/gimpimage.h" -#include "vectors/gimpbezierstroke.h" -#include "vectors/gimpvectors.h" #include "vectors/gimpanchor.h" +#include "vectors/gimpbezierstroke.h" +#include "vectors/gimppath.h" #include "gimptext.h" #include "gimptext-vectors.h" @@ -41,7 +41,7 @@ typedef struct { - GimpVectors *vectors; + GimpPath *vectors; GimpStroke *stroke; GimpAnchor *anchor; } RenderContext; @@ -51,11 +51,11 @@ static void gimp_text_render_vectors (cairo_t *cr, RenderContext *context); -GimpVectors * +GimpPath * gimp_text_vectors_new (GimpImage *image, GimpText *text) { - GimpVectors *vectors; + GimpPath *vectors; RenderContext context = { NULL, }; g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL); diff --git a/app/text/gimptext-vectors.h b/app/text/gimptext-vectors.h index df01aae87c..3eeddb0a29 100644 --- a/app/text/gimptext-vectors.h +++ b/app/text/gimptext-vectors.h @@ -22,8 +22,8 @@ #define __GIMP_TEXT_VECTORS_H__ -GimpVectors * gimp_text_vectors_new (GimpImage *image, - GimpText *text); +GimpPath * gimp_text_vectors_new (GimpImage *image, + GimpText *text); #endif /* __GIMP_TEXT_VECTORS_H__ */ diff --git a/app/tools/gimpalignoptions.c b/app/tools/gimpalignoptions.c index 730dd0be48..fe73ae9d72 100644 --- a/app/tools/gimpalignoptions.c +++ b/app/tools/gimpalignoptions.c @@ -32,7 +32,7 @@ #include "core/gimplayer.h" #include "core/gimpchannel.h" -#include "vectors/gimpvectors.h" +#include "vectors/gimppath.h" #include "widgets/gimppivotselector.h" #include "widgets/gimppropwidgets.h" @@ -824,7 +824,7 @@ gimp_align_options_update_area (GimpAlignOptions *options) else if (GIMP_IS_CHANNEL (options->priv->reference)) tmp_txt = g_strdup_printf (_("Reference channel: %s"), gimp_object_get_name (options->priv->reference)); - else if (GIMP_IS_VECTORS (options->priv->reference)) + else if (GIMP_IS_PATH (options->priv->reference)) tmp_txt = g_strdup_printf (_("Reference path: %s"), gimp_object_get_name (options->priv->reference)); else if (GIMP_IS_GUIDE (options->priv->reference)) diff --git a/app/tools/gimpaligntool.c b/app/tools/gimpaligntool.c index ba93a969a2..da567fc8c0 100644 --- a/app/tools/gimpaligntool.c +++ b/app/tools/gimpaligntool.c @@ -38,7 +38,7 @@ #include "core/gimppickable.h" #include "core/gimppickable-auto-shrink.h" -#include "vectors/gimpvectors.h" +#include "vectors/gimppath.h" #include "widgets/gimphelp-ids.h" #include "widgets/gimpwidgets-utils.h" @@ -342,7 +342,7 @@ gimp_align_tool_button_release (GimpTool *tool, if (object == NULL) { - GimpVectors *vectors; + GimpPath *path; GimpGuide *guide; GimpLayer *layer; GObject *previously_picked; @@ -351,12 +351,12 @@ gimp_align_tool_button_release (GimpTool *tool, previously_picked = gimp_align_options_get_reference (options, FALSE); - if ((vectors = gimp_image_pick_path (image, + if ((path = gimp_image_pick_path (image, coords->x, coords->y, FUNSCALEX (shell, snap_distance), FUNSCALEY (shell, snap_distance)))) { - object = G_OBJECT (vectors); + object = G_OBJECT (path); } else if (gimp_display_shell_get_show_guides (shell) && (guide = gimp_image_pick_guide (image, diff --git a/app/tools/gimpaligntool.h b/app/tools/gimpaligntool.h index 2bf666f2e9..eb189f07a5 100644 --- a/app/tools/gimpaligntool.h +++ b/app/tools/gimpaligntool.h @@ -71,7 +71,7 @@ struct _GimpAlignToolClass void gimp_align_tool_register (GimpToolRegisterCallback callback, - gpointer data); + gpointer data); GType gimp_align_tool_get_type (void) G_GNUC_CONST; diff --git a/app/tools/gimpmovetool.c b/app/tools/gimpmovetool.c index 4e81cc8e77..56383dbde3 100644 --- a/app/tools/gimpmovetool.c +++ b/app/tools/gimpmovetool.c @@ -203,7 +203,7 @@ gimp_move_tool_button_press (GimpTool *tool, if (options->move_type == GIMP_TRANSFORM_TYPE_PATH) { - GimpVectors *vectors; + GimpPath *vectors; vectors = gimp_image_pick_path (image, coords->x, coords->y, diff --git a/app/tools/gimptexttool.c b/app/tools/gimptexttool.c index cca72cfcab..4afdc413af 100644 --- a/app/tools/gimptexttool.c +++ b/app/tools/gimptexttool.c @@ -57,7 +57,7 @@ #include "text/gimptextundo.h" #include "vectors/gimpstroke.h" -#include "vectors/gimpvectors.h" +#include "vectors/gimppath.h" #include "vectors/gimpvectors-warp.h" #include "widgets/gimpdialogfactory.h" @@ -2313,7 +2313,7 @@ gimp_text_tool_paste_clipboard (GimpTextTool *text_tool) void gimp_text_tool_create_vectors (GimpTextTool *text_tool) { - GimpVectors *path; + GimpPath *path; g_return_if_fail (GIMP_IS_TEXT_TOOL (text_tool)); @@ -2341,7 +2341,7 @@ gimp_text_tool_create_vectors_warped (GimpTextTool *text_tool, GError **error) { GList *vectors0; - GimpVectors *vectors; + GimpPath *vectors; gdouble box_width; gdouble box_height; GimpTextDirection dir; diff --git a/app/tools/gimptools-utils.c b/app/tools/gimptools-utils.c index 9b5f0cf376..483e061d4c 100644 --- a/app/tools/gimptools-utils.c +++ b/app/tools/gimptools-utils.c @@ -28,7 +28,7 @@ #include "core/gimpchannel.h" #include "core/gimplayer.h" -#include "vectors/gimpvectors.h" +#include "vectors/gimppath.h" #include "widgets/gimpcontainerview.h" #include "widgets/gimpdialogfactory.h" @@ -58,7 +58,7 @@ gimp_tools_blink_lock_box (Gimp *gimp, identifier = "gimp-layer-list"; else if (GIMP_IS_CHANNEL (item)) identifier = "gimp-channel-list"; - else if (GIMP_IS_VECTORS (item)) + else if (GIMP_IS_PATH (item)) identifier = "gimp-vectors-list"; else return; diff --git a/app/tools/gimptransformgridtool.c b/app/tools/gimptransformgridtool.c index 0dfc7a7abd..af34668675 100644 --- a/app/tools/gimptransformgridtool.c +++ b/app/tools/gimptransformgridtool.c @@ -50,8 +50,8 @@ #include "core/gimptoolinfo.h" #include "core/gimpviewable.h" -#include "vectors/gimpvectors.h" #include "vectors/gimpstroke.h" +#include "vectors/gimppath.h" #include "widgets/gimpwidgets-utils.h" @@ -832,8 +832,8 @@ gimp_transform_grid_tool_draw (GimpDrawTool *draw_tool) for (iter = gimp_image_get_selected_paths (image); iter; iter = iter->next) { - GimpVectors *path = iter->data; - GimpStroke *stroke = NULL; + GimpPath *path = iter->data; + GimpStroke *stroke = NULL; while ((stroke = gimp_vectors_stroke_get_next (path, stroke))) { diff --git a/app/tools/gimptransformtool.c b/app/tools/gimptransformtool.c index c1e3e1c790..cf576d06aa 100644 --- a/app/tools/gimptransformtool.c +++ b/app/tools/gimptransformtool.c @@ -39,7 +39,7 @@ #include "core/gimpprogress.h" #include "core/gimp-transform-resize.h" -#include "vectors/gimpvectors.h" +#include "vectors/gimppath.h" #include "display/gimpdisplay.h" #include "display/gimpdisplayshell.h" @@ -749,7 +749,7 @@ gimp_transform_tool_check_selected_objects (GimpTransformTool *tr_tool, locked_message = _("The selected path's strokes are locked."); else if (gimp_item_is_position_locked (item, &locked_item)) locked_message = _("The selected path's position is locked."); - else if (! gimp_vectors_get_n_strokes (GIMP_VECTORS (item))) + else if (! gimp_vectors_get_n_strokes (GIMP_PATH (item))) locked_message = _("The selected path has no strokes."); } break; diff --git a/app/tools/gimpvectortool.c b/app/tools/gimpvectortool.c index a8069831e2..7bf9c60e47 100644 --- a/app/tools/gimpvectortool.c +++ b/app/tools/gimpvectortool.c @@ -40,7 +40,7 @@ #include "paint/gimppaintoptions.h" /* GIMP_PAINT_OPTIONS_CONTEXT_MASK */ -#include "vectors/gimpvectors.h" +#include "vectors/gimppath.h" #include "widgets/gimpdialogfactory.h" #include "widgets/gimpdockcontainer.h" @@ -121,7 +121,7 @@ static void gimp_vector_tool_path_activate (GimpToolWidget *path, static void gimp_vector_tool_vectors_changed (GimpImage *image, GimpVectorTool *vector_tool); -static void gimp_vector_tool_vectors_removed (GimpVectors *vectors, +static void gimp_vector_tool_vectors_removed (GimpPath *vectors, GimpVectorTool *vector_tool); static void gimp_vector_tool_to_selection (GimpVectorTool *vector_tool); @@ -450,7 +450,7 @@ gimp_vector_tool_path_changed (GimpToolWidget *path, { GimpDisplayShell *shell = gimp_tool_widget_get_shell (path); GimpImage *image = gimp_display_get_image (shell->display); - GimpVectors *vectors; + GimpPath *vectors; g_object_get (path, "vectors", &vectors, @@ -532,7 +532,7 @@ static void gimp_vector_tool_vectors_changed (GimpImage *image, GimpVectorTool *vector_tool) { - GimpVectors *path = NULL; + GimpPath *path = NULL; /* The path tool can only work on one path at a time. */ if (g_list_length (gimp_image_get_selected_paths (image)) == 1) @@ -542,7 +542,7 @@ gimp_vector_tool_vectors_changed (GimpImage *image, } static void -gimp_vector_tool_vectors_removed (GimpVectors *vectors, +gimp_vector_tool_vectors_removed (GimpPath *vectors, GimpVectorTool *vector_tool) { gimp_vector_tool_set_vectors (vector_tool, NULL); @@ -550,14 +550,14 @@ gimp_vector_tool_vectors_removed (GimpVectors *vectors, void gimp_vector_tool_set_vectors (GimpVectorTool *vector_tool, - GimpVectors *vectors) + GimpPath *vectors) { GimpTool *tool; GimpItem *item = NULL; GimpVectorOptions *options; g_return_if_fail (GIMP_IS_VECTOR_TOOL (vector_tool)); - g_return_if_fail (vectors == NULL || GIMP_IS_VECTORS (vectors)); + g_return_if_fail (vectors == NULL || GIMP_IS_PATH (vectors)); tool = GIMP_TOOL (vector_tool); options = GIMP_VECTOR_TOOL_GET_OPTIONS (vector_tool); diff --git a/app/tools/gimpvectortool.h b/app/tools/gimpvectortool.h index d0622ca375..d08910e216 100644 --- a/app/tools/gimpvectortool.h +++ b/app/tools/gimpvectortool.h @@ -42,7 +42,7 @@ struct _GimpVectorTool { GimpDrawTool parent_instance; - GimpVectors *vectors; /* the current Vector data */ + GimpPath *vectors; /* the current Path data */ GimpVectorMode saved_mode; /* used by modifier_key() */ GimpToolWidget *widget; @@ -61,6 +61,6 @@ void gimp_vector_tool_register (GimpToolRegisterCallback callback, GType gimp_vector_tool_get_type (void) G_GNUC_CONST; void gimp_vector_tool_set_vectors (GimpVectorTool *vector_tool, - GimpVectors *vectors); + GimpPath *vectors); #endif /* __GIMP_VECTOR_TOOL_H__ */ diff --git a/app/vectors/gimpvectors.c b/app/vectors/gimppath.c similarity index 82% rename from app/vectors/gimpvectors.c rename to app/vectors/gimppath.c index 346e79ba4c..c8a985aab1 100644 --- a/app/vectors/gimpvectors.c +++ b/app/vectors/gimppath.c @@ -1,7 +1,7 @@ /* GIMP - The GNU Image Manipulation Program * Copyright (C) 1995 Spencer Kimball and Peter Mattis * - * gimpvectors.c + * gimppath.c * Copyright (C) 2002 Simon Budig * * This program is free software: you can redistribute it and/or modify @@ -47,8 +47,8 @@ #include "paint/gimppaintoptions.h" #include "gimpanchor.h" +#include "gimppath.h" #include "gimpstroke.h" -#include "gimpvectors.h" #include "gimpvectors-preview.h" #include "gimp-intl.h" @@ -137,65 +137,65 @@ static void gimp_vectors_to_selection (GimpItem *item, gdouble feather_radius_x, gdouble feather_radius_y); -static void gimp_vectors_real_freeze (GimpVectors *vectors); -static void gimp_vectors_real_thaw (GimpVectors *vectors); -static void gimp_vectors_real_stroke_add (GimpVectors *vectors, +static void gimp_vectors_real_freeze (GimpPath *vectors); +static void gimp_vectors_real_thaw (GimpPath *vectors); +static void gimp_vectors_real_stroke_add (GimpPath *vectors, GimpStroke *stroke); -static void gimp_vectors_real_stroke_remove (GimpVectors *vectors, +static void gimp_vectors_real_stroke_remove (GimpPath *vectors, GimpStroke *stroke); -static GimpStroke * gimp_vectors_real_stroke_get (GimpVectors *vectors, +static GimpStroke * gimp_vectors_real_stroke_get (GimpPath *vectors, const GimpCoords *coord); -static GimpStroke *gimp_vectors_real_stroke_get_next(GimpVectors *vectors, +static GimpStroke *gimp_vectors_real_stroke_get_next(GimpPath *vectors, GimpStroke *prev); -static gdouble gimp_vectors_real_stroke_get_length (GimpVectors *vectors, +static gdouble gimp_vectors_real_stroke_get_length (GimpPath *vectors, GimpStroke *prev); -static GimpAnchor * gimp_vectors_real_anchor_get (GimpVectors *vectors, +static GimpAnchor * gimp_vectors_real_anchor_get (GimpPath *vectors, const GimpCoords *coord, GimpStroke **ret_stroke); -static void gimp_vectors_real_anchor_delete (GimpVectors *vectors, +static void gimp_vectors_real_anchor_delete (GimpPath *vectors, GimpAnchor *anchor); -static gdouble gimp_vectors_real_get_length (GimpVectors *vectors, +static gdouble gimp_vectors_real_get_length (GimpPath *vectors, const GimpAnchor *start); -static gdouble gimp_vectors_real_get_distance (GimpVectors *vectors, +static gdouble gimp_vectors_real_get_distance (GimpPath *vectors, const GimpCoords *coord); -static gint gimp_vectors_real_interpolate (GimpVectors *vectors, +static gint gimp_vectors_real_interpolate (GimpPath *vectors, GimpStroke *stroke, gdouble precision, gint max_points, GimpCoords *ret_coords); -static GimpBezierDesc * gimp_vectors_make_bezier (GimpVectors *vectors); -static GimpBezierDesc * gimp_vectors_real_make_bezier (GimpVectors *vectors); +static GimpBezierDesc * gimp_vectors_make_bezier (GimpPath *vectors); +static GimpBezierDesc * gimp_vectors_real_make_bezier (GimpPath *vectors); -G_DEFINE_TYPE (GimpVectors, gimp_vectors, GIMP_TYPE_ITEM) +G_DEFINE_TYPE (GimpPath, gimp_path, GIMP_TYPE_ITEM) -#define parent_class gimp_vectors_parent_class +#define parent_class gimp_path_parent_class -static guint gimp_vectors_signals[LAST_SIGNAL] = { 0 }; +static guint gimp_path_signals[LAST_SIGNAL] = { 0 }; static void -gimp_vectors_class_init (GimpVectorsClass *klass) +gimp_path_class_init (GimpPathClass *klass) { GObjectClass *object_class = G_OBJECT_CLASS (klass); GimpObjectClass *gimp_object_class = GIMP_OBJECT_CLASS (klass); GimpViewableClass *viewable_class = GIMP_VIEWABLE_CLASS (klass); GimpItemClass *item_class = GIMP_ITEM_CLASS (klass); - gimp_vectors_signals[FREEZE] = + gimp_path_signals[FREEZE] = g_signal_new ("freeze", G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST, - G_STRUCT_OFFSET (GimpVectorsClass, freeze), + G_STRUCT_OFFSET (GimpPathClass, freeze), NULL, NULL, NULL, G_TYPE_NONE, 0); - gimp_vectors_signals[THAW] = + gimp_path_signals[THAW] = g_signal_new ("thaw", G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_FIRST, - G_STRUCT_OFFSET (GimpVectorsClass, thaw), + G_STRUCT_OFFSET (GimpPathClass, thaw), NULL, NULL, NULL, G_TYPE_NONE, 0); @@ -260,24 +260,24 @@ gimp_vectors_class_init (GimpVectorsClass *klass) } static void -gimp_vectors_init (GimpVectors *vectors) +gimp_path_init (GimpPath *path) { - gimp_item_set_visible (GIMP_ITEM (vectors), FALSE, FALSE); + gimp_item_set_visible (GIMP_ITEM (path), FALSE, FALSE); - vectors->strokes = g_queue_new (); - vectors->stroke_to_list = g_hash_table_new (g_direct_hash, g_direct_equal); - vectors->last_stroke_id = 0; - vectors->freeze_count = 0; - vectors->precision = 0.2; + path->strokes = g_queue_new (); + path->stroke_to_list = g_hash_table_new (g_direct_hash, g_direct_equal); + path->last_stroke_id = 0; + path->freeze_count = 0; + path->precision = 0.2; - vectors->bezier_desc = NULL; - vectors->bounds_valid = FALSE; + path->bezier_desc = NULL; + path->bounds_valid = FALSE; } static void gimp_vectors_finalize (GObject *object) { - GimpVectors *vectors = GIMP_VECTORS (object); + GimpPath *vectors = GIMP_PATH (object); if (vectors->bezier_desc) { @@ -304,11 +304,11 @@ static gint64 gimp_vectors_get_memsize (GimpObject *object, gint64 *gui_size) { - GimpVectors *vectors; + GimpPath *vectors; GList *list; gint64 memsize = 0; - vectors = GIMP_VECTORS (object); + vectors = GIMP_PATH (object); for (list = vectors->strokes->head; list; list = g_list_next (list)) memsize += (gimp_object_get_memsize (GIMP_OBJECT (list->data), gui_size) + @@ -348,7 +348,7 @@ gimp_vectors_bounds (GimpItem *item, gdouble *width, gdouble *height) { - GimpVectors *vectors = GIMP_VECTORS (item); + GimpPath *vectors = GIMP_PATH (item); if (! vectors->bounds_valid) { @@ -413,14 +413,14 @@ gimp_vectors_duplicate (GimpItem *item, { GimpItem *new_item; - g_return_val_if_fail (g_type_is_a (new_type, GIMP_TYPE_VECTORS), NULL); + g_return_val_if_fail (g_type_is_a (new_type, GIMP_TYPE_PATH), NULL); new_item = GIMP_ITEM_CLASS (parent_class)->duplicate (item, new_type); - if (GIMP_IS_VECTORS (new_item)) + if (GIMP_IS_PATH (new_item)) { - GimpVectors *vectors = GIMP_VECTORS (item); - GimpVectors *new_vectors = GIMP_VECTORS (new_item); + GimpPath *vectors = GIMP_PATH (item); + GimpPath *new_vectors = GIMP_PATH (new_item); gimp_vectors_copy_strokes (vectors, new_vectors); } @@ -446,8 +446,8 @@ gimp_vectors_translate (GimpItem *item, gdouble offset_y, gboolean push_undo) { - GimpVectors *path = GIMP_VECTORS (item); - GList *list; + GimpPath *path = GIMP_PATH (item); + GList *list; gimp_vectors_freeze (path); @@ -475,9 +475,9 @@ gimp_vectors_scale (GimpItem *item, GimpInterpolationType interpolation_type, GimpProgress *progress) { - GimpVectors *path = GIMP_VECTORS (item); - GimpImage *image = gimp_item_get_image (item); - GList *list; + GimpPath *path = GIMP_PATH (item); + GimpImage *image = gimp_item_get_image (item); + GList *list; gimp_vectors_freeze (path); @@ -512,9 +512,9 @@ gimp_vectors_resize (GimpItem *item, gint offset_x, gint offset_y) { - GimpVectors *path = GIMP_VECTORS (item); - GimpImage *image = gimp_item_get_image (item); - GList *list; + GimpPath *path = GIMP_PATH (item); + GimpImage *image = gimp_item_get_image (item); + GList *list; gimp_vectors_freeze (path); @@ -543,7 +543,7 @@ gimp_vectors_flip (GimpItem *item, gdouble axis, gboolean clip_result) { - GimpVectors *path = GIMP_VECTORS (item); + GimpPath *path = GIMP_PATH (item); GList *list; GimpMatrix3 matrix; @@ -574,7 +574,7 @@ gimp_vectors_rotate (GimpItem *item, gdouble center_y, gboolean clip_result) { - GimpVectors *path = GIMP_VECTORS (item); + GimpPath *path = GIMP_PATH (item); GList *list; GimpMatrix3 matrix; @@ -606,7 +606,7 @@ gimp_vectors_transform (GimpItem *item, GimpTransformResize clip_result, GimpProgress *progress) { - GimpVectors *path = GIMP_VECTORS (item); + GimpPath *path = GIMP_PATH (item); GimpMatrix3 local_matrix; GQueue strokes; GList *list; @@ -668,7 +668,7 @@ gimp_vectors_fill (GimpItem *item, GimpProgress *progress, GError **error) { - GimpVectors *vectors = GIMP_VECTORS (item); + GimpPath *vectors = GIMP_PATH (item); if (g_queue_is_empty (vectors->strokes)) { @@ -689,7 +689,7 @@ gimp_vectors_stroke (GimpItem *item, GimpProgress *progress, GError **error) { - GimpVectors *vectors = GIMP_VECTORS (item); + GimpPath *vectors = GIMP_PATH (item); gboolean retval = FALSE; if (g_queue_is_empty (vectors->strokes)) @@ -744,7 +744,7 @@ gimp_vectors_to_selection (GimpItem *item, gdouble feather_radius_x, gdouble feather_radius_y) { - GimpVectors *path = GIMP_VECTORS (item); + GimpPath *path = GIMP_PATH (item); GimpImage *image = gimp_item_get_image (item); gimp_channel_select_vectors (gimp_image_get_mask (image), @@ -756,7 +756,7 @@ gimp_vectors_to_selection (GimpItem *item, } static void -gimp_vectors_real_freeze (GimpVectors *vectors) +gimp_vectors_real_freeze (GimpPath *vectors) { /* release cached bezier representation */ if (vectors->bezier_desc) @@ -770,7 +770,7 @@ gimp_vectors_real_freeze (GimpVectors *vectors) } static void -gimp_vectors_real_thaw (GimpVectors *vectors) +gimp_vectors_real_thaw (GimpPath *vectors) { gimp_viewable_invalidate_preview (GIMP_VIEWABLE (vectors)); } @@ -778,60 +778,60 @@ gimp_vectors_real_thaw (GimpVectors *vectors) /* public functions */ -GimpVectors * +GimpPath * gimp_vectors_new (GimpImage *image, const gchar *name) { - GimpVectors *vectors; + GimpPath *vectors; g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL); - vectors = GIMP_VECTORS (gimp_item_new (GIMP_TYPE_VECTORS, - image, name, - 0, 0, - gimp_image_get_width (image), - gimp_image_get_height (image))); + vectors = GIMP_PATH (gimp_item_new (GIMP_TYPE_PATH, + image, name, + 0, 0, + gimp_image_get_width (image), + gimp_image_get_height (image))); return vectors; } -GimpVectors * -gimp_vectors_get_parent (GimpVectors *vectors) +GimpPath * +gimp_vectors_get_parent (GimpPath *vectors) { - g_return_val_if_fail (GIMP_IS_VECTORS (vectors), NULL); + g_return_val_if_fail (GIMP_IS_PATH (vectors), NULL); - return GIMP_VECTORS (gimp_viewable_get_parent (GIMP_VIEWABLE (vectors))); + return GIMP_PATH (gimp_viewable_get_parent (GIMP_VIEWABLE (vectors))); } void -gimp_vectors_freeze (GimpVectors *vectors) +gimp_vectors_freeze (GimpPath *vectors) { - g_return_if_fail (GIMP_IS_VECTORS (vectors)); + g_return_if_fail (GIMP_IS_PATH (vectors)); vectors->freeze_count++; if (vectors->freeze_count == 1) - g_signal_emit (vectors, gimp_vectors_signals[FREEZE], 0); + g_signal_emit (vectors, gimp_path_signals[FREEZE], 0); } void -gimp_vectors_thaw (GimpVectors *vectors) +gimp_vectors_thaw (GimpPath *vectors) { - g_return_if_fail (GIMP_IS_VECTORS (vectors)); + g_return_if_fail (GIMP_IS_PATH (vectors)); g_return_if_fail (vectors->freeze_count > 0); vectors->freeze_count--; if (vectors->freeze_count == 0) - g_signal_emit (vectors, gimp_vectors_signals[THAW], 0); + g_signal_emit (vectors, gimp_path_signals[THAW], 0); } void -gimp_vectors_copy_strokes (GimpVectors *src_vectors, - GimpVectors *dest_vectors) +gimp_vectors_copy_strokes (GimpPath *src_vectors, + GimpPath *dest_vectors) { - g_return_if_fail (GIMP_IS_VECTORS (src_vectors)); - g_return_if_fail (GIMP_IS_VECTORS (dest_vectors)); + g_return_if_fail (GIMP_IS_PATH (src_vectors)); + g_return_if_fail (GIMP_IS_PATH (dest_vectors)); gimp_vectors_freeze (dest_vectors); @@ -848,13 +848,13 @@ gimp_vectors_copy_strokes (GimpVectors *src_vectors, void -gimp_vectors_add_strokes (GimpVectors *src_vectors, - GimpVectors *dest_vectors) +gimp_vectors_add_strokes (GimpPath *src_vectors, + GimpPath *dest_vectors) { GList *stroke; - g_return_if_fail (GIMP_IS_VECTORS (src_vectors)); - g_return_if_fail (GIMP_IS_VECTORS (dest_vectors)); + g_return_if_fail (GIMP_IS_PATH (src_vectors)); + g_return_if_fail (GIMP_IS_PATH (dest_vectors)); gimp_vectors_freeze (dest_vectors); @@ -881,21 +881,21 @@ gimp_vectors_add_strokes (GimpVectors *src_vectors, void -gimp_vectors_stroke_add (GimpVectors *vectors, +gimp_vectors_stroke_add (GimpPath *vectors, GimpStroke *stroke) { - g_return_if_fail (GIMP_IS_VECTORS (vectors)); + g_return_if_fail (GIMP_IS_PATH (vectors)); g_return_if_fail (GIMP_IS_STROKE (stroke)); gimp_vectors_freeze (vectors); - GIMP_VECTORS_GET_CLASS (vectors)->stroke_add (vectors, stroke); + GIMP_PATH_GET_CLASS (vectors)->stroke_add (vectors, stroke); gimp_vectors_thaw (vectors); } static void -gimp_vectors_real_stroke_add (GimpVectors *vectors, +gimp_vectors_real_stroke_add (GimpPath *vectors, GimpStroke *stroke) { /* @@ -914,21 +914,21 @@ gimp_vectors_real_stroke_add (GimpVectors *vectors, } void -gimp_vectors_stroke_remove (GimpVectors *vectors, +gimp_vectors_stroke_remove (GimpPath *vectors, GimpStroke *stroke) { - g_return_if_fail (GIMP_IS_VECTORS (vectors)); + g_return_if_fail (GIMP_IS_PATH (vectors)); g_return_if_fail (GIMP_IS_STROKE (stroke)); gimp_vectors_freeze (vectors); - GIMP_VECTORS_GET_CLASS (vectors)->stroke_remove (vectors, stroke); + GIMP_PATH_GET_CLASS (vectors)->stroke_remove (vectors, stroke); gimp_vectors_thaw (vectors); } static void -gimp_vectors_real_stroke_remove (GimpVectors *vectors, +gimp_vectors_real_stroke_remove (GimpPath *vectors, GimpStroke *stroke) { GList *list = g_hash_table_lookup (vectors->stroke_to_list, stroke); @@ -942,25 +942,25 @@ gimp_vectors_real_stroke_remove (GimpVectors *vectors, } gint -gimp_vectors_get_n_strokes (GimpVectors *vectors) +gimp_vectors_get_n_strokes (GimpPath *vectors) { - g_return_val_if_fail (GIMP_IS_VECTORS (vectors), 0); + g_return_val_if_fail (GIMP_IS_PATH (vectors), 0); return g_queue_get_length (vectors->strokes); } GimpStroke * -gimp_vectors_stroke_get (GimpVectors *vectors, +gimp_vectors_stroke_get (GimpPath *vectors, const GimpCoords *coord) { - g_return_val_if_fail (GIMP_IS_VECTORS (vectors), NULL); + g_return_val_if_fail (GIMP_IS_PATH (vectors), NULL); - return GIMP_VECTORS_GET_CLASS (vectors)->stroke_get (vectors, coord); + return GIMP_PATH_GET_CLASS (vectors)->stroke_get (vectors, coord); } static GimpStroke * -gimp_vectors_real_stroke_get (GimpVectors *vectors, +gimp_vectors_real_stroke_get (GimpPath *vectors, const GimpCoords *coord) { GimpStroke *minstroke = NULL; @@ -989,12 +989,12 @@ gimp_vectors_real_stroke_get (GimpVectors *vectors, } GimpStroke * -gimp_vectors_stroke_get_by_id (GimpVectors *vectors, - gint id) +gimp_vectors_stroke_get_by_id (GimpPath *vectors, + gint id) { GList *list; - g_return_val_if_fail (GIMP_IS_VECTORS (vectors), NULL); + g_return_val_if_fail (GIMP_IS_PATH (vectors), NULL); for (list = vectors->strokes->head; list; list = g_list_next (list)) { @@ -1007,16 +1007,16 @@ gimp_vectors_stroke_get_by_id (GimpVectors *vectors, GimpStroke * -gimp_vectors_stroke_get_next (GimpVectors *vectors, +gimp_vectors_stroke_get_next (GimpPath *vectors, GimpStroke *prev) { - g_return_val_if_fail (GIMP_IS_VECTORS (vectors), NULL); + g_return_val_if_fail (GIMP_IS_PATH (vectors), NULL); - return GIMP_VECTORS_GET_CLASS (vectors)->stroke_get_next (vectors, prev); + return GIMP_PATH_GET_CLASS (vectors)->stroke_get_next (vectors, prev); } static GimpStroke * -gimp_vectors_real_stroke_get_next (GimpVectors *vectors, +gimp_vectors_real_stroke_get_next (GimpPath *vectors, GimpStroke *prev) { if (! prev) @@ -1035,20 +1035,20 @@ gimp_vectors_real_stroke_get_next (GimpVectors *vectors, gdouble -gimp_vectors_stroke_get_length (GimpVectors *vectors, +gimp_vectors_stroke_get_length (GimpPath *vectors, GimpStroke *stroke) { - g_return_val_if_fail (GIMP_IS_VECTORS (vectors), 0.0); + g_return_val_if_fail (GIMP_IS_PATH (vectors), 0.0); g_return_val_if_fail (GIMP_IS_STROKE (stroke), 0.0); - return GIMP_VECTORS_GET_CLASS (vectors)->stroke_get_length (vectors, stroke); + return GIMP_PATH_GET_CLASS (vectors)->stroke_get_length (vectors, stroke); } static gdouble -gimp_vectors_real_stroke_get_length (GimpVectors *vectors, +gimp_vectors_real_stroke_get_length (GimpPath *vectors, GimpStroke *stroke) { - g_return_val_if_fail (GIMP_IS_VECTORS (vectors), 0.0); + g_return_val_if_fail (GIMP_IS_PATH (vectors), 0.0); g_return_val_if_fail (GIMP_IS_STROKE (stroke), 0.0); return gimp_stroke_get_length (stroke, vectors->precision); @@ -1056,18 +1056,18 @@ gimp_vectors_real_stroke_get_length (GimpVectors *vectors, GimpAnchor * -gimp_vectors_anchor_get (GimpVectors *vectors, +gimp_vectors_anchor_get (GimpPath *vectors, const GimpCoords *coord, GimpStroke **ret_stroke) { - g_return_val_if_fail (GIMP_IS_VECTORS (vectors), NULL); + g_return_val_if_fail (GIMP_IS_PATH (vectors), NULL); - return GIMP_VECTORS_GET_CLASS (vectors)->anchor_get (vectors, coord, - ret_stroke); + return GIMP_PATH_GET_CLASS (vectors)->anchor_get (vectors, coord, + ret_stroke); } static GimpAnchor * -gimp_vectors_real_anchor_get (GimpVectors *vectors, +gimp_vectors_real_anchor_get (GimpPath *vectors, const GimpCoords *coord, GimpStroke **ret_stroke) { @@ -1101,24 +1101,24 @@ gimp_vectors_real_anchor_get (GimpVectors *vectors, void -gimp_vectors_anchor_delete (GimpVectors *vectors, +gimp_vectors_anchor_delete (GimpPath *vectors, GimpAnchor *anchor) { - g_return_if_fail (GIMP_IS_VECTORS (vectors)); + g_return_if_fail (GIMP_IS_PATH (vectors)); g_return_if_fail (anchor != NULL); - GIMP_VECTORS_GET_CLASS (vectors)->anchor_delete (vectors, anchor); + GIMP_PATH_GET_CLASS (vectors)->anchor_delete (vectors, anchor); } static void -gimp_vectors_real_anchor_delete (GimpVectors *vectors, +gimp_vectors_real_anchor_delete (GimpPath *vectors, GimpAnchor *anchor) { } void -gimp_vectors_anchor_select (GimpVectors *vectors, +gimp_vectors_anchor_select (GimpPath *vectors, GimpStroke *target_stroke, GimpAnchor *anchor, gboolean selected, @@ -1138,16 +1138,16 @@ gimp_vectors_anchor_select (GimpVectors *vectors, gdouble -gimp_vectors_get_length (GimpVectors *vectors, +gimp_vectors_get_length (GimpPath *vectors, const GimpAnchor *start) { - g_return_val_if_fail (GIMP_IS_VECTORS (vectors), 0.0); + g_return_val_if_fail (GIMP_IS_PATH (vectors), 0.0); - return GIMP_VECTORS_GET_CLASS (vectors)->get_length (vectors, start); + return GIMP_PATH_GET_CLASS (vectors)->get_length (vectors, start); } static gdouble -gimp_vectors_real_get_length (GimpVectors *vectors, +gimp_vectors_real_get_length (GimpPath *vectors, const GimpAnchor *start) { g_printerr ("gimp_vectors_get_length: default implementation\n"); @@ -1157,16 +1157,16 @@ gimp_vectors_real_get_length (GimpVectors *vectors, gdouble -gimp_vectors_get_distance (GimpVectors *vectors, +gimp_vectors_get_distance (GimpPath *vectors, const GimpCoords *coord) { - g_return_val_if_fail (GIMP_IS_VECTORS (vectors), 0.0); + g_return_val_if_fail (GIMP_IS_PATH (vectors), 0.0); - return GIMP_VECTORS_GET_CLASS (vectors)->get_distance (vectors, coord); + return GIMP_PATH_GET_CLASS (vectors)->get_distance (vectors, coord); } static gdouble -gimp_vectors_real_get_distance (GimpVectors *vectors, +gimp_vectors_real_get_distance (GimpPath *vectors, const GimpCoords *coord) { g_printerr ("gimp_vectors_get_distance: default implementation\n"); @@ -1175,21 +1175,21 @@ gimp_vectors_real_get_distance (GimpVectors *vectors, } gint -gimp_vectors_interpolate (GimpVectors *vectors, +gimp_vectors_interpolate (GimpPath *vectors, GimpStroke *stroke, gdouble precision, gint max_points, GimpCoords *ret_coords) { - g_return_val_if_fail (GIMP_IS_VECTORS (vectors), 0); + g_return_val_if_fail (GIMP_IS_PATH (vectors), 0); - return GIMP_VECTORS_GET_CLASS (vectors)->interpolate (vectors, stroke, - precision, max_points, - ret_coords); + return GIMP_PATH_GET_CLASS (vectors)->interpolate (vectors, stroke, + precision, max_points, + ret_coords); } static gint -gimp_vectors_real_interpolate (GimpVectors *vectors, +gimp_vectors_real_interpolate (GimpPath *vectors, GimpStroke *stroke, gdouble precision, gint max_points, @@ -1201,9 +1201,9 @@ gimp_vectors_real_interpolate (GimpVectors *vectors, } const GimpBezierDesc * -gimp_vectors_get_bezier (GimpVectors *vectors) +gimp_vectors_get_bezier (GimpPath *vectors) { - g_return_val_if_fail (GIMP_IS_VECTORS (vectors), NULL); + g_return_val_if_fail (GIMP_IS_PATH (vectors), NULL); if (! vectors->bezier_desc) { @@ -1214,13 +1214,13 @@ gimp_vectors_get_bezier (GimpVectors *vectors) } static GimpBezierDesc * -gimp_vectors_make_bezier (GimpVectors *vectors) +gimp_vectors_make_bezier (GimpPath *vectors) { - return GIMP_VECTORS_GET_CLASS (vectors)->make_bezier (vectors); + return GIMP_PATH_GET_CLASS (vectors)->make_bezier (vectors); } static GimpBezierDesc * -gimp_vectors_real_make_bezier (GimpVectors *vectors) +gimp_vectors_real_make_bezier (GimpPath *vectors) { GimpStroke *stroke; GArray *cmd_array; diff --git a/app/vectors/gimpvectors.h b/app/vectors/gimppath.h similarity index 57% rename from app/vectors/gimpvectors.h rename to app/vectors/gimppath.h index bafa0505cd..cafea618ee 100644 --- a/app/vectors/gimpvectors.h +++ b/app/vectors/gimppath.h @@ -1,7 +1,7 @@ /* GIMP - The GNU Image Manipulation Program * Copyright (C) 1995 Spencer Kimball and Peter Mattis * - * gimpvectors.h + * gimppath.h * Copyright (C) 2002 Simon Budig * * This program is free software: you can redistribute it and/or modify @@ -18,22 +18,22 @@ * along with this program. If not, see . */ -#ifndef __GIMP_VECTORS_H__ -#define __GIMP_VECTORS_H__ +#ifndef __GIMP_PATH_H__ +#define __GIMP_PATH_H__ #include "core/gimpitem.h" -#define GIMP_TYPE_VECTORS (gimp_vectors_get_type ()) -#define GIMP_VECTORS(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_VECTORS, GimpVectors)) -#define GIMP_VECTORS_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_VECTORS, GimpVectorsClass)) -#define GIMP_IS_VECTORS(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GIMP_TYPE_VECTORS)) -#define GIMP_IS_VECTORS_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_VECTORS)) -#define GIMP_VECTORS_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GIMP_TYPE_VECTORS, GimpVectorsClass)) +#define GIMP_TYPE_PATH (gimp_path_get_type ()) +#define GIMP_PATH(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_PATH, GimpPath)) +#define GIMP_PATH_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_PATH, GimpPathClass)) +#define GIMP_IS_PATH(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GIMP_TYPE_PATH)) +#define GIMP_IS_PATH_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_PATH)) +#define GIMP_PATH_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GIMP_TYPE_PATH, GimpPathClass)) -typedef struct _GimpVectorsClass GimpVectorsClass; +typedef struct _GimpPathClass GimpPathClass; -struct _GimpVectors +struct _GimpPath { GimpItem parent_instance; @@ -54,122 +54,122 @@ struct _GimpVectors gdouble bounds_y2; }; -struct _GimpVectorsClass +struct _GimpPathClass { GimpItemClass parent_class; /* signals */ - void (* freeze) (GimpVectors *vectors); - void (* thaw) (GimpVectors *vectors); + void (* freeze) (GimpPath *path); + void (* thaw) (GimpPath *path); /* virtual functions */ - void (* stroke_add) (GimpVectors *vectors, + void (* stroke_add) (GimpPath *path, GimpStroke *stroke); - void (* stroke_remove) (GimpVectors *vectors, + void (* stroke_remove) (GimpPath *path, GimpStroke *stroke); - GimpStroke * (* stroke_get) (GimpVectors *vectors, + GimpStroke * (* stroke_get) (GimpPath *path, const GimpCoords *coord); - GimpStroke * (* stroke_get_next) (GimpVectors *vectors, + GimpStroke * (* stroke_get_next) (GimpPath *path, GimpStroke *prev); - gdouble (* stroke_get_length) (GimpVectors *vectors, + gdouble (* stroke_get_length) (GimpPath *path, GimpStroke *stroke); - GimpAnchor * (* anchor_get) (GimpVectors *vectors, + GimpAnchor * (* anchor_get) (GimpPath *path, const GimpCoords *coord, GimpStroke **ret_stroke); - void (* anchor_delete) (GimpVectors *vectors, + void (* anchor_delete) (GimpPath *path, GimpAnchor *anchor); - gdouble (* get_length) (GimpVectors *vectors, + gdouble (* get_length) (GimpPath *path, const GimpAnchor *start); - gdouble (* get_distance) (GimpVectors *vectors, + gdouble (* get_distance) (GimpPath *path, const GimpCoords *coord); - gint (* interpolate) (GimpVectors *vectors, + gint (* interpolate) (GimpPath *path, GimpStroke *stroke, gdouble precision, gint max_points, GimpCoords *ret_coords); - GimpBezierDesc * (* make_bezier) (GimpVectors *vectors); + GimpBezierDesc * (* make_bezier) (GimpPath *path); }; -/* vectors utility functions */ +/* path utility functions */ -GType gimp_vectors_get_type (void) G_GNUC_CONST; +GType gimp_path_get_type (void) G_GNUC_CONST; -GimpVectors * gimp_vectors_new (GimpImage *image, - const gchar *name); +GimpPath * gimp_vectors_new (GimpImage *image, + const gchar *name); -GimpVectors * gimp_vectors_get_parent (GimpVectors *vectors); +GimpPath * gimp_vectors_get_parent (GimpPath *path); -void gimp_vectors_freeze (GimpVectors *vectors); -void gimp_vectors_thaw (GimpVectors *vectors); +void gimp_vectors_freeze (GimpPath *path); +void gimp_vectors_thaw (GimpPath *path); -void gimp_vectors_copy_strokes (GimpVectors *src_vectors, - GimpVectors *dest_vectors); -void gimp_vectors_add_strokes (GimpVectors *src_vectors, - GimpVectors *dest_vectors); +void gimp_vectors_copy_strokes (GimpPath *src_vectors, + GimpPath *dest_vectors); +void gimp_vectors_add_strokes (GimpPath *src_vectors, + GimpPath *dest_vectors); /* accessing / modifying the anchors */ -GimpAnchor * gimp_vectors_anchor_get (GimpVectors *vectors, +GimpAnchor * gimp_vectors_anchor_get (GimpPath *path, const GimpCoords *coord, GimpStroke **ret_stroke); /* prev == NULL: "first" anchor */ -GimpAnchor * gimp_vectors_anchor_get_next (GimpVectors *vectors, +GimpAnchor * gimp_vectors_anchor_get_next (GimpPath *path, const GimpAnchor *prev); /* type will be an xorable enum: * VECTORS_NONE, VECTORS_FIX_ANGLE, VECTORS_FIX_RATIO, VECTORS_RESTRICT_ANGLE * or so. */ -void gimp_vectors_anchor_move_relative (GimpVectors *vectors, +void gimp_vectors_anchor_move_relative (GimpPath *path, GimpAnchor *anchor, const GimpCoords *deltacoord, gint type); -void gimp_vectors_anchor_move_absolute (GimpVectors *vectors, +void gimp_vectors_anchor_move_absolute (GimpPath *path, GimpAnchor *anchor, const GimpCoords *coord, gint type); -void gimp_vectors_anchor_delete (GimpVectors *vectors, +void gimp_vectors_anchor_delete (GimpPath *path, GimpAnchor *anchor); -void gimp_vectors_anchor_select (GimpVectors *vectors, +void gimp_vectors_anchor_select (GimpPath *path, GimpStroke *target_stroke, GimpAnchor *anchor, gboolean selected, gboolean exclusive); -/* GimpStroke is a connected component of a GimpVectors object */ +/* GimpStroke is a connected component of a GimpPath object */ -void gimp_vectors_stroke_add (GimpVectors *vectors, +void gimp_vectors_stroke_add (GimpPath *path, GimpStroke *stroke); -void gimp_vectors_stroke_remove (GimpVectors *vectors, +void gimp_vectors_stroke_remove (GimpPath *path, GimpStroke *stroke); -gint gimp_vectors_get_n_strokes (GimpVectors *vectors); -GimpStroke * gimp_vectors_stroke_get (GimpVectors *vectors, +gint gimp_vectors_get_n_strokes (GimpPath *path); +GimpStroke * gimp_vectors_stroke_get (GimpPath *path, const GimpCoords *coord); -GimpStroke * gimp_vectors_stroke_get_by_id (GimpVectors *vectors, +GimpStroke * gimp_vectors_stroke_get_by_id (GimpPath *path, gint id); /* prev == NULL: "first" stroke */ -GimpStroke * gimp_vectors_stroke_get_next (GimpVectors *vectors, +GimpStroke * gimp_vectors_stroke_get_next (GimpPath *path, GimpStroke *prev); -gdouble gimp_vectors_stroke_get_length (GimpVectors *vectors, +gdouble gimp_vectors_stroke_get_length (GimpPath *path, GimpStroke *stroke); /* accessing the shape of the curve */ -gdouble gimp_vectors_get_length (GimpVectors *vectors, +gdouble gimp_vectors_get_length (GimpPath *path, const GimpAnchor *start); -gdouble gimp_vectors_get_distance (GimpVectors *vectors, +gdouble gimp_vectors_get_distance (GimpPath *path, const GimpCoords *coord); /* returns the number of valid coordinates */ -gint gimp_vectors_interpolate (GimpVectors *vectors, +gint gimp_vectors_interpolate (GimpPath *path, GimpStroke *stroke, gdouble precision, gint max_points, @@ -178,7 +178,7 @@ gint gimp_vectors_interpolate (GimpVectors *vectors, /* usually overloaded */ /* returns a bezier representation */ -const GimpBezierDesc * gimp_vectors_get_bezier (GimpVectors *vectors); +const GimpBezierDesc * gimp_vectors_get_bezier (GimpPath *path); #endif /* __GIMP_VECTORS_H__ */ diff --git a/app/vectors/gimpvectors-compat.c b/app/vectors/gimpvectors-compat.c index 15fdf4e7d2..f78b9ec245 100644 --- a/app/vectors/gimpvectors-compat.c +++ b/app/vectors/gimpvectors-compat.c @@ -29,7 +29,7 @@ #include "gimpanchor.h" #include "gimpbezierstroke.h" -#include "gimpvectors.h" +#include "gimppath.h" #include "gimpvectors-compat.h" @@ -44,14 +44,14 @@ enum static const GimpCoords default_coords = GIMP_COORDS_DEFAULT_VALUES; -GimpVectors * +GimpPath * gimp_vectors_compat_new (GimpImage *image, const gchar *name, GimpVectorsCompatPoint *points, gint n_points, gboolean closed) { - GimpVectors *vectors; + GimpPath *vectors; GimpStroke *stroke; GimpCoords *coords; GimpCoords *curr_stroke; @@ -135,7 +135,7 @@ gimp_vectors_compat_is_compatible (GimpImage *image) list; list = g_list_next (list)) { - GimpVectors *vectors = GIMP_VECTORS (list->data); + GimpPath *vectors = GIMP_PATH (list->data); GList *strokes; gint open_count = 0; @@ -163,9 +163,9 @@ gimp_vectors_compat_is_compatible (GimpImage *image) } GimpVectorsCompatPoint * -gimp_vectors_compat_get_points (GimpVectors *vectors, - gint32 *n_points, - gint32 *closed) +gimp_vectors_compat_get_points (GimpPath *vectors, + gint32 *n_points, + gint32 *closed) { GimpVectorsCompatPoint *points; GList *strokes; @@ -174,7 +174,7 @@ gimp_vectors_compat_get_points (GimpVectors *vectors, gint open_count; gboolean first_stroke = TRUE; - g_return_val_if_fail (GIMP_IS_VECTORS (vectors), NULL); + g_return_val_if_fail (GIMP_IS_PATH (vectors), NULL); g_return_val_if_fail (n_points != NULL, NULL); g_return_val_if_fail (closed != NULL, NULL); diff --git a/app/vectors/gimpvectors-compat.h b/app/vectors/gimpvectors-compat.h index 561043a123..f14e6c38a5 100644 --- a/app/vectors/gimpvectors-compat.h +++ b/app/vectors/gimpvectors-compat.h @@ -32,7 +32,7 @@ struct _GimpVectorsCompatPoint }; -GimpVectors * gimp_vectors_compat_new (GimpImage *image, +GimpPath * gimp_vectors_compat_new (GimpImage *image, const gchar *name, GimpVectorsCompatPoint *points, gint n_points, @@ -40,7 +40,7 @@ GimpVectors * gimp_vectors_compat_new (GimpImage *image, gboolean gimp_vectors_compat_is_compatible (GimpImage *image); -GimpVectorsCompatPoint * gimp_vectors_compat_get_points (GimpVectors *vectors, +GimpVectorsCompatPoint * gimp_vectors_compat_get_points (GimpPath *vectors, gint32 *n_points, gint32 *closed); diff --git a/app/vectors/gimpvectors-export.c b/app/vectors/gimpvectors-export.c index 584fe6ed56..4b7d470f5f 100644 --- a/app/vectors/gimpvectors-export.c +++ b/app/vectors/gimpvectors-export.c @@ -28,9 +28,9 @@ #include "core/gimpitem.h" #include "gimpanchor.h" -#include "gimpstroke.h" #include "gimpbezierstroke.h" -#include "gimpvectors.h" +#include "gimppath.h" +#include "gimpstroke.h" #include "gimpvectors-export.h" #include "gimp-intl.h" @@ -40,15 +40,15 @@ static GString * gimp_vectors_export (GimpImage *image, GList *vectors); static void gimp_vectors_export_image_size (GimpImage *image, GString *str); -static void gimp_vectors_export_path (GimpVectors *vectors, +static void gimp_vectors_export_path (GimpPath *vectors, GString *str); -static gchar * gimp_vectors_export_path_data (GimpVectors *vectors); +static gchar * gimp_vectors_export_path_data (GimpPath *vectors); /** * gimp_vectors_export_file: * @image: the #GimpImage from which to export - * @path_list: a #GList of #GimpVectors objects or %NULL to export all paths in @image + * @path_list: a #GList of #GimpPath objects or %NULL to export all paths in @image * @file: the file to write * @error: return location for errors * @@ -115,7 +115,7 @@ gimp_vectors_export_file (GimpImage *image, /** * gimp_vectors_export_string: * @image: the #GimpImage from which to export - * @path_list: a #GList of #GimpVectors objects, or %NULL to export all paths in @image + * @path_list: a #GList of #GimpPath objects, or %NULL to export all paths in @image * * Exports one or more vectors aka path to a SVG string. * @@ -162,7 +162,7 @@ gimp_vectors_export (GimpImage *image, vectors = gimp_image_get_path_iter (image); for (list = vectors; list; list = list->next) - gimp_vectors_export_path (GIMP_VECTORS (list->data), str); + gimp_vectors_export_path (GIMP_PATH (list->data), str); g_string_append (str, "\n"); @@ -210,8 +210,8 @@ gimp_vectors_export_image_size (GimpImage *image, } static void -gimp_vectors_export_path (GimpVectors *vectors, - GString *str) +gimp_vectors_export_path (GimpPath *vectors, + GString *str) { const gchar *name = gimp_object_get_name (vectors); gchar *data = gimp_vectors_export_path_data (vectors); @@ -233,7 +233,7 @@ gimp_vectors_export_path (GimpVectors *vectors, #define NEWLINE "\n " static gchar * -gimp_vectors_export_path_data (GimpVectors *vectors) +gimp_vectors_export_path_data (GimpPath *vectors) { GString *str; GList *strokes; diff --git a/app/vectors/gimpvectors-import.c b/app/vectors/gimpvectors-import.c index 0b8064d76b..09ac4f3995 100644 --- a/app/vectors/gimpvectors-import.c +++ b/app/vectors/gimpvectors-import.c @@ -49,7 +49,7 @@ #include "gimpbezierstroke.h" #include "gimpstroke.h" -#include "gimpvectors.h" +#include "gimppath.h" #include "gimpvectors-import.h" #include "gimp-intl.h" @@ -111,7 +111,7 @@ static gboolean gimp_vectors_import (GimpImage *image, gsize len, gboolean merge, gboolean scale, - GimpVectors *parent, + GimpPath *parent, gint position, GList **ret_vectors, GError **error); @@ -199,7 +199,7 @@ static GList * parse_path_data (const gchar *data); * gimp_vectors_import_file: * @image: the #GimpImage to add the paths to * @file: a SVG file - * @merge: should multiple paths be merged into a single #GimpVectors object + * @merge: should multiple paths be merged into a single #GimpPath object * @scale: should the SVG be scaled to fit the image dimensions * @position: position in the image's vectors stack where to add the vectors * @error: location to store possible errors @@ -213,7 +213,7 @@ gimp_vectors_import_file (GimpImage *image, GFile *file, gboolean merge, gboolean scale, - GimpVectors *parent, + GimpPath *parent, gint position, GList **ret_vectors, GError **error) @@ -222,7 +222,7 @@ gimp_vectors_import_file (GimpImage *image, g_return_val_if_fail (G_IS_FILE (file), FALSE); g_return_val_if_fail (parent == NULL || parent == GIMP_IMAGE_ACTIVE_PARENT || - GIMP_IS_VECTORS (parent), FALSE); + GIMP_IS_PATH (parent), FALSE); g_return_val_if_fail (parent == NULL || parent == GIMP_IMAGE_ACTIVE_PARENT || gimp_item_is_attached (GIMP_ITEM (parent)), FALSE); @@ -247,7 +247,7 @@ gimp_vectors_import_file (GimpImage *image, * @image: the #GimpImage to add the paths to * @buffer: a character buffer to parse * @len: number of bytes in @str or -1 if @str is %NUL-terminated - * @merge: should multiple paths be merged into a single #GimpVectors object + * @merge: should multiple paths be merged into a single #GimpPath object * @scale: should the SVG be scaled to fit the image dimensions * @error: location to store possible errors * @@ -261,7 +261,7 @@ gimp_vectors_import_buffer (GimpImage *image, gsize len, gboolean merge, gboolean scale, - GimpVectors *parent, + GimpPath *parent, gint position, GList **ret_vectors, GError **error) @@ -270,7 +270,7 @@ gimp_vectors_import_buffer (GimpImage *image, g_return_val_if_fail (buffer != NULL || len == 0, FALSE); g_return_val_if_fail (parent == NULL || parent == GIMP_IMAGE_ACTIVE_PARENT || - GIMP_IS_VECTORS (parent), FALSE); + GIMP_IS_PATH (parent), FALSE); g_return_val_if_fail (parent == NULL || parent == GIMP_IMAGE_ACTIVE_PARENT || gimp_item_is_attached (GIMP_ITEM (parent)), FALSE); @@ -297,7 +297,7 @@ gimp_vectors_import (GimpImage *image, gsize len, gboolean merge, gboolean scale, - GimpVectors *parent, + GimpPath *parent, gint position, GList **ret_vectors, GError **error) @@ -334,7 +334,7 @@ gimp_vectors_import (GimpImage *image, { if (base->paths) { - GimpVectors *vectors = NULL; + GimpPath *vectors = NULL; base->paths = g_list_reverse (base->paths); diff --git a/app/vectors/gimpvectors-import.h b/app/vectors/gimpvectors-import.h index 1d7f8a6f82..1c66ae84b3 100644 --- a/app/vectors/gimpvectors-import.h +++ b/app/vectors/gimpvectors-import.h @@ -26,7 +26,7 @@ gboolean gimp_vectors_import_file (GimpImage *image, GFile *file, gboolean merge, gboolean scale, - GimpVectors *parent, + GimpPath *parent, gint position, GList **ret_vectors, GError **error); @@ -35,7 +35,7 @@ gboolean gimp_vectors_import_buffer (GimpImage *image, gsize len, gboolean merge, gboolean scale, - GimpVectors *parent, + GimpPath *parent, gint position, GList **ret_vectors, GError **error); diff --git a/app/vectors/gimpvectors-preview.c b/app/vectors/gimpvectors-preview.c index 988148a8a0..2320a51e51 100644 --- a/app/vectors/gimpvectors-preview.c +++ b/app/vectors/gimpvectors-preview.c @@ -29,8 +29,8 @@ #include "core/gimpimage.h" #include "core/gimptempbuf.h" +#include "gimppath.h" #include "gimpstroke.h" -#include "gimpvectors.h" #include "gimpvectors-preview.h" @@ -42,14 +42,14 @@ gimp_vectors_get_new_preview (GimpViewable *viewable, gint width, gint height) { - GimpVectors *vectors; + GimpPath *vectors; GimpItem *item; GimpStroke *cur_stroke; gdouble xscale, yscale; guchar *data; GimpTempBuf *temp_buf; - vectors = GIMP_VECTORS (viewable); + vectors = GIMP_PATH (viewable); item = GIMP_ITEM (viewable); xscale = ((gdouble) width) / gimp_image_get_width (gimp_item_get_image (item)); diff --git a/app/vectors/gimpvectors-warp.c b/app/vectors/gimpvectors-warp.c index aeb8decb0f..b9d003f26a 100644 --- a/app/vectors/gimpvectors-warp.c +++ b/app/vectors/gimpvectors-warp.c @@ -31,8 +31,8 @@ #include "core/gimpcoords.h" #include "gimpanchor.h" +#include "gimppath.h" #include "gimpstroke.h" -#include "gimpvectors.h" #include "gimpvectors-warp.h" @@ -47,16 +47,16 @@ static void gimp_stroke_warp_point (GimpStroke *stroke, gdouble y_offset, gdouble x_len); -static void gimp_vectors_warp_stroke (GimpVectors *vectors, +static void gimp_vectors_warp_stroke (GimpPath *vectors, GimpStroke *stroke, gdouble y_offset); void -gimp_vectors_warp_point (GimpVectors *vectors, - GimpCoords *point, - GimpCoords *point_warped, - gdouble y_offset) +gimp_vectors_warp_point (GimpPath *vectors, + GimpCoords *point, + GimpCoords *point_warped, + gdouble y_offset) { gdouble x = point->x; gdouble y = point->y; @@ -176,9 +176,9 @@ gimp_stroke_warp_point (GimpStroke *stroke, } static void -gimp_vectors_warp_stroke (GimpVectors *vectors, - GimpStroke *stroke, - gdouble y_offset) +gimp_vectors_warp_stroke (GimpPath *vectors, + GimpStroke *stroke, + gdouble y_offset) { GList *list; @@ -193,9 +193,9 @@ gimp_vectors_warp_stroke (GimpVectors *vectors, } void -gimp_vectors_warp_vectors (GimpVectors *vectors, - GimpVectors *vectors_in, - gdouble y_offset) +gimp_vectors_warp_vectors (GimpPath *vectors, + GimpPath *vectors_in, + gdouble y_offset) { GList *list; diff --git a/app/vectors/gimpvectors-warp.h b/app/vectors/gimpvectors-warp.h index 12b899326e..155c6addbc 100644 --- a/app/vectors/gimpvectors-warp.h +++ b/app/vectors/gimpvectors-warp.h @@ -22,14 +22,14 @@ #define __GIMP_VECTORS_WARP_H__ -void gimp_vectors_warp_point (GimpVectors *vectors, - GimpCoords *point, - GimpCoords *point_warped, - gdouble y_offset); +void gimp_vectors_warp_point (GimpPath *vectors, + GimpCoords *point, + GimpCoords *point_warped, + gdouble y_offset); -void gimp_vectors_warp_vectors (GimpVectors *vectors, - GimpVectors *vectors_in, - gdouble yoffset); +void gimp_vectors_warp_vectors (GimpPath *vectors, + GimpPath *vectors_in, + gdouble yoffset); #endif /* __GIMP_VECTORS_WARP_H__ */ diff --git a/app/vectors/gimpvectorsmodundo.c b/app/vectors/gimpvectorsmodundo.c index b681ba91a0..851a06b60a 100644 --- a/app/vectors/gimpvectorsmodundo.c +++ b/app/vectors/gimpvectorsmodundo.c @@ -22,7 +22,7 @@ #include "vectors-types.h" -#include "gimpvectors.h" +#include "gimppath.h" #include "gimpvectorsmodundo.h" @@ -67,17 +67,17 @@ static void gimp_vectors_mod_undo_constructed (GObject *object) { GimpVectorsModUndo *vectors_mod_undo = GIMP_VECTORS_MOD_UNDO (object); - GimpVectors *vectors; + GimpPath *vectors; G_OBJECT_CLASS (parent_class)->constructed (object); - gimp_assert (GIMP_IS_VECTORS (GIMP_ITEM_UNDO (object)->item)); + gimp_assert (GIMP_IS_PATH (GIMP_ITEM_UNDO (object)->item)); - vectors = GIMP_VECTORS (GIMP_ITEM_UNDO (object)->item); + vectors = GIMP_PATH (GIMP_ITEM_UNDO (object)->item); vectors_mod_undo->vectors = - GIMP_VECTORS (gimp_item_duplicate (GIMP_ITEM (vectors), - G_TYPE_FROM_INSTANCE (vectors))); + GIMP_PATH (gimp_item_duplicate (GIMP_ITEM (vectors), + G_TYPE_FROM_INSTANCE (vectors))); } static gint64 @@ -100,8 +100,8 @@ gimp_vectors_mod_undo_pop (GimpUndo *undo, GimpUndoAccumulator *accum) { GimpVectorsModUndo *vectors_mod_undo = GIMP_VECTORS_MOD_UNDO (undo); - GimpVectors *vectors = GIMP_VECTORS (GIMP_ITEM_UNDO (undo)->item); - GimpVectors *temp; + GimpPath *vectors = GIMP_PATH (GIMP_ITEM_UNDO (undo)->item); + GimpPath *temp; gint offset_x; gint offset_y; @@ -110,8 +110,8 @@ gimp_vectors_mod_undo_pop (GimpUndo *undo, temp = vectors_mod_undo->vectors; vectors_mod_undo->vectors = - GIMP_VECTORS (gimp_item_duplicate (GIMP_ITEM (vectors), - G_TYPE_FROM_INSTANCE (vectors))); + GIMP_PATH (gimp_item_duplicate (GIMP_ITEM (vectors), + G_TYPE_FROM_INSTANCE (vectors))); gimp_vectors_freeze (vectors); diff --git a/app/vectors/gimpvectorsmodundo.h b/app/vectors/gimpvectorsmodundo.h index e63a0efc51..16fe21df23 100644 --- a/app/vectors/gimpvectorsmodundo.h +++ b/app/vectors/gimpvectorsmodundo.h @@ -37,7 +37,7 @@ struct _GimpVectorsModUndo { GimpItemUndo parent_instance; - GimpVectors *vectors; + GimpPath *vectors; }; struct _GimpVectorsModUndoClass diff --git a/app/vectors/gimpvectorspropundo.c b/app/vectors/gimpvectorspropundo.c index 1a093df783..69527eb7f9 100644 --- a/app/vectors/gimpvectorspropundo.c +++ b/app/vectors/gimpvectorspropundo.c @@ -24,7 +24,7 @@ #include "core/gimpimage.h" -#include "gimpvectors.h" +#include "gimppath.h" #include "gimpvectorspropundo.h" @@ -63,9 +63,9 @@ gimp_vectors_prop_undo_constructed (GObject *object) G_OBJECT_CLASS (parent_class)->constructed (object); - gimp_assert (GIMP_IS_VECTORS (GIMP_ITEM_UNDO (object)->item)); + gimp_assert (GIMP_IS_PATH (GIMP_ITEM_UNDO (object)->item)); - /* vectors = GIMP_VECTORS (GIMP_ITEM_UNDO (object)->item); */ + /* vectors = GIMP_PATH (GIMP_ITEM_UNDO (object)->item); */ switch (GIMP_UNDO (object)->undo_type) { @@ -81,7 +81,7 @@ gimp_vectors_prop_undo_pop (GimpUndo *undo, { #if 0 GimpVectorsPropUndo *vectors_prop_undo = GIMP_VECTORS_PROP_UNDO (undo); - GimpVectors *vectors = GIMP_VECTORS (GIMP_ITEM_UNDO (undo)->item); + GimpPath *vectors = GIMP_PATH (GIMP_ITEM_UNDO (undo)->item); #endif GIMP_UNDO_CLASS (parent_class)->pop (undo, undo_mode, accum); diff --git a/app/vectors/gimpvectorsundo.c b/app/vectors/gimpvectorsundo.c index 789b1e9cc6..c42a1f6742 100644 --- a/app/vectors/gimpvectorsundo.c +++ b/app/vectors/gimpvectorsundo.c @@ -26,7 +26,7 @@ #include "core/gimpimage.h" -#include "gimpvectors.h" +#include "gimppath.h" #include "gimpvectorsundo.h" @@ -82,7 +82,7 @@ gimp_vectors_undo_class_init (GimpVectorsUndoClass *klass) g_object_class_install_property (object_class, PROP_PREV_PARENT, g_param_spec_object ("prev-parent", NULL, NULL, - GIMP_TYPE_VECTORS, + GIMP_TYPE_PATH, GIMP_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY)); @@ -109,7 +109,7 @@ gimp_vectors_undo_constructed (GObject *object) { G_OBJECT_CLASS (parent_class)->constructed (object); - gimp_assert (GIMP_IS_VECTORS (GIMP_ITEM_UNDO (object)->item)); + gimp_assert (GIMP_IS_PATH (GIMP_ITEM_UNDO (object)->item)); } static void @@ -195,7 +195,7 @@ gimp_vectors_undo_pop (GimpUndo *undo, GimpUndoAccumulator *accum) { GimpVectorsUndo *vectors_undo = GIMP_VECTORS_UNDO (undo); - GimpVectors *path = GIMP_VECTORS (GIMP_ITEM_UNDO (undo)->item); + GimpPath *path = GIMP_PATH (GIMP_ITEM_UNDO (undo)->item); GIMP_UNDO_CLASS (parent_class)->pop (undo, undo_mode, accum); diff --git a/app/vectors/gimpvectorsundo.h b/app/vectors/gimpvectorsundo.h index 3df54f2228..6113581892 100644 --- a/app/vectors/gimpvectorsundo.h +++ b/app/vectors/gimpvectorsundo.h @@ -37,7 +37,7 @@ struct _GimpVectorsUndo { GimpItemUndo parent_instance; - GimpVectors *prev_parent; + GimpPath *prev_parent; gint prev_position; /* former position in list */ GList *prev_vectors; /* previous selected vectors */ }; diff --git a/app/vectors/meson.build b/app/vectors/meson.build index 356d88bffb..05aa729eb8 100644 --- a/app/vectors/meson.build +++ b/app/vectors/meson.build @@ -1,6 +1,7 @@ libappvectors_sources = [ 'gimpanchor.c', 'gimpbezierstroke.c', + 'gimppath.c', 'gimpstroke-new.c', 'gimpstroke.c', 'gimpvectors-compat.c', @@ -8,7 +9,6 @@ libappvectors_sources = [ 'gimpvectors-import.c', 'gimpvectors-preview.c', 'gimpvectors-warp.c', - 'gimpvectors.c', 'gimpvectorsmodundo.c', 'gimpvectorspropundo.c', 'gimpvectorsundo.c', diff --git a/app/vectors/vectors-types.h b/app/vectors/vectors-types.h index 7c0d2d381a..37193a0055 100644 --- a/app/vectors/vectors-types.h +++ b/app/vectors/vectors-types.h @@ -29,7 +29,7 @@ typedef struct _GimpAnchor GimpAnchor; -typedef struct _GimpVectors GimpVectors; +typedef struct _GimpPath GimpPath; typedef struct _GimpStroke GimpStroke; typedef struct _GimpBezierStroke GimpBezierStroke; diff --git a/app/widgets/gimpdnd.c b/app/widgets/gimpdnd.c index 72de4abb9b..8187b6851e 100644 --- a/app/widgets/gimpdnd.c +++ b/app/widgets/gimpdnd.c @@ -47,7 +47,7 @@ #include "text/gimpfont.h" -#include "vectors/gimpvectors.h" +#include "vectors/gimppath.h" #include "gimpdnd.h" #include "gimpdnd-xds.h" @@ -476,7 +476,7 @@ static const GimpDndDataDef dnd_data_defs[] = }, { - GIMP_TARGET_VECTORS, + GIMP_TARGET_PATH, "gimp-dnd-get-vectors-func", "gimp-dnd-get-vectors-data", @@ -658,7 +658,7 @@ static const GimpDndDataDef dnd_data_defs[] = }, { - GIMP_TARGET_VECTORS_LIST, + GIMP_TARGET_PATH_LIST, "gimp-dnd-get-vectors-list-func", "gimp-dnd-get-vectors-list-data", @@ -1948,7 +1948,7 @@ gimp_dnd_data_type_get_by_g_type (GType type, { dnd_type = list ? GIMP_DND_TYPE_CHANNEL_LIST : GIMP_DND_TYPE_CHANNEL; } - else if (g_type_is_a (type, GIMP_TYPE_VECTORS)) + else if (g_type_is_a (type, GIMP_TYPE_PATH)) { dnd_type = list ? GIMP_DND_TYPE_VECTORS_LIST : GIMP_DND_TYPE_VECTORS; } diff --git a/app/widgets/gimpdnd.h b/app/widgets/gimpdnd.h index dca460cd61..d4735e2a99 100644 --- a/app/widgets/gimpdnd.h +++ b/app/widgets/gimpdnd.h @@ -61,7 +61,7 @@ #define GIMP_TARGET_LAYER_MASK \ { "application/x-gimp-layer-mask-id", GTK_TARGET_SAME_APP, GIMP_DND_TYPE_LAYER_MASK } -#define GIMP_TARGET_VECTORS \ +#define GIMP_TARGET_PATH \ { "application/x-gimp-vectors-id", GTK_TARGET_SAME_APP, GIMP_DND_TYPE_VECTORS } #define GIMP_TARGET_BRUSH \ @@ -100,7 +100,7 @@ #define GIMP_TARGET_CHANNEL_LIST \ { "application/x-gimp-channel-list", GTK_TARGET_SAME_APP, GIMP_DND_TYPE_CHANNEL_LIST } -#define GIMP_TARGET_VECTORS_LIST \ +#define GIMP_TARGET_PATH_LIST \ { "application/x-gimp-vectors-list", GTK_TARGET_SAME_APP, GIMP_DND_TYPE_VECTORS_LIST } /* dnd initialization */ diff --git a/app/widgets/gimpitemtreeview.c b/app/widgets/gimpitemtreeview.c index eb1a233dc4..eb813b6b48 100644 --- a/app/widgets/gimpitemtreeview.c +++ b/app/widgets/gimpitemtreeview.c @@ -56,7 +56,7 @@ #include "core/gimptreehandler.h" #include "core/gimpundostack.h" -#include "vectors/gimpvectors.h" +#include "vectors/gimppath.h" #include "gimpaction.h" #include "gimpcontainertreestore.h" diff --git a/app/widgets/gimpvectorstreeview.c b/app/widgets/gimpvectorstreeview.c index 911c580e0b..6f75e69ec0 100644 --- a/app/widgets/gimpvectorstreeview.c +++ b/app/widgets/gimpvectorstreeview.c @@ -34,7 +34,7 @@ #include "core/gimpcontext.h" #include "core/gimpimage.h" -#include "vectors/gimpvectors.h" +#include "vectors/gimppath.h" #include "vectors/gimpvectors-export.h" #include "vectors/gimpvectors-import.h" @@ -87,7 +87,7 @@ gimp_vectors_tree_view_class_init (GimpVectorsTreeViewClass *klass) view_class->drop_svg = gimp_vectors_tree_view_drop_svg; - iv_class->item_type = GIMP_TYPE_VECTORS; + iv_class->item_type = GIMP_TYPE_PATH; iv_class->signal_name = "selected-paths-changed"; iv_class->get_container = gimp_image_get_paths; @@ -156,7 +156,7 @@ gimp_vectors_tree_view_constructed (GObject *object) NULL); gimp_container_view_enable_dnd (GIMP_CONTAINER_VIEW (editor), GTK_BUTTON (view->toselection_button), - GIMP_TYPE_VECTORS); + GIMP_TYPE_PATH); gtk_box_reorder_child (gimp_editor_get_button_box (editor), view->toselection_button, 4); @@ -177,7 +177,7 @@ gimp_vectors_tree_view_constructed (GObject *object) NULL); gimp_container_view_enable_dnd (GIMP_CONTAINER_VIEW (editor), GTK_BUTTON (view->stroke_button), - GIMP_TYPE_VECTORS); + GIMP_TYPE_PATH); gtk_box_reorder_child (gimp_editor_get_button_box (editor), view->stroke_button, 6); @@ -217,7 +217,7 @@ gimp_vectors_tree_view_drop_svg (GimpContainerTreeView *tree_view, { GimpItemTreeView *item_view = GIMP_ITEM_TREE_VIEW (tree_view); GimpImage *image = gimp_item_tree_view_get_image (item_view); - GimpVectors *parent; + GimpPath *parent; gint index; GError *error = NULL; @@ -245,7 +245,7 @@ gimp_vectors_tree_view_drop_svg (GimpContainerTreeView *tree_view, static GimpItem * gimp_vectors_tree_view_item_new (GimpImage *image) { - GimpVectors *new_path; + GimpPath *new_path; new_path = gimp_vectors_new (image, _("Path")); diff --git a/app/widgets/gimpviewrenderer-utils.c b/app/widgets/gimpviewrenderer-utils.c index ed642d449a..a0cb0cc7c7 100644 --- a/app/widgets/gimpviewrenderer-utils.c +++ b/app/widgets/gimpviewrenderer-utils.c @@ -35,7 +35,7 @@ #include "core/gimplayer.h" #include "core/gimppalette.h" -#include "vectors/gimpvectors.h" +#include "vectors/gimppath.h" #include "gimpviewrenderer-utils.h" #include "gimpviewrendererbrush.h" @@ -81,7 +81,7 @@ gimp_view_renderer_type_from_viewable_type (GType viewable_type) { type = GIMP_TYPE_VIEW_RENDERER_GRADIENT; } - else if (g_type_is_a (viewable_type, GIMP_TYPE_VECTORS)) + else if (g_type_is_a (viewable_type, GIMP_TYPE_PATH)) { type = GIMP_TYPE_VIEW_RENDERER_VECTORS; } diff --git a/app/widgets/gimpviewrenderervectors.c b/app/widgets/gimpviewrenderervectors.c index 2d04048457..a16820a053 100644 --- a/app/widgets/gimpviewrenderervectors.c +++ b/app/widgets/gimpviewrenderervectors.c @@ -32,8 +32,8 @@ #include "core/gimpimage.h" #include "core/gimpitem.h" +#include "vectors/gimppath.h" #include "vectors/gimpstroke.h" -#include "vectors/gimpvectors.h" #include "gimpviewrenderervectors.h" @@ -71,7 +71,7 @@ gimp_view_renderer_vectors_draw (GimpViewRenderer *renderer, gint available_width, gint available_height) { - GimpVectors *vectors = GIMP_VECTORS (renderer->viewable); + GimpPath *vectors = GIMP_PATH (renderer->viewable); const GimpBezierDesc *desc; cairo_set_source_rgb (cr, 1.0, 1.0, 1.0); diff --git a/app/xcf/xcf-load.c b/app/xcf/xcf-load.c index ee91765f71..8a19aa160b 100644 --- a/app/xcf/xcf-load.c +++ b/app/xcf/xcf-load.c @@ -72,7 +72,7 @@ #include "vectors/gimpanchor.h" #include "vectors/gimpstroke.h" #include "vectors/gimpbezierstroke.h" -#include "vectors/gimpvectors.h" +#include "vectors/gimppath.h" #include "vectors/gimpvectors-compat.h" #include "xcf-private.h" @@ -136,7 +136,7 @@ static gboolean xcf_load_effect_props (XcfInfo *info, FilterData *filter); static gboolean xcf_load_path_props (XcfInfo *info, GimpImage *image, - GimpVectors **vectors); + GimpPath **vectors); static gboolean xcf_load_prop (XcfInfo *info, PropType *prop_type, guint32 *prop_size); @@ -150,7 +150,7 @@ static FilterData * xcf_load_effect (XcfInfo *info, GimpDrawable *drawable); static void xcf_load_free_effect (FilterData *data); static void xcf_load_free_effects (GList *effects); -static GimpVectors * xcf_load_path (XcfInfo *info, +static GimpPath * xcf_load_path (XcfInfo *info, GimpImage *image); static GimpLayerMask * xcf_load_layer_mask (XcfInfo *info, GimpImage *image); @@ -822,7 +822,7 @@ xcf_load_image (Gimp *gimp, { while (TRUE) { - GimpVectors *vectors; + GimpPath *vectors; /* read in the offset of the next path */ xcf_read_offset (info, &offset, 1); @@ -933,7 +933,7 @@ xcf_load_image (Gimp *gimp, #if 0 GimpItemList *set; - set = gimp_item_list_named_new (image, GIMP_TYPE_VECTORS, + set = gimp_item_list_named_new (image, GIMP_TYPE_PATH, _("Linked Paths"), info->linked_paths); gimp_image_store_item_set (image, set); @@ -2743,9 +2743,9 @@ set_or_seek_node_property: } static gboolean -xcf_load_path_props (XcfInfo *info, - GimpImage *image, - GimpVectors **vectors) +xcf_load_path_props (XcfInfo *info, + GimpImage *image, + GimpPath **vectors) { PropType prop_type; guint32 prop_size; @@ -3410,17 +3410,17 @@ xcf_load_free_effects (GList *effects) } /* The new path structure since XCF 18. */ -static GimpVectors * +static GimpPath * xcf_load_path (XcfInfo *info, GimpImage *image) { - GimpVectors *vectors = NULL; - gchar *name; - guint32 version; - guint32 plength; - guint32 num_strokes; - goffset base; - gint i; + GimpPath *vectors = NULL; + gchar *name; + guint32 version; + guint32 plength; + guint32 num_strokes; + goffset base; + gint i; /* read in the path name. */ xcf_read_string (info, &name, 1); @@ -4193,9 +4193,9 @@ static gboolean xcf_load_old_paths (XcfInfo *info, GimpImage *image) { - guint32 num_paths; - guint32 last_selected_row; - GimpVectors *active_vectors; + guint32 num_paths; + guint32 last_selected_row; + GimpPath *active_vectors; xcf_read_int32 (info, &last_selected_row, 1); xcf_read_int32 (info, &num_paths, 1); @@ -4207,7 +4207,7 @@ xcf_load_old_paths (XcfInfo *info, return FALSE; active_vectors = - GIMP_VECTORS (gimp_container_get_child_by_index (gimp_image_get_paths (image), + GIMP_PATH (gimp_container_get_child_by_index (gimp_image_get_paths (image), last_selected_row)); if (active_vectors) @@ -4231,7 +4231,7 @@ xcf_load_old_path (XcfInfo *info, guint32 num_points; guint32 version; /* changed from num_paths */ GimpTattoo tattoo = 0; - GimpVectors *vectors; + GimpPath *vectors; GimpVectorsCompatPoint *points; gint i; @@ -4326,10 +4326,10 @@ static gboolean xcf_load_old_vectors (XcfInfo *info, GimpImage *image) { - guint32 version; - guint32 active_index; - guint32 num_paths; - GimpVectors *active_vectors; + guint32 version; + guint32 active_index; + guint32 num_paths; + GimpPath *active_vectors; #ifdef GIMP_XCF_PATH_DEBUG g_printerr ("xcf_load_old_vectors\n"); @@ -4358,8 +4358,8 @@ xcf_load_old_vectors (XcfInfo *info, /* FIXME tree */ active_vectors = - GIMP_VECTORS (gimp_container_get_child_by_index (gimp_image_get_paths (image), - active_index)); + GIMP_PATH (gimp_container_get_child_by_index (gimp_image_get_paths (image), + active_index)); if (active_vectors) { @@ -4378,14 +4378,14 @@ static gboolean xcf_load_old_vector (XcfInfo *info, GimpImage *image) { - gchar *name; - GimpTattoo tattoo = 0; - guint32 visible; - guint32 linked; - guint32 num_parasites; - guint32 num_strokes; - GimpVectors *vectors; - gint i; + gchar *name; + GimpTattoo tattoo = 0; + guint32 visible; + guint32 linked; + guint32 num_parasites; + guint32 num_strokes; + GimpPath *vectors; + gint i; #ifdef GIMP_XCF_PATH_DEBUG g_printerr ("xcf_load_old_vector\n"); diff --git a/app/xcf/xcf-save.c b/app/xcf/xcf-save.c index af5633b0e1..7dd28d282e 100644 --- a/app/xcf/xcf-save.c +++ b/app/xcf/xcf-save.c @@ -66,9 +66,9 @@ #include "text/gimptextlayer-xcf.h" #include "vectors/gimpanchor.h" -#include "vectors/gimpstroke.h" #include "vectors/gimpbezierstroke.h" -#include "vectors/gimpvectors.h" +#include "vectors/gimppath.h" +#include "vectors/gimpstroke.h" #include "vectors/gimpvectors-compat.h" #include "xcf-private.h" @@ -124,7 +124,7 @@ static gboolean xcf_save_effect_props (XcfInfo *info, GError **error); static gboolean xcf_save_path_props (XcfInfo *info, GimpImage *image, - GimpVectors *vectors, + GimpPath *vectors, GError **error); static gboolean xcf_save_prop (XcfInfo *info, GimpImage *image, @@ -145,7 +145,7 @@ static gboolean xcf_save_effect (XcfInfo *info, GError **error); static gboolean xcf_save_path (XcfInfo *info, GimpImage *image, - GimpVectors *vectors, + GimpPath *vectors, GError **error); static gboolean xcf_save_buffer (XcfInfo *info, GimpImage *image, @@ -435,7 +435,7 @@ xcf_save_image (XcfInfo *info, for (list = all_paths; list; list = g_list_next (list)) { - GimpVectors *vectors = list->data; + GimpPath *vectors = list->data; /* seek back to the next slot in the offset table and write the * offset of the channel @@ -941,7 +941,7 @@ xcf_save_effect_props (XcfInfo *info, static gboolean xcf_save_path_props (XcfInfo *info, GimpImage *image, - GimpVectors *vectors, + GimpPath *vectors, GError **error) { GimpParasiteList *parasites; @@ -1706,7 +1706,7 @@ xcf_save_prop (XcfInfo *info, item_type = 0; else if (gimp_item_list_get_item_type (set) == GIMP_TYPE_CHANNEL) item_type = 1; - else if (gimp_item_list_get_item_type (set) == GIMP_TYPE_VECTORS) + else if (gimp_item_list_get_item_type (set) == GIMP_TYPE_PATH) item_type = 2; else g_return_val_if_reached (FALSE); @@ -2897,11 +2897,11 @@ xcf_save_old_paths (XcfInfo *info, GimpImage *image, GError **error) { - GimpVectors *active_path = NULL; - guint32 num_paths; - guint32 active_index = 0; - GList *list; - GError *tmp_error = NULL; + GimpPath *active_path = NULL; + guint32 num_paths; + guint32 active_index = 0; + GList *list; + GError *tmp_error = NULL; /* Write out the following:- * @@ -2935,7 +2935,7 @@ xcf_save_old_paths (XcfInfo *info, list; list = g_list_next (list)) { - GimpVectors *vectors = list->data; + GimpPath *vectors = list->data; gchar *name; guint32 locked; guint8 state; @@ -3019,13 +3019,13 @@ xcf_save_old_vectors (XcfInfo *info, GimpImage *image, GError **error) { - GimpVectors *active_path = NULL; - guint32 version = 1; - guint32 active_index = 0; - guint32 num_paths; - GList *list; - GList *stroke_list; - GError *tmp_error = NULL; + GimpPath *active_path = NULL; + guint32 version = 1; + guint32 active_index = 0; + guint32 num_paths; + GList *list; + GList *stroke_list; + GError *tmp_error = NULL; /* Write out the following:- * @@ -3061,7 +3061,7 @@ xcf_save_old_vectors (XcfInfo *info, list; list = g_list_next (list)) { - GimpVectors *vectors = list->data; + GimpPath *vectors = list->data; GimpParasiteList *parasites; const gchar *name; guint32 tattoo; @@ -3182,7 +3182,7 @@ xcf_save_old_vectors (XcfInfo *info, static gboolean xcf_save_path (XcfInfo *info, GimpImage *image, - GimpVectors *vectors, + GimpPath *vectors, GError **error) { const gchar *string; diff --git a/libgimp/gimp.c b/libgimp/gimp.c index 9b1b10e53a..5df8b19f0f 100644 --- a/libgimp/gimp.c +++ b/libgimp/gimp.c @@ -438,7 +438,7 @@ gimp_main (GType plug_in_type, GIMP_TYPE_CHANNEL, GIMP_TYPE_PARAM_CHANNEL, GIMP_TYPE_LAYER_MASK, GIMP_TYPE_PARAM_LAYER_MASK, GIMP_TYPE_SELECTION, GIMP_TYPE_PARAM_SELECTION, - GIMP_TYPE_VECTORS, GIMP_TYPE_PARAM_VECTORS, + GIMP_TYPE_PATH, GIMP_TYPE_PARAM_PATH, GIMP_TYPE_BRUSH, GIMP_TYPE_PARAM_BRUSH, GIMP_TYPE_FONT, GIMP_TYPE_PARAM_FONT, diff --git a/libgimp/gimp.def b/libgimp/gimp.def index abf5ff7c34..b80160fdf5 100644 --- a/libgimp/gimp.def +++ b/libgimp/gimp.def @@ -685,6 +685,7 @@ EXPORTS gimp_param_layer_get_type gimp_param_layer_mask_get_type gimp_param_palette_get_type + gimp_param_path_get_type gimp_param_pattern_get_type gimp_param_resource_get_type gimp_param_selection_get_type @@ -701,13 +702,12 @@ EXPORTS gimp_param_spec_layer gimp_param_spec_layer_mask gimp_param_spec_palette + gimp_param_spec_path gimp_param_spec_pattern gimp_param_spec_resource gimp_param_spec_selection gimp_param_spec_text_layer - gimp_param_spec_vectors gimp_param_text_layer_get_type - gimp_param_vectors_get_type gimp_path_bezier_stroke_conicto gimp_path_bezier_stroke_cubicto gimp_path_bezier_stroke_lineto @@ -716,7 +716,9 @@ EXPORTS gimp_path_copy gimp_path_export_to_file gimp_path_export_to_string + gimp_path_get_by_id gimp_path_get_strokes + gimp_path_get_type gimp_path_import_from_file gimp_path_import_from_string gimp_path_new @@ -1018,7 +1020,5 @@ EXPORTS gimp_vector_load_procedure_extract_dimensions gimp_vector_load_procedure_get_type gimp_vector_load_procedure_new - gimp_vectors_get_by_id - gimp_vectors_get_type gimp_version gimp_wm_class diff --git a/libgimp/gimp.h b/libgimp/gimp.h index 4204c44f91..6f9efcdeab 100644 --- a/libgimp/gimp.h +++ b/libgimp/gimp.h @@ -57,6 +57,7 @@ #include #include #include +#include #include #include #include @@ -68,7 +69,6 @@ #include #include #include -#include /* Resources and their widgets. Order important. */ #include diff --git a/libgimp/gimpgpparams-body.c b/libgimp/gimpgpparams-body.c index 23d6042b63..72bc060a54 100644 --- a/libgimp/gimpgpparams-body.c +++ b/libgimp/gimpgpparams-body.c @@ -258,10 +258,10 @@ _gimp_gp_param_def_to_param_spec (const GPParamDef *param_def) param_def->meta.m_id.none_ok, flags); - if (! strcmp (param_def->type_name, "GimpParamVectors")) - return gimp_param_spec_vectors (name, nick, blurb, - param_def->meta.m_id.none_ok, - flags); + if (! strcmp (param_def->type_name, "GimpParamPath")) + return gimp_param_spec_path (name, nick, blurb, + param_def->meta.m_id.none_ok, + flags); if (! strcmp (param_def->type_name, "GimpParamResource")) return gimp_param_spec_resource (name, nick, blurb, @@ -546,9 +546,9 @@ _gimp_param_spec_to_gp_param_def (GParamSpec *pspec, { type_name = "GimpParamSelection"; } - else if (value_type == GIMP_TYPE_VECTORS) + else if (value_type == GIMP_TYPE_PATH) { - type_name = "GimpParamVectors"; + type_name = "GimpParamPath"; } else if (value_type == GIMP_TYPE_RESOURCE) { diff --git a/libgimp/gimpimage.c b/libgimp/gimpimage.c index 474e87eefd..10152b8475 100644 --- a/libgimp/gimpimage.c +++ b/libgimp/gimpimage.c @@ -397,7 +397,7 @@ gimp_image_take_selected_channels (GimpImage *image, * This procedure returns the list of paths selected in the specified * image. * - * Returns: (element-type GimpVectors) (transfer container): + * Returns: (element-type GimpPath) (transfer container): * The list of selected paths in the image. * The returned list must be freed with g_list_free(). * Path elements belong to libgimp and must not be freed. @@ -407,10 +407,10 @@ gimp_image_take_selected_channels (GimpImage *image, GList * gimp_image_list_selected_paths (GimpImage *image) { - GimpVectors **paths; - gint num_paths; - GList *list = NULL; - gint i; + GimpPath **paths; + gint num_paths; + GList *list = NULL; + gint i; paths = gimp_image_get_selected_paths (image, &num_paths); @@ -425,7 +425,7 @@ gimp_image_list_selected_paths (GimpImage *image) /** * gimp_image_take_selected_paths: * @image: The image. - * @paths: (transfer container) (element-type GimpVectors): The list of paths to select. + * @paths: (transfer container) (element-type GimpPath): The list of paths to select. * * The paths are set as the selected paths in the image. Any previous * selected paths are unselected. @@ -438,17 +438,17 @@ gboolean gimp_image_take_selected_paths (GimpImage *image, GList *paths) { - GimpVectors **sel_paths; - GList *list; - gboolean success; - gint i; + GimpPath **sel_paths; + GList *list; + gboolean success; + gint i; - sel_paths = g_new0 (GimpVectors *, g_list_length (paths)); + sel_paths = g_new0 (GimpPath *, g_list_length (paths)); for (list = paths, i = 0; list; list = list->next, i++) sel_paths[i] = list->data; success = gimp_image_set_selected_paths (image, g_list_length (paths), - (const GimpVectors **) sel_paths); + (const GimpPath **) sel_paths); g_list_free (paths); return success; @@ -500,7 +500,7 @@ gimp_image_list_channels (GimpImage *image) * This procedure returns the list of paths contained in the * specified image. * - * Returns: (element-type GimpVectors) (transfer container): + * Returns: (element-type GimpPath) (transfer container): * The list of paths contained in the image. * The returned value must be freed with g_list_free(). Path * elements belong to libgimp and must not be freed. @@ -510,10 +510,10 @@ gimp_image_list_channels (GimpImage *image) GList * gimp_image_list_paths (GimpImage *image) { - GimpVectors **paths; - gint num_paths; - GList *list = NULL; - gint i; + GimpPath **paths; + gint num_paths; + GList *list = NULL; + gint i; paths = gimp_image_get_paths (image, &num_paths); diff --git a/libgimp/gimpimage_pdb.c b/libgimp/gimpimage_pdb.c index 0562744a7e..eacc413f96 100644 --- a/libgimp/gimpimage_pdb.c +++ b/libgimp/gimpimage_pdb.c @@ -569,19 +569,19 @@ gimp_image_get_channels (GimpImage *image, * This procedure returns the list of paths contained in the specified * image. * - * Returns: (array length=num_paths) (element-type GimpVectors) (transfer container): + * Returns: (array length=num_paths) (element-type GimpPath) (transfer container): * The list of paths contained in the image. * The returned value must be freed with g_free(). * * Since: 2.4 **/ -GimpVectors ** +GimpPath ** gimp_image_get_paths (GimpImage *image, gint *num_paths) { GimpValueArray *args; GimpValueArray *return_vals; - GimpVectors **paths = NULL; + GimpPath **paths = NULL; args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_IMAGE, image, @@ -1189,10 +1189,10 @@ gimp_image_thaw_channels (GimpImage *image) * Returns: TRUE on success. **/ gboolean -gimp_image_insert_path (GimpImage *image, - GimpVectors *path, - GimpVectors *parent, - gint position) +gimp_image_insert_path (GimpImage *image, + GimpPath *path, + GimpPath *parent, + gint position) { GimpValueArray *args; GimpValueArray *return_vals; @@ -1200,8 +1200,8 @@ gimp_image_insert_path (GimpImage *image, args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_IMAGE, image, - GIMP_TYPE_VECTORS, path, - GIMP_TYPE_VECTORS, parent, + GIMP_TYPE_PATH, path, + GIMP_TYPE_PATH, parent, G_TYPE_INT, position, G_TYPE_NONE); @@ -1232,8 +1232,8 @@ gimp_image_insert_path (GimpImage *image, * Since: 2.4 **/ gboolean -gimp_image_remove_path (GimpImage *image, - GimpVectors *path) +gimp_image_remove_path (GimpImage *image, + GimpPath *path) { GimpValueArray *args; GimpValueArray *return_vals; @@ -1241,7 +1241,7 @@ gimp_image_remove_path (GimpImage *image, args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_IMAGE, image, - GIMP_TYPE_VECTORS, path, + GIMP_TYPE_PATH, path, G_TYPE_NONE); return_vals = _gimp_pdb_run_procedure_array (gimp_get_pdb (), @@ -2220,19 +2220,19 @@ gimp_image_set_selected_channels (GimpImage *image, * This procedure returns the list of selected paths in the specified * image. * - * Returns: (array length=num_paths) (element-type GimpVectors) (transfer container): + * Returns: (array length=num_paths) (element-type GimpPath) (transfer container): * The list of selected paths in the image. * The returned value must be freed with g_free(). * * Since: 3.0.0 **/ -GimpVectors ** +GimpPath ** gimp_image_get_selected_paths (GimpImage *image, gint *num_paths) { GimpValueArray *args; GimpValueArray *return_vals; - GimpVectors **paths = NULL; + GimpPath **paths = NULL; args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_IMAGE, image, @@ -2260,7 +2260,7 @@ gimp_image_get_selected_paths (GimpImage *image, * gimp_image_set_selected_paths: * @image: The image. * @num_paths: The number of paths to select. - * @paths: (array length=num_paths) (element-type GimpVectors): The list of paths to select. + * @paths: (array length=num_paths) (element-type GimpPath): The list of paths to select. * * Sets the specified image's selected paths. * @@ -2271,9 +2271,9 @@ gimp_image_get_selected_paths (GimpImage *image, * Since: 3.0.0 **/ gboolean -gimp_image_set_selected_paths (GimpImage *image, - gint num_paths, - const GimpVectors **paths) +gimp_image_set_selected_paths (GimpImage *image, + gint num_paths, + const GimpPath **paths) { GimpValueArray *args; GimpValueArray *return_vals; @@ -2284,7 +2284,7 @@ gimp_image_set_selected_paths (GimpImage *image, G_TYPE_INT, num_paths, GIMP_TYPE_OBJECT_ARRAY, NULL, G_TYPE_NONE); - gimp_value_set_object_array (gimp_value_array_index (args, 2), GIMP_TYPE_VECTORS, (GObject **) paths, num_paths); + gimp_value_set_object_array (gimp_value_array_index (args, 2), GIMP_TYPE_PATH, (GObject **) paths, num_paths); return_vals = _gimp_pdb_run_procedure_array (gimp_get_pdb (), "gimp-image-set-selected-paths", @@ -3123,13 +3123,13 @@ gimp_image_get_channel_by_tattoo (GimpImage *image, * * Since: 2.6 **/ -GimpVectors * +GimpPath * gimp_image_get_path_by_tattoo (GimpImage *image, guint tattoo) { GimpValueArray *args; GimpValueArray *return_vals; - GimpVectors *path = NULL; + GimpPath *path = NULL; args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_IMAGE, image, @@ -3142,7 +3142,7 @@ gimp_image_get_path_by_tattoo (GimpImage *image, gimp_value_array_unref (args); if (GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS) - path = GIMP_VALUES_GET_VECTORS (return_vals, 1); + path = GIMP_VALUES_GET_PATH (return_vals, 1); gimp_value_array_unref (return_vals); @@ -3243,13 +3243,13 @@ gimp_image_get_channel_by_name (GimpImage *image, * * Since: 2.8 **/ -GimpVectors * +GimpPath * gimp_image_get_path_by_name (GimpImage *image, const gchar *name) { GimpValueArray *args; GimpValueArray *return_vals; - GimpVectors *path = NULL; + GimpPath *path = NULL; args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_IMAGE, image, @@ -3262,7 +3262,7 @@ gimp_image_get_path_by_name (GimpImage *image, gimp_value_array_unref (args); if (GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS) - path = GIMP_VALUES_GET_VECTORS (return_vals, 1); + path = GIMP_VALUES_GET_PATH (return_vals, 1); gimp_value_array_unref (return_vals); diff --git a/libgimp/gimpimage_pdb.h b/libgimp/gimpimage_pdb.h index dc4aeb4630..d23f174c39 100644 --- a/libgimp/gimpimage_pdb.h +++ b/libgimp/gimpimage_pdb.h @@ -52,7 +52,7 @@ GimpLayer** gimp_image_get_layers (GimpImage gint *num_layers); GimpChannel** gimp_image_get_channels (GimpImage *image, gint *num_channels); -GimpVectors** gimp_image_get_paths (GimpImage *image, +GimpPath** gimp_image_get_paths (GimpImage *image, gint *num_paths); gboolean gimp_image_unset_active_channel (GimpImage *image); GimpLayer* gimp_image_get_floating_sel (GimpImage *image); @@ -86,11 +86,11 @@ gboolean gimp_image_remove_channel (GimpImage gboolean gimp_image_freeze_channels (GimpImage *image); gboolean gimp_image_thaw_channels (GimpImage *image); gboolean gimp_image_insert_path (GimpImage *image, - GimpVectors *path, - GimpVectors *parent, + GimpPath *path, + GimpPath *parent, gint position); gboolean gimp_image_remove_path (GimpImage *image, - GimpVectors *path); + GimpPath *path); gboolean gimp_image_freeze_paths (GimpImage *image); gboolean gimp_image_thaw_paths (GimpImage *image); gint gimp_image_get_item_position (GimpImage *image, @@ -139,11 +139,11 @@ GimpChannel** gimp_image_get_selected_channels (GimpImage gboolean gimp_image_set_selected_channels (GimpImage *image, gint num_channels, const GimpChannel **channels); -GimpVectors** gimp_image_get_selected_paths (GimpImage *image, +GimpPath** gimp_image_get_selected_paths (GimpImage *image, gint *num_paths); gboolean gimp_image_set_selected_paths (GimpImage *image, gint num_paths, - const GimpVectors **paths); + const GimpPath **paths); GimpItem** gimp_image_get_selected_drawables (GimpImage *image, gint *num_drawables); GimpSelection* gimp_image_get_selection (GimpImage *image); @@ -180,13 +180,13 @@ GimpLayer* gimp_image_get_layer_by_tattoo (GimpImage guint tattoo); GimpChannel* gimp_image_get_channel_by_tattoo (GimpImage *image, guint tattoo); -GimpVectors* gimp_image_get_path_by_tattoo (GimpImage *image, +GimpPath* gimp_image_get_path_by_tattoo (GimpImage *image, guint tattoo); GimpLayer* gimp_image_get_layer_by_name (GimpImage *image, const gchar *name); GimpChannel* gimp_image_get_channel_by_name (GimpImage *image, const gchar *name); -GimpVectors* gimp_image_get_path_by_name (GimpImage *image, +GimpPath* gimp_image_get_path_by_name (GimpImage *image, const gchar *name); gboolean gimp_image_attach_parasite (GimpImage *image, const GimpParasite *parasite); diff --git a/libgimp/gimpparamspecs-body.c b/libgimp/gimpparamspecs-body.c index 2949b16994..d719481d75 100644 --- a/libgimp/gimpparamspecs-body.c +++ b/libgimp/gimpparamspecs-body.c @@ -799,14 +799,14 @@ gimp_param_spec_selection (const gchar *name, /* - * GIMP_TYPE_PARAM_VECTORS + * GIMP_TYPE_PARAM_PATH */ -static void gimp_param_vectors_class_init (GParamSpecClass *klass); -static void gimp_param_vectors_init (GParamSpec *pspec); +static void gimp_param_path_class_init (GParamSpecClass *klass); +static void gimp_param_path_init (GParamSpec *pspec); GType -gimp_param_vectors_get_type (void) +gimp_param_path_get_type (void) { static GType type = 0; @@ -816,58 +816,58 @@ gimp_param_vectors_get_type (void) { sizeof (GParamSpecClass), NULL, NULL, - (GClassInitFunc) gimp_param_vectors_class_init, + (GClassInitFunc) gimp_param_path_class_init, NULL, NULL, - sizeof (GimpParamSpecVectors), + sizeof (GimpParamSpecPath), 0, - (GInstanceInitFunc) gimp_param_vectors_init + (GInstanceInitFunc) gimp_param_path_init }; type = g_type_register_static (GIMP_TYPE_PARAM_ITEM, - "GimpParamVectors", &info, 0); + "GimpParamPath", &info, 0); } return type; } static void -gimp_param_vectors_class_init (GParamSpecClass *klass) +gimp_param_path_class_init (GParamSpecClass *klass) { - klass->value_type = GIMP_TYPE_VECTORS; + klass->value_type = GIMP_TYPE_PATH; } static void -gimp_param_vectors_init (GParamSpec *pspec) +gimp_param_path_init (GParamSpec *pspec) { } /** - * gimp_param_spec_vectors: + * gimp_param_spec_path: * @name: Canonical name of the property specified. * @nick: Nick name of the property specified. * @blurb: Description of the property specified. - * @none_ok: Whether no is a valid value. + * @none_ok: Whether no is a valid value. * @flags: Flags for the property specified. * - * Creates a new #GimpParamSpecVectors specifying a - * [type@Vectors] property. + * Creates a new #GimpParamSpecPath specifying a + * [type@Path] property. * * See g_param_spec_internal() for details on property names. * - * Returns: (transfer full): The newly created #GimpParamSpecVectors. + * Returns: (transfer full): The newly created #GimpParamSpecPath. * * Since: 3.0 **/ GParamSpec * -gimp_param_spec_vectors (const gchar *name, - const gchar *nick, - const gchar *blurb, - gboolean none_ok, - GParamFlags flags) +gimp_param_spec_path (const gchar *name, + const gchar *nick, + const gchar *blurb, + gboolean none_ok, + GParamFlags flags) { GimpParamSpecItem *ispec; - ispec = g_param_spec_internal (GIMP_TYPE_PARAM_VECTORS, + ispec = g_param_spec_internal (GIMP_TYPE_PARAM_PATH, name, nick, blurb, flags); g_return_val_if_fail (ispec, NULL); diff --git a/libgimp/gimpparamspecs.h b/libgimp/gimpparamspecs.h index 2eb938a764..007eaa086b 100644 --- a/libgimp/gimpparamspecs.h +++ b/libgimp/gimpparamspecs.h @@ -278,30 +278,30 @@ GParamSpec * gimp_param_spec_selection (const gchar *name, /* - * GIMP_TYPE_PARAM_VECTORS + * GIMP_TYPE_PARAM_PATH */ -#define GIMP_VALUE_HOLDS_VECTORS(value) (G_TYPE_CHECK_VALUE_TYPE ((value),\ - GIMP_TYPE_VECTORS)) +#define GIMP_VALUE_HOLDS_PATH(value) (G_TYPE_CHECK_VALUE_TYPE ((value),\ + GIMP_TYPE_PATH)) -#define GIMP_TYPE_PARAM_VECTORS (gimp_param_vectors_get_type ()) -#define GIMP_PARAM_SPEC_VECTORS(pspec) (G_TYPE_CHECK_INSTANCE_CAST ((pspec), GIMP_TYPE_PARAM_VECTORS, GimpParamSpecVectors)) -#define GIMP_IS_PARAM_SPEC_VECTORS(pspec) (G_TYPE_CHECK_INSTANCE_TYPE ((pspec), GIMP_TYPE_PARAM_VECTORS)) +#define GIMP_TYPE_PARAM_PATH (gimp_param_path_get_type ()) +#define GIMP_PARAM_SPEC_PATH(pspec) (G_TYPE_CHECK_INSTANCE_CAST ((pspec), GIMP_TYPE_PARAM_PATH, GimpParamSpecPath)) +#define GIMP_IS_PARAM_SPEC_PATH(pspec) (G_TYPE_CHECK_INSTANCE_TYPE ((pspec), GIMP_TYPE_PARAM_PATH)) -typedef struct _GimpParamSpecVectors GimpParamSpecVectors; +typedef struct _GimpParamSpecPath GimpParamSpecPath; -struct _GimpParamSpecVectors +struct _GimpParamSpecPath { GimpParamSpecItem parent_instance; }; -GType gimp_param_vectors_get_type (void) G_GNUC_CONST; +GType gimp_param_path_get_type (void) G_GNUC_CONST; -GParamSpec * gimp_param_spec_vectors (const gchar *name, - const gchar *nick, - const gchar *blurb, - gboolean none_ok, - GParamFlags flags); +GParamSpec * gimp_param_spec_path (const gchar *name, + const gchar *nick, + const gchar *blurb, + gboolean none_ok, + GParamFlags flags); /* diff --git a/libgimp/gimpvectors.c b/libgimp/gimppath.c similarity index 55% rename from libgimp/gimpvectors.c rename to libgimp/gimppath.c index a84f8c079e..bea8cb46fa 100644 --- a/libgimp/gimpvectors.c +++ b/libgimp/gimppath.c @@ -1,7 +1,7 @@ /* LIBGIMP - The GIMP Library * Copyright (C) 1995-2000 Peter Mattis and Spencer Kimball * - * gimpvectors.c + * gimppath.c * Copyright (C) Jehan * * This library is free software: you can redistribute it and/or @@ -24,48 +24,48 @@ #include "gimp.h" -struct _GimpVectors +struct _GimpPath { GimpItem parent_instance; }; -G_DEFINE_TYPE (GimpVectors, gimp_vectors, GIMP_TYPE_ITEM) +G_DEFINE_TYPE (GimpPath, gimp_path, GIMP_TYPE_ITEM) -#define parent_class gimp_vectors_parent_class +#define parent_class gimp_path_parent_class static void -gimp_vectors_class_init (GimpVectorsClass *klass) +gimp_path_class_init (GimpPathClass *klass) { } static void -gimp_vectors_init (GimpVectors *vectors) +gimp_path_init (GimpPath *path) { } /** - * gimp_vectors_get_by_id: - * @vectors_id: The vectors id. + * gimp_path_get_by_id: + * @path_id: The path id. * - * Returns a #GimpVectors representing @vectors_id. This function - * calls gimp_item_get_by_id() and returns the item if it is vectors + * Returns a #GimpPath representing @path_id. This function + * calls gimp_item_get_by_id() and returns the item if it is a path * or %NULL otherwise. * - * Returns: (nullable) (transfer none): a #GimpVectors for @vectors_id - * or %NULL if @vectors_id does not represent a valid - * vectors. The object belongs to libgimp and you must not + * Returns: (nullable) (transfer none): a #GimpPath for @path_id + * or %NULL if @path_id does not represent a valid + * path. The object belongs to libgimp and you must not * modify or unref it. * * Since: 3.0 **/ -GimpVectors * -gimp_vectors_get_by_id (gint32 vectors_id) +GimpPath * +gimp_path_get_by_id (gint32 path_id) { - GimpItem *item = gimp_item_get_by_id (vectors_id); + GimpItem *item = gimp_item_get_by_id (path_id); - if (GIMP_IS_VECTORS (item)) - return (GimpVectors *) item; + if (GIMP_IS_PATH (item)) + return (GimpPath *) item; return NULL; } diff --git a/libgimp/gimpvectors.h b/libgimp/gimppath.h similarity index 78% rename from libgimp/gimpvectors.h rename to libgimp/gimppath.h index 8b09c4c255..a22d1bce48 100644 --- a/libgimp/gimpvectors.h +++ b/libgimp/gimppath.h @@ -1,7 +1,7 @@ /* LIBGIMP - The GIMP Library * Copyright (C) 1995-2000 Peter Mattis and Spencer Kimball * - * gimpvectors.h + * gimppath.h * Copyright (C) Jehan * * This library is free software: you can redistribute it and/or @@ -23,21 +23,21 @@ #error "Only can be included directly." #endif -#ifndef __GIMP_VECTORS_H__ -#define __GIMP_VECTORS_H__ +#ifndef __GIMP_PATH_H__ +#define __GIMP_PATH_H__ G_BEGIN_DECLS /* For information look into the C source or the html documentation */ -#define GIMP_TYPE_VECTORS (gimp_vectors_get_type ()) -G_DECLARE_FINAL_TYPE (GimpVectors, gimp_vectors, GIMP, VECTORS, GimpItem) +#define GIMP_TYPE_PATH (gimp_path_get_type ()) +G_DECLARE_FINAL_TYPE (GimpPath, gimp_path, GIMP, PATH, GimpItem) -GimpVectors * gimp_vectors_get_by_id (gint32 vectors_id); +GimpPath * gimp_path_get_by_id (gint32 path_id); G_END_DECLS -#endif /* __GIMP_VECTORS_H__ */ +#endif /* __GIMP_PATH_H__ */ diff --git a/libgimp/gimppath_pdb.c b/libgimp/gimppath_pdb.c index 806fad5d18..907c3aa353 100644 --- a/libgimp/gimppath_pdb.c +++ b/libgimp/gimppath_pdb.c @@ -51,13 +51,13 @@ * * Since: 2.4 **/ -GimpVectors * +GimpPath * gimp_path_new (GimpImage *image, const gchar *name) { GimpValueArray *args; GimpValueArray *return_vals; - GimpVectors *path = NULL; + GimpPath *path = NULL; args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_IMAGE, image, @@ -70,7 +70,7 @@ gimp_path_new (GimpImage *image, gimp_value_array_unref (args); if (GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS) - path = GIMP_VALUES_GET_VECTORS (return_vals, 1); + path = GIMP_VALUES_GET_PATH (return_vals, 1); gimp_value_array_unref (return_vals); @@ -91,13 +91,13 @@ gimp_path_new (GimpImage *image, * * Since: 2.6 **/ -GimpVectors * +GimpPath * gimp_path_new_from_text_layer (GimpImage *image, GimpLayer *layer) { GimpValueArray *args; GimpValueArray *return_vals; - GimpVectors *path = NULL; + GimpPath *path = NULL; args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_IMAGE, image, @@ -110,7 +110,7 @@ gimp_path_new_from_text_layer (GimpImage *image, gimp_value_array_unref (args); if (GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS) - path = GIMP_VALUES_GET_VECTORS (return_vals, 1); + path = GIMP_VALUES_GET_PATH (return_vals, 1); gimp_value_array_unref (return_vals); @@ -130,15 +130,15 @@ gimp_path_new_from_text_layer (GimpImage *image, * * Since: 2.6 **/ -GimpVectors * -gimp_path_copy (GimpVectors *path) +GimpPath * +gimp_path_copy (GimpPath *path) { GimpValueArray *args; GimpValueArray *return_vals; - GimpVectors *path_copy = NULL; + GimpPath *path_copy = NULL; args = gimp_value_array_new_from_types (NULL, - GIMP_TYPE_VECTORS, path, + GIMP_TYPE_PATH, path, G_TYPE_NONE); return_vals = _gimp_pdb_run_procedure_array (gimp_get_pdb (), @@ -147,7 +147,7 @@ gimp_path_copy (GimpVectors *path) gimp_value_array_unref (args); if (GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS) - path_copy = GIMP_VALUES_GET_VECTORS (return_vals, 1); + path_copy = GIMP_VALUES_GET_PATH (return_vals, 1); gimp_value_array_unref (return_vals); @@ -171,15 +171,15 @@ gimp_path_copy (GimpVectors *path) * Since: 2.4 **/ gint * -gimp_path_get_strokes (GimpVectors *path, - gint *num_strokes) +gimp_path_get_strokes (GimpPath *path, + gint *num_strokes) { GimpValueArray *args; GimpValueArray *return_vals; gint *stroke_ids = NULL; args = gimp_value_array_new_from_types (NULL, - GIMP_TYPE_VECTORS, path, + GIMP_TYPE_PATH, path, G_TYPE_NONE); return_vals = _gimp_pdb_run_procedure_array (gimp_get_pdb (), @@ -215,16 +215,16 @@ gimp_path_get_strokes (GimpVectors *path, * Since: 2.4 **/ gdouble -gimp_path_stroke_get_length (GimpVectors *path, - gint stroke_id, - gdouble precision) +gimp_path_stroke_get_length (GimpPath *path, + gint stroke_id, + gdouble precision) { GimpValueArray *args; GimpValueArray *return_vals; gdouble length = 0.0; args = gimp_value_array_new_from_types (NULL, - GIMP_TYPE_VECTORS, path, + GIMP_TYPE_PATH, path, G_TYPE_INT, stroke_id, G_TYPE_DOUBLE, precision, G_TYPE_NONE); @@ -267,21 +267,21 @@ gimp_path_stroke_get_length (GimpVectors *path, * Since: 2.4 **/ gboolean -gimp_path_stroke_get_point_at_dist (GimpVectors *path, - gint stroke_id, - gdouble dist, - gdouble precision, - gdouble *x_point, - gdouble *y_point, - gdouble *slope, - gboolean *valid) +gimp_path_stroke_get_point_at_dist (GimpPath *path, + gint stroke_id, + gdouble dist, + gdouble precision, + gdouble *x_point, + gdouble *y_point, + gdouble *slope, + gboolean *valid) { GimpValueArray *args; GimpValueArray *return_vals; gboolean success = TRUE; args = gimp_value_array_new_from_types (NULL, - GIMP_TYPE_VECTORS, path, + GIMP_TYPE_PATH, path, G_TYPE_INT, stroke_id, G_TYPE_DOUBLE, dist, G_TYPE_DOUBLE, precision, @@ -326,15 +326,15 @@ gimp_path_stroke_get_point_at_dist (GimpVectors *path, * Since: 2.4 **/ gboolean -gimp_path_remove_stroke (GimpVectors *path, - gint stroke_id) +gimp_path_remove_stroke (GimpPath *path, + gint stroke_id) { GimpValueArray *args; GimpValueArray *return_vals; gboolean success = TRUE; args = gimp_value_array_new_from_types (NULL, - GIMP_TYPE_VECTORS, path, + GIMP_TYPE_PATH, path, G_TYPE_INT, stroke_id, G_TYPE_NONE); @@ -364,15 +364,15 @@ gimp_path_remove_stroke (GimpVectors *path, * Since: 2.4 **/ gboolean -gimp_path_stroke_close (GimpVectors *path, - gint stroke_id) +gimp_path_stroke_close (GimpPath *path, + gint stroke_id) { GimpValueArray *args; GimpValueArray *return_vals; gboolean success = TRUE; args = gimp_value_array_new_from_types (NULL, - GIMP_TYPE_VECTORS, path, + GIMP_TYPE_PATH, path, G_TYPE_INT, stroke_id, G_TYPE_NONE); @@ -402,15 +402,15 @@ gimp_path_stroke_close (GimpVectors *path, * Since: 3.0 **/ gboolean -gimp_path_stroke_reverse (GimpVectors *path, - gint stroke_id) +gimp_path_stroke_reverse (GimpPath *path, + gint stroke_id) { GimpValueArray *args; GimpValueArray *return_vals; gboolean success = TRUE; args = gimp_value_array_new_from_types (NULL, - GIMP_TYPE_VECTORS, path, + GIMP_TYPE_PATH, path, G_TYPE_INT, stroke_id, G_TYPE_NONE); @@ -442,17 +442,17 @@ gimp_path_stroke_reverse (GimpVectors *path, * Since: 2.4 **/ gboolean -gimp_path_stroke_translate (GimpVectors *path, - gint stroke_id, - gdouble off_x, - gdouble off_y) +gimp_path_stroke_translate (GimpPath *path, + gint stroke_id, + gdouble off_x, + gdouble off_y) { GimpValueArray *args; GimpValueArray *return_vals; gboolean success = TRUE; args = gimp_value_array_new_from_types (NULL, - GIMP_TYPE_VECTORS, path, + GIMP_TYPE_PATH, path, G_TYPE_INT, stroke_id, G_TYPE_DOUBLE, off_x, G_TYPE_DOUBLE, off_y, @@ -486,17 +486,17 @@ gimp_path_stroke_translate (GimpVectors *path, * Since: 2.4 **/ gboolean -gimp_path_stroke_scale (GimpVectors *path, - gint stroke_id, - gdouble scale_x, - gdouble scale_y) +gimp_path_stroke_scale (GimpPath *path, + gint stroke_id, + gdouble scale_x, + gdouble scale_y) { GimpValueArray *args; GimpValueArray *return_vals; gboolean success = TRUE; args = gimp_value_array_new_from_types (NULL, - GIMP_TYPE_VECTORS, path, + GIMP_TYPE_PATH, path, G_TYPE_INT, stroke_id, G_TYPE_DOUBLE, scale_x, G_TYPE_DOUBLE, scale_y, @@ -531,18 +531,18 @@ gimp_path_stroke_scale (GimpVectors *path, * Since: 2.4 **/ gboolean -gimp_path_stroke_rotate (GimpVectors *path, - gint stroke_id, - gdouble center_x, - gdouble center_y, - gdouble angle) +gimp_path_stroke_rotate (GimpPath *path, + gint stroke_id, + gdouble center_x, + gdouble center_y, + gdouble angle) { GimpValueArray *args; GimpValueArray *return_vals; gboolean success = TRUE; args = gimp_value_array_new_from_types (NULL, - GIMP_TYPE_VECTORS, path, + GIMP_TYPE_PATH, path, G_TYPE_INT, stroke_id, G_TYPE_DOUBLE, center_x, G_TYPE_DOUBLE, center_y, @@ -577,7 +577,7 @@ gimp_path_stroke_rotate (GimpVectors *path, * Since: 2.4 **/ gboolean -gimp_path_stroke_flip (GimpVectors *path, +gimp_path_stroke_flip (GimpPath *path, gint stroke_id, GimpOrientationType flip_type, gdouble axis) @@ -587,7 +587,7 @@ gimp_path_stroke_flip (GimpVectors *path, gboolean success = TRUE; args = gimp_value_array_new_from_types (NULL, - GIMP_TYPE_VECTORS, path, + GIMP_TYPE_PATH, path, G_TYPE_INT, stroke_id, GIMP_TYPE_ORIENTATION_TYPE, flip_type, G_TYPE_DOUBLE, axis, @@ -625,19 +625,19 @@ gimp_path_stroke_flip (GimpVectors *path, * Since: 2.4 **/ gboolean -gimp_path_stroke_flip_free (GimpVectors *path, - gint stroke_id, - gdouble x1, - gdouble y1, - gdouble x2, - gdouble y2) +gimp_path_stroke_flip_free (GimpPath *path, + gint stroke_id, + gdouble x1, + gdouble y1, + gdouble x2, + gdouble y2) { GimpValueArray *args; GimpValueArray *return_vals; gboolean success = TRUE; args = gimp_value_array_new_from_types (NULL, - GIMP_TYPE_VECTORS, path, + GIMP_TYPE_PATH, path, G_TYPE_INT, stroke_id, G_TYPE_DOUBLE, x1, G_TYPE_DOUBLE, y1, @@ -677,18 +677,18 @@ gimp_path_stroke_flip_free (GimpVectors *path, * Since: 2.4 **/ GimpVectorsStrokeType -gimp_path_stroke_get_points (GimpVectors *path, - gint stroke_id, - gint *num_points, - gdouble **controlpoints, - gboolean *closed) +gimp_path_stroke_get_points (GimpPath *path, + gint stroke_id, + gint *num_points, + gdouble **controlpoints, + gboolean *closed) { GimpValueArray *args; GimpValueArray *return_vals; GimpVectorsStrokeType type = 0; args = gimp_value_array_new_from_types (NULL, - GIMP_TYPE_VECTORS, path, + GIMP_TYPE_PATH, path, G_TYPE_INT, stroke_id, G_TYPE_NONE); @@ -736,7 +736,7 @@ gimp_path_stroke_get_points (GimpVectors *path, * Since: 2.4 **/ gint -gimp_path_stroke_new_from_points (GimpVectors *path, +gimp_path_stroke_new_from_points (GimpPath *path, GimpVectorsStrokeType type, gint num_points, const gdouble *controlpoints, @@ -747,7 +747,7 @@ gimp_path_stroke_new_from_points (GimpVectors *path, gint stroke_id = 0; args = gimp_value_array_new_from_types (NULL, - GIMP_TYPE_VECTORS, path, + GIMP_TYPE_PATH, path, GIMP_TYPE_VECTORS_STROKE_TYPE, type, G_TYPE_INT, num_points, GIMP_TYPE_FLOAT_ARRAY, NULL, @@ -787,18 +787,18 @@ gimp_path_stroke_new_from_points (GimpVectors *path, * Since: 2.4 **/ gdouble * -gimp_path_stroke_interpolate (GimpVectors *path, - gint stroke_id, - gdouble precision, - gint *num_coords, - gboolean *closed) +gimp_path_stroke_interpolate (GimpPath *path, + gint stroke_id, + gdouble precision, + gint *num_coords, + gboolean *closed) { GimpValueArray *args; GimpValueArray *return_vals; gdouble *coords = NULL; args = gimp_value_array_new_from_types (NULL, - GIMP_TYPE_VECTORS, path, + GIMP_TYPE_PATH, path, G_TYPE_INT, stroke_id, G_TYPE_DOUBLE, precision, G_TYPE_NONE); @@ -837,16 +837,16 @@ gimp_path_stroke_interpolate (GimpVectors *path, * Since: 2.4 **/ gint -gimp_path_bezier_stroke_new_moveto (GimpVectors *path, - gdouble x0, - gdouble y0) +gimp_path_bezier_stroke_new_moveto (GimpPath *path, + gdouble x0, + gdouble y0) { GimpValueArray *args; GimpValueArray *return_vals; gint stroke_id = 0; args = gimp_value_array_new_from_types (NULL, - GIMP_TYPE_VECTORS, path, + GIMP_TYPE_PATH, path, G_TYPE_DOUBLE, x0, G_TYPE_DOUBLE, y0, G_TYPE_NONE); @@ -880,17 +880,17 @@ gimp_path_bezier_stroke_new_moveto (GimpVectors *path, * Since: 2.4 **/ gboolean -gimp_path_bezier_stroke_lineto (GimpVectors *path, - gint stroke_id, - gdouble x0, - gdouble y0) +gimp_path_bezier_stroke_lineto (GimpPath *path, + gint stroke_id, + gdouble x0, + gdouble y0) { GimpValueArray *args; GimpValueArray *return_vals; gboolean success = TRUE; args = gimp_value_array_new_from_types (NULL, - GIMP_TYPE_VECTORS, path, + GIMP_TYPE_PATH, path, G_TYPE_INT, stroke_id, G_TYPE_DOUBLE, x0, G_TYPE_DOUBLE, y0, @@ -928,19 +928,19 @@ gimp_path_bezier_stroke_lineto (GimpVectors *path, * Since: 2.4 **/ gboolean -gimp_path_bezier_stroke_conicto (GimpVectors *path, - gint stroke_id, - gdouble x0, - gdouble y0, - gdouble x1, - gdouble y1) +gimp_path_bezier_stroke_conicto (GimpPath *path, + gint stroke_id, + gdouble x0, + gdouble y0, + gdouble x1, + gdouble y1) { GimpValueArray *args; GimpValueArray *return_vals; gboolean success = TRUE; args = gimp_value_array_new_from_types (NULL, - GIMP_TYPE_VECTORS, path, + GIMP_TYPE_PATH, path, G_TYPE_INT, stroke_id, G_TYPE_DOUBLE, x0, G_TYPE_DOUBLE, y0, @@ -980,21 +980,21 @@ gimp_path_bezier_stroke_conicto (GimpVectors *path, * Since: 2.4 **/ gboolean -gimp_path_bezier_stroke_cubicto (GimpVectors *path, - gint stroke_id, - gdouble x0, - gdouble y0, - gdouble x1, - gdouble y1, - gdouble x2, - gdouble y2) +gimp_path_bezier_stroke_cubicto (GimpPath *path, + gint stroke_id, + gdouble x0, + gdouble y0, + gdouble x1, + gdouble y1, + gdouble x2, + gdouble y2) { GimpValueArray *args; GimpValueArray *return_vals; gboolean success = TRUE; args = gimp_value_array_new_from_types (NULL, - GIMP_TYPE_VECTORS, path, + GIMP_TYPE_PATH, path, G_TYPE_INT, stroke_id, G_TYPE_DOUBLE, x0, G_TYPE_DOUBLE, y0, @@ -1034,19 +1034,19 @@ gimp_path_bezier_stroke_cubicto (GimpVectors *path, * Since: 2.4 **/ gint -gimp_path_bezier_stroke_new_ellipse (GimpVectors *path, - gdouble x0, - gdouble y0, - gdouble radius_x, - gdouble radius_y, - gdouble angle) +gimp_path_bezier_stroke_new_ellipse (GimpPath *path, + gdouble x0, + gdouble y0, + gdouble radius_x, + gdouble radius_y, + gdouble angle) { GimpValueArray *args; GimpValueArray *return_vals; gint stroke_id = 0; args = gimp_value_array_new_from_types (NULL, - GIMP_TYPE_VECTORS, path, + GIMP_TYPE_PATH, path, G_TYPE_DOUBLE, x0, G_TYPE_DOUBLE, y0, G_TYPE_DOUBLE, radius_x, @@ -1074,7 +1074,7 @@ gimp_path_bezier_stroke_new_ellipse (GimpVectors *path, * @merge: Merge paths into a single path object. * @scale: Scale the SVG to image dimensions. * @num_paths: (out): The number of newly created path. - * @path: (out) (array length=num_paths) (element-type GimpVectors) (transfer container): The list of newly created path. + * @path: (out) (array length=num_paths) (element-type GimpPath) (transfer container): The list of newly created path. * * Import paths from an SVG file. * @@ -1086,12 +1086,12 @@ gimp_path_bezier_stroke_new_ellipse (GimpVectors *path, * Since: 2.4 **/ gboolean -gimp_path_import_from_file (GimpImage *image, - GFile *file, - gboolean merge, - gboolean scale, - gint *num_paths, - GimpVectors ***path) +gimp_path_import_from_file (GimpImage *image, + GFile *file, + gboolean merge, + gboolean scale, + gint *num_paths, + GimpPath ***path) { GimpValueArray *args; GimpValueArray *return_vals; @@ -1133,7 +1133,7 @@ gimp_path_import_from_file (GimpImage *image, * @merge: Merge paths into a single path object. * @scale: Scale the SVG to image dimensions. * @num_paths: (out): The number of newly created path. - * @path: (out) (array length=num_paths) (element-type GimpVectors) (transfer container): The list of newly created path. + * @path: (out) (array length=num_paths) (element-type GimpPath) (transfer container): The list of newly created path. * * Import paths from an SVG string. * @@ -1152,7 +1152,7 @@ gimp_path_import_from_string (GimpImage *image, gboolean merge, gboolean scale, gint *num_paths, - GimpVectors ***path) + GimpPath ***path) { GimpValueArray *args; GimpValueArray *return_vals; @@ -1205,9 +1205,9 @@ gimp_path_import_from_string (GimpImage *image, * Since: 2.6 **/ gboolean -gimp_path_export_to_file (GimpImage *image, - GFile *file, - GimpVectors *path) +gimp_path_export_to_file (GimpImage *image, + GFile *file, + GimpPath *path) { GimpValueArray *args; GimpValueArray *return_vals; @@ -1216,7 +1216,7 @@ gimp_path_export_to_file (GimpImage *image, args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_IMAGE, image, G_TYPE_FILE, file, - GIMP_TYPE_VECTORS, path, + GIMP_TYPE_PATH, path, G_TYPE_NONE); return_vals = _gimp_pdb_run_procedure_array (gimp_get_pdb (), @@ -1250,8 +1250,8 @@ gimp_path_export_to_file (GimpImage *image, * Since: 2.6 **/ gchar * -gimp_path_export_to_string (GimpImage *image, - GimpVectors *path) +gimp_path_export_to_string (GimpImage *image, + GimpPath *path) { GimpValueArray *args; GimpValueArray *return_vals; @@ -1259,7 +1259,7 @@ gimp_path_export_to_string (GimpImage *image, args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_IMAGE, image, - GIMP_TYPE_VECTORS, path, + GIMP_TYPE_PATH, path, G_TYPE_NONE); return_vals = _gimp_pdb_run_procedure_array (gimp_get_pdb (), diff --git a/libgimp/gimppath_pdb.h b/libgimp/gimppath_pdb.h index 48509f62a5..6c6d9e2298 100644 --- a/libgimp/gimppath_pdb.h +++ b/libgimp/gimppath_pdb.h @@ -32,17 +32,17 @@ G_BEGIN_DECLS /* For information look into the C source or the html documentation */ -GimpVectors* gimp_path_new (GimpImage *image, +GimpPath* gimp_path_new (GimpImage *image, const gchar *name); -GimpVectors* gimp_path_new_from_text_layer (GimpImage *image, +GimpPath* gimp_path_new_from_text_layer (GimpImage *image, GimpLayer *layer); -GimpVectors* gimp_path_copy (GimpVectors *path); -gint* gimp_path_get_strokes (GimpVectors *path, +GimpPath* gimp_path_copy (GimpPath *path); +gint* gimp_path_get_strokes (GimpPath *path, gint *num_strokes); -gdouble gimp_path_stroke_get_length (GimpVectors *path, +gdouble gimp_path_stroke_get_length (GimpPath *path, gint stroke_id, gdouble precision); -gboolean gimp_path_stroke_get_point_at_dist (GimpVectors *path, +gboolean gimp_path_stroke_get_point_at_dist (GimpPath *path, gint stroke_id, gdouble dist, gdouble precision, @@ -50,64 +50,64 @@ gboolean gimp_path_stroke_get_point_at_dist (GimpVectors gdouble *y_point, gdouble *slope, gboolean *valid); -gboolean gimp_path_remove_stroke (GimpVectors *path, +gboolean gimp_path_remove_stroke (GimpPath *path, gint stroke_id); -gboolean gimp_path_stroke_close (GimpVectors *path, +gboolean gimp_path_stroke_close (GimpPath *path, gint stroke_id); -gboolean gimp_path_stroke_reverse (GimpVectors *path, +gboolean gimp_path_stroke_reverse (GimpPath *path, gint stroke_id); -gboolean gimp_path_stroke_translate (GimpVectors *path, +gboolean gimp_path_stroke_translate (GimpPath *path, gint stroke_id, gdouble off_x, gdouble off_y); -gboolean gimp_path_stroke_scale (GimpVectors *path, +gboolean gimp_path_stroke_scale (GimpPath *path, gint stroke_id, gdouble scale_x, gdouble scale_y); -gboolean gimp_path_stroke_rotate (GimpVectors *path, +gboolean gimp_path_stroke_rotate (GimpPath *path, gint stroke_id, gdouble center_x, gdouble center_y, gdouble angle); -gboolean gimp_path_stroke_flip (GimpVectors *path, +gboolean gimp_path_stroke_flip (GimpPath *path, gint stroke_id, GimpOrientationType flip_type, gdouble axis); -gboolean gimp_path_stroke_flip_free (GimpVectors *path, +gboolean gimp_path_stroke_flip_free (GimpPath *path, gint stroke_id, gdouble x1, gdouble y1, gdouble x2, gdouble y2); -GimpVectorsStrokeType gimp_path_stroke_get_points (GimpVectors *path, +GimpVectorsStrokeType gimp_path_stroke_get_points (GimpPath *path, gint stroke_id, gint *num_points, gdouble **controlpoints, gboolean *closed); -gint gimp_path_stroke_new_from_points (GimpVectors *path, +gint gimp_path_stroke_new_from_points (GimpPath *path, GimpVectorsStrokeType type, gint num_points, const gdouble *controlpoints, gboolean closed); -gdouble* gimp_path_stroke_interpolate (GimpVectors *path, +gdouble* gimp_path_stroke_interpolate (GimpPath *path, gint stroke_id, gdouble precision, gint *num_coords, gboolean *closed); -gint gimp_path_bezier_stroke_new_moveto (GimpVectors *path, +gint gimp_path_bezier_stroke_new_moveto (GimpPath *path, gdouble x0, gdouble y0); -gboolean gimp_path_bezier_stroke_lineto (GimpVectors *path, +gboolean gimp_path_bezier_stroke_lineto (GimpPath *path, gint stroke_id, gdouble x0, gdouble y0); -gboolean gimp_path_bezier_stroke_conicto (GimpVectors *path, +gboolean gimp_path_bezier_stroke_conicto (GimpPath *path, gint stroke_id, gdouble x0, gdouble y0, gdouble x1, gdouble y1); -gboolean gimp_path_bezier_stroke_cubicto (GimpVectors *path, +gboolean gimp_path_bezier_stroke_cubicto (GimpPath *path, gint stroke_id, gdouble x0, gdouble y0, @@ -115,7 +115,7 @@ gboolean gimp_path_bezier_stroke_cubicto (GimpVectors gdouble y1, gdouble x2, gdouble y2); -gint gimp_path_bezier_stroke_new_ellipse (GimpVectors *path, +gint gimp_path_bezier_stroke_new_ellipse (GimpPath *path, gdouble x0, gdouble y0, gdouble radius_x, @@ -126,19 +126,19 @@ gboolean gimp_path_import_from_file (GimpImage gboolean merge, gboolean scale, gint *num_paths, - GimpVectors ***path); + GimpPath ***path); gboolean gimp_path_import_from_string (GimpImage *image, const gchar *string, gint length, gboolean merge, gboolean scale, gint *num_paths, - GimpVectors ***path); + GimpPath ***path); gboolean gimp_path_export_to_file (GimpImage *image, GFile *file, - GimpVectors *path); + GimpPath *path); gchar* gimp_path_export_to_string (GimpImage *image, - GimpVectors *path); + GimpPath *path); G_END_DECLS diff --git a/libgimp/gimpplugin.c b/libgimp/gimpplugin.c index a118f8adc9..97ff00ca1d 100644 --- a/libgimp/gimpplugin.c +++ b/libgimp/gimpplugin.c @@ -1602,7 +1602,7 @@ _gimp_plug_in_get_item (GimpPlugIn *plug_in, } else if (gimp_item_id_is_path (item_id)) { - item = g_object_new (GIMP_TYPE_VECTORS, + item = g_object_new (GIMP_TYPE_PATH, "id", item_id, NULL); } diff --git a/libgimp/gimpprocedure-params.c b/libgimp/gimpprocedure-params.c index 0abdc702aa..b1913a42db 100644 --- a/libgimp/gimpprocedure-params.c +++ b/libgimp/gimpprocedure-params.c @@ -2218,8 +2218,8 @@ gimp_procedure_add_vectors_argument (GimpProcedure *procedure, GParamFlags flags) { _gimp_procedure_add_argument (procedure, - gimp_param_spec_vectors (name, nick, blurb, - none_ok, flags)); + gimp_param_spec_path (name, nick, blurb, + none_ok, flags)); } /** @@ -2244,8 +2244,8 @@ gimp_procedure_add_vectors_aux_argument (GimpProcedure *procedure, GParamFlags flags) { _gimp_procedure_add_aux_argument (procedure, - gimp_param_spec_vectors (name, nick, blurb, - none_ok, flags)); + gimp_param_spec_path (name, nick, blurb, + none_ok, flags)); } /** @@ -2270,8 +2270,8 @@ gimp_procedure_add_vectors_return_value (GimpProcedure *procedure, GParamFlags flags) { _gimp_procedure_add_return_value (procedure, - gimp_param_spec_vectors (name, nick, blurb, - none_ok, flags)); + gimp_param_spec_path (name, nick, blurb, + none_ok, flags)); } /** diff --git a/libgimp/gimpprocedure-params.h b/libgimp/gimpprocedure-params.h index 616fed5389..c54cb9cb13 100644 --- a/libgimp/gimpprocedure-params.h +++ b/libgimp/gimpprocedure-params.h @@ -365,13 +365,13 @@ G_BEGIN_DECLS /* vectors */ -#define GIMP_VALUES_GET_VECTORS(args, n) \ +#define GIMP_VALUES_GET_PATH(args, n) \ g_value_get_object (gimp_value_array_index (args, n)) -#define GIMP_VALUES_GET_VECTORS_ID(args, n) \ +#define GIMP_VALUES_GET_PATH_ID(args, n) \ gimp_item_get_id (g_value_get_object (gimp_value_array_index (args, n))) -#define GIMP_VALUES_SET_VECTORS(args, n, value) \ +#define GIMP_VALUES_SET_PATH(args, n, value) \ g_value_set_object (gimp_value_array_index (args, n), value) diff --git a/libgimp/gimptypes.h b/libgimp/gimptypes.h index e376c17c87..904d9092b6 100644 --- a/libgimp/gimptypes.h +++ b/libgimp/gimptypes.h @@ -42,7 +42,7 @@ typedef struct _GimpChannel GimpChannel; typedef struct _GimpLayerMask GimpLayerMask; typedef struct _GimpSelection GimpSelection; typedef struct _GimpTextLayer GimpTextLayer; -typedef struct _GimpVectors GimpVectors; +typedef struct _GimpPath GimpPath; typedef struct _GimpDisplay GimpDisplay; diff --git a/libgimp/meson.build b/libgimp/meson.build index 09d311fce2..7a4aa82a51 100644 --- a/libgimp/meson.build +++ b/libgimp/meson.build @@ -193,6 +193,7 @@ libgimp_sources_introspectable = [ 'gimploadprocedure.c', 'gimppalette.c', 'gimpparamspecs.c', + 'gimppath.c', 'gimppattern.c', 'gimppdb.c', 'gimpplugin.c', @@ -206,7 +207,6 @@ libgimp_sources_introspectable = [ 'gimpselection.c', 'gimptextlayer.c', 'gimpthumbnailprocedure.c', - 'gimpvectors.c', 'gimpvectorloadprocedure.c', gimpenums, pdb_wrappers_sources, @@ -254,6 +254,7 @@ libgimp_headers_introspectable = [ 'gimploadprocedure.h', 'gimppalette.h', 'gimpparamspecs.h', + 'gimppath.h', 'gimppattern.h', 'gimppdb.h', 'gimpplugin.h', @@ -268,7 +269,6 @@ libgimp_headers_introspectable = [ 'gimptextlayer.h', 'gimpthumbnailprocedure.h', 'gimpvectorloadprocedure.h', - 'gimpvectors.h', pdb_wrappers_headers, ] diff --git a/libgimpconfig/gimpconfig-params.c b/libgimpconfig/gimpconfig-params.c index e0af57dbe7..b6c6636761 100644 --- a/libgimpconfig/gimpconfig-params.c +++ b/libgimpconfig/gimpconfig-params.c @@ -348,7 +348,7 @@ gimp_config_param_spec_duplicate (GParamSpec *pspec) g_strcmp0 (type_name, "GimpGradient") == 0 || g_strcmp0 (type_name, "GimpPalette") == 0 || g_strcmp0 (type_name, "GimpPattern") == 0 || - g_strcmp0 (type_name, "GimpVectors") == 0) + g_strcmp0 (type_name, "GimpPath") == 0) { copy = g_param_spec_object (name, nick, blurb, value_type, diff --git a/pdb/app.pl b/pdb/app.pl index 62b0c35663..6937e66b8a 100644 --- a/pdb/app.pl +++ b/pdb/app.pl @@ -379,14 +379,14 @@ gimp_param_spec_selection ("$name", $flags) CODE } - elsif ($pdbtype eq 'vectors') { + elsif ($pdbtype eq 'path') { $none_ok = exists $arg->{none_ok} ? 'TRUE' : 'FALSE'; $pspec = < 'paths', type => 'vectorarray', + { name => 'paths', type => 'patharray', desc => 'The list of paths contained in the image.', array => { name => 'num_paths', desc => 'The number of paths contained in the image' } } @@ -364,7 +364,7 @@ HELP { gint i; - paths = g_new (GimpVectors *, num_paths); + paths = g_new (GimpPath *, num_paths); for (i = 0; i < num_paths; i++, list = g_list_next (list)) paths[i] = g_object_ref (list->data); @@ -1225,9 +1225,9 @@ HELP @inargs = ( { name => 'image', type => 'image', desc => 'The image' }, - { name => 'path', type => 'vectors', + { name => 'path', type => 'path', desc => 'The path' }, - { name => 'parent', type => 'vectors', none_ok => 1, + { name => 'parent', type => 'path', none_ok => 1, desc => 'The parent path' }, { name => 'position', type => 'int32', desc => 'The path position' } @@ -1267,7 +1267,7 @@ HELP @inargs = ( { name => 'image', type => 'image', desc => 'The image' }, - { name => 'path', type => 'vectors', + { name => 'path', type => 'path', desc => 'The path object' } ); @@ -1962,7 +1962,7 @@ HELP ); @outargs = ( - { name => 'paths', type => 'vectorarray', + { name => 'paths', type => 'patharray', desc => 'The list of selected paths in the image.', array => { name => 'num_paths', desc => 'The number of selected paths in the image' } } @@ -1979,7 +1979,7 @@ HELP { gint i; - paths = g_new (GimpVectors *, num_paths); + paths = g_new (GimpPath *, num_paths); for (i = 0; i < num_paths; i++, list = g_list_next (list)) paths[i] = g_object_ref (list->data); @@ -2001,7 +2001,7 @@ HELP @inargs = ( { name => 'image', type => 'image', desc => 'The image' }, - { name => 'paths', type => 'vectorarray', + { name => 'paths', type => 'patharray', desc => 'The list of paths to select', no_validate => 1, array => { name => 'num_paths', @@ -2760,7 +2760,7 @@ HELP ); @outargs = ( - { name => 'path', type => 'vectors', + { name => 'path', type => 'path', desc => 'The path with the specified tattoo' } ); @@ -2851,7 +2851,7 @@ HELP ); @outargs = ( - { name => 'path', type => 'vectors', + { name => 'path', type => 'path', desc => 'The path with the specified name' } ); diff --git a/pdb/groups/item.pdb b/pdb/groups/item.pdb index 96ffa439aa..4dbb409454 100644 --- a/pdb/groups/item.pdb +++ b/pdb/groups/item.pdb @@ -295,7 +295,7 @@ HELP { GimpItem *item = gimp_item_get_by_id (gimp, item_id); - path = (GIMP_IS_VECTORS (item) && + path = (GIMP_IS_PATH (item) && ! gimp_item_is_removed (item)); } CODE @@ -1009,7 +1009,7 @@ CODE "core/gimplist.h" "core/gimpselection.h" "text/gimptextlayer.h" - "vectors/gimpvectors.h" + "vectors/gimppath.h" "gimppdb-utils.h" "gimppdbcontext.h" "gimp-intl.h"); diff --git a/pdb/groups/path.pdb b/pdb/groups/path.pdb index f6c745e77d..960546a450 100644 --- a/pdb/groups/path.pdb +++ b/pdb/groups/path.pdb @@ -32,7 +32,7 @@ HELP ); @outargs = ( - { name => 'path', type => 'vectors', + { name => 'path', type => 'path', desc => 'the current path object, 0 if no path exists in the image.' } ); @@ -64,7 +64,7 @@ HELP ); @outargs = ( - { name => 'path', type => 'vectors', + { name => 'path', type => 'path', desc => 'The path of the text layer.' } ); @@ -100,20 +100,20 @@ HELP barak_pdb_misc('2008', '2.6'); @inargs = ( - { name => 'path', type => 'vectors', + { name => 'path', type => 'path', desc => 'The path object to copy' } ); @outargs = ( - { name => 'path_copy', type => 'vectors', + { name => 'path_copy', type => 'path', desc => 'The newly copied path object' } ); %invoke = ( code => <<'CODE' { - path_copy = GIMP_VECTORS (gimp_item_duplicate (GIMP_ITEM (path), - G_TYPE_FROM_INSTANCE (path))); + path_copy = GIMP_PATH (gimp_item_duplicate (GIMP_ITEM (path), + G_TYPE_FROM_INSTANCE (path))); if (! path_copy) success = FALSE; @@ -132,7 +132,7 @@ HELP &simon_pdb_misc('2005', '2.4'); @inargs = ( - { name => 'path', type => 'vectors', + { name => 'path', type => 'path', desc => 'The path object' } ); @@ -175,7 +175,7 @@ sub path_stroke_get_length { &simon_pdb_misc('2005', '2.4'); @inargs = ( - { name => 'path', type => 'vectors', + { name => 'path', type => 'path', desc => 'The path object' }, { name => 'stroke_id', type => 'int32', desc => 'The stroke ID' }, @@ -216,7 +216,7 @@ HELP &simon_pdb_misc('2005', '2.4'); @inargs = ( - { name => 'path', type => 'vectors', + { name => 'path', type => 'path', desc => 'The path object' }, { name => 'stroke_id', type => 'int32', desc => 'The stroke ID' }, @@ -268,7 +268,7 @@ HELP &simon_pdb_misc('2005', '2.4'); @inargs = ( - { name => 'path', type => 'vectors', + { name => 'path', type => 'path', desc => 'The path object' }, { name => 'stroke_id', type => 'int32', desc => 'The stroke ID' } @@ -306,7 +306,7 @@ HELP &simon_pdb_misc('2005', '2.4'); @inargs = ( - { name => 'path', type => 'vectors', + { name => 'path', type => 'path', desc => 'The path object' }, { name => 'stroke_id', type => 'int32', desc => 'The stroke ID' } @@ -347,7 +347,7 @@ HELP &simon_pdb_misc('2020', '3.0'); @inargs = ( - { name => 'path', type => 'vectors', + { name => 'path', type => 'path', desc => 'The path object' }, { name => 'stroke_id', type => 'int32', desc => 'The stroke ID' } @@ -388,7 +388,7 @@ HELP &simon_pdb_misc('2005', '2.4'); @inargs = ( - { name => 'path', type => 'vectors', + { name => 'path', type => 'path', desc => 'The path object' }, { name => 'stroke_id', type => 'int32', desc => 'The stroke ID' }, @@ -434,7 +434,7 @@ HELP &simon_pdb_misc('2005', '2.4'); @inargs = ( - { name => 'path', type => 'vectors', + { name => 'path', type => 'path', desc => 'The path object' }, { name => 'stroke_id', type => 'int32', desc => 'The stroke ID' }, @@ -479,7 +479,7 @@ HELP &joao_pdb_misc('2006', '2.4'); @inargs = ( - { name => 'path', type => 'vectors', + { name => 'path', type => 'path', desc => 'The path object' }, { name => 'stroke_id', type => 'int32', desc => 'The stroke ID' }, @@ -526,7 +526,7 @@ HELP &joao_pdb_misc('2006', '2.4'); @inargs = ( - { name => 'path', type => 'vectors', + { name => 'path', type => 'path', desc => 'The path object' }, { name => 'stroke_id', type => 'int32', desc => 'The stroke ID' }, @@ -573,7 +573,7 @@ HELP &joao_pdb_misc('2006', '2.4'); @inargs = ( - { name => 'path', type => 'vectors', + { name => 'path', type => 'path', desc => 'The path object' }, { name => 'stroke_id', type => 'int32', desc => 'The stroke ID' }, @@ -626,7 +626,7 @@ HELP &simon_pdb_misc('2006', '2.4'); @inargs = ( - { name => 'path', type => 'vectors', + { name => 'path', type => 'path', desc => 'The path object' }, { name => 'stroke_id', type => 'int32', desc => 'The stroke ID' } @@ -692,7 +692,7 @@ HELP &simon_pdb_misc('2005', '2.4'); @inargs = ( - { name => 'path', type => 'vectors', + { name => 'path', type => 'path', desc => 'The path object' }, { name => 'stroke_id', type => 'int32', desc => 'The stroke ID' }, @@ -762,7 +762,7 @@ HELP &simon_pdb_misc('2006', '2.4'); @inargs = ( - { name => 'path', type => 'vectors', + { name => 'path', type => 'path', desc => 'The path object' }, { name => 'type', type => 'enum GimpVectorsStrokeType', desc => 'type of the stroke (always GIMP_VECTORS_STROKE_TYPE_BEZIER for now).' }, @@ -835,7 +835,7 @@ HELP &simon_pdb_misc('2005', '2.4'); @inargs = ( - { name => 'path', type => 'vectors', + { name => 'path', type => 'path', desc => 'The path object' }, { name => 'x0', type => 'float', desc => 'The x-coordinate of the moveto' }, @@ -890,7 +890,7 @@ HELP &simon_pdb_misc('2005', '2.4'); @inargs = ( - { name => 'path', type => 'vectors', + { name => 'path', type => 'path', desc => 'The path object' }, { name => 'stroke_id', type => 'int32', desc => 'The stroke ID' }, @@ -941,7 +941,7 @@ HELP &simon_pdb_misc('2005', '2.4'); @inargs = ( - { name => 'path', type => 'vectors', + { name => 'path', type => 'path', desc => 'The path object' }, { name => 'stroke_id', type => 'int32', desc => 'The stroke ID' }, @@ -998,7 +998,7 @@ HELP &simon_pdb_misc('2005', '2.4'); @inargs = ( - { name => 'path', type => 'vectors', + { name => 'path', type => 'path', desc => 'The path object' }, { name => 'stroke_id', type => 'int32', desc => 'The stroke ID' }, @@ -1063,7 +1063,7 @@ HELP &simon_pdb_misc('2005', '2.4'); @inargs = ( - { name => 'path', type => 'vectors', + { name => 'path', type => 'path', desc => 'The path object' }, { name => 'x0', type => 'float', desc => 'The x-coordinate of the center' }, @@ -1137,7 +1137,7 @@ HELP ); @outargs = ( - { name => 'path', type => 'vectorarray', void_ret => 1, + { name => 'path', type => 'patharray', void_ret => 1, desc => 'The list of newly created path', array => { name => 'num_paths', desc => 'The number of newly created path' } } @@ -1163,7 +1163,7 @@ HELP GList *list; gint i; - path = g_new (GimpVectors *, num_paths); + path = g_new (GimpPath *, num_paths); for (i = 0, list = path_list; i < num_paths; @@ -1206,7 +1206,7 @@ HELP ); @outargs = ( - { name => 'path', type => 'vectorarray', void_ret => 1, + { name => 'path', type => 'patharray', void_ret => 1, desc => 'The list of newly created path', array => { name => 'num_paths', desc => 'The number of newly created path' } } @@ -1232,7 +1232,7 @@ HELP GList *list; gint i; - path = g_new (GimpVectors *, num_paths); + path = g_new (GimpPath *, num_paths); for (i = 0, list = path_list; i < num_paths; @@ -1266,7 +1266,7 @@ HELP desc => 'The image' }, { name => 'file', type => 'file', desc => 'The SVG file to create.' }, - { name => 'path', type => 'vectors', + { name => 'path', type => 'path', no_validate => 1, none_ok => 1, desc => 'The path object to export, or %NULL for all in the image' } ); @@ -1303,7 +1303,7 @@ HELP @inargs = ( { name => 'image', type => 'image', desc => 'The image' }, - { name => 'path', type => 'vectors', + { name => 'path', type => 'path', no_validate => 1, none_ok => 1, desc => 'The path object to export, or %NULL for all in the image' } ); @@ -1341,7 +1341,7 @@ CODE "vectors/gimpanchor.h" "vectors/gimpstroke-new.h" "vectors/gimpbezierstroke.h" - "vectors/gimpvectors.h" + "vectors/gimppath.h" "gimppdb-utils.h" "gimp-intl.h"); diff --git a/pdb/pdb.pl b/pdb/pdb.pl index 80bc2dfbc9..90c5f51bea 100644 --- a/pdb/pdb.pl +++ b/pdb/pdb.pl @@ -161,18 +161,18 @@ package Gimp::CodeGen::pdb; set_value_func => 'gimp_value_set_object_array ($value, GIMP_TYPE_CHANNEL, (GObject **) $var, $var_len)', take_value_func => 'gimp_value_take_object_array ($value, GIMP_TYPE_CHANNEL, (GObject **) $var, $var_len)' }, - vectorarray => { name => 'VECTORSARRAY', + patharray => { name => 'PATHARRAY', gtype => 'GIMP_TYPE_OBJECT_ARRAY', - type => 'GimpVectors **', - const_type => 'const GimpVectors **', + type => 'GimpPath **', + const_type => 'const GimpPath **', array => 1, init_value => 'NULL', - in_annotate => '(element-type GimpVectors)', - out_annotate => '(element-type GimpVectors) (transfer container)', - get_value_func => '$var = (const GimpVectors **) gimp_value_get_object_array ($value)', + in_annotate => '(element-type GimpPath)', + out_annotate => '(element-type GimpPath) (transfer container)', + get_value_func => '$var = (const GimpPath **) gimp_value_get_object_array ($value)', dup_value_func => '{ GimpObjectArray *a = g_value_get_boxed (gimp_value_array_index ($value)); if (a) $var = g_memdup2 (a->data, a->length * sizeof (gpointer)); }', - set_value_func => 'gimp_value_set_object_array ($value, GIMP_TYPE_VECTORS, (GObject **) $var, $var_len)', - take_value_func => 'gimp_value_take_object_array ($value, GIMP_TYPE_VECTORS, (GObject **) $var, $var_len)' }, + set_value_func => 'gimp_value_set_object_array ($value, GIMP_TYPE_PATH, (GObject **) $var, $var_len)', + take_value_func => 'gimp_value_take_object_array ($value, GIMP_TYPE_PATH, (GObject **) $var, $var_len)' }, resourcearray => { name => 'RESOURCEARRAY', gtype => 'GIMP_TYPE_OBJECT_ARRAY', @@ -385,17 +385,17 @@ package Gimp::CodeGen::pdb; take_value_func => 'g_value_set_object ($value, $var)', headers => [ qw("core/gimplayermask.h") ] }, - vectors => { name => 'VECTORS', - gtype => 'GIMP_TYPE_VECTORS', - type => 'GimpVectors *', - const_type => 'GimpVectors *', + path => { name => 'PATH', + gtype => 'GIMP_TYPE_PATH', + type => 'GimpPath *', + const_type => 'GimpPath *', init_value => 'NULL', out_annotate => '(transfer none)', get_value_func => '$var = g_value_get_object ($value)', - dup_value_func => '$var = GIMP_VALUES_GET_VECTORS ($value)', + dup_value_func => '$var = GIMP_VALUES_GET_PATH ($value)', set_value_func => 'g_value_set_object ($value, $var)', take_value_func => 'g_value_set_object ($value, $var)', - headers => [ qw("vectors/gimpvectors.h") ] }, + headers => [ qw("vectors/gimppath.h") ] }, file => { name => 'FILE', gtype => 'G_TYPE_FILE', diff --git a/plug-ins/common/file-svg.c b/plug-ins/common/file-svg.c index f14c4bc012..3fc7292ade 100644 --- a/plug-ins/common/file-svg.c +++ b/plug-ins/common/file-svg.c @@ -497,8 +497,8 @@ svg_load (GimpProcedure *procedure, g_object_get (config, "paths", &import_paths, NULL); if (g_strcmp0 (import_paths, "no-import") != 0) { - GimpVectors **paths; - gint num_paths; + GimpPath **paths; + gint num_paths; gimp_path_import_from_file (image, file, g_strcmp0 (import_paths, "import-merged") == 0, diff --git a/plug-ins/file-psd/psd-image-res-load.c b/plug-ins/file-psd/psd-image-res-load.c index 5d24282c11..c6a9c7b0e3 100644 --- a/plug-ins/file-psd/psd-image-res-load.c +++ b/plug-ins/file-psd/psd-image-res-load.c @@ -1530,19 +1530,19 @@ load_resource_2000 (const PSDimageres *res_a, GInputStream *input, GError **error) { - gdouble *controlpoints; - gint32 x[3]; - gint32 y[3]; - GimpVectors *path = NULL; - gint16 type; - gint16 init_fill; - gint16 num_rec; - gint16 path_rec; - gint16 cntr; - gint image_width; - gint image_height; - gint i; - gboolean closed; + gdouble *controlpoints; + gint32 x[3]; + gint32 y[3]; + GimpPath *path = NULL; + gint16 type; + gint16 init_fill; + gint16 num_rec; + gint16 path_rec; + gint16 cntr; + gint image_width; + gint image_height; + gint i; + gboolean closed; /* Load path data from image resources 2000-2998 */ diff --git a/plug-ins/script-fu/libscriptfu/scheme-wrapper.c b/plug-ins/script-fu/libscriptfu/scheme-wrapper.c index 632bdc2779..0a1dfc3416 100644 --- a/plug-ins/script-fu/libscriptfu/scheme-wrapper.c +++ b/plug-ins/script-fu/libscriptfu/scheme-wrapper.c @@ -1033,16 +1033,16 @@ script_fu_marshal_procedure_call (scheme *sc, return error; } } - else if (GIMP_VALUE_HOLDS_VECTORS (&value)) + else if (GIMP_VALUE_HOLDS_PATH (&value)) { if (! sc->vptr->is_number (sc->vptr->pair_car (a))) return script_type_error (sc, "numeric", i, proc_name); else { - GimpVectors *vectors = - gimp_vectors_get_by_id (sc->vptr->ivalue (sc->vptr->pair_car (a))); + GimpPath *path = + gimp_path_get_by_id (sc->vptr->ivalue (sc->vptr->pair_car (a))); - g_value_set_object (&value, vectors); + g_value_set_object (&value, path); } } else if (GIMP_VALUE_HOLDS_ITEM (&value)) diff --git a/plug-ins/script-fu/libscriptfu/script-fu-script.c b/plug-ins/script-fu/libscriptfu/script-fu-script.c index 902922559a..9aa6df5900 100644 --- a/plug-ins/script-fu/libscriptfu/script-fu-script.c +++ b/plug-ins/script-fu/libscriptfu/script-fu-script.c @@ -289,7 +289,7 @@ script_fu_script_collect_standard_args (SFScript *script, params_consumed++; /* and may be followed by a DRAWABLE, LAYER, CHANNEL or - * VECTORS id + * PATH id */ if (script_fu_script_param_init (script, pspecs, n_pspecs, config, SF_DRAWABLE, @@ -543,7 +543,7 @@ script_fu_script_param_init (SFScript *script, break; case SF_VECTORS: - if (GIMP_VALUE_HOLDS_VECTORS (&value)) + if (GIMP_VALUE_HOLDS_PATH (&value)) { GimpItem *item = g_value_get_object (&value); diff --git a/plug-ins/selection-to-path/selection-to-path.c b/plug-ins/selection-to-path/selection-to-path.c index d17e18630a..266f41fb7a 100644 --- a/plug-ins/selection-to-path/selection-to-path.c +++ b/plug-ins/selection-to-path/selection-to-path.c @@ -512,7 +512,7 @@ static void do_points (spline_list_array_type in_splines, GimpImage *image) { - GimpVectors *path; + GimpPath *path; gint32 stroke; gint i, j; gboolean have_points = FALSE; diff --git a/po/POTFILES.in b/po/POTFILES.in index e685eb13c3..e6bbdcdede 100644 --- a/po/POTFILES.in +++ b/po/POTFILES.in @@ -529,7 +529,7 @@ app/tools/gimpwarpoptions.c app/tools/gimpwarptool.c app/tools/tools-enums.c -app/vectors/gimpvectors.c +app/vectors/gimppath.c app/vectors/gimpvectors-export.c app/vectors/gimpvectors-import.c