static cairo_int_status_t
_cairo_surface_subsurface_paint (void *abstract_surface,
cairo_operator_t op,
const cairo_pattern_t *source,
const cairo_clip_t *clip)
{
cairo_surface_subsurface_t *surface = abstract_surface;
cairo_rectangle_int_t rect = { 0, 0, surface->extents.width, surface->extents.height };
cairo_status_t status;
cairo_clip_t *target_clip;
target_clip = _cairo_clip_copy_intersect_rectangle (clip, &rect);
status = _cairo_surface_offset_paint (surface->target,
-surface->extents.x, -surface->extents.y,
op, source, target_clip);
_cairo_clip_destroy (target_clip);
return status;
}
static cairo_int_status_t
_cairo_fallback_compositor_paint (const cairo_compositor_t *_compositor,
cairo_composite_rectangles_t *extents)
{
cairo_image_surface_t *image;
cairo_int_status_t status;
TRACE ((stderr, "%s\n", __FUNCTION__));
image = _cairo_surface_map_to_image (extents->surface, &extents->unbounded);
status = _cairo_surface_offset_paint (&image->base,
extents->unbounded.x,
extents->unbounded.y,
extents->op,
&extents->source_pattern.base,
extents->clip);
return _cairo_surface_unmap_image (extents->surface, image);
}
static cairo_status_t
_cairo_gl_pattern_texture_setup (cairo_gl_operand_t *operand,
const cairo_pattern_t *_src,
cairo_gl_surface_t *dst,
const cairo_rectangle_int_t *extents)
{
cairo_status_t status;
cairo_gl_surface_t *surface;
cairo_gl_context_t *ctx;
cairo_image_surface_t *image;
cairo_bool_t src_is_gl_surface = FALSE;
cairo_rectangle_int_t map_extents;
if (_src->type == CAIRO_PATTERN_TYPE_SURFACE) {
cairo_surface_t* src_surface = ((cairo_surface_pattern_t *) _src)->surface;
src_is_gl_surface = src_surface->type == CAIRO_SURFACE_TYPE_GL;
}
status = _cairo_gl_context_acquire (dst->base.device, &ctx);
if (unlikely (status))
return status;
surface = (cairo_gl_surface_t *)
_cairo_gl_surface_create_scratch (ctx,
CAIRO_CONTENT_COLOR_ALPHA,
extents->width, extents->height);
map_extents = *extents;
map_extents.x = map_extents.y = 0;
image = _cairo_surface_map_to_image (&surface->base, &map_extents);
/* If the pattern is a GL surface, it belongs to some other GL context,
so we need to release this device while we paint it to the image. */
if (src_is_gl_surface) {
status = _cairo_gl_context_release (ctx, status);
if (unlikely (status)) {
_cairo_surface_unmap_image (&surface->base, image);
goto fail;
}
}
status = _cairo_surface_offset_paint (&image->base, extents->x, extents->y,
CAIRO_OPERATOR_SOURCE, _src, NULL);
if (src_is_gl_surface) {
status = _cairo_gl_context_acquire (dst->base.device, &ctx);
if (unlikely (status)) {
_cairo_surface_unmap_image (&surface->base, image);
goto fail;
}
}
status = _cairo_surface_unmap_image (&surface->base, image);
status = _cairo_gl_context_release (ctx, status);
if (unlikely (status))
goto fail;
*operand = surface->operand;
operand->texture.owns_surface = surface;
operand->texture.attributes.matrix.x0 -= extents->x * operand->texture.attributes.matrix.xx;
operand->texture.attributes.matrix.y0 -= extents->y * operand->texture.attributes.matrix.yy;
return CAIRO_STATUS_SUCCESS;
fail:
cairo_surface_destroy (&surface->base);
return status;
}
static cairo_int_status_t
_cairo_shape_mask_compositor_stroke (const cairo_compositor_t *_compositor,
cairo_composite_rectangles_t *extents,
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_antialias_t antialias)
{
cairo_surface_t *mask;
cairo_surface_pattern_t pattern;
cairo_int_status_t status;
cairo_clip_t *clip;
if (! extents->is_bounded)
return CAIRO_INT_STATUS_UNSUPPORTED;
TRACE ((stderr, "%s\n", __FUNCTION__));
mask = _cairo_surface_create_scratch (extents->surface,
CAIRO_CONTENT_ALPHA,
extents->bounded.width,
extents->bounded.height,
NULL);
if (unlikely (mask->status))
return mask->status;
clip = extents->clip;
if (! _cairo_clip_is_region (clip))
clip = _cairo_clip_copy_region (clip);
if (! mask->is_clear) {
status = _cairo_surface_offset_paint (mask,
extents->bounded.x,
extents->bounded.y,
CAIRO_OPERATOR_CLEAR,
&_cairo_pattern_clear.base,
clip);
if (unlikely (status))
goto error;
}
status = _cairo_surface_offset_stroke (mask,
extents->bounded.x,
extents->bounded.y,
CAIRO_OPERATOR_ADD,
&_cairo_pattern_white.base,
path, style, ctm, ctm_inverse,
tolerance, antialias,
clip);
if (unlikely (status))
goto error;
if (clip != extents->clip) {
status = _cairo_clip_combine_with_surface (extents->clip, mask,
extents->bounded.x,
extents->bounded.y);
if (unlikely (status))
goto error;
}
_cairo_pattern_init_for_surface (&pattern, mask);
cairo_matrix_init_translate (&pattern.base.matrix,
-extents->bounded.x,
-extents->bounded.y);
pattern.base.filter = CAIRO_FILTER_NEAREST;
pattern.base.extend = CAIRO_EXTEND_NONE;
if (extents->op == CAIRO_OPERATOR_SOURCE) {
status = _cairo_surface_mask (extents->surface,
CAIRO_OPERATOR_DEST_OUT,
&_cairo_pattern_white.base,
&pattern.base,
clip);
if ((status == CAIRO_INT_STATUS_SUCCESS)) {
status = _cairo_surface_mask (extents->surface,
CAIRO_OPERATOR_ADD,
&extents->source_pattern.base,
&pattern.base,
clip);
}
} else {
status = _cairo_surface_mask (extents->surface,
extents->op,
&extents->source_pattern.base,
&pattern.base,
clip);
}
_cairo_pattern_fini (&pattern.base);
error:
cairo_surface_destroy (mask);
if (clip != extents->clip)
_cairo_clip_destroy (clip);
return status;
}
