← Back to branch summary

~ubuntu-branches/ubuntu/jaunty/gimp/jaunty-security

« back to all changes in this revision

Viewing changes to libgimpmodule/gimpmodule.c

  • Committer: Bazaar Package Importer
  • Author(s): Daniel Holbach
  • Date: 2007-05-02 16:33:03 UTC
  • mfrom: (1.1.4 upstream)
  • Revision ID: james.westby@ubuntu.com-20070502163303-bvzhjzbpw8qglc4y
Tags: 2.3.16-1ubuntu1
* Resynchronized with Debian, remaining Ubuntu changes:
  - debian/rules: i18n magic.
* debian/control.in:
  - Maintainer: Ubuntu Core Developers <ubuntu-devel@lists.ubuntu.com>
* debian/patches/02_help-message.patch,
  debian/patches/03_gimp.desktop.in.in.patch,
  debian/patches/10_dont_show_wizard.patch: updated.
* debian/patches/04_composite-signedness.patch,
  debian/patches/05_add-letter-spacing.patch: dropped, used upstream.

Show diffs side-by-side

added added

removed removed

Lines of Context:
libgimpmodule/gimpmodule.c
28
28
 
29
29
#include "libgimpbase/gimpbase.h"
30
30
 
 
31
#undef GIMP_DISABLE_DEPRECATED
31
32
#include "gimpmodule.h"
32
33
 
33
34
#include "libgimp/libgimp-intl.h"
40
41
};
41
42
 
42
43
 
43
 
static void       gimp_module_class_init     (GimpModuleClass *klass);
44
 
static void       gimp_module_init           (GimpModule      *module);
45
 
 
46
 
static void       gimp_module_finalize       (GObject         *object);
47
 
 
48
 
static gboolean   gimp_module_load           (GTypeModule     *module);
49
 
static void       gimp_module_unload         (GTypeModule     *module);
50
 
 
51
 
static gboolean   gimp_module_open           (GimpModule      *module);
52
 
static gboolean   gimp_module_close          (GimpModule      *module);
53
 
static void       gimp_module_set_last_error (GimpModule      *module,
54
 
                                              const gchar     *error_str);
55
 
 
 
44
static void       gimp_module_finalize       (GObject     *object);
 
45
 
 
46
static gboolean   gimp_module_load           (GTypeModule *module);
 
47
static void       gimp_module_unload         (GTypeModule *module);
 
48
 
 
49
static gboolean   gimp_module_open           (GimpModule  *module);
 
50
static gboolean   gimp_module_close          (GimpModule  *module);
 
51
static void       gimp_module_set_last_error (GimpModule  *module,
 
52
                                              const gchar *error_str);
 
53
 
 
54
 
 
55
G_DEFINE_TYPE (GimpModule, gimp_module, G_TYPE_TYPE_MODULE)
 
56
 
 
57
#define parent_class gimp_module_parent_class
56
58
 
57
59
static guint module_signals[LAST_SIGNAL];
58
60
 
59
 
static GTypeModuleClass *parent_class = NULL;
60
 
 
61
 
 
62
 
GType
63
 
gimp_module_get_type (void)
64
 
{
65
 
  static GType module_type = 0;
66
 
 
67
 
  if (! module_type)
68
 
    {
69
 
      static const GTypeInfo module_info =
70
 
      {
71
 
        sizeof (GimpModuleClass),
72
 
        NULL,           /* base_init */
73
 
        NULL,           /* base_finalize */
74
 
        (GClassInitFunc) gimp_module_class_init,
75
 
        NULL,           /* class_finalize */
76
 
        NULL,           /* class_data */
77
 
        sizeof (GimpModule),
78
 
        0,              /* n_preallocs */
79
 
        (GInstanceInitFunc) gimp_module_init,
80
 
      };
81
 
 
82
 
      module_type = g_type_register_static (G_TYPE_TYPE_MODULE,
83
 
                                            "GimpModule",
84
 
                                            &module_info, 0);
85
 
    }
86
 
 
87
 
  return module_type;
88
 
}
89
61
 
