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

atk 0.90.2-x86-mingw32

Files changed (849) hide show

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>

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

@@ -0,0 +1,76 @@
+<!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 non-classed fundamental types</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-conventions.html" title="Conventions">
+<link rel="next" href="gtype-instantiable-classed.html" title="Instantiable classed types: objects">
+<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-conventions.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-instantiable-classed.html"><img src="right.png" width="24" height="24" border="0" alt="Next"></a></td>
+</tr></table>
+<div class="sect1" title="Non-instantiable non-classed fundamental types">
+<div class="titlepage"><div><div><h2 class="title" style="clear: both">
+<a name="gtype-non-instantiable"></a>Non-instantiable non-classed fundamental types</h2></div></div></div>
+<p>
+          A lot of types are not instantiable by the type system and do not have
+          a class. Most of these types are fundamental trivial types such as <span class="emphasis"><em>gchar</em></span>,
+          registered in <code class="function">g_value_types_init</code> (in <code class="filename">gvaluetypes.c</code>).
+        </p>
+<p>
+          To register such a type in the type system, you just need to fill the
+          <span class="type"><a class="link" href="gobject-Type-Information.html#GTypeInfo" title="GTypeInfo">GTypeInfo</a></span> structure with zeros since these types are also most of the time
+          fundamental:
+          </p>
+<pre class="programlisting">
+  GTypeInfo info = {
+    0,                                /* class_size */
+    NULL,                        /* base_init */
+    NULL,                        /* base_destroy */
+    NULL,                        /* class_init */
+    NULL,                        /* class_destroy */
+    NULL,                        /* class_data */
+    0,                                /* instance_size */
+    0,                                /* n_preallocs */
+    NULL,                        /* instance_init */
+    NULL,                        /* value_table */
+  };
+  static const GTypeValueTable value_table = {
+    value_init_long0,                /* value_init */
+    NULL,                        /* value_free */
+    value_copy_long0,                /* value_copy */
+    NULL,                        /* value_peek_pointer */
+    "i",                        /* collect_format */
+    value_collect_int,        /* collect_value */
+    "p",                        /* lcopy_format */
+    value_lcopy_char,                /* lcopy_value */
+  };
+  info.value_table = &amp;value_table;
+  type = g_type_register_fundamental (G_TYPE_CHAR, "gchar", &amp;info, &amp;finfo, 0);
+          </pre>
+<p>
+        </p>
+<p>
+          Having non-instantiable types might seem a bit useless: what good is a type
+          if you cannot instantiate an instance of that type ? Most of these types
+          are used in conjunction with <span class="type"><a class="link" href="gobject-Generic-values.html#GValue" title="GValue">GValue</a></span>s: a GValue is initialized
+          with an integer or a string and it is passed around by using the registered
+          type's value_table. <span class="type"><a class="link" href="gobject-Generic-values.html#GValue" title="GValue">GValue</a></span>s (and by extension these trivial fundamental
+          types) are most useful when used in conjunction with object properties and signals.
+        </p>
+</div>
+<div class="footer">
+<hr>
+          Generated by GTK-Doc V1.14</div>
+</body>
+</html>

data/vendor/local/share/gtk-doc/html/gobject/home.png ADDED Viewed

Binary file

data/vendor/local/share/gtk-doc/html/gobject/howto-gobject-chainup.html ADDED Viewed

