/src/cairo/src/cairo-svg-glyph-render.c

Source
/* -*- Mode: c; c-basic-offset: 4; indent-tabs-mode: t; tab-width: 8; -*- */
/* cairo - a vector graphics library with display and print output
 *
 * Copyright © 2022 Adrian Johnson
 *
 * This library is free software; you can redistribute it and/or
 * modify it either under the terms of the GNU Lesser General Public
 * License version 2.1 as published by the Free Software Foundation
 * (the "LGPL") or, at your option, under the terms of the Mozilla
 * Public License Version 1.1 (the "MPL"). If you do not alter this
 * notice, a recipient may use your version of this file under either
 * the MPL or the LGPL.
 *
 * You should have received a copy of the LGPL along with this library
 * in the file COPYING-LGPL-2.1; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA
 * You should have received a copy of the MPL along with this library
 * in the file COPYING-MPL-1.1
 *
 * The contents of this file are subject to the Mozilla Public License
 * Version 1.1 (the "License"); you may not use this file except in
 * compliance with the License. You may obtain a copy of the License at
 * http://www.mozilla.org/MPL/
 *
 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY
 * OF ANY KIND, either express or implied. See the LGPL or the MPL for
 * the specific language governing rights and limitations.
 *
 * The Original Code is the cairo graphics library.
 *
 * The Initial Developer of the Original Code is Adrian Johnson.
 *
 * Contributor(s):
 *  Adrian Johnson <ajohnson@redneon.com>
 */

#include "cairoint.h"
#include "cairo-array-private.h"
#include "cairo-ft-private.h"
#include "cairo-pattern-private.h"
#include "cairo-scaled-font-subsets-private.h"

#include <stdarg.h>
#include <stdio.h>
#include <string.h>

#if HAVE_FT_SVG_DOCUMENT

#include <ft2build.h>
#include FT_COLOR_H

/* #define SVG_RENDER_PRINT_FUNCTIONS 1 */

#define WHITE_SPACE_CHARS " \n\r\t\v\f"

typedef struct {
    const char *name;
    int red;
    int green;
    int blue;
} color_name_t;

/* Must be sorted */
static color_name_t color_names[] = {
    { "aliceblue", 240, 248, 255 },
    { "antiquewhite", 250, 235, 215 },
    { "aqua",  0, 255, 255 },
    { "aquamarine", 127, 255, 212 },
    { "azure", 240, 255, 255 },
    { "beige", 245, 245, 220 },
    { "bisque", 255, 228, 196 },
    { "black",  0, 0, 0 },
    { "blanchedalmond", 255, 235, 205 },
    { "blue",  0, 0, 255 },
    { "blueviolet", 138, 43, 226 },
    { "brown", 165, 42, 42 },
    { "burlywood", 222, 184, 135 },
    { "cadetblue",  95, 158, 160 },
    { "chartreuse", 127, 255, 0 },
    { "chocolate", 210, 105, 30 },
    { "coral", 255, 127, 80 },
    { "cornflowerblue", 100, 149, 237 },
    { "cornsilk", 255, 248, 220 },
    { "crimson", 220, 20, 60 },
    { "cyan",  0, 255, 255 },
    { "darkblue",  0, 0, 139 },
    { "darkcyan",  0, 139, 139 },
    { "darkgoldenrod", 184, 134, 11 },
    { "darkgray", 169, 169, 169 },
    { "darkgreen",  0, 100, 0 },
    { "darkgrey", 169, 169, 169 },
    { "darkkhaki", 189, 183, 107 },
    { "darkmagenta", 139, 0, 139 },
    { "darkolivegreen",  85, 107, 47 },
    { "darkorange", 255, 140, 0 },
    { "darkorchid", 153, 50, 204 },
    { "darkred", 139, 0, 0 },
    { "darksalmon", 233, 150, 122 },
    { "darkseagreen", 143, 188, 143 },
    { "darkslateblue",  72, 61, 139 },
    { "darkslategray",  47, 79, 79 },
    { "darkslategrey",  47, 79, 79 },
    { "darkturquoise",  0, 206, 209 },
    { "darkviolet", 148, 0, 211 },
    { "deeppink", 255, 20, 147 },
    { "deepskyblue",  0, 191, 255 },
    { "dimgray", 105, 105, 105 },
    { "dimgrey", 105, 105, 105 },
    { "dodgerblue",  30, 144, 255 },
    { "firebrick", 178, 34, 34 },
    { "floralwhite", 255, 250, 240 },
    { "forestgreen",  34, 139, 34 },
    { "fuchsia", 255, 0, 255 },
    { "gainsboro", 220, 220, 220 },
    { "ghostwhite", 248, 248, 255 },
    { "gold", 255, 215, 0 },
    { "goldenrod", 218, 165, 32 },
    { "gray", 128, 128, 128 },
    { "green",  0, 128, 0 },
    { "greenyellow", 173, 255, 47 },
    { "grey", 128, 128, 128 },
    { "honeydew", 240, 255, 240 },
    { "hotpink", 255, 105, 180 },
    { "indianred", 205, 92, 92 },
    { "indigo",  75, 0, 130 },
    { "ivory", 255, 255, 240 },
    { "khaki", 240, 230, 140 },
    { "lavender", 230, 230, 250 },
    { "lavenderblush", 255, 240, 245 },
    { "lawngreen", 124, 252, 0 },
    { "lemonchiffon", 255, 250, 205 },
    { "lightblue", 173, 216, 230 },
    { "lightcoral", 240, 128, 128 },
    { "lightcyan", 224, 255, 255 },
    { "lightgoldenrodyellow", 250, 250, 210 },
    { "lightgray", 211, 211, 211 },
    { "lightgreen", 144, 238, 144 },
    { "lightgrey", 211, 211, 211 },
    { "lightpink", 255, 182, 193 },
    { "lightsalmon", 255, 160, 122 },
    { "lightseagreen",  32, 178, 170 },
    { "lightskyblue", 135, 206, 250 },
    { "lightslategray", 119, 136, 153 },
    { "lightslategrey", 119, 136, 153 },
    { "lightsteelblue", 176, 196, 222 },
    { "lightyellow", 255, 255, 224 },
    { "lime",  0, 255, 0 },
    { "limegreen",  50, 205, 50 },
    { "linen", 250, 240, 230 },
    { "magenta", 255, 0, 255 },
    { "maroon", 128, 0, 0 },
    { "mediumaquamarine", 102, 205, 170 },
    { "mediumblue",  0, 0, 205 },
    { "mediumorchid", 186, 85, 211 },
    { "mediumpurple", 147, 112, 219 },
    { "mediumseagreen",  60, 179, 113 },
    { "mediumslateblue", 123, 104, 238 },
    { "mediumspringgreen",  0, 250, 154 },
    { "mediumturquoise",  72, 209, 204 },
    { "mediumvioletred", 199, 21, 133 },
    { "midnightblue",  25, 25, 112 },
    { "mintcream", 245, 255, 250 },
    { "mistyrose", 255, 228, 225 },
    { "moccasin", 255, 228, 181 },
    { "navajowhite", 255, 222, 173 },
    { "navy",  0, 0, 128 },
    { "oldlace", 253, 245, 230 },
    { "olive", 128, 128, 0 },
    { "olivedrab", 107, 142, 35 },
    { "orange", 255, 165, 0 },
    { "orangered", 255, 69, 0 },
    { "orchid", 218, 112, 214 },
    { "palegoldenrod", 238, 232, 170 },
    { "palegreen", 152, 251, 152 },
    { "paleturquoise", 175, 238, 238 },
    { "palevioletred", 219, 112, 147 },
    { "papayawhip", 255, 239, 213 },
    { "peachpuff", 255, 218, 185 },
    { "peru", 205, 133, 63 },
    { "pink", 255, 192, 203 },
    { "plum", 221, 160, 221 },
    { "powderblue", 176, 224, 230 },
    { "purple", 128, 0, 128 },
    { "red", 255, 0, 0 },
    { "rosybrown", 188, 143, 143 },
    { "royalblue",  65, 105, 225 },
    { "saddlebrown", 139, 69, 19 },
    { "salmon", 250, 128, 114 },
    { "sandybrown", 244, 164, 96 },
    { "seagreen",  46, 139, 87 },
    { "seashell", 255, 245, 238 },
    { "sienna", 160, 82, 45 },
    { "silver", 192, 192, 192 },
    { "skyblue", 135, 206, 235 },
    { "slateblue", 106, 90, 205 },
    { "slategray", 112, 128, 144 },
    { "slategrey", 112, 128, 144 },
    { "snow", 255, 250, 250 },
    { "springgreen",  0, 255, 127 },
    { "steelblue",  70, 130, 180 },
    { "tan", 210, 180, 140 },
    { "teal",  0, 128, 128 },
    { "thistle", 216, 191, 216 },
    { "tomato", 255, 99, 71 },
    { "turquoise",  64, 224, 208 },
    { "violet", 238, 130, 238 },
    { "wheat", 245, 222, 179 },
    { "white", 255, 255, 255 },
    { "whitesmoke", 245, 245, 245 },
    { "yellow", 255, 255, 0 },
    { "yellowgreen", 154, 205, 50 }
};

typedef struct {
    char *name;
    char *value;
} svg_attribute_t;

typedef enum {
    CONTAINER_ELEMENT,
    EMPTY_ELEMENT,
    PROCESSING_INSTRUCTION,
    DOCTYPE,
    CDATA,
    COMMENT
} tag_type_t;

#define TOP_ELEMENT_TAG "_top"

typedef struct _cairo_svg_element {
    cairo_hash_entry_t base;
    tag_type_t type;
    char *tag;
    char *id;
    cairo_array_t attributes; /* svg_attribute_t */
    cairo_array_t children; /* cairo_svg_element_t* */
    cairo_array_t  content; /* char */
    cairo_pattern_t *pattern; /* defined if a paint server */
    struct _cairo_svg_element *next; /* next on element stack */
} cairo_svg_element_t;

typedef struct _cairo_svg_color {
    enum { RGB, FOREGROUND } type;
    double red;
    double green;
    double blue;
} cairo_svg_color_t;

typedef struct _cairo_svg_paint {
    enum { PAINT_COLOR, PAINT_SERVER, PAINT_NONE } type;
    cairo_svg_color_t color;
    cairo_svg_element_t *paint_server;
} cairo_svg_paint_t;

typedef enum {
    GS_RENDER,
    GS_NO_RENDER,
    GS_COMPUTE_BBOX,
    GS_CLIP
} gs_mode_t;

typedef struct _cairo_svg_graphics_state {
    cairo_svg_paint_t fill;
    cairo_svg_paint_t stroke;
    cairo_svg_color_t color;
    double fill_opacity;
    double stroke_opacity;
    double opacity;
    cairo_fill_rule_t fill_rule;
    cairo_fill_rule_t clip_rule;
    cairo_path_t *clip_path;
    char *dash_array;
    double dash_offset;
    gs_mode_t mode;
    struct {
        double x;
        double y;
        double width;
        double height;
    } bbox;
    struct _cairo_svg_graphics_state *next;
} cairo_svg_graphics_state_t;

typedef enum {
    BUILD_PATTERN_NONE,
    BUILD_PATTERN_LINEAR,
    BUILD_PATTERN_RADIAL
} build_pattern_t;

typedef struct _cairo_svg_glyph_render {
    cairo_svg_element_t *tree;
    cairo_hash_table_t *ids;
    cairo_svg_graphics_state_t *graphics_state;
    cairo_t *cr;
    double units_per_em;
    struct {
        cairo_svg_element_t *paint_server;
        cairo_pattern_t *pattern;
        build_pattern_t type;
    } build_pattern;
    int render_element_tree_depth;
    int num_palette_entries;
    FT_Color* palette;

    /* Viewport */
    double width;
    double height;
    cairo_bool_t view_port_set;

    cairo_pattern_t *foreground_marker;
    cairo_pattern_t *foreground_source;
    cairo_bool_t foreground_source_used;

    int debug; /* 0 = quiet, 1 = errors, 2 = warnings, 3 = info */
} cairo_svg_glyph_render_t;


#define SVG_RENDER_ERROR 1
#define SVG_RENDER_WARNING 2
#define SVG_RENDER_INFO 3

#define print_error(render, ...) cairo_svg_glyph_render_printf(render, SVG_RENDER_ERROR, ##__VA_ARGS__)
#define print_warning(render, ...) cairo_svg_glyph_render_printf(render, SVG_RENDER_WARNING, ##__VA_ARGS__)
#define print_info(render, ...) cairo_svg_glyph_render_printf(render, SVG_RENDER_INFO, ##__VA_ARGS__)

