public static PolygonDrawable Create(SvgPolygon svgPolygon, Rect skOwnerBounds, DrawableBase?parent, IAssetLoader assetLoader, Attributes ignoreAttributes = Attributes.None)
{
var drawable = new PolygonDrawable(assetLoader)
{
Element = svgPolygon,
Parent = parent,
IgnoreAttributes = ignoreAttributes
};
drawable.IsDrawable = drawable.CanDraw(svgPolygon, drawable.IgnoreAttributes) && drawable.HasFeatures(svgPolygon, drawable.IgnoreAttributes);
if (!drawable.IsDrawable)
{
return(drawable);
}
drawable.Path = svgPolygon.Points?.ToPath(svgPolygon.FillRule, true, skOwnerBounds);
if (drawable.Path is null || drawable.Path.IsEmpty)
{
drawable.IsDrawable = false;
return(drawable);
}
drawable.IsAntialias = SvgModelExtensions.IsAntialias(svgPolygon);
drawable.TransformedBounds = drawable.Path.Bounds;
drawable.Transform = SvgModelExtensions.ToMatrix(svgPolygon.Transforms);
var canDrawFill = true;
var canDrawStroke = true;
if (SvgModelExtensions.IsValidFill(svgPolygon))
{
drawable.Fill = SvgModelExtensions.GetFillPaint(svgPolygon, drawable.TransformedBounds, assetLoader, ignoreAttributes);
if (drawable.Fill is null)
{
canDrawFill = false;
}
}
if (SvgModelExtensions.IsValidStroke(svgPolygon, drawable.TransformedBounds))
{
drawable.Stroke = SvgModelExtensions.GetStrokePaint(svgPolygon, drawable.TransformedBounds, assetLoader, ignoreAttributes);
if (drawable.Stroke is null)
{
canDrawStroke = false;
}
}
if (canDrawFill && !canDrawStroke)
{
drawable.IsDrawable = false;
return(drawable);
}
SvgModelExtensions.CreateMarkers(svgPolygon, drawable.Path, skOwnerBounds, drawable, assetLoader);
// TODO: Transform _skBounds using _skMatrix.
drawable.TransformedBounds = drawable.Transform.MapRect(drawable.TransformedBounds);
return(drawable);
}
public void Execute(GeneratorExecutionContext context)
{
try
{
context.AnalyzerConfigOptions.GlobalOptions.TryGetValue("build_property.NamespaceName", out var globalNamespaceName);
var files = context.AdditionalFiles.Where(at => at.Path.EndsWith(".svg", StringComparison.InvariantCultureIgnoreCase));
foreach (var file in files)
{
string?namespaceName = null;
if (!string.IsNullOrWhiteSpace(globalNamespaceName))
{
namespaceName = globalNamespaceName;
}
if (context.AnalyzerConfigOptions.GetOptions(file).TryGetValue("build_metadata.AdditionalFiles.NamespaceName", out var perFilenamespaceName))
{
if (!string.IsNullOrWhiteSpace(perFilenamespaceName))
{
namespaceName = perFilenamespaceName;
}
}
if (string.IsNullOrWhiteSpace(namespaceName))
{
namespaceName = "Svg";
}
context.AnalyzerConfigOptions.GetOptions(file).TryGetValue("build_metadata.AdditionalFiles.ClassName", out var className);
if (string.IsNullOrWhiteSpace(className))
{
className = CreateClassName(file.Path);
}
if (string.IsNullOrWhiteSpace(namespaceName))
{
context.ReportDiagnostic(Diagnostic.Create(s_errorDescriptor, Location.None, "The specified namespace name is invalid."));
return;
}
if (string.IsNullOrWhiteSpace(className))
{
context.ReportDiagnostic(Diagnostic.Create(s_errorDescriptor, Location.None, "The specified class name is invalid."));
return;
}
var svg = file.GetText(context.CancellationToken)?.ToString();
if (string.IsNullOrWhiteSpace(svg))
{
context.ReportDiagnostic(Diagnostic.Create(s_errorDescriptor, Location.None, "Svg file is null or empty."));
return;
}
var svgDocument = SvgModelExtensions.FromSvg(svg !);
if (svgDocument is { })
{
var picture = SvgModelExtensions.ToModel(svgDocument, _assetLoader);
if (picture is { } && picture.Commands is { })
public static AnchorDrawable Create(SvgAnchor svgAnchor, Rect skOwnerBounds, DrawableBase?parent, IAssetLoader assetLoader, Attributes ignoreAttributes = Attributes.None)
{
var drawable = new AnchorDrawable(assetLoader)
{
Element = svgAnchor,
Parent = parent,
IgnoreAttributes = ignoreAttributes,
IsDrawable = true
};
drawable.CreateChildren(svgAnchor, skOwnerBounds, drawable, assetLoader, ignoreAttributes);
drawable.IsAntialias = SvgModelExtensions.IsAntialias(svgAnchor);
drawable.TransformedBounds = Rect.Empty;
drawable.CreateTransformedBounds();
drawable.Transform = SvgModelExtensions.ToMatrix(svgAnchor.Transforms);
drawable.Fill = null;
drawable.Stroke = null;
// TODO: Transform _skBounds using _skMatrix.
drawable.TransformedBounds = drawable.Transform.MapRect(drawable.TransformedBounds);
drawable.ClipPath = null;
drawable.MaskDrawable = null;
drawable.Opacity = drawable.IgnoreAttributes.HasFlag(Attributes.Opacity) ? null : SvgModelExtensions.GetOpacityPaint(svgAnchor);
drawable.Filter = null;
return(drawable);
}
public static MaskDrawable Create(SvgMask svgMask, Rect skOwnerBounds, DrawableBase?parent, IAssetLoader assetLoader, Attributes ignoreAttributes = Attributes.None)
{
var drawable = new MaskDrawable(assetLoader)
{
Element = svgMask,
Parent = parent,
IgnoreAttributes = ignoreAttributes,
IsDrawable = true
};
if (!drawable.IsDrawable)
{
return(drawable);
}
var maskUnits = svgMask.MaskUnits;
var maskContentUnits = svgMask.MaskContentUnits;
var xUnit = svgMask.X;
var yUnit = svgMask.Y;
var widthUnit = svgMask.Width;
var heightUnit = svgMask.Height;
var x = xUnit.ToDeviceValue(UnitRenderingType.Horizontal, svgMask, skOwnerBounds);
var y = yUnit.ToDeviceValue(UnitRenderingType.Vertical, svgMask, skOwnerBounds);
var width = widthUnit.ToDeviceValue(UnitRenderingType.Horizontal, svgMask, skOwnerBounds);
var height = heightUnit.ToDeviceValue(UnitRenderingType.Vertical, svgMask, skOwnerBounds);
if (width <= 0 || height <= 0)
{
drawable.IsDrawable = false;
return(drawable);
}
if (maskUnits == SvgCoordinateUnits.ObjectBoundingBox)
{
if (xUnit.Type != SvgUnitType.Percentage)
{
x *= skOwnerBounds.Width;
}
if (yUnit.Type != SvgUnitType.Percentage)
{
y *= skOwnerBounds.Height;
}
if (widthUnit.Type != SvgUnitType.Percentage)
{
width *= skOwnerBounds.Width;
}
if (heightUnit.Type != SvgUnitType.Percentage)
{
height *= skOwnerBounds.Height;
}
x += skOwnerBounds.Left;
y += skOwnerBounds.Top;
}
var skRectTransformed = Rect.Create(x, y, width, height);
var skMatrix = Matrix.CreateIdentity();
if (maskContentUnits == SvgCoordinateUnits.ObjectBoundingBox)
{
var skBoundsTranslateTransform = Matrix.CreateTranslation(skOwnerBounds.Left, skOwnerBounds.Top);
skMatrix = skMatrix.PreConcat(skBoundsTranslateTransform);
var skBoundsScaleTransform = Matrix.CreateScale(skOwnerBounds.Width, skOwnerBounds.Height);
skMatrix = skMatrix.PreConcat(skBoundsScaleTransform);
}
drawable.CreateChildren(svgMask, skOwnerBounds, drawable, assetLoader, ignoreAttributes);
drawable.Overflow = skRectTransformed;
drawable.IsAntialias = SvgModelExtensions.IsAntialias(svgMask);
drawable.TransformedBounds = skRectTransformed;
drawable.Transform = skMatrix;
drawable.Fill = null;
drawable.Stroke = null;
// TODO: Transform _skBounds using _skMatrix.
drawable.TransformedBounds = drawable.Transform.MapRect(drawable.TransformedBounds);
return(drawable);
}
public static FragmentDrawable Create(SvgFragment svgFragment, Rect skOwnerBounds, DrawableBase?parent, IAssetLoader assetLoader, Attributes ignoreAttributes = Attributes.None)
{
var drawable = new FragmentDrawable(assetLoader)
{
Element = svgFragment,
Parent = parent,
IgnoreAttributes = ignoreAttributes
};
drawable.IsDrawable = drawable.HasFeatures(svgFragment, drawable.IgnoreAttributes);
if (!drawable.IsDrawable)
{
return(drawable);
}
var svgFragmentParent = svgFragment.Parent;
var x = svgFragmentParent is null ? 0f : svgFragment.X.ToDeviceValue(UnitRenderingType.Horizontal, svgFragment, skOwnerBounds);
var y = svgFragmentParent is null ? 0f : svgFragment.Y.ToDeviceValue(UnitRenderingType.Vertical, svgFragment, skOwnerBounds);
var skSize = SvgModelExtensions.GetDimensions(svgFragment);
if (skOwnerBounds.IsEmpty)
{
skOwnerBounds = Rect.Create(x, y, skSize.Width, skSize.Height);
}
drawable.CreateChildren(svgFragment, skOwnerBounds, drawable, assetLoader, ignoreAttributes);
drawable.IsAntialias = SvgModelExtensions.IsAntialias(svgFragment);
drawable.TransformedBounds = skOwnerBounds;
drawable.CreateTransformedBounds();
drawable.Transform = SvgModelExtensions.ToMatrix(svgFragment.Transforms);
var skMatrixViewBox = SvgModelExtensions.ToMatrix(svgFragment.ViewBox, svgFragment.AspectRatio, x, y, skSize.Width, skSize.Height);
drawable.Transform = drawable.Transform.PreConcat(skMatrixViewBox);
switch (svgFragment.Overflow)
{
case SvgOverflow.Auto:
case SvgOverflow.Visible:
case SvgOverflow.Inherit:
break;
default:
if (skSize.IsEmpty)
{
drawable.Overflow = Rect.Create(
x,
y,
Math.Abs(drawable.TransformedBounds.Left) + drawable.TransformedBounds.Width,
Math.Abs(drawable.TransformedBounds.Top) + drawable.TransformedBounds.Height);
}
else
{
drawable.Overflow = Rect.Create(x, y, skSize.Width, skSize.Height);
}
break;
}
var clipPathUris = new HashSet <Uri>();
var svgClipPath = svgFragment.GetUriElementReference <SvgClipPath>("clip-path", clipPathUris);
if (svgClipPath?.Children is { })
public static SymbolDrawable Create(SvgSymbol svgSymbol, float x, float y, float width, float height, Rect skOwnerBounds, DrawableBase?parent, IAssetLoader assetLoader, Attributes ignoreAttributes)
{
var drawable = new SymbolDrawable(assetLoader)
{
Element = svgSymbol,
Parent = parent,
IgnoreAttributes = ignoreAttributes
};
drawable.IsDrawable = drawable.CanDraw(svgSymbol, drawable.IgnoreAttributes) && drawable.HasFeatures(svgSymbol, drawable.IgnoreAttributes);
if (!drawable.IsDrawable)
{
return(drawable);
}
if (svgSymbol.CustomAttributes.TryGetValue("width", out var _widthString))
{
if (new SvgUnitConverter().ConvertFromString(_widthString) is SvgUnit _width)
{
width = _width.ToDeviceValue(UnitRenderingType.Horizontal, svgSymbol, skOwnerBounds);
}
}
if (svgSymbol.CustomAttributes.TryGetValue("height", out var heightString))
{
if (new SvgUnitConverter().ConvertFromString(heightString) is SvgUnit _height)
{
height = _height.ToDeviceValue(UnitRenderingType.Vertical, svgSymbol, skOwnerBounds);
}
}
var svgOverflow = SvgOverflow.Hidden;
if (svgSymbol.TryGetAttribute("overflow", out string overflowString))
{
if (new SvgOverflowConverter().ConvertFromString(overflowString) is SvgOverflow _svgOverflow)
{
svgOverflow = _svgOverflow;
}
}
switch (svgOverflow)
{
case SvgOverflow.Auto:
case SvgOverflow.Visible:
case SvgOverflow.Inherit:
break;
default:
drawable.Overflow = Rect.Create(x, y, width, height);
break;
}
drawable.CreateChildren(svgSymbol, skOwnerBounds, drawable, assetLoader, ignoreAttributes);
drawable.IsAntialias = SvgModelExtensions.IsAntialias(svgSymbol);
drawable.TransformedBounds = Rect.Empty;
drawable.CreateTransformedBounds();
drawable.Transform = SvgModelExtensions.ToMatrix(svgSymbol.Transforms);
var skMatrixViewBox = SvgModelExtensions.ToMatrix(svgSymbol.ViewBox, svgSymbol.AspectRatio, x, y, width, height);
drawable.Transform = drawable.Transform.PreConcat(skMatrixViewBox);
drawable.Fill = null;
drawable.Stroke = null;
// TODO: Transform _skBounds using _skMatrix.
drawable.TransformedBounds = drawable.Transform.MapRect(drawable.TransformedBounds);
return(drawable);
}
