/*

% Copyright (C) 2003-2025 GraphicsMagick Group

% Copyright (C) 2002 ImageMagick Studio

%

% This program is covered by multiple licenses, which are described in

% Copyright.txt. You should have received a copy of Copyright.txt with this

% package; otherwise see http://www.graphicsmagick.org/www/Copyright.html.

%

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%                                                                             %

%                                                                             %

%                                                                             %

%                            SSSSS  V   V   GGGG                              %

%                            SS     V   V  G                                  %

%                             SSS   V   V  G GG                               %

%                               SS   V V   G   G                              %

%                            SSSSS    V     GGG                               %

%                                                                             %

%                                                                             %

%                 Read/Write Scalable Vector Graphics Format.                 %

%                                                                             %

%                                                                             %

%                              Software Design                                %

%                                John Cristy                                  %

%                             William Radcliffe                               %

%                                March 2000                                   %

%                                                                             %

%                                                                             %

%                                                                             %

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%

%

*/

/*

  Include declarations.

*/

#include "magick/studio.h"

#include "magick/attribute.h"

#include "magick/blob.h"

#include "magick/color.h"

#include "magick/constitute.h"

#include "magick/gem.h"

#include "magick/log.h"

#include "magick/magick.h"

#include "magick/render.h"

#include "magick/tempfile.h"

#include "magick/utility.h"

#if defined(HasXML)

#  if defined(MSWINDOWS)

#    if defined(__MINGW32__)

#      if !defined(_MSC_VER)

#        define _MSC_VER 1200

#      endif

#    else

#      include <win32config.h>

#    endif

#  endif

#  include <libxml/parser.h>

#  include <libxml/xmlmemory.h>

#  include <libxml/parserInternals.h>

#  include <libxml/xmlerror.h>

#endif

/* Enable support for XML internal subset */

#define ENABLE_XML_INTERNAL_SUBSET 1

/*

  Avoid shadowing library globals and functions.

*/

#define attribute attribute_magick

#if defined(HasAUTOTRACE)

#include "types.h"

#include "image-header.h"

#include "fit.h"

#include "output.h"

#include "pxl-outline.h"

#include "atquantize.h"

#include "thin-image.h"

char

  *version_string = "AutoTrace version 0.24a";

#endif

/*

  Define declarations.

*/

#define MVGPrintf  (void) fprintf

/*

  Typedef declarations.

*/

typedef struct _BoundingBox

{

  double

    x,

    y,

    width,

    height;

} BoundingBox;

typedef struct _SVGInfo

{

  FILE

    *file;

  ExceptionInfo

    *exception;

  Image

    *image;

  const ImageInfo

    *image_info;

  AffineMatrix

    affine;

  unsigned long

    width,

    height;

  char

    *size,

    *title,

    *comment;

  int

    n;

  double

    *scale,

    pointsize;

  ElementInfo

    element;

  SegmentInfo

    segment;

  BoundingBox

    bounds,

    view_box;

  PointInfo

    radius;

  char

    *stop_color,

    *offset,

    *text,

    *vertices,

    *url;

  size_t

    comment_len,

    text_len;

  /*

    Even though it's unlikely to happen, keep track of nested <defs> and

    elements tagged with an id.

  */

  int

    defsPushCount,      /* for tracking nested <defs> */

    idLevelInsideDefs,  /* when an "id" is seen, remember svg->n (SVG element level) */

    svgPushCount;       /* for tracking nested <svg> elements */

  unsigned long

    signature;

} SVGInfo;

/*

  Forward declarations.

*/

#if defined(ENABLE_SVG_WRITER) && ENABLE_SVG_WRITER

static unsigned int

  WriteSVGImage(const ImageInfo *,Image *);

#endif /* if defined(ENABLE_SVG_WRITER) && ENABLE_SVG_WRITER */

#if defined(HasXML)