static void
cairo_svg_glyph_render_printf (cairo_svg_glyph_render_t *svg_render,
                               int level,
                               const char *fmt, ...) CAIRO_PRINTF_FORMAT (3, 4);

static void
cairo_svg_glyph_render_printf (cairo_svg_glyph_render_t *svg_render,
                               int level,
                               const char *fmt, ...)
{
    va_list ap;

    if (svg_render->debug >= level ) {
        switch (level) {
            case SVG_RENDER_ERROR:
                printf("ERROR: ");
                break;
            case SVG_RENDER_WARNING:
                printf("WARNING: ");
                break;
        }
  va_start (ap, fmt);
  vprintf (fmt, ap);
  va_end (ap);
  printf ("\n");
    }
}

static cairo_bool_t
string_equal (const char *s1, const char *s2)
{
    if (s1 && s2)
        return strcmp (s1, s2) == 0;

    if (!s1 && !s2)
        return TRUE;

    return FALSE;
}

static cairo_bool_t
string_match (const char **p, const char *str)
{
    if (*p && strncmp (*p, str, strlen (str)) == 0) {
        *p += strlen (str);
        return TRUE;
    }
    return FALSE;
}

static const char *
skip_space (const char *p)
{
    while (*p && _cairo_isspace (*p))
        p++;

    return p;
}

/* Skip over character c and and whitespace before or after. Returns
 * NULL if c not found. */
static const char *
skip_char (const char *p, char c)
{
    while (_cairo_isspace (*p))
        p++;

    if (*p != c)
        return NULL;

    p++;

    while (_cairo_isspace (*p))
        p++;

    return p;
}

static int
_color_name_compare (const void *a, const void *b)
{
    const color_name_t *a_color = a;
    const color_name_t *b_color = b;

    return strcmp (a_color->name, b_color->name);
}

static void
init_element_id_key (cairo_svg_element_t *element)
{
    element->base.hash = _cairo_hash_string (element->id);
}

static cairo_bool_t
_element_id_equal (const void *key_a, const void *key_b)
{
    const cairo_svg_element_t *a = key_a;
    const cairo_svg_element_t *b = key_b;

    return string_equal (a->id, b->id);
}

/* Find element with the "id" attribute matching id. id may have the
 * '#' prefix. It will be stripped before searching.
 */
static cairo_svg_element_t *
lookup_element (cairo_svg_glyph_render_t *svg_render, const char *id)
{
    cairo_svg_element_t key;

    if (!id || strlen (id) < 1)
        return NULL;

    key.id = (char *)(id[0] == '#' ? id + 1 : id);
    init_element_id_key (&key);
    return _cairo_hash_table_lookup (svg_render->ids, &key.base);
}

/* Find element with the "id" attribute matching url where url is of
 * the form "url(#id)".
 */
static cairo_svg_element_t *
lookup_url_element (cairo_svg_glyph_render_t *svg_render, const char *url)
{
    const char *p = url;
    cairo_svg_element_t *element = NULL;

    if (p && string_match (&p, "url")) {
        p = skip_char (p, '(');
        if (!p)
            return NULL;

        const char *end = strpbrk(p, WHITE_SPACE_CHARS ")");
        if (end) {
            char *id = _cairo_strndup (p, end - p);
            element = lookup_element (svg_render, id);
            free (id);
        }
    }
    return element;
}

static const char *
get_attribute (const cairo_svg_element_t *element, const char *name)
{
    svg_attribute_t attr;
    int num_elems, i;

    num_elems = _cairo_array_num_elements (&element->attributes);
    for (i = 0; i < num_elems; i++) {
  _cairo_array_copy_element (&element->attributes, i, &attr);
        if (string_equal (attr.name, name))
            return attr.value;
    }
    return NULL;
}

static const char *
get_href_attribute (const cairo_svg_element_t *element)
{
    svg_attribute_t attr;
    int num_elems, i, len;

    /* SVG2 requires the href attribute to be "href". Older versions
     * used "xlink:href". I have seen at least one font that used an
     * alternative name space eg "ns1:href". To keep things simple we
     * search for an attribute named "href" or ending in ":href".
     */
    num_elems = _cairo_array_num_elements (&element->attributes);
    for (i = 0; i < num_elems; i++) {
  _cairo_array_copy_element (&element->attributes, i, &attr);
        if (string_equal (attr.name, "href"))
            return attr.value;

        len = strlen (attr.name);
        if (len > 4 && string_equal (attr.name + len - 5, ":href"))
            return attr.value;
    }
    return NULL;
}

/* Get a float attribute or float percentage. If attribute is a
 * percentage, the returned value is percentage * scale.  Does not
 * modify value if it returns FALSE. This allows value to be set to a
 * default before calling get_float_attribute(), then used without
 * checking the return value of this function.
 */
static cairo_bool_t
get_float_or_percent_attribute (const cairo_svg_element_t *element,
                                const char *name,
                                double scale,
                                double *value)
{
    const char *p;
    char *end;
    double v;

    p = get_attribute (element, name);
    if (p) {
        v = _cairo_strtod (p, &end);
        if (end != p) {
            *value = v;
            if (*end == '%')
                *value *= scale / 100.0;
            return TRUE;
        }
    }
    return FALSE;
}

/* Does not modify value if it returns FALSE. This allows value to be
 * set to a default before calling get_float_attribute(), then used
 * without checking the return value of this function.
 */
static cairo_bool_t
get_float_attribute (const cairo_svg_element_t *element, const char *name, double *value)
{
    const char *p;
    char *end;
    double v;

    p = get_attribute (element, name);
    if (p) {
        v = _cairo_strtod (p, &end);
        if (end != p) {
            *value = v;
            return TRUE;
        }
    }
    return FALSE;
}

static cairo_fill_rule_t
get_fill_rule_attribute (const cairo_svg_element_t *element, const char *name, cairo_fill_rule_t default_value)
{
    const char *p;

    p = get_attribute (element, name);
    if (string_equal (p, "nonzero"))
        return CAIRO_FILL_RULE_WINDING;
    else if (string_equal (p, "evenodd"))
        return CAIRO_FILL_RULE_EVEN_ODD;
    else
        return default_value;
}

static void
free_elements (cairo_svg_glyph_render_t *svg_render,
              cairo_svg_element_t      *element)
{
    int num_elems;

    num_elems = _cairo_array_num_elements (&element->children);
    for (int i = 0; i < num_elems; i++) {
  cairo_svg_element_t *child;
        _cairo_array_copy_element (&element->children, i, &child);
  free_elements (svg_render, child);
    }
    _cairo_array_fini (&element->children);

    num_elems = _cairo_array_num_elements (&element->attributes);
    for (int i = 0; i < num_elems; i++) {
  svg_attribute_t *attr = _cairo_array_index (&element->attributes, i);
  free (attr->name);
  free (attr->value);
    }
    _cairo_array_fini (&element->attributes);
    _cairo_array_fini (&element->content);

    free (element->tag);

    if (element->id) {
        _cairo_hash_table_remove (svg_render->ids, &element->base);
        free (element->id);
    }

    if (element->pattern)
        cairo_pattern_destroy (element->pattern);

    free (element);
}

#if SVG_RENDER_PRINT_FUNCTIONS

static void indent(int level)
{
    for (int i = 1; i < level; i++)
        printf("  ");
}

static void
print_element (cairo_svg_element_t *element, cairo_bool_t recurse, int level)
{
    char *content = strndup (_cairo_array_index_const (&element->content, 0),
                             _cairo_array_num_elements (&element->content));

    indent(level);
    if (element->type == COMMENT) {
        printf("<!--%s-->\n", content);
    } else if (element->type == CDATA) {
        printf("<![CDATA[%s]]>\n", content);
    } else if (element->type == DOCTYPE) {
        printf("<!DOCTYPE%s>\n", content);
    } else if (element->type == PROCESSING_INSTRUCTION) {
        printf("<?%s?>\n", content);
    } else {
        cairo_bool_t top_element = string_equal (element->tag, TOP_ELEMENT_TAG);

        if (!top_element) {
            printf("<%s", element->tag);
            int num_elems = _cairo_array_num_elements (&element->attributes);
            for (int i = 0; i < num_elems; i++) {
                svg_attribute_t *attr = _cairo_array_index (&element->attributes, i);
                printf(" %s=\"%s\"", attr->name, attr->value);
            }
            if (num_elems > 0)
                printf(" ");

            if (element->type == EMPTY_ELEMENT)
                printf("/>\n");
            else
                printf(">\n");
        }

        if (element->type == CONTAINER_ELEMENT) {
            if (recurse) {
                int num_elems = _cairo_array_num_elements (&element->children);
                for (int i = 0; i < num_elems; i++) {
                    cairo_svg_element_t *child;
                    _cairo_array_copy_element (&element->children, i, &child);
                    print_element (child, TRUE, level + 1);
                }
            }
            if (!top_element)
                printf("</%s>\n", element->tag);
        }
    }
    free (content);
}
#endif

static const char *
parse_list_of_floats (const char *p,
                      int num_required,
                      int num_optional,
                      cairo_bool_t *have_optional,
                      va_list ap)
{
    double d;
    double *dp;
    char *end;
    const char *q = NULL;
    int num_found = 0;

    for (int i = 0; i < num_required + num_optional; i++) {
        while (p && (*p == ',' || _cairo_isspace (*p)))
            p++;

        if (!p)
            break;

        d = _cairo_strtod (p, &end);
        if (end == p) {
            p = NULL;
            break;
        }
        p = end;
        dp = va_arg (ap, double *);
        *dp = d;
        num_found++;
        if (num_found == num_required)
            q = p;
    }

    if (num_optional > 0) {
        if (num_found == num_required + num_optional) {
            *have_optional = TRUE;
        } else {
            *have_optional = FALSE;
            /* restore pointer to end of required floats */
            p = q;
        }
    }

    return p;
}

static const char *
get_floats (const char *p,
            int num_required,
            int num_optional,
            cairo_bool_t *have_optional,
            ...)
{
    va_list ap;

    va_start (ap, have_optional);
    p = parse_list_of_floats (p, num_required, num_optional, have_optional, ap);
    va_end (ap);
    return p;
}

static const char *
get_path_params (const char *p, int num_params, ...)
{
    va_list ap;

    va_start (ap, num_params);
    p = parse_list_of_floats (p, num_params, 0, NULL, ap);
    va_end (ap);
    return p;
}

static cairo_bool_t
get_color (cairo_svg_glyph_render_t *svg_render,
           const char               *s,
           cairo_svg_color_t        *color)
{
    int len, matched;
    unsigned r = 0, g = 0, b = 0;

    if (!s)
        return FALSE;

    len = strlen(s);

    if (string_equal (s, "inherit")) {
  return FALSE;
    } else if (string_equal (s, "currentColor") ||
         string_equal (s, "context-fill") ||
         string_equal (s, "context-stroke"))
    {
  *color = svg_render->graphics_state->color;
        return TRUE;
    } else if (len > 0 && s[0] == '#') {
        if (len == 4) {
            matched = sscanf (s + 1, "%1x%1x%1x", &r, &g, &b);
            if (matched == 3) {
                /* Each digit is repeated to convert to 6 digits. eg 0x123 -> 0x112233 */
                color->type = RGB;
                color->red = 0x11*r/255.0;
                color->green = 0x11*g/255.0;
                color->blue = 0x11*b/255.0;
                return TRUE;
            }
        } else if (len == 7) {
            matched = sscanf (s + 1, "%2x%2x%2x", &r, &g, &b);
            if (matched == 3) {
                color->type = RGB;
                color->red = r/255.0;
                color->green = g/255.0;
                color->blue = b/255.0;
                return TRUE;
            }
        }
    } else if (strncmp (s, "rgb", 3) == 0) {
        matched = sscanf (s, "rgb ( %u , %u , %u )", &r, &g, &b);
        if (matched == 3) {
            color->type = RGB;
            color->red = r/255.0;
            color->green = g/255.0;
            color->blue = b/255.0;
            return TRUE;
        }
    } else if (strncmp (s, "var", 3) == 0) {
        /* CPAL palettes colors. eg "var(--color0, yellow)" */
        s += 3;
        s = skip_char (s, '(');
        if (!string_match (&s, "--color"))
            return FALSE;

        char *end;
        int entry = strtol (s, &end, 10);
        if (end == s)
            return FALSE;

        if (svg_render->palette && entry >= 0 && entry < svg_render->num_palette_entries) {
            FT_Color *palette_color = &svg_render->palette[entry];
            color->type = RGB;
            color->red = palette_color->red / 255.0;
            color->green = palette_color->green/ 255.0;
            color->blue = palette_color->blue / 255.0;
            return TRUE;
        } else {
            /* Fallback color */
            s = skip_char (end, ',');
            if (!s)
            return FALSE;

            end = strpbrk(s, WHITE_SPACE_CHARS ")");
            if (!end || end == s)
    return FALSE;

            char *fallback = _cairo_strndup (s, end - s);
            cairo_bool_t success = get_color (svg_render, fallback, color);
            free (fallback);
            return success;
        }
    } else {
        const color_name_t *color_name;
        color_name_t color_name_key;

        color_name_key.name = (char *) s;
        color_name = bsearch (&color_name_key,
                              color_names,
                              ARRAY_LENGTH (color_names),
                              sizeof (color_name_t),
                             _color_name_compare);
        if (color_name) {
            color->type = RGB;
            color->red = color_name->red/255.0;
            color->green = color_name->green/255.0;
            color->blue = color_name->blue/255.0;
            return TRUE;
        }
    }
    return FALSE;
}

