demo/adg-demo.c

   1 #include <adg/adg.h>
   2 #include <math.h>
   3
   4 #include "demo.h"
   5
   6
   7 static AdgCanvas *      ldim_canvas             (void);
   8 static AdgCanvas *      drawing_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, *ldim, *drawing;
  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     ldim = (GtkWidget *) gtk_builder_get_object(builder, "areaLDim");
  45     adg_widget_set_canvas(ADG_WIDGET(ldim), ldim_canvas());
  46
  47     drawing = (GtkWidget *) gtk_builder_get_object(builder, "areaDrawing");
  48     adg_widget_set_canvas(ADG_WIDGET(drawing), drawing_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), drawing);
  57     g_signal_connect_swapped(gtk_builder_get_object(builder, "btnPdf"),
  58                              "clicked", G_CALLBACK(to_pdf), drawing);
  59     g_signal_connect_swapped(gtk_builder_get_object(builder, "btnPs"),
  60                              "clicked", G_CALLBACK(to_ps), drawing);
  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 simple example
  73  **********************************************/
  74
  75 static AdgCanvas *
  76 ldim_canvas(void)
  77 {
  78     AdgPath *path;
  79     AdgCanvas *canvas;
  80     AdgContainer *container;
  81     AdgEntity *entity;
  82     AdgMatrix transformation;
  83
  84     /* Build the path model */
  85     path = (AdgPath *) adg_path_new();
  86
  87     adg_path_move_to(path,  0,   0);
  88     adg_path_line_to(path,  0,  -5);
  89     adg_path_line_to(path,  2,  -5);
  90     adg_path_line_to(path,  2, -10);
  91     adg_path_line_to(path,  8, -10);
  92     adg_path_line_to(path,  8,  -5);
  93     adg_path_line_to(path, 10,  -5);
  94     adg_path_line_to(path, 10,   0);
  95     adg_path_close(path);
  96
  97     /* Populate the canvas */
  98     canvas = adg_canvas_new();
  99     container = (AdgContainer *) canvas;
 100
 101     entity = adg_stroke_new(path);
 102     adg_container_add(container, entity);
 103
 104     entity = adg_ldim_new_full_explicit(2, -10, 8, -10, ADG_DIR_UP, 0, -10);
 105     adg_container_add(container, entity);
 106
 107     entity = adg_ldim_new_full_explicit(0, -5, 10, -5, ADG_DIR_UP, 0, -10);
 108     adg_dim_set_level(ADG_DIM(entity), 2);
 109     adg_container_add(container, entity);
 110
 111     /* Set a decent starting pan position and zoom */
 112     cairo_matrix_init_translate(&transformation, 10, 80);
 113     cairo_matrix_scale(&transformation, 39, 39);
 114     cairo_matrix_translate(&transformation, 0, 10);
 115     adg_container_set_model_transformation(container, &transformation);
 116
 117     return canvas;
 118 }
 119
 120
 121 /**********************************************
 122  * A more complex example
 123  **********************************************/
 124
 125 #define SQRT3   1.732050808
 126 #define CHAMFER 0.3
 127
 128 typedef struct _DrawingData DrawingData;
 129
 130 struct _DrawingData {
 131     gdouble A, B, C;
 132     gdouble D1, D2, D3, D4, D5, D6, D7;
 133     gdouble RD34, RD56;
 134     gdouble LD2, LD3, LD5, LD6, LD7;
 135 };
 136
 137 static void     drawing_get             (DrawingData            *data);
 138 static AdgPath *drawing_path            (const DrawingData      *data);
 139 static void     drawing_add_dimensions  (AdgCanvas              *canvas,
 140                                          const DrawingData      *data);
 141 static void     drawing_add_stuff       (AdgCanvas              *canvas,
 142                                          const DrawingData      *data);
 143
 144
 145 static AdgCanvas *
 146 drawing_canvas(void)
 147 {
 148     DrawingData data;
 149     AdgPath *path;
 150     AdgCanvas *canvas;
 151     AdgContainer *container;
 152     AdgEntity *entity;
 153     AdgMatrix transformation;
 154
 155     drawing_get(&data);
 156     path = drawing_path(&data);
 157     canvas = adg_canvas_new();
 158     container = (AdgContainer *) canvas;
 159
 160     entity = adg_stroke_new(path);
 161     adg_container_add(container, entity);
 162
 163     drawing_add_dimensions(canvas, &data);
 164     drawing_add_stuff(canvas, &data);
 165
 166     cairo_matrix_init_translate(&transformation, 100, 70);
 167     cairo_matrix_scale(&transformation, 6.883, 6.883);
 168     cairo_matrix_translate(&transformation, 0, 10);
 169     adg_container_set_model_transformation(container, &transformation);
 170
 171     return canvas;
 172 }
 173
 174 static void
 175 drawing_get(DrawingData *data)
 176 {
 177     data->A = 52.3;
 178     data->B = 20.6;
 179     data->C = 2;
 180     data->D1 = 9.3;
 181     data->D2 = 6.5;
 182     data->D3 = 11.9;
 183     data->D4 = 6.5;
 184     data->D5 = 4.5;
 185     data->D6 = 7.2;
 186     data->D7 = 3.;
 187     data->RD34 = 1.;
 188     data->LD2 = 7.;
 189     data->LD3 = 3.5;
 190     data->LD5 = 5.;
 191     data->LD6 = 1.;
 192     data->LD7 = 0.5;
 193 }
 194
 195 static AdgPath *
 196 drawing_path(const DrawingData *data)
 197 {
 198     AdgPath *path;
 199     double x, y;
 200     cairo_path_t *cairo_path;
 201     CpmlSegment segment;
 202     cairo_matrix_t matrix;
 203
 204     path = (AdgPath *) adg_path_new();
 205
 206     adg_path_move_to(path, 0, data->D1 / 2);
 207     adg_path_line_to(path, data->A - data->B - data->LD2, data->D1 / 2);
 208     y = (data->D1 - data->D2) / 2;
 209     adg_path_line_to(path, data->A - data->B - data->LD2 + y * SQRT3, data->D1 / 2 - y);
 210     adg_path_line_to(path, data->A - data->B, data->D2 / 2);
 211     adg_path_fillet(path, 0.4);
 212     adg_path_line_to(path, data->A - data->B, data->D3 / 2);
 213     adg_path_chamfer(path, CHAMFER, CHAMFER);
 214     adg_path_line_to(path, data->A - data->B + data->LD3, data->D3 / 2);
 215     adg_path_chamfer(path, CHAMFER, CHAMFER);
 216     adg_path_line_to(path, data->A - data->B + data->LD3, data->D4 / 2);
 217     adg_path_fillet(path, data->RD34);
 218     adg_path_line_to(path, data->A - data->C - data->LD5, data->D4 / 2);
 219     y = (data->D4 - data->D5) / 2;
 220     adg_path_line_to(path, data->A - data->C - data->LD5 + y, data->D4 / 2 - y);
 221     adg_path_line_to(path, data->A - data->C, data->D5 / 2);
 222     adg_path_fillet(path, 0.2);
 223     adg_path_line_to(path, data->A - data->C, data->D6 / 2);
 224     adg_path_fillet(path, 0.1);
 225     adg_path_line_to(path, data->A - data->C + data->LD6, data->D6 / 2);
 226     x = data->C - data->LD7 - data->LD6;
 227     y = x / SQRT3;
 228     adg_path_line_to(path, data->A - data->C + data->LD6 + x, data->D6 / 2 - y);
 229     adg_path_line_to(path, data->A - data->LD7, data->D7 / 2);
 230     adg_path_line_to(path, data->A, data->D7 / 2);
 231
 232     /* Build the rounded shape by duplicating the current path, reflecting on
 233      * the y=0 axis, reversing it and joining the result to the current path */
 234     cairo_path = adg_path_dup_cpml_path(path);
 235
 236     cpml_segment_from_cairo(&segment, cairo_path);
 237     cpml_segment_reverse(&segment);
 238     adg_matrix_init_reflection(&matrix, 0);
 239     cpml_segment_transform(&segment, &matrix);
 240     cairo_path->data[0].header.type = CAIRO_PATH_LINE_TO;
 241
 242     adg_path_append_cairo_path(path, cairo_path);
 243
 244     g_free(cairo_path);
 245
 246     adg_path_close(path);
 247     return path;
 248 }
 249
 250 static void
 251 drawing_add_dimensions(AdgCanvas *canvas, const DrawingData *data)
 252 {
 253     AdgEntity *entity;
 254     double x, y;
 255
 256     /* NORTH */
 257
 258     /* LD2 */
 259     entity = adg_ldim_new_full_explicit(data->A - data->B - data->LD2, -data->D1 / 2, data->A - data->B,
 260                                         -data->D3 / 2 + CHAMFER, ADG_DIR_UP, 0,
 261                                         -data->D3 / 2);
 262     adg_container_add(ADG_CONTAINER(canvas), entity);
 263
 264     /* LD3 */
 265     entity = adg_ldim_new_full_explicit(data->A - data->B, -data->D3 / 2 + CHAMFER, data->A - data->B + data->LD3,
 266                                         -data->D3 / 2 + CHAMFER, ADG_DIR_UP, 0,
 267                                         -data->D3 / 2);
 268     adg_container_add(ADG_CONTAINER(canvas), entity);
 269
 270     /* SOUTH */
 271
 272     /* B */
 273     entity = adg_ldim_new_full_explicit(data->A - data->B, data->D3 / 2 - CHAMFER, data->A, data->D7 / 2,
 274                                         ADG_DIR_DOWN, 0, data->D3 / 2);
 275     adg_dim_set_tolerances(ADG_DIM(entity), "+0.1", NULL);
 276     adg_container_add(ADG_CONTAINER(canvas), entity);
 277
 278     /* A */
 279     entity = adg_ldim_new_full_explicit(0, data->D1 / 2, data->A, data->D7 / 2,
 280                                         ADG_DIR_DOWN, 0, data->D3 / 2);
 281     adg_dim_set_tolerances(ADG_DIM(entity), "+0.05", "-0.05");
 282     adg_dim_set_level(ADG_DIM(entity), 2);
 283     adg_container_add(ADG_CONTAINER(canvas), entity);
 284
 285     /* EAST */
 286
 287     /* D3 */
 288     x = data->A - data->B + data->LD3 - CHAMFER;
 289     entity = adg_ldim_new_full_explicit(x, -data->D3 / 2, x, data->D3 / 2,
 290                                         ADG_DIR_RIGHT, data->A, 0);
 291     adg_dim_set_tolerances(ADG_DIM(entity), "-0.25", NULL);
 292     adg_dim_set_level(ADG_DIM(entity), 5);
 293     adg_container_add(ADG_CONTAINER(canvas), entity);
 294
 295     /* D6 */
 296     x = data->A - data->C + data->LD6;
 297     entity = adg_ldim_new_full_explicit(x, -data->D6 / 2, x, data->D6 / 2,
 298                                         ADG_DIR_RIGHT, data->A, 0);
 299     adg_dim_set_tolerances(ADG_DIM(entity), "-0.1", NULL);
 300     adg_dim_set_level(ADG_DIM(entity), 4);
 301     adg_container_add(ADG_CONTAINER(canvas), entity);
 302
 303     /* D4 */
 304     x = data->A - data->C - data->LD5;
 305     entity = adg_ldim_new_full_explicit(x, -data->D4 / 2, x, data->D4 / 2,
 306                                         ADG_DIR_RIGHT, data->A, 0);
 307     adg_dim_set_level(ADG_DIM(entity), 3);
 308     adg_container_add(ADG_CONTAINER(canvas), entity);
 309
 310     /* D5 */
 311     x = data->A - data->C;
 312     entity = adg_ldim_new_full_explicit(x, -data->D5 / 2, x, data->D5 / 2,
 313                                         ADG_DIR_RIGHT, data->A, 0);
 314     adg_dim_set_tolerances(ADG_DIM(entity), "-0.1", NULL);
 315     adg_dim_set_level(ADG_DIM(entity), 2);
 316     adg_container_add(ADG_CONTAINER(canvas), entity);
 317
 318     /* D7 */
 319     entity = adg_ldim_new_full_explicit(data->A, -data->D7 / 2, data->A, data->D7 / 2,
 320                                         ADG_DIR_RIGHT, data->A, 0);
 321     adg_container_add(ADG_CONTAINER(canvas), entity);
 322
 323     /* WEST */
 324
 325     /* D1 */
 326     entity = adg_ldim_new_full_explicit(0, -data->D1 / 2, 0, data->D1 / 2,
 327                                         ADG_DIR_LEFT, 0, 0);
 328     adg_dim_set_tolerances(ADG_DIM(entity), "+0.05", "-0.05");
 329     adg_dim_set_level(ADG_DIM(entity), 2);
 330     adg_container_add(ADG_CONTAINER(canvas), entity);
 331
 332     /* D2 */
 333     y = (data->D1 - data->D2) / 2;
 334     x = data->A - data->B - data->LD2 + y * SQRT3;
 335     entity = adg_ldim_new_full_explicit(x, -data->D2 / 2, x, data->D2 / 2,
 336                                         ADG_DIR_LEFT, 0, 0);
 337     adg_dim_set_tolerances(ADG_DIM(entity), "-0.1", NULL);
 338     adg_container_add(ADG_CONTAINER(canvas), entity);
 339 }
 340
 341 static void
 342 drawing_add_stuff(AdgCanvas *canvas, const DrawingData *data)
 343 {
 344     AdgEntity *toy_text;
 345
 346     toy_text = adg_toy_text_new("Horizontal toy_text above the piston");
 347     adg_translatable_set_origin_explicit(ADG_TRANSLATABLE(toy_text),
 348                                          0., -data->D1 / 2,
 349                                          0., -5.);
 350     adg_container_add(ADG_CONTAINER(canvas), toy_text);
 351
 352     toy_text = adg_toy_text_new("toy_text");
 353     adg_translatable_set_origin_explicit(ADG_TRANSLATABLE(toy_text),
 354                                          0., data->D1 / 2,
 355                                          0., -5.);
 356     adg_rotable_set_angle(ADG_ROTABLE(toy_text), M_PI * 3./2.);
 357     adg_container_add(ADG_CONTAINER(canvas), toy_text);
 358 }
 359
 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 at least one supported surface */
 364 static void
 365 file_generated(GtkWidget *caller, const gchar *file)
 366 {
 367     GtkWindow *window;
 368     GtkWidget *dialog;
 369
 370     window = (GtkWindow *) gtk_widget_get_toplevel(caller);
 371     dialog = gtk_message_dialog_new_with_markup(window, GTK_DIALOG_MODAL,
 372                                                 GTK_MESSAGE_INFO,
 373                                                 GTK_BUTTONS_CLOSE,
 374                                                 "The requested operation generated\n"
 375                                                 "<b>%s</b> in the current directory.",
 376                                                 file);
 377     gtk_window_set_title(GTK_WINDOW(dialog), "Operation completed");
 378     gtk_dialog_run(GTK_DIALOG(dialog));
 379     gtk_widget_destroy(dialog);
 380 }
 381
 382 #endif
 383
 384 #if !defined(CAIRO_HAS_PNG_FUNCTIONS) || !defined(CAIRO_HAS_PDF_SURFACE) || !defined(CAIRO_HAS_PS_SURFACE)
 385
 386 /* Only needed if there is a missing surface */
 387 static void
 388 missing_feature(GtkWidget *caller, const gchar *feature)
 389 {
 390     GtkWindow *window;
 391     GtkWidget *dialog;
 392
 393     window = (GtkWindow *) gtk_widget_get_toplevel(caller);
 394     dialog = gtk_message_dialog_new(window, GTK_DIALOG_MODAL,
 395                                     GTK_MESSAGE_WARNING,
 396                                     GTK_BUTTONS_OK,
 397                                     "The provided cairo library\n"
 398                                     "was compiled with no %s support!",
 399                                     feature);
 400     gtk_window_set_title(GTK_WINDOW(dialog), "Missing feature");
 401     gtk_dialog_run(GTK_DIALOG(dialog));
 402     gtk_widget_destroy(dialog);
 403 }
 404
 405 #endif
 406
 407
 408 #ifdef CAIRO_HAS_PNG_FUNCTIONS
 409
 410 static void
 411 to_png(AdgWidget *widget, GtkWidget *caller)
 412 {
 413     cairo_surface_t *surface;
 414     cairo_t *cr;
 415
 416     surface = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, 800, 600);
 417     cr = cairo_create(surface);
 418     cairo_surface_destroy(surface);
 419
 420     /* Rendering process */
 421     adg_entity_render(ADG_ENTITY(adg_widget_get_canvas(widget)), cr);
 422
 423     cairo_show_page(cr);
 424     cairo_surface_write_to_png(surface, "test.png");
 425     cairo_destroy(cr);
 426
 427     file_generated(caller, "test.png");
 428 }
 429
 430 #else
 431
 432 static void
 433 to_png(AdgWidget *widget, GtkWidget *caller)
 434 {
 435     missing_feature(caller, "PNG");
 436 }
 437
 438 #endif
 439
 440 #ifdef CAIRO_HAS_PDF_SURFACE
 441
 442 #include <cairo-pdf.h>
 443
 444 static void
 445 to_pdf(AdgWidget *widget, GtkWidget *caller)
 446 {
 447     cairo_surface_t *surface;
 448     cairo_t *cr;
 449
 450     surface = cairo_pdf_surface_create("test.pdf", 841, 595);
 451     cr = cairo_create(surface);
 452     cairo_surface_destroy(surface);
 453
 454     adg_entity_render(ADG_ENTITY(adg_widget_get_canvas(widget)), cr);
 455
 456     cairo_show_page(cr);
 457     cairo_destroy(cr);
 458
 459     file_generated(caller, "test.pdf");
 460 }
 461
 462 #else
 463
 464 static void
 465 to_pdf(AdgWidget *widget, GtkWidget *caller)
 466 {
 467     missing_feature(caller, "PDF");
 468 }
 469
 470 #endif
 471
 472 #ifdef CAIRO_HAS_PS_SURFACE
 473
 474 #include <cairo-ps.h>
 475
 476 static void
 477 to_ps(AdgWidget *widget, GtkWidget *caller)
 478 {
 479     cairo_surface_t *surface;
 480     cairo_t *cr;
 481
 482     /* Surface creation: A4 size */
 483     surface = cairo_ps_surface_create("test.ps", 841, 595);
 484     cairo_ps_surface_dsc_comment(surface,
 485                                  "%%Title: Automatic Drawing Generation (Adg) demo");
 486     cairo_ps_surface_dsc_comment(surface,
 487                                  "%%Copyright: Copyright (C) 2006 Fontana Nicola");
 488     cairo_ps_surface_dsc_comment(surface, "%%Orientation: Portrait");
 489
 490     cairo_ps_surface_dsc_begin_setup(surface);
 491
 492     cairo_ps_surface_dsc_begin_page_setup(surface);
 493     cairo_ps_surface_dsc_comment(surface,
 494                                  "%%IncludeFeature: *PageSize A4");
 495
 496     cr = cairo_create(surface);
 497     cairo_surface_destroy(surface);
 498
 499     adg_entity_render(ADG_ENTITY(adg_widget_get_canvas(widget)), cr);
 500
 501     cairo_show_page(cr);
 502     cairo_destroy(cr);
 503
 504     file_generated(caller, "test.ps");
 505 }
 506
 507 #else
 508
 509 static void
 510 to_ps(AdgWidget *widget, GtkWidget *caller)
 511 {
 512     missing_feature(caller, "PostScript");
 513 }
 514
 515 #endif