Details
GladeNewFunc ()
This function signature should be used by functions that build particular
widget types. The function should create the new widget and set any non
standard widget parameters (ie. don't set visibility, size, etc), as
this is handled by glade_xml_build_widget, which calls these functions.
GladeBuildChildrenFunc ()
This function signature should be used by functions that are responsible
for adding children to a container widget. To create each child widget,
glade_xml_build_widget should be called.
GladeFindInternalChildFunc ()
GtkWidget* (*GladeFindInternalChildFunc) (GladeXML *xml,
GtkWidget *parent,
const char *childname); |
When some composite widgets are created, a number of children are
added at the same time (for example, the vbox in a GtkDialog).
These widgets are identified in the XML interface file by the
internal-child attribute on their <child> element.
When libglade encounters an internal child, rather than creating a
new widget instance, libglade walks up the tree until it finds the
first non internal-child parent. It then calls the
find_internal_child callback for that parent's class.
That callback should return the internal child corresponding to the
name passed in as the third argument.
glade_xml_build_widget ()
This function is not intended for people who just use libglade. Instead
it is for people extending it (it is designed to be called in the child
build routine defined for the parent widget). It first checks the type
of the widget from the class tag, then calls the corresponding widget
creation routine. This routine sets up all the settings specific to that
type of widget. Then general widget settings are performed on the widget.
Then it sets up accelerators for the widget, and extracts any signal
information for the widget. Then it checks to see if there are any
child widget nodes for this widget, and if so calls the widget's
build routine, which will create the children with this function and add
them to the widget in the appropriate way. Finally it returns the widget.
glade_xml_handle_internal_child ()
This function is intended to be called by the build_children
callback for container widgets. If the build_children callback
encounters a child with the internal-child attribute set, then it
should call this function to handle it and then continue on to the
next child.
glade_xml_set_common_params ()
This function sets the common parameters on a widget, and is responsible
for inserting it into the GladeXML object's internal structures. It will
also add the children to this widget. Usually this function is only called
by glade_xml_build_widget, but is exposed for difficult cases, such as
setting up toolbar buttons and the like.
struct GladeWidgetBuildData
struct GladeWidgetBuildData {
char *name;
GladeNewFunc new;
GladeBuildChildrenFunc build_children;
GType (* get_type_func)(void);
GType typecode; /* this member takes precedence over get_type_func */
GladeFindInternalChildFunc find_internal_child;
}; |
glade_register_widgets ()
This function is used to register new sets of widget building functions.
each member of widgets contains the widget name, a function to build
a widget of that type, and optionally a function to build the children
of this widget. The child building routine would call
glade_xml_build_widget on each child node to create the child before
packing it.
This function is mainly useful for addon widget modules for libglade
(it would get called from the glade_init_module function).
glade_xml_set_value_from_string ()
gboolean glade_xml_set_value_from_string (GParamSpec *pspec,
const gchar *string,
GValue *value); |
This function demarshals a value from a string. This function
calls g_value_init() on the value argument, so it need not be
initialised beforehand.
This function can handle char, uchar, boolean, int, uint, long,
ulong, enum, flags, float, double, string, GdkColor and
GtkAdjustment type values. Support for GtkWidget type values is
still to come.
glade_standard_build_widget ()
This is the standard widget building function. It processes all
the widget properties using the standard object properties
interfaces. This function will be sufficient for most widget
types, thus reducing the ammount of work needed to wrap a library.
glade_standard_build_children ()
This is the standard child building function. It simply calls
gtk_container_add on each child to add them to the parent, and
process any packing properties using the generic container packing
properties interfaces.
This function will be sufficient for most container widgets
provided that they implement the GtkContainer child packing
properties interfaces.
glade_xml_relative_file ()
gchar* glade_xml_relative_file (GladeXML *self,
const gchar *filename); |
This function resolves a relative pathname, using the directory of the
XML file as a base. If the pathname is absolute, then the original
filename is returned.
glade_enum_from_string ()
gint glade_enum_from_string (GType type,
const char *string); |
This helper routine is designed to be used by widget build routines to
convert the string representations of enumeration values found in the
XML descriptions to the integer values that can be used to configure
the widget.
glade_flags_from_string ()
guint glade_flags_from_string (GType type,
const char *string); |
This helper routine is designed to be used by widget build routines
to convert the string representations of flags values found in the
XML descriptions to the integer values that can be used to
configure the widget. The string is composed of string names or
nicknames for various flags separated by '|'.
glade_xml_set_toplevel ()
void glade_xml_set_toplevel (GladeXML *xml,
GtkWindow *window); |
This is used while the tree is being built to set the toplevel window that
is currently being built. It is mainly used to enable GtkAccelGroup's to
be bound to the correct window, but could have other uses.
glade_xml_push_accel ()
GtkAccelGroup* glade_xml_push_accel (GladeXML *xml); |
Make a new accel group amd push onto the stack. This is intended for use
by GtkNotebook so that each notebook page can set up its own accelerators.
glade_xml_pop_accel ()
GtkAccelGroup* glade_xml_pop_accel (GladeXML *xml); |
Pops the accel group. This will usually be called after a GtkNotebook page
has been built.
glade_xml_ensure_accel ()
GtkAccelGroup* glade_xml_ensure_accel (GladeXML *xml); |
This function is used to get the current GtkAccelGroup. If there isn't
one, a new one is created and bound to the current toplevel window (if
a toplevel has been set).
glade_xml_handle_label_accel ()
void glade_xml_handle_label_accel (GladeXML *xml,
const gchar *target,
guint key); |
This function is called by the GtkLabel creation routine to register an
underline accelerator for the label. If the target widget exists, the
accelerator is connected to the grab_focus signal. If it does not exist
yet, the (target, key) pair is saved so that it can be attached when the
widget is created.
If target is NULL, then the accelerator should be attached to one of
the parents of this widget (typically a GtkButton).