adg/adg-path.c

   1 /* ADG - Automatic Drawing Generation
   2  * Copyright (C) 2007,2008,2009 Nicola Fontana <ntd at entidi.it>
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the
  16  * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  17  * Boston, MA  02110-1301, USA.
  18  */
  19
  20
  21 /**
  22  * SECTION:path
  23  * @title: AdgPath
  24  * @short_description: The basic model representing a generic path
  25  *
  26  * The #AdgPath model is a virtual path: in a few words, it is a
  27  * simple conceptual #cairo_path_t struct. This class implements
  28  * methods to manipulate the underlying cairo path.
  29  *
  30  * Although some of the provided methods are clearly based on the
  31  * original cairo path manipulation API, their behavior could be
  32  * sligthly different. This is intentional, because the ADG provides
  33  * additional path manipulation algorithms, sometime quite complex,
  34  * and a more restrictive filter on the path quality is required.
  35  * Also, the ADG is designed to be used by technicians while cairo
  36  * targets a broader range of developers.
  37  *
  38  * As an example, following the rule of the less surprise, some
  39  * cairo functions guess the current point when it is not defined,
  40  * while the #AdgPath methods trigger a warning without other effect.
  41  * Furthermore, after a cairo_path_close_path() call a MOVE_TO
  42  * primitive to the starting point of the segment is automatically
  43  * added by cairo while in the ADG, after an adg_path_close(), the
  44  * current point is simply unset.
  45  **/
  46
  47 #include "adg-path.h"
  48 #include "adg-path-private.h"
  49 #include "adg-intl.h"
  50
  51 #include <math.h>
  52
  53 #define PARENT_CLASS    ((AdgModelClass *) adg_path_parent_class)
  54
  55
  56 static void             finalize                (GObject        *object);
  57 static void             changed                 (AdgModel       *model);
  58 static void             clear_cairo_path        (AdgPath        *path);
  59 static cairo_path_t *   get_cairo_path          (AdgPath        *path);
  60 static cairo_path_t *   get_cpml_path           (AdgPath        *path);
  61 static GArray *         arc_to_curves           (GArray         *array,
  62                                                  const cairo_path_data_t *src);
  63 static void             append_valist           (AdgPath        *path,
  64                                                  cairo_path_data_type_t type,
  65                                                  int             length,
  66                                                  va_list         var_args);
  67
  68
  69 G_DEFINE_TYPE(AdgPath, adg_path, ADG_TYPE_MODEL);
  70
  71
  72 static void
  73 adg_path_class_init(AdgPathClass *klass)
  74 {
  75     GObjectClass *gobject_class;
  76     AdgModelClass *model_class;
  77
  78     gobject_class = (GObjectClass *) klass;
  79     model_class = (AdgModelClass *) klass;
  80
  81     g_type_class_add_private(klass, sizeof(AdgPathPrivate));
  82
  83     gobject_class->finalize = finalize;
  84
  85     model_class->changed = changed;
  86 }
  87
  88 static void
  89 adg_path_init(AdgPath *path)
  90 {
  91     AdgPathPrivate *priv = G_TYPE_INSTANCE_GET_PRIVATE(path, ADG_TYPE_PATH,
  92                                                        AdgPathPrivate);
  93
  94     priv->cp_is_valid = FALSE;
  95     priv->path = g_array_new(FALSE, FALSE, sizeof(cairo_path_data_t));
  96     priv->cairo_path.status = CAIRO_STATUS_INVALID_PATH_DATA;
  97     priv->cairo_path.data = NULL;
  98     priv->cairo_path.num_data = 0;
  99
 100     path->priv = priv;
 101 }
 102
 103 static void
 104 finalize(GObject *object)
 105 {
 106     AdgPath *path = (AdgPath *) object;
 107
 108     g_array_free(path->priv->path, TRUE);
 109     clear_cairo_path(path);
 110
 111     ((GObjectClass *) PARENT_CLASS)->finalize(object);
 112 }
 113
 114
 115 /**
 116  * adg_path_new:
 117  *
 118  * Creates a new path model. The path must be constructed in the @callback
 119  * function: AdgPath will cache and reuse the cairo_copy_path() returned by
 120  * the cairo context after the @callback call.
 121  *
 122  * Return value: the new model
 123  **/
 124 AdgModel *
 125 adg_path_new(void)
 126 {
 127     return (AdgModel *) g_object_new(ADG_TYPE_PATH, NULL);
 128 }
 129
 130
 131 /**
 132  * adg_path_get_cairo_path:
 133  * @path: an #AdgPath
 134  *
 135  * Gets a pointer to the cairo path structure of @path. The return value
 136  * is owned by @path and must be considered read-only.
 137  *
 138  * This function also converts %CAIRO_PATH_ARC_TO primitives, not
 139  * recognized by cairo, into approximated Bézier curves. The conversion
 140  * is cached so any furter request is O(1). This cache is cleared
 141  * whenever @path is modified (by adding a new primitive or by calling
 142  * adg_path_clear()).
 143  *
 144  * <important>
 145  * <title>TODO</title>
 146  * <itemizedlist>
 147  * <listitem>Actually, the arcs are approximated to Bézier using the
 148  *           hardcoded max angle of PI/2. This should be customizable
 149  *           by adding, for instance, a property to the #AdgPath class
 150  *           with a default value of PI/2.</listitem>
 151  * </itemizedlist>
 152  * </important>
 153  *
 154  * Return value: a pointer to the internal cairo path or %NULL on errors
 155  **/
 156 const cairo_path_t *
 157 adg_path_get_cairo_path(AdgPath *path)
 158 {
 159     g_return_val_if_fail(ADG_IS_PATH(path), NULL);
 160
 161     return get_cairo_path(path);
 162 }
 163
 164 /**
 165  * adg_path_get_cpml_path:
 166  * @path: an #AdgPath
 167  *
 168  * Gets a pointer to the cairo path structure of @path. The return
 169  * value is owned by @path and must not be freed.
 170  *
 171  * This function is similar to adg_path_get_cairo_path() but with
 172  * two important differences: firstly the arc primitives are not
 173  * expanded to Bézier curves and secondly the returned path is
 174  * not read-only. This means it is allowed to modify the returned
 175  * path as long as its size is retained and its data contains a
 176  * valid path.
 177  *
 178  * Keep in mind any changes to @path makes the value returned by
 179  * this function useless, as it is likely to contain plain garbage.
 180  *
 181  * Return value: a pointer to the internal cpml path or %NULL on errors
 182  **/
 183 cairo_path_t *
 184 adg_path_get_cpml_path(AdgPath *path)
 185 {
 186     g_return_val_if_fail(ADG_IS_PATH(path), NULL);
 187
 188     clear_cairo_path(path);
 189
 190     return get_cpml_path(path);
 191 }
 192
 193 /**
 194  * adg_path_dup_cpml_path:
 195  * @path: an #AdgPath
 196  *
 197  * Gets a duplicate of the cairo path structure of @path. The return
 198  * value should be freed with g_free(). The returned #cairo_path_t
 199  * struct also contains the #cairo_path_data_t array in the same
 200  * chunk of memory, so a g_free() to the returned pointer also frees
 201  * the data array.
 202  *
 203  * Although quite similar to adg_path_get_cpml_path(), the use case
 204  * of this method is different: being a duplicate, modifying the
 205  * returned path does not modify @path itsself.
 206  *
 207  * Return value: a newly allocated #cairo_path_t pointer to be freed
 208  *               with g_free() or %NULL on errors
 209  **/
 210 cairo_path_t *
 211 adg_path_dup_cpml_path(AdgPath *path)
 212 {
 213     cairo_path_t *cpml_path;
 214     gsize head_size, data_size;
 215
 216     g_return_val_if_fail(ADG_IS_PATH(path), NULL);
 217
 218     head_size = sizeof(cairo_path_t);
 219     data_size = sizeof(cairo_path_data_t) * path->priv->path->len;
 220
 221     /* Both the cairo_path_t struct and the cairo_path_data_t array
 222      * are stored in the same chunk of memory, so only a single
 223      * g_free() is needed */
 224     cpml_path = g_malloc(head_size + data_size);
 225     cpml_path->status = CAIRO_STATUS_SUCCESS;
 226     cpml_path->data = (cairo_path_data_t *) ((gchar *) cpml_path + head_size);
 227     cpml_path->num_data = path->priv->path->len;
 228     memcpy(cpml_path->data, path->priv->path->data, data_size);
 229
 230     return cpml_path;
 231 }
 232
 233 /**
 234  * adg_path_get_current_point:
 235  * @path: an #AdgPath
 236  * @x:    return value for x coordinate of the current point
 237  * @y:    return value for y coordinate of the current point
 238  *
 239  * Gets the current point of @path, which is conceptually the
 240  * final point reached by the path so far.
 241  *
 242  * If there is no defined current point, @x and @y will both be set
 243  * to 0 and a warning will be triggered. It is possible to check this
 244  * in advance with adg_path_has_current_point().
 245  *
 246  * Most #AdgPath methods alter the current point and most of them
 247  * expect a current point to be defined otherwise will fail triggering
 248  * a warning. Check the description of every method for specific details.
 249  **/
 250 void
 251 adg_path_get_current_point(AdgPath *path, gdouble *x, gdouble *y)
 252 {
 253     g_return_if_fail(ADG_IS_PATH(path));
 254
 255     if (path->priv->cp_is_valid) {
 256         *x = path->priv->cp.x;
 257         *y = path->priv->cp.y;
 258     } else {
 259         *x = *y = 0.;
 260         g_return_if_reached();
 261     }
 262 }
 263
 264 /**
 265  * adg_path_has_current_point:
 266  * @path: an #AdgPath
 267  *
 268  * Returns whether a current point is defined on @path.
 269  * See adg_path_get_current_point() for details on the current point.
 270  *
 271  * Return value: whether a current point is defined
 272  **/
 273 gboolean
 274 adg_path_has_current_point(AdgPath *path)
 275 {
 276     g_return_val_if_fail(ADG_IS_PATH(path), FALSE);
 277
 278     return path->priv->cp_is_valid;
 279 }
 280
 281 /**
 282  * adg_path_clear:
 283  * @path: an #AdgPath
 284  *
 285  * Releases the internal memory hold by @path and resets its status,
 286  * so that after this call @path contains an empty path.
 287  **/
 288 void
 289 adg_path_clear(AdgPath *path)
 290 {
 291     g_return_if_fail(ADG_IS_PATH(path));
 292
 293     g_array_set_size(path->priv->path, 0);
 294     clear_cairo_path(path);
 295 }
 296
 297
 298 /**
 299  * adg_path_append:
 300  * @path: an #AdgPath
 301  * @type: a #cairo_data_type_t value
 302  * @...:  point data, specified as #AdgPair pointers
 303  *
 304  * Generic method to append a primitive to @path. The number of #AdgPair
 305  * structs depends on @type: there is no way with this function to
 306  * reserve more cairo_path_data_t structs than what is needed by the
 307  * primitive.
 308  *
 309  * This function accepts also the special %CAIRO_PATH_ARC_TO primitive.
 310  *
 311  * If @path has no current point while the requested primitive needs it,
 312  * a warning message will be triggered without other effect.
 313  **/
 314 void
 315 adg_path_append(AdgPath *path, cairo_path_data_type_t type, ...)
 316 {
 317     va_list var_args;
 318
 319     va_start(var_args, type);
 320     adg_path_append_valist(path, type, var_args);
 321     va_end(var_args);
 322 }
 323
 324 /**
 325  * adg_path_append_valist:
 326  * @path:     an #AdgPath
 327  * @type:     a #cairo_data_type_t value
 328  * @var_args: point data, specified as #AdgPair pointers
 329  *
 330  * va_list version of adg_path_append().
 331  **/
 332 void
 333 adg_path_append_valist(AdgPath *path, cairo_path_data_type_t type,
 334                        va_list var_args)
 335 {
 336     gint length;
 337
 338     g_return_if_fail(ADG_IS_PATH(path));
 339
 340     switch (type) {
 341
 342     case CAIRO_PATH_CLOSE_PATH:
 343         g_return_if_fail(path->priv->cp_is_valid);
 344         length = 1;
 345         break;
 346
 347     case CAIRO_PATH_MOVE_TO:
 348         length = 2;
 349         break;
 350
 351     case CAIRO_PATH_LINE_TO:
 352         g_return_if_fail(path->priv->cp_is_valid);
 353         length = 2;
 354         break;
 355
 356     case CAIRO_PATH_ARC_TO:
 357         g_return_if_fail(path->priv->cp_is_valid);
 358         length = 3;
 359         break;
 360
 361     case CAIRO_PATH_CURVE_TO:
 362         g_return_if_fail(path->priv->cp_is_valid);
 363         length = 4;
 364         break;
 365
 366     default:
 367         g_assert_not_reached();
 368         return;
 369     }
 370
 371     append_valist(path, type, length, var_args);
 372 }
 373
 374
 375 /**
 376  * adg_path_move_to:
 377  * @path: an #AdgPath
 378  * @x:    the new x coordinate
 379  * @y:    the new y coordinate
 380  *
 381  * Begins a new segment. After this call the current point will be (@x, @y).
 382  **/
 383 void
 384 adg_path_move_to(AdgPath *path, gdouble x, gdouble y)
 385 {
 386     AdgPair p;
 387
 388     p.x = x;
 389     p.y = y;
 390
 391     adg_path_append(path, CAIRO_PATH_MOVE_TO, &p);
 392 }
 393
 394 /**
 395  * adg_path_line_to:
 396  * @path: an #AdgPath
 397  * @x:    the new x coordinate
 398  * @y:    the new y coordinate
 399  *
 400  * Adds a line to @path from the current point to position (@x, @y).
 401  * After this call the current point will be (@x, @y).
 402  *
 403  * If @path has no current point before this call, this function will
 404  * trigger a warning without other effect.
 405  **/
 406 void
 407 adg_path_line_to(AdgPath *path, gdouble x, gdouble y)
 408 {
 409     AdgPair p;
 410
 411     p.x = x;
 412     p.y = y;
 413
 414     adg_path_append(path, CAIRO_PATH_LINE_TO, &p);
 415 }
 416
 417 /**
 418  * adg_path_arc_to:
 419  * @path: an #AdgPath
 420  * @x1:   the x coordinate of an intermediate point
 421  * @y1:   the y coordinate of an intermediate point
 422  * @x2:   the x coordinate of the end of the arc
 423  * @y2:   the y coordinate of the end of the arc
 424  *
 425  * Adds an arc to the path from the current point to (@x2, @y2),
 426  * passing throught (@x1, @y1). After this call the current point
 427  * will be (@x2, @y2).
 428  *
 429  * If @path has no current point before this call, this function will
 430  * trigger a warning without other effect.
 431  **/
 432 void
 433 adg_path_arc_to(AdgPath *path, gdouble x1, gdouble y1, gdouble x2, gdouble y2)
 434 {
 435     AdgPair p[2];
 436
 437     p[0].x = x1;
 438     p[0].y = y1;
 439     p[1].x = x2;
 440     p[1].y = y2;
 441
 442     adg_path_append(path, CAIRO_PATH_ARC_TO, &p[0], &p[1]);
 443 }
 444
 445 /**
 446  * adg_path_curve_to:
 447  * @path: an #AdgPath
 448  * @x1:   the x coordinate of the first control point
 449  * @y1:   the y coordinate of the first control point
 450  * @x2:   the x coordinate of the second control point
 451  * @y2:   the y coordinate of the second control point
 452  * @x3:   the x coordinate of the end of the curve
 453  * @y3:   the y coordinate of the end of the curve
 454  *
 455  * Adds a cubic Bézier curve to the path from the current point to
 456  * position (@x3, @y3), using (@x1, @y1) and (@x2, @y2) as the
 457  * control points. After this call the current point will be (@x3, @y3).
 458  *
 459  * If @path has no current point before this call, this function will
 460  * trigger a warning without other effect.
 461  **/
 462 void
 463 adg_path_curve_to(AdgPath *path, gdouble x1, gdouble y1,
 464                   gdouble x2, gdouble y2, gdouble x3, gdouble y3)
 465 {
 466     AdgPair p[3];
 467
 468     p[0].x = x1;
 469     p[0].y = y1;
 470     p[1].x = x2;
 471     p[1].y = y2;
 472     p[2].x = x3;
 473     p[2].y = y3;
 474
 475     adg_path_append(path, CAIRO_PATH_CURVE_TO, &p[0], &p[1], &p[2]);
 476 }
 477
 478 /**
 479  * adg_path_close:
 480  * @path: an #AdgPath
 481  *
 482  * Adds a line segment to the path from the current point to the
 483  * beginning of the current segment, (the most recent point passed
 484  * to an adg_path_move_to()), and closes this segment.
 485  * After this call the current point will be unset.
 486  *
 487  * The behavior of adg_path_close() is distinct from simply calling
 488  * adg_line_to() with the coordinates of the segment starting point.
 489  * When a closed segment is stroked, there are no caps on the ends.
 490  * Instead, there is a line join connecting the final and initial
 491  * primitive of the segment.
 492  *
 493  * If @path has no current point before this call, this function will
 494  * trigger a warning without other effect.
 495  **/
 496 void
 497 adg_path_close(AdgPath *path)
 498 {
 499     adg_path_append(path, CAIRO_PATH_CLOSE_PATH);
 500 }
 501
 502 /**
 503  * adg_path_arc
 504  * @path:  an #AdgPath
 505  * @xc:    x position of the center of the arc
 506  * @yc:    y position of the center of the arc
 507  * @r:     the radius of the arc
 508  * @start: the start angle, in radians
 509  * @end:   the end angle, in radians
 510  *
 511  * A more usual way to add an arc to @path. After this call, the current
 512  * point will be the computed end point of the arc. The arc will be
 513  * rendered in increasing angle, accordling to @start and @end. This means
 514  * if @start is less than @end, the arc will be rendered in clockwise
 515  * direction (accordling to the default cairo coordinate system) while if
 516  * @start is greather than @end, the arc will be rendered in couterclockwise
 517  * direction.
 518  *
 519  * By explicitely setting the whole arc data, the start point could be
 520  * different from the current point. In this case, if @path has no
 521  * current point before the call a %CAIRO_PATH_MOVE_TO to the start
 522  * point of the arc will be automatically prepended to the arc.
 523  * If @path has a current point, a %CAIRO_PATH_LINE_TO to the start
 524  * point of the arc will be used instead of the moveto.
 525  **/
 526 void
 527 adg_path_arc(AdgPath *path, gdouble xc, gdouble yc, gdouble r,
 528              gdouble start, gdouble end)
 529 {
 530     AdgPair center, p[3];
 531
 532     g_return_if_fail(ADG_IS_PATH(path));
 533
 534     center.x = xc;
 535     center.y = yc;
 536
 537     cpml_vector_from_angle(&p[0], start, r);
 538     cpml_vector_from_angle(&p[1], (end-start) / 2, r);
 539     cpml_vector_from_angle(&p[2], end, r);
 540
 541     cpml_pair_add(&p[0], &center);
 542     cpml_pair_add(&p[1], &center);
 543     cpml_pair_add(&p[2], &center);
 544
 545     if (!path->priv->cp_is_valid)
 546         adg_path_append(path, CAIRO_PATH_MOVE_TO, &p[0]);
 547     else if (p[0].x != path->priv->cp.x || p[0].y != path->priv->cp.y)
 548         adg_path_append(path, CAIRO_PATH_LINE_TO, &p[0]);
 549
 550     adg_path_append(path, CAIRO_PATH_ARC_TO, &p[1], &p[2]);
 551 }
 552
 553
 554 /**
 555  * adg_path_dump:
 556  * @path: an #AdgPath
 557  *
 558  * Dumps the data content of @path to stdout in a human readable format.
 559  **/
 560 void
 561 adg_path_dump(AdgPath *path)
 562 {
 563     CpmlSegment segment;
 564     cairo_path_t *cairo_path;
 565
 566     g_return_if_fail(ADG_IS_PATH(path));
 567
 568     cairo_path = get_cairo_path(path);
 569
 570     g_return_if_fail(cairo_path != NULL);
 571
 572     if (!cpml_segment_from_cairo(&segment, cairo_path)) {
 573         g_print("Invalid path data to dump!\n");
 574     } else {
 575         do {
 576             cpml_segment_dump(&segment);
 577         } while (cpml_segment_next(&segment));
 578     }
 579 }
 580
 581
 582 static void
 583 changed(AdgModel *model)
 584 {
 585     adg_path_clear((AdgPath *) model);
 586
 587     PARENT_CLASS->changed(model);
 588 }
 589
 590 static void
 591 clear_cairo_path(AdgPath *path)
 592 {
 593     cairo_path_t *cairo_path = &path->priv->cairo_path;
 594
 595     if (cairo_path->data == NULL)
 596         return;
 597
 598     g_free(cairo_path->data);
 599
 600     cairo_path->status = CAIRO_STATUS_INVALID_PATH_DATA;
 601     cairo_path->data = NULL;
 602     cairo_path->num_data = 0;
 603 }
 604
 605 static cairo_path_t *
 606 get_cairo_path(AdgPath *path)
 607 {
 608     cairo_path_t *cairo_path;
 609     const GArray *src;
 610     GArray *dst;
 611     const cairo_path_data_t *p_src;
 612     int i;
 613
 614     /* Check for cached result */
 615     cairo_path = &path->priv->cairo_path;
 616     if (cairo_path->data != NULL)
 617         return cairo_path;
 618
 619     src = path->priv->path;
 620     dst = g_array_sized_new(FALSE, FALSE, sizeof(cairo_path_data_t), src->len);
 621
 622     /* Cycle the path and convert arcs to Bézier curves */
 623     for (i = 0; i < src->len; i += p_src->header.length) {
 624         p_src = (const cairo_path_data_t *) src->data + i;
 625
 626         if (p_src->header.type == CAIRO_PATH_ARC_TO)
 627             dst = arc_to_curves(dst, p_src);
 628         else
 629             dst = g_array_append_vals(dst, p_src, p_src->header.length);
 630     }
 631
 632     cairo_path->status = CAIRO_STATUS_SUCCESS;
 633     cairo_path->num_data = dst->len;
 634     cairo_path->data = (cairo_path_data_t *) g_array_free(dst, FALSE);
 635
 636     return cairo_path;
 637 }
 638
 639 static cairo_path_t *
 640 get_cpml_path(AdgPath *path)
 641 {
 642     cairo_path_t *cpml_path = &path->priv->cpml_path;
 643
 644     cpml_path->status = CAIRO_STATUS_SUCCESS;
 645     cpml_path->data = (cairo_path_data_t *) path->priv->path->data;
 646     cpml_path->num_data = path->priv->path->len;
 647
 648     return cpml_path;
 649 }
 650
 651 static GArray *
 652 arc_to_curves(GArray *array, const cairo_path_data_t *src)
 653 {
 654     CpmlPrimitive arc;
 655     double start, end;
 656
 657     /* Build the arc primitive: the arc origin is supposed to be the previous
 658      * point (src-1): this means a primitive must exist before the arc */
 659     arc.segment = NULL;
 660     arc.org = (cairo_path_data_t *) (src-1);
 661     arc.data = (cairo_path_data_t *) src;
 662
 663     if (cpml_arc_info(&arc, NULL, NULL, &start, &end)) {
 664         CpmlSegment segment;
 665         int n_curves;
 666         cairo_path_data_t *curves;
 667
 668         n_curves = ceil(fabs(end-start) / M_PI_2);
 669         curves = g_new(cairo_path_data_t, n_curves * 4);
 670         segment.data = curves;
 671         cpml_arc_to_curves(&arc, &segment, n_curves);
 672
 673         array = g_array_append_vals(array, curves, n_curves * 4);
 674
 675         g_free(curves);
 676     }
 677
 678     return array;
 679 }
 680
 681 static void
 682 append_valist(AdgPath *path, cairo_path_data_type_t type,
 683               int length, va_list var_args)
 684 {
 685     AdgPathPrivate *priv;
 686     cairo_path_data_t item;
 687
 688     priv = path->priv;
 689
 690     /* Append the header item */
 691     item.header.type = type;
 692     item.header.length = length;
 693     priv->path = g_array_append_val(priv->path, item);
 694     priv->cp_is_valid = FALSE;
 695
 696     /* Append the data items (that is, the AdgPair points) */
 697     while (--length) {
 698         cpml_pair_to_cairo(va_arg(var_args, AdgPair *), &item);
 699         priv->path = g_array_append_val(priv->path, item);
 700         priv->cp_is_valid = TRUE;
 701     }
 702
 703     /* Save the last point as the current point */
 704     if (priv->cp_is_valid)
 705         cpml_pair_from_cairo(&priv->cp, &item);
 706
 707     /* Invalidate cairo_path: should be recomputed */
 708     clear_cairo_path(path);
 709 }