?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[demo] Removed custom signal catching from adg-demo
[adg.git] / demo / adg-demo.c
blobd182d3d174713b56b9f57992b12642b726270751
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_line_to(path, data->A - data->B, data->D3 / 2 - CHAMFER);
212 adg_path_line_to(path, data->A - data->B + CHAMFER, data->D3 / 2);
213 adg_path_line_to(path, data->A - data->B + data->LD3 - CHAMFER, data->D3 / 2);
214 adg_path_line_to(path, data->A - data->B + data->LD3, data->D3 / 2 - CHAMFER);
215 x = data->A - data->B + data->LD3 + data->RD34;
216 y = data->D4 / 2 + data->RD34;
217 adg_path_arc(path, x, y, data->RD34, G_PI, -G_PI_2);
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_line_to(path, data->A - data->C, data->D6 / 2);
223 adg_path_line_to(path, data->A - data->C + data->LD6, data->D6 / 2);
224 x = data->C - data->LD7 - data->LD6;
225 y = x / SQRT3;
226 adg_path_line_to(path, data->A - data->C + data->LD6 + x, data->D6 / 2 - y);
227 adg_path_line_to(path, data->A - data->LD7, data->D7 / 2);
228 adg_path_line_to(path, data->A, data->D7 / 2);
229
230 /* Build the shape by reflecting the current path, reversing the order
231 * and joining the result to the current path */
232 cairo_path = adg_path_dup_cpml_path(path);
233
234 cpml_segment_from_cairo(&segment, cairo_path);
235 cpml_segment_reverse(&segment);
236 adg_matrix_init_reflection(&matrix, 0);
237 cpml_segment_transform(&segment, &matrix);
238 cairo_path->data[0].header.type = CAIRO_PATH_LINE_TO;
239
240 adg_path_append_cairo_path(path, cairo_path);
241
242 g_free(cairo_path);
243
244 adg_path_close(path);
245 return path;
246 }
247
248 static void
249 drawing_add_dimensions(AdgCanvas *canvas, const DrawingData *data)
250 {
251 AdgEntity *entity;
252 double x, y;
253
254 /* NORTH */
255
256 /* LD2 */
257 entity = adg_ldim_new_full_explicit(data->A - data->B - data->LD2, -data->D1 / 2, data->A - data->B,
258 -data->D3 / 2 + CHAMFER, ADG_DIR_UP, 0,
259 -data->D3 / 2);
260 adg_container_add(ADG_CONTAINER(canvas), entity);
261
262 /* LD3 */
263 entity = adg_ldim_new_full_explicit(data->A - data->B, -data->D3 / 2 + CHAMFER, data->A - data->B + data->LD3,
264 -data->D3 / 2 + CHAMFER, ADG_DIR_UP, 0,
265 -data->D3 / 2);
266 adg_container_add(ADG_CONTAINER(canvas), entity);
267
268 /* SOUTH */
269
270 /* B */
271 entity = adg_ldim_new_full_explicit(data->A - data->B, data->D3 / 2 - CHAMFER, data->A, data->D7 / 2,
272 ADG_DIR_DOWN, 0, data->D3 / 2);
273 adg_dim_set_tolerances(ADG_DIM(entity), "+0.1", NULL);
274 adg_container_add(ADG_CONTAINER(canvas), entity);
275
276 /* A */
277 entity = adg_ldim_new_full_explicit(0, data->D1 / 2, data->A, data->D7 / 2,
278 ADG_DIR_DOWN, 0, data->D3 / 2);
279 adg_dim_set_tolerances(ADG_DIM(entity), "+0.05", "-0.05");
280 adg_dim_set_level(ADG_DIM(entity), 2);
281 adg_container_add(ADG_CONTAINER(canvas), entity);
282
283 /* EAST */
284
285 /* D3 */
286 x = data->A - data->B + data->LD3 - CHAMFER;
287 entity = adg_ldim_new_full_explicit(x, -data->D3 / 2, x, data->D3 / 2,
288 ADG_DIR_RIGHT, data->A, 0);
289 adg_dim_set_tolerances(ADG_DIM(entity), "-0.25", NULL);
290 adg_dim_set_level(ADG_DIM(entity), 5);
291 adg_container_add(ADG_CONTAINER(canvas), entity);
292
293 /* D6 */
294 x = data->A - data->C + data->LD6;
295 entity = adg_ldim_new_full_explicit(x, -data->D6 / 2, x, data->D6 / 2,
296 ADG_DIR_RIGHT, data->A, 0);
297 adg_dim_set_tolerances(ADG_DIM(entity), "-0.1", NULL);
298 adg_dim_set_level(ADG_DIM(entity), 4);
299 adg_container_add(ADG_CONTAINER(canvas), entity);
300
301 /* D4 */
302 x = data->A - data->C - data->LD5;
303 entity = adg_ldim_new_full_explicit(x, -data->D4 / 2, x, data->D4 / 2,
304 ADG_DIR_RIGHT, data->A, 0);
305 adg_dim_set_level(ADG_DIM(entity), 3);
306 adg_container_add(ADG_CONTAINER(canvas), entity);
307
308 /* D5 */
309 x = data->A - data->C;
310 entity = adg_ldim_new_full_explicit(x, -data->D5 / 2, x, data->D5 / 2,
311 ADG_DIR_RIGHT, data->A, 0);
312 adg_dim_set_tolerances(ADG_DIM(entity), "-0.1", NULL);
313 adg_dim_set_level(ADG_DIM(entity), 2);
314 adg_container_add(ADG_CONTAINER(canvas), entity);
315
316 /* D7 */
317 entity = adg_ldim_new_full_explicit(data->A, -data->D7 / 2, data->A, data->D7 / 2,
318 ADG_DIR_RIGHT, data->A, 0);
319 adg_container_add(ADG_CONTAINER(canvas), entity);
320
321 /* WEST */
322
323 /* D1 */
324 entity = adg_ldim_new_full_explicit(0, -data->D1 / 2, 0, data->D1 / 2,
325 ADG_DIR_LEFT, 0, 0);
326 adg_dim_set_tolerances(ADG_DIM(entity), "+0.05", "-0.05");
327 adg_dim_set_level(ADG_DIM(entity), 2);
328 adg_container_add(ADG_CONTAINER(canvas), entity);
329
330 /* D2 */
331 y = (data->D1 - data->D2) / 2;
332 x = data->A - data->B - data->LD2 + y * SQRT3;
333 entity = adg_ldim_new_full_explicit(x, -data->D2 / 2, x, data->D2 / 2,
334 ADG_DIR_LEFT, 0, 0);
335 adg_dim_set_tolerances(ADG_DIM(entity), "-0.1", NULL);
336 adg_container_add(ADG_CONTAINER(canvas), entity);
337 }
338
339 static void
340 drawing_add_stuff(AdgCanvas *canvas, const DrawingData *data)
341 {
342 AdgEntity *toy_text;
343
344 toy_text = adg_toy_text_new("Horizontal toy_text above the piston");
345 adg_translatable_set_origin_explicit(ADG_TRANSLATABLE(toy_text),
346 0., -data->D1 / 2,
347 0., -5.);
348 adg_container_add(ADG_CONTAINER(canvas), toy_text);
349
350 toy_text = adg_toy_text_new("toy_text");
351 adg_translatable_set_origin_explicit(ADG_TRANSLATABLE(toy_text),
352 0., data->D1 / 2,
353 0., -5.);
354 adg_rotable_set_angle(ADG_ROTABLE(toy_text), M_PI * 3./2.);
355 adg_container_add(ADG_CONTAINER(canvas), toy_text);
356 }
357
358
359 #if defined(CAIRO_HAS_PNG_FUNCTIONS) || defined(CAIRO_HAS_PDF_SURFACE) || defined(CAIRO_HAS_PS_SURFACE)
360
361 /* Only needed if there is at least one supported surface */
362 static void
363 file_generated(GtkWidget *caller, const gchar *file)
364 {
365 GtkWindow *window;
366 GtkWidget *dialog;
367
368 window = (GtkWindow *) gtk_widget_get_toplevel(caller);
369 dialog = gtk_message_dialog_new_with_markup(window, GTK_DIALOG_MODAL,
370 GTK_MESSAGE_INFO,
371 GTK_BUTTONS_CLOSE,
372 "The requested operation generated\n"
373 "<b>%s</b> in the current directory.",
374 file);
375 gtk_window_set_title(GTK_WINDOW(dialog), "Operation completed");
376 gtk_dialog_run(GTK_DIALOG(dialog));
377 gtk_widget_destroy(dialog);
378 }
379
380 #endif
381
382 #if !defined(CAIRO_HAS_PNG_FUNCTIONS) || !defined(CAIRO_HAS_PDF_SURFACE) || !defined(CAIRO_HAS_PS_SURFACE)
383
384 /* Only needed if there is a missing surface */
385 static void
386 missing_feature(GtkWidget *caller, const gchar *feature)
387 {
388 GtkWindow *window;
389 GtkWidget *dialog;
390
391 window = (GtkWindow *) gtk_widget_get_toplevel(caller);
392 dialog = gtk_message_dialog_new(window, GTK_DIALOG_MODAL,
393 GTK_MESSAGE_WARNING,
394 GTK_BUTTONS_OK,
395 "The provided cairo library\n"
396 "was compiled with no %s support!",
397 feature);
398 gtk_window_set_title(GTK_WINDOW(dialog), "Missing feature");
399 gtk_dialog_run(GTK_DIALOG(dialog));
400 gtk_widget_destroy(dialog);
401 }
402
403 #endif
404
405
406 #ifdef CAIRO_HAS_PNG_FUNCTIONS
407
408 static void
409 to_png(AdgWidget *widget, GtkWidget *caller)
410 {
411 cairo_surface_t *surface;
412 cairo_t *cr;
413
414 surface = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, 800, 600);
415 cr = cairo_create(surface);
416 cairo_surface_destroy(surface);
417
418 /* Rendering process */
419 adg_entity_render(ADG_ENTITY(adg_widget_get_canvas(widget)), cr);
420
421 cairo_show_page(cr);
422 cairo_surface_write_to_png(surface, "test.png");
423 cairo_destroy(cr);
424
425 file_generated(caller, "test.png");
426 }
427
428 #else
429
430 static void
431 to_png(AdgWidget *widget, GtkWidget *caller)
432 {
433 missing_feature(caller, "PNG");
434 }
435
436 #endif
437
438 #ifdef CAIRO_HAS_PDF_SURFACE
439
440 #include <cairo-pdf.h>
441
442 static void
443 to_pdf(AdgWidget *widget, GtkWidget *caller)
444 {
445 cairo_surface_t *surface;
446 cairo_t *cr;
447
448 surface = cairo_pdf_surface_create("test.pdf", 841, 595);
449 cr = cairo_create(surface);
450 cairo_surface_destroy(surface);
451
452 adg_entity_render(ADG_ENTITY(adg_widget_get_canvas(widget)), cr);
453
454 cairo_show_page(cr);
455 cairo_destroy(cr);
456
457 file_generated(caller, "test.pdf");
458 }
459
460 #else
461
462 static void
463 to_pdf(AdgWidget *widget, GtkWidget *caller)
464 {
465 missing_feature(caller, "PDF");
466 }
467
468 #endif
469
470 #ifdef CAIRO_HAS_PS_SURFACE
471
472 #include <cairo-ps.h>
473
474 static void
475 to_ps(AdgWidget *widget, GtkWidget *caller)
476 {
477 cairo_surface_t *surface;
478 cairo_t *cr;
479
480 /* Surface creation: A4 size */
481 surface = cairo_ps_surface_create("test.ps", 841, 595);
482 cairo_ps_surface_dsc_comment(surface,
483 "%%Title: Automatic Drawing Generation (Adg) demo");
484 cairo_ps_surface_dsc_comment(surface,
485 "%%Copyright: Copyright (C) 2006 Fontana Nicola");
486 cairo_ps_surface_dsc_comment(surface, "%%Orientation: Portrait");
487
488 cairo_ps_surface_dsc_begin_setup(surface);
489
490 cairo_ps_surface_dsc_begin_page_setup(surface);
491 cairo_ps_surface_dsc_comment(surface,
492 "%%IncludeFeature: *PageSize A4");
493
494 cr = cairo_create(surface);
495 cairo_surface_destroy(surface);
496
497 adg_entity_render(ADG_ENTITY(adg_widget_get_canvas(widget)), cr);
498
499 cairo_show_page(cr);
500 cairo_destroy(cr);
501
502 file_generated(caller, "test.ps");
503 }
504
505 #else
506
507 static void
508 to_ps(AdgWidget *widget, GtkWidget *caller)
509 {
510 missing_feature(caller, "PostScript");
511 }
512
513 #endif
ADG: Automatic Drawing Generation