WebSVN – Kolibri OS – Diff – /programs/develop/libraries/cairo/src/cairo-svg-surface.c

  *	Carl Worth
  */
 #define _BSD_SOURCE /* for snprintf() */
+#include "cairoint.h"
 #include "cairoint.h"
+#include "cairo-svg.h"
-#include "cairo-svg.h"
+#include "cairo-array-private.h"
+#include "cairo-analysis-surface-private.h"
-#include "cairo-analysis-surface-private.h"
+#include "cairo-default-context-private.h"
 #include "cairo-error-private.h"
+#include "cairo-image-info-private.h"
-#include "cairo-image-info-private.h"
+#include "cairo-image-surface-private.h"
-#include "cairo-recording-surface-private.h"
+#include "cairo-recording-surface-inline.h"
 #include "cairo-output-stream-private.h"
 #include "cairo-path-fixed-private.h"
 #include "cairo-paginated-private.h"
 #include "cairo-scaled-font-subsets-private.h"
+#include "cairo-surface-clipper-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.
- */
+ **/
 /**
  * CAIRO_HAS_SVG_SURFACE:
+ *
+ * Defined if the SVG surface backend is available.
- *
+ * This macro can be used to conditionally compile backend-specific code.
  * Defined if the SVG surface backend is available.
- * This macro can be used to conditionally compile backend-specific code.
+ * Since: 1.2
     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_URI,
+    NULL
-#define CAIRO_SVG_VERSION_LAST ARRAY_LENGTH (_cairo_svg_versions)
+};
 static void
 _cairo_svg_surface_emit_path (cairo_output_stream_t	*output,
-			      cairo_path_fixed_t	*path,
+			      const cairo_path_fixed_t	*path,
 			      const cairo_matrix_t	*ctm_inverse);
  * 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 *
 cairo_svg_surface_create_for_stream (cairo_write_func_t		 write_func,
 				     void			*closure,
 				     double			 width,
 				     double			 height)
+}
 static cairo_svg_page_t *
 _cairo_svg_surface_store_page (cairo_svg_surface_t *surface)
-{
     unsigned int i;
     cairo_svg_page_t page;
     cairo_output_stream_t *stream;
+    cairo_int_status_t status;
-    cairo_status_t status;
+    unsigned int i;
     stream = _cairo_memory_stream_create ();
     if (_cairo_output_stream_get_status (stream)) {
     return CAIRO_STATUS_SUCCESS;
+}
 static void
 _cairo_svg_surface_emit_path (cairo_output_stream_t	*output,
-			      cairo_path_fixed_t	*path,
+			      const cairo_path_fixed_t	*path,
 			      const cairo_matrix_t	*ctm_inverse)
+{
     cairo_status_t status;
     svg_path_info_t info;
     _cairo_output_stream_printf (output, "d=\"");
-    info.output = output;
-    info.ctm_inverse = ctm_inverse;
+    info.output = output;
-    status = _cairo_path_fixed_interpret (path,
+    info.ctm_inverse = ctm_inverse;
-					  CAIRO_DIRECTION_FORWARD,
+    status = _cairo_path_fixed_interpret (path,
 					  _cairo_svg_path_move_to,
 					  _cairo_svg_path_line_to,
     cairo_surface_destroy (&image->base);
     return CAIRO_STATUS_SUCCESS;
 }
-static cairo_status_t
+static cairo_int_status_t
 _cairo_svg_document_emit_glyph (cairo_svg_document_t	*document,
 				cairo_scaled_font_t	*scaled_font,
 				unsigned long		 scaled_font_glyph_index,
 				unsigned int		 font_id,
 				unsigned int		 subset_glyph_index)
+{
-    cairo_status_t	     status;
+    cairo_int_status_t	     status;
     _cairo_output_stream_printf (document->xml_node_glyphs,
     if (unlikely (status))
 	return status;
     _cairo_output_stream_printf (document->xml_node_glyphs, "\n");
-    return CAIRO_STATUS_SUCCESS;
+    return CAIRO_INT_STATUS_SUCCESS;
+}
-static cairo_status_t
+static cairo_int_status_t
 _cairo_svg_document_emit_font_subset (cairo_scaled_font_subset_t	*font_subset,
+				      void				*closure)
 				      void				*closure)
-{
     cairo_svg_document_t *document = closure;
-    unsigned int i;
+    cairo_int_status_t status = CAIRO_INT_STATUS_SUCCESS;
-    cairo_status_t status = CAIRO_STATUS_SUCCESS;
+    unsigned int i;
 	surface->paginated_mode == CAIRO_PAGINATED_MODE_ANALYZE)
+    {
 	return CAIRO_INT_STATUS_UNSUPPORTED;
+    }
+    if (pattern->type == CAIRO_PATTERN_TYPE_MESH)
+	return CAIRO_INT_STATUS_UNSUPPORTED;
     /* SVG doesn't support extend reflect for image pattern */
     if (pattern->type == CAIRO_PATTERN_TYPE_SURFACE &&
 	pattern->extend == CAIRO_EXTEND_REFLECT)
 static cairo_int_status_t
 _cairo_surface_base64_encode (cairo_surface_t       *surface,
 			      cairo_output_stream_t *output)
 {
-    cairo_status_t status;
+    cairo_int_status_t status;
     base64_write_closure_t info;
     status = _cairo_surface_base64_encode_jpeg (surface, output);
+    {
 	return CAIRO_STATUS_SUCCESS;
+    }
     paginated_surface = _cairo_svg_surface_create_for_document (document,
-								source->content,
+								source->base.content,
 								source->extents_pixels.width,
 								source->extents_pixels.height);
     if (unlikely (paginated_surface->status))
 				     svg_surface->base_clip,
 				     svg_surface->width,
 				     svg_surface->height);