/*

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%                                                                             %

%                                                                             %

%                                                                             %

%   R e a d S V G I m a g e                                                   %

%                                                                             %

%                                                                             %

%                                                                             %

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%

%  Method ReadSVGImage reads a Scalable Vector Gaphics file and returns it.  It

%  allocates the memory necessary for the new Image structure and returns a

%  pointer to the new image.

%

%  The format of the ReadSVGImage method is:

%

%      Image *ReadSVGImage(const ImageInfo *image_info,ExceptionInfo *exception)

%

%  A description of each parameter follows:

%

%    o image:  Method ReadSVGImage returns a pointer to the image after

%      reading. A null image is returned if there is a memory shortage or if

%      the image cannot be read.

%

%    o image_info: Specifies a pointer to a ImageInfo structure.

%

%    o exception: return any errors or warnings in this structure.

%

%

*/

static double

GetUserSpaceCoordinateValue(const SVGInfo *svg_info,

                            int type,

                            const char *string,

                            MagickBool positive)

{

  char

    *p,

    token[MaxTextExtent];

  double

    value;

  assert(string != (const char *) NULL);

  p=(char *) string;

  (void) MagickGetToken(p,&p,token,MaxTextExtent);

  if ((MagickAtoFChk(token,&value) == MagickFail) ||

      (((positive) && value < 0.0)))

    {

      errno=0;

      ThrowException(svg_info->exception,DrawError,InvalidPrimitiveArgument,

                     string);

    }

  if (strchr(token,'%') != (char *) NULL)

    {

      double

        alpha,

        beta;

      if (type > 0)

        return(svg_info->view_box.width*value/100.0);

      if (type < 0)

        return(svg_info->view_box.height*value/100.0);

      alpha=value-svg_info->view_box.width;

      beta=value-svg_info->view_box.height;

      return(sqrt(alpha*alpha+beta*beta)/sqrt(2.0)/100.0);

    }

  (void) MagickGetToken(p,&p,token,MaxTextExtent);

  if (LocaleNCompare(token,"cm",2) == 0)

    return(72.0*svg_info->scale[0]/2.54*value);

  if (LocaleNCompare(token,"em",2) == 0)

    return(svg_info->pointsize*value);

  if (LocaleNCompare(token,"ex",2) == 0)

    return(svg_info->pointsize*value/2.0);

  if (LocaleNCompare(token,"in",2) == 0)

    return(72.0*svg_info->scale[0]*value);

  if (LocaleNCompare(token,"mm",2) == 0)

    return(72.0*svg_info->scale[0]/25.4*value);

  if (LocaleNCompare(token,"pc",2) == 0)

    return(72.0*svg_info->scale[0]/6.0*value);

  if (LocaleNCompare(token,"pt",2) == 0)

    return(svg_info->scale[0]*value);

  if (LocaleNCompare(token,"px",2) == 0)

    return(value);

  return(value);

}

#define MagickCopySubstrToToken(dst, src, size)     \

  do {                                            \

    (void) memcpy(dst,src,(size));                \

    dst[(size)]='\0';                             \

  } while (0);

static char **GetStyleTokens(const SVGInfo *svg_info,const char *text,size_t *number_tokens)

