GtkBuildable
Interface for objects that can be built by GtkBuilder
In order to allow construction from a GtkBuilder
UI description, an object class must implement the
GtkBuildable interface. The interface includes methods for setting
names and properties of objects, parsing custom tags, constructing
child objects.
The GtkBuildable interface is implemented by all widgets and
many of the non-widget objects that are provided by GTK+. The
main user of this interface is #GtkBuilder, there should be
very little need for applications to call any
gtk_buildable_... functions.
The GtkBuildableIface interface contains method that are
necessary to allow #GtkBuilder to construct an object from
a GtkBuilder UI definition.
@g_iface: the parent class
@set_name: Stores the name attribute given in the GtkBuilder UI definition.
#GtkWidget maps this to the #GtkWidget:name property, and
gtk_buildable_set_name() has a fallback implementation that stores
the name as object data. Implement this method if your object
has some notion of "name" and it makes sense to map the XML name
attribute to it.
@get_name: The getter corresponding to @set_name. Implement this
if you implement @set_name.
@add_child: Adds a child. The @type parameter can be used to
differentiate the kind of child. #GtkContainer implements this
to add add a child widget to the container, #GtkNotebook uses
the @type to distinguish between page labels (of type "page-label")
and normal children.
@set_buildable_property: Sets a property of a buildable object.
It is normally not necessary to implement this, g_object_set_property()
is used by default. #GtkWindow implements this to delay showing itself
(i.e. setting the #GtkWidget:visible property) until the whole interface
is created.
@construct_child: Constructs a child of a buildable that has been
specified as "constructor" in the UI definition. #GtkUIManager implements
this to reference to a widget created in a <ui> tag which is outside
of the normal GtkBuilder UI definition hierarchy.
@custom_tag_start: Implement this if the buildable needs to parse
content below <child>. To handle an element, the implementation
must fill in the @parser structure and @user_data and return %TRUE.
#GtkWidget implements this to parse keyboard accelerators specified
in <accelerator> elements. #GtkContainer implements it to map
properties defined via <packing> elements to child properties.
Note that @user_data must be freed in @custom_tag_end or @custom_finished.
@custom_tag_end: Called for the end tag of each custom element that is
handled by the buildable (see @custom_tag_start).
@custom_finished: Called for each custom tag handled by the buildable
when the builder finishes parsing (see @custom_tag_start)
@parser_finished: Called when a builder finishes the parsing
of a UI definition. It is normally not necessary to implement this,
unless you need to perform special cleanup actions. #GtkWindow sets
the #GtkWidget:visible property here.
@get_internal_child: Returns an internal child of a buildable.
#GtkDialog implements this to give access to its @vbox, making
it possible to add children to the vbox in a UI definition.
Implement this if the buildable has internal children that may
need to be accessed from a UI definition.
@buildable:
@name:
@buildable:
@Returns:
@buildable:
@builder:
@child:
@type:
@buildable:
@builder:
@name:
@value:
@buildable:
@builder:
@name:
@Returns:
@buildable:
@builder:
@child:
@tagname:
@parser:
@data:
@Returns:
@buildable:
@builder:
@child:
@tagname:
@data:
@buildable:
@builder:
@child:
@tagname:
@data:
@buildable:
@builder:
@buildable:
@builder:
@childname:
@Returns: