Svg2Xaml.SvgURL.Parse C# (CSharp) Method

        public static SvgURL Parse(string value)
        {
            if(value == null)
            throw new ArgumentNullException("value");

              value = value.Trim();

              if(value == "none")
            return null;

              if(value == "")
            throw new ArgumentException("value must not be empty.");

              if(value.StartsWith("url"))
              {
            value = value.Substring(3).Trim();
            if(value.StartsWith("(") && value.EndsWith(")"))
            {
              value = value.Substring(1, value.Length - 2).Trim();
              if(value.StartsWith("#"))
            return new SvgURL(value.Substring(1));
            }
              }

              throw new ArgumentException(String.Format("Unsupported URL 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
        }