RubyGems - gio2 - Versions diffs - 0.90.5-x86-mingw32 → 0.90.6-x86-mingw32 - Mend

gio2 0.90.5-x86-mingw32 → 0.90.6-x86-mingw32

Files changed (830) hide show

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

@@ -1,143 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
-<html>
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
-<title>Conventions</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-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.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-gtype.html"><img src="left.png" width="24" height="24" border="0" alt="Prev"></a></td>
-<td><a accesskey="u" href="chapter-gtype.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="gtype-non-instantiable.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="gtype-conventions"></a>Conventions</h2></div></div></div>
-<p>
-        There are a number of conventions users are expected to follow when creating new types
-        which are to be exported in a header file:
-        </p>
-<div class="itemizedlist"><ul class="itemizedlist" type="disc">
-<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>.
-          </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>,
-            <sup>[<a name="id365787" href="#ftn.id365787" class="footnote">3</a>]</sup>
-            prefix all your function names with <span class="emphasis"><em>maman_</em></span>.
-            For example: <code class="function">maman_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/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).
-          </p></li>
-</ul></div>
-<p>
-        The implementation of these macros is pretty straightforward: a number of simple-to-use
-        macros are provided in <code class="filename">gtype.h</code>. For the example we used above, we would
-        write the following trivial code to declare the macros:
-</p>
-<pre class="programlisting">
-#define MAMAN_TYPE_BAR                  (maman_bar_get_type ())
-#define MAMAN_BAR(obj)                  (G_TYPE_CHECK_INSTANCE_CAST ((obj), MAMAN_TYPE_BAR, MamanBar))
-#define MAMAN_BAR_CLASS(klass)          (G_TYPE_CHECK_CLASS_CAST ((klass), MAMAN_TYPE_BAR, MamanBarClass))
-#define MAMAN_IS_BAR(obj)          (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MAMAN_TYPE_BAR))
-#define MAMAN_IS_BAR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MAMAN_TYPE_BAR))
-#define MAMAN_BAR_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), MAMAN_TYPE_BAR, MamanBarClass))
-</pre>
-<p>
-        </p>
-<div class="note" style="margin-left: 0.5in; margin-right: 0.5in;">
-<h3 class="title">Note</h3>
-<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>
-<p>
-        The following code shows how to implement the <code class="function">maman_bar_get_type</code>
-        function:
-</p>
-<pre class="programlisting">
-GType maman_bar_get_type (void)
-{
-  static GType type = 0;
-  if (type == 0) {
-    static const GTypeInfo info = {
-      /* You fill this structure. */
-    };
-    type = g_type_register_static (G_TYPE_OBJECT,
-                                   "MamanBarType",
-                                   &amp;info, 0);
-  }
-  return type;
-}
-</pre>
-<p>
-      </p>
-<p>
-        When having no special requirements you also can use the <code class="function">G_DEFINE_TYPE</code>
-	macro:
-</p>
-<pre class="programlisting">
-G_DEFINE_TYPE (MamanBar, maman_bar, G_TYPE_OBJECT)
-</pre>
-<p>
-      </p>
-<div class="footnotes">
-<br><hr width="100" align="left">
-<div class="footnote"><p><sup>[<a name="ftn.id365787" href="#id365787" class="para">3</a>] </sup>
-                <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.15.1</div>
-</body>
-</html>

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

