RubyGems - glib2 - Versions diffs - 3.0.7-x64-mingw32 → 3.0.8-x64-mingw32 - Mend

glib2 3.0.7-x64-mingw32 → 3.0.8-x64-mingw32

Files changed (1062) hide show

data/vendor/local/share/gtk-doc/html/gobject/gtype-conventions.html CHANGED Viewed

@@ -3,12 +3,12 @@
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
 <title>Conventions: GObject Reference Manual</title>
-<meta name="generator" content="DocBook XSL Stylesheets V1.78.1">
+<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
 <link rel="home" href="index.html" title="GObject Reference Manual">
 <link rel="up" href="chapter-gtype.html" title="The GLib Dynamic Type System">
 <link rel="prev" href="chapter-gtype.html" title="The GLib Dynamic Type System">
 <link rel="next" href="gtype-non-instantiable.html" title="Non-instantiable non-classed fundamental types">
-<meta name="generator" content="GTK-Doc V1.21.1 (XML mode)">
+<meta name="generator" content="GTK-Doc V1.24 (XML mode)">
 <link rel="stylesheet" href="style.css" type="text/css">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
@@ -27,55 +27,65 @@
         which are to be exported in a header file:
         </p>
 <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
+<li class="listitem"><p>
+            Type names (including object names) must be at least three
+            characters long and start with ‘a–z’, ‘A–Z’ or ‘_’.
+          </p></li>
 <li class="listitem"><p>
             Use the <code class="function">object_method</code> pattern for function names: to invoke
-            the method named foo on an instance of object type bar, call
-            <code class="function">bar_foo</code>.
+            the method named <code class="function">save</code> on an instance of object type <span class="type">file</span>, call
+            <code class="function">file_save</code>.
           </p></li>
 <li class="listitem"><p>Use prefixing to avoid namespace conflicts with other projects.
-            If your library (or application) is named <span class="emphasis"><em>Maman</em></span>,
-            <a href="#ftn.id-1.3.3.7.2.1.2.1.2" class="footnote" name="id-1.3.3.7.2.1.2.1.2"><sup class="footnote">[3]</sup></a>
-            prefix all your function names with <span class="emphasis"><em>maman_</em></span>.
-            For example: <code class="function">maman_object_method</code>.
+            If your library (or application) is named <span class="emphasis"><em>Viewer</em></span>,
+            prefix all your function names with <span class="emphasis"><em>viewer_</em></span>.
+            For example: <code class="function">viewer_object_method</code>.
           </p></li>
 <li class="listitem"><p>Create a macro named <code class="function">PREFIX_TYPE_OBJECT</code> which always
             returns the GType for the associated object type. For an object of type
-            <span class="emphasis"><em>Bar</em></span> in a library prefixed by <span class="emphasis"><em>maman</em></span>,
-            use: <code class="function">MAMAN_TYPE_BAR</code>.
-            It is common although not a convention to implement this macro using either a global
-            static variable or a function named <code class="function">prefix_object_get_type</code>.
-            We will follow the function pattern wherever possible in this document.
-          </p></li>
-<li class="listitem"><p>Create a macro named <code class="function">PREFIX_OBJECT (obj)</code> which
-            returns a pointer of type <span class="type">PrefixObject</span>. This macro is used to enforce
-            static type safety by doing explicit casts wherever needed. It also enforces
-            dynamic type safety by doing runtime checks. It is possible to disable the dynamic
-            type checks in production builds (see <a href="../glib/glib-building.html">building glib</a>).
-            For example, we would create
-            <code class="function">MAMAN_BAR (obj)</code> to keep the previous example.
-          </p></li>
-<li class="listitem"><p>If the type is classed, create a macro named
-            <code class="function">PREFIX_OBJECT_CLASS (klass)</code>. This macro
-            is strictly equivalent to the previous casting macro: it does static casting with
-            dynamic type checking of class structures. It is expected to return a pointer
-            to a class structure of type <span class="type">PrefixObjectClass</span>. Again, an example is:
-            <code class="function">MAMAN_BAR_CLASS</code>.
-          </p></li>
-<li class="listitem"><p>Create a macro named <code class="function">PREFIX_IS_BAR (obj)</code>: this macro is expected
-            to return a <span class="type">gboolean</span> which indicates whether or not the input
-            object instance pointer of type BAR.
-          </p></li>
-<li class="listitem"><p>If the type is classed, create a macro named
-            <code class="function">PREFIX_IS_OBJECT_CLASS (klass)</code> which, as above, returns a boolean
-            if the input class pointer is a pointer to a class of type OBJECT.
-          </p></li>
-<li class="listitem"><p>If the type is classed, create a macro named
-            <code class="function">PREFIX_OBJECT_GET_CLASS (obj)</code>
-            which returns the class pointer associated to an instance of a given type. This macro
-            is used for static and dynamic type safety purposes (just like the previous casting
-            macros).
+            <span class="emphasis"><em>File</em></span> in the <span class="emphasis"><em>Viewer</em></span> namespace,
+            use: <code class="function">VIEWER_TYPE_FILE</code>.
+            This macro is implemented using a function named
+            <code class="function">prefix_object_get_type</code>; for example, <code class="function">viewer_file_get_type</code>.
           </p></li>
