//==========================================================================
public SvgPatternElement(SvgDocument document, SvgBaseElement parent, XElement patternElement)
: base(document, parent, patternElement)
{
XAttribute pattern_transform_attribute = patternElement.Attribute("patternTransform");
if(pattern_transform_attribute != null)
PatternTransform = SvgTransform.Parse(pattern_transform_attribute.Value);
XAttribute pattern_units_attribute = patternElement.Attribute("patternUnits");
if(pattern_units_attribute != null)
switch(pattern_units_attribute.Value)
{
case "objectBoundingBox":
PatternUnits = SvgPatternUnits.ObjectBoundingBox;
break;
case "userSpaceOnUse":
PatternUnits = SvgPatternUnits.UserSpaceOnUse;
break;
default:
throw new NotImplementedException(String.Format("patternUnits value '{0}' is no supported", pattern_units_attribute.Value));
}
XAttribute width_attribute = patternElement.Attribute("width");
if(width_attribute != null)
Width = SvgLength.Parse(width_attribute.Value);
XAttribute height_attribute = patternElement.Attribute("height");
if(height_attribute != null)
Height = SvgLength.Parse(height_attribute.Value);
}
//==========================================================================
public SvgGradientBaseElement(SvgDocument document, SvgBaseElement parent, XElement gradientElement)
: base(document, parent, gradientElement)
{
XAttribute gradient_units_attribute = gradientElement.Attribute("gradientUnits");
if(gradient_units_attribute != null)
switch(gradient_units_attribute.Value)
{
case "objectBoundingBox":
GradientUnits = SvgGradientUnits.ObjectBoundingBox;
break;
case "userSpaceOnUse":
GradientUnits = SvgGradientUnits.UserSpaceOnUse;
break;
default:
throw new NotImplementedException(String.Format("gradientUnits value '{0}' is no supported", gradient_units_attribute.Value));
}
XAttribute gradient_transform_attribute = gradientElement.Attribute("gradientTransform");
if(gradient_transform_attribute != null)
Transform = SvgTransform.Parse(gradient_transform_attribute.Value);
XAttribute spread_method_attribute = gradientElement.Attribute("spreadMethod");
if(spread_method_attribute != null)
switch(spread_method_attribute.Value)
{
case "pad":
SpreadMethod = SvgSpreadMethod.Pad;
break;
case "reflect":
SpreadMethod = SvgSpreadMethod.Reflect;
break;
case "repeat":
SpreadMethod = SvgSpreadMethod.Repeat;
break;
}
foreach(XElement element in from element in gradientElement.Elements()
where element.Name.NamespaceName == "http://www.w3.org/2000/svg"
select element)
switch(element.Name.LocalName)
{
case "stop":
Stops.Add(new SvgStopElement(Document, this, element));
break;
default:
throw new NotImplementedException(String.Format("Unhandled element: {0}", element));
}
}
//==========================================================================
public SvgPatternElement(SvgDocument document, SvgBaseElement parent, XElement patternElement)
: base(document, parent, patternElement)
{
XAttribute pattern_transform_attribute = patternElement.Attribute("patternTransform");
if (pattern_transform_attribute != null)
{
PatternTransform = SvgTransform.Parse(pattern_transform_attribute.Value);
}
XAttribute pattern_units_attribute = patternElement.Attribute("patternUnits");
if (pattern_units_attribute != null)
{
switch (pattern_units_attribute.Value)
{
case "objectBoundingBox":
PatternUnits = SvgPatternUnits.ObjectBoundingBox;
break;
case "userSpaceOnUse":
PatternUnits = SvgPatternUnits.UserSpaceOnUse;
break;
default:
throw new NotImplementedException(String.Format("patternUnits value '{0}' is no supported", pattern_units_attribute.Value));
}
}
XAttribute width_attribute = patternElement.Attribute("width");
if (width_attribute != null)
{
Width = SvgLength.Parse(width_attribute.Value);
}
XAttribute height_attribute = patternElement.Attribute("height");
if (height_attribute != null)
{
Height = SvgLength.Parse(height_attribute.Value);
}
}
//==========================================================================
public SvgDrawableBaseElement(SvgDocument document, SvgBaseElement parent, XElement drawableBaseElement)
: base(document, parent, drawableBaseElement)
{
XAttribute opacity_attribute = drawableBaseElement.Attribute("opacity");
if (opacity_attribute != null)
{
Opacity = SvgLength.Parse(opacity_attribute.Value);
}
XAttribute fill_opacity_attribute = drawableBaseElement.Attribute("fill-opacity");
if (fill_opacity_attribute != null)
{
FillOpacity = SvgLength.Parse(fill_opacity_attribute.Value);
}
XAttribute stroke_opacity_attribute = drawableBaseElement.Attribute("stroke-opacity");
if (stroke_opacity_attribute != null)
{
StrokeOpacity = SvgLength.Parse(stroke_opacity_attribute.Value);
}
XAttribute transform_attribute = drawableBaseElement.Attribute("transform");
if (transform_attribute != null)
{
Transform = SvgTransform.Parse(transform_attribute.Value);
}
XAttribute fill_attribute = drawableBaseElement.Attribute("fill");
if (fill_attribute != null)
{
Fill = SvgPaint.Parse(fill_attribute.Value);
}
XAttribute stroke_attribute = drawableBaseElement.Attribute("stroke");
if (stroke_attribute != null)
{
Stroke = SvgPaint.Parse(stroke_attribute.Value);
}
XAttribute stroke_width_attribute = drawableBaseElement.Attribute("stroke-width");
if (stroke_width_attribute != null)
{
StrokeWidth = SvgLength.Parse(stroke_width_attribute.Value);
}
XAttribute stroke_linecap_attribute = drawableBaseElement.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 = drawableBaseElement.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 = drawableBaseElement.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 = drawableBaseElement.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>();
foreach (string length in stroke_dasharray_attribute.Value.Split(','))
{
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 = drawableBaseElement.Attribute("stroke-dashoffset");
if (stroke_dashoffset_attribute != null)
{
StrokeDashoffset = SvgLength.Parse(stroke_dashoffset_attribute.Value);
}
XAttribute clip_attribute = drawableBaseElement.Attribute("clip-path");
if (clip_attribute != null)
{
string clip_path = clip_attribute.Value.Trim();
if (clip_path.StartsWith("url"))
{
clip_path = clip_path.Substring(3).Trim();
if (clip_path.StartsWith("(") && clip_path.EndsWith(")"))
{
clip_path = clip_path.Substring(1, clip_path.Length - 2).Trim();
if (clip_path.StartsWith("#"))
{
ClipPath = clip_path.Substring(1);
}
}
}
}
XAttribute filter_attribute = drawableBaseElement.Attribute("filter");
if (filter_attribute != null)
{
string filter = filter_attribute.Value.Trim();
if (filter.StartsWith("url"))
{
filter = filter.Substring(3).Trim();
if (filter.StartsWith("(") && filter.EndsWith(")"))
{
filter = filter.Substring(1, filter.Length - 2).Trim();
if (filter.StartsWith("#"))
{
Filter = filter.Substring(1);
}
}
}
}
XAttribute mask_attribute = drawableBaseElement.Attribute("mask");
if (mask_attribute != null)
{
string mask = mask_attribute.Value.Trim();
if (mask.StartsWith("url"))
{
mask = mask.Substring(3).Trim();
if (mask.StartsWith("(") && mask.EndsWith(")"))
{
mask = mask.Substring(1, mask.Length - 2).Trim();
if (mask.StartsWith("#"))
{
Mask = mask.Substring(1);
}
}
}
}
XAttribute display_attribute = drawableBaseElement.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_rule_attribute = drawableBaseElement.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
// viewBox attribute
// preserveAspectRatio attribute
// overflow
foreach (XElement element in from element in drawableBaseElement.Elements()
where element.Name.NamespaceName == "http://www.w3.org/2000/svg"
select element)
{
switch (element.Name.LocalName)
{
default:
throw new NotImplementedException(String.Format("Unhandled element: {0}", element));
}
}
}
//==========================================================================
public SvgTransformGroup(SvgTransform[] transforms)
{
foreach(SvgTransform transform in transforms)
Transforms.Add(transform);
}
//==========================================================================
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
}
//==========================================================================
public SvgDrawableContainerBaseElement(SvgDocument document, SvgBaseElement parent, XElement drawableContainerElement)
: base(document, parent, drawableContainerElement)
{
XAttribute opacity_attribute = drawableContainerElement.Attribute("opacity");
if (opacity_attribute != null)
{
Opacity = SvgLength.Parse(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();
}
}
}
//==========================================================================
public SvgGradientBaseElement(SvgDocument document, SvgBaseElement parent, XElement gradientElement)
: base(document, parent, gradientElement)
{
XAttribute gradient_units_attribute = gradientElement.Attribute("gradientUnits");
if (gradient_units_attribute != null)
{
switch (gradient_units_attribute.Value)
{
case "objectBoundingBox":
GradientUnits = SvgGradientUnits.ObjectBoundingBox;
break;
case "userSpaceOnUse":
GradientUnits = SvgGradientUnits.UserSpaceOnUse;
break;
default:
throw new NotImplementedException(String.Format("gradientUnits value '{0}' is no supported", gradient_units_attribute.Value));
}
}
XAttribute gradient_transform_attribute = gradientElement.Attribute("gradientTransform");
if (gradient_transform_attribute != null)
{
Transform = SvgTransform.Parse(gradient_transform_attribute.Value);
}
XAttribute spread_method_attribute = gradientElement.Attribute("spreadMethod");
if (spread_method_attribute != null)
{
switch (spread_method_attribute.Value)
{
case "pad":
SpreadMethod = SvgSpreadMethod.Pad;
break;
case "reflect":
SpreadMethod = SvgSpreadMethod.Reflect;
break;
case "repeat":
SpreadMethod = SvgSpreadMethod.Repeat;
break;
}
}
foreach (XElement element in from element in gradientElement.Elements()
where element.Name.NamespaceName == "http://www.w3.org/2000/svg"
select element)
{
switch (element.Name.LocalName)
{
case "stop":
Stops.Add(new SvgStopElement(Document, this, element));
break;
default:
throw new NotImplementedException(String.Format("Unhandled element: {0}", element));
}
}
}
//==========================================================================
public SvgDrawableBaseElement(SvgDocument document, SvgBaseElement parent, XElement drawableBaseElement)
: base(document, parent, drawableBaseElement)
{
XAttribute opacity_attribute = drawableBaseElement.Attribute("opacity");
if(opacity_attribute != null)
Opacity = SvgLength.Parse(opacity_attribute.Value);
XAttribute fill_opacity_attribute = drawableBaseElement.Attribute("fill-opacity");
if(fill_opacity_attribute != null)
FillOpacity = SvgLength.Parse(fill_opacity_attribute.Value);
XAttribute stroke_opacity_attribute = drawableBaseElement.Attribute("stroke-opacity");
if(stroke_opacity_attribute != null)
StrokeOpacity = SvgLength.Parse(stroke_opacity_attribute.Value);
XAttribute transform_attribute = drawableBaseElement.Attribute("transform");
if(transform_attribute != null)
Transform = SvgTransform.Parse(transform_attribute.Value);
XAttribute fill_attribute = drawableBaseElement.Attribute("fill");
if(fill_attribute != null)
Fill = SvgPaint.Parse(fill_attribute.Value);
XAttribute stroke_attribute = drawableBaseElement.Attribute("stroke");
if(stroke_attribute != null)
Stroke = SvgPaint.Parse(stroke_attribute.Value);
XAttribute stroke_width_attribute = drawableBaseElement.Attribute("stroke-width");
if(stroke_width_attribute != null)
StrokeWidth = SvgLength.Parse(stroke_width_attribute.Value);
XAttribute stroke_linecap_attribute = drawableBaseElement.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 = drawableBaseElement.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 = drawableBaseElement.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 = drawableBaseElement.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>();
foreach(string length in stroke_dasharray_attribute.Value.Split(','))
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 = drawableBaseElement.Attribute("stroke-dashoffset");
if(stroke_dashoffset_attribute != null)
StrokeDashoffset = SvgLength.Parse(stroke_dashoffset_attribute.Value);
XAttribute clip_attribute = drawableBaseElement.Attribute("clip-path");
if(clip_attribute != null)
{
string clip_path = clip_attribute.Value.Trim();
if(clip_path.StartsWith("url"))
{
clip_path = clip_path.Substring(3).Trim();
if(clip_path.StartsWith("(") && clip_path.EndsWith(")"))
{
clip_path = clip_path.Substring(1, clip_path.Length - 2).Trim();
if(clip_path.StartsWith("#"))
ClipPath = clip_path.Substring(1);
}
}
}
XAttribute filter_attribute = drawableBaseElement.Attribute("filter");
if(filter_attribute != null)
{
string filter = filter_attribute.Value.Trim();
if(filter.StartsWith("url"))
{
filter = filter.Substring(3).Trim();
if(filter.StartsWith("(") && filter.EndsWith(")"))
{
filter = filter.Substring(1, filter.Length - 2).Trim();
if(filter.StartsWith("#"))
Filter = filter.Substring(1);
}
}
}
XAttribute mask_attribute = drawableBaseElement.Attribute("mask");
if(mask_attribute != null)
{
string mask = mask_attribute.Value.Trim();
if(mask.StartsWith("url"))
{
mask = mask.Substring(3).Trim();
if(mask.StartsWith("(") && mask.EndsWith(")"))
{
mask = mask.Substring(1, mask.Length - 2).Trim();
if(mask.StartsWith("#"))
Mask = mask.Substring(1);
}
}
}
XAttribute display_attribute = drawableBaseElement.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_rule_attribute = drawableBaseElement.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
// viewBox attribute
// preserveAspectRatio attribute
// overflow
foreach(XElement element in from element in drawableBaseElement.Elements()
where element.Name.NamespaceName == "http://www.w3.org/2000/svg"
select element)
switch(element.Name.LocalName)
{
default:
throw new NotImplementedException(String.Format("Unhandled element: {0}", element));
}
}
//==========================================================================
public SvgDrawableContainerBaseElement(SvgDocument document, SvgBaseElement parent, XElement drawableContainerElement)
: base(document, parent, drawableContainerElement)
{
XAttribute opacity_attribute = drawableContainerElement.Attribute("opacity");
if(opacity_attribute != null)
Opacity = SvgLength.Parse(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();
}
}