← Back to branch summary

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

« back to all changes in this revision

Viewing changes to app/core/gimpdata.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:
app/core/gimpdata.c
1
 
/* The GIMP -- an image manipulation program
 
1
/* GIMP - The GNU Image Manipulation Program
2
2
 * Copyright (C) 1995 Spencer Kimball and Peter Mattis
3
3
 *
4
4
 * gimpdata.c
22
22
#include "config.h"
23
23
 
24
24
#include <errno.h>
25
 
#include <stdio.h>
26
25
#include <string.h>
27
26
 
28
27
#ifdef HAVE_UNISTD_H
30
29
#endif
31
30
 
32
31
#include <glib-object.h>
 
32
#include <glib/gstdio.h>
33
33
 
34
34
#include "libgimpbase/gimpbase.h"
35
35
 
44
44
 
45
45
#include "gimp-intl.h"
46
46
 
47
 
/* Need this test somewhere, might as well do it here */
48
 
#ifdef G_OS_WIN32
49
 
#if GLIB_CHECK_VERSION (2,6,0)
50
 
#error GIMP 2.2 for Win32 must be compiled against GLib 2.4 
51
 
#endif
52
 
#endif
53
47
 
54
48
enum
55
49
{
57
51
  LAST_SIGNAL
58
52
};
59
53
 
60
 
 
61
 
static void    gimp_data_class_init   (GimpDataClass *klass);
62
 
static void    gimp_data_init         (GimpData      *data,
63
 
                                       GimpDataClass *data_class);
64
 
 
65
 
static void    gimp_data_finalize     (GObject       *object);
66
 
 
67
 
static void    gimp_data_name_changed (GimpObject    *object);
68
 
static gint64  gimp_data_get_memsize  (GimpObject    *object,
69
 
                                       gint64        *gui_size);
70
 
 
71
 
static void    gimp_data_real_dirty   (GimpData      *data);
 
54
enum
 
55
{
 
56
  PROP_0,
 
57
  PROP_FILENAME,
 
58
  PROP_WRITABLE,
 
59
  PROP_DELETABLE,
 
60
  PROP_MIME_TYPE
 
61
};
 
62
 
 
63
 
 
64
static void      gimp_data_class_init   (GimpDataClass *klass);
 
65
static void      gimp_data_init         (GimpData      *data,
 
66
                                         GimpDataClass *data_class);
 
67
 
 
68
static GObject * gimp_data_constructor  (GType                  type,
 
69
                                         guint                  n_params,
 
70
                                         GObjectConstructParam *params);
 
71
 
 
72
static void      gimp_data_finalize     (GObject       *object);
 
73
static void      gimp_data_set_property (GObject       *object,
 
74
                                         guint          property_id,
 
75
                                         const GValue  *value,
 
76
                                         GParamSpec    *pspec);
 
77
static void      gimp_data_get_property (GObject       *object,
 
78
                                         guint          property_id,
 
79
                                         GValue        *value,
 
80
                                         GParamSpec    *pspec);
 
81
 
 
82
static gint64    gimp_data_get_memsize  (GimpObject    *object,
 
83
                                         gint64        *gui_size);
 
84
 
 
85
static void      gimp_data_real_dirty   (GimpData      *data);
72
86
 
73
87
 
74
88
static guint data_signals[LAST_SIGNAL] = { 0 };
83
97
 
84
98
  if (! data_type)
