/* vim: set sw=4 sts=4: -*- Mode: c; tab-width: 8; c-basic-offset: 4; indent-tabs-mode: t; -*- */

/* cairo - a vector graphics library with display and print output

 *

 * Copyright © 2004 Red Hat, Inc

 * Copyright © 2005-2007 Emmanuel Pacaud <emmanuel.pacaud@free.fr>

 * Copyright © 2006 Red Hat, Inc

 * Copyright © 2020-2021 Anton Danilkin <afdw@yandex.ru>

 *

 * 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 University of Southern

 * California.

 *

 * Contributor(s):

 *	Kristian Høgsberg <krh@redhat.com>

 *	Emmanuel Pacaud <emmanuel.pacaud@free.fr>

 *	Carl Worth <cworth@cworth.org>

 *	Anton Danilkin <afdw@yandex.ru>

 */

#include "cairoint.h"

#include "cairo-svg.h"

#include "cairo-array-private.h"

#include "cairo-default-context-private.h"

#include "cairo-error-private.h"

#include "cairo-image-info-private.h"

#include "cairo-image-surface-private.h"

#include "cairo-recording-surface-inline.h"

#include "cairo-output-stream-private.h"

#include "cairo-paginated-private.h"

#include "cairo-scaled-font-subsets-private.h"

#include "cairo-surface-clipper-private.h"

#include "cairo-surface-snapshot-inline.h"

#include "cairo-svg-surface-private.h"

/**

 * SECTION:cairo-svg

 * @Title: SVG Surfaces

 * @Short_Description: Rendering SVG documents

 * @See_Also: #cairo_surface_t

 *

 * The SVG surface is used to render cairo graphics to

 * SVG files and is a multi-page vector surface backend.

 **/

typedef struct _cairo_svg_source_surface {

    cairo_hash_entry_t base;

    unsigned int id;

    unsigned char *unique_id;

    unsigned long unique_id_length;

    cairo_bool_t transitive_paint_used;

} cairo_svg_source_surface_t;

/*

 * _cairo_svg_paint_element and _cairo_svg_paint are used to implement paints in transformed recording patterns.

 */

typedef struct _cairo_svg_paint_element {

    unsigned int source_id;

    cairo_matrix_t matrix;

} cairo_svg_paint_element_t;

typedef struct _cairo_svg_paint {

    cairo_hash_entry_t base;

    unsigned int source_id;

    cairo_array_t paint_elements;

    cairo_box_double_t box;

} cairo_svg_paint_t;

static void

{

    } else {

    }

static cairo_bool_t

{

    }

}

static void

{

static void

{

static cairo_bool_t

{

}

static void

{

static void

{

enum cairo_svg_stream_element_type {

    CAIRO_SVG_STREAM_ELEMENT_TYPE_TEXT,

    CAIRO_SVG_STREAM_ELEMENT_TYPE_PAINT_DEPENDENT,

};

enum cairo_svg_stream_paint_dependent_element_type {

    CAIRO_SVG_STREAM_PAINT_DEPENDENT_ELEMENT_TYPE_RECTANGLE,

    CAIRO_SVG_STREAM_PAINT_DEPENDENT_ELEMENT_TYPE_RECTANGLE_AT_ORIGIN,

    CAIRO_SVG_STREAM_PAINT_DEPENDENT_ELEMENT_TYPE_TRANSLATION,

    CAIRO_SVG_STREAM_PAINT_DEPENDENT_ELEMENT_TYPE_INVERSE_TRANSLATION,

};

typedef struct _cairo_svg_stream_element {

    enum cairo_svg_stream_element_type type;

    union {

        struct {

	    cairo_output_stream_t *output_stream;

	} text;

        struct {

	    unsigned int source_id;

	    enum cairo_svg_stream_paint_dependent_element_type type;

        } paint_dependent;

    };

} cairo_svg_stream_element_t;

typedef struct _cairo_svg_stream {

    cairo_status_t status;

    cairo_array_t elements;

} cairo_svg_stream_t;

static cairo_svg_stream_t

{

    cairo_svg_stream_t svg_stream;

}

static void

			 const void *data,

			 size_t length)

{

    cairo_status_t status;

    }

	cairo_svg_stream_element_t element;

	    }

	}

    }

}

static void CAIRO_PRINTF_FORMAT (2, 0)

			  const char *fmt,

			  ...)

{

    cairo_status_t status;

    }

        cairo_svg_stream_element_t element;

	    }

	}

    }

    va_list ap;

}

