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; }