WebSVN – Kolibri OS – Diff – /programs/develop/libraries/cairo/src/cairo-path.c

  */
 #include "cairoint.h"
 #include "cairo-private.h"
-#include "cairo-private.h"
+#include "cairo-backend-private.h"
 #include "cairo-error-private.h"
 #include "cairo-path-private.h"
  * @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;
+typedef struct cairo_path_count {
-    cairo_point_t current_point;
+    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;
+    cpc_t *cpc = closure;
-    cpc->current_point = *point;
+    cpc->count += 2;
+{
     cpc_t *cpc = closure;
-    cpc->count += 2;
-    cpc->current_point = *point;
+    cpc->count += 2;
     return CAIRO_STATUS_SUCCESS;
+}
+{
     cpc_t *cpc = closure;
-    cpc->count += 4;
-    cpc->current_point = *p3;
+    cpc->count += 4;
     return CAIRO_STATUS_SUCCESS;
+}
+{
     cairo_status_t status;
     cpc_t cpc;
-    cpc.count = 0;
-    cpc.current_point.x = 0;
-    cpc.current_point.y = 0;
+    cpc.count = 0;
-    if (flatten) {
-	status = _cairo_path_fixed_interpret_flat (path_fixed,
+    if (flatten) {
-						   CAIRO_DIRECTION_FORWARD,
+	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,
+    } else {
-					      CAIRO_DIRECTION_FORWARD,
+	status = _cairo_path_fixed_interpret (path_fixed,
 					      _cpc_move_to,
 					      _cpc_line_to,
 					      _cpc_curve_to,
+}
 /* Closure for path interpretation. */
 typedef struct cairo_path_populate {
     cairo_path_data_t *data;
-    cairo_gstate_t    *gstate;
-    cairo_point_t      current_point;
+    cairo_t *cr;
 } cpp_t;
 static cairo_status_t
     double x, y;
     x = _cairo_fixed_to_double (point->x);
     y = _cairo_fixed_to_double (point->y);
-    _cairo_gstate_backend_to_user (cpp->gstate, &x, &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;
+    /* We index from 1 to leave room for data->header */
     data[1].point.x = x;
-    cpp->data += data->header.length;
+    data[1].point.y = y;
     double x, y;
     x = _cairo_fixed_to_double (point->x);
     y = _cairo_fixed_to_double (point->y);
-    _cairo_gstate_backend_to_user (cpp->gstate, &x, &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;
+    /* We index from 1 to leave room for data->header */
     data[1].point.x = x;
-    cpp->data += data->header.length;
+    data[1].point.y = y;
     double x2, y2;
     double x3, y3;
     x1 = _cairo_fixed_to_double (p1->x);
     y1 = _cairo_fixed_to_double (p1->y);
-    _cairo_gstate_backend_to_user (cpp->gstate, &x1, &y1);
+    _cairo_backend_to_user (cpp->cr, &x1, &y1);
     x2 = _cairo_fixed_to_double (p2->x);
     y2 = _cairo_fixed_to_double (p2->y);
-    _cairo_gstate_backend_to_user (cpp->gstate, &x2, &y2);
+    _cairo_backend_to_user (cpp->cr, &x2, &y2);
     x3 = _cairo_fixed_to_double (p3->x);
     y3 = _cairo_fixed_to_double (p3->y);
-    _cairo_gstate_backend_to_user (cpp->gstate, &x3, &y3);
+    _cairo_backend_to_user (cpp->cr, &x3, &y3);
     data[3].point.x = x3;
     data[3].point.y = y3;
-    cpp->data += data->header.length;
-    cpp->current_point = *p3;
+    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_gstate_t		*gstate,
+		      cairo_t			*cr,
 		      cairo_bool_t		 flatten)
+{
     cairo_status_t status;
     cpp_t cpp;
-    cpp.data = path->data;
-    cpp.gstate = gstate;
-    cpp.current_point.x = 0;
+    cpp.data = path->data;
-    cpp.current_point.y = 0;
     cpp.cr = cr;
-    if (flatten) {
 	double tolerance = _cairo_gstate_get_tolerance (gstate);
-	status = _cairo_path_fixed_interpret_flat (path_fixed,
+    if (flatten) {
-						   CAIRO_DIRECTION_FORWARD,
+	status = _cairo_path_fixed_interpret_flat (path_fixed,
 						   _cpp_move_to,
 						   _cpp_line_to,
 						   _cpp_close_path,
 						   &cpp,
-						   tolerance);
-    } else {
+						   cairo_get_tolerance (cr));
-	status = _cairo_path_fixed_interpret (path_fixed,
+    } else {
-				          CAIRO_DIRECTION_FORWARD,
+	status = _cairo_path_fixed_interpret (path_fixed,
 					  _cpp_move_to,
 					  _cpp_line_to,
     return path;
+}
 static cairo_path_t *
 _cairo_path_create_internal (cairo_path_fixed_t *path_fixed,
-			     cairo_gstate_t     *gstate,
+			     cairo_t		*cr,
 			     cairo_bool_t	 flatten)
+{
     cairo_path_t *path;
 	_cairo_error_throw (CAIRO_STATUS_NO_MEMORY);
 	return (cairo_path_t*) &_cairo_path_nil;
+    }
     path->num_data = _cairo_path_count (path, path_fixed,
-					_cairo_gstate_get_tolerance (gstate),
+					cairo_get_tolerance (cr),
 					flatten);
     if (path->num_data < 0) {
 	free (path);
 	return (cairo_path_t*) &_cairo_path_nil;
 	    free (path);
 	    _cairo_error_throw (CAIRO_STATUS_NO_MEMORY);
 	    return (cairo_path_t*) &_cairo_path_nil;
+	}
-	path->status = _cairo_path_populate (path, path_fixed,
-					     gstate, flatten);
+	path->status = _cairo_path_populate (path, path_fixed, cr, flatten);
     } else {
 	path->data = NULL;
 	path->status = CAIRO_STATUS_SUCCESS;
+ *
  * 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;
     if (path->data)
-	free (path->data);
+    free (path->data);
+    free (path);
     free (path);
 slim_hidden_def (cairo_path_destroy);
 /**
  * _cairo_path_create:
  * @path: a fixed-point, device-space path to be converted and copied
- * @gstate: the current graphics state
+ * @cr: the current graphics context
+ *
  * Creates a user-space #cairo_path_t copy of the given device-space
- * @path. The @gstate parameter provides the inverse CTM for the
+ * @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_path_create (cairo_path_fixed_t	*path,
-		    cairo_gstate_t     *gstate)
+		    cairo_t		*cr)
+{
-    return _cairo_path_create_internal (path, gstate, FALSE);
+    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
- * @gstate: the current graphics state
+ * @cr: the current graphics context
+ *
  * Creates a flattened, user-space #cairo_path_t copy of the given
- * device-space @path. The @gstate parameter provide the inverse CTM
+ * 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_gstate_t     *gstate)
+			 cairo_t	    *cr)
+{
-    return _cairo_path_create_internal (path, gstate, TRUE);
+    return _cairo_path_create_internal (path, cr, TRUE);
 cairo_status_t
 _cairo_path_append_to_context (const cairo_path_t	*path,
 			       cairo_t			*cr)
+{
     const cairo_path_data_t *p, *end;
-    cairo_fixed_t x1_fixed, y1_fixed;
-    cairo_fixed_t x2_fixed, y2_fixed;
-    cairo_fixed_t x3_fixed, y3_fixed;
-    cairo_matrix_t user_to_backend;
-    cairo_status_t status;
-    double x, y;
-    user_to_backend = cr->gstate->ctm;
-    cairo_matrix_multiply (&user_to_backend,
-			   &user_to_backend,
-	                   &cr->gstate->target->device_transform);
     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);
-	    x = p[1].point.x, y = p[1].point.y;
-	    cairo_matrix_transform_point (&user_to_backend, &x, &y);
-	    x1_fixed = _cairo_fixed_from_double (x);
-	    y1_fixed = _cairo_fixed_from_double (y);
-	    status = _cairo_path_fixed_move_to (cr->path, x1_fixed, y1_fixed);
+	    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);
-	    x = p[1].point.x, y = p[1].point.y;
-	    cairo_matrix_transform_point (&user_to_backend, &x, &y);
-	    x1_fixed = _cairo_fixed_from_double (x);
+	    if (unlikely (p->header.length < 2))
-	    y1_fixed = _cairo_fixed_from_double (y);
+		return _cairo_error (CAIRO_STATUS_INVALID_PATH_DATA);
-	    status = _cairo_path_fixed_line_to (cr->path, x1_fixed, y1_fixed);
+	    cairo_line_to (cr, p[1].point.x, p[1].point.y);
-	    break;
-	case CAIRO_PATH_CURVE_TO:
-	    if (unlikely (p->header.length < 4))
+	    break;
-		return _cairo_error (CAIRO_STATUS_INVALID_PATH_DATA);
-	    x = p[1].point.x, y = p[1].point.y;
-	    cairo_matrix_transform_point (&user_to_backend, &x, &y);
-	    x1_fixed = _cairo_fixed_from_double (x);
-	    y1_fixed = _cairo_fixed_from_double (y);
+	case CAIRO_PATH_CURVE_TO:
-	    x = p[2].point.x, y = p[2].point.y;
-	    cairo_matrix_transform_point (&user_to_backend, &x, &y);
-	    x2_fixed = _cairo_fixed_from_double (x);
-	    y2_fixed = _cairo_fixed_from_double (y);
-	    x = p[3].point.x, y = p[3].point.y;
-	    cairo_matrix_transform_point (&user_to_backend, &x, &y);
-	    x3_fixed = _cairo_fixed_from_double (x);
+	    if (unlikely (p->header.length < 4))
-	    y3_fixed = _cairo_fixed_from_double (y);
+		return _cairo_error (CAIRO_STATUS_INVALID_PATH_DATA);
-	    status = _cairo_path_fixed_curve_to (cr->path,
+	    cairo_curve_to (cr,
-		                                 x1_fixed, y1_fixed,
+			    p[1].point.x, p[1].point.y,
-						 x2_fixed, y2_fixed,
+			    p[2].point.x, p[2].point.y,
-						 x3_fixed, y3_fixed);
+			    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);
-	    status = _cairo_path_fixed_close_path (cr->path);
+	    cairo_close_path (cr);
 	    break;

Subversion Repositories Kolibri OS

(root)/programs/develop/libraries/cairo/src/cairo-path.c – Rev 1892 → 3959