//==========================================================================
public static SvgTransform Parse(string value)
{
if (value == null)
{
throw new ArgumentNullException("value");
}
value = value.Trim();
if (value == "")
{
throw new ArgumentException("value must not be empty", "value");
}
List <SvgTransform> transforms = new List <SvgTransform>();
string transform = value;
while (transform.Length > 0)
{
if (transform.StartsWith("translate"))
{
transform = transform.Substring(9).TrimStart();
if (transform.StartsWith("("))
{
transform = transform.Substring(1);
int index = transform.IndexOf(")");
if (index >= 0)
{
transforms.Add(SvgTranslateTransform.Parse(transform.Substring(0, index).Trim()));
transform = transform.Substring(index + 1).TrimStart();
continue;
}
}
}
if (transform.StartsWith("matrix"))
{
transform = transform.Substring(6).TrimStart();
if (transform.StartsWith("("))
{
transform = transform.Substring(1);
int index = transform.IndexOf(")");
if (index >= 0)
{
transforms.Add(SvgMatrixTransform.Parse(transform.Substring(0, index).Trim()));
transform = transform.Substring(index + 1).TrimStart();
continue;
}
}
}
if (transform.StartsWith("scale"))
{
transform = transform.Substring(5).TrimStart();
if (transform.StartsWith("("))
{
transform = transform.Substring(1);
int index = transform.IndexOf(")");
if (index >= 0)
{
transforms.Add(SvgScaleTransform.Parse(transform.Substring(0, index).Trim()));
transform = transform.Substring(index + 1).TrimStart();
continue;
}
}
}
if (transform.StartsWith("skew"))
{
transform = transform.Substring(5).TrimStart();
if (transform.StartsWith("("))
{
transform = transform.Substring(1);
int index = transform.IndexOf(")");
if (index >= 0)
{
transforms.Add(SvgSkewTransform.Parse(transform.Substring(0, index).Trim()));
transform = transform.Substring(index + 1).TrimStart();
continue;
}
}
}
if (transform.StartsWith("rotate"))
{
transform = transform.Substring(6).TrimStart();
if (transform.StartsWith("("))
{
transform = transform.Substring(1);
int index = transform.IndexOf(")");
if (index >= 0)
{
transforms.Add(SvgScaleTransform.Parse(transform.Substring(0, index).Trim()));
transform = transform.Substring(index + 1).TrimStart();
continue;
}
}
}
}
if (transforms.Count == 1)
{
return(transforms[0]);
}
else if (transforms.Count > 1)
{
return(new SvgTransformGroup(transforms.ToArray()));
}
throw new ArgumentException(String.Format("Unsupported transform value: {0}", value));
}
//==========================================================================
public SvgDrawableContainerBaseElement(SvgDocument document, SvgBaseElement parent, XElement drawableContainerElement)
: base(document, parent, drawableContainerElement)
{
XAttribute viewBox_attribute = drawableContainerElement.Attribute("viewBox");
if (viewBox_attribute != null)
{
this.ViewBox = SvgViewbox.Parse(viewBox_attribute.Value);
}
XAttribute opacity_attribute = drawableContainerElement.Attribute("opacity");
SvgLength.TryUpdate(ref Opacity, opacity_attribute?.Value);
XAttribute transform_attribute = drawableContainerElement.Attribute("transform");
if (transform_attribute != null)
{
Transform = SvgTransform.Parse(transform_attribute.Value);
}
XAttribute clip_attribute = drawableContainerElement.Attribute("clip-path");
if (clip_attribute != null)
{
ClipPath = SvgURL.Parse(clip_attribute.Value);
}
XAttribute filter_attribute = drawableContainerElement.Attribute("filter");
if (filter_attribute != null)
{
Filter = SvgURL.Parse(filter_attribute.Value);
}
XAttribute mask_attribute = drawableContainerElement.Attribute("mask");
if (mask_attribute != null)
{
Mask = SvgURL.Parse(mask_attribute.Value);
}
XAttribute display_attribute = drawableContainerElement.Attribute("display");
if (display_attribute != null)
{
switch (display_attribute.Value)
{
case "inline":
Display = SvgDisplay.Inline;
break;
case "block":
Display = SvgDisplay.Block;
break;
case "list-item":
Display = SvgDisplay.ListItem;
break;
case "run-in":
Display = SvgDisplay.RunIn;
break;
case "compact":
Display = SvgDisplay.Compact;
break;
case "marker":
Display = SvgDisplay.Marker;
break;
case "table":
Display = SvgDisplay.Table;
break;
case "inline-table":
Display = SvgDisplay.InlineTable;
break;
case "table-row-group":
Display = SvgDisplay.TableRowGroup;
break;
case "table-header-group":
Display = SvgDisplay.TableHeaderGroup;
break;
case "table-footer-group":
Display = SvgDisplay.TableFooterGroup;
break;
case "table-row":
Display = SvgDisplay.TableRow;
break;
case "table-column-group":
Display = SvgDisplay.TableColumnGroup;
break;
case "table-column":
Display = SvgDisplay.TableColumn;
break;
case "table-cell":
Display = SvgDisplay.TableCell;
break;
case "table-caption":
Display = SvgDisplay.TableCaption;
break;
case "none":
Display = SvgDisplay.None;
break;
default:
throw new NotImplementedException();
}
}
XAttribute fill_opacity_attribute = drawableContainerElement.Attribute("fill-opacity");
SvgLength.TryUpdate(ref FillOpacity, fill_opacity_attribute?.Value);
XAttribute stroke_opacity_attribute = drawableContainerElement.Attribute("stroke-opacity");
SvgLength.TryUpdate(ref StrokeOpacity, stroke_opacity_attribute?.Value);
XAttribute fill_attribute = drawableContainerElement.Attribute("fill");
if (fill_attribute != null)
{
Fill = SvgPaint.Parse(fill_attribute.Value);
}
XAttribute stroke_attribute = drawableContainerElement.Attribute("stroke");
if (stroke_attribute != null)
{
Stroke = SvgPaint.Parse(stroke_attribute.Value);
}
XAttribute stroke_width_attribute = drawableContainerElement.Attribute("stroke-width");
SvgLength.TryUpdate(ref StrokeWidth, stroke_width_attribute?.Value);
XAttribute stroke_linecap_attribute = drawableContainerElement.Attribute("stroke-linecap");
if (stroke_linecap_attribute != null)
{
switch (stroke_linecap_attribute.Value)
{
case "butt":
StrokeLinecap = SvgStrokeLinecap.Butt;
break;
case "round":
StrokeLinecap = SvgStrokeLinecap.Round;
break;
case "square":
StrokeLinecap = SvgStrokeLinecap.Square;
break;
case "inherit":
StrokeLinecap = SvgStrokeLinecap.Inherit;
break;
default:
throw new NotImplementedException();
}
}
XAttribute stroke_linejoin_attribute = drawableContainerElement.Attribute("stroke-linejoin");
if (stroke_linejoin_attribute != null)
{
switch (stroke_linejoin_attribute.Value)
{
case "miter":
StrokeLinejoin = SvgStrokeLinejoin.Miter;
break;
case "round":
StrokeLinejoin = SvgStrokeLinejoin.Round;
break;
case "bevel":
StrokeLinejoin = SvgStrokeLinejoin.Bevel;
break;
case "inherit":
StrokeLinejoin = SvgStrokeLinejoin.Inherit;
break;
default:
throw new NotSupportedException();
}
}
XAttribute stroke_miterlimit_attribute = drawableContainerElement.Attribute("stroke-miterlimit");
if (stroke_miterlimit_attribute != null)
{
if (stroke_miterlimit_attribute.Value == "inherit")
{
StrokeMiterlimit = Double.NaN;
}
else
{
double miterlimit = Double.Parse(stroke_miterlimit_attribute.Value, CultureInfo.InvariantCulture.NumberFormat);
//if(miterlimit < 1)
//throw new NotSupportedException("A miterlimit less than 1 is not supported.");
StrokeMiterlimit = miterlimit;
}
}
XAttribute stroke_dasharray_attribute = drawableContainerElement.Attribute("stroke-dasharray");
if (stroke_dasharray_attribute != null)
{
if (stroke_dasharray_attribute.Value == "none")
{
StrokeDasharray = null;
}
else if (stroke_dasharray_attribute.Value == "inherit")
{
StrokeDasharray = new SvgLength[0];
}
else
{
List <SvgLength> lengths = new List <SvgLength>();
var lengthTokens = stroke_dasharray_attribute.Value.Replace(";", "")
.Trim()
.Split(new[] { ' ', ',' }, StringSplitOptions.RemoveEmptyEntries);
foreach (string length in lengthTokens)
{
lengths.Add(SvgLength.Parse(length));
}
if (lengths.Count % 2 == 1)
{
StrokeDasharray = new SvgLength[lengths.Count * 2];
for (int i = 0; i < lengths.Count - 1; ++i)
{
StrokeDasharray[i] = lengths[i];
StrokeDasharray[i + lengths.Count] = lengths[i];
}
}
else
{
StrokeDasharray = lengths.ToArray();
}
}
}
XAttribute stroke_dashoffset_attribute = drawableContainerElement.Attribute("stroke-dashoffset");
SvgLength.TryUpdate(ref StrokeDashoffset, stroke_dashoffset_attribute?.Value);
XAttribute fill_rule_attribute = drawableContainerElement.Attribute("fill-rule");
if (fill_rule_attribute != null)
{
switch (fill_rule_attribute.Value)
{
case "nonzero":
FillRule = SvgFillRule.Nonzero;
break;
case "evenodd":
FillRule = SvgFillRule.Evenodd;
break;
case "inherit":
FillRule = SvgFillRule.Inherit;
break;
default:
throw new NotImplementedException();
}
}
// color, color-interpolation, color-rendering
XAttribute width_attribute = drawableContainerElement.Attribute("width");
SvgLength.TryUpdate(ref Width, width_attribute?.Value);
XAttribute height_attribute = drawableContainerElement.Attribute("height");
SvgLength.TryUpdate(ref Height, height_attribute?.Value);
XAttribute preserveAspectRatio_attribute = drawableContainerElement.Attribute("preserveAspectRatio");
if (preserveAspectRatio_attribute != null)
{
switch (preserveAspectRatio_attribute.Value)
{
case "none":
if (Width != null && Height != null)
{
var scaleTransform = new SvgScaleTransform(
Width.ToDouble() / ViewBox.Value.Width,
Height.ToDouble() / ViewBox.Value.Height);
Width.ToDouble();
if (Transform == null)
{
Transform = scaleTransform;
}
else
{
Transform = new SvgTransformGroup(new[] { Transform, scaleTransform });
}
}
break;
}
}
// overflow
}
