gimp/pdb/groups/vectors.pdb

1375 lines
38 KiB
Plaintext

# 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 => '0.0 <= float', default => 0.1,
desc => 'The precision used for approximating straight portions of the stroke' }
);
@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_reverse {
$blurb = 'reverses the specified stroke.';
$help = <<'HELP';
Reverses the specified stroke.
HELP
&simon_pdb_misc('2020', '3.0');
@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)),
_("Reverse path stroke"),
vectors);
gimp_vectors_freeze (vectors);
gimp_stroke_reverse (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 => 'float',
desc => "Offset in x direction" },
{ name => "off_y", type => 'float',
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_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 => 'file', type => 'file',
desc => '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', type => 'vectorarray', 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 *vectors_list = NULL;
/* FIXME tree */
success = gimp_vectors_import_file (image, file,
merge, scale, NULL, -1,
&vectors_list, error);
if (success)
{
num_vectors = g_list_length (vectors_list);
if (num_vectors)
{
GList *list;
gint i;
vectors = g_new (GimpVectors *, num_vectors);
for (i = 0, list = vectors_list;
i < num_vectors;
i++, list = g_list_next (list))
{
vectors[i] = g_object_ref (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', type => 'vectorarray', 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 *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)
{
GList *list;
gint i;
vectors = g_new (GimpVectors *, num_vectors);
for (i = 0, list = vectors_list;
i < num_vectors;
i++, list = g_list_next (list))
{
vectors[i] = g_object_ref (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 => 'file', type => 'file',
desc => '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'
{
GList *vectors_list = g_list_prepend (NULL, vectors);
success = gimp_vectors_export_file (image, vectors_list, file, error);
g_list_free (vectors_list);
}
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'
{
GList *vectors_list = g_list_prepend (NULL, vectors);
string = gimp_vectors_export_string (image, vectors_list);
g_list_free (vectors_list);
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_reverse
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_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;