<refentry id="GladeXML" revision="8 Nov 2000">
<refmeta>
<refentrytitle>GladeXML</refentrytitle>
<manvolnum>3</manvolnum>
<refmiscinfo>LIBGLADE Library</refmiscinfo>
</refmeta>

<refnamediv>
<refname>GladeXML</refname><refpurpose>Allows dynamic loading of user interfaces from XML descriptions.</refpurpose>
</refnamediv>

<refsynopsisdiv><title>Synopsis</title>
<synopsis>

#include &lt;glade/glade.h&gt;


struct      <link linkend="GladeXML-struct">GladeXML</link>;
struct      <link linkend="GladeXMLClass">GladeXMLClass</link>;
<link linkend="GladeXML">GladeXML</link>*   <link linkend="glade-xml-new">glade_xml_new</link>                   (const char *fname,
                                             const char *root);
<link linkend="GladeXML">GladeXML</link>*   <link linkend="glade-xml-new-with-domain">glade_xml_new_with_domain</link>       (const char *fname,
                                             const char *root,
                                             const char *domain);
<link linkend="GladeXML">GladeXML</link>*   <link linkend="glade-xml-new-from-memory">glade_xml_new_from_memory</link>       (char *buffer,
                                             int size,
                                             const char *root,
                                             const char *domain);
<link linkend="gboolean">gboolean</link>    <link linkend="glade-xml-construct">glade_xml_construct</link>             (<link linkend="GladeXML">GladeXML</link> *self,
                                             const char *fname,
                                             const char *root,
                                             const char *domain);

void        <link linkend="glade-xml-signal-connect">glade_xml_signal_connect</link>        (<link linkend="GladeXML">GladeXML</link> *self,
                                             const char *handlername,
                                             <link linkend="GtkSignalFunc">GtkSignalFunc</link> func);
void        <link linkend="glade-xml-signal-connect-data">glade_xml_signal_connect_data</link>   (<link linkend="GladeXML">GladeXML</link> *self,
                                             const char *handlername,
                                             <link linkend="GtkSignalFunc">GtkSignalFunc</link> func,
                                             <link linkend="gpointer">gpointer</link> user_data);
void        <link linkend="glade-xml-signal-autoconnect">glade_xml_signal_autoconnect</link>    (<link linkend="GladeXML">GladeXML</link> *self);

<link linkend="GtkWidget">GtkWidget</link>*  <link linkend="glade-xml-get-widget">glade_xml_get_widget</link>            (<link linkend="GladeXML">GladeXML</link> *self,
                                             const char *name);
<link linkend="GtkWidget">GtkWidget</link>*  <link linkend="glade-xml-get-widget-by-long-name">glade_xml_get_widget_by_long_name</link>
                                            (<link linkend="GladeXML">GladeXML</link> *self,
                                             const char *longname);
<link linkend="GList">GList</link>*      <link linkend="glade-xml-get-widget-prefix">glade_xml_get_widget_prefix</link>     (<link linkend="GladeXML">GladeXML</link> *self,
                                             const char *name);
const char* <link linkend="glade-get-widget-name">glade_get_widget_name</link>           (<link linkend="GtkWidget">GtkWidget</link> *widget);
const char* <link linkend="glade-get-widget-long-name">glade_get_widget_long_name</link>      (<link linkend="GtkWidget">GtkWidget</link> *widget);
<link linkend="GladeXML">GladeXML</link>*   <link linkend="glade-get-widget-tree">glade_get_widget_tree</link>           (<link linkend="GtkWidget">GtkWidget</link> *widget);

void        (<link linkend="GladeXMLConnectFunc">*GladeXMLConnectFunc</link>)          (const <link linkend="gchar">gchar</link> *handler_name,
                                             <link linkend="GtkObject">GtkObject</link> *object,
                                             const <link linkend="gchar">gchar</link> *signal_name,
                                             const <link linkend="gchar">gchar</link> *signal_data,
                                             <link linkend="GtkObject">GtkObject</link> *connect_object,
                                             <link linkend="gboolean">gboolean</link> after,
                                             <link linkend="gpointer">gpointer</link> user_data);
void        <link linkend="glade-xml-signal-connect-full">glade_xml_signal_connect_full</link>   (<link linkend="GladeXML">GladeXML</link> *self,
                                             const <link linkend="gchar">gchar</link> *handler_name,
                                             <link linkend="GladeXMLConnectFunc">GladeXMLConnectFunc</link> func,
                                             <link linkend="gpointer">gpointer</link> user_data);