90
62
static void
91
63
gimp_module_class_init (GimpModuleClass *klass)
92
64
{
93
 
  GObjectClass     *object_class;
94
 
  GTypeModuleClass *module_class;
95
 
 
96
 
  object_class = G_OBJECT_CLASS (klass);
97
 
  module_class = G_TYPE_MODULE_CLASS (klass);
98
 
 
99
 
  parent_class = g_type_class_peek_parent (klass);
 
65
  GObjectClass     *object_class = G_OBJECT_CLASS (klass);
 
66
  GTypeModuleClass *module_class = G_TYPE_MODULE_CLASS (klass);
100
67
 
101
68
  module_signals[MODIFIED] =
102
69
    g_signal_new ("modified",
103
 
                  G_TYPE_FROM_CLASS (klass),
104
 
                  G_SIGNAL_RUN_FIRST,
105
 
                  G_STRUCT_OFFSET (GimpModuleClass, modified),
106
 
                  NULL, NULL,
107
 
                  g_cclosure_marshal_VOID__VOID,
108
 
                  G_TYPE_NONE, 0);
 
70
                  G_TYPE_FROM_CLASS (klass),
 
71
                  G_SIGNAL_RUN_FIRST,
 
72
                  G_STRUCT_OFFSET (GimpModuleClass, modified),
 
73
                  NULL, NULL,
 
74
                  g_cclosure_marshal_VOID__VOID,
 
75
                  G_TYPE_NONE, 0);
109
76
 
110
77
  object_class->finalize = gimp_module_finalize;
111
78
 
