1 files changed, 274 insertions, 279 deletions

diff --git a/src/cairo-path-fixed.c b/src/cairo-path-fixed.c
index eea8630..e3e273b 100644
--- a/src/cairo-path-fixed.c
+++ b/src/cairo-path-fixed.c
@@ -38,6 +38,7 @@
 
 #include "cairoint.h"
 
+#include "cairo-box-private.h"
 #include "cairo-error-private.h"
 #include "cairo-path-fixed-private.h"
 #include "cairo-slope-private.h"
@@ -97,15 +98,18 @@ _cairo_path_fixed_init (cairo_path_fixed_t *path)
     path->current_point.x = 0;
     path->current_point.y = 0;
     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_extents = FALSE;
     path->has_curve_to = FALSE;
-    path->is_rectilinear = TRUE;
-    path->maybe_fill_region = TRUE;
-    path->is_empty_fill = TRUE;
+    path->stroke_is_rectilinear = TRUE;
+    path->fill_is_rectilinear = TRUE;
+    path->fill_maybe_region = TRUE;
+    path->fill_is_empty = TRUE;
 
-    path->extents.p1.x = path->extents.p1.y = INT_MAX;
-    path->extents.p2.x = path->extents.p2.y = INT_MIN;
+    path->extents.p1.x = path->extents.p1.y = 0;
+    path->extents.p2.x = path->extents.p2.y = 0;
 }
 
 cairo_status_t
@@ -126,12 +130,15 @@ _cairo_path_fixed_init_copy (cairo_path_fixed_t *path,
 
     path->current_point = other->current_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_extents = other->has_extents;
     path->has_curve_to = other->has_curve_to;
-    path->is_rectilinear = other->is_rectilinear;
-    path->maybe_fill_region = other->maybe_fill_region;
-    path->is_empty_fill = other->is_empty_fill;
+    path->stroke_is_rectilinear = other->stroke_is_rectilinear;
+    path->fill_is_rectilinear = other->fill_is_rectilinear;
+    path->fill_maybe_region = other->fill_maybe_region;
+    path->fill_is_empty = other->fill_is_empty;
 
     path->extents = other->extents;
 
@@ -182,23 +189,23 @@ _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;
+    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;
-	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));
-    hash = _cairo_hash_bytes (hash, &num_points, sizeof (num_points));
+    hash = _cairo_hash_bytes (hash, &count, sizeof (count));
 
     return hash;
 }
@@ -233,10 +240,7 @@ _cairo_path_fixed_equal (const cairo_path_fixed_t *a,
 	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 ||
-	a->is_rectilinear != b->is_rectilinear)
+    if (a->has_curve_to != b->has_curve_to)
     {
 	return FALSE;
     }
@@ -365,31 +369,43 @@ _cairo_path_fixed_destroy (cairo_path_fixed_t *path)
     free (path);
 }
 
-static cairo_path_op_t
-_cairo_path_last_op (cairo_path_fixed_t *path)
+static inline cairo_path_op_t
+_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)
-	return -1;
+    assert (buf->num_ops != 0);
 
     return buf->op[buf->num_ops - 1];
 }
 
-static inline void
-_cairo_path_fixed_extents_add (cairo_path_fixed_t *path,
-			       const cairo_point_t *point)
+static inline const cairo_point_t *
+_cairo_path_fixed_penultimate_point (cairo_path_fixed_t *path)
 {
-    if (point->x < path->extents.p1.x)
-	path->extents.p1.x = point->x;
-    if (point->y < path->extents.p1.y)
-	path->extents.p1.y = point->y;
-
-    if (point->x > path->extents.p2.x)
-	path->extents.p2.x = point->x;
-    if (point->y > path->extents.p2.y)
-	path->extents.p2.y = point->y;
+    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);
+
+	assert (prev_buf->num_points >= 2 - buf->num_points);
+	return &prev_buf->points[prev_buf->num_points - (2 - buf->num_points)];
+    }
+}
+
+static void
+_cairo_path_fixed_drop_line_to (cairo_path_fixed_t *path)
+{
+    cairo_path_buf_t *buf;
+
+    assert (_cairo_path_fixed_last_op (path) == CAIRO_PATH_OP_LINE_TO);
+
+    buf = cairo_path_tail (path);
+    buf->num_points--;
+    buf->num_ops--;
 }
 
 cairo_status_t
