## gimpvectors gimpvectors |

## Synopsis

    gint32              gimp_vectors_new                    (gint32 image_ID,
                                                             const gchar *name);
    gint32              gimp_vectors_new_from_text_layer    (gint32 image_ID,
                                                             gint32 layer_ID);
    gint32              gimp_vectors_copy                   (gint32 vectors_ID);
    gboolean            gimp_vectors_is_valid               (gint32 vectors_ID);
    gint*               gimp_vectors_get_strokes            (gint32 vectors_ID,
                                                             gint *num_strokes);
    gint32              gimp_vectors_get_image              (gint32 vectors_ID);
    gboolean            gimp_vectors_get_linked             (gint32 vectors_ID);
    gchar*              gimp_vectors_get_name               (gint32 vectors_ID);
    gint                gimp_vectors_get_tattoo             (gint32 vectors_ID);
    gboolean            gimp_vectors_get_visible            (gint32 vectors_ID);
    gboolean            gimp_vectors_set_linked             (gint32 vectors_ID,
                                                             gboolean linked);
    gboolean            gimp_vectors_set_name               (gint32 vectors_ID,
                                                             const gchar *name);
    gboolean            gimp_vectors_set_tattoo             (gint32 vectors_ID,
                                                             gint tattoo);
    gboolean            gimp_vectors_set_visible            (gint32 vectors_ID,
                                                             gboolean visible);
    gboolean            gimp_vectors_remove_stroke          (gint32 vectors_ID,
                                                             gint stroke_id);
    gboolean            gimp_vectors_to_selection           (gint32 vectors_ID,
                                                             GimpChannelOps operation,
                                                             gboolean antialias,
                                                             gboolean feather,
                                                             gdouble feather_radius_x,
                                                             gdouble feather_radius_y);
    gboolean            gimp_vectors_export_to_file         (gint32 image_ID,
                                                             const gchar *filename,
                                                             gint32 vectors_ID);
    gchar*              gimp_vectors_export_to_string       (gint32 image_ID,
                                                             gint32 vectors_ID);
    gboolean            gimp_vectors_import_from_file       (gint32 image_ID,
                                                             const gchar *filename,
                                                             gboolean merge,
                                                             gboolean scale,
                                                             gint *num_vectors,
                                                             gint32 **vectors_ids);
    gboolean            gimp_vectors_import_from_string     (gint32 image_ID,
                                                             const gchar *string,
                                                             gint length,
                                                             gboolean merge,
                                                             gboolean scale,
                                                             gint *num_vectors,
                                                             gint32 **vectors_ids);
    gboolean            gimp_vectors_parasite_attach        (gint32 vectors_ID,
                                                             const GimpParasite *parasite);
    gboolean            gimp_vectors_parasite_detach        (gint32 vectors_ID,
                                                             const gchar *name);
    GimpParasite*       gimp_vectors_parasite_find          (gint32 vectors_ID,
                                                             const gchar *name);
    gboolean            gimp_vectors_parasite_list          (gint32 vectors_ID,
                                                             gint *num_parasites,
                                                             gchar ***parasites);
    gint                gimp_vectors_stroke_new_from_points (gint32 vectors_ID,
                                                             GimpVectorsStrokeType type,
                                                             gint num_points,
                                                             const gdouble *controlpoints,
                                                             gboolean closed);
    gboolean            gimp_vectors_stroke_close           (gint32 vectors_ID,
                                                             gint stroke_id);
    gdouble             gimp_vectors_stroke_get_length      (gint32 vectors_ID,
                                                             gint stroke_id,
                                                             gdouble precision);
    GimpVectorsStrokeType  gimp_vectors_stroke_get_points   (gint32 vectors_ID,
                                                             gint stroke_id,
                                                             gint *num_points,
                                                             gdouble **controlpoints,
                                                             gboolean *closed);
    gboolean            gimp_vectors_stroke_get_point_at_dist
                                                            (gint32 vectors_ID,
                                                             gint stroke_id,
                                                             gdouble dist,
                                                             gdouble precision,
                                                             gdouble *x_point,
                                                             gdouble *y_point,
                                                             gdouble *slope,
                                                             gboolean *valid);
    gdouble*            gimp_vectors_stroke_interpolate     (gint32 vectors_ID,
                                                             gint stroke_id,
                                                             gdouble precision,
                                                             gint *num_coords,
                                                             gboolean *closed);
    gboolean            gimp_vectors_stroke_scale           (gint32 vectors_ID,
                                                             gint stroke_id,
                                                             gdouble scale_x,
                                                             gdouble scale_y);
    gboolean            gimp_vectors_stroke_translate       (gint32 vectors_ID,
                                                             gint stroke_id,
                                                             gint off_x,
                                                             gint off_y);
    gboolean            gimp_vectors_stroke_flip            (gint32 vectors_ID,
                                                             gint stroke_id,
                                                             GimpOrientationType flip_type,
                                                             gdouble axis);
    gboolean            gimp_vectors_stroke_flip_free       (gint32 vectors_ID,
                                                             gint stroke_id,
                                                             gdouble x1,
                                                             gdouble y1,
                                                             gdouble x2,
                                                             gdouble y2);
    gboolean            gimp_vectors_stroke_rotate          (gint32 vectors_ID,
                                                             gint stroke_id,
                                                             gdouble center_x,
                                                             gdouble center_y,
                                                             gdouble angle);
    gboolean            gimp_vectors_bezier_stroke_conicto  (gint32 vectors_ID,
                                                             gint stroke_id,
                                                             gdouble x0,
                                                             gdouble y0,
                                                             gdouble x1,
                                                             gdouble y1);
    gboolean            gimp_vectors_bezier_stroke_cubicto  (gint32 vectors_ID,
                                                             gint stroke_id,
                                                             gdouble x0,
                                                             gdouble y0,
                                                             gdouble x1,
                                                             gdouble y1,
                                                             gdouble x2,
                                                             gdouble y2);
    gboolean            gimp_vectors_bezier_stroke_lineto   (gint32 vectors_ID,
                                                             gint stroke_id,
                                                             gdouble x0,
                                                             gdouble y0);
    gint                gimp_vectors_bezier_stroke_new_ellipse
                                                            (gint32 vectors_ID,
                                                             gdouble x0,
                                                             gdouble y0,
                                                             gdouble radius_x,
                                                             gdouble radius_y,
                                                             gdouble angle);
    gint                gimp_vectors_bezier_stroke_new_moveto
                                                            (gint32 vectors_ID,
                                                             gdouble x0,
                                                             gdouble y0);

