bool SVGPathParserFactory::buildPathFromString(const String& d, Path& result)
{
if (d.isEmpty())
return false;
SVGPathBuilder* builder = globalSVGPathBuilder(result);
OwnPtr<SVGPathStringSource> source = SVGPathStringSource::create(d);
SVGPathParser* parser = globalSVGPathParser(source.get(), builder);
bool ok = parser->parsePathDataFromSource(NormalizedParsing);
parser->cleanup();
return ok;
}
bool buildPathFromString(const String& d, Path& result)
{
if (d.isEmpty())
return true;
SVGPathBuilder* builder = globalSVGPathBuilder(result);
auto source = std::make_unique<SVGPathStringSource>(d);
SVGPathParser* parser = globalSVGPathParser(source.get(), builder);
bool ok = parser->parsePathDataFromSource(NormalizedParsing);
parser->cleanup();
return ok;
}
bool SVGPathParserFactory::buildSVGPathByteStreamFromString(const String& d, OwnPtr<SVGPathByteStream>& result, PathParsingMode parsingMode)
{
result = SVGPathByteStream::create();
if (d.isEmpty())
return false;
SVGPathByteStreamBuilder* builder = globalSVGPathByteStreamBuilder(result.get());
OwnPtr<SVGPathStringSource> source = SVGPathStringSource::create(d);
SVGPathParser* parser = globalSVGPathParser(source.get(), builder);
bool ok = parser->parsePathDataFromSource(parsingMode);
parser->cleanup();
return ok;
}
bool SVGPathParserFactory::buildSVGPathSegListFromByteStream(SVGPathByteStream* stream, SVGPathElement* element, SVGPathSegList& result, PathParsingMode parsingMode)
{
ASSERT(stream);
if (stream->isEmpty())
return false;
SVGPathSegListBuilder* builder = globalSVGPathSegListBuilder(element, parsingMode == NormalizedParsing ? PathSegNormalizedRole : PathSegUnalteredRole, result);
OwnPtr<SVGPathByteStreamSource> source = SVGPathByteStreamSource::create(stream);
SVGPathParser* parser = globalSVGPathParser(source.get(), builder);
bool ok = parser->parsePathDataFromSource(parsingMode);
parser->cleanup();
return ok;
}
bool SVGPathParserFactory::buildPathFromSVGPathSegList(SVGPathSegList* pathSegList, Path& result)
{
ASSERT(pathSegList);
if (!pathSegList->numberOfItems())
return false;
SVGPathBuilder* builder = globalSVGPathBuilder(result);
OwnPtr<SVGPathSegListSource> source = SVGPathSegListSource::create(pathSegList);
SVGPathParser* parser = globalSVGPathParser(source.get(), builder);
bool ok = parser->parsePathDataFromSource(NormalizedParsing);
parser->cleanup();
return ok;
}
bool buildPathFromByteStream(const SVGPathByteStream* stream, Path& result)
{
ASSERT(stream);
if (stream->isEmpty())
return true;
SVGPathBuilder* builder = globalSVGPathBuilder(result);
SVGPathByteStreamSource source(stream);
SVGPathParser* parser = globalSVGPathParser(&source, builder);
bool ok = parser->parsePathDataFromSource(NormalizedParsing);
parser->cleanup();
return ok;
}
bool buildPathFromByteStream(SVGPathByteStream* stream, Path& result)
{
ASSERT(stream);
if (stream->isEmpty())
return true;
SVGPathBuilder* builder = globalSVGPathBuilder(result);
auto source = std::make_unique<SVGPathByteStreamSource>(stream);
SVGPathParser* parser = globalSVGPathParser(source.get(), builder);
bool ok = parser->parsePathDataFromSource(NormalizedParsing);
parser->cleanup();
return ok;
}
bool SVGPathParserFactory::buildSVGPathSegListFromString(const String& d, SVGPathSegList* result, PathParsingMode parsingMode)
{
ASSERT(result);
if (d.isEmpty())
return false;
SVGPathSegListBuilder* builder = globalSVGPathSegListBuilder(result);
OwnPtr<SVGPathStringSource> source = SVGPathStringSource::create(d);
SVGPathParser* parser = globalSVGPathParser(source.get(), builder);
bool ok = parser->parsePathDataFromSource(parsingMode);
parser->cleanup();
return ok;
}
bool SVGPathParserFactory::buildPathFromByteStream(SVGPathByteStream* stream, Path& result)
{
ASSERT(stream);
if (stream->isEmpty())
return false;
SVGPathBuilder* builder = globalSVGPathBuilder(result);
OwnPtr<SVGPathByteStreamSource> source = SVGPathByteStreamSource::create(stream);
SVGPathParser* parser = globalSVGPathParser(source.get(), builder);
bool ok = parser->parsePathDataFromSource(NormalizedParsing);
parser->cleanup();
return ok;
}
bool buildSVGPathSegListFromByteStream(SVGPathByteStream* stream, SVGPathElement* element, SVGPathSegList& result, PathParsingMode parsingMode)
{
ASSERT(stream);
if (stream->isEmpty())
return true;
SVGPathSegListBuilder* builder = globalSVGPathSegListBuilder(element, parsingMode == NormalizedParsing ? PathSegNormalizedRole : PathSegUnalteredRole, result);
auto source = std::make_unique<SVGPathByteStreamSource>(stream);
SVGPathParser* parser = globalSVGPathParser(source.get(), builder);
bool ok = parser->parsePathDataFromSource(parsingMode);
parser->cleanup();
return ok;
}
bool buildStringFromByteStream(SVGPathByteStream* stream, String& result, PathParsingMode parsingMode)
{
ASSERT(stream);
if (stream->isEmpty())
return true;
SVGPathStringBuilder* builder = globalSVGPathStringBuilder();
auto source = std::make_unique<SVGPathByteStreamSource>(stream);
SVGPathParser* parser = globalSVGPathParser(source.get(), builder);
bool ok = parser->parsePathDataFromSource(parsingMode);
result = builder->result();
parser->cleanup();
return ok;
}
bool SVGPathParserFactory::buildStringFromByteStream(SVGPathByteStream* stream, String& result, PathParsingMode parsingMode)
{
ASSERT(stream);
if (stream->isEmpty())
return false;
SVGPathStringBuilder* builder = globalSVGPathStringBuilder();
OwnPtr<SVGPathByteStreamSource> source = SVGPathByteStreamSource::create(stream);
SVGPathParser* parser = globalSVGPathParser(source.get(), builder);
bool ok = parser->parsePathDataFromSource(parsingMode);
result = builder->result();
parser->cleanup();
return ok;
}
bool buildStringFromByteStream(const SVGPathByteStream* stream, String& result, PathParsingMode parsingMode)
{
ASSERT(stream);
if (stream->isEmpty())
return true;
SVGPathStringBuilder* builder = globalSVGPathStringBuilder();
SVGPathByteStreamSource source(stream);
SVGPathParser* parser = globalSVGPathParser(&source, builder);
bool ok = parser->parsePathDataFromSource(parsingMode);
result = builder->result();
parser->cleanup();
return ok;
}
bool buildStringFromSVGPathSegList(const SVGPathSegList& list, String& result, PathParsingMode parsingMode)
{
result = String();
if (list.isEmpty())
return true;
SVGPathStringBuilder* builder = globalSVGPathStringBuilder();
auto source = std::make_unique<SVGPathSegListSource>(list);
SVGPathParser* parser = globalSVGPathParser(source.get(), builder);
bool ok = parser->parsePathDataFromSource(parsingMode);
result = builder->result();
parser->cleanup();
return ok;
}
bool buildSVGPathByteStreamFromString(const String& d, SVGPathByteStream* result, PathParsingMode parsingMode)
{
ASSERT(result);
result->clear();
if (d.isEmpty())
return true;
SVGPathByteStreamBuilder* builder = globalSVGPathByteStreamBuilder(result);
auto source = std::make_unique<SVGPathStringSource>(d);
SVGPathParser* parser = globalSVGPathParser(source.get(), builder);
bool ok = parser->parsePathDataFromSource(parsingMode);
parser->cleanup();
return ok;
}
bool buildStringFromSVGPathSegList(const SVGPathSegList& list, String& result, PathParsingMode parsingMode)
{
result = String();
if (list.isEmpty())
return false;
SVGPathStringBuilder* builder = globalSVGPathStringBuilder();
OwnPtr<SVGPathSegListSource> source = SVGPathSegListSource::create(list);
SVGPathParser* parser = globalSVGPathParser(source.get(), builder);
bool ok = parser->parsePathDataFromSource(parsingMode);
result = builder->result();
parser->cleanup();
return ok;
}
bool buildSVGPathByteStreamFromSVGPathSegList(const SVGPathSegList& list, SVGPathByteStream* result, PathParsingMode parsingMode)
{
ASSERT(result);
result->clear();
if (list.isEmpty())
return false;
SVGPathByteStreamBuilder* builder = globalSVGPathByteStreamBuilder(result);
OwnPtr<SVGPathSegListSource> source = SVGPathSegListSource::create(list);
SVGPathParser* parser = globalSVGPathParser(source.get(), builder);
bool ok = parser->parsePathDataFromSource(parsingMode);
parser->cleanup();
return ok;
}
bool SVGPathParserFactory::buildStringFromSVGPathSegList(SVGPathSegList* pathSegList, String& result, PathParsingMode parsingMode)
{
ASSERT(pathSegList);
if (!pathSegList->numberOfItems())
return false;
SVGPathStringBuilder* builder = globalSVGPathStringBuilder();
OwnPtr<SVGPathSegListSource> source = SVGPathSegListSource::create(pathSegList);
SVGPathParser* parser = globalSVGPathParser(source.get(), builder);
bool ok = parser->parsePathDataFromSource(parsingMode);
result = builder->result();
parser->cleanup();
return ok;
}
bool getTotalLengthOfSVGPathByteStream(const SVGPathByteStream* stream, float& totalLength)
{
ASSERT(stream);
if (stream->isEmpty())
return false;
PathTraversalState traversalState(PathTraversalState::TraversalTotalLength);
SVGPathTraversalStateBuilder* builder = globalSVGPathTraversalStateBuilder(traversalState, 0);
SVGPathByteStreamSource source(stream);
SVGPathParser* parser = globalSVGPathParser(&source, builder);
bool ok = parser->parsePathDataFromSource(NormalizedParsing);
totalLength = builder->totalLength();
parser->cleanup();
return ok;
}
bool SVGPathParserFactory::getSVGPathSegAtLengthFromSVGPathSegList(SVGPathSegList* pathSegList, float length, unsigned long& pathSeg)
{
ASSERT(pathSegList);
if (!pathSegList->numberOfItems())
return false;
PathTraversalState traversalState(PathTraversalState::TraversalSegmentAtLength);
SVGPathTraversalStateBuilder* builder = globalSVGPathTraversalStateBuilder(traversalState, length);
OwnPtr<SVGPathSegListSource> source = SVGPathSegListSource::create(pathSegList);
SVGPathParser* parser = globalSVGPathParser(source.get(), builder);
bool ok = parser->parsePathDataFromSource(NormalizedParsing);
pathSeg = builder->pathSegmentIndex();
parser->cleanup();
return ok;
}
bool SVGPathParserFactory::getTotalLengthOfSVGPathByteStream(SVGPathByteStream* stream, float& totalLength)
{
ASSERT(stream);
if (stream->isEmpty())
return false;
PathTraversalState traversalState(PathTraversalState::TraversalTotalLength);
SVGPathTraversalStateBuilder* builder = globalSVGPathTraversalStateBuilder(traversalState, 0);
OwnPtr<SVGPathByteStreamSource> source = SVGPathByteStreamSource::create(stream);
SVGPathParser* parser = globalSVGPathParser(source.get(), builder);
bool ok = parser->parsePathDataFromSource(NormalizedParsing);
totalLength = builder->totalLength();
parser->cleanup();
return ok;
}
bool getPointAtLengthOfSVGPathByteStream(SVGPathByteStream* stream, float length, FloatPoint& point)
{
ASSERT(stream);
if (stream->isEmpty())
return false;
PathTraversalState traversalState(PathTraversalState::TraversalPointAtLength);
SVGPathTraversalStateBuilder* builder = globalSVGPathTraversalStateBuilder(traversalState, length);
OwnPtr<SVGPathByteStreamSource> source = SVGPathByteStreamSource::create(stream);
SVGPathParser* parser = globalSVGPathParser(source.get(), builder);
bool ok = parser->parsePathDataFromSource(NormalizedParsing);
point = builder->currentPoint();
parser->cleanup();
return ok;
}
bool getPointAtLengthOfSVGPathByteStream(SVGPathByteStream* stream, float length, SVGPoint& point)
{
ASSERT(stream);
if (stream->isEmpty())
return false;
PathTraversalState traversalState(PathTraversalState::Action::VectorAtLength);
SVGPathTraversalStateBuilder* builder = globalSVGPathTraversalStateBuilder(traversalState, length);
auto source = std::make_unique<SVGPathByteStreamSource>(stream);
SVGPathParser* parser = globalSVGPathParser(source.get(), builder);
bool ok = parser->parsePathDataFromSource(NormalizedParsing);
point = builder->currentPoint();
parser->cleanup();
return ok;
}
bool SVGPathParserFactory::getSVGPathSegAtLengthFromSVGPathByteStream(SVGPathByteStream* stream, float length, unsigned& pathSeg)
{
ASSERT(stream);
if (stream->isEmpty())
return false;
PathTraversalState traversalState(PathTraversalState::TraversalSegmentAtLength);
SVGPathTraversalStateBuilder* builder = globalSVGPathTraversalStateBuilder(traversalState, length);
OwnPtr<SVGPathByteStreamSource> source = SVGPathByteStreamSource::create(stream);
SVGPathParser* parser = globalSVGPathParser(source.get(), builder);
bool ok = parser->parsePathDataFromSource(NormalizedParsing);
pathSeg = builder->pathSegmentIndex();
parser->cleanup();
return ok;
}
bool getTotalLengthOfSVGPathByteStream(SVGPathByteStream* stream, float& totalLength)
{
ASSERT(stream);
if (stream->isEmpty())
return false;
PathTraversalState traversalState(PathTraversalState::Action::TotalLength);
SVGPathTraversalStateBuilder* builder = globalSVGPathTraversalStateBuilder(traversalState, 0);
auto source = std::make_unique<SVGPathByteStreamSource>(stream);
SVGPathParser* parser = globalSVGPathParser(source.get(), builder);
bool ok = parser->parsePathDataFromSource(NormalizedParsing);
totalLength = builder->totalLength();
parser->cleanup();
return ok;
}
bool getSVGPathSegAtLengthFromSVGPathByteStream(SVGPathByteStream* stream, float length, unsigned& pathSeg)
{
ASSERT(stream);
if (stream->isEmpty())
return false;
PathTraversalState traversalState(PathTraversalState::Action::SegmentAtLength);
SVGPathTraversalStateBuilder* builder = globalSVGPathTraversalStateBuilder(traversalState, length);
auto source = std::make_unique<SVGPathByteStreamSource>(stream);
SVGPathParser* parser = globalSVGPathParser(source.get(), builder);
bool ok = parser->parsePathDataFromSource(NormalizedParsing);
pathSeg = builder->pathSegmentIndex();
parser->cleanup();
return ok;
}
bool buildSVGPathByteStreamFromString(const String& d, SVGPathByteStream* result, PathParsingMode parsingMode)
{
ASSERT(result);
result->clear();
if (d.isEmpty())
return false;
// The string length is typically a minor overestimate of eventual byte stream size, so it avoids us a lot of reallocs.
result->reserveInitialCapacity(d.length());
SVGPathByteStreamBuilder* builder = globalSVGPathByteStreamBuilder(result);
OwnPtr<SVGPathStringSource> source = SVGPathStringSource::create(d);
SVGPathParser* parser = globalSVGPathParser(source.get(), builder);
bool ok = parser->parsePathDataFromSource(parsingMode);
parser->cleanup();
result->shrinkToFit();
return ok;
}
bool appendSVGPathByteStreamFromSVGPathSeg(PassRefPtr<SVGPathSeg> pathSeg, SVGPathByteStream* result, PathParsingMode parsingMode)
{
ASSERT(result);
// FIXME: https://bugs.webkit.org/show_bug.cgi?id=15412 - Implement normalized path segment lists!
ASSERT(parsingMode == UnalteredParsing);
SVGPathSegList appendedItemList(PathSegUnalteredRole);
appendedItemList.append(pathSeg);
auto appendedByteStream = std::make_unique<SVGPathByteStream>();
SVGPathByteStreamBuilder* builder = globalSVGPathByteStreamBuilder(appendedByteStream.get());
auto source = std::make_unique<SVGPathSegListSource>(appendedItemList);
SVGPathParser* parser = globalSVGPathParser(source.get(), builder);
bool ok = parser->parsePathDataFromSource(parsingMode, false);
parser->cleanup();
if (ok)
result->append(appendedByteStream.get());
return ok;
}
bool SVGPathParserFactory::buildPathFromString(const CStdString& d, KdPath& result) {
if (d.IsEmpty())
return false;
SVGPathBuilder* builder = new SVGPathBuilder();
builder->setCurrentPath(&result);
//OwnPtr<SVGPathStringSource> source = SVGPathStringSource::create(d);
SVGPathStringSource* source = new SVGPathStringSource(d);
//SVGPathParser* parser = globalSVGPathParser(source.get(), builder);
SVGPathParser* parser = new SVGPathParser();
parser->setCurrentSource(source);
parser->setCurrentConsumer(builder);
bool ok = parser->parsePathDataFromSource(NormalizedParsing);
parser->cleanup();
delete parser;
delete source;
delete builder;
return ok;
}