static void
get_paint (cairo_svg_glyph_render_t *svg_render,
           const char *p,
           cairo_svg_paint_t *paint)
{
    cairo_svg_element_t *element;

    if (string_match (&p, "none")) {
        paint->type = PAINT_NONE;
        paint->paint_server = NULL;
    } else if (p && strncmp (p, "url", 3) == 0) {
        element = lookup_url_element (svg_render, p);
        if (element) {
            paint->type = PAINT_SERVER;
            paint->paint_server = element;
        }
    } else {
        if (get_color (svg_render, p, &paint->color)) {
            paint->type = PAINT_COLOR;
            paint->paint_server = NULL;
        }
    }
}

#ifdef SVG_RENDER_PRINT_FUNCTIONS

static void
print_color (cairo_svg_color_t *color)
{
    switch (color->type) {
        case FOREGROUND_COLOR:
            printf("foreground");
            break;
        case RGB:
            printf("#%02x%02x%02x",
                   (int)(color->red*255),
                   (int)(color->red*255),
                   (int)(color->red*255));
            break;
    }
}

static void
print_paint (cairo_svg_paint_t *paint)
{
    printf("Paint: ");
    switch (paint->type) {
        case PAINT_COLOR:
            printf("color: ");
            print_color (&paint->color);
            break;
        case PAINT_SERVER:
            printf("server: %s", paint->paint_server->tag);
            break;
        case PAINT_NONE:
            printf("none");
            break;
    }
    printf("\n");
}

#endif

static void
parse_error (cairo_svg_glyph_render_t *svg_render,
             const char *string,
             const char *location,
             const char *fmt,
             ...) CAIRO_PRINTF_FORMAT (4, 5);

static void
parse_error (cairo_svg_glyph_render_t *svg_render,
             const char *string,
             const char *location,
             const char *fmt,
             ...)
{
    va_list ap;
    const int context = 40;
    const char *start;
    const char *end;

    if (svg_render->debug >= SVG_RENDER_ERROR) {
        printf("ERROR: ");
  va_start (ap, fmt);
  vprintf (fmt, ap);
  va_end (ap);
        putchar ('\n');
        start = location - context;
        if (start < string)
            start = string;

        end = location + strlen (location);
        if (end - location > context)
            end = location + context;

        for (const char *p = start; p < end; p++) {
            if (_cairo_isspace (*p))
                putchar (' ');
            else
                putchar (*p);
        }
        putchar ('\n');

        for (int i = 0; i < location - start; i++)
            putchar(' ');
        putchar ('^');
        putchar ('\n');
  printf (" at position %td\n", location - string);
    }
}

static cairo_bool_t
append_attribute (cairo_svg_element_t *element, svg_attribute_t *attribute)
{
    const char *p;
    const char *end;
    svg_attribute_t attr;

    memset (&attr, 0, sizeof (attr));
    if (string_equal (attribute->name, "style")) {
        /* split style into individual attributes */
        p = attribute->value;
        while (*p) {
            end = strchr (p, ':');
            if (!end || end == p)
                break;
            attr.name = _cairo_strndup (p, end - p);
            p = end + 1;
            p = skip_space(p);
            end = strchr (p, ';');
            if (!end)
                end = strchr (p, 0);
            if (end == p)
                goto split_style_fail;

            attr.value = _cairo_strndup (p, end - p);
            if (*end)
                p = end + 1;

            if (_cairo_array_append (&element->attributes, &attr))
                goto split_style_fail;

            memset (&attr, 0, sizeof (attr));
            p = skip_space (p);
        }
    }

    if (_cairo_array_append (&element->attributes, attribute))
        return FALSE;

    return TRUE;

  split_style_fail:
    free (attr.name);
    free (attr.value);
    return FALSE;
}

static cairo_bool_t
add_child_element (cairo_svg_glyph_render_t *svg_render,
                   cairo_svg_element_t *parent,
                   cairo_svg_element_t *child)
{
    cairo_status_t status;
    const char* id;

    id = get_attribute (child, "id");
    if (id) {
        child->id = strdup (id);
        init_element_id_key (child);
  status = _cairo_hash_table_insert (svg_render->ids, &child->base);
  if (unlikely (status))
            return FALSE;
    }

    status = _cairo_array_append (&parent->children, &child);
    return status == CAIRO_STATUS_SUCCESS;
}

static cairo_svg_element_t *
create_element (tag_type_t type, char *tag)
{
    cairo_svg_element_t *elem;
    cairo_status_t status;

    elem = _cairo_calloc (sizeof (cairo_svg_element_t));
    if (unlikely (elem == NULL)) {
  status = _cairo_error (CAIRO_STATUS_NO_MEMORY);
        return NULL;
    }

    elem->type = type;
    elem->tag = tag;
    elem->id = NULL;
    _cairo_array_init (&elem->attributes, sizeof(svg_attribute_t));
    _cairo_array_init (&elem->children, sizeof(cairo_svg_element_t *));
    _cairo_array_init (&elem->content, sizeof(char));
    elem->pattern = NULL;
    elem->next = NULL;

    return elem;
}

static const char *
parse_attributes (cairo_svg_glyph_render_t *svg_render,
                  const char               *attributes,
                  cairo_svg_element_t      *element)
{
    svg_attribute_t attr;
    char quote_char;
    const char *p;
    const char *end;

    p = attributes;
    memset (&attr, 0, sizeof (svg_attribute_t));
    p = skip_space (p);
    while (*p && *p != '/' && *p != '>' && *p != '?') {
        end = strpbrk(p, WHITE_SPACE_CHARS "=");
        if (!end) {
            parse_error (svg_render, attributes, p, "Could not find '='");
            goto fail;
        }

        if (end == p) {
            parse_error (svg_render, attributes, p, "Missing attribute name");
            goto fail;
        }

        attr.name = _cairo_strndup (p, end - p);
        p = end;

        p = skip_space (p);
        if (*p != '=') {
            parse_error (svg_render, attributes, p, "Expected '='");
            goto fail;
        }

        p++;
        p = skip_space (p);
        if (*p == '\"' || *p == '\'') {
            quote_char = *p;
        } else {
            parse_error (svg_render, attributes, p, "Could not find '\"' or '''");
            goto fail;
        }

        p++;
        end = strchr (p, quote_char);
        if (!end) {
            parse_error (svg_render, attributes, p, "Could not find '%c'", quote_char);
            goto fail;
        }

        attr.value = _cairo_strndup (p, end - p);
        p = end + 1;

        if (!append_attribute (element, &attr))
            goto fail;

        memset (&attr, 0, sizeof (svg_attribute_t));

        p = skip_space (p);
    }

    return p;

  fail:
    free (attr.name);
    free (attr.value);
    return NULL;
}

static cairo_bool_t
parse_svg (cairo_svg_glyph_render_t *svg_render,
           const char               *svg_document)
{
    const char *p = svg_document;
    const char *end;
    int nesting; /* when > 0 we parse content */
    cairo_svg_element_t *open_elem; /* Stack of open elements */
    cairo_svg_element_t *new_elem = NULL;
    char *name;
    cairo_status_t status;

    /* Create top level element to use as a container for all top
     * level elements in the document and push it on the stack. */
    open_elem = create_element (CONTAINER_ELEMENT, strdup(TOP_ELEMENT_TAG));

    /* We don't want to add content to the top level container. There
     * should only be whitesapce between tags. */
    nesting = 0;

    while (*p) {
        if (nesting > 0) {
            /* In an open element. Anything before the next '<' is content */
            end = strchr (p, '<');
            if (!end) {
                parse_error (svg_render, svg_document, p, "Could not find '<'");
                goto fail;
            }
            status = _cairo_array_append_multiple (&open_elem->content, p, end - p);
            p = end;

        } else {
            p = skip_space (p);
            if (*p == 0)
                break; /* end of document */
        }

        /* We should now be at the start of a tag */
        if (*p != '<') {
            parse_error (svg_render, svg_document, p, "Could not find '<'");
            goto fail;
        }

        p++;
        if (*p == '!') {
            p++;
            if (string_match (&p, "[CDATA[")) {
                new_elem = create_element (CDATA, NULL);
                end = strstr (p, "]]>");
                if (!end) {
                    parse_error (svg_render, svg_document, p, "Could not find ']]>'");
                    goto fail;
                }

                status = _cairo_array_append_multiple (&new_elem->content, p, end - p);
                p = end + 3;
            } else if (string_match (&p, "--")) {
                new_elem = create_element (COMMENT, NULL);
                end = strstr (p, "-->");
                if (!end) {
                    parse_error (svg_render, svg_document, p, "Could not find '-->'");
                    goto fail;
                }

                status = _cairo_array_append_multiple (&new_elem->content, p, end - p);
                p = end + 3;
            } else if (string_match (&p, "DOCTYPE")) {
                new_elem = create_element (DOCTYPE, NULL);
                end = strchr (p, '>');
                if (!end) {
                    parse_error (svg_render, svg_document, p, "Could not find '>'");
                    goto fail;
                }

                status = _cairo_array_append_multiple (&new_elem->content, p, end - p);
                p = end + 1;
            } else {
                parse_error (svg_render, svg_document, p, "Invalid");
                goto fail;
            }

            if (!add_child_element (svg_render, open_elem, new_elem))
                goto fail;

            new_elem = NULL;
            continue;
        }

        if (*p == '?') {
            p++;
            new_elem = create_element (PROCESSING_INSTRUCTION, NULL);
            end = strstr (p, "?>");
            if (!end) {
                parse_error (svg_render, svg_document, p, "Could not find '?>'");
                goto fail;
            }

            status = _cairo_array_append_multiple (&new_elem->content, p, end - p);
            p = end + 2;

            if (!add_child_element (svg_render, open_elem, new_elem))
                goto fail;

            new_elem = NULL;
            continue;
        }

        if (*p == '/') {
            /* Closing tag */
            p++;

            /* find end of tag name */
            end = strpbrk(p, WHITE_SPACE_CHARS ">");
            if (!end) {
                parse_error (svg_render, svg_document, p, "Could not find '>'");
                goto fail;
            }

            name = _cairo_strndup (p, end - p);
            p = end;
            p = skip_space (p);
            if (*p != '>') {
                parse_error (svg_render, svg_document, p, "Could not find '>'");
                free (name);
                goto fail;
            }

            p++;
            if (nesting == 0) {
                parse_error (svg_render, svg_document, p, "parse_elements: parsed </%s> but no matching start tag", name);
                free (name);
                goto fail;
            }
            if (!string_equal (name, open_elem->tag)) {
                parse_error (svg_render, svg_document, p,
                             "parse_elements: found </%s> but current open tag is <%s>",
                             name, open_elem->tag);
                free (name);
                goto fail;
            }

            /* pop top element on open elements stack into new_elem */
            new_elem = open_elem;
            open_elem = open_elem->next;
            new_elem->next = NULL;
            nesting--;

            free (name);
            if (!add_child_element (svg_render, open_elem, new_elem))
                goto fail;

            new_elem = NULL;
            continue;
        }

        /* We should now be in a start or empty element tag */

        /* find end of tag name */
        end = strpbrk(p, WHITE_SPACE_CHARS "/>");
        if (!end) {
            parse_error (svg_render, svg_document, p, "Could not find '>'");
            goto fail;
        }

        name = _cairo_strndup (p, end - p);
        p = end;

        new_elem = create_element (CONTAINER_ELEMENT, name);
        p = parse_attributes (svg_render, p, new_elem);
        if (!p)
            goto fail;

        p = skip_space (p);
        if (*p == '/') {
            new_elem->type = EMPTY_ELEMENT;
            p++;
        }

        if (!p || *p != '>') {
            print_error (svg_render, "Could not find '>'");
            goto fail;
        }

        p++;
        if (new_elem->type == EMPTY_ELEMENT) {
            if (!add_child_element (svg_render, open_elem, new_elem))
                goto fail;

            new_elem = NULL;
        } else {
            /* push new elem onto open elements stack */
            new_elem->next = open_elem;
            open_elem = new_elem;
            new_elem = NULL;
            nesting++;
        }
    }

    if (nesting != 0) {
        parse_error (svg_render, svg_document, p, "Missing closing tag for <%s>", open_elem->tag);
        goto fail;
    }

    svg_render->tree = open_elem;
    return TRUE;

  fail:
    if (new_elem)
        free_elements (svg_render, new_elem);

    while (open_elem) {
        cairo_svg_element_t *elem = open_elem;
        open_elem = open_elem->next;
        free_elements (svg_render, elem);
    }

    return FALSE;
}

