IOModule

Description Provides an interface and default functions for loading and unloading modules. This is used internally to make GIO extensible, but can also be used by others to implement module loading.

Constructors

this
this(GIOModule* gIOModule)

Sets our main struct and passes it to the parent class

this
this(string filename)

Creates a new GIOModule that will load the specific shared library when in use.

Members

Functions

getIOModuleStruct
GIOModule* getIOModuleStruct()
Undocumented in source. Be warned that the author may not have intended to support it.
getStruct
void* getStruct()

the main Gtk struct as a void*

load
void load()

Required API for GIO modules to implement. This function is ran after the module has been loaded into GIO, to initialize the module.

setStruct
void setStruct(GObject* obj)
Undocumented in source. Be warned that the author may not have intended to support it.
unload
void unload()

Required API for GIO modules to implement. This function is ran when the module is being unloaded from GIO, to finalize the module.

Static functions

modulesLoadAllInDirectory
ListG modulesLoadAllInDirectory(string dirname)

Loads all the modules in the specified directory. If don't require all modules to be initialized (and thus registering all gtypes) then you can use g_io_modules_scan_all_in_directory() which allows delayed/lazy loading of modules.

modulesScanAllInDirectory
void modulesScanAllInDirectory(string dirname)

Scans all the modules in the specified directory, ensuring that any extension point implemented by a module is registered. This may not actually load and initialize all the types in each module, some modules may be lazily loaded and initialized when an extension point it implementes is used with e.g. g_io_extension_point_get_extensions() or g_io_extension_point_get_extension_by_name(). If you need to guarantee that all types are loaded in all the modules, use g_io_modules_load_all_in_directory(). Since 2.24

query
string[] query()

Optional API for GIO modules to implement. Should return a list of all the extension points that may be implemented in this module. This method will not be called in normal use, however it may be called when probing existing modules and recording which extension points that this modle is used for. This means we won't have to load and initialze this module unless its needed. If this function is not implemented by the module the module will always be loaded, initialized and then unloaded on application startup so that it can register its extension points during init. Note that a module need not actually implement all the extension points that g_io_module_query returns, since the exact list of extension may depend on runtime issues. However all extension points actually implemented must be returned by g_io_module_query() (if defined). When installing a module that implements g_io_module_query you must run gio-querymodules in order to build the cache files required for lazy loading. Since 2.24

Variables

gIOModule
GIOModule* gIOModule;

the main Gtk struct

Inherited Members

From TypeModule

gTypeModule
GTypeModule* gTypeModule;

the main Gtk struct

getTypeModuleStruct
GTypeModule* getTypeModuleStruct()
Undocumented in source. Be warned that the author may not have intended to support it.
getStruct
void* getStruct()

the main Gtk struct as a void*

setStruct
void setStruct(GObject* obj)
Undocumented in source. Be warned that the author may not have intended to support it.
use
int use()

Increases the use count of a GTypeModule by one. If the use count was zero before, the plugin will be loaded. If loading the plugin fails, the use count is reset to its prior value.

unuse
void unuse()

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.)

setName
void setName(string name)

Sets the name for a GTypeModule

registerType
GType registerType(GType parentType, string typeName, GTypeInfo* typeInfo, GTypeFlags flags)

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. 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. As long as any instances of the type exist, the type plugin will not be unloaded.

addInterface
void addInterface(GType instanceType, GType interfaceType, GInterfaceInfo* interfaceInfo)

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. As long as any instances of the type exist, the type plugin will not be unloaded.

registerEnum
GType registerEnum(string name, Enums _StaticValues)

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. As long as any instances of the type exist, the type plugin will not be unloaded. Since 2.6

registerFlags
GType registerFlags(string name, Flags _StaticValues)

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. As long as any instances of the type exist, the type plugin will not be unloaded. Since 2.6

Meta