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

  */
 #include "cairoint.h"
+#include "cairo-analysis-surface-private.h"
 #include "cairo-box-inline.h"
-#include "cairo-analysis-surface-private.h"
+#include "cairo-default-context-private.h"
 #include "cairo-error-private.h"
+#include "cairo-paginated-private.h"
-#include "cairo-paginated-private.h"
+#include "cairo-recording-surface-inline.h"
-#include "cairo-recording-surface-private.h"
+#include "cairo-surface-snapshot-inline.h"
-#include "cairo-surface-subsurface-private.h"
+#include "cairo-surface-subsurface-inline.h"
 #include "cairo-region-private.h"
 cairo_int_status_t
 _cairo_analysis_surface_merge_status (cairo_int_status_t status_a,
 				      cairo_int_status_t status_b)
+{
     /* fatal errors should be checked and propagated at source */
-    assert (! _cairo_status_is_error (status_a));
+    assert (! _cairo_int_status_is_error (status_a));
-    assert (! _cairo_status_is_error (status_b));
+    assert (! _cairo_int_status_is_error (status_b));
     /* return the most important status */
     if (status_a == CAIRO_INT_STATUS_UNSUPPORTED ||
 	status_b == CAIRO_INT_STATUS_UNSUPPORTED)
     if (status_a == CAIRO_INT_STATUS_FLATTEN_TRANSPARENCY ||
 	status_b == CAIRO_INT_STATUS_FLATTEN_TRANSPARENCY)
 	return CAIRO_INT_STATUS_FLATTEN_TRANSPARENCY;
     /* at this point we have checked all the valid internal codes, so... */
-    assert (status_a == CAIRO_STATUS_SUCCESS &&
+    assert (status_a == CAIRO_INT_STATUS_SUCCESS &&
+	    status_b == CAIRO_INT_STATUS_SUCCESS);
+    return CAIRO_INT_STATUS_SUCCESS;
+}
+struct proxy {
+    cairo_surface_t base;
+    cairo_surface_t *target;
+};
+static cairo_status_t
-	    status_b == CAIRO_STATUS_SUCCESS);
+proxy_finish (void *abstract_surface)
+{
+    return CAIRO_STATUS_SUCCESS;
+}
+static const cairo_surface_backend_t proxy_backend  = {
+    CAIRO_INTERNAL_SURFACE_TYPE_NULL,
+    proxy_finish,
+};
+static cairo_surface_t *
+attach_proxy (cairo_surface_t *source,
+	      cairo_surface_t *target)
+{
+    struct proxy *proxy;
+    proxy = malloc (sizeof (*proxy));
+    if (unlikely (proxy == NULL))
+	return _cairo_surface_create_in_error (CAIRO_STATUS_NO_MEMORY);
+    _cairo_surface_init (&proxy->base, &proxy_backend, NULL, target->content);
+    proxy->target = target;
+    _cairo_surface_attach_snapshot (source, &proxy->base, NULL);
+    return &proxy->base;
+}
+static void
+detach_proxy (cairo_surface_t *proxy)
+{
+    cairo_surface_finish (proxy);
-    return CAIRO_STATUS_SUCCESS;
+    cairo_surface_destroy (proxy);
+}
 static cairo_int_status_t
 _analyze_recording_surface_pattern (cairo_analysis_surface_t *surface,
 				    const cairo_pattern_t    *pattern)
 {
     const cairo_surface_pattern_t *surface_pattern;
-    cairo_bool_t old_has_ctm;
+    cairo_analysis_surface_t *tmp;
-    cairo_matrix_t old_ctm, p2d;
+    cairo_surface_t *source, *proxy;
-    cairo_status_t status;
+    cairo_matrix_t p2d;
-    cairo_surface_t *source;
+    cairo_status_t status, analysis_status;
+    assert (pattern->type == CAIRO_PATTERN_TYPE_SURFACE);
+    surface_pattern = (const cairo_surface_pattern_t *) pattern;
+    assert (surface_pattern->surface->type == CAIRO_SURFACE_TYPE_RECORDING);
+    source = surface_pattern->surface;
+    proxy = _cairo_surface_has_snapshot (source, &proxy_backend);
+    if (proxy != NULL) {
-    assert (pattern->type == CAIRO_PATTERN_TYPE_SURFACE);
+	/* nothing untoward found so far */
+	return CAIRO_STATUS_SUCCESS;
+    }
-    surface_pattern = (const cairo_surface_pattern_t *) pattern;
+    tmp = (cairo_analysis_surface_t *)
-    assert (surface_pattern->surface->type == CAIRO_SURFACE_TYPE_RECORDING);
+	_cairo_analysis_surface_create (surface->target);
     if (unlikely (tmp->base.status))
-    old_ctm = surface->ctm;
+	return tmp->base.status;
-    old_has_ctm = surface->has_ctm;
+    proxy = attach_proxy (source, &tmp->base);
-    p2d = pattern->matrix;
-    status = cairo_matrix_invert (&p2d);
-    assert (status == CAIRO_STATUS_SUCCESS);
-    cairo_matrix_multiply (&surface->ctm, &p2d, &surface->ctm);
-    surface->has_ctm = ! _cairo_matrix_is_identity (&surface->ctm);
+    p2d = pattern->matrix;
+    status = cairo_matrix_invert (&p2d);
+    assert (status == CAIRO_STATUS_SUCCESS);
-    source = surface_pattern->surface;
-    if (source->backend->type == CAIRO_SURFACE_TYPE_SUBSURFACE) {
+    cairo_matrix_multiply (&tmp->ctm, &p2d, &surface->ctm);
+    tmp->has_ctm = ! _cairo_matrix_is_identity (&tmp->ctm);
 	cairo_surface_subsurface_t *sub = (cairo_surface_subsurface_t *) source;
+    source = _cairo_surface_get_source (source, NULL);
+    status = _cairo_recording_surface_replay_and_create_regions (source,
-	source = sub->target;
+								 &tmp->base);
     analysis_status = tmp->has_unsupported ? CAIRO_INT_STATUS_IMAGE_FALLBACK : CAIRO_INT_STATUS_SUCCESS;
     detach_proxy (proxy);
-    status = _cairo_recording_surface_replay_and_create_regions (source, &surface->base);
+    cairo_surface_destroy (&tmp->base);
     if (rect->width == 0 || rect->height == 0) {
 	/* Even though the operation is not visible we must be careful
 	 * to not allow unsupported operations to be replayed to the
 	 * backend during CAIRO_PAGINATED_MODE_RENDER */
-	if (backend_status == CAIRO_STATUS_SUCCESS ||
+	if (backend_status == CAIRO_INT_STATUS_SUCCESS ||
+	    backend_status == CAIRO_INT_STATUS_FLATTEN_TRANSPARENCY ||
-	    backend_status == CAIRO_INT_STATUS_FLATTEN_TRANSPARENCY)
+	    backend_status == CAIRO_INT_STATUS_NOTHING_TO_DO)
 	{
-	    return CAIRO_STATUS_SUCCESS;
+	    return CAIRO_INT_STATUS_SUCCESS;
+	}
 	else
+	{
 	    return CAIRO_INT_STATUS_IMAGE_FALLBACK;
 	int tx, ty;
 	if (_cairo_matrix_is_integer_translation (&surface->ctm, &tx, &ty)) {
 	    rect->x += tx;
+	    rect->y += ty;
+	    tx = _cairo_fixed_from_int (tx);
+	    bbox.p1.x += tx;
+	    bbox.p2.x += tx;
+	    ty = _cairo_fixed_from_int (ty);
+	    bbox.p1.y += ty;
-	    rect->y += ty;
+	    bbox.p2.y += ty;
 	} else {
 	    _cairo_matrix_transform_bounding_box_fixed (&surface->ctm,
 							&bbox, NULL);
 	    if (bbox.p1.x == bbox.p2.x || bbox.p1.y == bbox.p2.y) {
 		/* Even though the operation is not visible we must be
 		 * careful to not allow unsupported operations to be
 		 * replayed to the backend during
 		 * CAIRO_PAGINATED_MODE_RENDER */
+		if (backend_status == CAIRO_INT_STATUS_SUCCESS ||
-		if (backend_status == CAIRO_STATUS_SUCCESS ||
+		    backend_status == CAIRO_INT_STATUS_FLATTEN_TRANSPARENCY ||
-		    backend_status == CAIRO_INT_STATUS_FLATTEN_TRANSPARENCY)
+		    backend_status == CAIRO_INT_STATUS_NOTHING_TO_DO)
+		{
-		    return CAIRO_STATUS_SUCCESS;
+		    return CAIRO_INT_STATUS_SUCCESS;
+		}
 		else
+		{
+    }
     if (surface->first_op) {
 	surface->first_op = FALSE;
 	surface->page_bbox = bbox;
-    } else {
-	if (bbox.p1.x < surface->page_bbox.p1.x)
-	    surface->page_bbox.p1.x = bbox.p1.x;
-	if (bbox.p1.y < surface->page_bbox.p1.y)
-	    surface->page_bbox.p1.y = bbox.p1.y;
+    } else
-	if (bbox.p2.x > surface->page_bbox.p2.x)
-	    surface->page_bbox.p2.x = bbox.p2.x;
-	if (bbox.p2.y > surface->page_bbox.p2.y)
-	    surface->page_bbox.p2.y = bbox.p2.y;
 	_cairo_box_add_box(&surface->page_bbox, &bbox);
     /* If the operation is completely enclosed within the fallback
      * region there is no benefit in emitting a native operation as
 	 * not intersect any other native operation, the operation is
 	 * natively supported and the backend will blend the
 	 * transparency into the white background.
 	 */
 	if (cairo_region_contains_rectangle (&surface->supported_region, rect) == CAIRO_REGION_OVERLAP_OUT)
-	    backend_status = CAIRO_STATUS_SUCCESS;
+	    backend_status = CAIRO_INT_STATUS_SUCCESS;
+    }
-    if (backend_status == CAIRO_STATUS_SUCCESS) {
+    if (backend_status == CAIRO_INT_STATUS_SUCCESS) {
 	/* Add the operation to the supported region. Operations in
 	 * this region will be emitted as native operations.
 	 */
 	surface->has_supported = TRUE;
      * unsupported operations to the recording surface as using
      * CAIRO_INT_STATUS_UNSUPPORTED would cause cairo-surface to
      * invoke the cairo-surface-fallback path then return
      * CAIRO_STATUS_SUCCESS.
      */
-    if (status == CAIRO_STATUS_SUCCESS)
+    if (status == CAIRO_INT_STATUS_SUCCESS)
 	return CAIRO_INT_STATUS_IMAGE_FALLBACK;
     else
 	return status;
+}
     return _cairo_surface_get_extents (surface->target, rectangle);
+}
 static void
-_rectangle_intersect_clip (cairo_rectangle_int_t *extents, cairo_clip_t *clip)
-{
-    const cairo_rectangle_int_t *clip_extents;
-    cairo_bool_t is_empty;
 _rectangle_intersect_clip (cairo_rectangle_int_t *extents, const cairo_clip_t *clip)
-    clip_extents = NULL;
-    if (clip != NULL)
-	clip_extents = _cairo_clip_get_extents (clip);
+{
-    if (clip_extents != NULL)
+    if (clip != NULL)
-	is_empty = _cairo_rectangle_intersect (extents, clip_extents);
+	_cairo_rectangle_intersect (extents, _cairo_clip_get_extents (clip));
+}
 static void
 _cairo_analysis_surface_operation_extents (cairo_analysis_surface_t *surface,
 					   cairo_operator_t op,
 					   const cairo_pattern_t *source,
-					   cairo_clip_t *clip,
+					   const cairo_clip_t *clip,
 					   cairo_rectangle_int_t *extents)
+{
     cairo_bool_t is_empty;
     is_empty = _cairo_surface_get_extents (&surface->base, extents);
     if (_cairo_operator_bounded_by_source (op)) {
 	cairo_rectangle_int_t source_extents;
 	_cairo_pattern_get_extents (source, &source_extents);
-	is_empty = _cairo_rectangle_intersect (extents, &source_extents);
+	_cairo_rectangle_intersect (extents, &source_extents);
+    }
     _rectangle_intersect_clip (extents, clip);
+}
 static cairo_int_status_t
 _cairo_analysis_surface_paint (void			*abstract_surface,
 			       cairo_operator_t		op,
 			       const cairo_pattern_t	*source,
-			       cairo_clip_t		*clip)
+			       const cairo_clip_t		*clip)
+{
     cairo_analysis_surface_t *surface = abstract_surface;
-    cairo_status_t	     backend_status;
+    cairo_int_status_t	     backend_status;
     cairo_rectangle_int_t  extents;
     if (surface->target->backend->paint == NULL) {
 	backend_status = CAIRO_INT_STATUS_UNSUPPORTED;
 static cairo_int_status_t
 _cairo_analysis_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_analysis_surface_t *surface = abstract_surface;
     cairo_int_status_t	      backend_status;
     cairo_rectangle_int_t   extents;
-    cairo_bool_t is_empty;
     if (surface->target->backend->mask == NULL) {
 	backend_status = CAIRO_INT_STATUS_UNSUPPORTED;
     } else {
 	backend_status =
 	    surface->target->backend->mask (surface->target,
 					    op, source, mask, clip);
-	if (_cairo_status_is_error (backend_status))
+	if (_cairo_int_status_is_error (backend_status))
 	    return backend_status;
+    }
     if (backend_status == CAIRO_INT_STATUS_ANALYZE_RECORDING_SURFACE_PATTERN) {
 	cairo_int_status_t backend_source_status = CAIRO_STATUS_SUCCESS;
 	cairo_int_status_t backend_mask_status = CAIRO_STATUS_SUCCESS;
+	if (source->type == CAIRO_PATTERN_TYPE_SURFACE) {
-	if (source->type == CAIRO_PATTERN_TYPE_SURFACE) {
+	    cairo_surface_t *src_surface = ((cairo_surface_pattern_t *)source)->surface;
-	    const cairo_surface_pattern_t *surface_pattern = (const cairo_surface_pattern_t *) source;
+	    src_surface = _cairo_surface_get_source (src_surface, NULL);
-	    if (_cairo_surface_is_recording (surface_pattern->surface)) {
+	    if (_cairo_surface_is_recording (src_surface)) {
 		backend_source_status =
 		    _analyze_recording_surface_pattern (surface, source);
-		if (_cairo_status_is_error (backend_source_status))
+		if (_cairo_int_status_is_error (backend_source_status))
 		    return backend_source_status;
 	    }
+	}
-	}
 	if (mask->type == CAIRO_PATTERN_TYPE_SURFACE) {
-	if (mask->type == CAIRO_PATTERN_TYPE_SURFACE) {
+	    cairo_surface_t *mask_surface = ((cairo_surface_pattern_t *)mask)->surface;
-	    cairo_surface_pattern_t *surface_pattern = (cairo_surface_pattern_t *) mask;
+	    mask_surface = _cairo_surface_get_source (mask_surface, NULL);
-	    if (_cairo_surface_is_recording (surface_pattern->surface)) {
+	    if (_cairo_surface_is_recording (mask_surface)) {
 		backend_mask_status =
 		    _analyze_recording_surface_pattern (surface, mask);
-		if (_cairo_status_is_error (backend_mask_status))
+		if (_cairo_int_status_is_error (backend_mask_status))
     if (_cairo_operator_bounded_by_mask (op)) {
 	cairo_rectangle_int_t mask_extents;
-	_cairo_pattern_get_extents (mask, &mask_extents);
-	is_empty = _cairo_rectangle_intersect (&extents, &mask_extents);
+	_cairo_pattern_get_extents (mask, &mask_extents);
 	_cairo_rectangle_intersect (&extents, &mask_extents);
+    }
     return _add_operation (surface, &extents, backend_status);
+}
 static cairo_int_status_t
 _cairo_analysis_surface_stroke (void			*abstract_surface,
 				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	*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_analysis_surface_t *surface = abstract_surface;
-    cairo_status_t	     backend_status;
+    cairo_analysis_surface_t *surface = abstract_surface;
-    cairo_rectangle_int_t    extents;
+    cairo_int_status_t	     backend_status;
-    cairo_bool_t             is_empty;
+    cairo_rectangle_int_t    extents;
     if (surface->target->backend->stroke == NULL) {
 	backend_status = CAIRO_INT_STATUS_UNSUPPORTED;
     } else {
 	backend_status =
 	    surface->target->backend->stroke (surface->target, op,
 					      source, path, style,
 					      ctm, ctm_inverse,
 					      tolerance, antialias,
 					      clip);
 					       op, source, clip,
 					       &extents);
     if (_cairo_operator_bounded_by_mask (op)) {
 	cairo_rectangle_int_t mask_extents;
-	cairo_status_t status;
+	cairo_int_status_t status;
 	status = _cairo_path_fixed_stroke_extents (path, style,
 						   ctm, ctm_inverse,
 						   tolerance,
 						   &mask_extents);
 	if (unlikely (status))
 	    return status;
-	is_empty = _cairo_rectangle_intersect (&extents, &mask_extents);
+	_cairo_rectangle_intersect (&extents, &mask_extents);
+    }
     return _add_operation (surface, &extents, backend_status);
+}
 static cairo_int_status_t
 _cairo_analysis_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_analysis_surface_t *surface = abstract_surface;
-    cairo_status_t	     backend_status;
+    cairo_analysis_surface_t *surface = abstract_surface;
-    cairo_rectangle_int_t    extents;
+    cairo_int_status_t	     backend_status;
-    cairo_bool_t             is_empty;
+    cairo_rectangle_int_t    extents;
     if (surface->target->backend->fill == NULL) {
 	backend_status = CAIRO_INT_STATUS_UNSUPPORTED;
     } else {
 	backend_status =
 	    surface->target->backend->fill (surface->target, op,
 					    source, path, fill_rule,
 					    tolerance, antialias,
 	cairo_rectangle_int_t mask_extents;
 	_cairo_path_fixed_fill_extents (path, fill_rule, tolerance,
 					&mask_extents);
-	is_empty = _cairo_rectangle_intersect (&extents, &mask_extents);
+	_cairo_rectangle_intersect (&extents, &mask_extents);
+    }
 				     cairo_operator_t	   op,
 				     const cairo_pattern_t *source,
 				     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_analysis_surface_t *surface = abstract_surface;
-    cairo_status_t	     status, backend_status;
+    cairo_int_status_t	     status, backend_status;
     cairo_rectangle_int_t    extents, glyph_extents;
-    cairo_bool_t             is_empty;
     /* Adapted from _cairo_surface_show_glyphs */
     if (surface->target->backend->show_glyphs != NULL) {
 	backend_status =
 	    surface->target->backend->show_glyphs (surface->target, op,
 						   source,
 						   glyphs, num_glyphs,
 						   scaled_font,
-						   clip,
-						   remaining_glyphs);
+						   clip);
-	if (_cairo_status_is_error (backend_status))
+	if (_cairo_int_status_is_error (backend_status))
 	    return backend_status;
+    }
     else if (surface->target->backend->show_text_glyphs != NULL)
+    {
 							glyphs, num_glyphs,
 							NULL, 0,
 							FALSE,
 							scaled_font,
 							clip);
-	if (_cairo_status_is_error (backend_status))
+	if (_cairo_int_status_is_error (backend_status))
 	    return backend_status;
+    }
     else
+    {
 	backend_status = CAIRO_INT_STATUS_UNSUPPORTED;
 							  &glyph_extents,
 							  NULL);
 	if (unlikely (status))
 	    return status;
-	is_empty = _cairo_rectangle_intersect (&extents, &glyph_extents);
+	_cairo_rectangle_intersect (&extents, &glyph_extents);
+    }
 					  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)
+					  const cairo_clip_t		    *clip)
+{
     cairo_analysis_surface_t *surface = abstract_surface;
-    cairo_status_t	     status, backend_status;
+    cairo_int_status_t	     status, backend_status;
     cairo_rectangle_int_t    extents, glyph_extents;
-    cairo_bool_t             is_empty;
     /* Adapted from _cairo_surface_show_glyphs */
     backend_status = CAIRO_INT_STATUS_UNSUPPORTED;
     if (surface->target->backend->show_text_glyphs != NULL) {
 							glyphs, num_glyphs,
 							clusters, num_clusters,
 							cluster_flags,
 							scaled_font,
 							clip);
-	if (_cairo_status_is_error (backend_status))
+	if (_cairo_int_status_is_error (backend_status))
 	    return backend_status;
+    }
     if (backend_status == CAIRO_INT_STATUS_UNSUPPORTED &&
 	surface->target->backend->show_glyphs != NULL)
+    {
-	int remaining_glyphs = num_glyphs;
 	backend_status =
 	    surface->target->backend->show_glyphs (surface->target, op,
 						   source,
 						   glyphs, num_glyphs,
 						   scaled_font,
-						   clip,
+						   clip);
-						   &remaining_glyphs);
-	if (_cairo_status_is_error (backend_status))
+	if (_cairo_int_status_is_error (backend_status))
 	    return backend_status;
-	glyphs += num_glyphs - remaining_glyphs;
-	num_glyphs = remaining_glyphs;
-	if (remaining_glyphs == 0)
-	    backend_status = CAIRO_STATUS_SUCCESS;
+    }
     if (backend_status == CAIRO_INT_STATUS_ANALYZE_RECORDING_SURFACE_PATTERN)
 							  &glyph_extents,
 							  NULL);
 	if (unlikely (status))
 	    return status;
-	is_empty = _cairo_rectangle_intersect (&extents, &glyph_extents);
+	_cairo_rectangle_intersect (&extents, &glyph_extents);
+    }
     return _add_operation (surface, &extents, backend_status);
+}
 static const cairo_surface_backend_t cairo_analysis_surface_backend = {
+    CAIRO_INTERNAL_SURFACE_TYPE_ANALYSIS,
+    _cairo_analysis_surface_finish,
+    NULL,
+    NULL, /* create_similar */
+    NULL, /* create_similar_image */
+    NULL, /* map_to_image */
-    CAIRO_INTERNAL_SURFACE_TYPE_ANALYSIS,
+    NULL, /* unmap */
     NULL, /* create_similar */
-    _cairo_analysis_surface_finish,
-    NULL, /* acquire_source_image */
-    NULL, /* release_source_image */
-    NULL, /* acquire_dest_image */
+    NULL, /* source */
-    NULL, /* release_dest_image */
-    NULL, /* clone_similar */
-    NULL, /* composite */
-    NULL, /* fill_rectangles */
+    NULL, /* acquire_source_image */
-    NULL, /* composite_trapezoids */
+    NULL, /* release_source_image */
-    NULL, /* create_span_renderer */
+    NULL, /* snapshot */
-    NULL, /* check_span_renderer */
+    NULL, /* copy_page */
-    NULL, /* copy_page */
     NULL, /* show_page */
     _cairo_analysis_surface_get_extents,
-    NULL, /* old_show_glyphs */
+    NULL, /* get_font_options */
-    NULL, /* get_font_options */
-    NULL, /* flush */
-    NULL, /* mark_dirty_rectangle */
+    NULL, /* flush */
-    NULL, /* scaled_font_fini */
+    NULL, /* mark_dirty_rectangle */
     NULL, /* scaled_glyph_fini */
     _cairo_analysis_surface_paint,
-    _cairo_analysis_surface_mask,
-    _cairo_analysis_surface_stroke,
-    _cairo_analysis_surface_fill,
-    _cairo_analysis_surface_show_glyphs,
+    _cairo_analysis_surface_mask,
-    NULL, /* snapshot */
-    NULL, /* is_similar */
+    _cairo_analysis_surface_stroke,
-    NULL, /* fill_stroke */
+    _cairo_analysis_surface_fill,
-    NULL, /* create_solid_pattern_surface */
+    NULL, /* fill_stroke */
-    NULL, /* can_repaint_solid_pattern_surface */
+    _cairo_analysis_surface_show_glyphs,
     _cairo_analysis_surface_has_show_text_glyphs,
 /* These typedefs are just to silence the compiler... */
 typedef cairo_int_status_t
 (*_paint_func)			(void			*surface,
 			         cairo_operator_t	 op,
 				 const cairo_pattern_t	*source,
-				 cairo_clip_t		*clip);
+				 const cairo_clip_t		*clip);
 typedef cairo_int_status_t
 (*_mask_func)			(void			*surface,
 			         cairo_operator_t	 op,
 				 const cairo_pattern_t	*source,
 				 const cairo_pattern_t	*mask,
-				 cairo_clip_t		*clip);
+				 const cairo_clip_t		*clip);
 typedef cairo_int_status_t
 (*_stroke_func)			(void			*surface,
 			         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	*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);
 typedef cairo_int_status_t
 (*_fill_func)			(void			*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);
 typedef cairo_int_status_t
 (*_show_glyphs_func)		(void			*surface,
 			         cairo_operator_t	 op,
 				 const cairo_pattern_t	*source,
-				 cairo_glyph_t		*glyphs,
-				 int			 num_glyphs,
+				 cairo_glyph_t		*glyphs,
-				 cairo_scaled_font_t	*scaled_font,
+				 int			 num_glyphs,
+				 cairo_scaled_font_t	*scaled_font,
+				 const cairo_clip_t		*clip);
-				 cairo_clip_t		*clip,
+static const cairo_surface_backend_t cairo_null_surface_backend = {
+    CAIRO_INTERNAL_SURFACE_TYPE_NULL,
+    NULL, /* finish */
+    NULL, /* only accessed through the surface functions */
-				 int			*remaining_glyphs);
     NULL, /* create_similar */
-static const cairo_surface_backend_t cairo_null_surface_backend = {
+    NULL, /* create similar image */
-    CAIRO_INTERNAL_SURFACE_TYPE_NULL,
-    NULL, /* create_similar */
-    NULL, /* finish */
+    NULL, /* map to image */
-    NULL, /* acquire_source_image */
-    NULL, /* release_source_image */
-    NULL, /* acquire_dest_image */
-    NULL, /* release_dest_image */
+    NULL, /* unmap image*/
     NULL, /* clone_similar */
-    NULL, /* composite */
+    NULL, /* source */
+    NULL, /* acquire_source_image */
-    NULL, /* fill_rectangles */
+    NULL, /* release_source_image */
-    NULL, /* composite_trapezoids */
-    NULL, /* create_span_renderer */
+    NULL, /* snapshot */
-    NULL, /* check_span_renderer */
+    NULL, /* copy_page */
-    NULL, /* copy_page */
+    NULL, /* show_page */
-    NULL, /* show_page */
-    NULL, /* get_extents */
-    NULL, /* old_show_glyphs */
+    NULL, /* get_extents */
     NULL, /* get_font_options */
     NULL, /* flush */
-    NULL, /* mark_dirty_rectangle */
+    NULL, /* flush */
-    NULL, /* scaled_font_fini */
-    NULL, /* scaled_glyph_fini */
-    (_paint_func) _return_success,	    /* paint */
-    (_mask_func) _return_success,	    /* mask */
+    NULL, /* mark_dirty_rectangle */
-    (_stroke_func) _return_success,	    /* stroke */
-    (_fill_func) _return_success,	    /* fill */
-    (_show_glyphs_func) _return_success,    /* show_glyphs */
+    (_paint_func) _return_success,	    /* paint */
-    NULL, /* snapshot */
+    (_mask_func) _return_success,	    /* mask */
-    NULL, /* is_similar */
+    (_stroke_func) _return_success,	    /* stroke */
-    NULL, /* fill_stroke */
+    (_fill_func) _return_success,	    /* fill */

Subversion Repositories Kolibri OS

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