{

#define MaxStyleTokens 256

  char

    **tokens;

  const char

    *p,

    *q;

  size_t

    alloc_tokens,

    i,

    iListFront;

  MagickBool

    IsFontSize = MagickFalse;

  assert(svg_info->signature == MagickSignature);

  *number_tokens=0;

  alloc_tokens=0;

  if (text == (const char *) NULL)

    return((char **) NULL);

  /*

    Determine the number of arguments.

    style="fill: red; stroke: blue; stroke-width: 3"

  */

  for (p=text; *p != '\0'; p++)

    if (*p == ':')

      alloc_tokens+=2;

  if (alloc_tokens == 0)

    return((char **) NULL);

  if (alloc_tokens >= MaxStyleTokens)

    alloc_tokens=MaxStyleTokens;

  tokens=MagickAllocateMemory(char **,(alloc_tokens+2)*sizeof(*tokens));

  if (tokens == (char **) NULL)

    {

      ThrowException3(svg_info->exception,ResourceLimitError,

                      MemoryAllocationFailed,UnableToConvertStringToTokens);

      return((char **) NULL);

    }

  (void) memset(tokens,0,(alloc_tokens+2)*sizeof(*tokens));

  /*

    Convert string to an ASCII list.

  */

  i=0;

  p=text;

  iListFront = 0;

  for (q=p; *q != '\0'; q++)

    {

      /*

        ':' terminates the style element (e.g., fill:)

        ';' terminates the style element value (e.g., red)

      */

      if ((*q != ':') && (*q != ';') && (*q != '\0'))

        continue;

      tokens[i]=MagickAllocateMemory(char *,(size_t) (q-p+1));

      if (tokens[i] == NULL)

        {

          ThrowException3(svg_info->exception,ResourceLimitError,

                          MemoryAllocationFailed,UnableToConvertStringToTokens);

          break;

        }

      MagickCopySubstrToToken(tokens[i], p, q-p);

      (void) MagickStripString(tokens[i]);

      /*

        Check for "font-size", which we will move to the first position in

        the list.  This will ensure that any following numerical conversions

        that depend on the font size will use the new value.

      */

      if  ( (i & 1) == 0 )  /*element name*/

        IsFontSize = (LocaleCompare("font-size",tokens[i]) == 0) ? MagickTrue : MagickFalse;

      else if  ( IsFontSize )

        {/*found font-size/value pair*/

          if  ( (i-1) == iListFront )

            iListFront += 2;  /* already at front of list */

          else

            {

              /* move "font-size" and value to top of list */

              char * pToken = tokens[iListFront];

              tokens[iListFront] = tokens[i-1];

              tokens[i-1] = pToken;

              iListFront++;

              pToken = tokens[iListFront];

              tokens[iListFront] = tokens[i];

              tokens[i] = pToken;

              iListFront++;

            }

        }/*found font-size/value pair*/

      i++;

      if (i >= alloc_tokens)

        break;

      p=q+1;

    }

  if (i < alloc_tokens)

    {

      tokens[i]=MagickAllocateMemory(char *,(size_t) (q-p+1));

      if (tokens[i] == NULL)

        {

          ThrowException3(svg_info->exception,ResourceLimitError,

                          MemoryAllocationFailed,UnableToConvertStringToTokens);

        }

      else

        {

          MagickCopySubstrToToken(tokens[i], p, q-p);

          (void) MagickStripString(tokens[i]);

          i++;

        }

    }

  tokens[i]=(char *) NULL;

  *number_tokens=i;

  return(tokens);

}

#define THROW_GET_TRANSFORM_TOKENS_EXCEPTION()                          \

  do {                                                                  \

    ThrowException3(svg_info->exception,ResourceLimitError,             \

                    MemoryAllocationFailed,UnableToConvertStringToTokens); \

  } while (0)

static char **GetTransformTokens(const SVGInfo *svg_info,const char *text,

                                 size_t *number_tokens)

