//==========================================================================
        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
        }
示例#2
0
        //==========================================================================
        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 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));
            }
        }