gobject/tests/binding.c

   1 #include <stdlib.h>
   2 #include <gstdio.h>
   3 #include <glib-object.h>
   4
   5 typedef struct _BindingSource
   6 {
   7   GObject parent_instance;
   8
   9   gint foo;
  10   gint bar;
  11   gdouble value;
  12   gboolean toggle;
  13 } BindingSource;
  14
  15 typedef struct _BindingSourceClass
  16 {
  17   GObjectClass parent_class;
  18 } BindingSourceClass;
  19
  20 enum
  21 {
  22   PROP_SOURCE_0,
  23
  24   PROP_SOURCE_FOO,
  25   PROP_SOURCE_BAR,
  26   PROP_SOURCE_VALUE,
  27   PROP_SOURCE_TOGGLE
  28 };
  29
  30 static GType binding_source_get_type (void);
  31 G_DEFINE_TYPE (BindingSource, binding_source, G_TYPE_OBJECT)
  32
  33 static void
  34 binding_source_set_property (GObject      *gobject,
  35                              guint         prop_id,
  36                              const GValue *value,
  37                              GParamSpec   *pspec)
  38 {
  39   BindingSource *source = (BindingSource *) gobject;
  40
  41   switch (prop_id)
  42     {
  43     case PROP_SOURCE_FOO:
  44       source->foo = g_value_get_int (value);
  45       break;
  46
  47     case PROP_SOURCE_BAR:
  48       source->bar = g_value_get_int (value);
  49       break;
  50
  51     case PROP_SOURCE_VALUE:
  52       source->value = g_value_get_double (value);
  53       break;
  54
  55     case PROP_SOURCE_TOGGLE:
  56       source->toggle = g_value_get_boolean (value);
  57       break;
  58
  59     default:
  60       G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec);
  61     }
  62 }
  63
  64 static void
  65 binding_source_get_property (GObject    *gobject,
  66                              guint       prop_id,
  67                              GValue     *value,
  68                              GParamSpec *pspec)
  69 {
  70   BindingSource *source = (BindingSource *) gobject;
  71
  72   switch (prop_id)
  73     {
  74     case PROP_SOURCE_FOO:
  75       g_value_set_int (value, source->foo);
  76       break;
  77
  78     case PROP_SOURCE_BAR:
  79       g_value_set_int (value, source->bar);
  80       break;
  81
  82     case PROP_SOURCE_VALUE:
  83       g_value_set_double (value, source->value);
  84       break;
  85
  86     case PROP_SOURCE_TOGGLE:
  87       g_value_set_boolean (value, source->toggle);
  88       break;
  89
  90     default:
  91       G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec);
  92     }
  93 }
  94
  95 static void
  96 binding_source_class_init (BindingSourceClass *klass)
  97 {
  98   GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
  99
 100   gobject_class->set_property = binding_source_set_property;
 101   gobject_class->get_property = binding_source_get_property;
 102
 103   g_object_class_install_property (gobject_class, PROP_SOURCE_FOO,
 104                                    g_param_spec_int ("foo", "Foo", "Foo",
 105                                                      -1, 100,
 106                                                      0,
 107                                                      G_PARAM_READWRITE));
 108   g_object_class_install_property (gobject_class, PROP_SOURCE_BAR,
 109                                    g_param_spec_int ("bar", "Bar", "Bar",
 110                                                      -1, 100,
 111                                                      0,
 112                                                      G_PARAM_READWRITE));
 113   g_object_class_install_property (gobject_class, PROP_SOURCE_VALUE,
 114                                    g_param_spec_double ("value", "Value", "Value",
 115                                                         -100.0, 200.0,
 116                                                         0.0,
 117                                                         G_PARAM_READWRITE));
 118   g_object_class_install_property (gobject_class, PROP_SOURCE_TOGGLE,
 119                                    g_param_spec_boolean ("toggle", "Toggle", "Toggle",
 120                                                          FALSE,
 121                                                          G_PARAM_READWRITE));
 122 }
 123
 124 static void
 125 binding_source_init (BindingSource *self)
 126 {
 127 }
 128
 129 typedef struct _BindingTarget
 130 {
 131   GObject parent_instance;
 132
 133   gint bar;
 134   gdouble value;
 135   gboolean toggle;
 136 } BindingTarget;
 137
 138 typedef struct _BindingTargetClass
 139 {
 140   GObjectClass parent_class;
 141 } BindingTargetClass;
 142
 143 enum
 144 {
 145   PROP_TARGET_0,
 146
 147   PROP_TARGET_BAR,
 148   PROP_TARGET_VALUE,
 149   PROP_TARGET_TOGGLE
 150 };
 151
 152 static GType binding_target_get_type (void);
 153 G_DEFINE_TYPE (BindingTarget, binding_target, G_TYPE_OBJECT)
 154
 155 static void
 156 binding_target_set_property (GObject      *gobject,
 157                              guint         prop_id,
 158                              const GValue *value,
 159                              GParamSpec   *pspec)
 160 {
 161   BindingTarget *target = (BindingTarget *) gobject;
 162
 163   switch (prop_id)
 164     {
 165     case PROP_TARGET_BAR:
 166       target->bar = g_value_get_int (value);
 167       break;
 168
 169     case PROP_TARGET_VALUE:
 170       target->value = g_value_get_double (value);
 171       break;
 172
 173     case PROP_TARGET_TOGGLE:
 174       target->toggle = g_value_get_boolean (value);
 175       break;
 176
 177     default:
 178       G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec);
 179     }
 180 }
 181
 182 static void
 183 binding_target_get_property (GObject    *gobject,
 184                              guint       prop_id,
 185                              GValue     *value,
 186                              GParamSpec *pspec)
 187 {
 188   BindingTarget *target = (BindingTarget *) gobject;
 189
 190   switch (prop_id)
 191     {
 192     case PROP_TARGET_BAR:
 193       g_value_set_int (value, target->bar);
 194       break;
 195
 196     case PROP_TARGET_VALUE:
 197       g_value_set_double (value, target->value);
 198       break;
 199
 200     case PROP_TARGET_TOGGLE:
 201       g_value_set_boolean (value, target->toggle);
 202       break;
 203
 204     default:
 205       G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec);
 206     }
 207 }
 208
 209 static void
 210 binding_target_class_init (BindingTargetClass *klass)
 211 {
 212   GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
 213
 214   gobject_class->set_property = binding_target_set_property;
 215   gobject_class->get_property = binding_target_get_property;
 216
 217   g_object_class_install_property (gobject_class, PROP_TARGET_BAR,
 218                                    g_param_spec_int ("bar", "Bar", "Bar",
 219                                                      -1, 100,
 220                                                      0,
 221                                                      G_PARAM_READWRITE));
 222   g_object_class_install_property (gobject_class, PROP_TARGET_VALUE,
 223                                    g_param_spec_double ("value", "Value", "Value",
 224                                                         -100.0, 200.0,
 225                                                         0.0,
 226                                                         G_PARAM_READWRITE));
 227   g_object_class_install_property (gobject_class, PROP_TARGET_TOGGLE,
 228                                    g_param_spec_boolean ("toggle", "Toggle", "Toggle",
 229                                                          FALSE,
 230                                                          G_PARAM_READWRITE));
 231 }
 232
 233 static void
 234 binding_target_init (BindingTarget *self)
 235 {
 236 }
 237
 238 static gboolean
 239 celsius_to_fahrenheit (GBinding     *binding,
 240                        const GValue *from_value,
 241                        GValue       *to_value,
 242                        gpointer      user_data G_GNUC_UNUSED)
 243 {
 244   gdouble celsius, fahrenheit;
 245
 246   g_assert (G_VALUE_HOLDS (from_value, G_TYPE_DOUBLE));
 247   g_assert (G_VALUE_HOLDS (to_value, G_TYPE_DOUBLE));
 248
 249   celsius = g_value_get_double (from_value);
 250   fahrenheit = (9 * celsius / 5) + 32.0;
 251
 252   if (g_test_verbose ())
 253     g_printerr ("Converting %.2fC to %.2fF\n", celsius, fahrenheit);
 254
 255   g_value_set_double (to_value, fahrenheit);
 256
 257   return TRUE;
 258 }
 259
 260 static gboolean
 261 fahrenheit_to_celsius (GBinding     *binding,
 262                        const GValue *from_value,
 263                        GValue       *to_value,
 264                        gpointer      user_data G_GNUC_UNUSED)
 265 {
 266   gdouble celsius, fahrenheit;
 267
 268   g_assert (G_VALUE_HOLDS (from_value, G_TYPE_DOUBLE));
 269   g_assert (G_VALUE_HOLDS (to_value, G_TYPE_DOUBLE));
 270
 271   fahrenheit = g_value_get_double (from_value);
 272   celsius = 5 * (fahrenheit - 32.0) / 9;
 273
 274   if (g_test_verbose ())
 275     g_printerr ("Converting %.2fF to %.2fC\n", fahrenheit, celsius);
 276
 277   g_value_set_double (to_value, celsius);
 278
 279   return TRUE;
 280 }
 281
 282 static void
 283 binding_default (void)
 284 {
 285   BindingSource *source = g_object_new (binding_source_get_type (), NULL);
 286   BindingTarget *target = g_object_new (binding_target_get_type (), NULL);
 287   GBinding *binding;
 288
 289   binding = g_object_bind_property (source, "foo",
 290                                     target, "bar",
 291                                     G_BINDING_DEFAULT);
 292
 293   g_object_add_weak_pointer (G_OBJECT (binding), (gpointer *) &binding);
 294   g_assert ((BindingSource *) g_binding_get_source (binding) == source);
 295   g_assert ((BindingTarget *) g_binding_get_target (binding) == target);
 296   g_assert_cmpstr (g_binding_get_source_property (binding), ==, "foo");
 297   g_assert_cmpstr (g_binding_get_target_property (binding), ==, "bar");
 298   g_assert_cmpint (g_binding_get_flags (binding), ==, G_BINDING_DEFAULT);
 299
 300   g_object_set (source, "foo", 42, NULL);
 301   g_assert_cmpint (source->foo, ==, target->bar);
 302
 303   g_object_set (target, "bar", 47, NULL);
 304   g_assert_cmpint (source->foo, !=, target->bar);
 305
 306   g_object_unref (binding);
 307
 308   g_object_set (source, "foo", 0, NULL);
 309   g_assert_cmpint (source->foo, !=, target->bar);
 310
 311   g_object_unref (source);
 312   g_object_unref (target);
 313   g_assert (binding == NULL);
 314 }
 315
 316 static void
 317 binding_bidirectional (void)
 318 {
 319   BindingSource *source = g_object_new (binding_source_get_type (), NULL);
 320   BindingTarget *target = g_object_new (binding_target_get_type (), NULL);
 321   GBinding *binding;
 322
 323   binding = g_object_bind_property (source, "foo",
 324                                     target, "bar",
 325                                     G_BINDING_BIDIRECTIONAL);
 326   g_object_add_weak_pointer (G_OBJECT (binding), (gpointer *) &binding);
 327
 328   g_object_set (source, "foo", 42, NULL);
 329   g_assert_cmpint (source->foo, ==, target->bar);
 330
 331   g_object_set (target, "bar", 47, NULL);
 332   g_assert_cmpint (source->foo, ==, target->bar);
 333
 334   g_object_unref (binding);
 335
 336   g_object_set (source, "foo", 0, NULL);
 337   g_assert_cmpint (source->foo, !=, target->bar);
 338
 339   g_object_unref (source);
 340   g_object_unref (target);
 341   g_assert (binding == NULL);
 342 }
 343
 344 static void
 345 data_free (gpointer data)
 346 {
 347   gboolean *b = data;
 348
 349   *b = TRUE;
 350 }
 351
 352 static void
 353 binding_transform_default (void)
 354 {
 355   BindingSource *source = g_object_new (binding_source_get_type (), NULL);
 356   BindingTarget *target = g_object_new (binding_target_get_type (), NULL);
 357   GBinding *binding;
 358   gpointer src, trg;
 359   gchar *src_prop, *trg_prop;
 360   GBindingFlags flags;
 361
 362   binding = g_object_bind_property (source, "foo",
 363                                     target, "value",
 364                                     G_BINDING_BIDIRECTIONAL);
 365
 366   g_object_add_weak_pointer (G_OBJECT (binding), (gpointer *) &binding);
 367
 368   g_object_get (binding,
 369                 "source", &src,
 370                 "source-property", &src_prop,
 371                 "target", &trg,
 372                 "target-property", &trg_prop,
 373                 "flags", &flags,
 374                 NULL);
 375   g_assert (src == source);
 376   g_assert (trg == target);
 377   g_assert_cmpstr (src_prop, ==, "foo");
 378   g_assert_cmpstr (trg_prop, ==, "value");
 379   g_assert_cmpint (flags, ==, G_BINDING_BIDIRECTIONAL);
 380   g_object_unref (src);
 381   g_object_unref (trg);
 382   g_free (src_prop);
 383   g_free (trg_prop);
 384
 385   g_object_set (source, "foo", 24, NULL);
 386   g_assert_cmpfloat (target->value, ==, 24.0);
 387
 388   g_object_set (target, "value", 69.0, NULL);
 389   g_assert_cmpint (source->foo, ==, 69);
 390
 391   g_object_unref (target);
 392   g_object_unref (source);
 393   g_assert (binding == NULL);
 394 }
 395
 396 static void
 397 binding_transform (void)
 398 {
 399   BindingSource *source = g_object_new (binding_source_get_type (), NULL);
 400   BindingTarget *target = g_object_new (binding_target_get_type (), NULL);
 401   GBinding *binding G_GNUC_UNUSED;
 402   gboolean unused_data = FALSE;
 403
 404   binding = g_object_bind_property_full (source, "value",
 405                                          target, "value",
 406                                          G_BINDING_BIDIRECTIONAL,
 407                                          celsius_to_fahrenheit,
 408                                          fahrenheit_to_celsius,
 409                                          &unused_data, data_free);
 410
 411   g_object_set (source, "value", 24.0, NULL);
 412   g_assert_cmpfloat (target->value, ==, ((9 * 24.0 / 5) + 32.0));
 413
 414   g_object_set (target, "value", 69.0, NULL);
 415   g_assert_cmpfloat (source->value, ==, (5 * (69.0 - 32.0) / 9));
 416
 417   g_object_unref (source);
 418   g_object_unref (target);
 419
 420   g_assert (unused_data);
 421 }
 422
 423 static void
 424 binding_transform_closure (void)
 425 {
 426   BindingSource *source = g_object_new (binding_source_get_type (), NULL);
 427   BindingTarget *target = g_object_new (binding_target_get_type (), NULL);
 428   GBinding *binding G_GNUC_UNUSED;
 429   gboolean unused_data_1 = FALSE, unused_data_2 = FALSE;
 430   GClosure *c2f_clos, *f2c_clos;
 431
 432   c2f_clos = g_cclosure_new (G_CALLBACK (celsius_to_fahrenheit), &unused_data_1, (GClosureNotify) data_free);
 433
 434   f2c_clos = g_cclosure_new (G_CALLBACK (fahrenheit_to_celsius), &unused_data_2, (GClosureNotify) data_free);
 435
 436   binding = g_object_bind_property_with_closures (source, "value",
 437                                                   target, "value",
 438                                                   G_BINDING_BIDIRECTIONAL,
 439                                                   c2f_clos,
 440                                                   f2c_clos);
 441
 442   g_object_set (source, "value", 24.0, NULL);
 443   g_assert_cmpfloat (target->value, ==, ((9 * 24.0 / 5) + 32.0));
 444
 445   g_object_set (target, "value", 69.0, NULL);
 446   g_assert_cmpfloat (source->value, ==, (5 * (69.0 - 32.0) / 9));
 447
 448   g_object_unref (source);
 449   g_object_unref (target);
 450
 451   g_assert (unused_data_1);
 452   g_assert (unused_data_2);
 453 }
 454
 455 static void
 456 binding_chain (void)
 457 {
 458   BindingSource *a = g_object_new (binding_source_get_type (), NULL);
 459   BindingSource *b = g_object_new (binding_source_get_type (), NULL);
 460   BindingSource *c = g_object_new (binding_source_get_type (), NULL);
 461   GBinding *binding_1, *binding_2;
 462
 463   g_test_bug ("621782");
 464
 465   /* A -> B, B -> C */
 466   binding_1 = g_object_bind_property (a, "foo", b, "foo", G_BINDING_BIDIRECTIONAL);
 467   g_object_add_weak_pointer (G_OBJECT (binding_1), (gpointer *) &binding_1);
 468
 469   binding_2 = g_object_bind_property (b, "foo", c, "foo", G_BINDING_BIDIRECTIONAL);
 470   g_object_add_weak_pointer (G_OBJECT (binding_2), (gpointer *) &binding_2);
 471
 472   /* verify the chain */
 473   g_object_set (a, "foo", 42, NULL);
 474   g_assert_cmpint (a->foo, ==, b->foo);
 475   g_assert_cmpint (b->foo, ==, c->foo);
 476
 477   /* unbind A -> B and B -> C */
 478   g_object_unref (binding_1);
 479   g_assert (binding_1 == NULL);
 480   g_object_unref (binding_2);
 481   g_assert (binding_2 == NULL);
 482
 483   /* bind A -> C directly */
 484   binding_2 = g_object_bind_property (a, "foo", c, "foo", G_BINDING_BIDIRECTIONAL);
 485
 486   /* verify the chain is broken */
 487   g_object_set (a, "foo", 47, NULL);
 488   g_assert_cmpint (a->foo, !=, b->foo);
 489   g_assert_cmpint (a->foo, ==, c->foo);
 490
 491   g_object_unref (a);
 492   g_object_unref (b);
 493   g_object_unref (c);
 494 }
 495
 496 static void
 497 binding_sync_create (void)
 498 {
 499   BindingSource *source = g_object_new (binding_source_get_type (),
 500                                         "foo", 42,
 501                                         NULL);
 502   BindingTarget *target = g_object_new (binding_target_get_type (),
 503                                         "bar", 47,
 504                                         NULL);
 505   GBinding *binding;
 506
 507   binding = g_object_bind_property (source, "foo",
 508                                     target, "bar",
 509                                     G_BINDING_DEFAULT | G_BINDING_SYNC_CREATE);
 510
 511   g_assert_cmpint (source->foo, ==, 42);
 512   g_assert_cmpint (target->bar, ==, 42);
 513
 514   g_object_set (source, "foo", 47, NULL);
 515   g_assert_cmpint (source->foo, ==, target->bar);
 516
 517   g_object_unref (binding);
 518
 519   g_object_set (target, "bar", 49, NULL);
 520
 521   binding = g_object_bind_property (source, "foo",
 522                                     target, "bar",
 523                                     G_BINDING_BIDIRECTIONAL | G_BINDING_SYNC_CREATE);
 524   g_assert_cmpint (source->foo, ==, 47);
 525   g_assert_cmpint (target->bar, ==, 47);
 526
 527   g_object_unref (source);
 528   g_object_unref (target);
 529 }
 530
 531 static void
 532 binding_invert_boolean (void)
 533 {
 534   BindingSource *source = g_object_new (binding_source_get_type (),
 535                                         "toggle", TRUE,
 536                                         NULL);
 537   BindingTarget *target = g_object_new (binding_target_get_type (),
 538                                         "toggle", FALSE,
 539                                         NULL);
 540   GBinding *binding;
 541
 542   binding = g_object_bind_property (source, "toggle",
 543                                     target, "toggle",
 544                                     G_BINDING_BIDIRECTIONAL | G_BINDING_INVERT_BOOLEAN);
 545
 546   g_assert (source->toggle);
 547   g_assert (!target->toggle);
 548
 549   g_object_set (source, "toggle", FALSE, NULL);
 550   g_assert (!source->toggle);
 551   g_assert (target->toggle);
 552
 553   g_object_set (target, "toggle", FALSE, NULL);
 554   g_assert (source->toggle);
 555   g_assert (!target->toggle);
 556
 557   g_object_unref (binding);
 558   g_object_unref (source);
 559   g_object_unref (target);
 560 }
 561
 562 static void
 563 binding_same_object (void)
 564 {
 565   BindingSource *source = g_object_new (binding_source_get_type (),
 566                                         "foo", 100,
 567                                         "bar", 50,
 568                                         NULL);
 569   GBinding *binding;
 570
 571   binding = g_object_bind_property (source, "foo",
 572                                     source, "bar",
 573                                     G_BINDING_BIDIRECTIONAL);
 574   g_object_add_weak_pointer (G_OBJECT (binding), (gpointer *) &binding);
 575
 576   g_object_set (source, "foo", 10, NULL);
 577   g_assert_cmpint (source->foo, ==, 10);
 578   g_assert_cmpint (source->bar, ==, 10);
 579   g_object_set (source, "bar", 30, NULL);
 580   g_assert_cmpint (source->foo, ==, 30);
 581   g_assert_cmpint (source->bar, ==, 30);
 582
 583   g_object_unref (source);
 584   g_assert (binding == NULL);
 585 }
 586
 587 static void
 588 binding_unbind (void)
 589 {
 590   BindingSource *source = g_object_new (binding_source_get_type (), NULL);
 591   BindingTarget *target = g_object_new (binding_target_get_type (), NULL);
 592   GBinding *binding;
 593
 594   binding = g_object_bind_property (source, "foo",
 595                                     target, "bar",
 596                                     G_BINDING_DEFAULT);
 597   g_object_add_weak_pointer (G_OBJECT (binding), (gpointer *) &binding);
 598
 599   g_object_set (source, "foo", 42, NULL);
 600   g_assert_cmpint (source->foo, ==, target->bar);
 601
 602   g_object_set (target, "bar", 47, NULL);
 603   g_assert_cmpint (source->foo, !=, target->bar);
 604
 605   g_binding_unbind (binding);
 606   g_assert (binding == NULL);
 607
 608   g_object_set (source, "foo", 0, NULL);
 609   g_assert_cmpint (source->foo, !=, target->bar);
 610
 611   g_object_unref (source);
 612   g_object_unref (target);
 613
 614
 615   /* g_binding_unbind() has a special case for this */
 616   source = g_object_new (binding_source_get_type (), NULL);
 617   binding = g_object_bind_property (source, "foo",
 618                                     source, "bar",
 619                                     G_BINDING_DEFAULT);
 620   g_object_add_weak_pointer (G_OBJECT (binding), (gpointer *) &binding);
 621
 622   g_binding_unbind (binding);
 623   g_assert (binding == NULL);
 624
 625   g_object_unref (source);
 626 }
 627
 628 static void
 629 binding_fail (void)
 630 {
 631   BindingSource *source = g_object_new (binding_source_get_type (), NULL);
 632   BindingTarget *target = g_object_new (binding_target_get_type (), NULL);
 633   GBinding *binding;
 634
 635   /* double -> boolean is not supported */
 636   binding = g_object_bind_property (source, "value",
 637                                     target, "toggle",
 638                                     G_BINDING_DEFAULT);
 639   g_object_add_weak_pointer (G_OBJECT (binding), (gpointer *) &binding);
 640
 641   g_test_expect_message ("GLib-GObject", G_LOG_LEVEL_WARNING,
 642                          "*Unable to convert*double*boolean*");
 643   g_object_set (source, "value", 1.0, NULL);
 644   g_test_assert_expected_messages ();
 645
 646   g_object_unref (source);
 647   g_object_unref (target);
 648   g_assert (binding == NULL);
 649 }
 650
 651 int
 652 main (int argc, char *argv[])
 653 {
 654   g_test_init (&argc, &argv, NULL);
 655
 656   g_test_bug_base ("http://bugzilla.gnome.org/");
 657
 658   g_test_add_func ("/binding/default", binding_default);
 659   g_test_add_func ("/binding/bidirectional", binding_bidirectional);
 660   g_test_add_func ("/binding/transform", binding_transform);
 661   g_test_add_func ("/binding/transform-default", binding_transform_default);
 662   g_test_add_func ("/binding/transform-closure", binding_transform_closure);
 663   g_test_add_func ("/binding/chain", binding_chain);
 664   g_test_add_func ("/binding/sync-create", binding_sync_create);
 665   g_test_add_func ("/binding/invert-boolean", binding_invert_boolean);
 666   g_test_add_func ("/binding/same-object", binding_same_object);
 667   g_test_add_func ("/binding/unbind", binding_unbind);
 668   g_test_add_func ("/binding/fail", binding_fail);
 669
 670   return g_test_run ();
 671 }