1 /* ADG - Automatic Drawing Generation
2 * Copyright (C) 2007-2017 Nicola Fontana <ntd at entidi.it>
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.
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.
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.
27 #define NULL_FILE "NUL"
31 #define NULL_FILE "/dev/null"
37 _adg_behavior_entity(void)
40 const CpmlExtents
*extents
;
41 AdgTitleBlock
*title_block
;
43 canvas
= ADG_CANVAS(adg_test_canvas());
45 adg_entity_arrange(ADG_ENTITY(canvas
));
46 extents
= adg_entity_get_extents(ADG_ENTITY(canvas
));
47 g_assert_true(extents
->is_defined
);
48 adg_assert_isapprox(extents
->size
.x
, 1);
49 adg_assert_isapprox(extents
->size
.y
, 1);
51 adg_entity_invalidate(ADG_ENTITY(canvas
));
52 extents
= adg_entity_get_extents(ADG_ENTITY(canvas
));
53 g_assert_false(extents
->is_defined
);
55 title_block
= adg_title_block_new();
56 adg_canvas_set_title_block(canvas
, title_block
);
57 adg_entity_arrange(ADG_ENTITY(canvas
));
58 extents
= adg_entity_get_extents(ADG_ENTITY(canvas
));
59 g_assert_true(extents
->is_defined
);
60 g_assert_cmpfloat(extents
->size
.x
, >, 1);
61 g_assert_cmpfloat(extents
->size
.y
, >, 1);
62 g_assert_cmpfloat(extents
->size
.x
, <, 5000);
63 g_assert_cmpfloat(extents
->size
.y
, <, 5000);
65 adg_canvas_set_size_explicit(canvas
, 5000, 5000);
66 adg_entity_arrange(ADG_ENTITY(canvas
));
67 extents
= adg_entity_get_extents(ADG_ENTITY(canvas
));
68 g_assert_true(extents
->is_defined
);
69 adg_assert_isapprox(extents
->size
.x
, 5000);
70 adg_assert_isapprox(extents
->size
.y
, 5000);
72 adg_entity_destroy(ADG_ENTITY(canvas
));
76 _adg_behavior_misc(void)
78 g_assert_cmpuint(ADG_CANVAS_ERROR
, !=, 0);
82 _adg_property_background_dress(void)
85 AdgDress valid_dress_1
, valid_dress_2
, incompatible_dress
;
86 AdgDress background_dress
;
88 canvas
= adg_canvas_new();
89 valid_dress_1
= ADG_DRESS_COLOR_DIMENSION
;
90 valid_dress_2
= ADG_DRESS_COLOR_FILL
;
91 incompatible_dress
= ADG_DRESS_FONT_QUOTE_ANNOTATION
;
93 /* Using the public APIs */
94 adg_canvas_set_background_dress(canvas
, valid_dress_1
);
95 background_dress
= adg_canvas_get_background_dress(canvas
);
96 g_assert_cmpint(background_dress
, ==, valid_dress_1
);
98 adg_canvas_set_background_dress(canvas
, incompatible_dress
);
99 background_dress
= adg_canvas_get_background_dress(canvas
);
100 g_assert_cmpint(background_dress
, ==, valid_dress_1
);
102 adg_canvas_set_background_dress(canvas
, valid_dress_2
);
103 background_dress
= adg_canvas_get_background_dress(canvas
);
104 g_assert_cmpint(background_dress
, ==, valid_dress_2
);
106 /* Using GObject property methods */
107 g_object_set(canvas
, "background-dress", valid_dress_1
, NULL
);
108 g_object_get(canvas
, "background-dress", &background_dress
, NULL
);
109 g_assert_cmpint(background_dress
, ==, valid_dress_1
);
111 g_object_set(canvas
, "background-dress", incompatible_dress
, NULL
);
112 g_object_get(canvas
, "background-dress", &background_dress
, NULL
);
113 g_assert_cmpint(background_dress
, ==, valid_dress_1
);
115 g_object_set(canvas
, "background-dress", valid_dress_2
, NULL
);
116 g_object_get(canvas
, "background-dress", &background_dress
, NULL
);
117 g_assert_cmpint(background_dress
, ==, valid_dress_2
);
119 adg_entity_destroy(ADG_ENTITY(canvas
));
123 _adg_property_frame_dress(void)
126 AdgDress valid_dress_1
, valid_dress_2
, incompatible_dress
;
127 AdgDress frame_dress
;
129 canvas
= adg_canvas_new();
130 valid_dress_1
= ADG_DRESS_LINE_DIMENSION
;
131 valid_dress_2
= ADG_DRESS_LINE_FILL
;
132 incompatible_dress
= ADG_DRESS_FONT
;
134 /* Using the public APIs */
135 adg_canvas_set_frame_dress(canvas
, valid_dress_1
);
136 frame_dress
= adg_canvas_get_frame_dress(canvas
);
137 g_assert_cmpint(frame_dress
, ==, valid_dress_1
);
139 adg_canvas_set_frame_dress(canvas
, incompatible_dress
);
140 frame_dress
= adg_canvas_get_frame_dress(canvas
);
141 g_assert_cmpint(frame_dress
, ==, valid_dress_1
);
143 adg_canvas_set_frame_dress(canvas
, valid_dress_2
);
144 frame_dress
= adg_canvas_get_frame_dress(canvas
);
145 g_assert_cmpint(frame_dress
, ==, valid_dress_2
);
147 /* Using GObject property methods */
148 g_object_set(canvas
, "frame-dress", valid_dress_1
, NULL
);
149 g_object_get(canvas
, "frame-dress", &frame_dress
, NULL
);
150 g_assert_cmpint(frame_dress
, ==, valid_dress_1
);
152 g_object_set(canvas
, "frame-dress", incompatible_dress
, NULL
);
153 g_object_get(canvas
, "frame-dress", &frame_dress
, NULL
);
154 g_assert_cmpint(frame_dress
, ==, valid_dress_1
);
156 g_object_set(canvas
, "frame-dress", valid_dress_2
, NULL
);
157 g_object_get(canvas
, "frame-dress", &frame_dress
, NULL
);
158 g_assert_cmpint(frame_dress
, ==, valid_dress_2
);
160 adg_entity_destroy(ADG_ENTITY(canvas
));
164 _adg_property_title_block(void)
167 AdgTitleBlock
*valid_title_block
, *invalid_title_block
, *title_block
;
169 canvas
= adg_canvas_new();
170 valid_title_block
= ADG_TITLE_BLOCK(adg_title_block_new());
171 invalid_title_block
= adg_test_invalid_pointer();
173 g_object_ref(valid_title_block
);
175 /* Using the public APIs */
176 adg_canvas_set_title_block(canvas
, NULL
);
177 title_block
= adg_canvas_get_title_block(canvas
);
178 g_assert_null(title_block
);
180 adg_canvas_set_title_block(canvas
, valid_title_block
);
181 title_block
= adg_canvas_get_title_block(canvas
);
182 g_assert_true(title_block
== valid_title_block
);
184 adg_canvas_set_title_block(canvas
, invalid_title_block
);
185 title_block
= adg_canvas_get_title_block(canvas
);
186 g_assert_true(title_block
== valid_title_block
);
188 adg_canvas_set_title_block(canvas
, NULL
);
189 title_block
= adg_canvas_get_title_block(canvas
);
190 g_assert_null(title_block
);
192 /* Using GObject property methods */
193 g_object_set(canvas
, "title-block", NULL
, NULL
);
194 g_object_get(canvas
, "title-block", &title_block
, NULL
);
195 g_assert_null(title_block
);
197 g_object_set(canvas
, "title-block", valid_title_block
, NULL
);
198 g_object_get(canvas
, "title-block", &title_block
, NULL
);
199 g_assert_true(title_block
== valid_title_block
);
200 g_object_unref(title_block
);
202 g_object_set(canvas
, "title-block", invalid_title_block
, NULL
);
203 g_object_get(canvas
, "title-block", &title_block
, NULL
);
204 g_assert_true(title_block
== valid_title_block
);
205 g_object_unref(title_block
);
207 g_object_set(canvas
, "title-block", NULL
, NULL
);
208 g_object_get(canvas
, "title-block", &title_block
, NULL
);
209 g_assert_null(title_block
);
211 adg_entity_destroy(ADG_ENTITY(canvas
));
215 _adg_property_size(void)
218 CpmlPair null_size
, sample_size
;
219 const CpmlPair
*size
;
222 canvas
= adg_canvas_new();
228 /* Using the public APIs */
229 size
= adg_canvas_get_size(canvas
);
231 /* The default size is 0, 0 (anamorphic canvas) */
232 g_assert_true(cpml_pair_equal(size
, &null_size
));
234 adg_canvas_set_size(canvas
, &sample_size
);
235 size
= adg_canvas_get_size(canvas
);
236 g_assert_true(cpml_pair_equal(size
, &sample_size
));
238 adg_canvas_set_size(canvas
, NULL
);
239 size
= adg_canvas_get_size(canvas
);
240 g_assert_true(cpml_pair_equal(size
, &sample_size
));
242 adg_canvas_set_size_explicit(canvas
, 0, 0);
243 size
= adg_canvas_get_size(canvas
);
244 g_assert_true(cpml_pair_equal(size
, &null_size
));
246 /* Using GObject property methods */
247 g_object_set(canvas
, "size", &sample_size
, NULL
);
248 g_object_get(canvas
, "size", &size_dup
, NULL
);
249 g_assert_true(cpml_pair_equal(size_dup
, &sample_size
));
252 g_object_set(canvas
, "size", NULL
, NULL
);
253 g_object_get(canvas
, "size", &size_dup
, NULL
);
254 g_assert_true(cpml_pair_equal(size_dup
, &sample_size
));
257 g_object_set(canvas
, "size", &null_size
, NULL
);
258 g_object_get(canvas
, "size", &size_dup
, NULL
);
259 g_assert_true(cpml_pair_equal(size_dup
, &null_size
));
262 adg_entity_destroy(ADG_ENTITY(canvas
));
266 _adg_property_factor(void)
271 canvas
= ADG_CANVAS(adg_canvas_new());
273 /* Using the public APIs */
274 factor
= adg_canvas_get_factor(canvas
);
275 adg_assert_isapprox(factor
, 1);
277 adg_canvas_set_factor(canvas
, 123);
278 factor
= adg_canvas_get_factor(canvas
);
279 adg_assert_isapprox(factor
, 123);
281 adg_canvas_set_factor(canvas
, -123);
282 factor
= adg_canvas_get_factor(canvas
);
283 adg_assert_isapprox(factor
, 123);
285 adg_canvas_set_factor(canvas
, 0);
286 factor
= adg_canvas_get_factor(canvas
);
287 adg_assert_isapprox(factor
, 123);
289 /* Using GObject property methods */
290 g_object_set(canvas
, "factor", 321., NULL
);
291 g_object_get(canvas
, "factor", &factor
, NULL
);
292 adg_assert_isapprox(factor
, 321);
294 g_object_set(canvas
, "factor", -321., NULL
);
295 g_object_get(canvas
, "factor", &factor
, NULL
);
296 adg_assert_isapprox(factor
, 321);
298 g_object_set(canvas
, "factor", 0., NULL
);
299 g_object_get(canvas
, "factor", &factor
, NULL
);
300 adg_assert_isapprox(factor
, 321);
302 adg_entity_destroy(ADG_ENTITY(canvas
));
306 _adg_property_scales(void)
310 gchar
*scales_array
[] = { "a", "b", "c", NULL
};
312 /* By default, AdgCanvas:scales is prefilled with some default scales */
313 canvas
= adg_canvas_new();
314 scales
= adg_canvas_get_scales(canvas
);
315 g_assert_nonnull(scales
);
316 adg_entity_destroy(ADG_ENTITY(canvas
));
318 /* AdgCanvas:scales must be prefilled also when using g_object_new() */
319 canvas
= g_object_new(ADG_TYPE_CANVAS
, NULL
);
320 scales
= adg_canvas_get_scales(canvas
);
321 g_assert_nonnull(scales
);
323 /* Using the public APIs */
324 adg_canvas_set_scales(canvas
, NULL
);
325 scales
= adg_canvas_get_scales(canvas
);
326 g_assert_null(scales
);
328 adg_canvas_set_scales(canvas
, "0", "1", NULL
);
329 scales
= adg_canvas_get_scales(canvas
);
330 g_assert_nonnull(scales
);
331 g_assert_cmpstr(scales
[0], ==, "0");
332 g_assert_cmpstr(scales
[1], ==, "1");
333 g_assert_null(scales
[2]);
335 adg_canvas_set_scales_array(canvas
, NULL
);
336 scales
= adg_canvas_get_scales(canvas
);
337 g_assert_null(scales
);
339 adg_canvas_set_scales_array(canvas
, scales_array
);
340 scales
= adg_canvas_get_scales(canvas
);
341 g_assert_nonnull(scales
);
342 g_assert_cmpstr(scales
[0], ==, "a");
343 g_assert_cmpstr(scales
[1], ==, "b");
344 g_assert_cmpstr(scales
[2], ==, "c");
345 g_assert_null(scales
[3]);
347 /* Using GObject property methods */
348 g_object_set(canvas
, "scales", NULL
, NULL
);
349 g_object_get(canvas
, "scales", &scales
, NULL
);
350 g_assert_null(scales
);
352 g_object_set(canvas
, "scales", scales_array
, NULL
);
353 g_object_get(canvas
, "scales", &scales
, NULL
);
354 g_assert_nonnull(scales
);
355 g_assert_cmpstr(scales
[0], ==, "a");
356 g_assert_cmpstr(scales
[1], ==, "b");
357 g_assert_cmpstr(scales
[2], ==, "c");
358 g_assert_null(scales
[3]);
361 adg_entity_destroy(ADG_ENTITY(canvas
));
365 _adg_property_top_margin(void)
368 gdouble valid_value_1
, valid_value_2
;
371 canvas
= ADG_CANVAS(adg_canvas_new());
372 valid_value_1
= 4321;
375 /* Using the public APIs */
376 adg_canvas_set_top_margin(canvas
, valid_value_1
);
377 top_margin
= adg_canvas_get_top_margin(canvas
);
378 adg_assert_isapprox(top_margin
, valid_value_1
);
380 adg_canvas_set_margins(canvas
, valid_value_2
, 0, 0, 0);
381 top_margin
= adg_canvas_get_top_margin(canvas
);
382 adg_assert_isapprox(top_margin
, valid_value_2
);
384 /* Using GObject property methods */
385 g_object_set(canvas
, "top-margin", valid_value_1
, NULL
);
386 g_object_get(canvas
, "top-margin", &top_margin
, NULL
);
387 adg_assert_isapprox(top_margin
, valid_value_1
);
389 g_object_set(canvas
, "top-margin", valid_value_2
, NULL
);
390 g_object_get(canvas
, "top-margin", &top_margin
, NULL
);
391 adg_assert_isapprox(top_margin
, valid_value_2
);
393 adg_entity_destroy(ADG_ENTITY(canvas
));
397 _adg_property_right_margin(void)
400 gdouble valid_value_1
, valid_value_2
;
401 gdouble right_margin
;
403 canvas
= ADG_CANVAS(adg_canvas_new());
404 valid_value_1
= 4321;
407 /* Using the public APIs */
408 adg_canvas_set_right_margin(canvas
, valid_value_1
);
409 right_margin
= adg_canvas_get_right_margin(canvas
);
410 adg_assert_isapprox(right_margin
, valid_value_1
);
412 adg_canvas_set_margins(canvas
, 0, valid_value_2
, 0, 0);
413 right_margin
= adg_canvas_get_right_margin(canvas
);
414 adg_assert_isapprox(right_margin
, valid_value_2
);
416 /* Using GObject property methods */
417 g_object_set(canvas
, "right-margin", valid_value_1
, NULL
);
418 g_object_get(canvas
, "right-margin", &right_margin
, NULL
);
419 adg_assert_isapprox(right_margin
, valid_value_1
);
421 g_object_set(canvas
, "right-margin", valid_value_2
, NULL
);
422 g_object_get(canvas
, "right-margin", &right_margin
, NULL
);
423 adg_assert_isapprox(right_margin
, valid_value_2
);
425 adg_entity_destroy(ADG_ENTITY(canvas
));
429 _adg_property_bottom_margin(void)
432 gdouble valid_value_1
, valid_value_2
;
433 gdouble bottom_margin
;
435 canvas
= ADG_CANVAS(adg_canvas_new());
436 valid_value_1
= 4321;
437 valid_value_2
= -1234;
439 /* Using the public APIs */
440 adg_canvas_set_bottom_margin(canvas
, valid_value_1
);
441 bottom_margin
= adg_canvas_get_bottom_margin(canvas
);
442 adg_assert_isapprox(bottom_margin
, valid_value_1
);
444 adg_canvas_set_margins(canvas
, 0, 0, valid_value_2
, 0);
445 bottom_margin
= adg_canvas_get_bottom_margin(canvas
);
446 adg_assert_isapprox(bottom_margin
, valid_value_2
);
448 /* Using GObject property methods */
449 g_object_set(canvas
, "bottom-margin", valid_value_1
, NULL
);
450 g_object_get(canvas
, "bottom-margin", &bottom_margin
, NULL
);
451 adg_assert_isapprox(bottom_margin
, valid_value_1
);
453 g_object_set(canvas
, "bottom-margin", valid_value_2
, NULL
);
454 g_object_get(canvas
, "bottom-margin", &bottom_margin
, NULL
);
455 adg_assert_isapprox(bottom_margin
, valid_value_2
);
457 adg_entity_destroy(ADG_ENTITY(canvas
));
461 _adg_property_left_margin(void)
464 gdouble valid_value_1
, valid_value_2
;
467 canvas
= ADG_CANVAS(adg_canvas_new());
468 valid_value_1
= 4321;
469 valid_value_2
= -4321;
471 /* Using the public APIs */
472 adg_canvas_set_left_margin(canvas
, valid_value_1
);
473 left_margin
= adg_canvas_get_left_margin(canvas
);
474 adg_assert_isapprox(left_margin
, valid_value_1
);
476 adg_canvas_set_margins(canvas
, 0, 0, 0, valid_value_2
);
477 left_margin
= adg_canvas_get_left_margin(canvas
);
478 adg_assert_isapprox(left_margin
, valid_value_2
);
480 /* Using GObject property methods */
481 g_object_set(canvas
, "left-margin", valid_value_1
, NULL
);
482 g_object_get(canvas
, "left-margin", &left_margin
, NULL
);
483 adg_assert_isapprox(left_margin
, valid_value_1
);
485 g_object_set(canvas
, "left-margin", valid_value_2
, NULL
);
486 g_object_get(canvas
, "left-margin", &left_margin
, NULL
);
487 adg_assert_isapprox(left_margin
, valid_value_2
);
489 adg_entity_destroy(ADG_ENTITY(canvas
));
493 _adg_property_has_frame(void)
496 gboolean invalid_boolean
;
499 canvas
= ADG_CANVAS(adg_canvas_new());
500 invalid_boolean
= (gboolean
) 1234;
502 /* Using the public APIs */
503 adg_canvas_switch_frame(canvas
, FALSE
);
504 has_frame
= adg_canvas_has_frame(canvas
);
505 g_assert_false(has_frame
);
507 adg_canvas_switch_frame(canvas
, invalid_boolean
);
508 has_frame
= adg_canvas_has_frame(canvas
);
509 g_assert_false(has_frame
);
511 adg_canvas_switch_frame(canvas
, TRUE
);
512 has_frame
= adg_canvas_has_frame(canvas
);
513 g_assert_true(has_frame
);
515 /* Using GObject property methods */
516 g_object_set(canvas
, "has-frame", FALSE
, NULL
);
517 g_object_get(canvas
, "has-frame", &has_frame
, NULL
);
518 g_assert_false(has_frame
);
520 g_object_set(canvas
, "has-frame", invalid_boolean
, NULL
);
521 g_object_get(canvas
, "has-frame", &has_frame
, NULL
);
522 g_assert_false(has_frame
);
524 g_object_set(canvas
, "has-frame", TRUE
, NULL
);
525 g_object_get(canvas
, "has-frame", &has_frame
, NULL
);
526 g_assert_true(has_frame
);
528 adg_entity_destroy(ADG_ENTITY(canvas
));
532 _adg_property_top_padding(void)
535 gdouble valid_value_1
, valid_value_2
;
538 canvas
= ADG_CANVAS(adg_canvas_new());
539 valid_value_1
= 4321;
542 /* Using the public APIs */
543 adg_canvas_set_top_padding(canvas
, valid_value_1
);
544 top_padding
= adg_canvas_get_top_padding(canvas
);
545 adg_assert_isapprox(top_padding
, valid_value_1
);
547 adg_canvas_set_paddings(canvas
, valid_value_2
, 0, 0, 0);
548 top_padding
= adg_canvas_get_top_padding(canvas
);
549 adg_assert_isapprox(top_padding
, valid_value_2
);
551 /* Using GObject property methods */
552 g_object_set(canvas
, "top-padding", valid_value_1
, NULL
);
553 g_object_get(canvas
, "top-padding", &top_padding
, NULL
);
554 adg_assert_isapprox(top_padding
, valid_value_1
);
556 g_object_set(canvas
, "top-padding", valid_value_2
, NULL
);
557 g_object_get(canvas
, "top-padding", &top_padding
, NULL
);
558 adg_assert_isapprox(top_padding
, valid_value_2
);
560 adg_entity_destroy(ADG_ENTITY(canvas
));
564 _adg_property_right_padding(void)
567 gdouble valid_value_1
, valid_value_2
;
568 gdouble right_padding
;
570 canvas
= ADG_CANVAS(adg_canvas_new());
571 valid_value_1
= 4321;
574 /* Using the public APIs */
575 adg_canvas_set_right_padding(canvas
, valid_value_1
);
576 right_padding
= adg_canvas_get_right_padding(canvas
);
577 adg_assert_isapprox(right_padding
, valid_value_1
);
579 adg_canvas_set_paddings(canvas
, 0, valid_value_2
, 0, 0);
580 right_padding
= adg_canvas_get_right_padding(canvas
);
581 adg_assert_isapprox(right_padding
, valid_value_2
);
583 /* Using GObject property methods */
584 g_object_set(canvas
, "right-padding", valid_value_1
, NULL
);
585 g_object_get(canvas
, "right-padding", &right_padding
, NULL
);
586 adg_assert_isapprox(right_padding
, valid_value_1
);
588 g_object_set(canvas
, "right-padding", valid_value_2
, NULL
);
589 g_object_get(canvas
, "right-padding", &right_padding
, NULL
);
590 adg_assert_isapprox(right_padding
, valid_value_2
);
592 adg_entity_destroy(ADG_ENTITY(canvas
));
596 _adg_property_bottom_padding(void)
599 gdouble valid_value_1
, valid_value_2
;
600 gdouble bottom_padding
;
602 canvas
= ADG_CANVAS(adg_canvas_new());
603 valid_value_1
= 4321;
604 valid_value_2
= -4321;
606 /* Using the public APIs */
607 adg_canvas_set_bottom_padding(canvas
, valid_value_1
);
608 bottom_padding
= adg_canvas_get_bottom_padding(canvas
);
609 adg_assert_isapprox(bottom_padding
, valid_value_1
);
611 adg_canvas_set_paddings(canvas
, 0, 0, valid_value_2
, 0);
612 bottom_padding
= adg_canvas_get_bottom_padding(canvas
);
613 adg_assert_isapprox(bottom_padding
, valid_value_2
);
615 /* Using GObject property methods */
616 g_object_set(canvas
, "bottom-padding", valid_value_1
, NULL
);
617 g_object_get(canvas
, "bottom-padding", &bottom_padding
, NULL
);
618 adg_assert_isapprox(bottom_padding
, valid_value_1
);
620 g_object_set(canvas
, "bottom-padding", valid_value_2
, NULL
);
621 g_object_get(canvas
, "bottom-padding", &bottom_padding
, NULL
);
622 adg_assert_isapprox(bottom_padding
, valid_value_2
);
624 adg_entity_destroy(ADG_ENTITY(canvas
));
628 _adg_property_left_padding(void)
631 gdouble valid_value_1
, valid_value_2
;
632 gdouble left_padding
;
634 canvas
= ADG_CANVAS(adg_canvas_new());
635 valid_value_1
= 4321;
636 valid_value_2
= -1111;
638 /* Using the public APIs */
639 adg_canvas_set_left_padding(canvas
, valid_value_1
);
640 left_padding
= adg_canvas_get_left_padding(canvas
);
641 adg_assert_isapprox(left_padding
, valid_value_1
);
643 adg_canvas_set_paddings(canvas
, 0, 0, 0, valid_value_2
);
644 left_padding
= adg_canvas_get_left_padding(canvas
);
645 adg_assert_isapprox(left_padding
, valid_value_2
);
647 /* Using GObject property methods */
648 g_object_set(canvas
, "left-padding", valid_value_1
, NULL
);
649 g_object_get(canvas
, "left-padding", &left_padding
, NULL
);
650 adg_assert_isapprox(left_padding
, valid_value_1
);
652 g_object_set(canvas
, "left-padding", valid_value_2
, NULL
);
653 g_object_get(canvas
, "left-padding", &left_padding
, NULL
);
654 adg_assert_isapprox(left_padding
, valid_value_2
);
656 adg_entity_destroy(ADG_ENTITY(canvas
));
660 _adg_method_autoscale(void)
663 AdgTitleBlock
*title_block
;
666 const cairo_matrix_t
*matrix
;
668 canvas
= adg_canvas_new();
670 /* Check autoscale does not crash on no scales */
671 adg_canvas_set_scales(canvas
, NULL
);
672 adg_canvas_autoscale(canvas
);
674 /* Set an arbitrary size on canvas: the first three scales
675 * are invalids and should be ignored*/
676 adg_canvas_set_scales(canvas
, "0", "-1:1", "1:0", "10:1", "1 a 1", "1:2", "1:10 ", NULL
);
677 adg_canvas_set_size_explicit(canvas
, 100, 100);
679 /* Check the scale will be reported on the title block */
680 title_block
= adg_title_block_new();
681 adg_canvas_set_title_block(canvas
, title_block
);
682 g_object_unref(title_block
);
684 path
= adg_path_new();
685 adg_path_move_to_explicit(path
, 0, 0);
686 adg_path_line_to_explicit(path
, 5, 5);
687 stroke
= adg_stroke_new(ADG_TRAIL(path
));
688 g_object_unref(path
);
690 adg_container_add(ADG_CONTAINER(canvas
), ADG_ENTITY(stroke
));
692 adg_canvas_autoscale(canvas
);
693 matrix
= adg_entity_get_local_matrix(ADG_ENTITY(canvas
));
694 adg_assert_isapprox(matrix
->xx
, 10);
695 g_assert_cmpstr(adg_title_block_get_scale(title_block
), ==, "10:1");
697 adg_path_line_to_explicit(path
, 50, 50);
699 adg_canvas_autoscale(canvas
);
700 matrix
= adg_entity_get_local_matrix(ADG_ENTITY(canvas
));
701 adg_assert_isapprox(matrix
->xx
, 1);
702 g_assert_cmpstr(adg_title_block_get_scale(title_block
), ==, "1 a 1");
704 adg_path_line_to_explicit(path
, 0, 100);
706 adg_canvas_autoscale(canvas
);
707 matrix
= adg_entity_get_local_matrix(ADG_ENTITY(canvas
));
708 adg_assert_isapprox(matrix
->xx
, 0.5);
709 g_assert_cmpstr(adg_title_block_get_scale(title_block
), ==, "1:2");
711 adg_path_line_to_explicit(path
, 800, 0);
713 adg_canvas_autoscale(canvas
);
714 matrix
= adg_entity_get_local_matrix(ADG_ENTITY(canvas
));
715 adg_assert_isapprox(matrix
->xx
, 0.1);
716 g_assert_cmpstr(adg_title_block_get_scale(title_block
), ==, "1:10 ");
718 adg_entity_destroy(ADG_ENTITY(canvas
));
722 _adg_method_set_margins(void)
724 AdgCanvas
*canvas
= ADG_CANVAS(adg_canvas_new());
726 adg_canvas_set_margins(canvas
, 0, 2, 4, 6);
728 g_assert_cmpfloat(adg_canvas_get_top_margin(canvas
), ==, 0);
729 g_assert_cmpfloat(adg_canvas_get_right_margin(canvas
), ==, 2);
730 adg_assert_isapprox(adg_canvas_get_bottom_margin(canvas
), 4);
731 g_assert_cmpfloat(adg_canvas_get_left_margin(canvas
), ==, 6);
733 adg_canvas_set_margins(canvas
, 1, 3, 5, 7);
735 g_assert_cmpfloat(adg_canvas_get_top_margin(canvas
), ==, 1);
736 g_assert_cmpfloat(adg_canvas_get_right_margin(canvas
), ==, 3);
737 adg_assert_isapprox(adg_canvas_get_bottom_margin(canvas
), 5);
738 g_assert_cmpfloat(adg_canvas_get_left_margin(canvas
), ==, 7);
740 adg_entity_destroy(ADG_ENTITY(canvas
));
744 _adg_method_apply_margins(void)
746 AdgCanvas
*canvas
= ADG_CANVAS(adg_canvas_new());
747 CpmlExtents extents
= {
754 adg_canvas_apply_margins(canvas
, NULL
);
755 //adg_canvas_apply_margins(NULL, &extents);
757 adg_canvas_set_margins(canvas
, 1, 2, 3, 4);
759 adg_canvas_apply_margins(canvas
, &extents
);
761 g_assert_cmpfloat(extents
.org
.x
, ==, -4);
762 g_assert_cmpfloat(extents
.org
.y
, ==, -1);
763 adg_assert_isapprox(extents
.size
.x
, 16);
764 adg_assert_isapprox(extents
.size
.y
, 14);
766 adg_canvas_apply_margins(canvas
, &extents
);
768 g_assert_cmpfloat(extents
.org
.x
, ==, -8);
769 g_assert_cmpfloat(extents
.org
.y
, ==, -2);
770 adg_assert_isapprox(extents
.size
.x
, 22);
771 adg_assert_isapprox(extents
.size
.y
, 18);
773 extents
.is_defined
= 0;
774 adg_canvas_apply_margins(canvas
, &extents
);
776 g_assert_cmpfloat(extents
.org
.x
, ==, -8);
777 g_assert_cmpfloat(extents
.org
.y
, ==, -2);
778 adg_assert_isapprox(extents
.size
.x
, 22);
779 adg_assert_isapprox(extents
.size
.y
, 18);
781 adg_entity_destroy(ADG_ENTITY(canvas
));
785 _adg_method_set_paddings(void)
787 AdgCanvas
*canvas
= ADG_CANVAS(adg_canvas_new());
789 adg_canvas_set_paddings(canvas
, 0, 2, 4, 6);
791 g_assert_cmpfloat(adg_canvas_get_top_padding(canvas
), ==, 0);
792 g_assert_cmpfloat(adg_canvas_get_right_padding(canvas
), ==, 2);
793 adg_assert_isapprox(adg_canvas_get_bottom_padding(canvas
), 4);
794 g_assert_cmpfloat(adg_canvas_get_left_padding(canvas
), ==, 6);
796 adg_canvas_set_paddings(canvas
, 1, 3, 5, 7);
798 g_assert_cmpfloat(adg_canvas_get_top_padding(canvas
), ==, 1);
799 g_assert_cmpfloat(adg_canvas_get_right_padding(canvas
), ==, 3);
800 adg_assert_isapprox(adg_canvas_get_bottom_padding(canvas
), 5);
801 g_assert_cmpfloat(adg_canvas_get_left_padding(canvas
), ==, 7);
803 adg_entity_destroy(ADG_ENTITY(canvas
));
807 _adg_method_export(void)
809 AdgCanvas
*canvas
= adg_test_canvas();
812 g_assert_false(adg_canvas_export(NULL
, CAIRO_SURFACE_TYPE_IMAGE
, NULL_FILE
, NULL
));
813 g_assert_false(adg_canvas_export(canvas
, CAIRO_SURFACE_TYPE_IMAGE
, NULL
, NULL
));
815 /* Supported surface types return TRUE while unsupported ones return FALSE */
816 g_assert_true(adg_canvas_export(canvas
, CAIRO_SURFACE_TYPE_IMAGE
, NULL_FILE
, NULL
));
817 g_assert_true(adg_canvas_export(canvas
, CAIRO_SURFACE_TYPE_PDF
, NULL_FILE
, NULL
));
818 g_assert_true(adg_canvas_export(canvas
, CAIRO_SURFACE_TYPE_PS
, NULL_FILE
, NULL
));
819 g_assert_false(adg_canvas_export(canvas
, CAIRO_SURFACE_TYPE_XLIB
, NULL_FILE
, NULL
));
820 g_assert_false(adg_canvas_export(canvas
, CAIRO_SURFACE_TYPE_XCB
, NULL_FILE
, NULL
));
821 g_assert_false(adg_canvas_export(canvas
, CAIRO_SURFACE_TYPE_GLITZ
, NULL_FILE
, NULL
));
822 g_assert_false(adg_canvas_export(canvas
, CAIRO_SURFACE_TYPE_QUARTZ
, NULL_FILE
, NULL
));
823 g_assert_false(adg_canvas_export(canvas
, CAIRO_SURFACE_TYPE_WIN32
, NULL_FILE
, NULL
));
824 g_assert_false(adg_canvas_export(canvas
, CAIRO_SURFACE_TYPE_BEOS
, NULL_FILE
, NULL
));
825 g_assert_false(adg_canvas_export(canvas
, CAIRO_SURFACE_TYPE_DIRECTFB
, NULL_FILE
, NULL
));
826 g_assert_true(adg_canvas_export(canvas
, CAIRO_SURFACE_TYPE_SVG
, NULL_FILE
, NULL
));
827 g_assert_false(adg_canvas_export(canvas
, CAIRO_SURFACE_TYPE_OS2
, NULL_FILE
, NULL
));
828 g_assert_false(adg_canvas_export(canvas
, CAIRO_SURFACE_TYPE_WIN32_PRINTING
, NULL_FILE
, NULL
));
829 g_assert_false(adg_canvas_export(canvas
, CAIRO_SURFACE_TYPE_QUARTZ_IMAGE
, NULL_FILE
, NULL
));
831 /* An empty canvas can fail depending on the surface type (e.g., the image
832 * surface fails while the PDF surface does not) so skipping that tests */
834 adg_entity_destroy(ADG_ENTITY(canvas
));
837 #if GTK3_ENABLED || GTK2_ENABLED
840 _adg_method_set_paper(void)
843 const CpmlPair
*size
;
844 gdouble width
, height
;
846 canvas
= ADG_CANVAS(adg_canvas_new());
848 size
= adg_canvas_get_size(canvas
);
849 adg_assert_isapprox(size
->x
, 0);
850 adg_assert_isapprox(size
->y
, 0);
852 adg_canvas_set_margins(canvas
, 0, 0, 0, 0);
853 adg_canvas_set_paper(canvas
, GTK_PAPER_NAME_A4
,
854 GTK_PAGE_ORIENTATION_LANDSCAPE
);
856 g_assert_cmpfloat(adg_canvas_get_top_margin(canvas
), !=, 0);
857 g_assert_cmpfloat(adg_canvas_get_right_margin(canvas
), !=, 0);
858 g_assert_cmpfloat(adg_canvas_get_bottom_margin(canvas
), !=, 0);
859 g_assert_cmpfloat(adg_canvas_get_left_margin(canvas
), !=, 0);
861 size
= adg_canvas_get_size(canvas
);
864 g_assert_cmpfloat(width
, !=, 0);
865 g_assert_cmpfloat(height
, !=, 0);
867 adg_canvas_set_left_margin(canvas
, 0);
868 adg_canvas_set_top_margin(canvas
, 0);
870 size
= adg_canvas_get_size(canvas
);
871 g_assert_cmpfloat(width
, !=, size
->x
);
872 g_assert_cmpfloat(height
, !=, size
->y
);
876 /* Ensure the page size is decreased when margins are increased */
877 adg_canvas_set_left_margin(canvas
, adg_canvas_get_left_margin(canvas
) + 1);
878 adg_canvas_set_top_margin(canvas
, adg_canvas_get_top_margin(canvas
) + 2);
879 size
= adg_canvas_get_size(canvas
);
880 adg_assert_isapprox(size
->x
, width
- 1);
881 adg_assert_isapprox(size
->y
, height
- 2);
883 adg_entity_destroy(ADG_ENTITY(canvas
));
887 _adg_method_get_page_setup(void)
890 GtkPageSetup
*page_setup
;
893 g_assert_null(adg_canvas_get_page_setup(NULL
));
895 canvas
= ADG_CANVAS(adg_canvas_new());
896 page_setup
= gtk_page_setup_new();
898 g_assert_null(adg_canvas_get_page_setup(canvas
));
900 adg_canvas_set_page_setup(canvas
, page_setup
);
901 g_assert_true(adg_canvas_get_page_setup(canvas
) == page_setup
);
903 /* canvas should still internally owns a reference to page_setup */
904 g_object_unref(page_setup
);
905 g_assert_true(GTK_IS_PAGE_SETUP(adg_canvas_get_page_setup(canvas
)));
907 adg_canvas_set_page_setup(canvas
, NULL
);
908 g_assert_null(adg_canvas_get_page_setup(canvas
));
910 adg_entity_destroy(ADG_ENTITY(canvas
));
914 _adg_method_set_page_setup(void)
917 GtkPageSetup
*page_setup
;
918 const CpmlPair
*size
;
919 gdouble width
, height
;
921 canvas
= ADG_CANVAS(adg_canvas_new());
922 page_setup
= gtk_page_setup_new();
925 adg_canvas_set_page_setup(NULL
, page_setup
);
927 gtk_page_setup_set_top_margin(page_setup
, 1, GTK_UNIT_POINTS
);
928 gtk_page_setup_set_right_margin(page_setup
, 2, GTK_UNIT_POINTS
);
929 gtk_page_setup_set_left_margin(page_setup
, 3, GTK_UNIT_POINTS
);
930 gtk_page_setup_set_bottom_margin(page_setup
, 4, GTK_UNIT_POINTS
);
932 adg_canvas_set_page_setup(canvas
, page_setup
);
933 g_object_unref(page_setup
);
935 /* For some unknown reason the margins are rounded, so using
936 * adg_assert_isapprox() instead of g_assert_cmpfloat() */
937 adg_assert_isapprox(adg_canvas_get_top_margin(canvas
), 1);
938 adg_assert_isapprox(adg_canvas_get_right_margin(canvas
), 2);
939 adg_assert_isapprox(adg_canvas_get_left_margin(canvas
), 3);
940 adg_assert_isapprox(adg_canvas_get_bottom_margin(canvas
), 4);
942 adg_canvas_set_page_setup(canvas
, NULL
);
944 adg_assert_isapprox(adg_canvas_get_top_margin(canvas
), 1);
945 adg_assert_isapprox(adg_canvas_get_right_margin(canvas
), 2);
946 adg_assert_isapprox(adg_canvas_get_left_margin(canvas
), 3);
947 adg_assert_isapprox(adg_canvas_get_bottom_margin(canvas
), 4);
949 size
= adg_canvas_get_size(canvas
);
952 g_assert_cmpfloat(adg_canvas_get_top_margin(canvas
), ==, 1);
954 /* When no page setup is bound to canvas, changing the margins
955 * should not change the page size */
956 adg_canvas_set_margins(canvas
, 10, 20, 30, 40);
957 size
= adg_canvas_get_size(canvas
);
958 adg_assert_isapprox(size
->x
, width
);
959 adg_assert_isapprox(size
->y
, height
);
961 adg_entity_destroy(ADG_ENTITY(canvas
));
968 main(int argc
, char *argv
[])
970 adg_test_init(&argc
, &argv
);
972 adg_test_add_object_checks("/adg/canvas/type/object", ADG_TYPE_CANVAS
);
973 adg_test_add_entity_checks("/adg/canvas/type/entity", ADG_TYPE_CANVAS
);
974 adg_test_add_container_checks("/adg/canvas/type/container", ADG_TYPE_CANVAS
);
976 g_test_add_func("/adg/canvas/behavior/entity", _adg_behavior_entity
);
977 g_test_add_func("/adg/canvas/behavior/misc", _adg_behavior_misc
);
978 adg_test_add_global_space_checks("/adg/canvas/behavior/global-space", adg_test_canvas());
979 adg_test_add_local_space_checks("/adg/canvas/behavior/local-space", adg_test_canvas());
981 g_test_add_func("/adg/canvas/property/background-dress", _adg_property_background_dress
);
982 g_test_add_func("/adg/canvas/property/frame-dress", _adg_property_frame_dress
);
983 g_test_add_func("/adg/canvas/property/title-block", _adg_property_title_block
);
984 g_test_add_func("/adg/canvas/property/size", _adg_property_size
);
985 g_test_add_func("/adg/canvas/property/factor", _adg_property_factor
);
986 g_test_add_func("/adg/canvas/property/scales", _adg_property_scales
);
987 g_test_add_func("/adg/canvas/property/top-margin", _adg_property_top_margin
);
988 g_test_add_func("/adg/canvas/property/right-margin", _adg_property_right_margin
);
989 g_test_add_func("/adg/canvas/property/bottom-margin", _adg_property_bottom_margin
);
990 g_test_add_func("/adg/canvas/property/left-margin", _adg_property_left_margin
);
991 g_test_add_func("/adg/canvas/property/has-frame", _adg_property_has_frame
);
992 g_test_add_func("/adg/canvas/property/top-padding", _adg_property_top_padding
);
993 g_test_add_func("/adg/canvas/property/right-padding", _adg_property_right_padding
);
994 g_test_add_func("/adg/canvas/property/bottom-padding", _adg_property_bottom_padding
);
995 g_test_add_func("/adg/canvas/property/left-padding", _adg_property_left_padding
);
997 g_test_add_func("/adg/canvas/method/autoscale", _adg_method_autoscale
);
998 g_test_add_func("/adg/canvas/method/set-margins", _adg_method_set_margins
);
999 g_test_add_func("/adg/canvas/method/apply-margins", _adg_method_apply_margins
);
1000 g_test_add_func("/adg/canvas/method/set-paddings", _adg_method_set_paddings
);
1001 g_test_add_func("/adg/canvas/method/export", _adg_method_export
);
1002 #if GTK3_ENABLED || GTK2_ENABLED
1003 g_test_add_func("/adg/canvas/method/set-paper", _adg_method_set_paper
);
1004 g_test_add_func("/adg/canvas/method/get-page-setup", _adg_method_get_page_setup
);
1005 g_test_add_func("/adg/canvas/method/set-page-setup", _adg_method_set_page_setup
);
1008 return g_test_run();