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 *source_value,
 241                        GValue       *target_value,
 242                        gpointer      user_data G_GNUC_UNUSED)
 243 {
 244   gdouble celsius, fahrenheit;
 245
 246   g_assert (G_VALUE_HOLDS (source_value, G_TYPE_DOUBLE));
 247   g_assert (G_VALUE_HOLDS (target_value, G_TYPE_DOUBLE));
 248
 249   celsius = g_value_get_double (source_value);
 250   fahrenheit = (9 * celsius / 5) + 32.0;
 251
 252   if (g_test_verbose ())
 253     g_print ("Converting %.2fC to %.2fF\n", celsius, fahrenheit);
 254
 255   g_value_set_double (target_value, fahrenheit);
 256
 257   return TRUE;
 258 }
 259
 260 static gboolean
 261 fahrenheit_to_celsius (GBinding     *binding,
 262                        const GValue *source_value,
 263                        GValue       *target_value,
 264                        gpointer      user_data G_GNUC_UNUSED)
 265 {
 266   gdouble celsius, fahrenheit;
 267
 268   g_assert (G_VALUE_HOLDS (source_value, G_TYPE_DOUBLE));
 269   g_assert (G_VALUE_HOLDS (target_value, G_TYPE_DOUBLE));
 270
 271   fahrenheit = g_value_get_double (source_value);
 272   celsius = 5 * (fahrenheit - 32.0) / 9;
 273
 274   if (g_test_verbose ())
 275     g_print ("Converting %.2fF to %.2fC\n", fahrenheit, celsius);
 276
 277   g_value_set_double (target_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_assert ((BindingSource *) g_binding_get_source (binding) == source);
 294   g_assert ((BindingTarget *) g_binding_get_target (binding) == target);
 295   g_assert_cmpstr (g_binding_get_source_property (binding), ==, "foo");
 296   g_assert_cmpstr (g_binding_get_target_property (binding), ==, "bar");
 297   g_assert_cmpint (g_binding_get_flags (binding), ==, G_BINDING_DEFAULT);
 298
 299   g_object_set (source, "foo", 42, NULL);
 300   g_assert_cmpint (source->foo, ==, target->bar);
 301
 302   g_object_set (target, "bar", 47, NULL);
 303   g_assert_cmpint (source->foo, !=, target->bar);
 304
 305   g_object_unref (binding);
 306
 307   g_object_set (source, "foo", 0, NULL);
 308   g_assert_cmpint (source->foo, !=, target->bar);
 309
 310   g_object_unref (source);
 311   g_object_unref (target);
 312 }
 313
 314 static void
 315 binding_bidirectional (void)
 316 {
 317   BindingSource *source = g_object_new (binding_source_get_type (), NULL);
 318   BindingTarget *target = g_object_new (binding_target_get_type (), NULL);
 319   GBinding *binding;
 320
 321   binding = g_object_bind_property (source, "foo",
 322                                     target, "bar",
 323                                     G_BINDING_BIDIRECTIONAL);
 324
 325   g_object_set (source, "foo", 42, NULL);
 326   g_assert_cmpint (source->foo, ==, target->bar);
 327
 328   g_object_set (target, "bar", 47, NULL);
 329   g_assert_cmpint (source->foo, ==, target->bar);
 330
 331   g_object_unref (binding);
 332
 333   g_object_set (source, "foo", 0, NULL);
 334   g_assert_cmpint (source->foo, !=, target->bar);
 335
 336   g_object_unref (source);
 337   g_object_unref (target);
 338 }
 339
 340 static void
 341 data_free (gpointer data)
 342 {
 343   gboolean *b = data;
 344
 345   *b = TRUE;
 346 }
 347
 348 static void
 349 binding_transform_default (void)
 350 {
 351   BindingSource *source = g_object_new (binding_source_get_type (), NULL);
 352   BindingTarget *target = g_object_new (binding_target_get_type (), NULL);
 353   GBinding *binding;
 354   gpointer src, trg;
 355   gchar *src_prop, *trg_prop;
 356   GBindingFlags flags;
 357
 358   binding = g_object_bind_property (source, "foo",
 359                                     target, "value",
 360                                     G_BINDING_BIDIRECTIONAL);
 361
 362   g_object_get (binding,
 363                 "source", &src,
 364                 "source-property", &src_prop,
 365                 "target", &trg,
 366                 "target-property", &trg_prop,
 367                 "flags", &flags,
 368                 NULL);
 369   g_assert (src == source);
 370   g_assert (trg == target);
 371   g_assert_cmpstr (src_prop, ==, "foo");
 372   g_assert_cmpstr (trg_prop, ==, "value");
 373   g_assert_cmpint (flags, ==, G_BINDING_BIDIRECTIONAL);
 374   g_object_unref (src);
 375   g_object_unref (trg);
 376   g_free (src_prop);
 377   g_free (trg_prop);
 378
 379   g_object_set (source, "foo", 24, NULL);
 380   g_assert_cmpfloat (target->value, ==, 24.0);
 381
 382   g_object_set (target, "value", 69.0, NULL);
 383   g_assert_cmpint (source->foo, ==, 69);
 384
 385   g_object_unref (target);
 386   g_object_unref (source);
 387 }
 388
 389 static void
 390 binding_transform (void)
 391 {
 392   BindingSource *source = g_object_new (binding_source_get_type (), NULL);
 393   BindingTarget *target = g_object_new (binding_target_get_type (), NULL);
 394   GBinding *binding G_GNUC_UNUSED;
 395   gboolean unused_data = FALSE;
 396
 397   binding = g_object_bind_property_full (source, "value",
 398                                          target, "value",
 399                                          G_BINDING_BIDIRECTIONAL,
 400                                          celsius_to_fahrenheit,
 401                                          fahrenheit_to_celsius,
 402                                          &unused_data, data_free);
 403
 404   g_object_set (source, "value", 24.0, NULL);
 405   g_assert_cmpfloat (target->value, ==, ((9 * 24.0 / 5) + 32.0));
 406
 407   g_object_set (target, "value", 69.0, NULL);
 408   g_assert_cmpfloat (source->value, ==, (5 * (69.0 - 32.0) / 9));
 409
 410   g_object_unref (source);
 411   g_object_unref (target);
 412
 413   g_assert (unused_data);
 414 }
 415
 416 static void
 417 binding_transform_closure (void)
 418 {
 419   BindingSource *source = g_object_new (binding_source_get_type (), NULL);
 420   BindingTarget *target = g_object_new (binding_target_get_type (), NULL);
 421   GBinding *binding G_GNUC_UNUSED;
 422   gboolean unused_data_1 = FALSE, unused_data_2 = FALSE;
 423   GClosure *c2f_clos, *f2c_clos;
 424
 425   c2f_clos = g_cclosure_new (G_CALLBACK (celsius_to_fahrenheit), &unused_data_1, (GClosureNotify) data_free);
 426
 427   f2c_clos = g_cclosure_new (G_CALLBACK (fahrenheit_to_celsius), &unused_data_2, (GClosureNotify) data_free);
 428
 429   binding = g_object_bind_property_with_closures (source, "value",
 430                                                   target, "value",
 431                                                   G_BINDING_BIDIRECTIONAL,
 432                                                   c2f_clos,
 433                                                   f2c_clos);
 434
 435   g_object_set (source, "value", 24.0, NULL);
 436   g_assert_cmpfloat (target->value, ==, ((9 * 24.0 / 5) + 32.0));
 437
 438   g_object_set (target, "value", 69.0, NULL);
 439   g_assert_cmpfloat (source->value, ==, (5 * (69.0 - 32.0) / 9));
 440
 441   g_object_unref (source);
 442   g_object_unref (target);
 443
 444   g_assert (unused_data_1);
 445   g_assert (unused_data_2);
 446 }
 447
 448 static void
 449 binding_chain (void)
 450 {
 451   BindingSource *a = g_object_new (binding_source_get_type (), NULL);
 452   BindingSource *b = g_object_new (binding_source_get_type (), NULL);
 453   BindingSource *c = g_object_new (binding_source_get_type (), NULL);
 454   GBinding *binding_1, *binding_2;
 455
 456   g_test_bug ("621782");
 457
 458   /* A -> B, B -> C */
 459   binding_1 = g_object_bind_property (a, "foo", b, "foo", G_BINDING_BIDIRECTIONAL);
 460   binding_2 = g_object_bind_property (b, "foo", c, "foo", G_BINDING_BIDIRECTIONAL);
 461
 462   /* verify the chain */
 463   g_object_set (a, "foo", 42, NULL);
 464   g_assert_cmpint (a->foo, ==, b->foo);
 465   g_assert_cmpint (b->foo, ==, c->foo);
 466
 467   /* unbind A -> B and B -> C */
 468   g_object_unref (binding_1);
 469   g_object_unref (binding_2);
 470
 471   /* bind A -> C directly */
 472   binding_2 = g_object_bind_property (a, "foo", c, "foo", G_BINDING_BIDIRECTIONAL);
 473
 474   /* verify the chain is broken */
 475   g_object_set (a, "foo", 47, NULL);
 476   g_assert_cmpint (a->foo, !=, b->foo);
 477   g_assert_cmpint (a->foo, ==, c->foo);
 478
 479   g_object_unref (a);
 480   g_object_unref (b);
 481   g_object_unref (c);
 482 }
 483
 484 static void
 485 binding_sync_create (void)
 486 {
 487   BindingSource *source = g_object_new (binding_source_get_type (),
 488                                         "foo", 42,
 489                                         NULL);
 490   BindingTarget *target = g_object_new (binding_target_get_type (),
 491                                         "bar", 47,
 492                                         NULL);
 493   GBinding *binding;
 494
 495   binding = g_object_bind_property (source, "foo",
 496                                     target, "bar",
 497                                     G_BINDING_DEFAULT | G_BINDING_SYNC_CREATE);
 498
 499   g_assert_cmpint (source->foo, ==, 42);
 500   g_assert_cmpint (target->bar, ==, 42);
 501
 502   g_object_set (source, "foo", 47, NULL);
 503   g_assert_cmpint (source->foo, ==, target->bar);
 504
 505   g_object_unref (binding);
 506
 507   g_object_set (target, "bar", 49, NULL);
 508
 509   binding = g_object_bind_property (source, "foo",
 510                                     target, "bar",
 511                                     G_BINDING_BIDIRECTIONAL | G_BINDING_SYNC_CREATE);
 512   g_assert_cmpint (source->foo, ==, 47);
 513   g_assert_cmpint (target->bar, ==, 47);
 514
 515   g_object_unref (source);
 516   g_object_unref (target);
 517 }
 518
 519 static void
 520 binding_invert_boolean (void)
 521 {
 522   BindingSource *source = g_object_new (binding_source_get_type (),
 523                                         "toggle", TRUE,
 524                                         NULL);
 525   BindingTarget *target = g_object_new (binding_target_get_type (),
 526                                         "toggle", FALSE,
 527                                         NULL);
 528   GBinding *binding;
 529
 530   binding = g_object_bind_property (source, "toggle",
 531                                     target, "toggle",
 532                                     G_BINDING_BIDIRECTIONAL | G_BINDING_INVERT_BOOLEAN);
 533
 534   g_assert (source->toggle);
 535   g_assert (!target->toggle);
 536
 537   g_object_set (source, "toggle", FALSE, NULL);
 538   g_assert (!source->toggle);
 539   g_assert (target->toggle);
 540
 541   g_object_set (target, "toggle", FALSE, NULL);
 542   g_assert (source->toggle);
 543   g_assert (!target->toggle);
 544
 545   g_object_unref (binding);
 546   g_object_unref (source);
 547   g_object_unref (target);
 548 }
 549
 550 static void
 551 binding_same_object (void)
 552 {
 553   BindingSource *source = g_object_new (binding_source_get_type (),
 554                                         "foo", 100,
 555                                         "bar", 50,
 556                                         NULL);
 557   GBinding *binding G_GNUC_UNUSED;
 558
 559   binding = g_object_bind_property (source, "foo",
 560                                     source, "bar",
 561                                     G_BINDING_BIDIRECTIONAL);
 562
 563   g_object_set (source, "foo", 10, NULL);
 564   g_assert_cmpint (source->foo, ==, 10);
 565   g_assert_cmpint (source->bar, ==, 10);
 566   g_object_set (source, "bar", 30, NULL);
 567   g_assert_cmpint (source->foo, ==, 30);
 568   g_assert_cmpint (source->bar, ==, 30);
 569
 570   g_object_unref (source);
 571 }
 572
 573 int
 574 main (int argc, char *argv[])
 575 {
 576   g_type_init ();
 577   g_test_init (&argc, &argv, NULL);
 578
 579   g_test_bug_base ("http://bugzilla.gnome.org/");
 580
 581   g_test_add_func ("/binding/default", binding_default);
 582   g_test_add_func ("/binding/bidirectional", binding_bidirectional);
 583   g_test_add_func ("/binding/transform", binding_transform);
 584   g_test_add_func ("/binding/transform-default", binding_transform_default);
 585   g_test_add_func ("/binding/transform-closure", binding_transform_closure);
 586   g_test_add_func ("/binding/chain", binding_chain);
 587   g_test_add_func ("/binding/sync-create", binding_sync_create);
 588   g_test_add_func ("/binding/invert-boolean", binding_invert_boolean);
 589   g_test_add_func ("/binding/same-object", binding_same_object);
 590
 591   return g_test_run ();
 592 }