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

  *	Carl D. Worth
  */
+#include "cairoint.h"
 #include "cairoint.h"
 #include "cairo-clip-inline.h"
+#include "cairo-clip-private.h"
-#include "cairo-clip-private.h"
+#include "cairo-error-private.h"
+#include "cairo-list-inline.h"
+#include "cairo-gstate-private.h"
-#include "cairo-error-private.h"
+#include "cairo-pattern-private.h"
-#include "cairo-gstate-private.h"
+#include "cairo-traps-private.h"
 #if _XOPEN_SOURCE >= 600 || defined (_ISOC99_SOURCE)
 _cairo_gstate_ensure_scaled_font (cairo_gstate_t *gstate);
 static void
 _cairo_gstate_unset_scaled_font (cairo_gstate_t *gstate);
-static cairo_status_t
+static void
 _cairo_gstate_transform_glyphs_to_backend (cairo_gstate_t      *gstate,
                                            const cairo_glyph_t *glyphs,
                                            int                  num_glyphs,
 cairo_status_t
 _cairo_gstate_init (cairo_gstate_t  *gstate,
 		    cairo_surface_t *target)
-{
-    cairo_status_t status;
+{
     VG (VALGRIND_MAKE_MEM_UNDEFINED (gstate, sizeof (cairo_gstate_t)));
+    gstate->next = NULL;
     gstate->next = NULL;
     gstate->op = CAIRO_GSTATE_OPERATOR_DEFAULT;
-    gstate->op = CAIRO_GSTATE_OPERATOR_DEFAULT;
+    gstate->opacity = 1.;
 			     CAIRO_GSTATE_DEFAULT_FONT_SIZE,
 			     CAIRO_GSTATE_DEFAULT_FONT_SIZE);
     _cairo_font_options_init_default (&gstate->font_options);
-    _cairo_clip_init (&gstate->clip);
+    gstate->clip = NULL;
     gstate->source = (cairo_pattern_t *) &_cairo_pattern_black.base;
     /* Now that the gstate is fully initialized and ready for the eventual
      * _cairo_gstate_fini(), we can check for errors (and not worry about
      * the resource deallocation). */
-    status = target->status;
-    if (unlikely (status))
-	return status;
-    status = gstate->source->status;
-    if (unlikely (status))
-	return status;
-    return CAIRO_STATUS_SUCCESS;
+    return target->status;
+}
 /**
     cairo_status_t status;
     VG (VALGRIND_MAKE_MEM_UNDEFINED (gstate, sizeof (cairo_gstate_t)));
     gstate->op = other->op;
-    gstate->op = other->op;
+    gstate->opacity = other->opacity;
     gstate->font_matrix = other->font_matrix;
     _cairo_font_options_init_copy (&gstate->font_options , &other->font_options);
-    _cairo_clip_init_copy (&gstate->clip, &other->clip);
+    gstate->clip = _cairo_clip_copy (other->clip);
     gstate->previous_scaled_font = NULL;
     cairo_scaled_font_destroy (gstate->scaled_font);
     gstate->scaled_font = NULL;
-    _cairo_clip_reset (&gstate->clip);
+    _cairo_clip_destroy (gstate->clip);
  * @child: the new child target
+ *
  * Redirect @gstate rendering to a "child" target. The original
  * "parent" target with which the gstate was created will not be
  * affected. See _cairo_gstate_get_target().
- *
- * Unless the redirected target has the same device offsets as the
- * original #cairo_t target, the clip will be INVALID after this call,
- * and the caller should either recreate or reset the clip.
  **/
 cairo_status_t
 _cairo_gstate_redirect_target (cairo_gstate_t *gstate, cairo_surface_t *child)
+{
-    cairo_matrix_t matrix;
     /* If this gstate is already redirected, this is an error; we need a
      * new gstate to be able to redirect */
     assert (gstate->parent_target == NULL);
     /* Set up our new parent_target based on our current target;
      * gstate->parent_target will take the ref that is held by gstate->target
-     */
-    cairo_surface_destroy (gstate->parent_target);
+     */
     gstate->parent_target = gstate->target;
     /* Now set up our new target; we overwrite gstate->target directly,
     cairo_list_move (&gstate->device_transform_observer.link,
 		     &gstate->target->device_transform_observers);
     /* The clip is in surface backend coordinates for the previous target;
      * translate it into the child's backend coordinates. */
+    _cairo_clip_destroy (gstate->clip);
-    cairo_matrix_init_translate (&matrix,
+    gstate->clip = _cairo_clip_copy_with_translation (gstate->next->clip,
-				 child->device_transform.x0 - gstate->parent_target->device_transform.x0,
+						      child->device_transform.x0 - gstate->parent_target->device_transform.x0,
+						      child->device_transform.y0 - gstate->parent_target->device_transform.y0);
-				 child->device_transform.y0 - gstate->parent_target->device_transform.y0);
-    _cairo_clip_reset (&gstate->clip);
-    return _cairo_clip_init_copy_transformed (&gstate->clip,
-					      &gstate->next->clip,
-					      &matrix);
+    return CAIRO_STATUS_SUCCESS;
+}
 /**
- * _cairo_gstate_is_redirected
+ * _cairo_gstate_is_group:
  * @gstate: a #cairo_gstate_t
+ *
  * Check if _cairo_gstate_redirect_target has been called on the head
- * This space left intentionally blank.
+ * of the stack.
  *
- * Return value: %TRUE if the gstate is redirected to a target
+ * Return value: %TRUE if @gstate is redirected to a target different
- * different than the original, %FALSE otherwise.
+ * than the previous state in the stack, %FALSE otherwise.
  **/
 cairo_bool_t
-_cairo_gstate_is_redirected (cairo_gstate_t *gstate)
+_cairo_gstate_is_group (cairo_gstate_t *gstate)
+{
-    return (gstate->target != gstate->original_target);
+    return gstate->parent_target != NULL;
+}
+{
     return gstate->target;
+}
-/**
- * _cairo_gstate_get_parent_target:
- * @gstate: a #cairo_gstate_t
- *
- * Return the parent surface of the current drawing target surface;
- * if this particular gstate isn't a redirect gstate, this will return %NULL.
- **/
-cairo_surface_t *
-_cairo_gstate_get_parent_target (cairo_gstate_t *gstate)
-{
-    return gstate->parent_target;
-}
 /**
  * _cairo_gstate_get_original_target:
  * @gstate: a #cairo_gstate_t
+ *
  * Return the original target with which @gstate was created. This
  * @gstate: a #cairo_gstate_t
+ *
  * This space left intentionally blank.
+ *
  * Return value: a pointer to the gstate's #cairo_clip_t structure.
- */
+ **/
 cairo_clip_t *
 _cairo_gstate_get_clip (cairo_gstate_t *gstate)
+{
-    return &gstate->clip;
+    return gstate->clip;
+}
 cairo_status_t
 _cairo_gstate_set_source (cairo_gstate_t  *gstate,
+{
     return gstate->op;
+}
+cairo_status_t
+_cairo_gstate_set_opacity (cairo_gstate_t *gstate, double op)
+{
+    gstate->opacity = op;
+    return CAIRO_STATUS_SUCCESS;
+}
+double
+_cairo_gstate_get_opacity (cairo_gstate_t *gstate)
+{
+    return gstate->opacity;
+}
 cairo_status_t
 _cairo_gstate_set_tolerance (cairo_gstate_t *gstate, double tolerance)
+{
     gstate->tolerance = tolerance;
+}
 cairo_status_t
 _cairo_gstate_set_dash (cairo_gstate_t *gstate, const double *dash, int num_dashes, double offset)
 {
-    unsigned int i;
+    double dash_total, on_total, off_total;
-    double dash_total;
     int i, j;
     if (gstate->stroke_style.dash)
-	free (gstate->stroke_style.dash);
+    free (gstate->stroke_style.dash);
     if (unlikely (gstate->stroke_style.dash == NULL)) {
 	gstate->stroke_style.num_dashes = 0;
 	return _cairo_error (CAIRO_STATUS_NO_MEMORY);
+    }
+    on_total = off_total = dash_total = 0.0;
+    for (i = j = 0; i < num_dashes; i++) {
+	if (dash[i] < 0)
-    memcpy (gstate->stroke_style.dash, dash, gstate->stroke_style.num_dashes * sizeof (double));
+	    return _cairo_error (CAIRO_STATUS_INVALID_DASH);
-    dash_total = 0.0;
-    for (i = 0; i < gstate->stroke_style.num_dashes; i++) {
+	if (dash[i] == 0 && i > 0 && i < num_dashes - 1) {
+	    if (dash[++i] < 0)
+		return _cairo_error (CAIRO_STATUS_INVALID_DASH);
-	if (gstate->stroke_style.dash[i] < 0)
+	    gstate->stroke_style.dash[j-1] += dash[i];
+	    gstate->stroke_style.num_dashes -= 2;
+	} else
+	    gstate->stroke_style.dash[j++] = dash[i];
+	if (dash[i]) {
+	    dash_total += dash[i];
+	    if ((i & 1) == 0)
+		on_total += dash[i];
-	    return _cairo_error (CAIRO_STATUS_INVALID_DASH);
+	    else
 		off_total += dash[i];
 	dash_total += gstate->stroke_style.dash[i];
+    }
     if (dash_total == 0.0)
 	return _cairo_error (CAIRO_STATUS_INVALID_DASH);
+    /* An odd dash value indicate symmetric repeating, so the total
+     * is twice as long. */
+    if (gstate->stroke_style.num_dashes & 1) {
+	dash_total *= 2;
+	on_total += off_total;
+    }
+    if (dash_total - on_total < CAIRO_FIXED_ERROR_DOUBLE) {
+	/* Degenerate dash -> solid line */
+	free (gstate->stroke_style.dash);
 	gstate->stroke_style.dash = NULL;
-    /* An odd dash value indicate symmetric repeating, so the total
+	gstate->stroke_style.num_dashes = 0;
-     * is twice as long. */
+	gstate->stroke_style.dash_offset = 0.0;
-    if (gstate->stroke_style.num_dashes & 1)
+	return CAIRO_STATUS_SUCCESS;
     cairo_matrix_transform_point (&gstate->ctm, x, y);
     cairo_matrix_transform_point (&gstate->target->device_transform, x, y);
+}
+void
+_do_cairo_gstate_user_to_backend_distance (cairo_gstate_t *gstate, double *x, double *y)
+{
+    cairo_matrix_transform_distance (&gstate->ctm, x, y);
+    cairo_matrix_transform_distance (&gstate->target->device_transform, x, y);
+}
 void
 _do_cairo_gstate_backend_to_user (cairo_gstate_t *gstate, double *x, double *y)
+{
     cairo_matrix_transform_point (&gstate->target->device_transform_inverse, x, y);
     cairo_matrix_transform_point (&gstate->ctm_inverse, x, y);
+}
+void
+_do_cairo_gstate_backend_to_user_distance (cairo_gstate_t *gstate, double *x, double *y)
+{
+    cairo_matrix_transform_distance (&gstate->target->device_transform_inverse, x, y);
+    cairo_matrix_transform_distance (&gstate->ctm_inverse, x, y);
+}
 void
 _cairo_gstate_backend_to_user_rectangle (cairo_gstate_t *gstate,
                                          double *x1, double *y1,
                                          double *x2, double *y2,
                                          cairo_bool_t *is_tight)
+{
+    cairo_matrix_t matrix_inverse;
     if (! _cairo_matrix_is_identity (&gstate->target->device_transform_inverse) ||
-    cairo_matrix_t matrix_inverse;
+    ! _cairo_matrix_is_identity (&gstate->ctm_inverse))
+    {
-    cairo_matrix_multiply (&matrix_inverse,
+	cairo_matrix_multiply (&matrix_inverse,
-                           &gstate->target->device_transform_inverse,
+			       &gstate->target->device_transform_inverse,
-			   &gstate->ctm_inverse);
+			       &gstate->ctm_inverse);
+	_cairo_matrix_transform_bounding_box (&matrix_inverse,
+					      x1, y1, x2, y2, is_tight);
+    }
+    else
+    {
+	if (is_tight)
-    _cairo_matrix_transform_bounding_box (&matrix_inverse,
+	    *is_tight = TRUE;
 					  x1, y1, x2, y2, is_tight);
+}
 /* XXX: NYI
     _cairo_gstate_copy_transformed_pattern (gstate, pattern,
 					    mask,
 					    &gstate->ctm_inverse);
+}
-/* We need to take a copy of the clip so that the lower layers may modify it
- * by, perhaps, intersecting it with the operation extents and other paths.
- */
-#define _gstate_get_clip(G, C) _cairo_clip_init_copy ((C), &(G)->clip)
-static cairo_bool_t
-_clipped (cairo_gstate_t *gstate)
-{
-    cairo_rectangle_int_t extents;
-    if (gstate->clip.all_clipped)
-	return TRUE;
-    /* XXX consider applying a surface clip? */
-    if (gstate->clip.path == NULL)
-	return FALSE;
-    if (_cairo_surface_get_extents (gstate->target, &extents)) {
-	if (extents.width == 0 || extents.height == 0)
-	    return TRUE;
-	if (! _cairo_rectangle_intersect (&extents,
-					  &gstate->clip.path->extents))
-	{
-	    return TRUE;
-	}
-    }
-    /* perform a simple query to exclude trivial all-clipped cases */
-    return _cairo_clip_get_region (&gstate->clip, NULL) == CAIRO_INT_STATUS_NOTHING_TO_DO;
-}
 static cairo_operator_t
 _reduce_op (cairo_gstate_t *gstate)
+{
     cairo_operator_t op;
+    }
     return op;
+}
+static cairo_status_t
+_cairo_gstate_get_pattern_status (const cairo_pattern_t *pattern)
+{
+    if (unlikely (pattern->type == CAIRO_PATTERN_TYPE_MESH &&
+		  ((const cairo_mesh_pattern_t *) pattern)->current_patch))
+    {
+	/* If current patch != NULL, the pattern is under construction
+	 * and cannot be used as a source */
+	return CAIRO_STATUS_INVALID_MESH_CONSTRUCTION;
+    }
+    return pattern->status;
+}
 cairo_status_t
 _cairo_gstate_paint (cairo_gstate_t *gstate)
+{
-    cairo_pattern_union_t source_pattern;
-    const cairo_pattern_t *pattern;
+    cairo_pattern_union_t source_pattern;
-    cairo_clip_t clip;
+    const cairo_pattern_t *pattern;
+    cairo_status_t status;
-    cairo_status_t status;
+    cairo_operator_t op;
-    cairo_operator_t op;
     status = _cairo_gstate_get_pattern_status (gstate->source);
-    if (unlikely (gstate->source->status))
+    if (unlikely (status))
-	return gstate->source->status;
+	return status;
     if (gstate->op == CAIRO_OPERATOR_DEST)
 	return CAIRO_STATUS_SUCCESS;
-    if (_clipped (gstate))
+    if (_cairo_clip_is_all_clipped (gstate->clip))
 	return CAIRO_STATUS_SUCCESS;
     op = _reduce_op (gstate);
     if (op == CAIRO_OPERATOR_CLEAR) {
 	pattern = &_cairo_pattern_clear.base;
     } else {
-	_cairo_gstate_copy_transformed_source (gstate, &source_pattern.base);
-	pattern = &source_pattern.base;
-    }
 	_cairo_gstate_copy_transformed_source (gstate, &source_pattern.base);
-    status = _cairo_surface_paint (gstate->target,
+	pattern = &source_pattern.base;
 				   op, pattern,
 				   _gstate_get_clip (gstate, &clip));
-    _cairo_clip_fini (&clip);
+    return _cairo_surface_paint (gstate->target,
 				 op, pattern,
-    return status;
+				 gstate->clip);
+}
 cairo_status_t
+cairo_status_t
 _cairo_gstate_mask (cairo_gstate_t  *gstate,
 		    cairo_pattern_t *mask)
+{
-{
+    cairo_pattern_union_t source_pattern, mask_pattern;
-    cairo_pattern_union_t source_pattern, mask_pattern;
+    const cairo_pattern_t *source;
-    const cairo_pattern_t *source;
+    cairo_operator_t op;
-    cairo_operator_t op;
+    cairo_status_t status;
-    cairo_clip_t clip;
-    cairo_status_t status;
+    status = _cairo_gstate_get_pattern_status (mask);
+    if (unlikely (status))
+	return status;
-    if (unlikely (mask->status))
+    status = _cairo_gstate_get_pattern_status (gstate->source);
-	return mask->status;
+    if (unlikely (status))
 	return status;
 	source = &source_pattern.base;
+    }
     _cairo_gstate_copy_transformed_mask (gstate, &mask_pattern.base, mask);
     if (source->type == CAIRO_PATTERN_TYPE_SOLID &&
-	mask_pattern.type == CAIRO_PATTERN_TYPE_SOLID &&
+	mask_pattern.base.type == CAIRO_PATTERN_TYPE_SOLID &&
 	_cairo_operator_bounded_by_source (op))
+    {
 	const cairo_solid_pattern_t *solid = (cairo_solid_pattern_t *) source;
 	_cairo_pattern_init_solid (&source_pattern.solid, &combined);
 	status = _cairo_surface_paint (gstate->target, op,
 				       &source_pattern.base,
-				       _gstate_get_clip (gstate, &clip));
+				       gstate->clip);
+    }
     else
+    {
 	status = _cairo_surface_mask (gstate->target, op,
 				      source,
 				      &mask_pattern.base,
-				      _gstate_get_clip (gstate, &clip));
 				      gstate->clip);
     _cairo_clip_fini (&clip);
     return status;
+}
 cairo_status_t
 _cairo_gstate_stroke (cairo_gstate_t *gstate, cairo_path_fixed_t *path)
-{
     cairo_pattern_union_t source_pattern;
+    cairo_pattern_union_t source_pattern;
     cairo_stroke_style_t style;
     double dash[2];
-    cairo_clip_t clip;
+    cairo_status_t status;
     cairo_status_t status;
     status = _cairo_gstate_get_pattern_status (gstate->source);
-    if (unlikely (gstate->source->status))
+    if (unlikely (status))
-	return gstate->source->status;
+	return status;
+    if (gstate->op == CAIRO_OPERATOR_DEST)
+	return CAIRO_STATUS_SUCCESS;
     if (gstate->op == CAIRO_OPERATOR_DEST)
-	return CAIRO_STATUS_SUCCESS;
+    if (gstate->stroke_style.line_width <= 0.0)
 	return CAIRO_STATUS_SUCCESS;
     if (gstate->stroke_style.line_width <= 0.0)
-	return CAIRO_STATUS_SUCCESS;
+    if (_cairo_clip_is_all_clipped (gstate->clip))
 					      &style.num_dashes);
+    }
     _cairo_gstate_copy_transformed_source (gstate, &source_pattern.base);
-    status = _cairo_surface_stroke (gstate->target,
+    return _cairo_surface_stroke (gstate->target,
-				    gstate->op,
+				  gstate->op,
-				    &source_pattern.base,
+				  &source_pattern.base,
-				    path,
+				  path,
-				    &style,
+				  &style,
-				    &gstate->ctm,
+				  &gstate->ctm,
-				    &gstate->ctm_inverse,
+				  &gstate->ctm_inverse,
-				    gstate->tolerance,
+				  gstate->tolerance,
-				    gstate->antialias,
-				    _gstate_get_clip (gstate, &clip));
-    _cairo_clip_fini (&clip);
 				  gstate->antialias,
-    return status;
+				  gstate->clip);
+}
     limit.p2.y = limit.p1.y + 2;
     _cairo_traps_init (&traps);
     _cairo_traps_limit (&traps, &limit, 1);
-    status = _cairo_path_fixed_stroke_to_traps (path,
+    status = _cairo_path_fixed_stroke_polygon_to_traps (path,
-						&gstate->stroke_style,
+							&gstate->stroke_style,
-						&gstate->ctm,
+							&gstate->ctm,
-						&gstate->ctm_inverse,
+							&gstate->ctm_inverse,
+}
 cairo_status_t
 _cairo_gstate_fill (cairo_gstate_t *gstate, cairo_path_fixed_t *path)
-{
     cairo_clip_t clip;
+    cairo_status_t status;
-    cairo_status_t status;
+    status = _cairo_gstate_get_pattern_status (gstate->source);
-    if (unlikely (gstate->source->status))
+    if (unlikely (status))
-	return gstate->source->status;
+	return status;
     if (gstate->op == CAIRO_OPERATOR_DEST)
+	return CAIRO_STATUS_SUCCESS;
-	return CAIRO_STATUS_SUCCESS;
+    if (_cairo_clip_is_all_clipped (gstate->clip))
 	return CAIRO_STATUS_SUCCESS;
     if (_clipped (gstate))
-	return CAIRO_STATUS_SUCCESS;
+    assert (gstate->opacity == 1.0);
     if (_cairo_path_fixed_fill_is_empty (path)) {
 	if (_cairo_operator_bounded_by_mask (gstate->op))
 	    return CAIRO_STATUS_SUCCESS;
 	status = _cairo_surface_paint (gstate->target,
 				       CAIRO_OPERATOR_CLEAR,
 				       &_cairo_pattern_clear.base,
 	    box.p1.y <= _cairo_fixed_from_int (extents.y) &&
 	    box.p2.x >= _cairo_fixed_from_int (extents.x + extents.width) &&
 	    box.p2.y >= _cairo_fixed_from_int (extents.y + extents.height))
+	{
 	    status = _cairo_surface_paint (gstate->target, op, pattern,
-					   _gstate_get_clip (gstate, &clip));
+					   gstate->clip);
+	}
 	else
+	{
 	    status = _cairo_surface_fill (gstate->target, op, pattern,
 					  path,
 					  gstate->fill_rule,
 					  gstate->tolerance,
 					  gstate->antialias,
-					  _gstate_get_clip (gstate, &clip));
+					  gstate->clip);
+	}
+    }
-    _cairo_clip_fini (&clip);
     return status;
+}
 cairo_bool_t
 _cairo_gstate_in_clip (cairo_gstate_t	  *gstate,
 		       double		   x,
 		       double		   y)
+{
-    cairo_clip_path_t *clip_path;
+    cairo_clip_t *clip = gstate->clip;
+    int i;
-    if (gstate->clip.all_clipped)
+    if (_cairo_clip_is_all_clipped (clip))
-	return FALSE;
+	return FALSE;
     clip_path = gstate->clip.path;
-    if (clip_path == NULL)
+    if (clip == NULL)
 	return TRUE;
     _cairo_gstate_user_to_backend (gstate, &x, &y);
-    if (x <  clip_path->extents.x ||
+    if (x <  clip->extents.x ||
-	x >= clip_path->extents.x + clip_path->extents.width ||
+	x >= clip->extents.x + clip->extents.width ||
-	y <  clip_path->extents.y ||
+	y <  clip->extents.y ||
+	y >= clip->extents.y + clip->extents.height)
+    {
+	return FALSE;
+    }
+    if (clip->num_boxes) {
+	int fx, fy;
+	fx = _cairo_fixed_from_double (x);
+	fy = _cairo_fixed_from_double (y);
+	for (i = 0; i < clip->num_boxes; i++) {
+	    if (fx >= clip->boxes[i].p1.x && fx <= clip->boxes[i].p2.x &&
+		fy >= clip->boxes[i].p1.y && fy <= clip->boxes[i].p2.y)
+		break;
+	}
+	if (i == clip->num_boxes)
-	y >= clip_path->extents.y + clip_path->extents.height)
+	    return FALSE;
+    }
 	return FALSE;
     if (clip->path) {
 	cairo_clip_path_t *clip_path = clip->path;
-    do {
+	do {
-	if (! _cairo_path_fixed_in_fill (&clip_path->path,
+	    if (! _cairo_path_fixed_in_fill (&clip_path->path,
+					     clip_path->fill_rule,
-					 clip_path->fill_rule,
+					     clip_path->tolerance,
-					 clip_path->tolerance,
+					     x, y))
-					 x, y))
+		return FALSE;
     cairo_surface_show_page (gstate->target);
     return cairo_surface_status (gstate->target);
+}
 static void
-_cairo_gstate_traps_extents_to_user_rectangle (cairo_gstate_t	  *gstate,
+_cairo_gstate_extents_to_user_rectangle (cairo_gstate_t	  *gstate,
-                                               cairo_traps_t      *traps,
+					 const cairo_box_t *extents,
-                                               double *x1, double *y1,
+					 double *x1, double *y1,
-                                               double *x2, double *y2)
+					 double *x2, double *y2)
-{
-    cairo_box_t extents;
-    if (traps->num_traps == 0) {
-        /* no traps, so we actually won't draw anything */
-	if (x1)
-	    *x1 = 0.0;
-	if (y1)
-	    *y1 = 0.0;
-	if (x2)
-	    *x2 = 0.0;
-	if (y2)
-	    *y2 = 0.0;
     } else {
-	double px1, py1, px2, py2;
-	_cairo_traps_extents (traps, &extents);
+    double px1, py1, px2, py2;
-	px1 = _cairo_fixed_to_double (extents.p1.x);
+    px1 = _cairo_fixed_to_double (extents->p1.x);
-	py1 = _cairo_fixed_to_double (extents.p1.y);
+    py1 = _cairo_fixed_to_double (extents->p1.y);
-	px2 = _cairo_fixed_to_double (extents.p2.x);
+    px2 = _cairo_fixed_to_double (extents->p2.x);
-	py2 = _cairo_fixed_to_double (extents.p2.y);
+    py2 = _cairo_fixed_to_double (extents->p2.y);
-        _cairo_gstate_backend_to_user_rectangle (gstate,
+    _cairo_gstate_backend_to_user_rectangle (gstate,
-	if (x2)
+    if (x2)
-	    *x2 = px2;
+	*x2 = px2;
-	if (y2)
+    if (y2)
-	    *y2 = py2;
+	*y2 = py2;
+}
-}
 cairo_status_t
 _cairo_gstate_stroke_extents (cairo_gstate_t	 *gstate,
 			      cairo_path_fixed_t *path,
                               double *x1, double *y1,
 			      double *x2, double *y2)
 {
-    cairo_status_t status;
+    cairo_int_status_t status;
+    cairo_box_t extents;
-    cairo_traps_t traps;
     cairo_bool_t empty;
     if (gstate->stroke_style.line_width <= 0.0) {
-	if (x1)
+    if (x1)
-	    *x1 = 0.0;
+	*x1 = 0.0;
-	if (y1)
+    if (y1)
-	    *y1 = 0.0;
+	*y1 = 0.0;
-	if (x2)
+    if (x2)
-	    *x2 = 0.0;
+	*x2 = 0.0;
+    if (y2)
+	*y2 = 0.0;
 	if (y2)
+    if (gstate->stroke_style.line_width <= 0.0)
+	return CAIRO_STATUS_SUCCESS;
+    status = CAIRO_INT_STATUS_UNSUPPORTED;
+    if (_cairo_path_fixed_stroke_is_rectilinear (path)) {
+	cairo_boxes_t boxes;
+	_cairo_boxes_init (&boxes);
+	status = _cairo_path_fixed_stroke_rectilinear_to_boxes (path,
+								&gstate->stroke_style,
+								&gstate->ctm,
+								gstate->antialias,
+								&boxes);
+	empty = boxes.num_boxes == 0;
+	if (! empty)
-	    *y2 = 0.0;
+	    _cairo_boxes_extents (&boxes, &extents);
+	_cairo_boxes_fini (&boxes);
-	return CAIRO_STATUS_SUCCESS;
+    }
-    }
+    if (status == CAIRO_INT_STATUS_UNSUPPORTED) {
 	cairo_polygon_t polygon;
     _cairo_traps_init (&traps);
 	_cairo_polygon_init (&polygon, NULL, 0);
-    status = _cairo_path_fixed_stroke_to_traps (path,
+	status = _cairo_path_fixed_stroke_to_polygon (path,
-						&gstate->stroke_style,
+						      &gstate->stroke_style,
+						      &gstate->ctm,
+						      &gstate->ctm_inverse,
-						&gstate->ctm,
+						      gstate->tolerance,
+						      &polygon);
+	empty = polygon.num_edges == 0;
+	if (! empty)
-						&gstate->ctm_inverse,
+	    extents = polygon.extents;
-						gstate->tolerance,
+	_cairo_polygon_fini (&polygon);
 						&traps);
-    if (likely (status == CAIRO_STATUS_SUCCESS)) {
-	_cairo_gstate_traps_extents_to_user_rectangle (gstate, &traps,
-						       x1, y1, x2, y2);
+    if (! empty) {
 	_cairo_gstate_extents_to_user_rectangle (gstate, &extents,
 						 x1, y1, x2, y2);
     _cairo_traps_fini (&traps);
     return status;
+}
 cairo_status_t
 _cairo_gstate_fill_extents (cairo_gstate_t     *gstate,
+			    cairo_path_fixed_t *path,
-			    cairo_path_fixed_t *path,
                             double *x1, double *y1,
 			    double *x2, double *y2)
+{
     cairo_status_t status;
-    cairo_traps_t traps;
+    cairo_box_t extents;
     cairo_bool_t empty;
     if (path->is_empty_fill) {
-	if (x1)
+    if (x1)
+	*x1 = 0.0;
+    if (y1)
-	    *x1 = 0.0;
+	*y1 = 0.0;
+    if (x2)
+	*x2 = 0.0;
+    if (y2)
+	*y2 = 0.0;
+    if (_cairo_path_fixed_fill_is_empty (path))
+	return CAIRO_STATUS_SUCCESS;
+    if (_cairo_path_fixed_fill_is_rectilinear (path)) {
+	cairo_boxes_t boxes;
+	_cairo_boxes_init (&boxes);
+	status = _cairo_path_fixed_fill_rectilinear_to_boxes (path,
+							      gstate->fill_rule,
-	if (y1)
+							      gstate->antialias,
+							      &boxes);
-	    *y1 = 0.0;
+	empty = boxes.num_boxes == 0;
-	if (x2)
+	if (! empty)
-	    *x2 = 0.0;
+	    _cairo_boxes_extents (&boxes, &extents);
 	if (y2)
-	    *y2 = 0.0;
+	_cairo_boxes_fini (&boxes);
-	return CAIRO_STATUS_SUCCESS;
+    } else {
+	cairo_traps_t traps;
-    }
-    _cairo_traps_init (&traps);
 	_cairo_traps_init (&traps);
+	status = _cairo_path_fixed_fill_to_traps (path,
+						  gstate->fill_rule,
+						  gstate->tolerance,
+						  &traps);
+	empty = traps.num_traps == 0;
-    status = _cairo_path_fixed_fill_to_traps (path,
+	if (! empty)
-					      gstate->fill_rule,
+	    _cairo_traps_extents (&traps, &extents);
 					      gstate->tolerance,
-					      &traps);
+	_cairo_traps_fini (&traps);
     if (likely (status == CAIRO_STATUS_SUCCESS)) {
-	_cairo_gstate_traps_extents_to_user_rectangle (gstate, &traps,
+    if (! empty) {
-						       x1, y1, x2, y2);
+	_cairo_gstate_extents_to_user_rectangle (gstate, &extents,
 						 x1, y1, x2, y2);
+    }
     _cairo_traps_fini (&traps);
     return status;
+}
-    return status;
+cairo_status_t
-}
+_cairo_gstate_reset_clip (cairo_gstate_t *gstate)
+{
+    _cairo_clip_destroy (gstate->clip);
+    gstate->clip = NULL;
-cairo_status_t
+    return CAIRO_STATUS_SUCCESS;
 _cairo_gstate_reset_clip (cairo_gstate_t *gstate)
-    _cairo_clip_reset (&gstate->clip);
+cairo_status_t
 _cairo_gstate_clip (cairo_gstate_t *gstate, cairo_path_fixed_t *path)
-    return CAIRO_STATUS_SUCCESS;
+{
     gstate->clip =
-cairo_status_t
-_cairo_gstate_clip (cairo_gstate_t *gstate, cairo_path_fixed_t *path)
+	_cairo_clip_intersect_path (gstate->clip,
-{
+				    path,
-    return _cairo_clip_clip (&gstate->clip,
-			     path, gstate->fill_rule,
+				    gstate->fill_rule,
-			     gstate->tolerance, gstate->antialias);
+				    gstate->tolerance,
 				    gstate->antialias);
     /* XXX */
-static cairo_bool_t
+    return CAIRO_STATUS_SUCCESS;
+}
 cairo_rectangle_list_t*
 _cairo_gstate_copy_clip_rectangle_list (cairo_gstate_t *gstate)
-{
     cairo_clip_t clip;
     cairo_rectangle_int_t extents;
-    cairo_rectangle_list_t *list;
+    cairo_rectangle_list_t *list;
-    _cairo_clip_init_copy (&clip, &gstate->clip);
+    cairo_clip_t *clip;
+    if (_cairo_surface_get_extents (gstate->target, &extents))
+	clip = _cairo_clip_copy_intersect_rectangle (gstate->clip, &extents);
-    if (_cairo_surface_get_extents (gstate->target, &extents))
+    else
+	clip = gstate->clip;
-        _cairo_clip_rectangle (&clip, &extents);
+    list = _cairo_clip_copy_rectangle_list (clip, gstate);
-    list = _cairo_clip_copy_rectangle_list (&clip, gstate);
+    if (clip != gstate->clip)
-    _cairo_clip_fini (&clip);
+	_cairo_clip_destroy (clip);
     gstate->previous_scaled_font = gstate->scaled_font;
     gstate->scaled_font = NULL;
+}
-cairo_status_t
-_cairo_gstate_select_font_face (cairo_gstate_t       *gstate,
-				const char           *family,
-				cairo_font_slant_t    slant,
-				cairo_font_weight_t   weight)
-{
-    cairo_font_face_t *font_face;
-    cairo_status_t status;
-    font_face = cairo_toy_font_face_create (family, slant, weight);
-    if (font_face->status)
-	return font_face->status;
-    status = _cairo_gstate_set_font_face (gstate, font_face);
-    cairo_font_face_destroy (font_face);
-    return status;
-}
 cairo_status_t
 _cairo_gstate_set_font_size (cairo_gstate_t *gstate,
 			     double          size)
+{
 			       const cairo_matrix_t *matrix)
+{
     if (memcmp (matrix, &gstate->font_matrix, sizeof (cairo_matrix_t)) == 0)
 	return CAIRO_STATUS_SUCCESS;
-    if (! _cairo_matrix_is_invertible (matrix))
-	return _cairo_error (CAIRO_STATUS_INVALID_MATRIX);
     _cairo_gstate_unset_scaled_font (gstate);
     return cairo_scaled_font_status (gstate->scaled_font);
+}
-cairo_status_t
-_cairo_gstate_text_to_glyphs (cairo_gstate_t	         *gstate,
-			      double		          x,
-			      double		          y,
-			      const char	         *utf8,
-			      int		          utf8_len,
-			      cairo_glyph_t	        **glyphs,
-			      int		         *num_glyphs,
-			      cairo_text_cluster_t      **clusters,
-			      int		         *num_clusters,
-			      cairo_text_cluster_flags_t *cluster_flags)
-{
-    cairo_status_t status;
-    status = _cairo_gstate_ensure_scaled_font (gstate);
-    if (unlikely (status))
-	return status;
-    return cairo_scaled_font_text_to_glyphs (gstate->scaled_font, x, y,
-					     utf8, utf8_len,
-					     glyphs, num_glyphs,
-					     clusters, num_clusters,
-					     cluster_flags);
-}
 cairo_status_t
 _cairo_gstate_set_font_face (cairo_gstate_t    *gstate,
 			     cairo_font_face_t *font_face)
+{
     return cairo_scaled_font_status (gstate->scaled_font);
+}
 cairo_status_t
-_cairo_gstate_show_text_glyphs (cairo_gstate_t		   *gstate,
-				const char		   *utf8,
-				int			    utf8_len,
+_cairo_gstate_show_text_glyphs (cairo_gstate_t		   *gstate,
 				const cairo_glyph_t	   *glyphs,
-				int			    num_glyphs,
-				const cairo_text_cluster_t *clusters,
-				int			    num_clusters,
+				int			    num_glyphs,
-				cairo_text_cluster_flags_t  cluster_flags)
+				cairo_glyph_text_info_t    *info)
-{
-    cairo_pattern_union_t source_pattern;
     const cairo_pattern_t *pattern;
-    cairo_glyph_t stack_transformed_glyphs[CAIRO_STACK_ARRAY_LENGTH (cairo_glyph_t)];
-    cairo_glyph_t *transformed_glyphs;
+    cairo_glyph_t stack_transformed_glyphs[CAIRO_STACK_ARRAY_LENGTH (cairo_glyph_t)];
+    cairo_text_cluster_t stack_transformed_clusters[CAIRO_STACK_ARRAY_LENGTH (cairo_text_cluster_t)];
+    cairo_pattern_union_t source_pattern;
+    cairo_glyph_t *transformed_glyphs;
-    cairo_text_cluster_t stack_transformed_clusters[CAIRO_STACK_ARRAY_LENGTH (cairo_text_cluster_t)];
+    const cairo_pattern_t *pattern;
     cairo_text_cluster_t *transformed_clusters;
     cairo_operator_t op;
-    cairo_status_t status;
+    cairo_status_t status;
-    cairo_clip_t clip;
+    status = _cairo_gstate_get_pattern_status (gstate->source);
-    if (unlikely (gstate->source->status))
+    if (unlikely (status))
-	return gstate->source->status;
+	return status;
     if (gstate->op == CAIRO_OPERATOR_DEST)
 	return CAIRO_STATUS_SUCCESS;
-    if (_clipped (gstate))
+    if (_cairo_clip_is_all_clipped (gstate->clip))
     transformed_glyphs = stack_transformed_glyphs;
     transformed_clusters = stack_transformed_clusters;
     if (num_glyphs > ARRAY_LENGTH (stack_transformed_glyphs)) {
 	transformed_glyphs = cairo_glyph_allocate (num_glyphs);
-	if (unlikely (transformed_glyphs == NULL)) {
+	if (unlikely (transformed_glyphs == NULL))
-	    status = _cairo_error (CAIRO_STATUS_NO_MEMORY);
-	    goto CLEANUP_GLYPHS;
 	    return _cairo_error (CAIRO_STATUS_NO_MEMORY);
-    }
+    }
-    /* Just in case */
-    if (!clusters)
-	num_clusters = 0;
+    if (info != NULL) {
-    if (num_clusters > ARRAY_LENGTH (stack_transformed_clusters)) {
+	if (info->num_clusters > ARRAY_LENGTH (stack_transformed_clusters)) {
-	transformed_clusters = cairo_text_cluster_allocate (num_clusters);
+	    transformed_clusters = cairo_text_cluster_allocate (info->num_clusters);
-	if (unlikely (transformed_clusters == NULL)) {
+	    if (unlikely (transformed_clusters == NULL)) {
-	    status = _cairo_error (CAIRO_STATUS_NO_MEMORY);
+		status = _cairo_error (CAIRO_STATUS_NO_MEMORY);
-	    goto CLEANUP_GLYPHS;
+		goto CLEANUP_GLYPHS;
-	}
+	    }
+	}
-    status = _cairo_gstate_transform_glyphs_to_backend (gstate,
+	_cairo_gstate_transform_glyphs_to_backend (gstate,
-							glyphs, num_glyphs,
+						   glyphs, num_glyphs,
-							clusters,
+						   info->clusters,
-							num_clusters,
+						   info->num_clusters,
-							cluster_flags,
+						   info->cluster_flags,
+						   transformed_glyphs,
+						   &num_glyphs,
+						   transformed_clusters);
+    } else {
+	_cairo_gstate_transform_glyphs_to_backend (gstate,
+						   glyphs, num_glyphs,
+						   NULL, 0, 0,
+						   transformed_glyphs,
-							transformed_glyphs,
+						   &num_glyphs,
-							&num_glyphs,
+						   NULL);
 							transformed_clusters);
-    if (status || num_glyphs == 0)
+    if (num_glyphs == 0)
+     *
      * Needless to say, do this only if show_text_glyphs is not available. */
     if (cairo_surface_has_show_text_glyphs (gstate->target) ||
 	_cairo_scaled_font_get_max_scale (gstate->scaled_font) <= 10240)
+    {
+	if (info != NULL) {
-	status = _cairo_surface_show_text_glyphs (gstate->target, op, pattern,
+	    status = _cairo_surface_show_text_glyphs (gstate->target, op, pattern,
-						  utf8, utf8_len,
+						      info->utf8, info->utf8_len,
-						  transformed_glyphs, num_glyphs,
+						      transformed_glyphs, num_glyphs,
-						  transformed_clusters, num_clusters,
+						      transformed_clusters, info->num_clusters,
-						  cluster_flags,
+						      info->cluster_flags,
-						  gstate->scaled_font,
+						      gstate->scaled_font,
-						  _gstate_get_clip (gstate, &clip));
+						      gstate->clip);
+	} else {
+	    status = _cairo_surface_show_text_glyphs (gstate->target, op, pattern,
+						      NULL, 0,
+						      transformed_glyphs, num_glyphs,
+						      NULL, 0, 0,
+						      gstate->scaled_font,
+						      gstate->clip);
+	}
+    }
     else
+    {
 	cairo_path_fixed_t path;
 	    status = _cairo_surface_fill (gstate->target, op, pattern,
 					  &path,
 					  CAIRO_FILL_RULE_WINDING,
 					  gstate->tolerance,
 					  gstate->scaled_font->options.antialias,
-					  _gstate_get_clip (gstate, &clip));
+					  gstate->clip);
+	}
 	_cairo_path_fixed_fini (&path);
-    }
     _cairo_clip_fini (&clip);
 CLEANUP_GLYPHS:
     if (transformed_glyphs != stack_transformed_glyphs)
       cairo_glyph_free (transformed_glyphs);
 _cairo_gstate_glyph_path (cairo_gstate_t      *gstate,
 			  const cairo_glyph_t *glyphs,
 			  int		       num_glyphs,
 			  cairo_path_fixed_t  *path)
+{
-    cairo_status_t status;
-    cairo_glyph_t *transformed_glyphs;
     cairo_glyph_t stack_transformed_glyphs[CAIRO_STACK_ARRAY_LENGTH (cairo_glyph_t)];
+    cairo_glyph_t *transformed_glyphs;
+    cairo_status_t status;
     status = _cairo_gstate_ensure_scaled_font (gstate);
     if (unlikely (status))
 	transformed_glyphs = cairo_glyph_allocate (num_glyphs);
 	if (unlikely (transformed_glyphs == NULL))
 	    return _cairo_error (CAIRO_STATUS_NO_MEMORY);
+    }
-    status = _cairo_gstate_transform_glyphs_to_backend (gstate,
+    _cairo_gstate_transform_glyphs_to_backend (gstate,
-							glyphs, num_glyphs,
+					       glyphs, num_glyphs,
-							NULL, 0, 0,
+					       NULL, 0, 0,
-							transformed_glyphs,
+					       transformed_glyphs,
-							NULL, NULL);
-    if (unlikely (status))
-	goto CLEANUP_GLYPHS;
+					       &num_glyphs, NULL);
     status = _cairo_scaled_font_glyph_path (gstate->scaled_font,
-					    transformed_glyphs, num_glyphs,
-					    path);
+					    transformed_glyphs, num_glyphs,
 					    path);
   CLEANUP_GLYPHS:
     if (transformed_glyphs != stack_transformed_glyphs)
  * The result of the transformation is placed in @transformed_glyphs.
+ *
  * This also uses information from the scaled font and the surface to
  * cull/drop glyphs that will not be visible.
  **/
-static cairo_status_t
+static void
 _cairo_gstate_transform_glyphs_to_backend (cairo_gstate_t	*gstate,
                                            const cairo_glyph_t	*glyphs,
                                            int			 num_glyphs,
 					   const cairo_text_cluster_t	*clusters,
 					   int			 num_clusters,
 					   cairo_text_cluster_flags_t cluster_flags,
                                            cairo_glyph_t	*transformed_glyphs,
 					   int			*num_transformed_glyphs,
 					   cairo_text_cluster_t *transformed_clusters)
+{
-    int i, j, k;
+    cairo_rectangle_int_t surface_extents;
     cairo_matrix_t *ctm = &gstate->ctm;
     cairo_matrix_t *font_matrix = &gstate->font_matrix;
     cairo_matrix_t *device_transform = &gstate->target->device_transform;
     cairo_bool_t drop = FALSE;
     double x1 = 0, x2 = 0, y1 = 0, y2 = 0;
-    if (num_transformed_glyphs != NULL) {
+    int i, j, k;
-	cairo_rectangle_int_t surface_extents;
-	drop = TRUE;
+    drop = TRUE;
-	if (! _cairo_gstate_int_clip_extents (gstate, &surface_extents)) {
+    if (! _cairo_gstate_int_clip_extents (gstate, &surface_extents)) {
-	    drop = FALSE; /* unbounded surface */
+	drop = FALSE; /* unbounded surface */
-	} else {
+    } else {
-	    double scale10 = 10 * _cairo_scaled_font_get_max_scale (gstate->scaled_font);
+	double scale10 = 10 * _cairo_scaled_font_get_max_scale (gstate->scaled_font);
-	    if (surface_extents.width == 0 || surface_extents.height == 0) {
+	if (surface_extents.width == 0 || surface_extents.height == 0) {
-	      /* No visible area.  Don't draw anything */
+	  /* No visible area.  Don't draw anything */
-	      *num_transformed_glyphs = 0;
+	  *num_transformed_glyphs = 0;
-	      return CAIRO_STATUS_SUCCESS;
+	  return;
+	}
-	    /* XXX We currently drop any glyphs that has its position outside
+	/* XXX We currently drop any glyphs that has its position outside
-	     * of the surface boundaries by a safety margin depending on the
+	 * of the surface boundaries by a safety margin depending on the
-	     * font scale.  This however can fail in extreme cases where the
+	 * font scale.  This however can fail in extreme cases where the
-	    y2 = surface_extents.y + (int) surface_extents.height + scale10;
+	y2 = surface_extents.y + (int) surface_extents.height + scale10;
+    }
-	if (!drop)
+    if (!drop)
-	    *num_transformed_glyphs = num_glyphs;
-    } else
-	num_transformed_glyphs = &j;
+	*num_transformed_glyphs = num_glyphs;
 #define KEEP_GLYPH(glyph) (x1 <= glyph.x && glyph.x <= x2 && y1 <= glyph.y && glyph.y <= y2)
 	font_matrix->x0 == 0 && font_matrix->y0 == 0)
+    {
 	if (! drop) {
 	    memcpy (transformed_glyphs, glyphs,
 		    num_glyphs * sizeof (cairo_glyph_t));
+	    memcpy (transformed_clusters, clusters,
+		    num_clusters * sizeof (cairo_text_cluster_t));
 	    j = num_glyphs;
 	} else if (num_clusters == 0) {
 	    for (i = 0; i < num_glyphs; i++) {
 		transformed_glyphs[j].index = glyphs[i].index;
 		transformed_glyphs[j].x = glyphs[i].x;
 		transformed_glyphs[j].x = glyphs[i].x + tx;
 		transformed_glyphs[j].y = glyphs[i].y + ty;
 		if (!drop || KEEP_GLYPH (transformed_glyphs[j]))
 		    j++;
+	    }
+	    memcpy (transformed_clusters, clusters,
+		    num_clusters * sizeof (cairo_text_cluster_t));
 	} else {
 	    const cairo_glyph_t *cur_glyph;
 	    if (cluster_flags & CAIRO_TEXT_CLUSTER_FLAG_BACKWARD)
 					      &transformed_glyphs[j].x,
 					      &transformed_glyphs[j].y);
 		if (! drop || KEEP_GLYPH (transformed_glyphs[j]))
 		    j++;
+	    }
+	    memcpy (transformed_clusters, clusters,
+		    num_clusters * sizeof (cairo_text_cluster_t));
 	} else {
 	    const cairo_glyph_t *cur_glyph;
 	    if (cluster_flags & CAIRO_TEXT_CLUSTER_FLAG_BACKWARD)
 	    tmp = transformed_glyphs[i];
 	    transformed_glyphs[i] = transformed_glyphs[j];
 	    transformed_glyphs[j] = tmp;
+	}
+    }
-    return CAIRO_STATUS_SUCCESS;
+}

Subversion Repositories Kolibri OS

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