gobject.Type.Type Class Reference

List of all members.

Detailed Description

Description The GType API is the foundation of the GObject system.

It provides the facilities for registering and managing all fundamental data types, user-defined object and interface types. Before using any GType or GObject functions, g_type_init() must be called to initialize the type system. For type creation and registration purposes, all types fall into one of two categories: static or dynamic. Static types are never loaded or unloaded at run-time as dynamic types may be. Static types are created with g_type_register_static() that gets type specific information passed in via a GTypeInfo structure. Dynamic types are created with g_type_register_dynamic() which takes a GTypePlugin structure instead. The remaining type information (the GTypeInfo structure) is retrieved during runtime through GTypePlugin and the g_type_plugin_*() API. These registration functions are usually called only once from a function whose only purpose is to return the type identifier for a specific class. Once the type (or class or interface) is registered, it may be instantiated, inherited, or implemented depending on exactly what sort of type it is. There is also a third registration function for registering fundamental types called g_type_register_fundamental() which requires both a GTypeInfo structure and a GTypeFundamentalInfo structure but it is seldom used since most fundamental types are predefined rather than user-defined. A final word about type names. Such an identifier needs to be at least three characters long. There is no upper length limit. The first character needs to be a letter (a-z or A-Z) or an underscore '_'. Subsequent characters can be letters, numbers or any of '-_+'.


Static Public Member Functions

static void init ()
 Prior to any use of the type system, g_type_init() has to be called to initialize the type system and assorted other code portions (such as the various fundamental type implementations or the signal system).
static void initWithDebugFlags (GTypeDebugFlags debugFlags)
 Similar to g_type_init(), but additionally sets debug flags.
static char[] name (GType type)
 Returns the unique name that is assigned to a type ID (this is the preferred method to find out whether a specific type has been registered for the passed in ID yet).
static GQuark qname (GType type)
 Return the corresponding quark of the type IDs name.
static GType fromName (char[] name)
 Lookup the type ID from a given type name, returning 0 if no type has been registered under this name (this is the preferred method to find out by name whether a specific type has been registered yet).
static GType parent (GType type)
 Return the direct parent type of the passed in type.
static uint depth (GType type)
 Returns the length of the ancestry of the passed in type.
static GType nextBase (GType leafType, GType rootType)
 Given a leaf_type and a root_type which is contained in its anchestry, return the type that root_type is the immediate parent of.
static int isA (GType type, GType isAType)
 If is_a_type is a derivable type, check whether type is a descendant of is_a_type.
static void * classRef (GType type)
 Increments the reference count of the class structure belonging to type.
static void * classPeek (GType type)
 This function is essentially the same as g_type_class_ref(), except that the classes reference count isn't incremented.
static void * classPeekStatic (GType type)
 A more efficient version of g_type_class_peek() which works only for static types.
static void classUnref (void *gClass)
 Decrements the reference count of the class structure being passed in.
static void * classPeekParent (void *gClass)
 This is a convenience function often needed in class initializers.
static void classAddPrivate (void *gClass, uint privateSize)
 Registers a private structure for a instantiatable type; when an object is allocated, the private structures for the type and and all of its parent types are allocated sequentially in the same memory block as the public structures.
static void * interfacePeek (void *instanceClass, GType ifaceType)
 Returns the GTypeInterface structure of an interface to which the passed in class conforms.
static void * interfacePeekParent (void *gIface)
 Returns the corresponding GTypeInterface structure of the parent type of the instance type to which g_iface belongs.
static void * defaultInterfaceRef (GType gType)
 Increments the reference count for the interface type g_type, and returns the default interface vtable for the type.
static void * defaultInterfacePeek (GType gType)
 If the interface type g_type is currently in use, returns its default interface vtable.
static void defaultInterfaceUnref (void *gIface)
 Decrements the reference count for the type corresponding to the interface default vtable g_iface.
static GTypechildren (GType type, uint *nChildren)
 Return a newly allocated and 0-terminated array of type IDs, listing the child types of type.
static GTypeinterfaces (GType type, uint *nInterfaces)
 Return a newly allocated and 0-terminated array of type IDs, listing the interface types that type conforms to.
static GTypeinterfacePrerequisites (GType interfaceType, uint *nPrerequisites)
 Returns the prerequisites of an interfaces type.
static void setQdata (GType type, GQuark quark, void *data)
 Attaches arbitrary data to a type.