static void

					  unsigned int source_id,

					  enum cairo_svg_stream_paint_dependent_element_type type)

{

    cairo_status_t status;

    cairo_svg_stream_element_t element;

    }

static void

			cairo_svg_stream_t *to)

{

    cairo_status_t status;

	}

    }

	    }

	}

	    }

	}

    }

}

static void

					 cairo_output_stream_t *to,

					 cairo_hash_table_t *paints)

{

	}

    }

	}

	    cairo_svg_paint_t paint_key;

									     &paint_key.base);

					     " x=\"%f\" y=\"%f\" width=\"%f\" height=\"%f\"",

					     found_paint_entry->box.p1.x,

					     found_paint_entry->box.p1.y,

					     " x=\"0\" y=\"0\" width=\"%f\" height=\"%f\"",

					     " transform=\"translate(%f, %f)\"",

					     found_paint_entry->box.p1.x,

					     found_paint_entry->box.p1.y);

					     " transform=\"translate(%f, %f)\"",

	    }

	}

    }

}

static cairo_status_t

{

	    }

	}

    }

}

/**

 * CAIRO_HAS_SVG_SURFACE:

 *

 * Defined if the SVG surface backend is available.

 * This macro can be used to conditionally compile backend-specific code.

 *

 * Since: 1.2

 **/

static const unsigned int invalid_pattern_id = -1;

static const cairo_svg_version_t _cairo_svg_versions[] =

{

    CAIRO_SVG_VERSION_1_1,

    CAIRO_SVG_VERSION_1_2

};

#define CAIRO_SVG_VERSION_LAST ARRAY_LENGTH (_cairo_svg_versions)

static const char *_cairo_svg_supported_mime_types[] =

{

    CAIRO_MIME_TYPE_JPEG,

    CAIRO_MIME_TYPE_PNG,

    CAIRO_MIME_TYPE_UNIQUE_ID,

    CAIRO_MIME_TYPE_URI,

    NULL

};

static void

_cairo_svg_surface_emit_path (cairo_svg_stream_t *output,

			      const cairo_path_fixed_t *path,

			      const cairo_matrix_t *ctm_inverse);

static const char * _cairo_svg_version_strings[CAIRO_SVG_VERSION_LAST] =

{

    "SVG 1.1",

    "SVG 1.2"

};

static const char * _cairo_svg_unit_strings[] =

{

    "",

    "em",

    "ex",

    "px",

    "in",

    "cm",

    "mm",

    "pt",

    "pc",

    "%"

};

enum cairo_svg_filter {

    CAIRO_SVG_FILTER_REMOVE_COLOR,

    CAIRO_SVG_FILTER_REMOVE_COLOR_AND_INVERT_ALPHA,

    CAIRO_SVG_FILTER_COLOR_TO_ALPHA,

    CAIRO_SVG_FILTER_LAST_STATIC_FILTER,

    CAIRO_SVG_FILTER_OVER,

    CAIRO_SVG_FILTER_IN,

    CAIRO_SVG_FILTER_OUT,

    CAIRO_SVG_FILTER_ATOP,

    CAIRO_SVG_FILTER_XOR,

    CAIRO_SVG_FILTER_ADD,

    CAIRO_SVG_FILTER_MULTIPLY,

    CAIRO_SVG_FILTER_SCREEN,

    CAIRO_SVG_FILTER_OVERLAY,

    CAIRO_SVG_FILTER_DARKEN,

    CAIRO_SVG_FILTER_LIGHTEN,

    CAIRO_SVG_FILTER_COLOR_DODGE,

    CAIRO_SVG_FILTER_COLOR_BURN,

    CAIRO_SVG_FILTER_HARD_LIGHT,

    CAIRO_SVG_FILTER_SOFT_LIGHT,

    CAIRO_SVG_FILTER_DIFFERENCE,

    CAIRO_SVG_FILTER_EXCLUSION,

    CAIRO_SVG_FILTER_HUE,

    CAIRO_SVG_FILTER_SATURATION,

    CAIRO_SVG_FILTER_COLOR,

    CAIRO_SVG_FILTER_LUMINOSITY,

};

typedef struct _cairo_svg_page {

    cairo_svg_stream_t xml_node;

} cairo_svg_page_t;

