One of GObject's nice features is its generic get/set mechanism for object properties. When an object is instantiated, the object's class_init handler should be used to register the object's properties with g_object_class_install_property (implemented in gobject.c).

The best way to understand how object properties work is by looking at a real example on how it is used:

/************************************************/
/* Implementation                               */
/************************************************/

enum
{
  PROP_0,

  PROP_MAMAN_NAME,
  PROP_PAPA_NUMBER
};

static void
maman_bar_set_property (GObject      *object,
                        guint         property_id,
                        const GValue *value,
                        GParamSpec   *pspec)
{
  MamanBar *self = MAMAN_BAR (object);

  switch (property_id)
    {
    case PROP_MAMAN_NAME:
      g_free (self->priv->name);
      self->priv->name = g_value_dup_string (value);
      g_print ("maman: %s\n", self->priv->name);
      break;

    case PROP_PAPA_NUMBER:
      self->priv->papa_number = g_value_get_uchar (value);
      g_print ("papa: %u\n", self->priv->papa_number);
      break;

    default:
      /* We don't have any other property... */
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
      break;
    }
}

static void
maman_bar_get_property (GObject    *object,
                        guint       property_id,
                        GValue     *value,
                        GParamSpec *pspec)
{
  MamanBar *self = MAMAN_BAR (object);

  switch (property_id)
    {
    case PROP_MAMAN_NAME:
      g_value_set_string (value, self->priv->name);
      break;

    case PROP_PAPA_NUMBER:
      g_value_set_uchar (value, self->priv->papa_number);
      break;

    default:
      /* We don't have any other property... */
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
      break;
    }
}

static void
maman_bar_class_init (MamanBarClass *klass)
{
  GObjectClass *gobject_class = G_OBJECT_CLASS (g_class);
  GParamSpec *pspec;

  gobject_class->set_property = maman_bar_set_property;
  gobject_class->get_property = maman_bar_get_property;

  pspec = g_param_spec_string ("maman-name",
                               "Maman construct prop",
                               "Set maman's name",
                               "no-name-set" /* default value */,
                               G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE);
  g_object_class_install_property (gobject_class,
                                   PROP_MAMAN_NAME_NAME,
                                   pspec);

  pspec = g_param_spec_uchar ("papa-number",
                              "Number of current Papa",
                              "Set/Get papa's number",
                              0  /* minimum value */,
                              10 /* maximum value */,
                              2  /* default value */,
                              G_PARAM_READWRITE);
  g_object_class_install_property (gobject_class,
                                   PROP_PAPA_NUMBER,
                                   pspec);
}

/************************************************/
/* Use                                          */
/************************************************/

GObject *bar;
GValue val = { 0, };

bar = g_object_new (MAMAN_TYPE_SUBBAR, NULL);

g_value_init (&val, G_TYPE_CHAR);
g_value_set_char (&val, 11);

g_object_set_property (G_OBJECT (bar), "papa-number", &val);

g_value_unset (&val);

The client code just above looks simple but a lot of things happen under the hood:

g_object_set_property first ensures a property with this name was registered in bar's class_init handler. If so, it calls object_set_property which first walks the class hierarchy, from bottom, most derived type, to top, fundamental type to find the class which registered that property. It then tries to convert the user-provided GValue into a GValue whose type if that of the associated property.

If the user provides a signed char GValue, as is shown here, and if the object's property was registered as an unsigned int, g_value_transform will try to transform the input signed char into an unsigned int. Of course, the success of the transformation depends on the availability of the required transform function. In practice, there will almost always be a transformation ^[6] which matches and conversion will be carried out if needed.

After transformation, the GValue is validated by g_param_value_validate which makes sure the user's data stored in the GValue matches the characteristics specified by the property's GParamSpec. Here, the GParamSpec we provided in class_init has a validation function which makes sure that the GValue contains a value which respects the minimum and maximum bounds of the GParamSpec. In the example above, the client's GValue does not respect these constraints (it is set to 11, while the maximum is 10). As such, the g_object_set_property function will return with an error.

If the user's GValue had been set to a valid value, g_object_set_property would have proceeded with calling the object's set_property class method. Here, since our implementation of Foo did override this method, the code path would jump to foo_set_property after having retrieved from the GParamSpec the param_id ^[7] which had been stored by g_object_class_install_property.

Once the property has been set by the object's set_property class method, the code path returns to g_object_set_property which calls g_object_notify_queue_thaw. This function makes sure that the "notify" signal is emitted on the object's instance with the changed property as parameter unless notifications were frozen by g_object_freeze_notify.

g_object_thaw_notify can be used to re-enable notification of property modifications through the "notify" signal. It is important to remember that even if properties are changed while property change notification is frozen, the "notify" signal will be emitted once for each of these changed properties as soon as the property change notification is thawed: no property change is lost for the "notify" signal. Signal can only be delayed by the notification freezing mechanism.

It sounds like a tedious task to set up GValues every time when one wants to modify a property. In practice one will rarely do this. The functions g_object_set_property and g_object_get_property are meant to be used by language bindings. For application there is an easier way and that is described next.

MamanBar *foo;
foo = /* */;
g_object_set (G_OBJECT (foo),
              "papa-number", 2, 
              "maman-name", "test", 
              NULL);