demo/adg-demo.c

   1 #include <adg/adg.h>
   2 #include <math.h>
   3
   4 #include "demo.h"
   5
   6
   7 static AdgCanvas *      sample_canvas           (void);
   8 static AdgCanvas *      operations_canvas       (void);
   9 static void             to_pdf                  (AdgWidget      *widget,
  10                                                  GtkWidget      *caller);
  11 static void             to_png                  (AdgWidget      *widget,
  12                                                  GtkWidget      *caller);
  13 static void             to_ps                   (AdgWidget      *widget,
  14                                                  GtkWidget      *caller);
  15
  16
  17 int
  18 main(gint argc, gchar **argv)
  19 {
  20     gchar *path;
  21     GtkBuilder *builder;
  22     GError *error;
  23     GtkWidget *window, *sample, *operations;
  24
  25     gtk_init(&argc, &argv);
  26
  27     path = demo_find_data_file("adg-demo.ui");
  28     if (path == NULL) {
  29         g_print("adg-demo.ui not found!\n");
  30         return 1;
  31     }
  32
  33     builder = gtk_builder_new();
  34     error = NULL;
  35
  36     gtk_builder_add_from_file(builder, path, &error);
  37     if (error != NULL) {
  38         g_print("%s\n", error->message);
  39         return 2;
  40     }
  41
  42     window = (GtkWidget *) gtk_builder_get_object(builder, "wndMain");
  43
  44     sample = (GtkWidget *) gtk_builder_get_object(builder, "areaSample");
  45     adg_widget_set_canvas(ADG_WIDGET(sample), sample_canvas());
  46
  47     operations = (GtkWidget *) gtk_builder_get_object(builder, "areaOperations");
  48     adg_widget_set_canvas(ADG_WIDGET(operations), operations_canvas());
  49
  50     /* Connect signals */
  51     g_signal_connect(window, "delete-event",
  52                      G_CALLBACK(gtk_main_quit), NULL);
  53     g_signal_connect(gtk_builder_get_object(builder, "btnQuit"),
  54                      "clicked", G_CALLBACK(gtk_main_quit), NULL);
  55     g_signal_connect_swapped(gtk_builder_get_object(builder, "btnPng"),
  56                              "clicked", G_CALLBACK(to_png), sample);
  57     g_signal_connect_swapped(gtk_builder_get_object(builder, "btnPdf"),
  58                              "clicked", G_CALLBACK(to_pdf), sample);
  59     g_signal_connect_swapped(gtk_builder_get_object(builder, "btnPs"),
  60                              "clicked", G_CALLBACK(to_ps), sample);
  61
  62     g_object_unref(builder);
  63
  64     gtk_widget_show_all(window);
  65     gtk_main();
  66
  67     return 0;
  68 }
  69
  70
  71 /**********************************************
  72  * A sample mechanical part example
  73  **********************************************/
  74
  75 #define SQRT3   1.732050808
  76 #define CHAMFER 0.3
  77
  78 typedef struct _SampleData SampleData;
  79
  80 struct _SampleData {
  81     gdouble A, B, C;
  82     gdouble D1, D2, D3, D4, D5, D6, D7;
  83     gdouble RD34, RD56;
  84     gdouble LD2, LD3, LD5, LD6, LD7;
  85 };
  86
  87 static void     sample_get              (SampleData             *data);
  88 static AdgPath *sample_path             (const SampleData       *data);
  89 static void     sample_add_dimensions   (AdgCanvas              *canvas,
  90                                          const SampleData       *data);
  91 static void     sample_add_stuff        (AdgCanvas              *canvas,
  92                                          const SampleData       *data);
  93
  94
  95 static AdgCanvas *
  96 sample_canvas(void)
  97 {
  98     SampleData data;
  99     AdgPath *path;
 100     AdgCanvas *canvas;
 101     AdgContainer *container;
 102     AdgEntity *entity;
 103     AdgMatrix transformation;
 104
 105     sample_get(&data);
 106     path = sample_path(&data);
 107     canvas = adg_canvas_new();
 108     container = (AdgContainer *) canvas;
 109
 110     entity = adg_stroke_new(path);
 111     adg_container_add(container, entity);
 112
 113     sample_add_dimensions(canvas, &data);
 114     sample_add_stuff(canvas, &data);
 115
 116     cairo_matrix_init_translate(&transformation, 100, 70);
 117     cairo_matrix_scale(&transformation, 6.883, 6.883);
 118     cairo_matrix_translate(&transformation, 0, 10);
 119     adg_container_set_model_transformation(container, &transformation);
 120
 121     return canvas;
 122 }
 123
 124 static void
 125 sample_get(SampleData *data)
 126 {
 127     data->A = 52.3;
 128     data->B = 20.6;
 129     data->C = 2;
 130     data->D1 = 9.3;
 131     data->D2 = 6.5;
 132     data->D3 = 11.9;
 133     data->D4 = 6.5;
 134     data->D5 = 4.5;
 135     data->D6 = 7.2;
 136     data->D7 = 3.;
 137     data->RD34 = 1.;
 138     data->LD2 = 7.;
 139     data->LD3 = 3.5;
 140     data->LD5 = 5.;
 141     data->LD6 = 1.;
 142     data->LD7 = 0.5;
 143 }
 144
 145 static AdgPath *
 146 sample_path(const SampleData *data)
 147 {
 148     AdgPath *path;
 149     double x, y;
 150     AdgSegment segment_org;
 151     AdgSegment *segment;
 152     cairo_matrix_t matrix;
 153
 154     path = (AdgPath *) adg_path_new();
 155
 156     adg_path_move_to(path, 0, data->D1 / 2);
 157     adg_path_line_to(path, data->A - data->B - data->LD2, data->D1 / 2);
 158     y = (data->D1 - data->D2) / 2;
 159     adg_path_line_to(path, data->A - data->B - data->LD2 + y * SQRT3, data->D1 / 2 - y);
 160     adg_path_line_to(path, data->A - data->B, data->D2 / 2);
 161     adg_path_fillet(path, 0.4);
 162     adg_path_line_to(path, data->A - data->B, data->D3 / 2);
 163     adg_path_chamfer(path, CHAMFER, CHAMFER);
 164     adg_path_line_to(path, data->A - data->B + data->LD3, data->D3 / 2);
 165     adg_path_chamfer(path, CHAMFER, CHAMFER);
 166     adg_path_line_to(path, data->A - data->B + data->LD3, data->D4 / 2);
 167     adg_path_fillet(path, data->RD34);
 168     adg_path_line_to(path, data->A - data->C - data->LD5, data->D4 / 2);
 169     y = (data->D4 - data->D5) / 2;
 170     adg_path_line_to(path, data->A - data->C - data->LD5 + y, data->D4 / 2 - y);
 171     adg_path_line_to(path, data->A - data->C, data->D5 / 2);
 172     adg_path_fillet(path, 0.2);
 173     adg_path_line_to(path, data->A - data->C, data->D6 / 2);
 174     adg_path_fillet(path, 0.1);
 175     adg_path_line_to(path, data->A - data->C + data->LD6, data->D6 / 2);
 176     x = data->C - data->LD7 - data->LD6;
 177     y = x / SQRT3;
 178     adg_path_line_to(path, data->A - data->C + data->LD6 + x, data->D6 / 2 - y);
 179     adg_path_line_to(path, data->A - data->LD7, data->D7 / 2);
 180     adg_path_line_to(path, data->A, data->D7 / 2);
 181
 182     /* Build the rounded shape by duplicating the first segment of
 183      * the current path, reflecting it on the y=0 axis, reversing and
 184      * joining it the result to the original path */
 185     cpml_segment_from_cairo(&segment_org, adg_path_get_cpml_path(path));
 186     segment = adg_segment_deep_dup(&segment_org);
 187     cpml_segment_reverse(segment);
 188     adg_matrix_init_reflection(&matrix, 0);
 189     cpml_segment_transform(segment, &matrix);
 190     segment->data[0].header.type = CAIRO_PATH_LINE_TO;
 191
 192     adg_path_append_segment(path, segment);
 193
 194     g_free(segment);
 195
 196     adg_path_close(path);
 197     return path;
 198 }
 199
 200 static void
 201 sample_add_dimensions(AdgCanvas *canvas, const SampleData *data)
 202 {
 203     AdgEntity *entity;
 204     double x, y;
 205
 206     /* NORTH */
 207
 208     /* LD2 */
 209     entity = adg_ldim_new_full_explicit(data->A - data->B - data->LD2, -data->D1 / 2, data->A - data->B,
 210                                         -data->D3 / 2 + CHAMFER, ADG_DIR_UP, 0,
 211                                         -data->D3 / 2);
 212     adg_container_add(ADG_CONTAINER(canvas), entity);
 213
 214     /* LD3 */
 215     entity = adg_ldim_new_full_explicit(data->A - data->B, -data->D3 / 2 + CHAMFER, data->A - data->B + data->LD3,
 216                                         -data->D3 / 2 + CHAMFER, ADG_DIR_UP, 0,
 217                                         -data->D3 / 2);
 218     adg_container_add(ADG_CONTAINER(canvas), entity);
 219
 220     /* SOUTH */
 221
 222     /* B */
 223     entity = adg_ldim_new_full_explicit(data->A - data->B, data->D3 / 2 - CHAMFER, data->A, data->D7 / 2,
 224                                         ADG_DIR_DOWN, 0, data->D3 / 2);
 225     adg_dim_set_tolerances(ADG_DIM(entity), "+0.1", NULL);
 226     adg_container_add(ADG_CONTAINER(canvas), entity);
 227
 228     /* A */
 229     entity = adg_ldim_new_full_explicit(0, data->D1 / 2, data->A, data->D7 / 2,
 230                                         ADG_DIR_DOWN, 0, data->D3 / 2);
 231     adg_dim_set_tolerances(ADG_DIM(entity), "+0.05", "-0.05");
 232     adg_dim_set_level(ADG_DIM(entity), 2);
 233     adg_container_add(ADG_CONTAINER(canvas), entity);
 234
 235     /* EAST */
 236
 237     /* D3 */
 238     x = data->A - data->B + data->LD3 - CHAMFER;
 239     entity = adg_ldim_new_full_explicit(x, -data->D3 / 2, x, data->D3 / 2,
 240                                         ADG_DIR_RIGHT, data->A, 0);
 241     adg_dim_set_tolerances(ADG_DIM(entity), "-0.25", NULL);
 242     adg_dim_set_level(ADG_DIM(entity), 5);
 243     adg_container_add(ADG_CONTAINER(canvas), entity);
 244
 245     /* D6 */
 246     x = data->A - data->C + data->LD6;
 247     entity = adg_ldim_new_full_explicit(x, -data->D6 / 2, x, data->D6 / 2,
 248                                         ADG_DIR_RIGHT, data->A, 0);
 249     adg_dim_set_tolerances(ADG_DIM(entity), "-0.1", NULL);
 250     adg_dim_set_level(ADG_DIM(entity), 4);
 251     adg_container_add(ADG_CONTAINER(canvas), entity);
 252
 253     /* D4 */
 254     x = data->A - data->C - data->LD5;
 255     entity = adg_ldim_new_full_explicit(x, -data->D4 / 2, x, data->D4 / 2,
 256                                         ADG_DIR_RIGHT, data->A, 0);
 257     adg_dim_set_level(ADG_DIM(entity), 3);
 258     adg_container_add(ADG_CONTAINER(canvas), entity);
 259
 260     /* D5 */
 261     x = data->A - data->C;
 262     entity = adg_ldim_new_full_explicit(x, -data->D5 / 2, x, data->D5 / 2,
 263                                         ADG_DIR_RIGHT, data->A, 0);
 264     adg_dim_set_tolerances(ADG_DIM(entity), "-0.1", NULL);
 265     adg_dim_set_level(ADG_DIM(entity), 2);
 266     adg_container_add(ADG_CONTAINER(canvas), entity);
 267
 268     /* D7 */
 269     entity = adg_ldim_new_full_explicit(data->A, -data->D7 / 2, data->A, data->D7 / 2,
 270                                         ADG_DIR_RIGHT, data->A, 0);
 271     adg_container_add(ADG_CONTAINER(canvas), entity);
 272
 273     /* WEST */
 274
 275     /* D1 */
 276     entity = adg_ldim_new_full_explicit(0, -data->D1 / 2, 0, data->D1 / 2,
 277                                         ADG_DIR_LEFT, 0, 0);
 278     adg_dim_set_tolerances(ADG_DIM(entity), "+0.05", "-0.05");
 279     adg_dim_set_level(ADG_DIM(entity), 2);
 280     adg_container_add(ADG_CONTAINER(canvas), entity);
 281
 282     /* D2 */
 283     y = (data->D1 - data->D2) / 2;
 284     x = data->A - data->B - data->LD2 + y * SQRT3;
 285     entity = adg_ldim_new_full_explicit(x, -data->D2 / 2, x, data->D2 / 2,
 286                                         ADG_DIR_LEFT, 0, 0);
 287     adg_dim_set_tolerances(ADG_DIM(entity), "-0.1", NULL);
 288     adg_container_add(ADG_CONTAINER(canvas), entity);
 289 }
 290
 291 static void
 292 sample_add_stuff(AdgCanvas *canvas, const SampleData *data)
 293 {
 294     AdgEntity *toy_text;
 295
 296     toy_text = adg_toy_text_new("Rotate the mouse wheel to zoom in and out");
 297     adg_translatable_set_origin_explicit(ADG_TRANSLATABLE(toy_text),
 298                                          0., data->D3 / 2,
 299                                          10., 30. + 30. * 2);
 300     adg_container_add(ADG_CONTAINER(canvas), toy_text);
 301
 302     toy_text = adg_toy_text_new("Keep the wheel pressed while dragging the mouse to translate");
 303     adg_translatable_set_origin_explicit(ADG_TRANSLATABLE(toy_text),
 304                                          0., data->D3 / 2,
 305                                          10., 45. + 30. * 2);
 306     adg_container_add(ADG_CONTAINER(canvas), toy_text);
 307 }
 308
 309
 310 #if defined(CAIRO_HAS_PNG_FUNCTIONS) || defined(CAIRO_HAS_PDF_SURFACE) || defined(CAIRO_HAS_PS_SURFACE)
 311
 312 /* Only needed if there is at least one supported surface */
 313 static void
 314 file_generated(GtkWidget *caller, const gchar *file)
 315 {
 316     GtkWindow *window;
 317     GtkWidget *dialog;
 318
 319     window = (GtkWindow *) gtk_widget_get_toplevel(caller);
 320     dialog = gtk_message_dialog_new_with_markup(window, GTK_DIALOG_MODAL,
 321                                                 GTK_MESSAGE_INFO,
 322                                                 GTK_BUTTONS_CLOSE,
 323                                                 "The requested operation generated\n"
 324                                                 "<b>%s</b> in the current directory.",
 325                                                 file);
 326     gtk_window_set_title(GTK_WINDOW(dialog), "Operation completed");
 327     gtk_dialog_run(GTK_DIALOG(dialog));
 328     gtk_widget_destroy(dialog);
 329 }
 330
 331 #endif
 332
 333 #if !defined(CAIRO_HAS_PNG_FUNCTIONS) || !defined(CAIRO_HAS_PDF_SURFACE) || !defined(CAIRO_HAS_PS_SURFACE)
 334
 335 /* Only needed if there is a missing surface */
 336 static void
 337 missing_feature(GtkWidget *caller, const gchar *feature)
 338 {
 339     GtkWindow *window;
 340     GtkWidget *dialog;
 341
 342     window = (GtkWindow *) gtk_widget_get_toplevel(caller);
 343     dialog = gtk_message_dialog_new(window, GTK_DIALOG_MODAL,
 344                                     GTK_MESSAGE_WARNING,
 345                                     GTK_BUTTONS_OK,
 346                                     "The provided cairo library\n"
 347                                     "was compiled with no %s support!",
 348                                     feature);
 349     gtk_window_set_title(GTK_WINDOW(dialog), "Missing feature");
 350     gtk_dialog_run(GTK_DIALOG(dialog));
 351     gtk_widget_destroy(dialog);
 352 }
 353
 354 #endif
 355
 356
 357 #ifdef CAIRO_HAS_PNG_FUNCTIONS
 358
 359 static void
 360 to_png(AdgWidget *widget, GtkWidget *caller)
 361 {
 362     cairo_surface_t *surface;
 363     cairo_t *cr;
 364
 365     surface = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, 800, 600);
 366     cr = cairo_create(surface);
 367     cairo_surface_destroy(surface);
 368
 369     /* Rendering process */
 370     adg_entity_render(ADG_ENTITY(adg_widget_get_canvas(widget)), cr);
 371
 372     cairo_show_page(cr);
 373     cairo_surface_write_to_png(surface, "test.png");
 374     cairo_destroy(cr);
 375
 376     file_generated(caller, "test.png");
 377 }
 378
 379 #else
 380
 381 static void
 382 to_png(AdgWidget *widget, GtkWidget *caller)
 383 {
 384     missing_feature(caller, "PNG");
 385 }
 386
 387 #endif
 388
 389 #ifdef CAIRO_HAS_PDF_SURFACE
 390
 391 #include <cairo-pdf.h>
 392
 393 static void
 394 to_pdf(AdgWidget *widget, GtkWidget *caller)
 395 {
 396     cairo_surface_t *surface;
 397     cairo_t *cr;
 398
 399     surface = cairo_pdf_surface_create("test.pdf", 841, 595);
 400     cr = cairo_create(surface);
 401     cairo_surface_destroy(surface);
 402
 403     adg_entity_render(ADG_ENTITY(adg_widget_get_canvas(widget)), cr);
 404
 405     cairo_show_page(cr);
 406     cairo_destroy(cr);
 407
 408     file_generated(caller, "test.pdf");
 409 }
 410
 411 #else
 412
 413 static void
 414 to_pdf(AdgWidget *widget, GtkWidget *caller)
 415 {
 416     missing_feature(caller, "PDF");
 417 }
 418
 419 #endif
 420
 421 #ifdef CAIRO_HAS_PS_SURFACE
 422
 423 #include <cairo-ps.h>
 424
 425 static void
 426 to_ps(AdgWidget *widget, GtkWidget *caller)
 427 {
 428     cairo_surface_t *surface;
 429     cairo_t *cr;
 430
 431     /* Surface creation: A4 size */
 432     surface = cairo_ps_surface_create("test.ps", 841, 595);
 433     cairo_ps_surface_dsc_comment(surface,
 434                                  "%%Title: Automatic Drawing Generation (ADG) demo");
 435     cairo_ps_surface_dsc_comment(surface,
 436                                  "%%Copyright: Copyright (C) 2006-2009 Fontana Nicola");
 437     cairo_ps_surface_dsc_comment(surface, "%%Orientation: Portrait");
 438
 439     cairo_ps_surface_dsc_begin_setup(surface);
 440
 441     cairo_ps_surface_dsc_begin_page_setup(surface);
 442     cairo_ps_surface_dsc_comment(surface,
 443                                  "%%IncludeFeature: *PageSize A4");
 444
 445     cr = cairo_create(surface);
 446     cairo_surface_destroy(surface);
 447
 448     adg_entity_render(ADG_ENTITY(adg_widget_get_canvas(widget)), cr);
 449
 450     cairo_show_page(cr);
 451     cairo_destroy(cr);
 452
 453     file_generated(caller, "test.ps");
 454 }
 455
 456 #else
 457
 458 static void
 459 to_ps(AdgWidget *widget, GtkWidget *caller)
 460 {
 461     missing_feature(caller, "PostScript");
 462 }
 463
 464 #endif
 465
 466
 467 /**********************************************
 468  * Test case for basic operations,
 469  * such as chamfer and fillet
 470  **********************************************/
 471
 472 static AdgPath *        operations_chamfer      (const AdgPath  *path,
 473                                                  gdouble         delta1,
 474                                                  gdouble         delta2);
 475 static AdgPath *        operations_fillet       (const AdgPath  *path,
 476                                                  gdouble         radius);
 477
 478 static AdgCanvas *
 479 operations_canvas(void)
 480 {
 481     AdgPath *path, *chamfer_path, *fillet_path;
 482     AdgCanvas *canvas;
 483     AdgContainer *container;
 484     AdgEntity *entity;
 485     AdgMatrix transformation;
 486
 487     /* Build the base model */
 488     path = (AdgPath *) adg_path_new();
 489
 490     adg_path_move_to(path,  2,  0);
 491     adg_path_line_to(path,  0,  5);
 492     adg_path_line_to(path,  2,  2);
 493     adg_path_line_to(path,  0,  8);
 494     adg_path_line_to(path,  2,  8);
 495     adg_path_line_to(path,  2, 10);
 496     adg_path_line_to(path,  3, 10);
 497     adg_path_line_to(path, 10,  9);
 498     adg_path_line_to(path,  5,  5);
 499     adg_path_line_to(path,  3,  0);
 500     adg_path_close(path);
 501
 502     /* Build the chamfer model */
 503     chamfer_path = operations_chamfer(path, 0.25, 0.25);
 504
 505     /* Build the fillet model */
 506     fillet_path = operations_fillet(path, 0.20);
 507
 508     /* Create the canvas */
 509     canvas = adg_canvas_new();
 510
 511     /* Add the original shape */
 512     container = (AdgContainer *) adg_container_new();
 513     adg_container_add(ADG_CONTAINER(canvas), ADG_ENTITY(container));
 514     adg_container_add(container, adg_stroke_new(path));
 515     entity = adg_toy_text_new("Original shape");
 516     adg_translatable_set_origin_explicit(ADG_TRANSLATABLE(entity),
 517                                            5., 10.,
 518                                          -50., 20.);
 519     adg_container_add(ADG_CONTAINER(canvas), entity);
 520
 521     /* Add the shape with 0.25x0.25 chamfer */
 522     container = (AdgContainer *) adg_container_new();
 523     cairo_matrix_init_translate(&transformation, 15., 0.);
 524     adg_container_set_model_transformation(container, &transformation);
 525     adg_container_add(ADG_CONTAINER(canvas), ADG_ENTITY(container));
 526     adg_container_add(container, adg_stroke_new(chamfer_path));
 527     entity = adg_toy_text_new("Shape with 0.25x0.25 chamfer");
 528     adg_translatable_set_origin_explicit(ADG_TRANSLATABLE(entity),
 529                                            5., 10.,
 530                                         -120., 20.);
 531     adg_container_add(container, entity);
 532
 533     /* Add the shape with fillets with 0.20 of radius */
 534     container = (AdgContainer *) adg_container_new();
 535     cairo_matrix_init_translate(&transformation, 30., 0.);
 536     adg_container_set_model_transformation(container, &transformation);
 537     adg_container_add(ADG_CONTAINER(canvas), ADG_ENTITY(container));
 538     adg_container_add(container, adg_stroke_new(fillet_path));
 539     entity = adg_toy_text_new("Shape with R=20 fillet");
 540     adg_translatable_set_origin_explicit(ADG_TRANSLATABLE(entity),
 541                                            5., 10.,
 542                                          -90., 20.);
 543     adg_container_add(container, entity);
 544
 545     /* Set a decent start position and zoom */
 546     cairo_matrix_init_translate(&transformation, 10, -140);
 547     cairo_matrix_scale(&transformation, 15, 15);
 548     cairo_matrix_translate(&transformation, 0, 10);
 549     adg_container_set_model_transformation(ADG_CONTAINER(canvas), &transformation);
 550
 551     return canvas;
 552 }
 553
 554 static AdgPath *
 555 operations_chamfer(const AdgPath *model, gdouble delta1, gdouble delta2)
 556 {
 557     AdgPath *path;
 558     CpmlSegment segment;
 559     CpmlPrimitive primitive;
 560
 561     path = (AdgPath *) adg_path_new();
 562     cpml_segment_from_cairo(&segment, adg_path_get_cpml_path((AdgPath *) model));
 563     cpml_primitive_from_segment(&primitive, &segment);
 564
 565     adg_path_move_to(path, (primitive.org)->point.x, (primitive.org)->point.y);
 566
 567     do {
 568         adg_path_append_primitive(path, &primitive);
 569         if (primitive.data[0].header.type == CAIRO_PATH_LINE_TO)
 570             adg_path_chamfer(path, delta1, delta2);
 571     } while (cpml_primitive_next(&primitive));
 572
 573     return path;
 574 }
 575
 576 static AdgPath *
 577 operations_fillet(const AdgPath *model, gdouble radius)
 578 {
 579     AdgPath *path;
 580     CpmlSegment segment;
 581     CpmlPrimitive primitive;
 582
 583     path = (AdgPath *) adg_path_new();
 584     cpml_segment_from_cairo(&segment, adg_path_get_cpml_path((AdgPath *) model));
 585     cpml_primitive_from_segment(&primitive, &segment);
 586
 587     adg_path_move_to(path, (primitive.org)->point.x, (primitive.org)->point.y);
 588
 589     do {
 590         adg_path_append_primitive(path, &primitive);
 591         if (primitive.data[0].header.type == CAIRO_PATH_LINE_TO)
 592             adg_path_fillet(path, radius);
 593     } while (cpml_primitive_next(&primitive));
 594
 595     return path;
 596 }