Adding upstream version 2.10.34.upstream/2.10.34upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

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);
+}