## Description

## Details

### gimp_vectors_new ()

    gint32              gimp_vectors_new                    (gint32 image_ID,
                                                             const gchar *name);

Creates a new empty vectors object.

Creates a new empty vectors object. The vectors object needs to be added to the image using `gimp_image_add_vectors()`.

`image_ID` : | The image.
`name` : | the name of the new vector object.
Returns : | the current vector object, 0 if no vector exists in the image.

Since GIMP 2.4

### gimp_vectors_new_from_text_layer ()

    gint32              gimp_vectors_new_from_text_layer    (gint32 image_ID,
                                                             gint32 layer_ID);

Creates a new vectors object from a text layer.

Creates a new vectors object from a text layer. The vectors object needs to be added to the image using `gimp_image_add_vectors()`.

`image_ID` : | The image.
`layer_ID` : | The text layer.
Returns : | The vectors of the text layer.

Since GIMP 2.6

### gimp_vectors_copy ()

    gint32              gimp_vectors_copy                   (gint32 vectors_ID);

Copy a vectors object.

This procedure copies the specified vectors object and returns the copy.

`vectors_ID` : | The vectors object to copy.
Returns : | The newly copied vectors object.

Since GIMP 2.6

### gimp_vectors_is_valid ()

    gboolean            gimp_vectors_is_valid               (gint32 vectors_ID);

