0,0 → 1,716 |
/* cairo - a vector graphics library with display and print output |
* |
* Copyright © 2005 Red Hat, Inc |
* Copyright © 2007 Adrian Johnson |
* |
* This library is free software; you can redistribute it and/or |
* modify it either under the terms of the GNU Lesser General Public |
* License version 2.1 as published by the Free Software Foundation |
* (the "LGPL") or, at your option, under the terms of the Mozilla |
* Public License Version 1.1 (the "MPL"). If you do not alter this |
* notice, a recipient may use your version of this file under either |
* the MPL or the LGPL. |
* |
* You should have received a copy of the LGPL along with this library |
* in the file COPYING-LGPL-2.1; if not, write to the Free Software |
* Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA |
* You should have received a copy of the MPL along with this library |
* in the file COPYING-MPL-1.1 |
* |
* The contents of this file are subject to the Mozilla Public License |
* Version 1.1 (the "License"); you may not use this file except in |
* compliance with the License. You may obtain a copy of the License at |
* http://www.mozilla.org/MPL/ |
* |
* This software is distributed on an "AS IS" basis, WITHOUT WARRANTY |
* OF ANY KIND, either express or implied. See the LGPL or the MPL for |
* the specific language governing rights and limitations. |
* |
* The Original Code is the cairo graphics library. |
* |
* The Initial Developer of the Original Code is Red Hat, Inc. |
* |
* Contributor(s): |
* Carl Worth <cworth@cworth.org> |
* Keith Packard <keithp@keithp.com> |
* Adrian Johnson <ajohnson@redneon.com> |
*/ |
|
/* The paginated surface layer exists to provide as much code sharing |
* as possible for the various paginated surface backends in cairo |
* (PostScript, PDF, etc.). See cairo-paginated-private.h for |
* more details on how it works and how to use it. |
*/ |
|
#include "cairoint.h" |
|
#include "cairo-paginated-private.h" |
#include "cairo-paginated-surface-private.h" |
#include "cairo-recording-surface-private.h" |
#include "cairo-analysis-surface-private.h" |
#include "cairo-error-private.h" |
#include "cairo-image-surface-private.h" |
#include "cairo-surface-subsurface-inline.h" |
|
static const cairo_surface_backend_t cairo_paginated_surface_backend; |
|
static cairo_int_status_t |
_cairo_paginated_surface_show_page (void *abstract_surface); |
|
static cairo_surface_t * |
_cairo_paginated_surface_create_similar (void *abstract_surface, |
cairo_content_t content, |
int width, |
int height) |
{ |
cairo_rectangle_t rect; |
rect.x = rect.y = 0.; |
rect.width = width; |
rect.height = height; |
return cairo_recording_surface_create (content, &rect); |
} |
|
static cairo_surface_t * |
_create_recording_surface_for_target (cairo_surface_t *target, |
cairo_content_t content) |
{ |
cairo_rectangle_int_t rect; |
|
if (_cairo_surface_get_extents (target, &rect)) { |
cairo_rectangle_t recording_extents; |
|
recording_extents.x = rect.x; |
recording_extents.y = rect.y; |
recording_extents.width = rect.width; |
recording_extents.height = rect.height; |
|
return cairo_recording_surface_create (content, &recording_extents); |
} else { |
return cairo_recording_surface_create (content, NULL); |
} |
} |
|
cairo_surface_t * |
_cairo_paginated_surface_create (cairo_surface_t *target, |
cairo_content_t content, |
const cairo_paginated_surface_backend_t *backend) |
{ |
cairo_paginated_surface_t *surface; |
cairo_status_t status; |
|
surface = malloc (sizeof (cairo_paginated_surface_t)); |
if (unlikely (surface == NULL)) { |
status = _cairo_error (CAIRO_STATUS_NO_MEMORY); |
goto FAIL; |
} |
|
_cairo_surface_init (&surface->base, |
&cairo_paginated_surface_backend, |
NULL, /* device */ |
content); |
|
/* Override surface->base.type with target's type so we don't leak |
* evidence of the paginated wrapper out to the user. */ |
surface->base.type = target->type; |
|
surface->target = cairo_surface_reference (target); |
|
surface->content = content; |
surface->backend = backend; |
|
surface->recording_surface = _create_recording_surface_for_target (target, content); |
status = surface->recording_surface->status; |
if (unlikely (status)) |
goto FAIL_CLEANUP_SURFACE; |
|
surface->page_num = 1; |
surface->base.is_clear = TRUE; |
|
return &surface->base; |
|
FAIL_CLEANUP_SURFACE: |
cairo_surface_destroy (target); |
free (surface); |
FAIL: |
return _cairo_surface_create_in_error (status); |
} |
|
cairo_bool_t |
_cairo_surface_is_paginated (cairo_surface_t *surface) |
{ |
return surface->backend == &cairo_paginated_surface_backend; |
} |
|
cairo_surface_t * |
_cairo_paginated_surface_get_target (cairo_surface_t *surface) |
{ |
cairo_paginated_surface_t *paginated_surface; |
|
assert (_cairo_surface_is_paginated (surface)); |
|
paginated_surface = (cairo_paginated_surface_t *) surface; |
return paginated_surface->target; |
} |
|
cairo_surface_t * |
_cairo_paginated_surface_get_recording (cairo_surface_t *surface) |
{ |
cairo_paginated_surface_t *paginated_surface; |
|
assert (_cairo_surface_is_paginated (surface)); |
|
paginated_surface = (cairo_paginated_surface_t *) surface; |
return paginated_surface->recording_surface; |
} |
|
cairo_status_t |
_cairo_paginated_surface_set_size (cairo_surface_t *surface, |
int width, |
int height) |
{ |
cairo_paginated_surface_t *paginated_surface; |
cairo_status_t status; |
cairo_rectangle_t recording_extents; |
|
assert (_cairo_surface_is_paginated (surface)); |
|
paginated_surface = (cairo_paginated_surface_t *) surface; |
|
recording_extents.x = 0; |
recording_extents.y = 0; |
recording_extents.width = width; |
recording_extents.height = height; |
|
cairo_surface_destroy (paginated_surface->recording_surface); |
paginated_surface->recording_surface = cairo_recording_surface_create (paginated_surface->content, |
&recording_extents); |
status = paginated_surface->recording_surface->status; |
if (unlikely (status)) |
return _cairo_surface_set_error (surface, status); |
|
return CAIRO_STATUS_SUCCESS; |
} |
|
static cairo_status_t |
_cairo_paginated_surface_finish (void *abstract_surface) |
{ |
cairo_paginated_surface_t *surface = abstract_surface; |
cairo_status_t status = CAIRO_STATUS_SUCCESS; |
|
if (! surface->base.is_clear || surface->page_num == 1) { |
/* Bypass some of the sanity checking in cairo-surface.c, as we |
* know that the surface is finished... |
*/ |
status = _cairo_paginated_surface_show_page (surface); |
} |
|
/* XXX We want to propagate any errors from destroy(), but those are not |
* returned via the api. So we need to explicitly finish the target, |
* and check the status afterwards. However, we can only call finish() |
* on the target, if we own it. |
*/ |
if (CAIRO_REFERENCE_COUNT_GET_VALUE (&surface->target->ref_count) == 1) |
cairo_surface_finish (surface->target); |
if (status == CAIRO_STATUS_SUCCESS) |
status = cairo_surface_status (surface->target); |
cairo_surface_destroy (surface->target); |
|
cairo_surface_finish (surface->recording_surface); |
if (status == CAIRO_STATUS_SUCCESS) |
status = cairo_surface_status (surface->recording_surface); |
cairo_surface_destroy (surface->recording_surface); |
|
return status; |
} |
|
static cairo_surface_t * |
_cairo_paginated_surface_create_image_surface (void *abstract_surface, |
int width, |
int height) |
{ |
cairo_paginated_surface_t *surface = abstract_surface; |
cairo_surface_t *image; |
cairo_font_options_t options; |
|
image = _cairo_image_surface_create_with_content (surface->content, |
width, |
height); |
|
cairo_surface_get_font_options (&surface->base, &options); |
_cairo_surface_set_font_options (image, &options); |
|
return image; |
} |
|
static cairo_surface_t * |
_cairo_paginated_surface_source (void *abstract_surface, |
cairo_rectangle_int_t *extents) |
{ |
cairo_paginated_surface_t *surface = abstract_surface; |
return _cairo_surface_get_source (surface->target, extents); |
} |
|
static cairo_status_t |
_cairo_paginated_surface_acquire_source_image (void *abstract_surface, |
cairo_image_surface_t **image_out, |
void **image_extra) |
{ |
cairo_paginated_surface_t *surface = abstract_surface; |
cairo_bool_t is_bounded; |
cairo_surface_t *image; |
cairo_status_t status; |
cairo_rectangle_int_t extents; |
|
is_bounded = _cairo_surface_get_extents (surface->target, &extents); |
if (! is_bounded) |
return CAIRO_INT_STATUS_UNSUPPORTED; |
|
image = _cairo_paginated_surface_create_image_surface (surface, |
extents.width, |
extents.height); |
|
status = _cairo_recording_surface_replay (surface->recording_surface, image); |
if (unlikely (status)) { |
cairo_surface_destroy (image); |
return status; |
} |
|
*image_out = (cairo_image_surface_t*) image; |
*image_extra = NULL; |
|
return CAIRO_STATUS_SUCCESS; |
} |
|
static void |
_cairo_paginated_surface_release_source_image (void *abstract_surface, |
cairo_image_surface_t *image, |
void *image_extra) |
{ |
cairo_surface_destroy (&image->base); |
} |
|
static cairo_int_status_t |
_paint_fallback_image (cairo_paginated_surface_t *surface, |
cairo_rectangle_int_t *rect) |
{ |
double x_scale = surface->base.x_fallback_resolution / surface->target->x_resolution; |
double y_scale = surface->base.y_fallback_resolution / surface->target->y_resolution; |
int x, y, width, height; |
cairo_status_t status; |
cairo_surface_t *image; |
cairo_surface_pattern_t pattern; |
cairo_clip_t *clip; |
|
x = rect->x; |
y = rect->y; |
width = rect->width; |
height = rect->height; |
image = _cairo_paginated_surface_create_image_surface (surface, |
ceil (width * x_scale), |
ceil (height * y_scale)); |
_cairo_surface_set_device_scale (image, x_scale, y_scale); |
/* set_device_offset just sets the x0/y0 components of the matrix; |
* so we have to do the scaling manually. */ |
cairo_surface_set_device_offset (image, -x*x_scale, -y*y_scale); |
|
status = _cairo_recording_surface_replay (surface->recording_surface, image); |
if (unlikely (status)) |
goto CLEANUP_IMAGE; |
|
_cairo_pattern_init_for_surface (&pattern, image); |
cairo_matrix_init (&pattern.base.matrix, |
x_scale, 0, 0, y_scale, -x*x_scale, -y*y_scale); |
/* the fallback should be rendered at native resolution, so disable |
* filtering (if possible) to avoid introducing potential artifacts. */ |
pattern.base.filter = CAIRO_FILTER_NEAREST; |
|
clip = _cairo_clip_intersect_rectangle (NULL, rect); |
status = _cairo_surface_paint (surface->target, |
CAIRO_OPERATOR_SOURCE, |
&pattern.base, clip); |
_cairo_clip_destroy (clip); |
_cairo_pattern_fini (&pattern.base); |
|
CLEANUP_IMAGE: |
cairo_surface_destroy (image); |
|
return status; |
} |
|
static cairo_int_status_t |
_paint_page (cairo_paginated_surface_t *surface) |
{ |
cairo_surface_t *analysis; |
cairo_int_status_t status; |
cairo_bool_t has_supported, has_page_fallback, has_finegrained_fallback; |
|
if (unlikely (surface->target->status)) |
return surface->target->status; |
|
analysis = _cairo_analysis_surface_create (surface->target); |
if (unlikely (analysis->status)) |
return _cairo_surface_set_error (surface->target, analysis->status); |
|
surface->backend->set_paginated_mode (surface->target, |
CAIRO_PAGINATED_MODE_ANALYZE); |
status = _cairo_recording_surface_replay_and_create_regions (surface->recording_surface, |
analysis); |
if (status) |
goto FAIL; |
|
assert (analysis->status == CAIRO_STATUS_SUCCESS); |
|
if (surface->backend->set_bounding_box) { |
cairo_box_t bbox; |
|
_cairo_analysis_surface_get_bounding_box (analysis, &bbox); |
status = surface->backend->set_bounding_box (surface->target, &bbox); |
if (unlikely (status)) |
goto FAIL; |
} |
|
if (surface->backend->set_fallback_images_required) { |
cairo_bool_t has_fallbacks = _cairo_analysis_surface_has_unsupported (analysis); |
|
status = surface->backend->set_fallback_images_required (surface->target, |
has_fallbacks); |
if (unlikely (status)) |
goto FAIL; |
} |
|
/* Finer grained fallbacks are currently only supported for some |
* surface types */ |
if (surface->backend->supports_fine_grained_fallbacks != NULL && |
surface->backend->supports_fine_grained_fallbacks (surface->target)) |
{ |
has_supported = _cairo_analysis_surface_has_supported (analysis); |
has_page_fallback = FALSE; |
has_finegrained_fallback = _cairo_analysis_surface_has_unsupported (analysis); |
} |
else |
{ |
if (_cairo_analysis_surface_has_unsupported (analysis)) { |
has_supported = FALSE; |
has_page_fallback = TRUE; |
} else { |
has_supported = TRUE; |
has_page_fallback = FALSE; |
} |
has_finegrained_fallback = FALSE; |
} |
|
if (has_supported) { |
surface->backend->set_paginated_mode (surface->target, |
CAIRO_PAGINATED_MODE_RENDER); |
|
status = _cairo_recording_surface_replay_region (surface->recording_surface, |
NULL, |
surface->target, |
CAIRO_RECORDING_REGION_NATIVE); |
assert (status != CAIRO_INT_STATUS_UNSUPPORTED); |
if (unlikely (status)) |
goto FAIL; |
} |
|
if (has_page_fallback) { |
cairo_rectangle_int_t extents; |
cairo_bool_t is_bounded; |
|
surface->backend->set_paginated_mode (surface->target, |
CAIRO_PAGINATED_MODE_FALLBACK); |
|
is_bounded = _cairo_surface_get_extents (surface->target, &extents); |
if (! is_bounded) { |
status = CAIRO_INT_STATUS_UNSUPPORTED; |
goto FAIL; |
} |
|
status = _paint_fallback_image (surface, &extents); |
if (unlikely (status)) |
goto FAIL; |
} |
|
if (has_finegrained_fallback) { |
cairo_region_t *region; |
int num_rects, i; |
|
surface->backend->set_paginated_mode (surface->target, |
CAIRO_PAGINATED_MODE_FALLBACK); |
|
region = _cairo_analysis_surface_get_unsupported (analysis); |
|
num_rects = cairo_region_num_rectangles (region); |
for (i = 0; i < num_rects; i++) { |
cairo_rectangle_int_t rect; |
|
cairo_region_get_rectangle (region, i, &rect); |
status = _paint_fallback_image (surface, &rect); |
if (unlikely (status)) |
goto FAIL; |
} |
} |
|
FAIL: |
cairo_surface_destroy (analysis); |
|
return _cairo_surface_set_error (surface->target, status); |
} |
|
static cairo_status_t |
_start_page (cairo_paginated_surface_t *surface) |
{ |
if (surface->target->status) |
return surface->target->status; |
|
if (! surface->backend->start_page) |
return CAIRO_STATUS_SUCCESS; |
|
return _cairo_surface_set_error (surface->target, |
surface->backend->start_page (surface->target)); |
} |
|
static cairo_int_status_t |
_cairo_paginated_surface_copy_page (void *abstract_surface) |
{ |
cairo_status_t status; |
cairo_paginated_surface_t *surface = abstract_surface; |
|
status = _start_page (surface); |
if (unlikely (status)) |
return status; |
|
status = _paint_page (surface); |
if (unlikely (status)) |
return status; |
|
surface->page_num++; |
|
/* XXX: It might make sense to add some support here for calling |
* cairo_surface_copy_page on the target surface. It would be an |
* optimization for the output, but the interaction with image |
* fallbacks gets tricky. For now, we just let the target see a |
* show_page and we implement the copying by simply not destroying |
* the recording-surface. */ |
|
cairo_surface_show_page (surface->target); |
return cairo_surface_status (surface->target); |
} |
|
static cairo_int_status_t |
_cairo_paginated_surface_show_page (void *abstract_surface) |
{ |
cairo_status_t status; |
cairo_paginated_surface_t *surface = abstract_surface; |
|
status = _start_page (surface); |
if (unlikely (status)) |
return status; |
|
status = _paint_page (surface); |
if (unlikely (status)) |
return status; |
|
cairo_surface_show_page (surface->target); |
status = surface->target->status; |
if (unlikely (status)) |
return status; |
|
status = surface->recording_surface->status; |
if (unlikely (status)) |
return status; |
|
if (! surface->base.finished) { |
cairo_surface_destroy (surface->recording_surface); |
|
surface->recording_surface = _create_recording_surface_for_target (surface->target, |
surface->content); |
status = surface->recording_surface->status; |
if (unlikely (status)) |
return status; |
|
surface->page_num++; |
surface->base.is_clear = TRUE; |
} |
|
return CAIRO_STATUS_SUCCESS; |
} |
|
static cairo_bool_t |
_cairo_paginated_surface_get_extents (void *abstract_surface, |
cairo_rectangle_int_t *rectangle) |
{ |
cairo_paginated_surface_t *surface = abstract_surface; |
|
return _cairo_surface_get_extents (surface->target, rectangle); |
} |
|
static void |
_cairo_paginated_surface_get_font_options (void *abstract_surface, |
cairo_font_options_t *options) |
{ |
cairo_paginated_surface_t *surface = abstract_surface; |
|
cairo_surface_get_font_options (surface->target, options); |
} |
|
static cairo_int_status_t |
_cairo_paginated_surface_paint (void *abstract_surface, |
cairo_operator_t op, |
const cairo_pattern_t *source, |
const cairo_clip_t *clip) |
{ |
cairo_paginated_surface_t *surface = abstract_surface; |
|
return _cairo_surface_paint (surface->recording_surface, op, source, clip); |
} |
|
static cairo_int_status_t |
_cairo_paginated_surface_mask (void *abstract_surface, |
cairo_operator_t op, |
const cairo_pattern_t *source, |
const cairo_pattern_t *mask, |
const cairo_clip_t *clip) |
{ |
cairo_paginated_surface_t *surface = abstract_surface; |
|
return _cairo_surface_mask (surface->recording_surface, op, source, mask, clip); |
} |
|
static cairo_int_status_t |
_cairo_paginated_surface_stroke (void *abstract_surface, |
cairo_operator_t op, |
const cairo_pattern_t *source, |
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, |
const cairo_clip_t *clip) |
{ |
cairo_paginated_surface_t *surface = abstract_surface; |
|
return _cairo_surface_stroke (surface->recording_surface, op, source, |
path, style, |
ctm, ctm_inverse, |
tolerance, antialias, |
clip); |
} |
|
static cairo_int_status_t |
_cairo_paginated_surface_fill (void *abstract_surface, |
cairo_operator_t op, |
const cairo_pattern_t *source, |
const cairo_path_fixed_t *path, |
cairo_fill_rule_t fill_rule, |
double tolerance, |
cairo_antialias_t antialias, |
const cairo_clip_t *clip) |
{ |
cairo_paginated_surface_t *surface = abstract_surface; |
|
return _cairo_surface_fill (surface->recording_surface, op, source, |
path, fill_rule, |
tolerance, antialias, |
clip); |
} |
|
static cairo_bool_t |
_cairo_paginated_surface_has_show_text_glyphs (void *abstract_surface) |
{ |
cairo_paginated_surface_t *surface = abstract_surface; |
|
return cairo_surface_has_show_text_glyphs (surface->target); |
} |
|
static cairo_int_status_t |
_cairo_paginated_surface_show_text_glyphs (void *abstract_surface, |
cairo_operator_t op, |
const cairo_pattern_t *source, |
const char *utf8, |
int utf8_len, |
cairo_glyph_t *glyphs, |
int num_glyphs, |
const cairo_text_cluster_t *clusters, |
int num_clusters, |
cairo_text_cluster_flags_t cluster_flags, |
cairo_scaled_font_t *scaled_font, |
const cairo_clip_t *clip) |
{ |
cairo_paginated_surface_t *surface = abstract_surface; |
|
return _cairo_surface_show_text_glyphs (surface->recording_surface, op, source, |
utf8, utf8_len, |
glyphs, num_glyphs, |
clusters, num_clusters, |
cluster_flags, |
scaled_font, |
clip); |
} |
|
static const char ** |
_cairo_paginated_surface_get_supported_mime_types (void *abstract_surface) |
{ |
cairo_paginated_surface_t *surface = abstract_surface; |
|
if (surface->target->backend->get_supported_mime_types) |
return surface->target->backend->get_supported_mime_types (surface->target); |
|
return NULL; |
} |
|
static cairo_surface_t * |
_cairo_paginated_surface_snapshot (void *abstract_other) |
{ |
cairo_paginated_surface_t *other = abstract_other; |
|
return other->recording_surface->backend->snapshot (other->recording_surface); |
} |
|
static cairo_t * |
_cairo_paginated_context_create (void *target) |
{ |
cairo_paginated_surface_t *surface = target; |
|
if (_cairo_surface_is_subsurface (&surface->base)) |
surface = (cairo_paginated_surface_t *) |
_cairo_surface_subsurface_get_target (&surface->base); |
|
return surface->recording_surface->backend->create_context (target); |
} |
|
static const cairo_surface_backend_t cairo_paginated_surface_backend = { |
CAIRO_INTERNAL_SURFACE_TYPE_PAGINATED, |
_cairo_paginated_surface_finish, |
|
_cairo_paginated_context_create, |
|
_cairo_paginated_surface_create_similar, |
NULL, /* create simlar image */ |
NULL, /* map to image */ |
NULL, /* unmap image */ |
|
_cairo_paginated_surface_source, |
_cairo_paginated_surface_acquire_source_image, |
_cairo_paginated_surface_release_source_image, |
_cairo_paginated_surface_snapshot, |
|
_cairo_paginated_surface_copy_page, |
_cairo_paginated_surface_show_page, |
|
_cairo_paginated_surface_get_extents, |
_cairo_paginated_surface_get_font_options, |
|
NULL, /* flush */ |
NULL, /* mark_dirty_rectangle */ |
|
_cairo_paginated_surface_paint, |
_cairo_paginated_surface_mask, |
_cairo_paginated_surface_stroke, |
_cairo_paginated_surface_fill, |
NULL, /* fill_stroke */ |
NULL, /* show_glyphs */ |
_cairo_paginated_surface_has_show_text_glyphs, |
_cairo_paginated_surface_show_text_glyphs, |
_cairo_paginated_surface_get_supported_mime_types, |
}; |