85
99
    {
86
 
      static const GTypeInfo data_info =
 
100
      const GTypeInfo data_info =
87
101
      {
88
102
        sizeof (GimpDataClass),
89
103
        (GBaseInitFunc) NULL,
121
135
                  gimp_marshal_VOID__VOID,
122
136
                  G_TYPE_NONE, 0);
123
137
 
 
138
  object_class->constructor       = gimp_data_constructor;
124
139
  object_class->finalize          = gimp_data_finalize;
 
140
  object_class->set_property      = gimp_data_set_property;
 
141
  object_class->get_property      = gimp_data_get_property;
125
142
 
126
 
  gimp_object_class->name_changed = gimp_data_name_changed;
127
143
  gimp_object_class->get_memsize  = gimp_data_get_memsize;
128
144
 
129
145
  klass->dirty                    = gimp_data_real_dirty;
130
146
  klass->save                     = NULL;
131
147
  klass->get_extension            = NULL;
132
148
  klass->duplicate                = NULL;
 
149
 
 
150
  g_object_class_install_property (object_class, PROP_FILENAME,
 
151
                                   g_param_spec_string ("filename", NULL, NULL,
 
152
                                                        NULL,
 
153
                                                        GIMP_PARAM_READWRITE));
 
154
 
 
155
  g_object_class_install_property (object_class, PROP_WRITABLE,
 
156
                                   g_param_spec_boolean ("writable", NULL, NULL,
 
157
                                                         FALSE,
 
158
                                                         GIMP_PARAM_READWRITE));
 
159
 
 
160
  g_object_class_install_property (object_class, PROP_DELETABLE,
 
161
                                   g_param_spec_boolean ("deletable", NULL, NULL,
 
162
                                                         FALSE,
 
163
                                                         GIMP_PARAM_READWRITE));
 
164
 
 
165
  g_object_class_install_property (object_class, PROP_MIME_TYPE,
 
166
                                   g_param_spec_string ("mime-type", NULL, NULL,
 
167
                                                        NULL,
 
168
                                                        GIMP_PARAM_READWRITE |
 
169
                                                        G_PARAM_CONSTRUCT_ONLY));
133
170
}
134
171
 
135
172
static void
137
174
                GimpDataClass *data_class)
138
175
{
139
176
  data->filename     = NULL;
 
177
  data->mime_type    = 0;
140
178
  data->writable     = TRUE;
141
179
  data->deletable    = TRUE;
142
180
  data->dirty        = TRUE;
143
181
  data->internal     = FALSE;
144
182
  data->freeze_count = 0;
 
183
  data->mtime        = 0;
145
184
 
146
185
  /*  look at the passed class pointer, not at GIMP_DATA_GET_CLASS(data)
147
186
   *  here, because the latter is always GimpDataClass itself
148
187
   */
149
188
  if (! data_class->save)
150
189
    data->writable = FALSE;
 
190
 
 
191
  /*  freeze the data object during construction  */
 
192
  gimp_data_freeze (data);
151
193
}
152
194
 
153
195
static void
165
207
}
166
208
 
167
209
static void
168
 
gimp_data_name_changed (GimpObject *object)
169
 
