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

  *	Kristian Høgsberg
  *	Chris Wilson
  */
+#include "cairoint.h"
-#include "cairoint.h"
+#include "cairo-clip-inline.h"
 #include "cairo-clip-private.h"
 #include "cairo-error-private.h"
 #include "cairo-freed-pool-private.h"
 #include "cairo-gstate-private.h"
+#include "cairo-path-fixed-private.h"
-#include "cairo-path-fixed-private.h"
+#include "cairo-pattern-private.h"
 #include "cairo-composite-rectangles-private.h"
-#include "cairo-region-private.h"
 #include "cairo-region-private.h"
-#if HAS_FREED_POOL
+static freed_pool_t clip_path_pool;
+static freed_pool_t clip_pool;
 static freed_pool_t clip_path_pool;
-#endif
+const cairo_clip_t __cairo_clip_all;
 static cairo_clip_path_t *
 	    return NULL;
+    }
-    CAIRO_REFERENCE_COUNT_INIT (&clip_path->ref_count, 1);
-    clip_path->flags = 0;
-    clip_path->region = NULL;
-    clip_path->surface = NULL;
+    CAIRO_REFERENCE_COUNT_INIT (&clip_path->ref_count, 1);
     clip_path->prev = clip->path;
     clip->path = clip_path;
     return clip_path;
+}
-static cairo_clip_path_t *
+cairo_clip_path_t *
 _cairo_clip_path_reference (cairo_clip_path_t *clip_path)
+{
     assert (CAIRO_REFERENCE_COUNT_HAS_REFERENCE (&clip_path->ref_count));
     _cairo_reference_count_inc (&clip_path->ref_count);
     return clip_path;
+}
-static void
-_cairo_clip_path_destroy (cairo_clip_path_t *clip_path)
-{
-    assert (CAIRO_REFERENCE_COUNT_HAS_REFERENCE (&clip_path->ref_count));
 void
-    if (! _cairo_reference_count_dec_and_test (&clip_path->ref_count))
+_cairo_clip_path_destroy (cairo_clip_path_t *clip_path)
 	return;
     assert (CAIRO_REFERENCE_COUNT_HAS_REFERENCE (&clip_path->ref_count));
-    _cairo_path_fixed_fini (&clip_path->path);
-    if (clip_path->region != NULL)
+    if (! _cairo_reference_count_dec_and_test (&clip_path->ref_count))
-	cairo_region_destroy (clip_path->region);
+	return;
-    if (clip_path->surface != NULL)
+    _cairo_path_fixed_fini (&clip_path->path);
+    if (clip_path->prev != NULL)
+	_cairo_clip_path_destroy (clip_path->prev);
+    _freed_pool_put (&clip_path_pool, clip_path);
+}
+cairo_clip_t *
+_cairo_clip_create (void)
 	cairo_surface_destroy (clip_path->surface);
+    cairo_clip_t *clip;
+    clip = _freed_pool_get (&clip_pool);
+    if (unlikely (clip == NULL)) {
+	clip = malloc (sizeof (cairo_clip_t));
+	if (unlikely (clip == NULL))
 	    return NULL;
-    if (clip_path->prev != NULL)
+    }
-	_cairo_clip_path_destroy (clip_path->prev);
     clip->extents = _cairo_unbounded_rectangle;
-    _freed_pool_put (&clip_path_pool, clip_path);
+    clip->path = NULL;
+    clip->boxes = NULL;
-}
+    clip->num_boxes = 0;
     clip->region = NULL;
+    clip->is_region = FALSE;
-void
+    return clip;
+}
-_cairo_clip_init (cairo_clip_t *clip)
+void
 _cairo_clip_destroy (cairo_clip_t *clip)
-    clip->all_clipped = FALSE;
+{
-    clip->path = NULL;
+    if (clip == NULL || _cairo_clip_is_all_clipped (clip))
-}
 	return;
-static void
-_cairo_clip_set_all_clipped (cairo_clip_t *clip)
-{
-    clip->all_clipped = TRUE;
-    if (clip->path != NULL) {
+    if (clip->path != NULL)
-	_cairo_clip_path_destroy (clip->path);
-	clip->path = NULL;
-    }
-}
+	_cairo_clip_path_destroy (clip->path);
-static cairo_status_t
-_cairo_clip_intersect_rectangle (cairo_clip_t *clip,
-				 const cairo_rectangle_int_t *rect)
-{
+    if (clip->boxes != &clip->embedded_box)
-    cairo_clip_path_t *clip_path;
+	free (clip->boxes);
-    cairo_status_t status;
-    if (clip->path != NULL) {
-	if (rect->x <= clip->path->extents.x &&
-	    rect->y <= clip->path->extents.y &&
-	    rect->x + rect->width >= clip->path->extents.x + clip->path->extents.width &&
-	    rect->y + rect->height >= clip->path->extents.y + clip->path->extents.height)
+    cairo_region_destroy (clip->region);
-	{
-	    return CAIRO_STATUS_SUCCESS;
-	}
-    }
+    _freed_pool_put (&clip_pool, clip);
-    clip_path = _cairo_clip_path_create (clip);
-    if (unlikely (clip_path == NULL))
-	return _cairo_error (CAIRO_STATUS_NO_MEMORY);
+}
-    _cairo_path_fixed_init (&clip_path->path);
-    status = _cairo_path_fixed_move_to (&clip_path->path,
-					_cairo_fixed_from_int (rect->x),
-					_cairo_fixed_from_int (rect->y));
-    assert (status == CAIRO_STATUS_SUCCESS);
-    status = _cairo_path_fixed_rel_line_to (&clip_path->path,
-					    _cairo_fixed_from_int (rect->width),
-					    _cairo_fixed_from_int (0));
-    assert (status == CAIRO_STATUS_SUCCESS);
+cairo_clip_t *
-    status = _cairo_path_fixed_rel_line_to (&clip_path->path,
-					    _cairo_fixed_from_int (0),
-					    _cairo_fixed_from_int (rect->height));
-    assert (status == CAIRO_STATUS_SUCCESS);
+_cairo_clip_copy (const cairo_clip_t *clip)
     status = _cairo_path_fixed_rel_line_to (&clip_path->path,
+    cairo_clip_t *copy;
+    if (clip == NULL || _cairo_clip_is_all_clipped (clip))
+	return (cairo_clip_t *) clip;
 					    _cairo_fixed_from_int (-rect->width),
+    copy = _cairo_clip_create ();
-					    _cairo_fixed_from_int (0));
+    if (clip->path)
-    assert (status == CAIRO_STATUS_SUCCESS);
+	copy->path = _cairo_clip_path_reference (clip->path);
     status = _cairo_path_fixed_close_path (&clip_path->path);
