demo/adg-demo.c

   1 #include <adg/adg.h>
   2 #include <gtk/gtk.h>
   3 #include <math.h>
   4 #include <cairo-ps.h>
   5
   6
   7 #ifndef G_SQRT3
   8 #define G_SQRT3 1.732050808
   9 #endif
  10
  11 #define CHAMFER 0.3
  12
  13
  14 typedef struct _Piston Piston;
  15
  16 struct _Piston {
  17     gdouble A, B, C;
  18     gdouble D1, D2, D3, D4, D5, D6, D7;
  19     gdouble RD34, RD56;
  20     gdouble LD2, LD3, LD5, LD6, LD7;
  21 };
  22
  23
  24 static void     fill_piston_model       (Piston         *piston);
  25 static void     add_piston_path         (AdgCanvas      *canvas,
  26                                          Piston         *piston);
  27 static void     add_piston_dimensions   (AdgCanvas      *canvas,
  28                                          Piston         *piston);
  29 static void     add_sample_stuff        (AdgCanvas      *canvas);
  30 static void     piston_path_extern      (AdgEntity      *entity,
  31                                          Piston         *piston);
  32 static void     piston_expose           (GtkWidget      *widget,
  33                                          GdkEventExpose *event,
  34                                          AdgCanvas      *canvas);
  35 static void     piston_to_ps            (AdgCanvas      *canvas);
  36
  37
  38 int
  39 main(gint argc, gchar **argv)
  40 {
  41     GtkWidget *window;
  42     GtkWidget *vbox;
  43     GtkWidget *button_box;
  44     GtkWidget *widget;
  45     AdgCanvas *canvas;
  46     Piston     model;
  47
  48     gtk_init(&argc, &argv);
  49
  50     /* Fill the model structure with some data */
  51     fill_piston_model(&model);
  52
  53     /* Create the canvas and populate it */
  54     canvas = adg_canvas_new();
  55     add_piston_path(canvas, &model);
  56     add_piston_dimensions(canvas, &model);
  57     add_sample_stuff(canvas);
  58
  59     /* User interface stuff */
  60     window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
  61     g_signal_connect(window, "delete-event", G_CALLBACK(gtk_main_quit), NULL);
  62
  63     vbox = gtk_vbox_new(FALSE, 0);
  64
  65     widget = gtk_drawing_area_new();
  66     gtk_widget_set_size_request(widget, 790, 240);
  67     g_signal_connect(widget, "expose-event", G_CALLBACK(piston_expose),
  68                      canvas);
  69     gtk_container_add(GTK_CONTAINER(vbox), widget);
  70
  71     button_box = gtk_hbutton_box_new();
  72     gtk_container_set_border_width(GTK_CONTAINER(button_box), 5);
  73     gtk_box_set_spacing(GTK_BOX(button_box), 5);
  74     gtk_button_box_set_layout(GTK_BUTTON_BOX(button_box), GTK_BUTTONBOX_END);
  75     gtk_box_pack_end(GTK_BOX(vbox), button_box, FALSE, TRUE, 0);
  76
  77     widget = gtk_button_new_from_stock(GTK_STOCK_SAVE);
  78     gtk_container_add(GTK_CONTAINER(button_box), widget);
  79
  80     widget = gtk_button_new_from_stock(GTK_STOCK_PRINT);
  81     g_signal_connect_swapped(widget, "clicked", G_CALLBACK(piston_to_ps),
  82                              canvas);
  83     gtk_container_add(GTK_CONTAINER(button_box), widget);
  84
  85     widget = gtk_button_new_from_stock(GTK_STOCK_QUIT);
  86     g_signal_connect(widget, "clicked", G_CALLBACK(gtk_main_quit), NULL);
  87     gtk_container_add(GTK_CONTAINER(button_box), widget);
  88
  89     gtk_container_add(GTK_CONTAINER(window), vbox);
  90     gtk_widget_show_all(window);
  91
  92     gtk_main();
  93
  94     return 0;
  95 }
  96
  97
  98 static void
  99 fill_piston_model(Piston *piston)
 100 {
 101     piston->A = 62.3;
 102     piston->B = 20.6;
 103     piston->C = 2;
 104     piston->D1 = 9.3;
 105     piston->D2 = 6.5;
 106     piston->D3 = 11.9;
 107     piston->D4 = 6.5;
 108     piston->D5 = 4.5;
 109     piston->D6 = 7.2;
 110     piston->D7 = 3.0;
 111     piston->RD34 = 1.0;
 112     piston->LD2 = 7.0;
 113     piston->LD3 = 3.5;
 114     piston->LD5 = 5.0;
 115     piston->LD6 = 1.0;
 116     piston->LD7 = 0.5;
 117 }
 118
 119 static void
 120 add_piston_path(AdgCanvas *canvas, Piston *piston)
 121 {
 122     AdgEntity *entity;
 123
 124     entity = adg_path_new(ADG_CALLBACK(piston_path_extern), piston);
 125
 126     adg_container_add(ADG_CONTAINER(canvas), entity);
 127 }
 128
 129 static void
 130 add_piston_dimensions(AdgCanvas *canvas, Piston *piston)
 131 {
 132     double A, B, C;
 133     double D1, D2, D3, D4, D5, D6, D7;
 134     double LD2, LD3, LD5, LD6, LD7;
 135     double RD34, RD56;
 136     AdgEntity *entity;
 137     double x, y;
 138
 139     A = piston->A;
 140     B = piston->B;
 141     C = piston->C;
 142     D1 = piston->D1;
 143     D2 = piston->D2;
 144     D3 = piston->D3;
 145     D4 = piston->D4;
 146     D5 = piston->D5;
 147     D6 = piston->D6;
 148     D7 = piston->D7;
 149     LD2 = piston->LD2;
 150     LD3 = piston->LD3;
 151     LD5 = piston->LD5;
 152     LD6 = piston->LD6;
 153     LD7 = piston->LD7;
 154     RD34 = piston->RD34;
 155     RD56 = piston->RD56;
 156
 157
 158     /* North */
 159
 160     /* LD2 */
 161     entity =
 162         adg_ldim_new_full_explicit(A - B - LD2, -D1 / 2.0, A - B,
 163                                    -D3 / 2.0 + CHAMFER, CPML_DIR_UP, 0.0,
 164                                    -D3 / 2.0);
 165     adg_container_add(ADG_CONTAINER(canvas), entity);
 166
 167     /* LD3 */
 168     entity =
 169         adg_ldim_new_full_explicit(A - B, -D3 / 2.0 + CHAMFER, A - B + LD3,
 170                                    -D3 / 2.0 + CHAMFER, CPML_DIR_UP, 0.0,
 171                                    -D3 / 2.0);
 172     adg_container_add(ADG_CONTAINER(canvas), entity);
 173
 174
 175     /* South */
 176
 177     /* B */
 178     entity =
 179         adg_ldim_new_full_explicit(A - B, D3 / 2.0 - CHAMFER, A, D7 / 2.0,
 180                                    CPML_DIR_DOWN, 0.0, D3 / 2.0);
 181     adg_dim_set_tolerances(ADG_DIM(entity), "+0.1", NULL);
 182     adg_container_add(ADG_CONTAINER(canvas), entity);
 183
 184     /* A */
 185     entity =
 186         adg_ldim_new_full_explicit(0.0, D1 / 2.0, A, D7 / 2.0,
 187                                    CPML_DIR_DOWN, 0.0, D3 / 2.0);
 188     adg_dim_set_tolerances(ADG_DIM(entity), "+0.05", "-0.05");
 189     adg_dim_set_level(ADG_DIM(entity), 2.0);
 190     adg_container_add(ADG_CONTAINER(canvas), entity);
 191
 192
 193     /* East */
 194
 195     /* D3 */
 196     x = A - B + LD3 - CHAMFER;
 197     entity =
 198         adg_ldim_new_full_explicit(x, -D3 / 2.0, x, D3 / 2.0,
 199                                    CPML_DIR_RIGHT, A, 0.0);
 200     adg_dim_set_tolerances(ADG_DIM(entity), "-0.25", NULL);
 201     adg_dim_set_level(ADG_DIM(entity), 5.0);
 202     adg_container_add(ADG_CONTAINER(canvas), entity);
 203
 204     /* D6 */
 205     x = A - C + LD6;
 206     entity =
 207         adg_ldim_new_full_explicit(x, -D6 / 2.0, x, D6 / 2.0,
 208                                    CPML_DIR_RIGHT, A, 0.0);
 209     adg_dim_set_tolerances(ADG_DIM(entity), "-0.1", NULL);
 210     adg_dim_set_level(ADG_DIM(entity), 4.0);
 211     adg_container_add(ADG_CONTAINER(canvas), entity);
 212
 213     /* D4 */
 214     x = A - C - LD5;
 215     entity =
 216         adg_ldim_new_full_explicit(x, -D4 / 2.0, x, D4 / 2.0,
 217                                    CPML_DIR_RIGHT, A, 0.0);
 218     adg_dim_set_level(ADG_DIM(entity), 3.0);
 219     adg_container_add(ADG_CONTAINER(canvas), entity);
 220
 221     /* D5 */
 222     x = A - C;
 223     entity =
 224         adg_ldim_new_full_explicit(x, -D5 / 2.0, x, D5 / 2.0,
 225                                    CPML_DIR_RIGHT, A, 0.0);
 226     adg_dim_set_tolerances(ADG_DIM(entity), "-0.1", NULL);
 227     adg_dim_set_level(ADG_DIM(entity), 2.0);
 228     adg_container_add(ADG_CONTAINER(canvas), entity);
 229
 230     /* D7 */
 231     entity =
 232         adg_ldim_new_full_explicit(A, -D7 / 2.0, A, D7 / 2.0,
 233                                    CPML_DIR_RIGHT, A, 0.0);
 234     adg_container_add(ADG_CONTAINER(canvas), entity);
 235
 236
 237     /* West */
 238
 239     /* D1 */
 240     entity =
 241         adg_ldim_new_full_explicit(0.0, -D1 / 2.0, 0.0, D1 / 2.0,
 242                                    CPML_DIR_LEFT, 0.0, 0.0);
 243     adg_dim_set_tolerances(ADG_DIM(entity), "+0.05", "-0.05");
 244     adg_dim_set_level(ADG_DIM(entity), 2.0);
 245     adg_container_add(ADG_CONTAINER(canvas), entity);
 246
 247     /* D2 */
 248     y = (D1 - D2) / 2.0;
 249     x = A - B - LD2 + y * G_SQRT3;
 250     entity =
 251         adg_ldim_new_full_explicit(x, -D2 / 2.0, x, D2 / 2.0,
 252                                    CPML_DIR_LEFT, 0.0, 0.0);
 253     adg_dim_set_tolerances(ADG_DIM(entity), "-0.1", NULL);
 254     adg_container_add(ADG_CONTAINER(canvas), entity);
 255 }
 256
 257 static void
 258 add_sample_stuff(AdgCanvas *canvas)
 259 {
 260     AdgEntity *toy_text;
 261
 262     toy_text = adg_toy_text_new("Test script near the piston");
 263     adg_positionable_set_org_explicit(ADG_POSITIONABLE(toy_text),
 264                                       0., -4.65,
 265                                       -2., -5.);
 266     adg_container_add(ADG_CONTAINER(canvas), toy_text);
 267 }
 268
 269 static void
 270 piston_path_extern(AdgEntity *entity, Piston *piston)
 271 {
 272     double A, B, C;
 273     double D1, D2, D3, D4, D5, D6, D7;
 274     double LD2, LD3, LD5, LD6, LD7;
 275     double RD34, RD56;
 276     AdgPath *path;
 277     double x, y;
 278
 279     A = piston->A;
 280     B = piston->B;
 281     C = piston->C;
 282     D1 = piston->D1;
 283     D2 = piston->D2;
 284     D3 = piston->D3;
 285     D4 = piston->D4;
 286     D5 = piston->D5;
 287     D6 = piston->D6;
 288     D7 = piston->D7;
 289     LD2 = piston->LD2;
 290     LD3 = piston->LD3;
 291     LD5 = piston->LD5;
 292     LD6 = piston->LD6;
 293     LD7 = piston->LD7;
 294     RD34 = piston->RD34;
 295     RD56 = piston->RD56;
 296
 297     path = ADG_PATH(entity);
 298
 299     adg_path_move_to(path, 0, D1 / 2.0);
 300     adg_path_line_to(path, A - B - LD2, D1 / 2.0);
 301     y = (D1 - D2) / 2.0;
 302     adg_path_line_to(path, A - B - LD2 + y * G_SQRT3, D1 / 2.0 - y);
 303     adg_path_line_to(path, A - B, D2 / 2.0);
 304     adg_path_line_to(path, A - B, D3 / 2.0 - CHAMFER);
 305     adg_path_line_to(path, A - B + CHAMFER, D3 / 2.0);
 306     adg_path_line_to(path, A - B + LD3 - CHAMFER, D3 / 2.0);
 307     adg_path_line_to(path, A - B + LD3, D3 / 2.0 - CHAMFER);
 308     x = A - B + LD3 + RD34;
 309     y = D4 / 2.0 + RD34;
 310     adg_path_arc(path, x, y, RD34, G_PI, 3.0 * G_PI_2);
 311     adg_path_line_to(path, A - C - LD5, D4 / 2.0);
 312     y = (D4 - D5) / 2.0;
 313     adg_path_line_to(path, A - C - LD5 + y, D4 / 2.0 - y);
 314     adg_path_line_to(path, A - C, D5 / 2.0);
 315     adg_path_line_to(path, A - C, D6 / 2.0);
 316     adg_path_line_to(path, A - C + LD6, D6 / 2.0);
 317     x = C - LD7 - LD6;
 318     y = x / G_SQRT3;
 319     adg_path_line_to(path, A - C + LD6 + x, D6 / 2.0 - y);
 320     adg_path_line_to(path, A - LD7, D7 / 2.0);
 321     adg_path_line_to(path, A, D7 / 2.0);
 322
 323     adg_path_chain_ymirror(path);
 324     adg_path_close(path);
 325 }
 326
 327 static void
 328 piston_expose(GtkWidget *widget, GdkEventExpose *event, AdgCanvas *canvas)
 329 {
 330     cairo_t *cr;
 331     gint width, height;
 332     double scale;
 333     AdgMatrix matrix;
 334
 335     cr = gdk_cairo_create(widget->window);
 336     width = widget->allocation.width;
 337     height = widget->allocation.height;
 338     scale = (double) (width - 80.0) / 80.0;
 339
 340     cairo_matrix_init(&matrix, scale, 0.0, 0.0, scale, scale + 71.0,
 341                       12.0 * scale);
 342     adg_container_set_model_transformation(ADG_CONTAINER(canvas), &matrix);
 343
 344     /* Rendering process */
 345     adg_entity_render(ADG_ENTITY(canvas), cr);
 346
 347     cairo_destroy(cr);
 348 }
 349
 350 static void
 351 piston_to_ps(AdgCanvas *canvas)
 352 {
 353     cairo_surface_t *surface;
 354     cairo_t *cr;
 355     AdgMatrix matrix;
 356     double scale;
 357
 358     /* Surface creation: A4 size */
 359     surface = cairo_ps_surface_create("test.ps", 595, 842);
 360     cairo_ps_surface_dsc_comment(surface,
 361                                  "%%Title: Automatic Drawing Generation (Adg) demo");
 362     cairo_ps_surface_dsc_comment(surface,
 363                                  "%%Copyright: Copyright (C) 2006 Fontana Nicola");
 364     cairo_ps_surface_dsc_comment(surface, "%%Orientation: Portrait");
 365
 366     cairo_ps_surface_dsc_begin_setup(surface);
 367
 368     cairo_ps_surface_dsc_begin_page_setup(surface);
 369     cairo_ps_surface_dsc_comment(surface,
 370                                  "%%IncludeFeature: *PageSize A4");
 371
 372     cr = cairo_create(surface);
 373     cairo_surface_destroy(surface);
 374
 375     scale = 9.0;
 376     cairo_matrix_init(&matrix, scale, 0.0, 0.0, scale, 100.0,
 377                       4.5 * scale + 100.0);
 378     adg_container_set_model_transformation(ADG_CONTAINER(canvas), &matrix);
 379     cairo_scale(cr, 70.0, 70.0);
 380
 381     /* Rendering process */
 382     adg_entity_render(ADG_ENTITY(canvas), cr);
 383
 384     cairo_show_page(cr);
 385     cairo_destroy(cr);
 386 }