summaryrefslogtreecommitdiff
path: root/Build/source/libs/cairo/cairo-1.12.8/src/cairo-path.c
diff options
context:
space:
mode:
Diffstat (limited to 'Build/source/libs/cairo/cairo-1.12.8/src/cairo-path.c')
-rw-r--r--Build/source/libs/cairo/cairo-1.12.8/src/cairo-path.c479
1 files changed, 479 insertions, 0 deletions
diff --git a/Build/source/libs/cairo/cairo-1.12.8/src/cairo-path.c b/Build/source/libs/cairo/cairo-1.12.8/src/cairo-path.c
new file mode 100644
index 00000000000..43cd175a3c5
--- /dev/null
+++ b/Build/source/libs/cairo/cairo-1.12.8/src/cairo-path.c
@@ -0,0 +1,479 @@
+/* cairo - a vector graphics library with display and print output
+ *
+ * Copyright © 2005 Red Hat, Inc.
+ * Copyright © 2006 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 <cworth@redhat.com>
+ */
+
+#include "cairoint.h"
+
+#include "cairo-private.h"
+#include "cairo-backend-private.h"
+#include "cairo-error-private.h"
+#include "cairo-path-private.h"
+#include "cairo-path-fixed-private.h"
+
+/**
+ * SECTION:cairo-paths
+ * @Title: Paths
+ * @Short_Description: Creating paths and manipulating path data
+ *
+ * Paths are the most basic drawing tools and are primarily used to implicitly
+ * generate simple masks.
+ **/
+
+static const cairo_path_t _cairo_path_nil = { CAIRO_STATUS_NO_MEMORY, NULL, 0 };
+
+/* Closure for path interpretation. */
+typedef struct cairo_path_count {
+ int count;
+} cpc_t;
+
+static cairo_status_t
+_cpc_move_to (void *closure,
+ const cairo_point_t *point)
+{
+ cpc_t *cpc = closure;
+
+ cpc->count += 2;
+
+ return CAIRO_STATUS_SUCCESS;
+}
+
+static cairo_status_t
+_cpc_line_to (void *closure,
+ const cairo_point_t *point)
+{
+ cpc_t *cpc = closure;
+
+ cpc->count += 2;
+
+ return CAIRO_STATUS_SUCCESS;
+}
+
+static cairo_status_t
+_cpc_curve_to (void *closure,
+ const cairo_point_t *p1,
+ const cairo_point_t *p2,
+ const cairo_point_t *p3)
+{
+ cpc_t *cpc = closure;
+
+ cpc->count += 4;
+
+ return CAIRO_STATUS_SUCCESS;
+}
+
+static cairo_status_t
+_cpc_close_path (void *closure)
+{
+ cpc_t *cpc = closure;
+
+ cpc->count += 1;
+
+ return CAIRO_STATUS_SUCCESS;
+}
+
+static int
+_cairo_path_count (cairo_path_t *path,
+ cairo_path_fixed_t *path_fixed,
+ double tolerance,
+ cairo_bool_t flatten)
+{
+ cairo_status_t status;
+ cpc_t cpc;
+
+ cpc.count = 0;
+
+ if (flatten) {
+ status = _cairo_path_fixed_interpret_flat (path_fixed,
+ _cpc_move_to,
+ _cpc_line_to,
+ _cpc_close_path,
+ &cpc,
+ tolerance);
+ } else {
+ status = _cairo_path_fixed_interpret (path_fixed,
+ _cpc_move_to,
+ _cpc_line_to,
+ _cpc_curve_to,
+ _cpc_close_path,
+ &cpc);
+ }
+
+ if (unlikely (status))
+ return -1;
+
+ return cpc.count;
+}
+
+/* Closure for path interpretation. */
+typedef struct cairo_path_populate {
+ cairo_path_data_t *data;
+ cairo_t *cr;
+} cpp_t;
+
+static cairo_status_t
+_cpp_move_to (void *closure,
+ const cairo_point_t *point)
+{
+ cpp_t *cpp = closure;
+ cairo_path_data_t *data = cpp->data;
+ double x, y;
+
+ x = _cairo_fixed_to_double (point->x);
+ y = _cairo_fixed_to_double (point->y);
+
+ _cairo_backend_to_user (cpp->cr, &x, &y);
+
+ data->header.type = CAIRO_PATH_MOVE_TO;
+ data->header.length = 2;
+
+ /* We index from 1 to leave room for data->header */
+ data[1].point.x = x;
+ data[1].point.y = y;
+
+ cpp->data += data->header.length;
+
+ return CAIRO_STATUS_SUCCESS;
+}
+
+static cairo_status_t
+_cpp_line_to (void *closure,
+ const cairo_point_t *point)
+{
+ cpp_t *cpp = closure;
+ cairo_path_data_t *data = cpp->data;
+ double x, y;
+
+ x = _cairo_fixed_to_double (point->x);
+ y = _cairo_fixed_to_double (point->y);
+
+ _cairo_backend_to_user (cpp->cr, &x, &y);
+
+ data->header.type = CAIRO_PATH_LINE_TO;
+ data->header.length = 2;
+
+ /* We index from 1 to leave room for data->header */
+ data[1].point.x = x;
+ data[1].point.y = y;
+
+ cpp->data += data->header.length;
+
+ return CAIRO_STATUS_SUCCESS;
+}
+
+static cairo_status_t
+_cpp_curve_to (void *closure,
+ const cairo_point_t *p1,
+ const cairo_point_t *p2,
+ const cairo_point_t *p3)
+{
+ cpp_t *cpp = closure;
+ cairo_path_data_t *data = cpp->data;
+ double x1, y1;
+ double x2, y2;
+ double x3, y3;
+
+ x1 = _cairo_fixed_to_double (p1->x);
+ y1 = _cairo_fixed_to_double (p1->y);
+ _cairo_backend_to_user (cpp->cr, &x1, &y1);
+
+ x2 = _cairo_fixed_to_double (p2->x);
+ y2 = _cairo_fixed_to_double (p2->y);
+ _cairo_backend_to_user (cpp->cr, &x2, &y2);
+
+ x3 = _cairo_fixed_to_double (p3->x);
+ y3 = _cairo_fixed_to_double (p3->y);
+ _cairo_backend_to_user (cpp->cr, &x3, &y3);
+
+ data->header.type = CAIRO_PATH_CURVE_TO;
+ data->header.length = 4;
+
+ /* We index from 1 to leave room for data->header */
+ data[1].point.x = x1;
+ data[1].point.y = y1;
+
+ data[2].point.x = x2;
+ data[2].point.y = y2;
+
+ data[3].point.x = x3;
+ data[3].point.y = y3;
+
+ cpp->data += data->header.length;
+
+ return CAIRO_STATUS_SUCCESS;
+}
+
+static cairo_status_t
+_cpp_close_path (void *closure)
+{
+ cpp_t *cpp = closure;
+ cairo_path_data_t *data = cpp->data;
+
+ data->header.type = CAIRO_PATH_CLOSE_PATH;
+ data->header.length = 1;
+
+ cpp->data += data->header.length;
+
+ return CAIRO_STATUS_SUCCESS;
+}
+
+static cairo_status_t
+_cairo_path_populate (cairo_path_t *path,
+ cairo_path_fixed_t *path_fixed,
+ cairo_t *cr,
+ cairo_bool_t flatten)
+{
+ cairo_status_t status;
+ cpp_t cpp;
+
+ cpp.data = path->data;
+ cpp.cr = cr;
+
+ if (flatten) {
+ status = _cairo_path_fixed_interpret_flat (path_fixed,
+ _cpp_move_to,
+ _cpp_line_to,
+ _cpp_close_path,
+ &cpp,
+ cairo_get_tolerance (cr));
+ } else {
+ status = _cairo_path_fixed_interpret (path_fixed,
+ _cpp_move_to,
+ _cpp_line_to,
+ _cpp_curve_to,
+ _cpp_close_path,
+ &cpp);
+ }
+
+ if (unlikely (status))
+ return status;
+
+ /* Sanity check the count */
+ assert (cpp.data - path->data == path->num_data);
+
+ return CAIRO_STATUS_SUCCESS;
+}
+
+cairo_path_t *
+_cairo_path_create_in_error (cairo_status_t status)
+{
+ cairo_path_t *path;
+
+ /* special case NO_MEMORY so as to avoid allocations */
+ if (status == CAIRO_STATUS_NO_MEMORY)
+ return (cairo_path_t*) &_cairo_path_nil;
+
+ path = malloc (sizeof (cairo_path_t));
+ if (unlikely (path == NULL)) {
+ _cairo_error_throw (CAIRO_STATUS_NO_MEMORY);
+ return (cairo_path_t*) &_cairo_path_nil;
+ }
+
+ path->num_data = 0;
+ path->data = NULL;
+ path->status = status;
+
+ return path;
+}
+
+static cairo_path_t *
+_cairo_path_create_internal (cairo_path_fixed_t *path_fixed,
+ cairo_t *cr,
+ cairo_bool_t flatten)
+{
+ cairo_path_t *path;
+
+ path = malloc (sizeof (cairo_path_t));
+ if (unlikely (path == NULL)) {
+ _cairo_error_throw (CAIRO_STATUS_NO_MEMORY);
+ return (cairo_path_t*) &_cairo_path_nil;
+ }
+
+ path->num_data = _cairo_path_count (path, path_fixed,
+ cairo_get_tolerance (cr),
+ flatten);
+ if (path->num_data < 0) {
+ free (path);
+ return (cairo_path_t*) &_cairo_path_nil;
+ }
+
+ if (path->num_data) {
+ path->data = _cairo_malloc_ab (path->num_data,
+ sizeof (cairo_path_data_t));
+ if (unlikely (path->data == NULL)) {
+ free (path);
+ _cairo_error_throw (CAIRO_STATUS_NO_MEMORY);
+ return (cairo_path_t*) &_cairo_path_nil;
+ }
+
+ path->status = _cairo_path_populate (path, path_fixed, cr, flatten);
+ } else {
+ path->data = NULL;
+ path->status = CAIRO_STATUS_SUCCESS;
+ }
+
+ return path;
+}
+
+/**
+ * cairo_path_destroy:
+ * @path: a path previously returned by either cairo_copy_path() or
+ * cairo_copy_path_flat().
+ *
+ * Immediately releases all memory associated with @path. After a call
+ * to cairo_path_destroy() the @path pointer is no longer valid and
+ * should not be used further.
+ *
+ * Note: cairo_path_destroy() should only be called with a
+ * pointer to a #cairo_path_t returned by a cairo function. Any path
+ * that is created manually (ie. outside of cairo) should be destroyed
+ * manually as well.
+ *
+ * Since: 1.0
+ **/
+void
+cairo_path_destroy (cairo_path_t *path)
+{
+ if (path == NULL || path == &_cairo_path_nil)
+ return;
+
+ free (path->data);
+
+ free (path);
+}
+slim_hidden_def (cairo_path_destroy);
+
+/**
+ * _cairo_path_create:
+ * @path: a fixed-point, device-space path to be converted and copied
+ * @cr: the current graphics context
+ *
+ * Creates a user-space #cairo_path_t copy of the given device-space
+ * @path. The @cr parameter provides the inverse CTM for the
+ * conversion.
+ *
+ * Return value: the new copy of the path. If there is insufficient
+ * memory a pointer to a special static nil #cairo_path_t will be
+ * returned instead with status==%CAIRO_STATUS_NO_MEMORY and
+ * data==%NULL.
+ **/
+cairo_path_t *
+_cairo_path_create (cairo_path_fixed_t *path,
+ cairo_t *cr)
+{
+ return _cairo_path_create_internal (path, cr, FALSE);
+}
+
+/**
+ * _cairo_path_create_flat:
+ * @path: a fixed-point, device-space path to be flattened, converted and copied
+ * @cr: the current graphics context
+ *
+ * Creates a flattened, user-space #cairo_path_t copy of the given
+ * device-space @path. The @cr parameter provide the inverse CTM
+ * for the conversion, as well as the tolerance value to control the
+ * accuracy of the flattening.
+ *
+ * Return value: the flattened copy of the path. If there is insufficient
+ * memory a pointer to a special static nil #cairo_path_t will be
+ * returned instead with status==%CAIRO_STATUS_NO_MEMORY and
+ * data==%NULL.
+ **/
+cairo_path_t *
+_cairo_path_create_flat (cairo_path_fixed_t *path,
+ cairo_t *cr)
+{
+ return _cairo_path_create_internal (path, cr, TRUE);
+}
+
+/**
+ * _cairo_path_append_to_context:
+ * @path: the path data to be appended
+ * @cr: a cairo context
+ *
+ * Append @path to the current path within @cr.
+ *
+ * Return value: %CAIRO_STATUS_INVALID_PATH_DATA if the data in @path
+ * is invalid, and %CAIRO_STATUS_SUCCESS otherwise.
+ **/
+cairo_status_t
+_cairo_path_append_to_context (const cairo_path_t *path,
+ cairo_t *cr)
+{
+ const cairo_path_data_t *p, *end;
+
+ end = &path->data[path->num_data];
+ for (p = &path->data[0]; p < end; p += p->header.length) {
+ switch (p->header.type) {
+ case CAIRO_PATH_MOVE_TO:
+ if (unlikely (p->header.length < 2))
+ return _cairo_error (CAIRO_STATUS_INVALID_PATH_DATA);
+
+ cairo_move_to (cr, p[1].point.x, p[1].point.y);
+ break;
+
+ case CAIRO_PATH_LINE_TO:
+ if (unlikely (p->header.length < 2))
+ return _cairo_error (CAIRO_STATUS_INVALID_PATH_DATA);
+
+ cairo_line_to (cr, p[1].point.x, p[1].point.y);
+ break;
+
+ case CAIRO_PATH_CURVE_TO:
+ if (unlikely (p->header.length < 4))
+ return _cairo_error (CAIRO_STATUS_INVALID_PATH_DATA);
+
+ cairo_curve_to (cr,
+ p[1].point.x, p[1].point.y,
+ p[2].point.x, p[2].point.y,
+ p[3].point.x, p[3].point.y);
+ break;
+
+ case CAIRO_PATH_CLOSE_PATH:
+ if (unlikely (p->header.length < 1))
+ return _cairo_error (CAIRO_STATUS_INVALID_PATH_DATA);
+
+ cairo_close_path (cr);
+ break;
+
+ default:
+ return _cairo_error (CAIRO_STATUS_INVALID_PATH_DATA);
+ }
+
+ if (unlikely (cr->status))
+ return cr->status;
+ }
+
+ return CAIRO_STATUS_SUCCESS;
+}
generated by cgit v1.2.3 (git 2.39.1) at 2024-11-13 06:38:11 +0000