static cairo_bool_t
parse_transform (const char *p, cairo_matrix_t *matrix)
{
    cairo_matrix_t m;
    double x, y, a;
    cairo_bool_t have_optional;

    cairo_matrix_init_identity (matrix);
    while (p) {
        while (p && (*p == ',' || _cairo_isspace (*p)))
            p++;

        if (!p || *p == 0)
            break;

        if (string_match (&p, "matrix")) {
            p = skip_char (p, '(');
            if (!p)
                break;

            p = get_floats (p, 6, 0, NULL, &m.xx, &m.yx, &m.xy, &m.yy, &m.x0, &m.y0);
            if (!p)
                break;

            p = skip_char (p, ')');
            if (!p)
                break;

            cairo_matrix_multiply (matrix, &m, matrix);

        } else if (string_match (&p, "translate")) {
            p = skip_char (p, '(');
            if (!p)
                break;

            p = get_floats (p, 1, 1, &have_optional, &x, &y);
            if (!p)
                break;

            p = skip_char (p, ')');
            if (!p)
                break;

            if (!have_optional)
                y = 0;

            cairo_matrix_translate (matrix, x, y);

        } else if (string_match (&p, "scale")) {
            p = skip_char (p, '(');
            if (!p)
                break;

            p = get_floats (p, 1, 1, &have_optional, &x, &y);
            if (!p)
                break;

            p = skip_char (p, ')');
            if (!p)
                break;

            if (!have_optional)
                y = x;

            cairo_matrix_scale (matrix, x, y);

        } else if (string_match (&p, "rotate")) {
            p = skip_char (p, '(');
            if (!p)
                break;

            p = get_floats (p, 1, 2, &have_optional, &a, &x, &y);
            if (!p)
                break;

            p = skip_char (p, ')');
            if (!p)
                break;

            if (!have_optional) {
                x = 0;
                y = 0;
            }

            a *= M_PI/180.0;
            cairo_matrix_translate (matrix, x, y);
            cairo_matrix_rotate (matrix, a);
            cairo_matrix_translate (matrix, -x, -y);

        } else if (string_match (&p, "skewX")) {
            p = skip_char (p, '(');
            if (!p)
                break;

            p = get_floats (p, 1, 0, NULL, &a);
            if (!p)
                break;

            p = skip_char (p, ')');
            if (!p)
                break;

            a *= M_PI/180.0;
            cairo_matrix_init_identity (&m);
            m.xy = tan (a);
            cairo_matrix_multiply (matrix, &m, matrix);

        } else if (string_match (&p, "skewY")) {
            p = skip_char (p, '(');
            if (!p)
                break;

            p = get_floats (p, 1, 0, NULL, &a);
            if (!p)
                break;

            p = skip_char (p, ')');
            if (!p)
                break;

            a *= M_PI/180.0;
            cairo_matrix_init_identity (&m);
            m.yx = tan (a);
            cairo_matrix_multiply (matrix, &m, matrix);

        } else {
            break;
        }
    }
    return p != NULL;
}

static void
render_element_tree (cairo_svg_glyph_render_t *svg_render,
                     cairo_svg_element_t      *element,
                     cairo_svg_element_t      *display_element,
                     cairo_bool_t              children_only);

static cairo_pattern_t *
create_pattern (cairo_svg_glyph_render_t *svg_render,
                cairo_svg_element_t      *paint_server)
{
    cairo_pattern_t *pattern = NULL;

    if (paint_server) {
        svg_render->build_pattern.paint_server = paint_server;
        render_element_tree (svg_render, paint_server, NULL, FALSE);
        pattern = svg_render->build_pattern.pattern;
        svg_render->build_pattern.pattern = NULL;
        svg_render->build_pattern.paint_server = NULL;
        svg_render->build_pattern.type = BUILD_PATTERN_NONE;
    }

    if (!pattern)
        pattern = cairo_pattern_create_rgb (0, 0, 0);

    return pattern;
}

static cairo_bool_t
render_element_svg (cairo_svg_glyph_render_t *svg_render,
                    cairo_svg_element_t      *element,
                    cairo_bool_t              end_tag)
{
    double width, height;
    double vb_x, vb_y, vb_height, vb_width;
    const char *p;
    const char *end;

    if (end_tag)
        return FALSE;

    /* Default viewport width, height is EM square */
    if (!get_float_or_percent_attribute (element, "width", svg_render->units_per_em, &width))
        width = svg_render->units_per_em;

    if (!get_float_or_percent_attribute (element, "height", svg_render->units_per_em, &height))
        height = svg_render->units_per_em;

    /* Transform viewport to unit square, centering it if width != height. */
    if (width > height) {
        cairo_scale (svg_render->cr, 1.0/width, 1.0/width);
        cairo_translate (svg_render->cr, 0, (width - height)/2.0);
    } else {
        cairo_scale (svg_render->cr, 1.0/height, 1.0/height);
        cairo_translate (svg_render->cr, (height - width)/2.0, 0);
    }

    svg_render->width = width;
    svg_render->height = height;

    p = get_attribute (element, "viewBox");
    if (p) {
        /* Transform viewport to viewbox */
        end = get_path_params (p, 4, &vb_x, &vb_y, &vb_width, &vb_height);
        if (!end) {
            print_warning (svg_render, "viewBox expected 4 numbers: %s", p);
            return FALSE;
        }
        cairo_translate (svg_render->cr, -vb_x * width/vb_width, -vb_y * width/vb_width);
        cairo_scale (svg_render->cr, width/vb_width, height/vb_height);
        svg_render->width = vb_width;
        svg_render->height = vb_height;
    }

    svg_render->view_port_set = TRUE;
    return TRUE;
}

static cairo_bool_t
render_element_clip_path (cairo_svg_glyph_render_t *svg_render,
                          cairo_svg_element_t      *element,
                          cairo_bool_t              end_tag)
{
    cairo_svg_graphics_state_t *gs = svg_render->graphics_state;
    const char *p;

    if (end_tag || gs->mode != GS_CLIP || svg_render->build_pattern.type != BUILD_PATTERN_NONE) {
        return FALSE;
    }

    p = get_attribute (element, "clipPathUnits");
    if (string_equal (p, "objectBoundingBox")) {
        cairo_translate (svg_render->cr,
                                svg_render->graphics_state->bbox.x,
                                svg_render->graphics_state->bbox.y);
        cairo_scale (svg_render->cr,
                     svg_render->graphics_state->bbox.width,
                     svg_render->graphics_state->bbox.height);
    }

    return TRUE;
}

static void
apply_gradient_attributes (cairo_svg_glyph_render_t *svg_render,
                           cairo_svg_element_t      *element)
{
    cairo_pattern_t *pattern = svg_render->build_pattern.pattern;
    cairo_bool_t object_bbox = TRUE;
    cairo_matrix_t transform;
    cairo_matrix_t mat;
    const char *p;

    if (!pattern)
        return;

    p = get_attribute (element, "gradientUnits");
    if (string_equal (p, "userSpaceOnUse"))
        object_bbox = FALSE;

    cairo_matrix_init_identity (&mat);
    if (object_bbox) {
        cairo_matrix_translate (&mat,
                                svg_render->graphics_state->bbox.x,
                                svg_render->graphics_state->bbox.y);
        cairo_matrix_scale (&mat,
                            svg_render->graphics_state->bbox.width,
                            svg_render->graphics_state->bbox.height);
    }

    p = get_attribute (element, "gradientTransform");
     if (parse_transform (p, &transform))
         cairo_matrix_multiply (&mat, &transform, &mat);

    if (cairo_matrix_invert (&mat) == CAIRO_STATUS_SUCCESS)
        cairo_pattern_set_matrix (pattern, &mat);

    p = get_attribute (element, "spreadMethod");
    if (string_equal (p, "reflect"))
        cairo_pattern_set_extend (pattern, CAIRO_EXTEND_REFLECT);
    else if (string_equal (p, "repeat"))
        cairo_pattern_set_extend (pattern, CAIRO_EXTEND_REPEAT);
}

static cairo_bool_t
render_element_linear_gradient (cairo_svg_glyph_render_t *svg_render,
                                cairo_svg_element_t      *element,
                                cairo_bool_t              end_tag)
{
    double x1, y1, x2, y2;

    if (svg_render->build_pattern.paint_server != element ||
        end_tag ||
        svg_render->build_pattern.type != BUILD_PATTERN_NONE)
        return FALSE;

    /* FIXME default value for userSpaceOnUse? */
    double width = 1.0;
    double height = 1.0;

    if (!get_float_or_percent_attribute (element, "x1", width, &x1))
        x1 = 0.0;

    if (!get_float_or_percent_attribute (element, "y1", height, &y1))
        y1 = 0.0;

    if (!get_float_or_percent_attribute (element, "x2", width, &x2))
        x2 = width;

    if (!get_float_or_percent_attribute (element, "y2", height, &y2))
        y2 = 0.0;

    if (svg_render->build_pattern.pattern)
        abort();

    svg_render->build_pattern.pattern = cairo_pattern_create_linear (x1, y1, x2, y2);
    svg_render->build_pattern.type = BUILD_PATTERN_LINEAR;
    apply_gradient_attributes (svg_render, element);
    return TRUE;
}

static cairo_bool_t
render_element_radial_gradient (cairo_svg_glyph_render_t *svg_render,
                                cairo_svg_element_t      *element,
                                cairo_bool_t              end_tag)
{
    double cx, cy, r, fx, fy;

    if (svg_render->build_pattern.paint_server != element ||
        end_tag ||
        svg_render->build_pattern.type != BUILD_PATTERN_NONE)
        return FALSE;

    /* FIXME default value for userSpaceOnUse? */
    double width = 1.0;
    double height = 1.0;

    if (!get_float_or_percent_attribute (element, "cx", width, &cx))
        cx = 0.5 * width;

    if (!get_float_or_percent_attribute (element, "cy", height, &cy))
        cy = 0.5 * height;

    if (!get_float_or_percent_attribute (element, "r", width, &r))
        r = 0.5 * width;

    if (!get_float_or_percent_attribute (element, "fx", width, &fx))
        fx = cx;

    if (!get_float_or_percent_attribute (element, "fy", height, &fy))
        fy = cy;

    svg_render->build_pattern.pattern = cairo_pattern_create_radial (fx, fy, 0, cx, cy, r);
    svg_render->build_pattern.type = BUILD_PATTERN_RADIAL;
    apply_gradient_attributes (svg_render, element);
    return TRUE;
}

static cairo_bool_t
render_element_stop (cairo_svg_glyph_render_t *svg_render,
                     cairo_svg_element_t      *element,
                     cairo_bool_t              end_tag)
{
    double offset, opacity;
    cairo_pattern_t *pattern = svg_render->build_pattern.pattern;

    if (!pattern)
        return FALSE;

    if (cairo_pattern_get_type (pattern) != CAIRO_PATTERN_TYPE_LINEAR &&
        cairo_pattern_get_type (pattern) != CAIRO_PATTERN_TYPE_RADIAL)
        return FALSE;

    if (!get_float_or_percent_attribute (element, "offset", 1.0, &offset))
        return FALSE;

    if (!get_float_attribute (element, "stop-opacity", &opacity))
        opacity = 1.0;

    cairo_svg_color_t color;
    get_color (svg_render, "black", &color);
    get_color (svg_render, get_attribute(element, "stop-color"), &color);
    if (color.type == RGB) {
        cairo_pattern_add_color_stop_rgba (pattern,
                                           offset,
                                           color.red,
                                           color.green,
                                           color.blue,
                                           opacity);
    } else { /* color.type == FOREGROUND */
        double red, green, blue, alpha;
        if (cairo_pattern_get_rgba (svg_render->foreground_source, &red, &green, &blue, &alpha) == CAIRO_STATUS_SUCCESS) {
      svg_render->foreground_source_used = TRUE;
  } else {
            red = green = blue = 0;
            alpha = 1;
        }
        cairo_pattern_add_color_stop_rgba (pattern, offset, red, green, blue, alpha);
    }
    return TRUE;
}

