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