{
170
 
  if (GIMP_OBJECT_CLASS (parent_class)->name_changed)
171
 
    GIMP_OBJECT_CLASS (parent_class)->name_changed (object);
172
 
 
173
 
  gimp_data_dirty (GIMP_DATA (object));
 
210
gimp_data_set_property (GObject      *object,
 
211
                        guint         property_id,
 
212
                        const GValue *value,
 
213
                        GParamSpec   *pspec)
 
214
{
 
215
  GimpData *data = GIMP_DATA (object);
 
216
 
 
217
  switch (property_id)
 
218
    {
 
219
    case PROP_FILENAME:
 
220
      gimp_data_set_filename (data,
 
221
                              g_value_get_string (value),
 
222
                              data->writable,
 
223
                              data->deletable);
 
224
      break;
 
225
 
 
226
    case PROP_WRITABLE:
 
227
      data->writable = g_value_get_boolean (value);
 
228
      break;
 
229
 
 
230
    case PROP_DELETABLE:
 
231
      data->deletable = g_value_get_boolean (value);
 
232
      break;
 
233
 
 
234
    case PROP_MIME_TYPE:
 
235
      if (g_value_get_string (value))
 
236
        data->mime_type = g_quark_from_string (g_value_get_string (value));
 
237
      else
 
238
        data->mime_type = 0;
 
239
      break;
 
240
 
 
241
    default:
 
242
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
 
243
      break;
 
244
    }
 
245
}
 
246
 
 
247
static void
 
248
gimp_data_get_property (GObject    *object,
 
249
                        guint       property_id,
 
250
                        GValue     *value,
 
251
                        GParamSpec *pspec)
 
252
{
 
253
  GimpData *data = GIMP_DATA (object);
 
254
 
 
255
  switch (property_id)
 
256
    {
 
257
    case PROP_FILENAME:
 
258
      g_value_set_string (value, data->filename);
 
259
      break;
 
260
 
 
261
    case PROP_WRITABLE:
 
262
      g_value_set_boolean (value, data->writable);
 
263
      break;
 
264
 
 
265
    case PROP_DELETABLE:
 
266
      g_value_set_boolean (value, data->deletable);
 
267
      break;
 
268
 
 
269
    case PROP_MIME_TYPE:
 
270
      g_value_set_string (value, g_quark_to_string (data->mime_type));
 
271
      break;
 
272
 
 
273
    default:
 
274
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
 
275
      break;
 
276
    }
 
277
}
 
278
 
 
279
static GObject *
 
280
gimp_data_constructor (GType                  type,
 
281
                       guint                  n_params,
 
282
                       GObjectConstructParam *params)
 
283
{
 
284
  GObject *object;
 
285
 
 
286
  object = G_OBJECT_CLASS (parent_class)->constructor (type, n_params, params);
 
287
 
 
288
  gimp_data_thaw (GIMP_DATA (object));
 
289
 
 
290
  return object;
174
291
}
175
292
 
176
293
static gint64
193
310
  data->dirty = TRUE;
194
311
 
195
312
  gimp_viewable_invalidate_preview (GIMP_VIEWABLE (data));
 
313
 
 
314
  gimp_object_name_changed (GIMP_OBJECT (data));
196
315
}
197
316
 
198
317
/**
230
349
    success = GIMP_DATA_GET_CLASS (data)->save (data, error);
231
350
 
232
351
  if (success)
233
 
    data->dirty = FALSE;
 
352
    {
 
353
      struct stat filestat;
 
354
 
 
355
      g_stat (data->filename, &filestat);
 
356
 
 
357
      data->mtime = filestat.st_mtime;
 
358
      data->dirty = FALSE;
 
359
    }
234
360
 
235
361
  return success;
236
362
}
314
440
  if (data->internal)
315
441
    return TRUE;
316
442
 
317
 
  if (unlink (data->filename) == -1)
 
443
  if (g_unlink (data->filename) == -1)
318
444
    {
319
445
      g_set_error (error, GIMP_DATA_ERROR, GIMP_DATA_ERROR_DELETE,
320
446
                   _("Could not delete '%s': %s"),
376
502
    {
377
503
      gchar *dirname = g_path_get_dirname (filename);
378
504
 
379
 
      if ((access (filename, F_OK) == 0 &&  /* check if the file exists    */
380
 
           access (filename, W_OK) == 0) || /* and is writable             */
381
 
          (access (filename, F_OK) != 0 &&  /* OR doesn't exist            */
382
 
           access (dirname,  W_OK) == 0))   /* and we can write to its dir */
 
505
      if ((g_access (filename, F_OK) == 0 &&  /* check if the file exists    */
 
506
           g_access (filename, W_OK) == 0) || /* and is writable             */
 
507
          (g_access (filename, F_OK) != 0 &&  /* OR doesn't exist            */
 
508
           g_access (dirname,  W_OK) == 0))   /* and we can write to its dir */