typedef struct _cairo_svg_document {

    cairo_output_stream_t *output_stream;

    unsigned long refcount;

    cairo_surface_t *owner;

    cairo_bool_t finished;

    double width;

    double height;

    cairo_svg_unit_t unit;

    cairo_svg_stream_t xml_node_defs;

    cairo_svg_stream_t xml_node_glyphs;

    cairo_svg_stream_t xml_node_filters;

    unsigned int linear_pattern_id;

    unsigned int radial_pattern_id;

    unsigned int pattern_id;

    unsigned int clip_id;

    unsigned int mask_id;

    unsigned int compositing_group_id;

    unsigned int filter_id;

    cairo_bool_t filters_emitted[CAIRO_SVG_FILTER_LAST_STATIC_FILTER];

    cairo_svg_version_t svg_version;

    cairo_scaled_font_subsets_t *font_subsets;

    cairo_hash_table_t *paints;

} cairo_svg_document_t;

// Must be compatible with the struct _cairo_svg_surface_start.

typedef struct _cairo_svg_surface {

    cairo_surface_t base;

    cairo_bool_t force_fallbacks;

    unsigned int source_id;

    unsigned int depth;

    double width;

    double height;

    cairo_bool_t surface_bounded;

    cairo_svg_document_t *document;

    cairo_svg_stream_t xml_node;

    cairo_array_t page_set;

    cairo_hash_table_t *source_surfaces;

    cairo_surface_clipper_t clipper;

    cairo_svg_stream_t *current_clipper_stream;

    unsigned int clip_level;

    cairo_bool_t transitive_paint_used;

    cairo_paginated_mode_t paginated_mode;

} cairo_svg_surface_t;

static cairo_status_t

_cairo_svg_document_create (cairo_output_stream_t *stream,

			    double width,

			    double height,

			    cairo_svg_version_t version,

			    cairo_svg_document_t **document_out);

static cairo_status_t

_cairo_svg_document_destroy (cairo_svg_document_t *document);

static cairo_status_t

_cairo_svg_document_finish (cairo_svg_document_t *document);

static cairo_svg_document_t *

_cairo_svg_document_reference (cairo_svg_document_t *document);

static cairo_surface_t *

_cairo_svg_surface_create_for_document (cairo_svg_document_t *document,

					cairo_content_t content,

					double width,

					double height,

					cairo_bool_t bounded);

static cairo_surface_t *

_cairo_svg_surface_create_for_stream_internal (cairo_output_stream_t *stream,

					       double width,

					       double height,

					       cairo_svg_version_t version);

static cairo_status_t

_cairo_svg_surface_emit_composite_pattern (cairo_svg_stream_t *output,

					   cairo_svg_surface_t *surface,

					   cairo_surface_pattern_t *pattern,

					   unsigned int pattern_id,

					   const cairo_matrix_t *parent_matrix);

static cairo_status_t

_cairo_svg_surface_emit_paint (cairo_svg_stream_t *output,

			       cairo_svg_surface_t *surface,

			       const cairo_pattern_t *source,

			       cairo_bool_t at_origin);

static const cairo_surface_backend_t cairo_svg_surface_backend;

static const cairo_paginated_surface_backend_t cairo_svg_surface_paginated_backend;

/**

 * cairo_svg_surface_create_for_stream:

 * @write_func: a #cairo_write_func_t to accept the output data, may be %NULL

 *              to indicate a no-op @write_func. With a no-op @write_func,

 *              the surface may be queried or used as a source without

 *              generating any temporary files.

 * @closure: the closure argument for @write_func

 * @width_in_points: width of the surface, in points (1 point == 1/72.0 inch)

 * @height_in_points: height of the surface, in points (1 point == 1/72.0 inch)

 *

 * Creates a SVG surface of the specified size in points to be written

 * incrementally to the stream represented by @write_func and @closure.

 *

 * Return value: a pointer to the newly created surface. The caller

 * owns the surface and should call cairo_surface_destroy() when done

 * with it.

 *

 * This function always returns a valid pointer, but it will return a

 * pointer to a "nil" surface if an error such as out of memory

 * occurs. You can use cairo_surface_status() to check for this.

 *

 * Since: 1.2

 **/

cairo_surface_t *

				     void			*closure,

				     double			 width,

				     double			 height)

{

    cairo_output_stream_t *stream;

}