@@ -397,48 +413,54 @@ _cairo_path_fixed_move_to (cairo_path_fixed_t  *path,
 			   cairo_fixed_t	x,
 			   cairo_fixed_t	y)
 {
-    cairo_status_t status;
-    cairo_point_t point;
+    _cairo_path_fixed_new_sub_path (path);
 
-    point.x = x;
-    point.y = y;
+    path->has_current_point = TRUE;
+    path->current_point.x = x;
+    path->current_point.y = y;
+
+    return CAIRO_STATUS_SUCCESS;
+}
+
+static cairo_status_t
+_cairo_path_fixed_move_to_apply (cairo_path_fixed_t  *path)
+{
+    if (likely (! path->needs_move_to))
+	return CAIRO_STATUS_SUCCESS;
 
-    /* If the previous op was also a MOVE_TO, then just change its
-     * point rather than adding a new op. */
-    if (_cairo_path_last_op (path) == CAIRO_PATH_OP_MOVE_TO) {
-	cairo_path_buf_t *buf;
+    path->needs_move_to = FALSE;
 
-	buf = cairo_path_tail (path);
-	buf->points[buf->num_points - 1] = point;
+    if (path->has_extents) {
+	_cairo_box_add_point (&path->extents, &path->current_point);
     } else {
-	status = _cairo_path_fixed_add (path, CAIRO_PATH_OP_MOVE_TO, &point, 1);
-	if (unlikely (status))
-	    return status;
-
-	if (path->has_current_point && path->is_rectilinear) {
-	    /* a move-to is first an implicit close */
-	    path->is_rectilinear = path->current_point.x == path->last_move_point.x ||
-				   path->current_point.y == path->last_move_point.y;
-	    path->maybe_fill_region &= path->is_rectilinear;
-	}
-	if (path->maybe_fill_region) {
-	    path->maybe_fill_region =
-		_cairo_fixed_is_integer (path->last_move_point.x) &&
-		_cairo_fixed_is_integer (path->last_move_point.y);
-	}
+	_cairo_box_set (&path->extents, &path->current_point, &path->current_point);
+	path->has_extents = TRUE;
     }
 
-    path->current_point = point;
-    path->last_move_point = point;
-    path->has_last_move_point = TRUE;
-    path->has_current_point = TRUE;
+    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);
+    }
 
-    return CAIRO_STATUS_SUCCESS;
+    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)
 {
+    if (! path->needs_move_to) {
+	/* If the current subpath doesn't need_move_to, it contains at least one command */
+	if (path->fill_is_rectilinear) {
+	    /* Implicitly close for fill */
+	    path->fill_is_rectilinear = path->current_point.x == path->last_move_point.x ||
+					path->current_point.y == path->last_move_point.y;
+	    path->fill_maybe_region &= path->fill_is_rectilinear;
+	}
+	path->needs_move_to = TRUE;
+    }
+
     path->has_current_point = FALSE;
 }
 
@@ -475,12 +497,16 @@ _cairo_path_fixed_line_to (cairo_path_fixed_t *path,
     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;
     }
@@ -488,22 +514,13 @@ _cairo_path_fixed_line_to (cairo_path_fixed_t *path,
     /* 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)];
-	}
-
+	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 */
-	    buf->points[buf->num_points - 1] = point;
-	    goto FLAGS;
+	    _cairo_path_fixed_drop_line_to (path);
 	} else {
 	    cairo_slope_t prev, self;
 
@@ -513,38 +530,36 @@ _cairo_path_fixed_line_to (cairo_path_fixed_t *path,
 		/* cannot trim anti-parallel segments whilst stroking */
 		! _cairo_slope_backwards (&prev, &self))
 	    {
-		buf->points[buf->num_points - 1] = point;
-		goto FLAGS;
+		_cairo_path_fixed_drop_line_to (path);
+		/* In this case the flags might be more restrictive than
+		 * what we actually need.
+		 * When changing the flags definition we should check if
+		 * changing the line_to point can affect them.
+		*/
 	    }
 	}
     }
 
