mirror of
https://github.com/darlinghq/darling-WebCore.git
synced 2024-11-23 20:39:40 +00:00
250 lines
8.2 KiB
C++
250 lines
8.2 KiB
C++
/*
|
|
* 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
|