/**

 * cairo_svg_surface_create:

 * @filename: a filename for the SVG output (must be writable), %NULL may be

 *            used to specify no output. This will generate a SVG surface that

 *            may be queried and used as a source, without generating a

 *            temporary file.

 * @width_in_points: width of the surface, in points (1 point == 1/72.0 inch)

 * @height_in_points: height of the surface, in points (1 point == 1/72.0 inch)

 *

 * Creates a SVG surface of the specified size in points to be written

 * to @filename.

 *

 * The SVG surface backend recognizes the following MIME types for the

 * data attached to a surface (see cairo_surface_set_mime_data()) when

 * it is used as a source pattern for drawing on this surface:

 * %CAIRO_MIME_TYPE_JPEG, %CAIRO_MIME_TYPE_PNG,

 * %CAIRO_MIME_TYPE_URI. If any of them is specified, the SVG backend

 * emits a href with the content of MIME data instead of a surface

 * snapshot (PNG, Base64-encoded) in the corresponding image tag.

 *

 * The unofficial MIME type %CAIRO_MIME_TYPE_URI is examined

 * first. If present, the URI is emitted as is: assuring the

 * correctness of URI is left to the client code.

 *

 * If %CAIRO_MIME_TYPE_URI is not present, but %CAIRO_MIME_TYPE_JPEG

 * or %CAIRO_MIME_TYPE_PNG is specified, the corresponding data is

 * Base64-encoded and emitted.

 *

 * If %CAIRO_MIME_TYPE_UNIQUE_ID is present, all surfaces with the same

 * unique identifier will only be embedded once.

 *

 * Return value: a pointer to the newly created surface. The caller

 * owns the surface and should call cairo_surface_destroy() when done

 * with it.

 *

 * This function always returns a valid pointer, but it will return a

 * pointer to a "nil" surface if an error such as out of memory

 * occurs. You can use cairo_surface_status() to check for this.

 *

 * Since: 1.2

 **/

cairo_surface_t *

			  double	 width,

			  double	 height)

{

    cairo_output_stream_t *stream;

}

static cairo_bool_t

{

}

/* If the abstract_surface is a paginated surface, and that paginated

 * surface's target is a svg_surface, then set svg_surface to that

 * target. Otherwise return FALSE.

 */

static cairo_bool_t

		      cairo_svg_surface_t **svg_surface)

{

    cairo_surface_t *target;

    }

    }

    }

    }

    }

}

/**

 * cairo_svg_surface_restrict_to_version:

 * @surface: a SVG #cairo_surface_t

 * @version: SVG version

 *

 * Restricts the generated SVG file to @version. See cairo_svg_get_versions()

 * for a list of available version values that can be used here.

 *

 * This function should only be called before any drawing operations

 * have been performed on the given surface. The simplest way to do

 * this is to call this function immediately after creating the

 * surface.

 *

 * Since: 1.2

 **/

void

				       cairo_svg_version_t	 version)

{

    cairo_svg_surface_t *surface;

}

/**

 * cairo_svg_get_versions:

 * @versions: supported version list

 * @num_versions: list length

 *

 * Used to retrieve the list of supported versions. See

 * cairo_svg_surface_restrict_to_version().

 *

 * Since: 1.2

 **/

void

                        int				 *num_versions)

{

/**

 * cairo_svg_version_to_string:

 * @version: a version id

 *

 * Get the string representation of the given @version id. This function

 * will return %NULL if @version isn't valid. See cairo_svg_get_versions()

 * for a way to get the list of valid version ids.

 *

 * Return value: the string associated to given version.

 *

 * Since: 1.2

 **/

const char *

{

}

/**

 * cairo_svg_surface_set_document_unit:

 * @surface: a SVG #cairo_surface_t

 * @unit: SVG unit

 *

 * Use the specified unit for the width and height of the generated SVG file.

 * See #cairo_svg_unit_t for a list of available unit values that can be used

 * here.

 *

 * This function can be called at any time before generating the SVG file.

 *

 * However to minimize the risk of ambiguities it's recommended to call it

 * before any drawing operations have been performed on the given surface, to

 * make it clearer what the unit used in the drawing operations is.

 *

 * The simplest way to do this is to call this function immediately after

 * creating the SVG surface.

 *

 * Note if this function is never called, the default unit for SVG documents

 * generated by cairo will be user unit.

 *

 * Since: 1.16

 **/

void

				     cairo_svg_unit_t	 unit)

{

    cairo_svg_surface_t *surface;

}

/**

 * cairo_svg_surface_get_document_unit:

 * @surface: a SVG #cairo_surface_t

 *

 * Get the unit of the SVG surface.

 *

 * If the surface passed as an argument is not a SVG surface, the function

 * sets the error status to CAIRO_STATUS_SURFACE_TYPE_MISMATCH and returns

 * CAIRO_SVG_UNIT_USER.

 *

 * Return value: the SVG unit of the SVG surface.

 *

 * Since: 1.16

 **/

cairo_svg_unit_t

{

    cairo_svg_surface_t *surface;

    }

}

