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

  *	Chris Wilson
  */
+#include "cairoint.h"
 #include "cairoint.h"
 #include "cairo-box-inline.h"
 #include "cairo-boxes-private.h"
 #include "cairo-error-private.h"
     boxes->is_pixel_aligned = TRUE;
+}
+void
+_cairo_boxes_init_from_rectangle (cairo_boxes_t *boxes,
+				  int x, int y, int w, int h)
+{
+    _cairo_boxes_init (boxes);
+    _cairo_box_from_integers (&boxes->chunks.base[0], x, y, w, h);
+    boxes->num_boxes = 1;
+}
+void
+_cairo_boxes_init_with_clip (cairo_boxes_t *boxes,
+			     cairo_clip_t *clip)
+{
+    _cairo_boxes_init (boxes);
+    if (clip)
+	_cairo_boxes_limit (boxes, clip->boxes, clip->num_boxes);
+}
 void
 _cairo_boxes_init_for_array (cairo_boxes_t *boxes,
 			     cairo_box_t *array,
 			     int num_boxes)
+    }
     chunk->base[chunk->count++] = *box;
     boxes->num_boxes++;
-    if (boxes->is_pixel_aligned) {
-	boxes->is_pixel_aligned =
-	    _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);
+    if (boxes->is_pixel_aligned)
 	boxes->is_pixel_aligned = _cairo_box_is_pixel_aligned (box);
+}
 cairo_status_t
