/* cairo - a vector graphics library with display and print output * * 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., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA * You should have received a copy of the MPL along with this library * in the file COPYING-MPL-1.1 * * The contents of this file are subject to the Mozilla Public License * Version 1.1 (the "License"); you may not use this file except in * compliance with the License. You may obtain a copy of the License at * http://www.mozilla.org/MPL/ * * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY * OF ANY KIND, either express or implied. See the LGPL or the MPL for * the specific language governing rights and limitations. * * The Original Code is the cairo graphics library. * * The Initial Developer of the Original Code is Red Hat, Inc. * * Contributor(s): * Carl D. Worth */ #ifndef CAIRO_PATTERN_PRIVATE_H #define CAIRO_PATTERN_PRIVATE_H #include "cairo-error-private.h" #include "cairo-types-private.h" #include "cairo-list-private.h" #include "cairo-surface-private.h" #include /* FILE* */ #define CAIRO_MAX_SIGMA 4 /* 4 defined in skia */ #define CAIRO_DEFAULT_SIGMA 0 #define CAIRO_MAX_BLUR 64 #define CAIRO_MIN_SHRINK_SIZE 32 #define CAIRO_MIN_LINE_WIDTH 1.0 CAIRO_BEGIN_DECLS typedef struct _cairo_pattern_observer cairo_pattern_observer_t; enum { CAIRO_PATTERN_NOTIFY_MATRIX = 0x1, CAIRO_PATTERN_NOTIFY_FILTER = 0x2, CAIRO_PATTERN_NOTIFY_EXTEND = 0x4, CAIRO_PATTERN_NOTIFY_OPACITY = 0x9, }; struct _cairo_pattern_observer { void (*notify) (cairo_pattern_observer_t *, cairo_pattern_t *pattern, unsigned int flags); cairo_list_t link; }; struct _cairo_pattern { cairo_reference_count_t ref_count; cairo_status_t status; cairo_user_data_array_t user_data; cairo_list_t observers; cairo_pattern_type_t type; cairo_filter_t filter; cairo_extend_t extend; cairo_bool_t has_component_alpha; cairo_matrix_t matrix; double opacity; /* we use this to shrink image before we apply blur */ unsigned int shrink_factor_x; unsigned int shrink_factor_y; unsigned int x_radius; unsigned int y_radius; double x_sigma; double y_sigma; double *convolution_matrix; cairo_bool_t convolution_changed; /* FIXME: I don't like to attach shadow to pattern. However, * cairo does not have a way to pass shadow info to backend. * so we attach shadow info in pattern */ cairo_shadow_t shadow; }; struct _cairo_solid_pattern { cairo_pattern_t base; cairo_color_t color; }; typedef struct _cairo_surface_pattern { cairo_pattern_t base; cairo_surface_t *surface; } cairo_surface_pattern_t; typedef struct _cairo_gradient_stop { double offset; cairo_color_stop_t color; } cairo_gradient_stop_t; typedef struct _cairo_gradient_pattern { cairo_pattern_t base; unsigned int n_stops; unsigned int stops_size; cairo_gradient_stop_t *stops; cairo_gradient_stop_t stops_embedded[2]; } cairo_gradient_pattern_t; typedef struct _cairo_linear_pattern { cairo_gradient_pattern_t base; cairo_point_double_t pd1; cairo_point_double_t pd2; } cairo_linear_pattern_t; typedef struct _cairo_radial_pattern { cairo_gradient_pattern_t base; cairo_circle_double_t cd1; cairo_circle_double_t cd2; } cairo_radial_pattern_t; typedef union { cairo_gradient_pattern_t base; cairo_linear_pattern_t linear; cairo_radial_pattern_t radial; } cairo_gradient_pattern_union_t; /* * A mesh patch is a tensor-product patch (bicubic Bezier surface * patch). It has 16 control points. Each set of 4 points along the * sides of the 4x4 grid of control points is a Bezier curve that * defines one side of the patch. A color is assigned to each * corner. The inner 4 points provide additional control over the * shape and the color mapping. * * Cairo uses the same convention as the PDF Reference for numbering * the points and side of the patch. * * * Side 1 * * p[0][3] p[1][3] p[2][3] p[3][3] * Side 0 p[0][2] p[1][2] p[2][2] p[3][2] Side 2 * p[0][1] p[1][1] p[2][1] p[3][1] * p[0][0] p[1][0] p[2][0] p[3][0] * * Side 3 * * * Point Color * ------------------------- * points[0][0] colors[0] * points[0][3] colors[1] * points[3][3] colors[2] * points[3][0] colors[3] */ typedef struct _cairo_mesh_patch { cairo_point_double_t points[4][4]; cairo_color_t colors[4]; } cairo_mesh_patch_t; typedef struct _cairo_mesh_pattern { cairo_pattern_t base; cairo_array_t patches; cairo_mesh_patch_t *current_patch; int current_side; cairo_bool_t has_control_point[4]; cairo_bool_t has_color[4]; } cairo_mesh_pattern_t; typedef struct _cairo_raster_source_pattern { cairo_pattern_t base; cairo_content_t content; cairo_rectangle_int_t extents; cairo_raster_source_acquire_func_t acquire; cairo_raster_source_release_func_t release; cairo_raster_source_snapshot_func_t snapshot; cairo_raster_source_copy_func_t copy; cairo_raster_source_finish_func_t finish; /* an explicit pre-allocated member in preference to the general user-data */ void *user_data; } cairo_raster_source_pattern_t; typedef union { cairo_pattern_t base; cairo_solid_pattern_t solid; cairo_surface_pattern_t surface; cairo_gradient_pattern_union_t gradient; cairo_mesh_pattern_t mesh; cairo_raster_source_pattern_t raster_source; } cairo_pattern_union_t; /* cairo-pattern.c */ cairo_private cairo_pattern_t * _cairo_pattern_create_in_error (cairo_status_t status); cairo_private cairo_status_t _cairo_pattern_create_copy (cairo_pattern_t **pattern, const cairo_pattern_t *other); cairo_private void _cairo_pattern_init (cairo_pattern_t *pattern, cairo_pattern_type_t type); cairo_private cairo_status_t _cairo_pattern_init_copy (cairo_pattern_t *pattern, const cairo_pattern_t *other); cairo_private void _cairo_pattern_init_static_copy (cairo_pattern_t *pattern, const cairo_pattern_t *other); cairo_private cairo_status_t _cairo_pattern_init_snapshot (cairo_pattern_t *pattern, const cairo_pattern_t *other); cairo_private void _cairo_pattern_init_solid (cairo_solid_pattern_t *pattern, const cairo_color_t *color); cairo_private void _cairo_pattern_init_for_surface (cairo_surface_pattern_t *pattern, cairo_surface_t *surface); cairo_private void _cairo_pattern_fini (cairo_pattern_t *pattern); cairo_private cairo_pattern_t * _cairo_pattern_create_solid (const cairo_color_t *color); cairo_private void _cairo_pattern_transform (cairo_pattern_t *pattern, const cairo_matrix_t *ctm_inverse); cairo_private void _cairo_pattern_pretransform (cairo_pattern_t *pattern, const cairo_matrix_t *ctm); cairo_private cairo_bool_t _cairo_pattern_is_opaque_solid (const cairo_pattern_t *pattern); cairo_private cairo_bool_t _cairo_pattern_is_opaque (const cairo_pattern_t *pattern, const cairo_rectangle_int_t *extents); cairo_private cairo_bool_t _cairo_pattern_is_clear (const cairo_pattern_t *pattern); cairo_private cairo_bool_t _cairo_gradient_pattern_is_solid (const cairo_gradient_pattern_t *gradient, const cairo_rectangle_int_t *extents, cairo_color_t *color); cairo_private void _cairo_gradient_pattern_fit_to_range (const cairo_gradient_pattern_t *gradient, double max_value, cairo_matrix_t *out_matrix, cairo_circle_double_t out_circle[2]); cairo_private cairo_bool_t _cairo_radial_pattern_focus_is_inside (const cairo_radial_pattern_t *radial); cairo_private void _cairo_gradient_pattern_box_to_parameter (const cairo_gradient_pattern_t *gradient, double x0, double y0, double x1, double y1, double tolerance, double out_range[2]); cairo_private void _cairo_gradient_pattern_interpolate (const cairo_gradient_pattern_t *gradient, double t, cairo_circle_double_t *out_circle); cairo_private void _cairo_pattern_alpha_range (const cairo_pattern_t *pattern, double *out_min, double *out_max); cairo_private cairo_bool_t _cairo_mesh_pattern_coord_box (const cairo_mesh_pattern_t *mesh, double *out_xmin, double *out_ymin, double *out_xmax, double *out_ymax); cairo_private void _cairo_pattern_sampled_area (const cairo_pattern_t *pattern, const cairo_rectangle_int_t *extents, cairo_rectangle_int_t *sample); cairo_private void _cairo_pattern_get_extents (const cairo_pattern_t *pattern, cairo_rectangle_int_t *extents); cairo_private void _cairo_pattern_get_exact_extents (const cairo_pattern_t *pattern, cairo_rectangle_t *extents); cairo_private cairo_int_status_t _cairo_pattern_get_ink_extents (const cairo_pattern_t *pattern, cairo_rectangle_int_t *extents); cairo_private unsigned long _cairo_pattern_hash (const cairo_pattern_t *pattern); cairo_private unsigned long _cairo_linear_pattern_hash (unsigned long hash, const cairo_linear_pattern_t *linear); cairo_private unsigned long _cairo_radial_pattern_hash (unsigned long hash, const cairo_radial_pattern_t *radial); cairo_private cairo_bool_t _cairo_linear_pattern_equal (const cairo_linear_pattern_t *a, const cairo_linear_pattern_t *b); cairo_private unsigned long _cairo_pattern_size (const cairo_pattern_t *pattern); cairo_private cairo_bool_t _cairo_radial_pattern_equal (const cairo_radial_pattern_t *a, const cairo_radial_pattern_t *b); cairo_private cairo_bool_t _cairo_pattern_equal (const cairo_pattern_t *a, const cairo_pattern_t *b); cairo_private cairo_filter_t _cairo_pattern_analyze_filter (const cairo_pattern_t *pattern); /* cairo-mesh-pattern-rasterizer.c */ cairo_private void _cairo_mesh_pattern_rasterize (const cairo_mesh_pattern_t *mesh, void *data, int width, int height, int stride, double x_offset, double y_offset); cairo_private cairo_surface_t * _cairo_raster_source_pattern_acquire (const cairo_pattern_t *abstract_pattern, cairo_surface_t *target, const cairo_rectangle_int_t *extents); cairo_private void _cairo_raster_source_pattern_release (const cairo_pattern_t *abstract_pattern, cairo_surface_t *surface); cairo_private cairo_status_t _cairo_raster_source_pattern_snapshot (cairo_pattern_t *abstract_pattern); cairo_private cairo_status_t _cairo_raster_source_pattern_init_copy (cairo_pattern_t *pattern, const cairo_pattern_t *other); cairo_private void _cairo_raster_source_pattern_finish (cairo_pattern_t *abstract_pattern); cairo_private cairo_status_t _cairo_pattern_create_gaussian_matrix (cairo_pattern_t *pattern, double line_width); unsigned long _cairo_pattern_hash_with_hash (unsigned long hash, const cairo_pattern_t *pattern, const cairo_bool_t use_color); cairo_private void _cairo_debug_print_pattern (FILE *file, const cairo_pattern_t *pattern); CAIRO_END_DECLS #endif /* CAIRO_PATTERN_PRIVATE */