-    assert (status == CAIRO_STATUS_SUCCESS);
+    if (clip->num_boxes) {
+	if (clip->num_boxes == 1) {
-    clip_path->fill_rule = CAIRO_FILL_RULE_WINDING;
+	    copy->boxes = ©->embedded_box;
-    clip_path->tolerance = 1;
+	} else {
+	    copy->boxes = _cairo_malloc_ab (clip->num_boxes, sizeof (cairo_box_t));
-    clip_path->antialias = CAIRO_ANTIALIAS_DEFAULT;
+	    if (unlikely (copy->boxes == NULL))
-    clip_path->flags |= CAIRO_CLIP_PATH_IS_BOX;
+		return _cairo_clip_set_all_clipped (copy);
+	}
+	memcpy (copy->boxes, clip->boxes,
-    clip_path->extents = *rect;
+		clip->num_boxes * sizeof (cairo_box_t));
-    if (clip_path->prev != NULL) {
+	copy->num_boxes = clip->num_boxes;
-	if (! _cairo_rectangle_intersect (&clip_path->extents,
+    }
-					  &clip_path->prev->extents))
+    copy->extents = clip->extents;
+    copy->region = cairo_region_reference (clip->region);
     copy->is_region = clip->is_region;
+    return copy;
+}
+cairo_clip_t *
+_cairo_clip_copy_path (const cairo_clip_t *clip)
+{
+    cairo_clip_t *copy;
+    if (clip == NULL || _cairo_clip_is_all_clipped (clip))
+	return (cairo_clip_t *) clip;
+    assert (clip->num_boxes);
+    copy = _cairo_clip_create ();
+    copy->extents = clip->extents;
+    if (clip->path)
-	    _cairo_clip_set_all_clipped (clip);
+	copy->path = _cairo_clip_path_reference (clip->path);
-	}
-    }
+    return copy;
+}
-    /* could preallocate the region if it proves worthwhile */
+cairo_clip_t *
+_cairo_clip_copy_region (const cairo_clip_t *clip)
+{
+    cairo_clip_t *copy;
+    int i;
+    if (clip == NULL || _cairo_clip_is_all_clipped (clip))
-    return CAIRO_STATUS_SUCCESS;
-}
+	return (cairo_clip_t *) clip;
+    assert (clip->num_boxes);
-cairo_clip_t *
-_cairo_clip_init_copy (cairo_clip_t *clip, cairo_clip_t *other)
-{
-    if (other != NULL) {
-	clip->all_clipped = other->all_clipped;
-	if (other->path == NULL) {
+    copy = _cairo_clip_create ();
-	    clip->path = NULL;
+    copy->extents = clip->extents;
 	    if (! clip->all_clipped)
-		clip = NULL;
+    if (clip->num_boxes == 1) {
-	} else {
+	copy->boxes = ©->embedded_box;
-	    clip->path = _cairo_clip_path_reference (other->path);
+    } else {
 	copy->boxes = _cairo_malloc_ab (clip->num_boxes, sizeof (cairo_box_t));
-    } else {
+	if (unlikely (copy->boxes == NULL))
-	_cairo_clip_init (clip);
+	    return _cairo_clip_set_all_clipped (copy);
 	clip = NULL;
     for (i = 0; i < clip->num_boxes; i++) {
-    return clip;
-}
-void
-_cairo_clip_reset (cairo_clip_t *clip)
-{
+	copy->boxes[i].p1.x = _cairo_fixed_floor (clip->boxes[i].p1.x);
-    clip->all_clipped = FALSE;
-    if (clip->path != NULL) {
+	copy->boxes[i].p1.y = _cairo_fixed_floor (clip->boxes[i].p1.y);
-	_cairo_clip_path_destroy (clip->path);
-	clip->path = NULL;
-    }
+	copy->boxes[i].p2.x = _cairo_fixed_ceil (clip->boxes[i].p2.x);
-}
+	copy->boxes[i].p2.y = _cairo_fixed_ceil (clip->boxes[i].p2.y);
+    }
-static cairo_status_t
-_cairo_clip_intersect_path (cairo_clip_t       *clip,
-			    const cairo_path_fixed_t *path,
+    copy->num_boxes = clip->num_boxes;
-			    cairo_fill_rule_t   fill_rule,
-			    double              tolerance,
+    copy->region = cairo_region_reference (clip->region);
-			    cairo_antialias_t   antialias)
+    copy->is_region = TRUE;
-{
+    return copy;
-    cairo_clip_path_t *clip_path;
+}
+cairo_clip_t *
+_cairo_clip_intersect_path (cairo_clip_t       *clip,
+			    const cairo_path_fixed_t *path,
+			    cairo_fill_rule_t   fill_rule,
+			    double              tolerance,
-    cairo_status_t status;
-    cairo_rectangle_int_t extents;
-    cairo_box_t box;
+			    cairo_antialias_t   antialias)
-    cairo_bool_t is_box = FALSE;
+{
+    cairo_clip_path_t *clip_path;
-    if (clip->path != NULL) {
-	if (clip->path->fill_rule == fill_rule &&
+    cairo_status_t status;
+    cairo_rectangle_int_t extents;
-	    (path->is_rectilinear || tolerance == clip->path->tolerance) &&
+    cairo_box_t box;
-	    antialias == clip->path->antialias &&
-	    _cairo_path_fixed_equal (&clip->path->path, path))
     if (_cairo_clip_is_all_clipped (clip))
-	    return CAIRO_STATUS_SUCCESS;
+	return clip;
-	}
     /* catch the empty clip path */
+    if (_cairo_path_fixed_fill_is_empty (path))
-    _cairo_path_fixed_approximate_clip_extents (path, &extents);
-    if (extents.width == 0 || extents.height == 0) {
+	return _cairo_clip_set_all_clipped (clip);
-	_cairo_clip_set_all_clipped (clip);
-	return CAIRO_STATUS_SUCCESS;
-    }
-    is_box = _cairo_path_fixed_is_box (path, &box);
+    if (_cairo_path_fixed_is_box (path, &box)) {
-    if (clip->path != NULL) {
+	if (antialias == CAIRO_ANTIALIAS_NONE) {
-	if (! _cairo_rectangle_intersect (&extents, &clip->path->extents)) {
-	    _cairo_clip_set_all_clipped (clip);
+	    box.p1.x = _cairo_fixed_round_down (box.p1.x);
-	    return CAIRO_STATUS_SUCCESS;
+	    box.p1.y = _cairo_fixed_round_down (box.p1.y);
+	    box.p2.x = _cairo_fixed_round_down (box.p2.x);
 	    box.p2.y = _cairo_fixed_round_down (box.p2.y);
+	}
+	return _cairo_clip_intersect_box (clip, &box);
+    }
+    if (_cairo_path_fixed_fill_is_rectilinear (path))
-	/* does this clip wholly subsume the others? */
+	return _cairo_clip_intersect_rectilinear_path (clip, path,
-	if (is_box &&
+						       fill_rule, antialias);
 	    box.p1.x <= _cairo_fixed_from_int (clip->path->extents.x) &&
+    _cairo_path_fixed_approximate_clip_extents (path, &extents);
-	    box.p2.x >= _cairo_fixed_from_int (clip->path->extents.x + clip->path->extents.width) &&
+    if (extents.width == 0 || extents.height == 0)
+	return _cairo_clip_set_all_clipped (clip);
-	    box.p1.y <= _cairo_fixed_from_int (clip->path->extents.y) &&
+    clip = _cairo_clip_intersect_rectangle (clip, &extents);
+    if (_cairo_clip_is_all_clipped (clip))
-	    box.p2.y >= _cairo_fixed_from_int (clip->path->extents.y + clip->path->extents.height))
+	return clip;
+    clip_path = _cairo_clip_path_create (clip);
-	{
+    if (unlikely (clip_path == NULL))
-	    return CAIRO_STATUS_SUCCESS;
+	return _cairo_clip_set_all_clipped (clip);
+    status = _cairo_path_fixed_init_copy (&clip_path->path, path);
-	}
+    if (unlikely (status))
-    }
+	return _cairo_clip_set_all_clipped (clip);
-    clip_path = _cairo_clip_path_create (clip);
+    clip_path->fill_rule = fill_rule;
-    if (unlikely (clip_path == NULL))
+    clip_path->tolerance = tolerance;
-	return _cairo_error (CAIRO_STATUS_NO_MEMORY);
+    clip_path->antialias = antialias;
-    status = _cairo_path_fixed_init_copy (&clip_path->path, path);
+    if (clip->region) {
-    if (unlikely (status)) {
+	cairo_region_destroy (clip->region);
-	clip->path = clip->path->prev;
+	clip->region = NULL;
-	_cairo_clip_path_destroy (clip_path);
+    }
-	return status;
-    }
+    clip->is_region = FALSE;
     return clip;
-    clip_path->extents = extents;
-    clip_path->fill_rule = fill_rule;
+}
-    clip_path->tolerance = tolerance;
-    clip_path->antialias = antialias;
+static cairo_clip_t *
-    if (is_box)
+_cairo_clip_intersect_clip_path (cairo_clip_t *clip,
+				 const cairo_clip_path_t *clip_path)
-	clip_path->flags |= CAIRO_CLIP_PATH_IS_BOX;
+{
+    if (clip_path->prev)
-    return CAIRO_STATUS_SUCCESS;
+	clip = _cairo_clip_intersect_clip_path (clip, clip_path->prev);
-}
-cairo_bool_t
-_cairo_clip_equal (const cairo_clip_t *clip_a,
+    return _cairo_clip_intersect_path (clip,
-		   const cairo_clip_t *clip_b)
+				       &clip_path->path,
 				       clip_path->fill_rule,
+				       clip_path->tolerance,
-    const cairo_clip_path_t *clip_path_a, *clip_path_b;
-    clip_path_a = clip_a->path;
+				       clip_path->antialias);
     clip_path_b = clip_b->path;
-    while (clip_path_a && clip_path_b) {
+cairo_clip_t *
-	if (clip_path_a == clip_path_b)
+_cairo_clip_intersect_clip (cairo_clip_t *clip,
-	    return TRUE;
+			    const cairo_clip_t *other)
+{
-	if (clip_path_a->fill_rule != clip_path_b->fill_rule)
-	    return FALSE;
+    if (_cairo_clip_is_all_clipped (clip))
+	return clip;
-	if (clip_path_a->tolerance != clip_path_b->tolerance)
-	    return FALSE;
+    if (other == NULL)
-	if (clip_path_a->antialias != clip_path_b->antialias)
+	return clip;
-	    return FALSE;
+    if (clip == NULL)
-	if (! _cairo_path_fixed_equal (&clip_path_a->path, &clip_path_b->path))
-	    return FALSE;
 	return _cairo_clip_copy (other);
-	clip_path_a = clip_path_a->prev;
-	clip_path_b = clip_path_b->prev;
     if (_cairo_clip_is_all_clipped (other))
+	return _cairo_clip_set_all_clipped (clip);
-    return clip_path_a == clip_path_b; /* ie both NULL */
-}
-cairo_status_t
-_cairo_clip_clip (cairo_clip_t       *clip,
-		  const cairo_path_fixed_t *path,
-		  cairo_fill_rule_t   fill_rule,
-		  double              tolerance,
-		  cairo_antialias_t   antialias)
+    if (! _cairo_rectangle_intersect (&clip->extents, &other->extents))
-{
+	return _cairo_clip_set_all_clipped (clip);
-    if (clip->all_clipped)
-	return CAIRO_STATUS_SUCCESS;
-    /* catch the empty clip path */
-    if (_cairo_path_fixed_fill_is_empty (path)) {
+    if (other->num_boxes) {
-	_cairo_clip_set_all_clipped (clip);
-	return CAIRO_STATUS_SUCCESS;
+	cairo_boxes_t boxes;
-    }
+	_cairo_boxes_init_for_array (&boxes, other->boxes, other->num_boxes);
+	clip = _cairo_clip_intersect_boxes (clip, &boxes);
+    }
-    return _cairo_clip_intersect_path (clip,
-				       path, fill_rule, tolerance,
-				       antialias);
-}
-cairo_status_t
-_cairo_clip_rectangle (cairo_clip_t       *clip,
-		       const cairo_rectangle_int_t *rectangle)
+    if (! _cairo_clip_is_all_clipped (clip)) {
-{
-    if (clip->all_clipped)
-	return CAIRO_STATUS_SUCCESS;
+	if (other->path) {
-    if (rectangle->width == 0 || rectangle->height == 0) {
-	_cairo_clip_set_all_clipped (clip);
-	return CAIRO_STATUS_SUCCESS;
-    }
+	    if (clip->path == NULL)
+		clip->path = _cairo_clip_path_reference (other->path);
+	    else
+		clip = _cairo_clip_intersect_clip_path (clip, other->path);
+	}
+    }
-    /* if a smaller clip has already been set, ignore the new path */
+    if (clip->region) {
+	cairo_region_destroy (clip->region);
+	clip->region = NULL;
+    }
-    if (clip->path != NULL) {
+    clip->is_region = FALSE;
+    return clip;
+}
-	if (rectangle->x <= clip->path->extents.x &&
-	    rectangle->y <= clip->path->extents.y &&
+cairo_bool_t
-	    rectangle->x + rectangle->width  >= clip->path->extents.x + clip->path->extents.width &&
+_cairo_clip_equal (const cairo_clip_t *clip_a,
-	    rectangle->y + rectangle->height >= clip->path->extents.y + clip->path->extents.height)
+		   const cairo_clip_t *clip_b)
+{
-	    return CAIRO_STATUS_SUCCESS;
+    const cairo_clip_path_t *cp_a, *cp_b;
-    }
+    /* are both all-clipped or no-clip? */
+    if (clip_a == clip_b)
-    return _cairo_clip_intersect_rectangle (clip, rectangle);
-}
+	return TRUE;
-static cairo_status_t
+    /* or just one of them? */
-_cairo_clip_path_reapply_clip_path_transform (cairo_clip_t      *clip,
-					      cairo_clip_path_t *other_path,
+    if (clip_a == NULL || clip_b == NULL ||
-					      const cairo_matrix_t *matrix)
+	_cairo_clip_is_all_clipped (clip_a) ||
-{
+	_cairo_clip_is_all_clipped (clip_b))
     cairo_status_t status;
-    cairo_clip_path_t *clip_path;
+	return FALSE;
-    cairo_bool_t is_empty;
+    }
-    if (other_path->prev != NULL) {
-        status = _cairo_clip_path_reapply_clip_path_transform (clip,
-							       other_path->prev,
-							       matrix);
+    /* We have a pair of normal clips, check their contents */
-	if (unlikely (status))
-	    return status;
     if (clip_a->num_boxes != clip_b->num_boxes)
-    clip_path = _cairo_clip_path_create (clip);
+	return FALSE;
-    if (unlikely (clip_path == NULL))
-	return _cairo_error (CAIRO_STATUS_NO_MEMORY);
-    status = _cairo_path_fixed_init_copy (&clip_path->path,
-					  &other_path->path);
-    if (unlikely (status)) {
-	clip->path = clip->path->prev;
-	_cairo_clip_path_destroy (clip_path);
-	return status;
-    }
-    _cairo_path_fixed_transform (&clip_path->path, matrix);
-    _cairo_path_fixed_approximate_clip_extents (&clip_path->path,
-						&clip_path->extents);
-    if (clip_path->prev != NULL) {
-	is_empty = _cairo_rectangle_intersect (&clip_path->extents,
-					       &clip_path->prev->extents);
-    }
-    clip_path->fill_rule = other_path->fill_rule;
-    clip_path->tolerance = other_path->tolerance;
-    clip_path->antialias = other_path->antialias;
-    return CAIRO_STATUS_SUCCESS;
-}
-static cairo_status_t
-_cairo_clip_path_reapply_clip_path_translate (cairo_clip_t      *clip,
-					      cairo_clip_path_t *other_path,
-					      int tx, int ty)
-{
-    cairo_status_t status;
-    cairo_clip_path_t *clip_path;
-    if (other_path->prev != NULL) {
-        status = _cairo_clip_path_reapply_clip_path_translate (clip,
-							       other_path->prev,
-							       tx, ty);
-	if (unlikely (status))
-	    return status;
-    }
-    clip_path = _cairo_clip_path_create (clip);
-    if (unlikely (clip_path == NULL))
-	return _cairo_error (CAIRO_STATUS_NO_MEMORY);
-    status = _cairo_path_fixed_init_copy (&clip_path->path,
-					  &other_path->path);
-    if (unlikely (status)) {
-	clip->path = clip->path->prev;
-	_cairo_clip_path_destroy (clip_path);
-	return status;
-    }
-    _cairo_path_fixed_translate (&clip_path->path,
-				 _cairo_fixed_from_int (tx),
-				 _cairo_fixed_from_int (ty));
-    clip_path->fill_rule = other_path->fill_rule;
-    clip_path->tolerance = other_path->tolerance;
-    clip_path->antialias = other_path->antialias;
-    clip_path->flags = other_path->flags;
-    if (other_path->region != NULL) {
-	clip_path->region = cairo_region_copy (other_path->region);
-	status = clip_path->region->status;
-	if (unlikely (status)) {
-	    clip->path = clip->path->prev;
-	    _cairo_clip_path_destroy (clip_path);
-	    return status;
+    if (memcmp (clip_a->boxes, clip_b->boxes,
-	}
+		sizeof (cairo_box_t) * clip_a->num_boxes))
+	return FALSE;
-	cairo_region_translate (clip_path->region, tx, ty);
-    clip_path->surface = cairo_surface_reference (other_path->surface);
+    cp_a = clip_a->path;
-    clip_path->extents = other_path->extents;
-    clip_path->extents.x += tx;
+    cp_b = clip_b->path;
-    clip_path->extents.y += ty;
+    while (cp_a && cp_b) {
-    return CAIRO_STATUS_SUCCESS;
-}
+	if (cp_a == cp_b)
-cairo_status_t
-_cairo_clip_init_copy_transformed (cairo_clip_t    *clip,
-				   cairo_clip_t    *other,
-				   const cairo_matrix_t *matrix)
+	    return TRUE;
-{
-    cairo_status_t status = CAIRO_STATUS_SUCCESS;
-    int tx, ty;
+	/* XXX compare reduced polygons? */
-    if (other == NULL) {
+	if (cp_a->antialias != cp_b->antialias)
+	    return FALSE;
-	_cairo_clip_init (clip);
+	if (cp_a->tolerance != cp_b->tolerance)
-	return CAIRO_STATUS_SUCCESS;
+	    return FALSE;
-    if (other->all_clipped) {
+	if (cp_a->fill_rule != cp_b->fill_rule)
-	_cairo_clip_init (clip);
-	clip->all_clipped = TRUE;
-	return CAIRO_STATUS_SUCCESS;
+	    return FALSE;
-    }
-    if (_cairo_matrix_is_identity (matrix)) {
-	_cairo_clip_init_copy (clip, other);
-	return CAIRO_STATUS_SUCCESS;
-    }
+	if (! _cairo_path_fixed_equal (&cp_a->path,
-    if (other->path != NULL) {
+				       &cp_b->path))
-	_cairo_clip_init (clip);
+	    return FALSE;
+	cp_a = cp_a->prev;
+	cp_b = cp_b->prev;
 	/* if we only need to translate, so we can reuse the caches... */
-	/* XXX we still loose the benefit of constructs when the copy is
-	 * deleted though. Indirect clip_paths?
+    return cp_a == NULL && cp_b == NULL;
+}
 	 */
-	if (_cairo_matrix_is_integer_translation (matrix, &tx, &ty)) {
-	    status = _cairo_clip_path_reapply_clip_path_translate (clip,
-								   other->path,
-								   tx, ty);
+static cairo_clip_t *
-	} else {
-	    status = _cairo_clip_path_reapply_clip_path_transform (clip,
-								   other->path,
-								   matrix);
-	    if (clip->path->extents.width == 0 &&
-		clip->path->extents.height == 0)
-	    {
-		_cairo_clip_set_all_clipped (clip);
-	    }
-	}
-    }
-    return status;
-}
-static cairo_status_t
-_cairo_clip_apply_clip_path (cairo_clip_t *clip,
-			     const cairo_clip_path_t *path)
-{
-    cairo_status_t status;
-    if (path->prev != NULL)
-	status = _cairo_clip_apply_clip_path (clip, path->prev);
-    return _cairo_clip_intersect_path (clip,
-				       &path->path,
-				       path->fill_rule,
-				       path->tolerance,
-				       path->antialias);
-}
-cairo_status_t
-_cairo_clip_apply_clip (cairo_clip_t *clip,
-			const cairo_clip_t *other)
-{
-    cairo_status_t status;
-    if (clip->all_clipped)
-	return CAIRO_STATUS_SUCCESS;
-    if (other->all_clipped) {
-	_cairo_clip_set_all_clipped (clip);
-	return CAIRO_STATUS_SUCCESS;
-    }
-    status = CAIRO_STATUS_SUCCESS;
-    if (other->path != NULL)
+_cairo_clip_path_copy_with_translation (cairo_clip_t      *clip,
-	status = _cairo_clip_apply_clip_path (clip, other->path);
+					cairo_clip_path_t *other_path,
 					int fx, int fy)
-    return status;
+{
-}
-static inline cairo_bool_t
-_clip_paths_are_rectilinear (cairo_clip_path_t *clip_path)
     cairo_status_t status;
-    while (clip_path != NULL) {
+    cairo_clip_path_t *clip_path;
-	if (! clip_path->path.is_rectilinear)
-	    return FALSE;
-	clip_path = clip_path->prev;
-    }
-    return TRUE;
-}
-static cairo_int_status_t
-_cairo_clip_path_to_region_geometric (cairo_clip_path_t *clip_path)
-{
-    cairo_traps_t traps;
-    cairo_box_t stack_boxes[CAIRO_STACK_ARRAY_LENGTH (cairo_box_t)];
-    cairo_box_t *boxes = stack_boxes;
-    cairo_status_t status;
-    int n;
-    /* If we have nothing to intersect with this path, then it cannot
-     * magically be reduced into a region.
-     */
-    if (clip_path->prev == NULL)
-	goto UNSUPPORTED;
-    /* Start simple... Intersect some boxes with an arbitrary path. */
-    if (! clip_path->path.is_rectilinear)
-	goto UNSUPPORTED;
-    if (clip_path->prev->prev != NULL)
-	goto UNSUPPORTED;
-    _cairo_traps_init (&traps);
-    _cairo_box_from_rectangle (&boxes[0], &clip_path->extents);
-    _cairo_traps_limit (&traps, boxes, 1);
-    status = _cairo_path_fixed_fill_rectilinear_to_traps (&clip_path->path,
-							  clip_path->fill_rule,
-							  &traps);
-    if (unlikely (_cairo_status_is_error (status)))
-	return status;
-    if (status == CAIRO_INT_STATUS_UNSUPPORTED)
-	goto UNSUPPORTED;
-    if (traps.num_traps > ARRAY_LENGTH (stack_boxes)) {
-	boxes = _cairo_malloc_ab (traps.num_traps, sizeof (cairo_box_t));
-	if (unlikely (boxes == NULL))
-	    return _cairo_error (CAIRO_STATUS_NO_MEMORY);
-    }
     if (other_path->prev != NULL)
-    for (n = 0; n < traps.num_traps; n++) {
+	clip = _cairo_clip_path_copy_with_translation (clip, other_path->prev,
-	boxes[n].p1.x = traps.traps[n].left.p1.x;
-	boxes[n].p1.y = traps.traps[n].top;
+						       fx, fy);
-	boxes[n].p2.x = traps.traps[n].right.p1.x;
+    if (_cairo_clip_is_all_clipped (clip))
-	boxes[n].p2.y = traps.traps[n].bottom;
+	return clip;
-    }
-    _cairo_traps_clear (&traps);
-    _cairo_traps_limit (&traps, boxes, n);
-    status = _cairo_path_fixed_fill_to_traps (&clip_path->prev->path,
-					      clip_path->prev->fill_rule,
-					      clip_path->prev->tolerance,
-					      &traps);
-    if (boxes != stack_boxes)
-	free (boxes);
-    if (unlikely (status))
-	return status;
-    status = _cairo_traps_extract_region (&traps, &clip_path->region);
-    _cairo_traps_fini (&traps);
-    if (status == CAIRO_INT_STATUS_UNSUPPORTED)
-	goto UNSUPPORTED;
-    if (unlikely (status))
-	return status;
-    clip_path->flags |= CAIRO_CLIP_PATH_HAS_REGION;
-    return CAIRO_STATUS_SUCCESS;
-UNSUPPORTED:
-    clip_path->flags |= CAIRO_CLIP_PATH_REGION_IS_UNSUPPORTED;
-    return CAIRO_INT_STATUS_UNSUPPORTED;
-}
-static cairo_int_status_t
-_cairo_clip_path_to_region (cairo_clip_path_t *clip_path)
-{
-    cairo_int_status_t status;
-    cairo_region_t *prev = NULL;
-    if (clip_path->flags &
-	(CAIRO_CLIP_PATH_HAS_REGION |
-	 CAIRO_CLIP_PATH_REGION_IS_UNSUPPORTED))
-    {
-	return clip_path->flags & CAIRO_CLIP_PATH_REGION_IS_UNSUPPORTED ?
-	    CAIRO_INT_STATUS_UNSUPPORTED :
-	    CAIRO_STATUS_SUCCESS;
-    }
-    if (! clip_path->path.maybe_fill_region)
-	return _cairo_clip_path_to_region_geometric (clip_path);
-    /* first retrieve the region for our antecedents */
-    if (clip_path->prev != NULL) {
-	status = _cairo_clip_path_to_region (clip_path->prev);
-	if (status) {
-	    if (status == CAIRO_INT_STATUS_UNSUPPORTED)
-		return _cairo_clip_path_to_region_geometric (clip_path);
-	    return status;
-	}
-	prev = clip_path->prev->region;
-    }
-    /* now extract the region for ourselves */
-    clip_path->region =
-	_cairo_path_fixed_fill_rectilinear_to_region (&clip_path->path,
-						      clip_path->fill_rule,
-						      &clip_path->extents);
-    assert (clip_path->region != NULL);
-    status = clip_path->region->status;
-    if (unlikely (status))
-	return status;
-    if (prev != NULL) {
-	status = cairo_region_intersect (clip_path->region, prev);
-	if (unlikely (status))
-	    return status;
-    }
-    clip_path->flags |= CAIRO_CLIP_PATH_HAS_REGION;
-    return CAIRO_STATUS_SUCCESS;
-}
-static inline int
-pot (int v)
-{
-    v--;
-    v |= v >> 1;
-    v |= v >> 2;
+    clip_path = _cairo_clip_path_create (clip);
-    v |= v >> 4;
+    if (unlikely (clip_path == NULL))
-    v |= v >> 8;
+	return _cairo_clip_set_all_clipped (clip);
-    v |= v >> 16;
-    v++;
-    return v;
-}
     status = _cairo_path_fixed_init_copy (&clip_path->path,
-/* XXX there is likely a faster method! ;-) */
-static cairo_status_t
-_region_clip_to_boxes (const cairo_region_t *region,
+					  &other_path->path);
-		       cairo_box_t **boxes,
-		       int *num_boxes,
-		       int *size_boxes)
-{
-    cairo_traps_t traps;
-    cairo_status_t status;
-    int n, num_rects;
-    _cairo_traps_init (&traps);
-    _cairo_traps_limit (&traps, *boxes, *num_boxes);
-    traps.is_rectilinear = TRUE;
+    if (unlikely (status))
-    traps.is_rectangular = TRUE;
-    num_rects = cairo_region_num_rectangles (region);
-    for (n = 0; n < num_rects; n++) {
-	cairo_rectangle_int_t rect;
-	cairo_point_t p1, p2;
-	cairo_region_get_rectangle (region, n, &rect);
-	p1.x = _cairo_fixed_from_int (rect.x);
-	p1.y = _cairo_fixed_from_int (rect.y);
-	p2.x = _cairo_fixed_from_int (rect.x + rect.width);
-	p2.y = _cairo_fixed_from_int (rect.y + rect.height);
-	status = _cairo_traps_tessellate_rectangle (&traps, &p1, &p2);
-	if (unlikely (status))
-	    goto CLEANUP;
+	return _cairo_clip_set_all_clipped (clip);
-    }
-    status = _cairo_bentley_ottmann_tessellate_rectangular_traps (&traps, CAIRO_FILL_RULE_WINDING);
-    if (unlikely (status))
-	goto CLEANUP;
+    _cairo_path_fixed_translate (&clip_path->path, fx, fy);
-    n = *size_boxes;
-    if (n < 0)
-	n = -n;
-    if (traps.num_traps > n) {
-	cairo_box_t *new_boxes;
-	new_boxes = _cairo_malloc_ab (traps.num_traps, sizeof (cairo_box_t));
-	if (unlikely (new_boxes == NULL)) {
-	    status = _cairo_error (CAIRO_STATUS_NO_MEMORY);
-	    goto CLEANUP;
-	}
-	if (*size_boxes > 0)
-	    free (*boxes);
+    clip_path->fill_rule = other_path->fill_rule;
-	*boxes = new_boxes;
+    clip_path->tolerance = other_path->tolerance;
-	*size_boxes = traps.num_traps;
+    clip_path->antialias = other_path->antialias;
-    }
+    return clip;
-    for (n = 0; n < traps.num_traps; n++) {
+}
 	(*boxes)[n].p1.x = traps.traps[n].left.p1.x;
-	(*boxes)[n].p1.y = traps.traps[n].top;
-	(*boxes)[n].p2.x = traps.traps[n].right.p1.x;
+cairo_clip_t *
-	(*boxes)[n].p2.y = traps.traps[n].bottom;
+_cairo_clip_translate (cairo_clip_t *clip, int tx, int ty)
-    }
-    *num_boxes = n;
-  CLEANUP:
-    _cairo_traps_fini (&traps);
+{
     int fx, fy, i;
-    return status;
+    cairo_clip_path_t *clip_path;
-}
+    if (clip == NULL || _cairo_clip_is_all_clipped (clip))
-static cairo_status_t
+	return clip;
 _rectilinear_clip_to_boxes (const cairo_path_fixed_t *path,
-			    cairo_fill_rule_t fill_rule,
-			    cairo_box_t **boxes,
-			    int *num_boxes,
+    if (tx == 0 && ty == 0)
-			    int *size_boxes)
-{
-    cairo_polygon_t polygon;
-    cairo_traps_t traps;
-    cairo_status_t status;
-    _cairo_traps_init (&traps);
-    _cairo_traps_limit (&traps, *boxes, *num_boxes);
-    _cairo_polygon_init (&polygon);
-    _cairo_polygon_limit (&polygon, *boxes, *num_boxes);
+	return clip;
-    status = _cairo_path_fixed_fill_rectilinear_to_traps (path,
-							  fill_rule,
-							  &traps);
-    if (unlikely (_cairo_status_is_error (status)))
+    fx = _cairo_fixed_from_int (tx);
+    fy = _cairo_fixed_from_int (ty);
-	goto CLEANUP;
-    if (status == CAIRO_STATUS_SUCCESS)
+    for (i = 0; i < clip->num_boxes; i++) {
-	goto BOXES;
-    /* tolerance will be ignored as the path is rectilinear */
-    status = _cairo_path_fixed_fill_to_polygon (path, 0., &polygon);
-    if (unlikely (status))
-	goto CLEANUP;
+	clip->boxes[i].p1.x += fx;
-    if (polygon.num_edges == 0) {
-	*num_boxes = 0;
+	clip->boxes[i].p2.x += fx;
-    } else {
-	status = _cairo_bentley_ottmann_tessellate_rectilinear_polygon (&traps,
-									&polygon,
-									fill_rule);
-	if (likely (status == CAIRO_STATUS_SUCCESS)) {
-	    int i;
+	clip->boxes[i].p1.y += fy;
-          BOXES:
+	clip->boxes[i].p2.y += fy;
-	    i = *size_boxes;
+    }
-	    if (i < 0)
-		i = -i;
-	    if (traps.num_traps > i) {
-		cairo_box_t *new_boxes;
-		int new_size;
-		new_size = pot (traps.num_traps);
-		new_boxes = _cairo_malloc_ab (new_size, sizeof (cairo_box_t));
-		if (unlikely (new_boxes == NULL)) {
-		    status = _cairo_error (CAIRO_STATUS_NO_MEMORY);
-		    goto CLEANUP;
-		}
-		if (*size_boxes > 0)
+    clip->extents.x += tx;
-		    free (*boxes);
-		*boxes = new_boxes;
+    clip->extents.y += ty;
-		*size_boxes = new_size;
-	    }
+    if (clip->path == NULL)
-	    for (i = 0; i < traps.num_traps; i++) {
+	return clip;
-		(*boxes)[i].p1.x = traps.traps[i].left.p1.x;
+    clip_path = clip->path;
-		(*boxes)[i].p1.y = traps.traps[i].top;
+    clip->path = NULL;
-		(*boxes)[i].p2.x = traps.traps[i].right.p1.x;
+    clip = _cairo_clip_path_copy_with_translation (clip, clip_path, fx, fy);
-		(*boxes)[i].p2.y = traps.traps[i].bottom;
-	    }
-	    *num_boxes = i;
+    _cairo_clip_path_destroy (clip_path);
-	}
-    }
-  CLEANUP:
-    _cairo_polygon_fini (&polygon);
-    _cairo_traps_fini (&traps);
-    return status;
+    return clip;
-}
-static cairo_int_status_t
-_cairo_clip_path_to_boxes (cairo_clip_path_t *clip_path,
+}
-			   cairo_box_t **boxes,
-			   int *count)
+static cairo_status_t
-{
-    int size = -*count;
+_cairo_path_fixed_add_box (cairo_path_fixed_t *path,
-    int num_boxes = 0;
-    cairo_status_t status;
-    if (clip_path->region != NULL) {
+			   const cairo_box_t *box)
-	int num_rects, n;
+{
-	num_rects = cairo_region_num_rectangles (clip_path->region);
-	if (num_rects > -size) {
-	    cairo_box_t *new_boxes;
-	    new_boxes = _cairo_malloc_ab (num_rects, sizeof (cairo_box_t));
-	    if (unlikely (new_boxes == NULL))
-		return _cairo_error (CAIRO_STATUS_NO_MEMORY);
-	    *boxes = new_boxes;
-	}
-	for (n = 0; n < num_rects; n++) {
-	    cairo_rectangle_int_t rect;
-	    cairo_region_get_rectangle (clip_path->region, n, &rect);
-	    (*boxes)[n].p1.x = _cairo_fixed_from_int (rect.x);
-	    (*boxes)[n].p1.y = _cairo_fixed_from_int (rect.y);
-	    (*boxes)[n].p2.x = _cairo_fixed_from_int (rect.x + rect.width);
-	    (*boxes)[n].p2.y = _cairo_fixed_from_int (rect.y + rect.height);
-	}
-	*count = num_rects;
-	return CAIRO_STATUS_SUCCESS;
-    }
-    /* keep it simple at first */
-    if (! _clip_paths_are_rectilinear (clip_path))
-	return CAIRO_INT_STATUS_UNSUPPORTED;
-    assert (-size >= 1);
-    if (_cairo_path_fixed_is_box (&clip_path->path, *boxes)) {
-	num_boxes = 1;
-    } else {
-	status = _rectilinear_clip_to_boxes (&clip_path->path,
-					     clip_path->fill_rule,
+    cairo_status_t status;
-					     boxes, &num_boxes, &size);
-	if (unlikely (status))
-	    return status;
+    status = _cairo_path_fixed_move_to (path, box->p1.x, box->p1.y);
-    }
-    while (num_boxes > 0 && (clip_path = clip_path->prev) != NULL) {
-	cairo_box_t box;
-	if (clip_path->region != NULL) {
-	    status = _region_clip_to_boxes (clip_path->region,
+    if (unlikely (status))
-					    boxes, &num_boxes, &size);
-	    if (unlikely (status))
-		return status;
-	    break;
-	} else if (_cairo_path_fixed_is_box (&clip_path->path, &box)) {
+	return status;
-	    int i, j;
-	    for (i = j = 0; i < num_boxes; i++) {
-		if (j != i)
-		    (*boxes)[j] = (*boxes)[i];
-		if (box.p1.x > (*boxes)[j].p1.x)
-		    (*boxes)[j].p1.x = box.p1.x;
-		if (box.p2.x < (*boxes)[j].p2.x)
-		    (*boxes)[j].p2.x = box.p2.x;
-		if (box.p1.y > (*boxes)[j].p1.y)
-		    (*boxes)[j].p1.y = box.p1.y;
-		if (box.p2.y < (*boxes)[j].p2.y)
-		    (*boxes)[j].p2.y = box.p2.y;
-		j += (*boxes)[j].p2.x > (*boxes)[j].p1.x &&
+    status = _cairo_path_fixed_line_to (path, box->p2.x, box->p1.y);
-		     (*boxes)[j].p2.y > (*boxes)[j].p1.y;
+    if (unlikely (status))
-	    }
+	return status;
-	    num_boxes = j;
-	} else {
-	    status = _rectilinear_clip_to_boxes (&clip_path->path,
-						 clip_path->fill_rule,
-						 boxes, &num_boxes, &size);
-	    if (unlikely (status))
-		return status;
-	}
-    }
-    *count = num_boxes;
-    return CAIRO_STATUS_SUCCESS;
-}
-static cairo_surface_t *
-_cairo_clip_path_get_surface (cairo_clip_path_t *clip_path,
-			      cairo_surface_t *target,
-			      int *tx, int *ty)
-{
-    const cairo_rectangle_int_t *clip_extents = &clip_path->extents;
-    cairo_bool_t need_translate;
-    cairo_surface_t *surface;
-    cairo_clip_path_t *prev;
-    cairo_status_t status;
-    while (clip_path->prev != NULL &&
-	   clip_path->flags & CAIRO_CLIP_PATH_IS_BOX &&
-	   clip_path->path.maybe_fill_region)
+    status = _cairo_path_fixed_line_to (path, box->p2.x, box->p2.y);
-    {
-	clip_path = clip_path->prev;
+    if (unlikely (status))
-    }
+	return status;
     clip_extents = &clip_path->extents;
-    if (clip_path->surface != NULL &&
-	clip_path->surface->backend == target->backend)
+    status = _cairo_path_fixed_line_to (path, box->p1.x, box->p2.y);
-    {
+    if (unlikely (status))
-	*tx = clip_extents->x;
+	return status;
-	*ty = clip_extents->y;
-	return clip_path->surface;
-    }
-    surface = _cairo_surface_create_similar_scratch (target,
-						     CAIRO_CONTENT_ALPHA,
-						     clip_extents->width,
-						     clip_extents->height);
+    return _cairo_path_fixed_close_path (path);
-    if (surface == NULL) {
+}
-	surface = cairo_image_surface_create (CAIRO_FORMAT_A8,
-					      clip_extents->width,
-					      clip_extents->height);
-    }
-    if (unlikely (surface->status))
-	return surface;
+static cairo_status_t
+_cairo_path_fixed_init_from_boxes (cairo_path_fixed_t *path,
+				   const cairo_boxes_t *boxes)
-    need_translate = clip_extents->x | clip_extents->y;
+{
+    cairo_status_t status;
+    const struct _cairo_boxes_chunk *chunk;
-    if (clip_path->flags & CAIRO_CLIP_PATH_IS_BOX &&
+    int i;
+    _cairo_path_fixed_init (path);
+    if (boxes->num_boxes == 0)
+	return CAIRO_STATUS_SUCCESS;
 	clip_path->path.maybe_fill_region)
-    {
-	status = _cairo_surface_paint (surface,
+    for (chunk = &boxes->chunks; chunk; chunk = chunk->next) {
-				       CAIRO_OPERATOR_SOURCE,
+	for (i = 0; i < chunk->count; i++) {
-				       &_cairo_pattern_white.base,
+	    status = _cairo_path_fixed_add_box (path, &chunk->base[i]);
-				       NULL);
-	if (unlikely (status))
-	    goto BAIL;
+	    if (unlikely (status)) {
-    }
+		_cairo_path_fixed_fini (path);
-    else
+		return status;
-    {
-	status = _cairo_surface_paint (surface,
-				       CAIRO_OPERATOR_CLEAR,
-				       &_cairo_pattern_clear.base,
-				       NULL);
-	if (unlikely (status))
-	    goto BAIL;
-	if (need_translate) {
-	    _cairo_path_fixed_translate (&clip_path->path,
-					 _cairo_fixed_from_int (-clip_extents->x),
+	    }
-					 _cairo_fixed_from_int (-clip_extents->y));
-	}
-	status = _cairo_surface_fill (surface,
-				      CAIRO_OPERATOR_ADD,
-				      &_cairo_pattern_white.base,
-				      &clip_path->path,
 				      clip_path->fill_rule,
-				      clip_path->tolerance,
-				      clip_path->antialias,
+    }
-				      NULL);
-	if (need_translate) {
-	    _cairo_path_fixed_translate (&clip_path->path,
-					 _cairo_fixed_from_int (clip_extents->x),
-					 _cairo_fixed_from_int (clip_extents->y));
-	}
+    return CAIRO_STATUS_SUCCESS;
-	if (unlikely (status))
+}
-	    goto BAIL;
-    }
-    prev = clip_path->prev;
-    while (prev != NULL) {
-	if (prev->flags & CAIRO_CLIP_PATH_IS_BOX &&
-	    prev->path.maybe_fill_region)
+static cairo_clip_t *
 _cairo_clip_intersect_clip_path_transformed (cairo_clip_t *clip,
-	    /* a simple box only affects the extents */
+					     const cairo_clip_path_t *clip_path,
-	}
+					     const cairo_matrix_t *m)
 	else if (prev->path.is_rectilinear ||
-		prev->surface == NULL ||
+    cairo_path_fixed_t path;
 		prev->surface->backend != target->backend)
-	{
-	    if (need_translate) {
-		_cairo_path_fixed_translate (&prev->path,
-					     _cairo_fixed_from_int (-clip_extents->x),
+    if (clip_path->prev)
-					     _cairo_fixed_from_int (-clip_extents->y));
+	clip = _cairo_clip_intersect_clip_path_transformed (clip,
 							    clip_path->prev,
-	    status = _cairo_surface_fill (surface,
+							    m);
-					  CAIRO_OPERATOR_IN,
-					  &_cairo_pattern_white.base,
+    if (_cairo_path_fixed_init_copy (&path, &clip_path->path))
-					  &prev->path,
+	return _cairo_clip_set_all_clipped (clip);
 					  prev->fill_rule,
-					  prev->tolerance,
+    _cairo_path_fixed_transform (&path, m);
 					  prev->antialias,
-					  NULL);
+    clip =  _cairo_clip_intersect_path (clip,
-	    if (need_translate) {
+				       &path,
-		_cairo_path_fixed_translate (&prev->path,
+				       clip_path->fill_rule,
-					     _cairo_fixed_from_int (clip_extents->x),
+				       clip_path->tolerance,
-					     _cairo_fixed_from_int (clip_extents->y));
+				       clip_path->antialias);
-	    }
-	    if (unlikely (status))
-		goto BAIL;
-	}
-	else
+    _cairo_path_fixed_fini (&path);
+    return clip;
+}
+cairo_clip_t *
+_cairo_clip_transform (cairo_clip_t *clip, const cairo_matrix_t *m)
+{
+    cairo_clip_t *copy;
+    if (clip == NULL || _cairo_clip_is_all_clipped (clip))
+	return clip;
+    if (_cairo_matrix_is_translation (m))
-	{
+	return _cairo_clip_translate (clip, m->x0, m->y0);
-	    cairo_surface_pattern_t pattern;
+    copy = _cairo_clip_create ();
-	    cairo_surface_t *prev_surface;
-	    int prev_tx, prev_ty;
-	    prev_surface = _cairo_clip_path_get_surface (prev, target, &prev_tx, &prev_ty);
+    if (clip->num_boxes) {
-	    status = prev_surface->status;
+	cairo_path_fixed_t path;
-	    if (unlikely (status))
+	cairo_boxes_t boxes;
 		goto BAIL;
 	_cairo_boxes_init_for_array (&boxes, clip->boxes, clip->num_boxes);
-	    _cairo_pattern_init_for_surface (&pattern, prev_surface);
+	_cairo_path_fixed_init_from_boxes (&path, &boxes);
-	    pattern.base.filter = CAIRO_FILTER_NEAREST;
+	_cairo_path_fixed_transform (&path, m);
-	    cairo_matrix_init_translate (&pattern.base.matrix,
-					 clip_extents->x - prev_tx,
-					 clip_extents->y - prev_ty);
-	    status = _cairo_surface_paint (surface,
-					   CAIRO_OPERATOR_IN,
-					   &pattern.base,
-					   NULL);
-	    _cairo_pattern_fini (&pattern.base);
-	    if (unlikely (status))
-		goto BAIL;
-	    break;
-	}
-	prev = prev->prev;
-    }
-    *tx = clip_extents->x;
-    *ty = clip_extents->y;
-    cairo_surface_destroy (clip_path->surface);
-    return clip_path->surface = surface;
-  BAIL:
-    cairo_surface_destroy (surface);
-    return _cairo_surface_create_in_error (status);
-}
-cairo_bool_t
-_cairo_clip_contains_rectangle (cairo_clip_t *clip,
-				const cairo_rectangle_int_t *rect)
-{
-    cairo_clip_path_t *clip_path;
-    if (clip == NULL)
-	return FALSE;
-    clip_path = clip->path;
-    if (clip_path->extents.x > rect->x ||
-	clip_path->extents.y > rect->y ||
-	clip_path->extents.x + clip_path->extents.width  < rect->x + rect->width ||
-	clip_path->extents.y + clip_path->extents.height < rect->y + rect->height)
-    {
-	return FALSE;
-    }
-    do {
-	cairo_box_t box;
-	if ((clip_path->flags & CAIRO_CLIP_PATH_IS_BOX) == 0)
-	    return FALSE;
-	if (! _cairo_path_fixed_is_box (&clip_path->path, &box))
-	    return FALSE;
-	if (box.p1.x > _cairo_fixed_from_int (rect->x) ||
-	    box.p1.y > _cairo_fixed_from_int (rect->y) ||
-	    box.p2.x < _cairo_fixed_from_int (rect->x + rect->width) ||
-	    box.p2.y < _cairo_fixed_from_int (rect->y + rect->height))
-	{
-	    return FALSE;
-	}
-    } while ((clip_path = clip_path->prev) != NULL);
-    return TRUE;
-}
-cairo_bool_t
-_cairo_clip_contains_extents (cairo_clip_t *clip,
-			      const cairo_composite_rectangles_t *extents)
-{
-    const cairo_rectangle_int_t *rect;
-    if (clip == NULL)
-	return FALSE;
 	copy = _cairo_clip_intersect_path (copy, &path,
-    rect = extents->is_bounded ? &extents->bounded : &extents->unbounded;
+					   CAIRO_FILL_RULE_WINDING,
-    return _cairo_clip_contains_rectangle (clip, rect);
+.1,
-}
+					   CAIRO_ANTIALIAS_DEFAULT);
-void
-_cairo_debug_print_clip (FILE *stream, cairo_clip_t *clip)
-{
-    cairo_clip_path_t *clip_path;
-    if (clip == NULL) {
-	fprintf (stream, "no clip\n");
-	return;
-    }
-    if (clip->all_clipped) {
-	fprintf (stream, "clip: all-clipped\n");
-	return;
-    }
-    if (clip->path == NULL) {
-	fprintf (stream, "clip: empty\n");
-	return;
+	_cairo_path_fixed_fini (&path);
     }
-    fprintf (stream, "clip:\n");
-    clip_path = clip->path;
-    do {
-	fprintf (stream, "path: has region? %s, has surface? %s, aa=%d, tolerance=%f, rule=%d: ",
-		 clip_path->region == NULL ? "no" : "yes",
-		 clip_path->surface == NULL ? "no" : "yes",
-		 clip_path->antialias,
+    if (clip->path)
-		 clip_path->tolerance,
+	copy = _cairo_clip_intersect_clip_path_transformed (copy, clip->path,m);
 		 clip_path->fill_rule);
-	_cairo_debug_print_path (stream, &clip_path->path);
+    _cairo_clip_destroy (clip);
     user_rect->height = y2 - y1;
     return is_tight;
-}
-cairo_int_status_t
-_cairo_clip_get_region (cairo_clip_t *clip,
-			cairo_region_t **region)
-{
-    cairo_int_status_t status;
-    if (clip->all_clipped)
-	goto CLIPPED;
-    assert (clip->path != NULL);
-    status = _cairo_clip_path_to_region (clip->path);
-    if (status)
-	return status;
-    if (cairo_region_is_empty (clip->path->region)) {
-	_cairo_clip_set_all_clipped (clip);
-	goto CLIPPED;
-    }
-    if (region)
-	*region = clip->path->region;
-    return CAIRO_STATUS_SUCCESS;
-  CLIPPED:
-    if (region)
-	*region = NULL;
-    return CAIRO_INT_STATUS_NOTHING_TO_DO;
-}
-cairo_int_status_t
-_cairo_clip_get_boxes (cairo_clip_t *clip,
-		       cairo_box_t **boxes,
-		       int *count)
-{
-    cairo_int_status_t status;
-    if (clip->all_clipped)
-	return CAIRO_INT_STATUS_NOTHING_TO_DO;
-    assert (clip->path != NULL);
-    status = _cairo_clip_path_to_boxes (clip->path, boxes, count);
-    if (status)
-	return status;
-    if (*count == 0) {
-	_cairo_clip_set_all_clipped (clip);
-	return CAIRO_INT_STATUS_NOTHING_TO_DO;
-    }
-    return CAIRO_STATUS_SUCCESS;
-}
-static cairo_bool_t
-box_is_aligned (const cairo_box_t *box)
-{
-    return
-	_cairo_fixed_is_integer (box->p1.x) &&
-	_cairo_fixed_is_integer (box->p1.y) &&
-	_cairo_fixed_is_integer (box->p2.x) &&
-	_cairo_fixed_is_integer (box->p2.y);
-}
-static void
-intersect_with_boxes (cairo_composite_rectangles_t *extents,
-		      cairo_box_t *boxes,
-		      int num_boxes)
-{
-    cairo_rectangle_int_t rect;
-    cairo_box_t box;
-    cairo_bool_t is_empty;
-    box.p1.x = box.p1.y = INT_MIN;
-    box.p2.x = box.p2.y = INT_MAX;
-    while (num_boxes--) {
-	if (boxes->p1.x < box.p1.x)
-	    box.p1.x = boxes->p1.x;
-	if (boxes->p1.y < box.p1.y)
-	    box.p1.y = boxes->p1.y;
-	if (boxes->p2.x > box.p2.x)
-	    box.p2.x = boxes->p2.x;
-	if (boxes->p2.y > box.p2.y)
-	    box.p2.y = boxes->p2.y;
-    }
-    _cairo_box_round_to_rectangle (&box, &rect);
-    is_empty = _cairo_rectangle_intersect (&extents->bounded, &rect);
-    is_empty = _cairo_rectangle_intersect (&extents->unbounded, &rect);
-}
-cairo_status_t
-_cairo_clip_to_boxes (cairo_clip_t **clip,
-		      cairo_composite_rectangles_t *extents,
-		      cairo_box_t **boxes,
-		      int *num_boxes)
-{
-    cairo_status_t status;
-    const cairo_rectangle_int_t *rect;
-    rect = extents->is_bounded ? &extents->bounded : &extents->unbounded;
-    if (*clip == NULL)
-	goto EXTENTS;
-    status = _cairo_clip_rectangle (*clip, rect);
-    if (unlikely (status))
-	return status;
-    status = _cairo_clip_get_boxes (*clip, boxes, num_boxes);
-    switch ((int) status) {
-    case CAIRO_STATUS_SUCCESS:
-	intersect_with_boxes (extents, *boxes, *num_boxes);
-	if (rect->width == 0 || rect->height == 0 ||
-	    extents->is_bounded ||
-	    (*num_boxes == 1 && box_is_aligned (*boxes)))
-	{
-	    *clip = NULL;
-	}
-	goto DONE;
-    case CAIRO_INT_STATUS_UNSUPPORTED:
-	goto EXTENTS;
-    default:
-	return status;
-    }
-  EXTENTS:
-    status = CAIRO_STATUS_SUCCESS;
-    _cairo_box_from_rectangle (&(*boxes)[0], rect);
-    *num_boxes = 1;
-  DONE:
-    return status;
-}
+}
-static cairo_rectangle_list_t *
+cairo_rectangle_list_t *
 _cairo_rectangle_list_create_in_error (cairo_status_t status)
+{
     if (status == CAIRO_STATUS_CLIP_NOT_REPRESENTABLE)
 	return (cairo_rectangle_list_t*) &_cairo_rectangles_not_representable;
     list = malloc (sizeof (*list));
     if (unlikely (list == NULL)) {
-	_cairo_error_throw (status);
+	status = _cairo_error (CAIRO_STATUS_NO_MEMORY);
 	return (cairo_rectangle_list_t*) &_cairo_rectangles_nil;
+    }
 #define ERROR_LIST(S) _cairo_rectangle_list_create_in_error (_cairo_error (S))
     cairo_rectangle_list_t *list;
     cairo_rectangle_t *rectangles = NULL;
-    cairo_region_t *region = NULL;
-    cairo_int_status_t status;
+    cairo_region_t *region = NULL;
     int n_rects = 0;
-    int i;
-    if (clip->all_clipped)
-	goto DONE;
+    int i;
-    if (!clip->path)
+    if (clip == NULL)
-	return ERROR_LIST (CAIRO_STATUS_CLIP_NOT_REPRESENTABLE);
 	return ERROR_LIST (CAIRO_STATUS_CLIP_NOT_REPRESENTABLE);
-    status = _cairo_clip_get_region (clip, ®ion);
+    if (_cairo_clip_is_all_clipped (clip))
-    if (status == CAIRO_INT_STATUS_NOTHING_TO_DO) {
+	goto DONE;
+    if (! _cairo_clip_is_region (clip))
-	goto DONE;
+	return ERROR_LIST (CAIRO_STATUS_CLIP_NOT_REPRESENTABLE);
-    } else if (status == CAIRO_INT_STATUS_UNSUPPORTED) {
-	return ERROR_LIST (CAIRO_STATUS_CLIP_NOT_REPRESENTABLE);
-    } else if (unlikely (status)) {
+    region = _cairo_clip_get_region (clip);
-	return ERROR_LIST (status);
+    if (region == NULL)
 	return ERROR_LIST (CAIRO_STATUS_NO_MEMORY);
 #undef ERROR_LIST
+}
 /**
  * cairo_rectangle_list_destroy:
- * @rectangle_list: a rectangle list, as obtained from cairo_copy_clip_rectangles()
+ * @rectangle_list: a rectangle list, as obtained from cairo_copy_clip_rectangle_list()
+ *
  * Unconditionally frees @rectangle_list and all associated
  * references. After this call, the @rectangle_list pointer must not
  * be dereferenced.
 void
 _cairo_clip_reset_static_data (void)
+{
+    _freed_pool_reset (&clip_path_pool);
-    _freed_pool_reset (&clip_path_pool);
+    _freed_pool_reset (&clip_pool);

Subversion Repositories Kolibri OS

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