?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
build: do not call ./configure in autogen.sh
[adg.git] / demo / adg-demo.c
blobbfc6326edd1a2421484bcfed5ccc260dc7824d71
1 /* ADG - Automatic Drawing Generation
2 * Copyright (C) 2007,2008,2009,2010,2011,2012,2013 Nicola Fontana <ntd at entidi.it>
3 *
4 * This library is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Lesser General Public
6 * License as published by the Free Software Foundation; either
7 * version 2 of the License, or (at your option) any later version.
8 *
9 * This library is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Lesser General Public License for more details.
13 *
14 * You should have received a copy of the GNU Lesser General Public
15 * License along with this library; if not, write to the
16 * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
17 * Boston, MA 02110-1301, USA.
18 */
19
20 #include "demo.h"
21 #include <adg.h>
22 #include <string.h>
23 #include <math.h>
24
25 #define SQRT3 1.732050808
26 #define CHAMFER 0.3
27
28
29 /* Whether render the boxes to highlight the extents of every entity */
30 static gboolean show_extents = FALSE;
31
32
33 typedef struct _DemoPart DemoPart;
34
35 struct _DemoPart {
36 /* Dimensions */
37 gdouble A;
38 gdouble B;
39 gdouble C;
40 gdouble DHOLE;
41 gdouble LHOLE;
42 gdouble D1;
43 gdouble D2;
44 gdouble D3;
45 gdouble D4;
46 gdouble D5;
47 gdouble D6;
48 gdouble D7;
49 gdouble RD34;
50 gdouble RD56;
51 gdouble LD2;
52 gdouble LD3;
53 gdouble LD5;
54 gdouble LD6;
55 gdouble LD7;
56 gboolean GROOVE;
57 gdouble ZGROOVE;
58 gdouble DGROOVE;
59 gdouble LGROOVE;
60
61 /* Metadata */
62 gchar *TITLE;
63 gchar *DRAWING;
64 gchar *AUTHOR;
65 gchar *DATE;
66
67 /* User interface widgets */
68 AdgGtkArea *area;
69 GHashTable *widgets;
70 GtkButton *apply;
71 GtkButton *reset;
72
73 /* Data models */
74 AdgPath *body;
75 AdgPath *hole;
76 AdgPath *axis;
77
78 /* Special entities */
79 AdgTitleBlock *title_block;
80 AdgEdges *edges;
81 };
82
83
84 static void
85 _adg_version(void)
86 {
87 g_print("adg-demo " PACKAGE_VERSION "\n");
88 exit(0);
89 }
90
91 static void
92 parse_args(gint *p_argc, gchar **p_argv[])
93 {
94 GOptionEntry entries[] = {
95 {"version", 'V', G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK,
96 (gpointer) _adg_version, _("Display version information"), NULL},
97 {"show-extents", 'E', 0, G_OPTION_ARG_NONE,
98 &show_extents, _("Show the boundary boxes of every entity"), NULL},
99 {NULL}
100 };
101 GError *error;
102
103 error = NULL;
104 gtk_init_with_args(p_argc, p_argv, _("- ADG demonstration program"),
105 entries, GETTEXT_PACKAGE, &error);
106 if (error != NULL) {
107 g_error("%s", error->message);
108 g_assert_not_reached();
109 }
110 }
111
112 /**
113 * _adg_error:
114 * @message: a custom error message
115 * @parent_window: the parent window or %NULL
116 *
117 * Convenient function that presents an error dialog and waits the user
118 * to close this modal dialog.
119 **/
120 void
121 _adg_error(const gchar *message, GtkWindow *parent_window)
122 {
123 GtkWidget *dialog = gtk_message_dialog_new(parent_window,
124 GTK_DIALOG_DESTROY_WITH_PARENT,
125 GTK_MESSAGE_ERROR,
126 GTK_BUTTONS_CLOSE,
127 "%s", message);
128 gtk_window_set_title(GTK_WINDOW(dialog), _("Error from adg-demo"));
129 gtk_dialog_run(GTK_DIALOG(dialog));
130 gtk_widget_destroy(dialog);
131 }
132
133 static void
134 _adg_path_add_groove(AdgPath *path, const DemoPart *part)
135 {
136 AdgModel *model;
137 CpmlPair pair;
138
139 model = ADG_MODEL(path);
140
141 pair.x = part->ZGROOVE;
142 pair.y = part->D1 / 2;
143 adg_path_line_to(path, &pair);
144 adg_model_set_named_pair(model, "DGROOVEI_X", &pair);
145
146 pair.y = part->D3 / 2;
147 adg_model_set_named_pair(model, "DGROOVEY_POS", &pair);
148
149 pair.y = part->DGROOVE / 2;
150 adg_path_line_to(path, &pair);
151 adg_model_set_named_pair(model, "DGROOVEI_Y", &pair);
152
153 pair.x += part->LGROOVE;
154 adg_path_line_to(path, &pair);
155
156 pair.y = part->D3 / 2;
157 adg_model_set_named_pair(model, "DGROOVEX_POS", &pair);
158
159 pair.y = part->D1 / 2;
160 adg_path_line_to(path, &pair);
161 adg_model_set_named_pair(model, "DGROOVEF_X", &pair);
162 }
163
164
165 static void
166 _adg_part_define_title_block(DemoPart *part)
167 {
168 g_object_set(part->title_block,
169 "title", part->TITLE,
170 "author", part->AUTHOR,
171 "date", part->DATE,
172 "drawing", part->DRAWING,
173 "logo", adg_logo_new(),
174 "projection", adg_projection_new(ADG_PROJECTION_SCHEME_FIRST_ANGLE),
175 "size", "A4",
176 NULL);
177 }
178
179 static void
180 _adg_part_define_hole(DemoPart *part)
181 {
182 AdgPath *path;
183 AdgModel *model;
184 CpmlPair pair, edge;
185
186 path = part->hole;
187 model = ADG_MODEL(path);
188
189 pair.x = part->LHOLE;
190 pair.y = 0;
191
192 adg_path_move_to(path, &pair);
193 adg_model_set_named_pair(model, "LHOLE", &pair);
194
195 pair.y = part->DHOLE / 2;
196 pair.x -= pair.y / SQRT3;
197 adg_path_line_to(path, &pair);
198 cpml_pair_copy(&edge, &pair);
199
200 pair.x = 0;
201 adg_path_line_to(path, &pair);
202 adg_model_set_named_pair(model, "DHOLE", &pair);
203
204 pair.y = (part->D1 + part->DHOLE) / 4;
205 adg_path_line_to(path, &pair);
206
207 adg_path_curve_to_explicit(path,
208 part->LHOLE / 2, part->DHOLE / 2,
209 part->LHOLE + 2, part->D1 / 2,
210 part->LHOLE + 2, 0);
211 adg_path_reflect(path, NULL);
212 adg_path_close(path);
213
214 /* No need to incomodate an AdgEdge model for two reasons:
215 * it is only a single line and it is always needed */
216 adg_path_move_to(path, &edge);
217 edge.y = -edge.y;
218 adg_path_line_to(path, &edge);
219 }
220
221 static void
222 _adg_part_define_body(DemoPart *part)
223 {
224 AdgModel *model;
225 AdgPath *path;
226 CpmlPair pair, tmp;
227 const CpmlPrimitive *primitive;
228
229 path = part->body;
230 model = ADG_MODEL(path);
231
232 pair.x = 0;
233 pair.y = part->D1 / 2;
234 adg_path_move_to(path, &pair);
235 adg_model_set_named_pair(model, "D1I", &pair);
236
237 if (part->GROOVE) {
238 _adg_path_add_groove(path, part);
239 }
240
241 pair.x = part->A - part->B - part->LD2;
242 adg_path_line_to(path, &pair);
243 adg_model_set_named_pair(model, "D1F", &pair);
244
245 pair.y = part->D3 / 2;
246 adg_model_set_named_pair(model, "D2_POS", &pair);
247
248 pair.x += (part->D1 - part->D2) / 2;
249 pair.y = part->D2 / 2;
250 adg_path_line_to(path, &pair);
251 adg_model_set_named_pair(model, "D2I", &pair);
252
253 pair.x = part->A - part->B;
254 adg_path_line_to(path, &pair);
255 adg_path_fillet(path, 0.4);
256
257 pair.x = part->A - part->B;
258 pair.y = part->D3 / 2;
259 adg_path_line_to(path, &pair);
260 adg_model_set_named_pair(model, "D3I", &pair);
261
262 pair.x = part->A;
263 adg_model_set_named_pair(model, "East", &pair);
264
265 pair.x = 0;
266 adg_model_set_named_pair(model, "West", &pair);
267
268 adg_path_chamfer(path, CHAMFER, CHAMFER);
269
270 pair.x = part->A - part->B + part->LD3;
271 pair.y = part->D3 / 2;
272 adg_path_line_to(path, &pair);
273
274 primitive = adg_path_over_primitive(path);
275 cpml_primitive_put_point(primitive, 0, &tmp);
276 adg_model_set_named_pair(model, "D3I_X", &tmp);
277
278 cpml_primitive_put_point(primitive, -1, &tmp);
279 adg_model_set_named_pair(model, "D3I_Y", &tmp);
280
281 adg_path_chamfer(path, CHAMFER, CHAMFER);
282
283 pair.y = part->D4 / 2;
284 adg_path_line_to(path, &pair);
285
286 primitive = adg_path_over_primitive(path);
287 cpml_primitive_put_point(primitive, 0, &tmp);
288 adg_model_set_named_pair(model, "D3F_Y", &tmp);
289 cpml_primitive_put_point(primitive, -1, &tmp);
290 adg_model_set_named_pair(model, "D3F_X", &tmp);
291
292 adg_path_fillet(path, part->RD34);
293
294 pair.x += part->RD34;
295 adg_model_set_named_pair(model, "D4I", &pair);
296
297 pair.x = part->A - part->C - part->LD5;
298 adg_path_line_to(path, &pair);
299 adg_model_set_named_pair(model, "D4F", &pair);
300
301 pair.y = part->D3 / 2;
302 adg_model_set_named_pair(model, "D4_POS", &pair);
303
304 primitive = adg_path_over_primitive(path);
305 cpml_primitive_put_point(primitive, 0, &tmp);
306 tmp.x += part->RD34;
307 adg_model_set_named_pair(model, "RD34", &tmp);
308
309 tmp.x -= cos(G_PI_4) * part->RD34,
310 tmp.y -= sin(G_PI_4) * part->RD34,
311 adg_model_set_named_pair(model, "RD34_R", &tmp);
312
313 tmp.x += part->RD34,
314 tmp.y += part->RD34,
315 adg_model_set_named_pair(model, "RD34_XY", &tmp);
316
317 pair.x += (part->D4 - part->D5) / 2;
318 pair.y = part->D5 / 2;
319 adg_path_line_to(path, &pair);
320 adg_model_set_named_pair(model, "D5I", &pair);
321
322 pair.x = part->A - part->C;
323 adg_path_line_to(path, &pair);
324
325 adg_path_fillet(path, 0.2);
326
327 pair.y = part->D6 / 2;
328 adg_path_line_to(path, &pair);
329
330 primitive = adg_path_over_primitive(path);
331 cpml_primitive_put_point(primitive, 0, &tmp);
332 adg_model_set_named_pair(model, "D5F", &tmp);
333
334 adg_path_fillet(path, 0.1);
335
336 pair.x += part->LD6;
337 adg_path_line_to(path, &pair);
338 adg_model_set_named_pair(model, "D6F", &pair);
339
340 primitive = adg_path_over_primitive(path);
341 cpml_primitive_put_point(primitive, 0, &tmp);
342 adg_model_set_named_pair(model, "D6I_X", &tmp);
343
344 primitive = adg_path_over_primitive(path);
345 cpml_primitive_put_point(primitive, -1, &tmp);
346 adg_model_set_named_pair(model, "D6I_Y", &tmp);
347
348 pair.x = part->A - part->LD7;
349 pair.y -= (part->C - part->LD7 - part->LD6) / SQRT3;
350 adg_path_line_to(path, &pair);
351 adg_model_set_named_pair(model, "D67", &pair);
352
353 pair.y = part->D7 / 2;
354 adg_path_line_to(path, &pair);
355
356 pair.x = part->A;
357 adg_path_line_to(path, &pair);
358 adg_model_set_named_pair(model, "D7F", &pair);
359
360 adg_path_reflect(path, NULL);
361 adg_path_close(path);
362 }
363
364 static void
365 _adg_part_define_axis(DemoPart *part)
366 {
367 AdgPath *path;
368
369 path = part->axis;
370
371 /* XXX: actually the end points can extend outside the body
372 * only in local space. The proper extension values should be
373 * expressed in global space but actually is impossible to
374 * combine local and global space in the AdgPath API.
375 */
376 adg_path_move_to_explicit(path, -1, 0);
377 adg_path_line_to_explicit(path, part->A + 1, 0);
378 }
379
380 static void
381 _adg_part_lock(DemoPart *part)
382 {
383 gtk_widget_set_sensitive(GTK_WIDGET(part->apply), FALSE);
384 gtk_widget_set_sensitive(GTK_WIDGET(part->reset), FALSE);
385 }
386
387 static void
388 _adg_part_unlock(DemoPart *part)
389 {
390 gtk_widget_set_sensitive(GTK_WIDGET(part->apply), TRUE);
391 gtk_widget_set_sensitive(GTK_WIDGET(part->reset), TRUE);
392 }
393
394 static void
395 _adg_part_link(DemoPart *part, gpointer data, GObject *widget)
396 {
397 const gchar *edit_signal;
398
399 g_assert(GTK_IS_WIDGET(widget));
400 g_object_ref(widget);
401 g_hash_table_insert(part->widgets, data, widget);
402
403 if (GTK_IS_SPIN_BUTTON(widget)) {
404 GtkSpinButton *spin_button = GTK_SPIN_BUTTON(widget);
405 gtk_adjustment_value_changed(gtk_spin_button_get_adjustment(spin_button));
406 }
407
408 edit_signal = GTK_IS_TOGGLE_BUTTON(widget) ? "toggled" : "changed";
409 g_signal_connect_swapped(widget, edit_signal,
410 G_CALLBACK(_adg_part_unlock), part);
411 }
412
413 static void
414 _adg_part_ui_to_boolean(DemoPart *part, gboolean *data)
415 {
416 GtkWidget *widget = g_hash_table_lookup(part->widgets, data);
417
418 g_assert(GTK_IS_TOGGLE_BUTTON(widget));
419
420 *data = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget));
421 }
422
423 static void
424 _adg_part_ui_to_double(DemoPart *part, gdouble *data)
425 {
426 GtkWidget *widget;
427 GtkSpinButton *spin_button;
428
429 widget = g_hash_table_lookup(part->widgets, data);
430 g_assert(GTK_IS_SPIN_BUTTON(widget));
431
432 spin_button = GTK_SPIN_BUTTON(widget);
433 gtk_spin_button_update(spin_button);
434 *data = gtk_spin_button_get_value(spin_button);
435 }
436
437 static void
438 _adg_part_ui_to_string(DemoPart *part, gchar **data)
439 {
440 GtkWidget *widget = g_hash_table_lookup(part->widgets, data);
441
442 g_assert(GTK_IS_ENTRY(widget));
443
444 g_free(*data);
445 *data = g_strdup(gtk_entry_get_text(GTK_ENTRY(widget)));
446 }
447
448 static void
449 _adg_part_boolean_to_ui(DemoPart *part, gboolean *data)
450 {
451 GtkWidget *widget = g_hash_table_lookup(part->widgets, data);
452
453 g_assert(GTK_IS_TOGGLE_BUTTON(widget));
454
455 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widget), *data);
456 }
457
458 static void
459 _adg_part_double_to_ui(DemoPart *part, gdouble *data)
460 {
461 GtkWidget *widget = g_hash_table_lookup(part->widgets, data);
462
463 g_assert(GTK_IS_SPIN_BUTTON(widget));
464
465 gtk_spin_button_set_value(GTK_SPIN_BUTTON(widget), *data);
466 }
467
468 static void
469 _adg_part_string_to_ui(DemoPart *part, gchar **data)
470 {
471 GtkWidget *widget = g_hash_table_lookup(part->widgets, data);
472
473 g_assert(GTK_IS_ENTRY(widget));
474
475 gtk_entry_set_text(GTK_ENTRY(widget), *data);
476 }
477
478 static void
479 _adg_demo_canvas_add_dimensions(AdgCanvas *canvas, AdgModel *model)
480 {
481 AdgLDim *ldim;
482 AdgADim *adim;
483 AdgRDim *rdim;
484
485 /* NORTH */
486 ldim = adg_ldim_new_full_from_model(model, "-D3I_X", "-D3F_X", "-D3F_Y",
487 ADG_DIR_UP);
488 adg_dim_set_outside(ADG_DIM(ldim), ADG_THREE_STATE_OFF);
489 adg_container_add(ADG_CONTAINER(canvas), ADG_ENTITY(ldim));
490
491 ldim = adg_ldim_new_full_from_model(model, "-D6I_X", "-D67", "-East",
492 ADG_DIR_UP);
493 adg_dim_set_level(ADG_DIM(ldim), 0);
494 adg_ldim_switch_extension1(ldim, FALSE);
495 adg_container_add(ADG_CONTAINER(canvas), ADG_ENTITY(ldim));
496
497 ldim = adg_ldim_new_full_from_model(model, "-D6I_X", "-D7F", "-East",
498 ADG_DIR_UP);
499 adg_dim_set_limits(ADG_DIM(ldim), "-0.06", NULL);
500 adg_container_add(ADG_CONTAINER(canvas), ADG_ENTITY(ldim));
501
502 adim = adg_adim_new_full_from_model(model, "-D6I_Y", "-D6F",
503 "-D6F", "-D67", "-D6F");
504 adg_dim_set_level(ADG_DIM(adim), 2);
505 adg_container_add(ADG_CONTAINER(canvas), ADG_ENTITY(adim));
506
507 rdim = adg_rdim_new_full_from_model(model, "-RD34", "-RD34_R", "-RD34_XY");
508 adg_container_add(ADG_CONTAINER(canvas), ADG_ENTITY(rdim));
509
510 ldim = adg_ldim_new_full_from_model(model, "-DGROOVEI_X", "-DGROOVEF_X",
511 "-DGROOVEX_POS", ADG_DIR_UP);
512 adg_container_add(ADG_CONTAINER(canvas), ADG_ENTITY(ldim));
513
514 ldim = adg_ldim_new_full_from_model(model, "D2I", "-D2I", "-D2_POS",
515 ADG_DIR_LEFT);
516 adg_dim_set_limits(ADG_DIM(ldim), "-0.1", NULL);
517 adg_dim_set_outside(ADG_DIM(ldim), ADG_THREE_STATE_OFF);
518 adg_dim_set_value(ADG_DIM(ldim), ADG_UTF8_DIAMETER "<>");
519 adg_container_add(ADG_CONTAINER(canvas), ADG_ENTITY(ldim));
520
521 ldim = adg_ldim_new_full_from_model(model, "DGROOVEI_Y", "-DGROOVEI_Y",
522 "-DGROOVEY_POS", ADG_DIR_LEFT);
523 adg_dim_set_limits(ADG_DIM(ldim), "-0.1", NULL);
524 adg_dim_set_outside(ADG_DIM(ldim), ADG_THREE_STATE_OFF);
525 adg_dim_set_value(ADG_DIM(ldim), ADG_UTF8_DIAMETER "<>");
526 adg_container_add(ADG_CONTAINER(canvas), ADG_ENTITY(ldim));
527
528 /* SOUTH */
529 adim = adg_adim_new_full_from_model(model, "D1F", "D1I", "D2I", "D1F", "D1F");
530 adg_dim_set_level(ADG_DIM(adim), 2);
531 adg_adim_switch_extension2(adim, FALSE);
532 adg_container_add(ADG_CONTAINER(canvas), ADG_ENTITY(adim));
533
534 ldim = adg_ldim_new_full_from_model(model, "D1I", "LHOLE", "West",
535 ADG_DIR_DOWN);
536 adg_ldim_switch_extension1(ldim, FALSE);
537 adg_container_add(ADG_CONTAINER(canvas), ADG_ENTITY(ldim));
538
539 ldim = adg_ldim_new_full_from_model(model, "D1I", "DGROOVEI_X", "West",
540 ADG_DIR_DOWN);
541 adg_ldim_switch_extension1(ldim, FALSE);
542 adg_dim_set_level(ADG_DIM(ldim), 2);
543 adg_container_add(ADG_CONTAINER(canvas), ADG_ENTITY(ldim));
544
545 ldim = adg_ldim_new_full_from_model(model, "D4F", "D6I_X", "D4_POS",
546 ADG_DIR_DOWN);
547 adg_dim_set_limits(ADG_DIM(ldim), NULL, "+0.2");
548 adg_dim_set_outside(ADG_DIM(ldim), ADG_THREE_STATE_OFF);
549 adg_container_add(ADG_CONTAINER(canvas), ADG_ENTITY(ldim));
550
551 ldim = adg_ldim_new_full_from_model(model, "D1F", "D3I_X", "D2_POS",
552 ADG_DIR_DOWN);
553 adg_dim_set_level(ADG_DIM(ldim), 2);
554 adg_ldim_switch_extension2(ldim, FALSE);
555 adg_dim_set_outside(ADG_DIM(ldim), ADG_THREE_STATE_OFF);
556 adg_container_add(ADG_CONTAINER(canvas), ADG_ENTITY(ldim));
557
558 ldim = adg_ldim_new_full_from_model(model, "D3I_X", "D7F", "East",
559 ADG_DIR_DOWN);
560 adg_dim_set_limits(ADG_DIM(ldim), NULL, "+0.1");
561 adg_dim_set_level(ADG_DIM(ldim), 2);
562 adg_dim_set_outside(ADG_DIM(ldim), ADG_THREE_STATE_OFF);
563 adg_ldim_switch_extension2(ldim, FALSE);
564 adg_container_add(ADG_CONTAINER(canvas), ADG_ENTITY(ldim));
565
566 ldim = adg_ldim_new_full_from_model(model, "D1I", "D7F", "D3F_Y",
567 ADG_DIR_DOWN);
568 adg_dim_set_limits(ADG_DIM(ldim), "-0.05", "+0.05");
569 adg_dim_set_level(ADG_DIM(ldim), 3);
570 adg_container_add(ADG_CONTAINER(canvas), ADG_ENTITY(ldim));
571
572 adim = adg_adim_new_full_from_model(model, "D4F", "D4I",
573 "D5I", "D4F", "D4F");
574 adg_dim_set_level(ADG_DIM(adim), 1.5);
575 adg_adim_switch_extension2(adim, FALSE);
576 adg_container_add(ADG_CONTAINER(canvas), ADG_ENTITY(adim));
577
578 /* EAST */
579 ldim = adg_ldim_new_full_from_model(model, "D6F", "-D6F", "East",
580 ADG_DIR_RIGHT);
581 adg_dim_set_limits(ADG_DIM(ldim), "-0.1", NULL);
582 adg_dim_set_level(ADG_DIM(ldim), 4);
583 adg_dim_set_value(ADG_DIM(ldim), ADG_UTF8_DIAMETER "<>");
584 adg_container_add(ADG_CONTAINER(canvas), ADG_ENTITY(ldim));
585
586 ldim = adg_ldim_new_full_from_model(model, "D4F", "-D4F", "East",
587 ADG_DIR_RIGHT);
588 adg_dim_set_level(ADG_DIM(ldim), 3);
589 adg_dim_set_value(ADG_DIM(ldim), ADG_UTF8_DIAMETER "<>");
590 adg_container_add(ADG_CONTAINER(canvas), ADG_ENTITY(ldim));
591
592 ldim = adg_ldim_new_full_from_model(model, "D5F", "-D5F", "East",
593 ADG_DIR_RIGHT);
594 adg_dim_set_limits(ADG_DIM(ldim), "-0.1", NULL);
595 adg_dim_set_level(ADG_DIM(ldim), 2);
596 adg_dim_set_value(ADG_DIM(ldim), ADG_UTF8_DIAMETER "<>");
597 adg_container_add(ADG_CONTAINER(canvas), ADG_ENTITY(ldim));
598
599 ldim = adg_ldim_new_full_from_model(model, "D7F", "-D7F", "East",
600 ADG_DIR_RIGHT);
601 adg_dim_set_value(ADG_DIM(ldim), ADG_UTF8_DIAMETER "<>");
602 adg_container_add(ADG_CONTAINER(canvas), ADG_ENTITY(ldim));
603
604 /* WEST */
605 ldim = adg_ldim_new_full_from_model(model, "DHOLE", "-DHOLE", "-West",
606 ADG_DIR_LEFT);
607 adg_dim_set_value(ADG_DIM(ldim), ADG_UTF8_DIAMETER "<>");
608 adg_container_add(ADG_CONTAINER(canvas), ADG_ENTITY(ldim));
609
610 ldim = adg_ldim_new_full_from_model(model, "D1I", "-D1I", "-West",
611 ADG_DIR_LEFT);
612 adg_dim_set_limits(ADG_DIM(ldim), "-0.05", "+0.05");
613 adg_dim_set_level(ADG_DIM(ldim), 2);
614 adg_dim_set_value(ADG_DIM(ldim), ADG_UTF8_DIAMETER "<>");
615 adg_container_add(ADG_CONTAINER(canvas), ADG_ENTITY(ldim));
616
617 ldim = adg_ldim_new_full_from_model(model, "D3I_Y", "-D3I_Y", "-West",
618 ADG_DIR_LEFT);
619 adg_dim_set_limits(ADG_DIM(ldim), "-0.25", NULL);
620 adg_dim_set_level(ADG_DIM(ldim), 3);
621 adg_dim_set_value(ADG_DIM(ldim), ADG_UTF8_DIAMETER "<>");
622 adg_container_add(ADG_CONTAINER(canvas), ADG_ENTITY(ldim));
623 }
624
625 static void
626 _adg_demo_canvas_add_axis(AdgCanvas *canvas, AdgTrail *trail)
627 {
628 AdgStroke *stroke = adg_stroke_new(trail);
629 adg_stroke_set_line_dress(stroke, ADG_DRESS_LINE_AXIS);
630 adg_container_add(ADG_CONTAINER(canvas), ADG_ENTITY(stroke));
631 }
632
633 static AdgCanvas *
634 _adg_canvas_init(AdgCanvas *canvas, DemoPart *part)
635 {
636 AdgContainer *container;
637 AdgEntity *entity;
638
639 container = (AdgContainer *) canvas;
640
641 adg_canvas_set_paper(canvas, GTK_PAPER_NAME_A4,
642 GTK_PAGE_ORIENTATION_LANDSCAPE);
643 adg_canvas_set_title_block(canvas, part->title_block);
644
645 entity = ADG_ENTITY(adg_stroke_new(ADG_TRAIL(part->body)));
646 adg_container_add(container, entity);
647
648 entity = ADG_ENTITY(adg_hatch_new(ADG_TRAIL(part->hole)));
649 adg_container_add(container, entity);
650
651 entity = ADG_ENTITY(adg_stroke_new(ADG_TRAIL(part->hole)));
652 adg_container_add(container, entity);
653
654 entity = ADG_ENTITY(adg_stroke_new(ADG_TRAIL(part->edges)));
655 adg_container_add(container, entity);
656
657 _adg_demo_canvas_add_dimensions(canvas, ADG_MODEL(part->body));
658
659 _adg_demo_canvas_add_axis(canvas, ADG_TRAIL(part->axis));
660
661 return canvas;
662 }
663
664 static GtkRadioButton *
665 _adg_group_get_active(GtkRadioButton *radio_group)
666 {
667 GSList *list = gtk_radio_button_get_group(radio_group);
668
669 while (list) {
670 if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(list->data)))
671 return list->data;
672
673 list = list->next;
674 }
675
676 return NULL;
677 }
678
679 static void
680 _adg_do_edit(DemoPart *part)
681 {
682 _adg_part_ui_to_double(part, &part->A);
683 _adg_part_ui_to_double(part, &part->B);
684 _adg_part_ui_to_double(part, &part->C);
685 _adg_part_ui_to_double(part, &part->DHOLE);
686 _adg_part_ui_to_double(part, &part->LHOLE);
687 _adg_part_ui_to_double(part, &part->D1);
688 _adg_part_ui_to_double(part, &part->D2);
689 _adg_part_ui_to_double(part, &part->LD2);
690 _adg_part_ui_to_double(part, &part->D3);
691 _adg_part_ui_to_double(part, &part->LD3);
692 _adg_part_ui_to_double(part, &part->D4);
693 //_adg_part_ui_to_double(part, &part->D5);
694 _adg_part_ui_to_double(part, &part->D6);
695 //_adg_part_ui_to_double(part, &part->LD6);
696 _adg_part_ui_to_double(part, &part->D7);
697 //_adg_part_ui_to_double(part, &part->LD7);
698
699 _adg_part_ui_to_boolean(part, &part->GROOVE);
700 _adg_part_ui_to_double(part, &part->ZGROOVE);
701 _adg_part_ui_to_double(part, &part->DGROOVE);
702 _adg_part_ui_to_double(part, &part->LGROOVE);
703
704 _adg_part_ui_to_string(part, &part->TITLE);
705 _adg_part_ui_to_string(part, &part->DRAWING);
706 _adg_part_ui_to_string(part, &part->AUTHOR);
707 _adg_part_ui_to_string(part, &part->DATE);
708
709 _adg_part_lock(part);
710
711 adg_model_reset(ADG_MODEL(part->body));
712 adg_model_reset(ADG_MODEL(part->hole));
713 adg_model_reset(ADG_MODEL(part->axis));
714 adg_model_reset(ADG_MODEL(part->edges));
715
716 _adg_part_define_title_block(part);
717 _adg_part_define_body(part);
718 _adg_part_define_hole(part);
719 _adg_part_define_axis(part);
720
721 adg_model_changed(ADG_MODEL(part->body));
722 adg_model_changed(ADG_MODEL(part->hole));
723 adg_model_changed(ADG_MODEL(part->axis));
724 adg_model_changed(ADG_MODEL(part->edges));
725
726 gtk_widget_queue_draw(GTK_WIDGET(part->area));
727 }
728
729 static void
730 _adg_do_reset(DemoPart *part)
731 {
732 _adg_part_double_to_ui(part, &part->A);
733 _adg_part_double_to_ui(part, &part->B);
734 _adg_part_double_to_ui(part, &part->C);
735 _adg_part_double_to_ui(part, &part->DHOLE);
736 _adg_part_double_to_ui(part, &part->LHOLE);
737 _adg_part_double_to_ui(part, &part->D1);
738 _adg_part_double_to_ui(part, &part->D2);
739 _adg_part_double_to_ui(part, &part->LD2);
740 _adg_part_double_to_ui(part, &part->D3);
741 _adg_part_double_to_ui(part, &part->LD3);
742 _adg_part_double_to_ui(part, &part->D4);
743 //_adg_part_double_to_ui(part, &part->D5);
744 _adg_part_double_to_ui(part, &part->D6);
745 //_adg_part_double_to_ui(part, &part->LD6);
746 _adg_part_double_to_ui(part, &part->D7);
747 //_adg_part_double_to_ui(part, &part->LD7);
748
749 _adg_part_boolean_to_ui(part, &part->GROOVE);
750 _adg_part_double_to_ui(part, &part->ZGROOVE);
751 _adg_part_double_to_ui(part, &part->DGROOVE);
752 _adg_part_double_to_ui(part, &part->LGROOVE);
753
754 _adg_part_string_to_ui(part, &part->TITLE);
755 _adg_part_string_to_ui(part, &part->DRAWING);
756 _adg_part_string_to_ui(part, &part->AUTHOR);
757 _adg_part_string_to_ui(part, &part->DATE);
758
759 _adg_part_lock(part);
760 }
761
762 static void
763 _adg_do_save_as(GtkWindow *window, GtkResponseType response, AdgCanvas *canvas)
764 {
765 GtkRadioButton *type_radio;
766 gchar *file, *suffix;
767 cairo_surface_t *surface;
768
769 if (response != GTK_RESPONSE_OK) {
770 gtk_widget_hide(GTK_WIDGET(window));
771 return;
772 }
773
774 file = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(window));
775 if (file == NULL)
776 return;
777
778 type_radio = _adg_group_get_active(g_object_get_data(G_OBJECT(window),
779 "type-group"));
780 g_assert(GTK_IS_RADIO_BUTTON(type_radio));
781 suffix = gtk_widget_get_tooltip_markup(GTK_WIDGET(type_radio));
782 g_assert(suffix != NULL);
783
784 if (!g_str_has_suffix(file, suffix)) {
785 gchar *tmp = file;
786 file = g_strconcat(file, suffix, NULL);
787 g_free(tmp);
788 }
789
790 #ifdef CAIRO_HAS_PNG_FUNCTIONS
791 if (strcmp(suffix, ".png") == 0) {
792 surface = cairo_image_surface_create(CAIRO_FORMAT_RGB24, 800, 600);
793 } else
794 #endif
795 #ifdef CAIRO_HAS_SVG_SURFACE
796 if (strcmp(suffix, ".svg") == 0) {
797 #include <cairo-svg.h>
798 surface = cairo_svg_surface_create(file, 841, 595);
799 } else
800 #endif
801 #ifdef CAIRO_HAS_PDF_SURFACE
802 if (strcmp(suffix, ".pdf") == 0) {
803 #include <cairo-pdf.h>
804 surface = cairo_pdf_surface_create(file, 841, 595);
805 } else
806 #endif
807 #ifdef CAIRO_HAS_PS_SURFACE
808 if (strcmp(suffix, ".ps") == 0) {
809 #include <cairo-ps.h>
810 surface = cairo_ps_surface_create(file, 841, 595);
811 cairo_ps_surface_dsc_comment(surface, "%%Title: " PACKAGE_STRING);
812 cairo_ps_surface_dsc_comment(surface, "%%Copyright: Copyleft (C) 2006-2013 Fontana Nicola");
813 cairo_ps_surface_dsc_comment(surface, "%%Orientation: Landscape");
814 cairo_ps_surface_dsc_begin_setup(surface);
815 cairo_ps_surface_dsc_begin_page_setup(surface);
816 cairo_ps_surface_dsc_comment(surface, "%%IncludeFeature: *PageSize A4");
817 } else
818 #endif
819 {
820 _adg_error(_("Requested format not supported"), window);
821 surface = NULL;
822 }
823
824 if (surface) {
825 cairo_t *cr;
826 cairo_status_t status;
827
828 cr = cairo_create(surface);
829 cairo_surface_destroy(surface);
830 adg_entity_render(ADG_ENTITY(canvas), cr);
831
832 if (cairo_surface_get_type(surface) == CAIRO_SURFACE_TYPE_IMAGE) {
833 status = cairo_surface_write_to_png(surface, file);
834 } else {
835 cairo_show_page(cr);
836 status = cairo_status(cr);
837 }
838
839 cairo_destroy(cr);
840
841 if (status != CAIRO_STATUS_SUCCESS)
842 _adg_error(cairo_status_to_string(status), window);
843 }
844
845 g_free(file);
846 g_free(suffix);
847 gtk_widget_hide(GTK_WIDGET(window));
848 }
849
850 static void
851 _adg_print_prepare(GtkPrintOperation *operation, GtkPrintContext *context)
852 {
853 gtk_print_operation_set_n_pages(operation, 1);
854 }
855
856 static void
857 _adg_print_page(GtkPrintOperation *operation, GtkPrintContext *context,
858 gint page_nr, AdgEntity *canvas)
859 {
860 cairo_t *cr = gtk_print_context_get_cairo_context(context);
861 cairo_matrix_t old_map;
862
863 adg_matrix_copy(&old_map, adg_entity_get_global_map(canvas));;
864
865 adg_entity_set_global_map(canvas, adg_matrix_identity());
866 adg_entity_render(canvas, cr);
867
868 adg_entity_set_global_map(canvas, &old_map);
869 }
870
871 static void
872 _adg_do_print(GtkWidget *button, AdgCanvas *canvas)
873 {
874 static GtkPrintSettings *settings = NULL;
875 GtkWindow *window;
876 GtkPrintOperation *operation;
877 GtkPageSetup *page_setup;
878 GError *error;
879
880 window = (GtkWindow *) gtk_widget_get_toplevel(button);
881 operation = gtk_print_operation_new();
882 page_setup = g_object_get_data(G_OBJECT(canvas), "_adg_page_setup");
883 error = NULL;
884
885 if (settings)
886 gtk_print_operation_set_print_settings(operation, settings);
887 if (page_setup)
888 gtk_print_operation_set_default_page_setup(operation, page_setup);
889
890 g_signal_connect(operation, "begin-print",
891 G_CALLBACK(_adg_print_prepare), NULL);
892 g_signal_connect(operation, "draw-page",
893 G_CALLBACK(_adg_print_page), canvas);
894
895 gtk_print_operation_set_use_full_page(operation, FALSE);
896 gtk_print_operation_set_unit(operation, GTK_UNIT_POINTS);
897 #if GTK_CHECK_VERSION(2, 18, 0)
898 gtk_print_operation_set_embed_page_setup(operation, TRUE);
899 #endif
900
901 switch (gtk_print_operation_run(operation,
902 GTK_PRINT_OPERATION_ACTION_PRINT_DIALOG,
903 window, &error)) {
904
905 case GTK_PRINT_OPERATION_RESULT_APPLY:
906 if (settings)
907 g_object_unref(settings);
908 settings = gtk_print_operation_get_print_settings(operation);
909 if (settings)
910 g_object_ref(settings);
911 break;
912
913 default:
914 break;
915 }
916
917 g_object_unref(operation);
918
919 if (error)
920 _adg_error(error->message, window);
921 }
922
923 static gboolean
924 _adg_button_press(AdgGtkArea *area, GdkEventButton *event)
925 {
926 AdgCanvas *canvas;
927
928 if (event->button != 1 && event->button != 3)
929 return FALSE;
930
931 canvas = adg_gtk_area_get_canvas(area);
932 g_return_val_if_fail(ADG_IS_CANVAS(canvas), FALSE);
933
934 if (event->button == 1) {
935 /* Restore the original zoom */
936 adg_gtk_area_reset(area);
937 } else if (event->button == 3) {
938 adg_canvas_autoscale(canvas);
939 gtk_widget_queue_draw((GtkWidget *) area);
940 }
941
942 return FALSE;
943 }
944
945 static DemoPart *
946 _adg_part_new(GtkBuilder *builder)
947 {
948 DemoPart *part;
949 GObject *object, *toggle_object;
950
951 part = g_new0(DemoPart, 1);
952 part->widgets = g_hash_table_new_full(g_direct_hash, g_direct_equal,
953 NULL, g_object_unref);
954 part->area = (AdgGtkArea *) gtk_builder_get_object(builder, "mainCanvas");
955 part->apply = (GtkButton *) gtk_builder_get_object(builder, "btnApply");
956 part->reset = (GtkButton *) gtk_builder_get_object(builder, "btnReset");
957 part->body = adg_path_new();
958 part->hole = adg_path_new();
959 part->axis = adg_path_new();
960 part->title_block = adg_title_block_new();
961 part->edges = adg_edges_new_with_source(ADG_TRAIL(part->body));
962
963 g_assert(ADG_GTK_IS_AREA(part->area));
964 g_assert(GTK_IS_BUTTON(part->apply));
965 g_assert(GTK_IS_BUTTON(part->reset));
966
967 _adg_part_link(part, &part->A, gtk_builder_get_object(builder, "editA"));
968 _adg_part_link(part, &part->B, gtk_builder_get_object(builder, "editB"));
969 _adg_part_link(part, &part->C, gtk_builder_get_object(builder, "editC"));
970 _adg_part_link(part, &part->D1, gtk_builder_get_object(builder, "editD1"));
971 _adg_part_link(part, &part->D2, gtk_builder_get_object(builder, "editD2"));
972 _adg_part_link(part, &part->LD2, gtk_builder_get_object(builder, "editLD2"));
973 _adg_part_link(part, &part->D3, gtk_builder_get_object(builder, "editD3"));
974 _adg_part_link(part, &part->LD3, gtk_builder_get_object(builder, "editLD3"));
975 _adg_part_link(part, &part->D4, gtk_builder_get_object(builder, "editD4"));
976 //_adg_part_link(part, &part->D5, gtk_builder_get_object(builder, "editD5"));
977 _adg_part_link(part, &part->D6, gtk_builder_get_object(builder, "editD6"));
978 //_adg_part_link(part, &part->LD6, gtk_builder_get_object(builder, "editLD6"));
979 _adg_part_link(part, &part->D7, gtk_builder_get_object(builder, "editD7"));
980 //_adg_part_link(part, &part->LD7, gtk_builder_get_object(builder, "editLD7"));
981 _adg_part_link(part, &part->DHOLE, gtk_builder_get_object(builder, "editDHOLE"));
982 _adg_part_link(part, &part->LHOLE, gtk_builder_get_object(builder, "editLHOLE"));
983
984 g_signal_connect(part->area, "button-press-event",
985 G_CALLBACK(_adg_button_press), NULL);
986
987 toggle_object = gtk_builder_get_object(builder, "editGROOVE");
988 _adg_part_link(part, &part->GROOVE, toggle_object);
989
990 object = gtk_builder_get_object(builder, "editZGROOVE");
991 _adg_part_link(part, &part->ZGROOVE, object);
992 g_signal_connect(toggle_object, "toggled",
993 G_CALLBACK(adg_gtk_toggle_button_sensitivize), object);
994 object = gtk_builder_get_object(builder, "editZGROOVELabel");
995 g_signal_connect(toggle_object, "toggled",
996 G_CALLBACK(adg_gtk_toggle_button_sensitivize), object);
997
998 object = gtk_builder_get_object(builder, "editDGROOVE");
999 _adg_part_link(part, &part->DGROOVE, object);
1000 g_signal_connect(toggle_object, "toggled",
1001 G_CALLBACK(adg_gtk_toggle_button_sensitivize), object);
1002 object = gtk_builder_get_object(builder, "editDGROOVELabel");
1003 g_signal_connect(toggle_object, "toggled",
1004 G_CALLBACK(adg_gtk_toggle_button_sensitivize), object);
1005
1006 object = gtk_builder_get_object(builder, "editLGROOVE");
1007 _adg_part_link(part, &part->LGROOVE, object);
1008 g_signal_connect(toggle_object, "toggled",
1009 G_CALLBACK(adg_gtk_toggle_button_sensitivize), object);
1010 object = gtk_builder_get_object(builder, "editLGROOVELabel");
1011 g_signal_connect(toggle_object, "toggled",
1012 G_CALLBACK(adg_gtk_toggle_button_sensitivize), object);
1013
1014 _adg_part_link(part, &part->TITLE, gtk_builder_get_object(builder, "editTITLE"));
1015 _adg_part_link(part, &part->DRAWING, gtk_builder_get_object(builder, "editDRAWING"));
1016 _adg_part_link(part, &part->AUTHOR, gtk_builder_get_object(builder, "editAUTHOR"));
1017 _adg_part_link(part, &part->DATE, gtk_builder_get_object(builder, "editDATE"));
1018
1019 part->D5 = 4.5;
1020 part->RD34 = 1;
1021 part->LD5 = 5;
1022 part->LD6 = 1;
1023 part->LD7 = 0.5;
1024
1025 _adg_do_edit(part);
1026
1027 return part;
1028 }
1029
1030 static void
1031 _adg_part_destroy(DemoPart *part)
1032 {
1033 g_hash_table_destroy(part->widgets);
1034 g_free(part);
1035 }
1036
1037 static GtkWidget *
1038 _adg_help_window(GtkBuilder *builder)
1039 {
1040 GtkWidget *window;
1041
1042 window = (GtkWidget *) gtk_builder_get_object(builder, "wndHelp");
1043 g_assert(GTK_IS_MESSAGE_DIALOG(window));
1044 g_signal_connect(window, "response", G_CALLBACK(gtk_widget_hide), NULL);
1045
1046 return window;
1047 }
1048
1049 static GtkWidget *
1050 _adg_about_window(GtkBuilder *builder)
1051 {
1052 GtkWidget *window;
1053 GList *icon_list, *last_node;
1054
1055 window = (GtkWidget *) gtk_builder_get_object(builder, "wndAbout");
1056 g_assert(GTK_IS_ABOUT_DIALOG(window));
1057 g_signal_connect(window, "response", G_CALLBACK(gtk_widget_hide), NULL);
1058
1059 icon_list = gtk_window_get_default_icon_list();
1060 last_node = g_list_last(icon_list);
1061 if (last_node != NULL) {
1062 /* The last icon is supposed to be the largest one:
1063 * check adg_gtk_use_default_icons() implementation. */
1064 GdkPixbuf *last_icon = last_node->data;
1065 gtk_about_dialog_set_logo(GTK_ABOUT_DIALOG(window), last_icon);
1066 }
1067 g_list_free(icon_list);
1068
1069 return window;
1070 }
1071
1072 static GtkWidget *
1073 _adg_edit_window(GtkBuilder *builder, DemoPart *part)
1074 {
1075 GtkWidget *window;
1076
1077 window = (GtkWidget *) gtk_builder_get_object(builder, "wndEdit");
1078 g_assert(GTK_IS_DIALOG(window));
1079
1080 gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_MOUSE);
1081
1082 g_signal_connect_swapped(part->apply, "clicked",
1083 G_CALLBACK(_adg_do_edit), part);
1084 g_signal_connect_swapped(part->reset, "clicked",
1085 G_CALLBACK(_adg_do_reset), part);
1086 g_signal_connect(window, "response",
1087 G_CALLBACK(adg_gtk_window_hide_here), NULL);
1088
1089 return window;
1090 }
1091
1092 static GtkWidget *
1093 _adg_save_as_window(GtkBuilder *builder, AdgCanvas *canvas)
1094 {
1095 GtkWidget *window;
1096 GtkWidget *type_group;
1097
1098 window = (GtkWidget *) gtk_builder_get_object(builder, "wndSaveAs");
1099 g_assert(GTK_IS_WINDOW(window));
1100 type_group = (GtkWidget *) gtk_builder_get_object(builder, "saveAsPng");
1101 g_assert(GTK_IS_RADIO_BUTTON(type_group));
1102
1103 g_object_set_data(G_OBJECT(window), "type-group", type_group);
1104
1105 /* Set the default destination file */
1106 if (GTK_IS_FILE_CHOOSER(window)) {
1107 GtkFileChooser *file_chooser;
1108 const gchar *dir;
1109
1110 file_chooser = (GtkFileChooser *) window;
1111
1112 #if GLIB_CHECK_VERSION(2, 14, 0)
1113 dir = g_get_user_special_dir(G_USER_DIRECTORY_DOCUMENTS);
1114 #else
1115 dir = NULL;
1116 #endif
1117
1118 if (dir == NULL)
1119 dir = g_get_home_dir();
1120
1121 gtk_file_chooser_set_current_folder(file_chooser, dir);
1122 gtk_file_chooser_set_current_name(file_chooser, "adg-demo");
1123 }
1124
1125 g_signal_connect(window, "response", G_CALLBACK(_adg_do_save_as), canvas);
1126
1127 return window;
1128 }
1129
1130 static GtkWidget *
1131 _adg_main_window(GtkBuilder *builder)
1132 {
1133 GtkWidget *window;
1134 DemoPart *part;
1135 AdgCanvas *canvas;
1136 GtkWidget *button_edit, *button_save_as, *button_print;
1137 GtkWidget *button_help, *button_about, *button_quit;
1138
1139 if (is_installed) {
1140 #ifdef G_OS_WIN32
1141 gchar *icondir = g_build_filename(basedir, PKGDATADIR, NULL);
1142 adg_gtk_use_default_icons(icondir);
1143 g_free(icondir);
1144 #else
1145 adg_gtk_use_default_icons(PKGDATADIR);
1146 #endif
1147 } else {
1148 adg_gtk_use_default_icons(SRCDIR);
1149 }
1150
1151 window = (GtkWidget *) gtk_builder_get_object(builder, "wndMain");
1152 part = _adg_part_new(builder);
1153 canvas = adg_canvas_new();
1154
1155 _adg_canvas_init(canvas, part);
1156 adg_gtk_area_set_canvas(part->area, canvas);
1157 adg_canvas_autoscale(canvas);
1158
1159 button_help = (GtkWidget *) gtk_builder_get_object(builder, "mainHelp");
1160 g_assert(GTK_IS_BUTTON(button_help));
1161 button_about = (GtkWidget *) gtk_builder_get_object(builder, "mainAbout");
1162 g_assert(GTK_IS_BUTTON(button_about));
1163 g_assert(GTK_IS_WINDOW(window));
1164 button_edit = (GtkWidget *) gtk_builder_get_object(builder, "mainEdit");
1165 g_assert(GTK_IS_BUTTON(button_edit));
1166 button_save_as = (GtkWidget *) gtk_builder_get_object(builder, "mainSaveAs");
1167 g_assert(GTK_IS_BUTTON(button_save_as));
1168 button_print = (GtkWidget *) gtk_builder_get_object(builder, "mainPrint");
1169 g_assert(GTK_IS_BUTTON(button_print));
1170 button_quit = (GtkWidget *) gtk_builder_get_object(builder, "mainQuit");
1171 g_assert(GTK_IS_BUTTON(button_quit));
1172
1173 g_signal_connect_swapped(button_help, "clicked",
1174 G_CALLBACK(gtk_dialog_run),
1175 _adg_help_window(builder));
1176 g_signal_connect_swapped(button_about, "clicked",
1177 G_CALLBACK(gtk_dialog_run),
1178 _adg_about_window(builder));
1179 g_signal_connect_swapped(button_edit, "clicked",
1180 G_CALLBACK(gtk_dialog_run),
1181 _adg_edit_window(builder, part));
1182 g_signal_connect_swapped(button_save_as, "clicked",
1183 G_CALLBACK(gtk_dialog_run),
1184 _adg_save_as_window(builder, canvas));
1185 g_signal_connect(button_print, "clicked",
1186 G_CALLBACK(_adg_do_print), canvas);
1187 g_signal_connect(button_quit, "clicked", G_CALLBACK(gtk_main_quit), NULL);
1188 g_signal_connect(window, "delete-event", G_CALLBACK(gtk_main_quit), NULL);
1189 g_signal_connect_swapped(window, "destroy",
1190 G_CALLBACK(_adg_part_destroy), part);
1191
1192 return window;
1193 }
1194
1195
1196 int
1197 main(gint argc, gchar **argv)
1198 {
1199 gchar *path;
1200 GtkBuilder *builder;
1201 GError *error;
1202 GtkWidget *main_window;
1203
1204 _demo_init(argc, argv);
1205 parse_args(&argc, &argv);
1206 adg_switch_extents(show_extents);
1207
1208 path = _demo_file("adg-demo.ui");
1209 if (path == NULL) {
1210 g_printerr(_("adg-demo.ui not found!\n"));
1211 return 1;
1212 }
1213
1214 builder = gtk_builder_new();
1215 error = NULL;
1216
1217 gtk_builder_set_translation_domain(builder, GETTEXT_PACKAGE);
1218 gtk_builder_add_from_file(builder, path, &error);
1219 g_free(path);
1220
1221 if (error != NULL) {
1222 g_critical("%s", error->message);
1223 g_error_free(error);
1224 return 2;
1225 }
1226
1227 main_window = _adg_main_window(builder);
1228 g_object_unref(builder);
1229
1230 gtk_widget_show_all(main_window);
1231 gtk_main();
1232
1233 return 0;
1234 }
ADG: Automatic Drawing Generation