src/adg/tests/test-gtk-area.c

   1 /* ADG - Automatic Drawing Generation
   2  * Copyright (C) 2007-2021  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
  21 #include <config.h>
  22 #include <adg-test.h>
  23 #include <adg.h>
  24
  25
  26 static AdgGtkArea *
  27 _adg_gtk_area_new(void)
  28 {
  29     AdgGtkArea *area;
  30     AdgCanvas *canvas;
  31
  32     canvas = adg_test_canvas();
  33     area = ADG_GTK_AREA(adg_gtk_area_new_with_canvas(canvas));
  34     g_object_unref(canvas);
  35
  36     return area;
  37 }
  38
  39 static void
  40 _adg_behavior_translation(void)
  41 {
  42     AdgGtkArea *area;
  43     AdgCanvas *canvas;
  44     GdkEventMotion event_motion;
  45     GdkEventButton event_button;
  46     gboolean stop;
  47     const cairo_matrix_t *map;
  48
  49     area = _adg_gtk_area_new();
  50     canvas = adg_gtk_area_get_canvas(area);
  51
  52     /* Translating requires an arranged canvas */
  53     adg_entity_arrange(ADG_ENTITY(canvas));
  54
  55     /* Translating (local space) */
  56     map = adg_entity_get_local_map(ADG_ENTITY(canvas));
  57     adg_assert_isapprox(map->x0, 0);
  58     adg_assert_isapprox(map->y0, 0);
  59
  60     event_button.type = GDK_BUTTON_PRESS;
  61     event_button.button = 2;
  62     event_button.x = 10;
  63     event_button.y = 20;
  64     g_signal_emit_by_name(area, "button-press-event", &event_button, NULL, &stop);
  65
  66     event_motion.type = GDK_MOTION_NOTIFY;
  67     event_motion.state = GDK_BUTTON2_MASK;
  68     event_motion.x = 100;
  69     event_motion.y = 200;
  70     g_signal_emit_by_name(area, "motion-notify-event", &event_motion, NULL, &stop);
  71     map = adg_entity_get_local_map(ADG_ENTITY(canvas));
  72     adg_assert_isapprox(map->x0, 90);
  73     adg_assert_isapprox(map->y0, 180);
  74
  75     /* Translating (global space) */
  76     map = adg_gtk_area_get_render_map(area);
  77     adg_assert_isapprox(map->x0, 0);
  78     adg_assert_isapprox(map->y0, 0);
  79
  80     event_button.x = 30;
  81     event_button.y = 40;
  82     g_signal_emit_by_name(area, "button-press-event", &event_button, NULL, &stop);
  83
  84     event_motion.state |= GDK_SHIFT_MASK;
  85     event_motion.x = 300;
  86     event_motion.y = 400;
  87     g_signal_emit_by_name(area, "motion-notify-event", &event_motion, NULL, &stop);
  88     map = adg_gtk_area_get_render_map(area);
  89     adg_assert_isapprox(map->x0, 270);
  90     adg_assert_isapprox(map->y0, 360);
  91
  92     gtk_widget_destroy(GTK_WIDGET(area));
  93 }
  94
  95 static void
  96 _adg_property_canvas(void)
  97 {
  98     AdgGtkArea *area;
  99     AdgCanvas *valid_canvas, *invalid_canvas, *canvas;
 100
 101     area = ADG_GTK_AREA(adg_gtk_area_new());
 102     valid_canvas = adg_canvas_new();
 103     invalid_canvas = adg_test_invalid_pointer();
 104
 105     g_object_ref(valid_canvas);
 106
 107     /* Using the public APIs */
 108     adg_test_signal(area, "canvas-changed");
 109     adg_gtk_area_set_canvas(area, NULL);
 110     g_assert_false(adg_test_signal_check(FALSE));
 111     canvas = adg_gtk_area_get_canvas(area);
 112     g_assert_null(canvas);
 113
 114     adg_gtk_area_set_canvas(area, valid_canvas);
 115     g_assert_true(adg_test_signal_check(FALSE));
 116     canvas = adg_gtk_area_get_canvas(area);
 117     g_assert_true(canvas == valid_canvas);
 118
 119     adg_gtk_area_set_canvas(area, invalid_canvas);
 120     g_assert_false(adg_test_signal_check(FALSE));
 121     canvas = adg_gtk_area_get_canvas(area);
 122     g_assert_true(canvas == valid_canvas);
 123
 124     /* Setting the canvas to NULL is a valid operation
 125      * and means to unset the canvas */
 126     adg_gtk_area_set_canvas(area, NULL);
 127     g_assert_true(adg_test_signal_check(FALSE));
 128
 129     /* Resetting the same value is a no-op */
 130     adg_gtk_area_set_canvas(area, NULL);
 131     g_assert_false(adg_test_signal_check(FALSE));
 132     canvas = adg_gtk_area_get_canvas(area);
 133     g_assert_null(canvas);
 134
 135     /* Using GObject property methods */
 136     g_object_set(area, "canvas", NULL, NULL);
 137     g_assert_false(adg_test_signal_check(FALSE));
 138     g_object_get(area, "canvas", &canvas, NULL);
 139     g_assert_null(canvas);
 140
 141     g_object_set(area, "canvas", valid_canvas, NULL);
 142     g_assert_true(adg_test_signal_check(FALSE));
 143     g_object_get(area, "canvas", &canvas, NULL);
 144     g_assert_true(canvas == valid_canvas);
 145     adg_entity_destroy(ADG_ENTITY(canvas));
 146
 147     g_object_set(area, "canvas", invalid_canvas, NULL);
 148     g_assert_false(adg_test_signal_check(FALSE));
 149     g_object_get(area, "canvas", &canvas, NULL);
 150     g_assert_true(canvas == valid_canvas);
 151     adg_entity_destroy(ADG_ENTITY(canvas));
 152
 153     g_object_set(area, "canvas", NULL, NULL);
 154     g_assert_true(adg_test_signal_check(TRUE));
 155     g_object_get(area, "canvas", &canvas, NULL);
 156     g_assert_null(canvas);
 157
 158     adg_gtk_area_set_canvas(area, valid_canvas);
 159     gtk_widget_destroy(GTK_WIDGET(area));
 160     adg_entity_destroy(ADG_ENTITY(valid_canvas));
 161 }
 162
 163 static void
 164 _adg_property_factor(void)
 165 {
 166     AdgGtkArea *area;
 167     gdouble valid_factor1, valid_factor2, invalid_factor, factor;
 168
 169     area = ADG_GTK_AREA(adg_gtk_area_new());
 170     valid_factor1 = 10;
 171     valid_factor2 = 1;
 172     invalid_factor = 0.5;
 173
 174     /* Using the public APIs */
 175     adg_gtk_area_set_factor(area, valid_factor1);
 176     factor = adg_gtk_area_get_factor(area);
 177     adg_assert_isapprox(factor, valid_factor1);
 178
 179     adg_gtk_area_set_factor(area, invalid_factor);
 180     factor = adg_gtk_area_get_factor(area);
 181     adg_assert_isapprox(factor, valid_factor1);
 182
 183     adg_gtk_area_set_factor(area, valid_factor2);
 184     factor = adg_gtk_area_get_factor(area);
 185     adg_assert_isapprox(factor, valid_factor2);
 186
 187     /* Using GObject property methods */
 188     g_object_set(area, "factor", valid_factor1, NULL);
 189     g_object_get(area, "factor", &factor, NULL);
 190     adg_assert_isapprox(factor, valid_factor1);
 191
 192     g_object_set(area, "factor", invalid_factor, NULL);
 193     g_object_get(area, "factor", &factor, NULL);
 194     adg_assert_isapprox(factor, valid_factor1);
 195
 196     g_object_set(area, "factor", valid_factor2, NULL);
 197     g_object_get(area, "factor", &factor, NULL);
 198     adg_assert_isapprox(factor, valid_factor2);
 199
 200     gtk_widget_destroy(GTK_WIDGET(area));
 201 }
 202
 203 static void
 204 _adg_property_autozoom(void)
 205 {
 206     AdgGtkArea *area;
 207     gboolean invalid_boolean;
 208     gboolean has_autozoom;
 209
 210     area = (AdgGtkArea *) adg_gtk_area_new();
 211     invalid_boolean = (gboolean) 1234;
 212
 213     /* Using the public APIs */
 214     adg_gtk_area_switch_autozoom(area, FALSE);
 215     has_autozoom = adg_gtk_area_has_autozoom(area);
 216     g_assert_false(has_autozoom);
 217
 218     adg_gtk_area_switch_autozoom(area, invalid_boolean);
 219     has_autozoom = adg_gtk_area_has_autozoom(area);
 220     g_assert_false(has_autozoom);
 221
 222     adg_gtk_area_switch_autozoom(area, TRUE);
 223     has_autozoom = adg_gtk_area_has_autozoom(area);
 224     g_assert_true(has_autozoom);
 225
 226     /* Using GObject property methods */
 227     g_object_set(area, "autozoom", invalid_boolean, NULL);
 228     g_object_get(area, "autozoom", &has_autozoom, NULL);
 229     g_assert_true(has_autozoom);
 230
 231     g_object_set(area, "autozoom", FALSE, NULL);
 232     g_object_get(area, "autozoom", &has_autozoom, NULL);
 233     g_assert_false(has_autozoom);
 234
 235     g_object_set(area, "autozoom", TRUE, NULL);
 236     g_object_get(area, "autozoom", &has_autozoom, NULL);
 237     g_assert_true(has_autozoom);
 238
 239     gtk_widget_destroy(GTK_WIDGET(area));
 240 }
 241
 242 static void
 243 _adg_property_render_map(void)
 244 {
 245     AdgGtkArea *area;
 246     const cairo_matrix_t *identity_map;
 247     cairo_matrix_t null_map, dummy_map;
 248     const cairo_matrix_t *render_map;
 249     cairo_matrix_t *render_map_dup;
 250
 251     area = ADG_GTK_AREA(adg_gtk_area_new());
 252     identity_map = adg_matrix_identity();
 253
 254     /* A null map is a kind of degenerated matrix: it must be
 255      * treated as valid value by the API */
 256     cairo_matrix_init(&null_map, 0, 0, 0, 0, 0, 0);
 257     /* A general purpose map value without translations */
 258     cairo_matrix_init(&dummy_map, 1, 2, 3, 4, 0, 0);
 259
 260     /* Using the public APIs */
 261     adg_gtk_area_set_render_map(area, &null_map);
 262     render_map = adg_gtk_area_get_render_map(area);
 263     g_assert_true(adg_matrix_equal(render_map, &null_map));
 264
 265     adg_gtk_area_transform_render_map(area, &dummy_map, ADG_TRANSFORM_AFTER);
 266     render_map = adg_gtk_area_get_render_map(area);
 267     g_assert_true(adg_matrix_equal(render_map, &null_map));
 268
 269     adg_gtk_area_set_render_map(area, identity_map);
 270     render_map = adg_gtk_area_get_render_map(area);
 271     g_assert_true(adg_matrix_equal(render_map, identity_map));
 272
 273     adg_gtk_area_set_render_map(area, NULL);
 274     render_map = adg_gtk_area_get_render_map(area);
 275     g_assert_true(adg_matrix_equal(render_map, identity_map));
 276
 277     adg_gtk_area_transform_render_map(area, &dummy_map, ADG_TRANSFORM_BEFORE);
 278     render_map = adg_gtk_area_get_render_map(area);
 279     g_assert_true(adg_matrix_equal(render_map, &dummy_map));
 280
 281     /* Using GObject property methods */
 282     g_object_set(area, "render-map", &null_map, NULL);
 283     g_object_get(area, "render-map", &render_map_dup, NULL);
 284     g_assert_true(adg_matrix_equal(render_map_dup, &null_map));
 285     g_free(render_map_dup);
 286
 287     g_object_set(area, "render-map", NULL, NULL);
 288     g_object_get(area, "render-map", &render_map_dup, NULL);
 289     g_assert_true(adg_matrix_equal(render_map_dup, &null_map));
 290     g_free(render_map_dup);
 291
 292     g_object_set(area, "render-map", identity_map, NULL);
 293     g_object_get(area, "render-map", &render_map_dup, NULL);
 294     g_assert_true(adg_matrix_equal(render_map_dup, identity_map));
 295     g_free(render_map_dup);
 296
 297     gtk_widget_destroy(GTK_WIDGET(area));
 298 }
 299
 300 static void
 301 _adg_method_get_extents(void)
 302 {
 303     AdgGtkArea *area;
 304     const CpmlExtents *extents;
 305     AdgCanvas *canvas;
 306
 307     area = ADG_GTK_AREA(adg_gtk_area_new());
 308     canvas = adg_test_canvas();
 309
 310     /* Sanity check */
 311     g_assert_null(adg_gtk_area_get_extents(NULL));
 312
 313     /* With no canvas, the extents should be undefined */
 314     extents = adg_gtk_area_get_extents(area);
 315     g_assert_false(extents->is_defined);
 316
 317     adg_gtk_area_set_canvas(area, canvas);
 318     g_object_unref(canvas);
 319     extents = adg_gtk_area_get_extents(area);
 320     g_assert_true(extents->is_defined);
 321     adg_assert_isapprox(extents->org.x, 0);
 322     adg_assert_isapprox(extents->org.y, 0);
 323     adg_assert_isapprox(extents->size.x, 1);
 324     adg_assert_isapprox(extents->size.y, 1);
 325
 326     gtk_widget_destroy(GTK_WIDGET(area));
 327 }
 328
 329 static void
 330 _adg_method_get_zoom(void)
 331 {
 332     AdgGtkArea *area;
 333     AdgCanvas *canvas;
 334
 335     area = ADG_GTK_AREA(adg_gtk_area_new());
 336     canvas = adg_test_canvas();
 337
 338     /* Sanity check */
 339     adg_assert_isapprox(adg_gtk_area_get_zoom(NULL), 0);
 340
 341     adg_assert_isapprox(adg_gtk_area_get_zoom(area), 1);
 342
 343     adg_gtk_area_set_canvas(area, canvas);
 344     g_object_unref(canvas);
 345     adg_assert_isapprox(adg_gtk_area_get_zoom(area), 1);
 346
 347     gtk_widget_destroy(GTK_WIDGET(area));
 348 }
 349
 350 static void
 351 _adg_method_switch_autozoom(void)
 352 {
 353     AdgGtkArea *area;
 354     GtkAllocation allocation;
 355
 356     area = _adg_gtk_area_new();
 357     allocation.width = 100;
 358     allocation.height = 100;
 359
 360     /* Allocation does not work if the widget is not visible: without a
 361      * top-level this will hopefully do not require an X server running */
 362     gtk_widget_show(GTK_WIDGET(area));
 363
 364     /* Without autozoom the zoom factor is left to 1 */
 365     gtk_widget_size_allocate(GTK_WIDGET(area), &allocation);
 366     adg_assert_isapprox(adg_gtk_area_get_zoom(area), 1);
 367
 368     /* The allocation phase is one-shot, so I must destroy and recreate
 369      * the AdgGtkArea widget every time to trigger the size allocation */
 370     gtk_widget_destroy(GTK_WIDGET(area));
 371     area = _adg_gtk_area_new();
 372     gtk_widget_show(GTK_WIDGET(area));
 373
 374     /* With autozoom */
 375     adg_gtk_area_switch_autozoom(area, TRUE);
 376     gtk_widget_size_allocate(GTK_WIDGET(area), &allocation);
 377     adg_assert_isapprox(adg_gtk_area_get_zoom(area), 100);
 378
 379     gtk_widget_destroy(GTK_WIDGET(area));
 380     area = _adg_gtk_area_new();
 381     gtk_widget_show(GTK_WIDGET(area));
 382
 383     /* Trying different allocation size */
 384     adg_gtk_area_switch_autozoom(area, TRUE);
 385     allocation.width = 200;
 386     allocation.height = 200;
 387     gtk_widget_size_allocate(GTK_WIDGET(area), &allocation);
 388     adg_assert_isapprox(adg_gtk_area_get_zoom(area), 200);
 389
 390     gtk_widget_destroy(GTK_WIDGET(area));
 391 }
 392
 393 static void
 394 _adg_method_reset(void)
 395 {
 396     GtkWidget *window;
 397     AdgGtkArea *area;
 398     AdgCanvas *canvas;
 399     cairo_matrix_t map;
 400
 401     /* Sanity check */
 402     adg_gtk_area_reset(NULL);
 403
 404     window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
 405     area = ADG_GTK_AREA(adg_gtk_area_new());
 406     gtk_container_add(GTK_CONTAINER(window), GTK_WIDGET(area));
 407
 408     canvas = adg_test_canvas();
 409     adg_gtk_area_set_canvas(area, canvas);
 410     g_object_unref(canvas);
 411
 412     cairo_matrix_init_scale(&map, 2, 2);
 413
 414     adg_gtk_area_reset(area);
 415     adg_gtk_area_reset(area);
 416     adg_assert_isapprox(adg_gtk_area_get_zoom(area), 1);
 417
 418     adg_gtk_area_set_render_map(area, &map);
 419     adg_assert_isapprox(adg_gtk_area_get_zoom(area), 2);
 420
 421     adg_gtk_area_reset(area);
 422     adg_assert_isapprox(adg_gtk_area_get_zoom(area), 1);
 423
 424     gtk_widget_destroy(window);
 425 }
 426
 427 static void
 428 _adg_method_extents_changed(void)
 429 {
 430     AdgGtkArea *area;
 431     CpmlExtents extents;
 432
 433     area = ADG_GTK_AREA(adg_gtk_area_new());
 434     extents.is_defined = FALSE;
 435
 436     /* Sanity check */
 437     adg_gtk_area_extents_changed(NULL, &extents);
 438
 439     adg_test_signal(area, "extents-changed");
 440     adg_gtk_area_extents_changed(area, &extents);
 441     g_assert_true(adg_test_signal_check(FALSE));
 442
 443     adg_gtk_area_extents_changed(area, NULL);
 444     g_assert_true(adg_test_signal_check(TRUE));
 445
 446     gtk_widget_destroy(GTK_WIDGET(area));
 447 }
 448
 449 static void
 450 _adg_method_canvas_changed(void)
 451 {
 452     AdgGtkArea *area;
 453     AdgCanvas *canvas;
 454
 455     area = ADG_GTK_AREA(adg_gtk_area_new());
 456     canvas = adg_canvas_new();
 457
 458     /* Sanity check */
 459     adg_gtk_area_canvas_changed(NULL, canvas);
 460
 461     adg_test_signal(area, "canvas-changed");
 462     adg_gtk_area_canvas_changed(area, canvas);
 463     g_assert_true(adg_test_signal_check(FALSE));
 464
 465     adg_gtk_area_canvas_changed(area, NULL);
 466     g_assert_true(adg_test_signal_check(TRUE));
 467
 468     gtk_widget_destroy(GTK_WIDGET(area));
 469     adg_entity_destroy(ADG_ENTITY(canvas));
 470 }
 471
 472 static void
 473 _adg_method_scroll_event(void)
 474 {
 475     AdgGtkArea *area;
 476     AdgCanvas *canvas;
 477     GdkEventScroll event;
 478     gboolean stop;
 479     const cairo_matrix_t *map;
 480
 481     area = _adg_gtk_area_new();
 482     canvas = adg_gtk_area_get_canvas(area);
 483
 484     /* Zooming requires an arranged canvas */
 485     adg_entity_arrange(ADG_ENTITY(canvas));
 486
 487     map = adg_entity_get_local_map(ADG_ENTITY(canvas));
 488     adg_assert_isapprox(map->xx, 1);
 489
 490     /* Zoom in (local space) */
 491     event.type = GDK_SCROLL;
 492     event.direction = GDK_SCROLL_UP;
 493     event.state = 0;
 494     g_signal_emit_by_name(area, "scroll-event", &event, NULL, &stop);
 495     map = adg_entity_get_local_map(ADG_ENTITY(canvas));
 496     g_assert_cmpfloat(map->xx, >, 1);
 497
 498     /* Zoom out (local space) */
 499     event.direction = GDK_SCROLL_DOWN;
 500     g_signal_emit_by_name(area, "scroll-event", &event, NULL, &stop);
 501     map = adg_entity_get_local_map(ADG_ENTITY(canvas));
 502     adg_assert_isapprox(map->xx, 1);
 503     g_signal_emit_by_name(area, "scroll-event", &event, NULL, &stop);
 504     map = adg_entity_get_local_map(ADG_ENTITY(canvas));
 505     g_assert_cmpfloat(map->xx, <, 1);
 506
 507     adg_assert_isapprox(adg_gtk_area_get_zoom(area), 1);
 508
 509     /* Zoom out (global space) */
 510     event.state = GDK_SHIFT_MASK;
 511     g_signal_emit_by_name(area, "scroll-event", &event, NULL, &stop);
 512     g_assert_cmpfloat(adg_gtk_area_get_zoom(area), <, 1);
 513
 514     /* Zoom in (global space) */
 515     event.direction = GDK_SCROLL_UP;
 516     g_signal_emit_by_name(area, "scroll-event", &event, NULL, &stop);
 517     adg_assert_isapprox(adg_gtk_area_get_zoom(area), 1);
 518     g_signal_emit_by_name(area, "scroll-event", &event, NULL, &stop);
 519     g_assert_cmpfloat(adg_gtk_area_get_zoom(area), >, 1);
 520
 521     gtk_widget_destroy(GTK_WIDGET(area));
 522 }
 523
 524 static void
 525 _adg_method_motion_event(void)
 526 {
 527     AdgGtkArea *area;
 528     AdgCanvas *canvas;
 529     GdkEventMotion event;
 530     gboolean stop;
 531     const cairo_matrix_t *map;
 532
 533     area = _adg_gtk_area_new();
 534     canvas = adg_gtk_area_get_canvas(area);
 535
 536     /* Checking motion requires an arranged canvas */
 537     adg_entity_arrange(ADG_ENTITY(canvas));
 538
 539     map = adg_entity_get_local_map(ADG_ENTITY(canvas));
 540     adg_assert_isapprox(map->x0, 0);
 541     adg_assert_isapprox(map->y0, 0);
 542
 543     /* Motion (local space) */
 544     event.type = GDK_MOTION_NOTIFY;
 545     event.state = GDK_BUTTON2_MASK;
 546     event.x = 10;
 547     event.y = 20;
 548     g_signal_emit_by_name(area, "motion-notify-event", &event, NULL, &stop);
 549     map = adg_entity_get_local_map(ADG_ENTITY(canvas));
 550     g_assert_cmpfloat(map->x0, >, 0);
 551     g_assert_cmpfloat(map->y0, >, 0);
 552     event.x = -event.x;
 553     event.y = -event.y;
 554     g_signal_emit_by_name(area, "motion-notify-event", &event, NULL, &stop);
 555     map = adg_entity_get_local_map(ADG_ENTITY(canvas));
 556     g_assert_cmpfloat(map->x0, <, 0);
 557     g_assert_cmpfloat(map->y0, <, 0);
 558     event.x = 0;
 559     event.y = 0;
 560     g_signal_emit_by_name(area, "motion-notify-event", &event, NULL, &stop);
 561     map = adg_entity_get_local_map(ADG_ENTITY(canvas));
 562     adg_assert_isapprox(map->x0, 0);
 563     adg_assert_isapprox(map->y0, 0);
 564
 565     map = adg_gtk_area_get_render_map(area);
 566     adg_assert_isapprox(map->x0, 0);
 567     adg_assert_isapprox(map->y0, 0);
 568
 569     /* Motion (global space) */
 570     event.state |= GDK_SHIFT_MASK;
 571     event.x = 30;
 572     event.y = 40;
 573     g_signal_emit_by_name(area, "motion-notify-event", &event, NULL, &stop);
 574     map = adg_gtk_area_get_render_map(area);
 575     g_assert_cmpfloat(map->x0, >, 0);
 576     g_assert_cmpfloat(map->y0, >, 0);
 577     event.x = -event.x;
 578     event.y = -event.y;
 579     g_signal_emit_by_name(area, "motion-notify-event", &event, NULL, &stop);
 580     map = adg_gtk_area_get_render_map(area);
 581     g_assert_cmpfloat(map->x0, <, 0);
 582     g_assert_cmpfloat(map->y0, <, 0);
 583     event.x = 0;
 584     event.y = 0;
 585     g_signal_emit_by_name(area, "motion-notify-event", &event, NULL, &stop);
 586     map = adg_gtk_area_get_render_map(area);
 587     adg_assert_isapprox(map->x0, 0);
 588     adg_assert_isapprox(map->y0, 0);
 589
 590     gtk_widget_destroy(GTK_WIDGET(area));
 591 }
 592
 593 #ifdef GTK2_ENABLED
 594
 595 static void
 596 _adg_method_size_request(void)
 597 {
 598     AdgGtkArea *area;
 599     AdgCanvas *canvas;
 600     GtkRequisition requisition;
 601
 602     area = ADG_GTK_AREA(adg_gtk_area_new());
 603     canvas = adg_test_canvas();
 604
 605     gtk_widget_size_request(GTK_WIDGET(area), &requisition);
 606     g_assert_cmpint(requisition.width, ==, 0);
 607     g_assert_cmpint(requisition.height, ==, 0);
 608
 609     /* Size requests are cached so recreate the area widget */
 610     gtk_widget_destroy(GTK_WIDGET(area));
 611
 612     area = ADG_GTK_AREA(adg_gtk_area_new());
 613     adg_gtk_area_set_canvas(area, canvas);
 614     g_object_unref(canvas);
 615
 616     gtk_widget_size_request(GTK_WIDGET(area), &requisition);
 617     g_assert_cmpint(requisition.width, ==, 1);
 618     g_assert_cmpint(requisition.height, ==, 1);
 619
 620     gtk_widget_destroy(GTK_WIDGET(area));
 621 }
 622
 623 #endif
 624
 625
 626 int
 627 main(int argc, char *argv[])
 628 {
 629     adg_test_init(&argc, &argv);
 630     gtk_init_check(&argc, &argv);
 631
 632     adg_test_add_object_checks("/adg-gtk/area/type/object", ADG_GTK_TYPE_AREA);
 633
 634     g_test_add_func("/adg-gtk/area/behavior/translation", _adg_behavior_translation);
 635
 636     g_test_add_func("/adg-gtk/area/property/canvas", _adg_property_canvas);
 637     g_test_add_func("/adg-gtk/area/property/factor", _adg_property_factor);
 638     g_test_add_func("/adg-gtk/area/property/autozoom", _adg_property_autozoom);
 639     g_test_add_func("/adg-gtk/area/property/render-map", _adg_property_render_map);
 640
 641     g_test_add_func("/adg-gtk/area/method/get-extents", _adg_method_get_extents);
 642     g_test_add_func("/adg-gtk/area/method/get-zoom", _adg_method_get_zoom);
 643     g_test_add_func("/adg-gtk/area/method/switch-autozoom", _adg_method_switch_autozoom);
 644     g_test_add_func("/adg-gtk/area/method/reset", _adg_method_reset);
 645     g_test_add_func("/adg-gtk/area/method/extents-changed", _adg_method_extents_changed);
 646     g_test_add_func("/adg-gtk/area/method/canvas-changed", _adg_method_canvas_changed);
 647     g_test_add_func("/adg-gtk/area/method/scroll-event", _adg_method_scroll_event);
 648     g_test_add_func("/adg-gtk/area/method/motion-event", _adg_method_motion_event);
 649 #ifdef GTK2_ENABLED
 650     g_test_add_func("/adg-gtk/area/method/size-request", _adg_method_size_request);
 651 #endif
 652
 653     return g_test_run();
 654 }