Returns TRUE if the vectors object is valid.

This procedure checks if the given vectors ID is valid and refers to an existing vectors object.

`vectors_ID` : | The vectors object to check.
Returns : | Whether the vectors ID is valid.

Since GIMP 2.4

### gimp_vectors_get_strokes ()

    gint*               gimp_vectors_get_strokes            (gint32 vectors_ID,
                                                             gint *num_strokes);

List the strokes associated with the passed path.

Returns an Array with the stroke-IDs associated with the passed path.

`vectors_ID` : | The vectors object.
`num_strokes` : | The number of strokes returned.
Returns : | List of the strokes belonging to the path.

Since GIMP 2.4

### gimp_vectors_get_image ()

    gint32              gimp_vectors_get_image              (gint32 vectors_ID);

Returns the vectors objects image.

Returns the vectors objects image.

`vectors_ID` : | The vectors object.
Returns : | The vectors image.

Since GIMP 2.4

### gimp_vectors_get_linked ()

    gboolean            gimp_vectors_get_linked             (gint32 vectors_ID);

Gets the linked state of the vectors object.

Gets the linked state of the vectors object.

`vectors_ID` : | The vectors object.
Returns : | TRUE if the path is linked, FALSE otherwise.

Since GIMP 2.4

### gimp_vectors_get_name ()

    gchar*              gimp_vectors_get_name               (gint32 vectors_ID);

Gets the name of the vectors object.

Gets the name of the vectors object.

`vectors_ID` : | The vectors object.
Returns : | The name of the vectors object.

Since GIMP 2.4

### gimp_vectors_get_tattoo ()

    gint                gimp_vectors_get_tattoo             (gint32 vectors_ID);

Get the tattoo of the vectors object.

Get the tattoo state of the vectors object.

`vectors_ID` : | The vectors object.
Returns : | The vectors tattoo.

Since GIMP 2.4

### gimp_vectors_get_visible ()

    gboolean            gimp_vectors_get_visible            (gint32 vectors_ID);

Gets the visibility of the vectors object.

Gets the visibility of the vectors object.

`vectors_ID` : | The vectors object.
Returns : | TRUE if the path is visible, FALSE otherwise.

Since GIMP 2.4

### gimp_vectors_set_linked ()

    gboolean            gimp_vectors_set_linked             (gint32 vectors_ID,
                                                             gboolean linked);

Sets the linked state of the vectors object.

Sets the linked state of the vectors object.

`vectors_ID` : | The vectors object.
`linked` : | Whether the path is linked.
Returns : | TRUE on success.

Since GIMP 2.4

### gimp_vectors_set_name ()

    gboolean            gimp_vectors_set_name               (gint32 vectors_ID,
                                                             const gchar *name);

Sets the name of the vectors object.

Sets the name of the vectors object.

`vectors_ID` : | The vectors object.
`name` : | the new name of the path.
Returns : | TRUE on success.

Since GIMP 2.4

### gimp_vectors_set_tattoo ()

    gboolean            gimp_vectors_set_tattoo             (gint32 vectors_ID,
                                                             gint tattoo);

Set the tattoo of the vectors object.

Set the tattoo of the vectors object.

`vectors_ID` : | The vectors object.
`tattoo` : | the new tattoo.
Returns : | TRUE on success.

Since GIMP 2.4

### gimp_vectors_set_visible ()

    gboolean            gimp_vectors_set_visible            (gint32 vectors_ID,
                                                             gboolean visible);

Sets the visibility of the vectors object.

Sets the visibility of the vectors object.

`vectors_ID` : | The vectors object.
`visible` : | Whether the path is visible.
Returns : | TRUE on success.

Since GIMP 2.4

### gimp_vectors_remove_stroke ()

    gboolean            gimp_vectors_remove_stroke          (gint32 vectors_ID,
                                                             gint stroke_id);