static void * getQdata (GType type, GQuark quark)
 Obtains data which has previously been attached to type with g_type_set_qdata().
static void query (GType type, GTypeQuery *query)
 Queries the type system for information about a specific type.
static GType registerStatic (GType parentType, char[] typeName, GTypeInfo *info, GTypeFlags flags)
 Registers type_name as the name of a new static type derived from parent_type.
static GType registerStaticSimple (GType parentType, char[] typeName, uint classSize, GClassInitFunc classInit, uint instanceSize, GInstanceInitFunc instanceInit, GTypeFlags flags)
 Registers type_name as the name of a new static type derived from parent_type.
static GType registerDynamic (GType parentType, char[] typeName, TypePlugin plugin, GTypeFlags flags)
 Registers type_name as the name of a new dynamic type derived from parent_type.
static GType registerFundamental (GType typeId, char[] typeName, GTypeInfo *info, GTypeFundamentalInfo *finfo, GTypeFlags flags)
 Registers type_id as the predefined identifier and type_name as the name of a fundamental type.
static void addInterfaceStatic (GType instanceType, GType interfaceType, GInterfaceInfo *info)
 Adds the static interface_type to instantiable_type.
static void addInterfaceDynamic (GType instanceType, GType interfaceType, TypePlugin plugin)
 Adds the dynamic interface_type to instantiable_type.
static void interfaceAddPrerequisite (GType interfaceType, GType prerequisiteType)
 Adds prerequisite_type to the list of prerequisites of interface_type.
static TypePlugin getPlugin (GType type)
 Returns the GTypePlugin structure for type or NULL if type does not have a GTypePlugin structure.
static TypePlugin interfaceGetPlugin (GType instanceType, GType interfaceType)
 Returns the GTypePlugin structure for the dynamic interface interface_type which has been added to instance_type, or NULL if interface_type has not been added to instance_type or does not have a GTypePlugin structure.
static GType fundamentalNext ()
 Returns the next free fundamental type id which can be used to register a new fundamental type with g_type_register_fundamental().
static GType fundamental (GType typeId)
 Internal function, used to extract the fundamental type ID portion.
static GTypeInstancecreateInstance (GType type)
 Creates and initializes an instance of type if type is valid and can be instantiated.
static void freeInstance (GTypeInstance *instanc)
 Frees an instance of a type, returning it to the instance pool for the type, if there is one.
static void addClassCacheFunc (void *cacheData, GTypeClassCacheFunc cacheFunc)
 Adds a GTypeClassCacheFunc to be called before the reference count of a class goes from one to zero.
static void removeClassCacheFunc (void *cacheData, GTypeClassCacheFunc cacheFunc)
 Removes a previously installed GTypeClassCacheFunc.
static void classUnrefUncached (void *gClass)
 A variant of g_type_class_unref() for use in GTypeClassCacheFunc implementations.
