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

  *	Carl D. Worth
  */
+#include "cairoint.h"
 #include "cairoint.h"
+#include "cairo-box-inline.h"
 #include "cairo-error-private.h"
-#include "cairo-error-private.h"
+#include "cairo-list-inline.h"
 #include "cairo-path-fixed-private.h"
 #include "cairo-slope-private.h"
 static void
 _cairo_path_buf_add_points (cairo_path_buf_t       *buf,
 			    const cairo_point_t    *points,
 			    int		            num_points);
-#define cairo_path_head(path__) (&(path__)->buf.base)
-#define cairo_path_tail(path__) cairo_path_buf_prev (cairo_path_head (path__))
-#define cairo_path_buf_next(pos__) \
-    cairo_list_entry ((pos__)->link.next, cairo_path_buf_t, link)
-#define cairo_path_buf_prev(pos__) \
-    cairo_list_entry ((pos__)->link.prev, cairo_path_buf_t, link)
-#define cairo_path_foreach_buf_start(pos__, path__) \
-    pos__ = cairo_path_head (path__); do
-#define cairo_path_foreach_buf_end(pos__, path__) \
-    while ((pos__ = cairo_path_buf_next (pos__)) !=  cairo_path_head (path__))
 void
 _cairo_path_fixed_init (cairo_path_fixed_t *path)
+{
     path->buf.base.points = path->buf.points;
     path->current_point.x = 0;
     path->current_point.y = 0;
-    path->last_move_point = path->current_point;
+    path->last_move_point = path->current_point;
     path->has_last_move_point = FALSE;
+    path->has_current_point = FALSE;
+    path->needs_move_to = TRUE;
-    path->has_current_point = FALSE;
+    path->has_extents = FALSE;
+    path->has_curve_to = FALSE;
-    path->has_curve_to = FALSE;
+    path->stroke_is_rectilinear = TRUE;
-    path->is_rectilinear = TRUE;
+    path->fill_is_rectilinear = TRUE;
-    path->maybe_fill_region = TRUE;
+    path->fill_maybe_region = TRUE;
-    path->is_empty_fill = TRUE;
+    path->fill_is_empty = TRUE;
-    path->extents.p1.x = path->extents.p1.y = INT_MAX;
+    path->extents.p1.x = path->extents.p1.y = 0;
-    path->extents.p2.x = path->extents.p2.y = INT_MIN;
+    path->extents.p2.x = path->extents.p2.y = 0;
+}
     path->buf.base.size_ops = ARRAY_LENGTH (path->buf.op);
     path->buf.base.size_points = ARRAY_LENGTH (path->buf.points);
     path->current_point = other->current_point;
-    path->last_move_point = other->last_move_point;
+    path->last_move_point = other->last_move_point;
     path->has_last_move_point = other->has_last_move_point;
+    path->has_current_point = other->has_current_point;
+    path->needs_move_to = other->needs_move_to;
-    path->has_current_point = other->has_current_point;
+    path->has_extents = other->has_extents;
+    path->has_curve_to = other->has_curve_to;
-    path->has_curve_to = other->has_curve_to;
+    path->stroke_is_rectilinear = other->stroke_is_rectilinear;
-    path->is_rectilinear = other->is_rectilinear;
+    path->fill_is_rectilinear = other->fill_is_rectilinear;
-    path->maybe_fill_region = other->maybe_fill_region;
+    path->fill_maybe_region = other->fill_maybe_region;
-    path->is_empty_fill = other->is_empty_fill;
+    path->fill_is_empty = other->fill_is_empty;
     path->extents = other->extents;
 unsigned long
 _cairo_path_fixed_hash (const cairo_path_fixed_t *path)
+{
     unsigned long hash = _CAIRO_HASH_INIT_VALUE;
     const cairo_path_buf_t *buf;
-    int num_points, num_ops;
+    unsigned int count;
-    hash = _cairo_hash_bytes (hash, &path->extents, sizeof (path->extents));
-    num_ops = num_points = 0;
+    count = 0;
     cairo_path_foreach_buf_start (buf, path) {
 	hash = _cairo_hash_bytes (hash, buf->op,
+			          buf->num_ops * sizeof (buf->op[0]));
+	count += buf->num_ops;
+    } cairo_path_foreach_buf_end (buf, path);
+    hash = _cairo_hash_bytes (hash, &count, sizeof (count));
+    count = 0;
-			          buf->num_ops * sizeof (buf->op[0]));
+    cairo_path_foreach_buf_start (buf, path) {
 	hash = _cairo_hash_bytes (hash, buf->points,
-			          buf->num_points * sizeof (buf->points[0]));
-	num_ops    += buf->num_ops;
+			          buf->num_points * sizeof (buf->points[0]));
-	num_points += buf->num_points;
+	count += buf->num_points;
-    } cairo_path_foreach_buf_end (buf, path);
-    hash = _cairo_hash_bytes (hash, &num_ops, sizeof (num_ops));
+    } cairo_path_foreach_buf_end (buf, path);
-    hash = _cairo_hash_bytes (hash, &num_points, sizeof (num_points));
+    hash = _cairo_hash_bytes (hash, &count, sizeof (count));
     return hash;
     if (a == b)
 	return TRUE;
-    /* use the flags to quickly differentiate based on contents */
-    if (a->is_empty_fill != b->is_empty_fill ||
-	a->has_curve_to != b->has_curve_to ||
-	a->maybe_fill_region != b->maybe_fill_region ||
+    /* use the flags to quickly differentiate based on contents */
-	a->is_rectilinear != b->is_rectilinear)
+    if (a->has_curve_to != b->has_curve_to)
+    {
 	return FALSE;
     _cairo_path_fixed_fini (path);
     free (path);
+}
 static cairo_path_op_t