+<li class="listitem">
+<p>
+              Use <a class="link" href="gobject-Type-Information.html#G-DECLARE-FINAL-TYPE:CAPS" title="G_DECLARE_FINAL_TYPE()"><code class="function">G_DECLARE_FINAL_TYPE</code></a>
+              or <a class="link" href="gobject-Type-Information.html#G-DECLARE-DERIVABLE-TYPE:CAPS" title="G_DECLARE_DERIVABLE_TYPE()"><code class="function">G_DECLARE_DERIVABLE_TYPE</code></a>
+              to define various other conventional macros for your object:
+            </p>
+<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: circle; ">
+<li class="listitem"><p><code class="function">PREFIX_OBJECT (obj)</code>, which
+                returns a pointer of type <span class="type">PrefixObject</span>. This macro is used to enforce
+                static type safety by doing explicit casts wherever needed. It also enforces
+                dynamic type safety by doing runtime checks. It is possible to disable the dynamic
+                type checks in production builds (see <a href="../glib/glib-building.html">building GLib</a>).
+                For example, we would create
+                <code class="function">VIEWER_FILE (obj)</code> to keep the previous example.
+              </p></li>
+<li class="listitem"><p><code class="function">PREFIX_OBJECT_CLASS (klass)</code>, which
+                is strictly equivalent to the previous casting macro: it does static casting with
+                dynamic type checking of class structures. It is expected to return a pointer
+                to a class structure of type <span class="type">PrefixObjectClass</span>. An example is:
+                <code class="function">VIEWER_FILE_CLASS</code>.
+              </p></li>
+<li class="listitem"><p><code class="function">PREFIX_IS_OBJECT (obj)</code>, which
+                returns a <span class="type">gboolean</span> which indicates whether the input
+                object instance pointer is non-<span class="type">NULL</span> and of type <span class="type">OBJECT</span>.
+                For example, <code class="function">VIEWER_IS_FILE</code>.
+              </p></li>
+<li class="listitem"><p><code class="function">PREFIX_IS_OBJECT_CLASS (klass)</code>, which returns a boolean
+                if the input class pointer is a pointer to a class of type OBJECT.
+                For example, <code class="function">VIEWER_IS_FILE_CLASS</code>.
+              </p></li>
+<li class="listitem"><p><code class="function">PREFIX_OBJECT_GET_CLASS (obj)</code>,
+                which returns the class pointer associated to an instance of a given type. This macro
+                is used for static and dynamic type safety purposes (just like the previous casting
+                macros).
+                For example, <code class="function">VIEWER_FILE_GET_CLASS</code>.
+              </p></li>
+</ul></div>
+</li>
 </ul></div>
 <p>
         The implementation of these macros is pretty straightforward: a number of simple-to-use
@@ -87,30 +97,37 @@
     <tbody>
       <tr>
         <td class="listing_lines" align="right"><pre>1
-2
-3
-4
-5
-6</pre></td>
-        <td class="listing_code"><pre class="programlisting"><span class="preproc">#define</span><span class="normal"> </span><span class="function">MAMAN_TYPE_BAR</span><span class="normal">                  </span><span class="symbol">(</span><span class="function">maman_bar_get_type</span><span class="normal"> </span><span class="symbol">())</span>
-<span class="preproc">#define</span><span class="normal"> </span><span class="function">MAMAN_BAR</span><span class="symbol">(</span><span class="normal">obj</span><span class="symbol">)</span><span class="normal">                  </span><span class="symbol">(</span><span class="function"><a href="gobject-Type-Information.html#G-TYPE-CHECK-INSTANCE-CAST:CAPS">G_TYPE_CHECK_INSTANCE_CAST</a></span><span class="normal"> </span><span class="symbol">((</span><span class="normal">obj</span><span class="symbol">),</span><span class="normal"> MAMAN_TYPE_BAR</span><span class="symbol">,</span><span class="normal"> MamanBar</span><span class="symbol">))</span>
-<span class="preproc">#define</span><span class="normal"> </span><span class="function">MAMAN_BAR_CLASS</span><span class="symbol">(</span><span class="normal">klass</span><span class="symbol">)</span><span class="normal">          </span><span class="symbol">(</span><span class="function"><a href="gobject-Type-Information.html#G-TYPE-CHECK-CLASS-CAST:CAPS">G_TYPE_CHECK_CLASS_CAST</a></span><span class="normal"> </span><span class="symbol">((</span><span class="normal">klass</span><span class="symbol">),</span><span class="normal"> MAMAN_TYPE_BAR</span><span class="symbol">,</span><span class="normal"> MamanBarClass</span><span class="symbol">))</span>
-<span class="preproc">#define</span><span class="normal"> </span><span class="function">MAMAN_IS_BAR</span><span class="symbol">(</span><span class="normal">obj</span><span class="symbol">)</span><span class="normal">          </span><span class="symbol">(</span><span class="function"><a href="gobject-Type-Information.html#G-TYPE-CHECK-INSTANCE-TYPE:CAPS">G_TYPE_CHECK_INSTANCE_TYPE</a></span><span class="normal"> </span><span class="symbol">((</span><span class="normal">obj</span><span class="symbol">),</span><span class="normal"> MAMAN_TYPE_BAR</span><span class="symbol">))</span>
-<span class="preproc">#define</span><span class="normal"> </span><span class="function">MAMAN_IS_BAR_CLASS</span><span class="symbol">(</span><span class="normal">klass</span><span class="symbol">)</span><span class="normal"> </span><span class="symbol">(</span><span class="function"><a href="gobject-Type-Information.html#G-TYPE-CHECK-CLASS-TYPE:CAPS">G_TYPE_CHECK_CLASS_TYPE</a></span><span class="normal"> </span><span class="symbol">((</span><span class="normal">klass</span><span class="symbol">),</span><span class="normal"> MAMAN_TYPE_BAR</span><span class="symbol">))</span>
-<span class="preproc">#define</span><span class="normal"> </span><span class="function">MAMAN_BAR_GET_CLASS</span><span class="symbol">(</span><span class="normal">obj</span><span class="symbol">)</span><span class="normal">  </span><span class="symbol">(</span><span class="function"><a href="gobject-Type-Information.html#G-TYPE-INSTANCE-GET-CLASS:CAPS">G_TYPE_INSTANCE_GET_CLASS</a></span><span class="normal"> </span><span class="symbol">((</span><span class="normal">obj</span><span class="symbol">),</span><span class="normal"> MAMAN_TYPE_BAR</span><span class="symbol">,</span><span class="normal"> MamanBarClass</span><span class="symbol">))</span></pre></td>
+2</pre></td>
+        <td class="listing_code"><pre class="programlisting"><span class="gtkdoc ppc">#define VIEWER_TYPE_FILE viewer_file_get_type ()</span>
+<span class="function"><a href="gobject-Type-Information.html#G-DECLARE-FINAL-TYPE:CAPS">G_DECLARE_FINAL_TYPE</a></span> <span class="gtkdoc opt">(</span>ViewerFile<span class="gtkdoc opt">,</span> viewer_file<span class="gtkdoc opt">,</span> VIEWER<span class="gtkdoc opt">,</span> <span class="gtkdoc kwb">FILE</span><span class="gtkdoc opt">,</span> GObject<span class="gtkdoc opt">)</span></pre></td>
       </tr>
     </tbody>
   </table>
 </div>
 <p>