{

#define MaxTransformTokens 256

  char

    **tokens;

  register const char

    *p,

    *q;

  register size_t

    i;

  size_t

    alloc_tokens;

  assert(svg_info->signature == MagickSignature);

  *number_tokens=0;

  if (text == (const char *) NULL)

    return((char **) NULL);

  alloc_tokens=8;

  tokens=MagickAllocateMemory(char **,(alloc_tokens+2)*sizeof(*tokens));

  if (tokens == (char **) NULL)

    {

      ThrowException3(svg_info->exception,ResourceLimitError,

                      MemoryAllocationFailed,UnableToConvertStringToTokens);

      return((char **) NULL);

    }

  /*

    Convert string to an ASCII list.

  */

  i=0;

  p=text;

  for (q=p; *q != '\0'; q++)

    {

      if ((*q != '(') && (*q != ')') && (*q != '\0'))

        continue;

      if (i == alloc_tokens)

        {

          alloc_tokens <<= 1;

          MagickReallocMemory(char **,tokens,(alloc_tokens+2)*sizeof(*tokens));

          if (tokens == (char **) NULL)

            THROW_GET_TRANSFORM_TOKENS_EXCEPTION();

        }

      /*

        Apply an arbitrary limit on number of tokens to avoid DOS

      */

      if (i >= MaxTransformTokens)

        break;

      tokens[i]=MagickAllocateMemory(char *,(size_t) (q-p+1));

      if (tokens[i] == NULL)

        THROW_GET_TRANSFORM_TOKENS_EXCEPTION();

      MagickCopySubstrToToken(tokens[i], p, q-p);

      (void) MagickStripString(tokens[i]);

      i++;

      p=q+1;

    }

  if (i < MaxTransformTokens)

    {

      tokens[i]=MagickAllocateMemory(char *,(size_t) (q-p+1));

      if (tokens[i] == NULL)

        THROW_GET_TRANSFORM_TOKENS_EXCEPTION();

      MagickCopySubstrToToken(tokens[i], p, q-p);

      (void) MagickStripString(tokens[i]);

      i++;

    }

  tokens[i]=(char *) NULL;

  *number_tokens=i;

  return(tokens);

}

#if defined(__cplusplus) || defined(c_plusplus)

extern "C" {

#endif

  static void SVGStartElement(void *context,const xmlChar *name,

                              const xmlChar **attributes);

  static void SVGEndElement(void *context,const xmlChar *name);

  static void SVGCharacters(void *context,const xmlChar *c,int length);

  static void SVGWarning(void *context,const char *format,...);

  ModuleExport void RegisterSVGImage(void);

  ModuleExport void UnregisterSVGImage(void);

#if defined(__cplusplus) || defined(c_plusplus)

}

#endif

/*

  Code from SVGStartElement() that processed transform="..." has been refactored

  into new function SVGProcessTransformString().

*/

static void

SVGProcessTransformString(const SVGInfo *svg_info,char const *TransformString)