-_cairo_path_last_op (cairo_path_fixed_t *path)
+_cairo_path_fixed_last_op (cairo_path_fixed_t *path)
+{
     cairo_path_buf_t *buf;
-    buf = cairo_path_tail (path);
-    if (buf->num_ops == 0)
+    buf = cairo_path_tail (path);
-	return -1;
+    assert (buf->num_ops != 0);
     return buf->op[buf->num_ops - 1];
-}
+}
-static inline void
+static inline const cairo_point_t *
-_cairo_path_fixed_extents_add (cairo_path_fixed_t *path,
+_cairo_path_fixed_penultimate_point (cairo_path_fixed_t *path)
-			       const cairo_point_t *point)
+{
-{
+    cairo_path_buf_t *buf;
+    buf = cairo_path_tail (path);
+    if (likely (buf->num_points >= 2)) {
+	return &buf->points[buf->num_points - 2];
+    } else {
+	cairo_path_buf_t *prev_buf = cairo_path_buf_prev (buf);
-    if (point->x < path->extents.p1.x)
+	assert (prev_buf->num_points >= 2 - buf->num_points);
+	return &prev_buf->points[prev_buf->num_points - (2 - buf->num_points)];
-	path->extents.p1.x = point->x;
+    }
+}
-    if (point->y < path->extents.p1.y)
+static void
+_cairo_path_fixed_drop_line_to (cairo_path_fixed_t *path)
+{
-	path->extents.p1.y = point->y;
+    cairo_path_buf_t *buf;
+    assert (_cairo_path_fixed_last_op (path) == CAIRO_PATH_OP_LINE_TO);
     if (point->x > path->extents.p2.x)
-	path->extents.p2.x = point->x;
+    buf = cairo_path_tail (path);
-    if (point->y > path->extents.p2.y)
+    buf->num_points--;
-	path->extents.p2.y = point->y;
+    buf->num_ops--;
+}
 cairo_status_t
-_cairo_path_fixed_move_to (cairo_path_fixed_t  *path,
+_cairo_path_fixed_move_to (cairo_path_fixed_t  *path,
 			   cairo_fixed_t	x,
 			   cairo_fixed_t	y)
+{
-{
-    cairo_status_t status;
+    _cairo_path_fixed_new_sub_path (path);
-    cairo_point_t point;
-    point.x = x;
+    path->has_current_point = TRUE;
-    point.y = y;
+    path->current_point.x = x;
+    path->current_point.y = y;
-    /* If the previous op was also a MOVE_TO, then just change its
-     * point rather than adding a new op. */
+    path->last_move_point = path->current_point;
-    if (_cairo_path_last_op (path) == CAIRO_PATH_OP_MOVE_TO) {
-	cairo_path_buf_t *buf;
-	buf = cairo_path_tail (path);
-	buf->points[buf->num_points - 1] = point;
-    } else {
+    return CAIRO_STATUS_SUCCESS;
-	status = _cairo_path_fixed_add (path, CAIRO_PATH_OP_MOVE_TO, &point, 1);
+}
-	if (unlikely (status))
+static cairo_status_t
-	    return status;
+_cairo_path_fixed_move_to_apply (cairo_path_fixed_t  *path)
+{
-	if (path->has_current_point && path->is_rectilinear) {
+    if (likely (! path->needs_move_to))
-	    /* a move-to is first an implicit close */
+	return CAIRO_STATUS_SUCCESS;
+    path->needs_move_to = FALSE;
+    if (path->has_extents) {
-	    path->is_rectilinear = path->current_point.x == path->last_move_point.x ||
+	_cairo_box_add_point (&path->extents, &path->current_point);
-				   path->current_point.y == path->last_move_point.y;
-	    path->maybe_fill_region &= path->is_rectilinear;
+    } else {
-	}
-	if (path->maybe_fill_region) {
-	    path->maybe_fill_region =
+	_cairo_box_set (&path->extents, &path->current_point, &path->current_point);
-		_cairo_fixed_is_integer (path->last_move_point.x) &&
+	path->has_extents = TRUE;
 		_cairo_fixed_is_integer (path->last_move_point.y);
     if (path->fill_maybe_region) {
+	path->fill_maybe_region = _cairo_fixed_is_integer (path->current_point.x) &&
+				  _cairo_fixed_is_integer (path->current_point.y);
+    }
+    path->last_move_point = path->current_point;
+    return _cairo_path_fixed_add (path, CAIRO_PATH_OP_MOVE_TO, &path->current_point, 1);
+}
+void
+_cairo_path_fixed_new_sub_path (cairo_path_fixed_t *path)
+{
-    path->current_point = point;
+    if (! path->needs_move_to) {
-    path->last_move_point = point;
+	/* If the current subpath doesn't need_move_to, it contains at least one command */
-    path->has_last_move_point = TRUE;
+	if (path->fill_is_rectilinear) {
      * that the last_move_point state is updated properly.
      */
     if (! path->has_current_point)
 	return _cairo_path_fixed_move_to (path, point.x, point.y);
+    status = _cairo_path_fixed_move_to_apply (path);
+    if (unlikely (status))
+	return status;
     /* If the previous op was but the initial MOVE_TO and this segment
      * is degenerate, then we can simply skip this point. Note that
      * a move-to followed by a degenerate line-to is a valid path for
      * stroking, but at all other times is simply a degenerate segment.
      */
-    if (_cairo_path_last_op (path) != CAIRO_PATH_OP_MOVE_TO) {
+    if (_cairo_path_fixed_last_op (path) != CAIRO_PATH_OP_MOVE_TO) {
 	if (x == path->current_point.x && y == path->current_point.y)
 	    return CAIRO_STATUS_SUCCESS;
+    }
     /* If the previous op was also a LINE_TO with the same gradient,
      * then just change its end-point rather than adding a new op.
-     */
-    if (_cairo_path_last_op (path) == CAIRO_PATH_OP_LINE_TO) {
+     */
-	cairo_path_buf_t *buf;
+    if (_cairo_path_fixed_last_op (path) == CAIRO_PATH_OP_LINE_TO) {
-	const cairo_point_t *p;
-	buf = cairo_path_tail (path);
-	if (likely (buf->num_points >= 2)) {
-	    p = &buf->points[buf->num_points-2];
-	} else {
-	    cairo_path_buf_t *prev_buf = cairo_path_buf_prev (buf);
-	    p = &prev_buf->points[prev_buf->num_points - (2 - buf->num_points)];
+	const cairo_point_t *p;
+	p = _cairo_path_fixed_penultimate_point (path);
-	if (p->x == path->current_point.x && p->y == path->current_point.y) {
-	    /* previous line element was degenerate, replace */
+	if (p->x == path->current_point.x && p->y == path->current_point.y) {
-	    buf->points[buf->num_points - 1] = point;
+	    /* previous line element was degenerate, replace */
-	    goto FLAGS;
+	    _cairo_path_fixed_drop_line_to (path);
 	} else {
 	    cairo_slope_t prev, self;
 	    _cairo_slope_init (&prev, p, &path->current_point);
 	    _cairo_slope_init (&self, &path->current_point, &point);
+	    if (_cairo_slope_equal (&prev, &self) &&
+		/* cannot trim anti-parallel segments whilst stroking */
+		! _cairo_slope_backwards (&prev, &self))
+	    {
-	    if (_cairo_slope_equal (&prev, &self) &&
+		_cairo_path_fixed_drop_line_to (path);
-		/* cannot trim anti-parallel segments whilst stroking */
+		/* In this case the flags might be more restrictive than
-		! _cairo_slope_backwards (&prev, &self))
+		 * what we actually need.
 		 * When changing the flags definition we should check if
-		buf->points[buf->num_points - 1] = point;
+		 * changing the line_to point can affect them.
-		goto FLAGS;
-	    }
-	}
-    }
-    status = _cairo_path_fixed_add (path, CAIRO_PATH_OP_LINE_TO, &point, 1);
+		*/
-    if (unlikely (status))
+	    }
 	return status;
+    }
-  FLAGS:
-    if (path->is_rectilinear) {
+    if (path->stroke_is_rectilinear) {
-	path->is_rectilinear = path->current_point.x == x ||
+	path->stroke_is_rectilinear = path->current_point.x == x ||
-			       path->current_point.y == y;
+				      path->current_point.y == y;
-	path->maybe_fill_region &= path->is_rectilinear;
+	path->fill_is_rectilinear &= path->stroke_is_rectilinear;
-    }
+	path->fill_maybe_region &= path->fill_is_rectilinear;
-    if (path->maybe_fill_region) {
+	if (path->fill_maybe_region) {
-	path->maybe_fill_region = _cairo_fixed_is_integer (x) &&
+	    path->fill_maybe_region = _cairo_fixed_is_integer (x) &&
-				  _cairo_fixed_is_integer (y);
+				      _cairo_fixed_is_integer (y);
+	}
 	if (path->fill_is_empty) {
-    if (path->is_empty_fill) {
+	    path->fill_is_empty = path->current_point.x == x &&
-	path->is_empty_fill = path->current_point.x == x &&
+				  path->current_point.y == y;
-			      path->current_point.y == y;
-    }
+	}
+    }
-    path->current_point = point;
     if (path->has_last_move_point) {
-	_cairo_path_fixed_extents_add (path, &path->last_move_point);
+    path->current_point = point;
 	path->has_last_move_point = FALSE;
     _cairo_box_add_point (&path->extents, &point);
 			    cairo_fixed_t x2, cairo_fixed_t y2)
+{
     cairo_status_t status;
     cairo_point_t point[3];
+    /* If this curves does not move, replace it with a line-to.
+     * This frequently happens with rounded-rectangles and r==0.
+    */
+    if (path->current_point.x == x2 && path->current_point.y == y2) {
+	if (x1 == x2 && x0 == x2 && y1 == y2 && y0 == y2)
+	    return _cairo_path_fixed_line_to (path, x2, y2);
+	/* We may want to check for the absence of a cusp, in which case
+	 * we can also replace the curve-to with a line-to.
+	 */
+    }
     /* make sure subpaths are started properly */
     if (! path->has_current_point) {
+	status = _cairo_path_fixed_move_to (path, x0, y0);
+	assert (status == CAIRO_STATUS_SUCCESS);
+    }
-	status = _cairo_path_fixed_move_to (path, x0, y0);
+    status = _cairo_path_fixed_move_to_apply (path);
-	if (unlikely (status))
+    if (unlikely (status))
+	return status;
+    /* If the previous op was a degenerate LINE_TO, drop it. */
+    if (_cairo_path_fixed_last_op (path) == CAIRO_PATH_OP_LINE_TO) {
+	const cairo_point_t *p;
+	p = _cairo_path_fixed_penultimate_point (path);
+	if (p->x == path->current_point.x && p->y == path->current_point.y) {
+	    /* previous line element was degenerate, replace */
+	    _cairo_path_fixed_drop_line_to (path);
 	    return status;
+    }
     point[0].x = x0; point[0].y = y0;
+    point[1].x = x1; point[1].y = y1;
-    point[1].x = x1; point[1].y = y1;
+    point[2].x = x2; point[2].y = y2;
-    point[2].x = x2; point[2].y = y2;
-    status = _cairo_path_fixed_add (path, CAIRO_PATH_OP_CURVE_TO, point, 3);
-    if (unlikely (status))
+    _cairo_box_add_curve_to (&path->extents, &path->current_point,
-	return status;
-    path->current_point = point[2];
+			     &point[0], &point[1], &point[2]);
-    path->has_current_point = TRUE;
-    path->is_empty_fill = FALSE;
+    path->current_point = point[2];
-    path->has_curve_to = TRUE;
-    path->is_rectilinear = FALSE;
-    path->maybe_fill_region = FALSE;
+    path->has_curve_to = TRUE;
-    /* coarse bounds */
+    path->stroke_is_rectilinear = FALSE;
-    if (path->has_last_move_point) {
-	_cairo_path_fixed_extents_add (path, &path->last_move_point);
-	path->has_last_move_point = FALSE;
-    }
-    _cairo_path_fixed_extents_add (path, &point[0]);
+    path->fill_is_rectilinear = FALSE;
-    _cairo_path_fixed_extents_add (path, &point[1]);
+    path->fill_maybe_region = FALSE;
-    _cairo_path_fixed_extents_add (path, &point[2]);
+    path->fill_is_empty = FALSE;
-    return CAIRO_STATUS_SUCCESS;
+    return _cairo_path_fixed_add (path, CAIRO_PATH_OP_CURVE_TO, point, 3);
     cairo_status_t status;
     if (! path->has_current_point)
-	return CAIRO_STATUS_SUCCESS;
-    /* If the previous op was also a LINE_TO back to the start, discard it */
-    if (_cairo_path_last_op (path) == CAIRO_PATH_OP_LINE_TO) {
-	if (path->current_point.x == path->last_move_point.x &&
-	    path->current_point.y == path->last_move_point.y)
-	{
-	    cairo_path_buf_t *buf;
-	    cairo_point_t *p;
-	    buf = cairo_path_tail (path);
-	    if (likely (buf->num_points >= 2)) {
+	return CAIRO_STATUS_SUCCESS;
-		p = &buf->points[buf->num_points-2];
-	    } else {
+    /*
-		cairo_path_buf_t *prev_buf = cairo_path_buf_prev (buf);
+     * Add a line_to, to compute flags and solve any degeneracy.
-		p = &prev_buf->points[prev_buf->num_points - (2 - buf->num_points)];
-	    }
+     * It will be removed later (if it was actually added).
+     */
-	    path->current_point = *p;
+    status = _cairo_path_fixed_line_to (path,
-	    buf->num_ops--;
-	    buf->num_points--;
-	}
-    }
 					path->last_move_point.x,
-    status = _cairo_path_fixed_add (path, CAIRO_PATH_OP_CLOSE_PATH, NULL, 0);
+					path->last_move_point.y);
+    if (unlikely (status))
-    if (unlikely (status))
+	return status;
-	return status;
+    /*
+     * If the command used to close the path is a line_to, drop it.
+     * We must check that last command is actually a line_to,
+     * because the path could have been closed with a curve_to (and
+     * the previous line_to not added as it would be degenerate).
+     */
+    if (_cairo_path_fixed_last_op (path) == CAIRO_PATH_OP_LINE_TO)
+	    _cairo_path_fixed_drop_line_to (path);
-    return _cairo_path_fixed_move_to (path,
+    path->needs_move_to = TRUE; /* After close_path, add an implicit move_to */
 				      path->last_move_point.x,
-				      path->last_move_point.y);
+    return _cairo_path_fixed_add (path, CAIRO_PATH_OP_CLOSE_PATH, NULL, 0);
+}
 			     _cairo_fixed_to_double (points[i].x),
 			     _cairo_fixed_to_double (points[i].y));
+	}
 	len += snprintf (buf + len, sizeof (buf), "]");
 #define STRINGIFYFLAG(x)  (path->x ? #x " " : "")
 	fprintf (stderr,
-		 "_cairo_path_fixed_add (%s, %s)\n",
+		 "_cairo_path_fixed_add (%s, %s) [%s%s%s%s%s%s%s%s]\n",
+		 op_str[(int) op], buf,
+		 STRINGIFYFLAG(has_current_point),
+		 STRINGIFYFLAG(needs_move_to),
+		 STRINGIFYFLAG(has_extents),
+		 STRINGIFYFLAG(has_curve_to),
+		 STRINGIFYFLAG(stroke_is_rectilinear),
+		 STRINGIFYFLAG(fill_is_rectilinear),
+		 STRINGIFYFLAG(fill_is_empty),
+		 STRINGIFYFLAG(fill_maybe_region)
+		 );
-		 op_str[(int) op], buf);
+#undef STRINGIFYFLAG
+    }
 static void
 _cairo_path_buf_add_points (cairo_path_buf_t       *buf,
 			    const cairo_point_t    *points,
 			    int		            num_points)
+{
+    if (num_points == 0)
+	return;
     memcpy (buf->points + buf->num_points,
 	    points,
 	    sizeof (points[0]) * num_points);
     buf->num_points += num_points;
+}
 cairo_status_t
-_cairo_path_fixed_interpret (const cairo_path_fixed_t		*path,
-			     cairo_direction_t			 dir,
+_cairo_path_fixed_interpret (const cairo_path_fixed_t		*path,
 			     cairo_path_fixed_move_to_func_t	*move_to,
 			     cairo_path_fixed_line_to_func_t	*line_to,
 			     cairo_path_fixed_curve_to_func_t	*curve_to,
 			     cairo_path_fixed_close_path_func_t	*close_path,
 			     void				*closure)
-{
-    const uint8_t num_args[] = {
+{
-, /* cairo_path_move_to */
-, /* cairo_path_op_line_to */
-, /* cairo_path_op_curve_to */
-, /* cairo_path_op_close_path */
-    };
+    const cairo_path_buf_t *buf;
-    cairo_status_t status;
-    const cairo_path_buf_t *buf, *first;
-    cairo_bool_t forward = (dir == CAIRO_DIRECTION_FORWARD);
-    int step = forward ? 1 : -1;
-    buf = first = forward ? cairo_path_head (path) : cairo_path_tail (path);
-    do {
-	cairo_point_t *points;
-	int start, stop, i;
-	if (forward) {
-	    start = 0;
-	    stop = buf->num_ops;
-	    points = buf->points;
-	} else {
-	    start = buf->num_ops - 1;
-	    stop = -1;
-	    points = buf->points + buf->num_points;
-	}
-	for (i = start; i != stop; i += step) {
-	    cairo_path_op_t op = buf->op[i];
+    cairo_status_t status;
+    cairo_path_foreach_buf_start (buf, path) {
+	const cairo_point_t *points = buf->points;
-	    if (! forward)
+	unsigned int i;
 		points -= num_args[(int) op];
 	for (i = 0; i < buf->num_ops; i++) {
+	    switch (buf->op[i]) {
-	    switch (op) {
+	    case CAIRO_PATH_OP_MOVE_TO:
-	    case CAIRO_PATH_OP_MOVE_TO:
+		status = (*move_to) (closure, &points[0]);
-		status = (*move_to) (closure, &points[0]);
+		points += 1;
+		break;
-		break;
+	    case CAIRO_PATH_OP_LINE_TO:
-	    case CAIRO_PATH_OP_LINE_TO:
+		status = (*line_to) (closure, &points[0]);
-		status = (*line_to) (closure, &points[0]);
+		points += 1;
+		break;
-		break;
+	    case CAIRO_PATH_OP_CURVE_TO:
-	    case CAIRO_PATH_OP_CURVE_TO:
+		status = (*curve_to) (closure, &points[0], &points[1], &points[2]);
-		status = (*curve_to) (closure, &points[0], &points[1], &points[2]);
+		points += 3;
 		break;
 	    default:
 		ASSERT_NOT_REACHED;
 	    case CAIRO_PATH_OP_CLOSE_PATH:
+		status = (*close_path) (closure);
-		status = (*close_path) (closure);
+		break;
 		break;
-	    }
-	    if (unlikely (status))
-		return status;
-	    if (forward)
+	    if (unlikely (status))
-		points += num_args[(int) op];
+		return status;
+	}
-    } while ((buf = forward ? cairo_path_buf_next (buf) : cairo_path_buf_prev (buf)) != first);
+    } cairo_path_foreach_buf_end (buf, path);
+}
 cairo_status_t
 _cairo_path_fixed_append (cairo_path_fixed_t		    *path,
-			  const cairo_path_fixed_t	    *other,
-			  cairo_direction_t		     dir,
+			  const cairo_path_fixed_t	    *other,
 			  cairo_fixed_t			     tx,
 			  cairo_fixed_t			     ty)
+{
     cairo_path_fixed_append_closure_t closure;
     closure.path = path;
     closure.offset.x = tx;
     closure.offset.y = ty;
-    return _cairo_path_fixed_interpret (other, dir,
+    return _cairo_path_fixed_interpret (other,
 					_append_move_to,
 					_append_line_to,
 				    cairo_fixed_t scaley)
+{
     cairo_path_buf_t *buf;
     unsigned int i;
-    if (path->maybe_fill_region) {
-	path->maybe_fill_region = _cairo_fixed_is_integer (offx) &&
-	                          _cairo_fixed_is_integer (offy) &&
+    if (scalex == CAIRO_FIXED_ONE && scaley == CAIRO_FIXED_ONE) {
-			          _cairo_fixed_is_integer (scalex) &&
+	_cairo_path_fixed_translate (path, offx, offy);
-			          _cairo_fixed_is_integer (scaley);
+	return;
+    }
+    path->last_move_point.x = _cairo_fixed_mul (scalex, path->last_move_point.x) + offx;
+    path->last_move_point.y = _cairo_fixed_mul (scaley, path->last_move_point.y) + offy;
+    path->current_point.x   = _cairo_fixed_mul (scalex, path->current_point.x) + offx;
+    path->current_point.y   = _cairo_fixed_mul (scaley, path->current_point.y) + offy;
     path->fill_maybe_region = TRUE;
     cairo_path_foreach_buf_start (buf, path) {
 	 for (i = 0; i < buf->num_points; i++) {
 	     if (scalex != CAIRO_FIXED_ONE)
 		 buf->points[i].x = _cairo_fixed_mul (buf->points[i].x, scalex);
 	     buf->points[i].x += offx;
+	     if (scaley != CAIRO_FIXED_ONE)
+		 buf->points[i].y = _cairo_fixed_mul (buf->points[i].y, scaley);
+	     buf->points[i].y += offy;
+	    if (path->fill_maybe_region) {
-	     if (scaley != CAIRO_FIXED_ONE)
+		path->fill_maybe_region = _cairo_fixed_is_integer (buf->points[i].x) &&
-		 buf->points[i].y = _cairo_fixed_mul (buf->points[i].y, scaley);
+					  _cairo_fixed_is_integer (buf->points[i].y);
+	    }
+	 }
-	     buf->points[i].y += offy;
+    } cairo_path_foreach_buf_end (buf, path);
+    path->fill_maybe_region &= path->fill_is_rectilinear;
+    path->extents.p1.x = _cairo_fixed_mul (scalex, path->extents.p1.x) + offx;
+    path->extents.p2.x = _cairo_fixed_mul (scalex, path->extents.p2.x) + offx;
+    if (scalex < 0) {
-    } cairo_path_foreach_buf_end (buf, path);
+	cairo_fixed_t t = path->extents.p1.x;
 	path->extents.p1.x = path->extents.p2.x;
+	path->extents.p2.x = t;
+    }
+    path->extents.p1.y = _cairo_fixed_mul (scaley, path->extents.p1.y) + offy;
+    path->extents.p2.y = _cairo_fixed_mul (scaley, path->extents.p2.y) + offy;
-    path->extents.p1.x = _cairo_fixed_mul (scalex, path->extents.p1.x) + offx;
+    if (scaley < 0) {
-    path->extents.p2.x = _cairo_fixed_mul (scalex, path->extents.p2.x) + offx;
+	cairo_fixed_t t = path->extents.p1.y;
 	path->extents.p1.y = path->extents.p2.y;
-    path->extents.p1.y = _cairo_fixed_mul (scaley, path->extents.p1.y) + offy;
+	path->extents.p2.y = t;
     unsigned int i;
     if (offx == 0 && offy == 0)
-	return;
-    if (path->maybe_fill_region &&
-	! (_cairo_fixed_is_integer (offx) && _cairo_fixed_is_integer (offy)))
-    {
-	path->maybe_fill_region = FALSE;
 	return;
     path->last_move_point.x += offx;
     path->last_move_point.y += offy;
+    path->current_point.x += offx;
+    path->current_point.y += offy;
     path->current_point.x += offx;
-    path->current_point.y += offy;
+    path->fill_maybe_region = TRUE;
     cairo_path_foreach_buf_start (buf, path) {
+	for (i = 0; i < buf->num_points; i++) {
+	    buf->points[i].x += offx;
+	    buf->points[i].y += offy;
+	    if (path->fill_maybe_region) {
-	 for (i = 0; i < buf->num_points; i++) {
+		path->fill_maybe_region = _cairo_fixed_is_integer (buf->points[i].x) &&
-	     buf->points[i].x += offx;
+					  _cairo_fixed_is_integer (buf->points[i].y);
+	    }
+	 }
-	     buf->points[i].y += offy;
+    } cairo_path_foreach_buf_end (buf, path);
-    } cairo_path_foreach_buf_end (buf, path);
+    path->fill_maybe_region &= path->fill_is_rectilinear;
     path->extents.p1.x += offx;
+    path->extents.p1.y += offy;
+    path->extents.p2.x += offx;
+    path->extents.p2.y += offy;
+}
+static inline void
+_cairo_path_fixed_transform_point (cairo_point_t *p,
+				   const cairo_matrix_t *matrix)
+{
+    double dx, dy;
+    dx = _cairo_fixed_to_double (p->x);
+    dy = _cairo_fixed_to_double (p->y);
-    path->extents.p1.y += offy;
+    cairo_matrix_transform_point (matrix, &dx, &dy);
-    path->extents.p2.x += offx;
+    p->x = _cairo_fixed_from_double (dx);
-    path->extents.p2.y += offy;
+    p->y = _cairo_fixed_from_double (dy);
+}
  **/
 void
 _cairo_path_fixed_transform (cairo_path_fixed_t	*path,
 			     const cairo_matrix_t     *matrix)
+{
+    cairo_box_t extents;
+    cairo_point_t point;
     cairo_path_buf_t *buf;
     unsigned int i;
-    double dx, dy;
-    /* XXX current_point, last_move_to */
     if (matrix->yx == 0.0 && matrix->xy == 0.0) {
-	/* Fast path for the common case of scale+transform */
-	 if (matrix->xx == 1. && matrix->yy == 1.) {
-	     _cairo_path_fixed_translate (path,
-					  _cairo_fixed_from_double (matrix->x0),
-					  _cairo_fixed_from_double (matrix->y0));
-	 } else {
+	/* Fast path for the common case of scale+transform */
-	     _cairo_path_fixed_offset_and_scale (path,
+	_cairo_path_fixed_offset_and_scale (path,
-						 _cairo_fixed_from_double (matrix->x0),
+					    _cairo_fixed_from_double (matrix->x0),
-						 _cairo_fixed_from_double (matrix->y0),
+					    _cairo_fixed_from_double (matrix->y0),
-						 _cairo_fixed_from_double (matrix->xx),
+					    _cairo_fixed_from_double (matrix->xx),
-						 _cairo_fixed_from_double (matrix->yy));
 					    _cairo_fixed_from_double (matrix->yy));
 	return;
-    }
-    path->extents.p1.x = path->extents.p1.y = INT_MAX;
-    path->extents.p2.x = path->extents.p2.y = INT_MIN;
-    path->maybe_fill_region = FALSE;
-    cairo_path_foreach_buf_start (buf, path) {
+    }
-	 for (i = 0; i < buf->num_points; i++) {
-	    dx = _cairo_fixed_to_double (buf->points[i].x);
+    _cairo_path_fixed_transform_point (&path->last_move_point, matrix);
+    _cairo_path_fixed_transform_point (&path->current_point, matrix);
+    buf = cairo_path_head (path);
+    if (buf->num_points == 0)
-	    dy = _cairo_fixed_to_double (buf->points[i].y);
+	return;
-	    cairo_matrix_transform_point (matrix, &dx, &dy);
+    extents = path->extents;
+    point = buf->points[0];
+    _cairo_path_fixed_transform_point (&point, matrix);
+    _cairo_box_set (&path->extents, &point, &point);
 	    buf->points[i].x = _cairo_fixed_from_double (dx);
-	    buf->points[i].y = _cairo_fixed_from_double (dy);
+    cairo_path_foreach_buf_start (buf, path) {
-	    /* XXX need to eliminate surplus move-to's? */
-	    _cairo_path_fixed_extents_add (path, &buf->points[i]);
-	 }
+	for (i = 0; i < buf->num_points; i++) {
-    } cairo_path_foreach_buf_end (buf, path);
-}
+	    _cairo_path_fixed_transform_point (&buf->points[i], matrix);
+	    _cairo_box_add_point (&path->extents, &buf->points[i]);
-cairo_bool_t
-_cairo_path_fixed_is_equal (const cairo_path_fixed_t *path,
-			    const cairo_path_fixed_t *other)
-{
+	}
-    const cairo_path_buf_t *path_buf, *other_buf;
-    if (path->current_point.x != other->current_point.x ||
+    } cairo_path_foreach_buf_end (buf, path);
-	path->current_point.y != other->current_point.y ||
-	path->has_current_point != other->has_current_point ||
-	path->has_curve_to != other->has_curve_to ||
-	path->is_rectilinear != other->is_rectilinear ||
-	path->maybe_fill_region != other->maybe_fill_region ||
-	path->last_move_point.x != other->last_move_point.x ||
-	path->last_move_point.y != other->last_move_point.y)
-    {
+    if (path->has_curve_to) {
-	return FALSE;
-    }
-    other_buf = cairo_path_head (other);
+	cairo_bool_t is_tight;
-    cairo_path_foreach_buf_start (path_buf, path) {
-	if (path_buf->num_ops != other_buf->num_ops ||
+	_cairo_matrix_transform_bounding_box_fixed (matrix, &extents, &is_tight);
-	    path_buf->num_points != other_buf->num_points ||
-	    memcmp (path_buf->op, other_buf->op,
+	if (!is_tight) {
+	    cairo_bool_t has_extents;
-		    sizeof (cairo_path_op_t) * path_buf->num_ops) != 0 ||
+	    has_extents = _cairo_path_bounder_extents (path, &extents);
+	    assert (has_extents);
 	    memcmp (path_buf->points, other_buf->points,
-		    sizeof (cairo_point_t) * path_buf->num_points) != 0)
+	path->extents = extents;
+    }
 	    return FALSE;
     cairo_spline_t spline;
     cairo_point_t *p0 = &cpf->current_point;
     if (! _cairo_spline_init (&spline,
-			      cpf->line_to,
+			      (cairo_spline_add_point_func_t)cpf->line_to,
 			      cpf->closure,
 			      p0, p1, p2, p3))
+    {
     return cpf->close_path (cpf->closure);
+}
 cairo_status_t
-_cairo_path_fixed_interpret_flat (const cairo_path_fixed_t		*path,
-				  cairo_direction_t			dir,
+_cairo_path_fixed_interpret_flat (const cairo_path_fixed_t		*path,
 				  cairo_path_fixed_move_to_func_t	*move_to,
 				  cairo_path_fixed_line_to_func_t	*line_to,
 				  cairo_path_fixed_close_path_func_t	*close_path,
 				  void					*closure,
 				  double				tolerance)
+{
     cpf_t flattener;
     if (! path->has_curve_to) {
-	return _cairo_path_fixed_interpret (path, dir,
+	return _cairo_path_fixed_interpret (path,
 					    move_to,
 					    line_to,
 					    NULL,
     flattener.tolerance = tolerance;
     flattener.move_to = move_to;
     flattener.line_to = line_to;
     flattener.close_path = close_path;
     flattener.closure = closure;
-    return _cairo_path_fixed_interpret (path, dir,
+    return _cairo_path_fixed_interpret (path,
 					_cpf_move_to,
 					_cpf_line_to,
 					_cpf_curve_to,
 					_cpf_close_path,
 					&flattener);
 	box->p1.y = p2->y;
 	box->p2.y = p1->y;
+    }
+}
-/*
- * Check whether the given path contains a single rectangle.
- */
-cairo_bool_t
+static inline cairo_bool_t
-_cairo_path_fixed_is_box (const cairo_path_fixed_t *path,
-			  cairo_box_t *box)
+_path_is_quad (const cairo_path_fixed_t *path)
+{
-    const cairo_path_buf_t *buf = cairo_path_head (path);
-    if (! path->is_rectilinear)
-	return FALSE;
+    const cairo_path_buf_t *buf = cairo_path_head (path);
     /* Do we have the right number of ops? */
     if (buf->num_ops < 4 || buf->num_ops > 6)
 		buf->op[5] != CAIRO_PATH_OP_CLOSE_PATH)
 		return FALSE;
+	}
+    }
+    return TRUE;
+}
+static inline cairo_bool_t
+_points_form_rect (const cairo_point_t *points)
+{
+    if (points[0].y == points[1].y &&
+	points[1].x == points[2].x &&
+	points[2].y == points[3].y &&
+	points[3].x == points[0].x)
+	return TRUE;
+    if (points[0].x == points[1].x &&
+	points[1].y == points[2].y &&
+	points[2].x == points[3].x &&
+	points[3].y == points[0].y)
+	return TRUE;
+    return FALSE;
+}
+/*
+ * Check whether the given path contains a single rectangle.
+ */
+cairo_bool_t
+_cairo_path_fixed_is_box (const cairo_path_fixed_t *path,
+			  cairo_box_t *box)
+{
+    const cairo_path_buf_t *buf;
+    if (! path->fill_is_rectilinear)
+	return FALSE;
+    if (! _path_is_quad (path))
+	return FALSE;
+    buf = cairo_path_head (path);
+    if (_points_form_rect (buf->points)) {
+	_canonical_box (box, &buf->points[0], &buf->points[2]);
+	return TRUE;
+    }
+    return FALSE;
+}
+/* Determine whether two lines A->B and C->D intersect based on the
+ * algorithm described here: http://paulbourke.net/geometry/pointlineplane/ */
+static inline cairo_bool_t
+_lines_intersect_or_are_coincident (cairo_point_t a,
+				    cairo_point_t b,
+				    cairo_point_t c,
+				    cairo_point_t d)
+{
+    cairo_int64_t numerator_a, numerator_b, denominator;
+    cairo_bool_t denominator_negative;
+    denominator = _cairo_int64_sub (_cairo_int32x32_64_mul (d.y - c.y, b.x - a.x),
+				    _cairo_int32x32_64_mul (d.x - c.x, b.y - a.y));
+    numerator_a = _cairo_int64_sub (_cairo_int32x32_64_mul (d.x - c.x, a.y - c.y),
+				    _cairo_int32x32_64_mul (d.y - c.y, a.x - c.x));
+    numerator_b = _cairo_int64_sub (_cairo_int32x32_64_mul (b.x - a.x, a.y - c.y),
+				    _cairo_int32x32_64_mul (b.y - a.y, a.x - c.x));
+    if (_cairo_int64_is_zero (denominator)) {
+	/* If the denominator and numerators are both zero,
+	 * the lines are coincident. */
+	if (_cairo_int64_is_zero (numerator_a) && _cairo_int64_is_zero (numerator_b))
+	    return TRUE;
+	/* Otherwise, a zero denominator indicates the lines are
+	*  parallel and never intersect. */
+	return FALSE;
+    }
+    /* The lines intersect if both quotients are between 0 and 1 (exclusive). */
+     /* We first test whether either quotient is a negative number. */
+    denominator_negative = _cairo_int64_negative (denominator);
+    if (_cairo_int64_negative (numerator_a) ^ denominator_negative)
+	return FALSE;
+    if (_cairo_int64_negative (numerator_b) ^ denominator_negative)
+	return FALSE;
+    /* A zero quotient indicates an "intersection" at an endpoint, which
+     * we aren't considering a true intersection. */
+    if (_cairo_int64_is_zero (numerator_a) || _cairo_int64_is_zero (numerator_b))
+	return FALSE;
+    /* If the absolute value of the numerator is larger than or equal to the
+     * denominator the result of the division would be greater than or equal
+     * to one. */
+    if (! denominator_negative) {
+        if (! _cairo_int64_lt (numerator_a, denominator) ||
+	    ! _cairo_int64_lt (numerator_b, denominator))
+	    return FALSE;
+    } else {
+        if (! _cairo_int64_lt (denominator, numerator_a) ||
+	    ! _cairo_int64_lt (denominator, numerator_b))
+	    return FALSE;
+    }
+    return TRUE;
+}
+cairo_bool_t
+_cairo_path_fixed_is_simple_quad (const cairo_path_fixed_t *path)
+{
+    const cairo_point_t *points;
+    if (! _path_is_quad (path))
+	return FALSE;
+    points = cairo_path_head (path)->points;
+    if (_points_form_rect (points))
+	return TRUE;
+    if (_lines_intersect_or_are_coincident (points[0], points[1],
+					    points[3], points[2]))
+	return FALSE;
+    if (_lines_intersect_or_are_coincident (points[0], points[3],
+					    points[1], points[2]))
+	return FALSE;
+    return TRUE;
+}
+cairo_bool_t
+_cairo_path_fixed_is_stroke_box (const cairo_path_fixed_t *path,
+				 cairo_box_t *box)
+{
+    const cairo_path_buf_t *buf = cairo_path_head (path);
+    if (! path->fill_is_rectilinear)
+	return FALSE;
+    /* Do we have the right number of ops? */
+    if (buf->num_ops != 5)
+	return FALSE;
+    /* Check whether the ops are those that would be used for a rectangle */
+    if (buf->op[0] != CAIRO_PATH_OP_MOVE_TO ||
+	buf->op[1] != CAIRO_PATH_OP_LINE_TO ||
+	buf->op[2] != CAIRO_PATH_OP_LINE_TO ||
+	buf->op[3] != CAIRO_PATH_OP_LINE_TO ||
+	buf->op[4] != CAIRO_PATH_OP_CLOSE_PATH)
+    {
+	return FALSE;
+    }
     /* Ok, we may have a box, if the points line up */
     if (buf->points[0].y == buf->points[1].y &&
 	buf->points[1].x == buf->points[2].x &&
 	buf->points[2].y == buf->points[3].y &&
     const cairo_path_buf_t *buf;
     if (! _cairo_path_fixed_is_box (path, box))
+	return FALSE;
+    /* This check is valid because the current implementation of
-	return FALSE;
+     * _cairo_path_fixed_is_box () only accepts rectangles like:
+     * move,line,line,line[,line|close[,close|move]]. */
     buf = cairo_path_head (path);
-    if (buf->points[0].y == buf->points[1].y)
+    if (buf->num_ops > 4)
 	return TRUE;
     if (_iter->buf == NULL)
 	return FALSE;
-    iter = *_iter;
+    iter = *_iter;
-    if (iter.n_op == iter.buf->num_ops &&
 	! _cairo_path_fixed_iter_next_op (&iter))
-    {
-	return FALSE;
+    if (iter.n_op == iter.buf->num_ops && ! _cairo_path_fixed_iter_next_op (&iter))
 	return FALSE;
     /* Check whether the ops are those that would be used for a rectangle */
 	return FALSE;
     points[1] = iter.buf->points[iter.n_point++];
     if (! _cairo_path_fixed_iter_next_op (&iter))
 	return FALSE;
+    /* a horizontal/vertical closed line is also a degenerate rectangle */
+    switch (iter.buf->op[iter.n_op]) {
+    case CAIRO_PATH_OP_CLOSE_PATH:
+	_cairo_path_fixed_iter_next_op (&iter);
+    case CAIRO_PATH_OP_MOVE_TO: /* implicit close */
+	box->p1 = box->p2 = points[0];
+	*_iter = iter;
+	return TRUE;
-    if (iter.buf->op[iter.n_op] != CAIRO_PATH_OP_LINE_TO)
+    default:
+	return FALSE;
+    case CAIRO_PATH_OP_LINE_TO:
+	break;
+    }
 	return FALSE;
     points[2] = iter.buf->points[iter.n_point++];
     if (! _cairo_path_fixed_iter_next_op (&iter))
 	return FALSE;
     if (iter.buf->op[iter.n_op] != CAIRO_PATH_OP_LINE_TO)
-	return FALSE;
-    points[3] = iter.buf->points[iter.n_point++];
-    if (! _cairo_path_fixed_iter_next_op (&iter))
+	return FALSE;
-	return FALSE;
+    points[3] = iter.buf->points[iter.n_point++];
+    /* Now, there are choices. The rectangle might end with a LINE_TO
+     * (to the original point), but this isn't required. If it
-    /* Now, there are choices. The rectangle might end with a LINE_TO
+     * doesn't, then it must end with a CLOSE_PATH (which may be implicit). */
-     * (to the original point), but this isn't required. If it
-     * doesn't, then it must end with a CLOSE_PATH (which may be implicit). */
+    if (! _cairo_path_fixed_iter_next_op (&iter)) {
-    if (iter.buf->op[iter.n_op] == CAIRO_PATH_OP_LINE_TO)
+	/* implicit close due to fill */
     } else if (iter.buf->op[iter.n_op] == CAIRO_PATH_OP_LINE_TO) {
 	points[4] = iter.buf->points[iter.n_point++];
 	if (points[4].x != points[0].x || points[4].y != points[0].y)
+	    return FALSE;
-	    return FALSE;
+	_cairo_path_fixed_iter_next_op (&iter);
+    } else if (iter.buf->op[iter.n_op] == CAIRO_PATH_OP_CLOSE_PATH) {
-    }
+	_cairo_path_fixed_iter_next_op (&iter);
-    else if (! (iter.buf->op[iter.n_op] == CAIRO_PATH_OP_CLOSE_PATH ||
+    } else if (iter.buf->op[iter.n_op] == CAIRO_PATH_OP_MOVE_TO) {
-		iter.buf->op[iter.n_op] == CAIRO_PATH_OP_MOVE_TO))
+	/* implicit close-path due to new-sub-path */
-    {
-	return FALSE;
     } else {
-    if (! _cairo_path_fixed_iter_next_op (&iter))
+	return FALSE;
 	return FALSE;
 _cairo_path_fixed_iter_at_end (const cairo_path_fixed_iter_t *iter)
+{
     if (iter->buf == NULL)
 	return TRUE;
-    if (iter->n_op == iter->buf->num_ops)
-	return TRUE;
-    if (iter->buf->op[iter->n_op] == CAIRO_PATH_OP_MOVE_TO &&
-	iter->buf->num_ops == iter->n_op + 1)
-    {
-	return TRUE;
-    }
-    return FALSE;
+    return iter->n_op == iter->buf->num_ops;

Subversion Repositories Kolibri OS

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