1 /* ADG - Automatic Drawing Generation
2 * Copyright (C) 2007-2015 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.
26 _adg_test_background_dress(void)
29 AdgDress valid_dress_1
, valid_dress_2
, incompatible_dress
;
30 AdgDress background_dress
;
32 canvas
= adg_canvas_new();
33 valid_dress_1
= ADG_DRESS_COLOR_DIMENSION
;
34 valid_dress_2
= ADG_DRESS_COLOR_FILL
;
35 incompatible_dress
= ADG_DRESS_FONT_QUOTE_ANNOTATION
;
37 /* Using the public APIs */
38 adg_canvas_set_background_dress(canvas
, valid_dress_1
);
39 background_dress
= adg_canvas_get_background_dress(canvas
);
40 g_assert_cmpint(background_dress
, ==, valid_dress_1
);
42 adg_canvas_set_background_dress(canvas
, incompatible_dress
);
43 background_dress
= adg_canvas_get_background_dress(canvas
);
44 g_assert_cmpint(background_dress
, ==, valid_dress_1
);
46 adg_canvas_set_background_dress(canvas
, valid_dress_2
);
47 background_dress
= adg_canvas_get_background_dress(canvas
);
48 g_assert_cmpint(background_dress
, ==, valid_dress_2
);
50 /* Using GObject property methods */
51 g_object_set(canvas
, "background-dress", valid_dress_1
, NULL
);
52 g_object_get(canvas
, "background-dress", &background_dress
, NULL
);
53 g_assert_cmpint(background_dress
, ==, valid_dress_1
);
55 g_object_set(canvas
, "background-dress", incompatible_dress
, NULL
);
56 g_object_get(canvas
, "background-dress", &background_dress
, NULL
);
57 g_assert_cmpint(background_dress
, ==, valid_dress_1
);
59 g_object_set(canvas
, "background-dress", valid_dress_2
, NULL
);
60 g_object_get(canvas
, "background-dress", &background_dress
, NULL
);
61 g_assert_cmpint(background_dress
, ==, valid_dress_2
);
63 adg_entity_destroy(ADG_ENTITY(canvas
));
67 _adg_test_frame_dress(void)
70 AdgDress valid_dress_1
, valid_dress_2
, incompatible_dress
;
73 canvas
= adg_canvas_new();
74 valid_dress_1
= ADG_DRESS_LINE_DIMENSION
;
75 valid_dress_2
= ADG_DRESS_LINE_FILL
;
76 incompatible_dress
= ADG_DRESS_FONT
;
78 /* Using the public APIs */
79 adg_canvas_set_frame_dress(canvas
, valid_dress_1
);
80 frame_dress
= adg_canvas_get_frame_dress(canvas
);
81 g_assert_cmpint(frame_dress
, ==, valid_dress_1
);
83 adg_canvas_set_frame_dress(canvas
, incompatible_dress
);
84 frame_dress
= adg_canvas_get_frame_dress(canvas
);
85 g_assert_cmpint(frame_dress
, ==, valid_dress_1
);
87 adg_canvas_set_frame_dress(canvas
, valid_dress_2
);
88 frame_dress
= adg_canvas_get_frame_dress(canvas
);
89 g_assert_cmpint(frame_dress
, ==, valid_dress_2
);
91 /* Using GObject property methods */
92 g_object_set(canvas
, "frame-dress", valid_dress_1
, NULL
);
93 g_object_get(canvas
, "frame-dress", &frame_dress
, NULL
);
94 g_assert_cmpint(frame_dress
, ==, valid_dress_1
);
96 g_object_set(canvas
, "frame-dress", incompatible_dress
, NULL
);
97 g_object_get(canvas
, "frame-dress", &frame_dress
, NULL
);
98 g_assert_cmpint(frame_dress
, ==, valid_dress_1
);
100 g_object_set(canvas
, "frame-dress", valid_dress_2
, NULL
);
101 g_object_get(canvas
, "frame-dress", &frame_dress
, NULL
);
102 g_assert_cmpint(frame_dress
, ==, valid_dress_2
);
104 adg_entity_destroy(ADG_ENTITY(canvas
));
108 _adg_test_title_block(void)
111 AdgTitleBlock
*valid_title_block
, *invalid_title_block
, *title_block
;
113 canvas
= adg_canvas_new();
114 valid_title_block
= ADG_TITLE_BLOCK(adg_title_block_new());
115 invalid_title_block
= adg_test_invalid_pointer();
117 g_object_ref(valid_title_block
);
119 /* Using the public APIs */
120 adg_canvas_set_title_block(canvas
, NULL
);
121 title_block
= adg_canvas_get_title_block(canvas
);
122 g_assert_null(title_block
);
124 adg_canvas_set_title_block(canvas
, valid_title_block
);
125 title_block
= adg_canvas_get_title_block(canvas
);
126 g_assert_true(title_block
== valid_title_block
);
128 adg_canvas_set_title_block(canvas
, invalid_title_block
);
129 title_block
= adg_canvas_get_title_block(canvas
);
130 g_assert_true(title_block
== valid_title_block
);
132 adg_canvas_set_title_block(canvas
, NULL
);
133 title_block
= adg_canvas_get_title_block(canvas
);
134 g_assert_null(title_block
);
136 /* Using GObject property methods */
137 g_object_set(canvas
, "title-block", NULL
, NULL
);
138 g_object_get(canvas
, "title-block", &title_block
, NULL
);
139 g_assert_null(title_block
);
141 g_object_set(canvas
, "title-block", valid_title_block
, NULL
);
142 g_object_get(canvas
, "title-block", &title_block
, NULL
);
143 g_assert_true(title_block
== valid_title_block
);
144 adg_entity_destroy(ADG_ENTITY(title_block
));
146 g_object_set(canvas
, "title-block", invalid_title_block
, NULL
);
147 g_object_get(canvas
, "title-block", &title_block
, NULL
);
148 g_assert_true(title_block
== valid_title_block
);
149 adg_entity_destroy(ADG_ENTITY(title_block
));
151 g_object_set(canvas
, "title-block", NULL
, NULL
);
152 g_object_get(canvas
, "title-block", &title_block
, NULL
);
153 g_assert_null(title_block
);
155 adg_entity_destroy(ADG_ENTITY(canvas
));
156 adg_entity_destroy(ADG_ENTITY(valid_title_block
));
163 CpmlPair null_size
, sample_size
;
164 const CpmlPair
*size
;
167 canvas
= adg_canvas_new();
173 /* Using the public APIs */
174 size
= adg_canvas_get_size(canvas
);
176 /* The default size is 0, 0 (anamorphic canvas) */
177 g_assert_true(cpml_pair_equal(size
, &null_size
));
179 adg_canvas_set_size(canvas
, &sample_size
);
180 size
= adg_canvas_get_size(canvas
);
181 g_assert_true(cpml_pair_equal(size
, &sample_size
));
183 adg_canvas_set_size(canvas
, NULL
);
184 size
= adg_canvas_get_size(canvas
);
185 g_assert_true(cpml_pair_equal(size
, &sample_size
));
187 adg_canvas_set_size_explicit(canvas
, 0, 0);
188 size
= adg_canvas_get_size(canvas
);
189 g_assert_true(cpml_pair_equal(size
, &null_size
));
191 /* Using GObject property methods */
192 g_object_set(canvas
, "size", &sample_size
, NULL
);
193 g_object_get(canvas
, "size", &size_dup
, NULL
);
194 g_assert_true(cpml_pair_equal(size_dup
, &sample_size
));
197 g_object_set(canvas
, "size", NULL
, NULL
);
198 g_object_get(canvas
, "size", &size_dup
, NULL
);
199 g_assert_true(cpml_pair_equal(size_dup
, &sample_size
));
202 g_object_set(canvas
, "size", &null_size
, NULL
);
203 g_object_get(canvas
, "size", &size_dup
, NULL
);
204 g_assert_true(cpml_pair_equal(size_dup
, &null_size
));
207 adg_entity_destroy(ADG_ENTITY(canvas
));
211 _adg_test_scales(void)
215 gchar
*scales_array
[] = { "a", "b", "c", NULL
};
217 /* By default, AdgCanvas:scales is prefilled with some default scales */
218 canvas
= adg_canvas_new();
219 scales
= adg_canvas_get_scales(canvas
);
220 g_assert_nonnull(scales
);
221 adg_entity_destroy(ADG_ENTITY(canvas
));
223 /* AdgCanvas:scales must be prefilled also when using g_object_new() */
224 canvas
= g_object_new(ADG_TYPE_CANVAS
, NULL
);
225 scales
= adg_canvas_get_scales(canvas
);
226 g_assert_nonnull(scales
);
228 /* Using the public APIs */
229 adg_canvas_set_scales(canvas
, NULL
);
230 scales
= adg_canvas_get_scales(canvas
);
231 g_assert_null(scales
);
233 adg_canvas_set_scales(canvas
, "0", "1", NULL
);
234 scales
= adg_canvas_get_scales(canvas
);
235 g_assert_nonnull(scales
);
236 g_assert_cmpstr(scales
[0], ==, "0");
237 g_assert_cmpstr(scales
[1], ==, "1");
238 g_assert_null(scales
[2]);
240 adg_canvas_set_scales_array(canvas
, NULL
);
241 scales
= adg_canvas_get_scales(canvas
);
242 g_assert_null(scales
);
244 adg_canvas_set_scales_array(canvas
, scales_array
);
245 scales
= adg_canvas_get_scales(canvas
);
246 g_assert_nonnull(scales
);
247 g_assert_cmpstr(scales
[0], ==, "a");
248 g_assert_cmpstr(scales
[1], ==, "b");
249 g_assert_cmpstr(scales
[2], ==, "c");
250 g_assert_null(scales
[3]);
252 /* Using GObject property methods */
253 g_object_set(canvas
, "scales", NULL
, NULL
);
254 g_object_get(canvas
, "scales", &scales
, NULL
);
255 g_assert_null(scales
);
257 g_object_set(canvas
, "scales", scales_array
, NULL
);
258 g_object_get(canvas
, "scales", &scales
, NULL
);
259 g_assert_nonnull(scales
);
260 g_assert_cmpstr(scales
[0], ==, "a");
261 g_assert_cmpstr(scales
[1], ==, "b");
262 g_assert_cmpstr(scales
[2], ==, "c");
263 g_assert_null(scales
[3]);
266 /* Check autoscale does not crash on no scales */
267 g_object_set(canvas
, "scales", NULL
, NULL
);
268 adg_canvas_autoscale(canvas
);
270 adg_entity_destroy(ADG_ENTITY(canvas
));
274 _adg_test_top_margin(void)
277 gdouble valid_value_1
, valid_value_2
;
280 canvas
= ADG_CANVAS(adg_canvas_new());
281 valid_value_1
= 4321;
284 /* Using the public APIs */
285 adg_canvas_set_top_margin(canvas
, valid_value_1
);
286 top_margin
= adg_canvas_get_top_margin(canvas
);
287 g_assert_cmpfloat(top_margin
, ==, valid_value_1
);
289 adg_canvas_set_margins(canvas
, valid_value_2
, 0, 0, 0);
290 top_margin
= adg_canvas_get_top_margin(canvas
);
291 g_assert_cmpfloat(top_margin
, ==, valid_value_2
);
293 /* Using GObject property methods */
294 g_object_set(canvas
, "top-margin", valid_value_1
, NULL
);
295 g_object_get(canvas
, "top-margin", &top_margin
, NULL
);
296 g_assert_cmpfloat(top_margin
, ==, valid_value_1
);
298 g_object_set(canvas
, "top-margin", valid_value_2
, NULL
);
299 g_object_get(canvas
, "top-margin", &top_margin
, NULL
);
300 g_assert_cmpfloat(top_margin
, ==, valid_value_2
);
302 adg_entity_destroy(ADG_ENTITY(canvas
));
306 _adg_test_right_margin(void)
309 gdouble valid_value_1
, valid_value_2
;
310 gdouble right_margin
;
312 canvas
= ADG_CANVAS(adg_canvas_new());
313 valid_value_1
= 4321;
316 /* Using the public APIs */
317 adg_canvas_set_right_margin(canvas
, valid_value_1
);
318 right_margin
= adg_canvas_get_right_margin(canvas
);
319 g_assert_cmpfloat(right_margin
, ==, valid_value_1
);
321 adg_canvas_set_margins(canvas
, 0, valid_value_2
, 0, 0);
322 right_margin
= adg_canvas_get_right_margin(canvas
);
323 g_assert_cmpfloat(right_margin
, ==, valid_value_2
);
325 /* Using GObject property methods */
326 g_object_set(canvas
, "right-margin", valid_value_1
, NULL
);
327 g_object_get(canvas
, "right-margin", &right_margin
, NULL
);
328 g_assert_cmpfloat(right_margin
, ==, valid_value_1
);
330 g_object_set(canvas
, "right-margin", valid_value_2
, NULL
);
331 g_object_get(canvas
, "right-margin", &right_margin
, NULL
);
332 g_assert_cmpfloat(right_margin
, ==, valid_value_2
);
334 adg_entity_destroy(ADG_ENTITY(canvas
));
338 _adg_test_bottom_margin(void)
341 gdouble valid_value_1
, valid_value_2
;
342 gdouble bottom_margin
;
344 canvas
= ADG_CANVAS(adg_canvas_new());
345 valid_value_1
= 4321;
346 valid_value_2
= -1234;
348 /* Using the public APIs */
349 adg_canvas_set_bottom_margin(canvas
, valid_value_1
);
350 bottom_margin
= adg_canvas_get_bottom_margin(canvas
);
351 g_assert_cmpfloat(bottom_margin
, ==, valid_value_1
);
353 adg_canvas_set_margins(canvas
, 0, 0, valid_value_2
, 0);
354 bottom_margin
= adg_canvas_get_bottom_margin(canvas
);
355 g_assert_cmpfloat(bottom_margin
, ==, valid_value_2
);
357 /* Using GObject property methods */
358 g_object_set(canvas
, "bottom-margin", valid_value_1
, NULL
);
359 g_object_get(canvas
, "bottom-margin", &bottom_margin
, NULL
);
360 g_assert_cmpfloat(bottom_margin
, ==, valid_value_1
);
362 g_object_set(canvas
, "bottom-margin", valid_value_2
, NULL
);
363 g_object_get(canvas
, "bottom-margin", &bottom_margin
, NULL
);
364 g_assert_cmpfloat(bottom_margin
, ==, valid_value_2
);
366 adg_entity_destroy(ADG_ENTITY(canvas
));
370 _adg_test_left_margin(void)
373 gdouble valid_value_1
, valid_value_2
;
376 canvas
= ADG_CANVAS(adg_canvas_new());
377 valid_value_1
= 4321;
378 valid_value_2
= -4321;
380 /* Using the public APIs */
381 adg_canvas_set_left_margin(canvas
, valid_value_1
);
382 left_margin
= adg_canvas_get_left_margin(canvas
);
383 g_assert_cmpfloat(left_margin
, ==, valid_value_1
);
385 adg_canvas_set_margins(canvas
, 0, 0, 0, valid_value_2
);
386 left_margin
= adg_canvas_get_left_margin(canvas
);
387 g_assert_cmpfloat(left_margin
, ==, valid_value_2
);
389 /* Using GObject property methods */
390 g_object_set(canvas
, "left-margin", valid_value_1
, NULL
);
391 g_object_get(canvas
, "left-margin", &left_margin
, NULL
);
392 g_assert_cmpfloat(left_margin
, ==, valid_value_1
);
394 g_object_set(canvas
, "left-margin", valid_value_2
, NULL
);
395 g_object_get(canvas
, "left-margin", &left_margin
, NULL
);
396 g_assert_cmpfloat(left_margin
, ==, valid_value_2
);
398 adg_entity_destroy(ADG_ENTITY(canvas
));
402 _adg_test_has_frame(void)
405 gboolean invalid_boolean
;
408 canvas
= ADG_CANVAS(adg_canvas_new());
409 invalid_boolean
= (gboolean
) 1234;
411 /* Using the public APIs */
412 adg_canvas_switch_frame(canvas
, FALSE
);
413 has_frame
= adg_canvas_has_frame(canvas
);
414 g_assert_false(has_frame
);
416 adg_canvas_switch_frame(canvas
, invalid_boolean
);
417 has_frame
= adg_canvas_has_frame(canvas
);
418 g_assert_false(has_frame
);
420 adg_canvas_switch_frame(canvas
, TRUE
);
421 has_frame
= adg_canvas_has_frame(canvas
);
422 g_assert_true(has_frame
);
424 /* Using GObject property methods */
425 g_object_set(canvas
, "has-frame", FALSE
, NULL
);
426 g_object_get(canvas
, "has-frame", &has_frame
, NULL
);
427 g_assert_false(has_frame
);
429 g_object_set(canvas
, "has-frame", invalid_boolean
, NULL
);
430 g_object_get(canvas
, "has-frame", &has_frame
, NULL
);
431 g_assert_false(has_frame
);
433 g_object_set(canvas
, "has-frame", TRUE
, NULL
);
434 g_object_get(canvas
, "has-frame", &has_frame
, NULL
);
435 g_assert_true(has_frame
);
437 adg_entity_destroy(ADG_ENTITY(canvas
));
441 _adg_test_top_padding(void)
444 gdouble valid_value_1
, valid_value_2
;
447 canvas
= ADG_CANVAS(adg_canvas_new());
448 valid_value_1
= 4321;
451 /* Using the public APIs */
452 adg_canvas_set_top_padding(canvas
, valid_value_1
);
453 top_padding
= adg_canvas_get_top_padding(canvas
);
454 g_assert_cmpfloat(top_padding
, ==, valid_value_1
);
456 adg_canvas_set_paddings(canvas
, valid_value_2
, 0, 0, 0);
457 top_padding
= adg_canvas_get_top_padding(canvas
);
458 g_assert_cmpfloat(top_padding
, ==, valid_value_2
);
460 /* Using GObject property methods */
461 g_object_set(canvas
, "top-padding", valid_value_1
, NULL
);
462 g_object_get(canvas
, "top-padding", &top_padding
, NULL
);
463 g_assert_cmpfloat(top_padding
, ==, valid_value_1
);
465 g_object_set(canvas
, "top-padding", valid_value_2
, NULL
);
466 g_object_get(canvas
, "top-padding", &top_padding
, NULL
);
467 g_assert_cmpfloat(top_padding
, ==, valid_value_2
);
469 adg_entity_destroy(ADG_ENTITY(canvas
));
473 _adg_test_right_padding(void)
476 gdouble valid_value_1
, valid_value_2
;
477 gdouble right_padding
;
479 canvas
= ADG_CANVAS(adg_canvas_new());
480 valid_value_1
= 4321;
483 /* Using the public APIs */
484 adg_canvas_set_right_padding(canvas
, valid_value_1
);
485 right_padding
= adg_canvas_get_right_padding(canvas
);
486 g_assert_cmpfloat(right_padding
, ==, valid_value_1
);
488 adg_canvas_set_paddings(canvas
, 0, valid_value_2
, 0, 0);
489 right_padding
= adg_canvas_get_right_padding(canvas
);
490 g_assert_cmpfloat(right_padding
, ==, valid_value_2
);
492 /* Using GObject property methods */
493 g_object_set(canvas
, "right-padding", valid_value_1
, NULL
);
494 g_object_get(canvas
, "right-padding", &right_padding
, NULL
);
495 g_assert_cmpfloat(right_padding
, ==, valid_value_1
);
497 g_object_set(canvas
, "right-padding", valid_value_2
, NULL
);
498 g_object_get(canvas
, "right-padding", &right_padding
, NULL
);
499 g_assert_cmpfloat(right_padding
, ==, valid_value_2
);
501 adg_entity_destroy(ADG_ENTITY(canvas
));
505 _adg_test_bottom_padding(void)
508 gdouble valid_value_1
, valid_value_2
;
509 gdouble bottom_padding
;
511 canvas
= ADG_CANVAS(adg_canvas_new());
512 valid_value_1
= 4321;
513 valid_value_2
= -4321;
515 /* Using the public APIs */
516 adg_canvas_set_bottom_padding(canvas
, valid_value_1
);
517 bottom_padding
= adg_canvas_get_bottom_padding(canvas
);
518 g_assert_cmpfloat(bottom_padding
, ==, valid_value_1
);
520 adg_canvas_set_paddings(canvas
, 0, 0, valid_value_2
, 0);
521 bottom_padding
= adg_canvas_get_bottom_padding(canvas
);
522 g_assert_cmpfloat(bottom_padding
, ==, valid_value_2
);
524 /* Using GObject property methods */
525 g_object_set(canvas
, "bottom-padding", valid_value_1
, NULL
);
526 g_object_get(canvas
, "bottom-padding", &bottom_padding
, NULL
);
527 g_assert_cmpfloat(bottom_padding
, ==, valid_value_1
);
529 g_object_set(canvas
, "bottom-padding", valid_value_2
, NULL
);
530 g_object_get(canvas
, "bottom-padding", &bottom_padding
, NULL
);
531 g_assert_cmpfloat(bottom_padding
, ==, valid_value_2
);
533 adg_entity_destroy(ADG_ENTITY(canvas
));
537 _adg_test_left_padding(void)
540 gdouble valid_value_1
, valid_value_2
;
541 gdouble left_padding
;
543 canvas
= ADG_CANVAS(adg_canvas_new());
544 valid_value_1
= 4321;
545 valid_value_2
= -1111;
547 /* Using the public APIs */
548 adg_canvas_set_left_padding(canvas
, valid_value_1
);
549 left_padding
= adg_canvas_get_left_padding(canvas
);
550 g_assert_cmpfloat(left_padding
, ==, valid_value_1
);
552 adg_canvas_set_paddings(canvas
, 0, 0, 0, valid_value_2
);
553 left_padding
= adg_canvas_get_left_padding(canvas
);
554 g_assert_cmpfloat(left_padding
, ==, valid_value_2
);
556 /* Using GObject property methods */
557 g_object_set(canvas
, "left-padding", valid_value_1
, NULL
);
558 g_object_get(canvas
, "left-padding", &left_padding
, NULL
);
559 g_assert_cmpfloat(left_padding
, ==, valid_value_1
);
561 g_object_set(canvas
, "left-padding", valid_value_2
, NULL
);
562 g_object_get(canvas
, "left-padding", &left_padding
, NULL
);
563 g_assert_cmpfloat(left_padding
, ==, valid_value_2
);
565 adg_entity_destroy(ADG_ENTITY(canvas
));
569 _adg_method_set_margins(void)
571 AdgCanvas
*canvas
= ADG_CANVAS(adg_canvas_new());
573 adg_canvas_set_margins(canvas
, 0, 2, 4, 6);
575 g_assert_cmpfloat(adg_canvas_get_top_margin(canvas
), ==, 0);
576 g_assert_cmpfloat(adg_canvas_get_right_margin(canvas
), ==, 2);
577 g_assert_cmpfloat(adg_canvas_get_bottom_margin(canvas
), ==, 4);
578 g_assert_cmpfloat(adg_canvas_get_left_margin(canvas
), ==, 6);
580 adg_canvas_set_margins(canvas
, 1, 3, 5, 7);
582 g_assert_cmpfloat(adg_canvas_get_top_margin(canvas
), ==, 1);
583 g_assert_cmpfloat(adg_canvas_get_right_margin(canvas
), ==, 3);
584 g_assert_cmpfloat(adg_canvas_get_bottom_margin(canvas
), ==, 5);
585 g_assert_cmpfloat(adg_canvas_get_left_margin(canvas
), ==, 7);
587 adg_entity_destroy(ADG_ENTITY(canvas
));
591 _adg_method_set_paddings(void)
593 AdgCanvas
*canvas
= ADG_CANVAS(adg_canvas_new());
595 adg_canvas_set_paddings(canvas
, 0, 2, 4, 6);
597 g_assert_cmpfloat(adg_canvas_get_top_padding(canvas
), ==, 0);
598 g_assert_cmpfloat(adg_canvas_get_right_padding(canvas
), ==, 2);
599 g_assert_cmpfloat(adg_canvas_get_bottom_padding(canvas
), ==, 4);
600 g_assert_cmpfloat(adg_canvas_get_left_padding(canvas
), ==, 6);
602 adg_canvas_set_paddings(canvas
, 1, 3, 5, 7);
604 g_assert_cmpfloat(adg_canvas_get_top_padding(canvas
), ==, 1);
605 g_assert_cmpfloat(adg_canvas_get_right_padding(canvas
), ==, 3);
606 g_assert_cmpfloat(adg_canvas_get_bottom_padding(canvas
), ==, 5);
607 g_assert_cmpfloat(adg_canvas_get_left_padding(canvas
), ==, 7);
609 adg_entity_destroy(ADG_ENTITY(canvas
));
612 #if GTK3_ENABLED || GTK2_ENABLED
614 _adg_method_set_paper(void)
617 const CpmlPair
*size
;
618 gdouble width
, height
;
620 canvas
= ADG_CANVAS(adg_canvas_new());
622 size
= adg_canvas_get_size(canvas
);
623 g_assert_cmpfloat(size
->x
, ==, 0);
624 g_assert_cmpfloat(size
->y
, ==, 0);
626 adg_canvas_set_margins(canvas
, 0, 0, 0, 0);
627 adg_canvas_set_paper(canvas
, GTK_PAPER_NAME_A4
,
628 GTK_PAGE_ORIENTATION_LANDSCAPE
);
630 g_assert_cmpfloat(adg_canvas_get_top_margin(canvas
), !=, 0);
631 g_assert_cmpfloat(adg_canvas_get_right_margin(canvas
), !=, 0);
632 g_assert_cmpfloat(adg_canvas_get_bottom_margin(canvas
), !=, 0);
633 g_assert_cmpfloat(adg_canvas_get_left_margin(canvas
), !=, 0);
635 size
= adg_canvas_get_size(canvas
);
638 g_assert_cmpfloat(width
, !=, 0);
639 g_assert_cmpfloat(height
, !=, 0);
641 adg_canvas_set_left_margin(canvas
, 0);
642 adg_canvas_set_top_margin(canvas
, 0);
644 size
= adg_canvas_get_size(canvas
);
645 g_assert_cmpfloat(width
, !=, size
->x
);
646 g_assert_cmpfloat(height
, !=, size
->y
);
650 /* Ensure the page size is decreased when margins are increased */
651 adg_canvas_set_left_margin(canvas
, adg_canvas_get_left_margin(canvas
) + 1);
652 adg_canvas_set_top_margin(canvas
, adg_canvas_get_top_margin(canvas
) + 2);
653 size
= adg_canvas_get_size(canvas
);
654 g_assert_cmpfloat(size
->x
, ==, width
- 1);
655 g_assert_cmpfloat(size
->y
, ==, height
- 2);
657 adg_entity_destroy(ADG_ENTITY(canvas
));
661 _adg_method_get_page_setup(void)
664 GtkPageSetup
*page_setup
;
666 canvas
= ADG_CANVAS(adg_canvas_new());
667 page_setup
= gtk_page_setup_new();
669 g_assert_null(adg_canvas_get_page_setup(canvas
));
671 adg_canvas_set_page_setup(canvas
, page_setup
);
672 g_assert_true(adg_canvas_get_page_setup(canvas
) == page_setup
);
674 /* canvas should still internally owns a reference to page_setup */
675 g_object_unref(page_setup
);
676 g_assert_true(GTK_IS_PAGE_SETUP(adg_canvas_get_page_setup(canvas
)));
678 adg_canvas_set_page_setup(canvas
, NULL
);
679 g_assert_null(adg_canvas_get_page_setup(canvas
));
681 adg_entity_destroy(ADG_ENTITY(canvas
));
685 _adg_method_set_page_setup(void)
688 GtkPageSetup
*page_setup
;
689 const CpmlPair
*size
;
690 gdouble width
, height
;
692 canvas
= ADG_CANVAS(adg_canvas_new());
693 page_setup
= gtk_page_setup_new();
695 gtk_page_setup_set_top_margin(page_setup
, 1, GTK_UNIT_POINTS
);
696 gtk_page_setup_set_right_margin(page_setup
, 2, GTK_UNIT_POINTS
);
697 gtk_page_setup_set_left_margin(page_setup
, 3, GTK_UNIT_POINTS
);
698 gtk_page_setup_set_bottom_margin(page_setup
, 4, GTK_UNIT_POINTS
);
700 adg_canvas_set_page_setup(canvas
, page_setup
);
701 g_object_unref(page_setup
);
703 g_assert_cmpfloat(adg_canvas_get_top_margin(canvas
), ==, 1);
704 g_assert_cmpfloat(adg_canvas_get_right_margin(canvas
), ==, 2);
705 g_assert_cmpfloat(adg_canvas_get_left_margin(canvas
), ==, 3);
706 g_assert_cmpfloat(adg_canvas_get_bottom_margin(canvas
), ==, 4);
708 adg_canvas_set_page_setup(canvas
, NULL
);
710 g_assert_cmpfloat(adg_canvas_get_top_margin(canvas
), ==, 1);
711 g_assert_cmpfloat(adg_canvas_get_right_margin(canvas
), ==, 2);
712 g_assert_cmpfloat(adg_canvas_get_left_margin(canvas
), ==, 3);
713 g_assert_cmpfloat(adg_canvas_get_bottom_margin(canvas
), ==, 4);
715 size
= adg_canvas_get_size(canvas
);
718 g_assert_cmpfloat(adg_canvas_get_top_margin(canvas
), ==, 1);
720 /* When no page setup is bound to canvas, changing the margins
721 * should not change the page size */
722 adg_canvas_set_margins(canvas
, 10, 20, 30, 40);
723 size
= adg_canvas_get_size(canvas
);
724 g_assert_cmpfloat(size
->x
, ==, width
);
725 g_assert_cmpfloat(size
->y
, ==, height
);
727 adg_entity_destroy(ADG_ENTITY(canvas
));
732 main(int argc
, char *argv
[])
734 adg_test_init(&argc
, &argv
);
736 adg_test_add_object_checks("/adg/canvas/type/object", ADG_TYPE_CANVAS
);
737 adg_test_add_entity_checks("/adg/canvas/type/entity", ADG_TYPE_CANVAS
);
738 adg_test_add_container_checks("/adg/canvas/type/container", ADG_TYPE_CANVAS
);
740 g_test_add_func("/adg/canvas/property/background-dress", _adg_test_background_dress
);
741 g_test_add_func("/adg/canvas/property/frame-dress", _adg_test_frame_dress
);
742 g_test_add_func("/adg/canvas/property/title-block", _adg_test_title_block
);
743 g_test_add_func("/adg/canvas/property/size", _adg_test_size
);
744 g_test_add_func("/adg/canvas/property/scales", _adg_test_scales
);
745 g_test_add_func("/adg/canvas/property/top-margin", _adg_test_top_margin
);
746 g_test_add_func("/adg/canvas/property/right-margin", _adg_test_right_margin
);
747 g_test_add_func("/adg/canvas/property/bottom-margin", _adg_test_bottom_margin
);
748 g_test_add_func("/adg/canvas/property/left-margin", _adg_test_left_margin
);
749 g_test_add_func("/adg/canvas/property/has-frame", _adg_test_has_frame
);
750 g_test_add_func("/adg/canvas/property/top-padding", _adg_test_top_padding
);
751 g_test_add_func("/adg/canvas/property/right-padding", _adg_test_right_padding
);
752 g_test_add_func("/adg/canvas/property/bottom-padding", _adg_test_bottom_padding
);
753 g_test_add_func("/adg/canvas/property/left-padding", _adg_test_left_padding
);
755 g_test_add_func("/adg/canvas/method/set_margins", _adg_method_set_margins
);
756 g_test_add_func("/adg/canvas/method/set_paddings", _adg_method_set_paddings
);
757 #if GTK3_ENABLED || GTK2_ENABLED
758 g_test_add_func("/adg/canvas/method/set_paper", _adg_method_set_paper
);
759 g_test_add_func("/adg/canvas/method/get_page_setup", _adg_method_get_page_setup
);
760 g_test_add_func("/adg/canvas/method/set_page_setup", _adg_method_set_page_setup
);