-cairo_status_t
+_cairo_boxes_add (cairo_boxes_t *boxes,
+		  cairo_antialias_t antialias,
+		  const cairo_box_t *box)
+{
+    cairo_box_t b;
+    if (antialias == CAIRO_ANTIALIAS_NONE) {
+	b.p1.x = _cairo_fixed_round_down (box->p1.x);
+	b.p1.y = _cairo_fixed_round_down (box->p1.y);
+	b.p2.x = _cairo_fixed_round_down (box->p2.x);
+	b.p2.y = _cairo_fixed_round_down (box->p2.y);
-_cairo_boxes_add (cairo_boxes_t *boxes,
+	box = &b;
 		  const cairo_box_t *box)
     if (box->p1.y == box->p2.y)
     return boxes->status;
+}
 void
 _cairo_boxes_extents (const cairo_boxes_t *boxes,
-		      cairo_rectangle_int_t *extents)
+		      cairo_box_t *box)
+{
     const struct _cairo_boxes_chunk *chunk;
-    cairo_box_t box;
+    cairo_box_t b;
     int i;
+    if (boxes->num_boxes == 0) {
+	box->p1.x = box->p1.y = box->p2.x = box->p2.y = 0;
+	return;
     box.p1.y = box.p1.x = INT_MAX;
-    box.p2.y = box.p2.x = INT_MIN;
-    for (chunk = &boxes->chunks; chunk != NULL; chunk = chunk->next) {
+    b = boxes->chunks.base[0];
-	const cairo_box_t *b = chunk->base;
+    for (chunk = &boxes->chunks; chunk != NULL; chunk = chunk->next) {
 	for (i = 0; i < chunk->count; i++) {
-	    if (b[i].p1.x < box.p1.x)
+	    if (chunk->base[i].p1.x < b.p1.x)
-		box.p1.x = b[i].p1.x;
+		b.p1.x = chunk->base[i].p1.x;
-	    if (b[i].p1.y < box.p1.y)
+	    if (chunk->base[i].p1.y < b.p1.y)
-		box.p1.y = b[i].p1.y;
+		b.p1.y = chunk->base[i].p1.y;
-	    if (b[i].p2.x > box.p2.x)
+	    if (chunk->base[i].p2.x > b.p2.x)
-		box.p2.x = b[i].p2.x;
+		b.p2.x = chunk->base[i].p2.x;
 	    if (b[i].p2.y > box.p2.y)
-		box.p2.y = b[i].p2.y;
+	    if (chunk->base[i].p2.y > b.p2.y)
 		b.p2.y = chunk->base[i].p2.y;
+	}
+    }
     boxes->tail = &boxes->chunks;
     boxes->chunks.next = 0;
+    boxes->chunks.count = 0;
+    boxes->chunks.base = boxes->boxes_embedded;
-    boxes->chunks.count = 0;
+    boxes->chunks.size = ARRAY_LENGTH (boxes->boxes_embedded);
     boxes->num_boxes = 0;
+    boxes->is_pixel_aligned = TRUE;
+}
+cairo_box_t *
+_cairo_boxes_to_array (const cairo_boxes_t *boxes,
+		       int *num_boxes,
+		       cairo_bool_t force_allocation)
+{
+    const struct _cairo_boxes_chunk *chunk;
+    cairo_box_t *box;
+    int i, j;
+    *num_boxes = boxes->num_boxes;
+    if (boxes->chunks.next == NULL && ! force_allocation)
+	    return boxes->chunks.base;
+    box = _cairo_malloc_ab (boxes->num_boxes, sizeof (cairo_box_t));
+    if (box == NULL) {
+	_cairo_error_throw (CAIRO_STATUS_NO_MEMORY);
+	return NULL;
+    }
+    j = 0;
+    for (chunk = &boxes->chunks; chunk != NULL; chunk = chunk->next) {
+	for (i = 0; i < chunk->count; i++)
+	    box[j++] = chunk->base[i];
+    }
-    boxes->is_pixel_aligned = TRUE;
+    return box;
+}
 void
 _cairo_boxes_fini (cairo_boxes_t *boxes)
+{
     struct _cairo_boxes_chunk *chunk, *next;
     for (chunk = boxes->chunks.next; chunk != NULL; chunk = next) {
+	next = chunk->next;
+	free (chunk);
+    }
+}
+cairo_bool_t
+_cairo_boxes_for_each_box (cairo_boxes_t *boxes,
+			   cairo_bool_t (*func) (cairo_box_t *box, void *data),
+			   void *data)
+{
+    struct _cairo_boxes_chunk *chunk;
+    int i;
+    for (chunk = &boxes->chunks; chunk != NULL; chunk = chunk->next) {
+	for (i = 0; i < chunk->count; i++)
+	    if (! func (&chunk->base[i], data))
+		return FALSE;
+    }
+    return TRUE;
+}
+struct cairo_box_renderer {
+    cairo_span_renderer_t base;
+    cairo_boxes_t *boxes;
+};
+static cairo_status_t
+span_to_boxes (void *abstract_renderer, int y, int h,
+	       const cairo_half_open_span_t *spans, unsigned num_spans)
+{
+    struct cairo_box_renderer *r = abstract_renderer;
+    cairo_status_t status = CAIRO_STATUS_SUCCESS;
+    cairo_box_t box;
+    if (num_spans == 0)
+	return CAIRO_STATUS_SUCCESS;
+    box.p1.y = _cairo_fixed_from_int (y);
+    box.p2.y = _cairo_fixed_from_int (y + h);
+    do {
+	if (spans[0].coverage) {
+	    box.p1.x = _cairo_fixed_from_int(spans[0].x);
+	    box.p2.x = _cairo_fixed_from_int(spans[1].x);
+	    status = _cairo_boxes_add (r->boxes, CAIRO_ANTIALIAS_DEFAULT, &box);
+	}
+	spans++;
+    } while (--num_spans > 1 && status == CAIRO_STATUS_SUCCESS);
+    return status;
+}
+cairo_status_t
+_cairo_rasterise_polygon_to_boxes (cairo_polygon_t			*polygon,
+				   cairo_fill_rule_t			 fill_rule,
+				   cairo_boxes_t *boxes)
+{
+    struct cairo_box_renderer renderer;
+    cairo_scan_converter_t *converter;
+    cairo_int_status_t status;
+    cairo_rectangle_int_t r;
+    TRACE ((stderr, "%s: fill_rule=%d\n", __FUNCTION__, fill_rule));
+    _cairo_box_round_to_rectangle (&polygon->extents, &r);
+    converter = _cairo_mono_scan_converter_create (r.x, r.y,
+						   r.x + r.width,
+						   r.y + r.height,
+						   fill_rule);
+    status = _cairo_mono_scan_converter_add_polygon (converter, polygon);
+    if (unlikely (status))
+	goto cleanup_converter;
+    renderer.boxes = boxes;
+    renderer.base.render_rows = span_to_boxes;
+    status = converter->generate (converter, &renderer.base);
+cleanup_converter:
+    converter->destroy (converter);
+    return status;
+}
+void
+_cairo_debug_print_boxes (FILE *stream, const cairo_boxes_t *boxes)
+{
+    const struct _cairo_boxes_chunk *chunk;
+    cairo_box_t extents;
+    int i;
+    _cairo_boxes_extents (boxes, &extents);
+    fprintf (stream, "boxes x %d: (%f, %f) x (%f, %f)\n",
+	     boxes->num_boxes,
+	     _cairo_fixed_to_double (extents.p1.x),
+	     _cairo_fixed_to_double (extents.p1.y),
+	     _cairo_fixed_to_double (extents.p2.x),
+	     _cairo_fixed_to_double (extents.p2.y));
+    for (chunk = &boxes->chunks; chunk != NULL; chunk = chunk->next) {
+	for (i = 0; i < chunk->count; i++) {
+	    fprintf (stderr, "  box[%d]: (%f, %f), (%f, %f)\n", i,
+		     _cairo_fixed_to_double (chunk->base[i].p1.x),
+		     _cairo_fixed_to_double (chunk->base[i].p1.y),
+		     _cairo_fixed_to_double (chunk->base[i].p2.x),

Subversion Repositories Kolibri OS

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