383
509
        {
384
510
          data->writable  = writable  ? TRUE : FALSE;
385
511
          data->deletable = deletable ? TRUE : FALSE;
422
548
  if (data->internal)
423
549
    return;
424
550
 
425
 
#ifdef G_OS_WIN32
426
 
  {
427
 
    const gchar *charset;
428
 
 
429
 
    filename = g_strdup (gimp_object_get_name (GIMP_OBJECT (data)));
430
 
 
431
 
    /* Map illegal characters to '-' while the name is still in UTF-8 */
432
 
    for (i = 0; filename[i]; i++)
433
 
      if (strchr ("<>:\"/\\|", filename[i]) ||
434
 
          g_ascii_iscntrl (filename[i]) ||
435
 
          g_ascii_isspace (filename[i]))
436
 
        filename[i] = '-';
437
 
 
438
 
    /* Map also trailing periods to '-' */
439
 
    for (i = strlen (filename) - 1; i >= 0; i--)
440
 
      if (filename[i] == '.')
441
 
        filename[i] = '-';
442
 
      else
443
 
        break;
444
 
 
445
 
    /* Next convert to the filename charset. Note that this branch of
446
 
     * GIMP must be compiled against GLib 2.4 and we thus use system
447
 
     * codepage for file names in the GLib API.
448
 
     */
449
 
    g_get_charset (&charset);
450
 
    safename = g_convert_with_fallback (filename,
451
 
                                        -1, charset, "UTF-8",
452
 
                                        "-", NULL, NULL, &error);
453
 
    if (! safename)
454
 
      {
455
 
        g_warning ("gimp_data_create_filename:\n"
456
 
                   "g_convert_with_fallback() failed for '%s': %s",
457
 
                   filename, error->message);
458
 
        g_free (filename);
459
 
        g_error_free (error);
460
 
        return;
461
 
      }
462
 
    g_free (filename);
463
 
  }
464
 
#else
465
551
  safename = g_filename_from_utf8 (gimp_object_get_name (GIMP_OBJECT (data)),
466
552
                                   -1, NULL, NULL, &error);
467
553
  if (! safename)
479
565
  for (i = 0; safename[i]; i++)
480
566
    if (safename[i] == G_DIR_SEPARATOR || g_ascii_isspace (safename[i]))
481
567
      safename[i] = '-';
482
 
#endif
483
568
 
484
569
  filename = g_strconcat (safename, gimp_data_get_extension (data), NULL);
485
570
 
508
593
  g_free (fullpath);
509
594
}
510
595
 
 
596
const gchar *
 
597
gimp_data_get_mime_type (GimpData *data)
 
598
{
 
599
  g_return_val_if_fail (GIMP_IS_DATA (data), NULL);
 
600
 
 
601
  return g_quark_to_string (data->mime_type);
 
602
}
 
603
 
511
604
/**
512
605
 * gimp_data_duplicate:
513
 
 * @data:              a #GimpData object
514
 
 * @stingy_memory_use: if %TRUE, use the disk rather than RAM
515
 
 *                     where possible.
 
606
 * @data: a #GimpData object
516
607
 *
517
608
 * Creates a copy of @data, if possible.  Only the object data is
518
609
 * copied:  the newly created object is not automatically given an
521
612
 * Returns: the newly created copy, or %NULL if @data cannot be copied.
522
613
 **/
523
614
GimpData *
524
 
gimp_data_duplicate (GimpData *data,
525
 
                     gboolean  stingy_memory_use)
 
615
gimp_data_duplicate (GimpData *data)
526
616
{
527
617
  g_return_val_if_fail (GIMP_IS_DATA (data), NULL);
528
618
 
529
619
  if (GIMP_DATA_GET_CLASS (data)->duplicate)
530
 
    return GIMP_DATA_GET_CLASS (data)->duplicate (data, stingy_memory_use);
 
620
    return GIMP_DATA_GET_CLASS (data)->duplicate (data);
531
621
 
532
622
  return NULL;
533
623
}
593
683
GQuark
594
684
gimp_data_error_quark (void)
595
685
{
596
 
  static GQuark quark = 0;
597
 
 
598
 
  if (! quark)
599
 
    quark = g_quark_from_static_string ("gimp-data-error-quark");
600
 
 
601
 
  return quark;
 
686
  return g_quark_from_static_string ("gimp-data-error-quark");
602
687
}