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

gio2 0.90.3-x86-mingw32

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>