graphics/gimp
graphics/gimp
1
0
Fork 0
mirror of https://gitlab.gnome.org/GNOME/gimp synced 2024-10-21 20:12:30 +00:00
Code Issues Packages Projects Releases Wiki Activity
gimp/app/core/gimpgradient-load.c
Sven Neumann a6f4f62608 libgimpcolor/gimprgb-parse.c use a signed integer to pass the string 
2004-07-22  Sven Neumann  <sven@gimp.org>

	* libgimpcolor/gimprgb-parse.c
	* libgimpcolor/gimprgb.h: use a signed integer to pass the string
	length to the new parser functions. The API explicitely asks for
	-1 to be passed...

	* app/core/gimp.c
	* app/core/gimpgradient-load.[ch]
	* app/core/gimpgradient.h: added preliminary support for loading
	simple SVG gradients (see bug #148127).  Be careful with this new
	feature; editing the loaded gradient will cause the SVG file to be
	overwritten! Work in progress...
2004-07-22 19:07:28 +00:00

484 lines
13 KiB
C
Raw Blame History

/* The GIMP -- an image manipulation program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#include "config.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <glib-object.h>
#include "libgimpbase/gimpbase.h"
#include "libgimpcolor/gimpcolor.h"
#include "core-types.h"
#include "config/gimpxmlparser.h"
#include "gimpgradient.h"
#include "gimpgradient-load.h"
#include "gimp-intl.h"
GimpData *
gimp_gradient_load (const gchar *filename,
gboolean stingy_memory_use,
GError **error)
{
GimpGradient *gradient;
GimpGradientSegment *seg;
GimpGradientSegment *prev;
gint num_segments;
gint i;
gint type, color;
FILE *file;
gchar line[1024];
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 = 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;
}
fgets (line, 1024, file);
if (strcmp (line, "GIMP Gradient\n") != 0)
{
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, NULL);
fgets (line, 1024, file);
if (! strncmp (line, "Name: ", strlen ("Name: ")))
{
gchar *utf8;
utf8 = gimp_any_to_utf8 (&line[strlen ("Name: ")], -1,
_("Invalid UTF-8 string in gradient file '%s'."),
gimp_filename_to_utf8 (filename));
g_strstrip (utf8);
gimp_object_set_name (GIMP_OBJECT (gradient), utf8);
g_free (utf8);
fgets (line, 1024, file);
}
else /* old gradient format */
{
gchar *basename;
gchar *utf8;
basename = g_path_get_basename (filename);
utf8 = g_filename_to_utf8 (basename, -1, NULL, NULL, NULL);
g_free (basename);
gimp_object_set_name (GIMP_OBJECT (gradient), utf8);
g_free (utf8);
}
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."),
gimp_filename_to_utf8 (filename));
g_object_unref (gradient);
fclose (file);
return NULL;
}
prev = NULL;
for (i = 0; i < num_segments; i++)
{
gchar *end;
seg = gimp_gradient_segment_new ();
seg->prev = prev;
if (prev)
prev->next = seg;
else
gradient->segments = seg;
fgets (line, 1024, file);
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 &&
sscanf (end, "%d %d", &type, &color) == 2)
{
seg->type = (GimpGradientSegmentType) type;
seg->color = (GimpGradientSegmentColor) color;
}
else
{
g_message (_("Corrupt segment %d in gradient file '%s'."),
i, gimp_filename_to_utf8 (filename));
}
prev = seg;
}
fclose (file);
return GIMP_DATA (gradient);
}
/* SVG gradient parser */
typedef enum
{
SVG_START,
SVG_IN_SVG,
SVG_IN_GRADIENT,
SVG_IN_GRADIENT_STOP,
SVG_IN_UNKNOWN
} SvgParserState;
typedef struct
{
SvgParserState state;
SvgParserState last_known_state;
gint unknown_depth;
GimpGradient *gradient;
GList *stops;
} SvgParser;
typedef struct
{
gdouble offset;
GimpRGB color;
} SvgStop;
static void svg_parser_start_element (GMarkupParseContext *context,
const gchar *element_name,
const gchar **attribute_names,
const gchar **attribute_values,
gpointer user_data,
GError **error);
static void svg_parser_end_element (GMarkupParseContext *context,
const gchar *element_name,
gpointer user_data,
GError **error);
static void svg_parser_start_unknown (SvgParser *parser);
static void svg_parser_end_unknown (SvgParser *parser);
static SvgStop * svg_parse_gradient_stop (const gchar **names,
const gchar **values);
static const GMarkupParser markup_parser =
{
svg_parser_start_element,
svg_parser_end_element,
NULL, /* characters */
NULL, /* passthrough */
NULL /* error */
};
GimpData *
gimp_gradient_load_svg (const gchar *filename,
gboolean stingy_memory_use,
GError **error)
{
GimpData *data = NULL;
GimpXmlParser *xml_parser;
SvgParser parser;
gboolean success;
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);
parser.state = SVG_START;
parser.unknown_depth = 0;
parser.gradient = NULL;
parser.stops = NULL;
xml_parser = gimp_xml_parser_new (&markup_parser, &parser);
success = gimp_xml_parser_parse_file (xml_parser, filename, error);
gimp_xml_parser_free (xml_parser);
if (success && parser.gradient && parser.stops)
{
GimpGradientSegment *seg = gimp_gradient_segment_new ();
GimpGradientSegment *next = NULL;
SvgStop *stop = parser.stops->data;
GList *list;
seg->left_color = stop->color;
seg->right_color = stop->color;
/* the list of offsets is sorted from largest to smallest */
for (list = g_list_next (parser.stops); list; list = g_list_next (list))
{
seg->left = stop->offset;
seg->middle = (seg->left + seg->right) / 2.0;
next = seg;
seg = gimp_gradient_segment_new ();
seg->next = next;
next->prev = seg;
seg->right = stop->offset;
seg->right_color = stop->color;
stop = list->data;
seg->left_color = stop->color;
}
seg->middle = (seg->left + seg->right) / 2.0;
parser.gradient->segments = seg;
data = g_object_ref (parser.gradient);
/* FIXME: this will be overwritten by GimpDataFactory */
data->writable = FALSE;
}
/* FIXME: error handling */
if (parser.gradient)
g_object_unref (parser.gradient);
g_list_foreach (parser.stops, (GFunc) g_free, NULL);
g_list_free (parser.stops);
return data;
}
static void
svg_parser_start_element (GMarkupParseContext *context,
const gchar *element_name,
const gchar **attribute_names,
const gchar **attribute_values,
gpointer user_data,
GError **error)
{
SvgParser *parser = user_data;
switch (parser->state)
{
case SVG_START:
if (strcmp (element_name, "svg") == 0)
parser->state = SVG_IN_SVG;
else
svg_parser_start_unknown (parser);
break;
case SVG_IN_SVG:
if (parser->gradient == NULL &&
strcmp (element_name, "linearGradient") == 0)
{
const gchar *name = NULL;
while (*attribute_names && *attribute_values)
{
if (strcmp (*attribute_names, "id") == 0 && *attribute_values)
name = *attribute_values;
attribute_names++;
attribute_values++;
}
parser->gradient = g_object_new (GIMP_TYPE_GRADIENT,
"name", name,
NULL);
parser->state = SVG_IN_GRADIENT;
}
else
svg_parser_start_unknown (parser);
break;
case SVG_IN_GRADIENT:
if (strcmp (element_name, "stop") == 0)
{
SvgStop *stop = svg_parse_gradient_stop (attribute_names,
attribute_values);
/* The spec clearly states that each gradient stop's offset
* value is required to be equal to or greater than the
* previous gradient stop's offset value.
*/
if (parser->stops)
stop->offset = MAX (stop->offset,
((SvgStop *) parser->stops->data)->offset);
parser->stops = g_list_prepend (parser->stops, stop);
parser->state = SVG_IN_GRADIENT_STOP;
}
else
svg_parser_start_unknown (parser);
break;
case SVG_IN_GRADIENT_STOP:
svg_parser_start_unknown (parser);
break;
case SVG_IN_UNKNOWN:
svg_parser_start_unknown (parser);
break;
}
}
static void
svg_parser_end_element (GMarkupParseContext *context,
const gchar *element_name,
gpointer user_data,
GError **error)
{
SvgParser *parser = user_data;
switch (parser->state)
{
case SVG_START:
g_return_if_reached ();
break;
case SVG_IN_SVG:
parser->state = SVG_START;
break;
case SVG_IN_GRADIENT:
parser->state = SVG_IN_SVG;
break;
case SVG_IN_GRADIENT_STOP:
parser->state = SVG_IN_GRADIENT;
break;
case SVG_IN_UNKNOWN:
svg_parser_end_unknown (parser);
break;
}
}
static void
svg_parser_start_unknown (SvgParser *parser)
{
if (parser->unknown_depth == 0)
parser->last_known_state = parser->state;
parser->state = SVG_IN_UNKNOWN;
parser->unknown_depth++;
}
static void
svg_parser_end_unknown (SvgParser *parser)
{
g_return_if_fail (parser->unknown_depth > 0 &&
parser->state == SVG_IN_UNKNOWN);
parser->unknown_depth--;
if (parser->unknown_depth == 0)
parser->state = parser->last_known_state;
}
static SvgStop *
svg_parse_gradient_stop (const gchar **names,
const gchar **values)
{
SvgStop stop;
stop.offset = 0.0;
gimp_rgba_set (&stop.color, 0.0, 0.0, 0.0, 1.0);
while (*names && *values)
{
if (strcmp (*names, "offset") == 0)
{
gchar *end;
stop.offset = g_ascii_strtod (*values, &end);
if (end && *end == '%')
stop.offset /= 100.0;
stop.offset = CLAMP (stop.offset, 0.0, 1.0);
}
else if (strcmp (*names, "stop-color") == 0)
{
gimp_rgb_parse_css (&stop.color, *values, -1);
}
else if (strcmp (*names, "stop-opacity") == 0)
{
gdouble opacity = g_ascii_strtod (*values, NULL);
if (errno != ERANGE)
gimp_rgb_set_alpha (&stop.color, CLAMP (opacity, 0.0, 1.0));
}
names++;
values++;
}
return g_memdup (&stop, sizeof (SvgStop));
}
Reference in a new issue View git blame Copy permalink