{/*SVGProcessTransformString*/

  char

    **tokens;

  AffineMatrix

    affine,

    current,

    transform;

  char

    *p = NULL,

    token[MaxTextExtent];

  size_t

    j,

    number_tokens = 0;

  assert(svg_info->signature == MagickSignature);

  IdentityAffine(&transform);

  (void) LogMagickEvent(CoderEvent,GetMagickModule(),"  ");

  tokens=GetTransformTokens(svg_info,TransformString,&number_tokens);

  if ((tokens != (char **) NULL) && (number_tokens > 0))

    {/*if ((tokens != (char **) NULL) && (number_tokens > 0))*/

                const char

        *keyword = NULL,

        *value = NULL;

      for (j=0; j < (number_tokens-1); j+=2)

        {/*j token loop*/

          keyword=(char *) tokens[j];   /* matrix, rotate, etc. */

          value=(char *) tokens[j+1];   /* associated numerical values */

          (void) LogMagickEvent(CoderEvent,GetMagickModule(),

                                "    %.1024s: %.1024s",keyword,value);

          current=transform;

          IdentityAffine(&affine);

          switch (*keyword)

            {/*keyword switch*/

            case 'M':

            case 'm':

              {/*Mm*/

                if (LocaleCompare(keyword,"matrix") == 0)

                  {

                    p=(char *) value;

                    (void) MagickGetToken(p,&p,token,MaxTextExtent);

                    affine.sx=MagickAtoF(token);

                    (void) MagickGetToken(p,&p,token,MaxTextExtent);

                    if (*token == ',')

                      (void) MagickGetToken(p,&p,token,MaxTextExtent);

                    affine.rx=MagickAtoF(token);

                    (void) MagickGetToken(p,&p,token,MaxTextExtent);

                    if (*token == ',')

                      (void) MagickGetToken(p,&p,token,MaxTextExtent);

                    affine.ry=MagickAtoF(token);

                    (void) MagickGetToken(p,&p,token,MaxTextExtent);

                    if (*token == ',')

                      (void) MagickGetToken(p,&p,token,MaxTextExtent);

                    affine.sy=MagickAtoF(token);

                    (void) MagickGetToken(p,&p,token,MaxTextExtent);

                    if (*token == ',')

                      (void) MagickGetToken(p,&p,token,MaxTextExtent);

                    affine.tx=MagickAtoF(token);

                    (void) MagickGetToken(p,&p,token,MaxTextExtent);

                    if (*token == ',')

                      (void) MagickGetToken(p,&p,token,MaxTextExtent);

                    affine.ty=MagickAtoF(token);

                    break;

                  }

                break;

              }/*Mm*/

            case 'R':

            case 'r':

              {/*Rr*/

                if (LocaleCompare(keyword,"rotate") == 0)

                  {

                    double

                      angle;

                    angle=GetUserSpaceCoordinateValue(svg_info,0,value,MagickFalse);

                    affine.sx=cos(DegreesToRadians(fmod(angle,360.0)));

                    affine.rx=sin(DegreesToRadians(fmod(angle,360.0)));

                    affine.ry=(-sin(DegreesToRadians(fmod(angle,360.0))));

                    affine.sy=cos(DegreesToRadians(fmod(angle,360.0)));

                    break;

                  }

                break;

              }/*Rr*/

            case 'S':

            case 's':

              {/*Ss*/

                if (LocaleCompare(keyword,"scale") == 0)

                  {

                    for (p=(char *) value; *p != '\0'; p++)

                      if (isspace((int) (*p)) || (*p == ','))

                        break;

                    affine.sx=GetUserSpaceCoordinateValue(svg_info,1,value,MagickFalse);

                    affine.sy=affine.sx;

                    if (*p != '\0')

                      affine.sy=

                        GetUserSpaceCoordinateValue(svg_info,-1,p+1,MagickFalse);

                    svg_info->scale[svg_info->n]=ExpandAffine(&affine);

                    break;

                  }

                if (LocaleCompare(keyword,"skewX") == 0)

                  {

                    affine.sx=svg_info->affine.sx;

                    affine.ry=tan(DegreesToRadians(fmod(

                      GetUserSpaceCoordinateValue(svg_info,1,value,MagickFalse),

                      360.0)));

                    affine.sy=svg_info->affine.sy;

                    break;

                  }

                if (LocaleCompare(keyword,"skewY") == 0)

                  {

                    affine.sx=svg_info->affine.sx;

                    affine.rx=tan(DegreesToRadians(fmod(

                      GetUserSpaceCoordinateValue(svg_info,-1,value,MagickFalse),

                      360.0)));

                    affine.sy=svg_info->affine.sy;

                    break;

                  }

                break;

              }/*Ss*/

            case 'T':

            case 't':

              {/*Tt*/

                if (LocaleCompare(keyword,"translate") == 0)

                  {

                    for (p=(char *) value; *p != '\0'; p++)

                      if (isspace((int) (*p)) || (*p == ','))

                        break;

                    affine.tx=GetUserSpaceCoordinateValue(svg_info,1,value,MagickFalse);

                    affine.ty=affine.tx;

                    if (*p != '\0')

                      affine.ty=

                        GetUserSpaceCoordinateValue(svg_info,-1,p+1,MagickFalse);

                    break;

                  }

                break;

              }/*Tt*/

            default:

              break;

            }/*keyword switch*/

          transform.sx=current.sx*affine.sx+current.ry*affine.rx;

          transform.rx=current.rx*affine.sx+current.sy*affine.rx;

          transform.ry=current.sx*affine.ry+current.ry*affine.sy;

          transform.sy=current.rx*affine.ry+current.sy*affine.sy;

          transform.tx=current.sx*affine.tx+current.ry*affine.ty+

            current.tx;

          transform.ty=current.rx*affine.tx+current.sy*affine.ty+

            current.ty;

        }/*j token loop*/

      MVGPrintf(svg_info->file,"affine %g %g %g %g %g %g\n",

                transform.sx,transform.rx,transform.ry,transform.sy,

                transform.tx,transform.ty);

    }/*if ((tokens != (char **) NULL) && (number_tokens > 0))*/

  /* clean up memory used for tokens */

  if (tokens != (char **) NULL)

    {

      for (j=0; tokens[j] != (char *) NULL; j++)

        MagickFreeMemory(tokens[j]);

      MagickFreeMemory(tokens);

    }

}/*SVGProcessTransformString*/

