IOModule

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.

class IOModule : TypeModule {

protected

GIOModule* gIOModule;

GIOModule* getIOModuleStruct();

void* getStruct();

this(GIOModule* gIOModule);

void setStruct(GObject* obj);

this(string filename);

static ListG loadAllInDirectory(string dirname);

static ListG loadAllInDirectoryWithScope(string dirname, IOModuleScope scop);

static void scanAllInDirectory(string dirname);

static void scanAllInDirectoryWithScope(string dirname, IOModuleScope scop);

void load();

void unload();

static string[] query();

}

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(): Get the main Gtk struct
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

loadAllInDirectory ListG loadAllInDirectory(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.
loadAllInDirectoryWithScope ListG loadAllInDirectoryWithScope(string dirname, IOModuleScope scop): 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. Since 2.30
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 model 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
scanAllInDirectory void scanAllInDirectory(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
scanAllInDirectoryWithScope void scanAllInDirectoryWithScope(string dirname, IOModuleScope scop): 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.30

Variables

gIOModule GIOModule* gIOModule;: the main Gtk struct

Inherited Members

From TypeModule

gTypeModule GTypeModule* gTypeModule;: the main Gtk struct
getTypeModuleStruct GTypeModule* getTypeModuleStruct(): Get the main Gtk struct
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