cairo_int_status_t
_cairo_path_fixed_stroke_to_tristrip (const cairo_path_fixed_t *path,
const cairo_stroke_style_t*style,
const cairo_matrix_t *ctm,
const cairo_matrix_t *ctm_inverse,
double tolerance,
cairo_tristrip_t *strip)
{
struct stroker stroker;
cairo_int_status_t status;
int i;
if (style->num_dashes)
return CAIRO_INT_STATUS_UNSUPPORTED;
stroker.style = *style;
stroker.ctm = ctm;
stroker.ctm_inverse = ctm_inverse;
stroker.tolerance = tolerance;
stroker.ctm_det_positive =
_cairo_matrix_compute_determinant (ctm) >= 0.0;
status = _cairo_pen_init (&stroker.pen,
style->line_width / 2.0,
tolerance, ctm);
if (unlikely (status))
return status;
if (stroker.pen.num_vertices <= 1)
return CAIRO_INT_STATUS_NOTHING_TO_DO;
stroker.has_current_face = FALSE;
stroker.has_first_face = FALSE;
stroker.has_sub_path = FALSE;
stroker.has_limits = strip->num_limits > 0;
stroker.limit = strip->limits[0];
for (i = 1; i < strip->num_limits; i++)
_cairo_box_add_box (&stroker.limit, &strip->limits[i]);
stroker.strip = strip;
status = _cairo_path_fixed_interpret (path,
move_to,
line_to,
curve_to,
close_path,
&stroker);
/* Cap the start and end of the final sub path as needed */
if (likely (status == CAIRO_INT_STATUS_SUCCESS))
add_caps (&stroker);
_cairo_pen_fini (&stroker.pen);
return status;
}
void
_cairo_traps_limit (cairo_traps_t *traps,
const cairo_box_t *limits,
int num_limits)
{
int i;
traps->limits = limits;
traps->num_limits = num_limits;
traps->bounds = limits[0];
for (i = 1; i < num_limits; i++)
_cairo_box_add_box (&traps->bounds, &limits[i]);
}
cairo_status_t
_cairo_path_fixed_stroke_to_polygon (const cairo_path_fixed_t *path,
const cairo_stroke_style_t *style,
const cairo_matrix_t *ctm,
const cairo_matrix_t *ctm_inverse,
double tolerance,
cairo_polygon_t *polygon)
{
struct stroker stroker;
cairo_status_t status;
if (style->num_dashes) {
return _cairo_path_fixed_stroke_dashed_to_polygon (path,
style,
ctm,
ctm_inverse,
tolerance,
polygon);
}
stroker.has_bounds = polygon->num_limits;
if (stroker.has_bounds) {
/* Extend the bounds in each direction to account for the maximum area
* we might generate trapezoids, to capture line segments that are
* outside of the bounds but which might generate rendering that's
* within bounds.
*/
double dx, dy;
cairo_fixed_t fdx, fdy;
int i;
stroker.bounds = polygon->limits[0];
for (i = 1; i < polygon->num_limits; i++)
_cairo_box_add_box (&stroker.bounds, &polygon->limits[i]);
_cairo_stroke_style_max_distance_from_path (style, path, ctm, &dx, &dy);
fdx = _cairo_fixed_from_double (dx);
fdy = _cairo_fixed_from_double (dy);
stroker.bounds.p1.x -= fdx;
stroker.bounds.p2.x += fdx;
stroker.bounds.p1.y -= fdy;
stroker.bounds.p2.y += fdy;
}
stroker.style = *style;
stroker.ctm = ctm;
stroker.ctm_inverse = ctm_inverse;
stroker.tolerance = tolerance;
stroker.half_line_width = style->line_width / 2.;
/* To test whether we need to join two segments of a spline using
* a round-join or a bevel-join, we can inspect the angle between the
* two segments. If the difference between the chord distance
* (half-line-width times the cosine of the bisection angle) and the
* half-line-width itself is greater than tolerance then we need to
* inject a point.
*/
stroker.spline_cusp_tolerance = 1 - tolerance / stroker.half_line_width;
stroker.spline_cusp_tolerance *= stroker.spline_cusp_tolerance;
stroker.spline_cusp_tolerance *= 2;
stroker.spline_cusp_tolerance -= 1;
stroker.ctm_det_positive =
_cairo_matrix_compute_determinant (ctm) >= 0.0;
stroker.pen.num_vertices = 0;
if (path->has_curve_to ||
style->line_join == CAIRO_LINE_JOIN_ROUND ||
style->line_cap == CAIRO_LINE_CAP_ROUND) {
status = _cairo_pen_init (&stroker.pen,
stroker.half_line_width,
tolerance, ctm);
if (unlikely (status))
return status;
/* If the line width is so small that the pen is reduced to a
single point, then we have nothing to do. */
if (stroker.pen.num_vertices <= 1)
return CAIRO_STATUS_SUCCESS;
}
stroker.has_current_face = FALSE;
stroker.has_first_face = FALSE;
stroker.has_initial_sub_path = FALSE;
#if DEBUG
remove ("contours.txt");
remove ("polygons.txt");
_cairo_contour_init (&stroker.path, 0);
#endif
_cairo_contour_init (&stroker.cw.contour, 1);
_cairo_contour_init (&stroker.ccw.contour, -1);
tolerance *= CAIRO_FIXED_ONE;
tolerance *= tolerance;
stroker.contour_tolerance = tolerance;
stroker.polygon = polygon;
status = _cairo_path_fixed_interpret (path,
move_to,
line_to,
curve_to,
close_path,
&stroker);
/* Cap the start and end of the final sub path as needed */
if (likely (status == CAIRO_STATUS_SUCCESS))
add_caps (&stroker);
_cairo_contour_fini (&stroker.cw.contour);
_cairo_contour_fini (&stroker.ccw.contour);
if (stroker.pen.num_vertices)
_cairo_pen_fini (&stroker.pen);
#if DEBUG
{
FILE *file = fopen ("polygons.txt", "a");
_cairo_debug_print_polygon (file, polygon);
fclose (file);
}
#endif
return status;
}
static cairo_int_status_t
_add_operation (cairo_analysis_surface_t *surface,
cairo_rectangle_int_t *rect,
cairo_int_status_t backend_status)
{
cairo_int_status_t status;
cairo_box_t bbox;
if (rect->width == 0 || rect->height == 0) {
/* Even though the operation is not visible we must be careful
* to not allow unsupported operations to be replayed to the
* backend during CAIRO_PAGINATED_MODE_RENDER */
if (backend_status == CAIRO_INT_STATUS_SUCCESS ||
backend_status == CAIRO_INT_STATUS_FLATTEN_TRANSPARENCY ||
backend_status == CAIRO_INT_STATUS_NOTHING_TO_DO)
{
return CAIRO_INT_STATUS_SUCCESS;
}
else
{
return CAIRO_INT_STATUS_IMAGE_FALLBACK;
}
}
_cairo_box_from_rectangle (&bbox, rect);
if (surface->has_ctm) {
int tx, ty;
if (_cairo_matrix_is_integer_translation (&surface->ctm, &tx, &ty)) {
rect->x += tx;
rect->y += ty;
tx = _cairo_fixed_from_int (tx);
bbox.p1.x += tx;
bbox.p2.x += tx;
ty = _cairo_fixed_from_int (ty);
bbox.p1.y += ty;
bbox.p2.y += ty;
} else {
_cairo_matrix_transform_bounding_box_fixed (&surface->ctm,
&bbox, NULL);
if (bbox.p1.x == bbox.p2.x || bbox.p1.y == bbox.p2.y) {
/* Even though the operation is not visible we must be
* careful to not allow unsupported operations to be
* replayed to the backend during
* CAIRO_PAGINATED_MODE_RENDER */
if (backend_status == CAIRO_INT_STATUS_SUCCESS ||
backend_status == CAIRO_INT_STATUS_FLATTEN_TRANSPARENCY ||
backend_status == CAIRO_INT_STATUS_NOTHING_TO_DO)
{
return CAIRO_INT_STATUS_SUCCESS;
}
else
{
return CAIRO_INT_STATUS_IMAGE_FALLBACK;
}
}
_cairo_box_round_to_rectangle (&bbox, rect);
}
}
if (surface->first_op) {
surface->first_op = FALSE;
surface->page_bbox = bbox;
} else
_cairo_box_add_box(&surface->page_bbox, &bbox);
/* If the operation is completely enclosed within the fallback
* region there is no benefit in emitting a native operation as
* the fallback image will be painted on top.
*/
if (cairo_region_contains_rectangle (&surface->fallback_region, rect) == CAIRO_REGION_OVERLAP_IN)
return CAIRO_INT_STATUS_IMAGE_FALLBACK;
if (backend_status == CAIRO_INT_STATUS_FLATTEN_TRANSPARENCY) {
/* A status of CAIRO_INT_STATUS_FLATTEN_TRANSPARENCY indicates
* that the backend only supports this operation if the
* transparency removed. If the extents of this operation does
* not intersect any other native operation, the operation is
* natively supported and the backend will blend the
* transparency into the white background.
*/
if (cairo_region_contains_rectangle (&surface->supported_region, rect) == CAIRO_REGION_OVERLAP_OUT)
backend_status = CAIRO_INT_STATUS_SUCCESS;
}
if (backend_status == CAIRO_INT_STATUS_SUCCESS) {
/* Add the operation to the supported region. Operations in
* this region will be emitted as native operations.
*/
surface->has_supported = TRUE;
return cairo_region_union_rectangle (&surface->supported_region, rect);
}
/* Add the operation to the unsupported region. This region will
* be painted as an image after all native operations have been
* emitted.
*/
surface->has_unsupported = TRUE;
status = cairo_region_union_rectangle (&surface->fallback_region, rect);
/* The status CAIRO_INT_STATUS_IMAGE_FALLBACK is used to indicate
* unsupported operations to the recording surface as using
* CAIRO_INT_STATUS_UNSUPPORTED would cause cairo-surface to
* invoke the cairo-surface-fallback path then return
* CAIRO_STATUS_SUCCESS.
*/
if (status == CAIRO_INT_STATUS_SUCCESS)
return CAIRO_INT_STATUS_IMAGE_FALLBACK;
else
return status;
}