-    status = _cairo_path_fixed_add (path, CAIRO_PATH_OP_LINE_TO, &point, 1);
-    if (unlikely (status))
-	return status;
-
-  FLAGS:
-    if (path->is_rectilinear) {
-	path->is_rectilinear = path->current_point.x == x ||
-			       path->current_point.y == y;
-	path->maybe_fill_region &= path->is_rectilinear;
-    }
-    if (path->maybe_fill_region) {
-	path->maybe_fill_region = _cairo_fixed_is_integer (x) &&
-				  _cairo_fixed_is_integer (y);
-    }
-    if (path->is_empty_fill) {
-	path->is_empty_fill = path->current_point.x == x &&
-			      path->current_point.y == y;
+    if (path->stroke_is_rectilinear) {
+	path->stroke_is_rectilinear = path->current_point.x == x ||
+				      path->current_point.y == y;
+	path->fill_is_rectilinear &= path->stroke_is_rectilinear;
+	path->fill_maybe_region &= path->fill_is_rectilinear;
+	if (path->fill_maybe_region) {
+	    path->fill_maybe_region = _cairo_fixed_is_integer (x) &&
+				      _cairo_fixed_is_integer (y);
+	}
+	if (path->fill_is_empty) {
+	    path->fill_is_empty = path->current_point.x == x &&
+				  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->has_last_move_point = FALSE;
-    }
-    _cairo_path_fixed_extents_add (path, &point);
-    return CAIRO_STATUS_SUCCESS;
+
+    _cairo_box_add_point (&path->extents, &point);
+
+    return _cairo_path_fixed_add (path, CAIRO_PATH_OP_LINE_TO, &point, 1);
 }
 
 cairo_status_t
@@ -572,34 +587,39 @@ _cairo_path_fixed_curve_to (cairo_path_fixed_t	*path,
     /* make sure subpaths are started properly */
     if (! path->has_current_point) {
 	status = _cairo_path_fixed_move_to (path, x0, y0);
-	if (unlikely (status))
-	    return status;
+	assert (status == CAIRO_STATUS_SUCCESS);
+    }
+
+    status = _cairo_path_fixed_move_to_apply (path);
+    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);
+	}
     }
 
     point[0].x = x0; point[0].y = y0;
     point[1].x = x1; point[1].y = y1;
     point[2].x = x2; point[2].y = y2;
-    status = _cairo_path_fixed_add (path, CAIRO_PATH_OP_CURVE_TO, point, 3);
-    if (unlikely (status))
-	return status;
+
+    _cairo_box_add_curve_to (&path->extents, &path->current_point,
+			     &point[0], &point[1], &point[2]);
 
     path->current_point = point[2];
-    path->has_current_point = TRUE;
-    path->is_empty_fill = FALSE;
     path->has_curve_to = TRUE;
-    path->is_rectilinear = FALSE;
-    path->maybe_fill_region = FALSE;
-
-    /* coarse bounds */
-    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]);
-    _cairo_path_fixed_extents_add (path, &point[1]);
-    _cairo_path_fixed_extents_add (path, &point[2]);
+    path->stroke_is_rectilinear = FALSE;
+    path->fill_is_rectilinear = FALSE;
+    path->fill_maybe_region = FALSE;
+    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
@@ -630,35 +650,28 @@ _cairo_path_fixed_close_path (cairo_path_fixed_t *path)
     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)) {
-		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)];
-	    }
-
-	    path->current_point = *p;
-	    buf->num_ops--;
-	    buf->num_points--;
-	}
-    }
-
-    status = _cairo_path_fixed_add (path, CAIRO_PATH_OP_CLOSE_PATH, NULL, 0);
+    /*
+     * Add a line_to, to compute flags and solve any degeneracy.
+     * It will be removed later (if it was actually added).
+     */
+    status = _cairo_path_fixed_line_to (path,
+					path->last_move_point.x,
+					path->last_move_point.y);
     if (unlikely (status))
 	return status;
 
-    return _cairo_path_fixed_move_to (path,
-				      path->last_move_point.x,
-				      path->last_move_point.y);
+    /*
+     * 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);
+
+    path->needs_move_to = TRUE; /* After close_path, add an implicit move_to */
+
+    return _cairo_path_fixed_add (path, CAIRO_PATH_OP_CLOSE_PATH, NULL, 0);
 }
 
 cairo_bool_t
@@ -714,9 +727,20 @@ _cairo_path_fixed_add (cairo_path_fixed_t   *path,
 	}
 	len += snprintf (buf + len, sizeof (buf), "]");
 
