diff --git a/examples/graphics/data/svg/mozilla2.svg b/examples/graphics/data/svg/mozilla2.svg new file mode 100644 index 000000000..8f537cb8c --- /dev/null +++ b/examples/graphics/data/svg/mozilla2.svg @@ -0,0 +1,60 @@ + + + + + + + Large arc flag + + Sweep flag + + 0 + 1 + 0 + 1 + + + + + + + + + + + + + \ No newline at end of file diff --git a/examples/graphics/data/svg/pulpitrock.svg b/examples/graphics/data/svg/pulpitrock.svg new file mode 100644 index 000000000..4a3102021 --- /dev/null +++ b/examples/graphics/data/svg/pulpitrock.svg @@ -0,0 +1,6 @@ + + + + Pulpit Rock, Norway + Sorry, your browser does not support inline SVG. + diff --git a/examples/graphics/source/examples/Svg.h b/examples/graphics/source/examples/Svg.h index 2f03c93e4..bef85201f 100644 --- a/examples/graphics/source/examples/Svg.h +++ b/examples/graphics/source/examples/Svg.h @@ -27,18 +27,17 @@ class SvgDemo : public yup::Component SvgDemo() { updateListOfSvgFiles(); + loadDemoFont(); parseSvgFile (currentSvgFileIndex); } - void resized() override - { - //drawable.setBounds (getLocalBounds()); - } - void mouseDown (const yup::MouseEvent& event) override { - ++currentSvgFileIndex; + if (event.isLeftButtonDown()) + ++currentSvgFileIndex; + else if (event.isRightButtonDown()) + --currentSvgFileIndex; parseSvgFile (currentSvgFileIndex); } @@ -59,12 +58,17 @@ class SvgDemo : public yup::Component .getParentDirectory() .getParentDirectory(); + dataDirectory = riveBasePath.getChildFile ("data"); + auto files = riveBasePath.getChildFile ("data/svg").findChildFiles (yup::File::findFiles, false, "*.svg"); if (files.isEmpty()) return; for (const auto& svgFile : files) + { + //if (svgFile.getFileName() == "mozilla2.svg") svgFiles.add (svgFile); + } } void parseSvgFile (int index) @@ -83,12 +87,97 @@ class SvgDemo : public yup::Component YUP_DBG ("Showing " << svgFiles[currentSvgFileIndex].getFullPathName()); drawable.clear(); - drawable.parseSVG (svgFiles[currentSvgFileIndex]); + drawable.parseSVG (svgFiles[currentSvgFileIndex], createParseOptions (svgFiles[currentSvgFileIndex])); repaint(); } + void loadDemoFont() + { + yup::Font font; + if (font.loadFromFile (dataDirectory.getChildFile ("RobotoFlex-VariableFont.ttf")).wasOk()) + demoFont = std::move (font); + } + + std::optional fetchHttpImage (const yup::String& href) + { + if (! href.startsWithIgnoreCase ("http:") && ! href.startsWithIgnoreCase ("https:")) + return std::nullopt; + + if (httpImageCache.contains (href)) + return httpImageCache[href]; + + yup::MemoryBlock imageData; + int statusCode = 0; + + auto streamOptions = yup::URL::InputStreamOptions (yup::URL::ParameterHandling::inAddress) + .withConnectionTimeoutMs (5000) + .withNumRedirectsToFollow (5) + .withStatusCode (&statusCode) + .withExtraHeaders ("User-Agent: YUP SVG Demo\r\nAccept: image/*\r\n"); + + auto stream = yup::URL (href).createInputStream (streamOptions); + if (stream == nullptr) + { + YUP_DBG ("Unable to fetch SVG image href: " << href); + return std::nullopt; + } + + stream->readIntoMemoryBlock (imageData); + + if ((statusCode != 0 && (statusCode < 200 || statusCode >= 300)) || imageData.isEmpty()) + { + YUP_DBG ("Unable to fetch SVG image href: " << href << " status: " << statusCode); + return std::nullopt; + } + + auto imageResult = yup::Image::loadFromData (imageData.asBytes()); + if (imageResult.failed()) + { + YUP_DBG ("Unable to decode SVG image href: " << href << " error: " << imageResult.getErrorMessage()); + return std::nullopt; + } + + auto image = imageResult.getValue(); + httpImageCache.set (href, image); + return image; + } + + yup::Drawable::ParseOptions createParseOptions (const yup::File& svgFile) + { + yup::Drawable::ParseOptions options; + options.baseDirectory = svgFile.getParentDirectory(); + options.imageResolver = [this] (yup::StringRef href, const yup::File&) -> std::optional + { + return fetchHttpImage (yup::String (href.text)); + }; + + options.fontResolver = [this] (yup::StringRef, float fontSize, int weight, bool italic) -> std::optional + { + if (demoFont) + { + auto font = *demoFont; + font.setAxisValue ("wght", static_cast (weight)); + if (italic) + font.setAxisValue ("slnt", -10.0f); + else + font.setAxisValue ("slnt", 0.0f); + return font.withHeight (fontSize); + } + + if (auto theme = yup::ApplicationTheme::getGlobalTheme()) + return theme->getDefaultFont().withHeight (fontSize); + + return std::nullopt; + }; + + return options; + } + yup::Drawable drawable; yup::Array svgFiles; + yup::File dataDirectory; + std::optional demoFont; + yup::HashMap httpImageCache; int currentSvgFileIndex = 0; }; diff --git a/modules/yup_audio_basics/sources/yup_BufferingAudioSource.cpp b/modules/yup_audio_basics/sources/yup_BufferingAudioSource.cpp index 64b494993..cdeb97d57 100644 --- a/modules/yup_audio_basics/sources/yup_BufferingAudioSource.cpp +++ b/modules/yup_audio_basics/sources/yup_BufferingAudioSource.cpp @@ -107,16 +107,12 @@ void BufferingAudioSource::releaseResources() buffer.setSize (numberOfChannels, 0); - // MSVC2017 seems to need this if statement to not generate a warning during linking. - // As source is set in the constructor, there is no way that source could - // ever equal this, but it seems to make MSVC2017 happy. - if (source != this) - source->releaseResources(); + source->releaseResources(); } void BufferingAudioSource::getNextAudioBlock (const AudioSourceChannelInfo& info) { - const auto bufferRange = getValidBufferRange (info.numSamples); + auto [playPos, bufferRange] = getValidBufferRangeAndAdvance (info.numSamples); if (bufferRange.isEmpty()) { @@ -143,8 +139,8 @@ void BufferingAudioSource::getNextAudioBlock (const AudioSourceChannelInfo& info { jassert (buffer.getNumSamples() > 0); - const auto startBufferIndex = (int) ((validStart + nextPlayPos) % buffer.getNumSamples()); - const auto endBufferIndex = (int) ((validEnd + nextPlayPos) % buffer.getNumSamples()); + const auto startBufferIndex = (int) ((validStart + playPos) % buffer.getNumSamples()); + const auto endBufferIndex = (int) ((validEnd + playPos) % buffer.getNumSamples()); if (startBufferIndex < endBufferIndex) { @@ -155,13 +151,10 @@ void BufferingAudioSource::getNextAudioBlock (const AudioSourceChannelInfo& info const auto initialSize = buffer.getNumSamples() - startBufferIndex; info.buffer->copyFrom (chan, info.startSample + validStart, buffer, chan, startBufferIndex, initialSize); - info.buffer->copyFrom (chan, info.startSample + validStart + initialSize, buffer, chan, 0, (validEnd - validStart) - initialSize); } } } - - nextPlayPos += info.numSamples; } bool BufferingAudioSource::waitForNextAudioBlockReady (const AudioSourceChannelInfo& info, uint32 timeout) @@ -235,6 +228,18 @@ Range BufferingAudioSource::getValidBufferRange (int numSamples) const (int) (jlimit (bufferValidStart, bufferValidEnd, pos + numSamples) - pos) }; } +std::tuple> BufferingAudioSource::getValidBufferRangeAndAdvance (int numSamples) +{ + const ScopedLock sl (bufferRangeLock); + + const auto pos = nextPlayPos.load(); + + nextPlayPos = pos + numSamples; + + return std::make_tuple ( + pos, Range { (int) (jlimit (bufferValidStart, bufferValidEnd, pos) - pos), (int) (jlimit (bufferValidStart, bufferValidEnd, pos + numSamples) - pos) }); +} + bool BufferingAudioSource::readNextBufferChunk() { int64 newBVS, newBVE, sectionToReadStart, sectionToReadEnd; diff --git a/modules/yup_audio_basics/sources/yup_BufferingAudioSource.h b/modules/yup_audio_basics/sources/yup_BufferingAudioSource.h index 6c839de13..8589358a8 100644 --- a/modules/yup_audio_basics/sources/yup_BufferingAudioSource.h +++ b/modules/yup_audio_basics/sources/yup_BufferingAudioSource.h @@ -117,6 +117,7 @@ class YUP_API BufferingAudioSource : public PositionableAudioSource private: //============================================================================== Range getValidBufferRange (int numSamples) const; + std::tuple> getValidBufferRangeAndAdvance (int numSamples); bool readNextBufferChunk(); void readBufferSection (int64 start, int length, int bufferOffset); int useTimeSlice() override; diff --git a/modules/yup_core/containers/yup_HashMap.h b/modules/yup_core/containers/yup_HashMap.h index 85b93ac80..8cef8c552 100644 --- a/modules/yup_core/containers/yup_HashMap.h +++ b/modules/yup_core/containers/yup_HashMap.h @@ -134,6 +134,25 @@ class HashMap public: //============================================================================== + /** Creates an empty hash-map. + */ + HashMap() + : HashMap (defaultHashTableSize, HashFunctionType()) + { + } + + /** Creates an empty hash-map. + + @param numberOfSlots Specifies the number of hash entries the map will use. This will be + the "upperLimit" parameter that is passed to your generateHash() + function. The number of hash slots will grow automatically if necessary, + or it can be remapped manually using remapTable(). + */ + explicit HashMap (int numberOfSlots) + : HashMap (numberOfSlots, HashFunctionType()) + { + } + /** Creates an empty hash-map. @param numberOfSlots Specifies the number of hash entries the map will use. This will be @@ -141,11 +160,9 @@ class HashMap function. The number of hash slots will grow automatically if necessary, or it can be remapped manually using remapTable(). @param hashFunction An instance of HashFunctionType, which will be copied and - stored to use with the HashMap. This parameter can be omitted - if HashFunctionType has a default constructor. + stored to use with the HashMap. */ - explicit HashMap (int numberOfSlots = defaultHashTableSize, - HashFunctionType hashFunction = HashFunctionType()) + HashMap (int numberOfSlots, HashFunctionType hashFunction) : hashFunctionToUse (hashFunction) { hashSlots.insertMultiple (0, nullptr, numberOfSlots); diff --git a/modules/yup_core/files/yup_File.h b/modules/yup_core/files/yup_File.h index 775be9911..c102e04c8 100644 --- a/modules/yup_core/files/yup_File.h +++ b/modules/yup_core/files/yup_File.h @@ -81,7 +81,7 @@ class YUP_API File final On the Mac/Linux, the path can include "~" notation for referring to user home directories. */ - File (const String& absolutePath); + explicit File (const String& absolutePath); /** Creates a copy of another file object. */ File (const File&); diff --git a/modules/yup_core/files/yup_FileSearchPath.cpp b/modules/yup_core/files/yup_FileSearchPath.cpp index 9426c2be8..0b09c7c3b 100644 --- a/modules/yup_core/files/yup_FileSearchPath.cpp +++ b/modules/yup_core/files/yup_FileSearchPath.cpp @@ -138,7 +138,7 @@ void FileSearchPath::removeRedundantPaths() { const auto checkedIsChildOf = [&] (const auto& a, const auto& b) { - return File::isAbsolutePath (a) && File::isAbsolutePath (b) && File (a).isAChildOf (b); + return File::isAbsolutePath (a) && File::isAbsolutePath (b) && File (a).isAChildOf (File (b)); }; const auto fContainsDirectory = [&] (const auto& f) diff --git a/modules/yup_core/native/yup_Files_android.cpp b/modules/yup_core/native/yup_Files_android.cpp index 35e5b35ae..d63ec2e88 100644 --- a/modules/yup_core/native/yup_Files_android.cpp +++ b/modules/yup_core/native/yup_Files_android.cpp @@ -251,12 +251,12 @@ File AndroidContentUriResolver::getLocalFileFromContentUri (const URL& url) if (type == "image") type = "images"; - return getCursorDataColumn (URL ("content://media/external/" + type + "/media"), - "_id=?", - StringArray { mediaId }); + return File (getCursorDataColumn (URL ("content://media/external/" + type + "/media"), + "_id=?", + StringArray { mediaId })); } - return getCursorDataColumn (url); + return File (getCursorDataColumn (url)); } String AndroidContentUriResolver::getFileNameFromContentUri (const URL& url) @@ -745,7 +745,7 @@ static File getAppDataDir (bool dataDir) LocalRef applicationInfo (env->CallObjectMethod (getAppContext().get(), AndroidContext.getApplicationInfo)); LocalRef jString (env->GetObjectField (applicationInfo.get(), dataDir ? AndroidApplicationInfo.dataDir : AndroidApplicationInfo.publicSourceDir)); - return { yupString ((jstring) jString.get()) }; + return File (yupString ((jstring) jString.get())); } File File::getSpecialLocation (const SpecialLocationType type) diff --git a/modules/yup_core/native/yup_Files_apple.mm b/modules/yup_core/native/yup_Files_apple.mm index 613f83ebc..d5abe7fc5 100644 --- a/modules/yup_core/native/yup_Files_apple.mm +++ b/modules/yup_core/native/yup_Files_apple.mm @@ -163,11 +163,11 @@ bool openDocument(const String& fileName, const String& parameters, const Array< StringArray params; params.addTokens(parameters, true); - NSMutableArray* paramArray = [NSMutableArray array]; + NSMutableArray* paramArray = [NSMutableArray array]; for (int i = 0; i < params.size(); ++i) [paramArray addObject:yupStringToNS(params[i])]; - NSMutableDictionary* envDict = [NSMutableDictionary dictionary]; + NSMutableDictionary* envDict = [NSMutableDictionary dictionary]; if (environment) { for (int i = 0; i < environment->size(); ++i) @@ -202,7 +202,7 @@ bool openDocument(const String& fileName, const String& parameters, const Array< YUP_BEGIN_IGNORE_DEPRECATION_WARNINGS - NSMutableDictionary* dict = [NSMutableDictionary dictionary]; + NSMutableDictionary* dict = [NSMutableDictionary dictionary]; if (params.size()) { @@ -306,6 +306,7 @@ bool openDocument(const String& fileName, const String& parameters, const Array< case userDocumentsDirectory: resultPath = MacFileHelpers::getIOSSystemLocation(NSDocumentDirectory); break; + case userDesktopDirectory: resultPath = MacFileHelpers::getIOSSystemLocation(NSDesktopDirectory); break; @@ -315,13 +316,14 @@ bool openDocument(const String& fileName, const String& parameters, const Array< File tmp(MacFileHelpers::getIOSSystemLocation(NSCachesDirectory)); tmp = tmp.getChildFile(yup_getExecutableFile().getFileNameWithoutExtension()); tmp.createDirectory(); - return tmp.getFullPathName(); + return File(tmp.getFullPathName()); } #else case userDocumentsDirectory: resultPath = "~/Documents"; break; + case userDesktopDirectory: resultPath = "~/Desktop"; break; @@ -336,21 +338,27 @@ bool openDocument(const String& fileName, const String& parameters, const Array< case userMusicDirectory: resultPath = "~/Music"; break; + case userMoviesDirectory: resultPath = "~/Movies"; break; + case userPicturesDirectory: resultPath = "~/Pictures"; break; + case userApplicationDataDirectory: resultPath = "~/Library"; break; + case commonApplicationDataDirectory: resultPath = "/Library"; break; + case commonDocumentsDirectory: resultPath = "/Users/Shared"; break; + case globalApplicationsDirectory: resultPath = "/Applications"; break; @@ -481,11 +489,11 @@ bool openDocument(const String& fileName, const String& parameters, const Array< { YUP_AUTORELEASEPOOL { - enumerator = [[NSFileManager defaultManager] enumeratorAtPath:yupStringToNS(directory.getFullPathName())]; - } - } - - ~Pimpl() = default; + enumerator = [[NSFileManager defaultManager] enumeratorAtPath:yupStringToNS(directory.getFullPathName())]; + } + } + + ~Pimpl() = default; bool next(String& filenameFound, bool* const isDir, diff --git a/modules/yup_core/native/yup_Files_wasm.cpp b/modules/yup_core/native/yup_Files_wasm.cpp index afb942314..bec374437 100644 --- a/modules/yup_core/native/yup_Files_wasm.cpp +++ b/modules/yup_core/native/yup_Files_wasm.cpp @@ -135,7 +135,7 @@ File File::getSpecialLocation (const SpecialLocationType type) } */ - return { "/" }; + return File ("/"); } //============================================================================== diff --git a/modules/yup_core/native/yup_Files_windows.cpp b/modules/yup_core/native/yup_Files_windows.cpp index 621fbf557..aa0c6fefb 100644 --- a/modules/yup_core/native/yup_Files_windows.cpp +++ b/modules/yup_core/native/yup_Files_windows.cpp @@ -687,7 +687,7 @@ void File::findFileSystemRoots (Array& destArray) roots.sort (true); for (int i = 0; i < roots.size(); ++i) - destArray.add (roots[i]); + destArray.add (File (roots[i])); } //============================================================================== diff --git a/modules/yup_core/native/yup_Network_wasm.cpp b/modules/yup_core/native/yup_Network_wasm.cpp index e828a3a4e..2e7e40a2a 100644 --- a/modules/yup_core/native/yup_Network_wasm.cpp +++ b/modules/yup_core/native/yup_Network_wasm.cpp @@ -37,7 +37,7 @@ bool YUP_CALLTYPE Process::openEmailWithAttachments (const String& /* targetEmai } //============================================================================== -#if YUP_EMSCRIPTEN && ! YUP_USE_CURL +#if YUP_EMSCRIPTEN class WebInputStream::Pimpl { public: diff --git a/modules/yup_core/network/yup_URL.cpp b/modules/yup_core/network/yup_URL.cpp index f72dbf3bc..d41e608b0 100644 --- a/modules/yup_core/network/yup_URL.cpp +++ b/modules/yup_core/network/yup_URL.cpp @@ -854,7 +854,7 @@ File URL::fileFromFileSchemeURL (const URL& fileURL) path = path.substring (1); #endif - return path; + return File (path); } int URL::getPort() const diff --git a/modules/yup_core/yup_core.cpp b/modules/yup_core/yup_core.cpp index 57fd7f003..d955f37ba 100644 --- a/modules/yup_core/yup_core.cpp +++ b/modules/yup_core/yup_core.cpp @@ -323,11 +323,11 @@ extern char** environ; #include "threads/yup_HighResolutionTimer.cpp" #include "threads/yup_WaitableEvent.cpp" #include "network/yup_URL.cpp" +#include "network/yup_WebInputStream.cpp" +#include "streams/yup_URLInputSource.cpp" #if ! YUP_WASM #include "threads/yup_ChildProcess.cpp" -#include "network/yup_WebInputStream.cpp" -#include "streams/yup_URLInputSource.cpp" #endif //============================================================================== diff --git a/modules/yup_graphics/drawables/yup_Drawable.cpp b/modules/yup_graphics/drawables/yup_Drawable.cpp index e3e478c15..d25a5ed1a 100644 --- a/modules/yup_graphics/drawables/yup_Drawable.cpp +++ b/modules/yup_graphics/drawables/yup_Drawable.cpp @@ -2,7 +2,7 @@ ============================================================================== This file is part of the YUP library. - Copyright (c) 2025 - kunitoki@gmail.com + Copyright (c) 2026 - kunitoki@gmail.com YUP is an open source library subject to open-source licensing. @@ -23,17 +23,112 @@ namespace yup { //============================================================================== -#ifndef YUP_DRAWABLE_LOGGING -#define YUP_DRAWABLE_LOGGING 0 -#endif - -#if YUP_DRAWABLE_LOGGING -#define YUP_DRAWABLE_LOG(textToWrite) YUP_DBG (textToWrite) -#else -#define YUP_DRAWABLE_LOG(textToWrite) \ - { \ + +namespace +{ +SVGGradient::Ptr getGradientById (const SVGData& data, const String& id) +{ + return data.gradientsById[id]; +} + +SVGGradient::Ptr resolveGradient (const SVGData& data, SVGGradient::Ptr gradient) +{ + if (gradient == nullptr || gradient->href.isEmpty()) + return gradient; + + auto referencedGradient = getGradientById (data, gradient->href); + if (referencedGradient == nullptr) + return gradient; + + referencedGradient = resolveGradient (data, referencedGradient); + + SVGGradient::Ptr resolved = new SVGGradient; + resolved->type = gradient->type; + resolved->id = gradient->id; + resolved->units = referencedGradient->units; + resolved->spreadMethod = referencedGradient->spreadMethod; + resolved->start = referencedGradient->start; + resolved->end = referencedGradient->end; + resolved->center = referencedGradient->center; + resolved->radius = referencedGradient->radius; + resolved->focal = referencedGradient->focal; + resolved->transform = referencedGradient->transform; + resolved->stops = referencedGradient->stops; + resolved->hasUnits = referencedGradient->hasUnits; + resolved->hasSpreadMethod = referencedGradient->hasSpreadMethod; + + if (gradient->hasStart) + resolved->start = gradient->start; + if (gradient->hasEnd) + resolved->end = gradient->end; + if (gradient->hasCenter) + resolved->center = gradient->center; + if (gradient->hasRadius) + resolved->radius = gradient->radius; + if (gradient->hasFocal) + resolved->focal = gradient->focal; + + if (! gradient->transform.isIdentity()) + resolved->transform = gradient->transform; + if (gradient->hasUnits) + { + resolved->units = gradient->units; + resolved->hasUnits = true; + } + if (gradient->hasSpreadMethod) + { + resolved->spreadMethod = gradient->spreadMethod; + resolved->hasSpreadMethod = true; } -#endif + if (! gradient->stops.empty()) + resolved->stops = gradient->stops; + + return resolved; +} + +SVGFilter::Ptr getFilterById (const SVGData& data, const String& id) +{ + return data.filtersById[id]; +} + +SVGFilter::Ptr resolveFilter (const SVGData& data, SVGFilter::Ptr filter) +{ + if (filter == nullptr || filter->href.isEmpty()) + return filter; + + auto referencedFilter = resolveFilter (data, getFilterById (data, filter->href)); + if (referencedFilter == nullptr) + return filter; + + SVGFilter::Ptr resolved = new SVGFilter; + resolved->id = filter->id; + resolved->href = filter->href; + resolved->gaussianBlurStdDeviation = filter->gaussianBlurStdDeviation + ? filter->gaussianBlurStdDeviation + : referencedFilter->gaussianBlurStdDeviation; + return resolved; +} + +SVGClipPath::Ptr getClipPathById (const SVGData& data, const String& id) +{ + return data.clipPathsById[id]; +} + +SVGMask::Ptr getMaskById (const SVGData& data, const String& id) +{ + return data.masksById[id]; +} + +SVGMarker::Ptr getMarkerById (const SVGData& data, const String& id) +{ + return data.markersById[id]; +} + +SVGPattern::Ptr getPatternById (const SVGData& data, const String& id) +{ + return data.patternsById[id]; +} +} // namespace //============================================================================== @@ -45,177 +140,315 @@ Drawable::Drawable() bool Drawable::parseSVG (const File& svgFile) { - clear(); + YUP_DRAWABLE_LOG ("parseSVG(file) - file: " << svgFile.getFullPathName()); - XmlDocument svgDoc (svgFile); - std::unique_ptr svgRoot (svgDoc.getDocumentElement()); + ParseOptions options; + options.baseDirectory = svgFile.getParentDirectory(); - if (svgRoot == nullptr || ! svgRoot->hasTagName ("svg")) - return false; + return parseSVG (svgFile, options); +} - if (auto view = svgRoot->getStringAttribute ("viewBox"); view.isNotEmpty()) - { - auto coords = StringArray::fromTokens (view, " ,", ""); - if (coords.size() == 4) - { - viewBox.setX (coords.getReference (0).getFloatValue()); - viewBox.setY (coords.getReference (1).getFloatValue()); - viewBox.setWidth (coords.getReference (2).getFloatValue()); - viewBox.setHeight (coords.getReference (3).getFloatValue()); - } - } +bool Drawable::parseSVG (const File& svgFile, const ParseOptions& options) +{ + YUP_DRAWABLE_LOG ("parseSVG(file, options) - file: " << svgFile.getFullPathName()); - auto width = svgRoot->getFloatAttribute ("width"); - size.setWidth (width == 0.0f ? viewBox.getWidth() : width); + document = SVGParser::parse (svgFile, options); + return document != nullptr; +} - auto height = svgRoot->getFloatAttribute ("height"); - size.setHeight (height == 0.0f ? viewBox.getHeight() : height); +//============================================================================== - // ViewBox transform is now calculated at render-time based on actual target area - YUP_DRAWABLE_LOG ("Parse complete - viewBox: " << viewBox.toString() << " size: " << size.getWidth() << "x" << size.getHeight()); +bool Drawable::parseSVG (StringRef svgText) +{ + YUP_DRAWABLE_LOG ("parseSVG(text) - length: " << String (svgText.text).length()); - auto result = parseElement (*svgRoot, true, {}); + return parseSVG (svgText, ParseOptions()); +} - if (result) - bounds = calculateBounds(); +bool Drawable::parseSVG (StringRef svgText, const ParseOptions& options) +{ + YUP_DRAWABLE_LOG ("parseSVG(text, options) - length: " << String (svgText.text).length()); - return result; + document = SVGParser::parse (svgText, options); + return document != nullptr; } //============================================================================== void Drawable::clear() { - viewBox = { 0.0f, 0.0f, 0.0f, 0.0f }; - size = { 0.0f, 0.0f }; - bounds = { 0.0f, 0.0f, 0.0f, 0.0f }; - transform = AffineTransform::identity(); - - elements.clear(); - elementsById.clear(); - gradients.clear(); - gradientsById.clear(); - clipPaths.clear(); - clipPathsById.clear(); - - // Reset root element's default presentation attributes to SVG defaults - rootHasFill = true; // SVG default fill is black - rootHasStroke = false; // SVG default stroke is none - rootFillColor = std::nullopt; - rootStrokeColor = std::nullopt; + document = nullptr; } //============================================================================== Rectangle Drawable::getBounds() const { - return bounds; + if (document == nullptr) + return {}; + + return document->getBounds(); } //============================================================================== void Drawable::paint (Graphics& g) { - const auto savedState = g.saveState(); + if (document == nullptr) + return; + + document->visit ([&] (const SVGData& data) + { + YUP_DRAWABLE_LOG ("paint - bounds: " << data.bounds.toString() + << " topLevelElements: " << data.elements.size() + << " rootHasFill: " << (data.rootHasFill ? "true" : "false") + << " rootHasStroke: " << (data.rootHasStroke ? "true" : "false")); + + const auto savedState = g.saveState(); - g.setStrokeWidth (1.0f); + g.setStrokeWidth (1.0f); - // Set default fill color based on root SVG element or SVG default (black) - if (rootFillColor) - g.setFillColor (*rootFillColor); - else - g.setFillColor (Colors::black); + if (data.rootFillColor) + g.setFillColor (*data.rootFillColor); + else + g.setFillColor (Colors::black); - // Set default stroke color if root SVG element specified one - if (rootStrokeColor) - g.setStrokeColor (*rootStrokeColor); + if (data.rootStrokeColor) + g.setStrokeColor (*data.rootStrokeColor); - if (! transform.isIdentity()) - g.addTransform (transform); + if (! data.transform.isIdentity()) + g.addTransform (data.transform); - // Pass root element's fill/stroke state to top-level elements - for (const auto& element : elements) - paintElement (g, *element, rootHasFill, rootHasStroke); + std::unordered_set visiting; + for (const auto& element : data.elements) + paintElement (g, data, *element, data.rootHasFill, data.rootHasStroke, data.rootFillColor.value_or (Colors::black), visiting); + }); } void Drawable::paint (Graphics& g, const Rectangle& targetArea, Fitting fitting, Justification justification) { - YUP_DRAWABLE_LOG ("Fitted paint called - bounds: " << bounds.toString() << " targetArea: " << targetArea.toString()); - - if (bounds.isEmpty()) + if (document == nullptr) return; - const auto savedState = g.saveState(); + document->visit ([&] (const SVGData& data) + { + YUP_DRAWABLE_LOG ("Fitted paint called - bounds: " << data.bounds.toString() << " targetArea: " << targetArea.toString()); + + if (data.bounds.isEmpty()) + { + YUP_DRAWABLE_LOG ("Fitted paint skipped - drawable bounds are empty"); + return; + } + + const auto savedState = g.saveState(); - auto finalBounds = viewBox.isEmpty() ? bounds : viewBox; - auto finalTransform = calculateTransformForTarget (finalBounds, targetArea, fitting, justification); - if (! finalTransform.isIdentity()) - g.addTransform (finalTransform); + auto finalBounds = data.viewBox.isEmpty() ? data.bounds : data.viewBox; + auto finalTransform = calculateTransformForTarget (finalBounds, targetArea, fitting, justification); - g.setStrokeWidth (1.0f); + if (! finalTransform.isIdentity()) + g.addTransform (finalTransform); - // Set default fill color based on root SVG element or SVG default (black) - if (rootFillColor) - g.setFillColor (*rootFillColor); - else - g.setFillColor (Colors::black); + g.setStrokeWidth (1.0f); + + if (data.rootFillColor) + g.setFillColor (*data.rootFillColor); + else + g.setFillColor (Colors::black); - // Set default stroke color if root SVG element specified one - if (rootStrokeColor) - g.setStrokeColor (*rootStrokeColor); + if (data.rootStrokeColor) + g.setStrokeColor (*data.rootStrokeColor); - // Pass root element's fill/stroke state to top-level elements - for (const auto& element : elements) - paintElement (g, *element, rootHasFill, rootHasStroke); + std::unordered_set visiting; + for (const auto& element : data.elements) + paintElement (g, data, *element, data.rootHasFill, data.rootHasStroke, data.rootFillColor.value_or (Colors::black), visiting); + }); } //============================================================================== -void Drawable::paintElement (Graphics& g, const Element& element, bool hasParentFillEnabled, bool hasParentStrokeEnabled) +void Drawable::paintElement (Graphics& g, const SVGData& data, const SVGElement& element, bool hasParentFillEnabled, bool hasParentStrokeEnabled, Color currentColor, std::unordered_set& visitingElements, int recursionDepth) { + if (element.hidden) + { + YUP_DRAWABLE_LOG ("paintElement skipped - hidden tag: " << element.tagName + << " id: " << (element.id ? *element.id : "none") + << " depth: " << recursionDepth); + return; + } + + if (recursionDepth > 64) + { + YUP_DRAWABLE_LOG ("paintElement skipped - recursion limit tag: " << element.tagName + << " id: " << (element.id ? *element.id : "none") + << " depth: " << recursionDepth); + return; + } + const auto savedState = g.saveState(); bool isFillDefined = hasParentFillEnabled; bool isStrokeDefined = hasParentStrokeEnabled; + if (element.color) + currentColor = *element.color; - YUP_DRAWABLE_LOG ("paintElement called - hasPath: " << (element.path ? "true" : "false") << " hasTransform: " << (element.transform ? "true" : "false")); - - // Apply element transform if present - use proper composition for coordinate systems if (element.transform) - { - YUP_DRAWABLE_LOG ("Applying element transform - before: " << g.getTransform().toString() << " adding: " << element.transform->toString()); - // For proper coordinate system handling, we need to apply element transform - // in the element's local space, then transform to viewport space g.setTransform (element.transform->followedBy (g.getTransform())); - YUP_DRAWABLE_LOG ("After transform: " << g.getTransform().toString()); - } if (element.opacity) g.setOpacity (g.getOpacity() * (*element.opacity)); - // Apply clipping path if specified + if (element.blendMode) + g.setBlendMode (*element.blendMode); + + if (element.filterUrl) + { + if (auto filter = resolveFilter (data, getFilterById (data, *element.filterUrl))) + { + if (filter->gaussianBlurStdDeviation) + { + const auto svgStdDeviationToFeather = 2.0f; + const auto feather = jmax (g.getFeather(), *filter->gaussianBlurStdDeviation * svgStdDeviationToFeather); + g.setFeather (feather); + } + } + } + + if (element.viewBox && element.viewportSize) + { + Rectangle viewport (0.0f, 0.0f, element.viewportSize->getWidth(), element.viewportSize->getHeight()); + auto viewBoxTransform = calculateTransformForTarget (*element.viewBox, viewport, element.preserveAspectRatioFitting, element.preserveAspectRatioJustification); + if (! viewBoxTransform.isIdentity()) + g.addTransform (viewBoxTransform); + } + bool hasClipping = false; if (element.clipPathUrl) { - if (auto clipPath = getClipPathById (*element.clipPathUrl)) + if (auto clipPath = getClipPathById (data, *element.clipPathUrl)) { - // Create a combined path from all clip path elements + std::optional> clipObjectBounds; + + if (clipPath->units == SVGClipPath::ObjectBoundingBox) + { + if (element.path) + clipObjectBounds = element.path->getBounds(); + else if (element.reference) + { + if (auto refElement = data.elementsById[*element.reference]; refElement != nullptr && refElement->path) + clipObjectBounds = refElement->path->getBounds(); + } + else if (element.imageBounds) + { + clipObjectBounds = *element.imageBounds; + } + } + Path combinedClipPath; + bool clipUsesNonZeroWinding = true; + for (const auto& clipElement : clipPath->elements) { if (clipElement->path) - combinedClipPath.appendPath (*clipElement->path); + { + if (clipElement->clipRule == "evenodd") + clipUsesNonZeroWinding = false; + + AffineTransform clipTransform = clipElement->transform.value_or (AffineTransform::identity()); + + if (clipPath->units == SVGClipPath::ObjectBoundingBox) + { + if (! clipObjectBounds || clipObjectBounds->isEmpty()) + continue; + + auto unitsTransform = AffineTransform::translation (clipObjectBounds->getX(), clipObjectBounds->getY()) + .scaled (clipObjectBounds->getWidth(), clipObjectBounds->getHeight()); + clipTransform = clipTransform.followedBy (unitsTransform); + } + + if (! clipTransform.isIdentity()) + combinedClipPath.appendPath (*clipElement->path, clipTransform); + else + combinedClipPath.appendPath (*clipElement->path); + } } if (! combinedClipPath.isEmpty()) { - g.setClipPath (combinedClipPath); + combinedClipPath.setUsingNonZeroWinding (clipUsesNonZeroWinding); + + auto clipTransform = g.getTransform().translated (g.getDrawingArea().getTopLeft()); + auto transformedClipPath = combinedClipPath.transformed (clipTransform); + + const auto savedClipTransform = g.getTransform(); + g.setTransform (AffineTransform::identity()); + g.setClipPath (transformedClipPath); + g.setTransform (savedClipTransform); + hasClipping = true; } } } - // Setup fill + if (element.maskUrl) + { + if (auto mask = getMaskById (data, *element.maskUrl)) + { + std::optional> maskObjectBounds; + + if (mask->maskUnits == SVGMask::ObjectBoundingBox) + { + if (element.path) + maskObjectBounds = element.path->getBounds(); + else if (element.reference) + { + if (auto refElement = data.elementsById[*element.reference]; refElement != nullptr && refElement->path) + maskObjectBounds = refElement->path->getBounds(); + } + else if (element.imageBounds) + { + maskObjectBounds = *element.imageBounds; + } + } + + Path combinedMaskPath; + + for (const auto& maskElement : mask->elements) + { + if (maskElement->path) + { + AffineTransform maskTransform = maskElement->transform.value_or (AffineTransform::identity()); + + if (mask->maskUnits == SVGMask::ObjectBoundingBox) + { + if (! maskObjectBounds || maskObjectBounds->isEmpty()) + continue; + + auto unitsTransform = AffineTransform::translation (maskObjectBounds->getX(), maskObjectBounds->getY()) + .scaled (maskObjectBounds->getWidth(), maskObjectBounds->getHeight()); + maskTransform = maskTransform.followedBy (unitsTransform); + } + + if (! maskTransform.isIdentity()) + combinedMaskPath.appendPath (*maskElement->path, maskTransform); + else + combinedMaskPath.appendPath (*maskElement->path); + } + } + + if (! combinedMaskPath.isEmpty()) + { + auto maskClipTransform = g.getTransform().translated (g.getDrawingArea().getTopLeft()); + auto transformedMaskPath = combinedMaskPath.transformed (maskClipTransform); + + const auto savedMaskTransform = g.getTransform(); + g.setTransform (AffineTransform::identity()); + g.setClipPath (transformedMaskPath); + g.setTransform (savedMaskTransform); + } + } + } + + // Fill setup if (element.fillColor) { Color fillColor = *element.fillColor; @@ -224,20 +457,26 @@ void Drawable::paintElement (Graphics& g, const Element& element, bool hasParent g.setFillColor (fillColor); isFillDefined = true; } + else if (element.fillCurrentColor) + { + Color fillColor = currentColor; + if (element.fillOpacity) + fillColor = fillColor.withMultipliedAlpha (*element.fillOpacity); + g.setFillColor (fillColor); + isFillDefined = true; + } else if (element.fillUrl) { - YUP_DRAWABLE_LOG ("Looking for gradient with ID: " << *element.fillUrl); - if (auto gradient = getGradientById (*element.fillUrl)) + if (auto gradient = getGradientById (data, *element.fillUrl)) { - YUP_DRAWABLE_LOG ("Found gradient, resolving references..."); - auto resolvedGradient = resolveGradient (gradient); + auto resolvedGradient = resolveGradient (data, gradient); std::optional> gradientBounds; if (element.path) gradientBounds = element.path->getBounds(); else if (element.reference) { - if (auto refElement = elementsById[*element.reference]; refElement != nullptr && refElement->path) + if (auto refElement = data.elementsById[*element.reference]; refElement != nullptr && refElement->path) gradientBounds = refElement->path->getBounds(); } @@ -245,16 +484,14 @@ void Drawable::paintElement (Graphics& g, const Element& element, bool hasParent gradientBounds ? std::addressof (*gradientBounds) : nullptr); g.setFillColorGradient (colorGradient); isFillDefined = true; - YUP_DRAWABLE_LOG ("Applied gradient to fill"); } - else + else if (getPatternById (data, *element.fillUrl)) { - YUP_DRAWABLE_LOG ("Gradient not found for ID: " << *element.fillUrl); + isFillDefined = true; } } else if (hasParentFillEnabled) { - // Inherit parent fill - don't change graphics state, just mark as defined isFillDefined = true; } @@ -262,79 +499,79 @@ void Drawable::paintElement (Graphics& g, const Element& element, bool hasParent { if (element.path) { - // SVG spec: fill is applied to both closed and unclosed paths - // For unclosed paths, an implicit line connects the last point to the first point - // TODO: Apply fill-rule when Graphics class supports it - // if (element.fillRule) - // g.setFillRule (*element.fillRule == "evenodd" ? FillRule::EvenOdd : FillRule::NonZero); - g.fillPath (*element.path); + if (element.fillUrl) + { + if (auto pattern = getPatternById (data, *element.fillUrl)) + { + paintPatternFill (g, data, *element.path, element, *pattern, currentColor, visitingElements, recursionDepth); + } + else + { + YUP_DRAWABLE_LOG ("Filling path - tag: " << element.tagName + << " id: " << (element.id ? *element.id : "none") + << " bounds: " << element.path->getBounds().toString() + << " clip: " << (hasClipping ? "true" : "false")); + g.fillPath (*element.path); + } + } + else + { + YUP_DRAWABLE_LOG ("Filling path - tag: " << element.tagName + << " id: " << (element.id ? *element.id : "none") + << " bounds: " << element.path->getBounds().toString() + << " clip: " << (hasClipping ? "true" : "false")); + g.fillPath (*element.path); + } } else if (element.reference) { - if (auto refElement = elementsById[*element.reference]; refElement != nullptr && refElement->path) + if (auto refElement = data.elementsById[*element.reference]; refElement != nullptr && refElement->path) { - YUP_DRAWABLE_LOG ("Rendering use element - reference: " << *element.reference); - YUP_DRAWABLE_LOG ("Use element transform: " << (element.transform ? element.transform->toString() : "none")); - YUP_DRAWABLE_LOG ("Referenced element local transform: " << (refElement->localTransform ? refElement->localTransform->toString() : "none")); - YUP_DRAWABLE_LOG ("Graphics transform during use fill: " << g.getTransform().toString()); + const bool useDefinesFill = element.fillColor || element.fillCurrentColor || element.fillUrl || element.noFill; + if (useDefinesFill || ! refElement->noFill) + { + const auto savedReferenceState = g.saveState(); - // For elements, apply only the referenced element's own transform (not inherited parents) - const auto savedTransform = g.getTransform(); - if (refElement->localTransform) - g.setTransform (refElement->localTransform->followedBy (savedTransform)); + if (! useDefinesFill) + { + if (refElement->fillColor) + { + Color fillColor = *refElement->fillColor; + if (refElement->fillOpacity) + fillColor = fillColor.withMultipliedAlpha (*refElement->fillOpacity); + g.setFillColor (fillColor); + } + else if (refElement->fillCurrentColor) + { + Color fillColor = currentColor; + if (refElement->fillOpacity) + fillColor = fillColor.withMultipliedAlpha (*refElement->fillOpacity); + g.setFillColor (fillColor); + } + } - // SVG spec: fill is applied to both closed and unclosed paths - g.fillPath (*refElement->path); + const auto savedTransform = g.getTransform(); + if (refElement->localTransform) + g.setTransform (refElement->localTransform->followedBy (savedTransform)); - if (refElement->localTransform) - g.setTransform (savedTransform); + g.fillPath (*refElement->path); + + if (refElement->localTransform) + g.setTransform (savedTransform); + } } } else if (element.text && element.textPosition) { - /* - // Create StyledText for text rendering - StyledText styledText; - styledText.setText (*element.text); - - // Set font properties - if (element.fontSize) - styledText.setFontSize (*element.fontSize); - else - styledText.setFontSize (12.0f); - - if (element.fontFamily) - styledText.setFontFamily (*element.fontFamily); - - // Set text alignment based on text-anchor - if (element.textAnchor) - { - if (*element.textAnchor == "middle") - styledText.setHorizontalAlignment (StyledText::HorizontalAlignment::Center); - else if (*element.textAnchor == "end") - styledText.setHorizontalAlignment (StyledText::HorizontalAlignment::Right); - else - styledText.setHorizontalAlignment (StyledText::HorizontalAlignment::Left); - } - - // Render text at specified position - auto textBounds = styledText.getBounds(); - g.drawStyledText (styledText, element.textPosition->getX(), element.textPosition->getY() - textBounds.getHeight()); - */ + renderTextElement (g, element); } - else if (element.imageHref && element.imageBounds) + else if ((element.imageHref || element.image) && element.imageBounds) { - // TODO: Load and render image - // For now, draw a placeholder rectangle - g.setFillColor (Colors::lightgray); - g.fillRect (*element.imageBounds); - g.setStrokeColor (Colors::darkgray); - g.setStrokeWidth (1.0f); - g.strokeRect (*element.imageBounds); + renderImageElement (g, element); } } - // Setup stroke + // Stroke setup if (element.strokeColor) { Color strokeColor = *element.strokeColor; @@ -343,18 +580,26 @@ void Drawable::paintElement (Graphics& g, const Element& element, bool hasParent g.setStrokeColor (strokeColor); isStrokeDefined = true; } + else if (element.strokeCurrentColor) + { + Color strokeColor = currentColor; + if (element.strokeOpacity) + strokeColor = strokeColor.withMultipliedAlpha (*element.strokeOpacity); + g.setStrokeColor (strokeColor); + isStrokeDefined = true; + } else if (element.strokeUrl) { - if (auto gradient = getGradientById (*element.strokeUrl)) + if (auto gradient = getGradientById (data, *element.strokeUrl)) { - auto resolvedGradient = resolveGradient (gradient); + auto resolvedGradient = resolveGradient (data, gradient); std::optional> gradientBounds; if (element.path) gradientBounds = element.path->getBounds(); else if (element.reference) { - if (auto refElement = elementsById[*element.reference]; refElement != nullptr && refElement->path) + if (auto refElement = data.elementsById[*element.reference]; refElement != nullptr && refElement->path) gradientBounds = refElement->path->getBounds(); } @@ -366,48 +611,74 @@ void Drawable::paintElement (Graphics& g, const Element& element, bool hasParent } else if (hasParentStrokeEnabled) { - // Inherit parent stroke - don't change graphics state, just mark as defined isStrokeDefined = true; } if (element.strokeJoin) g.setStrokeJoin (*element.strokeJoin); - if (element.strokeCap) g.setStrokeCap (*element.strokeCap); - if (element.strokeWidth) g.setStrokeWidth (*element.strokeWidth); + g.setStrokeMiterLimit (element.strokeMiterLimit); - // Apply stroke dash patterns - if (element.strokeDashArray) + bool referenceDefinesStroke = false; + if (! isStrokeDefined && element.reference) { - // Convert Array to what Graphics expects - const auto& dashArray = *element.strokeDashArray; - if (! dashArray.isEmpty()) - { - // TODO: Graphics class needs stroke dash pattern support - // For now, this is prepared for when Graphics supports it - // g.setStrokeDashPattern (dashArray.getRawDataPointer(), dashArray.size()); - // if (element.strokeDashOffset) - // g.setStrokeDashOffset (*element.strokeDashOffset); - } + if (auto refElement = data.elementsById[*element.reference]; refElement != nullptr) + referenceDefinesStroke = (refElement->strokeColor || refElement->strokeCurrentColor || refElement->strokeUrl) && ! refElement->noStroke; } - if (isStrokeDefined && ! element.noStroke) + if ((isStrokeDefined || referenceDefinesStroke) && ! element.noStroke) { - if (element.path) + const Path* pathToStroke = element.path ? std::addressof (*element.path) : nullptr; + std::optional dashedPath; + + if (pathToStroke != nullptr && element.strokeDashArray && ! element.strokeDashArray->isEmpty()) + { + dashedPath = createDashedPath (*pathToStroke, *element.strokeDashArray, element.strokeDashOffset.value_or (0.0f)); + pathToStroke = std::addressof (*dashedPath); + } + + if (pathToStroke != nullptr) { - g.strokePath (*element.path); + YUP_DRAWABLE_LOG ("Stroking path - tag: " << element.tagName + << " id: " << (element.id ? *element.id : "none") + << " bounds: " << pathToStroke->getBounds().toString()); + g.strokePath (*pathToStroke); } else if (element.reference) { - if (auto refElement = elementsById[*element.reference]; refElement != nullptr && refElement->path) + if (auto refElement = data.elementsById[*element.reference]; refElement != nullptr && refElement->path) { - YUP_DRAWABLE_LOG ("Stroking use element - reference: " << *element.reference); - YUP_DRAWABLE_LOG ("Graphics transform during stroke: " << g.getTransform().toString()); + const bool useDefinesStroke = element.strokeColor || element.strokeCurrentColor || element.strokeUrl || element.noStroke; + const auto savedReferenceState = g.saveState(); + + if (! useDefinesStroke) + { + if (refElement->strokeColor) + { + Color strokeColor = *refElement->strokeColor; + if (refElement->strokeOpacity) + strokeColor = strokeColor.withMultipliedAlpha (*refElement->strokeOpacity); + g.setStrokeColor (strokeColor); + } + else if (refElement->strokeCurrentColor) + { + Color strokeColor = currentColor; + if (refElement->strokeOpacity) + strokeColor = strokeColor.withMultipliedAlpha (*refElement->strokeOpacity); + g.setStrokeColor (strokeColor); + } + + if (refElement->strokeWidth) + g.setStrokeWidth (*refElement->strokeWidth); + if (refElement->strokeJoin) + g.setStrokeJoin (*refElement->strokeJoin); + if (refElement->strokeCap) + g.setStrokeCap (*refElement->strokeCap); + } - // For elements, apply only the referenced element's own transform (not inherited parents) const auto savedTransform = g.getTransform(); if (refElement->localTransform) g.setTransform (refElement->localTransform->followedBy (savedTransform)); @@ -420,536 +691,338 @@ void Drawable::paintElement (Graphics& g, const Element& element, bool hasParent } } - for (const auto& childElement : element.children) + if (element.path && (element.markerStart || element.markerMid || element.markerEnd)) { - YUP_DRAWABLE_LOG ("Rendering child element - current graphics transform: " << g.getTransform().toString()); - // Pass fill/stroke state to children, but respect explicit "none" values - // If this element has fill="none", children should not inherit fill - paintElement (g, *childElement, isFillDefined && ! element.noFill, isStrokeDefined && ! element.noStroke); - } + struct MarkerPlacement + { + Point position; + float tangentAngle = 0.0f; + }; - // paintDebugElement (g, element); -} + std::vector startPlacements, midPlacements, endPlacements; + Point firstPoint, prevPoint, subpathStart; + bool hasFirstPoint = false; + float firstTangent = 0.0f, prevTangent = 0.0f; + bool firstSegmentAfterMove = false; -//============================================================================== + for (const auto& seg : *element.path) + { + switch (seg.verb) + { + case Path::Verb::MoveTo: + { + if (hasFirstPoint && ! endPlacements.empty()) + { + // Flush pending end for the previous sub-path + } -bool Drawable::parseElement (const XmlElement& element, bool parentIsRoot, AffineTransform currentTransform, Element* parent) -{ - Element::Ptr e = new Element; - bool isRootElement = element.hasTagName ("svg"); + firstPoint = seg.point; + prevPoint = seg.point; + subpathStart = seg.point; + hasFirstPoint = true; + firstSegmentAfterMove = true; + firstTangent = 0.0f; + prevTangent = 0.0f; + endPlacements.clear(); + break; + } - if (auto id = element.getStringAttribute ("id"); id.isNotEmpty()) - { - e->id = id; - elementsById.set (id, e); - } + case Path::Verb::LineTo: + { + if (! hasFirstPoint) + break; - if (element.hasTagName ("path")) - { - auto path = Path(); + const float dx = seg.point.getX() - prevPoint.getX(); + const float dy = seg.point.getY() - prevPoint.getY(); + const float angle = std::atan2 (dy, dx); - String pathData = element.getStringAttribute ("d"); - if (pathData.isEmpty() || ! path.fromString (pathData)) - return false; + if (firstSegmentAfterMove) + { + startPlacements.push_back ({ firstPoint, angle }); + firstTangent = angle; + firstSegmentAfterMove = false; + } + else + { + midPlacements.push_back ({ prevPoint, prevTangent }); + } - e->path = std::move (path); + prevPoint = seg.point; + prevTangent = angle; + endPlacements = { { seg.point, angle } }; + break; + } - currentTransform = parseTransform (element, currentTransform, *e); - parseStyle (element, currentTransform, *e); + case Path::Verb::QuadTo: + { + if (! hasFirstPoint) + break; - // Apply fill-rule after parsing style - if (e->fillRule && *e->fillRule == "evenodd") - e->path->setUsingNonZeroWinding (false); - } - else if (element.hasTagName ("g")) - { - currentTransform = parseTransform (element, currentTransform, *e); - parseStyle (element, currentTransform, *e); - } - else if (element.hasTagName ("use")) - { - String href = element.getStringAttribute ("href"); - if (href.isNotEmpty() && href.startsWith ("#")) - e->reference = href.substring (1); + const float dx = seg.point.getX() - seg.controlPoint1.getX(); + const float dy = seg.point.getY() - seg.controlPoint1.getY(); + const float angle = std::atan2 (dy, dx); + const float startDx = seg.controlPoint1.getX() - prevPoint.getX(); + const float startDy = seg.controlPoint1.getY() - prevPoint.getY(); + const float startAngle = std::atan2 (startDy, startDx); - // Handle x,y positioning for use elements (SVG spec requirement) - auto x = element.getFloatAttribute ("x"); - auto y = element.getFloatAttribute ("y"); - AffineTransform useTransform; - if (x != 0.0f || y != 0.0f) - useTransform = AffineTransform::translation (x, y); + if (firstSegmentAfterMove) + { + startPlacements.push_back ({ firstPoint, startAngle }); + firstTangent = startAngle; + firstSegmentAfterMove = false; + } + else + { + midPlacements.push_back ({ prevPoint, prevTangent }); + } - currentTransform = parseTransform (element, currentTransform, *e); + prevPoint = seg.point; + prevTangent = angle; + endPlacements = { { seg.point, angle } }; + break; + } - // Combine use element positioning with any explicit transform - if (! useTransform.isIdentity()) - { - if (e->transform.has_value()) - e->transform = useTransform.followedBy (*e->transform); - else - e->transform = useTransform; - } + case Path::Verb::CubicTo: + { + if (! hasFirstPoint) + break; - parseStyle (element, currentTransform, *e); - } - else if (element.hasTagName ("ellipse")) - { - auto cx = element.getFloatAttribute ("cx"); - auto cy = element.getFloatAttribute ("cy"); - auto rx = element.getFloatAttribute ("rx"); - auto ry = element.getFloatAttribute ("ry"); + const float dx = seg.point.getX() - seg.controlPoint2.getX(); + const float dy = seg.point.getY() - seg.controlPoint2.getY(); + const float angle = std::atan2 (dy, dx); + const float startDx = seg.controlPoint1.getX() - prevPoint.getX(); + const float startDy = seg.controlPoint1.getY() - prevPoint.getY(); + const float startAngle = std::atan2 (startDy, startDx); - auto path = Path(); - path.addCenteredEllipse (cx, cy, rx, ry); - e->path = std::move (path); + if (firstSegmentAfterMove) + { + startPlacements.push_back ({ firstPoint, startAngle }); + firstTangent = startAngle; + firstSegmentAfterMove = false; + } + else + { + midPlacements.push_back ({ prevPoint, prevTangent }); + } - currentTransform = parseTransform (element, currentTransform, *e); - parseStyle (element, currentTransform, *e); - } - else if (element.hasTagName ("circle")) - { - auto cx = element.getFloatAttribute ("cx"); - auto cy = element.getFloatAttribute ("cy"); - auto r = element.getFloatAttribute ("r"); + prevPoint = seg.point; + prevTangent = angle; + endPlacements = { { seg.point, angle } }; + break; + } - auto path = Path(); - path.addCenteredEllipse (cx, cy, r, r); - e->path = std::move (path); + case Path::Verb::Close: + { + if (! hasFirstPoint) + break; - currentTransform = parseTransform (element, currentTransform, *e); - parseStyle (element, currentTransform, *e); - } - else if (element.hasTagName ("rect")) - { - auto x = element.getFloatAttribute ("x"); - auto y = element.getFloatAttribute ("y"); - auto width = element.getFloatAttribute ("width"); - auto height = element.getFloatAttribute ("height"); - auto rx = element.getFloatAttribute ("rx"); - auto ry = element.getFloatAttribute ("ry"); - - auto path = Path(); - if (rx > 0.0f || ry > 0.0f) - { - if (rx == 0.0f) - rx = ry; - if (ry == 0.0f) - ry = rx; + if (! firstSegmentAfterMove) + midPlacements.push_back ({ prevPoint, prevTangent }); - path.addRoundedRectangle (x, y, width, height, rx, ry, rx, ry); - } - else - { - path.addRectangle (x, y, width, height); + prevPoint = subpathStart; + firstSegmentAfterMove = true; + endPlacements.clear(); + break; + } + } } - e->path = std::move (path); + const float sw = element.strokeWidth.value_or (1.0f); - currentTransform = parseTransform (element, currentTransform, *e); - parseStyle (element, currentTransform, *e); - } - else if (element.hasTagName ("line")) - { - auto x1 = element.getFloatAttribute ("x1"); - auto y1 = element.getFloatAttribute ("y1"); - auto x2 = element.getFloatAttribute ("x2"); - auto y2 = element.getFloatAttribute ("y2"); - - auto path = Path(); - path.startNewSubPath (x1, y1); - path.lineTo (x2, y2); - e->path = std::move (path); - - currentTransform = parseTransform (element, currentTransform, *e); - parseStyle (element, currentTransform, *e); - } - else if (element.hasTagName ("polygon")) - { - String points = element.getStringAttribute ("points"); - if (points.isNotEmpty()) + if (element.markerStart) { - auto path = Path(); - auto coords = StringArray::fromTokens (points, " ,", ""); - - if (coords.size() >= 4 && coords.size() % 2 == 0) + if (auto marker = getMarkerById (data, *element.markerStart)) { - path.startNewSubPath (coords[0].getFloatValue(), coords[1].getFloatValue()); - - for (int i = 2; i < coords.size(); i += 2) - path.lineTo (coords[i].getFloatValue(), coords[i + 1].getFloatValue()); + for (const auto& p : startPlacements) + { + float angle = p.tangentAngle; + if (marker->orientAutoStartReverse) + angle += MathConstants::pi; - path.closeSubPath(); + paintMarker (g, data, *marker, sw, p.position, angle, visitingElements, recursionDepth); + } } - - e->path = std::move (path); } - currentTransform = parseTransform (element, currentTransform, *e); - parseStyle (element, currentTransform, *e); - } - else if (element.hasTagName ("polyline")) - { - String points = element.getStringAttribute ("points"); - if (points.isNotEmpty()) + if (element.markerMid) { - auto path = Path(); - auto coords = StringArray::fromTokens (points, " ,", ""); - - if (coords.size() >= 4 && coords.size() % 2 == 0) + if (auto marker = getMarkerById (data, *element.markerMid)) { - path.startNewSubPath (coords[0].getFloatValue(), coords[1].getFloatValue()); - - for (int i = 2; i < coords.size(); i += 2) - path.lineTo (coords[i].getFloatValue(), coords[i + 1].getFloatValue()); + for (const auto& p : midPlacements) + paintMarker (g, data, *marker, sw, p.position, p.tangentAngle, visitingElements, recursionDepth); } - - e->path = std::move (path); } - currentTransform = parseTransform (element, currentTransform, *e); - parseStyle (element, currentTransform, *e); + if (element.markerEnd) + { + if (auto marker = getMarkerById (data, *element.markerEnd)) + { + for (const auto& p : endPlacements) + paintMarker (g, data, *marker, sw, p.position, p.tangentAngle, visitingElements, recursionDepth); + } + } } - else if (element.hasTagName ("text")) - { - float x = element.getFloatAttribute ("x"); - float y = element.getFloatAttribute ("y"); - e->textPosition = Point (x, y); - - e->text = element.getAllSubText(); - - String fontFamily = element.getStringAttribute ("font-family"); - if (fontFamily.isNotEmpty()) - e->fontFamily = fontFamily; - float fontSize = element.getFloatAttribute ("font-size"); - if (fontSize > 0.0f) - e->fontSize = fontSize; - - String textAnchor = element.getStringAttribute ("text-anchor"); - if (textAnchor.isNotEmpty()) - e->textAnchor = textAnchor; - - currentTransform = parseTransform (element, currentTransform, *e); - parseStyle (element, currentTransform, *e); - } - else if (element.hasTagName ("image")) + if (element.reference) { - auto x = element.getFloatAttribute ("x"); - auto y = element.getFloatAttribute ("y"); - auto width = element.getFloatAttribute ("width"); - auto height = element.getFloatAttribute ("height"); - - e->imageBounds = Rectangle (x, y, width, height); + if (auto refElement = data.elementsById[*element.reference]; refElement != nullptr && ! refElement->children.empty()) + { + if (visitingElements.count (refElement.get()) != 0) + { + YUP_DRAWABLE_LOG ("paintElement skipped - cycle detected in use reference id: " << *element.reference); + } + else + { + struct ScopeErase + { + std::unordered_set& set; + const SVGElement* elem; - String href = element.getStringAttribute ("href"); - if (href.isEmpty()) - href = element.getStringAttribute ("xlink:href"); + ~ScopeErase() { set.erase (elem); } + } eraseGuard { visitingElements, refElement.get() }; - if (href.isNotEmpty()) - e->imageHref = href; + visitingElements.insert (refElement.get()); - currentTransform = parseTransform (element, currentTransform, *e); - parseStyle (element, currentTransform, *e); - } - else if (element.hasTagName ("defs")) - { - // Parse definitions like gradients and clip paths - for (auto* child = element.getFirstChildElement(); child != nullptr; child = child->getNextElement()) - { - if (child->hasTagName ("linearGradient") || child->hasTagName ("radialGradient")) - parseGradient (*child); - else if (child->hasTagName ("clipPath")) - parseClipPath (*child); - } - } + const auto savedTransform = g.getTransform(); + if (refElement->localTransform) + g.setTransform (refElement->localTransform->followedBy (savedTransform)); - for (auto* child = element.getFirstChildElement(); child != nullptr; child = child->getNextElement()) - { - // Parse gradients and clip paths regardless of whether they're in or not - if (child->hasTagName ("linearGradient") || child->hasTagName ("radialGradient")) - parseGradient (*child); - else if (child->hasTagName ("clipPath")) - parseClipPath (*child); - else - parseElement (*child, isRootElement, currentTransform, e.get()); - } + if (refElement->viewBox) + { + auto viewportSizeToUse = element.viewportSize.value_or (refElement->viewportSize.value_or (Size (refElement->viewBox->getWidth(), refElement->viewBox->getHeight()))); + Rectangle viewport (0.0f, 0.0f, viewportSizeToUse.getWidth(), viewportSizeToUse.getHeight()); + auto viewBoxTransform = calculateTransformForTarget (*refElement->viewBox, viewport, refElement->preserveAspectRatioFitting, refElement->preserveAspectRatioJustification); + if (! viewBoxTransform.isIdentity()) + g.addTransform (viewBoxTransform); + } - if (isRootElement) - { - // Store root SVG element's default fill/stroke for inheritance by top-level elements - if (e->fillColor) - { - rootFillColor = e->fillColor; - rootHasFill = true; - } - else if (e->noFill) - { - rootHasFill = false; - } + for (const auto& childElement : refElement->children) + paintElement (g, data, *childElement, isFillDefined && ! element.noFill, isStrokeDefined && ! element.noStroke, currentColor, visitingElements, recursionDepth + 1); - if (e->strokeColor) - { - rootStrokeColor = e->strokeColor; - rootHasStroke = true; - } - else if (e->noStroke) - { - rootHasStroke = false; + g.setTransform (savedTransform); + } } - - return true; } - if (parent != nullptr && ! parentIsRoot) - parent->children.push_back (std::move (e)); - else - elements.push_back (std::move (e)); + for (const auto& childElement : element.children) + paintElement (g, data, *childElement, isFillDefined && ! element.noFill, isStrokeDefined && ! element.noStroke, currentColor, visitingElements, recursionDepth + 1); - return true; + // paintDebugElement (g, element); } //============================================================================== -void Drawable::parseStyle (const XmlElement& element, const AffineTransform& currentTransform, Element& e) +void Drawable::paintMarker (Graphics& g, + const SVGData& data, + const SVGMarker& marker, + float strokeWidth, + Point position, + float tangentAngle, + std::unordered_set& visitingElements, + int recursionDepth) { - // Parse CSS style attribute first - String styleAttr = element.getStringAttribute ("style"); - if (styleAttr.isNotEmpty()) - parseCSSStyle (styleAttr, e); - - // Parse individual attributes (these override style attribute values) - String fill = element.getStringAttribute ("fill"); - if (fill.isNotEmpty()) - { - if (fill != "none") - { - String gradientUrl = extractGradientUrl (fill); - if (gradientUrl.isNotEmpty()) - e.fillUrl = gradientUrl; - else - { - e.fillColor = Color::fromString (fill); - YUP_DRAWABLE_LOG ("Parsed fill color: " << fill << " -> " << e.fillColor->toString()); - } - } - else - { - e.noFill = true; - } - } + const auto savedState = g.saveState(); - String stroke = element.getStringAttribute ("stroke"); - if (stroke.isNotEmpty()) - { - if (stroke != "none") - { - String gradientUrl = extractGradientUrl (stroke); - if (gradientUrl.isNotEmpty()) - e.strokeUrl = gradientUrl; - else - e.strokeColor = Color::fromString (stroke); - } - else - { - e.noStroke = true; - } - } + float scale = (marker.markerUnits == SVGMarker::StrokeWidth) ? strokeWidth : 1.0f; - String strokeJoin = element.getStringAttribute ("stroke-linejoin"); - if (strokeJoin == "round") - e.strokeJoin = StrokeJoin::Round; - else if (strokeJoin == "miter") - e.strokeJoin = StrokeJoin::Miter; - else if (strokeJoin == "bevel") - e.strokeJoin = StrokeJoin::Bevel; - - String strokeCap = element.getStringAttribute ("stroke-linecap"); - if (strokeCap == "round") - e.strokeCap = StrokeCap::Round; - else if (strokeCap == "square") - e.strokeCap = StrokeCap::Square; - else if (strokeCap == "butt") - e.strokeCap = StrokeCap::Butt; - - float strokeWidth = element.getFloatAttribute ("stroke-width", -1.0f); - if (strokeWidth > 0.0f) - e.strokeWidth = strokeWidth; - - float opacity = element.getFloatAttribute ("opacity", -1.0f); - if (opacity >= 0.0f && opacity <= 1.0f) - e.opacity = opacity; - - String clipPath = element.getStringAttribute ("clip-path"); - if (clipPath.isNotEmpty()) + if (marker.viewBox + && marker.viewBox->getWidth() > 0.0f + && marker.viewBox->getHeight() > 0.0f) { - String clipPathUrl = extractGradientUrl (clipPath); - if (clipPathUrl.isNotEmpty()) - e.clipPathUrl = clipPathUrl; + const float scaleX = marker.markerWidth / marker.viewBox->getWidth(); + const float scaleY = marker.markerHeight / marker.viewBox->getHeight(); + scale *= std::min (scaleX, scaleY); } - // Parse stroke-dasharray - String dashArray = element.getStringAttribute ("stroke-dasharray"); - if (dashArray.isNotEmpty() && dashArray != "none") - { - auto dashValues = StringArray::fromTokens (dashArray, " ,", ""); - if (! dashValues.isEmpty()) - { - Array dashes; - for (const auto& dash : dashValues) - { - float value = parseUnit (dash); - if (value >= 0.0f) - dashes.add (value); - } + // Build the marker transform: T(position) * R(angle) * S(scale) * T(-refX, -refY) + // Each followedBy call appends a transform that is applied AFTER the current one. + const float angle = marker.orient ? degreesToRadians (*marker.orient) : tangentAngle; - if (! dashes.isEmpty()) - e.strokeDashArray = dashes; - } - } + const AffineTransform markerTransform = AffineTransform::translation (-marker.refX, -marker.refY) + .followedBy (AffineTransform::scaling (scale)) + .followedBy (AffineTransform::rotation (angle)) + .followedBy (AffineTransform::translation (position.getX(), position.getY())); - // Parse stroke-dashoffset - String dashOffset = element.getStringAttribute ("stroke-dashoffset"); - if (dashOffset.isNotEmpty()) - e.strokeDashOffset = parseUnit (dashOffset); - - // Parse fill-opacity - float fillOpacity = element.getFloatAttribute ("fill-opacity", -1.0f); - if (fillOpacity >= 0.0f && fillOpacity <= 1.0f) - e.fillOpacity = fillOpacity; - - // Parse stroke-opacity - float strokeOpacity = element.getFloatAttribute ("stroke-opacity", -1.0f); - if (strokeOpacity >= 0.0f && strokeOpacity <= 1.0f) - e.strokeOpacity = strokeOpacity; - - // Parse fill-rule - String fillRule = element.getStringAttribute ("fill-rule"); - if (fillRule == "evenodd" || fillRule == "nonzero") - e.fillRule = fillRule; + g.addTransform (markerTransform); + + for (const auto& element : marker.elements) + paintElement (g, data, *element, true, false, Colors::black, visitingElements, recursionDepth + 1); } //============================================================================== -AffineTransform Drawable::parseTransform (const XmlElement& element, const AffineTransform& currentTransform, Element& e) +void Drawable::paintPatternFill (Graphics& g, + const SVGData& data, + const Path& shape, + const SVGElement& element, + const SVGPattern& pattern, + Color currentColor, + std::unordered_set& visitingElements, + int recursionDepth) { - AffineTransform result; + float tileW = pattern.width; + float tileH = pattern.height; + float originX = pattern.x; + float originY = pattern.y; - if (auto transformString = element.getStringAttribute ("transform"); transformString.isNotEmpty()) + if (pattern.patternUnits == SVGPattern::ObjectBoundingBox) { - result = parseTransform (transformString); - - e.transform = result; - e.localTransform = result; // Store the local transform separately for use by elements - - YUP_DRAWABLE_LOG ("Parsed element transform: " << result.toString()); + const auto bounds = shape.getBounds(); + tileW *= bounds.getWidth(); + tileH *= bounds.getHeight(); + originX = bounds.getX() + pattern.x * bounds.getWidth(); + originY = bounds.getY() + pattern.y * bounds.getHeight(); } - return currentTransform.followedBy (result); -} - -//============================================================================== - -AffineTransform Drawable::parseTransform (const String& transformString) -{ - if (transformString.isEmpty()) - return AffineTransform::identity(); + if (tileW <= 0.0f || tileH <= 0.0f) + return; - AffineTransform result; - auto data = transformString.getCharPointer(); + const auto savedState = g.saveState(); - while (! data.isEmpty()) + // Clip rendering to the filled shape { - // Skip whitespace - while (data.isWhitespace()) - ++data; - - if (data.isEmpty()) - break; + auto clipTransform = g.getTransform().translated (g.getDrawingArea().getTopLeft()); + auto transformedShape = shape.transformed (clipTransform); + const auto savedClipTransform = g.getTransform(); + g.setTransform (AffineTransform::identity()); + g.setClipPath (transformedShape); + g.setTransform (savedClipTransform); + } - // Parse transform type - String type; - while (! data.isEmpty() && CharacterFunctions::isLetter (*data)) - { - type += *data; - ++data; - } + if (! pattern.patternTransform.isIdentity()) + g.addTransform (pattern.patternTransform); - // Skip whitespace and the opening parenthesis - while (data.isWhitespace() || *data == '(') - ++data; + const auto shapeBounds = shape.getBounds(); + const float startX = std::floor ((shapeBounds.getX() - originX) / tileW) * tileW + originX; + const float startY = std::floor ((shapeBounds.getY() - originY) / tileH) * tileH + originY; - // Parse parameters - Array params; - while (! data.isEmpty() && *data != ')') + for (float tileY = startY; tileY < shapeBounds.getBottom(); tileY += tileH) + { + for (float tileX = startX; tileX < shapeBounds.getRight(); tileX += tileW) { - if (*data == ',' || *data == ' ') - { - ++data; - continue; - } + const auto savedTileState = g.saveState(); - String number; - while (! data.isEmpty() && (*data == '-' || *data == '.' || *data == 'e' || (*data >= '0' && *data <= '9'))) + g.addTransform (AffineTransform::translation (tileX, tileY)); + + if (pattern.viewBox + && pattern.viewBox->getWidth() > 0.0f + && pattern.viewBox->getHeight() > 0.0f) { - number += *data; - ++data; + const float scaleX = tileW / pattern.viewBox->getWidth(); + const float scaleY = tileH / pattern.viewBox->getHeight(); + g.addTransform (AffineTransform::scaling (scaleX, scaleY) + .translated (-pattern.viewBox->getX(), -pattern.viewBox->getY())); } - if (! number.isEmpty()) - params.add (number.getFloatValue()); - - // Skip whitespace or commas - while (data.isWhitespace() || *data == ',') - ++data; - } - - // Skip the closing parenthesis - if (*data == ')') - ++data; - - // Apply the parsed transform - // SVG transforms are post-multiplied (applied left-to-right), so we use prependedBy - // to append each new transform on the right: result = result * newTransform - if (type == "translate" && (params.size() == 1 || params.size() == 2)) - { - const auto tx = params[0]; - const auto ty = (params.size() == 2) ? params[1] : 0.0f; - result = result.prependedBy (AffineTransform::translation (tx, ty)); - } - else if (type == "scale" && (params.size() == 1 || params.size() == 2)) - { - const auto sx = params[0]; - const auto sy = (params.size() == 2) ? params[1] : params[0]; - result = result.prependedBy (AffineTransform::scaling (sx, sy)); - } - else if (type == "rotate" && (params.size() == 1 || params.size() == 3)) - { - if (params.size() == 1) - result = result.prependedBy (AffineTransform::rotation (degreesToRadians (params[0]))); - else - result = result.prependedBy (AffineTransform::rotation (degreesToRadians (params[0]), params[1], params[2])); - } - else if (type == "skewX" && params.size() == 1) - { - result = result.prependedBy (AffineTransform::shearing (tanf (degreesToRadians (params[0])), 0.0f)); - } - else if (type == "skewY" && params.size() == 1) - { - result = result.prependedBy (AffineTransform::shearing (0.0f, tanf (degreesToRadians (params[0])))); - } - else if (type == "matrix" && params.size() == 6) - { - result = result.prependedBy (AffineTransform ( - params[0], params[2], params[4], params[1], params[3], params[5])); + for (const auto& patternElement : pattern.elements) + paintElement (g, data, *patternElement, true, false, currentColor, visitingElements, recursionDepth + 1); } } - - return result; } //============================================================================== -void Drawable::paintDebugElement (Graphics& g, const Element& element) +void Drawable::paintDebugElement (Graphics& g, const SVGElement& element) { if (! element.path) return; @@ -978,626 +1051,227 @@ void Drawable::paintDebugElement (Graphics& g, const Element& element) //============================================================================== -void Drawable::parseGradient (const XmlElement& element) +Font Drawable::resolveFont (const SVGElement& element) const { - String id = element.getStringAttribute ("id"); - if (id.isEmpty()) - return; - - YUP_DRAWABLE_LOG ("Parsing gradient with ID: " << id); - - Gradient::Ptr gradient = new Gradient; - gradient->id = id; - gradient->start = { 0.0f, 0.0f }; - gradient->end = { 1.0f, 0.0f }; - gradient->center = { 0.5f, 0.5f }; - gradient->radius = 0.5f; - gradient->focal = gradient->center; - - auto parseCoordinate = [&element] (const String& name, float defaultValue, bool& hasValue) -> float - { - const auto value = element.getStringAttribute (name); - if (value.isEmpty()) - return defaultValue; - - hasValue = true; - - if (value.containsChar ('%')) - return value.upToFirstOccurrenceOf ("%", false, false).getFloatValue() / 100.0f; - - return value.getFloatValue(); - }; - - // Parse xlink:href reference - String href = element.getStringAttribute ("xlink:href"); - if (href.isNotEmpty() && href.startsWith ("#")) - { - gradient->href = href.substring (1); // Remove the # prefix - YUP_DRAWABLE_LOG ("Gradient references: " << gradient->href); - } - - if (element.hasTagName ("linearGradient")) - { - gradient->type = Gradient::Linear; - bool hasX1 = false, hasY1 = false, hasX2 = false, hasY2 = false; - gradient->start = { parseCoordinate ("x1", gradient->start.getX(), hasX1), parseCoordinate ("y1", gradient->start.getY(), hasY1) }; - gradient->end = { parseCoordinate ("x2", gradient->end.getX(), hasX2), parseCoordinate ("y2", gradient->end.getY(), hasY2) }; - gradient->hasStart = hasX1 || hasY1; - gradient->hasEnd = hasX2 || hasY2; - - YUP_DRAWABLE_LOG ("Linear gradient - start: (" << gradient->start.getX() << ", " << gradient->start.getY() << ") end: (" << gradient->end.getX() << ", " << gradient->end.getY() << ")"); - } - else if (element.hasTagName ("radialGradient")) - { - gradient->type = Gradient::Radial; - bool hasCx = false, hasCy = false, hasR = false; - bool hasFx = false, hasFy = false; - gradient->center = { parseCoordinate ("cx", gradient->center.getX(), hasCx), parseCoordinate ("cy", gradient->center.getY(), hasCy) }; - gradient->radius = parseCoordinate ("r", gradient->radius, hasR); - - auto fx = parseCoordinate ("fx", gradient->center.getX(), hasFx); - auto fy = parseCoordinate ("fy", gradient->center.getY(), hasFy); - gradient->focal = { fx, fy }; - gradient->hasCenter = hasCx || hasCy; - gradient->hasRadius = hasR; - gradient->hasFocal = hasFx || hasFy; - - YUP_DRAWABLE_LOG ("Radial gradient - center: (" << gradient->center.getX() << ", " << gradient->center.getY() << ") radius: " << gradient->radius); - } - - // Parse gradientUnits attribute - String gradientUnits = element.getStringAttribute ("gradientUnits"); - if (gradientUnits == "userSpaceOnUse") - { - gradient->units = Gradient::UserSpaceOnUse; - YUP_DRAWABLE_LOG ("Gradient units: userSpaceOnUse"); - } - else - { - gradient->units = Gradient::ObjectBoundingBox; - YUP_DRAWABLE_LOG ("Gradient units: objectBoundingBox (default)"); - } - - // Parse gradientTransform attribute - String gradientTransform = element.getStringAttribute ("gradientTransform"); - if (gradientTransform.isNotEmpty()) - { - YUP_DRAWABLE_LOG ("Parsing gradientTransform: " << gradientTransform); - gradient->transform = parseTransform (gradientTransform); - YUP_DRAWABLE_LOG ("Gradient transform: " << gradient->transform.toString()); - } - - // Parse gradient stops - for (auto* child = element.getFirstChildElement(); child != nullptr; child = child->getNextElement()) - { - if (child->hasTagName ("stop")) - { - GradientStop stop; - const auto offsetString = child->getStringAttribute ("offset"); - if (offsetString.containsChar ('%')) - stop.offset = offsetString.upToFirstOccurrenceOf ("%", false, false).getFloatValue() * 0.01f; - else - stop.offset = child->getFloatAttribute ("offset"); - - stop.offset = jlimit (0.0f, 1.0f, stop.offset); - - // First try to get stop-color from attributes - String stopColor = child->getStringAttribute ("stop-color"); - float stopOpacity = child->getFloatAttribute ("stop-opacity", 1.0f); - - // If not found in attributes, parse from CSS style - if (stopColor.isEmpty()) - { - String styleAttr = child->getStringAttribute ("style"); - if (styleAttr.isNotEmpty()) - { - YUP_DRAWABLE_LOG ("Parsing CSS style for gradient stop: " << styleAttr); + if (document == nullptr) + return Font().withHeight (element.fontSize.value_or (16.0f)); - // Parse CSS-style stop-color - auto declarations = StringArray::fromTokens (styleAttr, ";", ""); - for (const auto& declaration : declarations) - { - auto colonPos = declaration.indexOf (":"); - if (colonPos > 0) - { - String property = declaration.substring (0, colonPos).trim(); - String value = declaration.substring (colonPos + 1).trim(); - - if (property == "stop-color") - { - stopColor = value; - YUP_DRAWABLE_LOG ("Found stop-color in CSS: " << stopColor); - } - else if (property == "stop-opacity") - { - stopOpacity = value.getFloatValue(); - YUP_DRAWABLE_LOG ("Found stop-opacity in CSS: " << stopOpacity); - } - } - } - } - } - - if (stopColor.isNotEmpty()) - { - YUP_DRAWABLE_LOG ("Parsing color string: '" << stopColor << "' (length: " << stopColor.length() << ")"); - stop.color = Color::fromString (stopColor); - YUP_DRAWABLE_LOG ("Gradient stop - offset: " << stop.offset << " color: " << stopColor << " parsed: " << stop.color.toString()); - } + const auto& options = document->getParseOptions(); + const auto fontSize = element.fontSize.value_or (16.0f); + const auto fontWeight = element.fontWeight.value_or (400); + const auto fontItalic = element.fontItalic.value_or (false); - stop.opacity = stopOpacity; - - gradient->stops.push_back (stop); - } - } - - if (! gradient->stops.empty()) + if (options.fontResolver) { - std::sort (gradient->stops.begin(), gradient->stops.end(), [] (const GradientStop& a, const GradientStop& b) - { - return a.offset < b.offset; - }); - - // Ensure implicit first/last stops per SVG spec - if (gradient->stops.front().offset > 0.0f) - { - auto first = gradient->stops.front(); - first.offset = 0.0f; - gradient->stops.insert (gradient->stops.begin(), first); - } - - if (gradient->stops.back().offset < 1.0f) - { - auto last = gradient->stops.back(); - last.offset = 1.0f; - gradient->stops.push_back (last); - } + if (auto resolved = options.fontResolver (element.fontFamily.value_or (String()), fontSize, fontWeight, fontItalic)) + return resolved->withHeight (fontSize); } - YUP_DRAWABLE_LOG ("Gradient parsed with " << gradient->stops.size() << " stops"); - - gradients.push_back (gradient); - gradientsById.set (id, gradient); + return Font().withHeight (fontSize); } //============================================================================== -Drawable::Gradient::Ptr Drawable::getGradientById (const String& id) +void Drawable::renderTextElement (Graphics& g, const SVGElement& element) { - return gradientsById[id]; -} + if (! element.text || ! element.textPosition || element.text->isEmpty()) + return; -//============================================================================== + auto position = *element.textPosition; -Drawable::Gradient::Ptr Drawable::resolveGradient (Gradient::Ptr gradient) -{ - if (gradient == nullptr || gradient->href.isEmpty()) - return gradient; + if (element.textX && ! element.textX->isEmpty()) + position.setX (element.textX->getFirst()); + if (element.textY && ! element.textY->isEmpty()) + position.setY (element.textY->getFirst()); + if (element.textDx && ! element.textDx->isEmpty()) + position.setX (position.getX() + element.textDx->getFirst()); + if (element.textDy && ! element.textDy->isEmpty()) + position.setY (position.getY() + element.textDy->getFirst()); - auto referencedGradient = getGradientById (gradient->href); - if (referencedGradient == nullptr) + const auto font = resolveFont (element); + const auto fontSize = element.fontSize.value_or (16.0f); + + StyledText styledText; { - YUP_DRAWABLE_LOG ("Referenced gradient not found: " << gradient->href); - return gradient; + auto modifier = styledText.startUpdate(); + modifier.setMaxSize (Size (jmax (fontSize, static_cast (element.text->length()) * fontSize * 2.0f), + fontSize * 4.0f)); + modifier.setWrap (StyledText::noWrap); + modifier.setHorizontalAlign (StyledText::left); + modifier.setVerticalAlign (StyledText::top); + modifier.appendText (*element.text, font, -1.0f, element.letterSpacing.value_or (0.0f)); } - // Recursively resolve the referenced gradient first - referencedGradient = resolveGradient (referencedGradient); - - // Create a new gradient that inherits from the referenced gradient - Gradient::Ptr resolvedGradient = new Gradient; - - // Copy properties from referenced gradient - resolvedGradient->type = referencedGradient->type; - resolvedGradient->id = gradient->id; // Keep the original ID - resolvedGradient->units = referencedGradient->units; - resolvedGradient->start = referencedGradient->start; - resolvedGradient->end = referencedGradient->end; - resolvedGradient->center = referencedGradient->center; - resolvedGradient->radius = referencedGradient->radius; - resolvedGradient->focal = referencedGradient->focal; - resolvedGradient->transform = referencedGradient->transform; - resolvedGradient->stops = referencedGradient->stops; - - // Override with properties from the current gradient (if specified) - if (gradient->hasStart) - resolvedGradient->start = gradient->start; - if (gradient->hasEnd) - resolvedGradient->end = gradient->end; - if (gradient->hasCenter) - resolvedGradient->center = gradient->center; - if (gradient->hasRadius) - resolvedGradient->radius = gradient->radius; - if (gradient->hasFocal) - resolvedGradient->focal = gradient->focal; - - if (! gradient->transform.isIdentity()) - resolvedGradient->transform = gradient->transform; - if (gradient->units != Gradient::ObjectBoundingBox) // Only override if explicitly set - resolvedGradient->units = gradient->units; - if (! gradient->stops.empty()) // Use local stops if defined - resolvedGradient->stops = gradient->stops; - - YUP_DRAWABLE_LOG ("Resolved gradient " << gradient->id << " from reference " << gradient->href); - return resolvedGradient; + const auto computedTextBounds = styledText.getComputedTextBounds(); + const auto fontAscent = font.getAscent(); + const auto fontDescent = font.getDescent(); + const auto hasUsableFontMetrics = fontAscent < 0.0f && fontDescent > fontAscent; + const auto ascent = hasUsableFontMetrics ? fontAscent : -0.8f; + const auto descent = hasUsableFontMetrics ? fontDescent : 0.2f; + const auto metricsHeight = (descent - ascent) * fontSize; + const auto textWidth = jmax (fontSize, computedTextBounds.getWidth()); + const auto textHeight = jmax (computedTextBounds.getHeight(), metricsHeight); + const auto bottomPadding = fontSize * 0.25f; + + auto textX = position.getX(); + if (element.textAnchor == "middle") + textX -= textWidth * 0.5f; + else if (element.textAnchor == "end") + textX -= textWidth; + + Rectangle textBounds (textX, + position.getY() + (ascent * fontSize), + textWidth, + textHeight + bottomPadding); + + g.fillFittedText (styledText, textBounds); } //============================================================================== -ColorGradient Drawable::createColorGradientFromSVG (const Gradient& gradient, const Rectangle* objectBounds) +void Drawable::renderImageElement (Graphics& g, const SVGElement& element) { - YUP_DRAWABLE_LOG ("Creating ColorGradient from SVG gradient ID: " << gradient.id << " type: " << (gradient.type == Gradient::Linear ? "Linear" : "Radial") << " units: " << (gradient.units == Gradient::UserSpaceOnUse ? "userSpaceOnUse" : "objectBoundingBox")); - - if (gradient.stops.empty()) - { - YUP_DRAWABLE_LOG ("No stops in gradient, returning empty"); - return ColorGradient(); - } - - // Ensure we always have a valid bounds transform for objectBoundingBox gradients - const bool hasBounds = objectBounds != nullptr && objectBounds->getWidth() > 0.0f && objectBounds->getHeight() > 0.0f; - AffineTransform unitsTransform = AffineTransform::identity(); - - if (gradient.units == Gradient::ObjectBoundingBox && hasBounds) - { - // Normalize gradient space to the element bounds (0..1 -> bounds) - unitsTransform = AffineTransform::translation (objectBounds->getX(), objectBounds->getY()) - .scaled (objectBounds->getWidth(), objectBounds->getHeight()); - } - - // Per SVG spec, gradientUnits are applied first, then gradientTransform - const AffineTransform gradientSpaceTransform = unitsTransform.followedBy (gradient.transform); - - // Helper to apply transforms to a point - auto transformPoint = [&gradientSpaceTransform] (Point p) - { - float x = p.getX(); - float y = p.getY(); - if (! gradientSpaceTransform.isIdentity()) - gradientSpaceTransform.transformPoint (x, y); - return Point (x, y); - }; - - // Prepare start/end/center after transforms (in local space; Graphics will apply viewport transforms) - const Point start = transformPoint (gradient.start); - const Point end = transformPoint (gradient.end); - const Point center = transformPoint (gradient.center); + if (! element.imageBounds) + return; - // Compute radial radius in transformed space - auto computeRadius = [&]() -> float + auto drawImage = [this, &g, &element] (const Image& image) { - if (gradient.radius <= 0.0f) - return 0.0f; - - const auto edgePoint = transformPoint (Point (gradient.center.getX() + gradient.radius, gradient.center.getY())); - return Line (center, edgePoint).length(); + if (! image.isValid()) + return; + + const Rectangle imageSourceBounds (0.0f, 0.0f, static_cast (image.getWidth()), static_cast (image.getHeight())); + const auto imageTransform = calculateTransformForTarget (imageSourceBounds, + *element.imageBounds, + element.preserveAspectRatioFitting, + element.preserveAspectRatioJustification); + const auto fittedImageBounds = imageSourceBounds.transformed (imageTransform); + + const auto savedState = g.saveState(); + g.setClipPath (*element.imageBounds); + g.drawImage (image, fittedImageBounds); }; - const auto radius = gradient.type == Gradient::Radial ? computeRadius() : 0.0f; - - // Build color stops in gradient space - std::vector colorStops; - colorStops.reserve (gradient.stops.size()); - - for (const auto& stop : gradient.stops) + if (element.image) { - Color color = stop.color.withMultipliedAlpha (stop.opacity); - - if (gradient.type == Gradient::Linear) - { - const auto interpolated = Point (start.getX() + stop.offset * (end.getX() - start.getX()), - start.getY() + stop.offset * (end.getY() - start.getY())); - - colorStops.emplace_back (color, interpolated, stop.offset); - } - else - { - // Radial gradient: position lies along the radius vector to preserve radius computation - const auto radialPoint = Point (center.getX() + radius * stop.offset, center.getY()); - colorStops.emplace_back (color, radialPoint, stop.offset); - } - } - - ColorGradient::Type type = (gradient.type == Gradient::Linear) ? ColorGradient::Linear : ColorGradient::Radial; - ColorGradient result (type, colorStops); - - YUP_DRAWABLE_LOG ("Created ColorGradient with " << colorStops.size() << " stops"); - return result; -} - -//============================================================================== - -void Drawable::parseClipPath (const XmlElement& element) -{ - String id = element.getStringAttribute ("id"); - if (id.isEmpty()) + drawImage (*element.image); return; + } - ClipPath::Ptr clipPath = new ClipPath; - clipPath->id = id; - - // Parse child elements that make up the clipping path - for (auto* child = element.getFirstChildElement(); child != nullptr; child = child->getNextElement()) + if (element.imageHref) { - Element::Ptr clipElement = new Element; - - if (child->hasTagName ("path")) - { - auto path = Path(); - String pathData = child->getStringAttribute ("d"); - if (pathData.isNotEmpty() && path.fromString (pathData)) - clipElement->path = std::move (path); - } - else if (child->hasTagName ("rect")) + if (document != nullptr) { - auto x = child->getFloatAttribute ("x"); - auto y = child->getFloatAttribute ("y"); - auto width = child->getFloatAttribute ("width"); - auto height = child->getFloatAttribute ("height"); - - auto path = Path(); - path.addRectangle (x, y, width, height); - clipElement->path = std::move (path); - } - else if (child->hasTagName ("circle")) - { - auto cx = child->getFloatAttribute ("cx"); - auto cy = child->getFloatAttribute ("cy"); - auto r = child->getFloatAttribute ("r"); - - auto path = Path(); - path.addCenteredEllipse (cx, cy, r, r); - clipElement->path = std::move (path); + if (auto image = SVGParser::loadImageFromHref (document->getParseOptions(), *element.imageHref)) + drawImage (*image); } - - if (clipElement->path) - clipPath->elements.push_back (clipElement); } - - clipPaths.push_back (clipPath); - clipPathsById.set (id, clipPath); -} - -//============================================================================== - -Drawable::ClipPath::Ptr Drawable::getClipPathById (const String& id) -{ - return clipPathsById[id]; } //============================================================================== -void Drawable::parseCSSStyle (const String& styleString, Element& e) +Path Drawable::createDashedPath (const Path& source, const Array& dashArray, float dashOffset) const { - // Parse CSS style declarations separated by semicolons - auto declarations = StringArray::fromTokens (styleString, ";", ""); + if (dashArray.isEmpty()) + return source; - for (const auto& declaration : declarations) + Array positiveDashes; + for (auto dash : dashArray) { - auto colonPos = declaration.indexOf (":"); - if (colonPos > 0) - { - String property = declaration.substring (0, colonPos).trim(); - String value = declaration.substring (colonPos + 1).trim(); - - if (property == "fill") - { - if (value != "none") - { - String gradientUrl = extractGradientUrl (value); - if (gradientUrl.isNotEmpty()) - e.fillUrl = gradientUrl; - else - e.fillColor = Color::fromString (value); - } - else - { - e.noFill = true; - } - } - else if (property == "stroke") - { - if (value != "none") - { - String gradientUrl = extractGradientUrl (value); - if (gradientUrl.isNotEmpty()) - e.strokeUrl = gradientUrl; - else - e.strokeColor = Color::fromString (value); - } - else - { - e.noStroke = true; - } - } - else if (property == "stroke-width") - { - float strokeWidth = value.getFloatValue(); - if (strokeWidth > 0.0f) - e.strokeWidth = strokeWidth; - } - else if (property == "stroke-linejoin") - { - if (value == "round") - e.strokeJoin = StrokeJoin::Round; - else if (value == "miter") - e.strokeJoin = StrokeJoin::Miter; - else if (value == "bevel") - e.strokeJoin = StrokeJoin::Bevel; - } - else if (property == "stroke-linecap") - { - if (value == "round") - e.strokeCap = StrokeCap::Round; - else if (value == "square") - e.strokeCap = StrokeCap::Square; - else if (value == "butt") - e.strokeCap = StrokeCap::Butt; - } - else if (property == "opacity") - { - float opacity = value.getFloatValue(); - if (opacity >= 0.0f && opacity <= 1.0f) - e.opacity = opacity; - } - else if (property == "font-family") - { - e.fontFamily = value; - } - else if (property == "font-size") - { - float fontSize = value.getFloatValue(); - if (fontSize > 0.0f) - e.fontSize = fontSize; - } - else if (property == "text-anchor") - { - e.textAnchor = value; - } - else if (property == "clip-path") - { - String clipPathUrl = extractGradientUrl (value); - if (clipPathUrl.isNotEmpty()) - e.clipPathUrl = clipPathUrl; - } - else if (property == "stroke-dasharray") - { - if (value != "none") - { - auto dashValues = StringArray::fromTokens (value, " ,", ""); - if (! dashValues.isEmpty()) - { - Array dashes; - for (const auto& dash : dashValues) - { - float dashValue = parseUnit (dash); - if (dashValue >= 0.0f) - dashes.add (dashValue); - } - - if (! dashes.isEmpty()) - e.strokeDashArray = dashes; - } - } - } - else if (property == "stroke-dashoffset") - { - e.strokeDashOffset = parseUnit (value); - } - else if (property == "fill-opacity") - { - float opacity = value.getFloatValue(); - if (opacity >= 0.0f && opacity <= 1.0f) - e.fillOpacity = opacity; - } - else if (property == "stroke-opacity") - { - float opacity = value.getFloatValue(); - if (opacity >= 0.0f && opacity <= 1.0f) - e.strokeOpacity = opacity; - } - else if (property == "fill-rule") - { - if (value == "evenodd" || value == "nonzero") - e.fillRule = value; - } - } + if (dash > 0.0f) + positiveDashes.add (dash); } -} -//============================================================================== + if (positiveDashes.isEmpty()) + return source; -float Drawable::parseUnit (const String& value, float defaultValue, float fontSize, float viewportSize) -{ - if (value.isEmpty()) - return defaultValue; + Path result; + float totalPatternLength = 0.0f; + for (auto dash : positiveDashes) + totalPatternLength += dash; - String trimmed = value.trim(); - if (trimmed.isEmpty()) - return defaultValue; + if (totalPatternLength <= 0.0f) + return source; - // Extract numeric part and unit - int unitStart = 0; - while (unitStart < trimmed.length() && (CharacterFunctions::isDigit (trimmed[unitStart]) || trimmed[unitStart] == '.' || trimmed[unitStart] == '-' || trimmed[unitStart] == '+')) + int dashIndex = 0; + float patternPosition = std::fmod (jmax (0.0f, dashOffset), totalPatternLength); + while (patternPosition > positiveDashes[dashIndex]) { - unitStart++; + patternPosition -= positiveDashes[dashIndex]; + dashIndex = (dashIndex + 1) % positiveDashes.size(); } - float numericValue = trimmed.substring (0, unitStart).getFloatValue(); - String unit = trimmed.substring (unitStart).trim().toLowerCase(); - - // Handle different SVG units - if (unit.isEmpty() || unit == "px") - return numericValue; // Default user units or pixels - - else if (unit == "pt") - return numericValue * 1.333333f; // 1pt = 1.333px - - else if (unit == "pc") - return numericValue * 16.0f; // 1pc = 16px - - else if (unit == "mm") - return numericValue * 3.779528f; // 1mm = 3.779528px (96 DPI) - - else if (unit == "cm") - return numericValue * 37.79528f; // 1cm = 37.79528px (96 DPI) - - else if (unit == "in") - return numericValue * 96.0f; // 1in = 96px (96 DPI) - - else if (unit == "em") - return numericValue * fontSize; // Relative to font size - - else if (unit == "ex") - return numericValue * fontSize * 0.5f; // Approximately 0.5em - - else if (unit == "%") - return numericValue * viewportSize * 0.01f; // Percentage of viewport + auto drawLineDash = [&] (Point start, Point end) + { + const auto length = start.distanceTo (end); + if (length <= 0.0f) + return; - else - return numericValue; // Unknown unit, treat as user units -} + auto direction = (end - start) / length; + float distance = 0.0f; -//============================================================================== + while (distance < length) + { + const auto remainingInDash = positiveDashes[dashIndex] - patternPosition; + const auto step = jmin (remainingInDash, length - distance); -Rectangle Drawable::calculateBounds() const -{ - // Use viewBox if available, otherwise use size - if (! viewBox.isEmpty()) - return viewBox; + if ((dashIndex % 2) == 0 && step > 0.0f) + { + auto dashStart = start + direction * distance; + auto dashEnd = start + direction * (distance + step); + result.startNewSubPath (dashStart); + result.lineTo (dashEnd); + } - if (size.getWidth() > 0 && size.getHeight() > 0) - return Rectangle (0, 0, size.getWidth(), size.getHeight()); + distance += step; + patternPosition = 0.0f; + dashIndex = (dashIndex + 1) % positiveDashes.size(); + } + }; - // Fallback: calculate bounds from all elements with their transforms applied - // This gives us the actual visual bounds of the rendered content - Rectangle bounds; - bool hasValidBounds = false; + Point current; + Point subPathStart; + bool hasCurrent = false; - for (const auto& element : elements) + for (const auto& segment : source) { - if (element->path) + switch (segment.verb) { - auto pathBounds = element->path->getBounds(); - if (element->transform) - pathBounds = element->path->getBoundsTransformed (*element->transform); - - if (hasValidBounds) - bounds = bounds.unionWith (pathBounds); - else - { - bounds = pathBounds; - hasValidBounds = true; - } + case Path::Verb::MoveTo: + current = segment.point; + subPathStart = current; + hasCurrent = true; + break; + + case Path::Verb::LineTo: + if (hasCurrent) + drawLineDash (current, segment.point); + current = segment.point; + break; + + case Path::Verb::Close: + if (hasCurrent) + drawLineDash (current, subPathStart); + current = subPathStart; + break; + + case Path::Verb::QuadTo: + case Path::Verb::CubicTo: + if (hasCurrent) + drawLineDash (current, segment.point); + current = segment.point; + break; } } - return hasValidBounds ? bounds : Rectangle (0, 0, 100, 100); + return result; } //============================================================================== -AffineTransform Drawable::calculateTransformForTarget (const Rectangle& sourceBounds, const Rectangle& targetArea, Fitting fitting, Justification justification) const +AffineTransform Drawable::calculateTransformForTarget (const Rectangle& sourceBounds, + const Rectangle& targetArea, + Fitting fitting, + Justification justification) const { if (sourceBounds.isEmpty() || targetArea.isEmpty()) return AffineTransform::identity(); @@ -1605,7 +1279,6 @@ AffineTransform Drawable::calculateTransformForTarget (const Rectangle& s float scaleX = targetArea.getWidth() / sourceBounds.getWidth(); float scaleY = targetArea.getHeight() / sourceBounds.getHeight(); - // Apply scaling based on fitting mode switch (fitting) { case Fitting::none: @@ -1613,66 +1286,58 @@ AffineTransform Drawable::calculateTransformForTarget (const Rectangle& s break; case Fitting::scaleToFit: - scaleX = scaleY = jmin (scaleX, scaleY); // Scale to fit both dimensions + scaleX = scaleY = jmin (scaleX, scaleY); break; case Fitting::fitWidth: - scaleY = scaleX; // Scale to fit width, preserve aspect ratio + scaleY = scaleX; break; case Fitting::fitHeight: - scaleX = scaleY; // Scale to fit height, preserve aspect ratio + scaleX = scaleY; break; case Fitting::scaleToFill: case Fitting::centerCrop: - scaleX = scaleY = jmax (scaleX, scaleY); // Scale to fill, may crop + scaleX = scaleY = jmax (scaleX, scaleY); break; case Fitting::fill: - // Use calculated scales as-is (non-uniform scaling) break; case Fitting::centerInside: - // Like scaleToFit but don't upscale beyond original size scaleX = scaleY = jmin (1.0f, jmin (scaleX, scaleY)); break; case Fitting::stretchWidth: - scaleY = 1.0f; // Stretch horizontally only + scaleY = 1.0f; break; case Fitting::stretchHeight: - scaleX = 1.0f; // Stretch vertically only + scaleX = 1.0f; break; case Fitting::tile: - // For tile mode, use no scaling (tiling would be handled elsewhere) scaleX = scaleY = 1.0f; break; } - // Calculate scaled size float scaledWidth = sourceBounds.getWidth() * scaleX; float scaledHeight = sourceBounds.getHeight() * scaleY; - // Calculate offset based on justification float offsetX = targetArea.getX(); float offsetY = targetArea.getY(); - // Horizontal justification if (justification.testFlags (Justification::horizontalCenter)) offsetX += (targetArea.getWidth() - scaledWidth) * 0.5f; else if (justification.testFlags (Justification::right)) offsetX += targetArea.getWidth() - scaledWidth; - // Vertical justification if (justification.testFlags (Justification::verticalCenter)) offsetY += (targetArea.getHeight() - scaledHeight) * 0.5f; else if (justification.testFlags (Justification::bottom)) offsetY += targetArea.getHeight() - scaledHeight; - // Create transform: translate to origin, scale, then translate to target position return AffineTransform::translation (-sourceBounds.getX(), -sourceBounds.getY()) .scaled (scaleX, scaleY) .translated (offsetX, offsetY); @@ -1680,68 +1345,157 @@ AffineTransform Drawable::calculateTransformForTarget (const Rectangle& s //============================================================================== -Fitting Drawable::parsePreserveAspectRatio (const String& preserveAspectRatio) +ColorGradient Drawable::createColorGradientFromSVG (const SVGGradient& gradient, const Rectangle* objectBounds) const { - if (preserveAspectRatio.isEmpty() || preserveAspectRatio == "xMidYMid meet") - return Fitting::scaleToFit; // Default SVG behavior + YUP_DRAWABLE_LOG ("Creating ColorGradient from SVG gradient ID: " << gradient.id + << " type: " << (gradient.type == SVGGradient::Linear ? "Linear" : "Radial") + << " units: " << (gradient.units == SVGGradient::UserSpaceOnUse ? "userSpaceOnUse" : "objectBoundingBox")); - if (preserveAspectRatio.contains ("none")) - return Fitting::fill; // Non-uniform scaling allowed + if (gradient.stops.empty()) + { + YUP_DRAWABLE_LOG ("No stops in gradient, returning empty"); + return ColorGradient(); + } - if (preserveAspectRatio.contains ("slice")) - return Fitting::scaleToFill; // Scale to fill, may crop + const bool hasBounds = objectBounds != nullptr && objectBounds->getWidth() > 0.0f && objectBounds->getHeight() > 0.0f; + AffineTransform unitsTransform = AffineTransform::identity(); - // Default to uniform scaling (meet) - return Fitting::scaleToFit; -} + if (gradient.units == SVGGradient::ObjectBoundingBox && hasBounds) + { + unitsTransform = AffineTransform::translation (objectBounds->getX(), objectBounds->getY()) + .scaled (objectBounds->getWidth(), objectBounds->getHeight()); + } -Justification Drawable::parseAspectRatioAlignment (const String& preserveAspectRatio) -{ - if (preserveAspectRatio.isEmpty()) - return Justification::center; // Default SVG alignment - - Justification result = Justification::left; - - // Parse horizontal alignment - if (preserveAspectRatio.contains ("xMin")) - result = result | Justification::left; - else if (preserveAspectRatio.contains ("xMax")) - result = result | Justification::right; - else // xMid (default) - result = result | Justification::horizontalCenter; - - // Parse vertical alignment - if (preserveAspectRatio.contains ("YMin")) - result = result | Justification::top; - else if (preserveAspectRatio.contains ("YMax")) - result = result | Justification::bottom; - else // YMid (default) - result = result | Justification::verticalCenter; + const AffineTransform gradientSpaceTransform = unitsTransform.followedBy (gradient.transform); - return result; -} + auto transformPoint = [&gradientSpaceTransform] (Point p) + { + float x = p.getX(); + float y = p.getY(); + if (! gradientSpaceTransform.isIdentity()) + gradientSpaceTransform.transformPoint (x, y); + return Point (x, y); + }; -//============================================================================== + const Point start = transformPoint (gradient.start); + const Point end = transformPoint (gradient.end); + const Point center = transformPoint (gradient.center); -String Drawable::extractGradientUrl (const String& value) -{ - if (! value.contains ("url(#")) - return String(); - - // Find the start of the URL - int urlStart = value.indexOf ("url(#"); - if (urlStart == -1) - return String(); - - // Find the end of the URL (first closing parenthesis after the URL start) - int urlEnd = value.indexOf (urlStart, ")"); - if (urlEnd == -1) - return String(); - - // Extract the ID part (between "url(#" and ")") - String url = value.substring (urlStart + 5, urlEnd); // +5 to skip "url(#" - YUP_DRAWABLE_LOG ("Extracted gradient URL: '" << url << "' from: '" << value << "'"); - return url; + auto computeRadius = [&]() -> float + { + if (gradient.radius <= 0.0f) + return 0.0f; + + const Point edgePoints[] = { + transformPoint (Point (gradient.center.getX() + gradient.radius, gradient.center.getY())), + transformPoint (Point (gradient.center.getX() - gradient.radius, gradient.center.getY())), + transformPoint (Point (gradient.center.getX(), gradient.center.getY() + gradient.radius)), + transformPoint (Point (gradient.center.getX(), gradient.center.getY() - gradient.radius)) + }; + + float maxRadius = 0.0f; + for (const auto& edgePoint : edgePoints) + maxRadius = jmax (maxRadius, Line (center, edgePoint).length()); + + return maxRadius; + }; + + const auto radius = gradient.type == SVGGradient::Radial ? computeRadius() : 0.0f; + + std::vector colorStops; + colorStops.reserve (gradient.stops.size()); + + if (gradient.type == SVGGradient::Linear + && objectBounds != nullptr + && (gradient.spreadMethod == "reflect" || gradient.spreadMethod == "repeat")) + { + const auto dx = end.getX() - start.getX(); + const auto dy = end.getY() - start.getY(); + const auto lengthSquared = dx * dx + dy * dy; + + if (lengthSquared > 0.0f) + { + const Point corners[] = { + objectBounds->getTopLeft(), + objectBounds->getTopRight(), + objectBounds->getBottomLeft(), + objectBounds->getBottomRight() + }; + + float minT = 0.0f; + float maxT = 1.0f; + + for (const auto& corner : corners) + { + const auto t = ((corner.getX() - start.getX()) * dx + (corner.getY() - start.getY()) * dy) / lengthSquared; + minT = jmin (minT, t); + maxT = jmax (maxT, t); + } + + int firstRepeat = static_cast (std::floor (minT)); + int lastRepeat = static_cast (std::ceil (maxT)); + + constexpr int maxGradientRepeats = 32; + if (lastRepeat - firstRepeat > maxGradientRepeats) + { + const auto centerRepeat = (firstRepeat + lastRepeat) / 2; + firstRepeat = centerRepeat - (maxGradientRepeats / 2); + lastRepeat = firstRepeat + maxGradientRepeats; + } + + const auto repeatStart = static_cast (firstRepeat); + const auto repeatEnd = static_cast (jmax (lastRepeat, firstRepeat + 1)); + const auto repeatRange = repeatEnd - repeatStart; + const auto expandedStart = Point (start.getX() + dx * repeatStart, start.getY() + dy * repeatStart); + const auto expandedEnd = Point (start.getX() + dx * repeatEnd, start.getY() + dy * repeatEnd); + + colorStops.reserve (gradient.stops.size() * static_cast (repeatEnd - repeatStart)); + + for (int repeat = firstRepeat; repeat < lastRepeat; ++repeat) + { + const bool reflected = gradient.spreadMethod == "reflect" && (std::abs (repeat) % 2) == 1; + + for (const auto& stop : gradient.stops) + { + const auto repeatedOffset = static_cast (repeat) + (reflected ? (1.0f - stop.offset) : stop.offset); + const auto normalizedOffset = (repeatedOffset - repeatStart) / repeatRange; + const auto position = Point (expandedStart.getX() + (expandedEnd.getX() - expandedStart.getX()) * normalizedOffset, + expandedStart.getY() + (expandedEnd.getY() - expandedStart.getY()) * normalizedOffset); + + colorStops.emplace_back (stop.color.withMultipliedAlpha (stop.opacity), position, jlimit (0.0f, 1.0f, normalizedOffset)); + } + } + + std::sort (colorStops.begin(), colorStops.end(), [] (const auto& a, const auto& b) + { + return a.delta < b.delta; + }); + } + } + + if (colorStops.empty()) + { + for (const auto& stop : gradient.stops) + { + Color color = stop.color.withMultipliedAlpha (stop.opacity); + + if (gradient.type == SVGGradient::Linear) + { + const auto interpolated = Point (start.getX() + stop.offset * (end.getX() - start.getX()), + start.getY() + stop.offset * (end.getY() - start.getY())); + + colorStops.emplace_back (color, interpolated, stop.offset); + } + else + { + const auto radialPoint = Point (center.getX() + radius * stop.offset, center.getY()); + colorStops.emplace_back (color, radialPoint, stop.offset); + } + } + } + + ColorGradient::Type type = (gradient.type == SVGGradient::Linear) ? ColorGradient::Linear : ColorGradient::Radial; + return ColorGradient (type, colorStops); } } // namespace yup diff --git a/modules/yup_graphics/drawables/yup_Drawable.h b/modules/yup_graphics/drawables/yup_Drawable.h index c8b6deb7d..358993a76 100644 --- a/modules/yup_graphics/drawables/yup_Drawable.h +++ b/modules/yup_graphics/drawables/yup_Drawable.h @@ -2,7 +2,7 @@ ============================================================================== This file is part of the YUP library. - Copyright (c) 2024 - kunitoki@gmail.com + Copyright (c) 2026 - kunitoki@gmail.com YUP is an open source library subject to open-source licensing. @@ -31,6 +31,9 @@ namespace yup class YUP_API Drawable { public: + /** Options used when parsing SVG data. Alias for SVGDocument::ParseOptions. */ + using ParseOptions = SVGDocument::ParseOptions; + //============================================================================== /** Constructor. */ Drawable(); @@ -44,6 +47,21 @@ class YUP_API Drawable */ bool parseSVG (const File& svgFile); + /** Parses an SVG file with custom parse options. */ + bool parseSVG (const File& svgFile, const ParseOptions& options); + + //============================================================================== + /** Parses SVG text. + + @param svgText The SVG XML text to parse. + + @return True if the SVG text was parsed successfully, false otherwise. + */ + bool parseSVG (StringRef svgText); + + /** Parses SVG text with custom parse options. */ + bool parseSVG (StringRef svgText, const ParseOptions& options); + //============================================================================== /** Clears the drawable. */ void clear(); @@ -76,148 +94,22 @@ class YUP_API Drawable Justification justification = Justification::center); private: - struct Element : public ReferenceCountedObject - { - using Ptr = ReferenceCountedObjectPtr; - - std::optional id; - - std::optional transform; - std::optional localTransform; // Transform from the element itself (not accumulated) - std::optional path; - std::optional reference; - - std::optional fillColor; - std::optional strokeColor; - std::optional fillOpacity; - std::optional strokeOpacity; - std::optional strokeWidth; - std::optional strokeJoin; - std::optional strokeCap; - std::optional> strokeDashArray; - std::optional strokeDashOffset; - std::optional fillRule; // "evenodd" or "nonzero" - bool noFill = false; - bool noStroke = false; - - std::optional opacity; - - // Text properties - std::optional text; - std::optional> textPosition; - std::optional fontFamily; - std::optional fontSize; - std::optional textAnchor; - - // Gradient properties - std::optional fillUrl; - std::optional strokeUrl; - - // Image properties - std::optional imageHref; - std::optional> imageBounds; - - // Clipping properties - std::optional clipPathUrl; - - std::vector children; - }; - - struct GradientStop - { - float offset; - Color color; - float opacity = 1.0f; - }; - - struct Gradient : public ReferenceCountedObject - { - using Ptr = ReferenceCountedObjectPtr; - - enum Type - { - Linear, - Radial - }; - - enum Units - { - UserSpaceOnUse, - ObjectBoundingBox - }; - - Type type; - String id; - Units units = ObjectBoundingBox; // Default per SVG spec - String href; // xlink:href reference to another gradient - - // Linear gradient properties - Point start; - Point end; - - // Radial gradient properties - Point center; - float radius = 0.0f; - Point focal; - - std::vector stops; - AffineTransform transform; - - bool hasStart = false; - bool hasEnd = false; - bool hasCenter = false; - bool hasRadius = false; - bool hasFocal = false; - }; - - struct ClipPath : public ReferenceCountedObject - { - using Ptr = ReferenceCountedObjectPtr; - - String id; - std::vector elements; - }; - - void paintElement (Graphics& g, const Element& element, bool hasParentFillEnabled, bool hasParentStrokeEnabled); - void paintDebugElement (Graphics& g, const Element& element); - bool parseElement (const XmlElement& element, bool parentIsRoot, AffineTransform currentTransform, Element* parent = nullptr); - void parseStyle (const XmlElement& element, const AffineTransform& currentTransform, Element& e); - AffineTransform parseTransform (const XmlElement& element, const AffineTransform& currentTransform, Element& e); - void parseGradient (const XmlElement& element); - Gradient::Ptr getGradientById (const String& id); - Gradient::Ptr resolveGradient (Gradient::Ptr gradient); - ColorGradient createColorGradientFromSVG (const Gradient& gradient, const Rectangle* objectBounds = nullptr); - void parseClipPath (const XmlElement& element); - ClipPath::Ptr getClipPathById (const String& id); - void parseCSSStyle (const String& styleString, Element& e); - float parseUnit (const String& value, float defaultValue = 0.0f, float fontSize = 12.0f, float viewportSize = 100.0f); - AffineTransform parseTransform (const String& transformString); - String extractGradientUrl (const String& value); - - // SVG preserveAspectRatio parsing - Fitting parsePreserveAspectRatio (const String& preserveAspectRatio); - Justification parseAspectRatioAlignment (const String& preserveAspectRatio); - - // Helper methods for layout and painting - Rectangle calculateBounds() const; - AffineTransform calculateTransformForTarget (const Rectangle& sourceBounds, const Rectangle& targetArea, Fitting fitting, Justification justification) const; - - Rectangle viewBox; - Size size; - Rectangle bounds; - AffineTransform transform; - std::vector elements; - HashMap elementsById; - std::vector gradients; - HashMap gradientsById; - std::vector clipPaths; - HashMap clipPathsById; - - // Root SVG element's default presentation attributes - bool rootHasFill = true; // SVG default fill is black - bool rootHasStroke = false; // SVG default stroke is none - std::optional rootFillColor; - std::optional rootStrokeColor; + void paintElement (Graphics& g, const SVGData& data, const SVGElement& element, bool hasParentFillEnabled, bool hasParentStrokeEnabled, Color currentColor, std::unordered_set& visitingElements, int recursionDepth = 0); + void paintMarker (Graphics& g, const SVGData& data, const SVGMarker& marker, float strokeWidth, Point position, float tangentAngle, std::unordered_set& visitingElements, int recursionDepth); + void paintPatternFill (Graphics& g, const SVGData& data, const Path& shape, const SVGElement& element, const SVGPattern& pattern, Color currentColor, std::unordered_set& visitingElements, int recursionDepth); + void paintDebugElement (Graphics& g, const SVGElement& element); + void renderTextElement (Graphics& g, const SVGElement& element); + void renderImageElement (Graphics& g, const SVGElement& element); + Path createDashedPath (const Path& source, const Array& dashArray, float dashOffset) const; + AffineTransform calculateTransformForTarget (const Rectangle& sourceBounds, + const Rectangle& targetArea, + Fitting fitting, + Justification justification) const; + Font resolveFont (const SVGElement& element) const; + ColorGradient createColorGradientFromSVG (const SVGGradient& gradient, + const Rectangle* objectBounds = nullptr) const; + + SVGDocument::Ptr document; }; } // namespace yup diff --git a/modules/yup_graphics/graphics/yup_Graphics.cpp b/modules/yup_graphics/graphics/yup_Graphics.cpp index 9200d3b27..3003d9e19 100644 --- a/modules/yup_graphics/graphics/yup_Graphics.cpp +++ b/modules/yup_graphics/graphics/yup_Graphics.cpp @@ -404,6 +404,10 @@ StrokeCap Graphics::getStrokeCap() const return currentRenderOptions().cap; } +void Graphics::setStrokeMiterLimit (float /*limit*/) +{ +} + //============================================================================== void Graphics::setBlendMode (BlendMode blendMode) { @@ -458,7 +462,7 @@ void Graphics::setClipPath (const Path& clipPath) options.clipPath = clipPath; auto renderPath = rive::make_rcp(); - renderPath->fillRule (rive::FillRule::nonZero); + renderPath->fillRule (clipPath.isUsingNonZeroWinding() ? rive::FillRule::nonZero : rive::FillRule::evenOdd); renderPath->addRenderPath (clipPath.getRenderPath(), options.getLocalTransform().toMat2D()); renderer.clipPath (renderPath.get()); @@ -642,6 +646,7 @@ void Graphics::renderStrokePath (const Path& path, const RenderOptions& options, paint.thickness (options.getStrokeWidth()); paint.join (toStrokeJoin (options.join)); paint.cap (toStrokeCap (options.cap)); + paint.feather (options.feather); if (options.isStrokeColor()) paint.color ((rive::ColorInt) options.getStrokeColor()); @@ -674,11 +679,19 @@ void Graphics::renderFillPath (const Path& path, const RenderOptions& options, c //============================================================================== void Graphics::drawImageAt (const Image& image, const Point& pos) +{ + drawImage (image, Rectangle (pos.getX(), pos.getY(), static_cast (image.getWidth()), static_cast (image.getHeight()))); +} + +void Graphics::drawImage (const Image& image, const Rectangle& targetArea) { auto renderContext = context.renderContext(); if (renderContext == nullptr) return; + if (targetArea.isEmpty()) + return; + if (! image.createTextureIfNotPresent (context)) return; @@ -690,6 +703,7 @@ void Graphics::drawImageAt (const Image& image, const Point& pos) unitRectPath->line ({ 1, 0 }); unitRectPath->line ({ 1, 1 }); unitRectPath->line ({ 0, 1 }); + unitRectPath->close(); return unitRectPath; }(); @@ -697,9 +711,12 @@ void Graphics::drawImageAt (const Image& image, const Point& pos) paint.image (image.getTexture(), jlimit (0.0f, 1.0f, options.opacity)); paint.blendMode (toBlendMode (options.blendMode)); + const auto imageTransform = AffineTransform::scaling (targetArea.getWidth(), targetArea.getHeight()) + .translated (targetArea.getX(), targetArea.getY()) + .followedBy (options.getTransform()); + renderer.save(); - renderer.scale (image.getWidth(), image.getHeight()); - renderer.transform (options.getTransform().toMat2D()); + renderer.transform (imageTransform.toMat2D()); renderer.drawPath (unitRectPath.get(), std::addressof (paint)); renderer.restore(); } @@ -793,13 +810,16 @@ void Graphics::renderFittedText (const StyledText& text, const Rectangle& renderer.save(); - rive::RawPath path; - path.addRect (rect.toAABB()); - path.transformInPlace (options.getFixedTransform().toMat2D()); - auto renderPath = rive::make_rcp (rive::FillRule::clockwise, path); - renderer.clipPath (renderPath.get()); + if (text.getOverflow() != StyledText::visible) + { + rive::RawPath path; + path.addRect (rect.toAABB()); + path.transformInPlace (options.getTransform().toMat2D()); + auto renderPath = rive::make_rcp (rive::FillRule::clockwise, path); + renderer.clipPath (renderPath.get()); + } - auto offset = text.getOffset (rect); // We will just use vertical offset + auto offset = text.getOffset (rect); // Horizontal alignment is already baked into the shaped glyph paths. auto transform = options.getTransform (rect.getX(), rect.getY() + offset.getY()); renderer.transform (transform.toMat2D()); diff --git a/modules/yup_graphics/graphics/yup_Graphics.h b/modules/yup_graphics/graphics/yup_Graphics.h index 69482ca2d..cbc44a298 100644 --- a/modules/yup_graphics/graphics/yup_Graphics.h +++ b/modules/yup_graphics/graphics/yup_Graphics.h @@ -209,6 +209,12 @@ class YUP_API Graphics */ StrokeCap getStrokeCap() const; + /** Sets the miter limit used when drawing stroked paths with miter joins. + The miter limit controls when miter joins are clipped to bevel joins. + The SVG default is 4.0. The value is clamped to a minimum of 1.0. + */ + void setStrokeMiterLimit (float limit); + //============================================================================== /** Sets the blend mode for subsequent drawing operations. @@ -454,6 +460,13 @@ class YUP_API Graphics */ void drawImageAt (const Image& image, const Point& pos); + /** Draws an image into a target rectangle. + + @param image The image to draw. + @param targetArea The destination rectangle in the current coordinate space. + */ + void drawImage (const Image& image, const Rectangle& targetArea); + //============================================================================== /** Draws an attributed text. @@ -538,7 +551,7 @@ class YUP_API Graphics bool isStrokeColorGradient() const noexcept { - return ! isCurrentFillColor; + return ! isCurrentStrokeColor; } ColorGradient getFillColorGradient() const noexcept @@ -588,8 +601,9 @@ class YUP_API Graphics AffineTransform getTransform (float offsetX, float offsetY) const noexcept { - return transform - .translated (drawingArea.getX() + offsetX, drawingArea.getY() + offsetY) + return AffineTransform::translation (offsetX, offsetY) + .followedBy (transform) + .translated (drawingArea.getX(), drawingArea.getY()) .scaled (scale); } diff --git a/modules/yup_graphics/primitives/yup_Path.cpp b/modules/yup_graphics/primitives/yup_Path.cpp index 9ff75d6c3..b87566e0b 100644 --- a/modules/yup_graphics/primitives/yup_Path.cpp +++ b/modules/yup_graphics/primitives/yup_Path.cpp @@ -31,7 +31,7 @@ namespace bool isControlMarker (String::CharPointerType data) { - return ! data.isEmpty() && String ("MmLlHhVvQqCcSsZz").containsChar (*data); + return ! data.isEmpty() && String ("MmLlHhVvQqTtCcSsAaZz").containsChar (*data); } void skipWhitespace (String::CharPointerType& data) @@ -50,80 +50,98 @@ void skipWhitespaceOrComma (String::CharPointerType& data) bool parseFlag (String::CharPointerType& data, int& flag) { - skipWhitespace (data); + skipWhitespaceOrComma (data); - String number; - - while (! data.isEmpty()) - { - if (data.isWhitespace() || *data == '.' || *data == ',' || *data == '-' || isControlMarker (data)) - break; - - if (! (*data >= '0' && *data <= '9')) - break; - - number += *data; - ++data; - } - - if (number.isNotEmpty()) - { - flag = number.getIntValue(); - - skipWhitespaceOrComma (data); - return true; - } + if (data.isEmpty() || (*data != '0' && *data != '1')) + return false; - return false; + flag = *data - '0'; + ++data; + skipWhitespaceOrComma (data); + return true; } //============================================================================== bool parseCoordinate (String::CharPointerType& data, float& coord) { - skipWhitespace (data); + skipWhitespaceOrComma (data); + + auto start = data; + + if (data.isEmpty() || isControlMarker (data)) + return false; String number; - bool isNegative = false; - bool pointFound = false; + bool hasDigits = false; - if (*data == '-') + if (*data == '-' || *data == '+') { - isNegative = true; + number += *data; ++data; } - while (! data.isEmpty()) + while (! data.isEmpty() && *data >= '0' && *data <= '9') { - if (data.isWhitespace() || *data == ',' || *data == '-' || isControlMarker (data)) - break; + hasDigits = true; + number += *data; + ++data; + } - if (*data == '.') - { - if (pointFound) - break; - pointFound = true; - } - else if (! (*data >= '0' && *data <= '9')) + if (! data.isEmpty() && *data == '.') + { + number += *data; + ++data; + + while (! data.isEmpty() && *data >= '0' && *data <= '9') { - break; + hasDigits = true; + number += *data; + ++data; } + } - number += *data; - ++data; + if (! hasDigits) + { + data = start; + return false; } - if (number.isNotEmpty()) + if (! data.isEmpty() && (*data == 'e' || *data == 'E')) { - coord = number.getFloatValue(); - if (isNegative) - coord = -coord; + auto exponentStart = data; + String exponent; - skipWhitespaceOrComma (data); - return true; + exponent += *data; + ++data; + + if (! data.isEmpty() && (*data == '-' || *data == '+')) + { + exponent += *data; + ++data; + } + + bool hasExponentDigits = false; + while (! data.isEmpty() && *data >= '0' && *data <= '9') + { + hasExponentDigits = true; + exponent += *data; + ++data; + } + + if (hasExponentDigits) + { + number += exponent; + } + else + { + data = exponentStart; + } } - return false; + coord = number.getFloatValue(); + skipWhitespaceOrComma (data); + return true; } //============================================================================== @@ -421,6 +439,9 @@ void handleEllipticalArc (String::CharPointerType& data, Path& path, float& curr && parseFlag (data, sweep) && parseCoordinates (data, x, y)) { + rx = std::abs (rx); + ry = std::abs (ry); + if (relative) { x += currentX; @@ -1122,7 +1143,7 @@ Path& Path::addArc (const Rectangle& rect, Path& Path::addCenteredArc (float centerX, float centerY, float radiusX, float radiusY, float rotationOfEllipse, float fromRadians, float toRadians, bool startAsNewSubPath) { - const int segments = jlimit (2, 54, static_cast ((toRadians - fromRadians) / 0.1f)); + const int segments = jlimit (2, 54, static_cast (std::ceil (std::abs (toRadians - fromRadians) / 0.1f))); const float delta = (toRadians - fromRadians) / segments; const float cosTheta = std::cos (rotationOfEllipse); diff --git a/modules/yup_graphics/primitives/yup_Path.h b/modules/yup_graphics/primitives/yup_Path.h index eaf63a650..d9065a766 100644 --- a/modules/yup_graphics/primitives/yup_Path.h +++ b/modules/yup_graphics/primitives/yup_Path.h @@ -217,25 +217,26 @@ class YUP_API Path Path& quadTo (const Point& p, float x1, float y1); //============================================================================== - /** Draws a cubic Bezier curve to specified coordinates with two control points. + /** Draws a cubic Bezier curve with two control points and an endpoint. - This method draws a cubic Bezier curve from the current point to the point (x, y), using - (x1, y1) and (x2, y2) as the control points. The current point is then updated to (x, y). + This method draws a cubic Bezier curve from the current point using (x, y) as the first + control point, (x1, y1) as the second control point, and (x2, y2) as the endpoint. The + current point is then updated to (x2, y2). - @param x The x-coordinate of the endpoint. - @param y The y-coordinate of the endpoint. - @param x1 The x-coordinate of the first control point. - @param y1 The y-coordinate of the first control point. - @param x2 The x-coordinate of the second control point. - @param y2 The y-coordinate of the second control point. + @param x The x-coordinate of the first control point. + @param y The y-coordinate of the first control point. + @param x1 The x-coordinate of the second control point. + @param y1 The y-coordinate of the second control point. + @param x2 The x-coordinate of the endpoint. + @param y2 The y-coordinate of the endpoint. */ Path& cubicTo (float x, float y, float x1, float y1, float x2, float y2); - /** Draws a cubic Bezier curve to specified coordinates with two control points. + /** Draws a cubic Bezier curve with two control points and an endpoint. - This method draws a cubic Bezier curve from the current point to the endpoint (x1, y1), - using the given point p and (x2, y2) as the control points. The current point is then updated - to (x1, y1). + This method draws a cubic Bezier curve from the current point using p as the first control + point, (x1, y1) as the second control point, and (x2, y2) as the endpoint. The current point + is then updated to (x2, y2). @param p The first control point. @param x1 The x-coordinate of the second control point. diff --git a/modules/yup_graphics/svg/yup_SVGClipPath.h b/modules/yup_graphics/svg/yup_SVGClipPath.h new file mode 100644 index 000000000..4538a9941 --- /dev/null +++ b/modules/yup_graphics/svg/yup_SVGClipPath.h @@ -0,0 +1,41 @@ +/* + ============================================================================== + + This file is part of the YUP library. + Copyright (c) 2026 - kunitoki@gmail.com + + YUP is an open source library subject to open-source licensing. + + The code included in this file is provided under the terms of the ISC license + http://www.isc.org/downloads/software-support-policy/isc-license. Permission + to use, copy, modify, and/or distribute this software for any purpose with or + without fee is hereby granted provided that the above copyright notice and + this permission notice appear in all copies. + + YUP IS PROVIDED "AS IS" WITHOUT ANY WARRANTY, AND ALL WARRANTIES, WHETHER + EXPRESSED OR IMPLIED, INCLUDING MERCHANTABILITY AND FITNESS FOR PURPOSE, ARE + DISCLAIMED. + + ============================================================================== +*/ + +namespace yup +{ + +/** A parsed SVG clipPath element. */ +struct SVGClipPath : public ReferenceCountedObject +{ + using Ptr = ReferenceCountedObjectPtr; + + enum Units + { + UserSpaceOnUse, + ObjectBoundingBox + }; + + String id; + Units units = UserSpaceOnUse; + std::vector elements; +}; + +} // namespace yup diff --git a/modules/yup_graphics/svg/yup_SVGCssParser.cpp b/modules/yup_graphics/svg/yup_SVGCssParser.cpp new file mode 100644 index 000000000..025d4ad30 --- /dev/null +++ b/modules/yup_graphics/svg/yup_SVGCssParser.cpp @@ -0,0 +1,498 @@ +/* + ============================================================================== + + This file is part of the YUP library. + Copyright (c) 2026 - kunitoki@gmail.com + + YUP is an open source library subject to open-source licensing. + + The code included in this file is provided under the terms of the ISC license + http://www.isc.org/downloads/software-support-policy/isc-license. Permission + to use, copy, modify, and/or distribute this software for any purpose with or + without fee is hereby granted provided that the above copyright notice and + this permission notice appear in all copies. + + YUP IS PROVIDED "AS IS" WITHOUT ANY WARRANTY, AND ALL WARRANTIES, WHETHER + EXPRESSED OR IMPLIED, INCLUDING MERCHANTABILITY AND FITNESS FOR PURPOSE, ARE + DISCLAIMED. + + ============================================================================== +*/ + +namespace yup +{ + +//============================================================================== + +SVGCssParser::SVGCssParser (SVGData& dataRef) + : data (dataRef) +{ +} + +//============================================================================== + +void SVGCssParser::parseCSSStyle (const String& styleString, SVGElement& e) +{ + YUP_DRAWABLE_LOG ("parseCSSStyle - tag: " << e.tagName + << " id: " << e.id.value_or (String ("none")) + << " style: " << styleString); + + auto declarations = StringArray::fromTokens (styleString, ";", ""); + + for (const auto& declaration : declarations) + { + auto colonPos = declaration.indexOf (":"); + if (colonPos > 0) + { + String property = declaration.substring (0, colonPos).trim(); + String value = declaration.substring (colonPos + 1).trim(); + + YUP_DRAWABLE_LOG ("Applying inline CSS declaration - property: " << property << " value: " << value); + applyStyleProperty (property, value, e); + } + } +} + +//============================================================================== + +void SVGCssParser::applyStyleProperty (StringRef propertyRef, StringRef valueRef, SVGElement& e) +{ + String property (propertyRef.text); + String value (valueRef.text); + + property = property.trim().toLowerCase(); + value = value.trim(); + + YUP_DRAWABLE_LOG ("applyStyleProperty - tag: " << e.tagName + << " id: " << e.id.value_or (String ("none")) + << " property: " << property + << " value: " << value); + + if (property == "fill") + { + e.fillCurrentColor = false; + e.fillUrl.reset(); + e.fillColor.reset(); + e.noFill = false; + + if (value == "none") + e.noFill = true; + else if (value == "currentColor") + e.fillCurrentColor = true; + else if (auto url = SVGParser::extractUrlId (value); url.isNotEmpty()) + e.fillUrl = url; + else if (value.isNotEmpty()) + e.fillColor = Color::fromString (value); + } + else if (property == "stroke") + { + e.strokeCurrentColor = false; + e.strokeUrl.reset(); + e.strokeColor.reset(); + e.noStroke = false; + + if (value == "none") + e.noStroke = true; + else if (value == "currentColor") + e.strokeCurrentColor = true; + else if (auto url = SVGParser::extractUrlId (value); url.isNotEmpty()) + e.strokeUrl = url; + else if (value.isNotEmpty()) + e.strokeColor = Color::fromString (value); + } + else if (property == "color") + { + if (value != "currentColor" && value != "inherit") + e.color = Color::fromString (value); + } + else if (property == "stroke-width") + { + float strokeWidth = SVGParser::parseUnit (value, e.strokeWidth.value_or (1.0f), e.fontSize.value_or (12.0f)); + if (strokeWidth >= 0.0f) + e.strokeWidth = strokeWidth; + } + else if (property == "stroke-linejoin") + { + if (value == "round") + e.strokeJoin = StrokeJoin::Round; + else if (value == "miter") + e.strokeJoin = StrokeJoin::Miter; + else if (value == "bevel") + e.strokeJoin = StrokeJoin::Bevel; + } + else if (property == "stroke-linecap") + { + if (value == "round") + e.strokeCap = StrokeCap::Round; + else if (value == "square") + e.strokeCap = StrokeCap::Square; + else if (value == "butt") + e.strokeCap = StrokeCap::Butt; + } + else if (property == "opacity") + { + float opacity = value.getFloatValue(); + if (opacity >= 0.0f && opacity <= 1.0f) + e.opacity = opacity; + } + else if (property == "display") + { + if (value == "none") + e.hidden = true; + } + else if (property == "visibility") + { + e.hidden = value == "hidden" || value == "collapse"; + } + else if (property == "font-family") + { + e.fontFamily = value.unquoted(); + } + else if (property == "font-size") + { + float fontSize = SVGParser::parseUnit (value, e.fontSize.value_or (12.0f), e.fontSize.value_or (12.0f), e.fontSize.value_or (12.0f)); + if (fontSize > 0.0f) + e.fontSize = fontSize; + } + else if (property == "text-anchor") + { + e.textAnchor = value; + } + else if (property == "letter-spacing") + { + if (value != "normal") + e.letterSpacing = SVGParser::parseUnit (value, 0.0f, e.fontSize.value_or (12.0f), e.fontSize.value_or (12.0f)); + } + else if (property == "word-spacing") + { + if (value != "normal") + e.wordSpacing = SVGParser::parseUnit (value, 0.0f, e.fontSize.value_or (12.0f), e.fontSize.value_or (12.0f)); + } + else if (property == "font-weight") + { + if (value == "bold" || value == "bolder") + e.fontWeight = 700; + else if (value == "normal" || value == "lighter") + e.fontWeight = 400; + else + { + const int numericWeight = value.getIntValue(); + if (numericWeight >= 100 && numericWeight <= 900) + e.fontWeight = numericWeight; + } + } + else if (property == "font-style") + { + e.fontItalic = (value == "italic" || value == "oblique"); + } + else if (property == "font-variant") + { + YUP_DRAWABLE_LOG ("CSS font-variant currently not applied - value: " << value); + } + else if (property == "font-stretch") + { + YUP_DRAWABLE_LOG ("CSS font-stretch currently not applied - value: " << value); + } + else if (property == "font") + { + YUP_DRAWABLE_LOG ("CSS font shorthand currently not parsed - value: " << value); + } + else if (property == "dominant-baseline") + { + YUP_DRAWABLE_LOG ("CSS dominant-baseline currently not applied - value: " << value); + } + else if (property == "alignment-baseline") + { + YUP_DRAWABLE_LOG ("CSS alignment-baseline currently not applied - value: " << value); + } + else if (property == "baseline-shift") + { + YUP_DRAWABLE_LOG ("CSS baseline-shift currently not applied - value: " << value); + } + else if (property == "clip-path") + { + String clipPathUrl = SVGParser::extractUrlId (value); + if (clipPathUrl.isNotEmpty()) + e.clipPathUrl = clipPathUrl; + } + else if (property == "mask") + { + if (auto maskUrl = SVGParser::extractUrlId (value); maskUrl.isNotEmpty()) + e.maskUrl = maskUrl; + } + else if (property == "marker-start") + { + if (auto url = SVGParser::extractUrlId (value); url.isNotEmpty()) + e.markerStart = url; + } + else if (property == "marker-mid") + { + if (auto url = SVGParser::extractUrlId (value); url.isNotEmpty()) + e.markerMid = url; + } + else if (property == "marker-end") + { + if (auto url = SVGParser::extractUrlId (value); url.isNotEmpty()) + e.markerEnd = url; + } + else if (property == "marker") + { + if (auto url = SVGParser::extractUrlId (value); url.isNotEmpty()) + { + e.markerStart = url; + e.markerMid = url; + e.markerEnd = url; + } + } + else if (property == "stroke-miterlimit") + { + float val = value.getFloatValue(); + e.strokeMiterLimit = std::max (1.0f, val); + } + else if (property == "filter") + { + if (value == "none") + e.filterUrl.reset(); + else if (auto filterUrl = SVGParser::extractUrlId (value); filterUrl.isNotEmpty()) + e.filterUrl = filterUrl; + else + YUP_DRAWABLE_LOG ("CSS filter currently only supports url(...) - value: " << value); + } + else if (property == "stroke-dasharray") + { + if (value == "none") + e.strokeDashArray.reset(); + else + { + auto dashes = SVGParser::parseLengthList (value, e.fontSize.value_or (12.0f), 100.0f); + if (! dashes.isEmpty()) + e.strokeDashArray = dashes; + } + } + else if (property == "stroke-dashoffset") + { + e.strokeDashOffset = SVGParser::parseUnit (value); + } + else if (property == "fill-opacity") + { + float opacity = value.getFloatValue(); + if (opacity >= 0.0f && opacity <= 1.0f) + e.fillOpacity = opacity; + } + else if (property == "stroke-opacity") + { + float opacity = value.getFloatValue(); + if (opacity >= 0.0f && opacity <= 1.0f) + e.strokeOpacity = opacity; + } + else if (property == "fill-rule") + { + if (value == "evenodd" || value == "nonzero") + e.fillRule = value; + } + else if (property == "clip-rule") + { + if (value == "evenodd" || value == "nonzero") + e.clipRule = value; + } + else if (property == "mix-blend-mode") + { + if (value == "multiply") + e.blendMode = BlendMode::Multiply; + else if (value == "screen") + e.blendMode = BlendMode::Screen; + else if (value == "overlay") + e.blendMode = BlendMode::Overlay; + else if (value == "darken") + e.blendMode = BlendMode::Darken; + else if (value == "lighten") + e.blendMode = BlendMode::Lighten; + else if (value == "color-dodge") + e.blendMode = BlendMode::ColorDodge; + else if (value == "color-burn") + e.blendMode = BlendMode::ColorBurn; + else if (value == "hard-light") + e.blendMode = BlendMode::HardLight; + else if (value == "soft-light") + e.blendMode = BlendMode::SoftLight; + else if (value == "difference") + e.blendMode = BlendMode::Difference; + else if (value == "exclusion") + e.blendMode = BlendMode::Exclusion; + else if (value == "hue") + e.blendMode = BlendMode::Hue; + else if (value == "saturation") + e.blendMode = BlendMode::Saturation; + else if (value == "color") + e.blendMode = BlendMode::Color; + else if (value == "luminosity") + e.blendMode = BlendMode::Luminosity; + } + else + { + YUP_DRAWABLE_LOG ("Unsupported CSS property ignored - property: " << property << " value: " << value); + } +} + +//============================================================================== + +void SVGCssParser::applyStylesheetRules (const XmlElement& xmlElement, SVGElement& e) +{ + std::vector matchedRules; + + for (const auto& rule : data.cssRules) + { + if (matchesCssSelector (xmlElement, rule)) + matchedRules.push_back (std::addressof (rule)); + } + + std::stable_sort (matchedRules.begin(), matchedRules.end(), [] (const SVGCssRule* a, const SVGCssRule* b) + { + if (a->specificity != b->specificity) + return a->specificity < b->specificity; + + return a->order < b->order; + }); + + if (! matchedRules.empty()) + { + YUP_DRAWABLE_LOG ("applyStylesheetRules - tag: " << e.tagName + << " id: " << e.id.value_or (String ("none")) + << " matchedRules: " << matchedRules.size()); + } + + for (const auto* rule : matchedRules) + { + YUP_DRAWABLE_LOG ("Applying stylesheet rule - selector: " << rule->selector + << " specificity: " << rule->specificity + << " order: " << rule->order + << " declarationCount: " << rule->declarations.size()); + + for (const auto& declaration : rule->declarations) + { + auto colonPos = declaration.indexOf (":"); + if (colonPos > 0) + applyStyleProperty (declaration.substring (0, colonPos).trim(), declaration.substring (colonPos + 1).trim(), e); + } + } +} + +//============================================================================== + +void SVGCssParser::parseStyleElement (const XmlElement& element) +{ + auto css = element.getAllSubText(); + int ruleOrder = static_cast (data.cssRules.size()); + + YUP_DRAWABLE_LOG ("parseStyleElement - cssLength: " << css.length() << " existingRules: " << data.cssRules.size()); + + while (css.isNotEmpty()) + { + auto openBrace = css.indexOf ("{"); + auto closeBrace = css.indexOf ("}"); + if (openBrace <= 0 || closeBrace <= openBrace) + break; + + auto selectorText = css.substring (0, openBrace).trim(); + auto declarationText = css.substring (openBrace + 1, closeBrace).trim(); + + css = css.substring (closeBrace + 1); + + auto selectors = StringArray::fromTokens (selectorText, ",", ""); + auto declarationTokens = StringArray::fromTokens (declarationText, ";", ""); + StringArray declarations; + + for (const auto& declaration : declarationTokens) + { + auto trimmedDeclaration = declaration.trim(); + if (trimmedDeclaration.isNotEmpty()) + declarations.add (trimmedDeclaration); + } + + for (auto selector : selectors) + { + selector = selector.trim(); + if (selector.isEmpty()) + continue; + + SVGCssRule rule; + rule.selector = selector; + rule.declarations = declarations; + rule.order = ruleOrder++; + + if (selector.startsWithChar ('#')) + rule.specificity = 100; + else if (selector.startsWithChar ('.')) + rule.specificity = 10; + else if (selector.containsChar ('#')) + rule.specificity = 101; + else if (selector.containsChar ('.')) + rule.specificity = 11; + else + rule.specificity = 1; + + YUP_DRAWABLE_LOG ("Parsed CSS rule - selector: " << rule.selector + << " specificity: " << rule.specificity + << " declarationCount: " << rule.declarations.size() + << " order: " << rule.order); + data.cssRules.push_back (std::move (rule)); + } + } + + YUP_DRAWABLE_LOG ("parseStyleElement result - totalRules: " << data.cssRules.size()); +} + +//============================================================================== + +bool SVGCssParser::matchesCssSelector (const XmlElement& xmlElement, const SVGCssRule& rule) const +{ + auto selector = rule.selector.trim(); + if (selector.isEmpty() || selector.containsChar (' ') || selector.containsChar ('>') || selector.containsChar ('+')) + return false; + + String tagName; + String id; + String className; + + auto hashIndex = selector.indexOf ("#"); + auto dotIndex = selector.indexOf ("."); + auto splitIndex = -1; + + if (hashIndex >= 0 && dotIndex >= 0) + splitIndex = jmin (hashIndex, dotIndex); + else + splitIndex = jmax (hashIndex, dotIndex); + + if (splitIndex > 0) + tagName = selector.substring (0, splitIndex); + + if (hashIndex == 0) + id = selector.substring (1); + else if (hashIndex > 0) + id = selector.substring (hashIndex + 1, dotIndex > hashIndex ? dotIndex : selector.length()); + + if (dotIndex == 0) + className = selector.substring (1); + else if (dotIndex > 0) + className = selector.substring (dotIndex + 1); + + if (splitIndex < 0 && ! selector.startsWithChar ('#') && ! selector.startsWithChar ('.')) + tagName = selector; + + if (tagName.isNotEmpty() && tagName != xmlElement.getTagNameWithoutNamespace()) + return false; + + if (id.isNotEmpty() && id != xmlElement.getStringAttribute ("id")) + return false; + + if (className.isNotEmpty()) + { + auto classes = StringArray::fromTokens (xmlElement.getStringAttribute ("class"), " \t\r\n", ""); + if (! classes.contains (className)) + return false; + } + + return tagName.isNotEmpty() || id.isNotEmpty() || className.isNotEmpty(); +} + +} // namespace yup diff --git a/modules/yup_graphics/svg/yup_SVGCssParser.h b/modules/yup_graphics/svg/yup_SVGCssParser.h new file mode 100644 index 000000000..4f305159d --- /dev/null +++ b/modules/yup_graphics/svg/yup_SVGCssParser.h @@ -0,0 +1,45 @@ +/* + ============================================================================== + + This file is part of the YUP library. + Copyright (c) 2026 - kunitoki@gmail.com + + YUP is an open source library subject to open-source licensing. + + The code included in this file is provided under the terms of the ISC license + http://www.isc.org/downloads/software-support-policy/isc-license. Permission + to use, copy, modify, and/or distribute this software for any purpose with or + without fee is hereby granted provided that the above copyright notice and + this permission notice appear in all copies. + + YUP IS PROVIDED "AS IS" WITHOUT ANY WARRANTY, AND ALL WARRANTIES, WHETHER + EXPRESSED OR IMPLIED, INCLUDING MERCHANTABILITY AND FITNESS FOR PURPOSE, ARE + DISCLAIMED. + + ============================================================================== +*/ + +namespace yup +{ + +/** Handles all CSS / style-related parsing for an SVG document. + + Constructed with a reference to the mutable SVGData being built. + The SVGParser drives this class during a parse pass. +*/ +class SVGCssParser +{ +public: + explicit SVGCssParser (SVGData& data); + + void parseCSSStyle (const String& styleString, SVGElement& e); + void applyStyleProperty (StringRef property, StringRef value, SVGElement& e); + void applyStylesheetRules (const XmlElement& xmlElement, SVGElement& e); + void parseStyleElement (const XmlElement& element); + bool matchesCssSelector (const XmlElement& xmlElement, const SVGCssRule& rule) const; + +private: + SVGData& data; +}; + +} // namespace yup diff --git a/modules/yup_graphics/svg/yup_SVGCssRule.h b/modules/yup_graphics/svg/yup_SVGCssRule.h new file mode 100644 index 000000000..e17ed5acc --- /dev/null +++ b/modules/yup_graphics/svg/yup_SVGCssRule.h @@ -0,0 +1,34 @@ +/* + ============================================================================== + + This file is part of the YUP library. + Copyright (c) 2026 - kunitoki@gmail.com + + YUP is an open source library subject to open-source licensing. + + The code included in this file is provided under the terms of the ISC license + http://www.isc.org/downloads/software-support-policy/isc-license. Permission + to use, copy, modify, and/or distribute this software for any purpose with or + without fee is hereby granted provided that the above copyright notice and + this permission notice appear in all copies. + + YUP IS PROVIDED "AS IS" WITHOUT ANY WARRANTY, AND ALL WARRANTIES, WHETHER + EXPRESSED OR IMPLIED, INCLUDING MERCHANTABILITY AND FITNESS FOR PURPOSE, ARE + DISCLAIMED. + + ============================================================================== +*/ + +namespace yup +{ + +/** A single parsed CSS rule from an SVG " + "" + "" + ""); + + EXPECT_TRUE (result); +} + +TEST (DrawableTests, ParseSVGWithParseOptionsImageResolver) +{ + Drawable drawable; + + Drawable::ParseOptions options; + options.imageResolver = [] (StringRef href, const File&) -> std::optional + { + if (href == StringRef ("custom-image")) + { + Image image (2, 2, PixelFormat::RGBA); + image.fill (0xffff0000); + return image; + } + + return std::nullopt; + }; + + bool result = drawable.parseSVG ( + "" + "" + "", + options); + + EXPECT_TRUE (result); +} + TEST (DrawableTests, ParseSVGWithViewBox) { Drawable drawable; @@ -499,6 +561,91 @@ TEST (DrawableTests, ParseSVGWithNestedGroups) tempFile.deleteFile(); } +TEST (DrawableTests, ParseSVGWithSymbolAndUse) +{ + Drawable drawable; + + bool result = drawable.parseSVG ( + "" + "" + "" + "" + "" + "" + "" + ""); + + EXPECT_TRUE (result); +} + +TEST (DrawableTests, ParseSVGWithDefsXLinkUseAndTspanFlow) +{ + Drawable drawable; + + bool result = drawable.parseSVG ( + "" + "" + "" + "" + "" + "" + "" + "" + "first" + "second" + "" + ""); + + EXPECT_TRUE (result); + + auto context = GraphicsContext::createContext (GraphicsContext::Headless, {}); + auto renderer = context->makeRenderer (80, 40); + Graphics graphics (*context, *renderer); + + EXPECT_NO_THROW ({ + drawable.paint (graphics, Rectangle (0.0f, 0.0f, 80.0f, 40.0f)); + }); +} + +TEST (DrawableTests, ParseSVGWithUnitsNestedViewportTextAndDash) +{ + Drawable drawable; + + bool result = drawable.parseSVG ( + "" + "" + "" + "OK!" + "" + ""); + + EXPECT_TRUE (result); + EXPECT_EQ (192.0f, drawable.getBounds().getWidth()); + EXPECT_EQ (96.0f, drawable.getBounds().getHeight()); +} + +TEST (DrawableTests, ParseSVGWithTransformOrigin) +{ + Drawable drawable; + + bool result = drawable.parseSVG ( + "" + "" + "Sweep flag" + "" + ""); + + EXPECT_TRUE (result); + + auto context = GraphicsContext::createContext (GraphicsContext::Headless, {}); + auto renderer = context->makeRenderer (360, 360); + Graphics graphics (*context, *renderer); + + EXPECT_NO_THROW ({ + drawable.paint (graphics, Rectangle (0.0f, 0.0f, 360.0f, 360.0f)); + }); +} + // ============================================================================== // SVG Style Tests // ============================================================================== @@ -689,20 +836,115 @@ TEST (DrawableTests, ParseSVGWithRadialGradient) tempFile.deleteFile(); } +TEST (DrawableTests, PaintSVGWithTransformedClipPath) +{ + Drawable drawable; + + bool result = drawable.parseSVG ( + "" + "" + "" + "" + "" + ""); + + EXPECT_TRUE (result); + + auto context = GraphicsContext::createContext (GraphicsContext::Headless, {}); + auto renderer = context->makeRenderer (64, 64); + Graphics graphics (*context, *renderer); + + EXPECT_NO_THROW ({ + drawable.paint (graphics, Rectangle (0.0f, 0.0f, 64.0f, 64.0f)); + }); +} + +TEST (DrawableTests, PaintSVGWithScimitarClipPathAndGradientStroke) +{ + Drawable drawable; + + const String scimitarPath = "M 171.59375,-167.8125 L 153.4375,-131.09375 C 153.4375,-131.09375 240.05975,-44.592207 260.53125,61.53125 " + "C 263.78902,59.713413 267.53809,58.6875 271.53125,58.6875 C 283.99674,58.687502 294.11733,68.78455 294.15625,81.25 " + "L 294.15625,81.3125 C 294.15624,93.802829 284.02158,103.9375 271.53125,103.9375 " + "C 269.20004,103.9375 266.9604,103.59314 264.84375,102.9375 C 265.00283,118.53432 263.43644,134.33614 259.71875,150.1875 " + "C 279.93177,155.71176 336.35552,161.63753 367.0625,234.84375 C 388.95186,159.67792 354.15709,-29.134107 171.59375,-167.8125 z "; + + String svg; + svg << "" + << "" + << "" + << "" + << "" + << "" + << "" + << "" + << "" + << "" + << "" + << "" + << "" + << "" + << ""; + + bool result = drawable.parseSVG (svg); + + EXPECT_TRUE (result); + + auto context = GraphicsContext::createContext (GraphicsContext::Headless, {}); + auto renderer = context->makeRenderer (96, 96); + Graphics graphics (*context, *renderer); + graphics.setDrawingArea (Rectangle (23.0f, 17.0f, 96.0f, 96.0f)); + + EXPECT_NO_THROW ({ + drawable.paint (graphics, Rectangle (0.0f, 0.0f, 96.0f, 96.0f)); + }); +} + +TEST (DrawableTests, PaintSVGWithTransformedRadialGradient) +{ + Drawable drawable; + + bool result = drawable.parseSVG ( + "" + "" + "" + "" + "" + "" + "" + "" + ""); + + EXPECT_TRUE (result); + + auto context = GraphicsContext::createContext (GraphicsContext::Headless, {}); + auto renderer = context->makeRenderer (64, 64); + Graphics graphics (*context, *renderer); + + EXPECT_NO_THROW ({ + drawable.paint (graphics, Rectangle (0.0f, 0.0f, 64.0f, 64.0f)); + }); +} + // ============================================================================== // Edge Cases and Error Handling // ============================================================================== -TEST (DrawableTests, ParseSVGWithInvalidPath) +TEST (DrawableTests, ParseSVGWithInvalidPathStillSucceeds) { Drawable drawable; + // Child element failures don't abort the document parse — the bad element is + // silently skipped so the document still reports success. File tempFile = File::getSpecialLocation (File::tempDirectory).getChildFile ("test_invalid_path.svg"); tempFile.replaceWithText (""); bool result = drawable.parseSVG (tempFile); - // Path::fromString always returns true, so parsing succeeds even with invalid data EXPECT_TRUE (result); tempFile.deleteFile(); @@ -816,3 +1058,175 @@ TEST (DrawableTests, GetBoundsWithViewBoxTakesPrecedence) tempFile.deleteFile(); } + +// ============================================================================== +// SVG 1.1 Feature Tests +// ============================================================================== + +TEST (DrawableTests, PaintSVGWithMask) +{ + Drawable drawable; + + bool result = drawable.parseSVG ( + "" + "" + "" + "" + "" + "" + "" + ""); + + EXPECT_TRUE (result); + + auto context = GraphicsContext::createContext (GraphicsContext::Headless, {}); + auto renderer = context->makeRenderer (64, 64); + Graphics graphics (*context, *renderer); + + EXPECT_NO_THROW ({ + drawable.paint (graphics, Rectangle (0.0f, 0.0f, 64.0f, 64.0f)); + }); +} + +TEST (DrawableTests, PaintSVGWithMarkerEnd) +{ + Drawable drawable; + + bool result = drawable.parseSVG ( + "" + "" + "" + "" + "" + "" + "" + ""); + + EXPECT_TRUE (result); + + auto context = GraphicsContext::createContext (GraphicsContext::Headless, {}); + auto renderer = context->makeRenderer (64, 64); + Graphics graphics (*context, *renderer); + + EXPECT_NO_THROW ({ + drawable.paint (graphics, Rectangle (0.0f, 0.0f, 64.0f, 64.0f)); + }); +} + +TEST (DrawableTests, PaintSVGWithPattern) +{ + Drawable drawable; + + bool result = drawable.parseSVG ( + "" + "" + "" + "" + "" + "" + "" + ""); + + EXPECT_TRUE (result); + + auto context = GraphicsContext::createContext (GraphicsContext::Headless, {}); + auto renderer = context->makeRenderer (64, 64); + Graphics graphics (*context, *renderer); + + EXPECT_NO_THROW ({ + drawable.paint (graphics, Rectangle (0.0f, 0.0f, 64.0f, 64.0f)); + }); +} + +TEST (DrawableTests, PaintSVGWithCyclicUseDoesNotCrash) +{ + Drawable drawable; + + bool result = drawable.parseSVG ( + "" + "" + "" + "" + "" + "" + "" + ""); + + EXPECT_TRUE (result); + + auto context = GraphicsContext::createContext (GraphicsContext::Headless, {}); + auto renderer = context->makeRenderer (64, 64); + Graphics graphics (*context, *renderer); + + EXPECT_NO_THROW ({ + drawable.paint (graphics, Rectangle (0.0f, 0.0f, 64.0f, 64.0f)); + }); +} + +TEST (DrawableTests, PaintSVGWithStrokeMiterLimit) +{ + Drawable drawable; + + bool result = drawable.parseSVG ( + "" + "" + ""); + + EXPECT_TRUE (result); + + auto context = GraphicsContext::createContext (GraphicsContext::Headless, {}); + auto renderer = context->makeRenderer (64, 64); + Graphics graphics (*context, *renderer); + + EXPECT_NO_THROW ({ + drawable.paint (graphics, Rectangle (0.0f, 0.0f, 64.0f, 64.0f)); + }); +} + +TEST (DrawableTests, PaintSVGWithClipRuleEvenOdd) +{ + Drawable drawable; + + bool result = drawable.parseSVG ( + "" + "" + "" + "" + "" + "" + "" + ""); + + EXPECT_TRUE (result); + + auto context = GraphicsContext::createContext (GraphicsContext::Headless, {}); + auto renderer = context->makeRenderer (64, 64); + Graphics graphics (*context, *renderer); + + EXPECT_NO_THROW ({ + drawable.paint (graphics, Rectangle (0.0f, 0.0f, 64.0f, 64.0f)); + }); +} + +TEST (DrawableTests, PaintSVGWithMixBlendMode) +{ + Drawable drawable; + + bool result = drawable.parseSVG ( + "" + "" + "" + ""); + + EXPECT_TRUE (result); + + auto context = GraphicsContext::createContext (GraphicsContext::Headless, {}); + auto renderer = context->makeRenderer (64, 64); + Graphics graphics (*context, *renderer); + + EXPECT_NO_THROW ({ + drawable.paint (graphics, Rectangle (0.0f, 0.0f, 64.0f, 64.0f)); + }); +} diff --git a/tests/yup_graphics/yup_Path.cpp b/tests/yup_graphics/yup_Path.cpp index fb5ec9d20..f422a5121 100644 --- a/tests/yup_graphics/yup_Path.cpp +++ b/tests/yup_graphics/yup_Path.cpp @@ -151,6 +151,14 @@ TEST (PathTests, AddArc) EXPECT_FALSE (p.getBounds().isEmpty()); } +TEST (PathTests, AddCenteredArcUsesAbsoluteSweepForSegments) +{ + Path p; + p.addCenteredArc (100.0f, 145.0f, 45.0f, 45.0f, 0.0f, -MathConstants::halfPi, -MathConstants::pi, true); + + EXPECT_GT (p.size(), 4); +} + TEST (PathTests, AddPolygon) { Path p; @@ -710,6 +718,103 @@ TEST (PathTests, FromStringCubicBezierRelative) EXPECT_FALSE (p.getBounds().isEmpty()); } +TEST (PathTests, FromStringCubicBezierPreservesSVGCoordinateOrder) +{ + Path p; + bool ok = p.fromString ("M 0 0 C 10 0, 20 10, 30 0"); + EXPECT_TRUE (ok); + + auto it = p.begin(); + ASSERT_NE (it, p.end()); + EXPECT_EQ ((*it).verb, Path::Verb::MoveTo); + + ++it; + ASSERT_NE (it, p.end()); + + const auto segment = *it; + EXPECT_EQ (segment.verb, Path::Verb::CubicTo); + expectPointNear (segment.controlPoint1, Point (10.0f, 0.0f)); + expectPointNear (segment.controlPoint2, Point (20.0f, 10.0f)); + expectPointNear (segment.point, Point (30.0f, 0.0f)); +} + +TEST (PathTests, FromStringParsesScimitarCubicPath) +{ + Path p; + bool ok = p.fromString ( + "M 171.59375,-167.8125 L 153.4375,-131.09375 C 153.4375,-131.09375 240.05975,-44.592207 260.53125,61.53125 " + "C 263.78902,59.713413 267.53809,58.6875 271.53125,58.6875 C 283.99674,58.687502 294.11733,68.78455 294.15625,81.25 " + "L 294.15625,81.3125 C 294.15624,93.802829 284.02158,103.9375 271.53125,103.9375 " + "C 269.20004,103.9375 266.9604,103.59314 264.84375,102.9375 C 265.00283,118.53432 263.43644,134.33614 259.71875,150.1875 " + "C 279.93177,155.71176 336.35552,161.63753 367.0625,234.84375 C 388.95186,159.67792 354.15709,-29.134107 171.59375,-167.8125 z "); + + EXPECT_TRUE (ok); + EXPECT_EQ (12, p.size()); + + auto it = p.begin(); + ASSERT_NE (it, p.end()); + EXPECT_EQ ((*it).verb, Path::Verb::MoveTo); + expectPointNear ((*it).point, Point (171.59375f, -167.8125f)); + + ++it; + ASSERT_NE (it, p.end()); + EXPECT_EQ ((*it).verb, Path::Verb::LineTo); + expectPointNear ((*it).point, Point (153.4375f, -131.09375f)); + + ++it; + ASSERT_NE (it, p.end()); + + const auto segment = *it; + EXPECT_EQ (segment.verb, Path::Verb::CubicTo); + expectPointNear (segment.controlPoint1, Point (153.4375f, -131.09375f)); + expectPointNear (segment.controlPoint2, Point (240.05975f, -44.592207f)); + expectPointNear (segment.point, Point (260.53125f, 61.53125f)); +} + +TEST (PathTests, FromStringQuadraticBezierConvertsUsingSVGCoordinateOrder) +{ + Path p; + bool ok = p.fromString ("M 0 0 Q 30 30, 60 0"); + EXPECT_TRUE (ok); + + auto it = p.begin(); + ASSERT_NE (it, p.end()); + EXPECT_EQ ((*it).verb, Path::Verb::MoveTo); + + ++it; + ASSERT_NE (it, p.end()); + + const auto segment = *it; + EXPECT_EQ (segment.verb, Path::Verb::CubicTo); + expectPointNear (segment.controlPoint1, Point (20.0f, 20.0f)); + expectPointNear (segment.controlPoint2, Point (40.0f, 20.0f)); + expectPointNear (segment.point, Point (60.0f, 0.0f)); +} + +TEST (PathTests, FromStringParsesSignedExponentCoordinates) +{ + Path p; + bool ok = p.fromString ("M +1e1 -2e1 L 2.5e1,+3.5e1 C +3e1 -4e1 4e1 -5e1 5e1 -6e1"); + EXPECT_TRUE (ok); + + auto it = p.begin(); + ASSERT_NE (it, p.end()); + expectPointNear ((*it).point, Point (10.0f, -20.0f)); + + ++it; + ASSERT_NE (it, p.end()); + expectPointNear ((*it).point, Point (25.0f, 35.0f)); + + ++it; + ASSERT_NE (it, p.end()); + + const auto segment = *it; + EXPECT_EQ (segment.verb, Path::Verb::CubicTo); + expectPointNear (segment.controlPoint1, Point (30.0f, -40.0f)); + expectPointNear (segment.controlPoint2, Point (40.0f, -50.0f)); + expectPointNear (segment.point, Point (50.0f, -60.0f)); +} + TEST (PathTests, FromStringSmoothCubicAbsolute) { Path p; @@ -734,6 +839,24 @@ TEST (PathTests, FromStringEllipticalArcAbsolute) EXPECT_FALSE (p.getBounds().isEmpty()); } +TEST (PathTests, FromStringEllipticalArcParsesCompactFlags) +{ + Path p; + bool ok = p.fromString ("M 0 0 A 10 10 0 0150 0"); + EXPECT_TRUE (ok); + EXPECT_GT (p.size(), 1); + EXPECT_FALSE (p.getBounds().isEmpty()); +} + +TEST (PathTests, FromStringEllipticalArcUsesAbsoluteRadii) +{ + Path p; + bool ok = p.fromString ("M 0 0 A -10 -10 0 0 1 50 0"); + EXPECT_TRUE (ok); + EXPECT_GT (p.size(), 1); + EXPECT_FALSE (p.getBounds().isEmpty()); +} + TEST (PathTests, FromStringEllipticalArcRelative) { Path p; diff --git a/tests/yup_graphics/yup_SVGDocument.cpp b/tests/yup_graphics/yup_SVGDocument.cpp new file mode 100644 index 000000000..4207b4aa6 --- /dev/null +++ b/tests/yup_graphics/yup_SVGDocument.cpp @@ -0,0 +1,2392 @@ +/* + ============================================================================== + + This file is part of the YUP library. + Copyright (c) 2026 - kunitoki@gmail.com + + YUP is an open source library subject to open-source licensing. + + The code included in this file is provided under the terms of the ISC license + http://www.isc.org/downloads/software-support-policy/isc-license. Permission + to use, copy, modify, and/or distribute this software for any purpose with or + without fee is hereby granted provided that the above copyright notice and + this permission notice appear in all copies. + + YUP IS PROVIDED "AS IS" WITHOUT ANY WARRANTY, AND ALL WARRANTIES, WHETHER + EXPRESSED OR IMPLIED, INCLUDING MERCHANTABILITY AND FITNESS FOR PURPOSE, ARE + DISCLAIMED. + + ============================================================================== +*/ + +#include + +#include + +using namespace yup; + +namespace +{ + +SVGDocument::Ptr parse (const char* svgText) +{ + return SVGParser::parse (StringRef (svgText)); +} + +} // namespace + +// ============================================================================== +// SVGDocument null / root validation +// ============================================================================== + +TEST (SVGDocumentTests, ParseNullptrForEmptyString) +{ + EXPECT_EQ (nullptr, parse ("")); +} + +TEST (SVGDocumentTests, ParseNullptrForNonSVGRoot) +{ + EXPECT_EQ (nullptr, parse ("")); +} + +TEST (SVGDocumentTests, ParseNullptrForMalformedXML) +{ + EXPECT_EQ (nullptr, parse ("not xml")); +} + +TEST (SVGDocumentTests, ParseReturnsNonNullForMinimalSVG) +{ + EXPECT_NE (nullptr, parse ("")); +} + +// ============================================================================== +// SVGData::viewBox, size and bounds +// ============================================================================== + +TEST (SVGDocumentTests, ViewBoxParsedFromAttribute) +{ + auto doc = parse (""); + ASSERT_NE (nullptr, doc); + + doc->visit ([] (const SVGData& data) + { + EXPECT_FLOAT_EQ (0.0f, data.viewBox.getX()); + EXPECT_FLOAT_EQ (0.0f, data.viewBox.getY()); + EXPECT_FLOAT_EQ (200.0f, data.viewBox.getWidth()); + EXPECT_FLOAT_EQ (100.0f, data.viewBox.getHeight()); + }); +} + +TEST (SVGDocumentTests, ViewBoxWithNonZeroOrigin) +{ + auto doc = parse (""); + ASSERT_NE (nullptr, doc); + + doc->visit ([] (const SVGData& data) + { + EXPECT_FLOAT_EQ (10.0f, data.viewBox.getX()); + EXPECT_FLOAT_EQ (20.0f, data.viewBox.getY()); + EXPECT_FLOAT_EQ (80.0f, data.viewBox.getWidth()); + EXPECT_FLOAT_EQ (60.0f, data.viewBox.getHeight()); + }); +} + +TEST (SVGDocumentTests, SizeFallsBackToViewBoxWhenWidthHeightAbsent) +{ + auto doc = parse (""); + ASSERT_NE (nullptr, doc); + + doc->visit ([] (const SVGData& data) + { + EXPECT_FLOAT_EQ (50.0f, data.size.getWidth()); + EXPECT_FLOAT_EQ (40.0f, data.size.getHeight()); + }); +} + +TEST (SVGDocumentTests, ExplicitWidthHeightOverridesViewBoxForSize) +{ + auto doc = parse (""); + ASSERT_NE (nullptr, doc); + + doc->visit ([] (const SVGData& data) + { + EXPECT_FLOAT_EQ (120.0f, data.size.getWidth()); + EXPECT_FLOAT_EQ (90.0f, data.size.getHeight()); + // viewBox remains as declared + EXPECT_FLOAT_EQ (50.0f, data.viewBox.getWidth()); + EXPECT_FLOAT_EQ (40.0f, data.viewBox.getHeight()); + }); +} + +TEST (SVGDocumentTests, BoundsMatchViewBox) +{ + auto doc = parse (""); + ASSERT_NE (nullptr, doc); + + EXPECT_FLOAT_EQ (300.0f, doc->getBounds().getWidth()); + EXPECT_FLOAT_EQ (150.0f, doc->getBounds().getHeight()); +} + +TEST (SVGDocumentTests, BoundsMatchWidthHeightWhenNoViewBox) +{ + auto doc = parse (""); + ASSERT_NE (nullptr, doc); + + EXPECT_FLOAT_EQ (400.0f, doc->getBounds().getWidth()); + EXPECT_FLOAT_EQ (250.0f, doc->getBounds().getHeight()); +} + +// ============================================================================== +// SVGData root fill / stroke flags +// ============================================================================== + +TEST (SVGDocumentTests, RootHasFillByDefault) +{ + auto doc = parse (""); + ASSERT_NE (nullptr, doc); + + doc->visit ([] (const SVGData& data) + { + EXPECT_TRUE (data.rootHasFill); + }); +} + +TEST (SVGDocumentTests, RootFillNoneDisablesRootHasFill) +{ + auto doc = parse (""); + ASSERT_NE (nullptr, doc); + + doc->visit ([] (const SVGData& data) + { + EXPECT_FALSE (data.rootHasFill); + }); +} + +TEST (SVGDocumentTests, RootFillColorIsSetWhenFillAttributePresent) +{ + auto doc = parse (""); + ASSERT_NE (nullptr, doc); + + doc->visit ([] (const SVGData& data) + { + EXPECT_TRUE (data.rootHasFill); + ASSERT_TRUE (data.rootFillColor.has_value()); + }); +} + +TEST (SVGDocumentTests, RootHasStrokeFalseByDefault) +{ + auto doc = parse (""); + ASSERT_NE (nullptr, doc); + + doc->visit ([] (const SVGData& data) + { + EXPECT_FALSE (data.rootHasStroke); + }); +} + +TEST (SVGDocumentTests, RootStrokeColorIsSetWhenStrokeAttributePresent) +{ + auto doc = parse (""); + ASSERT_NE (nullptr, doc); + + doc->visit ([] (const SVGData& data) + { + EXPECT_TRUE (data.rootHasStroke); + ASSERT_TRUE (data.rootStrokeColor.has_value()); + }); +} + +// ============================================================================== +// SVGData::elements (top-level element tree) +// ============================================================================== + +TEST (SVGDocumentTests, EmptySVGHasZeroElements) +{ + auto doc = parse (""); + ASSERT_NE (nullptr, doc); + + doc->visit ([] (const SVGData& data) + { + EXPECT_EQ (0u, data.elements.size()); + }); +} + +TEST (SVGDocumentTests, SingleRectProducesOneTopLevelElement) +{ + auto doc = parse (""); + ASSERT_NE (nullptr, doc); + + doc->visit ([] (const SVGData& data) + { + EXPECT_EQ (1u, data.elements.size()); + EXPECT_EQ (String ("rect"), data.elements[0]->tagName); + }); +} + +TEST (SVGDocumentTests, MultipleTopLevelElementsAreAllCollected) +{ + auto doc = parse ("" + "" + "" + "" + ""); + ASSERT_NE (nullptr, doc); + + doc->visit ([] (const SVGData& data) + { + EXPECT_EQ (3u, data.elements.size()); + EXPECT_EQ (String ("rect"), data.elements[0]->tagName); + EXPECT_EQ (String ("circle"), data.elements[1]->tagName); + EXPECT_EQ (String ("line"), data.elements[2]->tagName); + }); +} + +TEST (SVGDocumentTests, GroupChildrenAreNestedNotTopLevel) +{ + auto doc = parse (""); + ASSERT_NE (nullptr, doc); + + doc->visit ([] (const SVGData& data) + { + ASSERT_EQ (1u, data.elements.size()); + EXPECT_EQ (String ("g"), data.elements[0]->tagName); + ASSERT_EQ (1u, data.elements[0]->children.size()); + EXPECT_EQ (String ("rect"), data.elements[0]->children[0]->tagName); + }); +} + +TEST (SVGDocumentTests, DefsElementIsHiddenAndNotInTopLevelElements) +{ + auto doc = parse ("" + "" + "" + ""); + ASSERT_NE (nullptr, doc); + + doc->visit ([] (const SVGData& data) + { + // defs is parsed as hidden, and its children shouldn't be top-level elements + // only the circle should appear + ASSERT_EQ (2u, data.elements.size()); + // defs comes first as a hidden element, circle second + const auto* defs = data.elements[0].get(); + EXPECT_TRUE (defs->hidden); + EXPECT_EQ (String ("defs"), defs->tagName); + EXPECT_EQ (String ("circle"), data.elements[1]->tagName); + }); +} + +// ============================================================================== +// SVGData::elementsById +// ============================================================================== + +TEST (SVGDocumentTests, ElementWithIdIsRegisteredInById) +{ + auto doc = parse (""); + ASSERT_NE (nullptr, doc); + + doc->visit ([] (const SVGData& data) + { + EXPECT_TRUE (data.elementsById.contains ("myRect")); + ASSERT_NE (nullptr, data.elementsById["myRect"].get()); + EXPECT_EQ (String ("rect"), data.elementsById["myRect"]->tagName); + }); +} + +TEST (SVGDocumentTests, ElementWithoutIdIsNotInById) +{ + auto doc = parse (""); + ASSERT_NE (nullptr, doc); + + doc->visit ([] (const SVGData& data) + { + EXPECT_EQ (0, data.elementsById.size()); + }); +} + +TEST (SVGDocumentTests, MultipleIdsAllRegistered) +{ + auto doc = parse ("" + "" + "" + "" + ""); + ASSERT_NE (nullptr, doc); + + doc->visit ([] (const SVGData& data) + { + EXPECT_EQ (4, data.elementsById.size()); + EXPECT_TRUE (data.elementsById.contains ("r1")); + EXPECT_TRUE (data.elementsById.contains ("c1")); + EXPECT_TRUE (data.elementsById.contains ("g1")); + EXPECT_TRUE (data.elementsById.contains ("l1")); + }); +} + +// ============================================================================== +// SVGElement path geometry +// ============================================================================== + +TEST (SVGDocumentTests, RectElementHasPathSet) +{ + auto doc = parse (""); + ASSERT_NE (nullptr, doc); + + doc->visit ([] (const SVGData& data) + { + ASSERT_EQ (1u, data.elements.size()); + const auto& elem = *data.elements[0]; + ASSERT_TRUE (elem.path.has_value()); + EXPECT_FALSE (elem.path->isEmpty()); + auto b = elem.path->getBounds(); + EXPECT_FLOAT_EQ (10.0f, b.getX()); + EXPECT_FLOAT_EQ (20.0f, b.getY()); + EXPECT_FLOAT_EQ (80.0f, b.getWidth()); + EXPECT_FLOAT_EQ (60.0f, b.getHeight()); + }); +} + +TEST (SVGDocumentTests, CircleElementHasPathSet) +{ + auto doc = parse (""); + ASSERT_NE (nullptr, doc); + + doc->visit ([] (const SVGData& data) + { + ASSERT_EQ (1u, data.elements.size()); + const auto& elem = *data.elements[0]; + ASSERT_TRUE (elem.path.has_value()); + EXPECT_FALSE (elem.path->isEmpty()); + auto b = elem.path->getBounds(); + EXPECT_NEAR (20.0f, b.getX(), 0.1f); + EXPECT_NEAR (20.0f, b.getY(), 0.1f); + EXPECT_NEAR (60.0f, b.getWidth(), 0.5f); + EXPECT_NEAR (60.0f, b.getHeight(), 0.5f); + }); +} + +TEST (SVGDocumentTests, EllipseElementHasPathSet) +{ + auto doc = parse (""); + ASSERT_NE (nullptr, doc); + + doc->visit ([] (const SVGData& data) + { + ASSERT_EQ (1u, data.elements.size()); + const auto& elem = *data.elements[0]; + ASSERT_TRUE (elem.path.has_value()); + EXPECT_FALSE (elem.path->isEmpty()); + auto b = elem.path->getBounds(); + EXPECT_NEAR (10.0f, b.getX(), 0.1f); + EXPECT_NEAR (30.0f, b.getY(), 0.1f); + EXPECT_NEAR (80.0f, b.getWidth(), 0.5f); + EXPECT_NEAR (40.0f, b.getHeight(), 0.5f); + }); +} + +TEST (SVGDocumentTests, LineElementHasPathSet) +{ + auto doc = parse (""); + ASSERT_NE (nullptr, doc); + + doc->visit ([] (const SVGData& data) + { + ASSERT_EQ (1u, data.elements.size()); + const auto& elem = *data.elements[0]; + ASSERT_TRUE (elem.path.has_value()); + EXPECT_FALSE (elem.path->isEmpty()); + }); +} + +TEST (SVGDocumentTests, PathElementHasPathSetWithCorrectBounds) +{ + auto doc = parse (""); + ASSERT_NE (nullptr, doc); + + doc->visit ([] (const SVGData& data) + { + ASSERT_EQ (1u, data.elements.size()); + const auto& elem = *data.elements[0]; + ASSERT_TRUE (elem.path.has_value()); + EXPECT_FALSE (elem.path->isEmpty()); + auto b = elem.path->getBounds(); + EXPECT_NEAR (10.0f, b.getX(), 0.01f); + EXPECT_NEAR (10.0f, b.getY(), 0.01f); + EXPECT_NEAR (80.0f, b.getWidth(), 0.5f); + EXPECT_NEAR (80.0f, b.getHeight(), 0.5f); + }); +} + +TEST (SVGDocumentTests, EmptyPathDAttributeProducesEmptyPath) +{ + auto doc = parse (""); + ASSERT_NE (nullptr, doc); + + doc->visit ([] (const SVGData& data) + { + ASSERT_EQ (1u, data.elements.size()); + const auto& elem = *data.elements[0]; + ASSERT_TRUE (elem.path.has_value()); + EXPECT_TRUE (elem.path->isEmpty()); + }); +} + +TEST (SVGDocumentTests, PathWithEvenOddFillRuleUsesNonZeroWindingFalse) +{ + auto doc = parse (""); + ASSERT_NE (nullptr, doc); + + doc->visit ([] (const SVGData& data) + { + ASSERT_EQ (1u, data.elements.size()); + const auto& elem = *data.elements[0]; + ASSERT_TRUE (elem.path.has_value()); + EXPECT_FALSE (elem.path->isUsingNonZeroWinding()); + ASSERT_TRUE (elem.fillRule.has_value()); + EXPECT_EQ (String ("evenodd"), *elem.fillRule); + }); +} + +TEST (SVGDocumentTests, PathWithNonZeroFillRuleUsesNonZeroWindingTrue) +{ + auto doc = parse (""); + ASSERT_NE (nullptr, doc); + + doc->visit ([] (const SVGData& data) + { + ASSERT_EQ (1u, data.elements.size()); + const auto& elem = *data.elements[0]; + ASSERT_TRUE (elem.path.has_value()); + EXPECT_TRUE (elem.path->isUsingNonZeroWinding()); + }); +} + +// ============================================================================== +// SVGElement fill / stroke attributes +// ============================================================================== + +TEST (SVGDocumentTests, FillColorAttribute) +{ + auto doc = parse (""); + ASSERT_NE (nullptr, doc); + + doc->visit ([] (const SVGData& data) + { + ASSERT_EQ (1u, data.elements.size()); + const auto& elem = *data.elements[0]; + ASSERT_TRUE (elem.fillColor.has_value()); + EXPECT_FALSE (elem.noFill); + EXPECT_FALSE (elem.fillCurrentColor); + }); +} + +TEST (SVGDocumentTests, FillNoneSetNoFill) +{ + auto doc = parse (""); + ASSERT_NE (nullptr, doc); + + doc->visit ([] (const SVGData& data) + { + ASSERT_EQ (1u, data.elements.size()); + const auto& elem = *data.elements[0]; + EXPECT_TRUE (elem.noFill); + EXPECT_FALSE (elem.fillColor.has_value()); + }); +} + +TEST (SVGDocumentTests, FillCurrentColorSetsFillCurrentColor) +{ + auto doc = parse (""); + ASSERT_NE (nullptr, doc); + + doc->visit ([] (const SVGData& data) + { + ASSERT_EQ (1u, data.elements.size()); + const auto& elem = *data.elements[0]; + EXPECT_TRUE (elem.fillCurrentColor); + EXPECT_FALSE (elem.fillColor.has_value()); + EXPECT_FALSE (elem.noFill); + }); +} + +TEST (SVGDocumentTests, FillUrlSetsFillUrl) +{ + auto doc = parse ("" + "" + "" + ""); + ASSERT_NE (nullptr, doc); + + doc->visit ([] (const SVGData& data) + { + ASSERT_EQ (2u, data.elements.size()); + const auto& elem = *data.elements[1]; + ASSERT_TRUE (elem.fillUrl.has_value()); + EXPECT_EQ (String ("g"), *elem.fillUrl); + }); +} + +TEST (SVGDocumentTests, StrokeColorAttribute) +{ + auto doc = parse (""); + ASSERT_NE (nullptr, doc); + + doc->visit ([] (const SVGData& data) + { + ASSERT_EQ (1u, data.elements.size()); + const auto& elem = *data.elements[0]; + ASSERT_TRUE (elem.strokeColor.has_value()); + EXPECT_FALSE (elem.noStroke); + }); +} + +TEST (SVGDocumentTests, StrokeNoneSetsNoStroke) +{ + auto doc = parse (""); + ASSERT_NE (nullptr, doc); + + doc->visit ([] (const SVGData& data) + { + ASSERT_EQ (1u, data.elements.size()); + const auto& elem = *data.elements[0]; + EXPECT_TRUE (elem.noStroke); + EXPECT_FALSE (elem.strokeColor.has_value()); + }); +} + +TEST (SVGDocumentTests, StrokeWidthAttribute) +{ + auto doc = parse (""); + ASSERT_NE (nullptr, doc); + + doc->visit ([] (const SVGData& data) + { + ASSERT_EQ (1u, data.elements.size()); + const auto& elem = *data.elements[0]; + ASSERT_TRUE (elem.strokeWidth.has_value()); + EXPECT_FLOAT_EQ (3.5f, *elem.strokeWidth); + }); +} + +TEST (SVGDocumentTests, StrokeLineJoinRound) +{ + auto doc = parse (""); + ASSERT_NE (nullptr, doc); + + doc->visit ([] (const SVGData& data) + { + ASSERT_EQ (1u, data.elements.size()); + const auto& elem = *data.elements[0]; + ASSERT_TRUE (elem.strokeJoin.has_value()); + EXPECT_EQ (StrokeJoin::Round, *elem.strokeJoin); + }); +} + +TEST (SVGDocumentTests, StrokeLineJoinMiter) +{ + auto doc = parse (""); + ASSERT_NE (nullptr, doc); + + doc->visit ([] (const SVGData& data) + { + ASSERT_EQ (1u, data.elements.size()); + EXPECT_EQ (StrokeJoin::Miter, *data.elements[0]->strokeJoin); + }); +} + +TEST (SVGDocumentTests, StrokeLineJoinBevel) +{ + auto doc = parse (""); + ASSERT_NE (nullptr, doc); + + doc->visit ([] (const SVGData& data) + { + ASSERT_EQ (1u, data.elements.size()); + EXPECT_EQ (StrokeJoin::Bevel, *data.elements[0]->strokeJoin); + }); +} + +TEST (SVGDocumentTests, StrokeLineCapButt) +{ + auto doc = parse (""); + ASSERT_NE (nullptr, doc); + + doc->visit ([] (const SVGData& data) + { + ASSERT_EQ (1u, data.elements.size()); + ASSERT_TRUE (data.elements[0]->strokeCap.has_value()); + EXPECT_EQ (StrokeCap::Butt, *data.elements[0]->strokeCap); + }); +} + +TEST (SVGDocumentTests, StrokeLineCapRound) +{ + auto doc = parse (""); + ASSERT_NE (nullptr, doc); + + doc->visit ([] (const SVGData& data) + { + ASSERT_TRUE (data.elements[0]->strokeCap.has_value()); + EXPECT_EQ (StrokeCap::Round, *data.elements[0]->strokeCap); + }); +} + +TEST (SVGDocumentTests, StrokeLineCapSquare) +{ + auto doc = parse (""); + ASSERT_NE (nullptr, doc); + + doc->visit ([] (const SVGData& data) + { + ASSERT_TRUE (data.elements[0]->strokeCap.has_value()); + EXPECT_EQ (StrokeCap::Square, *data.elements[0]->strokeCap); + }); +} + +TEST (SVGDocumentTests, StrokeMiterLimitAttribute) +{ + auto doc = parse (""); + ASSERT_NE (nullptr, doc); + + doc->visit ([] (const SVGData& data) + { + ASSERT_EQ (1u, data.elements.size()); + EXPECT_FLOAT_EQ (2.5f, data.elements[0]->strokeMiterLimit); + }); +} + +TEST (SVGDocumentTests, StrokeMiterLimitBelowOneIsClampedToOne) +{ + auto doc = parse (""); + ASSERT_NE (nullptr, doc); + + doc->visit ([] (const SVGData& data) + { + ASSERT_EQ (1u, data.elements.size()); + EXPECT_FLOAT_EQ (1.0f, data.elements[0]->strokeMiterLimit); + }); +} + +TEST (SVGDocumentTests, DefaultStrokeMiterLimitIsFour) +{ + auto doc = parse (""); + ASSERT_NE (nullptr, doc); + + doc->visit ([] (const SVGData& data) + { + ASSERT_EQ (1u, data.elements.size()); + EXPECT_FLOAT_EQ (4.0f, data.elements[0]->strokeMiterLimit); + }); +} + +TEST (SVGDocumentTests, StrokeDashArrayAttribute) +{ + auto doc = parse (""); + ASSERT_NE (nullptr, doc); + + doc->visit ([] (const SVGData& data) + { + ASSERT_EQ (1u, data.elements.size()); + const auto& elem = *data.elements[0]; + ASSERT_TRUE (elem.strokeDashArray.has_value()); + ASSERT_EQ (2, elem.strokeDashArray->size()); + EXPECT_FLOAT_EQ (5.0f, (*elem.strokeDashArray)[0]); + EXPECT_FLOAT_EQ (3.0f, (*elem.strokeDashArray)[1]); + }); +} + +TEST (SVGDocumentTests, StrokeDashOffsetAttribute) +{ + auto doc = parse (""); + ASSERT_NE (nullptr, doc); + + doc->visit ([] (const SVGData& data) + { + ASSERT_EQ (1u, data.elements.size()); + const auto& elem = *data.elements[0]; + ASSERT_TRUE (elem.strokeDashOffset.has_value()); + EXPECT_FLOAT_EQ (2.0f, *elem.strokeDashOffset); + }); +} + +TEST (SVGDocumentTests, OpacityAttribute) +{ + auto doc = parse (""); + ASSERT_NE (nullptr, doc); + + doc->visit ([] (const SVGData& data) + { + ASSERT_EQ (1u, data.elements.size()); + const auto& elem = *data.elements[0]; + ASSERT_TRUE (elem.opacity.has_value()); + EXPECT_FLOAT_EQ (0.6f, *elem.opacity); + }); +} + +TEST (SVGDocumentTests, FillOpacityAttribute) +{ + auto doc = parse (""); + ASSERT_NE (nullptr, doc); + + doc->visit ([] (const SVGData& data) + { + ASSERT_EQ (1u, data.elements.size()); + const auto& elem = *data.elements[0]; + ASSERT_TRUE (elem.fillOpacity.has_value()); + EXPECT_FLOAT_EQ (0.4f, *elem.fillOpacity); + }); +} + +TEST (SVGDocumentTests, StrokeOpacityAttribute) +{ + auto doc = parse (""); + ASSERT_NE (nullptr, doc); + + doc->visit ([] (const SVGData& data) + { + ASSERT_EQ (1u, data.elements.size()); + const auto& elem = *data.elements[0]; + ASSERT_TRUE (elem.strokeOpacity.has_value()); + EXPECT_FLOAT_EQ (0.7f, *elem.strokeOpacity); + }); +} + +// ============================================================================== +// SVGElement transform +// ============================================================================== + +TEST (SVGDocumentTests, TransformTranslateAttribute) +{ + auto doc = parse (""); + ASSERT_NE (nullptr, doc); + + doc->visit ([] (const SVGData& data) + { + ASSERT_EQ (1u, data.elements.size()); + const auto& elem = *data.elements[0]; + ASSERT_TRUE (elem.transform.has_value()); + EXPECT_FALSE (elem.transform->isIdentity()); + }); +} + +TEST (SVGDocumentTests, NoTransformAttributeProducesNoTransform) +{ + auto doc = parse (""); + ASSERT_NE (nullptr, doc); + + doc->visit ([] (const SVGData& data) + { + ASSERT_EQ (1u, data.elements.size()); + const auto& elem = *data.elements[0]; + EXPECT_FALSE (elem.transform.has_value()); + }); +} + +// ============================================================================== +// SVGElement visibility +// ============================================================================== + +TEST (SVGDocumentTests, SymbolIsHidden) +{ + auto doc = parse (""); + ASSERT_NE (nullptr, doc); + + doc->visit ([] (const SVGData& data) + { + ASSERT_EQ (1u, data.elements.size()); + EXPECT_TRUE (data.elements[0]->hidden); + EXPECT_TRUE (data.elements[0]->isSymbol); + }); +} + +TEST (SVGDocumentTests, DisplayNoneHidesElement) +{ + auto doc = parse (""); + ASSERT_NE (nullptr, doc); + + doc->visit ([] (const SVGData& data) + { + ASSERT_EQ (1u, data.elements.size()); + EXPECT_TRUE (data.elements[0]->hidden); + }); +} + +TEST (SVGDocumentTests, VisibilityHiddenHidesElement) +{ + auto doc = parse (""); + ASSERT_NE (nullptr, doc); + + doc->visit ([] (const SVGData& data) + { + ASSERT_EQ (1u, data.elements.size()); + EXPECT_TRUE (data.elements[0]->hidden); + }); +} + +// ============================================================================== +// SVGElement text +// ============================================================================== + +TEST (SVGDocumentTests, TextElementHasTextContent) +{ + auto doc = parse ("Hello"); + ASSERT_NE (nullptr, doc); + + doc->visit ([] (const SVGData& data) + { + ASSERT_EQ (1u, data.elements.size()); + const auto& elem = *data.elements[0]; + EXPECT_EQ (String ("text"), elem.tagName); + ASSERT_TRUE (elem.text.has_value()); + EXPECT_EQ (String ("Hello"), *elem.text); + ASSERT_TRUE (elem.textPosition.has_value()); + EXPECT_FLOAT_EQ (10.0f, elem.textPosition->getX()); + EXPECT_FLOAT_EQ (50.0f, elem.textPosition->getY()); + }); +} + +TEST (SVGDocumentTests, TextElementFontSize) +{ + auto doc = parse ("Test"); + ASSERT_NE (nullptr, doc); + + doc->visit ([] (const SVGData& data) + { + ASSERT_EQ (1u, data.elements.size()); + const auto& elem = *data.elements[0]; + ASSERT_TRUE (elem.fontSize.has_value()); + EXPECT_FLOAT_EQ (18.0f, *elem.fontSize); + }); +} + +TEST (SVGDocumentTests, TextElementFontFamily) +{ + auto doc = parse ("Test"); + ASSERT_NE (nullptr, doc); + + doc->visit ([] (const SVGData& data) + { + ASSERT_EQ (1u, data.elements.size()); + const auto& elem = *data.elements[0]; + ASSERT_TRUE (elem.fontFamily.has_value()); + EXPECT_EQ (String ("Arial"), *elem.fontFamily); + }); +} + +TEST (SVGDocumentTests, TextElementFontWeightBold) +{ + auto doc = parse ("Bold"); + ASSERT_NE (nullptr, doc); + + doc->visit ([] (const SVGData& data) + { + ASSERT_EQ (1u, data.elements.size()); + const auto& elem = *data.elements[0]; + ASSERT_TRUE (elem.fontWeight.has_value()); + EXPECT_EQ (700, *elem.fontWeight); + }); +} + +TEST (SVGDocumentTests, TextElementFontWeightNumeric) +{ + auto doc = parse ("Semi-bold"); + ASSERT_NE (nullptr, doc); + + doc->visit ([] (const SVGData& data) + { + ASSERT_EQ (1u, data.elements.size()); + const auto& elem = *data.elements[0]; + ASSERT_TRUE (elem.fontWeight.has_value()); + EXPECT_EQ (600, *elem.fontWeight); + }); +} + +TEST (SVGDocumentTests, TextElementItalic) +{ + auto doc = parse ("Italic"); + ASSERT_NE (nullptr, doc); + + doc->visit ([] (const SVGData& data) + { + ASSERT_EQ (1u, data.elements.size()); + const auto& elem = *data.elements[0]; + ASSERT_TRUE (elem.fontItalic.has_value()); + EXPECT_TRUE (*elem.fontItalic); + }); +} + +TEST (SVGDocumentTests, TextElementTextAnchor) +{ + auto doc = parse ("Center"); + ASSERT_NE (nullptr, doc); + + doc->visit ([] (const SVGData& data) + { + ASSERT_EQ (1u, data.elements.size()); + const auto& elem = *data.elements[0]; + ASSERT_TRUE (elem.textAnchor.has_value()); + EXPECT_EQ (String ("middle"), *elem.textAnchor); + }); +} + +TEST (SVGDocumentTests, TspanChildPositionResolvedFromParent) +{ + auto doc = parse ( + "" + "" + "Line 1" + "Line 2" + "" + ""); + ASSERT_NE (nullptr, doc); + + doc->visit ([] (const SVGData& data) + { + ASSERT_EQ (1u, data.elements.size()); + const auto& textElem = *data.elements[0]; + EXPECT_EQ (String ("text"), textElem.tagName); + ASSERT_EQ (2u, textElem.children.size()); + + const auto& tspan1 = *textElem.children[0]; + EXPECT_EQ (String ("tspan"), tspan1.tagName); + ASSERT_TRUE (tspan1.textPosition.has_value()); + EXPECT_FLOAT_EQ (10.0f, tspan1.textPosition->getX()); + EXPECT_FLOAT_EQ (20.0f, tspan1.textPosition->getY()); + + const auto& tspan2 = *textElem.children[1]; + EXPECT_EQ (String ("tspan"), tspan2.tagName); + ASSERT_TRUE (tspan2.textPosition.has_value()); + EXPECT_FLOAT_EQ (10.0f, tspan2.textPosition->getX()); + EXPECT_FLOAT_EQ (35.0f, tspan2.textPosition->getY()); + }); +} + +// ============================================================================== +// SVGElement use / reference +// ============================================================================== + +TEST (SVGDocumentTests, UseElementHasReferenceSet) +{ + auto doc = parse ("" + "" + "" + ""); + ASSERT_NE (nullptr, doc); + + doc->visit ([] (const SVGData& data) + { + ASSERT_EQ (2u, data.elements.size()); + const auto& useElem = *data.elements[1]; + EXPECT_EQ (String ("use"), useElem.tagName); + ASSERT_TRUE (useElem.reference.has_value()); + EXPECT_EQ (String ("r"), *useElem.reference); + }); +} + +TEST (SVGDocumentTests, UseElementTranslationEmbeddedInTransform) +{ + auto doc = parse ("" + "" + "" + ""); + ASSERT_NE (nullptr, doc); + + doc->visit ([] (const SVGData& data) + { + ASSERT_EQ (2u, data.elements.size()); + const auto& useElem = *data.elements[1]; + // x/y on is baked into a translate transform + ASSERT_TRUE (useElem.transform.has_value()); + EXPECT_FALSE (useElem.transform->isIdentity()); + }); +} + +TEST (SVGDocumentTests, UseElementWithNoHrefHasNoReference) +{ + auto doc = parse (""); + ASSERT_NE (nullptr, doc); + + doc->visit ([] (const SVGData& data) + { + ASSERT_EQ (1u, data.elements.size()); + const auto& useElem = *data.elements[0]; + EXPECT_FALSE (useElem.reference.has_value()); + }); +} + +// ============================================================================== +// SVGElement viewBox and viewport +// ============================================================================== + +TEST (SVGDocumentTests, NestedSVGHasViewBoxSet) +{ + auto doc = parse ("" + "" + "" + "" + ""); + ASSERT_NE (nullptr, doc); + + doc->visit ([] (const SVGData& data) + { + ASSERT_EQ (1u, data.elements.size()); + const auto& svgElem = *data.elements[0]; + EXPECT_EQ (String ("svg"), svgElem.tagName); + ASSERT_TRUE (svgElem.viewBox.has_value()); + EXPECT_FLOAT_EQ (50.0f, svgElem.viewBox->getWidth()); + EXPECT_FLOAT_EQ (50.0f, svgElem.viewBox->getHeight()); + ASSERT_TRUE (svgElem.viewportSize.has_value()); + EXPECT_FLOAT_EQ (40.0f, svgElem.viewportSize->getWidth()); + EXPECT_FLOAT_EQ (40.0f, svgElem.viewportSize->getHeight()); + }); +} + +TEST (SVGDocumentTests, SymbolHasViewBoxAndIsSymbolFlagSet) +{ + auto doc = parse ("" + "" + "" + "" + ""); + ASSERT_NE (nullptr, doc); + + doc->visit ([] (const SVGData& data) + { + ASSERT_EQ (1u, data.elements.size()); + const auto& sym = *data.elements[0]; + EXPECT_TRUE (sym.isSymbol); + ASSERT_TRUE (sym.viewBox.has_value()); + EXPECT_FLOAT_EQ (20.0f, sym.viewBox->getWidth()); + EXPECT_FLOAT_EQ (10.0f, sym.viewBox->getHeight()); + }); +} + +// ============================================================================== +// SVGElement markers, mask, clipPath URLs +// ============================================================================== + +TEST (SVGDocumentTests, MarkerStartAttributeStoredOnElement) +{ + auto doc = parse ("" + "" + "" + ""); + ASSERT_NE (nullptr, doc); + + doc->visit ([] (const SVGData& data) + { + const auto* pathElem = data.elementsById["path_id"].get(); + // Find path in top-level elements + for (const auto& e : data.elements) + { + if (e->tagName == "path") + { + ASSERT_TRUE (e->markerStart.has_value()); + EXPECT_EQ (String ("m"), *e->markerStart); + return; + } + } + ADD_FAILURE() << "path element not found"; + }); +} + +TEST (SVGDocumentTests, MarkerEndAttributeStoredOnElement) +{ + auto doc = parse ("" + "" + "" + ""); + ASSERT_NE (nullptr, doc); + + doc->visit ([] (const SVGData& data) + { + for (const auto& e : data.elements) + { + if (e->tagName == "path") + { + ASSERT_TRUE (e->markerEnd.has_value()); + EXPECT_EQ (String ("arrow"), *e->markerEnd); + return; + } + } + ADD_FAILURE() << "path element not found"; + }); +} + +TEST (SVGDocumentTests, MarkerShorthandSetsAllThreeMarkers) +{ + auto doc = parse ("" + "" + "" + ""); + ASSERT_NE (nullptr, doc); + + doc->visit ([] (const SVGData& data) + { + for (const auto& e : data.elements) + { + if (e->tagName == "polyline") + { + ASSERT_TRUE (e->markerStart.has_value()); + ASSERT_TRUE (e->markerMid.has_value()); + ASSERT_TRUE (e->markerEnd.has_value()); + EXPECT_EQ (String ("dot"), *e->markerStart); + EXPECT_EQ (String ("dot"), *e->markerMid); + EXPECT_EQ (String ("dot"), *e->markerEnd); + return; + } + } + ADD_FAILURE() << "polyline element not found"; + }); +} + +TEST (SVGDocumentTests, MaskUrlAttributeStoredOnElement) +{ + auto doc = parse ("" + "" + "" + ""); + ASSERT_NE (nullptr, doc); + + doc->visit ([] (const SVGData& data) + { + for (const auto& e : data.elements) + { + if (e->tagName == "rect") + { + ASSERT_TRUE (e->maskUrl.has_value()); + EXPECT_EQ (String ("fade"), *e->maskUrl); + return; + } + } + ADD_FAILURE() << "rect element not found"; + }); +} + +TEST (SVGDocumentTests, ClipPathUrlAttributeStoredOnElement) +{ + auto doc = parse ("" + "" + "" + ""); + ASSERT_NE (nullptr, doc); + + doc->visit ([] (const SVGData& data) + { + for (const auto& e : data.elements) + { + if (e->tagName == "circle") + { + ASSERT_TRUE (e->clipPathUrl.has_value()); + EXPECT_EQ (String ("clip"), *e->clipPathUrl); + return; + } + } + ADD_FAILURE() << "circle element not found"; + }); +} + +TEST (SVGDocumentTests, BlendModeStoredOnElement) +{ + auto doc = parse ("" + "" + ""); + ASSERT_NE (nullptr, doc); + + doc->visit ([] (const SVGData& data) + { + ASSERT_EQ (1u, data.elements.size()); + const auto& elem = *data.elements[0]; + ASSERT_TRUE (elem.blendMode.has_value()); + EXPECT_EQ (BlendMode::Multiply, *elem.blendMode); + }); +} + +// ============================================================================== +// SVGData::gradients +// ============================================================================== + +TEST (SVGDocumentTests, LinearGradientParsedAndStored) +{ + auto doc = parse ("" + "" + "" + "" + "" + "" + "" + ""); + ASSERT_NE (nullptr, doc); + + doc->visit ([] (const SVGData& data) + { + ASSERT_EQ (1u, data.gradients.size()); + const auto& g = *data.gradients[0]; + EXPECT_EQ (SVGGradient::Linear, g.type); + EXPECT_EQ (String ("lg"), g.id); + ASSERT_EQ (2u, g.stops.size()); + EXPECT_FLOAT_EQ (0.0f, g.stops[0].offset); + EXPECT_FLOAT_EQ (1.0f, g.stops[1].offset); + }); +} + +TEST (SVGDocumentTests, LinearGradientRegisteredById) +{ + auto doc = parse ("" + "" + ""); + ASSERT_NE (nullptr, doc); + + doc->visit ([] (const SVGData& data) + { + EXPECT_TRUE (data.gradientsById.contains ("myGrad")); + ASSERT_NE (nullptr, data.gradientsById["myGrad"].get()); + EXPECT_EQ (SVGGradient::Linear, data.gradientsById["myGrad"]->type); + }); +} + +TEST (SVGDocumentTests, RadialGradientType) +{ + auto doc = parse ("" + "" + "" + "" + "" + "" + "" + ""); + ASSERT_NE (nullptr, doc); + + doc->visit ([] (const SVGData& data) + { + ASSERT_EQ (1u, data.gradients.size()); + EXPECT_EQ (SVGGradient::Radial, data.gradients[0]->type); + }); +} + +TEST (SVGDocumentTests, GradientUserSpaceOnUseUnits) +{ + auto doc = parse ("" + "" + "" + "" + "" + "" + ""); + ASSERT_NE (nullptr, doc); + + doc->visit ([] (const SVGData& data) + { + ASSERT_EQ (1u, data.gradients.size()); + EXPECT_EQ (SVGGradient::UserSpaceOnUse, data.gradients[0]->units); + EXPECT_TRUE (data.gradients[0]->hasUnits); + }); +} + +TEST (SVGDocumentTests, GradientObjectBoundingBoxUnits) +{ + auto doc = parse ("" + "" + "" + "" + "" + "" + ""); + ASSERT_NE (nullptr, doc); + + doc->visit ([] (const SVGData& data) + { + ASSERT_EQ (1u, data.gradients.size()); + EXPECT_EQ (SVGGradient::ObjectBoundingBox, data.gradients[0]->units); + }); +} + +TEST (SVGDocumentTests, GradientSpreadMethodPad) +{ + auto doc = parse ("" + "" + "" + "" + "" + "" + ""); + ASSERT_NE (nullptr, doc); + + doc->visit ([] (const SVGData& data) + { + ASSERT_EQ (1u, data.gradients.size()); + EXPECT_EQ (String ("pad"), data.gradients[0]->spreadMethod); + }); +} + +TEST (SVGDocumentTests, GradientSpreadMethodReflect) +{ + auto doc = parse ("" + "" + "" + "" + "" + ""); + ASSERT_NE (nullptr, doc); + + doc->visit ([] (const SVGData& data) + { + ASSERT_EQ (1u, data.gradients.size()); + EXPECT_EQ (String ("reflect"), data.gradients[0]->spreadMethod); + }); +} + +TEST (SVGDocumentTests, GradientStopOpacity) +{ + auto doc = parse ("" + "" + "" + "" + "" + "" + "" + ""); + ASSERT_NE (nullptr, doc); + + doc->visit ([] (const SVGData& data) + { + ASSERT_EQ (1u, data.gradients.size()); + const auto& g = *data.gradients[0]; + ASSERT_EQ (2u, g.stops.size()); + EXPECT_FLOAT_EQ (0.5f, g.stops[0].opacity); + EXPECT_FLOAT_EQ (0.9f, g.stops[1].opacity); + }); +} + +TEST (SVGDocumentTests, LinearGradientStartEndCoordinates) +{ + auto doc = parse ("" + "" + "" + "" + "" + "" + ""); + ASSERT_NE (nullptr, doc); + + doc->visit ([] (const SVGData& data) + { + ASSERT_EQ (1u, data.gradients.size()); + const auto& g = *data.gradients[0]; + EXPECT_TRUE (g.hasStart); + EXPECT_TRUE (g.hasEnd); + EXPECT_NEAR (0.1f, g.start.getX(), 0.001f); + EXPECT_NEAR (0.2f, g.start.getY(), 0.001f); + EXPECT_NEAR (0.8f, g.end.getX(), 0.001f); + EXPECT_NEAR (0.9f, g.end.getY(), 0.001f); + }); +} + +TEST (SVGDocumentTests, RadialGradientCenterAndRadius) +{ + auto doc = parse ("" + "" + "" + "" + "" + "" + ""); + ASSERT_NE (nullptr, doc); + + doc->visit ([] (const SVGData& data) + { + ASSERT_EQ (1u, data.gradients.size()); + const auto& g = *data.gradients[0]; + EXPECT_TRUE (g.hasCenter); + EXPECT_TRUE (g.hasRadius); + EXPECT_NEAR (0.4f, g.center.getX(), 0.001f); + EXPECT_NEAR (0.6f, g.center.getY(), 0.001f); + EXPECT_NEAR (0.3f, g.radius, 0.001f); + }); +} + +TEST (SVGDocumentTests, RadialGradientFocalPoint) +{ + auto doc = parse ("" + "" + "" + "" + "" + "" + ""); + ASSERT_NE (nullptr, doc); + + doc->visit ([] (const SVGData& data) + { + ASSERT_EQ (1u, data.gradients.size()); + const auto& g = *data.gradients[0]; + EXPECT_TRUE (g.hasFocal); + EXPECT_NEAR (0.3f, g.focal.getX(), 0.001f); + EXPECT_NEAR (0.4f, g.focal.getY(), 0.001f); + }); +} + +TEST (SVGDocumentTests, GradientHrefResolvesStops) +{ + auto doc = parse ("" + "" + "" + "" + "" + "" + "" + "" + ""); + ASSERT_NE (nullptr, doc); + + doc->visit ([] (const SVGData& data) + { + EXPECT_EQ (2u, data.gradients.size()); + EXPECT_TRUE (data.gradientsById.contains ("derived")); + const auto& derived = *data.gradientsById["derived"]; + // href stored as string + EXPECT_EQ (String ("base"), derived.href); + }); +} + +TEST (SVGDocumentTests, MultipleGradientsBothStored) +{ + auto doc = parse ("" + "" + "" + "" + "" + ""); + ASSERT_NE (nullptr, doc); + + doc->visit ([] (const SVGData& data) + { + EXPECT_EQ (2u, data.gradients.size()); + EXPECT_TRUE (data.gradientsById.contains ("g1")); + EXPECT_TRUE (data.gradientsById.contains ("g2")); + }); +} + +// ============================================================================== +// SVGData::filters +// ============================================================================== + +TEST (SVGDocumentTests, FilterParsedAndStored) +{ + auto doc = parse ("" + "" + ""); + ASSERT_NE (nullptr, doc); + + doc->visit ([] (const SVGData& data) + { + ASSERT_EQ (1u, data.filters.size()); + const auto& f = *data.filters[0]; + EXPECT_EQ (String ("blur"), f.id); + ASSERT_TRUE (f.gaussianBlurStdDeviation.has_value()); + EXPECT_FLOAT_EQ (4.0f, *f.gaussianBlurStdDeviation); + }); +} + +TEST (SVGDocumentTests, FilterRegisteredById) +{ + auto doc = parse ("" + "" + ""); + ASSERT_NE (nullptr, doc); + + doc->visit ([] (const SVGData& data) + { + EXPECT_TRUE (data.filtersById.contains ("myFilter")); + }); +} + +TEST (SVGDocumentTests, FilterOnElementStoredAsUrl) +{ + auto doc = parse ("" + "" + "" + ""); + ASSERT_NE (nullptr, doc); + + doc->visit ([] (const SVGData& data) + { + for (const auto& e : data.elements) + { + if (e->tagName == "rect") + { + ASSERT_TRUE (e->filterUrl.has_value()); + EXPECT_EQ (String ("f"), *e->filterUrl); + return; + } + } + ADD_FAILURE() << "rect not found"; + }); +} + +// ============================================================================== +// SVGData::clipPaths +// ============================================================================== + +TEST (SVGDocumentTests, ClipPathParsedAndStored) +{ + auto doc = parse ("" + "" + "" + "" + "" + "" + ""); + ASSERT_NE (nullptr, doc); + + doc->visit ([] (const SVGData& data) + { + ASSERT_EQ (1u, data.clipPaths.size()); + const auto& cp = *data.clipPaths[0]; + EXPECT_EQ (String ("cp"), cp.id); + EXPECT_EQ (1u, cp.elements.size()); + EXPECT_EQ (String ("rect"), cp.elements[0]->tagName); + }); +} + +TEST (SVGDocumentTests, ClipPathRegisteredById) +{ + auto doc = parse ("" + "" + ""); + ASSERT_NE (nullptr, doc); + + doc->visit ([] (const SVGData& data) + { + EXPECT_TRUE (data.clipPathsById.contains ("myClip")); + }); +} + +TEST (SVGDocumentTests, ClipPathDefaultUnitsUserSpaceOnUse) +{ + auto doc = parse ("" + "" + ""); + ASSERT_NE (nullptr, doc); + + doc->visit ([] (const SVGData& data) + { + ASSERT_EQ (1u, data.clipPaths.size()); + EXPECT_EQ (SVGClipPath::UserSpaceOnUse, data.clipPaths[0]->units); + }); +} + +TEST (SVGDocumentTests, ClipPathWithMultipleElements) +{ + auto doc = parse ("" + "" + "" + "" + "" + "" + "" + ""); + ASSERT_NE (nullptr, doc); + + doc->visit ([] (const SVGData& data) + { + ASSERT_EQ (1u, data.clipPaths.size()); + EXPECT_EQ (2u, data.clipPaths[0]->elements.size()); + }); +} + +TEST (SVGDocumentTests, ClipRuleOnClipPathChildElement) +{ + auto doc = parse ("" + "" + "" + "" + "" + "" + ""); + ASSERT_NE (nullptr, doc); + + doc->visit ([] (const SVGData& data) + { + ASSERT_EQ (1u, data.clipPaths.size()); + const auto& cp = *data.clipPaths[0]; + ASSERT_EQ (1u, cp.elements.size()); + ASSERT_TRUE (cp.elements[0]->clipRule.has_value()); + EXPECT_EQ (String ("evenodd"), *cp.elements[0]->clipRule); + }); +} + +// ============================================================================== +// SVGData::masks +// ============================================================================== + +TEST (SVGDocumentTests, MaskParsedAndStored) +{ + auto doc = parse ("" + "" + "" + "" + "" + "" + ""); + ASSERT_NE (nullptr, doc); + + doc->visit ([] (const SVGData& data) + { + ASSERT_EQ (1u, data.masks.size()); + const auto& m = *data.masks[0]; + EXPECT_EQ (String ("m"), m.id); + EXPECT_EQ (1u, m.elements.size()); + EXPECT_EQ (String ("circle"), m.elements[0]->tagName); + }); +} + +TEST (SVGDocumentTests, MaskRegisteredById) +{ + auto doc = parse ("" + "" + ""); + ASSERT_NE (nullptr, doc); + + doc->visit ([] (const SVGData& data) + { + EXPECT_TRUE (data.masksById.contains ("fadeMask")); + }); +} + +TEST (SVGDocumentTests, MaskDefaultUnitsObjectBoundingBox) +{ + auto doc = parse ("" + "" + ""); + ASSERT_NE (nullptr, doc); + + doc->visit ([] (const SVGData& data) + { + ASSERT_EQ (1u, data.masks.size()); + EXPECT_EQ (SVGMask::ObjectBoundingBox, data.masks[0]->maskUnits); + }); +} + +TEST (SVGDocumentTests, MaskUserSpaceOnUseUnits) +{ + auto doc = parse ("" + "" + ""); + ASSERT_NE (nullptr, doc); + + doc->visit ([] (const SVGData& data) + { + ASSERT_EQ (1u, data.masks.size()); + EXPECT_EQ (SVGMask::UserSpaceOnUse, data.masks[0]->maskUnits); + }); +} + +TEST (SVGDocumentTests, MaskObjectBoundingBoxUnitsExplicit) +{ + auto doc = parse ("" + "" + ""); + ASSERT_NE (nullptr, doc); + + doc->visit ([] (const SVGData& data) + { + ASSERT_EQ (1u, data.masks.size()); + EXPECT_EQ (SVGMask::ObjectBoundingBox, data.masks[0]->maskUnits); + }); +} + +// ============================================================================== +// SVGData::markers +// ============================================================================== + +TEST (SVGDocumentTests, MarkerParsedAndStored) +{ + auto doc = parse ("" + "" + "" + "" + "" + "" + ""); + ASSERT_NE (nullptr, doc); + + doc->visit ([] (const SVGData& data) + { + ASSERT_EQ (1u, data.markers.size()); + const auto& m = *data.markers[0]; + EXPECT_EQ (String ("arrow"), m.id); + EXPECT_FLOAT_EQ (10.0f, m.markerWidth); + EXPECT_FLOAT_EQ (7.0f, m.markerHeight); + EXPECT_FLOAT_EQ (10.0f, m.refX); + EXPECT_FLOAT_EQ (3.5f, m.refY); + EXPECT_EQ (1u, m.elements.size()); + }); +} + +TEST (SVGDocumentTests, MarkerRegisteredById) +{ + auto doc = parse ("" + "" + ""); + ASSERT_NE (nullptr, doc); + + doc->visit ([] (const SVGData& data) + { + EXPECT_TRUE (data.markersById.contains ("dot")); + }); +} + +TEST (SVGDocumentTests, MarkerOrientAutoProducesNullopt) +{ + auto doc = parse ("" + "" + ""); + ASSERT_NE (nullptr, doc); + + doc->visit ([] (const SVGData& data) + { + ASSERT_EQ (1u, data.markers.size()); + const auto& m = *data.markers[0]; + EXPECT_FALSE (m.orient.has_value()); + EXPECT_FALSE (m.orientAutoStartReverse); + }); +} + +TEST (SVGDocumentTests, MarkerOrientAutoStartReverseSetFlag) +{ + auto doc = parse ("" + "" + ""); + ASSERT_NE (nullptr, doc); + + doc->visit ([] (const SVGData& data) + { + ASSERT_EQ (1u, data.markers.size()); + const auto& m = *data.markers[0]; + EXPECT_TRUE (m.orientAutoStartReverse); + EXPECT_FALSE (m.orient.has_value()); + }); +} + +TEST (SVGDocumentTests, MarkerOrientFixedAngle) +{ + auto doc = parse ("" + "" + ""); + ASSERT_NE (nullptr, doc); + + doc->visit ([] (const SVGData& data) + { + ASSERT_EQ (1u, data.markers.size()); + const auto& m = *data.markers[0]; + ASSERT_TRUE (m.orient.has_value()); + EXPECT_FLOAT_EQ (45.0f, *m.orient); + EXPECT_FALSE (m.orientAutoStartReverse); + }); +} + +TEST (SVGDocumentTests, MarkerDefaultUnitsStrokeWidth) +{ + auto doc = parse (""); + ASSERT_NE (nullptr, doc); + + doc->visit ([] (const SVGData& data) + { + ASSERT_EQ (1u, data.markers.size()); + EXPECT_EQ (SVGMarker::StrokeWidth, data.markers[0]->markerUnits); + }); +} + +TEST (SVGDocumentTests, MarkerUserSpaceOnUseUnits) +{ + auto doc = parse ("" + "" + ""); + ASSERT_NE (nullptr, doc); + + doc->visit ([] (const SVGData& data) + { + ASSERT_EQ (1u, data.markers.size()); + EXPECT_EQ (SVGMarker::UserSpaceOnUse, data.markers[0]->markerUnits); + }); +} + +TEST (SVGDocumentTests, MarkerViewBoxParsed) +{ + auto doc = parse ("" + "" + "" + "" + "" + "" + ""); + ASSERT_NE (nullptr, doc); + + doc->visit ([] (const SVGData& data) + { + ASSERT_EQ (1u, data.markers.size()); + const auto& m = *data.markers[0]; + ASSERT_TRUE (m.viewBox.has_value()); + EXPECT_FLOAT_EQ (10.0f, m.viewBox->getWidth()); + EXPECT_FLOAT_EQ (10.0f, m.viewBox->getHeight()); + }); +} + +// ============================================================================== +// SVGData::patterns +// ============================================================================== + +TEST (SVGDocumentTests, PatternParsedAndStored) +{ + auto doc = parse ("" + "" + "" + "" + "" + "" + ""); + ASSERT_NE (nullptr, doc); + + doc->visit ([] (const SVGData& data) + { + ASSERT_EQ (1u, data.patterns.size()); + const auto& p = *data.patterns[0]; + EXPECT_EQ (String ("p"), p.id); + EXPECT_FLOAT_EQ (20.0f, p.width); + EXPECT_FLOAT_EQ (20.0f, p.height); + EXPECT_EQ (1u, p.elements.size()); + }); +} + +TEST (SVGDocumentTests, PatternRegisteredById) +{ + auto doc = parse ("" + "" + ""); + ASSERT_NE (nullptr, doc); + + doc->visit ([] (const SVGData& data) + { + EXPECT_TRUE (data.patternsById.contains ("myPat")); + }); +} + +TEST (SVGDocumentTests, PatternDefaultUnitsObjectBoundingBox) +{ + auto doc = parse (""); + ASSERT_NE (nullptr, doc); + + doc->visit ([] (const SVGData& data) + { + ASSERT_EQ (1u, data.patterns.size()); + EXPECT_EQ (SVGPattern::ObjectBoundingBox, data.patterns[0]->patternUnits); + }); +} + +TEST (SVGDocumentTests, PatternUserSpaceOnUseUnits) +{ + auto doc = parse ("" + "" + ""); + ASSERT_NE (nullptr, doc); + + doc->visit ([] (const SVGData& data) + { + ASSERT_EQ (1u, data.patterns.size()); + EXPECT_EQ (SVGPattern::UserSpaceOnUse, data.patterns[0]->patternUnits); + }); +} + +TEST (SVGDocumentTests, PatternViewBox) +{ + auto doc = parse ("" + "" + "" + ""); + ASSERT_NE (nullptr, doc); + + doc->visit ([] (const SVGData& data) + { + ASSERT_EQ (1u, data.patterns.size()); + const auto& p = *data.patterns[0]; + ASSERT_TRUE (p.viewBox.has_value()); + EXPECT_FLOAT_EQ (10.0f, p.viewBox->getWidth()); + EXPECT_FLOAT_EQ (10.0f, p.viewBox->getHeight()); + }); +} + +TEST (SVGDocumentTests, PatternHrefResolvedAfterParsing) +{ + auto doc = parse ("" + "" + "" + "" + "" + ""); + ASSERT_NE (nullptr, doc); + + doc->visit ([] (const SVGData& data) + { + EXPECT_TRUE (data.patternsById.contains ("derived")); + const auto& derived = *data.patternsById["derived"]; + // After resolvePatternHrefs, derived should have inherited elements from base + EXPECT_FALSE (derived.elements.empty()); + EXPECT_FLOAT_EQ (20.0f, derived.width); + EXPECT_FLOAT_EQ (20.0f, derived.height); + }); +} + +TEST (SVGDocumentTests, PatternWithTransform) +{ + auto doc = parse ("" + "" + "" + ""); + ASSERT_NE (nullptr, doc); + + doc->visit ([] (const SVGData& data) + { + ASSERT_EQ (1u, data.patterns.size()); + const auto& p = *data.patterns[0]; + EXPECT_FALSE (p.patternTransform.isIdentity()); + }); +} + +// ============================================================================== +// SVGData::cssRules +// ============================================================================== + +TEST (SVGDocumentTests, CSSTypeRuleParsed) +{ + auto doc = parse ("" + "" + ""); + ASSERT_NE (nullptr, doc); + + doc->visit ([] (const SVGData& data) + { + ASSERT_EQ (1u, data.cssRules.size()); + const auto& rule = data.cssRules[0]; + EXPECT_EQ (String ("rect"), rule.selector); + EXPECT_EQ (1, rule.specificity); + EXPECT_EQ (2, rule.declarations.size()); + }); +} + +TEST (SVGDocumentTests, CSSIdRuleHasSpecificity100) +{ + auto doc = parse ("" + "" + ""); + ASSERT_NE (nullptr, doc); + + doc->visit ([] (const SVGData& data) + { + ASSERT_EQ (1u, data.cssRules.size()); + EXPECT_EQ (100, data.cssRules[0].specificity); + }); +} + +TEST (SVGDocumentTests, CSSClassRuleHasSpecificity10) +{ + auto doc = parse ("" + "" + ""); + ASSERT_NE (nullptr, doc); + + doc->visit ([] (const SVGData& data) + { + ASSERT_EQ (1u, data.cssRules.size()); + EXPECT_EQ (10, data.cssRules[0].specificity); + }); +} + +TEST (SVGDocumentTests, CSSMultipleRulesPreserveOrder) +{ + auto doc = parse ("" + "" + ""); + ASSERT_NE (nullptr, doc); + + doc->visit ([] (const SVGData& data) + { + ASSERT_EQ (3u, data.cssRules.size()); + EXPECT_EQ (String ("rect"), data.cssRules[0].selector); + EXPECT_EQ (String ("circle"), data.cssRules[1].selector); + EXPECT_EQ (String (".x"), data.cssRules[2].selector); + EXPECT_EQ (0, data.cssRules[0].order); + EXPECT_EQ (1, data.cssRules[1].order); + EXPECT_EQ (2, data.cssRules[2].order); + }); +} + +TEST (SVGDocumentTests, CSSRulesFromMultipleStyleElements) +{ + auto doc = parse ("" + "" + "" + "" + "" + "" + ""); + ASSERT_NE (nullptr, doc); + + doc->visit ([] (const SVGData& data) + { + EXPECT_EQ (2u, data.cssRules.size()); + }); +} + +TEST (SVGDocumentTests, CSSRuleDeclarationsContainPropertyColon) +{ + auto doc = parse ("" + "" + ""); + ASSERT_NE (nullptr, doc); + + doc->visit ([] (const SVGData& data) + { + ASSERT_EQ (1u, data.cssRules.size()); + const auto& rule = data.cssRules[0]; + EXPECT_EQ (3, rule.declarations.size()); + // Each declaration contains a colon + for (int i = 0; i < rule.declarations.size(); ++i) + EXPECT_TRUE (rule.declarations[i].contains (":")) << rule.declarations[i]; + }); +} + +TEST (SVGDocumentTests, SVGCssParserInlineStyleAppliesPresentationProperties) +{ + SVGData data; + SVGCssParser parser (data); + SVGElement element; + element.tagName = "rect"; + + parser.parseCSSStyle ("fill: none;" + "stroke: currentColor;" + "stroke-width: 3.5;" + "stroke-linejoin: round;" + "stroke-linecap: square;" + "opacity: 0.25;" + "visibility: collapse;" + "font-family: \"Yup Sans\";" + "font-size: 18px;" + "text-anchor: middle;" + "letter-spacing: 2px;" + "word-spacing: 3px;" + "font-weight: bolder;" + "font-style: oblique;" + "clip-path: url(#clip);" + "mask: url(#mask);" + "marker-start: url(#start);" + "marker-mid: url(#mid);" + "marker-end: url(#end);" + "stroke-miterlimit: 0.25;" + "filter: url(#blur);" + "stroke-dasharray: 4 6;" + "stroke-dashoffset: 2;" + "clip-rule: evenodd;" + "unsupported-property: ignored", + element); + + EXPECT_TRUE (element.noFill); + EXPECT_TRUE (element.strokeCurrentColor); + ASSERT_TRUE (element.strokeWidth.has_value()); + EXPECT_FLOAT_EQ (3.5f, *element.strokeWidth); + ASSERT_TRUE (element.strokeJoin.has_value()); + EXPECT_EQ (StrokeJoin::Round, *element.strokeJoin); + ASSERT_TRUE (element.strokeCap.has_value()); + EXPECT_EQ (StrokeCap::Square, *element.strokeCap); + ASSERT_TRUE (element.opacity.has_value()); + EXPECT_FLOAT_EQ (0.25f, *element.opacity); + EXPECT_TRUE (element.hidden); + ASSERT_TRUE (element.fontFamily.has_value()); + EXPECT_EQ (String ("Yup Sans"), *element.fontFamily); + ASSERT_TRUE (element.fontSize.has_value()); + EXPECT_FLOAT_EQ (18.0f, *element.fontSize); + ASSERT_TRUE (element.textAnchor.has_value()); + EXPECT_EQ (String ("middle"), *element.textAnchor); + ASSERT_TRUE (element.letterSpacing.has_value()); + EXPECT_FLOAT_EQ (2.0f, *element.letterSpacing); + ASSERT_TRUE (element.wordSpacing.has_value()); + EXPECT_FLOAT_EQ (3.0f, *element.wordSpacing); + ASSERT_TRUE (element.fontWeight.has_value()); + EXPECT_EQ (700, *element.fontWeight); + ASSERT_TRUE (element.fontItalic.has_value()); + EXPECT_TRUE (*element.fontItalic); + ASSERT_TRUE (element.clipPathUrl.has_value()); + EXPECT_EQ (String ("clip"), *element.clipPathUrl); + ASSERT_TRUE (element.maskUrl.has_value()); + EXPECT_EQ (String ("mask"), *element.maskUrl); + ASSERT_TRUE (element.markerStart.has_value()); + EXPECT_EQ (String ("start"), *element.markerStart); + ASSERT_TRUE (element.markerMid.has_value()); + EXPECT_EQ (String ("mid"), *element.markerMid); + ASSERT_TRUE (element.markerEnd.has_value()); + EXPECT_EQ (String ("end"), *element.markerEnd); + EXPECT_FLOAT_EQ (1.0f, element.strokeMiterLimit); + ASSERT_TRUE (element.filterUrl.has_value()); + EXPECT_EQ (String ("blur"), *element.filterUrl); + ASSERT_TRUE (element.strokeDashArray.has_value()); + ASSERT_EQ (2, element.strokeDashArray->size()); + EXPECT_FLOAT_EQ (4.0f, (*element.strokeDashArray)[0]); + EXPECT_FLOAT_EQ (6.0f, (*element.strokeDashArray)[1]); + ASSERT_TRUE (element.strokeDashOffset.has_value()); + EXPECT_FLOAT_EQ (2.0f, *element.strokeDashOffset); + ASSERT_TRUE (element.clipRule.has_value()); + EXPECT_EQ (String ("evenodd"), *element.clipRule); +} + +TEST (SVGDocumentTests, SVGCssParserApplyStylePropertyCoversAlternateBranches) +{ + SVGData data; + SVGCssParser parser (data); + SVGElement element; + + parser.applyStyleProperty ("fill", "url(#gradient)", element); + ASSERT_TRUE (element.fillUrl.has_value()); + EXPECT_EQ (String ("gradient"), *element.fillUrl); + + parser.applyStyleProperty ("stroke", "none", element); + EXPECT_TRUE (element.noStroke); + + parser.applyStyleProperty ("stroke", "currentColor", element); + EXPECT_TRUE (element.strokeCurrentColor); + + parser.applyStyleProperty ("stroke-linejoin", "miter", element); + ASSERT_TRUE (element.strokeJoin.has_value()); + EXPECT_EQ (StrokeJoin::Miter, *element.strokeJoin); + + parser.applyStyleProperty ("stroke-linejoin", "bevel", element); + EXPECT_EQ (StrokeJoin::Bevel, *element.strokeJoin); + + parser.applyStyleProperty ("stroke-linecap", "round", element); + ASSERT_TRUE (element.strokeCap.has_value()); + EXPECT_EQ (StrokeCap::Round, *element.strokeCap); + + parser.applyStyleProperty ("stroke-linecap", "butt", element); + EXPECT_EQ (StrokeCap::Butt, *element.strokeCap); + + parser.applyStyleProperty ("font-weight", "lighter", element); + ASSERT_TRUE (element.fontWeight.has_value()); + EXPECT_EQ (400, *element.fontWeight); + + parser.applyStyleProperty ("font-weight", "600", element); + EXPECT_EQ (600, *element.fontWeight); + + parser.applyStyleProperty ("font-style", "normal", element); + ASSERT_TRUE (element.fontItalic.has_value()); + EXPECT_FALSE (*element.fontItalic); + + parser.applyStyleProperty ("marker", "url(#marker)", element); + ASSERT_TRUE (element.markerStart.has_value()); + ASSERT_TRUE (element.markerMid.has_value()); + ASSERT_TRUE (element.markerEnd.has_value()); + EXPECT_EQ (String ("marker"), *element.markerStart); + EXPECT_EQ (String ("marker"), *element.markerMid); + EXPECT_EQ (String ("marker"), *element.markerEnd); + + element.filterUrl = String ("previous"); + parser.applyStyleProperty ("filter", "none", element); + EXPECT_FALSE (element.filterUrl.has_value()); + + parser.applyStyleProperty ("filter", "blur(2px)", element); + EXPECT_FALSE (element.filterUrl.has_value()); + + element.strokeDashArray = Array ({ 1.0f, 2.0f }); + parser.applyStyleProperty ("stroke-dasharray", "none", element); + EXPECT_FALSE (element.strokeDashArray.has_value()); + + parser.applyStyleProperty ("fill-rule", "nonzero", element); + ASSERT_TRUE (element.fillRule.has_value()); + EXPECT_EQ (String ("nonzero"), *element.fillRule); + + parser.applyStyleProperty ("font-variant", "small-caps", element); + parser.applyStyleProperty ("font-stretch", "condensed", element); + parser.applyStyleProperty ("font", "italic 12px serif", element); + parser.applyStyleProperty ("dominant-baseline", "middle", element); + parser.applyStyleProperty ("alignment-baseline", "central", element); + parser.applyStyleProperty ("baseline-shift", "super", element); +} + +TEST (SVGDocumentTests, SVGCssParserApplyStylePropertyCoversBlendModes) +{ + struct BlendModeCase + { + const char* cssValue; + BlendMode expectedMode; + }; + + const BlendModeCase cases[] = { + { "multiply", BlendMode::Multiply }, + { "screen", BlendMode::Screen }, + { "overlay", BlendMode::Overlay }, + { "darken", BlendMode::Darken }, + { "lighten", BlendMode::Lighten }, + { "color-dodge", BlendMode::ColorDodge }, + { "color-burn", BlendMode::ColorBurn }, + { "hard-light", BlendMode::HardLight }, + { "soft-light", BlendMode::SoftLight }, + { "difference", BlendMode::Difference }, + { "exclusion", BlendMode::Exclusion }, + { "hue", BlendMode::Hue }, + { "saturation", BlendMode::Saturation }, + { "color", BlendMode::Color }, + { "luminosity", BlendMode::Luminosity } + }; + + SVGData data; + SVGCssParser parser (data); + + for (const auto& testCase : cases) + { + SVGElement element; + parser.applyStyleProperty ("mix-blend-mode", testCase.cssValue, element); + + ASSERT_TRUE (element.blendMode.has_value()) << testCase.cssValue; + EXPECT_EQ (testCase.expectedMode, *element.blendMode) << testCase.cssValue; + } +} + +TEST (SVGDocumentTests, SVGCssParserParseStyleElementStoresSpecificityAndOrder) +{ + SVGData data; + SVGCssParser parser (data); + XmlElement styleElement ("style"); + styleElement.addTextElement (" , #target { fill: red; }" + ".highlight { stroke: blue; }" + "rect#target { opacity: 0.5; }" + "circle.highlight { fill: green; }" + "path { stroke-width: 2; }"); + + parser.parseStyleElement (styleElement); + + ASSERT_EQ (5u, data.cssRules.size()); + EXPECT_EQ (String ("#target"), data.cssRules[0].selector); + EXPECT_EQ (100, data.cssRules[0].specificity); + EXPECT_EQ (0, data.cssRules[0].order); + EXPECT_EQ (String (".highlight"), data.cssRules[1].selector); + EXPECT_EQ (10, data.cssRules[1].specificity); + EXPECT_EQ (1, data.cssRules[1].order); + EXPECT_EQ (String ("rect#target"), data.cssRules[2].selector); + EXPECT_EQ (101, data.cssRules[2].specificity); + EXPECT_EQ (2, data.cssRules[2].order); + EXPECT_EQ (String ("circle.highlight"), data.cssRules[3].selector); + EXPECT_EQ (11, data.cssRules[3].specificity); + EXPECT_EQ (3, data.cssRules[3].order); + EXPECT_EQ (String ("path"), data.cssRules[4].selector); + EXPECT_EQ (1, data.cssRules[4].specificity); + EXPECT_EQ (4, data.cssRules[4].order); +} + +TEST (SVGDocumentTests, SVGCssParserMatchesSimpleSelectors) +{ + SVGData data; + SVGCssParser parser (data); + XmlElement rect ("rect"); + rect.setAttribute ("id", "target"); + rect.setAttribute ("class", "highlight selected"); + + EXPECT_TRUE (parser.matchesCssSelector (rect, SVGCssRule { "rect", {}, 0, 0 })); + EXPECT_TRUE (parser.matchesCssSelector (rect, SVGCssRule { "#target", {}, 0, 0 })); + EXPECT_TRUE (parser.matchesCssSelector (rect, SVGCssRule { ".highlight", {}, 0, 0 })); + EXPECT_TRUE (parser.matchesCssSelector (rect, SVGCssRule { "rect#target.highlight", {}, 0, 0 })); + + EXPECT_FALSE (parser.matchesCssSelector (rect, SVGCssRule { "", {}, 0, 0 })); + EXPECT_FALSE (parser.matchesCssSelector (rect, SVGCssRule { "g rect", {}, 0, 0 })); + EXPECT_FALSE (parser.matchesCssSelector (rect, SVGCssRule { ".missing", {}, 0, 0 })); + EXPECT_FALSE (parser.matchesCssSelector (rect, SVGCssRule { "circle.highlight", {}, 0, 0 })); +} + +TEST (SVGDocumentTests, SVGCssParserApplyStylesheetRulesUsesSpecificityOrder) +{ + SVGData data; + data.cssRules.push_back ({ "rect", { "fill: red" }, 1, 1 }); + data.cssRules.push_back ({ ".highlight", { "fill: blue" }, 10, 0 }); + data.cssRules.push_back ({ "#target", { "fill: green" }, 100, 2 }); + + SVGCssParser parser (data); + XmlElement rect ("rect"); + rect.setAttribute ("id", "target"); + rect.setAttribute ("class", "highlight"); + + SVGElement element; + element.tagName = "rect"; + parser.applyStylesheetRules (rect, element); + + ASSERT_TRUE (element.fillColor.has_value()); +} + +// ============================================================================== +// SVGElement class names +// ============================================================================== + +TEST (SVGDocumentTests, ClassAttributeParsedIntoArray) +{ + auto doc = parse (""); + ASSERT_NE (nullptr, doc); + + doc->visit ([] (const SVGData& data) + { + ASSERT_EQ (1u, data.elements.size()); + const auto& elem = *data.elements[0]; + EXPECT_EQ (3, elem.classNames.size()); + EXPECT_TRUE (elem.classNames.contains ("foo")); + EXPECT_TRUE (elem.classNames.contains ("bar")); + EXPECT_TRUE (elem.classNames.contains ("baz")); + }); +} + +TEST (SVGDocumentTests, SingleClassParsed) +{ + auto doc = parse (""); + ASSERT_NE (nullptr, doc); + + doc->visit ([] (const SVGData& data) + { + ASSERT_EQ (1u, data.elements.size()); + EXPECT_EQ (1, data.elements[0]->classNames.size()); + EXPECT_TRUE (data.elements[0]->classNames.contains ("highlight")); + }); +} + +TEST (SVGDocumentTests, NoClassAttributeProducesEmptyArray) +{ + auto doc = parse (""); + ASSERT_NE (nullptr, doc); + + doc->visit ([] (const SVGData& data) + { + ASSERT_EQ (1u, data.elements.size()); + EXPECT_EQ (0, data.elements[0]->classNames.size()); + }); +} + +// ============================================================================== +// SVGDocument::clear +// ============================================================================== + +TEST (SVGDocumentTests, ClearResetsViewBoxToEmpty) +{ + auto doc = parse (""); + ASSERT_NE (nullptr, doc); + + doc->clear(); + + EXPECT_TRUE (doc->getBounds().isEmpty()); + doc->visit ([] (const SVGData& data) + { + EXPECT_TRUE (data.viewBox.isEmpty()); + EXPECT_EQ (0u, data.elements.size()); + EXPECT_EQ (0u, data.gradients.size()); + EXPECT_EQ (0u, data.filters.size()); + EXPECT_EQ (0u, data.clipPaths.size()); + EXPECT_EQ (0u, data.masks.size()); + EXPECT_EQ (0u, data.markers.size()); + EXPECT_EQ (0u, data.patterns.size()); + EXPECT_EQ (0u, data.cssRules.size()); + }); +} diff --git a/tests/yup_graphics/yup_SVGParser.cpp b/tests/yup_graphics/yup_SVGParser.cpp new file mode 100644 index 000000000..022735941 --- /dev/null +++ b/tests/yup_graphics/yup_SVGParser.cpp @@ -0,0 +1,2255 @@ +/* + ============================================================================== + + This file is part of the YUP library. + Copyright (c) 2026 - kunitoki@gmail.com + + YUP is an open source library subject to open-source licensing. + + The code included in this file is provided under the terms of the ISC license + http://www.isc.org/downloads/software-support-policy/isc-license. Permission + to use, copy, modify, and/or distribute this software for any purpose with or + without fee is hereby granted provided that the above copyright notice and + this permission notice appear in all copies. + + YUP IS PROVIDED "AS IS" WITHOUT ANY WARRANTY, AND ALL WARRANTIES, WHETHER + EXPRESSED OR IMPLIED, INCLUDING MERCHANTABILITY AND FITNESS FOR PURPOSE, ARE + DISCLAIMED. + + ============================================================================== +*/ + +#include + +#include + +using namespace yup; + +namespace +{ + +auto makeHeadlessGraphics (int w = 64, int h = 64) +{ + struct HeadlessGfx + { + std::unique_ptr ctx; + std::unique_ptr renderer; + std::unique_ptr graphics; + }; + + HeadlessGfx g; + g.ctx = GraphicsContext::createContext (GraphicsContext::Headless, {}); + g.renderer = g.ctx->makeRenderer (w, h); + g.graphics = std::make_unique (*g.ctx, *g.renderer); + return g; +} + +} // namespace + +// ============================================================================== +// Root SVG element parsing +// ============================================================================== + +TEST (SVGParserTests, ParseMinimalSVGTag) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ("")); +} + +TEST (SVGParserTests, ParseSVGWithXmlDeclaration) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ("")); + EXPECT_FLOAT_EQ (10.0f, d.getBounds().getWidth()); + EXPECT_FLOAT_EQ (10.0f, d.getBounds().getHeight()); +} + +TEST (SVGParserTests, ParseSVGWithNamespace) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ("")); + EXPECT_FLOAT_EQ (20.0f, d.getBounds().getWidth()); + EXPECT_FLOAT_EQ (30.0f, d.getBounds().getHeight()); +} + +TEST (SVGParserTests, ParseSVGWithXlinkNamespace) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ("")); +} + +TEST (SVGParserTests, ParseSVGWithWidthAndHeight) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ("")); + EXPECT_FLOAT_EQ (120.0f, d.getBounds().getWidth()); + EXPECT_FLOAT_EQ (80.0f, d.getBounds().getHeight()); +} + +TEST (SVGParserTests, ParseSVGViewBoxTakesPrecedenceOverWidthHeight) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ("")); + EXPECT_FLOAT_EQ (50.0f, d.getBounds().getWidth()); + EXPECT_FLOAT_EQ (25.0f, d.getBounds().getHeight()); +} + +TEST (SVGParserTests, ParseSVGWithViewBoxNonZeroOrigin) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ("")); + EXPECT_FLOAT_EQ (100.0f, d.getBounds().getWidth()); + EXPECT_FLOAT_EQ (80.0f, d.getBounds().getHeight()); +} + +TEST (SVGParserTests, ParseSVGReturnsFalseForNonSVGRoot) +{ + Drawable d; + EXPECT_FALSE (d.parseSVG ("")); +} + +TEST (SVGParserTests, ParseSVGReturnsFalseForInvalidXML) +{ + Drawable d; + EXPECT_FALSE (d.parseSVG ("not xml at all")); +} + +TEST (SVGParserTests, ParseSVGReturnsFalseForEmptyString) +{ + Drawable d; + EXPECT_FALSE (d.parseSVG ("")); +} + +TEST (SVGParserTests, ParseSVGReturnsFalseForPartialXML) +{ + Drawable d; + EXPECT_FALSE (d.parseSVG ("")); +} + +// ============================================================================== +// Path element — command coverage +// ============================================================================== + +TEST (SVGParserTests, ParsePathWithMoveToLineTo) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ("")); +} + +TEST (SVGParserTests, ParsePathWithRelativeMoveToLineTo) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ("")); +} + +TEST (SVGParserTests, ParsePathWithHorizontalAndVerticalLines) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ("")); +} + +TEST (SVGParserTests, ParsePathWithRelativeHorizontalVertical) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ("")); +} + +TEST (SVGParserTests, ParsePathWithCubicBezier) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ("")); +} + +TEST (SVGParserTests, ParsePathWithRelativeCubicBezier) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ("")); +} + +TEST (SVGParserTests, ParsePathWithSmoothCubicBezier) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ("")); +} + +TEST (SVGParserTests, ParsePathWithRelativeSmoothCubicBezier) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ("")); +} + +TEST (SVGParserTests, ParsePathWithQuadraticBezier) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ("")); +} + +TEST (SVGParserTests, ParsePathWithRelativeQuadraticBezier) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ("")); +} + +TEST (SVGParserTests, ParsePathWithSmoothQuadraticBezier) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ("")); +} + +TEST (SVGParserTests, ParsePathWithArcAbsolute) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ("")); +} + +TEST (SVGParserTests, ParsePathWithArcRelative) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ("")); +} + +TEST (SVGParserTests, ParsePathWithArcSweepFlags) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ("" + "" + "" + "" + "" + "")); +} + +TEST (SVGParserTests, ParsePathWithClosePath) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ("")); +} + +TEST (SVGParserTests, ParsePathWithLowercaseClose) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ("")); +} + +TEST (SVGParserTests, ParsePathWithMultipleSubpaths) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ("")); +} + +TEST (SVGParserTests, ParsePathWithImplicitLineTo) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ("")); +} + +TEST (SVGParserTests, ParsePathWithCompactNotation) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ("")); +} + +TEST (SVGParserTests, ParsePathWithInvalidStartCommandStillSucceeds) +{ + Drawable d; + // Child element failures don't abort the document parse — the bad path is + // silently skipped so the document still reports success. + EXPECT_TRUE (d.parseSVG ("")); +} + +TEST (SVGParserTests, ParsePathReturnsTrueForEmptyD) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ("")); +} + +TEST (SVGParserTests, ParsePathWithEvenOddFillRule) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ("")); +} + +TEST (SVGParserTests, ParsePathWithNonZeroFillRule) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ("")); +} + +// ============================================================================== +// Basic shapes +// ============================================================================== + +TEST (SVGParserTests, ParseRectBasic) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ("")); +} + +TEST (SVGParserTests, ParseRectWithRoundedCorners) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ("")); +} + +TEST (SVGParserTests, ParseRectWithOnlyRx) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ("")); +} + +TEST (SVGParserTests, ParseRectWithOnlyRy) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ("")); +} + +TEST (SVGParserTests, ParseRectWithZeroDimensions) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ("")); +} + +TEST (SVGParserTests, ParseCircleBasic) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ("")); +} + +TEST (SVGParserTests, ParseCircleAtOrigin) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ("")); +} + +TEST (SVGParserTests, ParseCircleWithZeroRadius) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ("")); +} + +TEST (SVGParserTests, ParseEllipseBasic) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ("")); +} + +TEST (SVGParserTests, ParseEllipseAtOrigin) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ("")); +} + +TEST (SVGParserTests, ParseLineBasic) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ("")); +} + +TEST (SVGParserTests, ParseLineHorizontal) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ("")); +} + +TEST (SVGParserTests, ParseLineVertical) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ("")); +} + +TEST (SVGParserTests, ParseLineSamePoint) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ("")); +} + +TEST (SVGParserTests, ParsePolygonTriangle) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ("")); +} + +TEST (SVGParserTests, ParsePolygonSquare) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ("")); +} + +TEST (SVGParserTests, ParsePolygonWithCommasAndSpaces) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ("")); +} + +TEST (SVGParserTests, ParsePolygonWithEmptyPoints) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ("")); +} + +TEST (SVGParserTests, ParsePolylineBasic) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ("")); +} + +TEST (SVGParserTests, ParsePolylineOpenPath) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ("")); +} + +// ============================================================================== +// Groups and structural elements +// ============================================================================== + +TEST (SVGParserTests, ParseGroupEmpty) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ("")); +} + +TEST (SVGParserTests, ParseGroupWithSingleChild) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ("")); +} + +TEST (SVGParserTests, ParseGroupWithMultipleChildren) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ("" + "" + "" + "" + "")); +} + +TEST (SVGParserTests, ParseDeepNestedGroups) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ("" + "" + "")); +} + +TEST (SVGParserTests, ParseGroupWithId) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ("")); +} + +TEST (SVGParserTests, ParseGroupWithClass) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ("")); +} + +TEST (SVGParserTests, ParseDefsEmpty) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ("")); +} + +TEST (SVGParserTests, ParseDefsWithMultipleDefinitions) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ( + "" + "" + "" + "" + "" + "" + "" + "")); +} + +TEST (SVGParserTests, ParseSymbolHiddenByDefault) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ( + "" + "" + "" + "" + "")); +} + +TEST (SVGParserTests, ParseUseWithHref) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ( + "" + "" + "" + "" + "")); +} + +TEST (SVGParserTests, ParseUseWithXlinkHref) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ( + "" + "" + "" + "")); +} + +TEST (SVGParserTests, ParseUseWithMissingReference) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ( + "" + "" + "")); +} + +TEST (SVGParserTests, ParseUseWithViewportSize) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ( + "" + "" + "" + "" + "" + "" + "" + "" + "")); +} + +// ============================================================================== +// Text elements +// ============================================================================== + +TEST (SVGParserTests, ParseTextBasic) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ("Hello World")); +} + +TEST (SVGParserTests, ParseTextWithFontAttributes) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ( + "" + "Bold Text" + "")); +} + +TEST (SVGParserTests, ParseTextWithTextAnchor) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ( + "" + "Centered" + "Left" + "Right" + "")); +} + +TEST (SVGParserTests, ParseTextWithTspanChildren) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ( + "" + "" + "Line one" + "Line two" + "Line three" + "" + "")); +} + +TEST (SVGParserTests, ParseTspanWithDxDy) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ( + "" + "" + "before" + "lifted" + "after" + "" + "")); +} + +TEST (SVGParserTests, ParseTextWithMultiplePositions) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ( + "" + "A B C D" + "")); +} + +TEST (SVGParserTests, ParseTextWithTransform) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ( + "" + "Rotated" + "")); +} + +TEST (SVGParserTests, ParseTextEmpty) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ("")); +} + +// ============================================================================== +// Image elements +// ============================================================================== + +TEST (SVGParserTests, ParseImageWithDataUri) +{ + Drawable d; + // 1x1 red PNG as data URI + EXPECT_TRUE (d.parseSVG ( + "" + "" + "")); +} + +TEST (SVGParserTests, ParseImageWithCustomResolver) +{ + Drawable d; + + Drawable::ParseOptions opts; + opts.imageResolver = [] (StringRef href, const File&) -> std::optional + { + if (String (href.text) == "test-icon") + { + Image img (4, 4, PixelFormat::RGBA); + img.fill (0xff0000ff); + return img; + } + return std::nullopt; + }; + + EXPECT_TRUE (d.parseSVG ( + "" + "" + "", + opts)); +} + +TEST (SVGParserTests, ParseImageWithXlinkHref) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ( + "" + "" + "")); +} + +TEST (SVGParserTests, ParseImageWithMissingHref) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ("")); +} + +TEST (SVGParserTests, ParseImageDefaultsToPreservingAspectRatio) +{ + auto doc = SVGParser::parse (""); + ASSERT_NE (nullptr, doc); + + doc->visit ([] (const SVGData& data) + { + ASSERT_EQ (1u, data.elements.size()); + + const auto& image = *data.elements.front(); + EXPECT_EQ (Fitting::scaleToFit, image.preserveAspectRatioFitting); + EXPECT_TRUE (image.preserveAspectRatioJustification.testFlags (Justification::center)); + }); +} + +TEST (SVGParserTests, ParseImagePreserveAspectRatioAttribute) +{ + auto doc = SVGParser::parse (""); + ASSERT_NE (nullptr, doc); + + doc->visit ([] (const SVGData& data) + { + ASSERT_EQ (1u, data.elements.size()); + + const auto& image = *data.elements.front(); + EXPECT_EQ (Fitting::scaleToFill, image.preserveAspectRatioFitting); + EXPECT_TRUE (image.preserveAspectRatioJustification.testFlags (Justification::right)); + EXPECT_TRUE (image.preserveAspectRatioJustification.testFlags (Justification::top)); + }); +} + +// ============================================================================== +// Gradients +// ============================================================================== + +TEST (SVGParserTests, ParseLinearGradientVertical) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ( + "" + "" + "" + "" + "" + "" + "" + "" + "")); +} + +TEST (SVGParserTests, ParseLinearGradientHorizontal) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ( + "" + "" + "" + "" + "" + "" + "" + "" + "" + "")); +} + +TEST (SVGParserTests, ParseLinearGradientUserSpaceOnUse) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ( + "" + "" + "" + "" + "" + "" + "" + "" + "")); +} + +TEST (SVGParserTests, ParseLinearGradientWithGradientTransform) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ( + "" + "" + "" + "" + "" + "" + "" + "" + "")); +} + +TEST (SVGParserTests, ParseLinearGradientHrefInheritance) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ( + "" + "" + "" + "" + "" + "" + "" + "" + "" + "")); +} + +TEST (SVGParserTests, ParseLinearGradientWithStopOpacity) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ( + "" + "" + "" + "" + "" + "" + "" + "" + "")); +} + +TEST (SVGParserTests, ParseRadialGradientBasic) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ( + "" + "" + "" + "" + "" + "" + "" + "" + "")); +} + +TEST (SVGParserTests, ParseRadialGradientWithFocalPoint) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ( + "" + "" + "" + "" + "" + "" + "" + "" + "")); +} + +TEST (SVGParserTests, ParseRadialGradientUserSpaceOnUse) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ( + "" + "" + "" + "" + "" + "" + "" + "" + "")); +} + +TEST (SVGParserTests, ParseGradientSpreadMethodReflect) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ( + "" + "" + "" + "" + "" + "" + "" + "" + "")); +} + +TEST (SVGParserTests, ParseGradientSpreadMethodRepeat) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ( + "" + "" + "" + "" + "" + "" + "" + "" + "")); +} + +TEST (SVGParserTests, ParseGradientUsedOnStroke) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ( + "" + "" + "" + "" + "" + "" + "" + "" + "")); +} + +// ============================================================================== +// ClipPath +// ============================================================================== + +TEST (SVGParserTests, ParseClipPathWithRect) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ( + "" + "" + "" + "" + "" + "" + "" + "")); +} + +TEST (SVGParserTests, ParseClipPathWithCircle) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ( + "" + "" + "" + "" + "" + "" + "" + "")); +} + +TEST (SVGParserTests, ParseClipPathWithPath) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ( + "" + "" + "" + "" + "" + "" + "" + "")); +} + +TEST (SVGParserTests, ParseClipPathWithEvenOddClipRule) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ( + "" + "" + "" + "" + "" + "" + "" + "")); +} + +TEST (SVGParserTests, ParseClipPathNestedUse) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ( + "" + "" + "" + "" + "" + "" + "" + "" + "")); +} + +TEST (SVGParserTests, ParseClipPathWithMissingId) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ( + "" + "" + "")); +} + +// ============================================================================== +// Mask +// ============================================================================== + +TEST (SVGParserTests, ParseMaskWithWhiteFill) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ( + "" + "" + "" + "" + "" + "" + "" + "")); +} + +TEST (SVGParserTests, ParseMaskWithGradientAlpha) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ( + "" + "" + "" + "" + "" + "" + "" + "" + "" + "" + "" + "")); +} + +TEST (SVGParserTests, ParseMaskUserSpaceOnUse) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ( + "" + "" + "" + "" + "" + "" + "" + "")); +} + +TEST (SVGParserTests, ParseMaskObjectBoundingBox) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ( + "" + "" + "" + "" + "" + "" + "" + "")); +} + +TEST (SVGParserTests, ParseMaskAppliedToGroup) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ( + "" + "" + "" + "" + "" + "" + "" + "" + "" + "" + "")); +} + +// ============================================================================== +// Markers +// ============================================================================== + +TEST (SVGParserTests, ParseMarkerOrientAuto) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ( + "" + "" + "" + "" + "" + "" + "" + "")); +} + +TEST (SVGParserTests, ParseMarkerOrientFixed) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ( + "" + "" + "" + "" + "" + "" + "" + "")); +} + +TEST (SVGParserTests, ParseMarkerOrientAutoStartReverse) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ( + "" + "" + "" + "" + "" + "" + "" + "")); +} + +TEST (SVGParserTests, ParseMarkerStrokeWidthUnits) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ( + "" + "" + "" + "" + "" + "" + "" + "")); +} + +TEST (SVGParserTests, ParseMarkerUserSpaceOnUse) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ( + "" + "" + "" + "" + "" + "" + "" + "")); +} + +TEST (SVGParserTests, ParseMarkerWithViewBox) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ( + "" + "" + "" + "" + "" + "" + "" + "")); +} + +TEST (SVGParserTests, ParseMarkerShorthand) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ( + "" + "" + "" + "" + "" + "" + "" + "")); +} + +TEST (SVGParserTests, ParseMarkersOnPolyline) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ( + "" + "" + "" + "" + "" + "" + "" + "")); +} + +// ============================================================================== +// Patterns +// ============================================================================== + +TEST (SVGParserTests, ParsePatternUserSpaceOnUse) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ( + "" + "" + "" + "" + "" + "" + "" + "")); +} + +TEST (SVGParserTests, ParsePatternObjectBoundingBox) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ( + "" + "" + "" + "" + "" + "" + "" + "")); +} + +TEST (SVGParserTests, ParsePatternWithViewBox) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ( + "" + "" + "" + "" + "" + "" + "" + "")); +} + +TEST (SVGParserTests, ParsePatternWithTransform) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ( + "" + "" + "" + "" + "" + "" + "" + "")); +} + +TEST (SVGParserTests, ParsePatternHrefInheritance) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ( + "" + "" + "" + "" + "" + "" + "" + "" + "")); +} + +TEST (SVGParserTests, ParsePatternWithComplexContent) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ( + "" + "" + "" + "" + "" + "" + "" + "" + "" + "" + "")); +} + +// ============================================================================== +// Filters +// ============================================================================== + +TEST (SVGParserTests, ParseFilterGaussianBlur) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ( + "" + "" + "" + "" + "" + "" + "" + "")); +} + +TEST (SVGParserTests, ParseFilterWithHref) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ( + "" + "" + "" + "" + "" + "" + "" + "" + "")); +} + +TEST (SVGParserTests, ParseFilterNoneResetsFilter) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ( + "" + "" + "" + "" + "" + "" + "")); +} + +// ============================================================================== +// CSS styling +// ============================================================================== + +TEST (SVGParserTests, ParseCSSTypeSelector) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ( + "" + "" + "" + "")); +} + +TEST (SVGParserTests, ParseCSSIdSelector) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ( + "" + "" + "" + "")); +} + +TEST (SVGParserTests, ParseCSSClassSelector) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ( + "" + "" + "" + "" + "")); +} + +TEST (SVGParserTests, ParseCSSMultipleSelectors) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ( + "" + "" + "" + "" + "")); +} + +TEST (SVGParserTests, ParseCSSInlineStyleOverridesAttribute) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ( + "" + "" + "" + "")); +} + +TEST (SVGParserTests, ParseCSSDisplayNone) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ( + "" + "" + "" + "")); +} + +TEST (SVGParserTests, ParseCSSVisibilityHidden) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ( + "" + "" + "" + "")); +} + +TEST (SVGParserTests, ParseCSSCurrentColor) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ( + "" + "" + "" + "")); +} + +TEST (SVGParserTests, ParseCSSFillOpacityAndStrokeOpacity) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ( + "" + "" + "")); +} + +TEST (SVGParserTests, ParseCSSFontProperties) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ( + "" + "" + "Styled text" + "")); +} + +TEST (SVGParserTests, ParseCSSLetterAndWordSpacing) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ( + "" + "Spaced out text" + "")); +} + +TEST (SVGParserTests, ParseCSSStrokeDasharray) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ( + "" + "" + "")); +} + +TEST (SVGParserTests, ParseCSSStrokeDasharrayNone) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ( + "" + "" + "")); +} + +TEST (SVGParserTests, ParseCSSMixBlendModeAllValues) +{ + static const char* modes[] = { + "multiply", "screen", "overlay", "darken", "lighten", "color-dodge", "color-burn", "hard-light", "soft-light", "difference", "exclusion", "hue", "saturation", "color", "luminosity" + }; + + for (auto* mode : modes) + { + Drawable d; + String svg = "" + "" + ""; + EXPECT_TRUE (d.parseSVG (svg)) << "Failed for blend mode: " << mode; + } +} + +// ============================================================================== +// Stroke and fill properties +// ============================================================================== + +TEST (SVGParserTests, ParseStrokeLineJoinValues) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ( + "" + "" + "" + "" + "")); +} + +TEST (SVGParserTests, ParseStrokeLineCapValues) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ( + "" + "" + "" + "" + "")); +} + +TEST (SVGParserTests, ParseStrokeMiterLimit) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ( + "" + "" + "" + "")); +} + +TEST (SVGParserTests, ParseFillNone) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ( + "" + "" + "")); +} + +TEST (SVGParserTests, ParseStrokeNone) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ( + "" + "" + "")); +} + +TEST (SVGParserTests, ParseColorNamedValues) +{ + static const char* colors[] = { + "red", "green", "blue", "black", "white", "yellow", "cyan", "magenta", "orange", "purple", "gray", "grey", "silver", "maroon", "navy" + }; + + for (auto* color : colors) + { + Drawable d; + String svg = ""; + EXPECT_TRUE (d.parseSVG (svg)) << "Failed for color: " << color; + } +} + +TEST (SVGParserTests, ParseColorHexValues) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ( + "" + "" + "" + "" + "" + "")); +} + +TEST (SVGParserTests, ParseColorRgbFunction) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ( + "" + "" + "" + "")); +} + +// ============================================================================== +// Transforms +// ============================================================================== + +TEST (SVGParserTests, ParseTransformTranslate) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ("")); +} + +TEST (SVGParserTests, ParseTransformTranslateSingleValue) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ("")); +} + +TEST (SVGParserTests, ParseTransformScale) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ("")); +} + +TEST (SVGParserTests, ParseTransformScaleXY) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ("")); +} + +TEST (SVGParserTests, ParseTransformRotate) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ("")); +} + +TEST (SVGParserTests, ParseTransformRotateAboutPoint) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ("")); +} + +TEST (SVGParserTests, ParseTransformSkewX) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ("")); +} + +TEST (SVGParserTests, ParseTransformSkewY) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ("")); +} + +TEST (SVGParserTests, ParseTransformMatrix) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ("")); +} + +TEST (SVGParserTests, ParseTransformMatrixCommas) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ("")); +} + +TEST (SVGParserTests, ParseTransformChained) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ("")); +} + +TEST (SVGParserTests, ParseTransformOnGroup) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ( + "" + "" + "" + "")); +} + +TEST (SVGParserTests, ParseTransformOriginAttribute) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ( + "" + "" + "")); +} + +// ============================================================================== +// Units +// ============================================================================== + +TEST (SVGParserTests, ParseDimensionsInPixels) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ("")); + EXPECT_FLOAT_EQ (100.0f, d.getBounds().getWidth()); + EXPECT_FLOAT_EQ (50.0f, d.getBounds().getHeight()); +} + +TEST (SVGParserTests, ParseDimensionsInInches) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ("")); + EXPECT_FLOAT_EQ (192.0f, d.getBounds().getWidth()); + EXPECT_FLOAT_EQ (96.0f, d.getBounds().getHeight()); +} + +TEST (SVGParserTests, ParseStrokeWidthWithUnits) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ( + "" + "" + "")); +} + +TEST (SVGParserTests, ParseFontSizeWithUnits) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ( + "" + "Point size text" + "Em size text" + "")); +} + +// ============================================================================== +// PreserveAspectRatio +// ============================================================================== + +TEST (SVGParserTests, ParsePreserveAspectRatioNone) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ("")); +} + +TEST (SVGParserTests, ParsePreserveAspectRatioXMidYMid) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ("")); +} + +TEST (SVGParserTests, ParsePreserveAspectRatioXMinYMin) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ("")); +} + +TEST (SVGParserTests, ParsePreserveAspectRatioXMaxYMax) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ("")); +} + +TEST (SVGParserTests, ParsePreserveAspectRatioOnSymbol) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ( + "" + "" + "" + "" + "" + "")); +} + +// ============================================================================== +// Nested SVG +// ============================================================================== + +TEST (SVGParserTests, ParseNestedSVG) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ( + "" + "" + "" + "" + "" + "" + "" + "" + "")); +} + +TEST (SVGParserTests, ParseNestedSVGWithPercentageDimensions) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ( + "" + "" + "" + "" + "")); +} + +// ============================================================================== +// Cascading and inheritance +// ============================================================================== + +TEST (SVGParserTests, ParseColorInheritanceFromParent) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ( + "" + "" + "" + "" + "")); +} + +TEST (SVGParserTests, ParseFontInheritanceFromParent) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ( + "" + "" + "Parent font" + "" + "Child font" + "" + "" + "")); +} + +TEST (SVGParserTests, ParseOpacityInheritance) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ( + "" + "" + "" + "" + "" + "")); +} + +// ============================================================================== +// Complex real-world documents +// ============================================================================== + +TEST (SVGParserTests, ParseComplexIconWithMultiplePaths) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ( + "" + "" + "" + "")); +} + +TEST (SVGParserTests, ParseComplexLogoWithGroupsAndGradients) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ( + "" + "" + "" + "" + "" + "" + "" + "" + "" + "" + "" + "LOGO" + "" + "")); +} + +TEST (SVGParserTests, ParseChartWithMultipleElements) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ( + "" + "" + "" + "" + "" + "" + "Q1" + "Q2" + "Q3" + "Q4" + "")); +} + +TEST (SVGParserTests, ParseSVGWithAllBasicShapes) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ( + "" + "" + "" + "" + "" + "" + "" + "" + "")); +} + +TEST (SVGParserTests, ParseArrowheadSVG) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ( + "" + "" + "" + "" + "" + "" + "" + "" + "" + "" + "")); +} + +TEST (SVGParserTests, ParseFlowchartSVG) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ( + "" + "" + "" + "" + "" + "" + "" + "Start" + "" + "" + "Process" + "" + "" + "Decision?" + "")); +} + +TEST (SVGParserTests, ParseHatchPatternSVG) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ( + "" + "" + "" + "" + "" + "" + "" + "")); +} + +// ============================================================================== +// Render tests (no crash) +// ============================================================================== + +TEST (SVGParserTests, RenderAllShapesToHeadlessContext) +{ + Drawable d; + ASSERT_TRUE (d.parseSVG ( + "" + "" + "" + "" + "" + "" + "" + "" + "")); + + auto g = makeHeadlessGraphics (128, 128); + EXPECT_NO_THROW (d.paint (*g.graphics, { 0.0f, 0.0f, 128.0f, 128.0f })); +} + +TEST (SVGParserTests, RenderGradientsToHeadlessContext) +{ + Drawable d; + ASSERT_TRUE (d.parseSVG ( + "" + "" + "" + "" + "" + "" + "" + "" + "" + "" + "" + "" + "" + "")); + + auto g = makeHeadlessGraphics(); + EXPECT_NO_THROW (d.paint (*g.graphics, { 0.0f, 0.0f, 64.0f, 64.0f })); +} + +TEST (SVGParserTests, RenderClipPathToHeadlessContext) +{ + Drawable d; + ASSERT_TRUE (d.parseSVG ( + "" + "" + "" + "" + "" + "")); + + auto g = makeHeadlessGraphics(); + EXPECT_NO_THROW (d.paint (*g.graphics, { 0.0f, 0.0f, 64.0f, 64.0f })); +} + +TEST (SVGParserTests, RenderMaskToHeadlessContext) +{ + Drawable d; + ASSERT_TRUE (d.parseSVG ( + "" + "" + "" + "" + "" + "" + "" + "")); + + auto g = makeHeadlessGraphics(); + EXPECT_NO_THROW (d.paint (*g.graphics, { 0.0f, 0.0f, 64.0f, 64.0f })); +} + +TEST (SVGParserTests, RenderMarkersToHeadlessContext) +{ + Drawable d; + ASSERT_TRUE (d.parseSVG ( + "" + "" + "" + "" + "" + "" + "" + "")); + + auto g = makeHeadlessGraphics(); + EXPECT_NO_THROW (d.paint (*g.graphics, { 0.0f, 0.0f, 64.0f, 64.0f })); +} + +TEST (SVGParserTests, RenderPatternToHeadlessContext) +{ + Drawable d; + ASSERT_TRUE (d.parseSVG ( + "" + "" + "" + "" + "" + "" + "" + "")); + + auto g = makeHeadlessGraphics(); + EXPECT_NO_THROW (d.paint (*g.graphics, { 0.0f, 0.0f, 64.0f, 64.0f })); +} + +TEST (SVGParserTests, RenderTextToHeadlessContext) +{ + Drawable d; + ASSERT_TRUE (d.parseSVG ( + "" + "Hello, World!" + "Bold Red" + "")); + + auto g = makeHeadlessGraphics (128, 64); + EXPECT_NO_THROW (d.paint (*g.graphics, { 0.0f, 0.0f, 128.0f, 64.0f })); +} + +TEST (SVGParserTests, RenderStrokeDashToHeadlessContext) +{ + Drawable d; + ASSERT_TRUE (d.parseSVG ( + "" + "" + "" + "" + "")); + + auto g = makeHeadlessGraphics(); + EXPECT_NO_THROW (d.paint (*g.graphics, { 0.0f, 0.0f, 64.0f, 64.0f })); +} + +TEST (SVGParserTests, RenderUseReferenceToHeadlessContext) +{ + Drawable d; + ASSERT_TRUE (d.parseSVG ( + "" + "" + "" + "" + "" + "" + "" + "" + "" + "" + "" + "" + "")); + + auto g = makeHeadlessGraphics(); + EXPECT_NO_THROW (d.paint (*g.graphics, { 0.0f, 0.0f, 64.0f, 64.0f })); +} + +TEST (SVGParserTests, RenderBlendModesToHeadlessContext) +{ + static const char* modes[] = { "multiply", "screen", "overlay", "difference" }; + + for (auto* mode : modes) + { + Drawable d; + String svg = "" + "" + ""; + ASSERT_TRUE (d.parseSVG (svg)) << mode; + + auto g = makeHeadlessGraphics(); + EXPECT_NO_THROW (d.paint (*g.graphics, { 0.0f, 0.0f, 64.0f, 64.0f })) << mode; + } +} + +TEST (SVGParserTests, RenderCyclicUseDoesNotCrash) +{ + Drawable d; + ASSERT_TRUE (d.parseSVG ( + "" + "" + "" + "" + "" + "")); + + auto g = makeHeadlessGraphics(); + EXPECT_NO_THROW (d.paint (*g.graphics, { 0.0f, 0.0f, 64.0f, 64.0f })); +} + +TEST (SVGParserTests, RenderMutuallyCyclicUseDoesNotCrash) +{ + Drawable d; + ASSERT_TRUE (d.parseSVG ( + "" + "" + "" + "" + "" + "" + "")); + + auto g = makeHeadlessGraphics(); + EXPECT_NO_THROW (d.paint (*g.graphics, { 0.0f, 0.0f, 64.0f, 64.0f })); +} + +TEST (SVGParserTests, RenderDeepRecursionInUseDoesNotCrash) +{ + String inner = ""; + String svg = ""; + for (int i = 0; i < 20; ++i) + svg += ""; + svg += ""; + + Drawable d; + ASSERT_TRUE (d.parseSVG (svg)); + + auto g = makeHeadlessGraphics(); + EXPECT_NO_THROW (d.paint (*g.graphics, { 0.0f, 0.0f, 64.0f, 64.0f })); +} + +// ============================================================================== +// Stress / edge cases +// ============================================================================== + +TEST (SVGParserTests, ParseSVGWithNoContent) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ("")); + EXPECT_FLOAT_EQ (100.0f, d.getBounds().getWidth()); + EXPECT_FLOAT_EQ (100.0f, d.getBounds().getHeight()); +} + +TEST (SVGParserTests, ParseSVGWithManyElements) +{ + String svg = ""; + for (int i = 0; i < 100; ++i) + { + float x = float (i % 10) * 100.0f; + float y = float (i / 10) * 100.0f; + svg += ""; + } + svg += ""; + + Drawable d; + EXPECT_TRUE (d.parseSVG (svg)); + + auto g = makeHeadlessGraphics (256, 256); + EXPECT_NO_THROW (d.paint (*g.graphics, { 0.0f, 0.0f, 256.0f, 256.0f })); +} + +TEST (SVGParserTests, ParseSVGWithCommentNodes) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ( + "" + "" + "" + "" + "")); +} + +TEST (SVGParserTests, ParseSVGWithCDATAInStyle) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ( + "" + "" + "" + "")); +} + +TEST (SVGParserTests, ParseAndReparseProducesSameBounds) +{ + const String svg = ""; + + Drawable d; + ASSERT_TRUE (d.parseSVG (svg)); + const auto bounds1 = d.getBounds(); + + ASSERT_TRUE (d.parseSVG (svg)); + const auto bounds2 = d.getBounds(); + + EXPECT_FLOAT_EQ (bounds1.getWidth(), bounds2.getWidth()); + EXPECT_FLOAT_EQ (bounds1.getHeight(), bounds2.getHeight()); +} + +TEST (SVGParserTests, ClearAfterParseThenParseDifferentSVG) +{ + Drawable d; + ASSERT_TRUE (d.parseSVG ("")); + EXPECT_FLOAT_EQ (100.0f, d.getBounds().getWidth()); + + d.clear(); + EXPECT_TRUE (d.getBounds().isEmpty()); + + ASSERT_TRUE (d.parseSVG ("")); + EXPECT_FLOAT_EQ (200.0f, d.getBounds().getWidth()); + EXPECT_FLOAT_EQ (150.0f, d.getBounds().getHeight()); +} + +TEST (SVGParserTests, ParseSVGWithUnknownElements) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ( + "" + "" + "ignored content" + "" + "")); +} + +TEST (SVGParserTests, ParseSVGWithUnknownAttributes) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ( + "" + "" + "")); +} + +TEST (SVGParserTests, ParseSVGWithWhitespaceInAttributes) +{ + Drawable d; + EXPECT_TRUE (d.parseSVG ( + "" + "" + "")); +}