A callback function used by the type system to finalize those portions of a derived types class structure that were setup from the corresponding GBaseInitFunc() function. Class finalization basically works the inverse way in which class intialization is performed. See GClassInitFunc() for a discussion of the class intialization process.

The #GTypeClass structure to finalize. A callback function used by the type system to do base initialization of the class structures of derived types. It is called as part of the initialization process of all derived classes and should reallocate or reset all dynamic class members copied over from the parent class. For example, class members (such as strings) that are not sufficiently handled by a plain memory copy of the parent class into the derived class have to be altered. See GClassInitFunc() for a discussion of the class intialization process.

The #GTypeClass structure to initialize. <structname>GBinding</structname> is an opaque structure whose members cannot be accessed directly.

Flags to be passed to g_object_bind_property() or g_object_bind_property_full(). This enumeration can be extended at later date. A function to be called to transform the source property of @source from @source_value into the target property of @target using @target_value. otherwise

%TRUE if the transformation was successful, and %FALSE

a #GBinding the value of the source property the value of the target property data passed to the transform function This function is provided by the user and should produce a copy of the passed in boxed structure.

The newly created copy of the boxed structure.

The boxed structure to be copied. This function is provided by the user and should free the boxed structure passed.

The boxed structure to be freed. A #GCClosure is a specialization of #GClosure for C function callbacks. The type used for callback functions in structure definitions and function signatures. This doesn't mean that all callback functions must take no parameters and return void. The required signature of a callback function is determined by the context in which is used (e.g. the signal to which it is connected). Use G_CALLBACK() to cast the callback function to a #GCallback.

A callback function used by the type system to finalize a class. This function is rarely needed, as dynamically allocated class resources should be handled by GBaseInitFunc() and GBaseFinalizeFunc(). Also, specification of a GClassFinalizeFunc() in the #GTypeInfo structure of a static type is invalid, because classes of static types will never be finalized (they are artificially kept alive when their reference count drops to zero).

The #GTypeClass structure to finalize. The @class_data member supplied via the #GTypeInfo structure. A callback function used by the type system to initialize the class of a specific type. This function should initialize all static class members. The initialization process of a class involves: <itemizedlist> <listitem><para> 1 - Copying common members from the parent class over to the derived class structure. </para></listitem> <listitem><para> 2 - Zero initialization of the remaining members not copied over from the parent class. </para></listitem> <listitem><para> 3 - Invocation of the GBaseInitFunc() initializers of all parent types and the class' type. </para></listitem> <listitem><para> 4 - Invocation of the class' GClassInitFunc() initializer. </para></listitem> </itemizedlist> Since derived classes are partially initialized through a memory copy of the parent class, the general rule is that GBaseInitFunc() and GBaseFinalizeFunc() should take care of necessary reinitialization and release of those class members that were introduced by the type that specified these GBaseInitFunc()/GBaseFinalizeFunc(). GClassInitFunc() should only care about initializing static class members, while dynamic class members (such as allocated strings or reference counted resources) are better handled by a GBaseInitFunc() for this type, so proper initialization of the dynamic class members is performed for class initialization of derived types as well. An example may help to correspond the intend of the different class initializers: |[ typedef struct { GObjectClass parent_class; gint static_integer; gchar *dynamic_string; } TypeAClass; static void type_a_base_class_init (TypeAClass *class) { class->dynamic_string = g_strdup ("some string"); } static void type_a_base_class_finalize (TypeAClass *class) { g_free (class->dynamic_string); } static void type_a_class_init (TypeAClass *class) { class->static_integer = 42; } typedef struct { TypeAClass parent_class; gfloat static_float; GString *dynamic_gstring; } TypeBClass; static void type_b_base_class_init (TypeBClass *class) { class->dynamic_gstring = g_string_new ("some other string"); } static void type_b_base_class_finalize (TypeBClass *class) { g_string_free (class->dynamic_gstring); } static void type_b_class_init (TypeBClass *class) { class->static_float = 3.14159265358979323846; } ]| Initialization of TypeBClass will first cause initialization of TypeAClass (derived classes reference their parent classes, see g_type_class_ref() on this). Initialization of TypeAClass roughly involves zero-initializing its fields, then calling its GBaseInitFunc() type_a_base_class_init() to allocate its dynamic members (dynamic_string), and finally calling its GClassInitFunc() type_a_class_init() to initialize its static members (static_integer). The first step in the initialization process of TypeBClass is then a plain memory copy of the contents of TypeAClass into TypeBClass and zero-initialization of the remaining fields in TypeBClass. The dynamic members of TypeAClass within TypeBClass now need reinitialization which is performed by calling type_a_base_class_init() with an argument of TypeBClass. After that, the GBaseInitFunc() of TypeBClass, type_b_base_class_init() is called to allocate the dynamic members of TypeBClass (dynamic_gstring), and finally the GClassInitFunc() of TypeBClass, type_b_class_init(), is called to complete the initialization process with the static members (static_float). Corresponding finalization counter parts to the GBaseInitFunc() functions have to be provided to release allocated resources at class finalization time.