static void addInterfaceCheck (void *checkData, GTypeInterfaceCheckFunc checkFunc)
 Adds a function to be called after an interface vtable is initialized for any class (i.e.
static void removeInterfaceCheck (void *checkData, GTypeInterfaceCheckFunc checkFunc)
 Removes an interface check function added with g_type_add_interface_check().
static GTypeValueTablevalueTablePeek (GType type)
 Returns the location of the GTypeValueTable associated with type.


Member Function Documentation

static void gobject.Type.Type.addClassCacheFunc ( void *  cacheData,
GTypeClassCacheFunc  cacheFunc 
) [static]

Adds a GTypeClassCacheFunc to be called before the reference count of a class goes from one to zero.

This can be used to prevent premature class destruction. All installed GTypeClassCacheFunc functions will be chained until one of them returns TRUE. 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. cache_data: data to be passed to cache_func cache_func: a GTypeClassCacheFunc

static void gobject.Type.Type.addInterfaceCheck ( void *  checkData,
GTypeInterfaceCheckFunc  checkFunc 
) [static]

Adds a function to be called after an interface vtable is initialized for any class (i.e.

after the interface_init member of GInterfaceInfo has been called). This function is useful when you want to check an invariant that depends on the interfaces of a class. For instance, the implementation of GObject uses this facility to check that an object implements all of the properties that are defined on its interfaces. check_data: data to pass to check_func check_func: function to be called after each interface is initialized. Since 2.4

static void gobject.Type.Type.addInterfaceDynamic ( GType  instanceType,
GType  interfaceType,
TypePlugin  plugin 
) [static]

Adds the dynamic interface_type to instantiable_type.

The information contained in the GTypePlugin structure pointed to by plugin is used to manage the relationship. instance_type: the GType value of an instantiable type. interface_type: the GType value of an interface type. plugin: the GTypePlugin structure to retrieve the GInterfaceInfo from.

static void gobject.Type.Type.addInterfaceStatic ( GType  instanceType,
GType  interfaceType,
GInterfaceInfo info 
) [static]

Adds the static interface_type to instantiable_type.

The information contained in the GTypeInterfaceInfo structure pointed to by info is used to manage the relationship. instance_type: GType value of an instantiable type. interface_type: GType value of an interface type. info: The GInterfaceInfo structure for this (instance_type, interface_type) combination.

static GType* gobject.Type.Type.children ( GType  type,
uint nChildren 
) [static]

Return a newly allocated and 0-terminated array of type IDs, listing the child types of type.

The return value has to be g_free()ed after use. type: The parent type. n_children: Optional guint pointer to contain the number of child types. Returns: Newly allocated and 0-terminated array of child types.

static void gobject.Type.Type.classAddPrivate ( void *  gClass,
uint  privateSize 
) [static]

Registers a private structure for a instantiatable type; when an object is allocated, the private structures for the type and and all of its parent types are allocated sequentially in the same memory block as the public structures.

This function should be called in the type's class_init() function. The private structure can be retrieved using the G_TYPE_INSTANCE_GET_PRIVATE() macro. The following example shows attaching a private structure MyObjectPrivate to an object MyObject defined in the standard GObject fashion. typedef struct _MyObjectPrivate MyObjectPrivate; struct _MyObjectPrivate { int some_field; }; define MY_OBJECT_GET_PRIVATE(o) \ (G_TYPE_INSTANCE_GET_PRIVATE ((o), MY_TYPE_OBJECT, MyObjectPrivate)) static void my_object_class_init (MyObjectClass *klass) { g_type_class_add_private (klass, sizeof (MyObjectPrivate)); } static int my_object_get_some_field (MyObject *my_object) { MyObjectPrivate *priv = MY_OBJECT_GET_PRIVATE (my_object); return priv->some_field; } g_class: class structure for an instantiatable type private_size: size of private structure. Since 2.4

static void* gobject.Type.Type.classPeek ( GType  type  )  [static]

This function is essentially the same as g_type_class_ref(), except that the classes reference count isn't incremented.

As a consequence, this function may return NULL if the class of the type passed in does not currently exist (hasn't been referenced before). type: Type ID of a classed type. Returns: The GTypeClass structure for the given type ID or NULL if the class does not currently exist.

static void* gobject.Type.Type.classPeekParent ( void *  gClass  )  [static]

This is a convenience function often needed in class initializers.

It returns the class structure of the immediate parent type of the class passed in. Since derived classes hold a reference count on their parent classes as long as they are instantiated, the returned class will always exist. This function is essentially equivalent to: g_type_class_peek (g_type_parent (G_TYPE_FROM_CLASS (g_class))); g_class: The GTypeClass structure to retrieve the parent class for. Returns: The parent class of g_class.

static void* gobject.Type.Type.classPeekStatic ( GType  type  )  [static]

A more efficient version of g_type_class_peek() which works only for static types.

type: Type ID of a classed type. Returns: The GTypeClass structure for the given type ID or NULL if the class does not currently exist or is dynamically loaded. Since 2.4

static void* gobject.Type.Type.classRef ( GType  type  )  [static]

Increments the reference count of the class structure belonging to type.

This function will demand-create the class if it doesn't exist already. type: Type ID of a classed type. Returns: The GTypeClass structure for the given type ID.

static void gobject.Type.Type.classUnref ( void *  gClass  )  [static]

Decrements the reference count of the class structure being passed in.

Once the last reference count of a class has been released, classes may be finalized by the type system, so further dereferencing of a class pointer after g_type_class_unref() are invalid. g_class: The GTypeClass structure to unreference.

static void gobject.Type.Type.classUnrefUncached ( void *  gClass  )  [static]

A variant of g_type_class_unref() for use in GTypeClassCacheFunc implementations.

It unreferences a class without consulting the chain of GTypeClassCacheFuncs, avoiding the recursion which would occur otherwise. g_class: The GTypeClass structure to unreference.

static GTypeInstance* gobject.Type.Type.createInstance ( GType  type  )  [static]

Creates and initializes an instance of type if type is valid and can be instantiated.

The type system only performs basic allocation and structure setups for instances: actual instance creation should happen through functions supplied by the type's fundamental type implementation. So use of g_type_create_instance() is reserved for implementators of fundamental types only. E.g. instances of the GObject hierarchy should be created via g_object_new() and never directly through g_type_create_instance() which doesn't handle things like singleton objects or object construction. Note: Do not use this function, unless you're implementing a fundamental type. Also language bindings should not use this function but g_object_new() instead. type: An instantiatable type to create an instance for. Returns: An allocated and initialized instance, subject to further treatment by the fundamental type implementation.

static void* gobject.Type.Type.defaultInterfacePeek ( GType  gType  )  [static]

If the interface type g_type is currently in use, returns its default interface vtable.

g_type: an interface type Returns: the default vtable for the interface, or NULL if the type is not currently in use. Since 2.4

static void* gobject.Type.Type.defaultInterfaceRef ( GType  gType  )  [static]

Increments the reference count for the interface type g_type, and returns the default interface vtable for the type.

If the type is not currently in use, then the default vtable for the type will be created and initalized by calling the base interface init and default vtable init functions for the type (the and class_init members of GTypeInfo). Calling g_type_default_interface_ref() is useful when you want to make sure that signals and properties for an interface have been installed. g_type: an interface type Returns: the default vtable for the interface; call g_type_default_interface_unref() when you are done using the interface. Since 2.4

static void gobject.Type.Type.defaultInterfaceUnref ( void *  gIface  )  [static]

Decrements the reference count for the type corresponding to the interface default vtable g_iface.

If the type is dynamic, then when no one is using the interface and all references have been released, the finalize function for the interface's default vtable (the class_finalize member of GTypeInfo) will be called. g_iface: the default vtable structure for a interface, as returned by g_type_default_interface_ref() Since 2.4

static uint gobject.Type.Type.depth ( GType  type  )  [static]

Returns the length of the ancestry of the passed in type.

This includes the type itself, so that e.g. a fundamental type has depth 1. type: A GType value. Returns: The depth of type.

static void gobject.Type.Type.freeInstance ( GTypeInstance instanc  )  [static]

Frees an instance of a type, returning it to the instance pool for the type, if there is one.

Like g_type_create_instance(), this function is reserved for implementors of fundamental types. instance: an instance of a type.

static GType gobject.Type.Type.fromName ( char[]  name  )  [static]

Lookup the type ID from a given type name, returning 0 if no type has been registered under this name (this is the preferred method to find out by name whether a specific type has been registered yet).

name: Type name to lookup. Returns: Corresponding type ID or 0.

static GType gobject.Type.Type.fundamental ( GType  typeId  )  [static]

Internal function, used to extract the fundamental type ID portion.

use G_TYPE_FUNDAMENTAL() instead. type_id: valid type ID Returns: fundamental type ID

static GType gobject.Type.Type.fundamentalNext (  )  [static]

Returns the next free fundamental type id which can be used to register a new fundamental type with g_type_register_fundamental().

The returned type ID represents the highest currently registered fundamental type identifier. Returns: The nextmost fundamental type ID to be registered, or 0 if the type system ran out of fundamental type IDs.

static TypePlugin gobject.Type.Type.getPlugin ( GType  type  )  [static]

Returns the GTypePlugin structure for type or NULL if type does not have a GTypePlugin structure.

type: The GType to retrieve the plugin for. Returns: The corresponding plugin if type is a dynamic type, NULL otherwise.

static void* gobject.Type.Type.getQdata ( GType  type,
GQuark  quark 
) [static]

Obtains data which has previously been attached to type with g_type_set_qdata().

type: a GType quark: a GQuark id to identify the data Returns: the data, or NULL if no data was found

static void gobject.Type.Type.init (  )  [static]

Prior to any use of the type system, g_type_init() has to be called to initialize the type system and assorted other code portions (such as the various fundamental type implementations or the signal system).

static void gobject.Type.Type.initWithDebugFlags ( GTypeDebugFlags  debugFlags  )  [static]

Similar to g_type_init(), but additionally sets debug flags.

debug_flags: Bitwise combination of GTypeDebugFlags values for debugging purposes.

static void gobject.Type.Type.interfaceAddPrerequisite ( GType  interfaceType,
GType  prerequisiteType 
) [static]

Adds prerequisite_type to the list of prerequisites of interface_type.

This means that any type implementing interface_type must also implement prerequisite_type. Prerequisites can be thought of as an alternative to interface derivation (which GType doesn't support). An interface can have at most one instantiatable prerequisite type. interface_type: GType value of an interface type. prerequisite_type: GType value of an interface or instantiatable type.

static TypePlugin gobject.Type.Type.interfaceGetPlugin ( GType  instanceType,
GType  interfaceType 
) [static]

Returns the GTypePlugin structure for the dynamic interface interface_type which has been added to instance_type, or NULL if interface_type has not been added to instance_type or does not have a GTypePlugin structure.

See g_type_add_interface_dynamic(). instance_type: the GType value of an instantiatable type. interface_type: the GType value of an interface type. Returns: the GTypePlugin for the dynamic interface interface_type of instance_type.

static void* gobject.Type.Type.interfacePeek ( void *  instanceClass,
GType  ifaceType 
) [static]

Returns the GTypeInterface structure of an interface to which the passed in class conforms.

instance_class: A GTypeClass structure. iface_type: An interface ID which this class conforms to. Returns: The GTypeInterface structure of iface_type if implemented by instance_class, NULL otherwise

static void* gobject.Type.Type.interfacePeekParent ( void *  gIface  )  [static]

Returns the corresponding GTypeInterface structure of the parent type of the instance type to which g_iface belongs.

This is useful when deriving the implementation of an interface from the parent type and then possibly overriding some methods. g_iface: A GTypeInterface structure. Returns: The corresponding GTypeInterface structure of the parent type of the instance type to which g_iface belongs, or NULL if the parent type doesn't conform to the interface.

static GType* gobject.Type.Type.interfacePrerequisites ( GType  interfaceType,
uint nPrerequisites 
) [static]

Returns the prerequisites of an interfaces type.

interface_type: an interface type n_prerequisites: location to return the number of prerequisites, or NULL Returns: a newly-allocated zero-terminated array of GType containing the prerequisites of interface_type Since 2.2

static GType* gobject.Type.Type.interfaces ( GType  type,
uint nInterfaces 
) [static]

Return a newly allocated and 0-terminated array of type IDs, listing the interface types that type conforms to.

The return value has to be g_free()ed after use. type: The type to list interface types for. n_interfaces: Optional guint pointer to contain the number of interface types. Returns: Newly allocated and 0-terminated array of interface types.

static int gobject.Type.Type.isA ( GType  type,
GType  isAType 
) [static]

If is_a_type is a derivable type, check whether type is a descendant of is_a_type.

If is_a_type is an interface, check whether type conforms to it. type: Type to check anchestry for. is_a_type: Possible anchestor of type or interface type could conform to. Returns: TRUE if type is_a is_a_type holds true.

static char [] gobject.Type.Type.name ( GType  type  )  [static]

Returns the unique name that is assigned to a type ID (this is the preferred method to find out whether a specific type has been registered for the passed in ID yet).

type: Type to return name for. Returns: Static type name or NULL.

static GType gobject.Type.Type.nextBase ( GType  leafType,
GType  rootType 
) [static]

Given a leaf_type and a root_type which is contained in its anchestry, return the type that root_type is the immediate parent of.

In other words, this function determines the type that is derived directly from root_type which is also a base class of leaf_type. Given a root type and a leaf type, this function can be used to determine the types and order in which the leaf type is descended from the root type. leaf_type: Descendant of root_type and the type to be returned. root_type: Immediate parent of the returned type. Returns: Immediate child of root_type and anchestor of leaf_type.

static GType gobject.Type.Type.parent ( GType  type  )  [static]

Return the direct parent type of the passed in type.

If the passed in type has no parent, i.e. is a fundamental type, 0 is returned. type: The derived type. Returns: The parent type.

static GQuark gobject.Type.Type.qname ( GType  type  )  [static]

Return the corresponding quark of the type IDs name.

type: Type to return quark of type name for. Returns: The type names quark or 0.

static void gobject.Type.Type.query ( GType  type,
GTypeQuery query 
) [static]

Queries the type system for information about a specific type.

This function will fill in a user-provided structure to hold type-specific information. If an invalid GType is passed in, the type member of the GTypeQuery is 0. All members filled into the GTypeQuery structure should be considered constant and have to be left untouched. type: the GType value of a static, classed type. query: A user provided structure that is filled in with constant values upon success.

static GType gobject.Type.Type.registerDynamic ( GType  parentType,
char[]  typeName,
TypePlugin  plugin,
GTypeFlags  flags 
) [static]

Registers type_name as the name of a new dynamic type derived from parent_type.

The type system uses the information contained in the GTypePlugin structure pointed to by plugin to manage the type and its instances (if not abstract). The value of flags determines the nature (e.g. abstract or not) of the type. parent_type: Type from which this type will be derived. type_name: 0-terminated string used as the name of the new type. plugin: The GTypePlugin structure to retrieve the GTypeInfo from. flags: Bitwise combination of GTypeFlags values. Returns: The new type identifier or G_TYPE_INVALID if registration failed.

static GType gobject.Type.Type.registerFundamental ( GType  typeId,
char[]  typeName,
GTypeInfo info,
GTypeFundamentalInfo finfo,
GTypeFlags  flags 
) [static]

Registers type_id as the predefined identifier and type_name as the name of a fundamental type.

The type system uses the information contained in the GTypeInfo structure pointed to by info and the GTypeFundamentalInfo structure pointed to by finfo to manage the type and its instances. The value of flags determines additional characteristics of the fundamental type. type_id: A predefined GTypeFundamentals value. type_name: 0-terminated string used as the name of the new type. info: The GTypeInfo structure for this type. finfo: The GTypeFundamentalInfo structure for this type. flags: Bitwise combination of GTypeFlags values. Returns: The predefined type identifier.

static GType gobject.Type.Type.registerStatic ( GType  parentType,
char[]  typeName,
GTypeInfo info,
GTypeFlags  flags 
) [static]

Registers type_name as the name of a new static type derived from parent_type.

The type system uses the information contained in the GTypeInfo structure pointed to by info to manage the type and its instances (if not abstract). The value of flags determines the nature (e.g. abstract or not) of the type. parent_type: Type from which this type will be derived. type_name: 0-terminated string used as the name of the new type. info: The GTypeInfo structure for this type. flags: Bitwise combination of GTypeFlags values. Returns: The new type identifier.

static GType gobject.Type.Type.registerStaticSimple ( GType  parentType,
char[]  typeName,
uint  classSize,
GClassInitFunc  classInit,
uint  instanceSize,
GInstanceInitFunc  instanceInit,
GTypeFlags  flags 
) [static]

Registers type_name as the name of a new static type derived from parent_type.

The value of flags determines the nature (e.g. abstract or not) of the type. It works by filling a GTypeInfo struct and calling g_type_info_register_static(). parent_type: Type from which this type will be derived. type_name: 0-terminated string used as the name of the new type. class_size: Size of the class structure (see GTypeInfo) class_init: Location of the class initialization function (see GTypeInfo) instance_size: Size of the instance structure (see GTypeInfo) instance_init: Location of the instance initialization function (see GTypeInfo) flags: Bitwise combination of GTypeFlags values. Returns: The new type identifier. Since 2.12

static void gobject.Type.Type.removeClassCacheFunc ( void *  cacheData,
GTypeClassCacheFunc  cacheFunc 
) [static]

Removes a previously installed GTypeClassCacheFunc.

The cache maintained by cache_func has to be empty when calling g_type_remove_class_cache_func() to avoid leaks. cache_data: data that was given when adding cache_func cache_func: a GTypeClassCacheFunc

static void gobject.Type.Type.removeInterfaceCheck ( void *  checkData,
GTypeInterfaceCheckFunc  checkFunc 
) [static]

Removes an interface check function added with g_type_add_interface_check().

check_data: callback data passed to g_type_add_interface_check() check_func: callback function passed to g_type_add_interface_check() Since 2.4

static void gobject.Type.Type.setQdata ( GType  type,
GQuark  quark,
void *  data 
) [static]

Attaches arbitrary data to a type.

type: a GType quark: a GQuark id to identify the data data: the data

static GTypeValueTable* gobject.Type.Type.valueTablePeek ( GType  type  )  [static]

Returns the location of the GTypeValueTable associated with type.

Note that this function should only be used from source code that implements or has internal knowledge of the implementation of type. type: A GType value. Returns: Location of the GTypeValueTable associated with type or NULL if there is no GTypeValueTable associated with type.


SourceForge.net Logo DSource.org Logo digitalmars.com Logo