RubyGems - gio2 - Versions diffs - 0.90.3-x86-mingw32 - Mend

gio2 0.90.3-x86-mingw32

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (856) hide show

data/vendor/local/share/gtk-doc/html/gobject/gobject-memory.html ADDED

@@ -0,0 +1,234 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
+<title>Object memory management</title>
+<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
+<link rel="home" href="index.html" title="GObject Reference Manual">
+<link rel="up" href="chapter-gobject.html" title="The GObject base class">
+<link rel="prev" href="chapter-gobject.html" title="The GObject base class">
+<link rel="next" href="gobject-properties.html" title="Object properties">
+<meta name="generator" content="GTK-Doc V1.15.1 (XML mode)">
+<link rel="stylesheet" href="style.css" type="text/css">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table class="navigation" id="top" width="100%" summary="Navigation header" cellpadding="2" cellspacing="2"><tr valign="middle">
+<td><a accesskey="p" href="chapter-gobject.html"><img src="left.png" width="24" height="24" border="0" alt="Prev"></a></td>
+<td><a accesskey="u" href="chapter-gobject.html"><img src="up.png" width="24" height="24" border="0" alt="Up"></a></td>
+<td><a accesskey="h" href="index.html"><img src="home.png" width="24" height="24" border="0" alt="Home"></a></td>
+<th width="100%" align="center">GObject Reference Manual</th>
+<td><a accesskey="n" href="gobject-properties.html"><img src="right.png" width="24" height="24" border="0" alt="Next"></a></td>
+</tr></table>
+<div class="sect1">
+<div class="titlepage"><div><div><h2 class="title" style="clear: both">
+<a name="gobject-memory"></a>Object memory management</h2></div></div></div>
+<p>
+      The memory-management API for GObjects is a bit complicated but the idea behind it
+      is pretty simple: the goal is to provide a flexible model based on reference counting
+      which can be integrated in applications which use or require different memory management
+      models (such as garbage collection, aso...). The methods which are used to
+      manipulate this reference count are described below.
+</p>
+<pre class="programlisting">
+/*
+  Refcounting
+*/
+gpointer    g_object_ref                      (gpointer        object);
+void        g_object_unref                    (gpointer        object);
+/*
+ * Weak References
+ */
+typedef void (*GWeakNotify) (gpointer  data,
+                             GObject  *where_the_object_was);
+void g_object_weak_ref            (GObject     *object,
+                                   GWeakNotify  notify,
+                                   gpointer     data);
+void g_object_weak_unref          (GObject     *object,
+                                   GWeakNotify  notify,
+                                   gpointer     data);
+void g_object_add_weak_pointer    (GObject     *object,
+                                   gpointer    *weak_pointer_location);
+void g_object_remove_weak_pointer (GObject     *object,
+                                   gpointer    *weak_pointer_location);
+/*
+ * Cycle handling
+ */
+void g_object_run_dispose         (GObject     *object);
+</pre>
+<p>
+    </p>
+<div class="sect2">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="gobject-memory-refcount"></a>Reference count</h3></div></div></div>
+<p>
+        The functions <code class="function"><a class="link" href="gobject-The-Base-Object-Type.html#g-object-ref" title="g_object_ref ()">g_object_ref</a></code>/<code class="function"><a class="link" href="gobject-The-Base-Object-Type.html#g-object-unref" title="g_object_unref ()">g_object_unref</a></code> respectively
+        increase and decrease the reference count.These functions are thread-safe as of GLib 2.8.
+        The reference count is, unsurprisingly, initialized to one by
+        <code class="function"><a class="link" href="gobject-The-Base-Object-Type.html#g-object-new" title="g_object_new ()">g_object_new</a></code> which means that the caller
+        is currently the sole owner of the newly-created reference.
+        When the reference count reaches zero, that is,
+        when <code class="function"><a class="link" href="gobject-The-Base-Object-Type.html#g-object-unref" title="g_object_unref ()">g_object_unref</a></code> is called by the last client holding
+        a reference to the object, the <span class="emphasis"><em>dispose</em></span> and the
+        <span class="emphasis"><em>finalize</em></span> class methods are invoked.
+      </p>
+<p>
+        Finally, after <span class="emphasis"><em>finalize</em></span> is invoked,
+        <code class="function"><a class="link" href="gobject-Type-Information.html#g-type-free-instance" title="g_type_free_instance ()">g_type_free_instance</a></code> is called to free the object instance.
+        Depending on the memory allocation policy decided when the type was registered (through
+        one of the <code class="function">g_type_register_*</code> functions), the object's instance
+        memory will be freed or returned to the object pool for this type.
+        Once the object has been freed, if it was the last instance of the type, the type's class
+        will be destroyed as described in <a class="xref" href="gtype-instantiable-classed.html" title="Instantiable classed types: objects">the section called “Instantiable classed types: objects”</a> and
+          <a class="xref" href="gtype-non-instantiable-classed.html" title="Non-instantiable classed types: interfaces">the section called “Non-instantiable classed types: interfaces”</a>.
+      </p>
+<p>
+        The table below summarizes the destruction process of a GObject:
+        </p>
+<div class="table">
+<a name="gobject-destruction-table"></a><p class="title"><b>Table 5. <code class="function"><a class="link" href="gobject-The-Base-Object-Type.html#g-object-unref" title="g_object_unref ()">g_object_unref</a></code></b></p>
+<div class="table-contents"><table summary="g_object_unref" border="1">
+<colgroup>
+<col align="left">
+<col align="left">
+<col align="left">
+</colgroup>
+<thead><tr>
+<th align="left">Invocation time</th>
+<th align="left">Function Invoked</th>
+<th align="left">Function's parameters</th>
+<th>Remark</th>
+</tr></thead>
+<tbody>
+<tr>
+<td rowspan="2" align="left">Last call to <code class="function"><a class="link" href="gobject-The-Base-Object-Type.html#g-object-unref" title="g_object_unref ()">g_object_unref</a></code> for an instance
+                  of target type
+                 </td>
+<td align="left">target type's dispose class function</td>
+<td align="left">GObject instance</td>
+<td>
+                  When dispose ends, the object should not hold any reference to any other
+                  member object. The object is also expected to be able to answer client
+                  method invocations (with possibly an error code but no memory violation)
+                  until finalize is executed. dispose can be executed more than once.
+                dispose should chain up to its parent implementation just before returning
+                to the caller.
+                </td>
+</tr>
+<tr>
+<td align="left">target type's finalize class function</td>
+<td align="left">GObject instance</td>
+<td>
+                  Finalize is expected to complete the destruction process initiated by
+                  dispose. It should complete the object's destruction. finalize will be
+                  executed only once.
+                finalize should chain up to its parent implementation just before returning
+                to the caller.
+                  The reason why the destruction process is split is two different phases is
+                  explained in <a class="xref" href="gobject-memory.html#gobject-memory-cycles" title="Reference counts and cycles">the section called “Reference counts and cycles”</a>.
+                </td>
+</tr>
+<tr>
+<td rowspan="4" align="left">Last call to <code class="function"><a class="link" href="gobject-The-Base-Object-Type.html#g-object-unref" title="g_object_unref ()">g_object_unref</a></code> for the last
+                  instance of target type
+                 </td>
+<td align="left">interface' interface_finalize function</td>
+<td align="left">On interface' vtable</td>
+<td>Never used in practice. Unlikely you will need it.</td>
+</tr>
+<tr>
+<td align="left">interface' base_finalize function</td>
+<td align="left">On interface' vtable</td>
+<td>Never used in practice. Unlikely you will need it.</td>
+</tr>
+<tr>
+<td align="left">target type's class_finalize function</td>
+<td align="left">On target type's class structure</td>
+<td>Never used in practice. Unlikely you will need it.</td>
+</tr>
+<tr>
+<td align="left">type's base_finalize function</td>
+<td align="left">On the inheritance tree of classes from fundamental type to target type.
+                  base_init is invoked once for each class structure.</td>
+<td>Never used in practice. Unlikely you will need it.</td>
+</tr>
+</tbody>
+</table></div>
+</div>
+<p><br class="table-break">
+      </p>
+</div>
+<div class="sect2">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="gobject-memory-weakref"></a>Weak References</h3></div></div></div>
+<p>
+      Weak References are used to monitor object finalization:
+      <code class="function"><a class="link" href="gobject-The-Base-Object-Type.html#g-object-weak-ref" title="g_object_weak_ref ()">g_object_weak_ref</a></code> adds a monitoring callback which does
+      not hold a reference to the object but which is invoked when the object runs
+      its dispose method. As such, each weak ref can be invoked more than once upon
+      object finalization (since dispose can run more than once during object
+      finalization).
+      </p>
+<p>
+        <code class="function"><a class="link" href="gobject-The-Base-Object-Type.html#g-object-weak-unref" title="g_object_weak_unref ()">g_object_weak_unref</a></code> can be used to remove a monitoring
+        callback from the object.
+      </p>
+<p>
+        Weak References are also used to implement <code class="function"><a class="link" href="gobject-The-Base-Object-Type.html#g-object-add-weak-pointer" title="g_object_add_weak_pointer ()">g_object_add_weak_pointer</a></code>
+        and <code class="function"><a class="link" href="gobject-The-Base-Object-Type.html#g-object-remove-weak-pointer" title="g_object_remove_weak_pointer ()">g_object_remove_weak_pointer</a></code>. These functions add a weak reference
+        to the object they are applied to which makes sure to nullify the pointer given by the user
+        when object is finalized.
+      </p>
+</div>
+<div class="sect2">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="gobject-memory-cycles"></a>Reference counts and cycles</h3></div></div></div>
+<p>
+        Note: the following section was inspired by James Henstridge. I guess this means that
+        all praise and all curses will be directly forwarded to him.
+      </p>
+<p>
+        GObject's memory management model was designed to be easily integrated in existing code
+        using garbage collection. This is why the destruction process is split in two phases:
+        the first phase, executed in the dispose handler is supposed to release all references
+        to other member objects. The second phase, executed by the finalize handler is supposed
+        to complete the object's destruction process. Object methods should be able to run
+        without program error (that is, without segfault :) in-between the two phases.
+      </p>
+<p>
+        This two-step destruction process is very useful to break reference counting cycles.
+        While the detection of the cycles is up to the external code, once the cycles have been
+        detected, the external code can invoke <code class="function">g_object_dispose</code> which
+        will indeed break any existing cycles since it will run the dispose handler associated
+        to the object and thus release all references to other objects.
+      </p>
+<p>
+        Attentive readers might now have understood one of the rules about the dispose handler
+        we stated a bit sooner: the dispose handler can be invoked multiple times. Let's say we
+        have a reference count cycle: object A references B which itself references object A.
+        Let's say we have detected the cycle and we want to destroy the two objects. One way to
+        do this would be to invoke <code class="function">g_object_dispose</code> on one of the
+        objects.
+      </p>
+<p>
+        If object A releases all its references to all objects, this means it releases its
+        reference to object B. If object B was not owned by anyone else, this is its last
+        reference count which means this last unref runs B's dispose handler which, in turn,
+        releases B's reference on object A. If this is A's last reference count, this last
+        unref runs A's dispose handler which is running for the second time before
+        A's finalize handler is invoked !
+      </p>
+<p>
+        The above example, which might seem a bit contrived can really happen if your
+        GObject's are being handled by language bindings. I would thus suggest the rules stated above
+        for object destruction are closely followed. Otherwise, <span class="emphasis"><em>Bad Bad Things</em></span>
+        will happen.
+      </p>
+</div>
+</div>
+<div class="footer">
+<hr>
+          Generated by GTK-Doc V1.15.1</div>
+</body>
+</html>