The #GTypeClass structure to initialize. The @class_data member supplied via the #GTypeInfo structure. A #GClosure represents a callback supplied by the programmer.

The type used for marshaller functions.

the #GClosure to which the marshaller belongs a #GValue to store the return value. May be %NULL if the callback of @closure doesn't return a value. the length of the @param_values array an array of #GValues holding the arguments on which to invoke the callback of @closure the invocation hint given as the last argument to g_closure_invoke() additional data specified when registering the marshaller, see g_closure_set_marshal() and g_closure_set_meta_marshal() The type used for the various notification callbacks which can be registered on closures.

data specified when registering the notification callback the #GClosure on which the notification is emitted The connection flags are used to specify the behaviour of a signal's connection. The class of an enumeration type holds information about its possible values. A structure which contains a single enum value, its name, and its nickname. The class of a flags type holds information about its possible values. A structure which contains a single flags value, its name, and its nickname. All the fields in the <structname>GInitiallyUnowned</structname> structure are private to the #GInitiallyUnowned implementation and should never be accessed directly. The class structure for the <structname>GInitiallyUnowned</structname> type.

A callback function used by the type system to initialize a new instance of a type. This function initializes all instance members and allocates any resources required by it. Initialization of a derived instance involves calling all its parent types instance initializers, so the class member of the instance is altered during its initialization to always point to the class that belongs to the type the current initializer was introduced for.

The instance to initialize. The class of the type the instance is created for. A callback function used by the type system to finalize an interface. This function should destroy any internal data and release any resources allocated by the corresponding GInterfaceInitFunc() function.

The interface structure to finalize. The @interface_data supplied via the #GInterfaceInfo structure. A structure that provides information to the type system which is used specifically for managing interface types. A callback function used by the type system to initialize a new interface. This function should initialize all internal data and allocate any resources required by the interface.

The interface structure to initialize. The @interface_data supplied via the #GInterfaceInfo structure. All the fields in the <structname>GObject</structname> structure are private to the #GObject implementation and should never be accessed directly.

(inout)

The class structure for the <structname>GObject</structname> type. <example> <title>Implementing singletons using a constructor</title> <programlisting> static MySingleton *the_singleton = NULL; static GObject* my_singleton_constructor (GType type, guint n_construct_params, GObjectConstructParam *construct_params) { GObject *object; if (!the_singleton) { object = G_OBJECT_CLASS (parent_class)->constructor (type, n_construct_params, construct_params); the_singleton = MY_SINGLETON (object); } else object = g_object_ref (G_OBJECT (the_singleton)); return object; } </programlisting></example>

The <structname>GObjectConstructParam</structname> struct is an auxiliary structure used to hand #GParamSpec/#GValue pairs to the @constructor of a #GObjectClass. The type of the @finalize function of #GObjectClass.

the #GObject being finalized The type of the @get_property function of #GObjectClass.

a #GObject the numeric id under which the property was registered with g_object_class_install_property(). a #GValue to return the property value in the #GParamSpec describing the property The type of the @set_property function of #GObjectClass.

