Attachment 51255 Details for Bug 38516 – show_text_glyphs support

[patch] show_text_glyphs support

font.patch (text/plain), 51.74 KB, created by MIYABE Tatsuhiko on 2011-09-16 01:14:01 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: MIYABE Tatsuhiko

Created: 2011-09-16 01:14:01 UTC

Size: 51.74 KB

patch

obsolete

>diff --git src/cairo-surface.c src/cairo-surface.c
>old mode 100644
>new mode 100755
>diff --git src/cairo-svg-surface-private.h src/cairo-svg-surface-private.h
>index ddbf464..904e485 100644
>--- src/cairo-svg-surface-private.h
>+++ src/cairo-svg-surface-private.h
>@@ -47,6 +47,7 @@
> #include "cairo-surface-clipper-private.h"
> 
> typedef struct cairo_svg_document cairo_svg_document_t;
>+typedef struct cairo_svg_font_output cairo_svg_font_output_t;
> 
> typedef struct cairo_svg_surface {
>     cairo_surface_t base;
>diff --git src/cairo-svg-surface.c src/cairo-svg-surface.c
>old mode 100644
>new mode 100755
>index 6f607d3..7f8a3ba
>--- src/cairo-svg-surface.c
>+++ src/cairo-svg-surface.c
>@@ -90,7 +90,8 @@ static const cairo_svg_version_t _cairo_svg_versions[] =
> static void
> _cairo_svg_surface_emit_path (cairo_output_stream_t	*output,
> 			      const cairo_path_fixed_t	*path,
>-			      const cairo_matrix_t	*ctm_inverse);
>+			      const cairo_matrix_t	*ctm_inverse,
>+			      double precision);
> 
> static cairo_bool_t
> _cairo_svg_version_has_page_set_support (cairo_svg_version_t version)
>@@ -110,12 +111,46 @@ static const char * _cairo_svg_internal_version_strings[CAIRO_SVG_VERSION_LAST]
>     "1.2"
> };
> 
>+static double _round(double a, int precision) {
>+	if (precision == 0) {
>+		return a;
>+	}
>+	if (a < 0) {
>+		return (double)(long)(a * precision - 0.5) / precision;
>+	}
>+	return (double)(long)(a * precision + 0.5) / precision;
>+}
>+
> struct cairo_svg_page {
>     unsigned int surface_id;
>     unsigned int clip_level;
>     cairo_output_stream_t *xml_node;
> };
> 
>+typedef struct _cairo_svg_font_style {
>+    cairo_hash_entry_t base;
>+    cairo_operator_t op;
>+    cairo_pattern_t* pattern;
>+    cairo_scaled_font_t *scaled_font;
>+    int id;
>+} cairo_svg_font_style;
>+
>+typedef struct _cairo_svg_fill_style {
>+    cairo_hash_entry_t base;
>+    cairo_operator_t op;
>+    cairo_pattern_t* pattern;
>+    cairo_fill_rule_t fill_rule;
>+    int id;
>+} cairo_svg_fill_style;
>+
>+typedef struct _cairo_svg_stroke_style {
>+    cairo_hash_entry_t base;
>+    cairo_operator_t op;
>+    cairo_pattern_t* pattern;
>+    cairo_stroke_style_t stroke_style;
>+    int id;
>+} cairo_svg_stroke_style;
>+
> struct cairo_svg_document {
>     cairo_output_stream_t *output_stream;
>     unsigned long refcount;
>@@ -126,7 +161,6 @@ struct cairo_svg_document {
>     double height;
> 
>     cairo_output_stream_t *xml_node_defs;
>-    cairo_output_stream_t *xml_node_glyphs;
> 
>     unsigned int linear_pattern_id;
>     unsigned int radial_pattern_id;
>@@ -139,7 +173,27 @@ struct cairo_svg_document {
> 
>     cairo_svg_version_t svg_version;
> 
>-    cairo_scaled_font_subsets_t *font_subsets;
>+    cairo_bool_t support_text_glyphs;
>+
>+    cairo_write_image_func_t	write_image_func;
>+    void	*write_image_closure;
>+
>+    cairo_scaled_font_subsets_t *font_text_subsets;
>+    cairo_scaled_font_subsets_t *font_glyphs_subsets;
>+
>+    unsigned int style_id;
>+    cairo_output_stream_t *css;
>+    cairo_hash_table_t *font_to_id;
>+    cairo_hash_table_t *fill_to_id;
>+    cairo_hash_table_t *stroke_to_id;
>+
>+    cairo_output_stream_t *text_x, *text_y, *text;
>+    cairo_svg_font_style prev_style;
>+};
>+
>+struct cairo_svg_font_output {
>+    cairo_output_stream_t *xml_node_glyphs;
>+    int prev_font_id;
> };
> 
> static cairo_status_t
>@@ -175,6 +229,9 @@ _cairo_svg_surface_create_for_stream_internal (cairo_output_stream_t	*stream,
> static const cairo_surface_backend_t cairo_svg_surface_backend;
> static const cairo_paginated_surface_backend_t cairo_svg_surface_paginated_backend;
> 
>+static void
>+_cairo_svg_end_text (cairo_svg_surface_t *surface);
>+
> /**
>  * cairo_svg_surface_create_for_stream:
>  * @write_func: a #cairo_write_func_t to accept the output data, may be %NULL
>@@ -388,6 +445,41 @@ cairo_svg_version_to_string (cairo_svg_version_t version)
>     return _cairo_svg_version_strings[version];
> }
> 
>+/**
>+ * cairo_svg_set_support_text_glyphs:
>+ * @surface: a SVG #cairo_surface_t
>+ * @supprt: support show_text_glyphs
>+ *
>+ * If true, support support_text_glyphs and render text by &lt;font&gt; and &lt;text&gt; elements.
>+ *
>+ * Since: 1.11.4
>+ **/
>+void
>+cairo_svg_set_support_text_glyphs (cairo_surface_t		*abstract_surface,
>+		cairo_bool_t	support_text_glyphs)
>+{
>+    cairo_svg_surface_t *surface = NULL; /* hide compiler warning */
>+
>+    if (! _extract_svg_surface (abstract_surface, &surface))
>+	return;
>+
>+	surface->document->support_text_glyphs = support_text_glyphs;
>+}
>+
>+void
>+cairo_svg_surface_set_write_image_func (cairo_surface_t 		*abstract_surface,
>+						cairo_write_image_func_t 		write_image_func,
>+						void  	 *write_image_closure)
>+{
>+	cairo_svg_surface_t *surface = NULL; /* hide compiler warning */
>+
>+    if (! _extract_svg_surface (abstract_surface, &surface))
>+	return;
>+
>+	surface->document->write_image_func = write_image_func;
>+	surface->document->write_image_closure = write_image_closure;
>+}
>+
> static cairo_bool_t
> _cliprect_covers_surface (cairo_svg_surface_t *surface,
> 			  cairo_path_fixed_t *path)
>@@ -420,6 +512,8 @@ _cairo_svg_surface_clipper_intersect_clip_path (cairo_surface_clipper_t *clipper
>     cairo_svg_document_t *document = surface->document;
>     unsigned int i;
> 
>+    _cairo_svg_end_text(surface);
>+
>     if (path == NULL) {
> 	for (i = 0; i < surface->clip_level; i++)
> 	    _cairo_output_stream_printf (surface->xml_node, "</g>\n");
>@@ -436,7 +530,7 @@ _cairo_svg_surface_clipper_intersect_clip_path (cairo_surface_clipper_t *clipper
> 				 "<clipPath id=\"clip%d\">\n"
> 				 "  <path ",
> 				 document->clip_id);
>-    _cairo_svg_surface_emit_path (document->xml_node_defs, path, NULL);
>+    _cairo_svg_surface_emit_path (document->xml_node_defs, path, NULL, 0);
> 
>     _cairo_output_stream_printf (document->xml_node_defs,
> 				 "/>\n"
>@@ -571,6 +665,8 @@ _cairo_svg_surface_store_page (cairo_svg_surface_t *surface)
>     cairo_int_status_t status;
>     unsigned int i;
> 
>+    _cairo_svg_end_text(surface);
>+
>     stream = _cairo_memory_stream_create ();
>     if (_cairo_output_stream_get_status (stream)) {
> 	status = _cairo_output_stream_destroy (stream);
>@@ -617,6 +713,8 @@ _cairo_svg_surface_show_page (void *abstract_surface)
> {
>     cairo_svg_surface_t *surface = abstract_surface;
> 
>+    _cairo_svg_end_text(surface);
>+
>     if (unlikely (_cairo_svg_surface_store_page (surface) == NULL))
> 	return _cairo_error (CAIRO_STATUS_NO_MEMORY);
> 
>@@ -646,6 +744,7 @@ _cairo_svg_surface_emit_transform (cairo_output_stream_t *output,
> typedef struct {
>     cairo_output_stream_t *output;
>     const cairo_matrix_t *ctm_inverse;
>+    double precision;
> } svg_path_info_t;
> 
> static cairo_status_t
>@@ -659,7 +758,8 @@ _cairo_svg_path_move_to (void *closure,
>     if (info->ctm_inverse)
> 	cairo_matrix_transform_point (info->ctm_inverse, &x, &y);
> 
>-    _cairo_output_stream_printf (info->output, "M %f %f ", x, y);
>+    _cairo_output_stream_printf (info->output, "M %f %f ",
>+    		_round(x, info->precision), _round(y, info->precision));
> 
>     return CAIRO_STATUS_SUCCESS;
> }
>@@ -675,7 +775,8 @@ _cairo_svg_path_line_to (void *closure,
>     if (info->ctm_inverse)
> 	cairo_matrix_transform_point (info->ctm_inverse, &x, &y);
> 
>-    _cairo_output_stream_printf (info->output, "L %f %f ", x, y);
>+    _cairo_output_stream_printf (info->output, "L %f %f ",
>+    		_round(x, info->precision), _round(y, info->precision));
> 
>     return CAIRO_STATUS_SUCCESS;
> }
>@@ -702,7 +803,7 @@ _cairo_svg_path_curve_to (void          *closure,
> 
>     _cairo_output_stream_printf (info->output,
> 				 "C %f %f %f %f %f %f ",
>-				 bx, by, cx, cy, dx, dy);
>+				 _round(bx, info->precision), _round(by, info->precision), _round(cx, info->precision), _round(cy, info->precision), _round(dx, info->precision), _round(dy, info->precision));
> 
>     return CAIRO_STATUS_SUCCESS;
> }
>@@ -720,7 +821,8 @@ _cairo_svg_path_close_path (void *closure)
> static void
> _cairo_svg_surface_emit_path (cairo_output_stream_t	*output,
> 			      const cairo_path_fixed_t	*path,
>-			      const cairo_matrix_t	*ctm_inverse)
>+			      const cairo_matrix_t	*ctm_inverse,
>+			      const double precision)
> {
>     cairo_status_t status;
>     svg_path_info_t info;
>@@ -729,6 +831,7 @@ _cairo_svg_surface_emit_path (cairo_output_stream_t	*output,
> 
>     info.output = output;
>     info.ctm_inverse = ctm_inverse;
>+    info.precision = precision;
>     status = _cairo_path_fixed_interpret (path,
> 					  _cairo_svg_path_move_to,
> 					  _cairo_svg_path_line_to,
>@@ -741,7 +844,7 @@ _cairo_svg_surface_emit_path (cairo_output_stream_t	*output,
> }
> 
> static cairo_int_status_t
>-_cairo_svg_document_emit_outline_glyph_data (cairo_svg_document_t	*document,
>+_cairo_svg_document_emit_outline_glyph_data (cairo_svg_font_output_t	*fontout,
> 					     cairo_scaled_font_t	*scaled_font,
> 					     unsigned long		 glyph_index)
> {
>@@ -756,20 +859,20 @@ _cairo_svg_document_emit_outline_glyph_data (cairo_svg_document_t	*document,
>     if (unlikely (status))
> 	return status;
> 
>-    _cairo_output_stream_printf (document->xml_node_glyphs,
>+    _cairo_output_stream_printf (fontout->xml_node_glyphs,
> 				 "<path style=\"stroke:none;\" ");
> 
>-    _cairo_svg_surface_emit_path (document->xml_node_glyphs,
>-				  scaled_glyph->path, NULL);
>+    _cairo_svg_surface_emit_path (fontout->xml_node_glyphs,
>+				  scaled_glyph->path, NULL, 0);
> 
>-    _cairo_output_stream_printf (document->xml_node_glyphs,
>+    _cairo_output_stream_printf (fontout->xml_node_glyphs,
> 				 "/>\n");
> 
>     return status;
> }
> 
> static cairo_int_status_t
>-_cairo_svg_document_emit_bitmap_glyph_data (cairo_svg_document_t	*document,
>+_cairo_svg_document_emit_bitmap_glyph_data (cairo_svg_font_output_t	*fontout,
> 					    cairo_scaled_font_t		*scaled_font,
> 					    unsigned long		 glyph_index)
> {
>@@ -794,24 +897,24 @@ _cairo_svg_document_emit_bitmap_glyph_data (cairo_svg_document_t	*document,
>     if (unlikely (status))
> 	return status;
> 
>-    _cairo_output_stream_printf (document->xml_node_glyphs, "<g");
>-    _cairo_svg_surface_emit_transform (document->xml_node_glyphs, " transform",
>+    _cairo_output_stream_printf (fontout->xml_node_glyphs, "<g");
>+    _cairo_svg_surface_emit_transform (fontout->xml_node_glyphs, " transform",
> 				       &image->base.device_transform_inverse, NULL);
>-    _cairo_output_stream_printf (document->xml_node_glyphs, ">/n");
>+    _cairo_output_stream_printf (fontout->xml_node_glyphs, ">/n");
> 
>     for (y = 0, row = image->data, rows = image->height; rows; row += image->stride, rows--, y++) {
> 	for (x = 0, byte = row, cols = (image->width + 7) / 8; cols; byte++, cols--) {
> 	    uint8_t output_byte = CAIRO_BITSWAP8_IF_LITTLE_ENDIAN (*byte);
> 	    for (bit = 7; bit >= 0 && x < image->width; bit--, x++) {
> 		if (output_byte & (1 << bit)) {
>-		    _cairo_output_stream_printf (document->xml_node_glyphs,
>+		    _cairo_output_stream_printf (fontout->xml_node_glyphs,
> 						 "<rect x=\"%d\" y=\"%d\" width=\"1\" height=\"1\"/>\n",
> 						 x, y);
> 		}
> 	    }
> 	}
>     }
>-    _cairo_output_stream_printf (document->xml_node_glyphs, "</g>\n");
>+    _cairo_output_stream_printf (fontout->xml_node_glyphs, "</g>\n");
> 
>     cairo_surface_destroy (&image->base);
> 
>@@ -819,7 +922,7 @@ _cairo_svg_document_emit_bitmap_glyph_data (cairo_svg_document_t	*document,
> }
> 
> static cairo_int_status_t
>-_cairo_svg_document_emit_glyph (cairo_svg_document_t	*document,
>+_cairo_svg_document_emit_glyph (cairo_svg_font_output_t	*fontout,
> 				cairo_scaled_font_t	*scaled_font,
> 				unsigned long		 scaled_font_glyph_index,
> 				unsigned int		 font_id,
>@@ -827,22 +930,22 @@ _cairo_svg_document_emit_glyph (cairo_svg_document_t	*document,
> {
>     cairo_int_status_t	     status;
> 
>-    _cairo_output_stream_printf (document->xml_node_glyphs,
>+    _cairo_output_stream_printf (fontout->xml_node_glyphs,
> 				 "<symbol overflow=\"visible\" id=\"glyph%d-%d\">\n",
> 				 font_id,
> 				 subset_glyph_index);
> 
>-    status = _cairo_svg_document_emit_outline_glyph_data (document,
>+    status = _cairo_svg_document_emit_outline_glyph_data (fontout,
> 							  scaled_font,
> 							  scaled_font_glyph_index);
>     if (status == CAIRO_INT_STATUS_UNSUPPORTED)
>-	status = _cairo_svg_document_emit_bitmap_glyph_data (document,
>+	status = _cairo_svg_document_emit_bitmap_glyph_data (fontout,
> 							     scaled_font,
> 							     scaled_font_glyph_index);
>     if (unlikely (status))
> 	return status;
> 
>-    _cairo_output_stream_printf (document->xml_node_glyphs, "</symbol>\n");
>+    _cairo_output_stream_printf (fontout->xml_node_glyphs, "</symbol>\n");
> 
>     return CAIRO_INT_STATUS_SUCCESS;
> }
>@@ -869,24 +972,183 @@ _cairo_svg_document_emit_font_subset (cairo_scaled_font_subset_t	*font_subset,
>     return status;
> }
> 
>+
>+static cairo_int_status_t
>+_cairo_svg_document_emit_outline_text_glyph_data (cairo_svg_font_output_t *fontout,
>+					     cairo_scaled_font_t	*scaled_font,
>+					     unsigned long		 glyph_index,
>+						const char* utf8)
>+{
>+    cairo_scaled_glyph_t *scaled_glyph;
>+    cairo_matrix_t matrix;
>+    cairo_int_status_t status = CAIRO_INT_STATUS_SUCCESS;
>+    long c;
>+    int len, i;
>+	double font_size;
>+	cairo_bool_t missing = FALSE;
>+
>+    status = _cairo_scaled_glyph_lookup (scaled_font,
>+					 glyph_index,
>+					 CAIRO_SCALED_GLYPH_INFO_METRICS|
>+					 CAIRO_SCALED_GLYPH_INFO_PATH,
>+					 &scaled_glyph);
>+    if (unlikely (status))
>+	return status;
>+
>+    font_size = scaled_font->font_matrix.xx;
>+    if (font_size == 0) {
>+    	font_size = -scaled_font->font_matrix.xy;
>+    }
>+
>+	if (utf8 == NULL || ((unsigned char)utf8[0] == (unsigned char)0xEF && (unsigned char)utf8[1] == (unsigned char)0xBF && (unsigned char)utf8[2] == (unsigned char)0xBF)) {
>+		if (scaled_glyph->x_advance) {
>+		    _cairo_output_stream_printf (fontout->xml_node_glyphs,
>+						 "<missing-glyph horiz-adv-x=\"%d\"><path ",
>+						 (int)(scaled_glyph->x_advance * 1000 / font_size));
>+		}
>+		else {
>+		    _cairo_output_stream_printf (fontout->xml_node_glyphs,
>+						 "<missing-glyph><path ");
>+		}
>+		missing = TRUE;
>+	}
>+	else {
>+		_cairo_output_stream_printf (fontout->xml_node_glyphs,
>+					 "<glyph unicode=\"");
>+		len = strlen(utf8);
>+		for (i = 0; i < len; i++) {
>+			if (utf8[i] == '<') {
>+				_cairo_output_stream_printf (fontout->xml_node_glyphs, "&lt;");
>+				continue;
>+			}
>+			if (utf8[i] == '>') {
>+				_cairo_output_stream_printf (fontout->xml_node_glyphs, "&gt;");
>+				continue;
>+			}
>+			if (utf8[i] == '&') {
>+				_cairo_output_stream_printf (fontout->xml_node_glyphs, "&amp;");
>+				continue;
>+			}
>+			if (utf8[i] == '\"') {
>+				_cairo_output_stream_printf (fontout->xml_node_glyphs, "&quot;");
>+				continue;
>+			}
>+			_cairo_output_stream_printf (fontout->xml_node_glyphs, "%c", utf8[i]);
>+		}
>+		if (scaled_glyph->x_advance) {
>+			_cairo_output_stream_printf (fontout->xml_node_glyphs,
>+						 "\" horiz-adv-x=\"%d\" ", (int)(scaled_glyph->x_advance * 1000 / font_size));
>+		}
>+		else {
>+			_cairo_output_stream_printf (fontout->xml_node_glyphs,
>+						 "\" ");
>+		}
>+	}
>+	cairo_matrix_init(&matrix, 1000 / font_size, 0, 0, -1000 / font_size, 0, 0);
>+
>+    _cairo_svg_surface_emit_path (fontout->xml_node_glyphs,
>+				  scaled_glyph->path, &matrix, 1);
>+
>+    if (missing) {
>+    	_cairo_output_stream_printf (fontout->xml_node_glyphs, "/></missing-glyph>\n");
>+    }
>+    else {
>+    	_cairo_output_stream_printf (fontout->xml_node_glyphs, "/>\n");
>+    }
>+    return status;
>+}
>+
>+static cairo_int_status_t
>+_cairo_svg_surface_emit_font_face (cairo_output_stream_t	*output,
>+		const cairo_scaled_font_subset_t *subset)
>+{
>+    _cairo_output_stream_printf (output,
>+				 " font-family=\"font%d\"", subset->font_id);
>+   _cairo_output_stream_printf (output,
>+				 " units-per-em=\"1000\"");
>+
>+    _cairo_output_stream_printf (output,
>+				 " ascent=\"1000\"");
>+    _cairo_output_stream_printf (output,
>+				 " descent=\"0\"");
>+
>+    return CAIRO_STATUS_SUCCESS;
>+}
>+
> static cairo_status_t
>-_cairo_svg_document_emit_font_subsets (cairo_svg_document_t *document)
>+_cairo_svg_document_emit_font_subset_text (cairo_scaled_font_subset_t	*font_subset,
>+				      void				*closure)
>+{
>+	cairo_svg_font_output_t *fontout = closure;
>+    unsigned int i;
>+    double font_size;
>+    cairo_status_t status = CAIRO_INT_STATUS_SUCCESS;
>+
>+    _cairo_scaled_font_freeze_cache (font_subset->scaled_font);
>+
>+    font_size = font_subset->scaled_font->font_matrix.xx;
>+    if (font_size == 0) {
>+    	font_size = -font_subset->scaled_font->font_matrix.xy;
>+    }
>+
>+    if (fontout->prev_font_id != font_subset->font_id) {
>+		if (fontout->prev_font_id != -1) {
>+			_cairo_output_stream_printf (fontout->xml_node_glyphs, "</font>\n");
>+		}
>+		fontout->prev_font_id = font_subset->font_id;
>+		_cairo_output_stream_printf (fontout->xml_node_glyphs,
>+						 "<font id=\"font-%d\" horiz-adv-x=\"1000\"",
>+						 font_subset->font_id);
>+		_cairo_output_stream_printf (fontout->xml_node_glyphs,
>+						 ">\n");
>+		_cairo_output_stream_printf (fontout->xml_node_glyphs,
>+						 "<font-face");
>+		_cairo_svg_surface_emit_font_face(fontout->xml_node_glyphs, font_subset);
>+		_cairo_output_stream_printf (fontout->xml_node_glyphs,
>+						 "/>\n");
>+    }
>+
>+	for (i = 0; i < font_subset->num_glyphs; i++) {
>+	status = _cairo_svg_document_emit_outline_text_glyph_data (fontout,
>+							 font_subset->scaled_font,
>+							 font_subset->glyphs[i],
>+							 font_subset->utf8[i]);
>+	if (unlikely (status))
>+		break;
>+	}
>+
>+	_cairo_scaled_font_thaw_cache (font_subset->scaled_font);
>+
>+    return status;
>+}
>+
>+static cairo_status_t
>+_cairo_svg_document_emit_font_subsets (cairo_svg_font_output_t *fontout,
>+		cairo_scaled_font_subsets_t*	font_text_subsets,
>+		cairo_scaled_font_subsets_t*	font_glyphs_subsets)
> {
>     cairo_status_t status;
> 
>-    status = _cairo_scaled_font_subsets_foreach_scaled (document->font_subsets,
>+     fontout->prev_font_id = -1;
>+    status = _cairo_scaled_font_subsets_foreach_unscaled (font_text_subsets,
>+                                                        _cairo_svg_document_emit_font_subset_text,
>+                                                        fontout);
>+	if (fontout->prev_font_id != -1) {
>+		_cairo_output_stream_printf (fontout->xml_node_glyphs, "</font>\n");
>+	}
>+
>+    if (unlikely (status))
>+    	return status;
>+
>+    status = _cairo_scaled_font_subsets_foreach_scaled (font_glyphs_subsets,
>                                                         _cairo_svg_document_emit_font_subset,
>-                                                        document);
>+                                                        fontout);
>     if (unlikely (status))
>-	goto FAIL;
>+    	return status;
> 
>-    status = _cairo_scaled_font_subsets_foreach_user (document->font_subsets,
>+    status = _cairo_scaled_font_subsets_foreach_user (font_glyphs_subsets,
> 						      _cairo_svg_document_emit_font_subset,
>-						      document);
>-
>-  FAIL:
>-    _cairo_scaled_font_subsets_destroy (document->font_subsets);
>-    document->font_subsets = NULL;
>+						      fontout);
> 
>     return status;
> }
>@@ -1207,7 +1469,8 @@ _cairo_svg_surface_emit_operator (cairo_output_stream_t *output,
> {
>     if (surface->document->svg_version >= CAIRO_SVG_VERSION_1_2 &&
> 	op != CAIRO_OPERATOR_OVER) {
>-	_cairo_output_stream_printf (output, " comp-op=\"%s\"", _cairo_svg_surface_operators[op]);
>+    	_cairo_output_stream_printf (output, " opacity=\".7\"");
>+    // miyabe FIXME_cairo_output_stream_printf (output, " comp-op=\"%s\"", _cairo_svg_surface_operators[op]);
> 	if (!_cairo_operator_bounded_by_source (op))
> 	   _cairo_output_stream_printf (output, " clip-to-self=\"true\"");
>     }
>@@ -1265,16 +1528,33 @@ _cairo_svg_surface_emit_attr_value (cairo_output_stream_t *stream,
> 	_cairo_output_stream_write (stream, q, p - q);
> }
> 
>+static cairo_int_status_t
>+_cairo_surface_image_func (cairo_svg_surface_t       *svg_surface,
>+			     cairo_surface_t       *surface)
>+{
>+	char filename[256];
>+	cairo_status_t status;
>+
>+	status = svg_surface->document->write_image_func(svg_surface->document->write_image_closure, surface, filename);
>+	if (status != CAIRO_INT_STATUS_UNSUPPORTED) {
>+		_cairo_svg_surface_emit_attr_value (svg_surface->document->xml_node_defs,
>+				    (const unsigned char*)filename, strlen(filename));
>+	}
>+	return status;
>+}
>+
> static cairo_status_t
>-_cairo_svg_surface_emit_surface (cairo_svg_document_t *document,
>+_cairo_svg_surface_emit_surface (cairo_svg_surface_t *svg_surface,
> 				 cairo_surface_t *surface)
> {
>+    cairo_svg_document_t *document;
>     cairo_rectangle_int_t extents;
>     cairo_bool_t is_bounded;
>     cairo_status_t status;
>     const unsigned char *uri;
>     unsigned long uri_len;
> 
>+	document = svg_surface->document;
>     if (_cairo_user_data_array_get_data (&surface->user_data,
> 					 (cairo_user_data_key_t *) document))
>     {
>@@ -1297,8 +1577,18 @@ _cairo_svg_surface_emit_surface (cairo_svg_document_t *document,
> 	_cairo_svg_surface_emit_attr_value (document->xml_node_defs,
> 					    uri, uri_len);
>     } else {
>-	status = _cairo_surface_base64_encode (surface,
>-					       document->xml_node_defs);
>+    	if (document->write_image_func != NULL) {
>+			status = _cairo_surface_image_func (svg_surface,
>+						   surface);
>+			if (unlikely (status))
>+			    return status;
>+		}
>+		if (document->write_image_func == NULL || status == CAIRO_INT_STATUS_UNSUPPORTED) {
>+			status = _cairo_surface_base64_encode (surface,
>+							       document->xml_node_defs);
>+			if (unlikely (status))
>+			    return status;
>+		}
> 	if (unlikely (status))
> 	    return status;
>     }
>@@ -1322,22 +1612,22 @@ _cairo_svg_surface_emit_composite_surface_pattern (cairo_output_stream_t   *outp
> {
>     cairo_status_t status;
>     cairo_matrix_t p2u;
>+	cairo_rectangle_int_t extents;
>+	cairo_bool_t is_bounded;
>+
>+	is_bounded = _cairo_surface_get_extents (pattern->surface, &extents);
> 
>     p2u = pattern->base.matrix;
>     status = cairo_matrix_invert (&p2u);
>     /* cairo_pattern_set_matrix ensures the matrix is invertible */
>     assert (status == CAIRO_STATUS_SUCCESS);
> 
>-    status = _cairo_svg_surface_emit_surface (svg_surface->document,
>+    status = _cairo_svg_surface_emit_surface (svg_surface,
> 					      pattern->surface);
>     if (unlikely (status))
> 	return status;
> 
>     if (pattern_id != invalid_pattern_id) {
>-	cairo_rectangle_int_t extents;
>-	cairo_bool_t is_bounded;
>-
>-	is_bounded = _cairo_surface_get_extents (pattern->surface, &extents);
> 	assert (is_bounded);
> 
> 	_cairo_output_stream_printf (output,
>@@ -1346,23 +1636,24 @@ _cairo_svg_surface_emit_composite_surface_pattern (cairo_output_stream_t   *outp
> 				     "width=\"%d\" height=\"%d\" ",
> 				     pattern_id,
> 				     extents.width, extents.height);
>-	_cairo_svg_surface_emit_transform (output,
>-					   " patternTransform",
>-					   &p2u, parent_matrix);
>-	_cairo_output_stream_printf (output, ">\n  ");
>+	_cairo_output_stream_printf (output, "x=\"%f\" y=\"%f\"",
>+			p2u.x0, p2u.y0);
>+	_cairo_output_stream_printf (output, ">\n");
>     }
> 
>     _cairo_output_stream_printf (output,
> 				 "<use xlink:href=\"#image%d\"",
> 				 pattern->surface->unique_id);
>+	_cairo_output_stream_printf (output, " transform=\"matrix(%f,%f,%f,%f,%f,%f)\"",
>+		     p2u.xx, p2u.yx,
>+		     p2u.xy, p2u.yy,
>+		     p2u.xx < 0 ? extents.width : 0,
>+		     p2u.yy < 0 ? extents.height : 0);
>     if (extra_attributes)
> 	_cairo_output_stream_printf (output, " %s", extra_attributes);
> 
>     if (pattern_id == invalid_pattern_id) {
> 	_cairo_svg_surface_emit_operator (output, svg_surface, op);
>-	_cairo_svg_surface_emit_transform (output,
>-					   " transform",
>-					   &p2u, parent_matrix);
>     }
>     _cairo_output_stream_printf (output, "/>\n");
> 
>@@ -1491,6 +1782,8 @@ _cairo_svg_surface_emit_composite_recording_pattern (cairo_output_stream_t	*outp
>     cairo_matrix_t p2u;
>     cairo_status_t status;
> 
>+    _cairo_svg_end_text(surface);
>+
>     p2u = pattern->base.matrix;
>     status = cairo_matrix_invert (&p2u);
>     /* cairo_pattern_set_matrix ensures the matrix is invertible */
>@@ -2048,12 +2341,41 @@ _cairo_svg_surface_emit_fill_style (cairo_output_stream_t	*output,
> 				    cairo_fill_rule_t		 fill_rule,
> 				    const cairo_matrix_t	*parent_matrix)
> {
>-    _cairo_output_stream_printf (output,
>+	cairo_svg_fill_style css_op;
>+	cairo_svg_fill_style *entry;
>+
>+	if (source->type == CAIRO_PATTERN_TYPE_SOLID) {
>+		css_op.id = 0;
>+		css_op.op = op;
>+		css_op.pattern = source;
>+		css_op.fill_rule = fill_rule;
>+		css_op.base.hash = _cairo_pattern_hash(css_op.pattern);
>+		css_op.base.hash = _cairo_hash_bytes(css_op.base.hash, &css_op.op, sizeof(css_op.op));
>+		css_op.base.hash = _cairo_hash_bytes(css_op.base.hash, &css_op.fill_rule, sizeof(css_op.fill_rule));
>+		entry = _cairo_hash_table_lookup(surface->document->fill_to_id, &css_op.base);
>+		if (entry) {
>+			_cairo_output_stream_printf (output, "f%d", entry->id);
>+			return CAIRO_STATUS_SUCCESS;
>+		}
>+		css_op.id = ++surface->document->style_id;
>+		entry = malloc(sizeof(css_op));
>+		*entry = css_op;
>+		_cairo_pattern_create_copy(&entry->pattern, entry->pattern);
>+		_cairo_hash_table_insert(surface->document->fill_to_id, entry);
>+	}
>+	else {
>+		css_op.id = ++surface->document->style_id;
>+	}
>+
>+	_cairo_output_stream_printf (surface->document->css, ".f%d {", css_op.id);
>+	_cairo_output_stream_printf (surface->document->css,
> 				 "fill-rule:%s;",
> 				 fill_rule == CAIRO_FILL_RULE_EVEN_ODD ?
> 				 "evenodd" : "nonzero");
>-    _cairo_svg_surface_emit_operator_for_style (output, surface, op);
>-    return _cairo_svg_surface_emit_pattern (surface, source, output, FALSE, parent_matrix);
>+	_cairo_svg_surface_emit_operator_for_style (surface->document->css, surface, op);
>+	_cairo_svg_surface_emit_pattern (surface, source, surface->document->css, FALSE, parent_matrix);
>+	_cairo_output_stream_printf (surface->document->css, "}\n");
>+	_cairo_output_stream_printf (output, "f%d", css_op.id);
> }
> 
> static cairo_status_t
>@@ -2067,6 +2389,32 @@ _cairo_svg_surface_emit_stroke_style (cairo_output_stream_t	   *output,
>     cairo_status_t status;
>     const char *line_cap, *line_join;
>     unsigned int i;
>+	cairo_svg_stroke_style css_op;
>+	cairo_svg_stroke_style *entry;
>+
>+	if (source->type == CAIRO_PATTERN_TYPE_SOLID) {
>+		css_op.id = 0;
>+		css_op.op = op;
>+		css_op.pattern = source;
>+		css_op.stroke_style = *stroke_style;
>+		css_op.base.hash = _cairo_pattern_hash(css_op.pattern);
>+		css_op.base.hash = _cairo_hash_bytes(css_op.base.hash, &css_op.op, sizeof(css_op.op));
>+		css_op.base.hash = _cairo_hash_bytes(css_op.base.hash, &css_op.stroke_style, sizeof(css_op.stroke_style));
>+		entry = _cairo_hash_table_lookup(surface->document->stroke_to_id, &css_op.base);
>+		if (entry) {
>+			_cairo_output_stream_printf (output, "s%d", entry->id);
>+			return CAIRO_STATUS_SUCCESS;
>+		}
>+		css_op.id = ++surface->document->style_id;
>+		entry = malloc(sizeof(css_op));
>+		*entry = css_op;
>+		_cairo_pattern_create_copy(&entry->pattern, entry->pattern);
>+		_cairo_hash_table_insert(surface->document->stroke_to_id, entry);
>+	}
>+	else {
>+		css_op.id = ++surface->document->style_id;
>+	}
>+	_cairo_output_stream_printf (surface->document->css, ".s%d {", css_op.id);
> 
>     switch (stroke_style->line_cap) {
> 	case CAIRO_LINE_CAP_BUTT:
>@@ -2096,7 +2444,7 @@ _cairo_svg_surface_emit_stroke_style (cairo_output_stream_t	   *output,
> 	    ASSERT_NOT_REACHED;
>     }
> 
>-    _cairo_output_stream_printf (output,
>+    _cairo_output_stream_printf (surface->document->css,
> 				 "stroke-width:%f;"
> 				 "stroke-linecap:%s;"
> 				 "stroke-linejoin:%s;",
>@@ -2104,33 +2452,36 @@ _cairo_svg_surface_emit_stroke_style (cairo_output_stream_t	   *output,
> 				 line_cap,
> 				 line_join);
> 
>-     status = _cairo_svg_surface_emit_pattern (surface, source, output, TRUE, parent_matrix);
>+     status = _cairo_svg_surface_emit_pattern (surface, source, surface->document->css, TRUE, parent_matrix);
>      if (unlikely (status))
> 	 return status;
> 
>-     _cairo_svg_surface_emit_operator_for_style (output, surface, op);
>+     _cairo_svg_surface_emit_operator_for_style (surface->document->css, surface, op);
> 
>     if (stroke_style->num_dashes > 0) {
>-	_cairo_output_stream_printf (output, "stroke-dasharray:");
>+	_cairo_output_stream_printf (surface->document->css, "stroke-dasharray:");
> 	for (i = 0; i < stroke_style->num_dashes; i++) {
>-	    _cairo_output_stream_printf (output, "%f",
>+	    _cairo_output_stream_printf (surface->document->css, "%f",
> 					 stroke_style->dash[i]);
> 	    if (i + 1 < stroke_style->num_dashes)
>-		_cairo_output_stream_printf (output, ",");
>+		_cairo_output_stream_printf (surface->document->css, ",");
> 	    else
>-		_cairo_output_stream_printf (output, ";");
>+		_cairo_output_stream_printf (surface->document->css, ";");
> 	}
> 	if (stroke_style->dash_offset != 0.0) {
>-	    _cairo_output_stream_printf (output,
>+	    _cairo_output_stream_printf (surface->document->css,
> 					 "stroke-dashoffset:%f;",
> 					 stroke_style->dash_offset);
> 	}
>     }
> 
>-    _cairo_output_stream_printf (output,
>+    _cairo_output_stream_printf (surface->document->css,
> 				 "stroke-miterlimit:%f;",
> 				 stroke_style->miter_limit);
> 
>+	_cairo_output_stream_printf (surface->document->css, "}\n");
>+	_cairo_output_stream_printf (output, "s%d", css_op.id);
>+
>     return CAIRO_STATUS_SUCCESS;
> }
> 
>@@ -2154,16 +2505,19 @@ _cairo_svg_surface_fill_stroke (void			*abstract_surface,
>     cairo_svg_surface_t *surface = abstract_surface;
>     cairo_status_t status;
> 
>+    _cairo_svg_end_text(surface);
>+
>     status = _cairo_surface_clipper_set_clip (&surface->clipper, clip);
>     if (unlikely (status))
> 	return status;
> 
>-    _cairo_output_stream_printf (surface->xml_node, "<path style=\"");
>+    _cairo_output_stream_printf (surface->xml_node, "<path class=\"");
>     status = _cairo_svg_surface_emit_fill_style (surface->xml_node, surface, fill_op,
> 						 fill_source, fill_rule, stroke_ctm_inverse);
>     if (unlikely (status))
> 	return status;
> 
>+    _cairo_output_stream_printf (surface->xml_node, " ");
>     status = _cairo_svg_surface_emit_stroke_style (surface->xml_node, surface, stroke_op,
> 						   stroke_source, stroke_style, stroke_ctm_inverse);
>     if (unlikely (status))
>@@ -2171,7 +2525,7 @@ _cairo_svg_surface_fill_stroke (void			*abstract_surface,
> 
>     _cairo_output_stream_printf (surface->xml_node, "\" ");
> 
>-    _cairo_svg_surface_emit_path (surface->xml_node, path, stroke_ctm_inverse);
>+    _cairo_svg_surface_emit_path (surface->xml_node, path, stroke_ctm_inverse, 0);
> 
>     _cairo_svg_surface_emit_transform (surface->xml_node, " transform", stroke_ctm, NULL);
>     _cairo_output_stream_printf (surface->xml_node, "/>\n");
>@@ -2195,20 +2549,22 @@ _cairo_svg_surface_fill (void			*abstract_surface,
>     if (surface->paginated_mode == CAIRO_PAGINATED_MODE_ANALYZE)
> 	return _cairo_svg_surface_analyze_operation (surface, op, source);
> 
>+    _cairo_svg_end_text(surface);
>+
>     assert (_cairo_svg_surface_operation_supported (surface, op, source));
> 
>     status = _cairo_surface_clipper_set_clip (&surface->clipper, clip);
>     if (unlikely (status))
> 	return status;
> 
>-    _cairo_output_stream_printf (surface->xml_node, "<path style=\" stroke:none;");
>+    _cairo_output_stream_printf (surface->xml_node, "<path style=\"stroke:none;\" class=\"");
>     status = _cairo_svg_surface_emit_fill_style (surface->xml_node, surface, op, source, fill_rule, NULL);
>     if (unlikely (status))
> 	return status;
> 
>     _cairo_output_stream_printf (surface->xml_node, "\" ");
> 
>-    _cairo_svg_surface_emit_path (surface->xml_node, path, NULL);
>+    _cairo_svg_surface_emit_path (surface->xml_node, path, NULL, 0);
> 
>     _cairo_output_stream_printf (surface->xml_node, "/>\n");
> 
>@@ -2283,6 +2639,8 @@ _cairo_svg_surface_paint (void		    *abstract_surface,
>     cairo_status_t status;
>     cairo_svg_surface_t *surface = abstract_surface;
> 
>+    _cairo_svg_end_text(surface);
>+
>     /* Emulation of clear and source operators, when no clipping region
>      * is defined. We just delete existing content of surface root node,
>      * and exit early if operator is clear.
>@@ -2376,6 +2734,8 @@ _cairo_svg_surface_mask (void		    *abstract_surface,
>     assert (_cairo_svg_surface_operation_supported (surface, op, source));
>     assert (_cairo_svg_surface_operation_supported (surface, CAIRO_OPERATOR_OVER, mask));
> 
>+    _cairo_svg_end_text(surface);
>+
>     status = _cairo_surface_clipper_set_clip (&surface->clipper, clip);
>     if (unlikely (status))
> 	return status;
>@@ -2450,11 +2810,13 @@ _cairo_svg_surface_stroke (void			*abstract_dst,
> 
>     assert (_cairo_svg_surface_operation_supported (surface, op, source));
> 
>+    _cairo_svg_end_text(surface);
>+
>     status = _cairo_surface_clipper_set_clip (&surface->clipper, clip);
>     if (unlikely (status))
> 	return status;
> 
>-    _cairo_output_stream_printf (surface->xml_node, "<path style=\"fill:none;");
>+    _cairo_output_stream_printf (surface->xml_node, "<path style=\"fill:none;\" class=\"");
>     status = _cairo_svg_surface_emit_stroke_style (surface->xml_node, surface, op,
> 						   source, stroke_style, ctm_inverse);
>     if (unlikely (status))
>@@ -2462,7 +2824,7 @@ _cairo_svg_surface_stroke (void			*abstract_dst,
> 
>     _cairo_output_stream_printf (surface->xml_node, "\" ");
> 
>-    _cairo_svg_surface_emit_path (surface->xml_node, path, ctm_inverse);
>+    _cairo_svg_surface_emit_path (surface->xml_node, path, ctm_inverse, 0);
> 
>     _cairo_svg_surface_emit_transform (surface->xml_node, " transform", ctm, NULL);
>     _cairo_output_stream_printf (surface->xml_node, "/>\n");
>@@ -2494,6 +2856,8 @@ _cairo_svg_surface_show_glyphs (void			*abstract_surface,
>     if (num_glyphs <= 0)
> 	return CAIRO_STATUS_SUCCESS;
> 
>+    _cairo_svg_end_text(surface);
>+
>     status = _cairo_surface_clipper_set_clip (&surface->clipper, clip);
>     if (unlikely (status))
> 	return status;
>@@ -2515,7 +2879,7 @@ _cairo_svg_surface_show_glyphs (void			*abstract_surface,
>     _cairo_output_stream_printf (surface->xml_node, "\">\n");
> 
>     for (i = 0; i < num_glyphs; i++) {
>-	status = _cairo_scaled_font_subsets_map_glyph (document->font_subsets,
>+	status = _cairo_scaled_font_subsets_map_glyph (document->font_glyphs_subsets,
> 						       scaled_font, glyphs[i].index,
> 						       NULL, 0,
>                                                        &subset_glyph);
>@@ -2576,6 +2940,263 @@ _cairo_svg_surface_get_font_options (void                  *abstract_surface,
>     _cairo_font_options_set_round_glyph_positions (options, CAIRO_ROUND_GLYPH_POS_OFF);
> }
> 
>+static cairo_bool_t
>+_cairo_svg_surface_has_show_text_glyphs	(void	*abstract_surface)
>+{
>+	cairo_svg_surface_t *surface = abstract_surface;
>+    return surface->document->support_text_glyphs;
>+}
>+
>+static void
>+_cairo_svg_end_text (cairo_svg_surface_t *surface)
>+{
>+	cairo_output_stream_t *output = surface->xml_node;
>+    if (surface->document->prev_style.scaled_font != NULL) {
>+		_cairo_output_stream_printf (output,
>+					 " x=\"");
>+    	_cairo_memory_stream_copy (surface->document->text_x, output);
>+		_cairo_output_stream_printf (output,
>+					 "\" y=\"");
>+    	_cairo_memory_stream_copy (surface->document->text_y, output);
>+		_cairo_output_stream_printf (output,
>+					 "\">");
>+		_cairo_memory_stream_copy (surface->document->text, output);
>+		_cairo_output_stream_printf (output,
>+					 "</text>\n");
>+
>+		surface->document->prev_style.scaled_font = (cairo_scaled_font_t*)NULL;
>+		_cairo_output_stream_destroy(surface->document->text_x);
>+		_cairo_output_stream_destroy(surface->document->text_y);
>+		_cairo_output_stream_destroy(surface->document->text);
>+    }
>+}
>+
>+static cairo_int_status_t
>+_cairo_svg_surface_emit_font_style (cairo_output_stream_t	*output,
>+				    cairo_svg_surface_t		*surface,
>+				    cairo_operator_t		op,
>+				    const cairo_pattern_t	*pattern,
>+				    const cairo_scaled_font_t	*scaled_font,
>+				    const cairo_scaled_font_subsets_glyph_t *subset_glyph)
>+{
>+    double font_size;
>+    cairo_status_t status;
>+
>+    font_size = scaled_font->font_matrix.xx;
>+    if (font_size == 0) {
>+    	font_size = -scaled_font->font_matrix.xy;
>+    }
>+    _cairo_output_stream_printf (output,
>+				 "font:%fpx font%d;", font_size, subset_glyph->font_id);
>+
>+    status = _cairo_svg_surface_emit_pattern (surface, pattern,
>+					      output, FALSE, NULL);
>+    if (unlikely (status))
>+	return status;
>+    _cairo_svg_surface_emit_operator_for_style (output, surface, op);
>+
>+    return CAIRO_STATUS_SUCCESS;
>+}
>+
>+static cairo_bool_t
>+_cairo_svg_surface_equal_font(const void *key_a, const void *key_b) {
>+	cairo_svg_font_style *style_a = (cairo_svg_font_style*)key_a;
>+	cairo_svg_font_style *style_b = (cairo_svg_font_style*)key_b;
>+	return style_a->op == style_b->op &&
>+			style_a->scaled_font == style_b->scaled_font &&
>+			_cairo_pattern_equal(style_a->pattern, style_b->pattern);
>+}
>+
>+static cairo_bool_t
>+_cairo_svg_surface_equal_fill(const void *key_a, const void *key_b) {
>+	cairo_svg_fill_style *op_a = (cairo_svg_fill_style*)key_a;
>+	cairo_svg_fill_style *op_b = (cairo_svg_fill_style*)key_b;
>+	return op_a->op == op_b->op &&
>+			_cairo_pattern_equal(op_a->pattern, op_b->pattern) &&
>+			op_a->fill_rule == op_b->fill_rule;
>+}
>+
>+static cairo_bool_t
>+_cairo_svg_surface_equal_stroke(const void *key_a, const void *key_b) {
>+	cairo_svg_stroke_style *op_a = (cairo_svg_stroke_style*)key_a;
>+	cairo_svg_stroke_style *op_b = (cairo_svg_stroke_style*)key_b;
>+	return op_a->op == op_b->op &&
>+			_cairo_pattern_equal(op_a->pattern, op_b->pattern) &&
>+			memcmp(&op_a->stroke_style, &op_b->stroke_style, sizeof(op_a->stroke_style)) == 0;
>+}
>+
>+static const char utf8_skip_data[256] = {
>+    1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
>+    1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
>+    1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
>+    1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
>+    1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
>+    1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
>+    2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,
>+    3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,4,4,4,4,4,4,4,4,5,5,5,5,6,6,1,1
>+};
>+
>+#define UTF8_NEXT_CHAR(p) ((p) + utf8_skip_data[*(unsigned char *)(p)])
>+
>+static cairo_int_status_t
>+_cairo_svg_surface_show_text_glyphs (void			*abstract_surface,
>+				     cairo_operator_t		 op,
>+				     const cairo_pattern_t	*pattern,
>+				     const char			*utf8,
>+				     int			 utf8_len,
>+				     cairo_glyph_t		*glyphs,
>+				     int			 num_glyphs,
>+				     const cairo_text_cluster_t *clusters,
>+				     int			 num_clusters,
>+				     cairo_text_cluster_flags_t	 cluster_flags,
>+				     cairo_scaled_font_t	*scaled_font,
>+				     cairo_clip_t		*clip)
>+{
>+    cairo_svg_surface_t *surface = abstract_surface;
>+    cairo_output_stream_t *output = surface->xml_node;
>+    cairo_scaled_font_subsets_t	*subsets = surface->document->font_text_subsets;
>+    cairo_status_t status;
>+    int i, j, k, l;
>+    double font_size, x, y;
>+    cairo_matrix_t matrix;
>+    cairo_svg_font_style style;
>+    cairo_svg_font_style *entry;
>+    cairo_scaled_font_subsets_glyph_t subset_glyph;
>+
>+    if (utf8_len == 0) {
>+    	return _cairo_svg_surface_show_glyphs(abstract_surface, op, pattern, glyphs, num_glyphs, scaled_font, clip);
>+    }
>+
>+    if (surface->paginated_mode == CAIRO_PAGINATED_MODE_ANALYZE)
>+	return _cairo_svg_surface_analyze_operation (surface, op, pattern);
>+
>+    assert (_cairo_svg_surface_operation_supported (surface, op, pattern));
>+
>+    if (num_glyphs <= 0)
>+	return CAIRO_STATUS_SUCCESS;
>+
>+    status = _cairo_surface_clipper_set_clip (&surface->clipper, clip);
>+    if (unlikely (status))
>+	return status;
>+
>+    j = k = 0;
>+    for (i = 0; i < num_clusters; ++i) {
>+ 		if (clusters[i].num_glyphs > 0)
>+    	status = _cairo_scaled_font_subsets_map_glyph (subsets,
>+							       scaled_font, glyphs[k].index,
>+							       &utf8[j], clusters[i].num_bytes, &subset_glyph);
>+		if (unlikely (status))
>+		    return status;
>+		j += clusters[i].num_bytes;
>+		k += clusters[i].num_glyphs;
>+    }
>+
>+    font_size = scaled_font->font_matrix.xx;
>+ 	if (font_size == 0) {
>+ 		font_size = -scaled_font->font_matrix.xy;
>+ 	}
>+
>+ 	i = l = 0;
>+    style.id = 0;
>+    style.op = op;
>+    style.scaled_font = scaled_font;
>+    style.pattern = pattern;
>+    style.base.hash = _cairo_pattern_hash(style.pattern);
>+    style.base.hash = _cairo_hash_bytes(style.base.hash, &style.op, sizeof(style.op));
>+    style.base.hash = _cairo_hash_bytes(style.base.hash, &style.scaled_font, sizeof(style.scaled_font));
>+    if (surface->document->prev_style.scaled_font == NULL ||
>+    	!_cairo_svg_surface_equal_font(&surface->document->prev_style, &style)) {
>+    	_cairo_svg_end_text(surface);
>+    	while(i < utf8_len && utf8[i] == 0x20) {
>+    		++i;
>+    		++l;
>+    	}
>+    	if (i == utf8_len) {
>+    		return status;
>+    	}
>+
>+    	entry = _cairo_hash_table_lookup(surface->document->font_to_id, &style.base);
>+    	if (!entry) {
>+    		style.id = ++surface->document->style_id;
>+			_cairo_output_stream_printf (surface->document->css, ".t%d {", surface->document->style_id);
>+			_cairo_svg_surface_emit_font_style(surface->document->css, surface, op, pattern, scaled_font, &subset_glyph);
>+			_cairo_output_stream_printf (surface->document->css, "}\n");
>+
>+			entry = malloc(sizeof(style));
>+			*entry = style;
>+			_cairo_pattern_create_copy(&entry->pattern, entry->pattern);
>+			_cairo_hash_table_insert(surface->document->font_to_id, entry);
>+    	}
>+    	else {
>+    		style.id = entry->id;
>+    	}
>+
>+		_cairo_output_stream_printf (output,
>+					 "<text class=\"t%d\"", style.id);
>+		surface->document->text_x = _cairo_memory_stream_create ();
>+		surface->document->text_y = _cairo_memory_stream_create ();
>+		surface->document->text = _cairo_memory_stream_create ();
>+		surface->document->prev_style = style;
>+
>+		matrix = scaled_font->scale;
>+		cairo_matrix_scale(&matrix, 1 / font_size, 1 / font_size);
>+		_cairo_svg_surface_emit_transform(output, " transform", &matrix, NULL);
>+		cairo_matrix_invert(&matrix);
>+
>+		x = glyphs[i].x;
>+		y = glyphs[i].y;
>+		cairo_matrix_transform_point(&matrix, &x, &y);
>+
>+	    _cairo_output_stream_printf (surface->document->text_x, "%f", x);
>+	    _cairo_output_stream_printf (surface->document->text_y, "%f", y);
>+	   ++i;
>+   }
>+    else {
>+ 		matrix = scaled_font->scale;
>+ 		cairo_matrix_scale(&matrix, 1 / font_size, 1 / font_size);
>+ 		cairo_matrix_invert(&matrix);
>+    }
>+    for (;i < num_glyphs; i++) {
>+		x = glyphs[i].x;
>+		y = glyphs[i].y;
>+		cairo_matrix_transform_point(&matrix, &x, &y);
>+		_cairo_output_stream_printf (surface->document->text_x, " %f", x);
>+		_cairo_output_stream_printf (surface->document->text_y, " %f", y);
>+    }
>+    for (i = l; i < utf8_len; i++) {
>+     	if (utf8[i] == '<') {
>+    		_cairo_output_stream_printf (surface->document->text, "&lt;");
>+    		continue;
>+    	}
>+    	if (utf8[i] == '>') {
>+    		_cairo_output_stream_printf (surface->document->text, "&gt;");
>+    		continue;
>+    	}
>+    	if (utf8[i] == '&') {
>+    		_cairo_output_stream_printf (surface->document->text, "&amp;");
>+    		continue;
>+    	}
>+		_cairo_output_stream_printf (surface->document->text, "%c", utf8[i]);
>+    }
>+    
>+    const unsigned char * const ustr = (const unsigned char *) utf8;
>+    const unsigned char *in = ustr;
>+    int n_chars = 0;
>+    while (ustr + utf8_len - in > 0) {
>+		n_chars++;
>+		in = UTF8_NEXT_CHAR (in);
>+    }
>+    if (n_chars != num_clusters)
>+    	_cairo_svg_end_text(surface);
>+
>+    // for XML space and Webkit performance.
>+    if (_cairo_memory_stream_length(surface->document->text)  >= 300) {
>+    	_cairo_svg_end_text(surface);
>+    }
>+
>+    return _cairo_output_stream_get_status (output);
>+}
>+
> static const cairo_surface_backend_t cairo_svg_surface_backend = {
> 	CAIRO_SURFACE_TYPE_SVG,
> 	_cairo_svg_surface_finish,
>@@ -2606,6 +3227,8 @@ static const cairo_surface_backend_t cairo_svg_surface_backend = {
> 	_cairo_svg_surface_fill,
> 	_cairo_svg_surface_fill_stroke,
> 	_cairo_svg_surface_show_glyphs,
>+	_cairo_svg_surface_has_show_text_glyphs,
>+	_cairo_svg_surface_show_text_glyphs,
> };
> 
> static cairo_status_t
>@@ -2625,9 +3248,16 @@ _cairo_svg_document_create (cairo_output_stream_t	 *output_stream,
>     if (unlikely (document == NULL))
> 	return _cairo_error (CAIRO_STATUS_NO_MEMORY);
> 
>-    /* The use of defs for font glyphs imposes no per-subset limit. */
>-    document->font_subsets = _cairo_scaled_font_subsets_create_scaled ();
>-    if (unlikely (document->font_subsets == NULL)) {
>+	/* The use of defs for font glyphs imposes no per-subset limit. */
>+	document->font_text_subsets = _cairo_scaled_font_subsets_create_simple ();
>+	if (unlikely (document->font_text_subsets == NULL)) {
>+	status = _cairo_error (CAIRO_STATUS_NO_MEMORY);
>+	goto CLEANUP_DOCUMENT;
>+	}
>+
>+	/* The use of defs for font glyphs imposes no per-subset limit. */
>+    document->font_glyphs_subsets = _cairo_scaled_font_subsets_create_scaled ();
>+    if (unlikely (document->font_glyphs_subsets == NULL)) {
> 	status = _cairo_error (CAIRO_STATUS_NO_MEMORY);
> 	goto CLEANUP_DOCUMENT;
>     }
>@@ -2639,6 +3269,23 @@ _cairo_svg_document_create (cairo_output_stream_t	 *output_stream,
>     document->width = width;
>     document->height = height;
> 
>+    document->write_image_func = NULL;
>+    document->write_image_closure = NULL;
>+
>+    document->style_id = 0;
>+    document->css = _cairo_memory_stream_create ();
>+    status = _cairo_output_stream_get_status (document->css);
>+    if (unlikely (status))
>+	goto CLEANUP_NODE_DEFS;
>+
>+    document->support_text_glyphs = FALSE;
>+
>+    document->prev_style.op = (cairo_operator_t)NULL;
>+    document->prev_style.scaled_font = (cairo_scaled_font_t*)NULL;
>+    document->font_to_id = _cairo_hash_table_create(_cairo_svg_surface_equal_font);
>+    document->fill_to_id = _cairo_hash_table_create(_cairo_svg_surface_equal_fill);
>+    document->stroke_to_id = _cairo_hash_table_create(_cairo_svg_surface_equal_stroke);
>+
>     document->linear_pattern_id = 0;
>     document->radial_pattern_id = 0;
>     document->pattern_id = 0;
>@@ -2651,11 +3298,6 @@ _cairo_svg_document_create (cairo_output_stream_t	 *output_stream,
>     if (unlikely (status))
> 	goto CLEANUP_NODE_DEFS;
> 
>-    document->xml_node_glyphs = _cairo_memory_stream_create ();
>-    status = _cairo_output_stream_get_status (document->xml_node_glyphs);
>-    if (unlikely (status))
>-	goto CLEANUP_NODE_GLYPHS;
>-
>     document->alpha_filter = FALSE;
> 
>     document->svg_version = version;
>@@ -2663,11 +3305,10 @@ _cairo_svg_document_create (cairo_output_stream_t	 *output_stream,
>     *document_out = document;
>     return CAIRO_STATUS_SUCCESS;
> 
>-  CLEANUP_NODE_GLYPHS:
>-    status_ignored = _cairo_output_stream_destroy (document->xml_node_glyphs);
>   CLEANUP_NODE_DEFS:
>     status_ignored = _cairo_output_stream_destroy (document->xml_node_defs);
>-    _cairo_scaled_font_subsets_destroy (document->font_subsets);
>+    _cairo_scaled_font_subsets_destroy (document->font_text_subsets);
>+    _cairo_scaled_font_subsets_destroy (document->font_glyphs_subsets);
>   CLEANUP_DOCUMENT:
>     free (document);
>     return status;
>@@ -2703,17 +3344,58 @@ _cairo_svg_document_destroy (cairo_svg_document_t *document)
>     return status;
> }
> 
>+static void
>+_cairo_svg_surface_font_pluck (void *_entry, void *dict)
>+{
>+	cairo_svg_font_style *entry = (cairo_svg_font_style*)_entry;
>+	_cairo_hash_table_remove (dict, &entry->base);
>+	cairo_pattern_destroy(entry->pattern);
>+    free(entry);
>+}
>+
>+static void
>+_cairo_svg_surface_fill_pluck (void *_entry, void *dict)
>+{
>+	cairo_svg_fill_style *entry = (cairo_svg_fill_style*)_entry;
>+	_cairo_hash_table_remove (dict, &entry->base);
>+	cairo_pattern_destroy(entry->pattern);
>+    free(entry);
>+}
>+
>+static void
>+_cairo_svg_surface_stroke_pluck (void *_entry, void *dict)
>+{
>+	cairo_svg_stroke_style *entry = (cairo_svg_stroke_style*)_entry;
>+	_cairo_hash_table_remove (dict, &entry->base);
>+	cairo_pattern_destroy(entry->pattern);
>+    free(entry);
>+}
>+
> static cairo_status_t
> _cairo_svg_document_finish (cairo_svg_document_t *document)
> {
>     cairo_status_t status, status2;
>     cairo_output_stream_t *output = document->output_stream;
>     cairo_svg_page_t *page;
>+    cairo_svg_font_output_t fontout;
>     unsigned int i;
> 
>     if (document->finished)
> 	return CAIRO_STATUS_SUCCESS;
> 
>+    _cairo_hash_table_foreach (document->font_to_id,
>+    				_cairo_svg_surface_font_pluck,
>+    				document->font_to_id);
>+    _cairo_hash_table_destroy(document->font_to_id);
>+    _cairo_hash_table_foreach (document->fill_to_id,
>+    				_cairo_svg_surface_fill_pluck,
>+    				document->fill_to_id);
>+    _cairo_hash_table_destroy(document->fill_to_id);
>+    _cairo_hash_table_foreach (document->stroke_to_id,
>+    				_cairo_svg_surface_stroke_pluck,
>+    				document->stroke_to_id);
>+    _cairo_hash_table_destroy(document->stroke_to_id);
>+
>     /*
>      * Should we add DOCTYPE?
>      *
>@@ -2746,14 +3428,34 @@ _cairo_svg_document_finish (cairo_svg_document_t *document)
> 				 document->width, document->height,
> 				 _cairo_svg_internal_version_strings [document->svg_version]);
> 
>-    status = _cairo_svg_document_emit_font_subsets (document);
>+    fontout.prev_font_id = -1;
>+    fontout.xml_node_glyphs = _cairo_memory_stream_create ();
>+    status = _cairo_output_stream_get_status (fontout.xml_node_glyphs);
>+    if (unlikely (status))
>+	goto CLEANUP_NODE_GLYPHS;
>+
>+    status = _cairo_svg_document_emit_font_subsets (&fontout,
>+    		document->font_text_subsets, document->font_glyphs_subsets);
> 
>-    if (_cairo_memory_stream_length (document->xml_node_glyphs) > 0 ||
>+    if (unlikely (status)) {
>+      _cairo_scaled_font_subsets_destroy (document->font_text_subsets);
>+      document->font_text_subsets = NULL;
>+      _cairo_scaled_font_subsets_destroy (document->font_glyphs_subsets);
>+      document->font_glyphs_subsets = NULL;
>+    }
>+
>+	if (_cairo_memory_stream_length (document->css) > 0) {
>+		_cairo_output_stream_printf (output, "<style type=\"text/css\">\n");
>+		_cairo_memory_stream_copy (document->css, output);
>+		_cairo_output_stream_printf (output, "</style>\n");
>+	}
>+
>+    if (_cairo_memory_stream_length (fontout.xml_node_glyphs) > 0 ||
> 	_cairo_memory_stream_length (document->xml_node_defs) > 0) {
> 	_cairo_output_stream_printf (output, "<defs>\n");
>-	if (_cairo_memory_stream_length (document->xml_node_glyphs) > 0) {
>+	if (_cairo_memory_stream_length (fontout.xml_node_glyphs) > 0) {
> 	    _cairo_output_stream_printf (output, "<g>\n");
>-	    _cairo_memory_stream_copy (document->xml_node_glyphs, output);
>+	    _cairo_memory_stream_copy (fontout.xml_node_glyphs, output);
> 	    _cairo_output_stream_printf (output, "</g>\n");
> 	}
> 	_cairo_memory_stream_copy (document->xml_node_defs, output);
>@@ -2797,7 +3499,7 @@ _cairo_svg_document_finish (cairo_svg_document_t *document)
> 
>     _cairo_output_stream_printf (output, "</svg>\n");
> 
>-    status2 = _cairo_output_stream_destroy (document->xml_node_glyphs);
>+    status2 = _cairo_output_stream_destroy (document->css);
>     if (status == CAIRO_STATUS_SUCCESS)
> 	status = status2;
> 
>@@ -2809,6 +3511,11 @@ _cairo_svg_document_finish (cairo_svg_document_t *document)
>     if (status == CAIRO_STATUS_SUCCESS)
> 	status = status2;
> 
>+    CLEANUP_NODE_GLYPHS:
>+    status2 = _cairo_output_stream_destroy (fontout.xml_node_glyphs);
>+    if (status == CAIRO_STATUS_SUCCESS)
>+	status = status2;
>+
>     document->finished = TRUE;
> 
>     return status;
>diff --git src/cairo-svg.h src/cairo-svg.h
>index 0f739fc..a08a4cf 100644
>--- src/cairo-svg.h
>+++ src/cairo-svg.h
>@@ -51,6 +51,10 @@ typedef enum _cairo_svg_version {
>     CAIRO_SVG_VERSION_1_2
> } cairo_svg_version_t;
> 
>+typedef cairo_status_t (*cairo_write_image_func_t) (void		  *closure,
>+					      cairo_surface_t *surface,
>+						  char *filename);
>+
> cairo_public cairo_surface_t *
> cairo_svg_surface_create (const char   *filename,
> 			  double	width_in_points,
>@@ -73,6 +77,15 @@ cairo_svg_get_versions (cairo_svg_version_t const	**versions,
> cairo_public const char *
> cairo_svg_version_to_string (cairo_svg_version_t version);
> 
>+cairo_public void
>+cairo_svg_set_support_text_glyphs (cairo_surface_t 		*surface,
>+	       cairo_bool_t  	 support_text_glyphs);
>+
>+cairo_public void
>+cairo_svg_surface_set_write_image_func (cairo_surface_t 		*surface,
>+						cairo_write_image_func_t 		write_image_func,
>+						void  	 *write_image_closure);
>+
> CAIRO_END_DECLS
> 
> #else  /* CAIRO_HAS_SVG_SURFACE */
>diff --git test/reference/hatchings.ref.png test/reference/hatchings.ref.png
>index 3b34e5c..449d040 100644
>Binary files test/reference/hatchings.ref.png and test/reference/hatchings.ref.png differ
>diff --git test/reference/twin-antialias-none.ref.png test/reference/twin-antialias-none.ref.png
>index 42f386d..d00e501 100644
>Binary files test/reference/twin-antialias-none.ref.png and test/reference/twin-antialias-none.ref.png differ

Actions: View | Splinter Review

Attachments on bug 38516: 48224 | 51255 | 51257 | 51287 | 51402

Use of freedesktop.org services, including Bugzilla, is subject to our Code of Conduct. How we collect and use information is described in our Privacy Policy.