public static SwitchDrawable Create(SvgSwitch svgSwitch, Rect skOwnerBounds, DrawableBase?parent, IAssetLoader assetLoader, Attributes ignoreAttributes = Attributes.None)
{
var drawable = new SwitchDrawable(assetLoader)
{
Element = svgSwitch,
Parent = parent,
IgnoreAttributes = ignoreAttributes
};
drawable.IsDrawable = drawable.CanDraw(svgSwitch, drawable.IgnoreAttributes) && drawable.HasFeatures(svgSwitch, drawable.IgnoreAttributes);
if (!drawable.IsDrawable)
{
return(drawable);
}
foreach (var child in svgSwitch.Children)
{
if (!child.IsKnownElement())
{
continue;
}
var hasRequiredFeatures = child.HasRequiredFeatures();
var hasRequiredExtensions = child.HasRequiredExtensions();
var hasSystemLanguage = child.HasSystemLanguage();
if (hasRequiredFeatures && hasRequiredExtensions && hasSystemLanguage)
{
var childDrawable = DrawableFactory.Create(child, skOwnerBounds, parent, assetLoader, ignoreAttributes);
if (childDrawable is { })
public static GroupDrawable Create(SvgGroup svgGroup, SKRect skViewport, DrawableBase?parent, IAssetLoader assetLoader, HashSet <Uri>?references, DrawAttributes ignoreAttributes = DrawAttributes.None)
{
var drawable = new GroupDrawable(assetLoader, references)
{
Element = svgGroup,
Parent = parent,
IgnoreAttributes = ignoreAttributes
};
drawable.IsDrawable = drawable.CanDraw(svgGroup, drawable.IgnoreAttributes) && drawable.HasFeatures(svgGroup, drawable.IgnoreAttributes);
// NOTE: Call AddMarkers only once.
SvgExtensions.AddMarkers(svgGroup);
drawable.CreateChildren(svgGroup, skViewport, drawable, assetLoader, references, ignoreAttributes);
// TODO: Check if children are explicitly set to be visible.
//foreach (var child in drawable.ChildrenDrawables)
//{
// if (child.IsDrawable)
// {
// IsDrawable = true;
// break;
// }
//}
if (!drawable.IsDrawable)
{
return(drawable);
}
drawable.Initialize(references);
return(drawable);
}
public static ImageDrawable Create(SvgImage svgImage, SKRect skViewport, DrawableBase?parent, IAssetLoader assetLoader, HashSet <Uri>?references, DrawAttributes ignoreAttributes = DrawAttributes.None)
{
var drawable = new ImageDrawable(assetLoader, references)
{
Element = svgImage,
Parent = parent,
IgnoreAttributes = ignoreAttributes
};
drawable.IsDrawable = drawable.CanDraw(svgImage, drawable.IgnoreAttributes) && drawable.HasFeatures(svgImage, drawable.IgnoreAttributes);
if (!drawable.IsDrawable)
{
return(drawable);
}
var width = svgImage.Width.ToDeviceValue(UnitRenderingType.Horizontal, svgImage, skViewport);
var height = svgImage.Height.ToDeviceValue(UnitRenderingType.Vertical, svgImage, skViewport);
var x = svgImage.Location.X.ToDeviceValue(UnitRenderingType.Horizontal, svgImage, skViewport);
var y = svgImage.Location.Y.ToDeviceValue(UnitRenderingType.Vertical, svgImage, skViewport);
var location = new SKPoint(x, y);
if (width <= 0f || height <= 0f || svgImage.Href is null)
{
drawable.IsDrawable = false;
return(drawable);
}
var uri = SvgExtensions.GetImageUri(svgImage.Href, svgImage.OwnerDocument);
if (references is { } && references.Contains(uri))
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 PathDrawable Create(SvgPath svgPath, SKRect skViewport, DrawableBase?parent, IAssetLoader assetLoader, HashSet <Uri>?references, DrawAttributes ignoreAttributes = DrawAttributes.None)
{
var drawable = new PathDrawable(assetLoader, references)
{
Element = svgPath,
Parent = parent,
IgnoreAttributes = ignoreAttributes
};
drawable.IsDrawable = drawable.CanDraw(svgPath, drawable.IgnoreAttributes) && drawable.HasFeatures(svgPath, drawable.IgnoreAttributes);
if (!drawable.IsDrawable)
{
return(drawable);
}
drawable.Path = svgPath.PathData?.ToPath(svgPath.FillRule);
if (drawable.Path is null || drawable.Path.IsEmpty)
{
drawable.IsDrawable = false;
return(drawable);
}
drawable.Initialize(skViewport, references);
return(drawable);
}
public virtual void Draw(Canvas canvas, Attributes ignoreAttributes, DrawableBase?until)
{
if (!IsDrawable)
{
return;
}
if (until is { } && this == until)
public virtual void Draw(SKCanvas canvas, DrawAttributes ignoreAttributes, DrawableBase?until, bool enableTransform)
{
if (!IsDrawable)
{
return;
}
if (until is { } && this == until)
public static GroupDrawable Create(SvgGroup svgGroup, Rect skOwnerBounds, DrawableBase?parent, IAssetLoader assetLoader, Attributes ignoreAttributes = Attributes.None)
{
var drawable = new GroupDrawable(assetLoader)
{
Element = svgGroup,
Parent = parent,
IgnoreAttributes = ignoreAttributes
};
drawable.IsDrawable = drawable.CanDraw(svgGroup, drawable.IgnoreAttributes) && drawable.HasFeatures(svgGroup, drawable.IgnoreAttributes);
// NOTE: Call AddMarkers only once.
SvgModelExtensions.AddMarkers(svgGroup);
drawable.CreateChildren(svgGroup, skOwnerBounds, drawable, assetLoader, ignoreAttributes);
// TODO: Check if children are explicitly set to be visible.
//foreach (var child in drawable.ChildrenDrawables)
//{
// if (child.IsDrawable)
// {
// IsDrawable = true;
// break;
// }
//}
if (!drawable.IsDrawable)
{
return(drawable);
}
drawable.IsAntialias = SvgModelExtensions.IsAntialias(svgGroup);
drawable.TransformedBounds = Rect.Empty;
drawable.CreateTransformedBounds();
drawable.Transform = SvgModelExtensions.ToMatrix(svgGroup.Transforms);
if (SvgModelExtensions.IsValidFill(svgGroup))
{
drawable.Fill = SvgModelExtensions.GetFillPaint(svgGroup, drawable.TransformedBounds, assetLoader, ignoreAttributes);
}
if (SvgModelExtensions.IsValidStroke(svgGroup, drawable.TransformedBounds))
{
drawable.Stroke = SvgModelExtensions.GetStrokePaint(svgGroup, drawable.TransformedBounds, assetLoader, ignoreAttributes);
}
// TODO: Transform _skBounds using _skMatrix.
drawable.TransformedBounds = drawable.Transform.MapRect(drawable.TransformedBounds);
return(drawable);
}
public static UseDrawable Create(SvgUse svgUse, SKRect skViewport, DrawableBase?parent, IAssetLoader assetLoader, HashSet <Uri>?references, DrawAttributes ignoreAttributes = DrawAttributes.None)
{
var drawable = new UseDrawable(assetLoader, references)
{
Element = svgUse,
Parent = parent,
IgnoreAttributes = ignoreAttributes
};
drawable.IsDrawable = drawable.CanDraw(svgUse, drawable.IgnoreAttributes) && drawable.HasFeatures(svgUse, drawable.IgnoreAttributes);
if (!drawable.IsDrawable)
{
return(drawable);
}
if (SvgExtensions.HasRecursiveReference(svgUse, (e) => e.ReferencedElement, new HashSet <Uri>()))
{
drawable.IsDrawable = false;
return(drawable);
}
var svgReferencedElement = SvgExtensions.GetReference <SvgElement>(svgUse, svgUse.ReferencedElement);
if (svgReferencedElement is null)
{
drawable.IsDrawable = false;
return(drawable);
}
var x = svgUse.X.ToDeviceValue(UnitRenderingType.Horizontal, svgUse, skViewport);
var y = svgUse.Y.ToDeviceValue(UnitRenderingType.Vertical, svgUse, skViewport);
var width = svgUse.Width.ToDeviceValue(UnitRenderingType.Horizontal, svgUse, skViewport);
var height = svgUse.Height.ToDeviceValue(UnitRenderingType.Vertical, svgUse, skViewport);
if (width <= 0f)
{
width = new SvgUnit(SvgUnitType.Percentage, 100f).ToDeviceValue(UnitRenderingType.Horizontal, svgUse, skViewport);
}
if (height <= 0f)
{
height = new SvgUnit(SvgUnitType.Percentage, 100f).ToDeviceValue(UnitRenderingType.Vertical, svgUse, skViewport);
}
var originalReferencedElementParent = svgReferencedElement.Parent;
try
{
if (s_referencedElementParent is { })
{
s_referencedElementParent.SetValue(svgReferencedElement, svgUse);
}
}
public static ImageDrawable Create(SvgImage svgImage, Rect skOwnerBounds, DrawableBase?parent, IAssetLoader assetLoader, Attributes ignoreAttributes = Attributes.None)
{
var drawable = new ImageDrawable(assetLoader)
{
Element = svgImage,
Parent = parent,
IgnoreAttributes = ignoreAttributes
};
drawable.IsDrawable = drawable.CanDraw(svgImage, drawable.IgnoreAttributes) && drawable.HasFeatures(svgImage, drawable.IgnoreAttributes);
if (!drawable.IsDrawable)
{
return(drawable);
}
var width = svgImage.Width.ToDeviceValue(UnitRenderingType.Horizontal, svgImage, skOwnerBounds);
var height = svgImage.Height.ToDeviceValue(UnitRenderingType.Vertical, svgImage, skOwnerBounds);
var x = svgImage.Location.X.ToDeviceValue(UnitRenderingType.Horizontal, svgImage, skOwnerBounds);
var y = svgImage.Location.Y.ToDeviceValue(UnitRenderingType.Vertical, svgImage, skOwnerBounds);
var location = new Point(x, y);
if (width <= 0f || height <= 0f || svgImage.Href is null)
{
drawable.IsDrawable = false;
return(drawable);
}
// TODO: Check for image recursive references.
//if (HasRecursiveReference(svgImage, (e) => e.Href))
//{
// _canDraw = false;
// return;
//}
var image = SvgModelExtensions.GetImage(svgImage.Href, svgImage.OwnerDocument, assetLoader);
var skImage = image as Image;
var svgFragment = image as SvgFragment;
if (skImage is null && svgFragment is null)
{
drawable.IsDrawable = false;
return(drawable);
}
drawable.SrcRect = default;
if (skImage is { })
public static MaskDrawable Create(SvgMask svgMask, SKRect skViewport, DrawableBase?parent, IAssetLoader assetLoader, HashSet <Uri>?references, DrawAttributes ignoreAttributes = DrawAttributes.None)
{
var drawable = new MaskDrawable(assetLoader, references)
{
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;
// TODO: Pass correct skViewport
var skRectTransformed = SvgExtensions.CalculateRect(xUnit, yUnit, widthUnit, heightUnit, maskUnits, skViewport, skViewport, svgMask);
if (skRectTransformed is null)
{
drawable.IsDrawable = false;
return(drawable);
}
var skMatrix = SKMatrix.CreateIdentity();
if (maskContentUnits == SvgCoordinateUnits.ObjectBoundingBox)
{
var skBoundsTranslateTransform = SKMatrix.CreateTranslation(skViewport.Left, skViewport.Top);
skMatrix = skMatrix.PreConcat(skBoundsTranslateTransform);
var skBoundsScaleTransform = SKMatrix.CreateScale(skViewport.Width, skViewport.Height);
skMatrix = skMatrix.PreConcat(skBoundsScaleTransform);
}
drawable.CreateChildren(svgMask, skViewport, drawable, assetLoader, references, ignoreAttributes);
drawable.Initialize(skRectTransformed.Value, skMatrix);
return(drawable);
}
public static AnchorDrawable Create(SvgAnchor svgAnchor, SKRect skViewport, DrawableBase?parent, IAssetLoader assetLoader, HashSet <Uri>?references, DrawAttributes ignoreAttributes = DrawAttributes.None)
{
var drawable = new AnchorDrawable(assetLoader, references)
{
Element = svgAnchor,
Parent = parent,
IgnoreAttributes = ignoreAttributes,
IsDrawable = true
};
drawable.CreateChildren(svgAnchor, skViewport, drawable, assetLoader, references, ignoreAttributes);
drawable.Initialize();
return(drawable);
}
public static DrawableBase?Create(SvgElement svgElement, Rect skOwnerBounds, DrawableBase?parent, IAssetLoader assetLoader, Attributes ignoreAttributes = Attributes.None)
{
return(svgElement switch
{
SvgAnchor svgAnchor => AnchorDrawable.Create(svgAnchor, skOwnerBounds, parent, assetLoader, ignoreAttributes),
SvgFragment svgFragment => FragmentDrawable.Create(svgFragment, skOwnerBounds, parent, assetLoader, ignoreAttributes),
SvgImage svgImage => ImageDrawable.Create(svgImage, skOwnerBounds, parent, assetLoader, ignoreAttributes),
SvgSwitch svgSwitch => SwitchDrawable.Create(svgSwitch, skOwnerBounds, parent, assetLoader, ignoreAttributes),
SvgUse svgUse => UseDrawable.Create(svgUse, skOwnerBounds, parent, assetLoader, ignoreAttributes),
SvgCircle svgCircle => CircleDrawable.Create(svgCircle, skOwnerBounds, parent, assetLoader, ignoreAttributes),
SvgEllipse svgEllipse => EllipseDrawable.Create(svgEllipse, skOwnerBounds, parent, assetLoader, ignoreAttributes),
SvgRectangle svgRectangle => RectangleDrawable.Create(svgRectangle, skOwnerBounds, parent, assetLoader, ignoreAttributes),
SvgGroup svgGroup => GroupDrawable.Create(svgGroup, skOwnerBounds, parent, assetLoader, ignoreAttributes),
SvgLine svgLine => LineDrawable.Create(svgLine, skOwnerBounds, parent, assetLoader, ignoreAttributes),
SvgPath svgPath => PathDrawable.Create(svgPath, skOwnerBounds, parent, assetLoader, ignoreAttributes),
SvgPolyline svgPolyline => PolylineDrawable.Create(svgPolyline, skOwnerBounds, parent, assetLoader, ignoreAttributes),
SvgPolygon svgPolygon => PolygonDrawable.Create(svgPolygon, skOwnerBounds, parent, assetLoader, ignoreAttributes),
SvgText svgText => TextDrawable.Create(svgText, skOwnerBounds, parent, assetLoader, ignoreAttributes),
_ => null,
});
public static FragmentDrawable Create(SvgFragment svgFragment, SKRect skViewport, DrawableBase?parent, IAssetLoader assetLoader, HashSet <Uri>?references, DrawAttributes ignoreAttributes = DrawAttributes.None)
{
var drawable = new FragmentDrawable(assetLoader, references)
{
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, skViewport);
var y = svgFragmentParent is null ? 0f : svgFragment.Y.ToDeviceValue(UnitRenderingType.Vertical, svgFragment, skViewport);
var skSize = SvgExtensions.GetDimensions(svgFragment);
if (skViewport.IsEmpty)
{
skViewport = SKRect.Create(x, y, skSize.Width, skSize.Height);
}
drawable.CreateChildren(svgFragment, skViewport, drawable, assetLoader, references, ignoreAttributes);
drawable.Initialize(skViewport, x, y, skSize);
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 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 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 abstract void OnDraw(SKCanvas canvas, DrawAttributes ignoreAttributes, DrawableBase?until);
public static SymbolDrawable Create(SvgSymbol svgSymbol, float x, float y, float width, float height, SKRect skViewport, DrawableBase?parent, IAssetLoader assetLoader, HashSet <Uri>?references, DrawAttributes ignoreAttributes)
{
var drawable = new SymbolDrawable(assetLoader, references)
{
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, skViewport);
}
}
if (svgSymbol.CustomAttributes.TryGetValue("height", out var heightString))
{
if (new SvgUnitConverter().ConvertFromString(heightString) is SvgUnit _height)
{
height = _height.ToDeviceValue(UnitRenderingType.Vertical, svgSymbol, skViewport);
}
}
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 = SKRect.Create(x, y, width, height);
break;
}
drawable.CreateChildren(svgSymbol, skViewport, drawable, assetLoader, references, ignoreAttributes);
drawable.Initialize(x, y, width, height);
return(drawable);
}
public override void OnDraw(SKCanvas canvas, DrawAttributes ignoreAttributes, DrawableBase?until)
{
if (until is { } && this == until)
protected void CreateChildren(SvgElement svgElement, SKRect skViewport, DrawableBase?parent, IAssetLoader assetLoader, HashSet <Uri>?references, DrawAttributes ignoreAttributes)
{
foreach (var child in svgElement.Children)
{
var drawable = DrawableFactory.Create(child, skViewport, parent, assetLoader, references, ignoreAttributes);
if (drawable 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);
}
public static MarkerDrawable Create(SvgMarker svgMarker, SvgVisualElement pOwner, Point pMarkerPoint, float fAngle, Rect skOwnerBounds, DrawableBase?parent, IAssetLoader assetLoader, Attributes ignoreAttributes = Attributes.None)
{
var drawable = new MarkerDrawable(assetLoader)
{
Element = svgMarker,
Parent = parent,
IgnoreAttributes = Attributes.Display | ignoreAttributes,
IsDrawable = true
};
if (!drawable.IsDrawable)
{
return(drawable);
}
var markerElement = drawable.GetMarkerElement(svgMarker);
if (markerElement is null)
{
drawable.IsDrawable = false;
return(drawable);
}
var skMarkerMatrix = Matrix.CreateIdentity();
var skMatrixMarkerPoint = Matrix.CreateTranslation(pMarkerPoint.X, pMarkerPoint.Y);
skMarkerMatrix = skMarkerMatrix.PreConcat(skMatrixMarkerPoint);
var skMatrixAngle = Matrix.CreateRotationDegrees(svgMarker.Orient.IsAuto ? fAngle : svgMarker.Orient.Angle);
skMarkerMatrix = skMarkerMatrix.PreConcat(skMatrixAngle);
var strokeWidth = pOwner.StrokeWidth.ToDeviceValue(UnitRenderingType.Other, svgMarker, skOwnerBounds);
var refX = svgMarker.RefX.ToDeviceValue(UnitRenderingType.Horizontal, svgMarker, skOwnerBounds);
var refY = svgMarker.RefY.ToDeviceValue(UnitRenderingType.Vertical, svgMarker, skOwnerBounds);
var markerWidth = svgMarker.MarkerWidth.ToDeviceValue(UnitRenderingType.Other, svgMarker, skOwnerBounds);
var markerHeight = svgMarker.MarkerHeight.ToDeviceValue(UnitRenderingType.Other, svgMarker, skOwnerBounds);
var viewBoxToMarkerUnitsScaleX = 1f;
var viewBoxToMarkerUnitsScaleY = 1f;
switch (svgMarker.MarkerUnits)
{
case SvgMarkerUnits.StrokeWidth:
{
var skMatrixStrokeWidth = Matrix.CreateScale(strokeWidth, strokeWidth);
skMarkerMatrix = skMarkerMatrix.PreConcat(skMatrixStrokeWidth);
var viewBoxWidth = svgMarker.ViewBox.Width;
var viewBoxHeight = svgMarker.ViewBox.Height;
var scaleFactorWidth = viewBoxWidth <= 0 ? 1 : markerWidth / viewBoxWidth;
var scaleFactorHeight = viewBoxHeight <= 0 ? 1 : markerHeight / viewBoxHeight;
viewBoxToMarkerUnitsScaleX = Math.Min(scaleFactorWidth, scaleFactorHeight);
viewBoxToMarkerUnitsScaleY = Math.Min(scaleFactorWidth, scaleFactorHeight);
var skMatrixTranslateRefXY = Matrix.CreateTranslation(-refX * viewBoxToMarkerUnitsScaleX, -refY * viewBoxToMarkerUnitsScaleY);
skMarkerMatrix = skMarkerMatrix.PreConcat(skMatrixTranslateRefXY);
var skMatrixScaleXY = Matrix.CreateScale(viewBoxToMarkerUnitsScaleX, viewBoxToMarkerUnitsScaleY);
skMarkerMatrix = skMarkerMatrix.PreConcat(skMatrixScaleXY);
}
break;
case SvgMarkerUnits.UserSpaceOnUse:
{
var skMatrixTranslateRefXY = Matrix.CreateTranslation(-refX, -refY);
skMarkerMatrix = skMarkerMatrix.PreConcat(skMatrixTranslateRefXY);
}
break;
}
switch (svgMarker.Overflow)
{
case SvgOverflow.Auto:
case SvgOverflow.Visible:
case SvgOverflow.Inherit:
break;
default:
drawable.MarkerClipRect = Rect.Create(
svgMarker.ViewBox.MinX,
svgMarker.ViewBox.MinY,
markerWidth / viewBoxToMarkerUnitsScaleX,
markerHeight / viewBoxToMarkerUnitsScaleY);
break;
}
var markerElementDrawable = DrawableFactory.Create(markerElement, skOwnerBounds, drawable, assetLoader, Attributes.Display);
if (markerElementDrawable is { })
protected void CreateChildren(SvgElement svgElement, Rect skOwnerBounds, DrawableBase?parent, IAssetLoader assetLoader, Attributes ignoreAttributes)
{
foreach (var child in svgElement.Children)
{
var drawable = DrawableFactory.Create(child, skOwnerBounds, parent, assetLoader, ignoreAttributes);
if (drawable is { })