a #GObject the numeric id under which the property was registered with g_object_class_install_property(). the new value for the property the #GParamSpec describing the property Through the #GParamFlags flag values, certain aspects of parameters can be configured. All other fields of the <structname>GParamSpec</structname> struct are private and should not be used directly.

A #GParamSpec derived structure that contains the meta data for boolean properties. A #GParamSpec derived structure that contains the meta data for boxed properties. A #GParamSpec derived structure that contains the meta data for character properties. The class structure for the <structname>GParamSpec</structname> type. Normally, <structname>GParamSpec</structname> classes are filled by g_param_type_register_static(). A #GParamSpec derived structure that contains the meta data for double properties. A #GParamSpec derived structure that contains the meta data for enum properties. A #GParamSpec derived structure that contains the meta data for flags properties. A #GParamSpec derived structure that contains the meta data for float properties. A #GParamSpec derived structure that contains the meta data for #GType properties. A #GParamSpec derived structure that contains the meta data for integer properties. A #GParamSpec derived structure that contains the meta data for 64bit integer properties. A #GParamSpec derived structure that contains the meta data for long integer properties. A #GParamSpec derived structure that contains the meta data for object properties. This is a type of #GParamSpec type that simply redirects operations to another paramspec. All operations other than getting or setting the value are redirected, including accessing the nick and blurb, validating a value, and so forth. See g_param_spec_get_redirect_target() for retrieving the overidden property. #GParamSpecOverride is used in implementing g_object_class_override_property(), and will not be directly useful unless you are implementing a new base type similar to GObject. A #GParamSpec derived structure that contains the meta data for %G_TYPE_PARAM properties. A #GParamSpec derived structure that contains the meta data for pointer properties.

A #GParamSpec derived structure that contains the meta data for string properties. This structure is used to provide the type system with the information required to initialize and destruct (finalize) a parameter's class and instances thereof. The initialized structure is passed to the g_param_type_register_static() The type system will perform a deep copy of this structure, so its memory does not need to be persistent across invocation of g_param_type_register_static(). A #GParamSpec derived structure that contains the meta data for unsigned character properties. A #GParamSpec derived structure that contains the meta data for unsigned integer properties. A #GParamSpec derived structure that contains the meta data for unsigned 64bit integer properties. A #GParamSpec derived structure that contains the meta data for unsigned long integer properties. A #GParamSpec derived structure that contains the meta data for unichar (unsigned integer) properties. A #GParamSpec derived structure that contains the meta data for #GValueArray properties. A #GParamSpec derived structure that contains the meta data for #GVariant properties. The <structname>GParameter</structname> struct is an auxiliary structure used to hand parameter name/value pairs to g_object_newv(). The signal accumulator is a special callback function that can be used to collect return values of the various callbacks that are called during a signal emission. The signal accumulator is specified at signal creation time, if it is left %NULL, no accumulation of callback return values is performed. The return value of signal emissions is then the value returned by the last callback. should be aborted. Returning %FALSE means to abort the current emission and %TRUE is returned for continuation.

The accumulator function returns whether the signal emission

Signal invocation hint, see #GSignalInvocationHint. Accumulator to collect callback return values in, this is the return value of the current signal emission. A #GValue holding the return value of the signal handler. Callback data that was specified when creating the signal. A simple function pointer to get invoked when the signal is emitted. This allows you to tie a hook to the signal type, so that it will trap all emissions of that signal, from any object. You may not attach these to signals created with the #G_SIGNAL_NO_HOOKS flag. hook is disconnected (and destroyed).

whether it wants to stay connected. If it returns %FALSE, the signal

Signal invocation hint, see #GSignalInvocationHint. the number of parameters to the function, including the instance on which the signal was emitted. the instance on which the signal was emitted, followed by the parameters of the emission. user data associated with the hook. The signal flags are used to specify a signal's behaviour, the overall signal description outlines how especially the RUN flags control the stages of a signal emission. The #GSignalInvocationHint structure is used to pass on additional information to callbacks during a signal emission. The match types specify what g_signal_handlers_block_matched(), g_signal_handlers_unblock_matched() and g_signal_handlers_disconnect_matched() match signals by. A structure holding in-depth information for a specific signal. It is filled in by the g_signal_query() function. A callback function used for notification when the state of a toggle reference changes. See g_object_add_toggle_ref().