remove the stroke from a vectors object.

Remove the stroke from a vectors object.

`vectors_ID` : | The vectors object.
`stroke_id` : | The stroke ID.
Returns : | TRUE on success.

Since GIMP 2.4

### gimp_vectors_to_selection ()

    gboolean            gimp_vectors_to_selection           (gint32 vectors_ID,
                                                             GimpChannelOps operation,
                                                             gboolean antialias,
                                                             gboolean feather,
                                                             gdouble feather_radius_x,
                                                             gdouble feather_radius_y);

Transforms the specified vectors object into a selection

This procedure renders the desired vectors object into the current selection of the image the vectors object belongs to.

`vectors_ID` : | The vectors object to render to the selection.
`operation` : | The desired operation with current selection.
`antialias` : | Antialias selection.
`feather` : | Feather selection.
`feather_radius_x` : | Feather radius x.
`feather_radius_y` : | Feather radius y.
Returns : | TRUE on success.

Since GIMP 2.4

### gimp_vectors_export_to_file ()

    gboolean            gimp_vectors_export_to_file         (gint32 image_ID,
                                                             const gchar *filename,
                                                             gint32 vectors_ID);

save a path as an SVG file.

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.

`image_ID` : | The image.
`filename` : | The name of the SVG file to create.
`vectors_ID` : | The vectors object to be saved, or 0 for all in the image.
Returns : | TRUE on success.

Since GIMP 2.6

### gimp_vectors_export_to_string ()

    gchar*              gimp_vectors_export_to_string       (gint32 image_ID,
                                                             gint32 vectors_ID);

Save a path as an SVG string.

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.

`image_ID` : | The image.
`vectors_ID` : | The vectors object to save, or 0 for all in the image.
Returns : | A string whose contents are a complete SVG document.

Since GIMP 2.6

### gimp_vectors_import_from_file ()

    gboolean            gimp_vectors_import_from_file       (gint32 image_ID,
                                                             const gchar *filename,
                                                             gboolean merge,
                                                             gboolean scale,
                                                             gint *num_vectors,
                                                             gint32 **vectors_ids);

Import paths from an SVG file.

This procedure imports paths from an SVG file. SVG elements other than paths and basic shapes are ignored.

`image_ID` : | The image.
`filename` : | The name of the SVG file to import.
`merge` : | Merge paths into a single vectors object.
`scale` : | Scale the SVG to image dimensions.
`num_vectors` : | The number of newly created vectors.
`vectors_ids` : | The list of newly created vectors.
Returns : | TRUE on success.

Since GIMP 2.4

### gimp_vectors_import_from_string ()

    gboolean            gimp_vectors_import_from_string     (gint32 image_ID,
                                                             const gchar *string,
                                                             gint length,
                                                             gboolean merge,
                                                             gboolean scale,
                                                             gint *num_vectors,
                                                             gint32 **vectors_ids);

Import paths from an SVG string.

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.

`image_ID` : | The image.
`string` : | A string that must be a complete and valid SVG document.
`length` : | Number of bytes in string or -1 if the string is NULL terminated.
`merge` : | Merge paths into a single vectors object.
`scale` : | Scale the SVG to image dimensions.
`num_vectors` : | The number of newly created vectors.
`vectors_ids` : | The list of newly created vectors.
Returns : | TRUE on success.

Since GIMP 2.4

### gimp_vectors_parasite_attach ()

    gboolean            gimp_vectors_parasite_attach        (gint32 vectors_ID,
                                                             const GimpParasite *parasite);

Add a parasite to a vectors object

This procedure attaches a parasite to a vectors object. It has no return values.

`vectors_ID` : | The vectors object.
`parasite` : | The parasite to attach to a vectors object.
Returns : | TRUE on success.

Since GIMP 2.4