data/vendor/local/share/gtk-doc/html/gobject/gobject-properties.html ADDED

@@ -0,0 +1,270 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
+<title>Object properties</title>
+<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
+<link rel="home" href="index.html" title="GObject Reference Manual">
+<link rel="up" href="chapter-gobject.html" title="The GObject base class">
+<link rel="prev" href="gobject-memory.html" title="Object memory management">
+<link rel="next" href="chapter-signal.html" title="The GObject messaging system">
+<meta name="generator" content="GTK-Doc V1.15.1 (XML mode)">
+<link rel="stylesheet" href="style.css" type="text/css">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table class="navigation" id="top" width="100%" summary="Navigation header" cellpadding="2" cellspacing="2"><tr valign="middle">
+<td><a accesskey="p" href="gobject-memory.html"><img src="left.png" width="24" height="24" border="0" alt="Prev"></a></td>
+<td><a accesskey="u" href="chapter-gobject.html"><img src="up.png" width="24" height="24" border="0" alt="Up"></a></td>
+<td><a accesskey="h" href="index.html"><img src="home.png" width="24" height="24" border="0" alt="Home"></a></td>
+<th width="100%" align="center">GObject Reference Manual</th>
+<td><a accesskey="n" href="chapter-signal.html"><img src="right.png" width="24" height="24" border="0" alt="Next"></a></td>
+</tr></table>
+<div class="sect1">
+<div class="titlepage"><div><div><h2 class="title" style="clear: both">
+<a name="gobject-properties"></a>Object properties</h2></div></div></div>
+<p>
+      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 <code class="function"><a class="link" href="gobject-The-Base-Object-Type.html#g-object-class-install-property" title="g_object_class_install_property ()">g_object_class_install_property</a></code>
+      (implemented in <code class="filename">gobject.c</code>).
+    </p>
+<p>
+      The best way to understand how object properties work is by looking at a real example
+      on how it is used:
+</p>
+<pre class="programlisting">
+/************************************************/
+/* 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-&gt;priv-&gt;name);
+      self-&gt;priv-&gt;name = g_value_dup_string (value);
+      g_print ("maman: %s\n", self-&gt;priv-&gt;name);
+      break;
+    case PROP_PAPA_NUMBER:
+      self-&gt;priv-&gt;papa_number = g_value_get_uchar (value);
+      g_print ("papa: %u\n", self-&gt;priv-&gt;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-&gt;priv-&gt;name);
+      break;
+    case PROP_PAPA_NUMBER:
+      g_value_set_uchar (value, self-&gt;priv-&gt;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 (klass);
+  GParamSpec *pspec;
+  gobject_class-&gt;set_property = maman_bar_set_property;
+  gobject_class-&gt;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,
+                                   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 (&amp;val, G_TYPE_CHAR);
+g_value_set_char (&amp;val, 11);
+g_object_set_property (G_OBJECT (bar), "papa-number", &amp;val);
+g_value_unset (&amp;val);
+</pre>
+<p>
+      The client code just above looks simple but a lot of things happen under the hood:
+    </p>
+<p>
+      <code class="function"><a class="link" href="gobject-The-Base-Object-Type.html#g-object-set-property" title="g_object_set_property ()">g_object_set_property</a></code> first ensures a property
+      with this name was registered in bar's class_init handler. If so, it calls
+      <code class="function">object_set_property</code> 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 is that of the associated property.
+    </p>
+<p>
+      If the user provides a signed char GValue, as is shown
+      here, and if the object's property was registered as an unsigned int,
+      <code class="function"><a class="link" href="gobject-Generic-values.html#g-value-transform" title="g_value_transform ()">g_value_transform</a></code> 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
+      <sup>[<a name="id393192" href="#ftn.id393192" class="footnote">4</a>]</sup>
+      which matches and conversion will be carried out if needed.
+    </p>
+<p>
+      After transformation, the <span class="type"><a class="link" href="gobject-Generic-values.html#GValue" title="GValue">GValue</a></span> is validated by
+      <code class="function"><a class="link" href="gobject-GParamSpec.html#g-param-value-validate" title="g_param_value_validate ()">g_param_value_validate</a></code> which makes sure the user's
+      data stored in the <span class="type"><a class="link" href="gobject-Generic-values.html#GValue" title="GValue">GValue</a></span> matches the characteristics specified by
+      the property's <span class="type"><a class="link" href="gobject-GParamSpec.html#GParamSpec" title="GParamSpec">GParamSpec</a></span>.  Here, the <span class="type"><a class="link" href="gobject-GParamSpec.html#GParamSpec" title="GParamSpec">GParamSpec</a></span> 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
+      <span class="type"><a class="link" href="gobject-GParamSpec.html#GParamSpec" title="GParamSpec">GParamSpec</a></span>. 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
+      <code class="function"><a class="link" href="gobject-The-Base-Object-Type.html#g-object-set-property" title="g_object_set_property ()">g_object_set_property</a></code> function will return with an error.
+    </p>
+<p>
+      If the user's GValue had been set to a valid value, <code class="function"><a class="link" href="gobject-The-Base-Object-Type.html#g-object-set-property" title="g_object_set_property ()">g_object_set_property</a></code>
+      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
+      <code class="function">foo_set_property</code> after having retrieved from the
+      <span class="type"><a class="link" href="gobject-GParamSpec.html#GParamSpec" title="GParamSpec">GParamSpec</a></span> the <span class="emphasis"><em>param_id</em></span>
+      <sup>[<a name="id393282" href="#ftn.id393282" class="footnote">5</a>]</sup>
+      which had been stored by
+      <code class="function"><a class="link" href="gobject-The-Base-Object-Type.html#g-object-class-install-property" title="g_object_class_install_property ()">g_object_class_install_property</a></code>.
+    </p>
+<p>
+      Once the property has been set by the object's set_property class method, the code path
+      returns to <code class="function"><a class="link" href="gobject-The-Base-Object-Type.html#g-object-set-property" title="g_object_set_property ()">g_object_set_property</a></code> which calls
+      <code class="function">g_object_notify_queue_thaw</code>. 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 <code class="function"><a class="link" href="gobject-The-Base-Object-Type.html#g-object-freeze-notify" title="g_object_freeze_notify ()">g_object_freeze_notify</a></code>.
+    </p>
+<p>
+      <code class="function"><a class="link" href="gobject-The-Base-Object-Type.html#g-object-thaw-notify" title="g_object_thaw_notify ()">g_object_thaw_notify</a></code> 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.
+    </p>
+<p>
+      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 <code class="function"><a class="link" href="gobject-The-Base-Object-Type.html#g-object-set-property" title="g_object_set_property ()">g_object_set_property</a></code>
+      and <code class="function"><a class="link" href="gobject-The-Base-Object-Type.html#g-object-get-property" title="g_object_get_property ()">g_object_get_property</a></code>
+      are meant to be used by language bindings. For application there is an easier way and
+      that is described next.
+    </p>
+<div class="sect2">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="gobject-multi-properties"></a>Accessing multiple properties at once</h3></div></div></div>
+<p>
+        It is interesting to note that the <code class="function"><a class="link" href="gobject-The-Base-Object-Type.html#g-object-set" title="g_object_set ()">g_object_set</a></code> and
+        <code class="function"><a class="link" href="gobject-The-Base-Object-Type.html#g-object-set-valist" title="g_object_set_valist ()">g_object_set_valist</a></code> (vararg version) functions can be used to set
+        multiple properties at once. The client code shown above can then be re-written as:
+</p>
+<pre class="programlisting">
+MamanBar *foo;
+foo = /* */;
+g_object_set (G_OBJECT (foo),
+              "papa-number", 2,
+              "maman-name", "test",
+              NULL);
+</pre>
+<p>
+        This saves us from managing the GValues that we were needing to handle when using
+        <code class="function"><a class="link" href="gobject-The-Base-Object-Type.html#g-object-set-property" title="g_object_set_property ()">g_object_set_property</a></code>.
+        The code above will trigger one notify signal emission for each property modified.
+      </p>
+<p>
+        Of course, the _get versions are also available: <code class="function"><a class="link" href="gobject-The-Base-Object-Type.html#g-object-get" title="g_object_get ()">g_object_get</a></code>
+        and <code class="function"><a class="link" href="gobject-The-Base-Object-Type.html#g-object-get-valist" title="g_object_get_valist ()">g_object_get_valist</a></code> (vararg version) can be used to get numerous
+        properties at once.
+      </p>
+<p>
+        These high level functions have one drawback - they don't provide a return result.
+        One should pay attention to the argument types and ranges when using them.
+        A known source of errors is to e.g. pass a gfloat instead of a gdouble and thus
+        shifting all subsequent parameters by four bytes. Also forgetting the terminating
+        NULL will lead to unexpected behaviour.
+      </p>
+<p>
+        Really attentive readers now understand how <code class="function"><a class="link" href="gobject-The-Base-Object-Type.html#g-object-new" title="g_object_new ()">g_object_new</a></code>,
+        <code class="function"><a class="link" href="gobject-The-Base-Object-Type.html#g-object-newv" title="g_object_newv ()">g_object_newv</a></code> and <code class="function"><a class="link" href="gobject-The-Base-Object-Type.html#g-object-new-valist" title="g_object_new_valist ()">g_object_new_valist</a></code>
+        work: they parse the user-provided variable number of parameters and invoke
+        <code class="function"><a class="link" href="gobject-The-Base-Object-Type.html#g-object-set" title="g_object_set ()">g_object_set</a></code> on the parameters only after the object has been successfully constructed.
+        Of course, the "notify" signal will be emitted for each property set.
+      </p>
+</div>
+<div class="footnotes">
+<br><hr width="100" align="left">
+<div class="footnote"><p><sup>[<a name="ftn.id393192" href="#id393192" class="para">4</a>] </sup>Its behaviour might not be what you expect but it is up to you to actually avoid
+          relying on these transformations.
+        </p></div>
+<div class="footnote"><p><sup>[<a name="ftn.id393282" href="#id393282" class="para">5</a>] </sup>
+          It should be noted that the param_id used here need only to uniquely identify each
+          <span class="type"><a class="link" href="gobject-GParamSpec.html#GParamSpec" title="GParamSpec">GParamSpec</a></span> within the <span class="type">FooClass</span> such that the switch
+          used in the set and get methods actually works. Of course, this locally-unique
+          integer is purely an optimization: it would have been possible to use a set of
+          <span class="emphasis"><em>if (strcmp (a, b) == 0) {} else if (strcmp (a, b) == 0) {}</em></span> statements.
+        </p></div>
+</div>
+</div>
+<div class="footer">
+<hr>
+          Generated by GTK-Doc V1.15.1</div>
+</body>
+</html>