#import "SVGHelperUtilities.h"
#import "CAShapeLayerWithHitTest.h"
#import "SVGUtils.h"
#import "SVGGradientElement.h"
#import "CGPathAdditions.h"
#import "SVGTransformable.h"
#import "SVGSVGElement.h"
#import "SVGGradientLayer.h"
@implementation SVGHelperUtilities
+(CGAffineTransform) transformRelativeIncludingViewportForTransformableOrViewportEstablishingElement:(SVGElement*) transformableOrSVGSVGElement
{
NSAssert([transformableOrSVGSVGElement conformsToProtocol:@protocol(SVGTransformable)] || [transformableOrSVGSVGElement isKindOfClass:[SVGSVGElement class]], @"Illegal argument, sent a non-SVGTransformable, non-SVGSVGElement object to a method that requires an SVGTransformable (NB: Apple's Xcode is rubbish, it should have thrown a compiler error that you even tried to do this, but it often doesn't bother). Incoming instance = %@", transformableOrSVGSVGElement );
/**
Each time you hit a viewPortElement in the DOM Tree, you
have to insert an ADDITIONAL transform into the flow of:
parent-transform -> child-transform
has to become:
parent-transform -> VIEWPORT-TRANSFORM -> child-transform
*/
CGAffineTransform currentRelativeTransform;
CGAffineTransform optionalViewportTransform;
/**
Current relative transform: for an incoming "SVGTransformable" it's .transform, for everything else its identity
*/
if( [transformableOrSVGSVGElement conformsToProtocol:@protocol(SVGTransformable)])
{
currentRelativeTransform = ((SVGElement<SVGTransformable>*)transformableOrSVGSVGElement).transform;
}
else
{
currentRelativeTransform = CGAffineTransformIdentity;
}
/**
Optional relative transform: if incoming element establishes a viewport, do something clever; for everything else, use identity
*/
if( transformableOrSVGSVGElement.viewportElement == nil // if it's nil, it means THE OPPOSITE of what you'd expect - it means that it IS the viewport element - SVG Spec REQUIRES this
|| transformableOrSVGSVGElement.viewportElement == transformableOrSVGSVGElement // ?? I don't understand: ?? if it's something other than itself, then: we simply don't need to worry about it ??
)
{
SVGSVGElement<SVGFitToViewBox>* svgSVGElement = (SVGSVGElement<SVGFitToViewBox>*) transformableOrSVGSVGElement;
/**
Calculate the "implicit" viewport->viewbox transform (caused by the <SVG> tag's possible "viewBox" attribute)
Also calculate the "implicit" realViewport -> svgDefaultViewport transform (caused by the user changing the external
size of the rendered SVG)
*/
SVGRect frameViewBox = svgSVGElement.viewBox; // the ACTUAL viewbox (may be Uninitalized if none specified in SVG file)
SVGRect frameActualViewport = svgSVGElement.viewport; // the ACTUAL viewport (dictated by the graphics engine; may be Uninitialized if the renderer has too little info to decide on a viewport at all!)
SVGRect frameRequestedViewport = svgSVGElement.requestedViewport; // the default viewport requested in the SVG source file (may be Uninitialized if no svg width or height params in original source file)
if( ! SVGRectIsInitialized(frameActualViewport))
{
/** We have NO VIEWPORT (renderer was presented too little info)
Net effect: we MUST render everything at 1:1, and apply NO FURTHER TRANSFORMS
*/
optionalViewportTransform = CGAffineTransformIdentity;
}
else
{
CGAffineTransform transformRealViewportToSVGViewport;
CGAffineTransform transformSVGViewportToSVGViewBox;
/** Transform part 1: from REAL viewport to EXPECTED viewport */
SVGRect viewportForViewBoxToRelateTo;
if( SVGRectIsInitialized( frameRequestedViewport ))
{
viewportForViewBoxToRelateTo = frameRequestedViewport;
transformRealViewportToSVGViewport = CGAffineTransformMakeScale( frameActualViewport.width / frameRequestedViewport.width, frameActualViewport.height / frameRequestedViewport.height);
}
else
{
viewportForViewBoxToRelateTo = frameActualViewport;
transformRealViewportToSVGViewport = CGAffineTransformIdentity;
}
/** Transform part 2: from EXPECTED viewport to internal viewBox */
if( SVGRectIsInitialized( frameViewBox ) )
{
CGAffineTransform translateToViewBox = CGAffineTransformMakeTranslation( -frameViewBox.x, -frameViewBox.y );
CGAffineTransform scaleToViewBox = CGAffineTransformMakeScale( viewportForViewBoxToRelateTo.width / frameViewBox.width, viewportForViewBoxToRelateTo.height / frameViewBox.height);
/** This is hard to find in the spec, but: if you have NO implementation of PreserveAspectRatio, you still need to
read the spec on PreserveAspectRatio - because it defines a default behaviour for files that DO NOT specify it,
which is different from the mathemetic default of co-ordinate systems.
In short, you MUST implement "<svg preserveAspectRatio=xMidYMid ... />", even if you're not supporting that attribute.
*/
if( svgSVGElement.preserveAspectRatio.baseVal.meetOrSlice == SVG_MEETORSLICE_MEET ) // ALWAYS TRUE in current implementation
{
if( ABS( svgSVGElement.aspectRatioFromWidthPerHeight - svgSVGElement.aspectRatioFromViewBox) > 0.00001 )
{
/** The aspect ratios for viewport and viewbox differ; Spec requires us to
insert an extra transform that causes aspect ratio for internal data to be
... MEET: == KEPT CONSTANT
and to "aspect-scale to fit" (i.e. leaving letterboxes at topbottom / leftright as required)
c.f.: http://www.w3.org/TR/SVG/coords.html#PreserveAspectRatioAttribute (read carefully)
*/
double ratioOfRatios = svgSVGElement.aspectRatioFromWidthPerHeight / svgSVGElement.aspectRatioFromViewBox;
SVGKitLogWarn(@"ratioOfRatios = %.2f", ratioOfRatios );
SVGKitLogWarn(@"Experimental: auto-scaling viewbox transform to fulfil SVG spec's default MEET settings, because your SVG file has different aspect-ratios for viewBox and for svg.width,svg.height");
/**
For MEET, we have to SHRINK the viewbox's contents if they aren't as wide:high as the viewport:
*/
CGAffineTransform catRestoreAspectRatio;
if( ratioOfRatios > 1 ) {
catRestoreAspectRatio = CGAffineTransformMakeScale( 1.0 / ratioOfRatios, 1.0 );
} else if (ratioOfRatios != 0) {
catRestoreAspectRatio = CGAffineTransformMakeScale( 1.0, 1.0 * ratioOfRatios );
} else {
catRestoreAspectRatio = CGAffineTransformIdentity;
}
double xTranslationRequired;
double yTranslationRequired;
if( ratioOfRatios > 1.0 ) // if we're going to have space to either side
{
switch( svgSVGElement.preserveAspectRatio.baseVal.align )
{
case SVG_PRESERVEASPECTRATIO_XMINYMIN:
case SVG_PRESERVEASPECTRATIO_XMINYMID:
case SVG_PRESERVEASPECTRATIO_XMINYMAX:
{
xTranslationRequired = 0.0;
}break;
case SVG_PRESERVEASPECTRATIO_XMIDYMIN:
case SVG_PRESERVEASPECTRATIO_XMIDYMID:
case SVG_PRESERVEASPECTRATIO_XMIDYMAX:
{
xTranslationRequired = ((ratioOfRatios-1.0)/2.0) * frameViewBox.width;
}break;
case SVG_PRESERVEASPECTRATIO_XMAXYMIN:
case SVG_PRESERVEASPECTRATIO_XMAXYMID:
case SVG_PRESERVEASPECTRATIO_XMAXYMAX:
{
xTranslationRequired = ((ratioOfRatios-1.0) * frameViewBox.width);
}break;
case SVG_PRESERVEASPECTRATIO_NONE:
case SVG_PRESERVEASPECTRATIO_UNKNOWN:
{
xTranslationRequired = 0;
}break;
}
}
else
xTranslationRequired = 0;
if( ratioOfRatios < 1.0 ) // if we're going to have space above and below
{
switch( svgSVGElement.preserveAspectRatio.baseVal.align )
{
case SVG_PRESERVEASPECTRATIO_XMINYMIN:
case SVG_PRESERVEASPECTRATIO_XMIDYMIN:
case SVG_PRESERVEASPECTRATIO_XMAXYMIN:
{
yTranslationRequired = 0.0;
}break;
case SVG_PRESERVEASPECTRATIO_XMINYMID:
case SVG_PRESERVEASPECTRATIO_XMIDYMID:
case SVG_PRESERVEASPECTRATIO_XMAXYMID:
{
yTranslationRequired = ((1.0-ratioOfRatios)/2.0 * [svgSVGElement.height pixelsValue]);
}break;
case SVG_PRESERVEASPECTRATIO_XMINYMAX:
case SVG_PRESERVEASPECTRATIO_XMIDYMAX:
case SVG_PRESERVEASPECTRATIO_XMAXYMAX:
{
yTranslationRequired = ((1.0-ratioOfRatios) * [svgSVGElement.height pixelsValue]);
}break;
case SVG_PRESERVEASPECTRATIO_NONE:
case SVG_PRESERVEASPECTRATIO_UNKNOWN:
{
yTranslationRequired = 0.0;
}break;
}
}
else
yTranslationRequired = 0.0;
/**
For xMidYMid, we have to RE-CENTER the viewbox's contents if they aren't as wide:high as the viewport:
*/
CGAffineTransform catRecenterNewAspectRatio = CGAffineTransformMakeTranslation( xTranslationRequired, yTranslationRequired );
CGAffineTransform transformsThatHonourAspectRatioRequirements = CGAffineTransformConcat(catRecenterNewAspectRatio, catRestoreAspectRatio);
scaleToViewBox = CGAffineTransformConcat( transformsThatHonourAspectRatioRequirements, scaleToViewBox );
}
}
else
SVGKitLogWarn( @"Unsupported: preserveAspectRatio set to SLICE. Code to handle this doesn't exist yet.");
transformSVGViewportToSVGViewBox = CGAffineTransformConcat( translateToViewBox, scaleToViewBox );
}
else
transformSVGViewportToSVGViewBox = CGAffineTransformIdentity;
optionalViewportTransform = CGAffineTransformConcat( transformRealViewportToSVGViewport, transformSVGViewportToSVGViewBox );
}
}
else
{
optionalViewportTransform = CGAffineTransformIdentity;
}
/**
TOTAL relative based on the local "transform" property and the viewport (if present)
*/
CGAffineTransform result = CGAffineTransformConcat( currentRelativeTransform, optionalViewportTransform);
return result;
}
/*!
Re-calculates the absolute transform on-demand by querying parent's absolute transform and appending self's relative transform.
Can take ONLY TWO kinds of element:
- something that implements SVGTransformable (non-transformables shouldn't be performing transforms!)
- something that defines a new viewport co-ordinate system (i.e. the SVG tag itself; this is AN IMPLICIT TRANSFORMABLE!)
*/
+(CGAffineTransform) transformAbsoluteIncludingViewportForTransformableOrViewportEstablishingElement:(SVGElement*) transformableOrSVGSVGElement
{
NSAssert([transformableOrSVGSVGElement conformsToProtocol:@protocol(SVGTransformable)] || [transformableOrSVGSVGElement isKindOfClass:[SVGSVGElement class]], @"Illegal argument, sent a non-SVGTransformable, non-SVGSVGElement object to a method that requires an SVGTransformable (NB: Apple's Xcode is rubbish, it should have thrown a compiler error that you even tried to do this, but it often doesn't bother). Incoming instance = %@", transformableOrSVGSVGElement );
CGAffineTransform parentAbsoluteTransform = CGAffineTransformIdentity;
NSAssert( transformableOrSVGSVGElement.parentNode == nil || [transformableOrSVGSVGElement.parentNode isKindOfClass:[SVGElement class]], @"I don't know what to do when parent node is NOT an SVG element of some kind; presumably, this is when SVG root node gets embedded inside something else? The Spec IS UNCLEAR and doesn't clearly define ANYTHING here, and provides very few examples" );
/**
Parent Absolute transform: one of the following
a. parent is an SVGTransformable (so recurse this method call to find it)
b. parent is a viewport-generating element (so recurse this method call to find it)
c. parent is nil (so treat it as Identity)
d. parent is something else (so do a while loop until we hit an a, b, or c above)
*/
SVGElement* parentSVGElement = transformableOrSVGSVGElement;
while( (parentSVGElement = (SVGElement*) parentSVGElement.parentNode) != nil )
{
if( [parentSVGElement conformsToProtocol:@protocol(SVGTransformable)] )
{
parentAbsoluteTransform = [self transformAbsoluteIncludingViewportForTransformableOrViewportEstablishingElement:parentSVGElement];
break;
}
if( [parentSVGElement isKindOfClass:[SVGSVGElement class]] )
{
parentAbsoluteTransform = [self transformAbsoluteIncludingViewportForTransformableOrViewportEstablishingElement:parentSVGElement];
break;
}
}
/**
TOTAL absolute based on the parent transform with relative (and possible viewport) transforms
*/
CGAffineTransform result = CGAffineTransformConcat( [self transformRelativeIncludingViewportForTransformableOrViewportEstablishingElement:transformableOrSVGSVGElement], parentAbsoluteTransform );
//DEBUG: SVGKitLogWarn( @"[%@] self.transformAbsolute: returning: affine( (%2.2f %2.2f %2.2f %2.2f), (%2.2f %2.2f)", [self class], result.a, result.b, result.c, result.d, result.tx, result.ty);
return result;
}
+(void) configureCALayer:(CALayer*) layer usingElement:(SVGElement*) nonStylableElement
{
layer.name = nonStylableElement.identifier;
[layer setValue:nonStylableElement.identifier forKey:kSVGElementIdentifier];
#if FORCE_RASTERIZE_LAYERS
if ([layer respondsToSelector:@selector(setShouldRasterize:)]) {
[layer performSelector:@selector(setShouldRasterize:)
withObject:[NSNumber numberWithBool:YES]];
}
/** If you're going to rasterize, Apple's code is dumb, and needs to be "told" if its using a Retina display */
layer.contentsScale = [[UIScreen mainScreen] scale];
layer.rasterizationScale = _shapeLayer.contentsScale;
#endif
if( [nonStylableElement conformsToProtocol:@protocol(SVGStylable)])
{
SVGElement<SVGStylable>* stylableElement = (SVGElement<SVGStylable>*) nonStylableElement;
NSString* actualOpacity = [stylableElement cascadedValueForStylableProperty:@"opacity" inherit:NO];
layer.opacity = actualOpacity.length > 0 ? [actualOpacity floatValue] : 1.0f; // svg's "opacity" defaults to 1!
// Apply fill-rule on layer (only CAShapeLayer)
NSString *fillRule = [stylableElement cascadedValueForStylableProperty:@"fill-rule"];
if([fillRule isEqualToString:@"evenodd"] && [layer isKindOfClass:[CAShapeLayer class]]){
CAShapeLayer *shapeLayer = (CAShapeLayer *)layer;
shapeLayer.fillRule = @"even-odd";
}
}
}
+(CALayer *) newCALayerForPathBasedSVGElement:(SVGElement<SVGTransformable>*) svgElement withPath:(CGPathRef) pathRelative
{
CAShapeLayer* _shapeLayer = [CAShapeLayerWithHitTest layer];
[self configureCALayer:_shapeLayer usingElement:svgElement];
NSString* actualStroke = [svgElement cascadedValueForStylableProperty:@"stroke"];
if (!actualStroke)
actualStroke = @"none";
NSString* actualStrokeWidth = [svgElement cascadedValueForStylableProperty:@"stroke-width"];
CGFloat strokeWidth = 1.0;
if (actualStrokeWidth)
{
SVGRect r = ((SVGSVGElement*) svgElement.viewportElement).viewport;
strokeWidth = [[SVGLength svgLengthFromNSString:actualStrokeWidth]
pixelsValueWithDimension: hypot(r.width, r.height)];
}
/** transform our LOCAL path into ABSOLUTE space */
CGAffineTransform transformAbsolute = [self transformAbsoluteIncludingViewportForTransformableOrViewportEstablishingElement:svgElement];
// calculate the rendered dimensions of the path
CGRect r = CGRectInset(CGPathGetBoundingBox(pathRelative), -strokeWidth/2., -strokeWidth/2.);
CGRect transformedPathBB = CGRectApplyAffineTransform(r, transformAbsolute);
CGPathRef pathToPlaceInLayer = CGPathCreateCopyByTransformingPath(pathRelative, &transformAbsolute);
/** find out the ABSOLUTE BOUNDING BOX of our transformed path */
//DEBUG ONLY: CGRect unTransformedPathBB = CGPathGetBoundingBox( _pathRelative );
#if IMPROVE_PERFORMANCE_BY_WORKING_AROUND_APPLE_FRAME_ALIGNMENT_BUG
transformedPathBB = CGRectIntegral( transformedPathBB ); // ridiculous but improves performance of apple's code by up to 50% !
#endif
/** NB: when we set the _shapeLayer.frame, it has a *side effect* of moving the path itself - so, in order to prevent that,
because Apple didn't provide a BOOL to disable that "feature", we have to pre-shift the path forwards by the amount it
will be shifted backwards */
CGPathRef finalPath = CGPathCreateByOffsettingPath( pathToPlaceInLayer, transformedPathBB.origin.x, transformedPathBB.origin.y );
/** Can't use this - iOS 5 only! path = CGPathCreateCopyByTransformingPath(path, transformFromSVGUnitsToScreenUnits ); */
_shapeLayer.path = finalPath;
CGPathRelease(finalPath);
/**
NB: this line, by changing the FRAME of the layer, has the side effect of also changing the CGPATH's position in absolute
space! This is why we needed the "CGPathRef finalPath =" line a few lines above...
*/
_shapeLayer.frame = transformedPathBB;
CGRect localRect = CGRectMake(0, 0, CGRectGetWidth(transformedPathBB), CGRectGetHeight(transformedPathBB));
//DEBUG ONLY: CGRect shapeLayerFrame = _shapeLayer.frame;
CAShapeLayer* strokeLayer = _shapeLayer;
CAShapeLayer* fillLayer = _shapeLayer;
if( strokeWidth > 0
&& (! [@"none" isEqualToString:actualStroke]) )
{
/*
We have to apply any scale-factor part of the affine transform to the stroke itself (this is bizarre and horrible, yes, but that's the spec for you!)
*/
CGSize fakeSize = CGSizeMake( strokeWidth, strokeWidth );
fakeSize = CGSizeApplyAffineTransform( fakeSize, transformAbsolute );
strokeLayer.lineWidth = hypot(fakeSize.width, fakeSize.height)/M_SQRT2;
NSString* actualStrokeOpacity = [svgElement cascadedValueForStylableProperty:@"stroke-opacity"];
strokeLayer.strokeColor = [self parseStrokeForElement:svgElement fromStroke:actualStroke andOpacity:actualStrokeOpacity];
/**
Stroke dash array
*/
NSString *dashArrayString = [svgElement cascadedValueForStylableProperty:@"stroke-dasharray"];
if(dashArrayString != nil && ![dashArrayString isEqualToString:@""]) {
NSArray *dashArrayStringComponents = [dashArrayString componentsSeparatedByString:@" "];
if( [dashArrayStringComponents count] < 2 )
{ // min 2 elements required, perhaps it's comma-separated:
dashArrayStringComponents = [dashArrayString componentsSeparatedByString:@","];
}
if( [dashArrayStringComponents count] > 1 )
{
BOOL valid = NO;
NSMutableArray *dashArray = [NSMutableArray array];
for( NSString *n in dashArrayStringComponents ){
[dashArray addObject:[NSNumber numberWithFloat:[n floatValue]]];
if( !valid && [n floatValue] != 0 ){
// avoid 'CGContextSetLineDash: invalid dash array: at least one element must be non-zero.'
valid = YES;
}
}
if( valid ){
strokeLayer.lineDashPattern = dashArray;
}
}
}
/**
Line joins + caps: butt / square / miter
*/
NSString* actualLineCap = [svgElement cascadedValueForStylableProperty:@"stroke-linecap"];
NSString* actualLineJoin = [svgElement cascadedValueForStylableProperty:@"stroke-linejoin"];
NSString* actualMiterLimit = [svgElement cascadedValueForStylableProperty:@"stroke-miterlimit"];
if( actualLineCap.length > 0 )
{
if( [actualLineCap isEqualToString:@"butt"] )
strokeLayer.lineCap = kCALineCapButt;
else if( [actualLineCap isEqualToString:@"round"] )
strokeLayer.lineCap = kCALineCapRound;
else if( [actualLineCap isEqualToString:@"square"] )
strokeLayer.lineCap = kCALineCapSquare;
}
if( actualLineJoin.length > 0 )
{
if( [actualLineJoin isEqualToString:@"miter"] )
strokeLayer.lineJoin = kCALineJoinMiter;
else if( [actualLineJoin isEqualToString:@"round"] )
strokeLayer.lineJoin = kCALineJoinRound;
else if( [actualLineJoin isEqualToString:@"bevel"] )
strokeLayer.lineJoin = kCALineJoinBevel;
}
if( actualMiterLimit.length > 0 )
{
strokeLayer.miterLimit = [actualMiterLimit floatValue];
}
if ( [actualStroke hasPrefix:@"url"] )
{
// need a new fill layer because the stroke layer is becoming a mask
fillLayer = [CAShapeLayerWithHitTest layer];
fillLayer.frame = strokeLayer.frame;
fillLayer.opacity = strokeLayer.opacity;
fillLayer.path = strokeLayer.path;
NSArray *strokeArgs = [actualStroke componentsSeparatedByCharactersInSet:NSCharacterSet.whitespaceCharacterSet];
NSString *strokeIdArg = strokeArgs.firstObject;
NSRange idKeyRange = NSMakeRange(5, strokeIdArg.length - 6);
NSString* strokeId = [strokeIdArg substringWithRange:idKeyRange];
// SVG spec: Vertical and horizontal lines don't have a boundingbox, since they are one-dimensional, even though the stroke-width makes it look like they should have a boundingbox with non-zero width and height.
CGRect boundingBox = strokeLayer.frame;
CGRect pathBoundingBox = CGPathGetPathBoundingBox(pathRelative);
if (!CGRectIsEmpty(pathBoundingBox)) {
// apply gradient
SVGGradientLayer *gradientLayer = [self getGradientLayerWithId:strokeId forElement:svgElement withRect:boundingBox transform:transformAbsolute];
if (gradientLayer) {
strokeLayer.frame = localRect;
strokeLayer.fillColor = nil;
strokeLayer.strokeColor = [UIColor blackColor].CGColor;
gradientLayer.mask = strokeLayer;
strokeLayer = (CAShapeLayer*) gradientLayer;
} else {
// no gradient, fallback
}
} else {
// no boundingBox, fallback
}
}
}
else
{
if( [@"none" isEqualToString:actualStroke] )
{
strokeLayer.strokeColor = nil; // This is how you tell Apple that the stroke is disabled; a strokewidth of 0 will NOT achieve this
strokeLayer.lineWidth = 0.0f; // MUST set this explicitly, or Apple assumes 1.0
}
else
{
strokeLayer.lineWidth = 1.0f; // default value from SVG spec
}
}
NSString* actualFill = [svgElement cascadedValueForStylableProperty:@"fill"];
NSString* actualFillOpacity = [svgElement cascadedValueForStylableProperty:@"fill-opacity"];
if ( [actualFill hasPrefix:@"url"] )
{
NSArray *fillArgs = [actualFill componentsSeparatedByCharactersInSet:NSCharacterSet.whitespaceCharacterSet];
NSString *fillIdArg = fillArgs.firstObject;
NSRange idKeyRange = NSMakeRange(5, fillIdArg.length - 6);
NSString* fillId = [fillIdArg substringWithRange:idKeyRange];
/** Replace the return layer with a special layer using the URL fill */
/** fetch the fill layer by URL using the DOM */
SVGGradientLayer *gradientLayer = [self getGradientLayerWithId:fillId forElement:svgElement withRect:fillLayer.frame
transform:transformAbsolute];
if (gradientLayer) {
CAShapeLayer* maskLayer = [CAShapeLayer layer];
maskLayer.frame = localRect;
maskLayer.path = fillLayer.path;
maskLayer.fillColor = [UIColor blackColor].CGColor;
maskLayer.strokeColor = nil;
gradientLayer.mask = maskLayer;
gradientLayer.frame = fillLayer.frame;
fillLayer = (CAShapeLayer* )gradientLayer;
} else {
// no gradient, fallback
}
}
else if( actualFill.length > 0 || actualFillOpacity.length > 0 )
{
fillLayer.fillColor = [self parseFillForElement:svgElement fromFill:actualFill andOpacity:actualFillOpacity];
}
CGPathRelease(pathToPlaceInLayer);
NSString* actualOpacity = [svgElement cascadedValueForStylableProperty:@"opacity" inherit:NO];
fillLayer.opacity = actualOpacity.length > 0 ? [actualOpacity floatValue] : 1; // unusually, the "opacity" attribute defaults to 1, not 0
if (strokeLayer == fillLayer)
{
return strokeLayer;
}
CALayer* combined = [CALayer layer];
combined.frame = strokeLayer.frame;
strokeLayer.frame = localRect;
if ([strokeLayer isKindOfClass:[CAShapeLayer class]])
strokeLayer.fillColor = nil;
fillLayer.frame = localRect;
[combined addSublayer:fillLayer];
[combined addSublayer:strokeLayer];
return combined;
}
+ (SVGGradientLayer*)getGradientLayerWithId:(NSString*)gradId
forElement:(SVGElement*)svgElement
withRect:(CGRect)r
transform:(CGAffineTransform)transform
{
/** Replace the return layer with a special layer using the URL fill */
/** fetch the fill layer by URL using the DOM */
NSAssert( svgElement.rootOfCurrentDocumentFragment != nil, @"This SVG shape has a URL fill type; it needs to search for that URL (%@) inside its nearest-ancestor <SVG> node, but the rootOfCurrentDocumentFragment reference was nil (suggests the parser failed, or the SVG file is corrupt)", gradId );
SVGGradientElement* svgGradient = (SVGGradientElement*) [svgElement.rootOfCurrentDocumentFragment getElementById:gradId];
if (svgGradient == nil) {
// SVG spec allows referenced gradient not exist and will use fallback color
SVGKitLogWarn(@"This SVG shape has a URL fill (%@), but could not find an XML Node with that ID inside the DOM tree (suggests the parser failed, or the SVG file is corrupt)", gradId );
}
[svgGradient synthesizeProperties];
SVGGradientLayer *gradientLayer = [svgGradient newGradientLayerForObjectRect:r
viewportRect:svgElement.rootOfCurrentDocumentFragment.viewBox
transform:transform];
return gradientLayer;
}
+(CGColorRef) parseFillForElement:(SVGElement *)svgElement
{
NSString* actualFill = [svgElement cascadedValueForStylableProperty:@"fill"];
NSString* actualFillOpacity = [svgElement cascadedValueForStylableProperty:@"fill-opacity"];
return [self parseFillForElement:svgElement fromFill:actualFill andOpacity:actualFillOpacity];
}
+(CGColorRef) parseFillForElement:(SVGElement *)svgElement fromFill:(NSString *)actualFill andOpacity:(NSString *)actualFillOpacity
{
return [self parsePaintColorForElement:svgElement paintColor:actualFill paintOpacity:actualFillOpacity defaultColor:@"black"];
}
+(CGColorRef) parseStrokeForElement:(SVGElement *)svgElement
{
NSString* actualStroke = [svgElement cascadedValueForStylableProperty:@"stroke"];
NSString* actualStrokeOpacity = [svgElement cascadedValueForStylableProperty:@"stroke-opacity"];
return [self parseStrokeForElement:svgElement fromStroke:actualStroke andOpacity:actualStrokeOpacity];
}
+(CGColorRef) parseStrokeForElement:(SVGElement *)svgElement fromStroke:(NSString *)actualStroke andOpacity:(NSString *)actualStrokeOpacity
{
return [self parsePaintColorForElement:svgElement paintColor:actualStroke paintOpacity:actualStrokeOpacity defaultColor:@"none"];
}
/**
Spec: https://www.w3.org/TR/SVG11/painting.html#SpecifyingPaint
`fill` or `stroke` allows paint color. This should actually be a <paint> interface.
`fill` default color is `black`, while `stroke` default color is `none`
*/
+(CGColorRef)parsePaintColorForElement:(SVGElement *)svgElement paintColor:(NSString *)paintColor paintOpacity:(NSString *)paintOpacity defaultColor:(NSString *)defaultColor {
CGColorRef colorRef = NULL;
if (!paintColor) {
paintColor = @"none";
}
if ([paintColor isEqualToString:@"none"])
{
return NULL;
}
// there may be a url before the actual color like `url(#grad) #0f0`, parse it
NSString *actualPaintColor;
NSString *actualPaintOpacity = paintOpacity;
NSArray *paintArgs = [paintColor componentsSeparatedByCharactersInSet:NSCharacterSet.whitespaceCharacterSet];
if ([paintColor hasPrefix:@"url"]) {
if (paintArgs.count > 1) {
actualPaintColor = paintArgs[1];
}
} else {
actualPaintColor = paintColor;
}
if( actualPaintColor.length > 0 || actualPaintOpacity.length > 0 ) {
SVGColor paintColorSVGColor;
if (actualPaintColor.length > 0) {
if (![actualPaintColor isEqualToString:@"none"]) {
paintColorSVGColor = SVGColorFromString([actualPaintColor UTF8String]); // have to use the intermediate of an SVGColor so that we can over-ride the ALPHA component in next line
} else {
return NULL;
}
} else {
if (![defaultColor isEqualToString:@"none"]) {
paintColorSVGColor = SVGColorFromString([actualPaintColor UTF8String]);
} else {
return NULL;
}
}
if( actualPaintOpacity.length > 0 )
paintColorSVGColor.a = (uint8_t) ([actualPaintOpacity floatValue] * 0xFF);
colorRef = CGColorWithSVGColor(paintColorSVGColor);
}
else
{
if (![defaultColor isEqualToString:@"none"]) {
colorRef = CGColorWithSVGColor(SVGColorFromString([defaultColor UTF8String]));
} else {
return NULL;
}
}
return colorRef;
}
+(void) parsePreserveAspectRatioFor:(Element<SVGFitToViewBox>*) element
{
element.preserveAspectRatio = [SVGAnimatedPreserveAspectRatio new]; // automatically sets defaults
NSString* stringPreserveAspectRatio = [element getAttribute:@"preserveAspectRatio"];
if( stringPreserveAspectRatio.length > 0 )
{
NSArray* aspectRatioCommands = [stringPreserveAspectRatio componentsSeparatedByString:@" "];
for( NSString* aspectRatioCommand in aspectRatioCommands )
{
if( [aspectRatioCommand isEqualToString:@"meet"]) /** NB this is default anyway. Dont technically need to set it */
element.preserveAspectRatio.baseVal.meetOrSlice = SVG_MEETORSLICE_MEET;
else if( [aspectRatioCommand isEqualToString:@"slice"])
element.preserveAspectRatio.baseVal.meetOrSlice = SVG_MEETORSLICE_SLICE;
else if( [aspectRatioCommand isEqualToString:@"xMinYMin"])
element.preserveAspectRatio.baseVal.align = SVG_PRESERVEASPECTRATIO_XMINYMIN;
else if( [aspectRatioCommand isEqualToString:@"xMinYMid"])
element.preserveAspectRatio.baseVal.align = SVG_PRESERVEASPECTRATIO_XMINYMID;
else if( [aspectRatioCommand isEqualToString:@"xMinYMax"])
element.preserveAspectRatio.baseVal.align = SVG_PRESERVEASPECTRATIO_XMINYMAX;
else if( [aspectRatioCommand isEqualToString:@"xMidYMin"])
element.preserveAspectRatio.baseVal.align = SVG_PRESERVEASPECTRATIO_XMIDYMIN;
else if( [aspectRatioCommand isEqualToString:@"xMidYMid"])
element.preserveAspectRatio.baseVal.align = SVG_PRESERVEASPECTRATIO_XMIDYMID;
else if( [aspectRatioCommand isEqualToString:@"xMidYMax"])
element.preserveAspectRatio.baseVal.align = SVG_PRESERVEASPECTRATIO_XMIDYMAX;
else if( [aspectRatioCommand isEqualToString:@"xMaxYMin"])
element.preserveAspectRatio.baseVal.align = SVG_PRESERVEASPECTRATIO_XMAXYMIN;
else if( [aspectRatioCommand isEqualToString:@"xMaxYMid"])
element.preserveAspectRatio.baseVal.align = SVG_PRESERVEASPECTRATIO_XMAXYMID;
else if( [aspectRatioCommand isEqualToString:@"xMaxYMax"])
element.preserveAspectRatio.baseVal.align = SVG_PRESERVEASPECTRATIO_XMAXYMAX;
else
{
SVGKitLogWarn(@"Found unexpected preserve-aspect-ratio command inside element's 'preserveAspectRatio' attribute. Command = '%@'", aspectRatioCommand );
}
}
}
}
@end