static cairo_bool_t
render_element_g (cairo_svg_glyph_render_t *svg_render,
                  cairo_svg_element_t      *element,
                  cairo_bool_t              end_tag)
{
    if (svg_render->graphics_state->mode == GS_NO_RENDER ||
        svg_render->build_pattern.type != BUILD_PATTERN_NONE)
        return FALSE;

    if (!end_tag) {
        cairo_push_group (svg_render->cr);
    } else {
        cairo_pop_group_to_source (svg_render->cr);
        cairo_paint_with_alpha (svg_render->cr, svg_render->graphics_state->opacity);
    }
    return TRUE;
}

typedef struct {
    const char *data; /* current position in base64 data */
    char buf[3]; /* decode buffer */
    int buf_pos; /* current position in buf_pos. */
} base64_decode_t;

static cairo_status_t
_read_png_from_base64 (void *closure, unsigned char *data, unsigned int length)
{
    base64_decode_t *decode = closure;
    int n, c;
    unsigned val;

    while (length) {
        if (decode->buf_pos >= 0) {
            *data++ = decode->buf[decode->buf_pos++];
            length--;
            if (decode->buf_pos == 3)
                decode->buf_pos = -1;
        }
        if (length > 0 && decode->buf_pos < 0) {
            n = 0;
            val = 0;
            while (*decode->data && n < 4) {
                c = *decode->data++;
                if (c >='A' && c <='Z') {
                    val = (val << 6) | (c -'A');
                    n++;
                } else if (c >='a' && c <='z') {
                    val = (val << 6) | (c -'a' + 26);
                    n++;
                } else if (c >='0' && c <='9') {
                    val = (val << 6) | (c -'0' + 52);
                    n++;
                } else if (c =='+') {
                    val = (val << 6) | 62;
                    n++;
                } else if (c =='/') {
                    val = (val << 6) | 63;
                    n++;
                } else if (c == '=') {
                    val = (val << 6);
                    n++;
                }
            }
            if (n < 4)
                return CAIRO_STATUS_READ_ERROR;

            decode->buf[0] = val >> 16;
            decode->buf[1] = val >> 8;
            decode->buf[2] = val >> 0;
            decode->buf_pos = 0;
        }
    }

    return CAIRO_STATUS_SUCCESS;
}

static cairo_bool_t
render_element_image (cairo_svg_glyph_render_t *svg_render,
                      cairo_svg_element_t      *element,
                      cairo_bool_t              end_tag)
{
    double x, y, width, height;
    int w, h;
    const char *data;
    cairo_surface_t *surface;
    base64_decode_t decode;

    if (svg_render->graphics_state->mode == GS_NO_RENDER ||
        svg_render->build_pattern.type != BUILD_PATTERN_NONE)
        return FALSE;

    if (!get_float_attribute (element, "x", &x))
        x = 0;

    if (!get_float_attribute (element, "y", &y))
        y = 0;

    if (!get_float_attribute (element, "width", &width))
        return FALSE;

    if (!get_float_attribute (element, "height", &height))
        return FALSE;

    data = get_href_attribute (element);
    if (!data)
        return FALSE;

    if (!string_match (&data, "data:image/png;base64,"))
        return FALSE;

    decode.data = data;
    decode.buf_pos = -1;
    surface = cairo_image_surface_create_from_png_stream (_read_png_from_base64, &decode);
    if (cairo_surface_status (surface)) {
        print_warning (svg_render, "Unable to decode PNG");
        cairo_surface_destroy (surface);
        return FALSE;
    }

    w = cairo_image_surface_get_width (surface);
    h = cairo_image_surface_get_height (surface);

    if (w > 0 && h > 0) {
        cairo_translate (svg_render->cr, x, y);
        cairo_scale (svg_render->cr, width/w, height/h);
        cairo_set_source_surface (svg_render->cr, surface, 0, 0);
        cairo_paint (svg_render->cr);
    }

    cairo_surface_destroy (surface);

    return FALSE;
}

static cairo_bool_t
render_element_use (cairo_svg_glyph_render_t *svg_render,
                    cairo_svg_element_t      *element,
                    cairo_bool_t              end_tag)
{
    double x = 0;
    double y = 0;
    const char *id;

    if (end_tag || svg_render->graphics_state->mode == GS_NO_RENDER ||
        svg_render->build_pattern.type != BUILD_PATTERN_NONE)
        return FALSE;

    get_float_attribute (element, "x", &x);
    get_float_attribute (element, "y", &y);

    id = get_href_attribute (element);
    if (!id)
        return FALSE;

    cairo_svg_element_t *use_element = lookup_element (svg_render, id);
    cairo_translate (svg_render->cr, x, y);
    render_element_tree (svg_render, use_element, NULL, FALSE);
    return TRUE;
}

static cairo_bool_t
draw_path (cairo_svg_glyph_render_t *svg_render)
{
    cairo_svg_graphics_state_t *gs = svg_render->graphics_state;
    cairo_pattern_t *pattern;
    cairo_bool_t opacity_group = FALSE;

    if (gs->mode == GS_COMPUTE_BBOX) {
        cairo_set_source_rgb (svg_render->cr, 0, 0, 0);
        cairo_set_fill_rule (svg_render->cr, gs->fill_rule);
        cairo_fill (svg_render->cr);
        return FALSE;
    } else if (gs->mode == GS_CLIP) {
        return FALSE;
    }

    if (gs->opacity < 1.0) {
        cairo_push_group (svg_render->cr);
        opacity_group = TRUE;
    }

    cairo_path_t *path = cairo_copy_path (svg_render->cr);
    cairo_new_path (svg_render->cr);

    if (gs->fill.type != PAINT_NONE) {
        cairo_bool_t group = FALSE;
        if (gs->fill.type == PAINT_COLOR) {
            if (gs->fill.color.type == RGB) {
                cairo_set_source_rgba (svg_render->cr,
                                       gs->fill.color.red,
                                       gs->fill.color.green,
                                       gs->fill.color.blue,
                                       gs->fill_opacity);
            } else if (gs->fill.color.type == FOREGROUND) {
    cairo_set_source (svg_render->cr, svg_render->foreground_marker);
    if (gs->fill_opacity < 1.0)
        group = TRUE;
            }
        } else if (gs->fill.type == PAINT_SERVER) {
            pattern = create_pattern (svg_render, gs->fill.paint_server);
            cairo_set_source (svg_render->cr, pattern);
            cairo_pattern_destroy (pattern);
            if (gs->fill_opacity < 1.0)
                group = TRUE;
        }

        if (group)
            cairo_push_group (svg_render->cr);

        cairo_append_path (svg_render->cr, path);
        cairo_set_fill_rule (svg_render->cr, gs->fill_rule);
        cairo_fill (svg_render->cr);
        if (group) {
            cairo_pop_group_to_source (svg_render->cr);
            cairo_paint_with_alpha (svg_render->cr, gs->fill_opacity);
        }
    }

    if (gs->stroke.type != PAINT_NONE) {
        cairo_bool_t group = FALSE;
        if (gs->stroke.type == PAINT_COLOR) {
            if (gs->stroke.color.type == RGB) {
                cairo_set_source_rgba (svg_render->cr,
                                       gs->stroke.color.red,
                                       gs->stroke.color.green,
                                       gs->stroke.color.blue,
                                       gs->stroke_opacity);
            } else if (gs->fill.color.type == FOREGROUND) {
    cairo_set_source (svg_render->cr, svg_render->foreground_marker);
    if (gs->fill_opacity < 1.0)
        group = TRUE;
            }
        } else if (gs->stroke.type == PAINT_SERVER) {
            pattern = create_pattern (svg_render, gs->stroke.paint_server);
            cairo_set_source (svg_render->cr, pattern);
            cairo_pattern_destroy (pattern);
            if (gs->stroke_opacity < 1.0)
                group = TRUE;
        }

        if (group)
            cairo_push_group (svg_render->cr);

        cairo_append_path (svg_render->cr, path);
        cairo_stroke (svg_render->cr);

        if (group) {
            cairo_pop_group_to_source (svg_render->cr);
            cairo_paint_with_alpha (svg_render->cr, gs->stroke_opacity);
        }
    }

    cairo_path_destroy (path);

    if (opacity_group) {
        cairo_pop_group_to_source (svg_render->cr);
        cairo_paint_with_alpha (svg_render->cr, gs->opacity);
    }
    return TRUE;
}

static void
elliptical_arc (cairo_svg_glyph_render_t *svg_render,
                double                    cx,
                double                    cy,
                double                    rx,
                double                    ry,
                double                    angle1,
                double                    angle2)
{
    cairo_save (svg_render->cr);
    cairo_translate (svg_render->cr, cx, cy);
    cairo_scale (svg_render->cr, rx, ry);
    cairo_arc (svg_render->cr, 0, 0, 1, angle1, angle2);
    cairo_restore (svg_render->cr);
}

static cairo_bool_t
render_element_rect (cairo_svg_glyph_render_t *svg_render,
                     cairo_svg_element_t      *element,
                     cairo_bool_t              end_tag)
{
    double x = 0;
    double y = 0;
    double width = svg_render->width;
    double height = svg_render->height;
    double rx = 0;
    double ry = 0;

    if (end_tag ||
        svg_render->graphics_state->mode == GS_NO_RENDER ||
        svg_render->build_pattern.type != BUILD_PATTERN_NONE)
        return FALSE;

    get_float_or_percent_attribute (element, "x", svg_render->width, &x);
    get_float_or_percent_attribute (element, "y", svg_render->height, &y);
    get_float_or_percent_attribute (element, "width", svg_render->width, &width);
    get_float_or_percent_attribute (element, "height", svg_render->height, &height);
    get_float_or_percent_attribute (element, "rx", svg_render->width, &rx);
    get_float_or_percent_attribute (element, "ry", svg_render->height, &ry);

    if (rx == 0 && ry == 0) {
        cairo_rectangle (svg_render->cr, x, y, width, height);
    } else {
        cairo_move_to (svg_render->cr, x + rx, y);
        cairo_line_to (svg_render->cr, x + width - rx, y);
        elliptical_arc (svg_render,    x + width - rx, y + ry, rx, ry, -M_PI/2, 0);
        cairo_line_to (svg_render->cr, x + width, y + height - ry);
        elliptical_arc (svg_render,    x + width - rx, y + height - ry, rx, ry, 0, M_PI/2);
        cairo_line_to (svg_render->cr, x + rx, y + height);
        elliptical_arc (svg_render,    x + rx, y + height - ry, rx, ry, M_PI/2, M_PI);
        cairo_line_to (svg_render->cr, x, y + ry);
        elliptical_arc (svg_render,    x + rx, y + ry, rx, ry, M_PI, -M_PI/2);
    }

    draw_path (svg_render);
    return TRUE;
}

static cairo_bool_t
render_element_circle (cairo_svg_glyph_render_t *svg_render,
                       cairo_svg_element_t      *element,
                       cairo_bool_t              end_tag)
{
    double cx = 0;
    double cy = 0;
    double r = 0;

    if (end_tag ||
        svg_render->graphics_state->mode == GS_NO_RENDER ||
        svg_render->build_pattern.type != BUILD_PATTERN_NONE)
        return FALSE;

    get_float_or_percent_attribute (element, "cx", svg_render->width, &cx);
    get_float_or_percent_attribute (element, "cy", svg_render->height, &cy);
    get_float_or_percent_attribute (element, "r", svg_render->width, &r);

    cairo_arc (svg_render->cr, cx, cy, r, 0, 2*M_PI);

    draw_path (svg_render);
    return TRUE;
}

static cairo_bool_t
render_element_ellipse (cairo_svg_glyph_render_t *svg_render,
                        cairo_svg_element_t      *element,
                        cairo_bool_t              end_tag)
{
    double cx = 0;
    double cy = 0;
    double rx = 0;
    double ry = 0;

    if (end_tag ||
        svg_render->graphics_state->mode == GS_NO_RENDER ||
        svg_render->build_pattern.type != BUILD_PATTERN_NONE)
        return FALSE;

    get_float_or_percent_attribute (element, "cx", svg_render->width, &cx);
    get_float_or_percent_attribute (element, "cy", svg_render->height, &cy);
    get_float_or_percent_attribute (element, "rx", svg_render->width, &rx);
    get_float_or_percent_attribute (element, "ry", svg_render->height, &ry);

    elliptical_arc (svg_render, cx, cy, rx, ry, 0, 2*M_PI);
    draw_path (svg_render);
    return TRUE;
}