135
102
static void
136
103
gimp_module_finalize (GObject *object)
137
104
{
138
 
  GimpModule *module;
139
 
 
140
 
  module = GIMP_MODULE (object);
 
105
  GimpModule *module = GIMP_MODULE (object);
141
106
 
142
107
  if (module->info)
143
108
    {
163
128
static gboolean
164
129
gimp_module_load (GTypeModule *module)
165
130
{
166
 
  GimpModule *gimp_module;
 
131
  GimpModule *gimp_module = GIMP_MODULE (module);
167
132
  gpointer    func;
168
133
 
169
 
  g_return_val_if_fail (GIMP_IS_MODULE (module), FALSE);
170
 
 
171
 
  gimp_module = GIMP_MODULE (module);
172
 
 
173
134
  g_return_val_if_fail (gimp_module->filename != NULL, FALSE);
174
135
  g_return_val_if_fail (gimp_module->module == NULL, FALSE);
175
136
 
176
137
  if (gimp_module->verbose)
177
 
    g_print (_("Loading module: '%s'\n"),
 
138
    g_print ("Loading module '%s'\n",
178
139
             gimp_filename_to_utf8 (gimp_module->filename));
179
140
 
180
141
  if (! gimp_module_open (gimp_module))
189
150
      gimp_module_set_last_error (gimp_module,
190
151
                                  "Missing gimp_module_register() symbol");
191
152
 
192
 
      if (gimp_module->verbose)
193
 
        g_message (_("Module '%s' load error: %s"),
194
 
                   gimp_filename_to_utf8 (gimp_module->filename),
195
 
                   gimp_module->last_module_error);
 
153
      g_message (_("Module '%s' load error: %s"),
 
154
                 gimp_filename_to_utf8 (gimp_module->filename),
 
155
                 gimp_module->last_module_error);
196
156
 
197
157
      gimp_module_close (gimp_module);
198
158
 
208
168
      gimp_module_set_last_error (gimp_module,
209
169
                                  "gimp_module_register() returned FALSE");
210
170
 
211
 
      if (gimp_module->verbose)
212
 
        g_message (_("Module '%s' load error: %s"),
213
 
                   gimp_filename_to_utf8 (gimp_module->filename),
214
 
                   gimp_module->last_module_error);
 
171
      g_message (_("Module '%s' load error: %s"),
 
172
                 gimp_filename_to_utf8 (gimp_module->filename),
 
173
                 gimp_module->last_module_error);
215
174
 
216
175
      gimp_module_close (gimp_module);
217
176
 
228
187
static void
229
188
gimp_module_unload (GTypeModule *module)
230
189
{
231
 
  GimpModule *gimp_module;
232
 
 
233
 
  g_return_if_fail (GIMP_IS_MODULE (module));
234
 
 
235
 
  gimp_module = GIMP_MODULE (module);
 
190
  GimpModule *gimp_module = GIMP_MODULE (module);
236
191
 
237
192
  g_return_if_fail (gimp_module->module != NULL);
238
193
 
 
194
  if (gimp_module->verbose)
 
195
    g_print ("Unloading module '%s'\n",
 
196
             gimp_filename_to_utf8 (gimp_module->filename));
 
197
 
239
198
  gimp_module_close (gimp_module);
240
199
}
241
200
 
276
235
  else
277
236
    {
278
237
      if (verbose)
279
 
        {
280
 
          gchar *filename_utf8 = g_filename_to_utf8 (filename,
281
 
                                                     -1, NULL, NULL, NULL);
282
 
          g_print (_("Skipping module: '%s'\n"), filename_utf8);
283
 
          g_free (filename_utf8);
284
 
        }
 
238
        g_print ("Skipping module '%s'\n",
 
239
                 gimp_filename_to_utf8 (filename));
285
240
 
286
241
      module->state = GIMP_MODULE_STATE_NOT_LOADED;
287
242
    }
322
277
      gimp_module_set_last_error (module,
323
278
                                  "Missing gimp_module_query() symbol");
324
279
 
325
 
      if (module->verbose)
326
 
        g_message (_("Module '%s' load error: %s"),
327
 
                   gimp_filename_to_utf8 (module->filename),
328
 
                   module->last_module_error);
 
280
      g_message (_("Module '%s' load error: %s"),
 
281
                 gimp_filename_to_utf8 (module->filename),
 
282
                 module->last_module_error);
329
283
 
330
284
      gimp_module_close (module);
331
285
 
350
304
                                  "module ABI version does not match" :
351
305
                                  "gimp_module_query() returned NULL");
352
306
 
353
 
      if (module->verbose)
354
 
        g_message (_("Module '%s' load error: %s"),
355
 
                   gimp_filename_to_utf8 (module->filename),
356
 
                   module->last_module_error);
 
307
      g_message (_("Module '%s' load error: %s"),
 
308
                 gimp_filename_to_utf8 (module->filename),
 
309
                 module->last_module_error);
357
310
 
358
311
      gimp_module_close (module);
359
312
 
437
390
 * @name:
438
391
 * @const_static_values:
439
392
 *
440
 
 * Registers an enum similar to g_enum_register_static() but for
441
 
 * modules. This function should actually live in GLib but since
442
 
 * there's no such API, it is provided here.
 
393
 * This function is deprecated! Use g_type_module_register_enum() instead.
443
394
 *
444
395
 * Return value: a new enum #GType
445
396
 **/
446
397
GType
447
398
gimp_module_register_enum (GTypeModule      *module,
448
 
                           const gchar      *name,
 
399
                           const gchar      *name,
449
400
                           const GEnumValue *const_static_values)
450
401
{
451
 
  GTypeInfo enum_type_info = { 0, };
452
 
 
453
 
  g_return_val_if_fail (G_IS_TYPE_MODULE (module), 0);
454
 
  g_return_val_if_fail (name != NULL, 0);
455
 
  g_return_val_if_fail (const_static_values != NULL, 0);
456
 
 
457
 
  g_enum_complete_type_info (G_TYPE_ENUM,
458
 
                             &enum_type_info, const_static_values);
459
 
 
460
 
  return g_type_module_register_type (G_TYPE_MODULE (module),
461
 
                                      G_TYPE_ENUM, name, &enum_type_info, 0);
 
402
  return g_type_module_register_enum (module, name, const_static_values);
462
403
}
463
404
 
464
405
 
474
415
      module->state = GIMP_MODULE_STATE_ERROR;
475
416
      gimp_module_set_last_error (module, g_module_error ());
476
417
 
477
 
      if (module->verbose)
478
 
        g_message (_("Module '%s' load error: %s"),
479
 
                   gimp_filename_to_utf8 (module->filename),
480
 
                   module->last_module_error);
 
418
      g_message (_("Module '%s' load error: %s"),
 
419
                 gimp_filename_to_utf8 (module->filename),
 
420
                 module->last_module_error);
481
421
 
482
422
      return FALSE;
483
423
    }