| <!-- ##### SECTION Title ##### --> |
| GTypeModule |
| |
| <!-- ##### SECTION Short_Description ##### --> |
| Type loading modules |
| |
| <!-- ##### SECTION Long_Description ##### --> |
| <para> |
| #GTypeModule provides a simple implementation of the #GTypePlugin |
| interface. The model of #GTypeModule is a dynamically loaded module |
| which implements some number of types and interface |
| implementations. When the module is loaded, it registers its types |
| and interfaces using g_type_module_register_type() and |
| g_type_module_add_interface(). As long as any instances of these |
| types and interface implementations are in use, the module is kept |
| loaded. When the types and interfaces are gone, the module may be |
| unloaded. If the types and interfaces become used again, the module |
| will be reloaded. |
| </para> |
| <para> |
| Keeping track of whether the module should be loaded or not is done by |
| using a use count - it starts at zero, and whenever it is greater than |
| zero, the module is loaded. The use count is maintained internally by |
| the type system, but also can be explicitly controlled by |
| g_type_module_use() and g_type_module_unuse(). Typically, when loading |
| a module for the first type, g_type_module_use() will be used to load |
| it so that it can initialize its types. At some later point, when the |
| module no longer needs to be loaded except for the type |
| implementations it contains, g_type_module_unuse() is called. |
| </para> |
| <para> |
| #GTypeModule does not actually provide any implementation of module |
| loading and unloading. To create a particular module type you must |
| derive from #GTypeModule and implement the load and unload functions |
| in #GTypeModuleClass. |
| </para> |
| |
| <!-- ##### SECTION See_Also ##### --> |
| <para> |
| <variablelist> |
| |
| <varlistentry> |
| <term>#GTypePlugin</term> |
| <listitem><para>The abstract type loader interface.</para></listitem> |
| </varlistentry> |
| |
| <varlistentry> |
| <term>#GModule</term> |
| <listitem><para>Portable mechanism for dynamically loaded modules.</para></listitem> |
| </varlistentry> |
| |
| </variablelist> |
| </para> |
| |
| <!-- ##### STRUCT GTypeModule ##### --> |
| <para> |
| The members of the <structname>GTypeModule</structname> structure should not |
| be accessed directly, except for the @name field. |
| </para> |
| |
| @name: |
| |
| <!-- ##### STRUCT GTypeModuleClass ##### --> |
| <para> |
| In order to implement dynamic loading of types based on #GTypeModule, |
| the @load and @unload functions in #GTypeModuleClass must be implemented. |
| </para> |
| |
| @parent_class: |
| @load: loads the module and registers one or more types using |
| g_type_module_register_type(). |
| @unload: unloads the module |
| |
| <!-- ##### FUNCTION g_type_module_use ##### --> |
| <para> |
| Increases the use count of a #GTypeModule by one. If the |
| use count was zero before, the plugin will be loaded. |
| </para> |
| |
| @module: a #GTypeModule |
| @Returns: %FALSE if the plugin needed to be loaded and |
| loading the plugin failed. |
| |
| |
| <!-- ##### FUNCTION g_type_module_unuse ##### --> |
| <para> |
| Decreases the use count of a #GTypeModule by one. If the |
| result is zero, the module will be unloaded. (However, the |
| #GTypeModule will not be freed, and types associated with the |
| #GTypeModule are not unregistered. Once a #GTypeModule is |
| initialized, it must exist forever.) |
| </para> |
| |
| @module: a #GTypeModule |
| |
| |
| <!-- ##### FUNCTION g_type_module_set_name ##### --> |
| <para> |
| Sets the name for a #GTypeModule |
| </para> |
| |
| @module: a #GTypeModule. |
| @name: a human-readable name to use in error messages. |
| |
| |
| <!-- ##### FUNCTION g_type_module_register_type ##### --> |
| <para> |
| Looks up or registers a type that is implemented with a particular |
| type plugin. If a type with name @type_name was previously registered, |
| the #GType identifier for the type is returned, otherwise the type |
| is newly registered, and the resulting #GType identifier returned. |
| </para> |
| <para> |
| When reregistering a type (typically because a module is unloaded |
| then reloaded, and reinitialized), @module and @parent_type must |
| be the same as they were previously. |
| </para> |
| <para> |
| As long as any instances of the type exist, the type plugin will |
| not be unloaded. |
| </para> |
| |
| @module: a #GTypeModule |
| @parent_type: the type for the parent class |
| @type_name: name for the type |
| @type_info: type information structure |
| @flags: flags field providing details about the type |
| @Returns: the new or existing type ID |
| |
| |
| <!-- ##### FUNCTION g_type_module_add_interface ##### --> |
| <para> |
| Registers an additional interface for a type, whose interface |
| lives in the given type plugin. If the interface was already registered |
| for the type in this plugin, nothing will be done. |
| </para> |
| <para> |
| As long as any instances of the type exist, the type plugin will |
| not be unloaded. |
| </para> |
| |
| @module: a #GTypeModule |
| @instance_type: type to which to add the interface. |
| @interface_type: interface type to add |
| @interface_info: type information structure |
| |
| |
| <!-- ##### FUNCTION g_type_module_register_enum ##### --> |
| <para> |
| Looks up or registers an enumeration that is implemented with a particular |
| type plugin. If a type with name @type_name was previously registered, |
| the #GType identifier for the type is returned, otherwise the type |
| is newly registered, and the resulting #GType identifier returned. |
| </para> |
| <para> |
| As long as any instances of the type exist, the type plugin will |
| not be unloaded. |
| </para> |
| |
| @module: a #GTypeModule |
| @name: name for the type |
| @const_static_values: an array of #GEnumValue structs for the possible |
| enumeration values. The array is terminated by a struct with all |
| members being 0. |
| @Returns: the new or existing type ID |
| @Since: 2.6 |
| |
| |
| <!-- ##### FUNCTION g_type_module_register_flags ##### --> |
| <para> |
| Looks up or registers a flags type that is implemented with a particular |
| type plugin. If a type with name @type_name was previously registered, |
| the #GType identifier for the type is returned, otherwise the type |
| is newly registered, and the resulting #GType identifier returned. |
| </para> |
| <para> |
| As long as any instances of the type exist, the type plugin will |
| not be unloaded. |
| </para> |
| |
| @module: a #GTypeModule |
| @name: name for the type |
| @const_static_values: an array of #GFlagsValue structs for the possible |
| flags values. The array is terminated by a struct with all |
| members being 0. |
| @Returns: the new or existing type ID |
| @Since: 2.6 |
| |
| |