-        </p>
-<div class="note"><p>Stick to the naming <code class="varname">klass</code> as <code class="varname">class</code> is a registered c++ keyword.</p></div>
+      </p>
+<p>
+        Unless your code has special requirements, you can use the
+        <code class="function"><a class="link" href="gobject-Type-Information.html#G-DEFINE-TYPE:CAPS" title="G_DEFINE_TYPE()">G_DEFINE_TYPE</a></code>
+	macro to define a class:
+</p>
+<div class="informalexample">
+  <table class="listing_frame" border="0" cellpadding="0" cellspacing="0">
+    <tbody>
+      <tr>
+        <td class="listing_lines" align="right"><pre>1</pre></td>
+        <td class="listing_code"><pre class="programlisting"><span class="function"><a href="gobject-Type-Information.html#G-DEFINE-TYPE:CAPS">G_DEFINE_TYPE</a></span> <span class="gtkdoc opt">(</span>ViewerFile<span class="gtkdoc opt">,</span> viewer_file<span class="gtkdoc opt">,</span> G_TYPE_OBJECT<span class="gtkdoc opt">)</span></pre></td>
+      </tr>
+    </tbody>
+  </table>
+</div>
 <p>
       </p>
 <p>
-        The following code shows how to implement the <code class="function">maman_bar_get_type</code>
-        function:
+        Otherwise, the <code class="function">viewer_file_get_type</code> function must be
+        implemented manually:
 </p>
 <div class="informalexample">
   <table class="listing_frame" border="0" cellpadding="0" cellspacing="0">
@@ -129,19 +146,19 @@
 11
 12
 13</pre></td>
-        <td class="listing_code"><pre class="programlisting"><span class="usertype">GType</span><span class="normal"> </span><span class="function">maman_bar_get_type</span><span class="normal"> </span><span class="symbol">(</span><span class="type">void</span><span class="symbol">)</span>
-<span class="cbracket">{</span>
-<span class="normal">  </span><span class="keyword">static</span><span class="normal"> </span><span class="usertype">GType</span><span class="normal"> type </span><span class="symbol">=</span><span class="normal"> </span><span class="number">0</span><span class="symbol">;</span>
-<span class="normal">  </span><span class="keyword">if</span><span class="normal"> </span><span class="symbol">(</span><span class="normal">type </span><span class="symbol">==</span><span class="normal"> </span><span class="number">0</span><span class="symbol">)</span><span class="normal"> </span><span class="cbracket">{</span>
-<span class="normal">    </span><span class="keyword">const</span><span class="normal"> </span><span class="usertype">GTypeInfo</span><span class="normal"> info </span><span class="symbol">=</span><span class="normal"> </span><span class="cbracket">{</span>
-<span class="normal">      </span><span class="comment">/* You fill this structure. */</span>
-<span class="normal">    </span><span class="cbracket">}</span><span class="symbol">;</span>
-<span class="normal">    type </span><span class="symbol">=</span><span class="normal"> </span><span class="function"><a href="gobject-Type-Information.html#g-type-register-static">g_type_register_static</a></span><span class="normal"> </span><span class="symbol">(</span><span class="normal"><a href="gobject-Type-Information.html#G-TYPE-OBJECT:CAPS">G_TYPE_OBJECT</a></span><span class="symbol">,</span>
-<span class="normal">                                   </span><span class="string">"MamanBarType"</span><span class="symbol">,</span>
-<span class="normal">                                   </span><span class="symbol">&amp;</span><span class="normal">info</span><span class="symbol">,</span><span class="normal"> </span><span class="number">0</span><span class="symbol">);</span>
-<span class="normal">  </span><span class="cbracket">}</span>
-<span class="normal">  </span><span class="keyword">return</span><span class="normal"> type</span><span class="symbol">;</span>
-<span class="cbracket">}</span></pre></td>
+        <td class="listing_code"><pre class="programlisting">GType <span class="function">viewer_file_get_type</span> <span class="gtkdoc opt">(</span><span class="gtkdoc kwb">void</span><span class="gtkdoc opt">)</span>
+<span class="gtkdoc opt">{</span>
+  <span class="gtkdoc kwb">static</span> GType type <span class="gtkdoc opt">=</span> <span class="number">0</span><span class="gtkdoc opt">;</span>
+  <span class="keyword">if</span> <span class="gtkdoc opt">(</span>type <span class="gtkdoc opt">==</span> <span class="number">0</span><span class="gtkdoc opt">) {</span>
+    <span class="gtkdoc kwb">const</span> GTypeInfo info <span class="gtkdoc opt">= {</span>
+      <span class="comment">/* You fill this structure. */</span>
+    <span class="gtkdoc opt">};</span>
+    type <span class="gtkdoc opt">=</span> <span class="function"><a href="gobject-Type-Information.html#g-type-register-static">g_type_register_static</a></span> <span class="gtkdoc opt">(</span>G_TYPE_OBJECT<span class="gtkdoc opt">,</span>
+                                   <span class="string">&quot;ViewerFile&quot;</span><span class="gtkdoc opt">,</span>
+                                   <span class="gtkdoc opt">&amp;</span>info<span class="gtkdoc opt">,</span> <span class="number">0</span><span class="gtkdoc opt">);</span>
+  <span class="gtkdoc opt">}</span>
+  <span class="keyword">return</span> type<span class="gtkdoc opt">;</span>
+<span class="gtkdoc opt">}</span></pre></td>
       </tr>
     </tbody>
   </table>
@@ -149,34 +166,8 @@
 <p>
       </p>
-<p>
-        If you have no special requirements you can use the
-        <code class="function"><a class="link" href="gobject-Type-Information.html#G-DEFINE-TYPE:CAPS" title="G_DEFINE_TYPE()">G_DEFINE_TYPE</a></code>
-	macro to define a class:
-</p>
-<div class="informalexample">
-  <table class="listing_frame" border="0" cellpadding="0" cellspacing="0">
-    <tbody>
-      <tr>
-        <td class="listing_lines" align="right"><pre>1</pre></td>
-        <td class="listing_code"><pre class="programlisting"><span class="function"><a href="gobject-Type-Information.html#G-DEFINE-TYPE:CAPS">G_DEFINE_TYPE</a></span><span class="normal"> </span><span class="symbol">(</span><span class="normal">MamanBar</span><span class="symbol">,</span><span class="normal"> maman_bar</span><span class="symbol">,</span><span class="normal"> <a href="gobject-Type-Information.html#G-TYPE-OBJECT:CAPS">G_TYPE_OBJECT</a></span><span class="symbol">)</span></pre></td>
-      </tr>
-    </tbody>
-  </table>
-</div>
-<p>
-      </p>
-<div class="footnotes">
-<br><hr style="width:100; text-align:left;margin-left: 0">
-<div id="ftn.id-1.3.3.7.2.1.2.1.2" class="footnote"><p><a href="#id-1.3.3.7.2.1.2.1.2" class="para"><sup class="para">[3] </sup></a>
-                <span class="emphasis"><em>Maman</em></span> is the French word for <span class="emphasis"><em>mum</em></span>
-                or <span class="emphasis"><em>mother</em></span> - nothing more and nothing less.
-              </p></div>
-</div>
 </div>
 <div class="footer">