### gimp_vectors_parasite_detach ()

    gboolean            gimp_vectors_parasite_detach        (gint32 vectors_ID,
                                                             const gchar *name);

Removes a parasite from a vectors object

This procedure detaches a parasite from a vectors object. It has no return values.

`vectors_ID` : | The vectors object.
`name` : | The name of the parasite to detach from a vectors object.
Returns : | TRUE on success.

Since GIMP 2.4

### gimp_vectors_parasite_find ()

    GimpParasite*       gimp_vectors_parasite_find          (gint32 vectors_ID,
                                                             const gchar *name);

Look up a parasite in a vectors object

Finds and returns the parasite that was previously attached to a vectors object.

`vectors_ID` : | The vectors object.
`name` : | The name of the parasite to find.
Returns : | The found parasite.

Since GIMP 2.4

### gimp_vectors_parasite_list ()

    gboolean            gimp_vectors_parasite_list          (gint32 vectors_ID,
                                                             gint *num_parasites,
                                                             gchar ***parasites);

List all parasites.

Returns a list of all currently attached parasites.

`vectors_ID` : | The vectors object.
`num_parasites` : | The number of attached parasites.
`parasites` : | The names of currently attached parasites.
Returns : | TRUE on success.

Since GIMP 2.4

### gimp_vectors_stroke_new_from_points ()

    gint                gimp_vectors_stroke_new_from_points (gint32 vectors_ID,
                                                             GimpVectorsStrokeType type,
                                                             gint num_points,
                                                             const gdouble *controlpoints,
                                                             gboolean closed);

Adds a stroke of a given type to the vectors object.

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...

`vectors_ID` : | The vectors object.
`type` : | type of the stroke (always GIMP_VECTORS_STROKE_TYPE_BEZIER for now).
`num_points` : | The number of elements in the array, i.e. the number of controlpoints in the stroke * 2 (x- and y-coordinate).
`controlpoints` : | List of the x- and y-coordinates of the control points.
`closed` : | Whether the stroke is to be closed or not.
Returns : | The stroke ID of the newly created stroke.

Since GIMP 2.4

### gimp_vectors_stroke_close ()

    gboolean            gimp_vectors_stroke_close           (gint32 vectors_ID,
                                                             gint stroke_id);

closes the specified stroke.

Closes the specified stroke.

`vectors_ID` : | The vectors object.
`stroke_id` : | The stroke ID.
Returns : | TRUE on success.

Since GIMP 2.4

### gimp_vectors_stroke_get_length ()

    gdouble             gimp_vectors_stroke_get_length      (gint32 vectors_ID,
                                                             gint stroke_id,
                                                             gdouble precision);

Measure the length of the given stroke.

Measure the length of the given stroke.

`vectors_ID` : | The vectors object.
`stroke_id` : | The stroke ID.
`precision` : | The precision used for the approximation.
Returns : | The length (in pixels) of the given stroke.

Since GIMP 2.4

### gimp_vectors_stroke_get_points ()

    GimpVectorsStrokeType  gimp_vectors_stroke_get_points   (gint32 vectors_ID,
                                                             gint stroke_id,
                                                             gint *num_points,
                                                             gdouble **controlpoints,
                                                             gboolean *closed);

returns the control points of a stroke.

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.

`vectors_ID` : | The vectors object.
`stroke_id` : | The stroke ID.
`num_points` : | The number of floats returned.
`controlpoints` : | List of the control points for the stroke (x0, y0, x1, y1, ...).
`closed` : | Whether the stroke is closed or not.
Returns : | type of the stroke (always GIMP_VECTORS_STROKE_TYPE_BEZIER for now).

Since GIMP 2.4

### gimp_vectors_stroke_get_point_at_dist ()

    gboolean            gimp_vectors_stroke_get_point_at_dist
                                                            (gint32 vectors_ID,
                                                             gint stroke_id,
                                                             gdouble dist,
                                                             gdouble precision,
                                                             gdouble *x_point,
                                                             gdouble *y_point,
                                                             gdouble *slope,
                                                             gboolean *valid);