@@ -0,0 +1,100 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
+<title>Chaining up</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="howto-gobject.html" title="How to define and implement a new GObject">
+<link rel="prev" href="howto-gobject-methods.html" title="Object methods">
+<link rel="next" href="howto-interface.html" title="How to define and implement 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="howto-gobject-methods.html"><img src="left.png" width="24" height="24" border="0" alt="Prev"></a></td>
+<td><a accesskey="u" href="howto-gobject.html"><img src="up.png" width="24" height="24" border="0" alt="Up"></a></td>
+<td><a accesskey="h" href="index.html"><img src="home.png" width="24" height="24" border="0" alt="Home"></a></td>
+<th width="100%" align="center">GObject Reference Manual</th>
+<td><a accesskey="n" href="howto-interface.html"><img src="right.png" width="24" height="24" border="0" alt="Next"></a></td>
+</tr></table>
+<div class="sect1" title="Chaining up">
+<div class="titlepage"><div><div><h2 class="title" style="clear: both">
+<a name="howto-gobject-chainup"></a>Chaining up</h2></div></div></div>
+<p>Chaining up is often loosely defined by the following set of
+    conditions:
+      </p>
+<div class="itemizedlist"><ul class="itemizedlist" type="disc">
+<li class="listitem"><p>Parent class A defines a public virtual method named <code class="function">foo</code> and
+        provides a default implementation.</p></li>
+<li class="listitem"><p>Child class B re-implements method <code class="function">foo</code>.</p></li>
+<li class="listitem"><p>In the method B::foo, the child class B calls its parent class method A::foo.</p></li>
+</ul></div>
+<p>
+      There are many uses to this idiom:
+      </p>
+<div class="itemizedlist"><ul class="itemizedlist" type="disc">
+<li class="listitem"><p>You need to change the behaviour of a class without modifying its code. You create
+          a subclass to inherit its implementation, re-implement a public virtual method to modify the behaviour
+          slightly and chain up to ensure that the previous behaviour is not really modified, just extended.
+          </p></li>
+<li class="listitem"><p>You are lazy, you have access to the source code of the parent class but you don't want
+          to modify it to add method calls to new specialized method calls: it is faster to hack the child class
+          to chain up than to modify the parent to call down.</p></li>
+<li class="listitem"><p>You need to implement the Chain Of Responsibility pattern: each object of the inheritance
+          tree chains up to its parent (typically, at the beginning or the end of the method) to ensure that
+          they each handler is run in turn.</p></li>
+</ul></div>
+<p>
+      I am personally not really convinced any of the last two uses are really a good idea but since this
+      programming idiom is often used, this section attempts to explain how to implement it.
+    </p>
+<p>
+      To explicitly chain up to the implementation of the virtual method in the parent class,
+      you first need a handle to the original parent class structure. This pointer can then be used to
+      access the original class function pointer and invoke it directly.
+      <sup>[<a name="id597386" href="#ftn.id597386" class="footnote">11</a>]</sup>
+    </p>
+<p>The function <code class="function"><a class="link" href="gobject-Type-Information.html#g-type-class-peek-parent" title="g_type_class_peek_parent ()">g_type_class_peek_parent</a></code> is used to access the original parent
+    class structure. Its input is a pointer to the class of the derived object and it returns a pointer
+    to the original parent class structure. The code below shows how you could use it:
+</p>
+<pre class="programlisting">
+static void
+b_method_to_call (B *obj, int a)
+{
+  BClass *klass;
+  AClass *parent_class;
+  klass = B_GET_CLASS (obj);
+  parent_class = g_type_class_peek_parent (klass);
+  /* do stuff before chain up */
+  parent_class-&gt;method_to_call (obj, a);
+  /* do stuff after chain up */
+}
+</pre>
+<p>
+  </p>
+<div class="footnotes">
+<br><hr width="100" align="left">
+<div class="footnote"><p><sup>[<a name="ftn.id597386" href="#id597386" class="para">11</a>] </sup>
+          The <span class="emphasis"><em>original</em></span> adjective used in this sentence is not innocuous. To fully
+          understand its meaning, you need to recall how class structures are initialized: for each object type,
+          the class structure associated to this object is created by first copying the class structure of its
+          parent type (a simple <code class="function">memcpy</code>) and then by invoking the class_init callback on
+          the resulting class structure. Since the class_init callback is responsible for overwriting the class structure
+          with the user re-implementations of the class methods, we cannot merely use the modified copy of the parent class
+          structure stored in our derived instance. We want to get a copy of the class structure of an instance of the parent
+          class.
+        </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/howto-gobject-code.html ADDED Viewed

@@ -0,0 +1,86 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
+<title>Boilerplate code</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="howto-gobject.html" title="How to define and implement a new GObject">
+<link rel="prev" href="howto-gobject.html" title="How to define and implement a new GObject">
+<link rel="next" href="howto-gobject-construction.html" title="Object Construction">
+<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="howto-gobject.html"><img src="left.png" width="24" height="24" border="0" alt="Prev"></a></td>
+<td><a accesskey="u" href="howto-gobject.html"><img src="up.png" width="24" height="24" border="0" alt="Up"></a></td>
+<td><a accesskey="h" href="index.html"><img src="home.png" width="24" height="24" border="0" alt="Home"></a></td>
+<th width="100%" align="center">GObject Reference Manual</th>
+<td><a accesskey="n" href="howto-gobject-construction.html"><img src="right.png" width="24" height="24" border="0" alt="Next"></a></td>
+</tr></table>
+<div class="sect1" title="Boilerplate code">
+<div class="titlepage"><div><div><h2 class="title" style="clear: both">
+<a name="howto-gobject-code"></a>Boilerplate code</h2></div></div></div>
+<p>
+      In your code, the first step is to #include the needed headers: depending
+      on your header include strategy, this can be as simple as
+      <code class="literal">#include "maman-bar.h"</code> or as complicated as tens
+      of #include lines ending with <code class="literal">#include "maman-bar.h"</code>:
+</p>
+<pre class="programlisting">
+/*
+ * Copyright information
+ */
+#include "maman-bar.h"
+/* If you use Pimpls, include the private structure
+ * definition here. Some people create a maman-bar-private.h header
+ * which is included by the maman-bar.c file and which contains the
+ * definition for this private structure.
+ */
+struct _MamanBarPrivate {
+  int member_1;
+  /* stuff */
+};
+/*
+ * forward definitions
+ */
+</pre>
+<p>
+    </p>
+<p>
+      Call the <code class="function">G_DEFINE_TYPE</code> macro using the name
+      of the type, the prefix of the functions and the parent GType to
+      reduce the amount of boilerplate needed. This macro will:
+      </p>
+<div class="itemizedlist"><ul class="itemizedlist" type="disc">
+<li class="listitem">implement the <code class="function">maman_bar_get_type</code>
+        function</li>
+<li class="listitem">define a parent class pointer accessible from
+        the whole .c file</li>
+</ul></div>
+<p>
+</p>
+<pre class="programlisting">
+G_DEFINE_TYPE (MamanBar, maman_bar, G_TYPE_OBJECT);
+</pre>
+<p>
+    </p>
+<p>
+      It is also possible to use the
+      <code class="function">G_DEFINE_TYPE_WITH_CODE</code> macro to control the
+      get_type function implementation - for instance, to add a call to
+      <code class="function">G_IMPLEMENT_INTERFACE</code> macro which will
+      call the <code class="function">g_type_implement_interface</code> function.
+    </p>
+</div>
+<div class="footer">
+<hr>
+          Generated by GTK-Doc V1.14</div>
+</body>
+</html>