GimpModule

GimpModule — A GTypeModule subclass which implements module loading using GModule.

Synopsis




struct      GimpModule;
struct      GimpModuleInfo;
enum        GimpModuleState;
const GimpModuleInfo* (*GimpModuleQueryFunc)
                                            (GTypeModule *module);
gboolean    (*GimpModuleRegisterFunc)       (GTypeModule *module);
#define     GIMP_MODULE_ABI_VERSION
GimpModule* gimp_module_new                 (const gchar *filename,
                                             gboolean load_inhibit,
                                             gboolean verbose);
void        gimp_module_modified            (GimpModule *module);
gboolean    gimp_module_query_module        (GimpModule *module);
void        gimp_module_set_load_inhibit    (GimpModule *module,
                                             gboolean load_inhibit);
const gchar* gimp_module_state_name         (GimpModuleState state);
GimpModuleInfo* gimp_module_info_new        (guint32 abi_version,
                                             const gchar *purpose,
                                             const gchar *author,
                                             const gchar *version,
                                             const gchar *copyright,
                                             const gchar *date);
GimpModuleInfo* gimp_module_info_copy       (const GimpModuleInfo *info);
void        gimp_module_info_free           (GimpModuleInfo *info);

Object Hierarchy


  GObject
   +----GTypeModule
         +----GimpModule

Implemented Interfaces

GimpModule implements GTypePlugin.

Signal Prototypes


"modified"  void        user_function      (GimpModule *gimpmodule,
                                            gpointer user_data);

Description

A GTypeModule subclass which implements module loading using GModule.

Details

struct GimpModule

struct GimpModule {
  gchar           *filename;     /* path to the module                       */
  gboolean         verbose;      /* verbose error reporting                  */
  GimpModuleState  state;        /* what's happened to the module            */
  gboolean         on_disk;      /* TRUE if file still exists                */
  gboolean         load_inhibit; /* user requests not to load at boot time   */

  /* stuff from now on may be NULL depending on the state the module is in   */
  GimpModuleInfo  *info;         /* returned values from module_query        */
  gchar           *last_module_error;

};

GimpModule is a generic mechanism to dynamically load modules into the GIMP. It is a GTypeModule subclass, implementing module loading using GModule. GimpModule does not know which functionality is implemented by the modules, it just provides a framework to get arbitrary GType implementations loaded from disk.


struct GimpModuleInfo

struct GimpModuleInfo {

  guint32  abi_version;
  gchar   *purpose;
  gchar   *author;
  gchar   *version;
  gchar   *copyright;
  gchar   *date;
};

This structure contains information about a loadable module.

guint32 abi_versionThe GIMP_MODULE_ABI_VERSION the module was compiled against.
gchar *purpose The module's general purpose.
gchar *author The module's author.
gchar *version The module's version.
gchar *copyright The module's copyright.
gchar *date The module's release date.

enum GimpModuleState

typedef enum
{
  GIMP_MODULE_STATE_ERROR,       /* missing gimp_module_register function
                                  * or other error
                                  */
  GIMP_MODULE_STATE_LOADED,      /* an instance of a type implemented by
                                  * this module is allocated
                                  */
  GIMP_MODULE_STATE_LOAD_FAILED, /* gimp_module_register returned FALSE
                                  */
  GIMP_MODULE_STATE_NOT_LOADED   /* there are no instances allocated of
                                  * types implemented by this module
                                  */
} GimpModuleState;

The possible states a GimpModule can be in.

GIMP_MODULE_STATE_ERROR Missing gimp_module_register() function or other error.
GIMP_MODULE_STATE_LOADED An instance of a type implemented by this module is allocated.
GIMP_MODULE_STATE_LOAD_FAILEDgimp_module_register() returned FALSE.
GIMP_MODULE_STATE_NOT_LOADED There are no instances allocated of types implemented by this module.

GimpModuleQueryFunc ()

const GimpModuleInfo* (*GimpModuleQueryFunc)
                                            (GTypeModule *module);

The signature of the query function a loadable GIMP module must implement. In the module, the function must be called gimp_module_query().

GimpModule will copy the returned GimpModuleInfo struct, so the module doesn't need to keep these values around (however in most cases the module will just return a pointer to a constant structure).

module : The GimpModule responsible for this loadable module.
Returns :The GimpModuleInfo struct describing the module.

GimpModuleRegisterFunc ()

gboolean    (*GimpModuleRegisterFunc)       (GTypeModule *module);

The signature of the register function a loadable GIMP module must implement. In the module, the function must be called gimp_module_register().

When this function is called, the module should register all the types it implements with the passed module.

module : The GimpModule responsible for this loadable module.
Returns :TRUE on success, FALSE otherwise.

GIMP_MODULE_ABI_VERSION

#define GIMP_MODULE_ABI_VERSION 0x0003

The version of the module system's ABI. Modules put this value into GimpModuleInfo's abi_version field so the code loading the modules can check if it was compiled against the same module ABI the modules are compiled against.


gimp_module_new ()

GimpModule* gimp_module_new                 (const gchar *filename,
                                             gboolean load_inhibit,
                                             gboolean verbose);

Creates a new GimpModule instance.

filename : The filename of a loadable module.
load_inhibit : Pass TRUE to exclude this module from auto-loading.
verbose : Pass TRUE to enable debugging output.
Returns : The new GimpModule object.

gimp_module_modified ()

void        gimp_module_modified            (GimpModule *module);

Emits the "modified" signal. Call it whenever you have modified the module manually (which you shouldn't do).

module : A GimpModule.

gimp_module_query_module ()

gboolean    gimp_module_query_module        (GimpModule *module);

Queries the module without actually registering any of the types it may implement. After successful query, the info field of the GimpModule struct will be available for further inspection.

module : A GimpModule.
Returns : TRUE on success.

gimp_module_set_load_inhibit ()

void        gimp_module_set_load_inhibit    (GimpModule *module,
                                             gboolean load_inhibit);

Sets the load_inhibit property if the module. Emits "modified".

module : A GimpModule.
load_inhibit : Pass TRUE to exclude this module from auto-loading.

gimp_module_state_name ()

const gchar* gimp_module_state_name         (GimpModuleState state);

Returns the translated textual representation of a GimpModuleState. The returned string must not be freed.

state : A GimpModuleState.
Returns : The state's name.

gimp_module_info_new ()

GimpModuleInfo* gimp_module_info_new        (guint32 abi_version,
                                             const gchar *purpose,
                                             const gchar *author,
                                             const gchar *version,
                                             const gchar *copyright,
                                             const gchar *date);

Creates a newly allocated GimpModuleInfo struct.

abi_version : The GIMP_MODULE_ABI_VERSION the module was compiled against.
purpose : The module's general purpose.
author : The module's author.
version : The module's version.
copyright : The module's copyright.
date : The module's release date.
Returns : The new GimpModuleInfo struct.

gimp_module_info_copy ()

GimpModuleInfo* gimp_module_info_copy       (const GimpModuleInfo *info);

Copies a GimpModuleInfo struct.

info : The GimpModuleInfo struct to copy.
Returns : The new copy.

gimp_module_info_free ()

void        gimp_module_info_free           (GimpModuleInfo *info);

Frees the passed GimpModuleInfo.

info : The GimpModuleInfo struct to free

Signals

The "modified" signal

void        user_function                  (GimpModule *gimpmodule,
                                            gpointer user_data);

gimpmodule :the object which received the signal.
user_data :user data set when the signal handler was connected.

See Also

GModule

GTypeModule