summaryrefslogtreecommitdiff
path: root/libs/cairo-1.16.0/src/cairo-surface-subsurface.c
diff options
context:
space:
mode:
Diffstat (limited to 'libs/cairo-1.16.0/src/cairo-surface-subsurface.c')
-rw-r--r--libs/cairo-1.16.0/src/cairo-surface-subsurface.c589
1 files changed, 589 insertions, 0 deletions
diff --git a/libs/cairo-1.16.0/src/cairo-surface-subsurface.c b/libs/cairo-1.16.0/src/cairo-surface-subsurface.c
new file mode 100644
index 0000000..b2a10e9
--- /dev/null
+++ b/libs/cairo-1.16.0/src/cairo-surface-subsurface.c
@@ -0,0 +1,589 @@
+/* cairo - a vector graphics library with display and print output
+ *
+ * Copyright © 2009 Intel Corporation
+ *
+ * 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 Intel Corporation.
+ *
+ * Contributor(s):
+ * Chris Wilson <chris@chris-wilson.co.uk>
+ */
+
+#include "cairoint.h"
+
+#include "cairo-clip-inline.h"
+#include "cairo-error-private.h"
+#include "cairo-image-surface-private.h"
+#include "cairo-recording-surface-private.h"
+#include "cairo-surface-offset-private.h"
+#include "cairo-surface-snapshot-private.h"
+#include "cairo-surface-subsurface-private.h"
+
+static const cairo_surface_backend_t _cairo_surface_subsurface_backend;
+
+static cairo_status_t
+_cairo_surface_subsurface_finish (void *abstract_surface)
+{
+ cairo_surface_subsurface_t *surface = abstract_surface;
+
+ cairo_surface_destroy (surface->target);
+ cairo_surface_destroy (surface->snapshot);
+
+ return CAIRO_STATUS_SUCCESS;
+}
+
+static cairo_surface_t *
+_cairo_surface_subsurface_create_similar (void *other,
+ cairo_content_t content,
+ int width, int height)
+{
+ cairo_surface_subsurface_t *surface = other;
+
+ if (surface->target->backend->create_similar == NULL)
+ return NULL;
+
+ return surface->target->backend->create_similar (surface->target, content, width, height);
+}
+
+static cairo_surface_t *
+_cairo_surface_subsurface_create_similar_image (void *other,
+ cairo_format_t format,
+ int width, int height)
+{
+ cairo_surface_subsurface_t *surface = other;
+
+ if (surface->target->backend->create_similar_image == NULL)
+ return NULL;
+
+ return surface->target->backend->create_similar_image (surface->target,
+ format,
+ width, height);
+}
+
+static cairo_image_surface_t *
+_cairo_surface_subsurface_map_to_image (void *abstract_surface,
+ const cairo_rectangle_int_t *extents)
+{
+ cairo_surface_subsurface_t *surface = abstract_surface;
+ cairo_rectangle_int_t target_extents;
+
+ target_extents.x = extents->x + surface->extents.x;
+ target_extents.y = extents->y + surface->extents.y;
+ target_extents.width = extents->width;
+ target_extents.height = extents->height;
+
+ return _cairo_surface_map_to_image (surface->target, &target_extents);
+}
+
+static cairo_int_status_t
+_cairo_surface_subsurface_unmap_image (void *abstract_surface,
+ cairo_image_surface_t *image)
+{
+ cairo_surface_subsurface_t *surface = abstract_surface;
+ return _cairo_surface_unmap_image (surface->target, image);
+}
+
+static cairo_int_status_t
+_cairo_surface_subsurface_paint (void *abstract_surface,
+ cairo_operator_t op,
+ const cairo_pattern_t *source,
+ const cairo_clip_t *clip)
+{
+ cairo_surface_subsurface_t *surface = abstract_surface;
+ cairo_rectangle_int_t rect = { 0, 0, surface->extents.width, surface->extents.height };
+ cairo_status_t status;
+ cairo_clip_t *target_clip;
+
+ target_clip = _cairo_clip_copy_intersect_rectangle (clip, &rect);
+ status = _cairo_surface_offset_paint (surface->target,
+ -surface->extents.x, -surface->extents.y,
+ op, source, target_clip);
+ _cairo_clip_destroy (target_clip);
+ return status;
+}
+
+static cairo_int_status_t
+_cairo_surface_subsurface_mask (void *abstract_surface,
+ cairo_operator_t op,
+ const cairo_pattern_t *source,
+ const cairo_pattern_t *mask,
+ const cairo_clip_t *clip)
+{
+ cairo_surface_subsurface_t *surface = abstract_surface;
+ cairo_rectangle_int_t rect = { 0, 0, surface->extents.width, surface->extents.height };
+ cairo_status_t status;
+ cairo_clip_t *target_clip;
+
+ target_clip = _cairo_clip_copy_intersect_rectangle (clip, &rect);
+ status = _cairo_surface_offset_mask (surface->target,
+ -surface->extents.x, -surface->extents.y,
+ op, source, mask, target_clip);
+ _cairo_clip_destroy (target_clip);
+ return status;
+}
+
+static cairo_int_status_t
+_cairo_surface_subsurface_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_surface_subsurface_t *surface = abstract_surface;
+ cairo_rectangle_int_t rect = { 0, 0, surface->extents.width, surface->extents.height };
+ cairo_status_t status;
+ cairo_clip_t *target_clip;
+
+ target_clip = _cairo_clip_copy_intersect_rectangle (clip, &rect);
+ status = _cairo_surface_offset_fill (surface->target,
+ -surface->extents.x, -surface->extents.y,
+ op, source, path, fill_rule, tolerance, antialias,
+ target_clip);
+ _cairo_clip_destroy (target_clip);
+ return status;
+}
+
+static cairo_int_status_t
+_cairo_surface_subsurface_stroke (void *abstract_surface,
+ cairo_operator_t op,
+ const cairo_pattern_t *source,
+ const cairo_path_fixed_t *path,
+ const cairo_stroke_style_t *stroke_style,
+ const cairo_matrix_t *ctm,
+ const cairo_matrix_t *ctm_inverse,
+ double tolerance,
+ cairo_antialias_t antialias,
+ const cairo_clip_t *clip)
+{
+ cairo_surface_subsurface_t *surface = abstract_surface;
+ cairo_rectangle_int_t rect = { 0, 0, surface->extents.width, surface->extents.height };
+ cairo_status_t status;
+ cairo_clip_t *target_clip;
+
+ target_clip = _cairo_clip_copy_intersect_rectangle (clip, &rect);
+ status = _cairo_surface_offset_stroke (surface->target,
+ -surface->extents.x, -surface->extents.y,
+ op, source, path, stroke_style, ctm, ctm_inverse,
+ tolerance, antialias,
+ target_clip);
+ _cairo_clip_destroy (target_clip);
+ return status;
+}
+
+static cairo_int_status_t
+_cairo_surface_subsurface_glyphs (void *abstract_surface,
+ cairo_operator_t op,
+ const cairo_pattern_t *source,
+ cairo_glyph_t *glyphs,
+ int num_glyphs,
+ cairo_scaled_font_t *scaled_font,
+ const cairo_clip_t *clip)
+{
+ cairo_surface_subsurface_t *surface = abstract_surface;
+ cairo_rectangle_int_t rect = { 0, 0, surface->extents.width, surface->extents.height };
+ cairo_status_t status;
+ cairo_clip_t *target_clip;
+
+ target_clip = _cairo_clip_copy_intersect_rectangle (clip, &rect);
+ status = _cairo_surface_offset_glyphs (surface->target,
+ -surface->extents.x, -surface->extents.y,
+ op, source,
+ scaled_font, glyphs, num_glyphs,
+ target_clip);
+ _cairo_clip_destroy (target_clip);
+ return status;
+}
+
+static cairo_status_t
+_cairo_surface_subsurface_flush (void *abstract_surface, unsigned flags)
+{
+ cairo_surface_subsurface_t *surface = abstract_surface;
+ return _cairo_surface_flush (surface->target, flags);
+}
+
+static cairo_status_t
+_cairo_surface_subsurface_mark_dirty (void *abstract_surface,
+ int x, int y,
+ int width, int height)
+{
+ cairo_surface_subsurface_t *surface = abstract_surface;
+ cairo_status_t status;
+
+ status = CAIRO_STATUS_SUCCESS;
+ if (surface->target->backend->mark_dirty_rectangle != NULL) {
+ cairo_rectangle_int_t rect, extents;
+
+ rect.x = x;
+ rect.y = y;
+ rect.width = width;
+ rect.height = height;
+
+ extents.x = extents.y = 0;
+ extents.width = surface->extents.width;
+ extents.height = surface->extents.height;
+
+ if (_cairo_rectangle_intersect (&rect, &extents)) {
+ status = surface->target->backend->mark_dirty_rectangle (surface->target,
+ rect.x + surface->extents.x,
+ rect.y + surface->extents.y,
+ rect.width, rect.height);
+ }
+ }
+
+ return status;
+}
+
+static cairo_bool_t
+_cairo_surface_subsurface_get_extents (void *abstract_surface,
+ cairo_rectangle_int_t *extents)
+{
+ cairo_surface_subsurface_t *surface = abstract_surface;
+
+ extents->x = 0;
+ extents->y = 0;
+ extents->width = surface->extents.width;
+ extents->height = surface->extents.height;
+
+ return TRUE;
+}
+
+static void
+_cairo_surface_subsurface_get_font_options (void *abstract_surface,
+ cairo_font_options_t *options)
+{
+ cairo_surface_subsurface_t *surface = abstract_surface;
+
+ if (surface->target->backend->get_font_options != NULL)
+ surface->target->backend->get_font_options (surface->target, options);
+}
+
+static cairo_surface_t *
+_cairo_surface_subsurface_source (void *abstract_surface,
+ cairo_rectangle_int_t *extents)
+{
+ cairo_surface_subsurface_t *surface = abstract_surface;
+ cairo_surface_t *source;
+
+ source = _cairo_surface_get_source (surface->target, extents);
+ if (extents)
+ *extents = surface->extents;
+
+ return source;
+}
+
+static cairo_status_t
+_cairo_surface_subsurface_acquire_source_image (void *abstract_surface,
+ cairo_image_surface_t **image_out,
+ void **extra_out)
+{
+ cairo_surface_subsurface_t *surface = abstract_surface;
+ cairo_surface_pattern_t pattern;
+ cairo_surface_t *image;
+ cairo_status_t status;
+
+ image = _cairo_image_surface_create_with_content (surface->base.content,
+ surface->extents.width,
+ surface->extents.height);
+ if (unlikely (image->status))
+ return image->status;
+
+ _cairo_pattern_init_for_surface (&pattern, surface->target);
+ cairo_matrix_init_translate (&pattern.base.matrix,
+ surface->extents.x,
+ surface->extents.y);
+ pattern.base.filter = CAIRO_FILTER_NEAREST;
+ status = _cairo_surface_paint (image,
+ CAIRO_OPERATOR_SOURCE,
+ &pattern.base, NULL);
+ _cairo_pattern_fini (&pattern.base);
+ if (unlikely (status)) {
+ cairo_surface_destroy (image);
+ return status;
+ }
+
+ *image_out = (cairo_image_surface_t *)image;
+ *extra_out = NULL;
+ return CAIRO_STATUS_SUCCESS;
+}
+
+static void
+_cairo_surface_subsurface_release_source_image (void *abstract_surface,
+ cairo_image_surface_t *image,
+ void *abstract_extra)
+{
+ cairo_surface_destroy (&image->base);
+}
+
+static cairo_surface_t *
+_cairo_surface_subsurface_snapshot (void *abstract_surface)
+{
+ cairo_surface_subsurface_t *surface = abstract_surface;
+ cairo_surface_pattern_t pattern;
+ cairo_surface_t *clone;
+ cairo_status_t status;
+
+ TRACE ((stderr, "%s: target=%d\n", __FUNCTION__, surface->target->unique_id));
+
+ clone = _cairo_surface_create_scratch (surface->target,
+ surface->target->content,
+ surface->extents.width,
+ surface->extents.height,
+ NULL);
+ if (unlikely (clone->status))
+ return clone;
+
+ _cairo_pattern_init_for_surface (&pattern, surface->target);
+ cairo_matrix_init_translate (&pattern.base.matrix,
+ surface->extents.x, surface->extents.y);
+ pattern.base.filter = CAIRO_FILTER_NEAREST;
+ status = _cairo_surface_paint (clone,
+ CAIRO_OPERATOR_SOURCE,
+ &pattern.base, NULL);
+ _cairo_pattern_fini (&pattern.base);
+
+ if (unlikely (status)) {
+ cairo_surface_destroy (clone);
+ clone = _cairo_surface_create_in_error (status);
+ }
+
+ return clone;
+}
+
+static cairo_t *
+_cairo_surface_subsurface_create_context(void *target)
+{
+ cairo_surface_subsurface_t *surface = target;
+ return surface->target->backend->create_context (&surface->base);
+}
+
+static const cairo_surface_backend_t _cairo_surface_subsurface_backend = {
+ CAIRO_SURFACE_TYPE_SUBSURFACE,
+ _cairo_surface_subsurface_finish,
+
+ _cairo_surface_subsurface_create_context,
+
+ _cairo_surface_subsurface_create_similar,
+ _cairo_surface_subsurface_create_similar_image,
+ _cairo_surface_subsurface_map_to_image,
+ _cairo_surface_subsurface_unmap_image,
+
+ _cairo_surface_subsurface_source,
+ _cairo_surface_subsurface_acquire_source_image,
+ _cairo_surface_subsurface_release_source_image,
+ _cairo_surface_subsurface_snapshot,
+
+ NULL, /* copy_page */
+ NULL, /* show_page */
+
+ _cairo_surface_subsurface_get_extents,
+ _cairo_surface_subsurface_get_font_options,
+
+ _cairo_surface_subsurface_flush,
+ _cairo_surface_subsurface_mark_dirty,
+
+ _cairo_surface_subsurface_paint,
+ _cairo_surface_subsurface_mask,
+ _cairo_surface_subsurface_stroke,
+ _cairo_surface_subsurface_fill,
+ NULL, /* fill/stroke */
+ _cairo_surface_subsurface_glyphs,
+};
+
+/**
+ * cairo_surface_create_for_rectangle:
+ * @target: an existing surface for which the sub-surface will point to
+ * @x: the x-origin of the sub-surface from the top-left of the target surface (in device-space units)
+ * @y: the y-origin of the sub-surface from the top-left of the target surface (in device-space units)
+ * @width: width of the sub-surface (in device-space units)
+ * @height: height of the sub-surface (in device-space units)
+ *
+ * Create a new surface that is a rectangle within the target surface.
+ * All operations drawn to this surface are then clipped and translated
+ * onto the target surface. Nothing drawn via this sub-surface outside of
+ * its bounds is drawn onto the target surface, making this a useful method
+ * for passing constrained child surfaces to library routines that draw
+ * directly onto the parent surface, i.e. with no further backend allocations,
+ * double buffering or copies.
+ *
+ * <note><para>The semantics of subsurfaces have not been finalized yet
+ * unless the rectangle is in full device units, is contained within
+ * the extents of the target surface, and the target or subsurface's
+ * device transforms are not changed.</para></note>
+ *
+ * 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.
+ *
+ * Since: 1.10
+ **/
+cairo_surface_t *
+cairo_surface_create_for_rectangle (cairo_surface_t *target,
+ double x, double y,
+ double width, double height)
+{
+ cairo_surface_subsurface_t *surface;
+
+ if (unlikely (width < 0 || height < 0))
+ return _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_INVALID_SIZE));
+
+ if (unlikely (target->status))
+ return _cairo_surface_create_in_error (target->status);
+ if (unlikely (target->finished))
+ return _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_SURFACE_FINISHED));
+
+ surface = _cairo_malloc (sizeof (cairo_surface_subsurface_t));
+ if (unlikely (surface == NULL))
+ return _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_NO_MEMORY));
+
+ x *= target->device_transform.xx;
+ y *= target->device_transform.yy;
+
+ width *= target->device_transform.xx;
+ height *= target->device_transform.yy;
+
+ x += target->device_transform.x0;
+ y += target->device_transform.y0;
+
+ _cairo_surface_init (&surface->base,
+ &_cairo_surface_subsurface_backend,
+ NULL, /* device */
+ target->content,
+ target->is_vector);
+
+ /* XXX forced integer alignment */
+ surface->extents.x = ceil (x);
+ surface->extents.y = ceil (y);
+ surface->extents.width = floor (x + width) - surface->extents.x;
+ surface->extents.height = floor (y + height) - surface->extents.y;
+ if ((surface->extents.width | surface->extents.height) < 0)
+ surface->extents.width = surface->extents.height = 0;
+
+ if (target->backend->type == CAIRO_SURFACE_TYPE_SUBSURFACE) {
+ /* Maintain subsurfaces as 1-depth */
+ cairo_surface_subsurface_t *sub = (cairo_surface_subsurface_t *) target;
+ surface->extents.x += sub->extents.x;
+ surface->extents.y += sub->extents.y;
+ target = sub->target;
+ }
+
+ surface->target = cairo_surface_reference (target);
+ surface->base.type = surface->target->type;
+
+ surface->snapshot = NULL;
+
+ cairo_surface_set_device_scale (&surface->base,
+ target->device_transform.xx,
+ target->device_transform.yy);
+
+ return &surface->base;
+}
+
+cairo_surface_t *
+_cairo_surface_create_for_rectangle_int (cairo_surface_t *target,
+ const cairo_rectangle_int_t *extents)
+{
+ cairo_surface_subsurface_t *surface;
+
+ if (unlikely (target->status))
+ return _cairo_surface_create_in_error (target->status);
+ if (unlikely (target->finished))
+ return _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_SURFACE_FINISHED));
+
+ assert (target->backend->type != CAIRO_SURFACE_TYPE_SUBSURFACE);
+
+ surface = _cairo_malloc (sizeof (cairo_surface_subsurface_t));
+ if (unlikely (surface == NULL))
+ return _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_NO_MEMORY));
+
+ _cairo_surface_init (&surface->base,
+ &_cairo_surface_subsurface_backend,
+ NULL, /* device */
+ target->content,
+ target->is_vector);
+
+ surface->extents = *extents;
+ surface->extents.x *= target->device_transform.xx;
+ surface->extents.y *= target->device_transform.yy;
+ surface->extents.width *= target->device_transform.xx;
+ surface->extents.height *= target->device_transform.yy;
+ surface->extents.x += target->device_transform.x0;
+ surface->extents.y += target->device_transform.y0;
+
+ surface->target = cairo_surface_reference (target);
+ surface->base.type = surface->target->type;
+
+ surface->snapshot = NULL;
+
+ cairo_surface_set_device_scale (&surface->base,
+ target->device_transform.xx,
+ target->device_transform.yy);
+
+ return &surface->base;
+}
+/* XXX observe mark-dirty */
+
+static void
+_cairo_surface_subsurface_detach_snapshot (cairo_surface_t *surface)
+{
+ cairo_surface_subsurface_t *ss = (cairo_surface_subsurface_t *) surface;
+
+ TRACE ((stderr, "%s: target=%d\n", __FUNCTION__, ss->target->unique_id));
+
+ cairo_surface_destroy (ss->snapshot);
+ ss->snapshot = NULL;
+}
+
+void
+_cairo_surface_subsurface_set_snapshot (cairo_surface_t *surface,
+ cairo_surface_t *snapshot)
+{
+ cairo_surface_subsurface_t *ss = (cairo_surface_subsurface_t *) surface;
+
+ TRACE ((stderr, "%s: target=%d, snapshot=%d\n", __FUNCTION__,
+ ss->target->unique_id, snapshot->unique_id));
+
+ /* FIXME: attaching the subsurface as a snapshot to its target creates
+ * a reference cycle. Let's make this call as a no-op until that bug
+ * is fixed.
+ */
+ return;
+
+ if (ss->snapshot)
+ _cairo_surface_detach_snapshot (ss->snapshot);
+
+ ss->snapshot = cairo_surface_reference (snapshot);
+
+ _cairo_surface_attach_snapshot (ss->target, &ss->base,
+ _cairo_surface_subsurface_detach_snapshot);
+}