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