blob: 21776b5fe3333d52b276a167bcd585e5c5d01e96 [file] [log] [blame]
/*
* Copyright (C) Research In Motion Limited 2010. All rights reserved.
* Copyright (C) 2013 Apple Inc. All rights reserved.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library 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
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public License
* along with this library; see the file COPYING.LIB. If not, write to
* the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
* Boston, MA 02110-1301, USA.
*/
#include "config.h"
#include "SVGPathStringSource.h"
#include "FloatPoint.h"
#include "SVGParserUtilities.h"
namespace WebCore {
SVGPathStringSource::SVGPathStringSource(const String& string)
: m_string(string)
, m_is8BitSource(string.is8Bit())
{
ASSERT(!string.isEmpty());
if (m_is8BitSource) {
m_current.m_character8 = string.characters8();
m_end.m_character8 = m_current.m_character8 + string.length();
} else {
m_current.m_character16 = string.characters16();
m_end.m_character16 = m_current.m_character16 + string.length();
}
}
bool SVGPathStringSource::hasMoreData() const
{
if (m_is8BitSource)
return m_current.m_character8 < m_end.m_character8;
return m_current.m_character16 < m_end.m_character16;
}
bool SVGPathStringSource::moveToNextToken()
{
if (m_is8BitSource)
return skipOptionalSVGSpaces(m_current.m_character8, m_end.m_character8);
return skipOptionalSVGSpaces(m_current.m_character16, m_end.m_character16);
}
template <typename CharacterType>
static bool parseSVGSegmentTypeHelper(const CharacterType*& current, SVGPathSegType& pathSegType)
{
switch (*(current++)) {
case 'Z':
case 'z':
pathSegType = PathSegClosePath;
break;
case 'M':
pathSegType = PathSegMoveToAbs;
break;
case 'm':
pathSegType = PathSegMoveToRel;
break;
case 'L':
pathSegType = PathSegLineToAbs;
break;
case 'l':
pathSegType = PathSegLineToRel;
break;
case 'C':
pathSegType = PathSegCurveToCubicAbs;
break;
case 'c':
pathSegType = PathSegCurveToCubicRel;
break;
case 'Q':
pathSegType = PathSegCurveToQuadraticAbs;
break;
case 'q':
pathSegType = PathSegCurveToQuadraticRel;
break;
case 'A':
pathSegType = PathSegArcAbs;
break;
case 'a':
pathSegType = PathSegArcRel;
break;
case 'H':
pathSegType = PathSegLineToHorizontalAbs;
break;
case 'h':
pathSegType = PathSegLineToHorizontalRel;
break;
case 'V':
pathSegType = PathSegLineToVerticalAbs;
break;
case 'v':
pathSegType = PathSegLineToVerticalRel;
break;
case 'S':
pathSegType = PathSegCurveToCubicSmoothAbs;
break;
case 's':
pathSegType = PathSegCurveToCubicSmoothRel;
break;
case 'T':
pathSegType = PathSegCurveToQuadraticSmoothAbs;
break;
case 't':
pathSegType = PathSegCurveToQuadraticSmoothRel;
break;
default:
pathSegType = PathSegUnknown;
}
return true;
}
bool SVGPathStringSource::parseSVGSegmentType(SVGPathSegType& pathSegType)
{
if (m_is8BitSource)
return parseSVGSegmentTypeHelper(m_current.m_character8, pathSegType);
return parseSVGSegmentTypeHelper(m_current.m_character16, pathSegType);
}
template <typename CharacterType>
static bool nextCommandHelper(const CharacterType*& current, SVGPathSegType previousCommand, SVGPathSegType& nextCommand)
{
// Check for remaining coordinates in the current command.
if ((*current == '+' || *current == '-' || *current == '.' || isASCIIDigit(*current))
&& previousCommand != PathSegClosePath) {
if (previousCommand == PathSegMoveToAbs) {
nextCommand = PathSegLineToAbs;
return true;
}
if (previousCommand == PathSegMoveToRel) {
nextCommand = PathSegLineToRel;
return true;
}
nextCommand = previousCommand;
return true;
}
return false;
}
SVGPathSegType SVGPathStringSource::nextCommand(SVGPathSegType previousCommand)
{
SVGPathSegType nextCommand;
if (m_is8BitSource) {
if (nextCommandHelper(m_current.m_character8, previousCommand, nextCommand))
return nextCommand;
} else {
if (nextCommandHelper(m_current.m_character16, previousCommand, nextCommand))
return nextCommand;
}
parseSVGSegmentType(nextCommand);
return nextCommand;
}
bool SVGPathStringSource::parseMoveToSegment(FloatPoint& targetPoint)
{
if (m_is8BitSource)
return parseFloatPoint(m_current.m_character8, m_end.m_character8, targetPoint);
return parseFloatPoint(m_current.m_character16, m_end.m_character16, targetPoint);
}
bool SVGPathStringSource::parseLineToSegment(FloatPoint& targetPoint)
{
if (m_is8BitSource)
return parseFloatPoint(m_current.m_character8, m_end.m_character8, targetPoint);
return parseFloatPoint(m_current.m_character16, m_end.m_character16, targetPoint);
}
bool SVGPathStringSource::parseLineToHorizontalSegment(float& x)
{
if (m_is8BitSource)
return parseNumber(m_current.m_character8, m_end.m_character8, x);
return parseNumber(m_current.m_character16, m_end.m_character16, x);
}
bool SVGPathStringSource::parseLineToVerticalSegment(float& y)
{
if (m_is8BitSource)
return parseNumber(m_current.m_character8, m_end.m_character8, y);
return parseNumber(m_current.m_character16, m_end.m_character16, y);
}
bool SVGPathStringSource::parseCurveToCubicSegment(FloatPoint& point1, FloatPoint& point2, FloatPoint& targetPoint)
{
if (m_is8BitSource)
return parseFloatPoint3(m_current.m_character8, m_end.m_character8, point1, point2, targetPoint);
return parseFloatPoint3(m_current.m_character16, m_end.m_character16, point1, point2, targetPoint);
}
bool SVGPathStringSource::parseCurveToCubicSmoothSegment(FloatPoint& point1, FloatPoint& targetPoint)
{
if (m_is8BitSource)
return parseFloatPoint2(m_current.m_character8, m_end.m_character8, point1, targetPoint);
return parseFloatPoint2(m_current.m_character16, m_end.m_character16, point1, targetPoint);
}
bool SVGPathStringSource::parseCurveToQuadraticSegment(FloatPoint& point2, FloatPoint& targetPoint)
{
if (m_is8BitSource)
return parseFloatPoint2(m_current.m_character8, m_end.m_character8, point2, targetPoint);
return parseFloatPoint2(m_current.m_character16, m_end.m_character16, point2, targetPoint);
}
bool SVGPathStringSource::parseCurveToQuadraticSmoothSegment(FloatPoint& targetPoint)
{
if (m_is8BitSource)
return parseFloatPoint(m_current.m_character8, m_end.m_character8, targetPoint);
return parseFloatPoint(m_current.m_character16, m_end.m_character16, targetPoint);
}
template <typename CharacterType>
static bool parseArcToSegmentHelper(const CharacterType*& current, const CharacterType* end, float& rx, float& ry, float& angle, bool& largeArc, bool& sweep, FloatPoint& targetPoint)
{
float toX;
float toY;
if (!parseNumber(current, end, rx)
|| !parseNumber(current, end, ry)
|| !parseNumber(current, end, angle)
|| !parseArcFlag(current, end, largeArc)
|| !parseArcFlag(current, end, sweep)
|| !parseNumber(current, end, toX)
|| !parseNumber(current, end, toY))
return false;
targetPoint = FloatPoint(toX, toY);
return true;
}
bool SVGPathStringSource::parseArcToSegment(float& rx, float& ry, float& angle, bool& largeArc, bool& sweep, FloatPoint& targetPoint)
{
if (m_is8BitSource)
return parseArcToSegmentHelper(m_current.m_character8, m_end.m_character8, rx, ry, angle, largeArc, sweep, targetPoint);
return parseArcToSegmentHelper(m_current.m_character16, m_end.m_character16, rx, ry, angle, largeArc, sweep, targetPoint);
}
} // namespace WebKit