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