summaryrefslogtreecommitdiffstats
path: root/app/pdb/paths-cmds.c
diff options
context:
space:
mode:
authorDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-19 03:13:10 +0000
committerDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-19 03:13:10 +0000
commit3c57dd931145d43f2b0aef96c4d178135956bf91 (patch)
tree3de698981e9f0cc2c4f9569b19a5f3595e741f6b /app/pdb/paths-cmds.c
parentInitial commit. (diff)
downloadgimp-3c57dd931145d43f2b0aef96c4d178135956bf91.tar.xz
gimp-3c57dd931145d43f2b0aef96c4d178135956bf91.zip
Adding upstream version 2.10.36.upstream/2.10.36
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to '')
-rw-r--r--app/pdb/paths-cmds.c1283
1 files changed, 1283 insertions, 0 deletions
diff --git a/app/pdb/paths-cmds.c b/app/pdb/paths-cmds.c
new file mode 100644
index 0000000..5d7248f
--- /dev/null
+++ b/app/pdb/paths-cmds.c
@@ -0,0 +1,1283 @@
+/* GIMP - The GNU Image Manipulation Program
+ * Copyright (C) 1995-2003 Spencer Kimball and Peter Mattis
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+/* NOTE: This file is auto-generated by pdbgen.pl. */
+
+#include "config.h"
+
+#include <string.h>
+
+#include <gegl.h>
+
+#include <gdk-pixbuf/gdk-pixbuf.h>
+
+#include "libgimpconfig/gimpconfig.h"
+#include "libgimpmath/gimpmath.h"
+
+#include "libgimpbase/gimpbase.h"
+
+#include "pdb-types.h"
+
+#include "core/gimpimage.h"
+#include "core/gimplist.h"
+#include "core/gimpparamspecs.h"
+#include "core/gimpstrokeoptions.h"
+#include "vectors/gimpanchor.h"
+#include "vectors/gimpbezierstroke.h"
+#include "vectors/gimpvectors-compat.h"
+#include "vectors/gimpvectors-import.h"
+#include "vectors/gimpvectors.h"
+
+#include "gimppdb.h"
+#include "gimppdb-utils.h"
+#include "gimppdbcontext.h"
+#include "gimpprocedure.h"
+#include "internal-procs.h"
+
+#include "gimp-intl.h"
+
+
+static GimpValueArray *
+path_list_invoker (GimpProcedure *procedure,
+ Gimp *gimp,
+ GimpContext *context,
+ GimpProgress *progress,
+ const GimpValueArray *args,
+ GError **error)
+{
+ gboolean success = TRUE;
+ GimpValueArray *return_vals;
+ GimpImage *image;
+ gint32 num_paths = 0;
+ gchar **path_list = NULL;
+
+ image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp);
+
+ if (success)
+ {
+ path_list = gimp_container_get_name_array (gimp_image_get_vectors (image),
+ &num_paths);
+ }
+
+ return_vals = gimp_procedure_get_return_values (procedure, success,
+ error ? *error : NULL);
+
+ if (success)
+ {
+ g_value_set_int (gimp_value_array_index (return_vals, 1), num_paths);
+ gimp_value_take_stringarray (gimp_value_array_index (return_vals, 2), path_list, num_paths);
+ }
+
+ return return_vals;
+}
+
+static GimpValueArray *
+path_get_current_invoker (GimpProcedure *procedure,
+ Gimp *gimp,
+ GimpContext *context,
+ GimpProgress *progress,
+ const GimpValueArray *args,
+ GError **error)
+{
+ gboolean success = TRUE;
+ GimpValueArray *return_vals;
+ GimpImage *image;
+ gchar *name = NULL;
+
+ image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp);
+
+ if (success)
+ {
+ GimpVectors *vectors = gimp_image_get_active_vectors (image);
+
+ if (vectors)
+ name = g_strdup (gimp_object_get_name (vectors));
+ else
+ success = FALSE;
+ }
+
+ return_vals = gimp_procedure_get_return_values (procedure, success,
+ error ? *error : NULL);
+
+ if (success)
+ g_value_take_string (gimp_value_array_index (return_vals, 1), name);
+
+ return return_vals;
+}
+
+static GimpValueArray *
+path_set_current_invoker (GimpProcedure *procedure,
+ Gimp *gimp,
+ GimpContext *context,
+ GimpProgress *progress,
+ const GimpValueArray *args,
+ GError **error)
+{
+ gboolean success = TRUE;
+ GimpImage *image;
+ const gchar *name;
+
+ image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp);
+ name = g_value_get_string (gimp_value_array_index (args, 1));
+
+ if (success)
+ {
+ GimpVectors *vectors = gimp_image_get_vectors_by_name (image, name);
+
+ if (vectors)
+ gimp_image_set_active_vectors (image, vectors);
+ else
+ success = FALSE;
+ }
+
+ return gimp_procedure_get_return_values (procedure, success,
+ error ? *error : NULL);
+}
+
+static GimpValueArray *
+path_delete_invoker (GimpProcedure *procedure,
+ Gimp *gimp,
+ GimpContext *context,
+ GimpProgress *progress,
+ const GimpValueArray *args,
+ GError **error)
+{
+ gboolean success = TRUE;
+ GimpImage *image;
+ const gchar *name;
+
+ image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp);
+ name = g_value_get_string (gimp_value_array_index (args, 1));
+
+ if (success)
+ {
+ GimpVectors *vectors = gimp_image_get_vectors_by_name (image, name);
+
+ if (vectors)
+ gimp_image_remove_vectors (image, vectors, TRUE, NULL);
+ else
+ success = FALSE;
+ }
+
+ return gimp_procedure_get_return_values (procedure, success,
+ error ? *error : NULL);
+}
+
+static GimpValueArray *
+path_get_points_invoker (GimpProcedure *procedure,
+ Gimp *gimp,
+ GimpContext *context,
+ GimpProgress *progress,
+ const GimpValueArray *args,
+ GError **error)
+{
+ gboolean success = TRUE;
+ GimpValueArray *return_vals;
+ GimpImage *image;
+ const gchar *name;
+ gint32 path_type = 0;
+ gint32 path_closed = 0;
+ gint32 num_path_point_details = 0;
+ gdouble *points_pairs = NULL;
+
+ image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp);
+ name = g_value_get_string (gimp_value_array_index (args, 1));
+
+ if (success)
+ {
+ GimpVectors *vectors = gimp_image_get_vectors_by_name (image, name);
+
+ if (vectors)
+ {
+ GimpVectorsCompatPoint *points;
+ gint num_points;
+
+ path_type = 1; /* BEZIER (1.2 compat) */
+
+ points = gimp_vectors_compat_get_points (vectors, &num_points,
+ &path_closed);
+
+ num_path_point_details = num_points * 3;
+
+ if (points)
+ {
+ gdouble *curr_point;
+ gint i;
+
+ points_pairs = g_new0 (gdouble, num_path_point_details);
+
+ for (i = 0, curr_point = points_pairs;
+ i < num_points;
+ i++, curr_point += 3)
+ {
+ curr_point[0] = points[i].x;
+ curr_point[1] = points[i].y;
+ curr_point[2] = points[i].type;
+ }
+
+ g_free (points);
+ }
+ else
+ success = FALSE;
+ }
+ else
+ success = FALSE;
+ }
+
+ return_vals = gimp_procedure_get_return_values (procedure, success,
+ error ? *error : NULL);
+
+ if (success)
+ {
+ g_value_set_int (gimp_value_array_index (return_vals, 1), path_type);
+ g_value_set_int (gimp_value_array_index (return_vals, 2), path_closed);
+ g_value_set_int (gimp_value_array_index (return_vals, 3), num_path_point_details);
+ gimp_value_take_floatarray (gimp_value_array_index (return_vals, 4), points_pairs, num_path_point_details);
+ }
+
+ return return_vals;
+}
+
+static GimpValueArray *
+path_set_points_invoker (GimpProcedure *procedure,
+ Gimp *gimp,
+ GimpContext *context,
+ GimpProgress *progress,
+ const GimpValueArray *args,
+ GError **error)
+{
+ gboolean success = TRUE;
+ GimpImage *image;
+ const gchar *name;
+ gint32 num_path_points;
+ const gdouble *points_pairs;
+
+ image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp);
+ name = g_value_get_string (gimp_value_array_index (args, 1));
+ num_path_points = g_value_get_int (gimp_value_array_index (args, 3));
+ points_pairs = gimp_value_get_floatarray (gimp_value_array_index (args, 4));
+
+ if (success)
+ {
+ gboolean closed = FALSE;
+
+ if ((num_path_points / 3) % 3 == 0)
+ closed = TRUE;
+ else if ((num_path_points / 3) % 3 != 2)
+ success = FALSE;
+
+ if (success)
+ {
+ GimpVectors *vectors;
+ const gdouble *curr_point_pair;
+ GimpVectorsCompatPoint *points;
+ gint n_points;
+ gint i;
+
+ n_points = num_path_points / 3;
+
+ points = g_new0 (GimpVectorsCompatPoint, n_points);
+
+ for (i = 0, curr_point_pair = points_pairs;
+ i < n_points;
+ i++, curr_point_pair += 3)
+ {
+ points[i].x = curr_point_pair[0];
+ points[i].y = curr_point_pair[1];
+ points[i].type = curr_point_pair[2];
+ }
+
+ vectors = gimp_vectors_compat_new (image, name, points, n_points,
+ closed);
+
+ g_free (points);
+
+ if (vectors)
+ success = gimp_image_add_vectors (image, vectors, NULL, 0, TRUE);
+ else
+ success = FALSE;
+ }
+ }
+
+ return gimp_procedure_get_return_values (procedure, success,
+ error ? *error : NULL);
+}
+
+static GimpValueArray *
+path_stroke_current_invoker (GimpProcedure *procedure,
+ Gimp *gimp,
+ GimpContext *context,
+ GimpProgress *progress,
+ const GimpValueArray *args,
+ GError **error)
+{
+ gboolean success = TRUE;
+ GimpImage *image;
+
+ image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp);
+
+ if (success)
+ {
+ GimpVectors *vectors = gimp_image_get_active_vectors (image);
+ GimpDrawable *drawable = gimp_image_get_active_drawable (image);
+
+ if (vectors && drawable &&
+ gimp_pdb_item_is_modifiable (GIMP_ITEM (drawable),
+ GIMP_PDB_ITEM_CONTENT, error) &&
+ gimp_pdb_item_is_not_group (GIMP_ITEM (drawable), error))
+ {
+ GimpStrokeOptions *options;
+ GimpPaintOptions *paint_options;
+
+ options = gimp_stroke_options_new (gimp, context, TRUE);
+ g_object_set (options,
+ "method", GIMP_STROKE_PAINT_METHOD,
+ NULL);
+
+ paint_options =
+ gimp_pdb_context_get_paint_options (GIMP_PDB_CONTEXT (context), NULL);
+ paint_options = gimp_config_duplicate (GIMP_CONFIG (paint_options));
+
+ success = gimp_item_stroke (GIMP_ITEM (vectors),
+ drawable, context, options, paint_options,
+ TRUE, progress, error);
+
+ g_object_unref (options);
+ g_object_unref (paint_options);
+ }
+ else
+ success = FALSE;
+ }
+
+ return gimp_procedure_get_return_values (procedure, success,
+ error ? *error : NULL);
+}
+
+static GimpValueArray *
+path_get_point_at_dist_invoker (GimpProcedure *procedure,
+ Gimp *gimp,
+ GimpContext *context,
+ GimpProgress *progress,
+ const GimpValueArray *args,
+ GError **error)
+{
+ gboolean success = TRUE;
+ GimpValueArray *return_vals;
+ GimpImage *image;
+ gdouble distance;
+ gint32 x_point = 0;
+ gint32 y_point = 0;
+ gdouble slope = 0.0;
+
+ image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp);
+ distance = g_value_get_double (gimp_value_array_index (args, 1));
+
+ if (success)
+ {
+ GimpVectors *vectors;
+ GimpStroke *stroke;
+ gdouble distance_along;
+ gdouble stroke_length;
+ gdouble stroke_distance;
+ GimpCoords position;
+
+ vectors = gimp_image_get_active_vectors (image);
+
+ if (vectors)
+ {
+ distance_along = 0.0;
+ stroke = gimp_vectors_stroke_get_next (vectors, NULL);
+
+ while (stroke != NULL )
+ {
+ stroke_length = gimp_stroke_get_length (stroke, 0.5);
+
+ if (distance_along + stroke_length < distance)
+ {
+ distance_along += stroke_length;
+ }
+ else
+ {
+ stroke_distance = distance - distance_along;
+ stroke_distance = stroke_distance < 0 ? 0: stroke_distance;
+
+ if (!gimp_stroke_get_point_at_dist (stroke, stroke_distance, 0.5,
+ &position, &slope))
+ {
+ success = FALSE;
+ break;
+ }
+ else
+ {
+ success = TRUE;
+ x_point = ROUND (position.x);
+ y_point = ROUND (position.y);
+ break;
+ }
+ }
+
+ stroke = gimp_vectors_stroke_get_next (vectors, stroke);
+ }
+ }
+ else
+ {
+ success = FALSE;
+ }
+ }
+
+ return_vals = gimp_procedure_get_return_values (procedure, success,
+ error ? *error : NULL);
+
+ if (success)
+ {
+ g_value_set_int (gimp_value_array_index (return_vals, 1), x_point);
+ g_value_set_int (gimp_value_array_index (return_vals, 2), y_point);
+ g_value_set_double (gimp_value_array_index (return_vals, 3), slope);
+ }
+
+ return return_vals;
+}
+
+static GimpValueArray *
+path_get_tattoo_invoker (GimpProcedure *procedure,
+ Gimp *gimp,
+ GimpContext *context,
+ GimpProgress *progress,
+ const GimpValueArray *args,
+ GError **error)
+{
+ gboolean success = TRUE;
+ GimpValueArray *return_vals;
+ GimpImage *image;
+ const gchar *name;
+ gint32 tattoo = 0;
+
+ image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp);
+ name = g_value_get_string (gimp_value_array_index (args, 1));
+
+ if (success)
+ {
+ GimpVectors *vectors = gimp_image_get_vectors_by_name (image, name);
+
+ if (vectors)
+ tattoo = gimp_item_get_tattoo (GIMP_ITEM (vectors));
+ else
+ success = FALSE;
+ }
+
+ return_vals = gimp_procedure_get_return_values (procedure, success,
+ error ? *error : NULL);
+
+ if (success)
+ g_value_set_int (gimp_value_array_index (return_vals, 1), tattoo);
+
+ return return_vals;
+}
+
+static GimpValueArray *
+path_set_tattoo_invoker (GimpProcedure *procedure,
+ Gimp *gimp,
+ GimpContext *context,
+ GimpProgress *progress,
+ const GimpValueArray *args,
+ GError **error)
+{
+ gboolean success = TRUE;
+ GimpImage *image;
+ const gchar *name;
+ gint32 tattovalue;
+
+ image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp);
+ name = g_value_get_string (gimp_value_array_index (args, 1));
+ tattovalue = g_value_get_int (gimp_value_array_index (args, 2));
+
+ if (success)
+ {
+ GimpVectors *vectors = gimp_image_get_vectors_by_name (image, name);
+
+ if (vectors)
+ gimp_item_set_tattoo (GIMP_ITEM (vectors), tattovalue);
+ else
+ success = FALSE;
+ }
+
+ return gimp_procedure_get_return_values (procedure, success,
+ error ? *error : NULL);
+}
+
+static GimpValueArray *
+get_path_by_tattoo_invoker (GimpProcedure *procedure,
+ Gimp *gimp,
+ GimpContext *context,
+ GimpProgress *progress,
+ const GimpValueArray *args,
+ GError **error)
+{
+ gboolean success = TRUE;
+ GimpValueArray *return_vals;
+ GimpImage *image;
+ gint32 tattoo;
+ gchar *name = NULL;
+
+ image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp);
+ tattoo = g_value_get_int (gimp_value_array_index (args, 1));
+
+ if (success)
+ {
+ GimpVectors *vectors = gimp_image_get_vectors_by_tattoo (image, tattoo);
+
+ if (vectors)
+ name = g_strdup (gimp_object_get_name (vectors));
+ else
+ success = FALSE;
+ }
+
+ return_vals = gimp_procedure_get_return_values (procedure, success,
+ error ? *error : NULL);
+
+ if (success)
+ g_value_take_string (gimp_value_array_index (return_vals, 1), name);
+
+ return return_vals;
+}
+
+static GimpValueArray *
+path_get_locked_invoker (GimpProcedure *procedure,
+ Gimp *gimp,
+ GimpContext *context,
+ GimpProgress *progress,
+ const GimpValueArray *args,
+ GError **error)
+{
+ gboolean success = TRUE;
+ GimpValueArray *return_vals;
+ GimpImage *image;
+ const gchar *name;
+ gboolean locked = FALSE;
+
+ image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp);
+ name = g_value_get_string (gimp_value_array_index (args, 1));
+
+ if (success)
+ {
+ GimpVectors *vectors = gimp_image_get_vectors_by_name (image, name);
+
+ if (vectors)
+ locked = gimp_item_get_linked (GIMP_ITEM (vectors));
+ else
+ success = FALSE;
+ }
+
+ return_vals = gimp_procedure_get_return_values (procedure, success,
+ error ? *error : NULL);
+
+ if (success)
+ g_value_set_boolean (gimp_value_array_index (return_vals, 1), locked);
+
+ return return_vals;
+}
+
+static GimpValueArray *
+path_set_locked_invoker (GimpProcedure *procedure,
+ Gimp *gimp,
+ GimpContext *context,
+ GimpProgress *progress,
+ const GimpValueArray *args,
+ GError **error)
+{
+ gboolean success = TRUE;
+ GimpImage *image;
+ const gchar *name;
+ gboolean locked;
+
+ image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp);
+ name = g_value_get_string (gimp_value_array_index (args, 1));
+ locked = g_value_get_boolean (gimp_value_array_index (args, 2));
+
+ if (success)
+ {
+ GimpVectors *vectors = gimp_image_get_vectors_by_name (image, name);
+
+ if (vectors)
+ gimp_item_set_linked (GIMP_ITEM (vectors), locked, TRUE);
+ else
+ success = FALSE;
+ }
+
+ return gimp_procedure_get_return_values (procedure, success,
+ error ? *error : NULL);
+}
+
+static GimpValueArray *
+path_to_selection_invoker (GimpProcedure *procedure,
+ Gimp *gimp,
+ GimpContext *context,
+ GimpProgress *progress,
+ const GimpValueArray *args,
+ GError **error)
+{
+ gboolean success = TRUE;
+ GimpImage *image;
+ const gchar *name;
+ gint32 op;
+ gboolean antialias;
+ gboolean feather;
+ gdouble feather_radius_x;
+ gdouble feather_radius_y;
+
+ image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp);
+ name = g_value_get_string (gimp_value_array_index (args, 1));
+ op = g_value_get_enum (gimp_value_array_index (args, 2));
+ antialias = g_value_get_boolean (gimp_value_array_index (args, 3));
+ feather = g_value_get_boolean (gimp_value_array_index (args, 4));
+ feather_radius_x = g_value_get_double (gimp_value_array_index (args, 5));
+ feather_radius_y = g_value_get_double (gimp_value_array_index (args, 6));
+
+ if (success)
+ {
+ GimpVectors *vectors = gimp_image_get_vectors_by_name (image, name);
+
+ if (vectors)
+ gimp_item_to_selection (GIMP_ITEM (vectors),
+ op,
+ antialias,
+ feather,
+ feather_radius_x,
+ feather_radius_y);
+ else
+ success = FALSE;
+ }
+
+ return gimp_procedure_get_return_values (procedure, success,
+ error ? *error : NULL);
+}
+
+static GimpValueArray *
+path_import_invoker (GimpProcedure *procedure,
+ Gimp *gimp,
+ GimpContext *context,
+ GimpProgress *progress,
+ const GimpValueArray *args,
+ GError **error)
+{
+ gboolean success = TRUE;
+ GimpImage *image;
+ const gchar *filename;
+ gboolean merge;
+ gboolean scale;
+
+ image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp);
+ filename = g_value_get_string (gimp_value_array_index (args, 1));
+ merge = g_value_get_boolean (gimp_value_array_index (args, 2));
+ scale = g_value_get_boolean (gimp_value_array_index (args, 3));
+
+ if (success)
+ {
+ GFile *file = g_file_new_for_path (filename);
+
+ success = gimp_vectors_import_file (image, file,
+ merge, scale, NULL, -1, NULL, NULL);
+
+ g_object_unref (file);
+ }
+
+ return gimp_procedure_get_return_values (procedure, success,
+ error ? *error : NULL);
+}
+
+void
+register_paths_procs (GimpPDB *pdb)
+{
+ GimpProcedure *procedure;
+
+ /*
+ * gimp-path-list
+ */
+ procedure = gimp_procedure_new (path_list_invoker);
+ gimp_object_set_static_name (GIMP_OBJECT (procedure),
+ "gimp-path-list");
+ gimp_procedure_set_static_strings (procedure,
+ "gimp-path-list",
+ "Deprecated: Use 'gimp-image-get-vectors' instead.",
+ "Deprecated: Use 'gimp-image-get-vectors' instead.",
+ "",
+ "",
+ "",
+ "gimp-image-get-vectors");
+ gimp_procedure_add_argument (procedure,
+ gimp_param_spec_image_id ("image",
+ "image",
+ "The image to list the paths from",
+ pdb->gimp, FALSE,
+ GIMP_PARAM_READWRITE));
+ gimp_procedure_add_return_value (procedure,
+ gimp_param_spec_int32 ("num-paths",
+ "num paths",
+ "The number of paths returned.",
+ 0, G_MAXINT32, 0,
+ GIMP_PARAM_READWRITE));
+ gimp_procedure_add_return_value (procedure,
+ gimp_param_spec_string_array ("path-list",
+ "path list",
+ "List of the paths belonging to this image",
+ GIMP_PARAM_READWRITE));
+ gimp_pdb_register_procedure (pdb, procedure);
+ g_object_unref (procedure);
+
+ /*
+ * gimp-path-get-current
+ */
+ procedure = gimp_procedure_new (path_get_current_invoker);
+ gimp_object_set_static_name (GIMP_OBJECT (procedure),
+ "gimp-path-get-current");
+ gimp_procedure_set_static_strings (procedure,
+ "gimp-path-get-current",
+ "Deprecated: Use 'gimp-image-get-active-vectors' instead.",
+ "Deprecated: Use 'gimp-image-get-active-vectors' instead.",
+ "",
+ "",
+ "",
+ "gimp-image-get-active-vectors");
+ gimp_procedure_add_argument (procedure,
+ gimp_param_spec_image_id ("image",
+ "image",
+ "The image to get the current path from",
+ pdb->gimp, FALSE,
+ GIMP_PARAM_READWRITE));
+ gimp_procedure_add_return_value (procedure,
+ gimp_param_spec_string ("name",
+ "name",
+ "The name of the current path.",
+ FALSE, FALSE, FALSE,
+ NULL,
+ GIMP_PARAM_READWRITE));
+ gimp_pdb_register_procedure (pdb, procedure);
+ g_object_unref (procedure);
+
+ /*
+ * gimp-path-set-current
+ */
+ procedure = gimp_procedure_new (path_set_current_invoker);
+ gimp_object_set_static_name (GIMP_OBJECT (procedure),
+ "gimp-path-set-current");
+ gimp_procedure_set_static_strings (procedure,
+ "gimp-path-set-current",
+ "Deprecated: Use 'gimp-image-set-active-vectors' instead.",
+ "Deprecated: Use 'gimp-image-set-active-vectors' instead.",
+ "",
+ "",
+ "",
+ "gimp-image-set-active-vectors");
+ gimp_procedure_add_argument (procedure,
+ gimp_param_spec_image_id ("image",
+ "image",
+ "The image in which a path will become current",
+ pdb->gimp, FALSE,
+ GIMP_PARAM_READWRITE));
+ gimp_procedure_add_argument (procedure,
+ gimp_param_spec_string ("name",
+ "name",
+ "The name of the path to make current.",
+ FALSE, FALSE, FALSE,
+ NULL,
+ GIMP_PARAM_READWRITE));
+ gimp_pdb_register_procedure (pdb, procedure);
+ g_object_unref (procedure);
+
+ /*
+ * gimp-path-delete
+ */
+ procedure = gimp_procedure_new (path_delete_invoker);
+ gimp_object_set_static_name (GIMP_OBJECT (procedure),
+ "gimp-path-delete");
+ gimp_procedure_set_static_strings (procedure,
+ "gimp-path-delete",
+ "Deprecated: Use 'gimp-image-remove-vectors' instead.",
+ "Deprecated: Use 'gimp-image-remove-vectors' instead.",
+ "",
+ "",
+ "",
+ "gimp-image-remove-vectors");
+ gimp_procedure_add_argument (procedure,
+ gimp_param_spec_image_id ("image",
+ "image",
+ "The image to delete the path from",
+ pdb->gimp, FALSE,
+ GIMP_PARAM_READWRITE));
+ gimp_procedure_add_argument (procedure,
+ gimp_param_spec_string ("name",
+ "name",
+ "The name of the path to delete.",
+ FALSE, FALSE, FALSE,
+ NULL,
+ GIMP_PARAM_READWRITE));
+ gimp_pdb_register_procedure (pdb, procedure);
+ g_object_unref (procedure);
+
+ /*
+ * gimp-path-get-points
+ */
+ procedure = gimp_procedure_new (path_get_points_invoker);
+ gimp_object_set_static_name (GIMP_OBJECT (procedure),
+ "gimp-path-get-points");
+ gimp_procedure_set_static_strings (procedure,
+ "gimp-path-get-points",
+ "Deprecated: Use 'gimp-vectors-stroke-get-points' instead.",
+ "Deprecated: Use 'gimp-vectors-stroke-get-points' instead.",
+ "",
+ "",
+ "",
+ "gimp-vectors-stroke-get-points");
+ gimp_procedure_add_argument (procedure,
+ gimp_param_spec_image_id ("image",
+ "image",
+ "The image to list the paths from",
+ pdb->gimp, FALSE,
+ GIMP_PARAM_READWRITE));
+ gimp_procedure_add_argument (procedure,
+ gimp_param_spec_string ("name",
+ "name",
+ "The name of the path whose points should be listed.",
+ FALSE, FALSE, FALSE,
+ NULL,
+ GIMP_PARAM_READWRITE));
+ gimp_procedure_add_return_value (procedure,
+ gimp_param_spec_int32 ("path-type",
+ "path type",
+ "The type of the path. Currently only one type (1 = Bezier) is supported",
+ G_MININT32, G_MAXINT32, 0,
+ GIMP_PARAM_READWRITE));
+ gimp_procedure_add_return_value (procedure,
+ gimp_param_spec_int32 ("path-closed",
+ "path closed",
+ "Return if the path is closed. (0 = path open, 1 = path closed)",
+ G_MININT32, G_MAXINT32, 0,
+ GIMP_PARAM_READWRITE));
+ gimp_procedure_add_return_value (procedure,
+ gimp_param_spec_int32 ("num-path-point-details",
+ "num path point details",
+ "The number of points returned. Each point is made up of (x, y, pnt_type) of floats.",
+ 0, G_MAXINT32, 0,
+ GIMP_PARAM_READWRITE));
+ gimp_procedure_add_return_value (procedure,
+ gimp_param_spec_float_array ("points-pairs",
+ "points pairs",
+ "The points in the path represented as 3 floats. The first is the x pos, next is the y pos, last is the type of the pnt. The type field is dependent on the path type. For beziers (type 1 paths) the type can either be (1.0 = BEZIER_ANCHOR, 2.0 = BEZIER_CONTROL, 3.0 = BEZIER_MOVE). Note all points are returned in pixel resolution.",
+ GIMP_PARAM_READWRITE));
+ gimp_pdb_register_procedure (pdb, procedure);
+ g_object_unref (procedure);
+
+ /*
+ * gimp-path-set-points
+ */
+ procedure = gimp_procedure_new (path_set_points_invoker);
+ gimp_object_set_static_name (GIMP_OBJECT (procedure),
+ "gimp-path-set-points");
+ gimp_procedure_set_static_strings (procedure,
+ "gimp-path-set-points",
+ "Deprecated: Use 'gimp-vectors-stroke-new-from-points' instead.",
+ "Deprecated: Use 'gimp-vectors-stroke-new-from-points' instead.",
+ "",
+ "",
+ "",
+ "gimp-vectors-stroke-new-from-points");
+ gimp_procedure_add_argument (procedure,
+ gimp_param_spec_image_id ("image",
+ "image",
+ "The image to set the paths in",
+ pdb->gimp, FALSE,
+ GIMP_PARAM_READWRITE));
+ gimp_procedure_add_argument (procedure,
+ gimp_param_spec_string ("name",
+ "name",
+ "The name of the path to create. If it exists then a unique name will be created - query the list of paths if you want to make sure that the name of the path you create is unique. This will be set as the current path.",
+ FALSE, FALSE, FALSE,
+ NULL,
+ GIMP_PARAM_READWRITE));
+ gimp_procedure_add_argument (procedure,
+ gimp_param_spec_int32 ("ptype",
+ "ptype",
+ "The type of the path. Currently only one type (1 = Bezier) is supported.",
+ G_MININT32, G_MAXINT32, 0,
+ GIMP_PARAM_READWRITE));
+ gimp_procedure_add_argument (procedure,
+ gimp_param_spec_int32 ("num-path-points",
+ "num path points",
+ "The number of elements in the array, i.e. the number of points in the path * 3. Each point is made up of (x, y, type) of floats. Currently only the creation of bezier curves is allowed. The type parameter must be set to (1) to indicate a BEZIER type curve. Note that for BEZIER curves, points must be given in the following order: ACCACCAC... If the path is not closed the last control point is missed off. Points consist of three control points (control/anchor/control) so for a curve that is not closed there must be at least two points passed (2 x,y pairs). If (num_path_points/3) % 3 = 0 then the path is assumed to be closed and the points are ACCACCACCACC.",
+ 0, G_MAXINT32, 0,
+ GIMP_PARAM_READWRITE));
+ gimp_procedure_add_argument (procedure,
+ gimp_param_spec_float_array ("points-pairs",
+ "points pairs",
+ "The points in the path represented as 3 floats. The first is the x pos, next is the y pos, last is the type of the pnt. The type field is dependent on the path type. For beziers (type 1 paths) the type can either be (1.0 = BEZIER_ANCHOR, 2.0 = BEZIER_CONTROL, 3.0= BEZIER_MOVE). Note all points are returned in pixel resolution.",
+ GIMP_PARAM_READWRITE));
+ gimp_pdb_register_procedure (pdb, procedure);
+ g_object_unref (procedure);
+
+ /*
+ * gimp-path-stroke-current
+ */
+ procedure = gimp_procedure_new (path_stroke_current_invoker);
+ gimp_object_set_static_name (GIMP_OBJECT (procedure),
+ "gimp-path-stroke-current");
+ gimp_procedure_set_static_strings (procedure,
+ "gimp-path-stroke-current",
+ "Deprecated: Use 'gimp-edit-stroke-vectors' instead.",
+ "Deprecated: Use 'gimp-edit-stroke-vectors' instead.",
+ "",
+ "",
+ "",
+ "gimp-edit-stroke-vectors");
+ gimp_procedure_add_argument (procedure,
+ gimp_param_spec_image_id ("image",
+ "image",
+ "The image which contains the path to stroke",
+ pdb->gimp, FALSE,
+ GIMP_PARAM_READWRITE));
+ gimp_pdb_register_procedure (pdb, procedure);
+ g_object_unref (procedure);
+
+ /*
+ * gimp-path-get-point-at-dist
+ */
+ procedure = gimp_procedure_new (path_get_point_at_dist_invoker);
+ gimp_object_set_static_name (GIMP_OBJECT (procedure),
+ "gimp-path-get-point-at-dist");
+ gimp_procedure_set_static_strings (procedure,
+ "gimp-path-get-point-at-dist",
+ "Deprecated: Use 'gimp-vectors-stroke-get-point-at-dist' instead.",
+ "Deprecated: Use 'gimp-vectors-stroke-get-point-at-dist' instead.",
+ "",
+ "",
+ "",
+ "gimp-vectors-stroke-get-point-at-dist");
+ gimp_procedure_add_argument (procedure,
+ gimp_param_spec_image_id ("image",
+ "image",
+ "The image the paths belongs to",
+ pdb->gimp, FALSE,
+ GIMP_PARAM_READWRITE));
+ gimp_procedure_add_argument (procedure,
+ g_param_spec_double ("distance",
+ "distance",
+ "The distance along the path.",
+ -G_MAXDOUBLE, G_MAXDOUBLE, 0,
+ GIMP_PARAM_READWRITE));
+ gimp_procedure_add_return_value (procedure,
+ gimp_param_spec_int32 ("x-point",
+ "x point",
+ "The x position of the point.",
+ G_MININT32, G_MAXINT32, 0,
+ GIMP_PARAM_READWRITE));
+ gimp_procedure_add_return_value (procedure,
+ gimp_param_spec_int32 ("y-point",
+ "y point",
+ "The y position of the point.",
+ G_MININT32, G_MAXINT32, 0,
+ GIMP_PARAM_READWRITE));
+ gimp_procedure_add_return_value (procedure,
+ g_param_spec_double ("slope",
+ "slope",
+ "The slope (dy / dx) at the specified point.",
+ -G_MAXDOUBLE, G_MAXDOUBLE, 0,
+ GIMP_PARAM_READWRITE));
+ gimp_pdb_register_procedure (pdb, procedure);
+ g_object_unref (procedure);
+
+ /*
+ * gimp-path-get-tattoo
+ */
+ procedure = gimp_procedure_new (path_get_tattoo_invoker);
+ gimp_object_set_static_name (GIMP_OBJECT (procedure),
+ "gimp-path-get-tattoo");
+ gimp_procedure_set_static_strings (procedure,
+ "gimp-path-get-tattoo",
+ "Deprecated: Use 'gimp-vectors-get-tattoo' instead.",
+ "Deprecated: Use 'gimp-vectors-get-tattoo' instead.",
+ "",
+ "",
+ "",
+ "gimp-vectors-get-tattoo");
+ gimp_procedure_add_argument (procedure,
+ gimp_param_spec_image_id ("image",
+ "image",
+ "The image",
+ pdb->gimp, FALSE,
+ GIMP_PARAM_READWRITE));
+ gimp_procedure_add_argument (procedure,
+ gimp_param_spec_string ("name",
+ "name",
+ "The name of the path whose tattoo should be obtained.",
+ FALSE, FALSE, FALSE,
+ NULL,
+ GIMP_PARAM_READWRITE));
+ gimp_procedure_add_return_value (procedure,
+ gimp_param_spec_int32 ("tattoo",
+ "tattoo",
+ "The tattoo associated with the named path.",
+ G_MININT32, G_MAXINT32, 0,
+ GIMP_PARAM_READWRITE));
+ gimp_pdb_register_procedure (pdb, procedure);
+ g_object_unref (procedure);
+
+ /*
+ * gimp-path-set-tattoo
+ */
+ procedure = gimp_procedure_new (path_set_tattoo_invoker);
+ gimp_object_set_static_name (GIMP_OBJECT (procedure),
+ "gimp-path-set-tattoo");
+ gimp_procedure_set_static_strings (procedure,
+ "gimp-path-set-tattoo",
+ "Deprecated: Use 'gimp-vectors-set-tattoo' instead.",
+ "Deprecated: Use 'gimp-vectors-set-tattoo' instead.",
+ "",
+ "",
+ "",
+ "gimp-vectors-set-tattoo");
+ gimp_procedure_add_argument (procedure,
+ gimp_param_spec_image_id ("image",
+ "image",
+ "The image",
+ pdb->gimp, FALSE,
+ GIMP_PARAM_READWRITE));
+ gimp_procedure_add_argument (procedure,
+ gimp_param_spec_string ("name",
+ "name",
+ "the name of the path whose tattoo should be set",
+ FALSE, FALSE, FALSE,
+ NULL,
+ GIMP_PARAM_READWRITE));
+ gimp_procedure_add_argument (procedure,
+ gimp_param_spec_int32 ("tattovalue",
+ "tattovalue",
+ "The tattoo associated with the name path. Only values returned from 'path_get_tattoo' should be used here",
+ G_MININT32, G_MAXINT32, 0,
+ GIMP_PARAM_READWRITE));
+ gimp_pdb_register_procedure (pdb, procedure);
+ g_object_unref (procedure);
+
+ /*
+ * gimp-get-path-by-tattoo
+ */
+ procedure = gimp_procedure_new (get_path_by_tattoo_invoker);
+ gimp_object_set_static_name (GIMP_OBJECT (procedure),
+ "gimp-get-path-by-tattoo");
+ gimp_procedure_set_static_strings (procedure,
+ "gimp-get-path-by-tattoo",
+ "Deprecated: Use 'gimp-image-get-vectors-by-tattoo' instead.",
+ "Deprecated: Use 'gimp-image-get-vectors-by-tattoo' instead.",
+ "",
+ "",
+ "",
+ "gimp-image-get-vectors-by-tattoo");
+ gimp_procedure_add_argument (procedure,
+ gimp_param_spec_image_id ("image",
+ "image",
+ "The image",
+ pdb->gimp, FALSE,
+ GIMP_PARAM_READWRITE));
+ gimp_procedure_add_argument (procedure,
+ gimp_param_spec_int32 ("tattoo",
+ "tattoo",
+ "The tattoo of the required path.",
+ G_MININT32, G_MAXINT32, 0,
+ GIMP_PARAM_READWRITE));
+ gimp_procedure_add_return_value (procedure,
+ gimp_param_spec_string ("name",
+ "name",
+ "The name of the path with the specified tattoo.",
+ FALSE, FALSE, FALSE,
+ NULL,
+ GIMP_PARAM_READWRITE));
+ gimp_pdb_register_procedure (pdb, procedure);
+ g_object_unref (procedure);
+
+ /*
+ * gimp-path-get-locked
+ */
+ procedure = gimp_procedure_new (path_get_locked_invoker);
+ gimp_object_set_static_name (GIMP_OBJECT (procedure),
+ "gimp-path-get-locked");
+ gimp_procedure_set_static_strings (procedure,
+ "gimp-path-get-locked",
+ "Deprecated: Use 'gimp-vectors-get-linked' instead.",
+ "Deprecated: Use 'gimp-vectors-get-linked' instead.",
+ "",
+ "",
+ "",
+ "gimp-vectors-get-linked");
+ gimp_procedure_add_argument (procedure,
+ gimp_param_spec_image_id ("image",
+ "image",
+ "The image",
+ pdb->gimp, FALSE,
+ GIMP_PARAM_READWRITE));
+ gimp_procedure_add_argument (procedure,
+ gimp_param_spec_string ("name",
+ "name",
+ "The name of the path whose locked status should be obtained.",
+ FALSE, FALSE, FALSE,
+ NULL,
+ GIMP_PARAM_READWRITE));
+ gimp_procedure_add_return_value (procedure,
+ g_param_spec_boolean ("locked",
+ "locked",
+ "TRUE if the path is locked, FALSE otherwise",
+ FALSE,
+ GIMP_PARAM_READWRITE));
+ gimp_pdb_register_procedure (pdb, procedure);
+ g_object_unref (procedure);
+
+ /*
+ * gimp-path-set-locked
+ */
+ procedure = gimp_procedure_new (path_set_locked_invoker);
+ gimp_object_set_static_name (GIMP_OBJECT (procedure),
+ "gimp-path-set-locked");
+ gimp_procedure_set_static_strings (procedure,
+ "gimp-path-set-locked",
+ "Deprecated: Use 'gimp-vectors-set-linked' instead.",
+ "Deprecated: Use 'gimp-vectors-set-linked' instead.",
+ "",
+ "",
+ "",
+ "gimp-vectors-set-linked");
+ gimp_procedure_add_argument (procedure,
+ gimp_param_spec_image_id ("image",
+ "image",
+ "The image",
+ pdb->gimp, FALSE,
+ GIMP_PARAM_READWRITE));
+ gimp_procedure_add_argument (procedure,
+ gimp_param_spec_string ("name",
+ "name",
+ "the name of the path whose locked status should be set",
+ FALSE, FALSE, FALSE,
+ NULL,
+ GIMP_PARAM_READWRITE));
+ gimp_procedure_add_argument (procedure,
+ g_param_spec_boolean ("locked",
+ "locked",
+ "Whether the path is locked",
+ FALSE,
+ GIMP_PARAM_READWRITE));
+ gimp_pdb_register_procedure (pdb, procedure);
+ g_object_unref (procedure);
+
+ /*
+ * gimp-path-to-selection
+ */
+ procedure = gimp_procedure_new (path_to_selection_invoker);
+ gimp_object_set_static_name (GIMP_OBJECT (procedure),
+ "gimp-path-to-selection");
+ gimp_procedure_set_static_strings (procedure,
+ "gimp-path-to-selection",
+ "Deprecated: Use 'gimp-vectors-to-selection' instead.",
+ "Deprecated: Use 'gimp-vectors-to-selection' instead.",
+ "",
+ "",
+ "",
+ "gimp-vectors-to-selection");
+ gimp_procedure_add_argument (procedure,
+ gimp_param_spec_image_id ("image",
+ "image",
+ "The image",
+ pdb->gimp, FALSE,
+ GIMP_PARAM_READWRITE));
+ gimp_procedure_add_argument (procedure,
+ gimp_param_spec_string ("name",
+ "name",
+ "The name of the path which should be made into selection.",
+ FALSE, FALSE, FALSE,
+ NULL,
+ GIMP_PARAM_READWRITE));
+ gimp_procedure_add_argument (procedure,
+ g_param_spec_enum ("op",
+ "op",
+ "The desired operation with current selection",
+ GIMP_TYPE_CHANNEL_OPS,
+ GIMP_CHANNEL_OP_ADD,
+ GIMP_PARAM_READWRITE));
+ gimp_procedure_add_argument (procedure,
+ g_param_spec_boolean ("antialias",
+ "antialias",
+ "Antialias selection.",
+ FALSE,
+ GIMP_PARAM_READWRITE));
+ gimp_procedure_add_argument (procedure,
+ g_param_spec_boolean ("feather",
+ "feather",
+ "Feather selection.",
+ FALSE,
+ GIMP_PARAM_READWRITE));
+ gimp_procedure_add_argument (procedure,
+ g_param_spec_double ("feather-radius-x",
+ "feather radius x",
+ "Feather radius x.",
+ -G_MAXDOUBLE, G_MAXDOUBLE, 0,
+ GIMP_PARAM_READWRITE));
+ gimp_procedure_add_argument (procedure,
+ g_param_spec_double ("feather-radius-y",
+ "feather radius y",
+ "Feather radius y.",
+ -G_MAXDOUBLE, G_MAXDOUBLE, 0,
+ GIMP_PARAM_READWRITE));
+ gimp_pdb_register_procedure (pdb, procedure);
+ g_object_unref (procedure);
+
+ /*
+ * gimp-path-import
+ */
+ procedure = gimp_procedure_new (path_import_invoker);
+ gimp_object_set_static_name (GIMP_OBJECT (procedure),
+ "gimp-path-import");
+ gimp_procedure_set_static_strings (procedure,
+ "gimp-path-import",
+ "Deprecated: Use 'gimp-vectors-import-from-file' instead.",
+ "Deprecated: Use 'gimp-vectors-import-from-file' instead.",
+ "",
+ "",
+ "",
+ "gimp-vectors-import-from-file");
+ gimp_procedure_add_argument (procedure,
+ gimp_param_spec_image_id ("image",
+ "image",
+ "The image",
+ pdb->gimp, FALSE,
+ GIMP_PARAM_READWRITE));
+ gimp_procedure_add_argument (procedure,
+ gimp_param_spec_string ("filename",
+ "filename",
+ "The name of the SVG file to import.",
+ TRUE, FALSE, FALSE,
+ NULL,
+ GIMP_PARAM_READWRITE));
+ gimp_procedure_add_argument (procedure,
+ g_param_spec_boolean ("merge",
+ "merge",
+ "Merge paths into a single vectors object.",
+ FALSE,
+ GIMP_PARAM_READWRITE));
+ gimp_procedure_add_argument (procedure,
+ g_param_spec_boolean ("scale",
+ "scale",
+ "Scale the SVG to image dimensions.",
+ FALSE,
+ GIMP_PARAM_READWRITE));
+ gimp_pdb_register_procedure (pdb, procedure);
+ g_object_unref (procedure);
+}