← Back to branch summary

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

« back to all changes in this revision

Viewing changes to app/core/gimpgradient-load.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/gimpgradient-load.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
 * This program is free software; you can redistribute it and/or modify
18
18
 
19
19
#include "config.h"
20
20
 
21
 
#include <stdio.h>
22
21
#include <stdlib.h>
23
22
#include <string.h>
24
23
#include <errno.h>
25
24
 
26
25
#include <glib-object.h>
 
26
#include <glib/gstdio.h>
27
27
 
28
28
#include "libgimpbase/gimpbase.h"
29
29
#include "libgimpcolor/gimpcolor.h"
40
40
 
41
41
GList *
42
42
gimp_gradient_load (const gchar  *filename,
43
 
                    gboolean      stingy_memory_use,
44
43
                    GError      **error)
45
44
{
46
45
  GimpGradient        *gradient;
47
 
  GimpGradientSegment *seg;
48
46
  GimpGradientSegment *prev;
49
47
  gint                 num_segments;
50
48
  gint                 i;
51
 
  gint                 type, color;
52
49
  FILE                *file;
53
50
  gchar                line[1024];
 
51
  gint                 linenum;
54
52
 
55
53
  g_return_val_if_fail (filename != NULL, NULL);
56
54
  g_return_val_if_fail (g_path_is_absolute (filename), NULL);
57
55
  g_return_val_if_fail (error == NULL || *error == NULL, NULL);
58
56
 
59
 
  file = fopen (filename, "rb");
 
57
  file = g_fopen (filename, "rb");
 
58
 
60
59
  if (!file)
61
60
    {
62
61
      g_set_error (error, GIMP_DATA_ERROR, GIMP_DATA_ERROR_OPEN,
65
64
      return NULL;
66
65
    }
67
66
 
68
 
  fgets (line, 1024, file);
69
 
  if (strcmp (line, "GIMP Gradient\n") != 0)
 
67
  linenum = 1;
 
68
  if (! fgets (line, sizeof (line), file))
 
69
    {
 
70
      g_set_error (error, GIMP_DATA_ERROR, GIMP_DATA_ERROR_READ,
 
71
                   _("Fatal parse error in gradient file '%s': "
 
72
                     "Read error in line %d."),
 
73
                   gimp_filename_to_utf8 (filename), linenum);
 
74
      fclose (file);
 
75
      return NULL;
 
76
    }
 
77
 
 
78
  if (! g_str_has_prefix (line, "GIMP Gradient"))
70
79
    {
71
80
      g_set_error (error, GIMP_DATA_ERROR, GIMP_DATA_ERROR_READ,
72
81
                   _("Fatal parse error in gradient file '%s': "
76
85
      return NULL;
77
86
    }
78
87
 
79
 
  gradient = g_object_new (GIMP_TYPE_GRADIENT, NULL);
80
 
 
81
 
  fgets (line, 1024, file);
82
 
  if (! strncmp (line, "Name: ", strlen ("Name: ")))
 
88
  gradient = g_object_new (GIMP_TYPE_GRADIENT,
 
89
                           "mime-type", "application/x-gimp-gradient",
 
90
                           NULL);
 
91
 
 
92
  linenum++;
 
93
  if (! fgets (line, sizeof (line), file))
 
94
    {
 
95
      g_set_error (error, GIMP_DATA_ERROR, GIMP_DATA_ERROR_READ,
 
96
                   _("Fatal parse error in gradient file '%s': "
 
97
                     "Read error in line %d."),
 
98
                   gimp_filename_to_utf8 (filename), linenum);
 
99
      fclose (file);
 
100
      g_object_unref (gradient);
 
101
      return NULL;
 
102
    }
 
103
 
 
104
  if (g_str_has_prefix (line, "Name: "))
83
105
    {
84
106
      gchar *utf8;
85
107
 
86
 
      utf8 = gimp_any_to_utf8 (&line[strlen ("Name: ")], -1,
 
108
      utf8 = gimp_any_to_utf8 (g_strstrip (line + strlen ("Name: ")), -1,
87
109
                               _("Invalid UTF-8 string in gradient file '%s'."),
88
110
                               gimp_filename_to_utf8 (filename));
89
 
      g_strstrip (utf8);
90
 
 
91
 
      gimp_object_set_name (GIMP_OBJECT (gradient), utf8);
92
 
      g_free (utf8);
93
 
 
94
 
      fgets (line, 1024, file);
 
111
      gimp_object_take_name (GIMP_OBJECT (gradient), utf8);
 
112
 
 
113
      linenum++;
 
114
      if (! fgets (line, sizeof (line), file))
 
115
        {
 
116
          g_set_error (error, GIMP_DATA_ERROR, GIMP_DATA_ERROR_READ,
 
117
                       _("Fatal parse error in gradient file '%s': "
 
118
                         "Read error in line %d."),
 
119
                       gimp_filename_to_utf8 (filename), linenum);
 
120
          fclose (file);
 
121
          g_object_unref (gradient);
 
122
          return NULL;
 
123
        }
95
124
    }
96
125
  else /* old gradient format */
97
126
    {
98
 
      gchar *basename;
99
 
      gchar *utf8;
100
 
 
101
 
      basename = g_path_get_basename (filename);
102
 
 
103
 
      utf8 = g_filename_to_utf8 (basename, -1, NULL, NULL, NULL);
104
 
      g_free (basename);
105
 
 
106
 
      gimp_object_set_name (GIMP_OBJECT (gradient), utf8);
107
 
      g_free (utf8);
 
127
      gimp_object_take_name (GIMP_OBJECT (gradient),
 
128
                             g_filename_display_basename (filename));
108
129
    }
109
130
 
110
131
  num_segments = atoi (line);
113
134
    {
114
135
      g_set_error (error, GIMP_DATA_ERROR, GIMP_DATA_ERROR_READ,
115
136
                   _("Fatal parse error in gradient file '%s': "
116
 
                     "File is corrupt."),
117
 
                   gimp_filename_to_utf8 (filename));
 
137
                     "File is corrupt in line %d."),
 
138
                   gimp_filename_to_utf8 (filename), linenum);
118
139
      g_object_unref (gradient);
119
140
      fclose (file);
120
141
      return NULL;
124
145
 
125
146
  for (i = 0; i < num_segments; i++)
126
147
    {
127
 
      gchar *end;
 
148
      GimpGradientSegment *seg;
 
149
      gchar               *end;
 
150
      gint                 color;
 
151
      gint                 type;
 
152
      gint                 left_color_type;
 
153
      gint                 right_color_type;
128
154
 
129
155
      seg = gimp_gradient_segment_new ();
130
156
 
131
157
      seg->prev = prev;
132
158
 
133
159
      if (prev)
134
 
        prev->next = seg;
 
160
        prev->next = seg;
135
161
      else
136
 
        gradient->segments = seg;
 
162
        gradient->segments = seg;
137
163
 
138
 
      fgets (line, 1024, file);
 
164
      linenum++;
 
165
      if (! fgets (line, sizeof (line), file))
 
166
        {
 
167
          g_set_error (error, GIMP_DATA_ERROR, GIMP_DATA_ERROR_READ,
 
168
                       _("Fatal parse error in gradient file '%s': "
 
169
                         "Read error in line %d."),
 
170
                       gimp_filename_to_utf8 (filename), linenum);
 
171
          fclose (file);
 
172
          g_object_unref (gradient);
 
173
          return NULL;
 
174
        }
139
175
 
140
176
      seg->left = g_ascii_strtod (line, &end);
141
177
      if (end && errno != ERANGE)
161
197
      if (end && errno != ERANGE)
162
198
        seg->right_color.a = g_ascii_strtod (end, &end);
163
199
 
164
 
      if (errno != ERANGE &&
165
 
          sscanf (end, "%d %d", &type, &color) == 2)
 
200
      if (errno != ERANGE)
166
201
        {
167
 
          seg->type  = (GimpGradientSegmentType) type;
168
 
          seg->color = (GimpGradientSegmentColor) color;
 
202
          switch (sscanf (end, "%d %d %d %d",
 
203
                          &type, &color,
 
204
                          &left_color_type, &right_color_type))
 
205
            {
 
206
            case 4:
 
207
              seg->left_color_type  = (GimpGradientColor) left_color_type;
 
208
              seg->right_color_type = (GimpGradientColor) right_color_type;
 
209
              /* fall thru */
 
210
 
 
211
            case 2:
 
212
              seg->type  = (GimpGradientSegmentType) type;
 
213
              seg->color = (GimpGradientSegmentColor) color;
 
214
              break;
 
215
 
 
216
            default:
 
217
              g_set_error (error, GIMP_DATA_ERROR, GIMP_DATA_ERROR_READ,
 
218
                           _("Fatal parse error in gradient file '%s': "
 
219
                             "Corrupt segment %d in line %d."),
 
220
                           gimp_filename_to_utf8 (filename), i, linenum);
 
221
              g_object_unref (gradient);
 
222
              fclose (file);
 
223
              return NULL;
 
224
            }
169
225
        }
170
226
      else
171
227
        {
172
228
          g_set_error (error, GIMP_DATA_ERROR, GIMP_DATA_ERROR_READ,
173
 
                       _("Corrupt segment %d in gradient file '%s'."),
174
 
                       i, gimp_filename_to_utf8 (filename));
 
229
                       _("Fatal parse error in gradient file '%s': "
 
230
                         "Corrupt segment %d in line %d."),
 
231
                       gimp_filename_to_utf8 (filename), i, linenum);
175
232
          g_object_unref (gradient);
176
233
          fclose (file);
177
234
          return NULL;
178
 
        }
 
235
        }
179
236
 
180
237
      if ( (prev && (prev->right < seg->left))
181
238
           || (!prev && (0. < seg->left) ))
255
312
 
256
313
GList *
257
314
gimp_gradient_load_svg (const gchar  *filename,
258
 
                        gboolean      stingy_memory_use,
259
315
                        GError      **error)
260
316
{
261
317
  GimpXmlParser *xml_parser;
332
388
        }
333
389
 
334
390
      parser->gradient = g_object_new (GIMP_TYPE_GRADIENT,
335
 
                                       "name", name,
 
391
                                       "name",      name,
 
392
                                       "mime-type", "image/svg+xml",
336
393
                                       NULL);
337
394
    }
338
395
  else if (parser->gradient && strcmp (element_name, "stop") == 0)