demo/adg-demo.c

   1 #include <adg-gtk.h>
   2 #include <math.h>
   3
   4 #include "demo.h"
   5
   6
   7 #define SQRT3   1.732050808
   8 #define CHAMFER 0.3
   9
  10
  11 typedef struct _AdgPart AdgPart;
  12
  13 struct _AdgPart {
  14     /* Raw data */
  15     gdouble     A, B, C;
  16     gdouble     DHOLE, LHOLE;
  17     gdouble     D1, D2, D3, D4, D5, D6, D7;
  18     gdouble     RD34, RD56;
  19     gdouble     LD2, LD3, LD5, LD6, LD7;
  20
  21     /* User interface widgets */
  22     AdgGtkArea *area;
  23     GHashTable *widgets;
  24     GtkButton  *apply, *reset;
  25
  26     /* Models */
  27     AdgPath    *shape, *hatch;
  28     AdgEdges   *edges;
  29 };
  30
  31
  32 static void
  33 _adg_version(void)
  34 {
  35     g_print("adg-demo " PACKAGE_VERSION "\n");
  36     exit(0);
  37 }
  38
  39 static void
  40 _adg_parse_args(gint *p_argc, gchar **p_argv[], gboolean *show_extents)
  41 {
  42     GError *error = NULL;
  43     GOptionEntry entries[] = {
  44         {"version", 'V', G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK,
  45          _adg_version, "Display version information", NULL},
  46         {"show-extents", 'E', 0, G_OPTION_ARG_NONE,
  47          NULL, "Show the boundary boxes of every entity", NULL},
  48         {NULL}
  49     };
  50
  51     entries[1].arg_data = show_extents;
  52     *show_extents = FALSE;
  53     gtk_init_with_args(p_argc, p_argv, "- ADG demonstration program",
  54                        entries, GETTEXT_PACKAGE, &error);
  55
  56     if (error != NULL) {
  57         gint error_code = error->code;
  58
  59         g_printerr("%s\n", error->message);
  60
  61         g_error_free(error);
  62         exit(error_code);
  63     }
  64 }
  65
  66 static void
  67 _adg_define_hole(AdgPath *path, const AdgPart *part, gdouble height)
  68 {
  69     AdgModel *model;
  70     AdgPair pair;
  71
  72     model = ADG_MODEL(path);
  73
  74     pair.x = part->LHOLE;
  75     pair.y = 0;
  76     adg_path_move_to(path, &pair);
  77     adg_model_set_named_pair(model, "LHOLE", &pair);
  78
  79     pair.y = part->DHOLE / 2;
  80     pair.x -= pair.y / SQRT3;
  81     adg_path_line_to(path, &pair);
  82
  83     pair.x = 0;
  84     adg_path_line_to(path, &pair);
  85     adg_model_set_named_pair(model, "DHOLE", &pair);
  86
  87     pair.y = part->D1 / 2;
  88     adg_path_line_to(path, &pair);
  89     adg_model_set_named_pair(model, "D1I", &pair);
  90
  91     pair.x = height;
  92     adg_path_line_to(path, &pair);
  93     adg_model_set_named_pair(model, "D1F", &pair);
  94 }
  95
  96 static void
  97 _adg_define_hatch(AdgPath *path, const AdgPart *part)
  98 {
  99     _adg_define_hole(path, part, part->LHOLE + 2);
 100     adg_path_reflect(path, NULL);
 101     adg_path_close(path);
 102 }
 103
 104 static void
 105 _adg_define_shape(AdgPath *path, const AdgPart *part)
 106 {
 107     AdgModel *model;
 108     AdgPair pair, tmp;
 109     const AdgPrimitive *primitive;
 110
 111     pair.x = part->A - part->B - part->LD2;
 112     _adg_define_hole(path, part, pair.x);
 113     model = ADG_MODEL(path);
 114
 115     pair.x += (part->D1 - part->D2) / 2;
 116     pair.y = part->D2 / 2;
 117     adg_path_line_to(path, &pair);
 118     adg_model_set_named_pair(model, "D2I", &pair);
 119
 120     pair.x = part->A - part->B;
 121     adg_path_line_to(path, &pair);
 122     adg_path_fillet(path, 0.4);
 123
 124     pair.x = part->A - part->B;
 125     pair.y = part->D3 / 2;
 126     adg_path_line_to(path, &pair);
 127     adg_model_set_named_pair(model, "D3I", &pair);
 128
 129     pair.x = part->A;
 130     adg_model_set_named_pair(model, "East", &pair);
 131
 132     pair.x = 0;
 133     adg_model_set_named_pair(model, "West", &pair);
 134
 135     adg_path_chamfer(path, CHAMFER, CHAMFER);
 136
 137     pair.x = part->A - part->B + part->LD3;
 138     pair.y = part->D3 / 2;
 139     adg_path_line_to(path, &pair);
 140
 141     primitive = adg_path_over_primitive(path);
 142     cpml_pair_from_cairo(&tmp, cpml_primitive_get_point(primitive, 0));
 143     adg_model_set_named_pair(model, "D3I_X", &tmp);
 144
 145     cpml_pair_from_cairo(&tmp, cpml_primitive_get_point(primitive, -1));
 146     adg_model_set_named_pair(model, "D3I_Y", &tmp);
 147
 148     adg_path_chamfer(path, CHAMFER, CHAMFER);
 149
 150     pair.y = part->D4 / 2;
 151     adg_path_line_to(path, &pair);
 152
 153     primitive = adg_path_over_primitive(path);
 154     cpml_pair_from_cairo(&tmp, cpml_primitive_get_point(primitive, 0));
 155     adg_model_set_named_pair(model, "D3F_Y", &tmp);
 156     cpml_pair_from_cairo(&tmp, cpml_primitive_get_point(primitive, -1));
 157     adg_model_set_named_pair(model, "D3F_X", &tmp);
 158
 159     adg_path_fillet(path, part->RD34);
 160
 161     pair.x += part->RD34;
 162     adg_model_set_named_pair(model, "D4I", &pair);
 163
 164     pair.x = part->A - part->C - part->LD5;
 165     adg_path_line_to(path, &pair);
 166     adg_model_set_named_pair(model, "D4F", &pair);
 167
 168     pair.y = part->D3 / 2;
 169     adg_model_set_named_pair(model, "D4_POS", &pair);
 170
 171     primitive = adg_path_over_primitive(path);
 172     cpml_pair_from_cairo(&tmp, cpml_primitive_get_point(primitive, 0));
 173     tmp.x += part->RD34;
 174     adg_model_set_named_pair(model, "RD34", &tmp);
 175
 176     tmp.x -= cos(G_PI_4) * part->RD34,
 177     tmp.y -= sin(G_PI_4) * part->RD34,
 178     adg_model_set_named_pair(model, "RD34_R", &tmp);
 179
 180     tmp.x += part->RD34,
 181     tmp.y += part->RD34,
 182     adg_model_set_named_pair(model, "RD34_XY", &tmp);
 183
 184     pair.x += (part->D4 - part->D5) / 2;
 185     pair.y = part->D5 / 2;
 186     adg_path_line_to(path, &pair);
 187     adg_model_set_named_pair(model, "D5I", &pair);
 188
 189     pair.x = part->A - part->C;
 190     adg_path_line_to(path, &pair);
 191
 192     adg_path_fillet(path, 0.2);
 193
 194     pair.y = part->D6 / 2;
 195     adg_path_line_to(path, &pair);
 196
 197     primitive = adg_path_over_primitive(path);
 198     cpml_pair_from_cairo(&tmp, cpml_primitive_get_point(primitive, 0));
 199     adg_model_set_named_pair(model, "D5F", &tmp);
 200
 201     adg_path_fillet(path, 0.1);
 202
 203     pair.x += part->LD6;
 204     adg_path_line_to(path, &pair);
 205     adg_model_set_named_pair(model, "D6F", &pair);
 206
 207     primitive = adg_path_over_primitive(path);
 208     cpml_pair_from_cairo(&tmp, cpml_primitive_get_point(primitive, 0));
 209     adg_model_set_named_pair(model, "D6I_X", &tmp);
 210
 211     primitive = adg_path_over_primitive(path);
 212     cpml_pair_from_cairo(&tmp, cpml_primitive_get_point(primitive, -1));
 213     adg_model_set_named_pair(model, "D6I_Y", &tmp);
 214
 215     pair.x = part->A - part->LD7;
 216     pair.y -= (part->C - part->LD7 - part->LD6) / SQRT3;
 217     adg_path_line_to(path, &pair);
 218     adg_model_set_named_pair(model, "D67", &pair);
 219
 220     pair.y = part->D7 / 2;
 221     adg_path_line_to(path, &pair);
 222
 223     pair.x = part->A;
 224     adg_path_line_to(path, &pair);
 225     adg_model_set_named_pair(model, "D7F", &pair);
 226
 227     adg_path_reflect(path, NULL);
 228     adg_path_close(path);
 229     adg_path_move_to_explicit(path, part->LHOLE + 2, part->D1 / 2);
 230     adg_path_line_to_explicit(path, part->LHOLE + 2, -part->D1 / 2);
 231 }
 232
 233 static void
 234 _adg_part_lock(AdgPart *part)
 235 {
 236     gtk_widget_set_sensitive(GTK_WIDGET(part->apply), FALSE);
 237     gtk_widget_set_sensitive(GTK_WIDGET(part->reset), FALSE);
 238 }
 239
 240 static void
 241 _adg_part_unlock(AdgPart *part)
 242 {
 243     gtk_widget_set_sensitive(GTK_WIDGET(part->apply), TRUE);
 244     gtk_widget_set_sensitive(GTK_WIDGET(part->reset), TRUE);
 245 }
 246
 247 static void
 248 _adg_part_link(AdgPart *part, gpointer data, GObject *widget)
 249 {
 250     g_assert(GTK_IS_WIDGET(widget));
 251     g_object_ref(widget);
 252     g_hash_table_insert(part->widgets, data, widget);
 253
 254     if (GTK_IS_SPIN_BUTTON(widget)) {
 255         GtkSpinButton *spin_button = GTK_SPIN_BUTTON(widget);
 256         gtk_adjustment_value_changed(gtk_spin_button_get_adjustment(spin_button));
 257     }
 258
 259     g_signal_connect_swapped(widget, "changed",
 260                              G_CALLBACK(_adg_part_unlock), part);
 261 }
 262
 263 static void
 264 _adg_part_ui_to_data_double(AdgPart *part, gdouble *data)
 265 {
 266     GtkWidget *widget = g_hash_table_lookup(part->widgets, data);
 267
 268     g_assert(GTK_IS_WIDGET(widget));
 269
 270     *data = gtk_spin_button_get_value(GTK_SPIN_BUTTON(widget));
 271 }
 272
 273 static void
 274 _adg_part_data_to_ui_double(AdgPart *part, gdouble *data)
 275 {
 276     GtkWidget *widget = g_hash_table_lookup(part->widgets, data);
 277
 278     g_assert(GTK_IS_WIDGET(widget));
 279
 280     gtk_spin_button_set_value(GTK_SPIN_BUTTON(widget), *data);
 281 }
 282
 283 static void
 284 _adg_part_data_to_ui(AdgPart *part)
 285 {
 286     _adg_part_data_to_ui_double(part, &part->A);
 287     _adg_part_data_to_ui_double(part, &part->B);
 288     _adg_part_data_to_ui_double(part, &part->C);
 289     _adg_part_data_to_ui_double(part, &part->DHOLE);
 290     _adg_part_data_to_ui_double(part, &part->LHOLE);
 291     _adg_part_data_to_ui_double(part, &part->D1);
 292     _adg_part_data_to_ui_double(part, &part->D2);
 293     _adg_part_data_to_ui_double(part, &part->LD2);
 294     _adg_part_data_to_ui_double(part, &part->D3);
 295     _adg_part_data_to_ui_double(part, &part->LD3);
 296     _adg_part_data_to_ui_double(part, &part->D4);
 297     //_adg_part_data_to_ui_double(part, &part->D5);
 298     _adg_part_data_to_ui_double(part, &part->D6);
 299     //_adg_part_data_to_ui_double(part, &part->LD6);
 300     _adg_part_data_to_ui_double(part, &part->D7);
 301     //_adg_part_data_to_ui_double(part, &part->LD7);
 302     _adg_part_lock(part);
 303 }
 304
 305 static void
 306 _adg_part_ui_to_data(AdgPart *part)
 307 {
 308     _adg_part_ui_to_data_double(part, &part->A);
 309     _adg_part_ui_to_data_double(part, &part->B);
 310     _adg_part_ui_to_data_double(part, &part->C);
 311     _adg_part_ui_to_data_double(part, &part->DHOLE);
 312     _adg_part_ui_to_data_double(part, &part->LHOLE);
 313     _adg_part_ui_to_data_double(part, &part->D1);
 314     _adg_part_ui_to_data_double(part, &part->D2);
 315     _adg_part_ui_to_data_double(part, &part->LD2);
 316     _adg_part_ui_to_data_double(part, &part->D3);
 317     _adg_part_ui_to_data_double(part, &part->LD3);
 318     _adg_part_ui_to_data_double(part, &part->D4);
 319     //_adg_part_ui_to_data_double(part, &part->D5);
 320     _adg_part_ui_to_data_double(part, &part->D6);
 321     //_adg_part_ui_to_data_double(part, &part->LD6);
 322     _adg_part_ui_to_data_double(part, &part->D7);
 323     //_adg_part_ui_to_data_double(part, &part->LD7);
 324
 325     _adg_part_lock(part);
 326
 327     adg_model_clear(ADG_MODEL(part->shape));
 328     _adg_define_shape(part->shape, part);
 329     adg_model_changed(ADG_MODEL(part->shape));
 330
 331     adg_model_clear(ADG_MODEL(part->hatch));
 332     _adg_define_hatch(part->hatch, part);
 333     adg_model_changed(ADG_MODEL(part->hatch));
 334
 335     adg_model_clear(ADG_MODEL(part->edges));
 336     adg_model_changed(ADG_MODEL(part->edges));
 337
 338     //adg_entity_invalidate(ADG_ENTITY(adg_gtk_area_get_canvas(part->area)));
 339     gtk_widget_queue_draw(GTK_WIDGET(part->area));
 340 }
 341
 342 static AdgPart *
 343 _adg_part_new(GtkBuilder *builder)
 344 {
 345     AdgPart *part;
 346
 347     part = g_new0(AdgPart, 1);
 348     part->widgets = g_hash_table_new_full(g_direct_hash, g_direct_equal,
 349                                           NULL, g_object_unref);
 350     part->area = (AdgGtkArea *) gtk_builder_get_object(builder, "mainCanvas");
 351     part->apply = (GtkButton *) gtk_builder_get_object(builder, "editApply");
 352     part->reset = (GtkButton *) gtk_builder_get_object(builder, "editReset");
 353     part->shape = adg_path_new();
 354     part->hatch = adg_path_new();
 355     part->edges = adg_edges_new_with_source(ADG_TRAIL(part->shape));
 356
 357     g_assert(ADG_GTK_IS_AREA(part->area));
 358     g_assert(GTK_IS_BUTTON(part->apply));
 359     g_assert(GTK_IS_BUTTON(part->reset));
 360
 361     _adg_part_link(part, &part->A, gtk_builder_get_object(builder, "editA"));
 362     _adg_part_link(part, &part->B, gtk_builder_get_object(builder, "editB"));
 363     _adg_part_link(part, &part->C, gtk_builder_get_object(builder, "editC"));
 364     _adg_part_link(part, &part->DHOLE, gtk_builder_get_object(builder, "editDHOLE"));
 365     _adg_part_link(part, &part->LHOLE, gtk_builder_get_object(builder, "editLHOLE"));
 366     _adg_part_link(part, &part->D1, gtk_builder_get_object(builder, "editD1"));
 367     _adg_part_link(part, &part->D2, gtk_builder_get_object(builder, "editD2"));
 368     _adg_part_link(part, &part->LD2, gtk_builder_get_object(builder, "editLD2"));
 369     _adg_part_link(part, &part->D3, gtk_builder_get_object(builder, "editD3"));
 370     _adg_part_link(part, &part->LD3, gtk_builder_get_object(builder, "editLD3"));
 371     _adg_part_link(part, &part->D4, gtk_builder_get_object(builder, "editD4"));
 372     //_adg_part_link(part, &part->D5, gtk_builder_get_object(builder, "editD5"));
 373     _adg_part_link(part, &part->D6, gtk_builder_get_object(builder, "editD6"));
 374     //_adg_part_link(part, &part->LD6, gtk_builder_get_object(builder, "editLD6"));
 375     _adg_part_link(part, &part->D7, gtk_builder_get_object(builder, "editD7"));
 376     //_adg_part_link(part, &part->LD7, gtk_builder_get_object(builder, "editLD7"));
 377
 378     part->D5 = 4.5;
 379     part->RD34 = 1;
 380     part->LD5 = 5;
 381     part->LD6 = 1;
 382     part->LD7 = 0.5;
 383
 384     _adg_part_ui_to_data(part);
 385
 386     return part;
 387 }
 388
 389 static void
 390 _adg_part_destroy(AdgPart *part)
 391 {
 392     g_hash_table_destroy(part->widgets);
 393     g_free(part);
 394 }
 395
 396 static void
 397 _adg_demo_canvas_add_sheet(AdgCanvas *canvas)
 398 {
 399     AdgTitleBlock *title_block;
 400     AdgLogo *logo;
 401     AdgMatrix map;
 402
 403     title_block = adg_title_block_new();
 404
 405     logo = adg_logo_new();
 406     cairo_matrix_init_scale(&map, 2, 2);
 407     adg_entity_set_global_map(ADG_ENTITY(logo), &map);
 408
 409     g_object_set(title_block,
 410                  "title", "SAMPLE DRAWING",
 411                  "author", "NtD",
 412                  "date", "",
 413                  "drawing", "TEST123",
 414                  "logo", logo,
 415                  "projection", adg_projection_new(ADG_PROJECTION_FIRST_ANGLE),
 416                  "scale", "NONE",
 417                  "size", "A4",
 418                  NULL);
 419
 420     cairo_matrix_init_translate(&map, 300, 150);
 421     adg_entity_set_global_map(ADG_ENTITY(title_block), &map);
 422
 423     adg_container_add(ADG_CONTAINER(canvas), ADG_ENTITY(title_block));
 424 }
 425
 426 static void
 427 _adg_demo_canvas_add_dimensions(AdgCanvas *canvas, AdgModel *model)
 428 {
 429     AdgLDim *ldim;
 430     AdgADim *adim;
 431     AdgRDim *rdim;
 432
 433     /* NORTH */
 434     adim = adg_adim_new_full_from_model(model, "-D1I", "-D1F",
 435                                         "-D1F", "-D2I", "-D1F");
 436     adg_dim_set_level(ADG_DIM(adim), 2);
 437     adg_container_add(ADG_CONTAINER(canvas), ADG_ENTITY(adim));
 438
 439     ldim = adg_ldim_new_full_from_model(model, "-D1F", "-D3I_X", "-D3F_Y",
 440                                         ADG_DIR_UP);
 441     adg_dim_set_outside(ADG_DIM(ldim), ADG_THREE_STATE_OFF);
 442     adg_container_add(ADG_CONTAINER(canvas), ADG_ENTITY(ldim));
 443
 444     ldim = adg_ldim_new_full_from_model(model, "-D3I_X", "-D3F_X", "-D3F_Y",
 445                                         ADG_DIR_UP);
 446     adg_ldim_switch_extension1(ldim, FALSE);
 447     adg_dim_set_outside(ADG_DIM(ldim), ADG_THREE_STATE_OFF);
 448     adg_container_add(ADG_CONTAINER(canvas), ADG_ENTITY(ldim));
 449
 450     ldim = adg_ldim_new_full_from_model(model, "-D6I_X", "-D67", "-East",
 451                                         ADG_DIR_UP);
 452     adg_dim_set_level(ADG_DIM(ldim), 0);
 453     adg_ldim_switch_extension1(ldim, FALSE);
 454     adg_container_add(ADG_CONTAINER(canvas), ADG_ENTITY(ldim));
 455
 456     ldim = adg_ldim_new_full_from_model(model, "-D6I_X", "-D7F", "-East",
 457                                         ADG_DIR_UP);
 458     adg_dim_set_limits(ADG_DIM(ldim), "-0.06", NULL);
 459     adg_container_add(ADG_CONTAINER(canvas), ADG_ENTITY(ldim));
 460
 461     adim = adg_adim_new_full_from_model(model, "-D6I_Y", "-D6F",
 462                                         "-D6F", "-D67", "-D6F");
 463     adg_dim_set_level(ADG_DIM(adim), 2);
 464     adg_container_add(ADG_CONTAINER(canvas), ADG_ENTITY(adim));
 465
 466     rdim = adg_rdim_new_full_from_model(model, "-RD34", "-RD34_R", "-RD34_XY");
 467     adg_container_add(ADG_CONTAINER(canvas), ADG_ENTITY(rdim));
 468
 469
 470     /* SOUTH */
 471     ldim = adg_ldim_new_full_from_model(model, "D1I", "LHOLE", "D3F_Y",
 472                                         ADG_DIR_DOWN);
 473     adg_ldim_switch_extension1(ldim, FALSE);
 474     adg_container_add(ADG_CONTAINER(canvas), ADG_ENTITY(ldim));
 475
 476     ldim = adg_ldim_new_full_from_model(model, "D4F", "D6I_X", "D4_POS",
 477                                         ADG_DIR_DOWN);
 478     adg_dim_set_limits(ADG_DIM(ldim), NULL, "+0.2");
 479     adg_dim_set_outside(ADG_DIM(ldim), ADG_THREE_STATE_OFF);
 480     adg_container_add(ADG_CONTAINER(canvas), ADG_ENTITY(ldim));
 481
 482     ldim = adg_ldim_new_full_from_model(model, "D3I_X", "D7F", "D3F_Y",
 483                                         ADG_DIR_DOWN);
 484     adg_dim_set_limits(ADG_DIM(ldim), NULL, "+0.1");
 485     adg_dim_set_level(ADG_DIM(ldim), 2);
 486     adg_ldim_switch_extension2(ldim, FALSE);
 487     adg_container_add(ADG_CONTAINER(canvas), ADG_ENTITY(ldim));
 488
 489     ldim = adg_ldim_new_full_from_model(model, "D1I", "D7F", "D3F_Y",
 490                                         ADG_DIR_DOWN);
 491     adg_dim_set_limits(ADG_DIM(ldim), "-0.05", "+0.05");
 492     adg_dim_set_level(ADG_DIM(ldim), 3);
 493     adg_container_add(ADG_CONTAINER(canvas), ADG_ENTITY(ldim));
 494
 495     adim = adg_adim_new_full_from_model(model, "D4F", "D4I",
 496                                         "D5I", "D4F", "D4F");
 497     adg_dim_set_level(ADG_DIM(adim), 1.5);
 498     adg_container_add(ADG_CONTAINER(canvas), ADG_ENTITY(adim));
 499
 500
 501     /* EAST */
 502     ldim = adg_ldim_new_full_from_model(model, "D6F", "-D6F", "East",
 503                                         ADG_DIR_RIGHT);
 504     adg_dim_set_limits(ADG_DIM(ldim), "-0.1", NULL);
 505     adg_dim_set_level(ADG_DIM(ldim), 4);
 506     adg_container_add(ADG_CONTAINER(canvas), ADG_ENTITY(ldim));
 507
 508     ldim = adg_ldim_new_full_from_model(model, "D4F", "-D4F", "East",
 509                                         ADG_DIR_RIGHT);
 510     adg_dim_set_level(ADG_DIM(ldim), 3);
 511     adg_container_add(ADG_CONTAINER(canvas), ADG_ENTITY(ldim));
 512
 513     ldim = adg_ldim_new_full_from_model(model, "D5F", "-D5F", "East",
 514                                         ADG_DIR_RIGHT);
 515     adg_dim_set_limits(ADG_DIM(ldim), "-0.1", NULL);
 516     adg_dim_set_level(ADG_DIM(ldim), 2);
 517     adg_container_add(ADG_CONTAINER(canvas), ADG_ENTITY(ldim));
 518
 519     ldim = adg_ldim_new_full_from_model(model, "D7F", "-D7F", "East",
 520                                         ADG_DIR_RIGHT);
 521     adg_container_add(ADG_CONTAINER(canvas), ADG_ENTITY(ldim));
 522
 523
 524     /* WEST */
 525     ldim = adg_ldim_new_full_from_model(model, "D3I_Y", "-D3I_Y", "-West",
 526                                         ADG_DIR_LEFT);
 527     adg_dim_set_limits(ADG_DIM(ldim), "-0.25", NULL);
 528     adg_dim_set_level(ADG_DIM(ldim), 4);
 529     adg_container_add(ADG_CONTAINER(canvas), ADG_ENTITY(ldim));
 530
 531     ldim = adg_ldim_new_full_from_model(model, "D1I", "-D1I", "-West",
 532                                         ADG_DIR_LEFT);
 533     adg_dim_set_limits(ADG_DIM(ldim), "+0.05", "-0.05");
 534     adg_dim_set_level(ADG_DIM(ldim), 3);
 535     adg_container_add(ADG_CONTAINER(canvas), ADG_ENTITY(ldim));
 536
 537     ldim = adg_ldim_new_full_from_model(model, "D2I", "-D2I", "-West",
 538                                         ADG_DIR_LEFT);
 539     adg_dim_set_limits(ADG_DIM(ldim), "-0.1", NULL);
 540     adg_dim_set_level(ADG_DIM(ldim), 2);
 541     adg_container_add(ADG_CONTAINER(canvas), ADG_ENTITY(ldim));
 542
 543     ldim = adg_ldim_new_full_from_model(model, "DHOLE", "-DHOLE", "-West",
 544                                         ADG_DIR_LEFT);
 545     adg_container_add(ADG_CONTAINER(canvas), ADG_ENTITY(ldim));
 546 }
 547
 548 static void
 549 _adg_demo_canvas_add_stuff(AdgCanvas *canvas, AdgModel *model)
 550 {
 551     AdgToyText *toy_text;
 552     AdgMatrix map;
 553
 554     toy_text = adg_toy_text_new("Rotate the mouse wheel to zoom in and out");
 555     adg_entity_set_local_method(ADG_ENTITY(toy_text), ADG_MIX_DISABLED);
 556     cairo_matrix_init_translate(&map, -100, 200);
 557     adg_entity_set_global_map(ADG_ENTITY(toy_text), &map);
 558     adg_container_add(ADG_CONTAINER(canvas), ADG_ENTITY(toy_text));
 559
 560     toy_text = adg_toy_text_new("Drag with the wheel pressed to pan");
 561     adg_entity_set_local_method(ADG_ENTITY(toy_text), ADG_MIX_DISABLED);
 562     cairo_matrix_init_translate(&map, -100, 215);
 563     adg_entity_set_global_map(ADG_ENTITY(toy_text), &map);
 564     adg_container_add(ADG_CONTAINER(canvas), ADG_ENTITY(toy_text));
 565 }
 566
 567 static AdgCanvas *
 568 _adg_canvas_init(AdgCanvas *canvas, AdgPart *part)
 569 {
 570     AdgContainer *container;
 571     AdgEntity *entity;
 572     AdgMatrix map;
 573
 574     container = (AdgContainer *) canvas;
 575
 576     entity = ADG_ENTITY(adg_stroke_new(ADG_TRAIL(part->shape)));
 577     adg_container_add(container, entity);
 578
 579     entity = ADG_ENTITY(adg_hatch_new(ADG_TRAIL(part->hatch)));
 580     adg_container_add(container, entity);
 581
 582     entity = ADG_ENTITY(adg_stroke_new(ADG_TRAIL(part->edges)));
 583     adg_container_add(container, entity);
 584
 585     _adg_demo_canvas_add_sheet(canvas);
 586     _adg_demo_canvas_add_dimensions(canvas, ADG_MODEL(part->shape));
 587     _adg_demo_canvas_add_stuff(canvas, ADG_MODEL(part->shape));
 588
 589     cairo_matrix_init_scale(&map, 7, 7);
 590     adg_entity_set_local_map(ADG_ENTITY(container), &map);
 591
 592     return canvas;
 593 }
 594
 595 static GtkRadioButton *
 596 _adg_group_get_active(GtkRadioButton *radio_group)
 597 {
 598     GSList *list = gtk_radio_button_get_group(radio_group);
 599
 600     while (list) {
 601         if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(list->data)))
 602             return list->data;
 603
 604         list = list->next;
 605     }
 606
 607     return NULL;
 608 }
 609
 610 static void
 611 _adg_save_as_response(GtkWidget *window, GtkResponseType response,
 612                       AdgCanvas *canvas)
 613 {
 614     gchar *file, *suffix;
 615     GtkRadioButton *type_radio;
 616     cairo_surface_t *surface = NULL;
 617     void (*callback)(cairo_surface_t *, gchar *) = NULL;
 618
 619     if (response != GTK_RESPONSE_OK) {
 620         gtk_widget_hide(window);
 621         return;
 622     }
 623
 624     file = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(window));
 625     if (file == NULL)
 626         return;
 627
 628     type_radio = _adg_group_get_active(g_object_get_data(G_OBJECT(window),
 629                                                          "type-group"));
 630     g_assert(GTK_IS_RADIO_BUTTON(type_radio));
 631
 632     suffix = gtk_widget_get_tooltip_markup(GTK_WIDGET(type_radio));
 633     g_assert(suffix != NULL);
 634
 635     if (!g_str_has_suffix(file, suffix)) {
 636         gchar *tmp = file;
 637         file = g_strconcat(file, suffix, NULL);
 638         g_free(tmp);
 639     }
 640
 641     if (strcmp(suffix, ".png") == 0) {
 642 #ifdef CAIRO_HAS_PNG_FUNCTIONS
 643         surface = cairo_image_surface_create(CAIRO_FORMAT_RGB24, 800, 600);
 644         callback = (gpointer) cairo_surface_write_to_png;
 645 #endif
 646     } else if (strcmp(suffix, ".pdf") == 0) {
 647 #ifdef CAIRO_HAS_PDF_SURFACE
 648 #include <cairo-pdf.h>
 649         surface = cairo_pdf_surface_create(file, 841, 595);
 650 #endif
 651     } else if (strcmp(suffix, ".ps") == 0) {
 652 #ifdef CAIRO_HAS_PS_SURFACE
 653 #include <cairo-ps.h>
 654         surface = cairo_ps_surface_create(file, 841, 595);
 655         cairo_ps_surface_dsc_comment(surface, "%%Title: " PACKAGE_STRING);
 656         cairo_ps_surface_dsc_comment(surface, "%%Copyright: Copyright (C) 2006-2010 Fontana Nicola");
 657         cairo_ps_surface_dsc_comment(surface, "%%Orientation: Portrait");
 658         cairo_ps_surface_dsc_begin_setup(surface);
 659         cairo_ps_surface_dsc_begin_page_setup(surface);
 660         cairo_ps_surface_dsc_comment(surface, "%%IncludeFeature: *PageSize A4");
 661 #endif
 662     }
 663
 664     if (surface) {
 665         cairo_t *cr = cairo_create(surface);
 666         cairo_surface_destroy(surface);
 667         adg_entity_render(ADG_ENTITY(canvas), cr);
 668         cairo_show_page(cr);
 669         if (callback)
 670             callback(surface, file);
 671         cairo_destroy(cr);
 672     }
 673
 674     g_free(file);
 675     g_free(suffix);
 676     gtk_widget_hide(window);
 677 }
 678
 679 static GtkWidget *
 680 _adg_about_window(GtkBuilder *builder)
 681 {
 682     GtkWidget *window;
 683
 684     window = (GtkWidget *) gtk_builder_get_object(builder, "wndAbout");
 685     g_assert(GTK_IS_ABOUT_DIALOG(window));
 686
 687     g_signal_connect(window, "response", G_CALLBACK(gtk_widget_hide), NULL);
 688
 689     return window;
 690 }
 691
 692 /**
 693  * _adg_window_hide:
 694  * @window: a #GtkWindow
 695  *
 696  * A convenient function that hides @window storing the current position
 697  * so any subsequent call to gtk_widget_show() will hopefully reopen
 698  * the window at this position.
 699  *
 700  * It is useful to connect this callback to a #GtkDialog::response signal.
 701  **/
 702 static void
 703 _adg_window_hide(GtkWindow *window)
 704 {
 705     gint x, y;
 706
 707     g_return_if_fail(GTK_IS_WINDOW(window));
 708
 709     gtk_window_get_position(window, &x, &y);
 710     gtk_widget_hide((GtkWidget *) window);
 711     gtk_window_set_position(window, GTK_WIN_POS_NONE);
 712     gtk_window_move(window, x, y);
 713 }
 714
 715 static GtkWidget *
 716 _adg_edit_window(GtkBuilder *builder, AdgPart *part)
 717 {
 718     GtkWidget *window;
 719
 720     window = (GtkWidget *) gtk_builder_get_object(builder, "wndEdit");
 721     g_assert(GTK_IS_DIALOG(window));
 722
 723     gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_MOUSE);
 724
 725     g_signal_connect_swapped(part->apply, "clicked",
 726                              G_CALLBACK(_adg_part_ui_to_data), part);
 727     g_signal_connect_swapped(part->reset, "clicked",
 728                              G_CALLBACK(_adg_part_data_to_ui), part);
 729     g_signal_connect(window, "response", G_CALLBACK(_adg_window_hide), NULL);
 730
 731     return window;
 732 }
 733
 734 static GtkWidget *
 735 _adg_save_as_window(GtkBuilder *builder, AdgCanvas *canvas)
 736 {
 737     GtkWidget *window;
 738     GtkWidget *type_group, *button_save;
 739
 740     window = (GtkWidget *) gtk_builder_get_object(builder, "wndSaveAs");
 741     g_assert(GTK_IS_WINDOW(window));
 742     type_group = (GtkWidget *) gtk_builder_get_object(builder, "saveAsPng");
 743     g_assert(GTK_IS_RADIO_BUTTON(type_group));
 744     button_save = (GtkWidget *) gtk_builder_get_object(builder, "saveAsSave");
 745     g_assert(GTK_IS_BUTTON(button_save));
 746
 747     g_object_set_data(G_OBJECT(window), "type-group", type_group);
 748
 749     g_signal_connect(window, "response",
 750                      G_CALLBACK(_adg_save_as_response), canvas);
 751
 752     return window;
 753 }
 754
 755 static GtkWidget *
 756 _adg_main_window(GtkBuilder *builder)
 757 {
 758     GtkWidget *window;
 759     AdgPart *part;
 760     AdgCanvas *canvas;
 761     GtkWidget *button_edit, *button_save_as, *button_about, *button_quit;
 762
 763     window = (GtkWidget *) gtk_builder_get_object(builder, "wndMain");
 764     part = _adg_part_new(builder);
 765     canvas = adg_canvas_new();
 766
 767     _adg_canvas_init(canvas, part);
 768     adg_gtk_area_set_canvas(part->area, canvas);
 769
 770     g_assert(GTK_IS_WINDOW(window));
 771     button_edit = (GtkWidget *) gtk_builder_get_object(builder, "mainEdit");
 772     g_assert(GTK_IS_BUTTON(button_edit));
 773     button_save_as = (GtkWidget *) gtk_builder_get_object(builder, "mainSaveAs");
 774     g_assert(GTK_IS_BUTTON(button_save_as));
 775     button_about = (GtkWidget *) gtk_builder_get_object(builder, "mainAbout");
 776     g_assert(GTK_IS_BUTTON(button_about));
 777     button_quit = (GtkWidget *) gtk_builder_get_object(builder, "mainQuit");
 778     g_assert(GTK_IS_BUTTON(button_quit));
 779
 780     g_signal_connect_swapped(button_edit, "clicked",
 781                              G_CALLBACK(gtk_dialog_run),
 782                              _adg_edit_window(builder, part));
 783     g_signal_connect_swapped(button_save_as, "clicked",
 784                              G_CALLBACK(gtk_dialog_run),
 785                              _adg_save_as_window(builder, canvas));
 786     g_signal_connect_swapped(button_about, "clicked",
 787                              G_CALLBACK(gtk_dialog_run),
 788                              _adg_about_window(builder));
 789     g_signal_connect(button_quit, "clicked", G_CALLBACK(gtk_main_quit), NULL);
 790     g_signal_connect(window, "delete-event", G_CALLBACK(gtk_main_quit), NULL);
 791     g_signal_connect_swapped(window, "destroy",
 792                              G_CALLBACK(_adg_part_destroy), part);
 793
 794     return window;
 795 }
 796
 797
 798 int
 799 main(gint argc, gchar **argv)
 800 {
 801     gboolean show_extents;
 802     gchar *path;
 803     GtkBuilder *builder;
 804     GError *error;
 805     GtkWidget *main_window;
 806
 807     _adg_parse_args(&argc, &argv, &show_extents);
 808     adg_switch_extents(show_extents);
 809
 810     path = demo_find_data_file("adg-demo.ui");
 811     if (path == NULL) {
 812         g_print("adg-demo.ui not found!\n");
 813         return 1;
 814     }
 815
 816     builder = gtk_builder_new();
 817     error = NULL;
 818     gtk_builder_add_from_file(builder, path, &error);
 819
 820     if (error != NULL) {
 821         g_critical(error->message);
 822         g_error_free(error);
 823         return 2;
 824     }
 825
 826     main_window = _adg_main_window(builder);
 827     g_object_unref(builder);
 828
 829     gtk_widget_show_all(main_window);
 830     gtk_main();
 831
 832     return 0;
 833 }