static cairo_bool_t
render_element_line (cairo_svg_glyph_render_t *svg_render,
                     cairo_svg_element_t      *element,
                     cairo_bool_t              end_tag)
{
    double x1 = 0;
    double y1 = 0;
    double x2 = 0;
    double y2 = 0;

    if (end_tag ||
        svg_render->graphics_state->mode == GS_NO_RENDER ||
        svg_render->build_pattern.type != BUILD_PATTERN_NONE)
        return FALSE;

    get_float_or_percent_attribute (element, "x1", svg_render->width, &x1);
    get_float_or_percent_attribute (element, "y1", svg_render->height, &y1);
    get_float_or_percent_attribute (element, "x2", svg_render->width, &x2);
    get_float_or_percent_attribute (element, "y2", svg_render->height, &y2);

    cairo_move_to (svg_render->cr, x1, y1);
    cairo_line_to (svg_render->cr, x2, y2);

    draw_path (svg_render);
    return TRUE;
}

static cairo_bool_t
render_element_polyline (cairo_svg_glyph_render_t *svg_render,
                         cairo_svg_element_t      *element,
                         cairo_bool_t              end_tag)
{
    const char *p;
    const char *end;
    double x, y;
    cairo_bool_t have_move = FALSE;

    if (end_tag ||
        svg_render->graphics_state->mode == GS_NO_RENDER ||
        svg_render->build_pattern.type != BUILD_PATTERN_NONE)
        return FALSE;

    p = get_attribute (element, "points");
    do {
        end = get_path_params (p, 2, &x, &y);
        if (!end) {
            print_warning (svg_render, "points expected 2 numbers: %s", p);
            break;
        }
        p = end;
        if (!have_move) {
            cairo_move_to (svg_render->cr, x, y);
            have_move = TRUE;
        } else {
            cairo_line_to (svg_render->cr, x, y);
        }
        p = skip_space (p);
    } while (p && *p);

    if (string_equal (element->tag, "polygon"))
        cairo_close_path (svg_render->cr);

    draw_path (svg_render);
    return TRUE;
}

static double
angle_between_vectors (double ux,
                       double uy,
                       double vx,
                       double vy)
{
    double dot = ux*vx + uy*vy;
    double umag = sqrt (ux*ux + uy*uy);
    double vmag = sqrt (vx*vx + vy*vy);
    double c = dot/(umag*vmag);
    if (c > 1.0)
        c = 1.0;

    if (c < -1.0)
        c = -1.0;

    double a = acos (c);
    if (ux * vy - uy * vx < 0.0)
        a = -a;

    return a;
}

static void
arc_path (cairo_t *cr,
          double x1, double y1,
          double x2, double y2,
          double rx, double ry,
          double rotate,
          cairo_bool_t large_flag,
          cairo_bool_t sweep_flag)
{
    double x1_, y1_, cx_, cy_;
    double xm, ym, cx, cy;
    double a, b, d;
    double ux, uy, vx, vy;
    double theta, delta_theta;
    double epsilon;
    cairo_matrix_t ctm;

    cairo_get_matrix (cr, &ctm);
    epsilon = _cairo_matrix_transformed_circle_major_axis (&ctm, cairo_get_tolerance (cr));

    rotate *= M_PI/180.0;

    /* Convert endpoint to center parameterization.
     * See SVG 1.1 Appendix F.6. Step numbers are the steps in the appendix.
     */

    rx = fabs (rx);
    ry = fabs (ry);
    if (rx < epsilon || ry < epsilon) {
        cairo_line_to (cr, x2, y2);
        return;
    }

    if (fabs(x1 - x2) < epsilon && fabs(y1 - y2) < epsilon) {
        cairo_line_to (cr, x2, y2);
        return;
    }

    /* Step 1 */
    xm = (x1 - x2)/2;
    ym = (y1 - y2)/2;
    x1_ = xm * cos (rotate) + ym * sin (rotate);
    y1_ = xm * -sin (rotate) + ym * cos (rotate);

    d = (x1_*x1_)/(rx*rx) + (y1_*y1_)/(ry*ry);
    if (d > 1.0) {
        d = sqrt (d);
        rx *= d;
        ry *= d;
    }

    /* Step 2 */
    a = (rx*rx * y1_*y1_) + (ry*ry * x1_*x1_);
    if (a == 0.0)
        return;

    b = (rx*rx * ry*ry) / a - 1.0;
    if (b < 0)
        b = 0.0;

    d = sqrt(b);
    if (large_flag == sweep_flag)
        d = -d;

    cx_ = d * rx*y1_/ry;
    cy_ = d * -ry*x1_/rx;

    /* Step 3 */
    cx = cx_ * cos (rotate) - cy_ * sin (rotate) + (x1 + x2)/2;
    cy = cx_ * sin (rotate) + cy_ * cos (rotate) + (y1 + y2)/2;

    /* Step 4 */
    ux = (x1_ - cx_)/rx;
    uy = (y1_ - cy_)/ry;
    vx = (-x1_ - cx_)/rx;
    vy = (-y1_ - cy_)/ry;
    theta = angle_between_vectors (1.0, 0, ux, uy);
    delta_theta = angle_between_vectors (ux, uy, vx, vy);

    if (!sweep_flag && delta_theta > 0)
        delta_theta -= 2 * M_PI;
    else if (sweep_flag && delta_theta < 0)
        delta_theta += 2 * M_PI;

    /* Now we can call cairo_arc() */
    cairo_save (cr);
    cairo_translate (cr, cx, cy);
    cairo_scale (cr, rx, ry);
    cairo_rotate (cr, theta);
    if (delta_theta >= 0.0)
        cairo_arc (cr, 0, 0, 1, 0, delta_theta);
    else
        cairo_arc_negative (cr, 0, 0, 1, 0, delta_theta);
    cairo_restore (cr);
}

static void
get_current_point (cairo_svg_glyph_render_t *svg_render, double *x, double *y)
{
    if (cairo_has_current_point (svg_render->cr)) {
        cairo_get_current_point (svg_render->cr, x, y);
    } else {
        *x = 0;
        *y = 0;
    }
}

static void
reflect_point (double origin_x, double origin_y, double *x, double *y)
{
    *x = 2*origin_x - *x;
    *y = 2*origin_y - *y;
}

static cairo_bool_t
render_element_path (cairo_svg_glyph_render_t *svg_render,
                     cairo_svg_element_t      *element,
                     cairo_bool_t              end_tag)
{
    double cur_x, cur_y;
    double last_cp_x, last_cp_y;
    double x, y, x1, y1, x2, y2;
    double qx1, qy1, qx2, qy2;
    double rx, ry, rotate, large_flag, sweep_flag;
    cairo_bool_t rel, have_move;
    enum { CUBIC, QUADRATIC, OTHER } last_op;

    if (end_tag ||
        svg_render->graphics_state->mode == GS_NO_RENDER ||
        svg_render->build_pattern.type != BUILD_PATTERN_NONE)
        return FALSE;

    last_op = OTHER;
    const char *p = get_attribute (element, "d");
    const char *end;
    int op;

    while (p) {
        while (p && _cairo_isspace (*p))
            p++;

        if (!p || *p == 0)
            break;

        op = *p;
        switch (op) {
            case 'M':
            case 'm':
                rel = op == 'm';
                p++;
                have_move = FALSE;
                do {
                    end = get_path_params (p, 2, &x, &y);
                    if (!end) {
                        print_warning (svg_render, "path %c expected 2 numbers: %s", op, p);
                        break;
                    }
                    p = end;
                    if (rel) {
                        get_current_point (svg_render, &cur_x, &cur_y);
                        x += cur_x;
                        y += cur_y;
                    }
                    if (!have_move) {
                        cairo_move_to (svg_render->cr, x, y);
                        have_move = TRUE;
                    } else {
                        cairo_line_to (svg_render->cr, x, y);
                    }
                    p = skip_space (p);
                } while (p && *p && !_cairo_isalpha(*p));
                last_op = OTHER;
                break;
            case 'Z':
            case 'z':
                p++;
                cairo_close_path (svg_render->cr);
                last_op = OTHER;
                break;
            case 'L':
            case 'l':
                rel = op == 'l';
                p++;
                do {
                    end = get_path_params (p, 2, &x, &y);
                    if (!end) {
                        print_warning (svg_render, "path %c expected 2 numbers: %s", op, p);
                        break;
                    }
                    p = end;
                    if (rel) {
                        get_current_point (svg_render, &cur_x, &cur_y);
                        x += cur_x;
                        y += cur_y;
                    }
                    cairo_line_to (svg_render->cr, x, y);
                    p = skip_space (p);
                } while (p && *p && !_cairo_isalpha(*p));
                last_op = OTHER;
                break;
            case 'H':
            case 'h':
                rel = op == 'h';
                p++;
                do {
                    end = get_path_params (p, 1, &x1);
                    if (!end) {
                        print_warning (svg_render, "path %c expected a number: %s", op, p);
                        break;
                    }
                    p = end;
                    get_current_point (svg_render, &cur_x, &cur_y);
                    if (rel) {
                        x1 += cur_x;
                    }
                    cairo_line_to (svg_render->cr, x1, cur_y);
                    p = skip_space (p);
                } while (p && *p && !_cairo_isalpha(*p));
                last_op = OTHER;
                break;
            case 'V':
            case 'v':
                rel = op == 'v';
                p++;
                do {
                    end = get_path_params (p, 1, &y1);
                    if (!end) {
                        print_warning (svg_render, "path %c expected a number: %s", op, p);
                        break;
                    }
                    p = end;
                    get_current_point (svg_render, &cur_x, &cur_y);
                    if (rel) {
                        y1 += cur_y;
                    }
                    cairo_line_to (svg_render->cr, cur_x, y1);
                    p = skip_space (p);
                } while (p && *p && !_cairo_isalpha(*p));
                last_op = OTHER;
                break;
            case 'C':
            case 'c':
                rel = op == 'c';
                p++;
                do {
                    end = get_path_params (p, 6, &x1, &y1, &x2, &y2, &x, &y);
                    if (!end) {
                        print_warning (svg_render, "path %c expected 6 numbers: %s", op, p);
                        break;
                    }
                    p = end;
                    if (rel) {
                        get_current_point (svg_render, &cur_x, &cur_y);
                        x1 += cur_x;
                        y1 += cur_y;
                        x2 += cur_x;
                        y2 += cur_y;
                        x += cur_x;
                        y += cur_y;
                    }
                    cairo_curve_to (svg_render->cr, x1, y1, x2, y2, x, y);
                    p = skip_space (p);
                } while (p && *p && !_cairo_isalpha(*p));
                last_op = CUBIC;
                last_cp_x = x2;
                last_cp_y = y2;
                break;
            case 'S':
            case 's':
                rel = op == 's';
                p++;
                do {
                    end = get_path_params (p, 4, &x2, &y2, &x, &y);
                    if (!end) {
                        print_warning (svg_render, "path %c expected 4 numbers: %s", op, p);
                        break;
                    }
                    p = end;
                    get_current_point (svg_render, &cur_x, &cur_y);
                    if (rel) {
                        x2 += cur_x;
                        y2 += cur_y;
                        x += cur_x;
                        y += cur_y;
                    }
                    if (last_op == CUBIC) {
                        x1 = last_cp_x;
                        y1 = last_cp_y;
                        reflect_point (cur_x, cur_y, &x1, &y1);
                    } else {
                        x1 = cur_x;
                        y1 = cur_y;
                    }
                    cairo_curve_to (svg_render->cr, x1, y1, x2, y2, x, y);
                    last_op = CUBIC;
                    last_cp_x = x2;
                    last_cp_y = y2;
                    p = skip_space (p);
                } while (p && *p && !_cairo_isalpha(*p));
                break;
            case 'Q':
            case 'q':
                rel = op == 'q';
                p++;
                do {
                    end = get_path_params (p, 4, &x1, &y1, &x, &y);
                    if (!end) {
                        print_warning (svg_render, "path %c expected 4 numbers: %s", op, p);
                        break;
                    }
                    p = end;
                    get_current_point (svg_render, &cur_x, &cur_y);
                    if (rel) {
                        x1 += cur_x;
                        y1 += cur_y;
                        x += cur_x;
                        y += cur_y;
                    }
                    qx1 = cur_x + (x1 - cur_x)*2/3;
                    qy1 = cur_y + (y1 - cur_y)*2/3;
                    qx2 = x + (x1 - x)*2/3;
                    qy2 = y + (y1 - y)*2/3;
                    cairo_curve_to (svg_render->cr, qx1, qy1, qx2, qy2, x, y);
                    p = skip_space (p);
                } while (p && *p && !_cairo_isalpha(*p));
                last_op = QUADRATIC;
                last_cp_x = x1;
                last_cp_y = y1;
                break;
            case 'T':
            case 't':
                rel = op == 't';
                p++;
                do {
                    end = get_path_params (p, 2, &x, &y);
                    if (!end) {
                        print_warning (svg_render, "path %c expected 2 numbers: %s", op, p);
                        break;
                    }
                    p = end;
                    get_current_point (svg_render, &cur_x, &cur_y);
                    if (rel) {
                        x += cur_x;
                        y += cur_y;
                    }
                    if (last_op == QUADRATIC) {
                        x1 = last_cp_x;
                        y1 = last_cp_y;
                        reflect_point (cur_x, cur_y, &x1, &y1);
                    } else {
                        x1 = cur_x;
                        y1 = cur_y;
                    }
                    qx1 = cur_x + (x1 - cur_x)*2/3;
                    qy1 = cur_y + (y1 - cur_y)*2/3;
                    qx2 = x + (x1 - x)*2/3;
                    qy2 = y + (y1 - y)*2/3;
                    cairo_curve_to (svg_render->cr, qx1, qy1, qx2, qy2, x, y);
                    last_op = QUADRATIC;
                    last_cp_x = x1;
                    last_cp_y = y1;
                    p = skip_space (p);
                } while (p && *p && *p && !_cairo_isalpha(*p));
                break;
            case 'A':
            case 'a':
                rel = op == 'a';
                p++;
                do {
                    end = get_path_params (p, 7, &rx, &ry, &rotate, &large_flag, &sweep_flag, &x, &y);
                    if (!end) {
                        print_warning (svg_render, "path %c expected 7 numbers: %s", op, p);
                        break;
                    }
                    p = end;
                    get_current_point (svg_render, &cur_x, &cur_y);
                    if (rel) {
                        x += cur_x;
                        y += cur_y;
                    }
                    arc_path (svg_render->cr,
                              cur_x, cur_y,
                              x, y,
                              rx, ry,
                              rotate,
                              large_flag > 0.5,
                              sweep_flag > 0.5);
                    p = skip_space (p);
                } while (p && *p && !_cairo_isalpha(*p));
                last_op = OTHER;
                break;
            default:
                p = NULL;
                break;
        }
    }

    draw_path (svg_render);
    return TRUE;
}