Get point at a specified distance along the stroke.

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.

`vectors_ID` : | The vectors object.
`stroke_id` : | The stroke ID.
`dist` : | The given distance.
`precision` : | The precision used for the approximation.
`x_point` : | The x position of the point.
`y_point` : | The y position of the point.
`slope` : | The slope (dy / dx) at the specified point.
`valid` : | Indicator for the validity of the returned data.
Returns : | TRUE on success.

Since GIMP 2.4

### gimp_vectors_stroke_interpolate ()

    gdouble*            gimp_vectors_stroke_interpolate     (gint32 vectors_ID,
                                                             gint stroke_id,
                                                             gdouble precision,
                                                             gint *num_coords,
                                                             gboolean *closed);

returns polygonal approximation of the stroke.

returns polygonal approximation of the stroke.

`vectors_ID` : | The vectors object.
`stroke_id` : | The stroke ID.
`precision` : | The precision used for the approximation.
`num_coords` : | The number of floats returned.
`closed` : | Whether the stroke is closed or not.
Returns : | List of the coords along the path (x0, y0, x1, y1, ...).

Since GIMP 2.4

### gimp_vectors_stroke_scale ()

    gboolean            gimp_vectors_stroke_scale           (gint32 vectors_ID,
                                                             gint stroke_id,
                                                             gdouble scale_x,
                                                             gdouble scale_y);

scales the given stroke.

Scale the given stroke.

`vectors_ID` : | The vectors object.
`stroke_id` : | The stroke ID.
`scale_x` : | Scale factor in x direction.
`scale_y` : | Scale factor in y direction.
Returns : | TRUE on success.

Since GIMP 2.4

### gimp_vectors_stroke_translate ()

    gboolean            gimp_vectors_stroke_translate       (gint32 vectors_ID,
                                                             gint stroke_id,
                                                             gint off_x,
                                                             gint off_y);

translate the given stroke.

Translate the given stroke.

`vectors_ID` : | The vectors object.
`stroke_id` : | The stroke ID.
`off_x` : | Offset in x direction.
`off_y` : | Offset in y direction.
Returns : | TRUE on success.

Since GIMP 2.4

### gimp_vectors_stroke_flip ()

    gboolean            gimp_vectors_stroke_flip            (gint32 vectors_ID,
                                                             gint stroke_id,
                                                             GimpOrientationType flip_type,
                                                             gdouble axis);

flips the given stroke.

Rotates the given stroke around given center by angle (in degrees).

`vectors_ID` : | The vectors object.
`stroke_id` : | The stroke ID.
`flip_type` : | Flip orientation, either vertical or horizontal.
`axis` : | axis coordinate about which to flip, in pixels.
Returns : | TRUE on success.

Since GIMP 2.4

### gimp_vectors_stroke_flip_free ()

    gboolean            gimp_vectors_stroke_flip_free       (gint32 vectors_ID,
                                                             gint stroke_id,
                                                             gdouble x1,
                                                             gdouble y1,
                                                             gdouble x2,
                                                             gdouble y2);

flips the given stroke about an arbitrary axis.

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.

`vectors_ID` : | The vectors object.
`stroke_id` : | The stroke ID.
`x1` : | X coordinate of the first point of the flipping axis.
`y1` : | Y coordinate of the first point of the flipping axis.
`x2` : | X coordinate of the second point of the flipping axis.
`y2` : | Y coordinate of the second point of the flipping axis.
Returns : | TRUE on success.

Since GIMP 2.4

### gimp_vectors_stroke_rotate ()

    gboolean            gimp_vectors_stroke_rotate          (gint32 vectors_ID,
                                                             gint stroke_id,
                                                             gdouble center_x,
                                                             gdouble center_y,
                                                             gdouble angle);

rotates the given stroke.

Rotates the given stroke around given center by angle (in degrees).