-<hr>
-          Generated by GTK-Doc V1.21.1</div>
+<hr>Generated by GTK-Doc V1.24</div>
 </body>
 </html>

data/vendor/local/share/gtk-doc/html/gobject/gtype-instantiable-classed.html CHANGED Viewed

@@ -3,12 +3,12 @@
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
 <title>Instantiable classed types: objects: GObject Reference Manual</title>
-<meta name="generator" content="DocBook XSL Stylesheets V1.78.1">
+<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
 <link rel="home" href="index.html" title="GObject Reference Manual">
 <link rel="up" href="chapter-gtype.html" title="The GLib Dynamic Type System">
 <link rel="prev" href="gtype-non-instantiable.html" title="Non-instantiable non-classed fundamental types">
 <link rel="next" href="gtype-non-instantiable-classed.html" title="Non-instantiable classed types: interfaces">
-<meta name="generator" content="GTK-Doc V1.21.1 (XML mode)">
+<meta name="generator" content="GTK-Doc V1.24 (XML mode)">
 <link rel="stylesheet" href="style.css" type="text/css">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
@@ -22,6 +22,11 @@
 <div class="sect1">
 <div class="titlepage"><div><div><h2 class="title" style="clear: both">
 <a name="gtype-instantiable-classed"></a>Instantiable classed types: objects</h2></div></div></div>
+<p>
+          This section covers the theory behind objects. See
+          <a class="xref" href="howto-gobject.html" title="How to define and implement a new GObject"><i>How to define and implement a new GObject</i></a> for the recommended way to define a
+          GObject.
+        </p>
 <p>
           Types which are registered with a class and are declared instantiable are
           what most closely resembles an <span class="emphasis"><em>object</em></span>.
@@ -33,7 +38,8 @@
         </p>
 <p>
           For example, the code below shows how you could register
-          such a fundamental object type in the type system:
+          such a fundamental object type in the type system (using none of the
+          GObject convenience API):
 </p>
 <div class="informalexample">
   <table class="listing_frame" border="0" cellpadding="0" cellspacing="0">
@@ -76,53 +82,65 @@
 35
 36
 37
