summaryrefslogtreecommitdiffstats
path: root/app/vectors/gimpvectors-import.c
diff options
context:
space:
mode:
Diffstat (limited to 'app/vectors/gimpvectors-import.c')
-rw-r--r--app/vectors/gimpvectors-import.c1784
1 files changed, 1784 insertions, 0 deletions
diff --git a/app/vectors/gimpvectors-import.c b/app/vectors/gimpvectors-import.c
new file mode 100644
index 0000000..fa631ee
--- /dev/null
+++ b/app/vectors/gimpvectors-import.c
@@ -0,0 +1,1784 @@
+/* GIMP - The GNU Image Manipulation Program
+ * Copyright (C) 1995 Spencer Kimball and Peter Mattis
+ *
+ * GimpVectors Import
+ * Copyright (C) 2003-2004 Sven Neumann <sven@gimp.org>
+ *
+ * Some code here is based on code from librsvg that was originally
+ * written by Raph Levien <raph@artofcode.com> for Gill.
+ *
+ * This SVG path importer implements a subset of SVG that is
+ * sufficient to parse path elements and basic shapes and to apply
+ * transformations as described by the SVG specification:
+ * http://www.w3.org/TR/SVG/. It must handle the SVG files exported
+ * by GIMP but it is also supposed to be able to extract paths and
+ * shapes from foreign SVG documents.
+ *
+ * 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/>.
+ */
+
+#include "config.h"
+
+#include <string.h>
+#include <errno.h>
+
+#include <gdk-pixbuf/gdk-pixbuf.h>
+#include <gegl.h>
+
+#include "libgimpbase/gimpbase.h"
+#include "libgimpmath/gimpmath.h"
+
+#include "vectors-types.h"
+
+#include "config/gimpxmlparser.h"
+
+#include "core/gimperror.h"
+#include "core/gimpimage.h"
+#include "core/gimpimage-undo.h"
+
+#include "gimpbezierstroke.h"
+#include "gimpstroke.h"
+#include "gimpvectors.h"
+#include "gimpvectors-import.h"
+
+#include "gimp-intl.h"
+
+
+#define COORDS_INIT \
+ { \
+ .x = 0.0, \
+ .y = 0.0, \
+ .pressure = 1.0, \
+ .xtilt = 0.0, \
+ .ytilt = 0.0, \
+ .wheel = 0.5, \
+ .velocity = 0.0, \
+ .direction = 0.0 \
+ }
+
+
+typedef struct
+{
+ GQueue *stack;
+ GimpImage *image;
+ gboolean scale;
+ gint svg_depth;
+} SvgParser;
+
+
+typedef struct _SvgHandler SvgHandler;
+
+struct _SvgHandler
+{
+ const gchar *name;
+
+ void (* start) (SvgHandler *handler,
+ const gchar **names,
+ const gchar **values,
+ SvgParser *parser);
+ void (* end) (SvgHandler *handler,
+ SvgParser *parser);
+
+ gdouble width;
+ gdouble height;
+ gchar *id;
+ GList *paths;
+ GimpMatrix3 *transform;
+};
+
+
+typedef struct
+{
+ gchar *id;
+ GList *strokes;
+} SvgPath;
+
+
+static gboolean gimp_vectors_import (GimpImage *image,
+ GFile *file,
+ const gchar *str,
+ gsize len,
+ gboolean merge,
+ gboolean scale,
+ GimpVectors *parent,
+ gint position,
+ GList **ret_vectors,
+ GError **error);
+
+static void svg_parser_start_element (GMarkupParseContext *context,
+ const gchar *element_name,
+ const gchar **attribute_names,
+ const gchar **attribute_values,
+ gpointer user_data,
+ GError **error);
+static void svg_parser_end_element (GMarkupParseContext *context,
+ const gchar *element_name,
+ gpointer user_data,
+ GError **error);
+
+static const GMarkupParser markup_parser =
+{
+ svg_parser_start_element,
+ svg_parser_end_element,
+ NULL, /* characters */
+ NULL, /* passthrough */
+ NULL /* error */
+};
+
+
+static void svg_handler_svg_start (SvgHandler *handler,
+ const gchar **names,
+ const gchar **values,
+ SvgParser *parser);
+static void svg_handler_svg_end (SvgHandler *handler,
+ SvgParser *parser);
+static void svg_handler_group_start (SvgHandler *handler,
+ const gchar **names,
+ const gchar **values,
+ SvgParser *parser);
+static void svg_handler_path_start (SvgHandler *handler,
+ const gchar **names,
+ const gchar **values,
+ SvgParser *parser);
+static void svg_handler_rect_start (SvgHandler *handler,
+ const gchar **names,
+ const gchar **values,
+ SvgParser *parser);
+static void svg_handler_ellipse_start (SvgHandler *handler,
+ const gchar **names,
+ const gchar **values,
+ SvgParser *parser);
+static void svg_handler_line_start (SvgHandler *handler,
+ const gchar **names,
+ const gchar **values,
+ SvgParser *parser);
+static void svg_handler_poly_start (SvgHandler *handler,
+ const gchar **names,
+ const gchar **values,
+ SvgParser *parser);
+
+static const SvgHandler svg_handlers[] =
+{
+ { "svg", svg_handler_svg_start, svg_handler_svg_end },
+ { "g", svg_handler_group_start, NULL },
+ { "path", svg_handler_path_start, NULL },
+ { "rect", svg_handler_rect_start, NULL },
+ { "circle", svg_handler_ellipse_start, NULL },
+ { "ellipse", svg_handler_ellipse_start, NULL },
+ { "line", svg_handler_line_start, NULL },
+ { "polyline", svg_handler_poly_start, NULL },
+ { "polygon", svg_handler_poly_start, NULL }
+};
+
+
+static gboolean parse_svg_length (const gchar *value,
+ gdouble reference,
+ gdouble resolution,
+ gdouble *length);
+static gboolean parse_svg_viewbox (const gchar *value,
+ gdouble *width,
+ gdouble *height,
+ GimpMatrix3 *matrix);
+static gboolean parse_svg_transform (const gchar *value,
+ GimpMatrix3 *matrix);
+static GList * parse_path_data (const gchar *data);
+
+
+/**
+ * gimp_vectors_import_file:
+ * @image: the #GimpImage to add the paths to
+ * @file: a SVG file
+ * @merge: should multiple paths be merged into a single #GimpVectors object
+ * @scale: should the SVG be scaled to fit the image dimensions
+ * @position: position in the image's vectors stack where to add the vectors
+ * @error: location to store possible errors
+ *
+ * Imports one or more paths and basic shapes from a SVG file.
+ *
+ * Return value: %TRUE on success, %FALSE if an error occurred
+ **/
+gboolean
+gimp_vectors_import_file (GimpImage *image,
+ GFile *file,
+ gboolean merge,
+ gboolean scale,
+ GimpVectors *parent,
+ gint position,
+ GList **ret_vectors,
+ GError **error)
+{
+ g_return_val_if_fail (GIMP_IS_IMAGE (image), FALSE);
+ g_return_val_if_fail (G_IS_FILE (file), FALSE);
+ g_return_val_if_fail (parent == NULL ||
+ parent == GIMP_IMAGE_ACTIVE_PARENT ||
+ GIMP_IS_VECTORS (parent), FALSE);
+ g_return_val_if_fail (parent == NULL ||
+ parent == GIMP_IMAGE_ACTIVE_PARENT ||
+ gimp_item_is_attached (GIMP_ITEM (parent)), FALSE);
+ g_return_val_if_fail (parent == NULL ||
+ parent == GIMP_IMAGE_ACTIVE_PARENT ||
+ gimp_item_get_image (GIMP_ITEM (parent)) == image,
+ FALSE);
+ g_return_val_if_fail (parent == NULL ||
+ parent == GIMP_IMAGE_ACTIVE_PARENT ||
+ gimp_viewable_get_children (GIMP_VIEWABLE (parent)),
+ FALSE);
+ g_return_val_if_fail (ret_vectors == NULL || *ret_vectors == NULL, FALSE);
+ g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
+
+ return gimp_vectors_import (image, file, NULL, 0, merge, scale,
+ parent, position,
+ ret_vectors, error);
+}
+
+/**
+ * gimp_vectors_import_string:
+ * @image: the #GimpImage to add the paths to
+ * @buffer: a character buffer to parse
+ * @len: number of bytes in @str or -1 if @str is %NUL-terminated
+ * @merge: should multiple paths be merged into a single #GimpVectors object
+ * @scale: should the SVG be scaled to fit the image dimensions
+ * @error: location to store possible errors
+ *
+ * Imports one or more paths and basic shapes from a SVG file.
+ *
+ * Return value: %TRUE on success, %FALSE if an error occurred
+ **/
+gboolean
+gimp_vectors_import_buffer (GimpImage *image,
+ const gchar *buffer,
+ gsize len,
+ gboolean merge,
+ gboolean scale,
+ GimpVectors *parent,
+ gint position,
+ GList **ret_vectors,
+ GError **error)
+{
+ g_return_val_if_fail (GIMP_IS_IMAGE (image), FALSE);
+ g_return_val_if_fail (buffer != NULL || len == 0, FALSE);
+ g_return_val_if_fail (parent == NULL ||
+ parent == GIMP_IMAGE_ACTIVE_PARENT ||
+ GIMP_IS_VECTORS (parent), FALSE);
+ g_return_val_if_fail (parent == NULL ||
+ parent == GIMP_IMAGE_ACTIVE_PARENT ||
+ gimp_item_is_attached (GIMP_ITEM (parent)), FALSE);
+ g_return_val_if_fail (parent == NULL ||
+ parent == GIMP_IMAGE_ACTIVE_PARENT ||
+ gimp_item_get_image (GIMP_ITEM (parent)) == image,
+ FALSE);
+ g_return_val_if_fail (parent == NULL ||
+ parent == GIMP_IMAGE_ACTIVE_PARENT ||
+ gimp_viewable_get_children (GIMP_VIEWABLE (parent)),
+ FALSE);
+ g_return_val_if_fail (ret_vectors == NULL || *ret_vectors == NULL, FALSE);
+ g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
+
+ return gimp_vectors_import (image, NULL, buffer, len, merge, scale,
+ parent, position,
+ ret_vectors, error);
+}
+
+static gboolean
+gimp_vectors_import (GimpImage *image,
+ GFile *file,
+ const gchar *str,
+ gsize len,
+ gboolean merge,
+ gboolean scale,
+ GimpVectors *parent,
+ gint position,
+ GList **ret_vectors,
+ GError **error)
+{
+ GimpXmlParser *xml_parser;
+ SvgParser parser;
+ GList *paths;
+ SvgHandler *base;
+ gboolean success = TRUE;
+
+ parser.stack = g_queue_new ();
+ parser.image = image;
+ parser.scale = scale;
+ parser.svg_depth = 0;
+
+ /* the base of the stack, defines the size of the view-port */
+ base = g_slice_new0 (SvgHandler);
+ base->name = "image";
+ base->width = gimp_image_get_width (image);
+ base->height = gimp_image_get_height (image);
+
+ g_queue_push_head (parser.stack, base);
+
+ xml_parser = gimp_xml_parser_new (&markup_parser, &parser);
+
+ if (file)
+ success = gimp_xml_parser_parse_gfile (xml_parser, file, error);
+ else
+ success = gimp_xml_parser_parse_buffer (xml_parser, str, len, error);
+
+ gimp_xml_parser_free (xml_parser);
+
+ if (success)
+ {
+ if (base->paths)
+ {
+ GimpVectors *vectors = NULL;
+
+ base->paths = g_list_reverse (base->paths);
+
+ merge = merge && base->paths->next;
+
+ gimp_image_undo_group_start (image, GIMP_UNDO_GROUP_VECTORS_IMPORT,
+ _("Import Paths"));
+
+ for (paths = base->paths; paths; paths = paths->next)
+ {
+ SvgPath *path = paths->data;
+ GList *list;
+
+ if (! merge || ! vectors)
+ {
+ vectors = gimp_vectors_new (image,
+ ((merge || ! path->id) ?
+ _("Imported Path") : path->id));
+ gimp_image_add_vectors (image, vectors,
+ parent, position, TRUE);
+ gimp_vectors_freeze (vectors);
+
+ if (ret_vectors)
+ *ret_vectors = g_list_prepend (*ret_vectors, vectors);
+
+ if (position != -1)
+ position++;
+ }
+
+ for (list = path->strokes; list; list = list->next)
+ gimp_vectors_stroke_add (vectors, GIMP_STROKE (list->data));
+
+ if (! merge)
+ gimp_vectors_thaw (vectors);
+
+ g_list_free_full (path->strokes, g_object_unref);
+ path->strokes = NULL;
+ }
+
+ if (merge)
+ gimp_vectors_thaw (vectors);
+
+ gimp_image_undo_group_end (image);
+ }
+ else
+ {
+ if (file)
+ g_set_error (error, GIMP_ERROR, GIMP_FAILED,
+ _("No paths found in '%s'"),
+ gimp_file_get_utf8_name (file));
+ else
+ g_set_error_literal (error, GIMP_ERROR, GIMP_FAILED,
+ _("No paths found in the buffer"));
+
+ success = FALSE;
+ }
+ }
+ else if (error && *error && file) /* parser reported an error */
+ {
+ gchar *msg = (*error)->message;
+
+ (*error)->message =
+ g_strdup_printf (_("Failed to import paths from '%s': %s"),
+ gimp_file_get_utf8_name (file), msg);
+
+ g_free (msg);
+ }
+
+ while ((base = g_queue_pop_head (parser.stack)) != NULL)
+ {
+ for (paths = base->paths; paths; paths = paths->next)
+ {
+ SvgPath *path = paths->data;
+ GList *list;
+
+ g_free (path->id);
+
+ for (list = path->strokes; list; list = list->next)
+ g_object_unref (list->data);
+
+ g_list_free (path->strokes);
+
+ g_slice_free (SvgPath, path);
+ }
+
+ g_list_free (base->paths);
+
+ g_slice_free (GimpMatrix3, base->transform);
+ g_slice_free (SvgHandler, base);
+ }
+
+ g_queue_free (parser.stack);
+
+ return success;
+}
+
+static void
+svg_parser_start_element (GMarkupParseContext *context,
+ const gchar *element_name,
+ const gchar **attribute_names,
+ const gchar **attribute_values,
+ gpointer user_data,
+ GError **error)
+{
+ SvgParser *parser = user_data;
+ SvgHandler *handler;
+ SvgHandler *base;
+ gint i = 0;
+
+ handler = g_slice_new0 (SvgHandler);
+ base = g_queue_peek_head (parser->stack);
+
+ /* if the element is not rendered, always use the generic handler */
+ if (base->width <= 0.0 || base->height <= 0.0)
+ i = G_N_ELEMENTS (svg_handlers);
+
+ for (; i < G_N_ELEMENTS (svg_handlers); i++)
+ if (strcmp (svg_handlers[i].name, element_name) == 0)
+ {
+ handler->name = svg_handlers[i].name;
+ handler->start = svg_handlers[i].start;
+ break;
+ }
+
+ handler->width = base->width;
+ handler->height = base->height;
+
+ g_queue_push_head (parser->stack, handler);
+
+ if (handler->start)
+ handler->start (handler, attribute_names, attribute_values, parser);
+}
+
+static void
+svg_parser_end_element (GMarkupParseContext *context,
+ const gchar *element_name,
+ gpointer user_data,
+ GError **error)
+{
+ SvgParser *parser = user_data;
+ SvgHandler *handler;
+ SvgHandler *base;
+ GList *paths;
+
+ handler = g_queue_pop_head (parser->stack);
+
+ g_return_if_fail (handler != NULL &&
+ (handler->name == NULL ||
+ strcmp (handler->name, element_name) == 0));
+
+ if (handler->end)
+ handler->end (handler, parser);
+
+ if (handler->paths)
+ {
+ if (handler->transform)
+ {
+ for (paths = handler->paths; paths; paths = paths->next)
+ {
+ SvgPath *path = paths->data;
+ GList *list;
+
+ for (list = path->strokes; list; list = list->next)
+ gimp_stroke_transform (GIMP_STROKE (list->data),
+ handler->transform, NULL);
+ }
+
+ g_slice_free (GimpMatrix3, handler->transform);
+ }
+
+ base = g_queue_peek_head (parser->stack);
+ base->paths = g_list_concat (base->paths, handler->paths);
+ }
+
+ g_slice_free (SvgHandler, handler);
+}
+
+static void
+svg_handler_svg_start (SvgHandler *handler,
+ const gchar **names,
+ const gchar **values,
+ SvgParser *parser)
+{
+ GimpMatrix3 *matrix;
+ GimpMatrix3 box;
+ const gchar *viewbox = NULL;
+ gdouble x = 0;
+ gdouble y = 0;
+ gdouble w = handler->width;
+ gdouble h = handler->height;
+ gdouble xres;
+ gdouble yres;
+
+ matrix = g_slice_new (GimpMatrix3);
+ gimp_matrix3_identity (matrix);
+
+ gimp_image_get_resolution (parser->image, &xres, &yres);
+
+ while (*names)
+ {
+ switch (*names[0])
+ {
+ case 'x':
+ if (strcmp (*names, "x") == 0)
+ parse_svg_length (*values, handler->width, xres, &x);
+ break;
+
+ case 'y':
+ if (strcmp (*names, "y") == 0)
+ parse_svg_length (*values, handler->height, yres, &y);
+ break;
+
+ case 'w':
+ if (strcmp (*names, "width") == 0)
+ parse_svg_length (*values, handler->width, xres, &w);
+ break;
+
+ case 'h':
+ if (strcmp (*names, "height") == 0)
+ parse_svg_length (*values, handler->height, yres, &h);
+ break;
+
+ case 'v':
+ if (strcmp (*names, "viewBox") == 0)
+ viewbox = *values;
+ break;
+ }
+
+ names++;
+ values++;
+ }
+
+ if (x || y)
+ {
+ /* according to the spec offsets are meaningless on the outermost svg */
+ if (parser->svg_depth > 0)
+ gimp_matrix3_translate (matrix, x, y);
+ }
+
+ if (viewbox && parse_svg_viewbox (viewbox, &w, &h, &box))
+ {
+ gimp_matrix3_mult (&box, matrix);
+ }
+
+ /* optionally scale the outermost svg to image size */
+ if (parser->scale && parser->svg_depth == 0)
+ {
+ if (w > 0.0 && h > 0.0)
+ gimp_matrix3_scale (matrix,
+ gimp_image_get_width (parser->image) / w,
+ gimp_image_get_height (parser->image) / h);
+ }
+
+ handler->width = w;
+ handler->height = h;
+
+ handler->transform = matrix;
+
+ parser->svg_depth++;
+}
+
+static void
+svg_handler_svg_end (SvgHandler *handler,
+ SvgParser *parser)
+{
+ parser->svg_depth--;
+}
+
+static void
+svg_handler_group_start (SvgHandler *handler,
+ const gchar **names,
+ const gchar **values,
+ SvgParser *parser)
+{
+ while (*names)
+ {
+ if (strcmp (*names, "transform") == 0 && ! handler->transform)
+ {
+ GimpMatrix3 matrix;
+
+ if (parse_svg_transform (*values, &matrix))
+ {
+ handler->transform = g_slice_dup (GimpMatrix3, &matrix);
+
+#ifdef DEBUG_VECTORS_IMPORT
+ g_printerr ("transform %s: %g %g %g %g %g %g %g %g %g\n",
+ handler->id ? handler->id : "(null)",
+ handler->transform->coeff[0][0],
+ handler->transform->coeff[0][1],
+ handler->transform->coeff[0][2],
+ handler->transform->coeff[1][0],
+ handler->transform->coeff[1][1],
+ handler->transform->coeff[1][2],
+ handler->transform->coeff[2][0],
+ handler->transform->coeff[2][1],
+ handler->transform->coeff[2][2]);
+#endif
+ }
+ }
+
+ names++;
+ values++;
+ }
+}
+
+static void
+svg_handler_path_start (SvgHandler *handler,
+ const gchar **names,
+ const gchar **values,
+ SvgParser *parser)
+{
+ SvgPath *path = g_slice_new0 (SvgPath);
+
+ while (*names)
+ {
+ switch (*names[0])
+ {
+ case 'i':
+ if (strcmp (*names, "id") == 0 && ! path->id)
+ path->id = g_strdup (*values);
+ break;
+
+ case 'd':
+ if (strcmp (*names, "d") == 0 && ! path->strokes)
+ path->strokes = parse_path_data (*values);
+ break;
+
+ case 't':
+ if (strcmp (*names, "transform") == 0 && ! handler->transform)
+ {
+ GimpMatrix3 matrix;
+
+ if (parse_svg_transform (*values, &matrix))
+ {
+ handler->transform = g_slice_dup (GimpMatrix3, &matrix);
+ }
+ }
+ break;
+ }
+
+ names++;
+ values++;
+ }
+
+ handler->paths = g_list_prepend (handler->paths, path);
+}
+
+static void
+svg_handler_rect_start (SvgHandler *handler,
+ const gchar **names,
+ const gchar **values,
+ SvgParser *parser)
+{
+ SvgPath *path = g_slice_new0 (SvgPath);
+ gdouble x = 0.0;
+ gdouble y = 0.0;
+ gdouble width = 0.0;
+ gdouble height = 0.0;
+ gdouble rx = 0.0;
+ gdouble ry = 0.0;
+ gdouble xres;
+ gdouble yres;
+
+ gimp_image_get_resolution (parser->image, &xres, &yres);
+
+ while (*names)
+ {
+ switch (*names[0])
+ {
+ case 'i':
+ if (strcmp (*names, "id") == 0 && ! path->id)
+ path->id = g_strdup (*values);
+ break;
+
+ case 'x':
+ if (strcmp (*names, "x") == 0)
+ parse_svg_length (*values, handler->width, xres, &x);
+ break;
+
+ case 'y':
+ if (strcmp (*names, "y") == 0)
+ parse_svg_length (*values, handler->height, yres, &y);
+ break;
+
+ case 'w':
+ if (strcmp (*names, "width") == 0)
+ parse_svg_length (*values, handler->width, xres, &width);
+ break;
+
+ case 'h':
+ if (strcmp (*names, "height") == 0)
+ parse_svg_length (*values, handler->height, yres, &height);
+ break;
+
+ case 'r':
+ if (strcmp (*names, "rx") == 0)
+ parse_svg_length (*values, handler->width, xres, &rx);
+ else if (strcmp (*names, "ry") == 0)
+ parse_svg_length (*values, handler->height, yres, &ry);
+ break;
+
+ case 't':
+ if (strcmp (*names, "transform") == 0 && ! handler->transform)
+ {
+ GimpMatrix3 matrix;
+
+ if (parse_svg_transform (*values, &matrix))
+ {
+ handler->transform = g_slice_dup (GimpMatrix3, &matrix);
+ }
+ }
+ break;
+ }
+
+ names++;
+ values++;
+ }
+
+ if (width > 0.0 && height > 0.0 && rx >= 0.0 && ry >= 0.0)
+ {
+ GimpStroke *stroke;
+ GimpCoords point = COORDS_INIT;
+
+ if (rx == 0.0)
+ rx = ry;
+ if (ry == 0.0)
+ ry = rx;
+
+ rx = MIN (rx, width / 2);
+ ry = MIN (ry, height / 2);
+
+ point.x = x + width - rx;
+ point.y = y;
+ stroke = gimp_bezier_stroke_new_moveto (&point);
+
+ if (rx)
+ {
+ GimpCoords end = COORDS_INIT;
+
+ end.x = x + width;
+ end.y = y + ry;
+
+ gimp_bezier_stroke_arcto (stroke, rx, ry, 0, FALSE, TRUE, &end);
+ }
+
+ point.x = x + width;
+ point.y = y + height - ry;
+ gimp_bezier_stroke_lineto (stroke, &point);
+
+ if (rx)
+ {
+ GimpCoords end = COORDS_INIT;
+
+ end.x = x + width - rx;
+ end.y = y + height;
+
+ gimp_bezier_stroke_arcto (stroke, rx, ry, 0, FALSE, TRUE, &end);
+ }
+
+ point.x = x + rx;
+ point.y = y + height;
+ gimp_bezier_stroke_lineto (stroke, &point);
+
+ if (rx)
+ {
+ GimpCoords end = COORDS_INIT;
+
+ end.x = x;
+ end.y = y + height - ry;
+
+ gimp_bezier_stroke_arcto (stroke, rx, ry, 0, FALSE, TRUE, &end);
+ }
+
+ point.x = x;
+ point.y = y + ry;
+ gimp_bezier_stroke_lineto (stroke, &point);
+
+ if (rx)
+ {
+ GimpCoords end = COORDS_INIT;
+
+ end.x = x + rx;
+ end.y = y;
+
+ gimp_bezier_stroke_arcto (stroke, rx, ry, 0, FALSE, TRUE, &end);
+ }
+
+ /* the last line is handled by closing the stroke */
+ gimp_stroke_close (stroke);
+
+ path->strokes = g_list_prepend (path->strokes, stroke);
+ }
+
+ handler->paths = g_list_prepend (handler->paths, path);
+}
+
+static void
+svg_handler_ellipse_start (SvgHandler *handler,
+ const gchar **names,
+ const gchar **values,
+ SvgParser *parser)
+{
+ SvgPath *path = g_slice_new0 (SvgPath);
+ GimpCoords center = COORDS_INIT;
+ gdouble rx = 0.0;
+ gdouble ry = 0.0;
+ gdouble xres;
+ gdouble yres;
+
+ gimp_image_get_resolution (parser->image, &xres, &yres);
+
+ while (*names)
+ {
+ switch (*names[0])
+ {
+ case 'i':
+ if (strcmp (*names, "id") == 0 && ! path->id)
+ path->id = g_strdup (*values);
+ break;
+
+ case 'c':
+ if (strcmp (*names, "cx") == 0)
+ parse_svg_length (*values, handler->width, xres, &center.x);
+ else if (strcmp (*names, "cy") == 0)
+ parse_svg_length (*values, handler->height, yres, &center.y);
+ break;
+
+ case 'r':
+ if (strcmp (*names, "r") == 0)
+ {
+ parse_svg_length (*values, handler->width, xres, &rx);
+ parse_svg_length (*values, handler->height, yres, &ry);
+ }
+ else if (strcmp (*names, "rx") == 0)
+ {
+ parse_svg_length (*values, handler->width, xres, &rx);
+ }
+ else if (strcmp (*names, "ry") == 0)
+ {
+ parse_svg_length (*values, handler->height, yres, &ry);
+ }
+ break;
+
+ case 't':
+ if (strcmp (*names, "transform") == 0 && ! handler->transform)
+ {
+ GimpMatrix3 matrix;
+
+ if (parse_svg_transform (*values, &matrix))
+ {
+ handler->transform = g_slice_dup (GimpMatrix3, &matrix);
+ }
+ }
+ break;
+ }
+
+ names++;
+ values++;
+ }
+
+ if (rx >= 0.0 && ry >= 0.0)
+ path->strokes = g_list_prepend (path->strokes,
+ gimp_bezier_stroke_new_ellipse (&center,
+ rx, ry,
+ 0.0));
+
+ handler->paths = g_list_prepend (handler->paths, path);
+}
+
+static void
+svg_handler_line_start (SvgHandler *handler,
+ const gchar **names,
+ const gchar **values,
+ SvgParser *parser)
+{
+ SvgPath *path = g_slice_new0 (SvgPath);
+ GimpCoords start = COORDS_INIT;
+ GimpCoords end = COORDS_INIT;
+ GimpStroke *stroke;
+ gdouble xres;
+ gdouble yres;
+
+ gimp_image_get_resolution (parser->image, &xres, &yres);
+
+ while (*names)
+ {
+ switch (*names[0])
+ {
+ case 'i':
+ if (strcmp (*names, "id") == 0 && ! path->id)
+ path->id = g_strdup (*values);
+ break;
+
+ case 'x':
+ if (strcmp (*names, "x1") == 0)
+ parse_svg_length (*values, handler->width, xres, &start.x);
+ else if (strcmp (*names, "x2") == 0)
+ parse_svg_length (*values, handler->width, xres, &end.x);
+ break;
+
+ case 'y':
+ if (strcmp (*names, "y1") == 0)
+ parse_svg_length (*values, handler->height, yres, &start.y);
+ else if (strcmp (*names, "y2") == 0)
+ parse_svg_length (*values, handler->height, yres, &end.y);
+ break;
+
+ case 't':
+ if (strcmp (*names, "transform") == 0 && ! handler->transform)
+ {
+ GimpMatrix3 matrix;
+
+ if (parse_svg_transform (*values, &matrix))
+ {
+ handler->transform = g_slice_dup (GimpMatrix3, &matrix);
+ }
+ }
+ break;
+ }
+
+ names++;
+ values++;
+ }
+
+ stroke = gimp_bezier_stroke_new_moveto (&start);
+ gimp_bezier_stroke_lineto (stroke, &end);
+
+ path->strokes = g_list_prepend (path->strokes, stroke);
+
+ handler->paths = g_list_prepend (handler->paths, path);
+}
+
+static void
+svg_handler_poly_start (SvgHandler *handler,
+ const gchar **names,
+ const gchar **values,
+ SvgParser *parser)
+{
+ SvgPath *path = g_slice_new0 (SvgPath);
+ GString *points = NULL;
+
+ while (*names)
+ {
+ switch (*names[0])
+ {
+ case 'i':
+ if (strcmp (*names, "id") == 0 && ! path->id)
+ path->id = g_strdup (*values);
+ break;
+
+ case 'p':
+ if (strcmp (*names, "points") == 0 && ! points)
+ {
+ const gchar *p = *values;
+ const gchar *m = NULL;
+ const gchar *l = NULL;
+ gint n = 0;
+
+ while (*p)
+ {
+ while (g_ascii_isspace (*p) || *p == ',')
+ p++;
+
+ switch (n)
+ {
+ case 0:
+ m = p;
+ break;
+ case 2:
+ l = p;
+ break;
+ }
+
+ if (*p)
+ n++;
+
+ while (*p && ! g_ascii_isspace (*p) && *p != ',')
+ p++;
+ }
+
+ if ((n > 3) && (n % 2 == 0))
+ {
+ points = g_string_sized_new (p - *values + 8);
+
+ g_string_append_len (points, "M ", 2);
+ g_string_append_len (points, m, l - m);
+
+ g_string_append_len (points, "L ", 2);
+ g_string_append_len (points, l, p - l);
+
+ if (strcmp (handler->name, "polygon") == 0)
+ g_string_append_c (points, 'Z');
+ }
+ }
+ break;
+
+ case 't':
+ if (strcmp (*names, "transform") == 0 && ! handler->transform)
+ {
+ GimpMatrix3 matrix;
+
+ if (parse_svg_transform (*values, &matrix))
+ {
+ handler->transform = g_slice_dup (GimpMatrix3, &matrix);
+ }
+ }
+ break;
+ }
+
+ names++;
+ values++;
+ }
+
+ if (points)
+ {
+ path->strokes = parse_path_data (points->str);
+ g_string_free (points, TRUE);
+ }
+
+ handler->paths = g_list_prepend (handler->paths, path);
+}
+
+static gboolean
+parse_svg_length (const gchar *value,
+ gdouble reference,
+ gdouble resolution,
+ gdouble *length)
+{
+ GimpUnit unit = GIMP_UNIT_PIXEL;
+ gdouble len;
+ gchar *ptr;
+
+ len = g_ascii_strtod (value, &ptr);
+
+ while (g_ascii_isspace (*ptr))
+ ptr++;
+
+ switch (ptr[0])
+ {
+ case '\0':
+ break;
+
+ case 'p':
+ switch (ptr[1])
+ {
+ case 'x': break;
+ case 't': unit = GIMP_UNIT_POINT; break;
+ case 'c': unit = GIMP_UNIT_PICA; break;
+ default:
+ return FALSE;
+ }
+ ptr += 2;
+ break;
+
+ case 'c':
+ if (ptr[1] == 'm')
+ len *= 10.0, unit = GIMP_UNIT_MM;
+ else
+ return FALSE;
+ ptr += 2;
+ break;
+
+ case 'm':
+ if (ptr[1] == 'm')
+ unit = GIMP_UNIT_MM;
+ else
+ return FALSE;
+ ptr += 2;
+ break;
+
+ case 'i':
+ if (ptr[1] == 'n')
+ unit = GIMP_UNIT_INCH;
+ else
+ return FALSE;
+ ptr += 2;
+ break;
+
+ case '%':
+ unit = GIMP_UNIT_PERCENT;
+ ptr += 1;
+ break;
+
+ default:
+ return FALSE;
+ }
+
+ while (g_ascii_isspace (*ptr))
+ ptr++;
+
+ if (*ptr)
+ return FALSE;
+
+ switch (unit)
+ {
+ case GIMP_UNIT_PERCENT:
+ *length = len * reference / 100.0;
+ break;
+
+ case GIMP_UNIT_PIXEL:
+ *length = len;
+ break;
+
+ default:
+ *length = len * resolution / gimp_unit_get_factor (unit);
+ break;
+ }
+
+ return TRUE;
+}
+
+static gboolean
+parse_svg_viewbox (const gchar *value,
+ gdouble *width,
+ gdouble *height,
+ GimpMatrix3 *matrix)
+{
+ gdouble x, y, w, h;
+ gchar *tok;
+ gchar *str = g_strdup (value);
+ gboolean success = FALSE;
+
+ x = y = w = h = 0;
+
+ tok = strtok (str, ", \t");
+ if (tok)
+ {
+ x = g_ascii_strtod (tok, NULL);
+ tok = strtok (NULL, ", \t");
+ if (tok)
+ {
+ y = g_ascii_strtod (tok, NULL);
+ tok = strtok (NULL, ", \t");
+ if (tok != NULL)
+ {
+ w = g_ascii_strtod (tok, NULL);
+ tok = strtok (NULL, ", \t");
+ if (tok)
+ {
+ h = g_ascii_strtod (tok, NULL);
+ success = TRUE;
+ }
+ }
+ }
+ }
+
+ g_free (str);
+
+ if (success)
+ {
+ gimp_matrix3_identity (matrix);
+ gimp_matrix3_translate (matrix, -x, -y);
+
+ if (w > 0.0 && h > 0.0)
+ {
+ gimp_matrix3_scale (matrix, *width / w, *height / h);
+ }
+ else /* disable rendering of the element */
+ {
+#ifdef DEBUG_VECTORS_IMPORT
+ g_printerr ("empty viewBox");
+#endif
+ *width = *height = 0.0;
+ }
+ }
+ else
+ {
+ g_printerr ("SVG import: cannot parse viewBox attribute\n");
+ }
+
+ return success;
+}
+
+static gboolean
+parse_svg_transform (const gchar *value,
+ GimpMatrix3 *matrix)
+{
+ gint i;
+
+ gimp_matrix3_identity (matrix);
+
+ for (i = 0; value[i]; i++)
+ {
+ GimpMatrix3 trafo;
+ gchar keyword[32];
+ gdouble args[6];
+ gint n_args;
+ gint key_len;
+
+ gimp_matrix3_identity (&trafo);
+
+ /* skip initial whitespace */
+ while (g_ascii_isspace (value[i]))
+ i++;
+
+ /* parse keyword */
+ for (key_len = 0; key_len < sizeof (keyword); key_len++)
+ {
+ gchar c = value[i];
+
+ if (g_ascii_isalpha (c) || c == '-')
+ keyword[key_len] = value[i++];
+ else
+ break;
+ }
+
+ if (key_len >= sizeof (keyword))
+ return FALSE;
+
+ keyword[key_len] = '\0';
+
+ /* skip whitespace */
+ while (g_ascii_isspace (value[i]))
+ i++;
+
+ if (value[i] != '(')
+ return FALSE;
+ i++;
+
+ for (n_args = 0; ; n_args++)
+ {
+ gchar c;
+ gchar *end_ptr;
+
+ /* skip whitespace */
+ while (g_ascii_isspace (value[i]))
+ i++;
+
+ c = value[i];
+ if (g_ascii_isdigit (c) || c == '+' || c == '-' || c == '.')
+ {
+ if (n_args == G_N_ELEMENTS (args))
+ return FALSE; /* too many args */
+
+ args[n_args] = g_ascii_strtod (value + i, &end_ptr);
+ i = end_ptr - value;
+
+ while (g_ascii_isspace (value[i]))
+ i++;
+
+ /* skip optional comma */
+ if (value[i] == ',')
+ i++;
+ }
+ else if (c == ')')
+ break;
+ else
+ return FALSE;
+ }
+
+ /* OK, have parsed keyword and args, now calculate the transform matrix */
+
+ if (strcmp (keyword, "matrix") == 0)
+ {
+ if (n_args != 6)
+ return FALSE;
+
+ gimp_matrix3_affine (&trafo,
+ args[0], args[1],
+ args[2], args[3],
+ args[4], args[5]);
+ }
+ else if (strcmp (keyword, "translate") == 0)
+ {
+ if (n_args == 1)
+ args[1] = 0.0;
+ else if (n_args != 2)
+ return FALSE;
+
+ gimp_matrix3_translate (&trafo, args[0], args[1]);
+ }
+ else if (strcmp (keyword, "scale") == 0)
+ {
+ if (n_args == 1)
+ args[1] = args[0];
+ else if (n_args != 2)
+ return FALSE;
+
+ gimp_matrix3_scale (&trafo, args[0], args[1]);
+ }
+ else if (strcmp (keyword, "rotate") == 0)
+ {
+ if (n_args == 1)
+ {
+ gimp_matrix3_rotate (&trafo, gimp_deg_to_rad (args[0]));
+ }
+ else if (n_args == 3)
+ {
+ gimp_matrix3_translate (&trafo, -args[1], -args[2]);
+ gimp_matrix3_rotate (&trafo, gimp_deg_to_rad (args[0]));
+ gimp_matrix3_translate (&trafo, args[1], args[2]);
+ }
+ else
+ return FALSE;
+ }
+ else if (strcmp (keyword, "skewX") == 0)
+ {
+ if (n_args != 1)
+ return FALSE;
+
+ gimp_matrix3_xshear (&trafo, tan (gimp_deg_to_rad (args[0])));
+ }
+ else if (strcmp (keyword, "skewY") == 0)
+ {
+ if (n_args != 1)
+ return FALSE;
+
+ gimp_matrix3_yshear (&trafo, tan (gimp_deg_to_rad (args[0])));
+ }
+ else
+ {
+ return FALSE; /* unknown keyword */
+ }
+
+ gimp_matrix3_invert (&trafo);
+ gimp_matrix3_mult (&trafo, matrix);
+ }
+
+ gimp_matrix3_invert (matrix);
+
+ return TRUE;
+}
+
+
+/**********************************************************/
+/* Below is the code that parses the actual path data. */
+/* */
+/* This code is taken from librsvg and was originally */
+/* written by Raph Levien <raph@artofcode.com> for Gill. */
+/**********************************************************/
+
+typedef struct
+{
+ GList *strokes;
+ GimpStroke *stroke;
+ gdouble cpx, cpy; /* current point */
+ gdouble rpx, rpy; /* reflection point (for 's' and 't' commands) */
+ gchar cmd; /* current command (lowercase) */
+ gint param; /* number of parameters */
+ gboolean rel; /* true if relative coords */
+ gdouble params[7]; /* parameters that have been parsed */
+} ParsePathContext;
+
+
+static void parse_path_default_xy (ParsePathContext *ctx,
+ gint n_params);
+static void parse_path_do_cmd (ParsePathContext *ctx,
+ gboolean final);
+
+
+static GList *
+parse_path_data (const gchar *data)
+{
+ ParsePathContext ctx;
+
+ gboolean in_num = FALSE;
+ gboolean in_frac = FALSE;
+ gboolean in_exp = FALSE;
+ gboolean exp_wait_sign = FALSE;
+ gdouble val = 0.0;
+ gchar c = 0;
+ gint sign = 0;
+ gint exp = 0;
+ gint exp_sign = 0;
+ gdouble frac = 0.0;
+ gint i;
+
+ memset (&ctx, 0, sizeof (ParsePathContext));
+
+ for (i = 0; ; i++)
+ {
+ c = data[i];
+
+ if (c >= '0' && c <= '9')
+ {
+ /* digit */
+ if (in_num)
+ {
+ if (in_exp)
+ {
+ exp = (exp * 10) + c - '0';
+ exp_wait_sign = FALSE;
+ }
+ else if (in_frac)
+ val += (frac *= 0.1) * (c - '0');
+ else
+ val = (val * 10) + c - '0';
+ }
+ else
+ {
+ in_num = TRUE;
+ in_frac = FALSE;
+ in_exp = FALSE;
+ exp = 0;
+ exp_sign = 1;
+ exp_wait_sign = FALSE;
+ val = c - '0';
+ sign = 1;
+ }
+ }
+ else if (c == '.')
+ {
+ if (! in_num)
+ {
+ in_num = TRUE;
+ val = 0;
+ }
+
+ in_frac = TRUE;
+ frac = 1;
+ }
+ else if ((c == 'E' || c == 'e') && in_num)
+ {
+ in_exp = TRUE;
+ exp_wait_sign = TRUE;
+ exp = 0;
+ exp_sign = 1;
+ }
+ else if ((c == '+' || c == '-') && in_exp)
+ {
+ exp_sign = c == '+' ? 1 : -1;
+ }
+ else if (in_num)
+ {
+ /* end of number */
+
+ val *= sign * pow (10, exp_sign * exp);
+
+ if (ctx.rel)
+ {
+ /* Handle relative coordinates. This switch statement attempts
+ to determine _what_ the coords are relative to. This is
+ underspecified in the 12 Apr working draft. */
+ switch (ctx.cmd)
+ {
+ case 'l':
+ case 'm':
+ case 'c':
+ case 's':
+ case 'q':
+ case 't':
+ /* rule: even-numbered params are x-relative, odd-numbered
+ are y-relative */
+ if ((ctx.param & 1) == 0)
+ val += ctx.cpx;
+ else if ((ctx.param & 1) == 1)
+ val += ctx.cpy;
+ break;
+
+ case 'a':
+ /* rule: sixth and seventh are x and y, rest are not
+ relative */
+ if (ctx.param == 5)
+ val += ctx.cpx;
+ else if (ctx.param == 6)
+ val += ctx.cpy;
+ break;
+
+ case 'h':
+ /* rule: x-relative */
+ val += ctx.cpx;
+ break;
+
+ case 'v':
+ /* rule: y-relative */
+ val += ctx.cpy;
+ break;
+ }
+ }
+
+ ctx.params[ctx.param++] = val;
+ parse_path_do_cmd (&ctx, FALSE);
+ in_num = FALSE;
+ }
+
+ if (c == '\0')
+ {
+ break;
+ }
+ else if ((c == '+' || c == '-') && ! exp_wait_sign)
+ {
+ sign = c == '+' ? 1 : -1;
+ val = 0;
+ in_num = TRUE;
+ in_frac = FALSE;
+ in_exp = FALSE;
+ exp = 0;
+ exp_sign = 1;
+ exp_wait_sign = FALSE;
+ }
+ else if (c == 'z' || c == 'Z')
+ {
+ if (ctx.param)
+ parse_path_do_cmd (&ctx, TRUE);
+
+ if (ctx.stroke)
+ gimp_stroke_close (ctx.stroke);
+ }
+ else if (c >= 'A' && c <= 'Z' && c != 'E')
+ {
+ if (ctx.param)
+ parse_path_do_cmd (&ctx, TRUE);
+
+ ctx.cmd = c + 'a' - 'A';
+ ctx.rel = FALSE;
+ }
+ else if (c >= 'a' && c <= 'z' && c != 'e')
+ {
+ if (ctx.param)
+ parse_path_do_cmd (&ctx, TRUE);
+
+ ctx.cmd = c;
+ ctx.rel = TRUE;
+ }
+ /* else c _should_ be whitespace or , */
+ }
+
+ return g_list_reverse (ctx.strokes);
+}
+
+/* supply defaults for missing parameters, assuming relative coordinates
+ are to be interpreted as x,y */
+static void
+parse_path_default_xy (ParsePathContext *ctx,
+ gint n_params)
+{
+ gint i;
+
+ if (ctx->rel)
+ {
+ for (i = ctx->param; i < n_params; i++)
+ {
+ if (i > 2)
+ ctx->params[i] = ctx->params[i - 2];
+ else if (i == 1)
+ ctx->params[i] = ctx->cpy;
+ else if (i == 0)
+ /* we shouldn't get here (ctx->param > 0 as precondition) */
+ ctx->params[i] = ctx->cpx;
+ }
+ }
+ else
+ {
+ for (i = ctx->param; i < n_params; i++)
+ ctx->params[i] = 0.0;
+ }
+}
+
+static void
+parse_path_do_cmd (ParsePathContext *ctx,
+ gboolean final)
+{
+ GimpCoords coords = COORDS_INIT;
+
+ switch (ctx->cmd)
+ {
+ case 'm':
+ /* moveto */
+ if (ctx->param == 2 || final)
+ {
+ parse_path_default_xy (ctx, 2);
+
+ coords.x = ctx->cpx = ctx->rpx = ctx->params[0];
+ coords.y = ctx->cpy = ctx->rpy = ctx->params[1];
+
+ ctx->stroke = gimp_bezier_stroke_new_moveto (&coords);
+ ctx->strokes = g_list_prepend (ctx->strokes, ctx->stroke);
+
+ ctx->param = 0;
+
+ /* If a moveto is followed by multiple pairs of coordinates,
+ * the subsequent pairs are treated as implicit lineto commands.
+ */
+ ctx->cmd = 'l';
+ }
+ break;
+
+ case 'l':
+ /* lineto */
+ if (ctx->param == 2 || final)
+ {
+ parse_path_default_xy (ctx, 2);
+
+ coords.x = ctx->cpx = ctx->rpx = ctx->params[0];
+ coords.y = ctx->cpy = ctx->rpy = ctx->params[1];
+
+ gimp_bezier_stroke_lineto (ctx->stroke, &coords);
+
+ ctx->param = 0;
+ }
+ break;
+
+ case 'c':
+ /* curveto */
+ if (ctx->param == 6 || final)
+ {
+ GimpCoords ctrl1 = COORDS_INIT;
+ GimpCoords ctrl2 = COORDS_INIT;
+
+ parse_path_default_xy (ctx, 6);
+
+ ctrl1.x = ctx->params[0];
+ ctrl1.y = ctx->params[1];
+ ctrl2.x = ctx->rpx = ctx->params[2];
+ ctrl2.y = ctx->rpy = ctx->params[3];
+ coords.x = ctx->cpx = ctx->params[4];
+ coords.y = ctx->cpy = ctx->params[5];
+
+ gimp_bezier_stroke_cubicto (ctx->stroke, &ctrl1, &ctrl2, &coords);
+
+ ctx->param = 0;
+ }
+ break;
+
+ case 's':
+ /* smooth curveto */
+ if (ctx->param == 4 || final)
+ {
+ GimpCoords ctrl1 = COORDS_INIT;
+ GimpCoords ctrl2 = COORDS_INIT;
+
+ parse_path_default_xy (ctx, 4);
+
+ ctrl1.x = 2 * ctx->cpx - ctx->rpx;
+ ctrl1.y = 2 * ctx->cpy - ctx->rpy;
+ ctrl2.x = ctx->rpx = ctx->params[0];
+ ctrl2.y = ctx->rpy = ctx->params[1];
+ coords.x = ctx->cpx = ctx->params[2];
+ coords.y = ctx->cpy = ctx->params[3];
+
+ gimp_bezier_stroke_cubicto (ctx->stroke, &ctrl1, &ctrl2, &coords);
+
+ ctx->param = 0;
+ }
+ break;
+
+ case 'h':
+ /* horizontal lineto */
+ if (ctx->param == 1)
+ {
+ coords.x = ctx->cpx = ctx->rpx = ctx->params[0];
+ coords.y = ctx->cpy;
+
+ gimp_bezier_stroke_lineto (ctx->stroke, &coords);
+
+ ctx->param = 0;
+ }
+ break;
+
+ case 'v':
+ /* vertical lineto */
+ if (ctx->param == 1)
+ {
+ coords.x = ctx->cpx;
+ coords.y = ctx->cpy = ctx->rpy = ctx->params[0];
+
+ gimp_bezier_stroke_lineto (ctx->stroke, &coords);
+
+ ctx->param = 0;
+ }
+ break;
+
+ case 'q':
+ /* quadratic bezier curveto */
+ if (ctx->param == 4 || final)
+ {
+ GimpCoords ctrl = COORDS_INIT;
+
+ parse_path_default_xy (ctx, 4);
+
+ ctrl.x = ctx->rpx = ctx->params[0];
+ ctrl.y = ctx->rpy = ctx->params[1];
+ coords.x = ctx->cpx = ctx->params[2];
+ coords.y = ctx->cpy = ctx->params[3];
+
+ gimp_bezier_stroke_conicto (ctx->stroke, &ctrl, &coords);
+
+ ctx->param = 0;
+ }
+ break;
+
+ case 't':
+ /* truetype quadratic bezier curveto */
+ if (ctx->param == 2 || final)
+ {
+ GimpCoords ctrl = COORDS_INIT;
+
+ parse_path_default_xy (ctx, 2);
+
+ ctrl.x = ctx->rpx = 2 * ctx->cpx - ctx->rpx;
+ ctrl.y = ctx->rpy = 2 * ctx->cpy - ctx->rpy;
+ coords.x = ctx->cpx = ctx->params[0];
+ coords.y = ctx->cpy = ctx->params[1];
+
+ gimp_bezier_stroke_conicto (ctx->stroke, &ctrl, &coords);
+
+ ctx->param = 0;
+ }
+ else if (final)
+ {
+ if (ctx->param > 2)
+ {
+ GimpCoords ctrl = COORDS_INIT;
+
+ parse_path_default_xy (ctx, 4);
+
+ ctrl.x = ctx->rpx = ctx->params[0];
+ ctrl.y = ctx->rpy = ctx->params[1];
+ coords.x = ctx->cpx = ctx->params[2];
+ coords.y = ctx->cpy = ctx->params[3];
+
+ gimp_bezier_stroke_conicto (ctx->stroke, &ctrl, &coords);
+ }
+ else
+ {
+ parse_path_default_xy (ctx, 2);
+
+ coords.x = ctx->cpx = ctx->rpx = ctx->params[0];
+ coords.y = ctx->cpy = ctx->rpy = ctx->params[1];
+
+ gimp_bezier_stroke_lineto (ctx->stroke, &coords);
+ }
+
+ ctx->param = 0;
+ }
+ break;
+
+ case 'a':
+ if (ctx->param == 7 || final)
+ {
+ coords.x = ctx->cpx = ctx->rpx = ctx->params[5];
+ coords.y = ctx->cpy = ctx->rpy = ctx->params[6];
+
+ gimp_bezier_stroke_arcto (ctx->stroke,
+ ctx->params[0], ctx->params[1],
+ gimp_deg_to_rad (ctx->params[2]),
+ ctx->params[3], ctx->params[4],
+ &coords);
+ ctx->param = 0;
+ }
+ break;
+
+ default:
+ ctx->param = 0;
+ break;
+ }
+}
generated by cgit v1.2.3 (git 2.39.1) at 2024-11-26 04:40:13 +0000