Callback data passed to g_object_add_toggle_ref() The object on which g_object_add_toggle_ref() was called. %TRUE if the toggle reference is now the last reference to the object. %FALSE if the toggle reference was the last reference and there are now other references. An opaque structure used as the base of all classes.

A callback function which is called when the reference count of a class drops to zero. It may use g_type_class_ref() to prevent the class from being freed. You should not call g_type_class_unref() from a #GTypeClassCacheFunc function to prevent infinite recursion, use g_type_class_unref_uncached() instead. The functions have to check the class id passed in to figure whether they actually want to cache the class of this type, since all classes are routed through the same #GTypeClassCacheFunc chain. called, %FALSE to continue.

%TRUE to stop further #GTypeClassCacheFuncs from being

data that was given to the g_type_add_class_cache_func() call The #GTypeClass structure which is unreferenced The <type>GTypeDebugFlags</type> enumeration values can be passed to g_type_init_with_debug_flags() to trigger debugging messages during runtime. Note that the messages can also be triggered by setting the <envar>GOBJECT_DEBUG</envar> environment variable to a ':'-separated list of "objects" and "signals". Bit masks used to check or determine characteristics of a type. Bit masks used to check or determine specific characteristics of a fundamental type. A structure that provides information to the type system which is used specifically for managing fundamental types. This structure is used to provide the type system with the information required to initialize and destruct (finalize) a type's class and its instances. The initialized structure is passed to the g_type_register_static() function (or is copied into the provided #GTypeInfo structure in the g_type_plugin_complete_type_info()). The type system will perform a deep copy of this structure, so its memory does not need to be persistent across invocation of g_type_register_static(). An opaque structure used as the base of all type instances.

An opaque structure used as the base of all interface types. A callback called after an interface vtable is initialized. See g_type_add_interface_check().

data passed to g_type_add_interface_check(). the interface that has been initialized The members of the <structname>GTypeModule</structname> structure should not be accessed directly, except for the @name field.

In order to implement dynamic loading of types based on #GTypeModule, the @load and @unload functions in #GTypeModuleClass must be implemented.

The <structname>GTypePlugin</structname> typedef is used as a placeholder for objects that implement the <structname>GTypePlugin</structname> interface.

The #GTypePlugin interface is used by the type system in order to handle the lifecycle of dynamically loaded types. The type of the @complete_interface_info function of #GTypePluginClass.

the #GTypePlugin the #GType of an instantiable type to which the interface is added the #GType of the interface whose info is completed the #GInterfaceInfo to fill in The type of the @complete_type_info function of #GTypePluginClass.

the #GTypePlugin the #GType whose info is completed the #GTypeInfo struct to fill in the #GTypeValueTable to fill in The type of the @unuse_plugin function of #GTypePluginClass.

the #GTypePlugin whose use count should be decreased The type of the @use_plugin function of #GTypePluginClass, which gets called to increase the use count of @plugin.

the #GTypePlugin whose use count should be increased A structure holding information for a specific type. It is filled in by the g_type_query() function. The #GTypeValueTable provides the functions required by the #GValue implementation, to serve as a container for values of a type. An opaque structure used to hold different types of values. to functions within a #GTypeValueTable structure, or implementations of the g_value_*() API. That is, code portions which implement new fundamental types. #GValue users can not make any assumptions about how data is stored within the 2 element @data union, and the @g_type member should only be accessed through the G_VALUE_TYPE() macro.

A #GValueArray contains an array of #GValue elements.

The type of value transformation functions which can be registered with g_value_register_transform_func().

Source value. Target value. A #GWeakNotify function can be added to an object as a callback that gets triggered when the object is finalized. Since the object is already being finalized when the #GWeakNotify is called, there's not much you could do with the object, apart from e.g. using its adress as hash-index or the like.

data that was provided when the weak reference was established the object being finalized