-38</pre></td>
-        <td class="listing_code"><pre class="programlisting"><span class="keyword">typedef</span><span class="normal"> </span><span class="keyword">struct</span><span class="normal"> </span><span class="cbracket">{</span>
-<span class="normal">  </span><span class="usertype">GObject</span><span class="normal"> parent</span><span class="symbol">;</span>
-<span class="normal">  </span><span class="comment">/* instance members */</span>
-<span class="normal">  </span><span class="type">int</span><span class="normal"> field_a</span><span class="symbol">;</span>
-<span class="cbracket">}</span><span class="normal"> MamanBar</span><span class="symbol">;</span>
+38
+39
+40
+41
+42
+43
+44</pre></td>
+        <td class="listing_code"><pre class="programlisting"><span class="gtkdoc kwc">typedef</span> <span class="gtkdoc kwb">struct</span> <span class="gtkdoc opt">{</span>
+  GObject parent<span class="gtkdoc opt">;</span>
+  <span class="comment">/* instance members */</span>
+  gchar <span class="gtkdoc opt">*</span>filename<span class="gtkdoc opt">;</span>
+<span class="gtkdoc opt">}</span> ViewerFile<span class="gtkdoc opt">;</span>
-<span class="keyword">typedef</span><span class="normal"> </span><span class="keyword">struct</span><span class="normal"> </span><span class="cbracket">{</span>
-<span class="normal">  </span><span class="usertype">GObjectClass</span><span class="normal"> parent</span><span class="symbol">;</span>
-<span class="normal">  </span><span class="comment">/* class members */</span>
-<span class="normal">  </span><span class="type">void</span><span class="normal"> </span><span class="symbol">(*</span><span class="normal">do_action_public_virtual</span><span class="symbol">)</span><span class="normal"> </span><span class="symbol">(</span><span class="usertype">MamanBar</span><span class="normal"> </span><span class="symbol">*</span><span class="normal">self</span><span class="symbol">,</span><span class="normal"> </span><span class="usertype">guint8</span><span class="normal"> i</span><span class="symbol">);</span>
+<span class="gtkdoc kwc">typedef</span> <span class="gtkdoc kwb">struct</span> <span class="gtkdoc opt">{</span>
+  GObjectClass parent<span class="gtkdoc opt">;</span>
-<span class="normal">  </span><span class="type">void</span><span class="normal"> </span><span class="symbol">(*</span><span class="normal">do_action_public_pure_virtual</span><span class="symbol">)</span><span class="normal"> </span><span class="symbol">(</span><span class="usertype">MamanBar</span><span class="normal"> </span><span class="symbol">*</span><span class="normal">self</span><span class="symbol">,</span><span class="normal"> </span><span class="usertype">guint8</span><span class="normal"> i</span><span class="symbol">);</span>
-<span class="cbracket">}</span><span class="normal"> MamanBarClass</span><span class="symbol">;</span>
+  <span class="comment">/* class members */</span>
+  <span class="comment">/* the first is public, pure and virtual */</span>
+  <span class="gtkdoc kwb">void</span> <span class="gtkdoc opt">(*</span>open<span class="gtkdoc opt">)  (</span>ViewerFile  <span class="gtkdoc opt">*</span>self<span class="gtkdoc opt">,</span>
+                 GError     <span class="gtkdoc opt">**</span>error<span class="gtkdoc opt">);</span>
-<span class="preproc">#define</span><span class="normal"> </span><span class="function">MAMAN_TYPE_BAR</span><span class="normal"> </span><span class="symbol">(</span><span class="function">maman_bar_get_type</span><span class="normal"> </span><span class="symbol">())</span>
+  <span class="comment">/* the second is public and virtual */</span>
+  <span class="gtkdoc kwb">void</span> <span class="gtkdoc opt">(*</span>close<span class="gtkdoc opt">) (</span>ViewerFile  <span class="gtkdoc opt">*</span>self<span class="gtkdoc opt">,</span>
+                 GError     <span class="gtkdoc opt">**</span>error<span class="gtkdoc opt">);</span>
+<span class="gtkdoc opt">}</span> ViewerFileClass<span class="gtkdoc opt">;</span>
-<span class="normal"><a href="gobject-Type-Information.html#GType">GType</a> </span>
-<span class="function">maman_bar_get_type</span><span class="normal"> </span><span class="symbol">(</span><span class="type">void</span><span class="symbol">)</span>
-<span class="cbracket">{</span>
-<span class="normal">  </span><span class="keyword">static</span><span class="normal"> </span><span class="usertype">GType</span><span class="normal"> type </span><span class="symbol">=</span><span class="normal"> </span><span class="number">0</span><span class="symbol">;</span>
-<span class="normal">  </span><span class="keyword">if</span><span class="normal"> </span><span class="symbol">(</span><span class="normal">type </span><span class="symbol">==</span><span class="normal"> </span><span class="number">0</span><span class="symbol">)</span><span class="normal"> </span><span class="cbracket">{</span>
-<span class="normal">    </span><span class="keyword">const</span><span class="normal"> </span><span class="usertype">GTypeInfo</span><span class="normal"> info </span><span class="symbol">=</span><span class="normal"> </span><span class="cbracket">{</span>
-<span class="normal">      </span><span class="keyword">sizeof</span><span class="normal"> </span><span class="symbol">(</span><span class="normal">MamanBarClass</span><span class="symbol">),</span>
-<span class="normal">      <a href="../glib/glib-Standard-Macros.html#NULL:CAPS">NULL</a></span><span class="symbol">,</span><span class="normal">           </span><span class="comment">/* base_init */</span>
-<span class="normal">      <a href="../glib/glib-Standard-Macros.html#NULL:CAPS">NULL</a></span><span class="symbol">,</span><span class="normal">           </span><span class="comment">/* base_finalize */</span>
-<span class="normal">      </span><span class="symbol">(</span><span class="normal"><a href="gobject-Type-Information.html#GClassInitFunc">GClassInitFunc</a></span><span class="symbol">)</span><span class="normal"> foo_class_init</span><span class="symbol">,</span>
-<span class="normal">      <a href="../glib/glib-Standard-Macros.html#NULL:CAPS">NULL</a></span><span class="symbol">,</span><span class="normal">           </span><span class="comment">/* class_finalize */</span>
-<span class="normal">      <a href="../glib/glib-Standard-Macros.html#NULL:CAPS">NULL</a></span><span class="symbol">,</span><span class="normal">           </span><span class="comment">/* class_data */</span>
-<span class="normal">      </span><span class="keyword">sizeof</span><span class="normal"> </span><span class="symbol">(</span><span class="normal">MamanBar</span><span class="symbol">),</span>
-<span class="normal">      </span><span class="number">0</span><span class="symbol">,</span><span class="normal">              </span><span class="comment">/* n_preallocs */</span>
-<span class="normal">      </span><span class="symbol">(</span><span class="normal"><a href="gobject-Type-Information.html#GInstanceInitFunc">GInstanceInitFunc</a></span><span class="symbol">)</span><span class="normal"> <a href="../glib/glib-Standard-Macros.html#NULL:CAPS">NULL</a> </span><span class="comment">/* instance_init */</span>
-<span class="normal">    </span><span class="cbracket">}</span><span class="symbol">;</span>
-<span class="normal">    type </span><span class="symbol">=</span><span class="normal"> </span><span class="function"><a href="gobject-Type-Information.html#g-type-register-static">g_type_register_static</a></span><span class="normal"> </span><span class="symbol">(</span><span class="normal"><a href="gobject-Type-Information.html#G-TYPE-OBJECT:CAPS">G_TYPE_OBJECT</a></span><span class="symbol">,</span>
-<span class="normal">                                   </span><span class="string">"BarType"</span><span class="symbol">,</span>
-<span class="normal">                                   </span><span class="symbol">&amp;</span><span class="normal">info</span><span class="symbol">,</span><span class="normal"> </span><span class="number">0</span><span class="symbol">);</span>
-<span class="normal">  </span><span class="cbracket">}</span>
-<span class="normal">  </span><span class="keyword">return</span><span class="normal"> type</span><span class="symbol">;</span>
-<span class="cbracket">}</span></pre></td>
+<span class="gtkdoc ppc">#define VIEWER_TYPE_FILE (viewer_file_get_type ())</span>
+GType
+<span class="function">viewer_file_get_type</span> <span class="gtkdoc opt">(</span><span class="gtkdoc kwb">void</span><span class="gtkdoc opt">)</span>
+<span class="gtkdoc opt">{</span>
+  <span class="gtkdoc kwb">static</span> GType type <span class="gtkdoc opt">=</span> <span class="number">0</span><span class="gtkdoc opt">;</span>
+  <span class="keyword">if</span> <span class="gtkdoc opt">(</span>type <span class="gtkdoc opt">==</span> <span class="number">0</span><span class="gtkdoc opt">) {</span>
+    <span class="gtkdoc kwb">const</span> GTypeInfo info <span class="gtkdoc opt">= {</span>
+      <span class="keyword">sizeof</span> <span class="gtkdoc opt">(</span>ViewerFileClass<span class="gtkdoc opt">),</span>
+      NULL<span class="gtkdoc opt">,</span>           <span class="comment">/* base_init */</span>
+      NULL<span class="gtkdoc opt">,</span>           <span class="comment">/* base_finalize */</span>
+      <span class="gtkdoc opt">(</span>GClassInitFunc<span class="gtkdoc opt">)</span> viewer_file_class_init<span class="gtkdoc opt">,</span>
+      NULL<span class="gtkdoc opt">,</span>           <span class="comment">/* class_finalize */</span>
+      NULL<span class="gtkdoc opt">,</span>           <span class="comment">/* class_data */</span>
+      <span class="keyword">sizeof</span> <span class="gtkdoc opt">(</span>ViewerFile<span class="gtkdoc opt">),</span>
+      <span class="number">0</span><span class="gtkdoc opt">,</span>              <span class="comment">/* n_preallocs */</span>
+      <span class="gtkdoc opt">(</span>GInstanceInitFunc<span class="gtkdoc opt">)</span> NULL <span class="comment">/* instance_init */</span>
+    <span class="gtkdoc opt">};</span>
+    type <span class="gtkdoc opt">=</span> <span class="function"><a href="gobject-Type-Information.html#g-type-register-static">g_type_register_static</a></span> <span class="gtkdoc opt">(</span>G_TYPE_OBJECT<span class="gtkdoc opt">,</span>
+                                   <span class="string">&quot;ViewerFile&quot;</span><span class="gtkdoc opt">,</span>
+                                   <span class="gtkdoc opt">&amp;</span>info<span class="gtkdoc opt">,</span> <span class="number">0</span><span class="gtkdoc opt">);</span>
+  <span class="gtkdoc opt">}</span>
+  <span class="keyword">return</span> type<span class="gtkdoc opt">;</span>
+<span class="gtkdoc opt">}</span></pre></td>
       </tr>
     </tbody>
   </table>
 </div>
 <p>