@@ -1,287 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
-<html>
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
-<title>Instantiable classed types: objects</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-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.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="gtype-non-instantiable.html"><img src="left.png" width="24" height="24" border="0" alt="Prev"></a></td>
-<td><a accesskey="u" href="chapter-gtype.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="gtype-non-instantiable-classed.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="gtype-instantiable-classed"></a>Instantiable classed types: objects</h2></div></div></div>
-<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>.
-          Although <span class="type"><a class="link" href="gobject-The-Base-Object-Type.html#GObject">GObject</a></span>s (detailed in <a class="xref" href="chapter-gobject.html" title="The GObject base class"><i>The GObject base class</i></a>)
-          are the most well known type of instantiable
-          classed types, other kinds of similar objects used as the base of an inheritance
-          hierarchy have been externally developed and they are all built on the fundamental
-          features described below.
-        </p>
-<p>
-          For example, the code below shows how you could register
-          such a fundamental object type in the type system:
-</p>
-<pre class="programlisting">
-typedef struct {
-  GObject parent;
-  /* instance members */
-  int field_a;
-} MamanBar;
-typedef struct {
-  GObjectClass parent;
-  /* class members */
-  void (*do_action_public_virtual) (MamanBar *self, guint8 i);
-  void (*do_action_public_pure_virtual) (MamanBar *self, guint8 i);
-} MamanBarClass;
-#define MAMAN_TYPE_BAR (maman_bar_get_type ())
-GType
-maman_bar_get_type (void)
-{
-  static GType type = 0;
-  if (type == 0) {
-    static const GTypeInfo info = {
-      sizeof (MamanBarClass),
-      NULL,           /* base_init */
-      NULL,           /* base_finalize */
-      (GClassInitFunc) foo_class_init,
-      NULL,           /* class_finalize */
-      NULL,           /* class_data */
-      sizeof (MamanBar),
-      0,              /* n_preallocs */
-      (GInstanceInitFunc) NULL /* instance_init */
-    };
-    type = g_type_register_static (G_TYPE_OBJECT,
-                                   "BarType",
-                                   &amp;info, 0);
-  }
-  return type;
-}
-</pre>
-<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
-          from the type <span class="emphasis"><em>G_TYPE_OBJECT</em></span>.
-        </p>
-<p>
-          Every object must define two structures: its class structure and its
-          instance structure. All class structures must contain as first member
-          a <span class="type"><a class="link" href="gobject-Type-Information.html#GTypeClass" title="GTypeClass">GTypeClass</a></span> structure. All instance structures must contain as first
-          member a <span class="type"><a class="link" href="gobject-Type-Information.html#GTypeInstance" title="GTypeInstance">GTypeInstance</a></span> structure. The declaration of these C types,
-          coming from <code class="filename">gtype.h</code> is shown below:
-</p>
-<pre class="programlisting">
-struct _GTypeClass
-{
-  GType g_type;
-};
-struct _GTypeInstance
-{
-  GTypeClass *g_class;
-};
-</pre>
-<p>
-          These constraints allow the type system to make sure that every object instance
-          (identified by a pointer to the object's instance structure) contains in its
-          first bytes a pointer to the object's class structure.
-        </p>
-<p>
-          This relationship is best explained by an example: let's take object B which
-          inherits from object A:
-</p>
-<pre class="programlisting">
-/* A definitions */
-typedef struct {
-  GTypeInstance parent;
-  int field_a;
-  int field_b;
-} A;
-typedef struct {
-  GTypeClass parent_class;
-  void (*method_a) (void);
-  void (*method_b) (void);
-} AClass;
-/* B definitions. */
-typedef struct {
-  A parent;
-  int field_c;
-  int field_d;
-} B;
-typedef struct {
-  AClass parent_class;
-  void (*method_c) (void);
-  void (*method_d) (void);
-} BClass;
-</pre>
-<p>
-          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
-          to B's class structure.
-        </p>
-<p>
-          Thanks to these simple conditions, it is possible to detect the type of every
-          object instance by doing:
-</p>
-<pre class="programlisting">
-B *b;
-b-&gt;parent.parent.g_class-&gt;g_type
-</pre>
-<p>
-          or, more quickly:
-</p>
-<pre class="programlisting">
-B *b;
-((GTypeInstance*)b)-&gt;g_class-&gt;g_type
-</pre>
-<p>
-        </p>
-<div class="sect2">
-<div class="titlepage"><div><div><h3 class="title">
-<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>
-<pre class="programlisting">
-GTypeInstance* g_type_create_instance (GType          type);
-void           g_type_free_instance   (GTypeInstance *instance);
-</pre>
-<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
-            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.
-          </p>
-<p>
-            If this is the first instance of the object ever created, the type system must create
-            a class structure: it allocates a buffer to hold the object's class structure and
-            initializes it. It first copies the parent's class structure over this structure
-            (if there is no parent, it initializes it to zero). It then invokes the
-            base_class_initialization functions (<span class="type"><a class="link" href="gobject-Type-Information.html#GBaseInitFunc" title="GBaseInitFunc ()">GBaseInitFunc</a></span>) from topmost
-            fundamental object to bottom-most most derived object. The object's class_init
-            (<span class="type"><a class="link" href="gobject-Type-Information.html#GClassInitFunc" title="GClassInitFunc ()">GClassInitFunc</a></span>) function is invoked afterwards to complete
-            initialization of the class structure.
-            Finally, the object's interfaces are initialized (we will discuss interface initialization
-            in more detail later).
-          </p>
-<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 (<span class="type"><a class="link" href="gobject-Type-Information.html#GInstanceInitFunc" title="GInstanceInitFunc ()">GInstanceInitFunc</a></span>)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:
-            the instance structure is returned to the instance pool if there is one and if this was the
-            last living instance of the object, the class is destroyed.
-          </p>
-<p>
-            Class destruction (the concept of destruction is sometimes partly
-            referred to as finalization in GType) is the symmetric process of
-            the initialization: interfaces are destroyed first.
-            Then, the most derived
-            class_finalize (<span class="type">ClassFinalizeFunc</span>) function is invoked. The
-            base_class_finalize (<span class="type"><a class="link" href="gobject-Type-Information.html#GBaseFinalizeFunc" title="GBaseFinalizeFunc ()">GBaseFinalizeFunc</a></span>) functions are
-            Finally invoked from bottom-most most-derived type to top-most fundamental type and
-            the class structure is freed.
-          </p>
-<p>
-            As many readers have now understood it, 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
-           types at runtime.
-          </p>
-<p>
-            The instantiation/finalization process can be summarized as follows:
-            </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">
-<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>
-</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">On the inheritance tree of classes from fundamental type to target type.
-                      base_init is invoked once for each class structure.</td>
-</tr>
-<tr>
-<td align="left">target type's class_init function</td>
-<td align="left">On target type's class structure</td>
-</tr>
-<tr>
-<td align="left">interface initialization, see
-                      <a class="xref" href="gtype-non-instantiable-classed.html#gtype-non-instantiable-classed-init" title="Interface Initialization">the section called “Interface Initialization”</a>
-</td>
-<td align="left"> </td>
-</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">On object's instance</td>
-</tr>
-<tr>
-<td rowspan="3" align="left">Last call to <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> for target type</td>
-<td align="left">interface destruction, see
-                      <a class="xref" href="gtype-non-instantiable-classed.html#gtype-non-instantiable-classed-dest" title="Interface Destruction">the section called “Interface Destruction”</a>
-</td>
-<td align="left"> </td>
-</tr>
-<tr>
-<td align="left">target type's class_finalize 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">On the inheritance tree of classes from fundamental type to target type.
-                      base_finalize is invoked once for each class structure.</td>
-</tr>
-</tbody>
-</table></div>
-</div>
-<p><br class="table-break">
-          </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/gtype-non-instantiable-classed.html DELETED

