Adding upstream version 2.10.34.upstream/2.10.34upstream

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

1 files changed, 1365 insertions, 0 deletions

diff --git a/pdb/groups/vectors.pdb b/pdb/groups/vectors.pdb
new file mode 100644
index 0000000..196c686
--- /dev/null
+++ b/pdb/groups/vectors.pdb
@@ -0,0 +1,1365 @@
+# GIMP - The GNU Image Manipulation Program
+# Copyright (C) 1995 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/>.
+
+sub vectors_new {
+    $blurb = 'Creates a new empty vectors object.';
+
+    $help = <<'HELP';
+Creates a new empty vectors object. The vectors object needs to be added to
+the image using gimp_image_insert_vectors().
+HELP
+
+    &simon_pdb_misc('2005', '2.4');
+
+    @inargs = (
+	{ name => 'image', type => 'image',
+	  desc => 'The image' },
+        { name => 'name', type => 'string',
+          desc => 'the name of the new vector object.' }
+    );
+
+    @outargs = (
+        { name => 'vectors', type => 'vectors',
+          desc => 'the current vector object, 0 if no vector exists
+                   in the image.' }
+    );
+
+    %invoke = (
+        code => <<'CODE'
+{
+  vectors = gimp_vectors_new (image, name);
+}
+CODE
+    );
+}
+
+sub vectors_new_from_text_layer {
+    $blurb = 'Creates a new vectors object from a text layer.';
+
+    $help = <<'HELP';
+Creates a new vectors object from a text layer. The vectors object needs to
+be added to the image using gimp_image_insert_vectors().
+HELP
+
+    &marcus_pdb_misc('2008', '2.6');
+
+    @inargs = (
+        { name => 'image', type => 'image',
+	  desc => 'The image.' },
+        { name => 'layer', type => 'layer',
+	  desc => 'The text layer.' }
+    );
+
+    @outargs = (
+        { name => 'vectors', type => 'vectors',
+	  desc => 'The vectors of the text layer.' }
+    );
+
+    %invoke = (
+        code => <<'CODE'
+{
+  if (gimp_pdb_layer_is_text_layer (layer, 0, error))
+    {
+      gint x, y;
+
+      vectors = gimp_text_vectors_new (image,
+				       gimp_text_layer_get_text (GIMP_TEXT_LAYER (layer)));
+
+      gimp_item_get_offset (GIMP_ITEM (layer), &x, &y);
+      gimp_item_translate (GIMP_ITEM (vectors), x, y, FALSE);
+    }
+  else
+    {
+      success = FALSE;
+    }
+}
+CODE
+    );
+}
+
+sub vectors_copy {
+    $blurb = 'Copy a vectors object.';
+
+    $help = <<'HELP';
+This procedure copies the specified vectors object and returns the copy.
+HELP
+
+    barak_pdb_misc('2008', '2.6');
+
+    @inargs = (
+	{ name => 'vectors', type => 'vectors',
+	  desc => 'The vectors object to copy' }
+    );
+
+    @outargs = (
+	{ name => 'vectors_copy', type => 'vectors',
+	  desc => 'The newly copied vectors object' }
+    );
+
+    %invoke = (
+	code => <<'CODE'
+{
+  vectors_copy = GIMP_VECTORS (gimp_item_duplicate (GIMP_ITEM (vectors),
+                               G_TYPE_FROM_INSTANCE (vectors)));
+
+  if (! vectors_copy)
+    success = FALSE;
+}
+CODE
+    );
+}
+
+sub vectors_get_strokes {
+    $blurb = 'List the strokes associated with the passed path.';
+
+    $help = <<'HELP';
+Returns an Array with the stroke-IDs associated with the passed path.
+HELP
+
+    &simon_pdb_misc('2005', '2.4');
+
+    @inargs = (
+	{ name => 'vectors', type => 'vectors',
+	  desc => 'The vectors object' }
+    );
+
+    @outargs = (
+        { name => 'stroke_ids', type => 'int32array',
+          desc => 'List of the strokes belonging to the path.',
+          array => { name => 'num_strokes',
+                     desc => 'The number of strokes returned.' } }
+    );
+
+    %invoke = (
+        code => <<"CODE"
+{
+  num_strokes = gimp_vectors_get_n_strokes (vectors);
+
+  if (num_strokes)
+    {
+      GimpStroke *cur_stroke;
+      gint        i = 0;
+
+      stroke_ids = g_new (gint32, num_strokes);
+
+      for (cur_stroke = gimp_vectors_stroke_get_next (vectors, NULL);
+           cur_stroke;
+           cur_stroke = gimp_vectors_stroke_get_next (vectors, cur_stroke))
+        {
+          stroke_ids[i] = gimp_stroke_get_ID (cur_stroke);
+          i++;
+        }
+    }
+}
+CODE
+    );
+}
+
+sub vectors_stroke_get_length {
+    $blurb = 'Measure the length of the given stroke.';
+    $help  = 'Measure the length of the given stroke.';
+
+    &simon_pdb_misc('2005', '2.4');
+
+    @inargs = (
+	{ name => 'vectors', type => 'vectors',
+	  desc => 'The vectors object' },
+	{ name => 'stroke_id', type => 'int32',
+	  desc => 'The stroke ID' },
+        { name => 'precision', type => 'float',
+          desc => 'The precision used for the approximation' }
+    );
+
+    @outargs = (
+        { name => 'length', type => 'float',
+          desc => 'The length (in pixels) of the given stroke.' }
+    );
+
+    %invoke = (
+        code => <<"CODE"
+{
+  GimpStroke *stroke = gimp_pdb_get_vectors_stroke (vectors, stroke_id, 0, error);
+  
+  if (stroke)
+    length = gimp_stroke_get_length (stroke, precision);
+  else
+    success = FALSE;
+}
+CODE
+    );
+}
+
+sub vectors_stroke_get_point_at_dist {
+    $blurb = 'Get point at a specified distance along the stroke.';
+
+    $help = <<'HELP';
+This will return the x,y position of a point at a given distance along the
+stroke. The distance will be obtained by first digitizing the 
+curve internally and then walking along the curve. For a closed stroke the
+start of the path is the first point on the path that was created. This might
+not be obvious. If the stroke is not long enough, a "valid" flag will be FALSE.
+HELP
+
+    &simon_pdb_misc('2005', '2.4');
+
+    @inargs = (
+	{ name => 'vectors', type => 'vectors',
+	  desc => 'The vectors object' },
+	{ name => 'stroke_id', type => 'int32',
+	  desc => 'The stroke ID' },
+        { name => 'dist', type => 'float',
+          desc => 'The given distance.' },
+        { name => 'precision', type => 'float',
+          desc => 'The precision used for the approximation' }
+    );
+
+    @outargs = (
+        { name => 'x_point', type => 'float', void_ret => 1,
+          desc => 'The x position of the point.' },
+        { name => 'y_point', type => 'float',
+          desc => 'The y position of the point.' },
+        { name => 'slope', type => 'float',
+          desc => 'The slope (dy / dx) at the specified point.' },
+        { name => 'valid', type => 'boolean',
+          desc => 'Indicator for the validity of the returned data.' }
+    );
+
+    %invoke = (
+        code => <<"CODE"
+{
+  GimpStroke *stroke = gimp_pdb_get_vectors_stroke (vectors, stroke_id, 0, error);
+  
+  if (stroke)
+    {
+      GimpCoords coord;
+
+      valid = gimp_stroke_get_point_at_dist (stroke, dist, precision,
+                                             &coord, &slope);
+      x_point = valid ? coord.x : 0;
+      y_point = valid ? coord.y : 0;
+    }
+  else
+    success = FALSE;
+}
+CODE
+    );
+}
+
+sub vectors_remove_stroke {
+    $blurb = 'remove the stroke from a vectors object.';
+
+    $help = <<'HELP';
+Remove the stroke from a vectors object.
+HELP
+
+    &simon_pdb_misc('2005', '2.4');
+
+    @inargs = (
+	{ name => 'vectors', type => 'vectors',
+	  desc => 'The vectors object' },
+	{ name => 'stroke_id', type => 'int32',
+	  desc => 'The stroke ID' }
+    );
+
+    %invoke = (
+        code => <<"CODE"
+{
+  GimpStroke *stroke = gimp_pdb_get_vectors_stroke (vectors, stroke_id,
+                                                    GIMP_PDB_ITEM_CONTENT, error);
+  
+  if (stroke)
+    {
+      if (gimp_item_is_attached (GIMP_ITEM (vectors)))
+        gimp_image_undo_push_vectors_mod (gimp_item_get_image (GIMP_ITEM (vectors)),
+                                          _("Remove path stroke"),
+                                          vectors);
+
+      gimp_vectors_stroke_remove (vectors, stroke);
+    }
+  else
+    success = FALSE;
+}
+CODE
+    );
+}
+
+sub vectors_stroke_close {
+    $blurb = 'closes the specified stroke.';
+
+    $help = <<'HELP';
+Closes the specified stroke.
+HELP
+
+    &simon_pdb_misc('2005', '2.4');
+
+    @inargs = (
+	{ name => 'vectors', type => 'vectors',
+	  desc => 'The vectors object' },
+	{ name => 'stroke_id', type => 'int32',
+	  desc => 'The stroke ID' }
+    );
+
+    %invoke = (
+        code => <<"CODE"
+{
+  GimpStroke *stroke = gimp_pdb_get_vectors_stroke (vectors, stroke_id,
+                                                    GIMP_PDB_ITEM_CONTENT, error);
+  
+  if (stroke)
+    {
+      if (gimp_item_is_attached (GIMP_ITEM (vectors)))
+        gimp_image_undo_push_vectors_mod (gimp_item_get_image (GIMP_ITEM (vectors)),
+                                          _("Close path stroke"),
+                                          vectors);
+
+      gimp_vectors_freeze (vectors);
+      gimp_stroke_close (stroke);
+      gimp_vectors_thaw (vectors);
+    }
+  else
+    success = FALSE;
+}
+CODE
+    );
+}
+
+
+sub vectors_stroke_translate {
+    $blurb = 'translate the given stroke.';
+
+    $help = <<'HELP';
+Translate the given stroke.
+HELP
+
+    &simon_pdb_misc('2005', '2.4');
+
+    @inargs = (
+	{ name => 'vectors', type => 'vectors',
+	  desc => 'The vectors object' },
+	{ name => 'stroke_id', type => 'int32',
+	  desc => 'The stroke ID' },
+	{ name => "off_x", type => 'int32',
+          desc => "Offset in x direction" },
+	{ name => "off_y", type => 'int32',
+          desc => "Offset in y direction" }
+    );
+
+    %invoke = (
+        code => <<"CODE"
+{
+  GimpStroke *stroke = gimp_pdb_get_vectors_stroke (vectors, stroke_id,
+                                                    GIMP_PDB_ITEM_CONTENT |
+                                                    GIMP_PDB_ITEM_POSITION,
+                                                    error);
+  
+  if (stroke)
+    {
+      if (gimp_item_is_attached (GIMP_ITEM (vectors)))
+        gimp_image_undo_push_vectors_mod (gimp_item_get_image (GIMP_ITEM (vectors)),
+                                          _("Translate path stroke"),
+                                          vectors);
+
+      gimp_vectors_freeze (vectors);
+      gimp_stroke_translate (stroke, off_x, off_y);
+      gimp_vectors_thaw (vectors);
+    }
+  else
+    success = FALSE;
+}
+CODE
+    );
+}
+
+sub vectors_stroke_scale {
+    $blurb = 'scales the given stroke.';
+
+    $help = <<'HELP';
+Scale the given stroke.
+HELP
+
+    &simon_pdb_misc('2005', '2.4');
+
+    @inargs = (
+	{ name => 'vectors', type => 'vectors',
+	  desc => 'The vectors object' },
+	{ name => 'stroke_id', type => 'int32',
+	  desc => 'The stroke ID' },
+	{ name => "scale_x", type => 'float',
+	  desc => "Scale factor in x direction" },
+	{ name => "scale_y", type => 'float',
+	  desc => "Scale factor in y direction" }
+    );
+
+    %invoke = (
+        code => <<"CODE"
+{
+  GimpStroke *stroke = gimp_pdb_get_vectors_stroke (vectors, stroke_id,
+                                                    GIMP_PDB_ITEM_CONTENT |
+                                                    GIMP_PDB_ITEM_POSITION,
+                                                    error);
+  
+  if (stroke)
+    {
+      if (gimp_item_is_attached (GIMP_ITEM (vectors)))
+        gimp_image_undo_push_vectors_mod (gimp_item_get_image (GIMP_ITEM (vectors)),
+                                          _("Scale path stroke"),
+                                          vectors);
+
+      gimp_vectors_freeze (vectors);
+      gimp_stroke_scale (stroke, scale_x, scale_y);
+      gimp_vectors_thaw (vectors);
+    }
+  else
+    success = FALSE;
+}
+CODE
+    );
+}
+
+sub vectors_stroke_rotate {
+    $blurb = 'rotates the given stroke.';
+
+    $help = <<'HELP';
+Rotates the given stroke around given center by angle (in degrees).
+HELP
+
+    &joao_pdb_misc('2006', '2.4');
+    @inargs = (
+	{ name => 'vectors', type => 'vectors',
+	  desc => 'The vectors object' },
+	{ name => 'stroke_id', type => 'int32',
+	  desc => 'The stroke ID' },
+	{ name => "center_x", type => 'float',
+	  desc => "X coordinate of the rotation center" },
+	{ name => "center_y", type => 'float',
+	  desc => "Y coordinate of the rotation center" },
+        { name => "angle", type => 'float',
+	  desc => "angle to rotate about" }
+    );
+
+    %invoke = (
+        code => <<"CODE"
+{
+  GimpStroke *stroke = gimp_pdb_get_vectors_stroke (vectors, stroke_id,
+                                                    GIMP_PDB_ITEM_CONTENT |
+                                                    GIMP_PDB_ITEM_POSITION,
+                                                    error);
+  
+  if (stroke)
+    {
+      if (gimp_item_is_attached (GIMP_ITEM (vectors)))
+        gimp_image_undo_push_vectors_mod (gimp_item_get_image (GIMP_ITEM (vectors)),
+                                          _("Rotate path stroke"),
+                                          vectors);
+
+      gimp_vectors_freeze (vectors);
+      gimp_stroke_rotate (stroke, center_x, center_y, angle);
+      gimp_vectors_thaw (vectors);
+    }
+  else
+    success = FALSE;
+}
+CODE
+    );
+}
+
+sub vectors_stroke_flip {
+    $blurb = 'flips the given stroke.';
+
+    $help = <<'HELP';
+Rotates the given stroke around given center by angle (in degrees).
+HELP
+
+    &joao_pdb_misc('2006', '2.4');
+    @inargs = (
+	{ name => 'vectors', type => 'vectors',
+	  desc => 'The vectors object' },
+	{ name => 'stroke_id', type => 'int32',
+	  desc => 'The stroke ID' },
+	{ name => "flip_type",
+	  type => 'enum GimpOrientationType (no GIMP_ORIENTATION_UNKNOWN)',
+	  desc => "Flip orientation, either vertical or horizontal" },
+	{ name => "axis", type => 'float',
+	  desc => "axis coordinate about which to flip, in pixels" }
+    );
+
+    %invoke = (
+        code => <<"CODE"
+{
+  GimpStroke *stroke = gimp_pdb_get_vectors_stroke (vectors, stroke_id,
+                                                    GIMP_PDB_ITEM_CONTENT |
+                                                    GIMP_PDB_ITEM_POSITION,
+                                                    error);
+  
+  if (stroke)
+    {
+      if (gimp_item_is_attached (GIMP_ITEM (vectors)))
+        gimp_image_undo_push_vectors_mod (gimp_item_get_image (GIMP_ITEM (vectors)),
+                                          _("Flip path stroke"),
+                                          vectors);
+
+      gimp_vectors_freeze (vectors);
+      gimp_stroke_flip (stroke, flip_type, axis);
+      gimp_vectors_thaw (vectors);
+    }
+  else
+    success = FALSE;
+}
+CODE
+    );
+}
+
+sub vectors_stroke_flip_free {
+    $blurb = 'flips the given stroke about an arbitrary axis.';
+
+    $help = <<'HELP';
+Flips the given stroke about an arbitrary axis. Axis is defined by two coordinates
+in the image (in pixels), through which the flipping axis passes.
+HELP
+
+    &joao_pdb_misc('2006', '2.4');
+    @inargs = (
+	{ name => 'vectors', type => 'vectors',
+	  desc => 'The vectors object' },
+	{ name => 'stroke_id', type => 'int32',
+	  desc => 'The stroke ID' },
+	{ name => "x1", type => 'float',
+	  desc => "X coordinate of the first point of the flipping axis" },
+	{ name => "y1", type => 'float',
+	  desc => "Y coordinate of the first point of the flipping axis" },
+	{ name => "x2", type => 'float',
+	  desc => "X coordinate of the second point of the flipping axis" },
+	{ name => "y2", type => 'float',
+	  desc => "Y coordinate of the second point of the flipping axis" },
+
+    );
+
+    %invoke = (
+        code => <<"CODE"
+{
+  GimpStroke *stroke = gimp_pdb_get_vectors_stroke (vectors, stroke_id,
+                                                    GIMP_PDB_ITEM_CONTENT |
+                                                    GIMP_PDB_ITEM_POSITION,
+                                                    error);
+  
+  if (stroke)
+    {
+      if (gimp_item_is_attached (GIMP_ITEM (vectors)))
+        gimp_image_undo_push_vectors_mod (gimp_item_get_image (GIMP_ITEM (vectors)),
+                                          _("Flip path stroke"),
+                                          vectors);
+
+      gimp_vectors_freeze (vectors);
+      gimp_stroke_flip_free (stroke, x1, y1, x2, y2);
+      gimp_vectors_thaw (vectors);
+    }
+  else
+    success = FALSE;
+}
+CODE
+    );
+}
+
+sub vectors_stroke_get_points {
+    $blurb = 'returns the control points of a stroke.';
+
+    $help = <<'HELP';
+returns the control points of a stroke. The interpretation of the coordinates
+returned depends on the type of the stroke. For Gimp 2.4 this is always a
+bezier stroke, where the coordinates are the control points.
+HELP
+
+    &simon_pdb_misc('2006', '2.4');
+
+    @inargs = (
+	{ name => 'vectors', type => 'vectors',
+	  desc => 'The vectors object' },
+	{ name => 'stroke_id', type => 'int32',
+	  desc => 'The stroke ID' }
+    );
+
+    @outargs = (
+        { name => 'type', type => 'enum GimpVectorsStrokeType',
+          desc => 'type of the stroke (always GIMP_VECTORS_STROKE_TYPE_BEZIER for now).' },
+        { name => 'controlpoints', type => 'floatarray',
+          desc => 'List of the control points for the stroke (x0, y0, x1, y1, ...).',
+          array => { name => 'num_points',
+                     desc => 'The number of floats returned.' } },
+        { name => 'closed', type => 'boolean',
+          desc => 'Whether the stroke is closed or not.' }
+    );
+
+    %invoke = (
+        code => <<"CODE"
+{
+  GimpStroke *stroke = gimp_pdb_get_vectors_stroke (vectors, stroke_id, 0, error);
+  
+  if (GIMP_IS_BEZIER_STROKE (stroke))
+    {
+      GArray *points_array;
+      gint    i;
+
+      points_array = gimp_stroke_control_points_get (stroke, &closed);
+
+      if (points_array)
+        {
+          num_points = points_array->len;
+          controlpoints = g_new (gdouble, num_points * 2);
+
+          type = GIMP_VECTORS_STROKE_TYPE_BEZIER;
+          for (i = 0; i < num_points; i++)
+            {
+              controlpoints[2*i]   = g_array_index (points_array,
+	                                            GimpAnchor, i).position.x;
+              controlpoints[2*i+1] = g_array_index (points_array,
+	                                            GimpAnchor, i).position.y;
+            }
+          g_array_free (points_array, TRUE);
+          num_points *= 2;
+        }
+      else
+        success = FALSE;
+    }
+  else
+    success = FALSE;
+}
+CODE
+    );
+}
+
+
+sub vectors_stroke_interpolate {
+    $blurb = 'returns polygonal approximation of the stroke.';
+
+    $help = <<'HELP';
+returns polygonal approximation of the stroke.
+HELP
+
+    &simon_pdb_misc('2005', '2.4');
+
+    @inargs = (
+	{ name => 'vectors', type => 'vectors',
+	  desc => 'The vectors object' },
+	{ name => 'stroke_id', type => 'int32',
+	  desc => 'The stroke ID' },
+        { name => 'precision', type => 'float',
+          desc => 'The precision used for the approximation' }
+    );
+
+    @outargs = (
+        { name => 'coords', type => 'floatarray',
+          desc => 'List of the coords along the path (x0, y0, x1, y1, ...).',
+          array => { name => 'num_coords',
+                     desc => 'The number of floats returned.' } },
+        { name => 'closed', type => 'boolean',
+          desc => 'Whether the stroke is closed or not.' }
+    );
+
+    %invoke = (
+        code => <<"CODE"
+{
+  GimpStroke *stroke = gimp_pdb_get_vectors_stroke (vectors, stroke_id, 0, error);
+  
+  if (stroke)
+    {
+      GArray *coords_array;
+      gint    i;
+
+      coords_array = gimp_stroke_interpolate (stroke, precision, &closed);
+
+      if (coords_array)
+        {
+          num_coords = coords_array->len;
+          coords = g_new (gdouble, num_coords * 2);
+
+          for (i = 0; i < num_coords; i++)
+            {
+              coords[2*i]   = g_array_index (coords_array, GimpCoords, i).x;
+              coords[2*i+1] = g_array_index (coords_array, GimpCoords, i).y;
+            }
+          g_array_free (coords_array, TRUE);
+          num_coords *= 2;
+        }
+      else
+        success = FALSE;
+    }
+  else
+    success = FALSE;
+}
+CODE
+    );
+}
+
+
+sub vectors_stroke_new_from_points {
+    $blurb = 'Adds a stroke of a given type to the vectors object.';
+
+    $help = <<'HELP';
+Adds a stroke of a given type to the vectors object. The coordinates of the
+control points can be specified.
+For now only strokes of the type GIMP_VECTORS_STROKE_TYPE_BEZIER are supported.
+The control points are specified as a pair of float values for the x- and
+y-coordinate.
+The Bezier stroke type needs a multiple of three control points. Each Bezier
+segment endpoint (anchor, A) has two additional control points (C) associated.
+They are specified in the order CACCACCAC...
+HELP
+
+    &simon_pdb_misc('2006', '2.4');
+
+    @inargs = (
+	{ name => 'vectors', type => 'vectors',
+	  desc => 'The vectors object' },
+	{ name => 'type', type => 'enum GimpVectorsStrokeType',
+	  desc => 'type of the stroke (always GIMP_VECTORS_STROKE_TYPE_BEZIER for now).' },
+	{ name => 'controlpoints', type => 'floatarray',
+	  desc => 'List of the x- and y-coordinates of the control points.',
+          array => { name => 'num_points',
+                     desc => 'The number of elements in the array, i.e. the
+                              number of controlpoints in the stroke * 2
+                              (x- and y-coordinate).' } },
+        { name => 'closed', type => 'boolean',
+          desc => 'Whether the stroke is to be closed or not.' }
+    );
+
+    @outargs = (
+        { name => 'stroke_id', type => 'int32',
+          desc => 'The stroke ID of the newly created stroke.' }
+    );
+
+    %invoke = (
+        code => <<"CODE"
+{
+  GimpStroke *stroke;
+  GimpCoords *coords;
+  GimpCoords  default_coords = GIMP_COORDS_DEFAULT_VALUES;
+  gint i;
+
+  success = FALSE;
+
+  if (type == GIMP_VECTORS_STROKE_TYPE_BEZIER &&
+      num_points % 6 == 0)
+    {
+      coords = g_new (GimpCoords, num_points/2);
+      for (i = 0; i < num_points/2; i++)
+        {
+	  coords[i] = default_coords;
+	  coords[i].x = controlpoints[i*2];
+	  coords[i].y = controlpoints[i*2+1];
+	}
+
+      stroke = gimp_stroke_new_from_coords (type, coords, num_points/2, closed);
+      if (stroke)
+        {
+          if (gimp_item_is_attached (GIMP_ITEM (vectors)))
+            gimp_image_undo_push_vectors_mod (gimp_item_get_image (GIMP_ITEM (vectors)),
+                                              _("Add path stroke"),
+                                              vectors);
+
+	  gimp_vectors_stroke_add (vectors, stroke);
+	  g_object_unref (stroke);
+
+	  stroke_id = gimp_stroke_get_ID (stroke);
+
+	  success = TRUE;
+	}
+
+      g_free (coords);
+    }
+}
+CODE
+    );
+}
+
+sub vectors_bezier_stroke_new_moveto {
+    $blurb = 'Adds a bezier stroke with a single moveto to the vectors object.';
+
+    $help = <<'HELP';
+Adds a bezier stroke with a single moveto to the vectors object.
+HELP
+
+    &simon_pdb_misc('2005', '2.4');
+
+    @inargs = (
+	{ name => 'vectors', type => 'vectors',
+	  desc => 'The vectors object' },
+        { name => 'x0', type => 'float',
+          desc => 'The x-coordinate of the moveto' },
+        { name => 'y0', type => 'float',
+          desc => 'The y-coordinate of the moveto' }
+    );
+
+    @outargs = (
+        { name => 'stroke_id', type => 'int32',
+          desc => 'The resulting stroke' }
+    );
+
+    %invoke = (
+        code => <<"CODE"
+{
+  if (gimp_pdb_item_is_modifiable (GIMP_ITEM (vectors),
+                                   GIMP_PDB_ITEM_CONTENT, error) &&
+      gimp_pdb_item_is_not_group (GIMP_ITEM (vectors), error))
+    {
+      GimpStroke *stroke;
+      GimpCoords  coord0 = GIMP_COORDS_DEFAULT_VALUES;
+
+      coord0.x = x0;
+      coord0.y = y0;
+
+      stroke = gimp_bezier_stroke_new_moveto (&coord0);
+
+      if (gimp_item_is_attached (GIMP_ITEM (vectors)))
+        gimp_image_undo_push_vectors_mod (gimp_item_get_image (GIMP_ITEM (vectors)),
+                                          _("Add path stroke"),
+                                          vectors);
+
+      gimp_vectors_stroke_add (vectors, stroke);
+      g_object_unref (stroke);
+
+      stroke_id = gimp_stroke_get_ID (stroke);
+    }
+  else
+    success = FALSE;
+}
+CODE
+    );
+}
+
+sub vectors_bezier_stroke_lineto {
+    $blurb = 'Extends a bezier stroke with a lineto.';
+
+    $help = <<'HELP';
+Extends a bezier stroke with a lineto.
+HELP
+
+    &simon_pdb_misc('2005', '2.4');
+
+    @inargs = (
+	{ name => 'vectors', type => 'vectors',
+	  desc => 'The vectors object' },
+	{ name => 'stroke_id', type => 'int32',
+	  desc => 'The stroke ID' },
+        { name => 'x0', type => 'float',
+          desc => 'The x-coordinate of the lineto' },
+        { name => 'y0', type => 'float',
+          desc => 'The y-coordinate of the lineto' }
+    );
+
+    %invoke = (
+        code => <<"CODE"
+{
+  GimpStroke *stroke = gimp_pdb_get_vectors_stroke (vectors, stroke_id,
+                                                    GIMP_PDB_ITEM_CONTENT, error);
+
+  if (stroke)
+    {
+      GimpCoords coord0 = GIMP_COORDS_DEFAULT_VALUES;
+
+      coord0.x = x0;
+      coord0.y = y0;
+
+     if (gimp_item_is_attached (GIMP_ITEM (vectors)))
+       gimp_image_undo_push_vectors_mod (gimp_item_get_image (GIMP_ITEM (vectors)),
+                                         _("Extend path stroke"),
+                                         vectors);
+
+      gimp_vectors_freeze (vectors);
+      gimp_bezier_stroke_lineto (stroke, &coord0);
+      gimp_vectors_thaw (vectors);
+    }
+  else
+    success = FALSE;
+}
+CODE
+    );
+}
+
+sub vectors_bezier_stroke_conicto {
+    $blurb = 'Extends a bezier stroke with a conic bezier spline.';
+
+    $help = <<'HELP';
+Extends a bezier stroke with a conic bezier spline. Actually a
+cubic bezier spline gets added that realizes the shape of a conic
+bezier spline.
+HELP
+
+    &simon_pdb_misc('2005', '2.4');
+
+    @inargs = (
+	{ name => 'vectors', type => 'vectors',
+	  desc => 'The vectors object' },
+	{ name => 'stroke_id', type => 'int32',
+	  desc => 'The stroke ID' },
+        { name => 'x0', type => 'float',
+          desc => 'The x-coordinate of the control point' },
+        { name => 'y0', type => 'float',
+          desc => 'The y-coordinate of the control point' },
+        { name => 'x1', type => 'float',
+          desc => 'The x-coordinate of the end point' },
+        { name => 'y1', type => 'float',
+          desc => 'The y-coordinate of the end point' }
+    );
+
+    %invoke = (
+        code => <<"CODE"
+{
+  GimpStroke *stroke = gimp_pdb_get_vectors_stroke (vectors, stroke_id,
+                                                    GIMP_PDB_ITEM_CONTENT, error);
+
+  if (stroke)
+    {
+      GimpCoords coord0 = GIMP_COORDS_DEFAULT_VALUES;
+      GimpCoords coord1 = GIMP_COORDS_DEFAULT_VALUES;
+
+      coord0.x = x0;
+      coord0.y = y0;
+
+      coord1.x = x1;
+      coord1.y = y1;
+
+     if (gimp_item_is_attached (GIMP_ITEM (vectors)))
+       gimp_image_undo_push_vectors_mod (gimp_item_get_image (GIMP_ITEM (vectors)),
+                                         _("Extend path stroke"),
+                                         vectors);
+
+      gimp_vectors_freeze (vectors);
+      gimp_bezier_stroke_conicto (stroke, &coord0, &coord1);
+      gimp_vectors_thaw (vectors);
+    }
+  else
+    success = FALSE;
+}
+CODE
+    );
+}
+
+sub vectors_bezier_stroke_cubicto {
+    $blurb = 'Extends a bezier stroke with a cubic bezier spline.';
+
+    $help = <<'HELP';
+Extends a bezier stroke with a cubic bezier spline.
+HELP
+
+    &simon_pdb_misc('2005', '2.4');
+
+    @inargs = (
+	{ name => 'vectors', type => 'vectors',
+	  desc => 'The vectors object' },
+	{ name => 'stroke_id', type => 'int32',
+	  desc => 'The stroke ID' },
+        { name => 'x0', type => 'float',
+          desc => 'The x-coordinate of the first control point' },
+        { name => 'y0', type => 'float',
+          desc => 'The y-coordinate of the first control point' },
+        { name => 'x1', type => 'float',
+          desc => 'The x-coordinate of the second control point' },
+        { name => 'y1', type => 'float',
+          desc => 'The y-coordinate of the second control point' },
+        { name => 'x2', type => 'float',
+          desc => 'The x-coordinate of the end point' },
+        { name => 'y2', type => 'float',
+          desc => 'The y-coordinate of the end point' }
+    );
+
+    %invoke = (
+        code => <<"CODE"
+{
+  GimpStroke *stroke = gimp_pdb_get_vectors_stroke (vectors, stroke_id,
+                                                    GIMP_PDB_ITEM_CONTENT, error);
+
+  if (stroke)
+    {
+      GimpCoords coord0 = GIMP_COORDS_DEFAULT_VALUES;
+      GimpCoords coord1 = GIMP_COORDS_DEFAULT_VALUES;
+      GimpCoords coord2 = GIMP_COORDS_DEFAULT_VALUES;
+
+      coord0.x = x0;
+      coord0.y = y0;
+
+      coord1.x = x1;
+      coord1.y = y1;
+
+      coord2.x = x2;
+      coord2.y = y2;
+
+     if (gimp_item_is_attached (GIMP_ITEM (vectors)))
+       gimp_image_undo_push_vectors_mod (gimp_item_get_image (GIMP_ITEM (vectors)),
+                                         _("Extend path stroke"),
+                                         vectors);
+
+      gimp_vectors_freeze (vectors);
+      gimp_bezier_stroke_cubicto (stroke, &coord0, &coord1, &coord2);
+      gimp_vectors_thaw (vectors);
+    }
+  else
+    success = FALSE;
+}
+CODE
+    );
+}
+
+sub vectors_bezier_stroke_new_ellipse {
+    $blurb = 'Adds a bezier stroke describing an ellipse the vectors object.';
+
+    $help = <<'HELP';
+Adds a bezier stroke describing an ellipse the vectors object.
+HELP
+
+    &simon_pdb_misc('2005', '2.4');
+
+    @inargs = (
+	{ name => 'vectors', type => 'vectors',
+	  desc => 'The vectors object' },
+        { name => 'x0', type => 'float',
+          desc => 'The x-coordinate of the center' },
+        { name => 'y0', type => 'float',
+          desc => 'The y-coordinate of the center' },
+        { name => 'radius_x', type => 'float',
+          desc => 'The radius in x direction' },
+        { name => 'radius_y', type => 'float',
+          desc => 'The radius in y direction' },
+        { name => 'angle', type => 'float',
+          desc => 'The angle the x-axis of the ellipse
+                   (radians, counterclockwise)' }
+    );
+
+    @outargs = (
+        { name => 'stroke_id', type => 'int32',
+          desc => 'The resulting stroke' }
+    );
+
+    %invoke = (
+        code => <<"CODE"
+{
+  if (gimp_pdb_item_is_modifiable (GIMP_ITEM (vectors),
+                                   GIMP_PDB_ITEM_CONTENT, error) &&
+      gimp_pdb_item_is_not_group (GIMP_ITEM (vectors), error))
+    {
+      GimpStroke *stroke;
+      GimpCoords  coord0 = GIMP_COORDS_DEFAULT_VALUES;
+
+      coord0.x = x0;
+      coord0.y = y0;
+
+      stroke = gimp_bezier_stroke_new_ellipse (&coord0, radius_x, radius_y, angle);
+
+      if (gimp_item_is_attached (GIMP_ITEM (vectors)))
+        gimp_image_undo_push_vectors_mod (gimp_item_get_image (GIMP_ITEM (vectors)),
+                                          _("Add path stroke"),
+                                          vectors);
+
+      gimp_vectors_stroke_add (vectors, stroke);
+      g_object_unref (stroke);
+
+      stroke_id = gimp_stroke_get_ID (stroke);
+    }
+  else
+    success = FALSE;
+}
+CODE
+    );
+}
+
+sub vectors_to_selection {
+    &std_pdb_deprecated ('gimp-image-select-item');
+    &simon_pdb_misc('2006', '2.4');
+
+    @inargs = (
+        { name => 'vectors', type => 'vectors',
+          desc => 'The vectors object to render to the selection' },
+        { name => 'operation', type => 'enum GimpChannelOps',
+          desc => 'The desired operation with current selection' },
+        { name => 'antialias', type => 'boolean',
+          desc => 'Antialias selection.' },
+        { name => 'feather', type => 'boolean',
+          desc => 'Feather selection.' },
+        { name => 'feather_radius_x', type => 'float',
+          desc => 'Feather radius x.'  },
+        { name => 'feather_radius_y', type => 'float',
+          desc => 'Feather radius y.'  }
+    );
+
+    %invoke = (
+        code => <<'CODE'
+{
+  if (gimp_pdb_item_is_attached (GIMP_ITEM (vectors), NULL, 0, error))
+    gimp_item_to_selection (GIMP_ITEM (vectors),
+                            operation,
+                            antialias,
+                            feather,
+                            feather_radius_x,
+                            feather_radius_y);
+  else
+    success = FALSE;
+}
+CODE
+    );
+
+}
+
+sub vectors_import_from_file {
+    $blurb = 'Import paths from an SVG file.';
+
+    $help = <<'HELP';
+This procedure imports paths from an SVG file. SVG elements other than
+paths and basic shapes are ignored.
+HELP
+
+    &simon_pdb_misc('2006', '2.4');
+
+    @inargs = (
+        { name => 'image', type => 'image',
+          desc => 'The image' },
+        { name => 'filename', type => 'string', allow_non_utf8 => 1,
+          non_empty => 1,
+          desc => 'The name of the SVG file to import.' },
+        { name => 'merge', type => 'boolean',
+          desc => 'Merge paths into a single vectors object.' },
+        { name => 'scale', type => 'boolean',
+          desc => 'Scale the SVG to image dimensions.' }
+    );
+
+    @outargs = (
+        { name => 'vectors_ids', type => 'int32array', void_ret => 1,
+          desc => 'The list of newly created vectors',
+          array => { name => 'num_vectors',
+                     desc => 'The number of newly created vectors' } }
+    );
+
+    %invoke = (
+        headers => [ qw("vectors/gimpvectors-import.h") ],
+        code    => <<'CODE'
+{
+  GFile *file         = g_file_new_for_path (filename);
+  GList *vectors_list = NULL;
+
+  /* FIXME tree */
+  success = gimp_vectors_import_file (image, file,
+                                      merge, scale, NULL, -1,
+                                      &vectors_list, error);
+
+  g_object_unref (file);
+
+  if (success)
+    {
+      num_vectors = g_list_length (vectors_list);
+
+      if (num_vectors)
+        {
+          GList *list;
+          gint   i;
+      
+          vectors_ids = g_new (gint32, num_vectors);
+      
+	  list = vectors_list;
+          for (i = 0; i < num_vectors; i++, list = g_list_next (list))
+            vectors_ids[i] = gimp_item_get_ID (GIMP_ITEM (list->data));
+
+          g_list_free (vectors_list);
+        }
+    }
+}
+CODE
+    );
+}
+
+sub vectors_import_from_string {
+    $blurb = 'Import paths from an SVG string.';
+
+    $help = <<'HELP';
+This procedure works like gimp_vectors_import_from_file() but takes a string
+rather than reading the SVG from a file. This allows you to write scripts that
+generate SVG and feed it to GIMP.
+HELP
+
+    &simon_pdb_misc('2006', '2.4');
+
+    @inargs = (
+        { name => 'image', type => 'image',
+          desc => 'The image' },
+        { name => 'string', type => 'string', allow_non_utf8 => 1,
+          desc => 'A string that must be a complete and valid SVG document.' },
+        { name => 'length', type => 'int32',
+          desc => 'Number of bytes in string or -1 if the string is NULL
+                   terminated.' },
+        { name => 'merge', type => 'boolean',
+          desc => 'Merge paths into a single vectors object.' },
+        { name => 'scale', type => 'boolean',
+          desc => 'Scale the SVG to image dimensions.' }
+    );
+
+    @outargs = (
+        { name => 'vectors_ids', type => 'int32array', void_ret => 1,
+          desc => 'The list of newly created vectors',
+          array => { name => 'num_vectors',
+                     desc => 'The number of newly created vectors' } }
+    );
+
+    %invoke = (
+        headers => [ qw("vectors/gimpvectors-import.h") ],
+        code    => <<'CODE'
+{
+  GList *list, *vectors_list = NULL;
+
+  /* FIXME tree */
+  success = gimp_vectors_import_buffer (image, string, length,
+                                        merge, scale, NULL, -1,
+                                        &vectors_list, error);
+
+  if (success)
+    {
+      num_vectors = g_list_length (vectors_list);
+
+      if (num_vectors)
+        {
+          gint i;
+      
+          vectors_ids = g_new (gint32, num_vectors);
+      
+	  list = vectors_list;
+          for (i = 0; i < num_vectors; i++, list = g_list_next (list))
+            vectors_ids[i] = gimp_item_get_ID (GIMP_ITEM (list->data));
+
+          g_list_free (vectors_list);
+        }
+    }
+}
+CODE
+    );
+}
+
+sub vectors_export_to_file {
+    $blurb = 'save a path as an SVG file.';
+
+    $help = <<'HELP';
+This procedure creates an SVG file to save a Vectors object, that is,
+a path.  The resulting file can be edited using a vector graphics
+application, or later reloaded into GIMP.  If you pass 0 as the 'vectors'
+argument, then all paths in the image will be exported.
+HELP
+
+    &bill_pdb_misc('2007', '2.6');
+
+    @inargs = (
+        { name => 'image', type => 'image',
+          desc => 'The image' },
+        { name => 'filename', type => 'string', allow_non_utf8 => 1,
+          non_empty => 1,
+          desc => 'The name of the SVG file to create.' },
+        { name => 'vectors', type => 'vectors', no_validate => 1,
+          desc => 'The vectors object to be saved, or 0 for all in the image' }
+    );
+
+    %invoke = (
+        headers => [ qw("vectors/gimpvectors-export.h") ],
+        code    => <<'CODE'
+{
+  GFile *file = g_file_new_for_path (filename);
+
+  success = gimp_vectors_export_file (image, vectors, file, error);
+
+  g_object_unref (file);
+}
+CODE
+    );
+}
+
+sub vectors_export_to_string {
+    $blurb = 'Save a path as an SVG string.';
+
+    $help = <<'HELP';
+This procedure works like gimp_vectors_export_to_file() but creates a string
+rather than a file. The contents are a NUL-terminated string that holds a 
+complete XML document.  If you pass 0 as the 'vectors' argument, then all
+paths in the image will be exported.
+HELP
+
+    &bill_pdb_misc('2007', '2.6');
+
+    @inargs = (
+        { name => 'image', type => 'image',
+          desc => 'The image' },
+        { name => 'vectors', type => 'vectors', no_validate => 1,
+          desc => 'The vectors object to save, or 0 for all in the image' }
+    );
+
+    @outargs = (
+        { name => 'string', type => 'string',
+          desc => 'A string whose contents are a complete SVG document.' }
+    );
+
+    %invoke = (
+        headers => [ qw("vectors/gimpvectors-export.h") ],
+        code    => <<'CODE'
+{
+  string = gimp_vectors_export_string (image, vectors);
+
+  success = (string != NULL);
+}
+CODE
+    );
+}
+
+
+@headers = qw(<string.h>
+              "core/gimplist.h"
+              "core/gimpimage.h"
+              "core/gimpimage-undo-push.h"
+	      "text/gimptext-vectors.h"
+	      "text/gimptextlayer.h"
+              "vectors/gimpanchor.h"
+              "vectors/gimpstroke-new.h"
+              "vectors/gimpbezierstroke.h"
+              "vectors/gimpvectors.h"
+              "gimppdb-utils.h"
+              "gimp-intl.h");
+
+@procs = qw(vectors_new
+	    vectors_new_from_text_layer
+            vectors_copy
+            vectors_get_strokes 
+            vectors_stroke_get_length
+            vectors_stroke_get_point_at_dist
+            vectors_remove_stroke
+            vectors_stroke_close
+            vectors_stroke_translate
+            vectors_stroke_scale
+            vectors_stroke_rotate
+            vectors_stroke_flip
+            vectors_stroke_flip_free
+            vectors_stroke_get_points
+            vectors_stroke_new_from_points
+            vectors_stroke_interpolate
+            vectors_bezier_stroke_new_moveto
+            vectors_bezier_stroke_lineto
+            vectors_bezier_stroke_conicto
+            vectors_bezier_stroke_cubicto
+            vectors_bezier_stroke_new_ellipse
+            vectors_to_selection
+            vectors_import_from_file
+            vectors_import_from_string
+            vectors_export_to_file
+            vectors_export_to_string);
+
+%exports = (app => [@procs], lib => [@procs]);
+
+$desc = 'Vectors';
+$doc_title = 'gimpvectors';
+$doc_short_desc = 'Functions for querying and manipulating vectors.';
+$doc_long_desc = 'Functions for querying and manipulating vectors.';
+
+1;