static void

SVGStartElement(void *context,const xmlChar *name,

                const xmlChar **attributes)

{

  char

    *color = NULL,

    id[MaxTextExtent],

    *p = NULL,

    token[MaxTextExtent],

    *units = NULL;

  const char

    *keyword = NULL,

    *value = NULL;

  size_t

    number_tokens = 0;

  SVGInfo

    *svg_info;

  xmlParserCtxtPtr

    parser;

  size_t

    i,

    j;

  char

    svg_element_background_color[MaxTextExtent];  /* to support style="background:color" */

  MagickBool

    IsTSpan = MagickFalse,

    IsTextOrTSpan = MagickFalse;

  /*

    Called when an opening tag has been processed.

  */

  (void) LogMagickEvent(CoderEvent,GetMagickModule(),

                        "  SAX.startElement(%.1024s",name);

  id[0]='\0';

  token[0]='\0';

  parser=(xmlParserCtxtPtr) context;

  svg_info=(SVGInfo *) parser->_private;

  assert(svg_info->signature == MagickSignature);

  svg_info->n++;

  MagickReallocMemory(double *,svg_info->scale,MagickArraySize((size_t)svg_info->n+1,sizeof(double)));

  if (svg_info->scale == (double *) NULL)

    {

      ThrowException(svg_info->exception,ResourceLimitError,

                     MemoryAllocationFailed,"unable to convert SVG image");

      return;

    }

  svg_info->scale[svg_info->n]=svg_info->scale[svg_info->n-1];

  color=AcquireString("none");

  units=AcquireString("userSpaceOnUse");

  value=(const char *) NULL;

  svg_element_background_color[0]='\0';

  IsTextOrTSpan = IsTSpan = LocaleCompare((char *) name,"tspan") == 0;  /* need to know this early */

  /*

    According to the SVG spec, for the following SVG elements, if the x or y

    attribute is not specified, the effect is as if a value of "0" were specified.

  */

  if (

         (LocaleCompare((char *) name,"image") == 0)

      || (LocaleCompare((char *) name,"pattern") == 0)

      || (LocaleCompare((char *) name,"rect") == 0)

      || (LocaleCompare((char *) name,"text") == 0)

      || (LocaleCompare((char *) name,"use") == 0)

      )

    {

      svg_info->bounds.x = svg_info->bounds.y = 0;

    }

  /*

    NOTE: SVG spec makes similar statements for cx,cy of circle and ellipse, and

    x1,y1,x2,y2 of line, but these are zeroed out initially, AND at the end of

    SVGEndElement() after they have been used.

  */

  /*

    When "font-size" is (or is contained in) one of the attributes for this SVG

    element, we want it to be processed first so that any numerical conversions

    that depend on the font size will use the new value.  So we will first scan

    the attribute list and move any "font-size", "class" (which may contain a

    "font-size"), or "style" (which may contain a "font-size") attributes to the

    front of the attribute list.

    For now we will ignore the possibility that "font-size" may be specified

    more than once among "font-size", "class", and "style".  However, the

    relative order among these three will be preserved.

  */

  if (attributes != (const xmlChar **) NULL)

  {/*have some attributes*/

    size_t iListFront = 0;

    for  ( i = 0; (attributes[i] != (const xmlChar *) NULL); i += 2 )

      {/*attribute[i]*/

        keyword = (const char *) attributes[i];

        if  (  (LocaleCompare(keyword,"font-size") == 0)

            || (LocaleCompare(keyword,"class") == 0)

            || (LocaleCompare(keyword,"style") == 0)

         )

         {/*(possible) font-size*/

            if  ( i == iListFront )

              iListFront += 2;  /* already at front of list */

            else

              {

                /* move to front of list */

                const xmlChar * pAttr = attributes[iListFront];

                attributes[iListFront] = attributes[i];

                attributes[i] = pAttr;

                iListFront++;

                pAttr = attributes[iListFront];

                attributes[iListFront] = attributes[i+1];

                attributes[i+1] = pAttr;

                iListFront++;

              }

         }/*(possible) font-size*/

      }/*attribute[i]*/

  }/*have some attributes*/

  if (attributes != (const xmlChar **) NULL)

    for (i=0; (svg_info->exception->severity < ErrorException) &&

           (attributes[i] != (const xmlChar *) NULL); i+=2)

      {

        keyword=(const char *) attributes[i];

        value=(const char *) attributes[i+1];

        switch (*keyword)

          {

          case 'C':

          case 'c':

            {

              if (LocaleCompare(keyword,"cx") == 0)

                {

                  svg_info->element.cx=

                    GetUserSpaceCoordinateValue(svg_info,1,value,MagickFalse);

                  break;

                }

              if (LocaleCompare(keyword,"cy") == 0)

                {

                  svg_info->element.cy=

                    GetUserSpaceCoordinateValue(svg_info,-1,value,MagickFalse);

                  break;

                }

              break;

            }

          case 'F':

          case 'f':

            {

              if (LocaleCompare(keyword,"fx") == 0)

                {

                  svg_info->element.major=

                    GetUserSpaceCoordinateValue(svg_info,1,value,MagickFalse);

                  break;

                }

              if (LocaleCompare(keyword,"fy") == 0)

                {

                  svg_info->element.minor=

                    GetUserSpaceCoordinateValue(svg_info,-1,value,MagickFalse);

                  break;

                }

              break;

            }

          case 'H':

          case 'h':

            {

              if (LocaleCompare(keyword,"height") == 0)

                {

                  svg_info->bounds.height=

                    GetUserSpaceCoordinateValue(svg_info,-1,value,MagickTrue);

                  break;

                }

              break;

            }

          case 'I':

          case 'i':

            {

              if (LocaleCompare(keyword,"id") == 0)

                {

                  (void) strlcpy(id,value,MaxTextExtent);

                  /* track elements inside <defs> that have an "id" */

                  if  ( (svg_info->defsPushCount > 0)

                    && (svg_info->idLevelInsideDefs == 0)   /* do not allow nested "id" elements for now */

                    && (LocaleCompare((const char *)name,"clipPath") != 0)  /* handled separately */

                    && (LocaleCompare((const char *)name,"mask") != 0)      /* handled separately */

                    )

                      svg_info->idLevelInsideDefs = svg_info->n;

                  break;

                }

              break;

            }

          case 'R':

          case 'r':

            {

              if (LocaleCompare(keyword,"r") == 0)

                {

                  svg_info->element.angle=

                    GetUserSpaceCoordinateValue(svg_info,0,value,MagickFalse);

                  break;

                }

              break;

            }

          case 'W':

          case 'w':

            {

              if (LocaleCompare(keyword,"width") == 0)

                {

                  svg_info->bounds.width=

                    GetUserSpaceCoordinateValue(svg_info,1,value,MagickTrue);

                  break;

                }

              break;

            }

          case 'X':

          case 'x':

            {

              if (LocaleCompare(keyword,"x") == 0)

                {

                  /* if processing a tspan, preserve the current bounds.x, which belongs to the

                     previously processed text or tspan; the bounds.x for the current tspan will

                     be set later */

                  if (!IsTSpan)

                    svg_info->bounds.x=GetUserSpaceCoordinateValue(svg_info,1,value,MagickFalse);

                  break;

                }

              if (LocaleCompare(keyword,"x1") == 0)

                {

                  svg_info->segment.x1=

                    GetUserSpaceCoordinateValue(svg_info,1,value,MagickFalse);

                  break;

                }

              if (LocaleCompare(keyword,"x2") == 0)

                {

                  svg_info->segment.x2=

                    GetUserSpaceCoordinateValue(svg_info,1,value,MagickFalse);

                  break;

                }

              break;

            }

          case 'Y':

          case 'y':

            {

              if (LocaleCompare(keyword,"y") == 0)

                {

                  /* if processing a tspan, preserve the current bounds.y, which belongs to the

                     previously processed text or tspan; the bounds.y for the current tspan will

                     be set later */

                  if (!IsTSpan)

                    svg_info->bounds.y=GetUserSpaceCoordinateValue(svg_info,-1,value,MagickFalse);

                  break;

                }

              if (LocaleCompare(keyword,"y1") == 0)

                {

                  svg_info->segment.y1=

                    GetUserSpaceCoordinateValue(svg_info,-1,value,MagickFalse);

                  break;

                }

              if (LocaleCompare(keyword,"y2") == 0)

                {

                  svg_info->segment.y2=

                    GetUserSpaceCoordinateValue(svg_info,-1,value,MagickFalse);

                  break;

                }

              break;

            }

          default:

            break;

          }

      }

  if (svg_info->exception->severity >= ErrorException)

    goto svg_start_element_error;

  if (strchr((char *) name,':') != (char *) NULL)

    {

      /*

        Skip over namespace.

      */

      for ( ; *name != ':'; name++) ;

      name++;

    }

  switch (*name)

    {

    case 'C':

    case 'c':

      {

        if (LocaleCompare((char *) name,"circle") == 0)

          {

            if  ( svg_info->idLevelInsideDefs == svg_info->n )  /* emit a "push id" if warranted */

              MVGPrintf(svg_info->file,"push id '%s'\n",id);

            MVGPrintf(svg_info->file,"push graphic-context\n");

            break;

          }

        if (LocaleCompare((char *) name,"clipPath") == 0)

          {

            MVGPrintf(svg_info->file,"push clip-path '%s'\n",id);

            break;

          }

        break;

      }

    case 'D':

    case 'd':

      {

        if (LocaleCompare((char *) name,"defs") == 0)

          {

            svg_info->defsPushCount++;

            MVGPrintf(svg_info->file,"push defs\n");

            break;

          }

        break;

      }

    case 'E':

    case 'e':

      {

        if (LocaleCompare((char *) name,"ellipse") == 0)

          {

            if  ( svg_info->idLevelInsideDefs == svg_info->n )  /* emit a "push id" if warranted */

              MVGPrintf(svg_info->file,"push id '%s'\n",id);

            MVGPrintf(svg_info->file,"push graphic-context\n");

            break;

          }

        break;

      }

    case 'F':

    case 'f':

      {

        /*

          For now we are ignoring "foreignObject".  However, we do a push/pop

          graphic-context so that any settings (e.g., fill) are consumed and

          discarded.  Otherwise they might persist and "leak" into the graphic

          elements that follow.

        */

        if (LocaleCompare((char *) name,"foreignObject") == 0)

          {

            MVGPrintf(svg_info->file,"push graphic-context\n");

            break;

          }

        break;

      }

    case 'G':

    case 'g':