+    }
-    if (source->content == CAIRO_CONTENT_ALPHA) {
+    if (source->base.content == CAIRO_CONTENT_ALPHA) {
 	_cairo_svg_surface_emit_alpha_filter (document);
 	_cairo_output_stream_printf (document->xml_node_defs,
+				     "
 				     "clip-path=\"url(#clip%d)\" "
     return _cairo_user_data_array_set_data (&source->base.user_data,
 					    (cairo_user_data_key_t *) document,
 					    document, NULL);
+}
+static cairo_recording_surface_t *
+to_recording_surface (const cairo_surface_pattern_t *pattern)
+{
+    cairo_surface_t *surface = pattern->surface;
+    if (_cairo_surface_is_paginated (surface))
+	surface = _cairo_paginated_surface_get_recording (surface);
+    if (_cairo_surface_is_snapshot (surface))
+	surface = _cairo_surface_snapshot_get_target (surface);
+    return (cairo_recording_surface_t *) surface;
+}
 static cairo_status_t
 _cairo_svg_surface_emit_composite_recording_pattern (cairo_output_stream_t	*output,
 						     cairo_svg_surface_t	*surface,
 						     cairo_operator_t	         op,
     p2u = pattern->base.matrix;
     status = cairo_matrix_invert (&p2u);
     /* cairo_pattern_set_matrix ensures the matrix is invertible */
     assert (status == CAIRO_STATUS_SUCCESS);
-    recording_surface = (cairo_recording_surface_t *) pattern->surface;
+    recording_surface = to_recording_surface (pattern);
     status = _cairo_svg_surface_emit_recording_surface (document, recording_surface);
     if (unlikely (status))
 	return status;
 					   int			    pattern_id,
 					   const cairo_matrix_t	   *parent_matrix,
 					   const char		   *extra_attributes)
+{
-    if (_cairo_surface_is_recording (pattern->surface)) {
+    if (pattern->surface->type == CAIRO_SURFACE_TYPE_RECORDING) {
 	return _cairo_svg_surface_emit_composite_recording_pattern (output, surface,
 								    op, pattern,
 								    pattern_id,
 								    parent_matrix,
 					cairo_output_stream_t  *style,
 					cairo_bool_t	        is_stroke,
 					const cairo_matrix_t   *parent_matrix)
+{
     cairo_svg_document_t *document = surface->document;
-    double x0, y0, x1, y1;
     cairo_matrix_t p2u;
     cairo_status_t status;
     p2u = pattern->base.base.matrix;
     status = cairo_matrix_invert (&p2u);
     /* cairo_pattern_set_matrix ensures the matrix is invertible */
-    assert (status == CAIRO_STATUS_SUCCESS);
-    x0 = _cairo_fixed_to_double (pattern->p1.x);
-    y0 = _cairo_fixed_to_double (pattern->p1.y);
-    x1 = _cairo_fixed_to_double (pattern->p2.x);
-    y1 = _cairo_fixed_to_double (pattern->p2.y);
+    assert (status == CAIRO_STATUS_SUCCESS);
     _cairo_output_stream_printf (document->xml_node_defs,
+				 "
 				 "gradientUnits=\"userSpaceOnUse\" "
 				 "x1=\"%f\" y1=\"%f\" x2=\"%f\" y2=\"%f\" ",
+				 document->linear_pattern_id,
-				 document->linear_pattern_id,
+				 pattern->pd1.x, pattern->pd1.y,
-				 x0, y0, x1, y1);
+				 pattern->pd2.x, pattern->pd2.y);
     cairo_extend_t extend;
     double x0, y0, x1, y1, r0, r1;
     double fx, fy;
     cairo_bool_t reverse_stops;
     cairo_status_t status;
-    cairo_point_t *c0, *c1;
+    cairo_circle_double_t *c0, *c1;
-    cairo_fixed_t radius0, radius1;
     extend = pattern->base.base.extend;
-    if (pattern->r1 < pattern->r2) {
+    if (pattern->cd1.radius < pattern->cd2.radius) {
-	c0 = &pattern->c1;
-	c1 = &pattern->c2;
-	radius0 = pattern->r1;
+	c0 = &pattern->cd1;
-	radius1 = pattern->r2;
+	c1 = &pattern->cd2;
 	reverse_stops = FALSE;
     } else {
-	c0 = &pattern->c2;
-	c1 = &pattern->c1;
-	radius0 = pattern->r2;
+	c0 = &pattern->cd2;
-	radius1 = pattern->r1;
+	c1 = &pattern->cd1;
 	reverse_stops = TRUE;
     }
-    x0 = _cairo_fixed_to_double (c0->x);
+    x0 = c0->center.x;
-    y0 = _cairo_fixed_to_double (c0->y);
+    y0 = c0->center.y;
-    r0 = _cairo_fixed_to_double (radius0);
+    r0 = c0->radius;
-    x1 = _cairo_fixed_to_double (c1->x);
+    x1 = c1->center.x;
-    y1 = _cairo_fixed_to_double (c1->y);
+    y1 = c1->center.y;
-    r1 = _cairo_fixed_to_double (radius1);
+    r1 = c1->radius;
     p2u = pattern->base.base.matrix;
     status = cairo_matrix_invert (&p2u);
     /* cairo_pattern_set_matrix ensures the matrix is invertible */
     assert (status == CAIRO_STATUS_SUCCESS);
 						       output, is_stroke, parent_matrix);
     case CAIRO_PATTERN_TYPE_RADIAL:
 	return _cairo_svg_surface_emit_radial_pattern (surface, (cairo_radial_pattern_t *) pattern,
+						       output, is_stroke, parent_matrix);
+    case CAIRO_PATTERN_TYPE_MESH:
+    case CAIRO_PATTERN_TYPE_RASTER_SOURCE:
-						       output, is_stroke, parent_matrix);
+	ASSERT_NOT_REACHED;
+    }
     return _cairo_error (CAIRO_STATUS_PATTERN_TYPE_MISMATCH);
+}
 				cairo_operator_t	 fill_op,
 				const cairo_pattern_t	*fill_source,
 				cairo_fill_rule_t	 fill_rule,
 				double			 fill_tolerance,
 				cairo_antialias_t	 fill_antialias,
-				cairo_path_fixed_t	*path,
+				const cairo_path_fixed_t*path,
 				cairo_operator_t	 stroke_op,
 				const cairo_pattern_t	*stroke_source,
 				const cairo_stroke_style_t	*stroke_style,
 				const cairo_matrix_t		*stroke_ctm,
 				const cairo_matrix_t		*stroke_ctm_inverse,
 				double			 stroke_tolerance,
 				cairo_antialias_t	 stroke_antialias,
-				cairo_clip_t		*clip)
+				const cairo_clip_t	*clip)
+{
     cairo_svg_surface_t *surface = abstract_surface;
     cairo_status_t status;
 static cairo_int_status_t
 _cairo_svg_surface_fill (void			*abstract_surface,
 			 cairo_operator_t	 op,
 			 const cairo_pattern_t	*source,
-			 cairo_path_fixed_t	*path,
+			 const cairo_path_fixed_t*path,
 			 cairo_fill_rule_t	 fill_rule,
 			 double			 tolerance,
 			 cairo_antialias_t	 antialias,
-			 cairo_clip_t		*clip)
+			 const cairo_clip_t	*clip)
+{
     cairo_svg_surface_t *surface = abstract_surface;
     cairo_status_t status;
 static cairo_int_status_t
 _cairo_svg_surface_paint (void		    *abstract_surface,
 			  cairo_operator_t   op,
 			  const cairo_pattern_t   *source,
-			  cairo_clip_t		  *clip)
+			  const cairo_clip_t	  *clip)
+{
     cairo_status_t status;
     cairo_svg_surface_t *surface = abstract_surface;
 static cairo_int_status_t
 _cairo_svg_surface_mask (void		    *abstract_surface,
 			 cairo_operator_t     op,
 			 const cairo_pattern_t	    *source,
 			 const cairo_pattern_t	    *mask,
-			 cairo_clip_t		    *clip)
+			 const cairo_clip_t	    *clip)
+{
     cairo_status_t status;
     cairo_svg_surface_t *surface = abstract_surface;
     cairo_svg_document_t *document = surface->document;
     cairo_output_stream_t *mask_stream;
     if (unlikely (status))
 	return status;
     if (mask->type == CAIRO_PATTERN_TYPE_SURFACE) {
 	const cairo_surface_pattern_t *surface_pattern = (const cairo_surface_pattern_t*) mask;
-	cairo_content_t content = cairo_surface_get_content (surface_pattern->surface);
+	cairo_content_t content = surface_pattern->surface->content;
 	if (content == CAIRO_CONTENT_ALPHA)
 	    discard_filter = TRUE;
+    }
 static cairo_int_status_t
 _cairo_svg_surface_stroke (void			*abstract_dst,
 			   cairo_operator_t      op,
 			   const cairo_pattern_t *source,
-			   cairo_path_fixed_t	*path,
+			   const cairo_path_fixed_t*path,
 			   const cairo_stroke_style_t *stroke_style,
 			   const cairo_matrix_t	*ctm,
 			   const cairo_matrix_t	*ctm_inverse,
 			   double		 tolerance,
 			   cairo_antialias_t	 antialias,
-			   cairo_clip_t		*clip)
+			   const cairo_clip_t	*clip)
+{
     cairo_svg_surface_t *surface = abstract_dst;
     cairo_status_t status;
 				cairo_operator_t	 op,
 				const cairo_pattern_t	*pattern,
 				cairo_glyph_t		*glyphs,
 				int			 num_glyphs,
 				cairo_scaled_font_t	*scaled_font,
-				cairo_clip_t		*clip,
+				const cairo_clip_t	*clip)
-				int			*remaining_glyphs)
+{
     cairo_svg_surface_t *surface = abstract_surface;
     cairo_svg_document_t *document = surface->document;
     cairo_path_fixed_t path;
-    cairo_status_t status;
+    cairo_int_status_t status;
     cairo_scaled_font_subsets_glyph_t subset_glyph;
     int i;
     if (surface->paginated_mode == CAIRO_PAGINATED_MODE_ANALYZE)
     _cairo_font_options_init_default (options);
     cairo_font_options_set_hint_style (options, CAIRO_HINT_STYLE_NONE);
     cairo_font_options_set_hint_metrics (options, CAIRO_HINT_METRICS_OFF);
+    cairo_font_options_set_antialias (options, CAIRO_ANTIALIAS_GRAY);
+    _cairo_font_options_set_round_glyph_positions (options, CAIRO_ROUND_GLYPH_POS_OFF);
+}
+static const char **
+_cairo_svg_surface_get_supported_mime_types (void	   *abstract_surface)
+{
-    cairo_font_options_set_antialias (options, CAIRO_ANTIALIAS_GRAY);
+    return _cairo_svg_supported_mime_types;
+}
-static const cairo_surface_backend_t cairo_svg_surface_backend = {
-	CAIRO_SURFACE_TYPE_SVG,
+static const cairo_surface_backend_t cairo_svg_surface_backend = {
+	CAIRO_SURFACE_TYPE_SVG,
+	_cairo_svg_surface_finish,
+	_cairo_default_context_create,
+	NULL, /* create_similar: handled by wrapper */
+	NULL, /* create_similar_image */
+	NULL, /* map to image */
+	NULL, /* unmap image */
 	NULL, /* create_similar: handled by wrapper */
-	_cairo_svg_surface_finish,
+	_cairo_surface_default_source,
-	NULL, /* acquire_source_image */
-	NULL, /* release_source_image */
-	NULL, /* acquire_dest_image */
+	NULL, /* acquire_source_image */
-	NULL, /* release_dest_image */
-	NULL, /* clone_similar */
-	NULL, /* _cairo_svg_surface_composite, */
-	NULL, /* _cairo_svg_surface_fill_rectangles, */
-	NULL, /* _cairo_svg_surface_composite_trapezoids,*/
+	NULL, /* release_source_image */
-	NULL, /* create_span_renderer */
+	NULL, /* snapshot */
 	NULL, /* check_span_renderer */
+	_cairo_svg_surface_copy_page,
-	_cairo_svg_surface_copy_page,
+	_cairo_svg_surface_show_page,
-	_cairo_svg_surface_show_page,
 	_cairo_svg_surface_get_extents,
+	_cairo_svg_surface_get_extents,
-	NULL, /* _cairo_svg_surface_old_show_glyphs, */
+	_cairo_svg_surface_get_font_options,
 	_cairo_svg_surface_get_font_options,
-	NULL, /* flush */
-	NULL, /* mark dirty rectangle */
+	NULL, /* flush */
-	NULL, /* scaled font fini */
+	NULL, /* mark dirty rectangle */
 	NULL, /* scaled glyph fini */
 	_cairo_svg_surface_paint,
 	_cairo_svg_surface_mask,
+	_cairo_svg_surface_stroke,
-	_cairo_svg_surface_stroke,
+	_cairo_svg_surface_fill,
-	_cairo_svg_surface_fill,
+	_cairo_svg_surface_fill_stroke,
 	_cairo_svg_surface_show_glyphs,
-	NULL, /* snapshot */
+	NULL, /* has_show_text_glyphs */
-	NULL, /* is_similar */
+	NULL, /* show_text_glyphs */
-	_cairo_svg_surface_fill_stroke
+	_cairo_svg_surface_get_supported_mime_types,
 };
     if (surface->document->svg_version >= CAIRO_SVG_VERSION_1_2) {
 	status =  _cairo_svg_surface_analyze_operator (surface,
 						       CAIRO_OPERATOR_SOURCE);
+    }
-    return status == CAIRO_STATUS_SUCCESS;
+    return status == CAIRO_INT_STATUS_SUCCESS;
+}
 static const cairo_paginated_surface_backend_t cairo_svg_surface_paginated_backend = {

Subversion Repositories Kolibri OS

(root)/programs/develop/libraries/cairo/src/cairo-svg-surface.c – Rev 1897 → 3959