+#define STRINGIFYFLAG(x)  (path->x ? #x " " : "")
 	fprintf (stderr,
-		 "_cairo_path_fixed_add (%s, %s)\n",
-		 op_str[(int) op], buf);
+		 "_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)
+		 );
+#undef STRINGIFYFLAG
     }
 
     _cairo_path_buf_add_op (buf, op);
@@ -780,54 +804,32 @@ _cairo_path_buf_add_points (cairo_path_buf_t       *buf,
 
 cairo_status_t
 _cairo_path_fixed_interpret (const cairo_path_fixed_t		*path,
-			     cairo_direction_t			 dir,
 			     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[] = {
-	1, /* cairo_path_move_to */
-	1, /* cairo_path_op_line_to */
-	3, /* cairo_path_op_curve_to */
-	0, /* 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];
-
-	    if (! forward)
-		points -= num_args[(int) op];
+    cairo_path_foreach_buf_start (buf, path) {
+	const cairo_point_t *points = buf->points;
+	unsigned int i;
 
-	    switch (op) {
+	for (i = 0; i < buf->num_ops; i++) {
+	    switch (buf->op[i]) {
 	    case CAIRO_PATH_OP_MOVE_TO:
 		status = (*move_to) (closure, &points[0]);
+		points += 1;
 		break;
 	    case CAIRO_PATH_OP_LINE_TO:
 		status = (*line_to) (closure, &points[0]);
+		points += 1;
 		break;
 	    case CAIRO_PATH_OP_CURVE_TO:
 		status = (*curve_to) (closure, &points[0], &points[1], &points[2]);
+		points += 3;
 		break;
 	    default:
 		ASSERT_NOT_REACHED;
@@ -835,13 +837,11 @@ _cairo_path_fixed_interpret (const cairo_path_fixed_t		*path,
 		status = (*close_path) (closure);
 		break;
 	    }
+
 	    if (unlikely (status))
 		return status;
-
-	    if (forward)
-		points += num_args[(int) op];
 	}
-    } while ((buf = forward ? cairo_path_buf_next (buf) : cairo_path_buf_prev (buf)) != first);
+    } cairo_path_foreach_buf_end (buf, path);
 
     return CAIRO_STATUS_SUCCESS;
 }
@@ -901,7 +901,6 @@ _append_close_path (void *abstract_closure)
 cairo_status_t
 _cairo_path_fixed_append (cairo_path_fixed_t		    *path,
 			  const cairo_path_fixed_t	    *other,
-			  cairo_direction_t		     dir,
 			  cairo_fixed_t			     tx,
 			  cairo_fixed_t			     ty)
 {
@@ -911,7 +910,7 @@ _cairo_path_fixed_append (cairo_path_fixed_t		    *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,
 					_append_curve_to,
@@ -929,13 +928,18 @@ _cairo_path_fixed_offset_and_scale (cairo_path_fixed_t *path,
     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) &&
-			          _cairo_fixed_is_integer (scalex) &&
-			          _cairo_fixed_is_integer (scaley);
+    if (scalex == CAIRO_FIXED_ONE && scaley == CAIRO_FIXED_ONE) {
+	_cairo_path_fixed_translate (path, offx, offy);
+	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)
@@ -945,12 +949,18 @@ _cairo_path_fixed_offset_and_scale (cairo_path_fixed_t *path,
 	     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) {
+		path->fill_maybe_region = _cairo_fixed_is_integer (buf->points[i].x) &&
+					  _cairo_fixed_is_integer (buf->points[i].y);
+	    }
 	 }
     } 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;
-
     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;
 }
@@ -966,30 +976,47 @@ _cairo_path_fixed_translate (cairo_path_fixed_t *path,
     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;
-    }
-
     path->last_move_point.x += offx;
     path->last_move_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;
+	for (i = 0; i < buf->num_points; i++) {
+	    buf->points[i].x += offx;
+	    buf->points[i].y += offy;
+
+	    if (path->fill_maybe_region) {
+		path->fill_maybe_region = _cairo_fixed_is_integer (buf->points[i].x) &&
+					  _cairo_fixed_is_integer (buf->points[i].y);
+	    }
 	 }
     } 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);
+    cairo_matrix_transform_point (matrix, &dx, &dy);
+    p->x = _cairo_fixed_from_double (dx);
+    p->y = _cairo_fixed_from_double (dy);
+}
+
 /**
  * _cairo_path_fixed_transform:
  * @path: a #cairo_path_fixed_t to be transformed
@@ -1003,80 +1030,58 @@ 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 {
-	     _cairo_path_fixed_offset_and_scale (path,
-						 _cairo_fixed_from_double (matrix->x0),
-						 _cairo_fixed_from_double (matrix->y0),
-						 _cairo_fixed_from_double (matrix->xx),
-						 _cairo_fixed_from_double (matrix->yy));
-	 }
+	_cairo_path_fixed_offset_and_scale (path,
+					    _cairo_fixed_from_double (matrix->x0),
+					    _cairo_fixed_from_double (matrix->y0),
+					    _cairo_fixed_from_double (matrix->xx),
+					    _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);
-	    dy = _cairo_fixed_to_double (buf->points[i].y);
+    _cairo_path_fixed_transform_point (&path->last_move_point, matrix);
+    _cairo_path_fixed_transform_point (&path->current_point, matrix);
 
-	    cairo_matrix_transform_point (matrix, &dx, &dy);
+    buf = cairo_path_head (path);
+    if (buf->num_points == 0)
+	return;
 
-	    buf->points[i].x = _cairo_fixed_from_double (dx);
-	    buf->points[i].y = _cairo_fixed_from_double (dy);
+    extents = path->extents;
+    point = buf->points[0];
+    _cairo_path_fixed_transform_point (&point, matrix);
+    _cairo_box_set (&path->extents, &point, &point);
 
-	    /* XXX need to eliminate surplus move-to's? */
-	    _cairo_path_fixed_extents_add (path, &buf->points[i]);
-	 }
+    cairo_path_foreach_buf_start (buf, path) {
+	for (i = 0; i < buf->num_points; i++) {
+	    _cairo_path_fixed_transform_point (&buf->points[i], matrix);
+	    _cairo_box_add_point (&path->extents, &buf->points[i]);
+	}
     } cairo_path_foreach_buf_end (buf, path);
-}
 
-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 ||
-	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)
-    {
-	return FALSE;
-    }
+    if (path->has_curve_to) {
+	cairo_bool_t is_tight;
 
-    other_buf = cairo_path_head (other);
-    cairo_path_foreach_buf_start (path_buf, path) {
-	if (path_buf->num_ops != other_buf->num_ops ||
-	    path_buf->num_points != other_buf->num_points ||
-	    memcmp (path_buf->op, other_buf->op,
-		    sizeof (cairo_path_op_t) * path_buf->num_ops) != 0 ||
-	    memcmp (path_buf->points, other_buf->points,
-		    sizeof (cairo_point_t) * path_buf->num_points) != 0)
-	{
-	    return FALSE;
+	_cairo_matrix_transform_bounding_box_fixed (matrix, &extents, &is_tight);
+	if (!is_tight) {
+	    cairo_bool_t has_extents;
+
+	    has_extents = _cairo_path_bounder_extents (path, &extents);
+	    assert (has_extents);
 	}
-	other_buf = cairo_path_buf_next (other_buf);
-    } cairo_path_foreach_buf_end (path_buf, path);
+	path->extents = extents;
+    }
 
-    return TRUE;
+    /* flags might become more strict than needed */
+    path->stroke_is_rectilinear = FALSE;
+    path->fill_is_rectilinear = FALSE;
+    path->fill_is_empty = FALSE;
+    path->fill_maybe_region = FALSE;
 }
 
 /* Closure for path flattening */
@@ -1145,7 +1150,6 @@ _cpf_close_path (void *closure)
 
 cairo_status_t
 _cairo_path_fixed_interpret_flat (const cairo_path_fixed_t		*path,
-				  cairo_direction_t			dir,
 				  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,
@@ -1155,7 +1159,7 @@ _cairo_path_fixed_interpret_flat (const cairo_path_fixed_t		*path,
     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,
@@ -1168,7 +1172,7 @@ _cairo_path_fixed_interpret_flat (const cairo_path_fixed_t		*path,
     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,
@@ -1207,7 +1211,7 @@ _cairo_path_fixed_is_box (const cairo_path_fixed_t *path,
 {
     const cairo_path_buf_t *buf = cairo_path_head (path);
 
-    if (! path->is_rectilinear)
+    if (! path->fill_is_rectilinear)
 	return FALSE;
 
     /* Do we have the right number of ops? */
@@ -1411,14 +1415,5 @@ _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;
 }