static void

	cairo_svg_paint_t paint_key;

									 &paint_key.base);

					      &box.p1.x, &box.p1.y,

					      &box.p2.x, &box.p2.y,

					      NULL);

	} else {

	}

    }

static void

{

static cairo_status_t

				       cairo_surface_t *source_surface,

				       cairo_bool_t *is_new,

				       cairo_svg_source_surface_t **result_source_surface)

{

    cairo_status_t status;

    cairo_svg_source_surface_t source_surface_key;

				 CAIRO_MIME_TYPE_UNIQUE_ID,

				 (const unsigned char **) &source_surface_key.unique_id,

				 &source_surface_key.unique_id_length);

										       &source_surface_key.base);

    }

	}

    } else {

    }

    }

    }

}

static cairo_bool_t

					    cairo_path_fixed_t *path)

{

    cairo_box_t box;

}

static cairo_status_t

						cairo_path_fixed_t *path,

						cairo_fill_rule_t fill_rule,

						double tolerance,

						cairo_antialias_t antialias)

{

						       cairo_svg_surface_t,

						       clipper);

	}

    }

    /* skip trivial whole-page clips */

    }

			      "<clipPath id=\"clip-%d\">\n",

			      document->clip_id);

			      "<path clip-rule=\"%s\"",

			      fill_rule == CAIRO_FILL_RULE_EVEN_ODD ? "evenodd" : "nonzero");

			      "<g clip-path=\"url(#clip-%d)\">\n",

			      document->clip_id);

}

static void

{

	}

    }

static cairo_status_t

			     cairo_svg_stream_t *clipper_stream,

			     const cairo_clip_t *clip)

{

    }

}

static cairo_surface_t *

					cairo_content_t content,

					double width,

					double height,

					cairo_bool_t bounded)

{

    cairo_svg_surface_t *surface;

    cairo_surface_t *paginated;

    cairo_status_t status;

    }

			 &cairo_svg_surface_backend,

			 NULL, /* device */

			 content,

			 TRUE); /* is_vector */

    }

						 surface->base.content,

						 &cairo_svg_surface_paginated_backend);

	/* paginated keeps the only reference to surface now, drop ours */

    }

    /* ignore status as we are on the error path */

}

static cairo_surface_t *

					       double			 width,

					       double			 height,

					       cairo_svg_version_t	 version)

{

    cairo_svg_document_t *document;

    cairo_surface_t *surface;

    cairo_status_t status;

	                                 width, height, version,

					 &document);

	/* consume the output stream on behalf of caller */

    }

						      width, height, TRUE);

    }

    /* the ref count should be 2 at this point */

}

static cairo_svg_page_t *

{

    cairo_svg_page_t page;

    }

}

static cairo_int_status_t

{

    }

}

static cairo_int_status_t

{

    }

}

static void

				   char const *attribute_name,

				   const cairo_matrix_t *object_matrix,

				   const cairo_matrix_t *parent_matrix)

{

    }

				  " %s=\"matrix(%f, %f, %f, %f, %f, %f)\"",

				  attribute_name,

				  matrix.xx, matrix.yx,

				  matrix.xy, matrix.yy,

				  matrix.x0, matrix.y0);

    }

typedef struct {

    cairo_svg_stream_t *output;

    const cairo_matrix_t *ctm_inverse;

} svg_path_info_t;

static cairo_status_t

			 const cairo_point_t *point)

{

}

static cairo_status_t

			 const cairo_point_t *point)

{

}

static cairo_status_t

			  const cairo_point_t *b,

			  const cairo_point_t *c,

			  const cairo_point_t *d)

{

    }

			      "C %f %f %f %f %f %f ",

			      bx, by, cx, cy, dx, dy);

}

static cairo_status_t

{

}

static void

			      const cairo_path_fixed_t *path,

			      const cairo_matrix_t *ctm_inverse)

{

    cairo_status_t status;

    svg_path_info_t info;

					  _cairo_svg_path_move_to,

					  _cairo_svg_path_line_to,

					  _cairo_svg_path_curve_to,

					  _cairo_svg_path_close_path,

					  &info);

static cairo_int_status_t

					     cairo_scaled_font_t *scaled_font,

					     unsigned long glyph_index)

{

    cairo_scaled_glyph_t *scaled_glyph;

    cairo_int_status_t status;

					 glyph_index,

					 CAIRO_SCALED_GLYPH_INFO_METRICS | CAIRO_SCALED_GLYPH_INFO_PATH,

					 NULL, /* foreground color */

					 &scaled_glyph);

    }