static void
init_graphics_state (cairo_svg_glyph_render_t *svg_render)
{
    cairo_svg_graphics_state_t *gs;

    gs = _cairo_calloc (sizeof (cairo_svg_graphics_state_t));
    get_paint (svg_render, "black", &gs->fill);
    get_paint (svg_render, "none", &gs->stroke);
    gs->color.type = FOREGROUND;
    gs->fill_opacity = 1.0;
    gs->stroke_opacity = 1.0;
    gs->opacity = 1.0;
    gs->fill_rule = CAIRO_FILL_RULE_WINDING;
    gs->clip_rule = CAIRO_FILL_RULE_WINDING;
    gs->clip_path = NULL;
    gs->dash_array = NULL;
    gs->dash_offset = 0.0;
    gs->mode = GS_RENDER;
    gs->bbox.x = 0;
    gs->bbox.y = 0;
    gs->bbox.width = 0;
    gs->bbox.height = 0;
    gs->next = NULL;

    svg_render->graphics_state = gs;

    cairo_save (svg_render->cr);
    cairo_set_source_rgb (svg_render->cr, 0, 0, 0);
    cairo_set_line_width (svg_render->cr, 1.0);
    cairo_set_line_cap (svg_render->cr, CAIRO_LINE_CAP_BUTT);
    cairo_set_line_join (svg_render->cr, CAIRO_LINE_JOIN_MITER);
    cairo_set_miter_limit (svg_render->cr, 4.0);
}

#define MAX_DASHES 100
static void update_dash (cairo_svg_glyph_render_t *svg_render,
                         cairo_svg_element_t      *element)
{
    cairo_svg_graphics_state_t *gs = svg_render->graphics_state;
    const char *p;
    char *end;
    double value;
    double dash_array[MAX_DASHES];
    int num_dashes = 0;
    cairo_bool_t not_zero = FALSE;
    
    if (gs->dash_array == NULL || string_equal (gs->dash_array, "none")) {
        cairo_set_dash (svg_render->cr, NULL, 0, 0);
        return;
    }

    p = gs->dash_array;
    while (*p && num_dashes < MAX_DASHES) {
        while (*p && (*p == ',' || _cairo_isspace (*p)))
            p++;

        if (*p == 0)
            break;

        value = _cairo_strtod (p, &end);
        if (end == p)
            break;

        p = end;
        if (*p == '%') {
            value *= svg_render->width / 100.0;
            p++;
        }

        if (value < 0.0)
            return;

        if (value > 0.0)
            not_zero = TRUE;

        dash_array[num_dashes++] = value;
    }

    if (not_zero)
        cairo_set_dash (svg_render->cr, dash_array, num_dashes, gs->dash_offset);
}

static cairo_bool_t
pattern_requires_bbox (cairo_svg_glyph_render_t *svg_render,
                       cairo_svg_element_t      *paint_server)
{
    const char *p;

    if (string_equal (paint_server->tag, "linearGradient") ||
        string_equal (paint_server->tag, "radialGradient"))
    {
        p = get_attribute (paint_server, "gradientUnits");
        if (string_equal (p, "userSpaceOnUse"))
            return FALSE;

        return TRUE;
    }
    return FALSE;
}

static cairo_bool_t
clip_requires_bbox (cairo_svg_glyph_render_t *svg_render,
                    const char               *clip_path)
{
    cairo_svg_element_t *element;
    const char *p;

    if (clip_path && strncmp (clip_path, "url", 3) == 0) {
        element = lookup_url_element (svg_render, clip_path);
        if (element) {
            p = get_attribute (element, "clipPathUnits");
            if (string_equal (p, "objectBoundingBox"))
                return TRUE;
        }
    }
    return FALSE;
}

static cairo_bool_t
need_bbox (cairo_svg_glyph_render_t *svg_render,
           cairo_svg_element_t      *element)
{
    cairo_svg_graphics_state_t *gs = svg_render->graphics_state;
    cairo_bool_t fill_needs_bbox = FALSE;
    cairo_bool_t stroke_needs_bbox = FALSE;
    cairo_bool_t clip_needs_bbox = FALSE;
    
    if (gs->mode != GS_RENDER)
        return FALSE;

    if (gs->fill.type == PAINT_SERVER && pattern_requires_bbox (svg_render, gs->fill.paint_server))
        fill_needs_bbox = TRUE;

    if (gs->stroke.type == PAINT_SERVER && pattern_requires_bbox (svg_render, gs->stroke.paint_server))
        stroke_needs_bbox = TRUE;

    if (clip_requires_bbox (svg_render, get_attribute (element, "clip-path")))
        clip_needs_bbox = TRUE;

    if (string_equal (element->tag, "circle") ||
        string_equal (element->tag, "ellipse") ||
        string_equal (element->tag, "path") ||
        string_equal (element->tag, "polygon") ||
        string_equal (element->tag, "rect"))
    {
        return fill_needs_bbox || stroke_needs_bbox || clip_needs_bbox;
    }

    if (string_equal (element->tag, "line") ||
        string_equal (element->tag, "polyline"))
    {
        return stroke_needs_bbox || clip_needs_bbox;
    }

    if (string_equal (element->tag, "g") ||
        string_equal (element->tag, "image") ||
        string_equal (element->tag, "use"))
    {
        return clip_needs_bbox;
    }
    
    return FALSE;
}

static cairo_bool_t
call_element (cairo_svg_glyph_render_t *svg_render,
              cairo_svg_element_t      *element,
              cairo_bool_t              end_tag);

static void
update_graphics_state (cairo_svg_glyph_render_t *svg_render,
                       cairo_svg_element_t      *element)
{
    double value;
    const char *p;
    cairo_svg_graphics_state_t *gs = svg_render->graphics_state;

    p = get_attribute (element, "transform");
    if (p) {
        cairo_matrix_t m;
        if (parse_transform (p, &m))
            cairo_transform (svg_render->cr, &m);
    }

    /* The transform is all we need for bbox computation. The SVG spec
     * excludes clipping and stroke-width from the bbox. */
    if (gs->mode == GS_COMPUTE_BBOX)
        return;
    
    p = get_attribute (element, "color");
    if (p)
        get_color (svg_render, p, &gs->color);

    if (!get_float_attribute (element, "opacity", &gs->opacity))
        gs->opacity = 1.0;

    p = get_attribute (element, "fill");
    if (p) {
        get_paint (svg_render, p, &gs->fill);
    }

    get_float_attribute (element, "fill-opacity", &gs->fill_opacity);

    gs->fill_rule = get_fill_rule_attribute (element, "fill-rule", gs->fill_rule);

    gs->clip_rule = get_fill_rule_attribute (element, "fill-rule", gs->clip_rule);

    p = get_attribute (element, "stroke");
    if (p)
        get_paint (svg_render, p, &gs->stroke);

    if (get_float_or_percent_attribute (element, "stroke-width", svg_render->width, &value))
        cairo_set_line_width (svg_render->cr, value);

    p = get_attribute (element, "stroke-linecap");
    if (string_equal (p, "butt"))
        cairo_set_line_cap (svg_render->cr, CAIRO_LINE_CAP_BUTT);
    else if (string_equal (p, "round"))
        cairo_set_line_cap (svg_render->cr, CAIRO_LINE_CAP_ROUND);
    else if (string_equal (p, "square"))
        cairo_set_line_cap (svg_render->cr, CAIRO_LINE_CAP_SQUARE);

    p = get_attribute (element, "stroke-linejoin");
    if (string_equal (p, "miter"))
        cairo_set_line_join (svg_render->cr, CAIRO_LINE_JOIN_MITER);
    else if (string_equal (p, "round"))
        cairo_set_line_join (svg_render->cr, CAIRO_LINE_JOIN_ROUND);
    else if (string_equal (p, "bevel"))
        cairo_set_line_join (svg_render->cr, CAIRO_LINE_JOIN_BEVEL);

    if (get_float_attribute (element, "stroke-miterlimit", &value))
        cairo_set_miter_limit (svg_render->cr, value);

    p = get_attribute (element, "stroke-dasharray");
    if (p) {
        free (gs->dash_array);
        gs->dash_array = strdup (p);
    }

    get_float_or_percent_attribute (element, "stroke-dashoffset", svg_render->width, &gs->dash_offset);
    update_dash (svg_render, element);

    /* Some elements may need the bounding box of the element thay are
     * applied to.  As this recursively calls render_element on the
     * same element while we are in render_element and setting up the
     * graphics state, we check gs->mode to avoid re-entering the
     * compute bbox code. The GS_COMPUTE_MODE flag is also used by
     * render functions to ignore patterns and strokes (SVG spec
     * ignores stroke with in bbox calculations) and just use a solid
     * color.
     */
    if (gs->mode == GS_RENDER && need_bbox (svg_render, element)) {
        cairo_surface_t *recording = cairo_recording_surface_create (CAIRO_CONTENT_COLOR_ALPHA, NULL);
        cairo_t *old_cr = svg_render->cr;
        svg_render->cr = cairo_create (recording);
        gs_mode_t old_mode = gs->mode;
        gs->mode = GS_COMPUTE_BBOX;
        /* To avoid recursing back into this function, we call the
         * element directory then use render_element_tree to render
         * the children */
        call_element (svg_render, element, FALSE);
        render_element_tree (svg_render, element, NULL, TRUE);
        if (element->type == CONTAINER_ELEMENT)
            call_element (svg_render, element, TRUE);
        gs->mode = old_mode;
        cairo_destroy (svg_render->cr);
        svg_render->cr = old_cr;
        cairo_recording_surface_ink_extents (recording,
                                             &gs->bbox.x,
                                             &gs->bbox.y,
                                             &gs->bbox.width,
                                             &gs->bbox.height);
        cairo_surface_destroy (recording);
    }

    /* clip-path may require bbox */
    p = get_attribute (element, "clip-path");
    if (p && strncmp (p, "url", 3) == 0) {
        element = lookup_url_element (svg_render, p);
        if (element) {
            gs_mode_t old_mode = gs->mode;
            gs->mode = GS_CLIP;
            render_element_tree (svg_render, element, NULL, FALSE);
            cairo_set_fill_rule (svg_render->cr, gs->clip_rule);
            cairo_clip (svg_render->cr);
            gs->mode = old_mode;
        }
    }
}

