libgimpmodule/gimpmodule.c

   1 /* LIBGIMP - The GIMP Library
   2  * Copyright (C) 1995-1997 Peter Mattis and Spencer Kimball
   3  *
   4  * gimpmodule.c
   5  * (C) 1999 Austin Donnelly <austin@gimp.org>
   6  *
   7  * This library is free software: you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 3 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library.  If not, see
  19  * <https://www.gnu.org/licenses/>.
  20  */
  21
  22 #include "config.h"
  23
  24 #include <string.h>
  25
  26 #include <gio/gio.h>
  27
  28 #include "libgimpbase/gimpbase.h"
  29
  30 #include "gimpmodule.h"
  31
  32 #include "libgimp/libgimp-intl.h"
  33
  34
  35 /**
  36  * SECTION: gimpmodule
  37  * @title: GimpModule
  38  * @short_description: A #GTypeModule subclass which implements module
  39  *                     loading using #GModule.
  40  * @see_also: #GModule, #GTypeModule
  41  *
  42  * A #GTypeModule subclass which implements module loading using #GModule.
  43  **/
  44
  45
  46 enum
  47 {
  48   MODIFIED,
  49   LAST_SIGNAL
  50 };
  51
  52
  53 static void       gimp_module_finalize       (GObject     *object);
  54
  55 static gboolean   gimp_module_load           (GTypeModule *module);
  56 static void       gimp_module_unload         (GTypeModule *module);
  57
  58 static gboolean   gimp_module_open           (GimpModule  *module);
  59 static gboolean   gimp_module_close          (GimpModule  *module);
  60 static void       gimp_module_set_last_error (GimpModule  *module,
  61                                               const gchar *error_str);
  62
  63
  64 G_DEFINE_TYPE (GimpModule, gimp_module, G_TYPE_TYPE_MODULE)
  65
  66 #define parent_class gimp_module_parent_class
  67
  68 static guint module_signals[LAST_SIGNAL];
  69
  70
  71 static void
  72 gimp_module_class_init (GimpModuleClass *klass)
  73 {
  74   GObjectClass     *object_class = G_OBJECT_CLASS (klass);
  75   GTypeModuleClass *module_class = G_TYPE_MODULE_CLASS (klass);
  76
  77   module_signals[MODIFIED] =
  78     g_signal_new ("modified",
  79                   G_TYPE_FROM_CLASS (klass),
  80                   G_SIGNAL_RUN_FIRST,
  81                   G_STRUCT_OFFSET (GimpModuleClass, modified),
  82                   NULL, NULL,
  83                   g_cclosure_marshal_VOID__VOID,
  84                   G_TYPE_NONE, 0);
  85
  86   object_class->finalize = gimp_module_finalize;
  87
  88   module_class->load     = gimp_module_load;
  89   module_class->unload   = gimp_module_unload;
  90
  91   klass->modified        = NULL;
  92 }
  93
  94 static void
  95 gimp_module_init (GimpModule *module)
  96 {
  97   module->filename          = NULL;
  98   module->verbose           = FALSE;
  99   module->state             = GIMP_MODULE_STATE_ERROR;
 100   module->on_disk           = FALSE;
 101   module->load_inhibit      = FALSE;
 102
 103   module->module            = NULL;
 104   module->info              = NULL;
 105   module->last_module_error = NULL;
 106
 107   module->query_module      = NULL;
 108   module->register_module   = NULL;
 109 }
 110
 111 static void
 112 gimp_module_finalize (GObject *object)
 113 {
 114   GimpModule *module = GIMP_MODULE (object);
 115
 116   if (module->info)
 117     {
 118       gimp_module_info_free (module->info);
 119       module->info = NULL;
 120     }
 121
 122   if (module->last_module_error)
 123     {
 124       g_free (module->last_module_error);
 125       module->last_module_error = NULL;
 126     }
 127
 128   if (module->filename)
 129     {
 130       g_free (module->filename);
 131       module->filename = NULL;
 132     }
 133
 134   G_OBJECT_CLASS (parent_class)->finalize (object);
 135 }
 136
 137 static gboolean
 138 gimp_module_load (GTypeModule *module)
 139 {
 140   GimpModule *gimp_module = GIMP_MODULE (module);
 141   gpointer    func;
 142
 143   g_return_val_if_fail (gimp_module->filename != NULL, FALSE);
 144   g_return_val_if_fail (gimp_module->module == NULL, FALSE);
 145
 146   if (gimp_module->verbose)
 147     g_print ("Loading module '%s'\n",
 148              gimp_filename_to_utf8 (gimp_module->filename));
 149
 150   if (! gimp_module_open (gimp_module))
 151     return FALSE;
 152
 153   if (! gimp_module_query_module (gimp_module))
 154     return FALSE;
 155
 156   /* find the gimp_module_register symbol */
 157   if (! g_module_symbol (gimp_module->module, "gimp_module_register", &func))
 158     {
 159       gimp_module_set_last_error (gimp_module,
 160                                   "Missing gimp_module_register() symbol");
 161
 162       g_message (_("Module '%s' load error: %s"),
 163                  gimp_filename_to_utf8 (gimp_module->filename),
 164                  gimp_module->last_module_error);
 165
 166       gimp_module_close (gimp_module);
 167
 168       gimp_module->state = GIMP_MODULE_STATE_ERROR;
 169
 170       return FALSE;
 171     }
 172
 173   gimp_module->register_module = func;
 174
 175   if (! gimp_module->register_module (module))
 176     {
 177       gimp_module_set_last_error (gimp_module,
 178                                   "gimp_module_register() returned FALSE");
 179
 180       g_message (_("Module '%s' load error: %s"),
 181                  gimp_filename_to_utf8 (gimp_module->filename),
 182                  gimp_module->last_module_error);
 183
 184       gimp_module_close (gimp_module);
 185
 186       gimp_module->state = GIMP_MODULE_STATE_LOAD_FAILED;
 187
 188       return FALSE;
 189     }
 190
 191   gimp_module->state = GIMP_MODULE_STATE_LOADED;
 192
 193   return TRUE;
 194 }
 195
 196 static void
 197 gimp_module_unload (GTypeModule *module)
 198 {
 199   GimpModule *gimp_module = GIMP_MODULE (module);
 200
 201   g_return_if_fail (gimp_module->module != NULL);
 202
 203   if (gimp_module->verbose)
 204     g_print ("Unloading module '%s'\n",
 205              gimp_filename_to_utf8 (gimp_module->filename));
 206
 207   gimp_module_close (gimp_module);
 208 }
 209
 210
 211 /*  public functions  */
 212
 213 /**
 214  * gimp_module_new:
 215  * @filename:     The filename of a loadable module.
 216  * @load_inhibit: Pass %TRUE to exclude this module from auto-loading.
 217  * @verbose:      Pass %TRUE to enable debugging output.
 218  *
 219  * Creates a new #GimpModule instance.
 220  *
 221  * Return value: The new #GimpModule object.
 222  **/
 223 GimpModule *
 224 gimp_module_new (const gchar *filename,
 225                  gboolean     load_inhibit,
 226                  gboolean     verbose)
 227 {
 228   GimpModule *module;
 229
 230   g_return_val_if_fail (filename != NULL, NULL);
 231
 232   module = g_object_new (GIMP_TYPE_MODULE, NULL);
 233
 234   module->filename     = g_strdup (filename);
 235   module->load_inhibit = load_inhibit ? TRUE : FALSE;
 236   module->verbose      = verbose ? TRUE : FALSE;
 237   module->on_disk      = TRUE;
 238
 239   if (! module->load_inhibit)
 240     {
 241       if (gimp_module_load (G_TYPE_MODULE (module)))
 242         gimp_module_unload (G_TYPE_MODULE (module));
 243     }
 244   else
 245     {
 246       if (verbose)
 247         g_print ("Skipping module '%s'\n",
 248                  gimp_filename_to_utf8 (filename));
 249
 250       module->state = GIMP_MODULE_STATE_NOT_LOADED;
 251     }
 252
 253   return module;
 254 }
 255
 256 /**
 257  * gimp_module_query_module:
 258  * @module: A #GimpModule.
 259  *
 260  * Queries the module without actually registering any of the types it
 261  * may implement. After successful query, the @info field of the
 262  * #GimpModule struct will be available for further inspection.
 263  *
 264  * Return value: %TRUE on success.
 265  **/
 266 gboolean
 267 gimp_module_query_module (GimpModule *module)
 268 {
 269   const GimpModuleInfo *info;
 270   gboolean              close_module = FALSE;
 271   gpointer              func;
 272
 273   g_return_val_if_fail (GIMP_IS_MODULE (module), FALSE);
 274
 275   if (! module->module)
 276     {
 277       if (! gimp_module_open (module))
 278         return FALSE;
 279
 280       close_module = TRUE;
 281     }
 282
 283   /* find the gimp_module_query symbol */
 284   if (! g_module_symbol (module->module, "gimp_module_query", &func))
 285     {
 286       gimp_module_set_last_error (module,
 287                                   "Missing gimp_module_query() symbol");
 288
 289       g_message (_("Module '%s' load error: %s"),
 290                  gimp_filename_to_utf8 (module->filename),
 291                  module->last_module_error);
 292
 293       gimp_module_close (module);
 294
 295       module->state = GIMP_MODULE_STATE_ERROR;
 296       return FALSE;
 297     }
 298
 299   module->query_module = func;
 300
 301   if (module->info)
 302     {
 303       gimp_module_info_free (module->info);
 304       module->info = NULL;
 305     }
 306
 307   info = module->query_module (G_TYPE_MODULE (module));
 308
 309   if (! info || info->abi_version != GIMP_MODULE_ABI_VERSION)
 310     {
 311       gimp_module_set_last_error (module,
 312                                   info ?
 313                                   "module ABI version does not match" :
 314                                   "gimp_module_query() returned NULL");
 315
 316       g_message (_("Module '%s' load error: %s"),
 317                  gimp_filename_to_utf8 (module->filename),
 318                  module->last_module_error);
 319
 320       gimp_module_close (module);
 321
 322       module->state = GIMP_MODULE_STATE_ERROR;
 323       return FALSE;
 324     }
 325
 326   module->info = gimp_module_info_copy (info);
 327
 328   if (close_module)
 329     return gimp_module_close (module);
 330
 331   return TRUE;
 332 }
 333
 334 /**
 335  * gimp_module_modified:
 336  * @module: A #GimpModule.
 337  *
 338  * Emits the "modified" signal. Call it whenever you have modified the module
 339  * manually (which you shouldn't do).
 340  **/
 341 void
 342 gimp_module_modified (GimpModule *module)
 343 {
 344   g_return_if_fail (GIMP_IS_MODULE (module));
 345
 346   g_signal_emit (module, module_signals[MODIFIED], 0);
 347 }
 348
 349 /**
 350  * gimp_module_set_load_inhibit:
 351  * @module:       A #GimpModule.
 352  * @load_inhibit: Pass %TRUE to exclude this module from auto-loading.
 353  *
 354  * Sets the @load_inhibit property if the module. Emits "modified".
 355  **/
 356 void
 357 gimp_module_set_load_inhibit (GimpModule *module,
 358                               gboolean    load_inhibit)
 359 {
 360   g_return_if_fail (GIMP_IS_MODULE (module));
 361
 362   if (load_inhibit != module->load_inhibit)
 363     {
 364       module->load_inhibit = load_inhibit ? TRUE : FALSE;
 365
 366       gimp_module_modified (module);
 367     }
 368 }
 369
 370 /**
 371  * gimp_module_state_name:
 372  * @state: A #GimpModuleState.
 373  *
 374  * Returns the translated textual representation of a #GimpModuleState.
 375  * The returned string must not be freed.
 376  *
 377  * Return value: The @state's name.
 378  **/
 379 const gchar *
 380 gimp_module_state_name (GimpModuleState state)
 381 {
 382   static const gchar * const statenames[] =
 383   {
 384     N_("Module error"),
 385     N_("Loaded"),
 386     N_("Load failed"),
 387     N_("Not loaded")
 388   };
 389
 390   g_return_val_if_fail (state >= GIMP_MODULE_STATE_ERROR &&
 391                         state <= GIMP_MODULE_STATE_NOT_LOADED, NULL);
 392
 393   return gettext (statenames[state]);
 394 }
 395
 396 /**
 397  * gimp_module_error_quark:
 398  *
 399  * This function is never called directly. Use GIMP_MODULE_ERROR() instead.
 400  *
 401  * Return value: the #GQuark that defines the GIMP module error domain.
 402  *
 403  * Since: 2.8
 404  **/
 405 GQuark
 406 gimp_module_error_quark (void)
 407 {
 408   return g_quark_from_static_string ("gimp-module-error-quark");
 409 }
 410
 411
 412 /*  private functions  */
 413
 414 static gboolean
 415 gimp_module_open (GimpModule *module)
 416 {
 417   module->module = g_module_open (module->filename, 0);
 418
 419   if (! module->module)
 420     {
 421       module->state = GIMP_MODULE_STATE_ERROR;
 422       gimp_module_set_last_error (module, g_module_error ());
 423
 424       g_message (_("Module '%s' load error: %s"),
 425                  gimp_filename_to_utf8 (module->filename),
 426                  module->last_module_error);
 427
 428       return FALSE;
 429     }
 430
 431   return TRUE;
 432 }
 433
 434 static gboolean
 435 gimp_module_close (GimpModule *module)
 436 {
 437   g_module_close (module->module); /* FIXME: error handling */
 438   module->module          = NULL;
 439   module->query_module    = NULL;
 440   module->register_module = NULL;
 441
 442   module->state = GIMP_MODULE_STATE_NOT_LOADED;
 443
 444   return TRUE;
 445 }
 446
 447 static void
 448 gimp_module_set_last_error (GimpModule  *module,
 449                             const gchar *error_str)
 450 {
 451   if (module->last_module_error)
 452     g_free (module->last_module_error);
 453
 454   module->last_module_error = g_strdup (error_str);
 455 }
 456
 457
 458 /*  GimpModuleInfo functions  */
 459
 460 /**
 461  * gimp_module_info_new:
 462  * @abi_version: The #GIMP_MODULE_ABI_VERSION the module was compiled against.
 463  * @purpose:     The module's general purpose.
 464  * @author:      The module's author.
 465  * @version:     The module's version.
 466  * @copyright:   The module's copyright.
 467  * @date:        The module's release date.
 468  *
 469  * Creates a newly allocated #GimpModuleInfo struct.
 470  *
 471  * Return value: The new #GimpModuleInfo struct.
 472  **/
 473 GimpModuleInfo *
 474 gimp_module_info_new (guint32      abi_version,
 475                       const gchar *purpose,
 476                       const gchar *author,
 477                       const gchar *version,
 478                       const gchar *copyright,
 479                       const gchar *date)
 480 {
 481   GimpModuleInfo *info = g_slice_new0 (GimpModuleInfo);
 482
 483   info->abi_version = abi_version;
 484   info->purpose     = g_strdup (purpose);
 485   info->author      = g_strdup (author);
 486   info->version     = g_strdup (version);
 487   info->copyright   = g_strdup (copyright);
 488   info->date        = g_strdup (date);
 489
 490   return info;
 491 }
 492
 493 /**
 494  * gimp_module_info_copy:
 495  * @info: The #GimpModuleInfo struct to copy.
 496  *
 497  * Copies a #GimpModuleInfo struct.
 498  *
 499  * Return value: The new copy.
 500  **/
 501 GimpModuleInfo *
 502 gimp_module_info_copy (const GimpModuleInfo *info)
 503 {
 504   g_return_val_if_fail (info != NULL, NULL);
 505
 506   return gimp_module_info_new (info->abi_version,
 507                                info->purpose,
 508                                info->author,
 509                                info->version,
 510                                info->copyright,
 511                                info->date);
 512 }
 513
 514 /**
 515  * gimp_module_info_free:
 516  * @info: The #GimpModuleInfo struct to free
 517  *
 518  * Frees the passed #GimpModuleInfo.
 519  **/
 520 void
 521 gimp_module_info_free (GimpModuleInfo *info)
 522 {
 523   g_return_if_fail (info != NULL);
 524
 525   g_free (info->purpose);
 526   g_free (info->author);
 527   g_free (info->version);
 528   g_free (info->copyright);
 529   g_free (info->date);
 530
 531   g_slice_free (GimpModuleInfo, info);
 532 }