-          Upon the first call to <code class="function">maman_bar_get_type</code>, the type named
-          <span class="emphasis"><em>BarType</em></span> will be registered in the type system as inheriting
+          Upon the first call to <code class="function">viewer_file_get_type</code>, the type named
+          <span class="emphasis"><em>ViewerFile</em></span> will be registered in the type system as inheriting
           from the type <span class="emphasis"><em>G_TYPE_OBJECT</em></span>.
         </p>
 <p>
@@ -144,14 +162,14 @@
 6
 7
 8</pre></td>
-        <td class="listing_code"><pre class="programlisting"><span class="keyword">struct</span><span class="normal"> </span><span class="classname">_GTypeClass</span>
-<span class="cbracket">{</span>
-<span class="normal">  </span><span class="usertype">GType</span><span class="normal"> g_type</span><span class="symbol">;</span>
-<span class="cbracket">}</span><span class="symbol">;</span>
-<span class="keyword">struct</span><span class="normal"> </span><span class="classname">_GTypeInstance</span>
-<span class="cbracket">{</span>
-<span class="normal">  </span><span class="usertype">GTypeClass</span><span class="normal"> </span><span class="symbol">*</span><span class="normal">g_class</span><span class="symbol">;</span>
-<span class="cbracket">}</span><span class="symbol">;</span></pre></td>
+        <td class="listing_code"><pre class="programlisting"><span class="gtkdoc kwb">struct</span> _GTypeClass
+<span class="gtkdoc opt">{</span>
+  GType g_type<span class="gtkdoc opt">;</span>
+<span class="gtkdoc opt">};</span>
+<span class="gtkdoc kwb">struct</span> _GTypeInstance
+<span class="gtkdoc opt">{</span>
+  GTypeClass <span class="gtkdoc opt">*</span>g_class<span class="gtkdoc opt">;</span>
+<span class="gtkdoc opt">};</span></pre></td>
       </tr>
     </tbody>
   </table>
@@ -194,28 +212,28 @@
 22
 23</pre></td>
         <td class="listing_code"><pre class="programlisting"><span class="comment">/* A definitions */</span>
-<span class="keyword">typedef</span><span class="normal"> </span><span class="keyword">struct</span><span class="normal"> </span><span class="cbracket">{</span>
-<span class="normal">  </span><span class="usertype">GTypeInstance</span><span class="normal"> parent</span><span class="symbol">;</span>
-<span class="normal">  </span><span class="type">int</span><span class="normal"> field_a</span><span class="symbol">;</span>
-<span class="normal">  </span><span class="type">int</span><span class="normal"> field_b</span><span class="symbol">;</span>
-<span class="cbracket">}</span><span class="normal"> A</span><span class="symbol">;</span>
-<span class="keyword">typedef</span><span class="normal"> </span><span class="keyword">struct</span><span class="normal"> </span><span class="cbracket">{</span>
-<span class="normal">  </span><span class="usertype">GTypeClass</span><span class="normal"> parent_class</span><span class="symbol">;</span>
-<span class="normal">  </span><span class="type">void</span><span class="normal"> </span><span class="symbol">(*</span><span class="normal">method_a</span><span class="symbol">)</span><span class="normal"> </span><span class="symbol">(</span><span class="type">void</span><span class="symbol">);</span>
-<span class="normal">  </span><span class="type">void</span><span class="normal"> </span><span class="symbol">(*</span><span class="normal">method_b</span><span class="symbol">)</span><span class="normal"> </span><span class="symbol">(</span><span class="type">void</span><span class="symbol">);</span>
-<span class="cbracket">}</span><span class="normal"> AClass</span><span class="symbol">;</span>
+<span class="gtkdoc kwc">typedef</span> <span class="gtkdoc kwb">struct</span> <span class="gtkdoc opt">{</span>
+  GTypeInstance parent<span class="gtkdoc opt">;</span>
+  <span class="gtkdoc kwb">int</span> field_a<span class="gtkdoc opt">;</span>
+  <span class="gtkdoc kwb">int</span> field_b<span class="gtkdoc opt">;</span>
+<span class="gtkdoc opt">}</span> A<span class="gtkdoc opt">;</span>
+<span class="gtkdoc kwc">typedef</span> <span class="gtkdoc kwb">struct</span> <span class="gtkdoc opt">{</span>
+  GTypeClass parent_class<span class="gtkdoc opt">;</span>
+  <span class="gtkdoc kwb">void</span> <span class="gtkdoc opt">(*</span>method_a<span class="gtkdoc opt">) (</span><span class="gtkdoc kwb">void</span><span class="gtkdoc opt">);</span>
+  <span class="gtkdoc kwb">void</span> <span class="gtkdoc opt">(*</span>method_b<span class="gtkdoc opt">) (</span><span class="gtkdoc kwb">void</span><span class="gtkdoc opt">);</span>
+<span class="gtkdoc opt">}</span> AClass<span class="gtkdoc opt">;</span>
 <span class="comment">/* B definitions. */</span>