static void
save_graphics_state (cairo_svg_glyph_render_t *svg_render)
{
    cairo_svg_graphics_state_t *gs;

    cairo_save (svg_render->cr);

    gs = _cairo_calloc (sizeof (cairo_svg_graphics_state_t));
    gs->fill           = svg_render->graphics_state->fill;
    gs->stroke         = svg_render->graphics_state->stroke;
    gs->color          = svg_render->graphics_state->color;
    gs->fill_opacity   = svg_render->graphics_state->fill_opacity;
    gs->stroke_opacity = svg_render->graphics_state->stroke_opacity;
    gs->opacity        = svg_render->graphics_state->opacity;
    gs->fill_rule      = svg_render->graphics_state->fill_rule;
    gs->clip_rule      = svg_render->graphics_state->clip_rule;
    gs->clip_path      = NULL;
    gs->dash_array     = NULL;
    if (svg_render->graphics_state->dash_array)
        gs->dash_array = strdup (svg_render->graphics_state->dash_array);
    gs->dash_offset    = svg_render->graphics_state->dash_offset;
    gs->mode           = svg_render->graphics_state->mode;
    gs->bbox           = svg_render->graphics_state->bbox;
    gs->next           = svg_render->graphics_state;
    svg_render->graphics_state = gs;
}

static void
restore_graphics_state (cairo_svg_glyph_render_t *svg_render)
{
    cairo_svg_graphics_state_t *gs;

    gs = svg_render->graphics_state;
    svg_render->graphics_state = gs->next;
    if (gs->clip_path)
        cairo_path_destroy (gs->clip_path);
    free (gs->dash_array);
    free (gs);

    cairo_restore (svg_render->cr);
}

/* render function returns TRUE if render_element_tree() is to render
 * the child nodes, FALSE if render_element_tree() is to skip the
 * child nodes.
 */
struct render_func {
    const char *tag;
    cairo_bool_t (*render) (cairo_svg_glyph_render_t *, cairo_svg_element_t *, cairo_bool_t);
};

/* Must be sorted */
static const struct render_func render_funcs[] = {
    { "circle", render_element_circle },
    { "clipPath", render_element_clip_path },
    { "defs", NULL },
    { "desc", NULL },
    { "ellipse", render_element_ellipse },
    { "g", render_element_g },
    { "image", render_element_image },
    { "line", render_element_line },
    { "linearGradient", render_element_linear_gradient },
    { "metadata", NULL },
    { "path", render_element_path },
    { "polygon", render_element_polyline },
    { "polyline", render_element_polyline },
    { "radialGradient", render_element_radial_gradient },
    { "rect", render_element_rect },
    { "stop", render_element_stop },
    { "svg", render_element_svg },
    { "title", NULL },
    { "use", render_element_use },
};

static int
_render_func_compare (const void *a, const void *b)
{
    const struct render_func *render_func_a = a;
    const struct render_func *render_func_b = b;

    return strcmp (render_func_a->tag, render_func_b->tag);
}

static cairo_bool_t
call_element (cairo_svg_glyph_render_t *svg_render,
              cairo_svg_element_t      *element,
              cairo_bool_t              end_tag)
{
    const struct render_func *func;
    struct render_func key;
    cairo_bool_t recurse = FALSE;

    key.tag = element->tag;
    key.render = NULL;
    func = bsearch (&key,
                    render_funcs,
                    ARRAY_LENGTH (render_funcs),
                    sizeof (struct render_func),
                    _render_func_compare);
    if (func) {
        if (func->render) {
            recurse = func->render (svg_render, element, end_tag);
        }
    } else {
        print_warning (svg_render, "Unsupported element: %s", element->tag);
    }

    return recurse;
}

static cairo_bool_t
render_element (cairo_svg_glyph_render_t *svg_render,
                cairo_svg_element_t      *element,
                cairo_bool_t              end_tag,
                cairo_svg_element_t      *display_element)
{
    cairo_bool_t recurse = FALSE;
    cairo_svg_graphics_state_t *gs;

    /* Ignore elements if we have not seen "<svg>". Ignore
      * "<svg>" if we have seen it */
    if (svg_render->view_port_set) {
        if (string_equal (element->tag, "svg"))
            return FALSE;
    } else {
        if (!string_equal (element->tag, "svg"))
            return FALSE;
    }

    if (element->type == EMPTY_ELEMENT ||
        (element->type == CONTAINER_ELEMENT && !end_tag))
    {
        save_graphics_state (svg_render);
        update_graphics_state (svg_render, element);
    }

    gs = svg_render->graphics_state;
    if (gs->mode == GS_NO_RENDER && element == display_element)
        gs->mode = GS_RENDER;

    recurse = call_element (svg_render, element, end_tag);

    if (element->type == EMPTY_ELEMENT ||
        (element->type == CONTAINER_ELEMENT && end_tag))
    {
        restore_graphics_state (svg_render);
    }

    return recurse;
}

#define MAX_DEPTH 100

static void
render_element_tree (cairo_svg_glyph_render_t *svg_render,
                     cairo_svg_element_t      *element,
                     cairo_svg_element_t      *display_element,
                     cairo_bool_t              children_only)
{
    if (!element)
        return;

    /* Avoid circular references by limiting the number of recursive
     * calls to this function. */
    if (svg_render->render_element_tree_depth > MAX_DEPTH)
        return;

    svg_render->render_element_tree_depth++;
    if (element->type == EMPTY_ELEMENT && !children_only) {
        render_element (svg_render, element, FALSE, display_element);

    } else if (element->type == CONTAINER_ELEMENT) {
        int num_elems;
        cairo_bool_t recurse = TRUE;;

        if (!children_only)
            recurse = render_element (svg_render, element, FALSE, display_element);

        /* We only render the children if the parent returned
         * success. This is how we avoid rendering non display
         * elements like gradients, <defs>, and anything not
         * implemented. */
        if (recurse) {
            num_elems = _cairo_array_num_elements (&element->children);
            for (int i = 0; i < num_elems; i++) {
                cairo_svg_element_t *child;
                _cairo_array_copy_element (&element->children, i, &child);
                render_element_tree (svg_render, child, display_element, FALSE);
            }
        }

        if (!children_only)
            render_element (svg_render, element, TRUE, display_element);
    }
    svg_render->render_element_tree_depth--;
}

static void
render_element_tree_id (cairo_svg_glyph_render_t *svg_render,
                        const char               *element_id)
{
    cairo_svg_element_t *glyph_element = NULL;

    if (element_id)
        glyph_element = lookup_element (svg_render, element_id);

    if (glyph_element)
        svg_render->graphics_state->mode = GS_NO_RENDER;
    else
        svg_render->graphics_state->mode = GS_RENDER;

    render_element_tree (svg_render, svg_render->tree, glyph_element, TRUE);
}

cairo_status_t
_cairo_render_svg_glyph (const char           *svg_document,
                         unsigned long         first_glyph,
                         unsigned long         last_glyph,
                         unsigned long         glyph,
                         double                units_per_em,
                         FT_Color             *palette,
                         int                   num_palette_entries,
                         cairo_t              *cr,
                         cairo_pattern_t      *foreground_source,
       cairo_bool_t         *foreground_source_used)
{
    cairo_status_t status = CAIRO_STATUS_SUCCESS;

    cairo_svg_glyph_render_t *svg_render = _cairo_calloc (sizeof (cairo_svg_glyph_render_t));
    if (unlikely (svg_render == NULL))
  return _cairo_error (CAIRO_STATUS_NO_MEMORY);

    svg_render->tree = NULL;
    svg_render->ids = _cairo_hash_table_create (_element_id_equal);
    if (unlikely (svg_render->ids == NULL)) {
        free (svg_render);
  return _cairo_error (CAIRO_STATUS_NO_MEMORY);
    }

    svg_render->debug = 0;
    const char *s = getenv ("CAIRO_DEBUG_SVG_RENDER");
    if (s) {
        if (strlen (s) > 0)
            svg_render->debug = atoi (s);
        else
            svg_render->debug = SVG_RENDER_ERROR;
    }

    svg_render->cr = cr;
    svg_render->units_per_em = units_per_em;
    svg_render->build_pattern.paint_server = NULL;
    svg_render->build_pattern.pattern = NULL;
    svg_render->build_pattern.type = BUILD_PATTERN_NONE;
    svg_render->render_element_tree_depth = 0;
    svg_render->view_port_set = FALSE;
    svg_render->num_palette_entries = num_palette_entries;
    svg_render->palette = palette;

    svg_render->foreground_marker = _cairo_pattern_create_foreground_marker ();
    svg_render->foreground_source = cairo_pattern_reference (foreground_source);;
    svg_render->foreground_source_used = FALSE;

    init_graphics_state (svg_render);

    print_info (svg_render, "Glyph ID: %ld", glyph);
    print_info (svg_render, "Palette Entries: %d", num_palette_entries);
    print_info (svg_render, "Units per EM: %f", units_per_em);
    print_info (svg_render, "SVG Document:\n%s\n", svg_document);

    /* First parse elements into a tree and populate ids hash table */
    if (!parse_svg (svg_render, svg_document)) {
        print_error (svg_render, "Parse SVG document failed");
        status = CAIRO_STATUS_SVG_FONT_ERROR;
        goto cleanup;
    }

#if SVG_RENDER_PRINT_FUNCTIONS
    printf("\nTREE\n");
    if (svg_render->tree) {
        print_element (svg_render->tree, TRUE, 0);
        printf("\n");
    }
#endif

    /* Next, render glyph */
    if (first_glyph == last_glyph) {
        /* Render whole document */
        render_element_tree_id (svg_render, NULL);
    } else {
        /* Render element with id "glyphID" where ID is glyph number. */

        char glyph_id[30];
        snprintf(glyph_id, sizeof(glyph_id), "#glyph%ld", glyph);
        render_element_tree_id (svg_render, glyph_id);
    }

  cleanup:
    if (svg_render->build_pattern.pattern)
        cairo_pattern_destroy (svg_render->build_pattern.pattern);

    if (svg_render->tree)
        free_elements (svg_render, svg_render->tree);

    while (svg_render->graphics_state)
        restore_graphics_state (svg_render);

    cairo_pattern_destroy (svg_render->foreground_marker);
    cairo_pattern_destroy (svg_render->foreground_source);
    *foreground_source_used = svg_render->foreground_source_used;

    /* The hash entry for each element with an id is removed by
     * free_elements() */
    _cairo_hash_table_destroy (svg_render->ids);

    free (svg_render);

    return status;
}

#ifdef DEBUG_SVG_RENDER

/**
 * _cairo_debug_svg_render:
 *
 * Debug function for cairo-svg-glyph-render.c. Allows invoking the renderer from outside
 * cairo to test with SVG documents, and to facilitate comparison with librsvg rendering.
 * The viewport is .
 *
 * @cr: render target
 * @svg_document: SVG Document
 * @element: element within svg_document to render (eg "#glyph8"), or NULL to render entire document.
 * @debug_level: 0 - quiet, 1 - print errors, 2 - print warnings, 3 - info
 * @return TRUE on success, ie no errors, FALSE if error
 **/
cairo_public cairo_bool_t
_cairo_debug_svg_render (cairo_t       *cr,
                         const char    *svg_document,
                         const char    *element,
                         double         units_per_em,
                         int            debug_level);

cairo_bool_t
_cairo_debug_svg_render (cairo_t       *cr,
                         const char    *svg_document,
                         const char    *element,
                         double         units_per_em,
                         int            debug_level)
{
    cairo_status_t status;
    cairo_bool_t foreground_source_used;
    cairo_pattern_t *foreground = _cairo_pattern_create_foreground_marker ();

    status = _cairo_render_svg_glyph (svg_document,
              1, 1, 1,
              units_per_em,
              NULL, 0,
              cr,
              foreground,
              &foreground_source_used);
    cairo_pattern_destroy (foreground);

    return status == CAIRO_STATUS_SUCCESS;
}

#endif /* DEBUG_SVG_RENDER */

#endif /* HAVE_FT_SVG_DOCUMENT */

Coverage Report

Created: 2026-10-01 07:23