@@ -1,316 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
-<html>
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
-<title>Non-instantiable classed types: interfaces</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-gtype.html" title="The GLib Dynamic Type System">
-<link rel="prev" href="gtype-instantiable-classed.html" title="Instantiable classed types: objects">
-<link rel="next" href="chapter-gobject.html" title="The GObject base class">
-<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="gtype-instantiable-classed.html"><img src="left.png" width="24" height="24" border="0" alt="Prev"></a></td>
-<td><a accesskey="u" href="chapter-gtype.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-gobject.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="gtype-non-instantiable-classed"></a>Non-instantiable classed types: interfaces</h2></div></div></div>
-<p>
-          GType's interfaces are very similar to Java's interfaces. They allow
-          to describe a common API that several classes will adhere to.
-          Imagine the play, pause and stop buttons on hi-fi equipment - those can
-          be seen as a playback interface. Once you know what they do, you can
-          control your CD player, MP3 player or anything that uses these symbols.
-          To declare an interface you have to register a non-instantiable
-          classed type which derives from
-          <span class="type"><a class="link" href="gobject-Type-Information.html#GTypeInterface" title="GTypeInterface">GTypeInterface</a></span>. The following piece of code declares such an interface.
-</p>
-<pre class="programlisting">
-#define MAMAN_IBAZ_TYPE                (maman_ibaz_get_type ())
-#define MAMAN_IBAZ(obj)                (G_TYPE_CHECK_INSTANCE_CAST ((obj), MAMAN_IBAZ_TYPE, MamanIbaz))
-#define MAMAN_IS_IBAZ(obj)             (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MAMAN_IBAZ_TYPE))
-#define MAMAN_IBAZ_GET_INTERFACE(inst) (G_TYPE_INSTANCE_GET_INTERFACE ((inst), MAMAN_IBAZ_TYPE, MamanIbazInterface))
-typedef struct _MamanIbaz MamanIbaz; /* dummy object */
-typedef struct _MamanIbazInterface MamanIbazInterface;
-struct _MamanIbazInterface {
-  GTypeInterface parent;
-  void (*do_action) (MamanIbaz *self);
-};
-GType maman_ibaz_get_type (void);
-void maman_ibaz_do_action (MamanIbaz *self);
-</pre>
-<p>
-          The interface function, <code class="function">maman_ibaz_do_action</code> is implemented
-          in a pretty simple way:
-</p>
-<pre class="programlisting">
-void maman_ibaz_do_action (MamanIbaz *self)
-{
-  MAMAN_IBAZ_GET_INTERFACE (self)-&gt;do_action (self);
-}
-</pre>
-<p>
-         <code class="function">maman_ibaz_get_type</code> registers a type named <span class="emphasis"><em>MamanIBaz</em></span>
-         which inherits from G_TYPE_INTERFACE. All interfaces must be children of G_TYPE_INTERFACE in the
-         inheritance tree.
-        </p>
-<p>
-          An interface is defined by only one structure which must contain as first member
-          a <span class="type"><a class="link" href="gobject-Type-Information.html#GTypeInterface" title="GTypeInterface">GTypeInterface</a></span> structure. The interface structure is expected to
-          contain the function pointers of the interface methods. It is good style to
-          define helper functions for each of the interface methods which simply call
-          the interface' method directly: <code class="function">maman_ibaz_do_action</code>
-          is one of these.
-        </p>
-<p>
-          Once an interface type is registered, you must register implementations for these
-          interfaces. The function named <code class="function">maman_baz_get_type</code> registers
-          a new GType named MamanBaz which inherits from <span class="type"><a class="link" href="gobject-The-Base-Object-Type.html#GObject">GObject</a></span> and which
-          implements the interface <span class="type">MamanIBaz</span>.
-</p>
-<pre class="programlisting">
-static void maman_baz_do_action (MamanIbaz *self)
-{
-  g_print ("Baz implementation of IBaz interface Action.\n");
-}
-static void
-baz_interface_init (gpointer         g_iface,
-                    gpointer         iface_data)
-{
-  MamanIbazInterface *iface = (MamanIbazInterface *)g_iface;
-  iface-&gt;do_action = maman_baz_do_action;
-}
-GType
-maman_baz_get_type (void)
-{
-  static GType type = 0;
-  if (type == 0) {
-    static const GTypeInfo info = {
-      sizeof (MamanBazInterface),
-      NULL,   /* base_init */
-      NULL,   /* base_finalize */
-      NULL,   /* class_init */
-      NULL,   /* class_finalize */
-      NULL,   /* class_data */
-      sizeof (MamanBaz),
-      0,      /* n_preallocs */
-      NULL    /* instance_init */
-    };
-    static const GInterfaceInfo ibaz_info = {
-      (GInterfaceInitFunc) baz_interface_init,    /* interface_init */
-      NULL,               /* interface_finalize */
-      NULL          /* interface_data */
-    };
-    type = g_type_register_static (G_TYPE_OBJECT,
-                                   "MamanBazType",
-                                   &amp;info, 0);
-    g_type_add_interface_static (type,
-                                 MAMAN_IBAZ_TYPE,
-                                 &amp;ibaz_info);
-  }
-  return type;
-}
-</pre>
-<p>
-        </p>
-<p>
-          <code class="function"><a class="link" href="gobject-Type-Information.html#g-type-add-interface-static" title="g_type_add_interface_static ()">g_type_add_interface_static</a></code> records in the type system that
-          a given type implements also <span class="type">FooInterface</span>
-          (<code class="function">foo_interface_get_type</code> returns the type of
-          <span class="type">FooInterface</span>).
-                The <span class="type"><a class="link" href="gobject-Type-Information.html#GInterfaceInfo" title="GInterfaceInfo">GInterfaceInfo</a></span> structure holds
-          information about the implementation of the interface:
-</p>
-<pre class="programlisting">
-struct _GInterfaceInfo
-{
-  GInterfaceInitFunc     interface_init;
-  GInterfaceFinalizeFunc interface_finalize;
-  gpointer               interface_data;
-};
-</pre>
-<p>
-        </p>
-<p>
-        When having no special requirements you also can use the <code class="function">G_DEFINE_INTERFACE</code> macro:
-</p>
-<pre class="programlisting">
-G_DEFINE_INTERFACE (MamanBaz, maman_baz, G_TYPE_OBJECT)
-</pre>
-<p>
-        </p>
-<div class="sect2">
-<div class="titlepage"><div><div><h3 class="title">
-<a name="gtype-non-instantiable-classed-init"></a>Interface Initialization</h3></div></div></div>
-<p>
-            When an instantiable classed type which registered an interface
-            implementation is created for the first time, its class structure
-            is initialized following the process
-            described in <a class="xref" href="gtype-instantiable-classed.html" title="Instantiable classed types: objects">the section called “Instantiable classed types: objects”</a>.
-            After that, the interface implementations associated with
-            the type are initialized.
-          </p>
-<p>
-            First a memory buffer is allocated to hold the interface structure. The parent's
-            interface structure is then copied over to the new interface structure (the parent
-            interface is already initialized at that point). If there is no parent interface,
-            the interface structure is initialized with zeros. The g_type and the g_instance_type
-            fields are then initialized: g_type is set to the type of the most-derived interface
-            and g_instance_type is set to the type of the most derived type which implements
-            this interface.
-          </p>
-<p>
-            Finally, the interface' most-derived <code class="function">base_init</code> function and then
-            the implementation's <code class="function">interface_init</code>
-            function are invoked. It is important to understand that if there are multiple
-            implementations of an interface the <code class="function">base_init</code> and
-            <code class="function">interface_init</code> functions will be
-            invoked once for each implementation initialized.
-          </p>
-<p>
-            It is thus common for base_init functions to hold a local static boolean variable
-            which makes sure that the interface type is initialized only once even if there are
-            multiple implementations of the interface:
-</p>
-<pre class="programlisting">
-static void
-maman_ibaz_base_init (gpointer g_iface)
-{
-  static gboolean initialized = FALSE;
-  if (!initialized) {
-    /* create interface signals here. */
-    initialized = TRUE;
-  }
-}
-</pre>
-<p>
-          </p>
-<p>
-          If you have found the stuff about interface hairy, you are right: it is hairy but
-          there is not much I can do about it. What I can do is summarize what you need to know
-          about interfaces:
-        </p>
-<p>
-            The above process can be summarized as follows:
-          </p>
-<div class="table">
-<a name="ginterface-init-table"></a><p class="title"><b>Table 2. Interface Initialization</b></p>
-<div class="table-contents"><table summary="Interface Initialization" 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">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 type
-                    implementing interface
-                   </td>
-<td align="left">interface' base_init function</td>
-<td align="left">On interface' vtable</td>
-<td>Register interface' signals here (use a local static
-                    boolean variable as described above to make sure not to register them
-                    twice.).</td>
-</tr>
-<tr>
-<td align="left">interface' interface_init function</td>
-<td align="left">On interface' vtable</td>
-<td>
-                    Initialize interface' implementation. That is, initialize the interface
-                    method pointers in the interface structure to the function's implementation.
-                  </td>
-</tr>
-</tbody>
-</table></div>
-</div>
-<p><br class="table-break">
-          It is highly unlikely (i.e. I do not know of <span class="emphasis"><em>anyone</em></span> who actually
-          used it) you will ever need other more fancy things such as the ones described in the
-          following section (<a class="xref" href="gtype-non-instantiable-classed.html#gtype-non-instantiable-classed-dest" title="Interface Destruction">the section called “Interface Destruction”</a>).
-        </p>
-</div>
-<div class="sect2">
-<div class="titlepage"><div><div><h3 class="title">
-<a name="gtype-non-instantiable-classed-dest"></a>Interface Destruction</h3></div></div></div>
-<p>
-            When the last instance of an instantiable type which registered
-            an interface implementation is destroyed, the interface's
-            implementations associated to the type are destroyed.
-          </p>
-<p>
-            To destroy an interface implementation, GType first calls the
-            implementation's <code class="function">interface_finalize</code> function
-            and then the interface's most-derived
-            <code class="function">base_finalize</code> function.
-          </p>
-<p>
-            Again, it is important to understand, as in
-            <a class="xref" href="gtype-non-instantiable-classed.html#gtype-non-instantiable-classed-init" title="Interface Initialization">the section called “Interface Initialization”</a>,
-              that both <code class="function">interface_finalize</code> and <code class="function">base_finalize</code>
-              are invoked exactly once for the destruction of each implementation of an interface. Thus,
-              if you were to use one of these functions, you would need to use a static integer variable
-              which would hold the number of instances of implementations of an interface such that
-              the interface's class is destroyed only once (when the integer variable reaches zero).
-          </p>
-<p>
-          The above process can be summarized as follows:
-          </p>
-<div class="table">
-<a name="ginterface-fini-table"></a><p class="title"><b>Table 3. Interface Finalization</b></p>
-<div class="table-contents"><table summary="Interface Finalization" 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>
-</tr></thead>
-<tbody>
-<tr>
-<td rowspan="2" align="left">Last call to <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> for type
-                    implementing interface
-                   </td>
-<td align="left">interface' interface_finalize function</td>
-<td align="left">On interface' vtable</td>
-</tr>
-<tr>
-<td align="left">interface' base_finalize function</td>
-<td align="left">On interface' vtable</td>
-</tr>
-</tbody>
-</table></div>
-</div>
-<p><br class="table-break">
-        </p>
-</div>
-</div>
-<div class="footer">
-<hr>
-          Generated by GTK-Doc V1.15.1</div>
-</body>
-</html>