-<span class="keyword">typedef</span><span class="normal"> </span><span class="keyword">struct</span><span class="normal"> </span><span class="cbracket">{</span>
-<span class="normal">  </span><span class="usertype">A</span><span class="normal"> parent</span><span class="symbol">;</span>
-<span class="normal">  </span><span class="type">int</span><span class="normal"> field_c</span><span class="symbol">;</span>
-<span class="normal">  </span><span class="type">int</span><span class="normal"> field_d</span><span class="symbol">;</span>
-<span class="cbracket">}</span><span class="normal"> B</span><span class="symbol">;</span>
-<span class="keyword">typedef</span><span class="normal"> </span><span class="keyword">struct</span><span class="normal"> </span><span class="cbracket">{</span>
-<span class="normal">  </span><span class="usertype">AClass</span><span class="normal"> parent_class</span><span class="symbol">;</span>
-<span class="normal">  </span><span class="type">void</span><span class="normal"> </span><span class="symbol">(*</span><span class="normal">method_c</span><span class="symbol">)</span><span class="normal"> </span><span class="symbol">(</span><span class="type">void</span><span class="symbol">);</span>
-<span class="normal">  </span><span class="type">void</span><span class="normal"> </span><span class="symbol">(*</span><span class="normal">method_d</span><span class="symbol">)</span><span class="normal"> </span><span class="symbol">(</span><span class="type">void</span><span class="symbol">);</span>
-<span class="cbracket">}</span><span class="normal"> BClass</span><span class="symbol">;</span></pre></td>
+<span class="gtkdoc kwc">typedef</span> <span class="gtkdoc kwb">struct</span> <span class="gtkdoc opt">{</span>
+  A parent<span class="gtkdoc opt">;</span>
+  <span class="gtkdoc kwb">int</span> field_c<span class="gtkdoc opt">;</span>
+  <span class="gtkdoc kwb">int</span> field_d<span class="gtkdoc opt">;</span>
+<span class="gtkdoc opt">}</span> B<span class="gtkdoc opt">;</span>
+<span class="gtkdoc kwc">typedef</span> <span class="gtkdoc kwb">struct</span> <span class="gtkdoc opt">{</span>
+  AClass parent_class<span class="gtkdoc opt">;</span>
+  <span class="gtkdoc kwb">void</span> <span class="gtkdoc opt">(*</span>method_c<span class="gtkdoc opt">) (</span><span class="gtkdoc kwb">void</span><span class="gtkdoc opt">);</span>
+  <span class="gtkdoc kwb">void</span> <span class="gtkdoc opt">(*</span>method_d<span class="gtkdoc opt">) (</span><span class="gtkdoc kwb">void</span><span class="gtkdoc opt">);</span>
+<span class="gtkdoc opt">}</span> BClass<span class="gtkdoc opt">;</span></pre></td>
       </tr>
     </tbody>
   </table>
@@ -225,7 +243,8 @@
           The C standard mandates that the first field of a C structure is stored starting
           in the first byte of the buffer used to hold the structure's fields in memory.
           This means that the first field of an instance of an object B is A's first field
-          which in turn is GTypeInstance's first field which in turn is g_class, a pointer
+          which in turn is <span class="type">GTypeInstance</span>'s first field which in
+          turn is <em class="structfield"><code>g_class</code></em>, a pointer
           to B's class structure.
         </p>
 <p>
@@ -238,8 +257,8 @@
       <tr>
         <td class="listing_lines" align="right"><pre>1
 2</pre></td>
-        <td class="listing_code"><pre class="programlisting"><span class="usertype">B</span><span class="normal"> </span><span class="symbol">*</span><span class="normal">b</span><span class="symbol">;</span>
-<span class="normal">b</span><span class="symbol">-&gt;</span><span class="normal">parent</span><span class="symbol">.</span><span class="normal">parent</span><span class="symbol">.</span><span class="normal">g_class</span><span class="symbol">-&gt;</span><span class="normal">g_type</span></pre></td>
+        <td class="listing_code"><pre class="programlisting">B <span class="gtkdoc opt">*</span>b<span class="gtkdoc opt">;</span>
+b<span class="gtkdoc opt">-&gt;</span>parent<span class="gtkdoc opt">.</span>parent<span class="gtkdoc opt">.</span>g_class<span class="gtkdoc opt">-&gt;</span>g_type</pre></td>
       </tr>
     </tbody>
   </table>
@@ -254,8 +273,8 @@
       <tr>
         <td class="listing_lines" align="right"><pre>1
 2</pre></td>
-        <td class="listing_code"><pre class="programlisting"><span class="usertype">B</span><span class="normal"> </span><span class="symbol">*</span><span class="normal">b</span><span class="symbol">;</span>
-<span class="symbol">((</span><span class="normal"><a href="gobject-Type-Information.html#GTypeInstance">GTypeInstance</a></span><span class="symbol">*)</span><span class="normal">b</span><span class="symbol">)-&gt;</span><span class="normal">g_class</span><span class="symbol">-&gt;</span><span class="normal">g_type</span></pre></td>
+        <td class="listing_code"><pre class="programlisting">B <span class="gtkdoc opt">*</span>b<span class="gtkdoc opt">;</span>
+<span class="gtkdoc opt">((</span>GTypeInstance <span class="gtkdoc opt">*)</span> b<span class="gtkdoc opt">)-&gt;</span>g_class<span class="gtkdoc opt">-&gt;</span>g_type</pre></td>
       </tr>
     </tbody>
   </table>
@@ -268,25 +287,11 @@
 <a name="gtype-instantiable-classed-init-done"></a>Initialization and Destruction</h3></div></div></div>
 <p>
             instantiation of these types can be done with