void        <link linkend="glade-xml-signal-autoconnect-full">glade_xml_signal_autoconnect_full</link>
                                            (<link linkend="GladeXML">GladeXML</link> *self,
                                             <link linkend="GladeXMLConnectFunc">GladeXMLConnectFunc</link> func,
                                             <link linkend="gpointer">gpointer</link> user_data);


</synopsis>
</refsynopsisdiv>

<refsect1>
<title>Object Hierarchy</title>
<synopsis>

  <link linkend="GtkObject">GtkObject</link>
   +----<link linkend="GtkData">GtkData</link>
         +----GladeXML
</synopsis>

</refsect1>




<refsect1>
<title>Description</title>
<para>
This object represents an `instantiation' of an XML interface description.
When one of these objects is created, the XML file is read, and the
interface is created.  The GladeXML object then provides an interface for
accessing the widgets in the interface by the names assigned to them
inside the XML description.
</para>

<para>
The GladeXML object can also be used to connect handlers to the named
signals in the description.  Libglade also provides an interface by which
it can look up the signal handler names in the program's symbol table and
automatically connect as many handlers up as it can that way.
</para>
</refsect1>

<refsect1>
<title>Details</title>
<refsect2>
<title><anchor id="GladeXML-struct">struct GladeXML</title>
<programlisting>struct GladeXML {
  GtkData parent;

  char *filename;
  char *txtdomain;

};
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="GladeXMLClass">struct GladeXMLClass</title>
<programlisting>struct GladeXMLClass;</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="glade-xml-new">glade_xml_new ()</title>
<programlisting><link linkend="GladeXML">GladeXML</link>*   glade_xml_new                   (const char *fname,
                                             const char *root);</programlisting>
<para>
Creates a new GladeXML object (and the corresponding widgets) from the
XML file <parameter>fname</parameter>.  Optionally it will only build the interface from the
widget node <parameter>root</parameter> (if it is not <literal>NULL</literal>).  This feature is useful if you
only want to build say a toolbar or menu from the XML file, but not the
window it is embedded in.  Note also that the XML parse tree is cached
to speed up creating another GladeXML object for the same file</para>
<para>

</para><informaltable pgwide=1 frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>fname</parameter>&nbsp;:</entry>
<entry> the XML file name.
</entry></row>
<row><entry align="right"><parameter>root</parameter>&nbsp;:</entry>
<entry> the widget node in <parameter>fname</parameter> to start building from (or <literal>NULL</literal>)
</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry> the newly created GladeXML object, or NULL on failure.
</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="glade-xml-new-with-domain">glade_xml_new_with_domain ()</title>
<programlisting><link linkend="GladeXML">GladeXML</link>*   glade_xml_new_with_domain       (const char *fname,
                                             const char *root,
                                             const char *domain);</programlisting>
<para>
Creates a new GladeXML object (and the corresponding widgets) from the
XML file <parameter>fname</parameter>.  Optionally it will only build the interface from the
widget node <parameter>root</parameter> (if it is not <literal>NULL</literal>).  This feature is useful if you
only want to build say a toolbar or menu from the XML file, but not the
window it is embedded in.  Note also that the XML parse tree is cached
to speed up creating another GladeXML object for the same file.  This
function differs from glade_xml_new in that you can specify a different
translation domain from the default to be used.</para>
<para>

</para><informaltable pgwide=1 frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>fname</parameter>&nbsp;:</entry>
<entry> the XML file name.
</entry></row>
<row><entry align="right"><parameter>root</parameter>&nbsp;:</entry>
<entry> the widget node in <parameter>fname</parameter> to start building from (or <literal>NULL</literal>)
</entry></row>
<row><entry align="right"><parameter>domain</parameter>&nbsp;:</entry>
<entry> the translation domain to use for this interface (or <literal>NULL</literal>)
</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry> the newly created GladeXML object, or NULL on failure.
</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="glade-xml-new-from-memory">glade_xml_new_from_memory ()</title>
<programlisting><link linkend="GladeXML">GladeXML</link>*   glade_xml_new_from_memory       (char *buffer,
                                             int size,
                                             const char *root,
                                             const char *domain);</programlisting>
<para>
Creates a new GladeXML object (and the corresponding widgets) from the
buffer <parameter>buffer</parameter>.  Optionally it will only build the interface from the
widget node <parameter>root</parameter> (if it is not <literal>NULL</literal>).  This feature is useful if you
only want to build say a toolbar or menu from the XML document, but not the
window it is embedded in.</para>
<para>

</para><informaltable pgwide=1 frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>buffer</parameter>&nbsp;:</entry>
<entry> the memory buffer containing the XML document.
</entry></row>
<row><entry align="right"><parameter>size</parameter>&nbsp;:</entry>
<entry> the size of the buffer.
</entry></row>
<row><entry align="right"><parameter>root</parameter>&nbsp;:</entry>
<entry> the widget node in <parameter>buffer</parameter> to start building from (or <literal>NULL</literal>)
</entry></row>
<row><entry align="right"><parameter>domain</parameter>&nbsp;:</entry>
<entry> the translation domain to use for this interface (or <literal>NULL</literal>)
</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry> the newly created GladeXML object, or NULL on failure.
</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="glade-xml-construct">glade_xml_construct ()</title>
<programlisting><link linkend="gboolean">gboolean</link>    glade_xml_construct             (<link linkend="GladeXML">GladeXML</link> *self,
                                             const char *fname,
                                             const char *root,
                                             const char *domain);</programlisting>
<para>
This routine can be used by bindings (such as gtk--) to help construct
a GladeXML object, if it is needed.</para>
<para>

</para><informaltable pgwide=1 frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>self</parameter>&nbsp;:</entry>
<entry> the GladeXML object
</entry></row>
<row><entry align="right"><parameter>fname</parameter>&nbsp;:</entry>
<entry> the XML filename
</entry></row>
<row><entry align="right"><parameter>root</parameter>&nbsp;:</entry>
<entry> the root widget node (or <literal>NULL</literal> for none)
</entry></row>
<row><entry align="right"><parameter>domain</parameter>&nbsp;:</entry>
<entry> the translation domain (or <literal>NULL</literal> for the default)
</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry> TRUE if the construction succeeded.
</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="glade-xml-signal-connect">glade_xml_signal_connect ()</title>
<programlisting>void        glade_xml_signal_connect        (<link linkend="GladeXML">GladeXML</link> *self,
                                             const char *handlername,
                                             <link linkend="GtkSignalFunc">GtkSignalFunc</link> func);</programlisting>
<para>
In the glade interface descriptions, signal handlers are specified for
widgets by name.  This function allows you to connect a C function to
all signals in the GladeXML file with the given signal handler name.</para>
<para>

</para><informaltable pgwide=1 frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>self</parameter>&nbsp;:</entry>
<entry> the GladeXML object
</entry></row>
<row><entry align="right"><parameter>handlername</parameter>&nbsp;:</entry>
<entry> the signal handler name
</entry></row>
<row><entry align="right"><parameter>func</parameter>&nbsp;:</entry>
<entry> the signal handler function
</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="glade-xml-signal-connect-data">glade_xml_signal_connect_data ()</title>
<programlisting>void        glade_xml_signal_connect_data   (<link linkend="GladeXML">GladeXML</link> *self,
                                             const char *handlername,
                                             <link linkend="GtkSignalFunc">GtkSignalFunc</link> func,
                                             <link linkend="gpointer">gpointer</link> user_data);</programlisting>
<para>
In the glade interface descriptions, signal handlers are specified for
widgets by name.  This function allows you to connect a C function to
all signals in the GladeXML file with the given signal handler name.
</para>
<para>
It differs from glade_xml_signal_connect since it allows you to
specify the data parameter for the signal handler.  It is also a small
demonstration of how to use glade_xml_signal_connect_full.</para>
<para>

</para><informaltable pgwide=1 frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>self</parameter>&nbsp;:</entry>
<entry> the GladeXML object
</entry></row>
<row><entry align="right"><parameter>handlername</parameter>&nbsp;:</entry>
<entry> the signal handler name
</entry></row>
<row><entry align="right"><parameter>func</parameter>&nbsp;:</entry>
<entry> the signal handler function
</entry></row>
<row><entry align="right"><parameter>user_data</parameter>&nbsp;:</entry>
<entry> the signal handler data
</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="glade-xml-signal-autoconnect">glade_xml_signal_autoconnect ()</title>
<programlisting>void        glade_xml_signal_autoconnect    (<link linkend="GladeXML">GladeXML</link> *self);</programlisting>
<para>
This function is a variation of glade_xml_signal_connect.  It uses
gmodule's introspective features (by openning the module <literal>NULL</literal>) to
look at the application's symbol table.  From here it tries to match
the signal handler names given in the interface description with
symbols in the application and connects the signals.
</para>
<para>
Note that this function will not work correctly if gmodule is not
supported on the platform.</para>
<para>

</para><informaltable pgwide=1 frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>self</parameter>&nbsp;:</entry>
<entry> the GladeXML object.
</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="glade-xml-get-widget">glade_xml_get_widget ()</title>
<programlisting><link linkend="GtkWidget">GtkWidget</link>*  glade_xml_get_widget            (<link linkend="GladeXML">GladeXML</link> *self,
                                             const char *name);</programlisting>
<para>
This function is used to get a pointer to the GtkWidget corresponding to
<parameter>name</parameter> in the interface description.  You would use this if you have to do
anything to the widget after loading.</para>
<para>

</para><informaltable pgwide=1 frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>self</parameter>&nbsp;:</entry>
<entry> the GladeXML object.
</entry></row>
<row><entry align="right"><parameter>name</parameter>&nbsp;:</entry>
<entry> the name of the widget.
</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry> the widget matching <parameter>name</parameter>, or <literal>NULL</literal> if none exists.
</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="glade-xml-get-widget-by-long-name">glade_xml_get_widget_by_long_name ()</title>
<programlisting><link linkend="GtkWidget">GtkWidget</link>*  glade_xml_get_widget_by_long_name
                                            (<link linkend="GladeXML">GladeXML</link> *self,
                                             const char *longname);</programlisting>
<para>
This function is used to get a pointer to the GtkWidget corresponding to
<parameter>longname</parameter> in the interface description.  You would use this if you have
to do anything to the widget after loading.  This function differs from
glade_xml_get_widget, in that you have to give the long form of the
widget name, with all its parent widget names, separated by periods.</para>
<para>

</para><informaltable pgwide=1 frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>self</parameter>&nbsp;:</entry>
<entry> the GladeXML object.
</entry></row>
<row><entry align="right"><parameter>longname</parameter>&nbsp;:</entry>
<entry> the long name of the widget (eg toplevel.parent.widgetname).
</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry> the widget matching <parameter>longname</parameter>, or <literal>NULL</literal> if none exists.
</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="glade-xml-get-widget-prefix">glade_xml_get_widget_prefix ()</title>
<programlisting><link linkend="GList">GList</link>*      glade_xml_get_widget_prefix     (<link linkend="GladeXML">GladeXML</link> *self,
                                             const char *name);</programlisting>
<para>
This function is used to get a list of pointers to the GtkWidget(s)
with names that start with the string <parameter>name</parameter> in the interface description.
You would use this if you have to do something  to all of these widgets
after loading.</para>
<para>

</para><informaltable pgwide=1 frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>self</parameter>&nbsp;:</entry>
<entry> the GladeXML object.
</entry></row>
<row><entry align="right"><parameter>name</parameter>&nbsp;:</entry>
<entry> the name of the widget.
</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry> A list of the widget that match <parameter>name</parameter> as the start of their
name, or <literal>NULL</literal> if none exists.
</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="glade-get-widget-name">glade_get_widget_name ()</title>
<programlisting>const char* glade_get_widget_name           (<link linkend="GtkWidget">GtkWidget</link> *widget);</programlisting>
<para>
Used to get the name of a widget that was generated by a GladeXML object.</para>
<para>

</para><informaltable pgwide=1 frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry> the widget
</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry> the name of the widget.
</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="glade-get-widget-long-name">glade_get_widget_long_name ()</title>
<programlisting>const char* glade_get_widget_long_name      (<link linkend="GtkWidget">GtkWidget</link> *widget);</programlisting>
<para>
Used to get the long name of a widget that was generated by a GladeXML
object.</para>
<para>

</para><informaltable pgwide=1 frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry> the widget
</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry> the long name of the widget.
</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="glade-get-widget-tree">glade_get_widget_tree ()</title>
<programlisting><link linkend="GladeXML">GladeXML</link>*   glade_get_widget_tree           (<link linkend="GtkWidget">GtkWidget</link> *widget);</programlisting>
<para>
This function is used to get the GladeXML object that built this widget.</para>
<para>

</para><informaltable pgwide=1 frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>widget</parameter>&nbsp;:</entry>
<entry> the widget
</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry> the GladeXML object that built this widget.
</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="GladeXMLConnectFunc">GladeXMLConnectFunc ()</title>
<programlisting>void        (*GladeXMLConnectFunc)          (const <link linkend="gchar">gchar</link> *handler_name,
                                             <link linkend="GtkObject">GtkObject</link> *object,
                                             const <link linkend="gchar">gchar</link> *signal_name,
                                             const <link linkend="gchar">gchar</link> *signal_data,
                                             <link linkend="GtkObject">GtkObject</link> *connect_object,
                                             <link linkend="gboolean">gboolean</link> after,
                                             <link linkend="gpointer">gpointer</link> user_data);</programlisting>
<para>
This is the signature of a function used to connect signals.  It is used
by the glade_xml_signal_connect_full and glade_xml_signal_autoconnect_full
functions.  It is mainly intented for interpreted language bindings, but
could be useful where the programmer wants more control over the signal
connection process.</para>
<para>

</para><informaltable pgwide=1 frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>handler_name</parameter>&nbsp;:</entry>
<entry> the name of the handler function to connect.
</entry></row>
<row><entry align="right"><parameter>object</parameter>&nbsp;:</entry>
<entry> the object to connect the signal to.
</entry></row>
<row><entry align="right"><parameter>signal_name</parameter>&nbsp;:</entry>
<entry> the name of the signal.
</entry></row>
<row><entry align="right"><parameter>signal_data</parameter>&nbsp;:</entry>
<entry> the string value of the signal data given in the XML file.
</entry></row>
<row><entry align="right"><parameter>connect_object</parameter>&nbsp;:</entry>
<entry> non NULL if gtk_signal_connect_object should be used.
</entry></row>
<row><entry align="right"><parameter>after</parameter>&nbsp;:</entry>
<entry> TRUE if the connection should be made with gtk_signal_connect_after.
</entry></row>
<row><entry align="right"><parameter>user_data</parameter>&nbsp;:</entry>
<entry> the user data argument.
</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="glade-xml-signal-connect-full">glade_xml_signal_connect_full ()</title>
<programlisting>void        glade_xml_signal_connect_full   (<link linkend="GladeXML">GladeXML</link> *self,
                                             const <link linkend="gchar">gchar</link> *handler_name,
                                             <link linkend="GladeXMLConnectFunc">GladeXMLConnectFunc</link> func,
                                             <link linkend="gpointer">gpointer</link> user_data);</programlisting>
<para>
This function is similar to glade_xml_signal_connect, except that it
allows you to give an arbitrary function that will be used for actually
connecting the signals.  This is mainly useful for writers of interpreted
language bindings, or applications where you need more control over the
signal connection process.</para>
<para>

</para><informaltable pgwide=1 frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>self</parameter>&nbsp;:</entry>
<entry> the GladeXML object.
</entry></row>
<row><entry align="right"><parameter>handler_name</parameter>&nbsp;:</entry>
<entry> the name of the signal handler that we want to connect.
</entry></row>
<row><entry align="right"><parameter>func</parameter>&nbsp;:</entry>
<entry> the function to use to connect the signals.
</entry></row>
<row><entry align="right"><parameter>user_data</parameter>&nbsp;:</entry>
<entry> arbitrary data to pass to the connect function.
</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="glade-xml-signal-autoconnect-full">glade_xml_signal_autoconnect_full ()</title>
<programlisting>void        glade_xml_signal_autoconnect_full
                                            (<link linkend="GladeXML">GladeXML</link> *self,
                                             <link linkend="GladeXMLConnectFunc">GladeXMLConnectFunc</link> func,
                                             <link linkend="gpointer">gpointer</link> user_data);</programlisting>
<para>
This function is similar to glade_xml_signal_connect_full, except that it
will try to connect all signals in the interface, not just a single
named handler.  It can be thought of the interpeted language binding
version of glade_xml_signal_autoconnect, except that it does not
require gmodule to function correctly.</para>
<para>

</para><informaltable pgwide=1 frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>self</parameter>&nbsp;:</entry>
<entry> the GladeXML object.
</entry></row>
<row><entry align="right"><parameter>func</parameter>&nbsp;:</entry>
<entry> the function used to connect the signals.
</entry></row>
<row><entry align="right"><parameter>user_data</parameter>&nbsp;:</entry>
<entry> arbitrary data that will be passed to the connection function.
</entry></row>
</tbody></tgroup></informaltable></refsect2>

</refsect1>




</refentry>
