GimpModule

typedef struct {
  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;

GimpModule is a generic mechanism to dynamically load modules into 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.

GimpModuleInfo

typedef struct {
  guint32  abi_version;
  gchar   *purpose;
  gchar   *author;
  gchar   *version;
  gchar   *copyright;
  gchar   *date;
} GimpModuleInfo;

This structure contains information about a loadable module.

enum GimpModuleState

typedef enum {
  GIMP_MODULE_STATE_ERROR,
  GIMP_MODULE_STATE_LOADED,
  GIMP_MODULE_STATE_LOAD_FAILED,
  GIMP_MODULE_STATE_NOT_LOADED
} GimpModuleState;

The possible states a GimpModule can be in.

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

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.

GIMP_MODULE_ERROR

#define GIMP_MODULE_ERROR (gimp_module_error_quark ())

enum GimpModuleError

typedef enum {
  GIMP_MODULE_FAILED             /* generic error condition */
} GimpModuleError;

GIMP_MODULE_ABI_VERSION

#define GIMP_MODULE_ABI_VERSION 0x0004

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_ABI_VERSION is incremented each time one of the following changes:

- the libgimpmodule implementation (if the change affects modules).

- one of the classes implemented by modules (currently GimpColorDisplay, GimpColorSelector and GimpController).

GIMP_MODULE_PARAM_SERIALIZE

#define GIMP_MODULE_PARAM_SERIALIZE (1 << (0 + G_PARAM_USER_SHIFT))

gimp_module_new ()

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

Creates a new GimpModule instance.

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

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.

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

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.

gimp_module_register_enum ()

GType               gimp_module_register_enum           (GTypeModule *module,
                                                         const gchar *name,
                                                         const GEnumValue *const_static_values);

This function is deprecated! Use g_type_module_register_enum() instead.

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.

gimp_module_info_copy ()

GimpModuleInfo *    gimp_module_info_copy               (const GimpModuleInfo *info);

Copies a GimpModuleInfo struct.

gimp_module_info_free ()

void                gimp_module_info_free               (GimpModuleInfo *info);

Frees the passed GimpModuleInfo.

gimp_module_error_quark ()

GQuark              gimp_module_error_quark             (void);

This function is never called directly. Use GIMP_MODULE_ERROR() instead.

Since GIMP 2.8

The "modified" signal

void                user_function                      (GimpModule *gimpmodule,
                                                        gpointer    user_data)       : Run First