-            <code class="function"><a class="link" href="gobject-Type-Information.html#g-type-create-instance" title="g_type_create_instance ()">g_type_create_instance</a></code>:
-</p>
-<div class="informalexample">
-  <table class="listing_frame" border="0" cellpadding="0" cellspacing="0">
-    <tbody>
-      <tr>
-        <td class="listing_lines" align="right"><pre>1
-2</pre></td>
-        <td class="listing_code"><pre class="programlisting"><span class="normal"><a href="gobject-Type-Information.html#GTypeInstance">GTypeInstance</a></span><span class="symbol">*</span><span class="normal"> </span><span class="function"><a href="gobject-Type-Information.html#g-type-create-instance">g_type_create_instance</a></span><span class="normal"> </span><span class="symbol">(</span><span class="usertype">GType</span><span class="normal">          type</span><span class="symbol">);</span>
-<span class="type">void</span><span class="normal">           </span><span class="function"><a href="gobject-Type-Information.html#g-type-free-instance">g_type_free_instance</a></span><span class="normal">   </span><span class="symbol">(</span><span class="usertype">GTypeInstance</span><span class="normal"> </span><span class="symbol">*</span><span class="normal">instance</span><span class="symbol">);</span></pre></td>
-      </tr>
-    </tbody>
-  </table>
-</div>
-<p>
-            <code class="function"><a class="link" href="gobject-Type-Information.html#g-type-create-instance" title="g_type_create_instance ()">g_type_create_instance</a></code> will look up the type information
-            structure associated to the type requested. Then, the instance size and instantiation
-            policy (if the n_preallocs field is set to a non-zero value, the type system allocates
+            <code class="function"><a class="link" href="gobject-Type-Information.html#g-type-create-instance" title="g_type_create_instance ()">g_type_create_instance</a></code>,
+            which will look up the type information
+            structure associated with the type requested. Then, the instance size and instantiation
+            policy (if the <em class="structfield"><code>n_preallocs</code></em> field is set
+            to a non-zero value, the type system allocates
             the object's instance structures in chunks rather than mallocing for every instance)
             declared by the user are used to get a buffer to hold the object's instance
             structure.
@@ -297,8 +302,9 @@
             class structure (ie: the embedded parent class structure) is initialized by copying the contents from
             the class structure of the parent class. The rest of class structure is initialized to zero.  If there
             is no parent, the entire class structure is initialized to zero. The type system then invokes the
-            base_class_initialization functions (<a class="link" href="gobject-Type-Information.html#GBaseInitFunc" title="GBaseInitFunc ()"><span class="type">GBaseInitFunc</span></a>) from topmost
-            fundamental object to bottom-most most derived object. The object's class_init
+            <code class="function">base_class_initialization</code> functions
+            (<a class="link" href="gobject-Type-Information.html#GBaseInitFunc" title="GBaseInitFunc ()"><span class="type">GBaseInitFunc</span></a>) from topmost
+            fundamental object to bottom-most most derived object. The object's <code class="function">class_init</code>
             (<a class="link" href="gobject-Type-Information.html#GClassInitFunc" title="GClassInitFunc ()"><span class="type">GClassInitFunc</span></a>) function is invoked afterwards to complete
             initialization of the class structure.
             Finally, the object's interfaces are initialized (we will discuss interface initialization
@@ -307,8 +313,10 @@
 <p>
             Once the type system has a pointer to an initialized class structure, it sets the object's
             instance class pointer to the object's class structure and invokes the object's
-            instance_init (<a class="link" href="gobject-Type-Information.html#GInstanceInitFunc" title="GInstanceInitFunc ()"><span class="type">GInstanceInitFunc</span></a>)functions, from top-most fundamental
-            type to bottom-most most derived type.
+            <code class="function">instance_init</code>
+            (<a class="link" href="gobject-Type-Information.html#GInstanceInitFunc" title="GInstanceInitFunc ()"><span class="type">GInstanceInitFunc</span></a>)
+            functions, from top-most fundamental
+            type to bottom-most most-derived type.
           </p>
 <p>
             Object instance destruction through <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 very simple:
@@ -326,15 +334,15 @@
             the class structure is freed.
           </p>
 <p>
-            As many readers have now understood it, the base initialization/finalization process is
+            The base initialization/finalization process is
             very similar to the C++ constructor/destructor paradigm. The practical details are different
             though and it is important not to get confused by superficial similarities.
             GTypes have no instance destruction mechanism. It is
             the user's responsibility to implement correct destruction semantics on top
-            of the existing GType code. (this is what GObject does. See
-            <a class="xref" href="chapter-gobject.html" title="The GObject base class"><i>The GObject base class</i></a>)
-           Furthermore, C++ code equivalent to the base_init
-           and class_init callbacks of GType is usually not needed because C++ cannot really create object
+            of the existing GType code. (This is what GObject does: see
+            <a class="xref" href="chapter-gobject.html" title="The GObject base class"><i>The GObject base class</i></a>.)
+           Furthermore, C++ code equivalent to the <code class="function">base_init</code>
+           and <code class="function">class_init</code> callbacks of GType is usually not needed because C++ cannot really create object
            types at runtime.
           </p>
 <p>
@@ -342,7 +350,7 @@
             </p>
 <div class="table">
 <a name="gtype-init-fini-table"></a><p class="title"><b>Table 1. GType Instantiation/Finalization</b></p>
-<div class="table-contents"><table summary="GType Instantiation/Finalization" border="1">
+<div class="table-contents"><table class="table" summary="GType Instantiation/Finalization" border="1">
 <colgroup>
 <col align="left">
 <col align="left">
@@ -350,18 +358,18 @@
 </colgroup>
 <thead><tr>
 <th align="left">Invocation time</th>
-<th align="left">Function Invoked</th>
+<th align="left">Function invoked</th>
 <th align="left">Function's parameters</th>
 </tr></thead>
 <tbody>
 <tr>
 <td rowspan="3" align="left">First call to <code class="function"><a class="link" href="gobject-Type-Information.html#g-type-create-instance" title="g_type_create_instance ()">g_type_create_instance</a></code> for target type</td>
-<td align="left">type's base_init function</td>
+<td align="left">type's <code class="function">base_init</code> 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>
+                      <code class="function">base_init</code> is invoked once for each class structure.</td>
 </tr>
 <tr>
-<td align="left">target type's class_init function</td>
+<td align="left">target type's <code class="function">class_init</code> function</td>
 <td align="left">On target type's class structure</td>
 </tr>
 <tr>
@@ -372,7 +380,7 @@
 </tr>
 <tr>
 <td align="left">Each call to <code class="function"><a class="link" href="gobject-Type-Information.html#g-type-create-instance" title="g_type_create_instance ()">g_type_create_instance</a></code> for target type</td>
-<td align="left">target type's instance_init function</td>
+<td align="left">target type's <code class="function">instance_init</code> function</td>
 <td align="left">On object's instance</td>
 </tr>
 <tr>
@@ -383,13 +391,13 @@
 <td align="left"> </td>
 </tr>
 <tr>
-<td align="left">target type's class_finalize function</td>
+<td align="left">target type's <code class="function">class_finalize</code> function</td>
 <td align="left">On target type's class structure</td>
 </tr>
 <tr>
-<td align="left">type's base_finalize function</td>
+<td align="left">type's <code class="function">base_finalize</code> function</td>
 <td align="left">On the inheritance tree of classes from fundamental type to target type.
-                      base_finalize is invoked once for each class structure.</td>
+                      <code class="function">base_finalize</code> is invoked once for each class structure.</td>
 </tr>
 </tbody>
 </table></div>
@@ -399,7 +407,6 @@
 </div>
 </div>
 <div class="footer">
-<hr>
-          Generated by GTK-Doc V1.21.1</div>
+<hr>Generated by GTK-Doc V1.24</div>
 </body>
 </html>