`vectors_ID` : | The vectors object.
`stroke_id` : | The stroke ID.
`center_x` : | X coordinate of the rotation center.
`center_y` : | Y coordinate of the rotation center.
`angle` : | angle to rotate about.
Returns : | TRUE on success.

Since GIMP 2.4

### gimp_vectors_bezier_stroke_conicto ()

    gboolean            gimp_vectors_bezier_stroke_conicto  (gint32 vectors_ID,
                                                             gint stroke_id,
                                                             gdouble x0,
                                                             gdouble y0,
                                                             gdouble x1,
                                                             gdouble y1);

Extends a bezier stroke with a conic bezier spline.

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.

`vectors_ID` : | The vectors object.
`stroke_id` : | The stroke ID.
`x0` : | The x-coordinate of the control point.
`y0` : | The y-coordinate of the control point.
`x1` : | The x-coordinate of the end point.
`y1` : | The y-coordinate of the end point.
Returns : | TRUE on success.

Since GIMP 2.4

### gimp_vectors_bezier_stroke_cubicto ()

    gboolean            gimp_vectors_bezier_stroke_cubicto  (gint32 vectors_ID,
                                                             gint stroke_id,
                                                             gdouble x0,
                                                             gdouble y0,
                                                             gdouble x1,
                                                             gdouble y1,
                                                             gdouble x2,
                                                             gdouble y2);

Extends a bezier stroke with a cubic bezier spline.

Extends a bezier stroke with a cubic bezier spline.

`vectors_ID` : | The vectors object.
`stroke_id` : | The stroke ID.
`x0` : | The x-coordinate of the first control point.
`y0` : | The y-coordinate of the first control point.
`x1` : | The x-coordinate of the second control point.
`y1` : | The y-coordinate of the second control point.
`x2` : | The x-coordinate of the end point.
`y2` : | The y-coordinate of the end point.
Returns : | TRUE on success.

Since GIMP 2.4

### gimp_vectors_bezier_stroke_lineto ()

    gboolean            gimp_vectors_bezier_stroke_lineto   (gint32 vectors_ID,
                                                             gint stroke_id,
                                                             gdouble x0,
                                                             gdouble y0);

Extends a bezier stroke with a lineto.

Extends a bezier stroke with a lineto.

`vectors_ID` : | The vectors object.
`stroke_id` : | The stroke ID.
`x0` : | The x-coordinate of the lineto.
`y0` : | The y-coordinate of the lineto.
Returns : | TRUE on success.

Since GIMP 2.4

### gimp_vectors_bezier_stroke_new_ellipse ()

    gint                gimp_vectors_bezier_stroke_new_ellipse
                                                            (gint32 vectors_ID,
                                                             gdouble x0,
                                                             gdouble y0,
                                                             gdouble radius_x,
                                                             gdouble radius_y,
                                                             gdouble angle);

Adds a bezier stroke describing an ellipse the vectors object.

Adds a bezier stroke describing an ellipse the vectors object.

`vectors_ID` : | The vectors object.
`x0` : | The x-coordinate of the center.
`y0` : | The y-coordinate of the center.
`radius_x` : | The radius in x direction.
`radius_y` : | The radius in y direction.
`angle` : | The angle the x-axis of the ellipse (radians, counterclockwise).
Returns : | The resulting stroke.

Since GIMP 2.4

### gimp_vectors_bezier_stroke_new_moveto ()

    gint                gimp_vectors_bezier_stroke_new_moveto
                                                            (gint32 vectors_ID,
                                                             gdouble x0,
                                                             gdouble y0);

Adds a bezier stroke with a single moveto to the vectors object.

Adds a bezier stroke with a single moveto to the vectors object.

`vectors_ID` : | The vectors object.
`x0` : | The x-coordinate of the moveto.
`y0` : | The y-coordinate of the moveto.
Returns : | The resulting stroke.

Since GIMP 2.4