static void
cdisplay_proof_combo_box_set_active (GimpColorProfileComboBox *combo,
const gchar *filename)
{
cmsHPROFILE profile = NULL;
gchar *label = NULL;
if (filename)
profile = cmsOpenProfileFromFile (filename, "r");
if (profile)
{
cmsUInt32Number descSize;
gchar *descData;
descSize = cmsGetProfileInfoASCII (profile, cmsInfoDescription,
"en", "US", NULL, 0);
if (descSize > 0)
{
descData = g_new (gchar, descSize + 1);
descSize = cmsGetProfileInfoASCII (profile, cmsInfoDescription,
"en", "US", descData, descSize);
if (descSize > 0)
label = gimp_any_to_utf8 (descData, -1, NULL);
g_free (descData);
}
if (! label)
{
descSize = cmsGetProfileInfoASCII (profile, cmsInfoModel,
"en", "US", NULL, 0);
if (descSize > 0)
{
descData = g_new (gchar, descSize + 1);
descSize = cmsGetProfileInfoASCII (profile, cmsInfoModel,
"en", "US", descData, descSize);
if (descSize > 0)
label = gimp_any_to_utf8 (descData, -1, NULL);
g_free (descData);
}
}
cmsCloseProfile (profile);
}
gimp_color_profile_combo_box_set_active (combo, filename, label);
g_free (label);
}
static gchar *
gimp_lcms_profile_get_info (GimpColorProfile profile,
cmsInfoType info)
{
cmsUInt32Number size;
gchar *text = NULL;
g_return_val_if_fail (profile != NULL, NULL);
size = cmsGetProfileInfoASCII (profile, info,
"en", "US", NULL, 0);
if (size > 0)
{
gchar *data = g_new (gchar, size + 1);
size = cmsGetProfileInfoASCII (profile, info,
"en", "US", data, size);
if (size > 0)
text = gimp_any_to_utf8 (data, -1, NULL);
g_free (data);
}
return text;
}
static void
gimp_message_box_set_label_text (GimpMessageBox *box,
gint n,
const gchar *format,
va_list args)
{
GtkWidget *label = box->label[n];
if (format)
{
gchar *text = g_strdup_vprintf (format, args);
gchar *utf8 = gimp_any_to_utf8 (text, -1, "Cannot convert text to utf8.");
gtk_label_set_text (GTK_LABEL (label), utf8);
gtk_widget_show (label);
g_free (utf8);
g_free (text);
}
else
{
gtk_widget_hide (label);
gtk_label_set_text (GTK_LABEL (label), NULL);
}
}
static void
cdisplay_proof_combo_box_set_active (GimpColorProfileComboBox *combo,
const gchar *filename)
{
cmsHPROFILE profile = NULL;
gchar *label = NULL;
if (filename)
profile = cmsOpenProfileFromFile (filename, "r");
if (profile)
{
label = gimp_any_to_utf8 (cmsTakeProductDesc (profile), -1, NULL);
if (! label)
label = gimp_any_to_utf8 (cmsTakeProductName (profile), -1, NULL);
cmsCloseProfile (profile);
}
gimp_color_profile_combo_box_set_active (combo, filename, label);
g_free (label);
}
guint
xcf_read_string (FILE *fp,
gchar **data,
gint count)
{
guint total = 0;
gint i;
for (i = 0; i < count; i++)
{
guint32 tmp;
total += xcf_read_int32 (fp, &tmp, 1);
if (tmp > 0)
{
gchar *str;
str = g_new (gchar, tmp);
total += xcf_read_int8 (fp, (guint8*) str, tmp);
if (str[tmp - 1] != '\0')
str[tmp - 1] = '\0';
data[i] = gimp_any_to_utf8 (str, -1,
_("Invalid UTF-8 string in XCF file"));
g_free (str);
}
else
{
data[i] = NULL;
}
}
return total;
}
GList *
gimp_palette_load (const gchar *filename,
GError **error)
{
GimpPalette *palette;
GimpPaletteEntry *entry;
gchar str[1024];
gchar *tok;
FILE *file;
gint r, g, b;
gint linenum;
g_return_val_if_fail (filename != NULL, NULL);
g_return_val_if_fail (g_path_is_absolute (filename), NULL);
g_return_val_if_fail (error == NULL || *error == NULL, NULL);
r = g = b = 0;
file = g_fopen (filename, "rb");
if (! file)
{
g_set_error (error, GIMP_DATA_ERROR, GIMP_DATA_ERROR_OPEN,
_("Could not open '%s' for reading: %s"),
gimp_filename_to_utf8 (filename), g_strerror (errno));
return NULL;
}
linenum = 1;
if (! fgets (str, sizeof (str), file))
{
g_set_error (error, GIMP_DATA_ERROR, GIMP_DATA_ERROR_READ,
_("Fatal parse error in palette file '%s': "
"Read error in line %d."),
gimp_filename_to_utf8 (filename), linenum);
fclose (file);
return NULL;
}
if (! g_str_has_prefix (str, "GIMP Palette"))
{
g_set_error (error, GIMP_DATA_ERROR, GIMP_DATA_ERROR_READ,
_("Fatal parse error in palette file '%s': "
"Missing magic header."),
gimp_filename_to_utf8 (filename));
fclose (file);
return NULL;
}
palette = g_object_new (GIMP_TYPE_PALETTE,
"mime-type", "application/x-gimp-palette",
NULL);
linenum++;
if (! fgets (str, sizeof (str), file))
{
g_set_error (error, GIMP_DATA_ERROR, GIMP_DATA_ERROR_READ,
_("Fatal parse error in palette file '%s': "
"Read error in line %d."),
gimp_filename_to_utf8 (filename), linenum);
fclose (file);
g_object_unref (palette);
return NULL;
}
if (g_str_has_prefix (str, "Name: "))
{
gchar *utf8;
utf8 = gimp_any_to_utf8 (g_strstrip (str + strlen ("Name: ")), -1,
_("Invalid UTF-8 string in palette file '%s'"),
gimp_filename_to_utf8 (filename));
gimp_object_take_name (GIMP_OBJECT (palette), utf8);
linenum++;
if (! fgets (str, sizeof (str), file))
{
g_set_error (error, GIMP_DATA_ERROR, GIMP_DATA_ERROR_READ,
_("Fatal parse error in palette file '%s': "
"Read error in line %d."),
gimp_filename_to_utf8 (filename), linenum);
fclose (file);
g_object_unref (palette);
return NULL;
}
if (g_str_has_prefix (str, "Columns: "))
{
gint columns;
columns = atoi (g_strstrip (str + strlen ("Columns: ")));
if (columns < 0 || columns > 256)
{
g_message (_("Reading palette file '%s': "
"Invalid number of columns in line %d. "
"Using default value."),
gimp_filename_to_utf8 (filename), linenum);
columns = 0;
}
palette->n_columns = columns;
linenum++;
if (! fgets (str, sizeof (str), file))
{
g_set_error (error, GIMP_DATA_ERROR, GIMP_DATA_ERROR_READ,
_("Fatal parse error in palette file '%s': "
"Read error in line %d."),
gimp_filename_to_utf8 (filename), linenum);
fclose (file);
g_object_unref (palette);
return NULL;
}
}
}
else /* old palette format */
{
gimp_object_take_name (GIMP_OBJECT (palette),
g_filename_display_basename (filename));
}
while (! feof (file))
{
if (str[0] != '#' && str[0] != '\n')
{
tok = strtok (str, " \t");
if (tok)
r = atoi (tok);
else
g_message (_("Reading palette file '%s': "
"Missing RED component in line %d."),
gimp_filename_to_utf8 (filename), linenum);
tok = strtok (NULL, " \t");
if (tok)
g = atoi (tok);
else
g_message (_("Reading palette file '%s': "
"Missing GREEN component in line %d."),
gimp_filename_to_utf8 (filename), linenum);
tok = strtok (NULL, " \t");
if (tok)
b = atoi (tok);
else
g_message (_("Reading palette file '%s': "
"Missing BLUE component in line %d."),
gimp_filename_to_utf8 (filename), linenum);
/* optional name */
tok = strtok (NULL, "\n");
if (r < 0 || r > 255 ||
g < 0 || g > 255 ||
b < 0 || b > 255)
g_message (_("Reading palette file '%s': "
"RGB value out of range in line %d."),
gimp_filename_to_utf8 (filename), linenum);
/* don't call gimp_palette_add_entry here, it's rather inefficient */
entry = g_slice_new0 (GimpPaletteEntry);
gimp_rgba_set_uchar (&entry->color,
(guchar) r,
(guchar) g,
(guchar) b,
255);
entry->name = g_strdup (tok ? tok : _("Untitled"));
entry->position = palette->n_colors;
palette->colors = g_list_prepend (palette->colors, entry);
palette->n_colors++;
}
linenum++;
if (! fgets (str, sizeof (str), file))
{
if (feof (file))
break;
g_set_error (error, GIMP_DATA_ERROR, GIMP_DATA_ERROR_READ,
_("Fatal parse error in palette file '%s': "
"Read error in line %d."),
gimp_filename_to_utf8 (filename), linenum);
fclose (file);
g_object_unref (palette);
return NULL;
}
}
fclose (file);
palette->colors = g_list_reverse (palette->colors);
return g_list_prepend (NULL, palette);
}
GList *
gimp_brush_generated_load (GimpContext *context,
GFile *file,
GInputStream *input,
GError **error)
{
GimpBrush *brush;
GDataInputStream *data_input;
gchar *string;
gsize string_len;
gint linenum;
gchar *name = NULL;
GimpBrushGeneratedShape shape = GIMP_BRUSH_GENERATED_CIRCLE;
gboolean have_shape = FALSE;
gint spikes = 2;
gdouble spacing;
gdouble radius;
gdouble hardness;
gdouble aspect_ratio;
gdouble angle;
g_return_val_if_fail (G_IS_FILE (file), NULL);
g_return_val_if_fail (G_IS_INPUT_STREAM (input), NULL);
g_return_val_if_fail (error == NULL || *error == NULL, NULL);
data_input = g_data_input_stream_new (input);
/* make sure the file we are reading is the right type */
linenum = 1;
string_len = 256;
string = g_data_input_stream_read_line (data_input, &string_len,
NULL, error);
if (! string)
goto failed;
if (! g_str_has_prefix (string, "GIMP-VBR"))
{
g_set_error (error, GIMP_DATA_ERROR, GIMP_DATA_ERROR_READ,
_("Not a GIMP brush file."));
g_free (string);
goto failed;
}
g_free (string);
/* make sure we are reading a compatible version */
linenum++;
string_len = 256;
string = g_data_input_stream_read_line (data_input, &string_len,
NULL, error);
if (! string)
goto failed;
if (! g_str_has_prefix (string, "1.0"))
{
if (! g_str_has_prefix (string, "1.5"))
{
g_set_error (error, GIMP_DATA_ERROR, GIMP_DATA_ERROR_READ,
_("Unknown GIMP brush version."));
g_free (string);
goto failed;
}
else
{
have_shape = TRUE;
}
}
g_free (string);
/* read name */
linenum++;
string_len = 256;
string = g_data_input_stream_read_line (data_input, &string_len,
NULL, error);
if (! string)
goto failed;
g_strstrip (string);
/* the empty string is not an allowed name */
if (strlen (string) < 1)
{
name = g_strdup (_("Untitled"));
}
else
{
name = gimp_any_to_utf8 (string, -1,
_("Invalid UTF-8 string in brush file '%s'."),
gimp_file_get_utf8_name (file));
}
g_free (string);
if (have_shape)
{
GEnumClass *enum_class;
GEnumValue *shape_val;
enum_class = g_type_class_peek (GIMP_TYPE_BRUSH_GENERATED_SHAPE);
/* read shape */
linenum++;
string_len = 256;
string = g_data_input_stream_read_line (data_input, &string_len,
NULL, error);
if (! string)
goto failed;
g_strstrip (string);
shape_val = g_enum_get_value_by_nick (enum_class, string);
if (! shape_val)
{
g_set_error (error, GIMP_DATA_ERROR, GIMP_DATA_ERROR_READ,
_("Unknown GIMP brush shape."));
g_free (string);
goto failed;
}
g_free (string);
shape = shape_val->value;
}
/* read brush spacing */
linenum++;
string_len = 256;
string = g_data_input_stream_read_line (data_input, &string_len,
NULL, error);
if (! string)
goto failed;
spacing = g_ascii_strtod (string, NULL);
g_free (string);
/* read brush radius */
linenum++;
string_len = 256;
string = g_data_input_stream_read_line (data_input, &string_len,
NULL, error);
if (! string)
goto failed;
radius = g_ascii_strtod (string, NULL);
g_free (string);
if (have_shape)
{
/* read number of spikes */
linenum++;
string_len = 256;
string = g_data_input_stream_read_line (data_input, &string_len,
NULL, error);
if (! string)
goto failed;
spikes = CLAMP (atoi (string), 2, 20);
g_free (string);
}
/* read brush hardness */
linenum++;
string_len = 256;
string = g_data_input_stream_read_line (data_input, &string_len,
NULL, error);
if (! string)
goto failed;
hardness = g_ascii_strtod (string, NULL);
g_free (string);
/* read brush aspect_ratio */
linenum++;
string_len = 256;
string = g_data_input_stream_read_line (data_input, &string_len,
NULL, error);
if (! string)
goto failed;
aspect_ratio = g_ascii_strtod (string, NULL);
g_free (string);
/* read brush angle */
linenum++;
string_len = 256;
string = g_data_input_stream_read_line (data_input, &string_len,
NULL, error);
if (! string)
goto failed;
angle = g_ascii_strtod (string, NULL);
g_free (string);
g_object_unref (data_input);
brush = GIMP_BRUSH (gimp_brush_generated_new (name, shape, radius, spikes,
hardness, aspect_ratio, angle));
g_free (name);
gimp_brush_set_spacing (brush, spacing);
return g_list_prepend (NULL, brush);
failed:
g_object_unref (data_input);
if (name)
g_free (name);
g_prefix_error (error, _("In line %d of brush file: "), linenum);
return NULL;
}
GList *
gimp_gradient_load (GimpContext *context,
const gchar *filename,
GError **error)
{
GimpGradient *gradient;
GimpGradientSegment *prev;
gint num_segments;
gint i;
FILE *file;
gchar line[1024];
gint linenum;
g_return_val_if_fail (filename != NULL, NULL);
g_return_val_if_fail (g_path_is_absolute (filename), NULL);
g_return_val_if_fail (error == NULL || *error == NULL, NULL);
file = g_fopen (filename, "rb");
if (!file)
{
g_set_error (error, GIMP_DATA_ERROR, GIMP_DATA_ERROR_OPEN,
_("Could not open '%s' for reading: %s"),
gimp_filename_to_utf8 (filename), g_strerror (errno));
return NULL;
}
linenum = 1;
if (! fgets (line, sizeof (line), file))
{
g_set_error (error, GIMP_DATA_ERROR, GIMP_DATA_ERROR_READ,
_("Fatal parse error in gradient file '%s': "
"Read error in line %d."),
gimp_filename_to_utf8 (filename), linenum);
fclose (file);
return NULL;
}
if (! g_str_has_prefix (line, "GIMP Gradient"))
{
g_set_error (error, GIMP_DATA_ERROR, GIMP_DATA_ERROR_READ,
_("Fatal parse error in gradient file '%s': "
"Not a GIMP gradient file."),
gimp_filename_to_utf8 (filename));
fclose (file);
return NULL;
}
gradient = g_object_new (GIMP_TYPE_GRADIENT,
"mime-type", "application/x-gimp-gradient",
NULL);
linenum++;
if (! fgets (line, sizeof (line), file))
{
g_set_error (error, GIMP_DATA_ERROR, GIMP_DATA_ERROR_READ,
_("Fatal parse error in gradient file '%s': "
"Read error in line %d."),
gimp_filename_to_utf8 (filename), linenum);
fclose (file);
g_object_unref (gradient);
return NULL;
}
if (g_str_has_prefix (line, "Name: "))
{
gchar *utf8;
utf8 = gimp_any_to_utf8 (g_strstrip (line + strlen ("Name: ")), -1,
_("Invalid UTF-8 string in gradient file '%s'."),
gimp_filename_to_utf8 (filename));
gimp_object_take_name (GIMP_OBJECT (gradient), utf8);
linenum++;
if (! fgets (line, sizeof (line), file))
{
g_set_error (error, GIMP_DATA_ERROR, GIMP_DATA_ERROR_READ,
_("Fatal parse error in gradient file '%s': "
"Read error in line %d."),
gimp_filename_to_utf8 (filename), linenum);
fclose (file);
g_object_unref (gradient);
return NULL;
}
}
else /* old gradient format */
{
gimp_object_take_name (GIMP_OBJECT (gradient),
g_filename_display_basename (filename));
}
num_segments = atoi (line);
if (num_segments < 1)
{
g_set_error (error, GIMP_DATA_ERROR, GIMP_DATA_ERROR_READ,
_("Fatal parse error in gradient file '%s': "
"File is corrupt in line %d."),
gimp_filename_to_utf8 (filename), linenum);
g_object_unref (gradient);
fclose (file);
return NULL;
}
prev = NULL;
for (i = 0; i < num_segments; i++)
{
GimpGradientSegment *seg;
gchar *end;
gint color;
gint type;
gint left_color_type;
gint right_color_type;
seg = gimp_gradient_segment_new ();
seg->prev = prev;
if (prev)
prev->next = seg;
else
gradient->segments = seg;
linenum++;
if (! fgets (line, sizeof (line), file))
{
g_set_error (error, GIMP_DATA_ERROR, GIMP_DATA_ERROR_READ,
_("Fatal parse error in gradient file '%s': "
"Read error in line %d."),
gimp_filename_to_utf8 (filename), linenum);
fclose (file);
g_object_unref (gradient);
return NULL;
}
seg->left = g_ascii_strtod (line, &end);
if (end && errno != ERANGE)
seg->middle = g_ascii_strtod (end, &end);
if (end && errno != ERANGE)
seg->right = g_ascii_strtod (end, &end);
if (end && errno != ERANGE)
seg->left_color.r = g_ascii_strtod (end, &end);
if (end && errno != ERANGE)
seg->left_color.g = g_ascii_strtod (end, &end);
if (end && errno != ERANGE)
seg->left_color.b = g_ascii_strtod (end, &end);
if (end && errno != ERANGE)
seg->left_color.a = g_ascii_strtod (end, &end);
if (end && errno != ERANGE)
seg->right_color.r = g_ascii_strtod (end, &end);
if (end && errno != ERANGE)
seg->right_color.g = g_ascii_strtod (end, &end);
if (end && errno != ERANGE)
seg->right_color.b = g_ascii_strtod (end, &end);
if (end && errno != ERANGE)
seg->right_color.a = g_ascii_strtod (end, &end);
if (errno != ERANGE)
{
switch (sscanf (end, "%d %d %d %d",
&type, &color,
&left_color_type, &right_color_type))
{
case 4:
seg->left_color_type = (GimpGradientColor) left_color_type;
seg->right_color_type = (GimpGradientColor) right_color_type;
/* fall thru */
case 2:
seg->type = (GimpGradientSegmentType) type;
seg->color = (GimpGradientSegmentColor) color;
break;
default:
g_set_error (error, GIMP_DATA_ERROR, GIMP_DATA_ERROR_READ,
_("Fatal parse error in gradient file '%s': "
"Corrupt segment %d in line %d."),
gimp_filename_to_utf8 (filename), i, linenum);
g_object_unref (gradient);
fclose (file);
return NULL;
}
}
else
{
g_set_error (error, GIMP_DATA_ERROR, GIMP_DATA_ERROR_READ,
_("Fatal parse error in gradient file '%s': "
"Corrupt segment %d in line %d."),
gimp_filename_to_utf8 (filename), i, linenum);
g_object_unref (gradient);
fclose (file);
return NULL;
}
if ( (prev && (prev->right < seg->left))
|| (!prev && (0. < seg->left) ))
{
g_set_error (error, GIMP_DATA_ERROR, GIMP_DATA_ERROR_READ,
_("Gradient file '%s' is corrupt: "
"Segments do not span the range 0-1."),
gimp_filename_to_utf8 (filename));
g_object_unref (gradient);
fclose (file);
return NULL;
}
prev = seg;
}
if (prev->right < 1.0)
{
g_set_error (error, GIMP_DATA_ERROR, GIMP_DATA_ERROR_READ,
_("Gradient file '%s' is corrupt: "
"Segments do not span the range 0-1."),
gimp_filename_to_utf8 (filename));
g_object_unref (gradient);
fclose (file);
return NULL;
}
fclose (file);
return g_list_prepend (NULL, gradient);
}
static gchar *
lcms_icc_profile_get_info (cmsHPROFILE profile)
{
return gimp_any_to_utf8 (cmsTakeProductInfo (profile), -1, NULL);
}
GList *
gimp_brush_generated_load (GimpContext *context,
const gchar *filename,
GError **error)
{
GimpBrush *brush;
FILE *file;
gchar string[256];
gint linenum;
gchar *name = NULL;
GimpBrushGeneratedShape shape = GIMP_BRUSH_GENERATED_CIRCLE;
gboolean have_shape = FALSE;
gint spikes = 2;
gdouble spacing;
gdouble radius;
gdouble hardness;
gdouble aspect_ratio;
gdouble angle;
g_return_val_if_fail (filename != NULL, NULL);
g_return_val_if_fail (g_path_is_absolute (filename), NULL);
g_return_val_if_fail (error == NULL || *error == NULL, NULL);
file = g_fopen (filename, "rb");
if (! file)
{
g_set_error (error, GIMP_DATA_ERROR, GIMP_DATA_ERROR_OPEN,
_("Could not open '%s' for reading: %s"),
gimp_filename_to_utf8 (filename), g_strerror (errno));
return NULL;
}
/* make sure the file we are reading is the right type */
errno = 0;
linenum = 1;
if (! fgets (string, sizeof (string), file))
goto failed;
if (! g_str_has_prefix (string, "GIMP-VBR"))
{
g_set_error (error, GIMP_DATA_ERROR, GIMP_DATA_ERROR_READ,
_("Fatal parse error in brush file '%s': "
"Not a GIMP brush file."),
gimp_filename_to_utf8 (filename));
goto failed;
}
/* make sure we are reading a compatible version */
errno = 0;
linenum++;
if (! fgets (string, sizeof (string), file))
goto failed;
if (! g_str_has_prefix (string, "1.0"))
{
if (! g_str_has_prefix (string, "1.5"))
{
g_set_error (error, GIMP_DATA_ERROR, GIMP_DATA_ERROR_READ,
_("Fatal parse error in brush file '%s': "
"Unknown GIMP brush version in line %d."),
gimp_filename_to_utf8 (filename), linenum);
goto failed;
}
else
{
have_shape = TRUE;
}
}
/* read name */
errno = 0;
linenum++;
if (! fgets (string, sizeof (string), file))
goto failed;
g_strstrip (string);
/* the empty string is not an allowed name */
if (strlen (string) < 1)
g_strlcpy (string, _("Untitled"), sizeof (string));
name = gimp_any_to_utf8 (string, -1,
_("Invalid UTF-8 string in brush file '%s'."),
gimp_filename_to_utf8 (filename));
if (have_shape)
{
GEnumClass *enum_class;
GEnumValue *shape_val;
enum_class = g_type_class_peek (GIMP_TYPE_BRUSH_GENERATED_SHAPE);
/* read shape */
errno = 0;
linenum++;
if (! fgets (string, sizeof (string), file))
goto failed;
g_strstrip (string);
shape_val = g_enum_get_value_by_nick (enum_class, string);
if (! shape_val)
{
g_set_error (error, GIMP_DATA_ERROR, GIMP_DATA_ERROR_READ,
_("Fatal parse error in brush file '%s': "
"Unknown GIMP brush shape in line %d."),
gimp_filename_to_utf8 (filename), linenum);
goto failed;
}
shape = shape_val->value;
}
/* read brush spacing */
errno = 0;
linenum++;
if (! fgets (string, sizeof (string), file))
goto failed;
spacing = g_ascii_strtod (string, NULL);
/* read brush radius */
errno = 0;
linenum++;
if (! fgets (string, sizeof (string), file))
goto failed;
radius = g_ascii_strtod (string, NULL);
if (have_shape)
{
/* read number of spikes */
errno = 0;
linenum++;
if (! fgets (string, sizeof (string), file))
goto failed;
spikes = CLAMP (atoi (string), 2, 20);
}
/* read brush hardness */
errno = 0;
linenum++;
if (! fgets (string, sizeof (string), file))
goto failed;
hardness = g_ascii_strtod (string, NULL);
/* read brush aspect_ratio */
errno = 0;
linenum++;
if (! fgets (string, sizeof (string), file))
goto failed;
aspect_ratio = g_ascii_strtod (string, NULL);
/* read brush angle */
errno = 0;
linenum++;
if (! fgets (string, sizeof (string), file))
goto failed;
angle = g_ascii_strtod (string, NULL);
fclose (file);
brush = GIMP_BRUSH (gimp_brush_generated_new (name, shape, radius, spikes,
hardness, aspect_ratio, angle));
g_free (name);
brush->spacing = spacing;
return g_list_prepend (NULL, brush);
failed:
fclose (file);
if (name)
g_free (name);
if (error && *error == NULL)
{
gchar *msg;
if (errno)
msg = g_strdup_printf (_("Line %d: %s"), linenum, g_strerror (errno));
else
msg = g_strdup_printf (_("File is truncated in line %d"), linenum);
g_set_error (error, GIMP_DATA_ERROR, GIMP_DATA_ERROR_READ,
_("Error while reading brush file '%s': %s"),
gimp_filename_to_utf8 (filename), msg);
g_free (msg);
}
return NULL;
}
GList *
gimp_palette_load (GimpContext *context,
GFile *file,
GInputStream *input,
GError **error)
{
GimpPalette *palette = NULL;
GimpPaletteEntry *entry;
GDataInputStream *data_input;
gchar *str;
gsize str_len;
gchar *tok;
gint r, g, b;
gint linenum;
g_return_val_if_fail (G_IS_FILE (file), NULL);
g_return_val_if_fail (G_IS_INPUT_STREAM (input), NULL);
g_return_val_if_fail (error == NULL || *error == NULL, NULL);
data_input = g_data_input_stream_new (input);
r = g = b = 0;
linenum = 1;
str_len = 1024;
str = gimp_data_input_stream_read_line_always (data_input, &str_len,
NULL, error);
if (! str)
goto failed;
if (! g_str_has_prefix (str, "GIMP Palette"))
{
g_set_error (error, GIMP_DATA_ERROR, GIMP_DATA_ERROR_READ,
_("Missing magic header."));
g_free (str);
goto failed;
}
g_free (str);
palette = g_object_new (GIMP_TYPE_PALETTE,
"mime-type", "application/x-gimp-palette",
NULL);
linenum++;
str_len = 1024;
str = gimp_data_input_stream_read_line_always (data_input, &str_len,
NULL, error);
if (! str)
goto failed;
if (g_str_has_prefix (str, "Name: "))
{
gchar *utf8;
utf8 = gimp_any_to_utf8 (g_strstrip (str + strlen ("Name: ")), -1,
_("Invalid UTF-8 string in palette file '%s'"),
gimp_file_get_utf8_name (file));
gimp_object_take_name (GIMP_OBJECT (palette), utf8);
g_free (str);
linenum++;
str_len = 1024;
str = gimp_data_input_stream_read_line_always (data_input, &str_len,
NULL, error);
if (! str)
goto failed;
if (g_str_has_prefix (str, "Columns: "))
{
gint columns;
if (! gimp_ascii_strtoi (g_strstrip (str + strlen ("Columns: ")),
NULL, 10, &columns))
{
g_set_error (error, GIMP_DATA_ERROR, GIMP_DATA_ERROR_READ,
_("Invalid column count."));
g_free (str);
goto failed;
}
if (columns < 0 || columns > 256)
{
g_message (_("Reading palette file '%s': "
"Invalid number of columns in line %d. "
"Using default value."),
gimp_file_get_utf8_name (file), linenum);
columns = 0;
}
gimp_palette_set_columns (palette, columns);
g_free (str);
linenum++;
str_len = 1024;
str = gimp_data_input_stream_read_line_always (data_input, &str_len,
NULL, error);
if (! str)
goto failed;
}
}
else /* old palette format */
{
gimp_object_take_name (GIMP_OBJECT (palette),
g_path_get_basename (gimp_file_get_utf8_name (file)));
}
while (str)
{
GError *my_error = NULL;
if (str[0] != '#' && str[0] != '\0')
{
tok = strtok (str, " \t");
if (tok)
r = atoi (tok);
else
g_message (_("Reading palette file '%s': "
"Missing RED component in line %d."),
gimp_file_get_utf8_name (file), linenum);
tok = strtok (NULL, " \t");
if (tok)
g = atoi (tok);
else
g_message (_("Reading palette file '%s': "
"Missing GREEN component in line %d."),
gimp_file_get_utf8_name (file), linenum);
tok = strtok (NULL, " \t");
if (tok)
b = atoi (tok);
else
g_message (_("Reading palette file '%s': "
"Missing BLUE component in line %d."),
gimp_file_get_utf8_name (file), linenum);
/* optional name */
tok = strtok (NULL, "\n");
if (r < 0 || r > 255 ||
g < 0 || g > 255 ||
b < 0 || b > 255)
g_message (_("Reading palette file '%s': "
"RGB value out of range in line %d."),
gimp_file_get_utf8_name (file), linenum);
/* don't call gimp_palette_add_entry here, it's rather inefficient */
entry = g_slice_new0 (GimpPaletteEntry);
gimp_rgba_set_uchar (&entry->color,
(guchar) r,
(guchar) g,
(guchar) b,
255);
entry->name = g_strdup (tok ? tok : _("Untitled"));
entry->position = gimp_palette_get_n_colors (palette);
palette->colors = g_list_prepend (palette->colors, entry);
palette->n_colors++;
}
g_free (str);
linenum++;
str_len = 1024;
str = g_data_input_stream_read_line (data_input, &str_len,
NULL, &my_error);
if (! str && my_error)
{
g_message (_("Reading palette file '%s': "
"Read %d colors from truncated file: %s"),
gimp_file_get_utf8_name (file),
g_list_length (palette->colors),
my_error->message);
g_clear_error (&my_error);
}
}
palette->colors = g_list_reverse (palette->colors);
g_object_unref (data_input);
return g_list_prepend (NULL, palette);
failed:
g_object_unref (data_input);
if (palette)
g_object_unref (palette);
g_prefix_error (error, _("In line %d of palette file: "), linenum);
return NULL;
}
GList *
gimp_brush_pipe_load (GimpContext *context,
const gchar *filename,
GError **error)
{
GimpBrushPipe *pipe = NULL;
GimpPixPipeParams params;
gint i;
gint num_of_brushes = 0;
gint totalcells;
gchar *paramstring;
GString *buffer;
gchar c;
gint fd;
g_return_val_if_fail (filename != NULL, NULL);
g_return_val_if_fail (g_path_is_absolute (filename), NULL);
g_return_val_if_fail (error == NULL || *error == NULL, NULL);
fd = g_open (filename, O_RDONLY | _O_BINARY, 0);
if (fd == -1)
{
g_set_error (error, GIMP_DATA_ERROR, GIMP_DATA_ERROR_OPEN,
_("Could not open '%s' for reading: %s"),
gimp_filename_to_utf8 (filename), g_strerror (errno));
return NULL;
}
/* The file format starts with a painfully simple text header */
/* get the name */
buffer = g_string_new (NULL);
while (read (fd, &c, 1) == 1 && c != '\n' && buffer->len < 1024)
g_string_append_c (buffer, c);
if (buffer->len > 0 && buffer->len < 1024)
{
gchar *utf8 =
gimp_any_to_utf8 (buffer->str, buffer->len,
_("Invalid UTF-8 string in brush file '%s'."),
gimp_filename_to_utf8 (filename));
pipe = g_object_new (GIMP_TYPE_BRUSH_PIPE,
"name", utf8,
"mime-type", "image/x-gimp-gih",
NULL);
g_free (utf8);
}
g_string_free (buffer, TRUE);
if (! pipe)
{
g_set_error (error, GIMP_DATA_ERROR, GIMP_DATA_ERROR_READ,
_("Fatal parse error in brush file '%s': "
"File is corrupt."),
gimp_filename_to_utf8 (filename));
close (fd);
return NULL;
}
/* get the number of brushes */
buffer = g_string_new (NULL);
while (read (fd, &c, 1) == 1 && c != '\n' && buffer->len < 1024)
g_string_append_c (buffer, c);
if (buffer->len > 0 && buffer->len < 1024)
{
num_of_brushes = strtol (buffer->str, ¶mstring, 10);
}
if (num_of_brushes < 1)
{
g_set_error (error, GIMP_DATA_ERROR, GIMP_DATA_ERROR_READ,
_("Fatal parse error in brush file '%s': "
"File is corrupt."),
gimp_filename_to_utf8 (filename));
close (fd);
g_object_unref (pipe);
g_string_free (buffer, TRUE);
return NULL;
}
while (*paramstring && g_ascii_isspace (*paramstring))
paramstring++;
if (*paramstring)
{
gimp_pixpipe_params_init (¶ms);
gimp_pixpipe_params_parse (paramstring, ¶ms);
pipe->dimension = params.dim;
pipe->rank = g_new0 (gint, pipe->dimension);
pipe->select = g_new0 (PipeSelectModes, pipe->dimension);
pipe->index = g_new0 (gint, pipe->dimension);
/* placement is not used at all ?? */
if (params.free_placement_string)
g_free (params.placement);
for (i = 0; i < pipe->dimension; i++)
{
pipe->rank[i] = MAX (1, params.rank[i]);
if (strcmp (params.selection[i], "incremental") == 0)
pipe->select[i] = PIPE_SELECT_INCREMENTAL;
else if (strcmp (params.selection[i], "angular") == 0)
pipe->select[i] = PIPE_SELECT_ANGULAR;
else if (strcmp (params.selection[i], "velocity") == 0)
pipe->select[i] = PIPE_SELECT_VELOCITY;
else if (strcmp (params.selection[i], "random") == 0)
pipe->select[i] = PIPE_SELECT_RANDOM;
else if (strcmp (params.selection[i], "pressure") == 0)
pipe->select[i] = PIPE_SELECT_PRESSURE;
else if (strcmp (params.selection[i], "xtilt") == 0)
pipe->select[i] = PIPE_SELECT_TILT_X;
else if (strcmp (params.selection[i], "ytilt") == 0)
pipe->select[i] = PIPE_SELECT_TILT_Y;
else
pipe->select[i] = PIPE_SELECT_CONSTANT;
if (params.free_selection_string)
g_free (params.selection[i]);
pipe->index[i] = 0;
}
}
else
{
pipe->dimension = 1;
pipe->rank = g_new (gint, 1);
pipe->rank[0] = num_of_brushes;
pipe->select = g_new (PipeSelectModes, 1);
pipe->select[0] = PIPE_SELECT_INCREMENTAL;
pipe->index = g_new (gint, 1);
pipe->index[0] = 0;
}
g_string_free (buffer, TRUE);
totalcells = 1; /* Not all necessarily present, maybe */
for (i = 0; i < pipe->dimension; i++)
totalcells *= pipe->rank[i];
pipe->stride = g_new0 (gint, pipe->dimension);
for (i = 0; i < pipe->dimension; i++)
{
if (i == 0)
pipe->stride[i] = totalcells / pipe->rank[i];
else
pipe->stride[i] = pipe->stride[i-1] / pipe->rank[i];
}
g_assert (pipe->stride[pipe->dimension-1] == 1);
pipe->brushes = g_new0 (GimpBrush *, num_of_brushes);
while (pipe->n_brushes < num_of_brushes)
{
GError *my_error = NULL;
pipe->brushes[pipe->n_brushes] = gimp_brush_load_brush (context,
fd, filename,
&my_error);
if (pipe->brushes[pipe->n_brushes])
{
gimp_object_set_name (GIMP_OBJECT (pipe->brushes[pipe->n_brushes]),
NULL);
}
else
{
g_propagate_error (error, my_error);
close (fd);
g_object_unref (pipe);
return NULL;
}
pipe->n_brushes++;
}
close (fd);
/* Current brush is the first one. */
pipe->current = pipe->brushes[0];
/* just to satisfy the code that relies on this crap */
GIMP_BRUSH (pipe)->spacing = pipe->current->spacing;
GIMP_BRUSH (pipe)->x_axis = pipe->current->x_axis;
GIMP_BRUSH (pipe)->y_axis = pipe->current->y_axis;
GIMP_BRUSH (pipe)->mask = pipe->current->mask;
GIMP_BRUSH (pipe)->pixmap = pipe->current->pixmap;
return g_list_prepend (NULL, pipe);
}
gchar *
fread_pascal_string (gint32 *bytes_read,
gint32 *bytes_written,
const guint16 mod_len,
FILE *f,
GError **error)
{
/*
* Reads a pascal string from the file padded to a multiple of mod_len
* and returns a utf-8 string.
*/
gchar *str;
gchar *utf8_str;
guchar len;
gint32 padded_len;
*bytes_read = 0;
*bytes_written = -1;
if (fread (&len, 1, 1, f) < 1)
{
psd_set_error (feof (f), errno, error);
return NULL;
}
(*bytes_read)++;
IFDBG(3) g_debug ("Pascal string length %d", len);
if (len == 0)
{
if (fseek (f, mod_len - 1, SEEK_CUR) < 0)
{
psd_set_error (feof (f), errno, error);
return NULL;
}
*bytes_read += (mod_len - 1);
*bytes_written = 0;
return NULL;
}
str = g_malloc (len);
if (fread (str, len, 1, f) < 1)
{
psd_set_error (feof (f), errno, error);
return NULL;
}
*bytes_read += len;
if (mod_len > 0)
{
padded_len = len + 1;
while (padded_len % mod_len != 0)
{
if (fseek (f, 1, SEEK_CUR) < 0)
{
psd_set_error (feof (f), errno, error);
return NULL;
}
(*bytes_read)++;
padded_len++;
}
}
utf8_str = gimp_any_to_utf8 (str, len, NULL);
*bytes_written = strlen (utf8_str);
g_free (str);
IFDBG(3) g_debug ("Pascal string: %s, bytes_read: %d, bytes_written: %d",
utf8_str, *bytes_read, *bytes_written);
return utf8_str;
}
GList *
gimp_pattern_load (GimpContext *context,
GFile *file,
GInputStream *input,
GError **error)
{
GimpPattern *pattern = NULL;
const Babl *format = NULL;
PatternHeader header;
gsize size;
gsize bytes_read;
gint bn_size;
gchar *name = NULL;
g_return_val_if_fail (G_IS_FILE (file), NULL);
g_return_val_if_fail (G_IS_INPUT_STREAM (input), NULL);
g_return_val_if_fail (error == NULL || *error == NULL, NULL);
/* read the size */
if (! g_input_stream_read_all (input, &header, sizeof (header),
&bytes_read, NULL, error) ||
bytes_read != sizeof (header))
{
g_prefix_error (error, _("File appears truncated: "));
goto error;
}
/* rearrange the bytes in each unsigned int */
header.header_size = g_ntohl (header.header_size);
header.version = g_ntohl (header.version);
header.width = g_ntohl (header.width);
header.height = g_ntohl (header.height);
header.bytes = g_ntohl (header.bytes);
header.magic_number = g_ntohl (header.magic_number);
/* Check for correct file format */
if (header.magic_number != GPATTERN_MAGIC || header.version != 1 ||
header.header_size <= sizeof (header))
{
g_set_error (error, GIMP_DATA_ERROR, GIMP_DATA_ERROR_READ,
_("Unknown pattern format version %d."),
header.version);
goto error;
}
/* Check for supported bit depths */
if (header.bytes < 1 || header.bytes > 4)
{
g_set_error (error, GIMP_DATA_ERROR, GIMP_DATA_ERROR_READ,
_("Unsupported pattern depth %d.\n"
"GIMP Patterns must be GRAY or RGB."),
header.bytes);
goto error;
}
/* Read in the pattern name */
if ((bn_size = (header.header_size - sizeof (header))))
{
gchar *utf8;
name = g_new (gchar, bn_size);
if (! g_input_stream_read_all (input, name, bn_size,
&bytes_read, NULL, error) ||
bytes_read != bn_size)
{
g_prefix_error (error, _("File appears truncated."));
g_free (name);
goto error;
}
utf8 = gimp_any_to_utf8 (name, -1,
_("Invalid UTF-8 string in pattern file '%s'."),
gimp_file_get_utf8_name (file));
g_free (name);
name = utf8;
}
if (! name)
name = g_strdup (_("Unnamed"));
pattern = g_object_new (GIMP_TYPE_PATTERN,
"name", name,
"mime-type", "image/x-gimp-pat",
NULL);
g_free (name);
switch (header.bytes)
{
case 1: format = babl_format ("Y' u8"); break;
case 2: format = babl_format ("Y'A u8"); break;
case 3: format = babl_format ("R'G'B' u8"); break;
case 4: format = babl_format ("R'G'B'A u8"); break;
}
pattern->mask = gimp_temp_buf_new (header.width, header.height, format);
size = header.width * header.height * header.bytes;
if (! g_input_stream_read_all (input,
gimp_temp_buf_get_data (pattern->mask), size,
&bytes_read, NULL, error) ||
bytes_read != size)
{
g_prefix_error (error, _("File appears truncated."));
goto error;
}
return g_list_prepend (NULL, pattern);
error:
if (pattern)
g_object_unref (pattern);
g_prefix_error (error, _("Fatal parse error in pattern file: "));
return NULL;
}
