/* -*- Mode: c; tab-width: 8; c-basic-offset: 4; indent-tabs-mode: t; -*- */ /* cairo - a vector graphics library with display and print output * * Copyright © 2002 University of Southern California * Copyright © 2005 Red Hat, Inc. * * 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 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 University of Southern * California. * * Contributor(s): * Carl D. Worth */ #include "cairoint.h" #include "cairo-surface-fallback-private.h" #include "cairo-clip-private.h" #define DEFINE_NIL_SURFACE(status, name) \ const cairo_surface_t name = { \ &_cairo_image_surface_backend, /* backend */ \ CAIRO_SURFACE_TYPE_IMAGE, \ CAIRO_CONTENT_COLOR, \ CAIRO_REFERENCE_COUNT_INVALID, /* ref_count */ \ status, /* status */ \ FALSE, /* finished */ \ { 0, /* size */ \ 0, /* num_elements */ \ 0, /* element_size */ \ NULL, /* elements */ \ }, /* user_data */ \ { 1.0, 0.0, \ 0.0, 1.0, \ 0.0, 0.0 \ }, /* device_transform */ \ { 1.0, 0.0, \ 0.0, 1.0, \ 0.0, 0.0 \ }, /* device_transform_inverse */ \ 0.0, /* x_resolution */ \ 0.0, /* y_resolution */ \ 0.0, /* x_fallback_resolution */ \ 0.0, /* y_fallback_resolution */ \ NULL, /* clip */ \ 0, /* next_clip_serial */ \ 0, /* current_clip_serial */ \ FALSE, /* is_snapshot */ \ FALSE, /* has_font_options */ \ { CAIRO_ANTIALIAS_DEFAULT, /* antialias */ \ CAIRO_SUBPIXEL_ORDER_DEFAULT, /* subpixel_order */ \ CAIRO_HINT_STYLE_DEFAULT, /* hint_style */ \ CAIRO_HINT_METRICS_DEFAULT /* hint_metrics */ \ } /* font_options */ \ } static DEFINE_NIL_SURFACE(CAIRO_STATUS_NO_MEMORY, _cairo_surface_nil); static DEFINE_NIL_SURFACE(CAIRO_STATUS_INVALID_CONTENT, _cairo_surface_nil_invalid_content); static DEFINE_NIL_SURFACE(CAIRO_STATUS_INVALID_FORMAT, _cairo_surface_nil_invalid_format); static DEFINE_NIL_SURFACE(CAIRO_STATUS_INVALID_VISUAL, _cairo_surface_nil_invalid_visual); static DEFINE_NIL_SURFACE(CAIRO_STATUS_FILE_NOT_FOUND, _cairo_surface_nil_file_not_found); static DEFINE_NIL_SURFACE(CAIRO_STATUS_TEMP_FILE_ERROR, _cairo_surface_nil_temp_file_error); static DEFINE_NIL_SURFACE(CAIRO_STATUS_READ_ERROR, _cairo_surface_nil_read_error); static DEFINE_NIL_SURFACE(CAIRO_STATUS_WRITE_ERROR, _cairo_surface_nil_write_error); static DEFINE_NIL_SURFACE(CAIRO_STATUS_INVALID_STRIDE, _cairo_surface_nil_invalid_stride); static cairo_status_t _cairo_surface_copy_pattern_for_destination (const cairo_pattern_t **pattern, cairo_surface_t *destination, cairo_pattern_t *pattern_copy); /** * _cairo_surface_set_error: * @surface: a surface * @status: a status value indicating an error * * Atomically sets surface->status to @status and calls _cairo_error; * Does nothing if status is %CAIRO_STATUS_SUCCESS or any of the internal * status values. * * All assignments of an error status to surface->status should happen * through _cairo_surface_set_error(). Note that due to the nature of * the atomic operation, it is not safe to call this function on the * nil objects. * * The purpose of this function is to allow the user to set a * breakpoint in _cairo_error() to generate a stack trace for when the * user causes cairo to detect an error. * * Return value: the error status. **/ cairo_status_t _cairo_surface_set_error (cairo_surface_t *surface, cairo_status_t status) { if (status == CAIRO_STATUS_SUCCESS || status >= CAIRO_INT_STATUS_UNSUPPORTED) return status; /* Don't overwrite an existing error. This preserves the first * error, which is the most significant. */ _cairo_status_set_error (&surface->status, status); return _cairo_error (status); } /** * cairo_surface_get_type: * @surface: a #cairo_surface_t * * This function returns the type of the backend used to create * a surface. See #cairo_surface_type_t for available types. * * Return value: The type of @surface. * * Since: 1.2 **/ cairo_surface_type_t cairo_surface_get_type (cairo_surface_t *surface) { /* We don't use surface->backend->type here so that some of the * special "wrapper" surfaces such as cairo_paginated_surface_t * can override surface->type with the type of the "child" * surface. */ return surface->type; } slim_hidden_def (cairo_surface_get_type); /** * cairo_surface_get_content: * @surface: a #cairo_surface_t * * This function returns the content type of @surface which indicates * whether the surface contains color and/or alpha information. See * #cairo_content_t. * * Return value: The content type of @surface. * * Since: 1.2 **/ cairo_content_t cairo_surface_get_content (cairo_surface_t *surface) { return surface->content; } slim_hidden_def(cairo_surface_get_content); /** * cairo_surface_status: * @surface: a #cairo_surface_t * * Checks whether an error has previously occurred for this * surface. * * Return value: %CAIRO_STATUS_SUCCESS, %CAIRO_STATUS_NULL_POINTER, * %CAIRO_STATUS_NO_MEMORY, %CAIRO_STATUS_READ_ERROR, * %CAIRO_STATUS_INVALID_CONTENT, %CAIRO_STATUS_INVALID_FORMAT, or * %CAIRO_STATUS_INVALID_VISUAL. **/ cairo_status_t cairo_surface_status (cairo_surface_t *surface) { return surface->status; } slim_hidden_def (cairo_surface_status); void _cairo_surface_init (cairo_surface_t *surface, const cairo_surface_backend_t *backend, cairo_content_t content) { CAIRO_MUTEX_INITIALIZE (); surface->backend = backend; surface->content = content; surface->type = backend->type; CAIRO_REFERENCE_COUNT_INIT (&surface->ref_count, 1); surface->status = CAIRO_STATUS_SUCCESS; surface->finished = FALSE; _cairo_user_data_array_init (&surface->user_data); cairo_matrix_init_identity (&surface->device_transform); cairo_matrix_init_identity (&surface->device_transform_inverse); surface->x_resolution = CAIRO_SURFACE_RESOLUTION_DEFAULT; surface->y_resolution = CAIRO_SURFACE_RESOLUTION_DEFAULT; surface->x_fallback_resolution = CAIRO_SURFACE_FALLBACK_RESOLUTION_DEFAULT; surface->y_fallback_resolution = CAIRO_SURFACE_FALLBACK_RESOLUTION_DEFAULT; surface->clip = NULL; surface->next_clip_serial = 0; surface->current_clip_serial = 0; surface->is_snapshot = FALSE; surface->has_font_options = FALSE; } cairo_surface_t * _cairo_surface_create_similar_scratch (cairo_surface_t *other, cairo_content_t content, int width, int height) { cairo_surface_t *surface = NULL; if (other->status) return _cairo_surface_create_in_error (other->status); if (other->backend->create_similar) { surface = other->backend->create_similar (other, content, width, height); if (surface != NULL && surface->status) return surface; } if (surface == NULL) { surface = cairo_image_surface_create (_cairo_format_from_content (content), width, height); } /* If any error occurred, then return the nil surface we received. */ if (surface->status) return surface; if (other->has_font_options || other->backend != surface->backend) { cairo_font_options_t options; cairo_surface_get_font_options (other, &options); _cairo_surface_set_font_options (surface, &options); } cairo_surface_set_fallback_resolution (surface, other->x_fallback_resolution, other->y_fallback_resolution); return surface; } /** * cairo_surface_create_similar: * @other: an existing surface used to select the backend of the new surface * @content: the content for the new surface * @width: width of the new surface, (in device-space units) * @height: height of the new surface (in device-space units) * * Create a new surface that is as compatible as possible with an * existing surface. For example the new surface will have the same * fallback resolution and font options as @other. Generally, the new * surface will also use the same backend as @other, unless that is * not possible for some reason. The type of the returned surface may * be examined with cairo_surface_get_type(). * * Initially the surface contents are all 0 (transparent if contents * have transparency, black otherwise.) * * Return value: a pointer to the newly allocated surface. The caller * owns the surface and should call cairo_surface_destroy() when done * with it. * * This function always returns a valid pointer, but it will return a * pointer to a "nil" surface if @other is already in an error state * or any other error occurs. **/ cairo_surface_t * cairo_surface_create_similar (cairo_surface_t *other, cairo_content_t content, int width, int height) { if (other->status) return _cairo_surface_create_in_error (other->status); if (! CAIRO_CONTENT_VALID (content)) return _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_INVALID_CONTENT)); return _cairo_surface_create_similar_solid (other, content, width, height, CAIRO_COLOR_TRANSPARENT); } slim_hidden_def (cairo_surface_create_similar); cairo_surface_t * _cairo_surface_create_similar_solid (cairo_surface_t *other, cairo_content_t content, int width, int height, const cairo_color_t *color) { cairo_status_t status; cairo_surface_t *surface; cairo_solid_pattern_t solid_pattern; surface = _cairo_surface_create_similar_scratch (other, content, width, height); if (surface->status) return surface; _cairo_pattern_init_solid (&solid_pattern, color, content); status = _cairo_surface_paint (surface, color == CAIRO_COLOR_TRANSPARENT ? CAIRO_OPERATOR_CLEAR : CAIRO_OPERATOR_SOURCE, &solid_pattern.base, NULL); _cairo_pattern_fini (&solid_pattern.base); if (status) { cairo_surface_destroy (surface); return _cairo_surface_create_in_error (status); } return surface; } cairo_surface_t * _cairo_surface_create_solid_pattern_surface (cairo_surface_t *other, const cairo_solid_pattern_t *solid_pattern) { cairo_surface_t *surface; if (other->backend->create_solid_pattern_surface) { surface = other->backend->create_solid_pattern_surface (other, solid_pattern); if (surface) return surface; } surface = _cairo_surface_create_similar_solid (other, solid_pattern->content, 1, 1, &solid_pattern->color); return surface; } cairo_int_status_t _cairo_surface_repaint_solid_pattern_surface (cairo_surface_t *other, cairo_surface_t *solid_surface, const cairo_solid_pattern_t *solid_pattern) { if (other->backend->create_solid_pattern_surface) /* Solid pattern surface for this backend are not trivial to make. * Skip repainting. * * This does not work optimally with things like analysis surface that * are proxies. But returning UNSUPPORTED is *safe* as it only * disables some caching. */ return CAIRO_INT_STATUS_UNSUPPORTED; return _cairo_surface_paint (solid_surface, CAIRO_OPERATOR_SOURCE, &solid_pattern->base, NULL); } cairo_clip_mode_t _cairo_surface_get_clip_mode (cairo_surface_t *surface) { if (surface->backend->intersect_clip_path != NULL) return CAIRO_CLIP_MODE_PATH; else if (surface->backend->set_clip_region != NULL) return CAIRO_CLIP_MODE_REGION; else return CAIRO_CLIP_MODE_MASK; } /** * cairo_surface_reference: * @surface: a #cairo_surface_t * * Increases the reference count on @surface by one. This prevents * @surface from being destroyed until a matching call to * cairo_surface_destroy() is made. * * The number of references to a #cairo_surface_t can be get using * cairo_surface_get_reference_count(). * * Return value: the referenced #cairo_surface_t. **/ cairo_surface_t * cairo_surface_reference (cairo_surface_t *surface) { if (surface == NULL || CAIRO_REFERENCE_COUNT_IS_INVALID (&surface->ref_count)) return surface; assert (CAIRO_REFERENCE_COUNT_HAS_REFERENCE (&surface->ref_count)); _cairo_reference_count_inc (&surface->ref_count); return surface; } slim_hidden_def (cairo_surface_reference); /** * cairo_surface_destroy: * @surface: a #cairo_surface_t * * Decreases the reference count on @surface by one. If the result is * zero, then @surface and all associated resources are freed. See * cairo_surface_reference(). **/ void cairo_surface_destroy (cairo_surface_t *surface) { if (surface == NULL || CAIRO_REFERENCE_COUNT_IS_INVALID (&surface->ref_count)) return; assert (CAIRO_REFERENCE_COUNT_HAS_REFERENCE (&surface->ref_count)); if (! _cairo_reference_count_dec_and_test (&surface->ref_count)) return; if (! surface->finished) cairo_surface_finish (surface); _cairo_user_data_array_fini (&surface->user_data); free (surface); } slim_hidden_def(cairo_surface_destroy); /** * _cairo_surface_reset: * @surface: a #cairo_surface_t * * Resets the surface back to defaults such that it may be reused in lieu * of creating a new surface. **/ cairo_status_t _cairo_surface_reset (cairo_surface_t *surface) { if (surface == NULL || CAIRO_REFERENCE_COUNT_IS_INVALID (&surface->ref_count)) return CAIRO_STATUS_SUCCESS; assert (CAIRO_REFERENCE_COUNT_GET_VALUE (&surface->ref_count) == 1); _cairo_user_data_array_fini (&surface->user_data); if (surface->backend->reset != NULL) { cairo_status_t status = surface->backend->reset (surface); if (status) return _cairo_surface_set_error (surface, status); } _cairo_surface_init (surface, surface->backend, surface->content); return CAIRO_STATUS_SUCCESS; } /** * cairo_surface_get_reference_count: * @surface: a #cairo_surface_t * * Returns the current reference count of @surface. * * Return value: the current reference count of @surface. If the * object is a nil object, 0 will be returned. * * Since: 1.4 **/ unsigned int cairo_surface_get_reference_count (cairo_surface_t *surface) { if (surface == NULL || CAIRO_REFERENCE_COUNT_IS_INVALID (&surface->ref_count)) return 0; return CAIRO_REFERENCE_COUNT_GET_VALUE (&surface->ref_count); } /** * cairo_surface_finish: * @surface: the #cairo_surface_t to finish * * This function finishes the surface and drops all references to * external resources. For example, for the Xlib backend it means * that cairo will no longer access the drawable, which can be freed. * After calling cairo_surface_finish() the only valid operations on a * surface are getting and setting user, referencing and * destroying, and flushing and finishing it. * Further drawing to the surface will not affect the * surface but will instead trigger a %CAIRO_STATUS_SURFACE_FINISHED * error. * * When the last call to cairo_surface_destroy() decreases the * reference count to zero, cairo will call cairo_surface_finish() if * it hasn't been called already, before freeing the resources * associated with the surface. **/ void cairo_surface_finish (cairo_surface_t *surface) { cairo_status_t status; if (surface == NULL) return; if (CAIRO_REFERENCE_COUNT_IS_INVALID (&surface->ref_count)) return; if (surface->finished) return; cairo_surface_flush (surface); /* call finish even if in error mode */ if (surface->backend->finish) { status = surface->backend->finish (surface); if (status) status = _cairo_surface_set_error (surface, status); } surface->finished = TRUE; } slim_hidden_def (cairo_surface_finish); /** * cairo_surface_get_user_data: * @surface: a #cairo_surface_t * @key: the address of the #cairo_user_data_key_t the user data was * attached to * * Return user data previously attached to @surface using the specified * key. If no user data has been attached with the given key this * function returns %NULL. * * Return value: the user data previously attached or %NULL. **/ void * cairo_surface_get_user_data (cairo_surface_t *surface, const cairo_user_data_key_t *key) { return _cairo_user_data_array_get_data (&surface->user_data, key); } /** * cairo_surface_set_user_data: * @surface: a #cairo_surface_t * @key: the address of a #cairo_user_data_key_t to attach the user data to * @user_data: the user data to attach to the surface * @destroy: a #cairo_destroy_func_t which will be called when the * surface is destroyed or when new user data is attached using the * same key. * * Attach user data to @surface. To remove user data from a surface, * call this function with the key that was used to set it and %NULL * for @data. * * Return value: %CAIRO_STATUS_SUCCESS or %CAIRO_STATUS_NO_MEMORY if a * slot could not be allocated for the user data. **/ cairo_status_t cairo_surface_set_user_data (cairo_surface_t *surface, const cairo_user_data_key_t *key, void *user_data, cairo_destroy_func_t destroy) { if (CAIRO_REFERENCE_COUNT_IS_INVALID (&surface->ref_count)) return surface->status; return _cairo_user_data_array_set_data (&surface->user_data, key, user_data, destroy); } /** * cairo_surface_get_mime_data: * @surface: a #cairo_surface_t * @mime_type: the mime type of the image data * @data: the image data to attached to the surface * @length: the length of the image data * * Return mime data previously attached to @surface using the * specified mime type. If no data has been attached with the given * mime type, @data is set %NULL. * * Since: 1.10 **/ void cairo_surface_get_mime_data (cairo_surface_t *surface, const char *mime_type, const unsigned char **data, unsigned int *length) { cairo_status_t status; cairo_mime_data_t *mime_data; *data = NULL; *length = 0; if (surface->status) return; status = _cairo_intern_string (&mime_type, -1); if (status) { status = _cairo_surface_set_error (surface, status); return; } mime_data = _cairo_user_data_array_get_data (&surface->user_data, (cairo_user_data_key_t *) mime_type); if (mime_data == NULL) return; *data = mime_data->data; *length = mime_data->length; } slim_hidden_def (cairo_surface_get_mime_data); static void _cairo_mime_data_destroy (void *ptr) { cairo_mime_data_t *mime_data = ptr; if (! _cairo_reference_count_dec_and_test (&mime_data->ref_count)) return; if (mime_data->destroy && mime_data->closure) mime_data->destroy (mime_data->closure); free (mime_data); } /** * cairo_surface_set_mime_data: * @surface: a #cairo_surface_t * @mime_type: the mime type of the image data * @data: the image data to attach to the surface * @length: the length of the image data * @destroy: a #cairo_destroy_func_t which will be called when the * surface is destroyed or when new image data is attached using the * same mime type. * @closure: the data to be passed to the @destroy notifier * * Attach an image in the format @mime_type to @surface. To remove * the data from a surface, call this function with same mime type * and %NULL for @data. * * Since: 1.10 * * Return value: %CAIRO_STATUS_SUCCESS or %CAIRO_STATUS_NO_MEMORY if a * slot could not be allocated for the user data. **/ cairo_status_t cairo_surface_set_mime_data (cairo_surface_t *surface, const char *mime_type, const unsigned char *data, unsigned int length, cairo_destroy_func_t destroy, void *closure) { cairo_status_t status; cairo_mime_data_t *mime_data; if (surface->status) return surface->status; status = _cairo_intern_string (&mime_type, -1); if (status) return _cairo_surface_set_error (surface, status); if (data != NULL) { mime_data = malloc (sizeof (cairo_mime_data_t)); if (mime_data == NULL) return _cairo_surface_set_error (surface, _cairo_error (CAIRO_STATUS_NO_MEMORY)); CAIRO_REFERENCE_COUNT_INIT (&mime_data->ref_count, 1); mime_data->data = (unsigned char *) data; mime_data->length = length; mime_data->destroy = destroy; mime_data->closure = closure; } else mime_data = NULL; status = _cairo_user_data_array_set_data (&surface->user_data, (cairo_user_data_key_t *) mime_type, mime_data, _cairo_mime_data_destroy); if (status) return _cairo_surface_set_error (surface, status); return CAIRO_STATUS_SUCCESS; } slim_hidden_def (cairo_surface_set_mime_data); cairo_status_t _cairo_surface_copy_mime_data (cairo_surface_t *dst, cairo_surface_t *src, const char *mime_type) { cairo_status_t status; cairo_mime_data_t *mime_data; if (dst->status) return dst->status; if (src->status) return _cairo_surface_set_error (dst, src->status); status = _cairo_intern_string (&mime_type, -1); if (status) return _cairo_surface_set_error (dst, status); mime_data = _cairo_user_data_array_get_data (&src->user_data, (cairo_user_data_key_t *) mime_type); if (mime_data == NULL) return CAIRO_STATUS_SUCCESS; _cairo_reference_count_inc (&mime_data->ref_count); status = _cairo_user_data_array_set_data (&dst->user_data, (cairo_user_data_key_t *) mime_type, mime_data, _cairo_mime_data_destroy); if (status) { _cairo_mime_data_destroy (mime_data); return _cairo_surface_set_error (dst, status); } return CAIRO_STATUS_SUCCESS; } /** * _cairo_surface_set_font_options: * @surface: a #cairo_surface_t * @options: a #cairo_font_options_t object that contains the * options to use for this surface instead of backend's default * font options. * * Sets the default font rendering options for the surface. * This is useful to correctly propagate default font options when * falling back to an image surface in a backend implementation. * This affects the options returned in cairo_surface_get_font_options(). * * If @options is %NULL the surface options are reset to those of * the backend default. **/ void _cairo_surface_set_font_options (cairo_surface_t *surface, cairo_font_options_t *options) { cairo_status_t status; if (surface->status) return; assert (! surface->is_snapshot); if (surface->finished) { status = _cairo_surface_set_error (surface, CAIRO_STATUS_SURFACE_FINISHED); return; } if (options) { surface->has_font_options = TRUE; _cairo_font_options_init_copy (&surface->font_options, options); } else { surface->has_font_options = FALSE; } } /** * cairo_surface_get_font_options: * @surface: a #cairo_surface_t * @options: a #cairo_font_options_t object into which to store * the retrieved options. All existing values are overwritten * * Retrieves the default font rendering options for the surface. * This allows display surfaces to report the correct subpixel order * for rendering on them, print surfaces to disable hinting of * metrics and so forth. The result can then be used with * cairo_scaled_font_create(). **/ void cairo_surface_get_font_options (cairo_surface_t *surface, cairo_font_options_t *options) { if (cairo_font_options_status (options)) return; if (surface->status) { _cairo_font_options_init_default (options); return; } if (! surface->has_font_options) { surface->has_font_options = TRUE; _cairo_font_options_init_default (&surface->font_options); if (!surface->finished && surface->backend->get_font_options) { surface->backend->get_font_options (surface, &surface->font_options); } } _cairo_font_options_init_copy (options, &surface->font_options); } slim_hidden_def (cairo_surface_get_font_options); /** * cairo_surface_flush: * @surface: a #cairo_surface_t * * Do any pending drawing for the surface and also restore any * temporary modification's cairo has made to the surface's * state. This function must be called before switching from * drawing on the surface with cairo to drawing on it directly * with native APIs. If the surface doesn't support direct access, * then this function does nothing. **/ void cairo_surface_flush (cairo_surface_t *surface) { cairo_status_t status; if (surface->status) return; if (surface->finished) return; if (surface->backend->flush) { status = surface->backend->flush (surface); if (status) status = _cairo_surface_set_error (surface, status); } } slim_hidden_def (cairo_surface_flush); /** * cairo_surface_mark_dirty: * @surface: a #cairo_surface_t * * Tells cairo that drawing has been done to surface using means other * than cairo, and that cairo should reread any cached areas. Note * that you must call cairo_surface_flush() before doing such drawing. */ void cairo_surface_mark_dirty (cairo_surface_t *surface) { if (surface->status) return; assert (! surface->is_snapshot); cairo_surface_mark_dirty_rectangle (surface, 0, 0, -1, -1); } /** * cairo_surface_mark_dirty_rectangle: * @surface: a #cairo_surface_t * @x: X coordinate of dirty rectangle * @y: Y coordinate of dirty rectangle * @width: width of dirty rectangle * @height: height of dirty rectangle * * Like cairo_surface_mark_dirty(), but drawing has been done only to * the specified rectangle, so that cairo can retain cached contents * for other parts of the surface. * * Any cached clip set on the surface will be reset by this function, * to make sure that future cairo calls have the clip set that they * expect. */ void cairo_surface_mark_dirty_rectangle (cairo_surface_t *surface, int x, int y, int width, int height) { cairo_status_t status; if (surface->status) return; assert (! surface->is_snapshot); if (surface->finished) { status = _cairo_surface_set_error (surface, CAIRO_STATUS_SURFACE_FINISHED); return; } /* Always reset the clip here, to avoid having external calls to * clip manipulation functions of the underlying device clip result * in a desync between the cairo clip and the backend clip, due to * the clip caching. */ surface->current_clip_serial = -1; if (surface->backend->mark_dirty_rectangle) { /* XXX: FRAGILE: We're ignoring the scaling component of * device_transform here. I don't know what the right thing to * do would actually be if there were some scaling here, but * we avoid this since device_transfom scaling is not exported * publicly and mark_dirty is not used internally. */ status = surface->backend->mark_dirty_rectangle (surface, x + surface->device_transform.x0, y + surface->device_transform.y0, width, height); if (status) status = _cairo_surface_set_error (surface, status); } } slim_hidden_def (cairo_surface_mark_dirty_rectangle); /** * _cairo_surface_set_device_scale: * @surface: a #cairo_surface_t * @sx: a scale factor in the X direction * @sy: a scale factor in the Y direction * * Private function for setting an extra scale factor to affect all * drawing to a surface. This is used, for example, when replaying a * meta surface to an image fallback intended for an eventual * vector-oriented backend. Since the meta surface will record * coordinates in one backend space, but the image fallback uses a * different backend space, (differing by the fallback resolution * scale factors), we need a scale factor correction. * * Caution: Not all places we use device transform correctly handle * both a translate and a scale. An audit would be nice. **/ void _cairo_surface_set_device_scale (cairo_surface_t *surface, double sx, double sy) { cairo_status_t status; if (surface->status) return; assert (! surface->is_snapshot); if (surface->finished) { status = _cairo_surface_set_error (surface, CAIRO_STATUS_SURFACE_FINISHED); return; } surface->device_transform.xx = sx; surface->device_transform.yy = sy; surface->device_transform.xy = 0.0; surface->device_transform.yx = 0.0; surface->device_transform_inverse = surface->device_transform; status = cairo_matrix_invert (&surface->device_transform_inverse); /* should always be invertible unless given pathological input */ assert (status == CAIRO_STATUS_SUCCESS); } /** * cairo_surface_set_device_offset: * @surface: a #cairo_surface_t * @x_offset: the offset in the X direction, in device units * @y_offset: the offset in the Y direction, in device units * * Sets an offset that is added to the device coordinates determined * by the CTM when drawing to @surface. One use case for this function * is when we want to create a #cairo_surface_t that redirects drawing * for a portion of an onscreen surface to an offscreen surface in a * way that is completely invisible to the user of the cairo * API. Setting a transformation via cairo_translate() isn't * sufficient to do this, since functions like * cairo_device_to_user() will expose the hidden offset. * * Note that the offset affects drawing to the surface as well as * using the surface in a source pattern. **/ void cairo_surface_set_device_offset (cairo_surface_t *surface, double x_offset, double y_offset) { cairo_status_t status; if (surface->status) return; assert (! surface->is_snapshot); if (surface->finished) { status = _cairo_surface_set_error (surface, CAIRO_STATUS_SURFACE_FINISHED); return; } surface->device_transform.x0 = x_offset; surface->device_transform.y0 = y_offset; surface->device_transform_inverse = surface->device_transform; status = cairo_matrix_invert (&surface->device_transform_inverse); /* should always be invertible unless given pathological input */ assert (status == CAIRO_STATUS_SUCCESS); } slim_hidden_def (cairo_surface_set_device_offset); /** * cairo_surface_get_device_offset: * @surface: a #cairo_surface_t * @x_offset: the offset in the X direction, in device units * @y_offset: the offset in the Y direction, in device units * * This function returns the previous device offset set by * cairo_surface_set_device_offset(). * * Since: 1.2 **/ void cairo_surface_get_device_offset (cairo_surface_t *surface, double *x_offset, double *y_offset) { if (x_offset) *x_offset = surface->device_transform.x0; if (y_offset) *y_offset = surface->device_transform.y0; } slim_hidden_def (cairo_surface_get_device_offset); /** * cairo_surface_set_fallback_resolution: * @surface: a #cairo_surface_t * @x_pixels_per_inch: horizontal setting for pixels per inch * @y_pixels_per_inch: vertical setting for pixels per inch * * Set the horizontal and vertical resolution for image fallbacks. * * When certain operations aren't supported natively by a backend, * cairo will fallback by rendering operations to an image and then * overlaying that image onto the output. For backends that are * natively vector-oriented, this function can be used to set the * resolution used for these image fallbacks, (larger values will * result in more detailed images, but also larger file sizes). * * Some examples of natively vector-oriented backends are the ps, pdf, * and svg backends. * * For backends that are natively raster-oriented, image fallbacks are * still possible, but they are always performed at the native * device resolution. So this function has no effect on those * backends. * * Note: The fallback resolution only takes effect at the time of * completing a page (with cairo_show_page() or cairo_copy_page()) so * there is currently no way to have more than one fallback resolution * in effect on a single page. * * The default fallback resoultion is 300 pixels per inch in both * dimensions. * * Since: 1.2 **/ void cairo_surface_set_fallback_resolution (cairo_surface_t *surface, double x_pixels_per_inch, double y_pixels_per_inch) { cairo_status_t status; if (surface->status) return; assert (! surface->is_snapshot); if (surface->finished) { status = _cairo_surface_set_error (surface, CAIRO_STATUS_SURFACE_FINISHED); return; } surface->x_fallback_resolution = x_pixels_per_inch; surface->y_fallback_resolution = y_pixels_per_inch; } slim_hidden_def (cairo_surface_set_fallback_resolution); /** * cairo_surface_get_fallback_resolution: * @surface: a #cairo_surface_t * @x_pixels_per_inch: horizontal pixels per inch * @y_pixels_per_inch: vertical pixels per inch * * This function returns the previous fallback resolution set by * cairo_surface_set_fallback_resolution(), or default fallback * resolution if never set. * * Since: 1.8 **/ void cairo_surface_get_fallback_resolution (cairo_surface_t *surface, double *x_pixels_per_inch, double *y_pixels_per_inch) { if (x_pixels_per_inch) *x_pixels_per_inch = surface->x_fallback_resolution; if (y_pixels_per_inch) *y_pixels_per_inch = surface->y_fallback_resolution; } cairo_bool_t _cairo_surface_has_device_transform (cairo_surface_t *surface) { return ! _cairo_matrix_is_identity (&surface->device_transform); } /** * _cairo_surface_acquire_source_image: * @surface: a #cairo_surface_t * @image_out: location to store a pointer to an image surface that * has identical contents to @surface. This surface could be @surface * itself, a surface held internal to @surface, or it could be a new * surface with a copy of the relevant portion of @surface. * @image_extra: location to store image specific backend data * * Gets an image surface to use when drawing as a fallback when drawing with * @surface as a source. _cairo_surface_release_source_image() must be called * when finished. * * Return value: %CAIRO_STATUS_SUCCESS if an image was stored in @image_out. * %CAIRO_INT_STATUS_UNSUPPORTED if an image cannot be retrieved for the specified * surface. Or %CAIRO_STATUS_NO_MEMORY. **/ cairo_status_t _cairo_surface_acquire_source_image (cairo_surface_t *surface, cairo_image_surface_t **image_out, void **image_extra) { if (surface->status) return surface->status; assert (!surface->finished); if (surface->backend->acquire_source_image == NULL) return CAIRO_INT_STATUS_UNSUPPORTED; return _cairo_surface_set_error (surface, surface->backend->acquire_source_image (surface, image_out, image_extra)); } /** * _cairo_surface_release_source_image: * @surface: a #cairo_surface_t * @image_extra: same as return from the matching _cairo_surface_acquire_source_image() * * Releases any resources obtained with _cairo_surface_acquire_source_image() **/ void _cairo_surface_release_source_image (cairo_surface_t *surface, cairo_image_surface_t *image, void *image_extra) { assert (!surface->finished); if (surface->backend->release_source_image) surface->backend->release_source_image (surface, image, image_extra); } /** * _cairo_surface_acquire_dest_image: * @surface: a #cairo_surface_t * @interest_rect: area of @surface for which fallback drawing is being done. * A value of %NULL indicates that the entire surface is desired. * XXXX I'd like to get rid of being able to pass %NULL here (nothing seems to) * @image_out: location to store a pointer to an image surface that includes at least * the intersection of @interest_rect with the visible area of @surface. * This surface could be @surface itself, a surface held internal to @surface, * or it could be a new surface with a copy of the relevant portion of @surface. * If a new surface is created, it should have the same channels and depth * as @surface so that copying to and from it is exact. * @image_rect: location to store area of the original surface occupied * by the surface stored in @image. * @image_extra: location to store image specific backend data * * Retrieves a local image for a surface for implementing a fallback drawing * operation. After calling this function, the implementation of the fallback * drawing operation draws the primitive to the surface stored in @image_out * then calls _cairo_surface_release_dest_image(), * which, if a temporary surface was created, copies the bits back to the * main surface and frees the temporary surface. * * Return value: %CAIRO_STATUS_SUCCESS or %CAIRO_STATUS_NO_MEMORY. * %CAIRO_INT_STATUS_UNSUPPORTED can be returned but this will mean that * the backend can't draw with fallbacks. It's possible for the routine * to store %NULL in @local_out and return %CAIRO_STATUS_SUCCESS; * that indicates that no part of @interest_rect is visible, so no drawing * is necessary. _cairo_surface_release_dest_image() should not be called in that * case. **/ cairo_status_t _cairo_surface_acquire_dest_image (cairo_surface_t *surface, cairo_rectangle_int_t *interest_rect, cairo_image_surface_t **image_out, cairo_rectangle_int_t *image_rect, void **image_extra) { if (surface->status) return surface->status; assert (!surface->finished); if (surface->backend->acquire_dest_image == NULL) return CAIRO_INT_STATUS_UNSUPPORTED; return _cairo_surface_set_error (surface, surface->backend->acquire_dest_image (surface, interest_rect, image_out, image_rect, image_extra)); } /** * _cairo_surface_release_dest_image: * @surface: a #cairo_surface_t * @interest_rect: same as passed to the matching _cairo_surface_acquire_dest_image() * @image: same as returned from the matching _cairo_surface_acquire_dest_image() * @image_rect: same as returned from the matching _cairo_surface_acquire_dest_image() * @image_extra: same as return from the matching _cairo_surface_acquire_dest_image() * * Finishes the operation started with _cairo_surface_acquire_dest_image(), by, if * necessary, copying the image from @image back to @surface and freeing any * resources that were allocated. **/ void _cairo_surface_release_dest_image (cairo_surface_t *surface, cairo_rectangle_int_t *interest_rect, cairo_image_surface_t *image, cairo_rectangle_int_t *image_rect, void *image_extra) { assert (!surface->finished); if (surface->backend->release_dest_image) surface->backend->release_dest_image (surface, interest_rect, image, image_rect, image_extra); } /** * _cairo_surface_clone_similar: * @surface: a #cairo_surface_t * @src: the source image * @src_x: extent for the rectangle in src we actually care about * @src_y: extent for the rectangle in src we actually care about * @width: extent for the rectangle in src we actually care about * @height: extent for the rectangle in src we actually care about * @clone_out: location to store a surface compatible with @surface * and with contents identical to @src. The caller must call * cairo_surface_destroy() on the result. * * Creates a surface with contents identical to @src but that * can be used efficiently with @surface. If @surface and @src are * already compatible then it may return a new reference to @src. * * Return value: %CAIRO_STATUS_SUCCESS if a surface was created and stored * in @clone_out. Otherwise %CAIRO_INT_STATUS_UNSUPPORTED or another * error like %CAIRO_STATUS_NO_MEMORY. **/ cairo_status_t _cairo_surface_clone_similar (cairo_surface_t *surface, cairo_surface_t *src, int src_x, int src_y, int width, int height, int *clone_offset_x, int *clone_offset_y, cairo_surface_t **clone_out) { cairo_status_t status = CAIRO_INT_STATUS_UNSUPPORTED; cairo_image_surface_t *image; void *image_extra; if (surface->status) return surface->status; if (surface->finished) return _cairo_error (CAIRO_STATUS_SURFACE_FINISHED); if (surface->backend->clone_similar) { status = surface->backend->clone_similar (surface, src, src_x, src_y, width, height, clone_offset_x, clone_offset_y, clone_out); if (status == CAIRO_INT_STATUS_UNSUPPORTED) { /* If we failed, try again with an image surface */ status = _cairo_surface_acquire_source_image (src, &image, &image_extra); if (status == CAIRO_STATUS_SUCCESS) { status = surface->backend->clone_similar (surface, &image->base, src_x, src_y, width, height, clone_offset_x, clone_offset_y, clone_out); _cairo_surface_release_source_image (src, image, image_extra); } } } /* If we're still unsupported, hit our fallback path to get a clone */ if (status == CAIRO_INT_STATUS_UNSUPPORTED) status = _cairo_surface_fallback_clone_similar (surface, src, src_x, src_y, width, height, clone_offset_x, clone_offset_y, clone_out); /* We should never get UNSUPPORTED here, so if we have an error, bail. */ if (status) return status; /* Update the clone's device_transform (which the underlying surface * backend knows nothing about) */ if (*clone_out != src) { (*clone_out)->device_transform = src->device_transform; (*clone_out)->device_transform_inverse = src->device_transform_inverse; } return status; } /* XXX: Shouldn't really need to do this here. */ #include "cairo-meta-surface-private.h" /** * _cairo_surface_snapshot * @surface: a #cairo_surface_t * * Make an immutable copy of @surface. It is an error to call a * surface-modifying function on the result of this function. * * The caller owns the return value and should call * cairo_surface_destroy() when finished with it. This function will not * return %NULL, but will return a nil surface instead. * * Return value: The snapshot surface. Note that the return surface * may not necessarily be of the same type as @surface. **/ cairo_surface_t * _cairo_surface_snapshot (cairo_surface_t *surface) { if (surface->status) return _cairo_surface_create_in_error (surface->status); if (surface->finished) return _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_SURFACE_FINISHED)); if (surface->backend->snapshot) return surface->backend->snapshot (surface); return _cairo_surface_fallback_snapshot (surface); } /** * _cairo_surface_is_similar * @surface_a: a #cairo_surface_t * @surface_b: a #cairo_surface_t * @content: a #cairo_content_t * * Find out whether the given surfaces share the same backend, * and if so, whether they can be considered similar. * * The definition of "similar" depends on the backend. In * general, it means that the surface is equivalent to one * that would have been generated by a call to cairo_surface_create_similar(). * * Return value: %TRUE if the surfaces are similar. **/ cairo_bool_t _cairo_surface_is_similar (cairo_surface_t *surface_a, cairo_surface_t *surface_b, cairo_content_t content) { if (surface_a->backend != surface_b->backend) return FALSE; if (surface_a->backend->is_similar != NULL) return surface_a->backend->is_similar (surface_a, surface_b, content); return TRUE; } cairo_status_t _cairo_surface_composite (cairo_operator_t op, const cairo_pattern_t *src, const cairo_pattern_t *mask, cairo_surface_t *dst, int src_x, int src_y, int mask_x, int mask_y, int dst_x, int dst_y, unsigned int width, unsigned int height) { cairo_int_status_t status; if (mask) { /* These operators aren't interpreted the same way by the backends; * they are implemented in terms of other operators in cairo-gstate.c */ assert (op != CAIRO_OPERATOR_SOURCE && op != CAIRO_OPERATOR_CLEAR); } if (dst->status) return dst->status; assert (! dst->is_snapshot); if (dst->finished) return _cairo_surface_set_error (dst, CAIRO_STATUS_SURFACE_FINISHED); if (dst->backend->composite) { status = dst->backend->composite (op, src, mask, dst, src_x, src_y, mask_x, mask_y, dst_x, dst_y, width, height); if (status != CAIRO_INT_STATUS_UNSUPPORTED) return _cairo_surface_set_error (dst, status); } return _cairo_surface_set_error (dst, _cairo_surface_fallback_composite (op, src, mask, dst, src_x, src_y, mask_x, mask_y, dst_x, dst_y, width, height)); } /** * _cairo_surface_fill_rectangle: * @surface: a #cairo_surface_t * @op: the operator to apply to the rectangle * @color: the source color * @x: X coordinate of rectangle, in backend coordinates * @y: Y coordinate of rectangle, in backend coordinates * @width: width of rectangle, in backend coordinates * @height: height of rectangle, in backend coordinates * * Applies an operator to a rectangle using a solid color as the source. * See _cairo_surface_fill_rectangles() for full details. * * Return value: %CAIRO_STATUS_SUCCESS or the error that occurred **/ cairo_status_t _cairo_surface_fill_rectangle (cairo_surface_t *surface, cairo_operator_t op, const cairo_color_t *color, int x, int y, int width, int height) { cairo_rectangle_int_t rect; if (surface->status) return surface->status; assert (! surface->is_snapshot); if (surface->finished) return _cairo_surface_set_error (surface,CAIRO_STATUS_SURFACE_FINISHED); rect.x = x; rect.y = y; rect.width = width; rect.height = height; return _cairo_surface_fill_rectangles (surface, op, color, &rect, 1); } /** * _cairo_surface_fill_region: * @surface: a #cairo_surface_t * @op: the operator to apply to the region * @color: the source color * @region: the region to modify, in backend coordinates * * Applies an operator to a set of rectangles specified as a * #cairo_region_t using a solid color as the source. * See _cairo_surface_fill_rectangles() for full details. * * Return value: %CAIRO_STATUS_SUCCESS or the error that occurred **/ cairo_status_t _cairo_surface_fill_region (cairo_surface_t *surface, cairo_operator_t op, const cairo_color_t *color, cairo_region_t *region) { int num_boxes; cairo_box_int_t *boxes = NULL; cairo_rectangle_int_t stack_rects[CAIRO_STACK_ARRAY_LENGTH (cairo_rectangle_int_t)]; cairo_rectangle_int_t *rects = stack_rects; cairo_status_t status; int i; if (surface->status) return surface->status; assert (! surface->is_snapshot); num_boxes = _cairo_region_num_boxes (region); if (num_boxes == 0) return CAIRO_STATUS_SUCCESS; /* handle the common case of a single box without allocation */ if (num_boxes > 1) { status = _cairo_region_get_boxes (region, &num_boxes, &boxes); if (status) return status; if (num_boxes > ARRAY_LENGTH (stack_rects)) { rects = _cairo_malloc_ab (num_boxes, sizeof (cairo_rectangle_int_t)); if (!rects) { _cairo_region_boxes_fini (region, boxes); return _cairo_surface_set_error (surface, CAIRO_STATUS_NO_MEMORY); } } for (i = 0; i < num_boxes; i++) { rects[i].x = boxes[i].p1.x; rects[i].y = boxes[i].p1.y; rects[i].width = boxes[i].p2.x - boxes[i].p1.x; rects[i].height = boxes[i].p2.y - boxes[i].p1.y; } } else _cairo_region_get_extents (region, &rects[0]); status = _cairo_surface_fill_rectangles (surface, op, color, rects, num_boxes); if (boxes != NULL) _cairo_region_boxes_fini (region, boxes); if (rects != stack_rects) free (rects); return _cairo_surface_set_error (surface, status); } /** * _cairo_surface_fill_rectangles: * @surface: a #cairo_surface_t * @op: the operator to apply to the region * @color: the source color * @rects: the rectangles to modify, in backend coordinates * @num_rects: the number of rectangles in @rects * * Applies an operator to a set of rectangles using a solid color * as the source. Note that even if the operator is an unbounded operator * such as %CAIRO_OPERATOR_IN, only the given set of rectangles * is affected. This differs from _cairo_surface_composite_trapezoids() * where the entire destination rectangle is cleared. * * Return value: %CAIRO_STATUS_SUCCESS or the error that occurred **/ cairo_status_t _cairo_surface_fill_rectangles (cairo_surface_t *surface, cairo_operator_t op, const cairo_color_t *color, cairo_rectangle_int_t *rects, int num_rects) { cairo_int_status_t status; if (surface->status) return surface->status; assert (! surface->is_snapshot); if (surface->finished) return _cairo_surface_set_error (surface,CAIRO_STATUS_SURFACE_FINISHED); if (num_rects == 0) return CAIRO_STATUS_SUCCESS; if (surface->backend->fill_rectangles) { status = surface->backend->fill_rectangles (surface, op, color, rects, num_rects); if (status != CAIRO_INT_STATUS_UNSUPPORTED) return _cairo_surface_set_error (surface, status); } return _cairo_surface_set_error (surface, _cairo_surface_fallback_fill_rectangles (surface, op, color, rects, num_rects)); } cairo_status_t _cairo_surface_paint (cairo_surface_t *surface, cairo_operator_t op, const cairo_pattern_t *source, cairo_rectangle_int_t *extents) { cairo_status_t status; cairo_pattern_union_t dev_source; if (surface->status) return surface->status; assert (! surface->is_snapshot); status = _cairo_surface_copy_pattern_for_destination (&source, surface, &dev_source.base); if (status) return _cairo_surface_set_error (surface, status); if (surface->backend->paint) { status = surface->backend->paint (surface, op, source, extents); if (status != CAIRO_INT_STATUS_UNSUPPORTED) goto FINISH; } status = _cairo_surface_fallback_paint (surface, op, source); FINISH: if (source == &dev_source.base) _cairo_pattern_fini (&dev_source.base); return _cairo_surface_set_error (surface, status); } cairo_status_t _cairo_surface_mask (cairo_surface_t *surface, cairo_operator_t op, const cairo_pattern_t *source, const cairo_pattern_t *mask, cairo_rectangle_int_t *extents) { cairo_status_t status; cairo_pattern_union_t dev_source; cairo_pattern_union_t dev_mask; if (surface->status) return surface->status; assert (! surface->is_snapshot); status = _cairo_surface_copy_pattern_for_destination (&source, surface, &dev_source.base); if (status) goto FINISH; status = _cairo_surface_copy_pattern_for_destination (&mask, surface, &dev_mask.base); if (status) goto CLEANUP_SOURCE; if (surface->backend->mask) { status = surface->backend->mask (surface, op, source, mask, extents); if (status != CAIRO_INT_STATUS_UNSUPPORTED) goto CLEANUP_MASK; } status = _cairo_surface_fallback_mask (surface, op, source, mask); CLEANUP_MASK: if (mask == &dev_mask.base) _cairo_pattern_fini (&dev_mask.base); CLEANUP_SOURCE: if (source == &dev_source.base) _cairo_pattern_fini (&dev_source.base); FINISH: return _cairo_surface_set_error (surface, status); } cairo_status_t _cairo_surface_fill_stroke (cairo_surface_t *surface, cairo_operator_t fill_op, const cairo_pattern_t *fill_source, cairo_fill_rule_t fill_rule, double fill_tolerance, cairo_antialias_t fill_antialias, cairo_path_fixed_t *path, cairo_operator_t stroke_op, const cairo_pattern_t *stroke_source, cairo_stroke_style_t *stroke_style, cairo_matrix_t *stroke_ctm, cairo_matrix_t *stroke_ctm_inverse, double stroke_tolerance, cairo_antialias_t stroke_antialias, cairo_rectangle_int_t *extents) { cairo_status_t status; if (surface->status) return surface->status; if (surface->backend->fill_stroke) { cairo_pattern_union_t dev_stroke_source; cairo_pattern_union_t dev_fill_source; cairo_matrix_t dev_ctm = *stroke_ctm; cairo_matrix_t dev_ctm_inverse = *stroke_ctm_inverse; status = _cairo_surface_copy_pattern_for_destination (&stroke_source, surface, &dev_stroke_source.base); if (status) return _cairo_surface_set_error (surface, status); status = _cairo_surface_copy_pattern_for_destination (&fill_source, surface, &dev_fill_source.base); if (status) { if (stroke_source == &dev_stroke_source.base) _cairo_pattern_fini (&dev_stroke_source.base); return _cairo_surface_set_error (surface, status); } status = surface->backend->fill_stroke (surface, fill_op, fill_source, fill_rule, fill_tolerance, fill_antialias, path, stroke_op, stroke_source, stroke_style, &dev_ctm, &dev_ctm_inverse, stroke_tolerance, stroke_antialias, extents); if (stroke_source == &dev_stroke_source.base) _cairo_pattern_fini (&dev_stroke_source.base); if (fill_source == &dev_fill_source.base) _cairo_pattern_fini (&dev_fill_source.base); if (status != CAIRO_INT_STATUS_UNSUPPORTED) return _cairo_surface_set_error (surface, status); } status = _cairo_surface_fill (surface, fill_op, fill_source, path, fill_rule, fill_tolerance, fill_antialias, NULL); if (status) return _cairo_surface_set_error (surface, status); status = _cairo_surface_stroke (surface, stroke_op, stroke_source, path, stroke_style, stroke_ctm, stroke_ctm_inverse, stroke_tolerance, stroke_antialias, NULL); if (status) return _cairo_surface_set_error (surface, status); return CAIRO_STATUS_SUCCESS; } cairo_status_t _cairo_surface_stroke (cairo_surface_t *surface, cairo_operator_t op, const cairo_pattern_t *source, cairo_path_fixed_t *path, cairo_stroke_style_t *stroke_style, cairo_matrix_t *ctm, cairo_matrix_t *ctm_inverse, double tolerance, cairo_antialias_t antialias, cairo_rectangle_int_t *extents) { cairo_status_t status; cairo_pattern_union_t dev_source; cairo_path_fixed_t *dev_path = path; cairo_path_fixed_t real_dev_path; cairo_matrix_t dev_ctm = *ctm; cairo_matrix_t dev_ctm_inverse = *ctm_inverse; if (surface->status) return surface->status; assert (! surface->is_snapshot); status = _cairo_surface_copy_pattern_for_destination (&source, surface, &dev_source.base); if (status) return _cairo_surface_set_error (surface, status); if (surface->backend->stroke) { status = surface->backend->stroke (surface, op, source, path, stroke_style, &dev_ctm, &dev_ctm_inverse, tolerance, antialias, extents); if (status != CAIRO_INT_STATUS_UNSUPPORTED) goto FINISH; } status = _cairo_surface_fallback_stroke (surface, op, source, path, stroke_style, &dev_ctm, &dev_ctm_inverse, tolerance, antialias); FINISH: if (dev_path == &real_dev_path) _cairo_path_fixed_fini (&real_dev_path); if (source == &dev_source.base) _cairo_pattern_fini (&dev_source.base); return _cairo_surface_set_error (surface, status); } cairo_status_t _cairo_surface_fill (cairo_surface_t *surface, cairo_operator_t op, const cairo_pattern_t *source, cairo_path_fixed_t *path, cairo_fill_rule_t fill_rule, double tolerance, cairo_antialias_t antialias, cairo_rectangle_int_t *extents) { cairo_status_t status; cairo_pattern_union_t dev_source; if (surface->status) return surface->status; assert (! surface->is_snapshot); status = _cairo_surface_copy_pattern_for_destination (&source, surface, &dev_source.base); if (status) return _cairo_surface_set_error (surface, status); if (surface->backend->fill) { status = surface->backend->fill (surface, op, source, path, fill_rule, tolerance, antialias, extents); if (status != CAIRO_INT_STATUS_UNSUPPORTED) goto FINISH; } status = _cairo_surface_fallback_fill (surface, op, source, path, fill_rule, tolerance, antialias); FINISH: if (source == &dev_source.base) _cairo_pattern_fini (&dev_source.base); return _cairo_surface_set_error (surface, status); } cairo_status_t _cairo_surface_composite_trapezoids (cairo_operator_t op, const cairo_pattern_t *pattern, cairo_surface_t *dst, cairo_antialias_t antialias, int src_x, int src_y, int dst_x, int dst_y, unsigned int width, unsigned int height, cairo_trapezoid_t *traps, int num_traps) { cairo_int_status_t status; /* These operators aren't interpreted the same way by the backends; * they are implemented in terms of other operators in cairo-gstate.c */ assert (op != CAIRO_OPERATOR_SOURCE && op != CAIRO_OPERATOR_CLEAR); if (dst->status) return dst->status; assert (! dst->is_snapshot); if (dst->finished) return _cairo_surface_set_error (dst, CAIRO_STATUS_SURFACE_FINISHED); if (dst->backend->composite_trapezoids) { status = dst->backend->composite_trapezoids (op, pattern, dst, antialias, src_x, src_y, dst_x, dst_y, width, height, traps, num_traps); if (status != CAIRO_INT_STATUS_UNSUPPORTED) return _cairo_surface_set_error (dst, status); } return _cairo_surface_set_error (dst, _cairo_surface_fallback_composite_trapezoids (op, pattern, dst, antialias, src_x, src_y, dst_x, dst_y, width, height, traps, num_traps)); } /** * cairo_surface_copy_page: * @surface: a #cairo_surface_t * * Emits the current page for backends that support multiple pages, * but doesn't clear it, so that the contents of the current page will * be retained for the next page. Use cairo_surface_show_page() if you * want to get an empty page after the emission. * * There is a convenience function for this that takes a #cairo_t, * namely cairo_copy_page(). * * Since: 1.6 */ void cairo_surface_copy_page (cairo_surface_t *surface) { cairo_status_t status_ignored; if (surface->status) return; assert (! surface->is_snapshot); if (surface->finished) { status_ignored = _cairo_surface_set_error (surface, CAIRO_STATUS_SURFACE_FINISHED); return; } /* It's fine if some backends don't implement copy_page */ if (surface->backend->copy_page == NULL) return; status_ignored = _cairo_surface_set_error (surface, surface->backend->copy_page (surface)); } slim_hidden_def (cairo_surface_copy_page); /** * cairo_surface_show_page: * @surface: a #cairo_Surface_t * * Emits and clears the current page for backends that support multiple * pages. Use cairo_surface_copy_page() if you don't want to clear the page. * * There is a convenience function for this that takes a #cairo_t, * namely cairo_show_page(). * * Since: 1.6 **/ void cairo_surface_show_page (cairo_surface_t *surface) { cairo_status_t status_ignored; if (surface->status) return; assert (! surface->is_snapshot); if (surface->finished) { status_ignored = _cairo_surface_set_error (surface, CAIRO_STATUS_SURFACE_FINISHED); return; } /* It's fine if some backends don't implement show_page */ if (surface->backend->show_page == NULL) return; status_ignored = _cairo_surface_set_error (surface, surface->backend->show_page (surface)); } slim_hidden_def (cairo_surface_show_page); /** * _cairo_surface_get_current_clip_serial: * @surface: the #cairo_surface_t to return the serial number for * * This space left intentionally blank. * * Returns: the serial number associated with the current * clip in the surface. All gstate functions must * verify that the correct clip is set in the surface before * invoking any surface drawing function. */ unsigned int _cairo_surface_get_current_clip_serial (cairo_surface_t *surface) { return surface->current_clip_serial; } /** * _cairo_surface_allocate_clip_serial: * @surface: the #cairo_surface_t to allocate a serial number from * * Each surface has a separate set of clipping serial numbers, and * this function allocates one from the specified surface. As zero is * reserved for the special no-clipping case, this function will not * return that except for an in-error surface, (ie. surface->status != * %CAIRO_STATUS_SUCCESS). */ unsigned int _cairo_surface_allocate_clip_serial (cairo_surface_t *surface) { unsigned int serial; if (surface->status) return 0; if ((serial = ++(surface->next_clip_serial)) == 0) serial = ++(surface->next_clip_serial); return serial; } /** * _cairo_surface_reset_clip: * @surface: the #cairo_surface_t to reset the clip on * * This function sets the clipping for the surface to * None, which is to say that drawing is entirely * unclipped. It also sets the clip serial number * to zero. */ cairo_status_t _cairo_surface_reset_clip (cairo_surface_t *surface) { cairo_status_t status; if (surface->status) return surface->status; if (surface->finished) return _cairo_surface_set_error (surface,CAIRO_STATUS_SURFACE_FINISHED); surface->current_clip_serial = 0; if (surface->backend->intersect_clip_path) { status = surface->backend->intersect_clip_path (surface, NULL, CAIRO_FILL_RULE_WINDING, 0, CAIRO_ANTIALIAS_DEFAULT); if (status) return _cairo_surface_set_error (surface, status); } if (surface->backend->set_clip_region != NULL) { status = surface->backend->set_clip_region (surface, NULL); if (status) return _cairo_surface_set_error (surface, status); } return CAIRO_STATUS_SUCCESS; } /** * _cairo_surface_set_clip_region: * @surface: the #cairo_surface_t to reset the clip on * @region: the #cairo_region_t to use for clipping * @serial: the clip serial number associated with the region * * This function sets the clipping for the surface to * the specified region and sets the surface clipping * serial number to the associated serial number. */ cairo_status_t _cairo_surface_set_clip_region (cairo_surface_t *surface, cairo_region_t *region, unsigned int serial) { cairo_status_t status; if (surface->status) return surface->status; assert (surface->backend->set_clip_region != NULL); surface->current_clip_serial = serial; status = surface->backend->set_clip_region (surface, region); return _cairo_surface_set_error (surface, status); } cairo_int_status_t _cairo_surface_intersect_clip_path (cairo_surface_t *surface, cairo_path_fixed_t *path, cairo_fill_rule_t fill_rule, double tolerance, cairo_antialias_t antialias) { cairo_path_fixed_t *dev_path = path; cairo_status_t status; if (surface->status) return surface->status; if (surface->finished) return _cairo_surface_set_error (surface,CAIRO_STATUS_SURFACE_FINISHED); assert (surface->backend->intersect_clip_path != NULL); status = surface->backend->intersect_clip_path (surface, dev_path, fill_rule, tolerance, antialias); return _cairo_surface_set_error (surface, status); } static cairo_status_t _cairo_surface_set_clip_path_recursive (cairo_surface_t *surface, cairo_clip_path_t *clip_path) { cairo_status_t status; if (surface->status) return surface->status; if (clip_path == NULL) return CAIRO_STATUS_SUCCESS; status = _cairo_surface_set_clip_path_recursive (surface, clip_path->prev); if (status) return status; return _cairo_surface_intersect_clip_path (surface, &clip_path->path, clip_path->fill_rule, clip_path->tolerance, clip_path->antialias); } /** * _cairo_surface_set_clip_path: * @surface: the #cairo_surface_t to set the clip on * @clip_path: the clip path to set * @serial: the clip serial number associated with the clip path * * Sets the given clipping path for the surface and assigns the * clipping serial to the surface. **/ static cairo_status_t _cairo_surface_set_clip_path (cairo_surface_t *surface, cairo_clip_path_t *clip_path, unsigned int serial) { cairo_status_t status; if (surface->status) return surface->status; if (surface->finished) return _cairo_surface_set_error (surface,CAIRO_STATUS_SURFACE_FINISHED); assert (surface->backend->intersect_clip_path != NULL); status = surface->backend->intersect_clip_path (surface, NULL, CAIRO_FILL_RULE_WINDING, 0, CAIRO_ANTIALIAS_DEFAULT); if (status) return _cairo_surface_set_error (surface, status); status = _cairo_surface_set_clip_path_recursive (surface, clip_path); if (status) return _cairo_surface_set_error (surface, status); surface->current_clip_serial = serial; return CAIRO_STATUS_SUCCESS; } /** * _cairo_surface_set_empty_clip_path: * @surface: the #cairo_surface_t to set the clip on * @serial: the clip serial number associated with the clip path * * Create an empty clip path, one that represents the entire surface clipped * out, and assigns the given clipping serial to the surface. **/ static cairo_status_t _cairo_surface_set_empty_clip_path (cairo_surface_t *surface, unsigned int serial) { cairo_path_fixed_t path; cairo_status_t status; if (surface->status) return surface->status; _cairo_path_fixed_init (&path); status = surface->backend->intersect_clip_path (surface, &path, CAIRO_FILL_RULE_WINDING, 0, CAIRO_ANTIALIAS_DEFAULT); if (status == CAIRO_STATUS_SUCCESS) surface->current_clip_serial = serial; _cairo_path_fixed_fini (&path); return _cairo_surface_set_error (surface, status); } cairo_clip_t * _cairo_surface_get_clip (cairo_surface_t *surface) { return surface->clip; } cairo_status_t _cairo_surface_set_clip (cairo_surface_t *surface, cairo_clip_t *clip) { unsigned int serial = 0; if (surface->status) return surface->status; if (surface->finished) return _cairo_surface_set_error (surface,CAIRO_STATUS_SURFACE_FINISHED); if (clip) { serial = clip->serial; if (serial == 0) clip = NULL; } surface->clip = clip; if (serial == _cairo_surface_get_current_clip_serial (surface)) return CAIRO_STATUS_SUCCESS; if (clip) { if (clip->all_clipped) { if (surface->backend->intersect_clip_path != NULL) return _cairo_surface_set_empty_clip_path (surface, clip->serial); if (surface->backend->set_clip_region != NULL) return _cairo_surface_set_clip_region (surface, &clip->region, clip->serial); } else { if (clip->path) return _cairo_surface_set_clip_path (surface, clip->path, clip->serial); if (clip->has_region) return _cairo_surface_set_clip_region (surface, &clip->region, clip->serial); } } return _cairo_surface_reset_clip (surface); } /** * _cairo_surface_get_extents: * @surface: the #cairo_surface_t to fetch extents for * * This function returns a bounding box for the surface. The surface * bounds are defined as a region beyond which no rendering will * possibly be recorded, in other words, it is the maximum extent of * potentially usable coordinates. * * For vector surfaces, (PDF, PS, SVG and meta-surfaces), the surface * might be conceived as unbounded, but we force the user to provide a * maximum size at the time of surface_create. So get_extents uses * that size. * * Note: The coordinates returned are in "backend" space rather than * "surface" space. That is, they are relative to the true (0,0) * origin rather than the device_transform origin. This might seem a * bit inconsistent with other #cairo_surface_t interfaces, but all * current callers are within the surface layer where backend space is * desired. * * This behavior would have to be changed is we ever exported a public * variant of this function. */ cairo_int_status_t _cairo_surface_get_extents (cairo_surface_t *surface, cairo_rectangle_int_t *extents) { cairo_int_status_t status = CAIRO_INT_STATUS_UNSUPPORTED; if (surface->status) return surface->status; if (surface->finished) return _cairo_surface_set_error (surface,CAIRO_STATUS_SURFACE_FINISHED); if (surface->backend->get_extents) { status = _cairo_surface_set_error (surface, surface->backend->get_extents (surface, extents)); } if (status == CAIRO_INT_STATUS_UNSUPPORTED) { extents->x = CAIRO_RECT_INT_MIN; extents->y = CAIRO_RECT_INT_MIN; extents->width = CAIRO_RECT_INT_MAX - CAIRO_RECT_INT_MIN; extents->height = CAIRO_RECT_INT_MAX - CAIRO_RECT_INT_MIN; } return status; } /** * cairo_surface_has_show_text_glyphs: * @surface: a #cairo_surface_t * * Returns whether the surface supports * sophisticated cairo_show_text_glyphs() operations. That is, * whether it actually uses the provided text and cluster data * to a cairo_show_text_glyphs() call. * * Note: Even if this function returns %FALSE, a * cairo_show_text_glyphs() operation targeted at @surface will * still succeed. It just will * act like a cairo_show_glyphs() operation. Users can use this * function to avoid computing UTF-8 text and cluster mapping if the * target surface does not use it. * * Return value: %TRUE if @surface supports * cairo_show_text_glyphs(), %FALSE otherwise * * Since: 1.8 **/ cairo_bool_t cairo_surface_has_show_text_glyphs (cairo_surface_t *surface) { cairo_status_t status_ignored; if (surface->status) return FALSE; if (surface->finished) { status_ignored = _cairo_surface_set_error (surface, CAIRO_STATUS_SURFACE_FINISHED); return FALSE; } if (surface->backend->has_show_text_glyphs) return surface->backend->has_show_text_glyphs (surface); else return surface->backend->show_text_glyphs != NULL; } slim_hidden_def (cairo_surface_has_show_text_glyphs); /* Note: the backends may modify the contents of the glyph array as long as * they do not return %CAIRO_INT_STATUS_UNSUPPORTED. This makes it possible to * avoid copying the array again and again, and edit it in-place. * Backends are in fact free to use the array as a generic buffer as they * see fit. * * For show_glyphs backend method, and NOT for show_text_glyphs method, * when they do return UNSUPPORTED, they may adjust remaining_glyphs to notify * that they have successfully rendered some of the glyphs (from the beginning * of the array), but not all. If they don't touch remaining_glyphs, it * defaults to all glyphs. * * See commits 5a9642c5746fd677aed35ce620ce90b1029b1a0c and * 1781e6018c17909311295a9cc74b70500c6b4d0a for the rationale. */ cairo_status_t _cairo_surface_show_text_glyphs (cairo_surface_t *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, cairo_rectangle_int_t *extents) { cairo_status_t status; cairo_scaled_font_t *dev_scaled_font = scaled_font; cairo_pattern_union_t dev_source; if (surface->status) return surface->status; assert (! surface->is_snapshot); if (!num_glyphs && !utf8_len) return CAIRO_STATUS_SUCCESS; status = _cairo_surface_copy_pattern_for_destination (&source, surface, &dev_source.base); if (status) return _cairo_surface_set_error (surface, status); if (_cairo_surface_has_device_transform (surface) && ! _cairo_matrix_is_integer_translation (&surface->device_transform, NULL, NULL)) { cairo_font_options_t font_options; cairo_matrix_t dev_ctm, font_matrix; cairo_scaled_font_get_font_matrix (scaled_font, &font_matrix); cairo_scaled_font_get_ctm (scaled_font, &dev_ctm); cairo_matrix_multiply (&dev_ctm, &dev_ctm, &surface->device_transform); cairo_scaled_font_get_font_options (scaled_font, &font_options); dev_scaled_font = cairo_scaled_font_create (cairo_scaled_font_get_font_face (scaled_font), &font_matrix, &dev_ctm, &font_options); } status = cairo_scaled_font_status (dev_scaled_font); if (status) { if (source == &dev_source.base) _cairo_pattern_fini (&dev_source.base); return _cairo_surface_set_error (surface, status); } status = CAIRO_INT_STATUS_UNSUPPORTED; /* The logic here is duplicated in _cairo_analysis_surface show_glyphs and * show_text_glyphs. Keep in synch. */ if (clusters) { /* A real show_text_glyphs call. Try show_text_glyphs backend * method first */ if (surface->backend->show_text_glyphs) { status = surface->backend->show_text_glyphs (surface, op, source, utf8, utf8_len, glyphs, num_glyphs, clusters, num_clusters, cluster_flags, dev_scaled_font, extents); } if (status == CAIRO_INT_STATUS_UNSUPPORTED && surface->backend->show_glyphs) { int remaining_glyphs = num_glyphs; status = surface->backend->show_glyphs (surface, op, source, glyphs, num_glyphs, dev_scaled_font, &remaining_glyphs, extents); glyphs += num_glyphs - remaining_glyphs; num_glyphs = remaining_glyphs; if (status == CAIRO_INT_STATUS_UNSUPPORTED && remaining_glyphs == 0) status = CAIRO_STATUS_SUCCESS; } } else { /* A mere show_glyphs call. Try show_glyphs backend method first */ if (surface->backend->show_glyphs) { int remaining_glyphs = num_glyphs; status = surface->backend->show_glyphs (surface, op, source, glyphs, num_glyphs, dev_scaled_font, &remaining_glyphs, extents); glyphs += num_glyphs - remaining_glyphs; num_glyphs = remaining_glyphs; if (status == CAIRO_INT_STATUS_UNSUPPORTED && remaining_glyphs == 0) status = CAIRO_STATUS_SUCCESS; } else if (surface->backend->show_text_glyphs) { /* Intentionally only try show_text_glyphs method for show_glyphs * calls if backend does not have show_glyphs. If backend has * both methods implemented, we don't fallback from show_glyphs to * show_text_glyphs, and hence the backend can assume in its * show_text_glyphs call that clusters is not NULL (which also * implies that UTF-8 is not NULL, unless the text is * zero-length). */ status = surface->backend->show_text_glyphs (surface, op, source, utf8, utf8_len, glyphs, num_glyphs, clusters, num_clusters, cluster_flags, dev_scaled_font, extents); } } if (status == CAIRO_INT_STATUS_UNSUPPORTED) status = _cairo_surface_fallback_show_glyphs (surface, op, source, glyphs, num_glyphs, dev_scaled_font); if (dev_scaled_font != scaled_font) cairo_scaled_font_destroy (dev_scaled_font); if (source == &dev_source.base) _cairo_pattern_fini (&dev_source.base); return _cairo_surface_set_error (surface, status); } /* XXX: Previously, we had a function named _cairo_surface_show_glyphs * with not-so-useful semantics. We've now got a * _cairo_surface_show_text_glyphs with the proper semantics, and its * fallback still uses this old function (which still needs to be * cleaned up in terms of both semantics and naming). */ cairo_status_t _cairo_surface_old_show_glyphs (cairo_scaled_font_t *scaled_font, cairo_operator_t op, const cairo_pattern_t *pattern, cairo_surface_t *dst, int source_x, int source_y, int dest_x, int dest_y, unsigned int width, unsigned int height, cairo_glyph_t *glyphs, int num_glyphs) { cairo_status_t status; if (dst->status) return dst->status; assert (! dst->is_snapshot); if (dst->finished) return _cairo_surface_set_error (dst, CAIRO_STATUS_SURFACE_FINISHED); if (dst->backend->old_show_glyphs) { status = dst->backend->old_show_glyphs (scaled_font, op, pattern, dst, source_x, source_y, dest_x, dest_y, width, height, glyphs, num_glyphs); } else status = CAIRO_INT_STATUS_UNSUPPORTED; return _cairo_surface_set_error (dst, status); } static cairo_status_t _cairo_surface_composite_fixup_unbounded_internal (cairo_surface_t *dst, cairo_rectangle_int_t *src_rectangle, cairo_rectangle_int_t *mask_rectangle, int dst_x, int dst_y, unsigned int width, unsigned int height) { cairo_rectangle_int_t dst_rectangle; cairo_rectangle_int_t drawn_rectangle; cairo_bool_t has_drawn_region = FALSE; cairo_region_t drawn_region; cairo_region_t clear_region; cairo_status_t status; /* The area that was drawn is the area in the destination rectangle but not within * the source or the mask. */ dst_rectangle.x = dst_x; dst_rectangle.y = dst_y; dst_rectangle.width = width; dst_rectangle.height = height; _cairo_region_init_rect (&clear_region, &dst_rectangle); drawn_rectangle = dst_rectangle; if (src_rectangle) { if (! _cairo_rectangle_intersect (&drawn_rectangle, src_rectangle)) goto EMPTY; } if (mask_rectangle) { if (! _cairo_rectangle_intersect (&drawn_rectangle, mask_rectangle)) goto EMPTY; } /* Now compute the area that is in dst_rectangle but not in drawn_rectangle */ _cairo_region_init_rect (&drawn_region, &drawn_rectangle); has_drawn_region = TRUE; status = _cairo_region_subtract (&clear_region, &clear_region, &drawn_region); if (status) goto CLEANUP_REGIONS; EMPTY: status = _cairo_surface_fill_region (dst, CAIRO_OPERATOR_SOURCE, CAIRO_COLOR_TRANSPARENT, &clear_region); CLEANUP_REGIONS: if (has_drawn_region) _cairo_region_fini (&drawn_region); _cairo_region_fini (&clear_region); return _cairo_surface_set_error (dst, status); } /** * _cairo_surface_composite_fixup_unbounded: * @dst: the destination surface * @src_attr: source surface attributes (from _cairo_pattern_acquire_surface()) * @src_width: width of source surface * @src_height: height of source surface * @mask_attr: mask surface attributes or %NULL if no mask * @mask_width: width of mask surface * @mask_height: height of mask surface * @src_x: @src_x from _cairo_surface_composite() * @src_y: @src_y from _cairo_surface_composite() * @mask_x: @mask_x from _cairo_surface_composite() * @mask_y: @mask_y from _cairo_surface_composite() * @dst_x: @dst_x from _cairo_surface_composite() * @dst_y: @dst_y from _cairo_surface_composite() * @width: @width from _cairo_surface_composite() * @height: @height_x from _cairo_surface_composite() * * Eeek! Too many parameters! This is a helper function to take care of fixing * up for bugs in libpixman and RENDER where, when asked to composite an * untransformed surface with an unbounded operator (like CLEAR or SOURCE) * only the region inside both the source and the mask is affected. * This function clears the region that should have been drawn but was wasn't. **/ cairo_status_t _cairo_surface_composite_fixup_unbounded (cairo_surface_t *dst, cairo_surface_attributes_t *src_attr, int src_width, int src_height, cairo_surface_attributes_t *mask_attr, int mask_width, int mask_height, int src_x, int src_y, int mask_x, int mask_y, int dst_x, int dst_y, unsigned int width, unsigned int height) { cairo_rectangle_int_t src_tmp, mask_tmp; cairo_rectangle_int_t *src_rectangle = NULL; cairo_rectangle_int_t *mask_rectangle = NULL; if (dst->status) return dst->status; assert (! dst->is_snapshot); /* The RENDER/libpixman operators are clipped to the bounds of the untransformed, * non-repeating sources and masks. Other sources and masks can be ignored. */ if (_cairo_matrix_is_integer_translation (&src_attr->matrix, NULL, NULL) && src_attr->extend == CAIRO_EXTEND_NONE) { src_tmp.x = (dst_x - (src_x + src_attr->x_offset)); src_tmp.y = (dst_y - (src_y + src_attr->y_offset)); src_tmp.width = src_width; src_tmp.height = src_height; src_rectangle = &src_tmp; } if (mask_attr && _cairo_matrix_is_integer_translation (&mask_attr->matrix, NULL, NULL) && mask_attr->extend == CAIRO_EXTEND_NONE) { mask_tmp.x = (dst_x - (mask_x + mask_attr->x_offset)); mask_tmp.y = (dst_y - (mask_y + mask_attr->y_offset)); mask_tmp.width = mask_width; mask_tmp.height = mask_height; mask_rectangle = &mask_tmp; } return _cairo_surface_composite_fixup_unbounded_internal (dst, src_rectangle, mask_rectangle, dst_x, dst_y, width, height); } /** * _cairo_surface_composite_shape_fixup_unbounded: * @dst: the destination surface * @src_attr: source surface attributes (from _cairo_pattern_acquire_surface()) * @src_width: width of source surface * @src_height: height of source surface * @mask_width: width of mask surface * @mask_height: height of mask surface * @src_x: @src_x from _cairo_surface_composite() * @src_y: @src_y from _cairo_surface_composite() * @mask_x: @mask_x from _cairo_surface_composite() * @mask_y: @mask_y from _cairo_surface_composite() * @dst_x: @dst_x from _cairo_surface_composite() * @dst_y: @dst_y from _cairo_surface_composite() * @width: @width from _cairo_surface_composite() * @height: @height_x from _cairo_surface_composite() * * Like _cairo_surface_composite_fixup_unbounded(), but instead of * handling the case where we have a source pattern and a mask * pattern, handle the case where we are compositing a source pattern * using a mask we create ourselves, as in * _cairo_surface_composite_glyphs() or _cairo_surface_composite_trapezoids() **/ cairo_status_t _cairo_surface_composite_shape_fixup_unbounded (cairo_surface_t *dst, cairo_surface_attributes_t *src_attr, int src_width, int src_height, int mask_width, int mask_height, int src_x, int src_y, int mask_x, int mask_y, int dst_x, int dst_y, unsigned int width, unsigned int height) { cairo_rectangle_int_t src_tmp, mask_tmp; cairo_rectangle_int_t *src_rectangle = NULL; cairo_rectangle_int_t *mask_rectangle = NULL; if (dst->status) return dst->status; assert (! dst->is_snapshot); /* The RENDER/libpixman operators are clipped to the bounds of the untransformed, * non-repeating sources and masks. Other sources and masks can be ignored. */ if (_cairo_matrix_is_integer_translation (&src_attr->matrix, NULL, NULL) && src_attr->extend == CAIRO_EXTEND_NONE) { src_tmp.x = (dst_x - (src_x + src_attr->x_offset)); src_tmp.y = (dst_y - (src_y + src_attr->y_offset)); src_tmp.width = src_width; src_tmp.height = src_height; src_rectangle = &src_tmp; } mask_tmp.x = dst_x - mask_x; mask_tmp.y = dst_y - mask_y; mask_tmp.width = mask_width; mask_tmp.height = mask_height; mask_rectangle = &mask_tmp; return _cairo_surface_composite_fixup_unbounded_internal (dst, src_rectangle, mask_rectangle, dst_x, dst_y, width, height); } /** * _cairo_surface_copy_pattern_for_destination * @pattern: the pattern to copy * @destination: the destination surface for which the pattern is being copied * @pattern_copy: the location to hold the copy * * Copies the given pattern, taking into account device scale and offsets * of the destination surface. */ static cairo_status_t _cairo_surface_copy_pattern_for_destination (const cairo_pattern_t **pattern, cairo_surface_t *destination, cairo_pattern_t *pattern_copy) { cairo_status_t status; if (! _cairo_surface_has_device_transform (destination)) return CAIRO_STATUS_SUCCESS; status = _cairo_pattern_init_copy (pattern_copy, *pattern); if (status) return status; _cairo_pattern_transform (pattern_copy, &destination->device_transform_inverse); *pattern = pattern_copy; return CAIRO_STATUS_SUCCESS; } /** * _cairo_surface_set_resolution * @surface: the surface * @x_res: x resolution, in dpi * @y_res: y resolution, in dpi * * Set the actual surface resolution of @surface to the given x and y DPI. * Mainly used for correctly computing the scale factor when fallback * rendering needs to take place in the paginated surface. */ void _cairo_surface_set_resolution (cairo_surface_t *surface, double x_res, double y_res) { if (surface->status) return; surface->x_resolution = x_res; surface->y_resolution = y_res; } cairo_surface_t * _cairo_surface_create_in_error (cairo_status_t status) { switch (status) { case CAIRO_STATUS_NO_MEMORY: return (cairo_surface_t *) &_cairo_surface_nil; case CAIRO_STATUS_INVALID_CONTENT: return (cairo_surface_t *) &_cairo_surface_nil_invalid_content; case CAIRO_STATUS_INVALID_FORMAT: return (cairo_surface_t *) &_cairo_surface_nil_invalid_format; case CAIRO_STATUS_INVALID_VISUAL: return (cairo_surface_t *) &_cairo_surface_nil_invalid_visual; case CAIRO_STATUS_READ_ERROR: return (cairo_surface_t *) &_cairo_surface_nil_read_error; case CAIRO_STATUS_WRITE_ERROR: return (cairo_surface_t *) &_cairo_surface_nil_write_error; case CAIRO_STATUS_FILE_NOT_FOUND: return (cairo_surface_t *) &_cairo_surface_nil_file_not_found; case CAIRO_STATUS_TEMP_FILE_ERROR: return (cairo_surface_t *) &_cairo_surface_nil_temp_file_error; case CAIRO_STATUS_INVALID_STRIDE: return (cairo_surface_t *) &_cairo_surface_nil_invalid_stride; case CAIRO_STATUS_SUCCESS: ASSERT_NOT_REACHED; /* fall-through */ case CAIRO_STATUS_INVALID_RESTORE: case CAIRO_STATUS_INVALID_POP_GROUP: case CAIRO_STATUS_NO_CURRENT_POINT: case CAIRO_STATUS_INVALID_MATRIX: case CAIRO_STATUS_INVALID_STATUS: case CAIRO_STATUS_NULL_POINTER: case CAIRO_STATUS_INVALID_STRING: case CAIRO_STATUS_INVALID_PATH_DATA: case CAIRO_STATUS_SURFACE_FINISHED: case CAIRO_STATUS_SURFACE_TYPE_MISMATCH: case CAIRO_STATUS_PATTERN_TYPE_MISMATCH: case CAIRO_STATUS_INVALID_DASH: case CAIRO_STATUS_INVALID_DSC_COMMENT: case CAIRO_STATUS_INVALID_INDEX: case CAIRO_STATUS_CLIP_NOT_REPRESENTABLE: case CAIRO_STATUS_FONT_TYPE_MISMATCH: case CAIRO_STATUS_USER_FONT_IMMUTABLE: case CAIRO_STATUS_USER_FONT_ERROR: case CAIRO_STATUS_NEGATIVE_COUNT: case CAIRO_STATUS_INVALID_CLUSTERS: case CAIRO_STATUS_INVALID_SLANT: case CAIRO_STATUS_INVALID_WEIGHT: default: _cairo_error_throw (CAIRO_STATUS_NO_MEMORY); return (cairo_surface_t *) &_cairo_surface_nil; } } /* LocalWords: rasterized */