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 initialization is performed. See GClassInitFunc() for a discussion of the class initialization process.
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 initialization process.
A function to be called to transform @from_value to @to_value. If this is the @transform_to function of a binding, then @from_value is the @source_property on the @source object, and @to_value is the @target_property on the @target object. If this is the @transform_from function of a %G_BINDING_BIDIRECTIONAL binding, then those roles are reversed.
This function is provided by the user and should produce a copy of the passed in boxed structure.
This function is provided by the user and should free the boxed structure passed.
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).
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 type used for marshaller functions.
The type used for the various notification callbacks which can be registered on closures.
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.
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.
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 type of the @finalize function of #GObjectClass.
The type of the @get_property function of #GObjectClass.
The type of the @set_property function of #GObjectClass.
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.
This is the signature of marshaller functions, required to marshall arrays of parameter values to signal emissions into C language callback invocations. It is merely an alias to #GClosureMarshal since the #GClosure mechanism takes over responsibility of actual function invocation for the signal system.
This is the signature of va_list marshaller functions, an optional marshaller that can be used in some situations to avoid marshalling the signal argument into GValues.
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.
A callback function used for notification when the state of a toggle reference changes. See g_object_add_toggle_ref().
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.
A callback called after an interface vtable is initialized. See g_type_add_interface_check().
The type of the @complete_interface_info function of #GTypePluginClass.
The type of the @complete_type_info function of #GTypePluginClass.
The type of the @unuse_plugin function of #GTypePluginClass.
The type of the @use_plugin function of #GTypePluginClass, which gets called to increase the use count of @plugin.
This is the signature of va_list marshaller functions, an optional marshaller that can be used in some situations to avoid marshalling the signal argument into GValues.
The type of value transformation functions which can be registered with g_value_register_transform_func().
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 address as hash-index or the like.
Flags to be passed to g_object_bind_property() or g_object_bind_property_full().
The connection flags are used to specify the behaviour of a signal's connection.
Through the #GParamFlags flag values, certain aspects of parameters can be configured. See also #G_PARAM_STATIC_STRINGS.
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 match types specify what g_signal_handlers_block_matched(), g_signal_handlers_unblock_matched() and g_signal_handlers_disconnect_matched() match signals by.
A value which represents the unique identifier of a registered type.
These flags used to be passed to g_type_init_with_debug_flags() which is now deprecated.
Bit masks used to check or determine characteristics of a type.
Bit masks used to check or determine specific characteristics of a fundamental type.
Mask containing the bits of #GParamSpec.flags which are reserved for GLib.
#GParamFlags value alias for %G_PARAM_STATIC_NAME | %G_PARAM_STATIC_NICK | %G_PARAM_STATIC_BLURB.
Minimum shift count to be used for user defined flags, to be stored in #GParamSpec.flags. The maximum allowed is 10.
A mask for all #GSignalFlags bits.
A mask for all #GSignalMatchType bits.
A bit in the type number that's supposed to be left untouched.
An integer constant that represents the number of identifiers reserved for types that are assigned at compile-time.
Shift value used in converting numbers to type IDs.
First fundamental type number to create a new fundamental type id with G_TYPE_MAKE_FUNDAMENTAL() reserved for BSE.
Last fundamental type number reserved for BSE.
First fundamental type number to create a new fundamental type id with G_TYPE_MAKE_FUNDAMENTAL() reserved for GLib.
Last fundamental type number reserved for GLib.
First available fundamental type number to create new fundamental type id with G_TYPE_MAKE_FUNDAMENTAL().
If passed to G_VALUE_COLLECT(), allocated data won't be copied but used verbatim. This does not affect ref-counted types like objects.
A #GCClosure is a specialization of #GClosure for C function callbacks.
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.
A structure that provides information to the type system which is used specifically for managing interface types.
The GObjectConstructParam struct is an auxiliary structure used to hand #GParamSpec/#GValue pairs to the @constructor of a #GObjectClass.
The class structure for the GParamSpec type. Normally, GParamSpec classes are filled by g_param_type_register_static().
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().
The GParameter struct is an auxiliary structure used to hand parameter name/value pairs to g_object_newv().
The #GSignalInvocationHint structure is used to pass on additional information to callbacks during a signal emission.
A structure holding in-depth information for a specific signal. It is filled in by the g_signal_query() function.
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.
In order to implement dynamic loading of types based on #GTypeModule, the @load and @unload functions in #GTypeModuleClass must be implemented.
The #GTypePlugin interface is used by the type system in order to handle the lifecycle of dynamically loaded types.
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.