RubyGems - pango - Versions diffs - 0.90.2-x86-mingw32 - Mend

pango 0.90.2-x86-mingw32

Files changed (1441) hide show

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

@@ -0,0 +1,143 @@
+<!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.14 (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" title="Conventions">
+<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="id529029" href="#ftn.id529029" 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" title="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.id529029" href="#id529029" 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.14</div>
+</body>
+</html>

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

@@ -0,0 +1,287 @@
+<!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.14 (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" title="Instantiable classed types: objects">
+<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" title="Initialization and Destruction">
+<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.14</div>
+</body>
+</html>

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

@@ -0,0 +1,316 @@
+<!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.14 (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" title="Non-instantiable classed types: interfaces">
+<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" title="Interface Initialization">
+<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" title="Interface Destruction">
+<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.14</div>
+</body>
+</html>