demo/cpml-demo.c

   1 /* Needed for localization support */
   2 #include <adg/adg-internal.h>
   3
   4 /* Force the reinclusion of adg.h */
   5 #undef __ADG_H__
   6
   7 #include <cpml.h>
   8 #include <math.h>
   9 #include <gtk/gtk.h>
  10
  11
  12 static void     parse_args              (gint           *p_argc,
  13                                          gchar         **p_argv[]);
  14 static cairo_path_t *
  15                 duplicate_and_stroke    (cairo_t        *cr);
  16 static void     stroke_and_destroy      (cairo_t        *cr,
  17                                          cairo_path_t   *path);
  18
  19 static void     browsing                (GtkWidget      *widget,
  20                                          cairo_t        *cr);
  21 static void     browsing_segment        (GtkToggleButton*togglebutton,
  22                                          gpointer        user_data);
  23 static void     browsing_primitive      (GtkToggleButton*togglebutton,
  24                                          gpointer        user_data);
  25 static void     browsing_reset          (GtkButton      *button,
  26                                          gpointer        user_data);
  27 static void     browsing_next           (GtkButton      *button,
  28                                          gpointer        user_data);
  29
  30 static gboolean arcs                    (GtkWidget      *widget,
  31                                          cairo_t        *cr);
  32 static void     arc3p                   (cairo_t        *cr,
  33                                          double          x1,
  34                                          double          y1,
  35                                          double          x2,
  36                                          double          y2,
  37                                          double          x3,
  38                                          double          y3);
  39
  40 static gboolean intersections           (GtkWidget      *widget,
  41                                          cairo_t        *cr);
  42 static gboolean offset_curves           (GtkWidget      *widget,
  43                                          cairo_t        *cr);
  44 static gboolean offset_segments         (GtkWidget      *widget,
  45                                          cairo_t        *cr);
  46
  47 static void     circle_callback         (cairo_t        *cr);
  48 static void     piston_callback         (cairo_t        *cr);
  49 static void     curve1_callback         (cairo_t        *cr);
  50 static void     line1_callback          (cairo_t        *cr);
  51
  52 static struct {
  53     GtkWidget           *area;
  54     cairo_path_t        *cairo_path;
  55     gboolean             use_segment;
  56     CpmlSegment          segment;
  57     CpmlPrimitive        primitive;
  58 } browsing_data = {
  59     NULL,
  60 };
  61
  62 static CpmlPair bezier_samples[][4] = {
  63     { { 0, 0 }, { 0, 40 }, { 120, 40 }, { 120, 0 } },   /* Simmetric low */
  64     { { 40, 0 }, { 40, 160 }, { 80, 160 }, { 80, 0 } }, /* Simmetric high */
  65     { { 0, 0 }, { 33.1371, 33.1371 }, { 86.8629, 33.1371 }, { 120, 0 } },
  66                                                         /* Arc approximation */
  67     { { 0, 0 }, { 70, 120 }, { 50, 120 }, { 120, 0 } }, /* Twisted controls */
  68
  69     { { 0, 0 }, { 0, 120 }, { 60, 120 }, { 120, 0 } },  /* Vertical p1-p2 */
  70     { { 0, 0 }, { 60, 120 }, { 120, 120 }, { 120, 0 } },/* Vertical p3-p4 */
  71     { { 0, 120 }, { 120, 120 }, { 120, 60 }, { 0, 0 } },/* Horizontal p1-p2 */
  72     { { 0, 120 }, { 120, 60 }, { 120, 0 }, { 0, 0 } },  /* Horizontal p3-p4 */
  73
  74     { { 0, 0 }, { 0, 120 }, { 120, 120 }, { 120, 0 } }, /* Down */
  75     { { 0, 120 }, { 120, 120 }, { 120, 0 }, { 0, 0 } }, /* Right */
  76     { { 0, 120 }, { 0, 0 }, { 120, 0 }, { 120, 120 } }, /* Up */
  77     { { 120, 120 }, { 0, 120 }, { 0, 0 }, { 120, 0 } }, /* Left */
  78
  79     { { 0, 60 }, { 60, 120 }, { 120, 60 }, { 60, 0 } }, /* Down-right */
  80     { { 60, 120 }, { 120, 60 }, { 60, 0 }, { 0, 60 } }, /* Up-right */
  81     { { 120, 60 }, { 60, 0 }, { 0, 60 }, { 60, 120 } }, /* Up-left */
  82     { { 60, 0 }, { 0, 60 }, { 60, 120 }, { 120, 60 } }, /* Down-left*/
  83
  84     { { 0, 0 }, { 60, 0 }, { 60, 120 }, { 120, 120 } }, /* Step left */
  85     { { 120, 0 }, { 60, 0 }, { 60, 120 }, { 0, 120 } }, /* Step right */
  86     { { 0, 0 }, { 60, 90 }, { 90, 120 }, { 120, 90 } }, /* Unbalanced opened */
  87     { { 0, 0 }, { 40, 120 }, { 120, 120 }, { 60, 80 } } /* Unbalanced closed */
  88 };
  89
  90 static void (*path_samples[]) (cairo_t *cr) = {
  91     circle_callback,
  92     piston_callback,
  93     curve1_callback,
  94     line1_callback,
  95 };
  96
  97
  98 int
  99 main(gint argc, gchar **argv)
 100 {
 101     gchar *path;
 102     GtkBuilder *builder;
 103     GError *error;
 104     GtkWidget *window;
 105
 106     parse_args(&argc, &argv);
 107
 108     path = adg_find_file("cpml-demo.ui", adg_datadir(), BUILDDIR, NULL);
 109     if (path == NULL) {
 110         g_warning(_("cpml-demo.ui not found!\n"));
 111         return 1;
 112     }
 113
 114     builder = gtk_builder_new();
 115     error = NULL;
 116
 117     gtk_builder_set_translation_domain(builder, GETTEXT_PACKAGE);
 118     gtk_builder_add_from_file(builder, path, &error);
 119     g_free(path);
 120
 121     if (error != NULL) {
 122         g_print("%s\n", error->message);
 123         return 2;
 124     }
 125
 126     window = (GtkWidget *) gtk_builder_get_object(builder, "wndMain");
 127
 128     /* Connect signals */
 129     g_signal_connect(window, "delete-event", G_CALLBACK(gtk_main_quit), NULL);
 130     g_signal_connect(gtk_builder_get_object(builder, "areaBrowsing"),
 131                      "draw", G_CALLBACK(browsing), NULL);
 132     g_signal_connect(gtk_builder_get_object(builder, "optBrowsingSegment"),
 133                      "toggled", G_CALLBACK(browsing_segment), NULL);
 134     g_signal_connect(gtk_builder_get_object(builder, "optBrowsingPrimitive"),
 135                      "toggled", G_CALLBACK(browsing_primitive), NULL);
 136     g_signal_connect(gtk_builder_get_object(builder, "btnBrowsingReset"),
 137                      "clicked", G_CALLBACK(browsing_reset), NULL);
 138     g_signal_connect(gtk_builder_get_object(builder, "btnBrowsingNext"),
 139                      "clicked", G_CALLBACK(browsing_next), NULL);
 140     g_signal_connect(gtk_builder_get_object(builder, "areaArcs"),
 141                      "draw", G_CALLBACK(arcs), NULL);
 142     g_signal_connect(gtk_builder_get_object(builder, "areaIntersections"),
 143                      "draw", G_CALLBACK(intersections), NULL);
 144     g_signal_connect(gtk_builder_get_object(builder, "areaOffsetCurves"),
 145                      "draw", G_CALLBACK(offset_curves), NULL);
 146     g_signal_connect(gtk_builder_get_object(builder, "areaOffsetSegments"),
 147                      "draw", G_CALLBACK(offset_segments), NULL);
 148     g_signal_connect(gtk_builder_get_object(builder, "btnQuit"),
 149                      "clicked", G_CALLBACK(gtk_main_quit), NULL);
 150
 151     g_object_unref(builder);
 152
 153     gtk_widget_show_all(window);
 154     gtk_main();
 155
 156     return 0;
 157 }
 158
 159
 160 /**********************************************
 161  * Command line options parser
 162  **********************************************/
 163
 164 static void
 165 version(void)
 166 {
 167     g_print("cpml-demo " PACKAGE_VERSION "\n");
 168     exit(0);
 169 }
 170
 171 static void
 172 parse_args(gint *p_argc, gchar **p_argv[])
 173 {
 174     GError *error = NULL;
 175     GOptionEntry entries[] = {
 176         {"version", 'V', G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK,
 177          (gpointer) version, _("Display version information"), NULL},
 178         {NULL}
 179     };
 180
 181     gtk_init_with_args(p_argc, p_argv, _("- CPML demonstration program"),
 182                        entries, GETTEXT_PACKAGE, &error);
 183
 184     if (error != NULL) {
 185         gint error_code = error->code;
 186
 187         g_printerr("%s\n", error->message);
 188
 189         g_error_free(error);
 190         exit(error_code);
 191     }
 192 }
 193
 194
 195 static cairo_path_t *
 196 duplicate_and_stroke(cairo_t *cr)
 197 {
 198     cairo_path_t *path = cairo_copy_path(cr);
 199
 200     cairo_set_line_width(cr, 2.);
 201     cairo_stroke(cr);
 202
 203     return path;
 204 }
 205
 206 static void
 207 stroke_and_destroy(cairo_t *cr, cairo_path_t *path)
 208 {
 209     cairo_append_path(cr, path);
 210     cairo_path_destroy(path);
 211
 212     cairo_set_line_width(cr, 1.);
 213     cairo_stroke(cr);
 214 }
 215
 216
 217 static void
 218 browsing(GtkWidget *widget, cairo_t *cr)
 219 {
 220     if (browsing_data.area == NULL) {
 221         int n;
 222
 223         /* Initialize browsing_data */
 224         browsing_data.area = widget;
 225         browsing_data.use_segment = TRUE;
 226
 227         /* Append all the path samples to the cairo context */
 228         cairo_save(cr);
 229         cairo_translate(cr, 270.5, -120.5);
 230         for (n = 0; n < G_N_ELEMENTS(path_samples); ++n) {
 231             if ((n & 1) == 0) {
 232                 cairo_translate(cr, -270., 240.);
 233             } else {
 234                 cairo_translate(cr, 270., 0.);
 235             }
 236
 237             (path_samples[n]) (cr);
 238         }
 239
 240         cairo_restore(cr);
 241         browsing_data.cairo_path = cairo_copy_path(cr);
 242         cpml_segment_from_cairo(&browsing_data.segment,
 243                                 browsing_data.cairo_path);
 244         cpml_primitive_from_segment(&browsing_data.primitive,
 245                                     &browsing_data.segment);
 246     } else {
 247         cairo_append_path(cr, browsing_data.cairo_path);
 248     }
 249
 250     cairo_set_line_width(cr, 2.);
 251     cairo_stroke(cr);
 252
 253     cairo_set_source_rgb(cr, 1., 0.4, 0.);
 254     cairo_set_line_width(cr, 5.);
 255
 256     if (browsing_data.use_segment)
 257         cpml_segment_to_cairo(&browsing_data.segment, cr);
 258     else
 259         cpml_primitive_to_cairo(&browsing_data.primitive, cr);
 260
 261     cairo_stroke(cr);
 262 }
 263
 264 static void
 265 browsing_segment(GtkToggleButton *togglebutton, gpointer user_data)
 266 {
 267     if (!gtk_toggle_button_get_active(togglebutton))
 268         return;
 269
 270     browsing_data.use_segment = TRUE;
 271     gtk_widget_queue_draw(browsing_data.area);
 272 }
 273
 274 static void
 275 browsing_primitive(GtkToggleButton*togglebutton, gpointer user_data)
 276 {
 277     if (!gtk_toggle_button_get_active(togglebutton))
 278         return;
 279
 280     browsing_data.use_segment = FALSE;
 281     gtk_widget_queue_draw(browsing_data.area);
 282 }
 283
 284 static void
 285 browsing_reset(GtkButton *button, gpointer user_data)
 286 {
 287     if (browsing_data.use_segment) {
 288         cpml_segment_reset(&browsing_data.segment);
 289         cpml_primitive_from_segment(&browsing_data.primitive,
 290                                     &browsing_data.segment);
 291     } else {
 292         cpml_primitive_reset(&browsing_data.primitive);
 293     }
 294
 295     gtk_widget_queue_draw(browsing_data.area);
 296 }
 297
 298 static void
 299 browsing_next(GtkButton *button, gpointer user_data)
 300 {
 301     if (browsing_data.use_segment) {
 302         cpml_segment_next(&browsing_data.segment);
 303         cpml_primitive_from_segment(&browsing_data.primitive,
 304                                     &browsing_data.segment);
 305     } else {
 306         cpml_primitive_next(&browsing_data.primitive);
 307     }
 308
 309     gtk_widget_queue_draw(browsing_data.area);
 310 }
 311
 312
 313 static gboolean
 314 arcs(GtkWidget *widget, cairo_t *cr)
 315 {
 316     cairo_translate(cr, 100.5, 100.5);
 317     arc3p(cr, 0, 0, 0, 120, 120, 120);
 318
 319     cairo_translate(cr, 200, 0.);
 320     arc3p(cr, 0, 0, 120, 0, 120, 120);
 321
 322     cairo_translate(cr, 200, 0.);
 323     arc3p(cr, 60, 0, 0, 120, 120, 120);
 324
 325     cairo_translate(cr, -400, 200);
 326     arc3p(cr, 0, 50, -2, 85, 120, 0);
 327
 328     cairo_translate(cr, 200, 0);
 329     arc3p(cr, -2, 85, 0, 50, 120, 0);
 330
 331     return FALSE;
 332 }
 333
 334 static void
 335 arc3p(cairo_t *cr, double x1, double y1,
 336       double x2, double y2, double x3, double y3)
 337 {
 338     CpmlPrimitive arc;
 339     cairo_path_data_t p[4];
 340     CpmlPair center;
 341     double r, start, end;
 342
 343     arc.segment = NULL;
 344     arc.org = &p[0];
 345     arc.data = &p[1];
 346
 347     p[1].header.type = CPML_ARC;
 348     p[1].header.length = 3;
 349
 350     p[0].point.x = x1;
 351     p[0].point.y = y1;
 352     p[2].point.x = x2;
 353     p[2].point.y = y2;
 354     p[3].point.x = x3;
 355     p[3].point.y = y3;
 356
 357     cpml_primitive_to_cairo(&arc, cr);
 358
 359     cairo_set_line_width(cr, 1.);
 360     cairo_stroke(cr);
 361
 362     /* Add an arc generated by cairo, just for reference */
 363     if (!cpml_arc_info(&arc, &center, &r, &start, &end)) {
 364         g_warning(_("Unable to get arc info (%lf, %lf) (%lf, %lf) (%lf, %lf)\n"),
 365                   x1, y1, x2, y2, x3, y3);
 366         return;
 367     }
 368
 369     if (start < end)
 370         cairo_arc(cr, center.x, center.y, r-5., start, end);
 371     else
 372         cairo_arc_negative(cr, center.x, center.y, r-5., start, end);
 373
 374     /* Show the inscribed triangle */
 375     cairo_move_to(cr, x1, y1);
 376     cairo_line_to(cr, x2, y2);
 377     cairo_line_to(cr, x3, y3);
 378
 379     cairo_set_line_width(cr, 0.5);
 380     cairo_stroke(cr);
 381 }
 382
 383
 384 static gboolean
 385 intersections(GtkWidget *widget, cairo_t *cr)
 386 {
 387     cairo_path_t *path;
 388     CpmlSegment segment1, segment2;
 389     CpmlPair intersection;
 390
 391     cairo_translate(cr, 10.5, 120.5);
 392
 393     line1_callback(cr);
 394
 395     path = cairo_copy_path(cr);
 396
 397     cairo_set_line_width(cr, 1.);
 398     cairo_stroke(cr);
 399
 400     cpml_segment_from_cairo(&segment1, path);
 401     cpml_segment_from_cairo(&segment2, path);
 402
 403     while (cpml_segment_next(&segment2)) {
 404         cpml_segment_put_intersections(&segment1, &segment2, 1, &intersection);
 405
 406         cairo_arc(cr, intersection.x, intersection.y, 2.5, 0, 2 * M_PI);
 407         cairo_fill(cr);
 408
 409         cpml_segment_next(&segment1);
 410     }
 411
 412     cairo_path_destroy(path);
 413     return FALSE;
 414 }
 415
 416
 417 static gboolean
 418 offset_curves(GtkWidget *widget, cairo_t *cr)
 419 {
 420     gint n;
 421     CpmlPair *bezier;
 422     cairo_path_t *path, *path_copy;
 423     CpmlSegment segment;
 424     CpmlPrimitive primitive;
 425     CpmlPair pair;
 426     CpmlVector vector;
 427     double t;
 428
 429     /* Add the Bézier curve samples */
 430     for (n = 0; n < G_N_ELEMENTS(bezier_samples); ++n) {
 431         bezier = &bezier_samples[n][0];
 432
 433         /* The samples are arranged in a 4x? matrix of 200x150 cells */
 434         if (n == 0)
 435             cairo_translate(cr, 25., 25.);
 436         else if (n % 4 == 0)
 437             cairo_translate(cr, -600., 150.);
 438         else
 439             cairo_translate(cr, 200., 0.);
 440
 441         /* Draw the Bézier curve */
 442         cairo_move_to(cr, bezier[0].x, bezier[0].y);
 443         cairo_curve_to(cr, bezier[1].x, bezier[1].y,
 444                        bezier[2].x, bezier[2].y, bezier[3].x, bezier[3].y);
 445
 446         /* Create a copy, to be used after */
 447         path_copy = cairo_copy_path(cr);
 448
 449         path = duplicate_and_stroke(cr);
 450         cpml_segment_from_cairo(&segment, path);
 451         cpml_segment_offset(&segment, 20.);
 452         stroke_and_destroy(cr, path);
 453
 454         cpml_segment_from_cairo(&segment, path_copy);
 455         cpml_primitive_from_segment(&primitive, &segment);
 456
 457         /* Checking cpml_curve_put_pair_at_time and cpml_curve_put_vector_at_time */
 458         cairo_set_line_width(cr, 1.);
 459         for (t = 0; t < 1; t += 0.1) {
 460             cpml_curve_put_pair_at_time(&primitive, t, &pair);
 461             cpml_curve_put_vector_at_time(&primitive, t, &vector);
 462             cpml_vector_set_length(&vector, 20.);
 463             cpml_vector_normal(&vector);
 464
 465             cairo_new_sub_path(cr);
 466             cairo_arc(cr, pair.x, pair.y, 2.5, 0, M_PI*2);
 467             cairo_fill(cr);
 468
 469             cairo_move_to(cr, pair.x, pair.y);
 470             cairo_line_to(cr, pair.x + vector.x, pair.y + vector.y);
 471             cairo_stroke(cr);
 472         }
 473
 474         cairo_path_destroy(path_copy);
 475     }
 476
 477     return FALSE;
 478 }
 479
 480
 481 static gboolean
 482 offset_segments(GtkWidget *widget, cairo_t *cr)
 483 {
 484     cairo_path_t *path;
 485     CpmlSegment segment;
 486     int n;
 487
 488     cairo_translate(cr, 270.5, -120.5);
 489
 490     /* Offset the path samples */
 491     for (n = 0; n < G_N_ELEMENTS(path_samples); ++n) {
 492         if ((n & 1) == 0) {
 493             cairo_translate(cr, -270., 240.);
 494         } else {
 495             cairo_translate(cr, 270., 0.);
 496         }
 497
 498         /* Call the path callback */
 499         (path_samples[n]) (cr);
 500
 501         path = duplicate_and_stroke(cr);
 502         cpml_segment_from_cairo(&segment, path);
 503         cpml_segment_offset(&segment, 15.);
 504         stroke_and_destroy(cr, path);
 505     }
 506
 507     return FALSE;
 508 }
 509
 510
 511 static void
 512 circle_callback(cairo_t *cr)
 513 {
 514     cairo_new_sub_path(cr);
 515     cairo_arc(cr, 120., 0., 100., 0., M_PI*2);
 516 }
 517
 518 static void
 519 piston_callback(cairo_t *cr)
 520 {
 521     cairo_path_t *old_path, *path;
 522     cairo_matrix_t matrix;
 523     CpmlSegment segment;
 524
 525     /* Save the previous path, if any */
 526     old_path = cairo_copy_path(cr);
 527
 528     cairo_new_path(cr);
 529     cairo_move_to(cr,  0.,   46.5);
 530     cairo_line_to(cr, 210.,   46.5);
 531     cairo_line_to(cr, 222.5,  35.);
 532     cairo_line_to(cr, 270.,   35.);
 533     cairo_line_to(cr, 270.,   56.);
 534     cairo_line_to(cr, 273.,   59.);
 535     cairo_line_to(cr, 302.,   59.);
 536     cairo_line_to(cr, 305.,   56.);
 537     cairo_arc(cr,     325.,   52.5,  20., G_PI, 3. * G_PI_2);
 538     cairo_line_to(cr, 400.,   32.5);
 539     cairo_line_to(cr, 410.,   22.5);
 540     cairo_line_to(cr, 450.,   22.5);
 541     cairo_arc_negative(cr,
 542                       452.,   34.,    2., G_PI,      G_PI_2);
 543     cairo_line_to(cr, 460.,   36.);
 544     cairo_line_to(cr, 470.,   30.);
 545     cairo_line_to(cr, 472.,   12.5);
 546
 547     /* Mirror a reversed copy of the current path on the y = 0 axis */
 548     path = cairo_copy_path(cr);
 549     cpml_segment_from_cairo(&segment, path);
 550
 551     cpml_segment_reverse(&segment);
 552     cairo_matrix_init_scale(&matrix, 1., -1.);
 553     cpml_segment_transform(&segment, &matrix);
 554
 555     /* Join the mirrored path to the old path... */
 556     path->data[0].header.type = CPML_LINE;
 557     cairo_append_path(cr, path);
 558     cairo_path_destroy(path);
 559
 560     /* ...and close the shape */
 561     cairo_close_path(cr);
 562
 563     /* Save the resulting path and clear the path memory */
 564     path = cairo_copy_path(cr);
 565     cairo_new_path(cr);
 566
 567     /* Restore the previous path and reappend the new path */
 568     cairo_append_path(cr, old_path);
 569     cairo_path_destroy(old_path);
 570     cairo_append_path(cr, path);
 571     cairo_path_destroy(path);
 572 }
 573
 574 static void
 575 curve1_callback(cairo_t *cr)
 576 {
 577     cairo_move_to(cr,    30.,   0.);
 578     cairo_curve_to(cr,  120., 120.,  180., 100.,  180.,  20.);
 579     cairo_curve_to(cr,  180., -20.,   50.,  40.,  150.,  40.);
 580     cairo_curve_to(cr,  220.,  40.,  190., -60.,  150., -60.);
 581     cairo_curve_to(cr,  100., -60.,   80., -40.,   60., -60.);
 582 }
 583
 584 static void
 585 line1_callback(cairo_t *cr)
 586 {
 587     cairo_move_to(cr, 0, -50);
 588     cairo_line_to(cr, 100, 50);
 589
 590     cairo_move_to(cr, 100, -50);
 591     cairo_line_to(cr, 0, 50);
 592
 593     cairo_move_to(cr, 120, -50);
 594     cairo_line_to(cr, 200, -10);
 595
 596     cairo_move_to(cr, 120, 50);
 597     cairo_line_to(cr, 200, 10);
 598
 599     cairo_move_to(cr, 220, 0);
 600     cairo_line_to(cr, 280, 0);
 601
 602     cairo_move_to(cr, 270, -40);
 603     cairo_line_to(cr, 270, 20);
 604
 605     cairo_move_to(cr, 320, 60);
 606     cairo_line_to(cr, 380, 60);
 607
 608     cairo_move_to(cr, 300, -40);
 609     cairo_line_to(cr, 340, 0);
 610
 611     cairo_move_to(cr, 480, 10);
 612     cairo_line_to(cr, 400, 40);
 613
 614     cairo_move_to(cr, 400, 40);
 615     cairo_line_to(cr, 450, -40);
 616 }