Base class for all other SVG elements.
예제 #1
0
        //==========================================================================
        public SvgRectElement(SvgDocument document, SvgBaseElement parent, XElement rectElement)
            : base(document, parent, rectElement)
        {
            XAttribute x_attribute = rectElement.Attribute("x");
              if(x_attribute != null)
            X = SvgCoordinate.Parse(x_attribute.Value);

              XAttribute y_attribute = rectElement.Attribute("y");
              if(y_attribute != null)
            Y = SvgCoordinate.Parse(y_attribute.Value);

              XAttribute width_attribute = rectElement.Attribute("width");
              if(width_attribute != null)
            Width = SvgLength.Parse(width_attribute.Value);

              XAttribute height_attribute = rectElement.Attribute("height");
              if(height_attribute != null)
            Height = SvgLength.Parse(height_attribute.Value);

              XAttribute rx_attribute = rectElement.Attribute("rx");
              if(rx_attribute != null)
            CornerRadiusX = SvgCoordinate.Parse(rx_attribute.Value);

              XAttribute ry_attribute = rectElement.Attribute("ry");
              if(ry_attribute != null)
            CornerRadiusY = SvgCoordinate.Parse(ry_attribute.Value);
        }
예제 #2
0
        //==========================================================================
        public SvgFilterElement(SvgDocument document, SvgBaseElement parent, XElement filterElement)
            : base(document, parent, filterElement)
        {
            foreach(XElement element in from element in filterElement.Elements()
                                  where element.Name.NamespaceName == "http://www.w3.org/2000/svg"
                                  select element)
            switch(element.Name.LocalName)
            {

              case "feGaussianBlur":
            FilterEffects.Add(new SvgFEGaussianBlurElement(document, this, element));
            break;

              case "feBlend":
            FilterEffects.Add(new SvgFEBlendElement(document, this, element));
            break;

              case "feColorMatrix":
            FilterEffects.Add(new SvgFEColorMatrixElement(document, this, element));
            break;

              default:
            throw new NotImplementedException(string.Format("Unhandled element: {0}", element));
            }
        }
예제 #3
0
        //==========================================================================
        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 SvgFEGaussianBlurElement(SvgDocument document, SvgBaseElement parent, XElement feGaussianBlurElement)
     : base(document, parent, feGaussianBlurElement)
 {
     XAttribute std_deviation_attribute = feGaussianBlurElement.Attribute("stdDeviation");
       if(std_deviation_attribute != null)
     StdDeviation = SvgCoordinate.Parse(std_deviation_attribute.Value);
 }
예제 #5
0
 //==========================================================================
 public SvgPathElement(SvgDocument document, SvgBaseElement parent, XElement pathElement)
     : base(document, parent, pathElement)
 {
     XAttribute d_attribute = pathElement.Attribute("d");
       if(d_attribute != null)
     Data = d_attribute.Value;
       else
     Data = null;
 }
        //==========================================================================
        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));
            }
        }
예제 #7
0
        //==========================================================================
        public override Brush ToBrush(SvgBaseElement element)
        {
            if (!element.Document.Elements.ContainsKey(Url))
            return null;

              SvgBaseElement reference = element.Document.Elements[Url];
              if (reference is SvgGradientBaseElement)
            return (reference as SvgGradientBaseElement).ToBrush();
              else if (reference is SvgPatternElement)
            return (reference as SvgPatternElement).ToBrush();

              throw new NotImplementedException();
        }
        //==========================================================================
        public SvgStopElement(SvgDocument document, SvgBaseElement parent, XElement stopElement)
            : base(document, parent, stopElement)
        {
            XAttribute offset_attribute = stopElement.Attribute("offset");
              if(offset_attribute != null)
            Offset = SvgLength.Parse(offset_attribute.Value);

              XAttribute stop_color_attribute = stopElement.Attribute("stop-color");
              if(stop_color_attribute != null)
            Color = SvgColor.Parse(stop_color_attribute.Value);

              XAttribute stop_opacity_attribute = stopElement.Attribute("stop-opacity");
              if(stop_opacity_attribute != null)
            Opacity = SvgLength.Parse(stop_opacity_attribute.Value);
        }
예제 #9
0
        //==========================================================================
        public SvgCircleElement(SvgDocument document, SvgBaseElement parent, XElement circleElement)
            : base(document, parent, circleElement)
        {
            XAttribute cx_attribute = circleElement.Attribute("cx");
              if(cx_attribute != null)
            CenterX = SvgCoordinate.Parse(cx_attribute.Value);

              XAttribute cy_attribute = circleElement.Attribute("cy");
              if(cy_attribute != null)
            CenterY = SvgCoordinate.Parse(cy_attribute.Value);

              XAttribute r_attribute = circleElement.Attribute("r");
              if(r_attribute != null)
            Radius = SvgLength.Parse(r_attribute.Value);
        }
        //==========================================================================
        public SvgFlowRootElement(SvgDocument document, SvgBaseElement parent, XElement flowRootElement)
            : base(document, parent, flowRootElement)
        {
            for(int i = 0; i < Children.Count; ++i)
              {
            FlowRegion = Children[i] as SvgFlowRegionElement;
            if(FlowRegion != null)
            {
              Children.RemoveAt(i);
              break;
            }
              }

              if(FlowRegion == null)
            throw new NotImplementedException();
        }
예제 #11
0
        //==========================================================================
        public SvgLineElement(SvgDocument document, SvgBaseElement parent, XElement lineElement)
            : base(document, parent, lineElement)
        {
            XAttribute x1_attribute = lineElement.Attribute("x1");
              if(x1_attribute != null)
            X1 = SvgCoordinate.Parse(x1_attribute.Value);

              XAttribute y1_attribute = lineElement.Attribute("y1");
              if(y1_attribute != null)
            Y1 = SvgCoordinate.Parse(y1_attribute.Value);

              XAttribute x2_attribute = lineElement.Attribute("x2");
              if(x2_attribute != null)
            X2 = SvgCoordinate.Parse(x2_attribute.Value);

              XAttribute y2_attribute = lineElement.Attribute("y2");
              if(y2_attribute != null)
            Y2 = SvgCoordinate.Parse(y2_attribute.Value);
        }
예제 #12
0
        //==========================================================================
        public SvgEllipseElement(SvgDocument document, SvgBaseElement parent, XElement ellipseElement)
            : base(document, parent, ellipseElement)
        {
            XAttribute cx_attribute = ellipseElement.Attribute("cx");
              if(cx_attribute != null)
            CenterX = SvgCoordinate.Parse(cx_attribute.Value);

              XAttribute cy_attribute = ellipseElement.Attribute("cy");
              if(cy_attribute != null)
            CenterY = SvgCoordinate.Parse(cy_attribute.Value);

              XAttribute rx_attribute = ellipseElement.Attribute("rx");
              if(rx_attribute != null)
            RadiusX = SvgCoordinate.Parse(rx_attribute.Value);

              XAttribute ry_attribute = ellipseElement.Attribute("ry");
              if(ry_attribute != null)
            RadiusY = SvgCoordinate.Parse(ry_attribute.Value);
        }
예제 #13
0
        //==========================================================================
        public SvgMaskElement(SvgDocument document, SvgBaseElement parent, XElement maskElement)
            : base(document, parent, maskElement)
        {
            XAttribute mask_units_attribute = maskElement.Attribute("maskUnits");
              if(mask_units_attribute != null)
            switch(mask_units_attribute.Value)
            {
              case "objectBoundingBox":
            MaskUnits = SvgMaskUnits.ObjectBoundingBox;
            break;

              case "userSpaceOnUse":
            MaskUnits = SvgMaskUnits.UserSpaceOnUse;
            break;

              default:
            throw new NotImplementedException(String.Format("maskUnits value '{0}' is no supported", mask_units_attribute.Value));
            }
        }
예제 #14
0
        //==========================================================================
        public SvgPolylineElement(SvgDocument document, SvgBaseElement parent, XElement polylineElement)
            : base(document, parent, polylineElement)
        {
            XAttribute points_attribute = polylineElement.Attribute("points");
              if(points_attribute != null)
              {
            List<double> coordinates = new List<double>();

            string[] points = points_attribute.Value.Split(',', ' ', '\t');
            foreach(string coordinate_value in points)
            {
              string coordinate = coordinate_value.Trim();
              if(coordinate == "")
            continue;
              coordinates.Add(Double.Parse(coordinate, CultureInfo.InvariantCulture.NumberFormat));
            }

            for(int i = 0; i < coordinates.Count - 1; i += 2)
              Points.Add(new SvgPoint(coordinates[i], coordinates[i + 1]));
              }
        }
        //==========================================================================
        protected SvgBaseElement(SvgDocument document, SvgBaseElement parent, XElement element)
        {
            Document = document;
              Parent   = parent;

              // Create attributes from styles...
              XAttribute style_attribute = element.Attribute("style");
              if(style_attribute != null)
              {
            foreach(string property in style_attribute.Value.Split(';'))
            {
              string[] tokens = property.Split(':');
              if(tokens.Length == 2)
            try
            {
              element.SetAttributeValue(tokens[0], tokens[1]);
            }
            catch(XmlException)
            {
              continue;
            }
            }
            style_attribute.Remove();
              }

              XAttribute id_attribute = element.Attribute("id");
              if(id_attribute != null)
            Document.Elements[Id = id_attribute.Value] = this;

              XAttribute href_attribute = element.Attribute(XName.Get("href", "http://www.w3.org/1999/xlink"));
              if(href_attribute != null)
              {
            string reference = href_attribute.Value;
            if(reference.StartsWith("#"))
              Reference = reference.Substring(1);
              }

              Element = element;
        }
        //==========================================================================
        public SvgRadialGradientElement(SvgDocument document, SvgBaseElement parent, XElement radialGradientElement)
            : base(document, parent, radialGradientElement)
        {
            XAttribute cx_attribute = radialGradientElement.Attribute("cx");
              if(cx_attribute != null)
            CX = SvgCoordinate.Parse(cx_attribute.Value);

              XAttribute cy_attribute = radialGradientElement.Attribute("cy");
              if(cy_attribute != null)
            CY = SvgCoordinate.Parse(cy_attribute.Value);

              XAttribute r_attribute = radialGradientElement.Attribute("r");
              if(r_attribute != null)
            R = SvgCoordinate.Parse(r_attribute.Value);

              XAttribute fx_attribute = radialGradientElement.Attribute("fx");
              if(fx_attribute != null)
            FX = SvgCoordinate.Parse(fx_attribute.Value);

              XAttribute fy_attribute = radialGradientElement.Attribute("fy");
              if(fy_attribute != null)
            FY = SvgCoordinate.Parse(fy_attribute.Value);
        }
예제 #17
0
 //==========================================================================
 public SvgForeignObjectElement(SvgDocument document, SvgBaseElement parent, XElement foreignObjectElement)
     : base(document, parent, foreignObjectElement)
 {
     // ...
 }
예제 #18
0
 //==========================================================================
 public SvgUseElement(SvgDocument document, SvgBaseElement parent, XElement useElement)
     : base(document, parent, useElement)
 {
     // ...
 }
예제 #19
0
        //==========================================================================
        public SvgTextElement(SvgDocument document, SvgBaseElement parent, XElement svgElement)
            : base(document, parent, svgElement)
        {
            var fontFamilyAttr = svgElement.Attribute("font-family");
            var fontFamilyStr  = fontFamilyAttr != null ? fontFamilyAttr.Value : "sans-serif";

            var fontSizeAttr = svgElement.Attribute("font-size");
            var fontSizeStr  = fontSizeAttr != null ? fontSizeAttr.Value : "12px";

            var fontStretchAttr = svgElement.Attribute("font-stretch");
            var fontStretchStr  = fontStretchAttr != null ? fontStretchAttr.Value : "normal";

            var fontStyleAttr = svgElement.Attribute("font-style");
            var fontStyleStr  = fontStyleAttr != null ? fontStyleAttr.Value : "normal";

            var fontWeightAttr = svgElement.Attribute("font-weight");
            var fontWeightStr  = fontWeightAttr != null ? fontWeightAttr.Value : "normal";

            var letterSpacingAttr = svgElement.Attribute("letter-spacing");
            var letterSpacingStr  = letterSpacingAttr != null ? letterSpacingAttr.Value : "0px";

            var lineHeightAttr = svgElement.Attribute("line-height");
            var lineHeightStr  = lineHeightAttr != null ? lineHeightAttr.Value : "100%";

            var wordSpacingAttr = svgElement.Attribute("word-spacing");
            var wordSpacingStr  = wordSpacingAttr != null ? wordSpacingAttr.Value : "0px";

            var textAnchorAttr = svgElement.Attribute("text-anchor");

            TextAnchor = textAnchorAttr != null ? textAnchorAttr.Value : "start";

            var xAttr = svgElement.Attribute("x");

            SvgCoordinate.TryUpdate(ref X, xAttr?.Value);

            var yAttr = svgElement.Attribute("y");

            SvgCoordinate.TryUpdate(ref Y, yAttr?.Value);

            var ff = new FontFamily(fontFamilyStr);
            var fs = fontStyleStr.TryConvert(FontStyles.Normal);
            var fw = fontWeightStr.TryConvert(FontWeights.Normal);
            var fc = fontStretchStr.TryConvert(FontStretches.Medium);

            this.FontSize = fontSizeStr.TryConvert <double, LengthConverter>(12.0);
            this.Typeface = new Typeface(ff, fs, fw, fc);

            var firstSubNode = svgElement.FirstNode;

            if (firstSubNode != null)
            {
                if (firstSubNode.NodeType == XmlNodeType.Text)
                {
                    this.Text = ((XText)firstSubNode).Value;
                }
                else
                {
                    this.Text = null;
                }
            }
        }
예제 #20
0
 //==========================================================================
 public SvgFlowParaElement(SvgDocument document, SvgBaseElement parent, XElement flowParaElement)
     : base(document, parent, flowParaElement)
 {
 }
예제 #21
0
 //==========================================================================
 public SvgDefsElement(SvgDocument document, SvgBaseElement parent, XElement defsElement)
     : base(document, parent, defsElement)
 {
     // ...
 }
        //==========================================================================
        public SvgContainerBaseElement(SvgDocument document, SvgBaseElement parent, XElement containerElement)
            : base(document, parent, containerElement)
        {
            foreach (XElement element in from element in containerElement.Elements()
                     where element.Name.NamespaceName == "http://www.w3.org/2000/svg"
                     select element)
            {
                switch (element.Name.LocalName)
                {
                case "svg":
                    Children.Add(new SvgSVGElement(document, this, element));
                    break;

                case "g":
                    Children.Add(new SvgGElement(document, this, element));
                    break;

                case "defs":
                    Children.Add(new SvgDefsElement(document, this, element));
                    break;

                case "symbol":
                    Children.Add(new SvgSymbolElement(document, this, element));
                    break;

                case "clipPath":
                    Children.Add(new SvgClipPathElement(document, this, element));
                    break;

                case "mask":
                    Children.Add(new SvgMaskElement(document, this, element));
                    break;

                case "pattern":
                    Children.Add(new SvgPatternElement(document, this, element));
                    break;

                case "marker":
                    Children.Add(new SvgMarkerElement(document, this, element));
                    break;

                case "a":
                    Children.Add(new SvgAElement(document, this, element));
                    break;

                case "switch":
                    Children.Add(new SvgSwitchElement(document, this, element));
                    break;

                case "path":
                    Children.Add(new SvgPathElement(document, this, element));
                    break;

                case "text":
                    Children.Add(new SvgTextElement(document, this, element));
                    break;

                case "rect":
                    Children.Add(new SvgRectElement(document, this, element));
                    break;

                case "circle":
                    Children.Add(new SvgCircleElement(document, this, element));
                    break;

                case "ellipse":
                    Children.Add(new SvgEllipseElement(document, this, element));
                    break;

                case "line":
                    Children.Add(new SvgLineElement(document, this, element));
                    break;

                case "polyline":
                    Children.Add(new SvgPolylineElement(document, this, element));
                    break;

                case "polygon":
                    Children.Add(new SvgPolygonElement(document, this, element));
                    break;

                case "image":
                    Children.Add(new SvgImageElement(document, this, element));
                    break;

                case "use":
                    Children.Add(new SvgUseElement(document, this, element));
                    break;

                case "linearGradient":
                    Children.Add(new SvgLinearGradientElement(document, this, element));
                    break;

                case "radialGradient":
                    Children.Add(new SvgRadialGradientElement(document, this, element));
                    break;

                case "filter":
                    Children.Add(new SvgFilterElement(document, this, element));
                    break;

                case "metadata":
                    Children.Add(new SvgMetadataElement(document, this, element));
                    break;

                case "flowRoot":
                    Children.Add(new SvgFlowRootElement(document, this, element));
                    break;

                case "flowRegion":
                    Children.Add(new SvgFlowRegionElement(document, this, element));
                    break;

                case "flowPara":
                    Children.Add(new SvgFlowParaElement(document, this, element));
                    break;

                case "flowSpan":
                    Children.Add(new SvgFlowSpanElement(document, this, element));
                    break;

                case "tspan":
                    Children.Add(new SvgTSpanElement(document, this, element));
                    break;

                case "foreignObject":
                    Children.Add(new SvgForeignObjectElement(document, this, element));
                    break;

                case "style":
                    Children.Add(new SvgStyleElement(document, this, element));
                    break;

                default:
                    throw new NotImplementedException(String.Format("Unhandled element: {0}", element));
                }
            }
        }
예제 #23
0
 //==========================================================================
 public SvgMarkerElement(SvgDocument document, SvgBaseElement parent, XElement markerElement)
     : base(document, parent, markerElement)
 {
     // ...
 }
        //==========================================================================
        public SvgContainerBaseElement(SvgDocument document, SvgBaseElement parent, XElement containerElement)
            : base(document, parent, containerElement)
        {
            foreach(XElement element in from element in containerElement.Elements()
                                  where element.Name.NamespaceName == "http://www.w3.org/2000/svg"
                                  select element)
              switch(element.Name.LocalName)
              {
            case "svg":
              Children.Add(new SvgSVGElement(document, this, element));
              break;

            case "g":
              Children.Add(new SvgGElement(document, this, element));
              break;

            case "defs":
              Children.Add(new SvgDefsElement(document, this, element));
              break;

            case "symbol":
              Children.Add(new SvgSymbolElement(document, this, element));
              break;

            case "clipPath":
              Children.Add(new SvgClipPathElement(document, this, element));
              break;

            case "mask":
              Children.Add(new SvgMaskElement(document, this, element));
              break;

            case "pattern":
              Children.Add(new SvgPatternElement(document, this, element));
              break;

            case "marker":
              Children.Add(new SvgMarkerElement(document, this, element));
              break;

            case "a":
              Children.Add(new SvgAElement(document, this, element));
              break;

            case "switch":
              Children.Add(new SvgSwitchElement(document, this, element));
              break;

            case "path":
              Children.Add(new SvgPathElement(document, this, element));
              break;

            case "text":
              Children.Add(new SvgTextElement(document, this, element));
              break;

            case "rect":
              Children.Add(new SvgRectElement(document, this, element));
              break;

            case "circle":
              Children.Add(new SvgCircleElement(document, this, element));
              break;

            case "ellipse":
              Children.Add(new SvgEllipseElement(document, this, element));
              break;

            case "line":
              Children.Add(new SvgLineElement(document, this, element));
              break;

            case "polyline":
              Children.Add(new SvgPolylineElement(document, this, element));
              break;

            case "polygon":
              Children.Add(new SvgPolygonElement(document, this, element));
              break;

            case "image":
              Children.Add(new SvgImageElement(document, this, element));
              break;

            case "use":
              Children.Add(new SvgUseElement(document, this, element));
              break;

            case "linearGradient":
              Children.Add(new SvgLinearGradientElement(document, this, element));
              break;

            case "radialGradient":
              Children.Add(new SvgRadialGradientElement(document, this, element));
              break;

            case "filter":
              Children.Add(new SvgFilterElement(document, this, element));
              break;

            case "metadata":
              Children.Add(new SvgMetadataElement(document, this, element));
              break;

            case "flowRoot":
              Children.Add(new SvgFlowRootElement(document, this, element));
              break;

            case "flowRegion":
              Children.Add(new SvgFlowRegionElement(document, this, element));
              break;

            case "flowPara":
              Children.Add(new SvgFlowParaElement(document, this, element));
              break;

            case "flowSpan":
              Children.Add(new SvgFlowSpanElement(document, this, element));
              break;

            case "tspan":
              Children.Add(new SvgTSpanElement(document, this, element));
              break;

            case "foreignObject":
              Children.Add(new SvgForeignObjectElement(document, this, element));
              break;

            case "style":
              Children.Add(new SvgStyleElement(document, this, element));
              break;

            default:
              throw new NotImplementedException(String.Format("Unhandled element: {0}", element));
              }
        }
예제 #25
0
 //==========================================================================
 public override Brush ToBrush(SvgBaseElement element)
 {
     return new SolidColorBrush(Color.ToColor());
 }
        //==========================================================================
        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));
            }
        }
예제 #27
0
 //==========================================================================
 public SvgFlowSpanElement(SvgDocument document, SvgBaseElement parent, XElement flowSpanElement)
     : base(document, parent, flowSpanElement)
 {
     // ...
 }
 //==========================================================================
 public SvgFilterEffectBaseElement(SvgDocument document, SvgBaseElement parent, XElement filterEffectElement)
     : base(document, parent, filterEffectElement)
 {
     // ...
 }
예제 #29
0
 //==========================================================================
 public SvgClipPathElement(SvgDocument document, SvgBaseElement parent, XElement clipPathElement)
     : base(document, parent, clipPathElement)
 {
     // ...
 }
예제 #30
0
        //==========================================================================
        protected SvgBaseElement(SvgDocument document, SvgBaseElement parent, XElement element)
        {
            Document = document;
            Parent   = parent;

            // Create attributes from styles...

            // ... use element name as class ...
            this.SetStyleAttributesForClasses(document, element, element.Name.LocalName);

            // ... use id as class ...
            var idAttribute = element.Attribute("id");

            if (idAttribute != null)
            {
                this.SetStyleAttributesForClasses(document, element, "#" + idAttribute.Value.Trim());
            }

            // ... use class attribute ...
            var classAttribute = element.Attribute("class");

            if (classAttribute != null)
            {
                var classNames = classAttribute.Value.Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
                classNames = Array.ConvertAll(classNames, className => "." + className);
                this.SetStyleAttributesForClasses(document, element, classNames);
            }

            // ... use style attribute ...
            XAttribute styleAttribute = element.Attribute("style");

            if (styleAttribute != null)
            {
                foreach (string property in styleAttribute.Value.Split(';'))
                {
                    string[] tokens = property.Split(':');
                    if (tokens.Length == 2)
                    {
                        try
                        {
                            element.SetAttributeValue(tokens[0].Trim(), tokens[1].Trim());
                        }
                        catch (XmlException ex)
                        {
                            Debug.WriteLine(ex);
                        }
                    }
                }
                styleAttribute.Remove();
            }

            if (idAttribute != null)
            {
                Document.Elements[Id = idAttribute.Value] = this;
            }

            XAttribute hrefAttribute = element.Attribute(XName.Get("href", "http://www.w3.org/1999/xlink"));

            if (hrefAttribute != null)
            {
                string reference = hrefAttribute.Value;
                if (reference.StartsWith("#"))
                {
                    Reference = reference.Substring(1);
                }
            }

            Element = element;
        }
예제 #31
0
 //==========================================================================
 public SvgMetadataElement(SvgDocument document, SvgBaseElement parent, XElement metadataElement)
     : base(document, parent, metadataElement)
 {
 }
예제 #32
0
 //==========================================================================
 public SvgGElement(SvgDocument document, SvgBaseElement parent, XElement gElement)
     : base(document, parent, gElement)
 {
     // ...
 }
예제 #33
0
 //==========================================================================
 public SvgStyleElement(SvgDocument document, SvgBaseElement parent, XElement styleElement)
     : base(document, parent, styleElement)
 {
     // ...
 }
예제 #34
0
        //==========================================================================
        public SvgImageElement(SvgDocument document, SvgBaseElement parent, XElement imageElement)
            : base(document, parent, imageElement)
        {
            XAttribute x_attribute = imageElement.Attribute("x");

            if (x_attribute != null)
            {
                X = SvgCoordinate.Parse(x_attribute.Value);
            }

            XAttribute y_attribute = imageElement.Attribute("y");

            if (y_attribute != null)
            {
                Y = SvgCoordinate.Parse(y_attribute.Value);
            }

            XAttribute width_attribute = imageElement.Attribute("width");

            if (width_attribute != null)
            {
                Width = SvgLength.Parse(width_attribute.Value);
            }

            XAttribute height_attribute = imageElement.Attribute("height");

            if (height_attribute != null)
            {
                Height = SvgLength.Parse(height_attribute.Value);
            }

            XAttribute href_attribute = imageElement.Attribute(XName.Get("href", "http://www.w3.org/1999/xlink"));

            if (href_attribute != null)
            {
                string reference = href_attribute.Value.TrimStart();
                if (reference.StartsWith("data:"))
                {
                    reference = reference.Substring(5).TrimStart();
                    int index = reference.IndexOf(";");
                    if (index > -1)
                    {
                        string type = reference.Substring(0, index).Trim();
                        reference = reference.Substring(index + 1);

                        index = reference.IndexOf(",");
                        string encoding = reference.Substring(0, index).Trim();
                        reference = reference.Substring(index + 1).TrimStart();

                        switch (encoding)
                        {
                        case "base64":
                            Data = Convert.FromBase64String(reference);
                            break;

                        default:
                            throw new NotSupportedException(String.Format("Unsupported encoding: {0}", encoding));
                        }

                        string[] type_tokens = type.Split('/');
                        if (type_tokens.Length != 2)
                        {
                            throw new NotSupportedException(String.Format("Unsupported type: {0}", type));
                        }

                        type_tokens[0] = type_tokens[0].Trim();
                        if (type_tokens[0] != "image")
                        {
                            throw new NotSupportedException(String.Format("Unsupported type: {0}", type));
                        }

                        switch (type_tokens[1].Trim())
                        {
                        case "jpeg":
                            DataType = "jpeg";
                            break;

                        case "png":
                            DataType = "png";
                            break;

                        default:
                            throw new NotSupportedException(String.Format("Unsupported type: {0}", type));
                        }
                    }
                }
            }
        }
예제 #35
0
 //==========================================================================
 public abstract Brush ToBrush(SvgBaseElement element);
 //==========================================================================
 public SvgAElement(SvgDocument document, SvgBaseElement parent, XElement aElement)
     : base(document, parent, aElement)
 {
     // ...
 }
예제 #37
0
 //==========================================================================
 public SvgFEColorMatrixElement(SvgDocument document, SvgBaseElement parent, XElement feColorMatrixElement)
     : base(document, parent, feColorMatrixElement)
 {
     // ...
 }
예제 #38
0
        //==========================================================================
        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();
                }
            }
        }
예제 #39
0
        //==========================================================================
        public virtual Drawing Draw()
        {
            DrawingGroup drawing_group = new DrawingGroup();

            drawing_group.Opacity = Opacity.ToDouble();
            if (Transform != null)
            {
                drawing_group.Transform = Transform.ToTransform();
            }

            //if (ViewBox != null)
            //    drawing_group.Children.Add(ViewBox.Process());

            foreach (SvgBaseElement child_element in Children)
            {
                SvgBaseElement element = child_element;
                if (element is SvgUseElement)
                {
                    element = (element as SvgUseElement).GetElement();
                }

                Drawing drawing = null;

                if (element is SvgDrawableBaseElement)
                {
                    if ((element as SvgDrawableBaseElement).Display != SvgDisplay.None)
                    {
                        drawing = (element as SvgDrawableBaseElement).Draw();
                    }
                }
                else if (element is SvgDrawableContainerBaseElement)
                {
                    if ((element as SvgDrawableContainerBaseElement).Display != SvgDisplay.None)
                    {
                        drawing = (element as SvgDrawableContainerBaseElement).Draw();
                    }
                }

                if (drawing != null)
                {
                    drawing_group.Children.Add(drawing);
                }
            }

            if (Filter != null)
            {
                SvgFilterElement filter_element = Document.Elements[Filter.Id] as SvgFilterElement;
                if (filter_element != null)
                {
                    drawing_group.BitmapEffect = filter_element.ToBitmapEffect();
                }
            }

            if (ClipPath != null)
            {
                SvgClipPathElement clip_path_element = Document.Elements[ClipPath.Id] as SvgClipPathElement;
                if (clip_path_element != null)
                {
                    drawing_group.ClipGeometry = clip_path_element.GetClipGeometry();
                }
            }

            if (Mask != null)
            {
                SvgMaskElement mask_element = Document.Elements[Mask.Id] as SvgMaskElement;
                if (mask_element != null)
                {
                    DrawingBrush opacity_mask = mask_element.GetOpacityMask();

                    /*
                     * if(Transform != null)
                     * opacity_mask.Transform = Transform.ToTransform();
                     */
                    drawing_group.OpacityMask = opacity_mask;
                }
            }

            // add base element size
            if (this is SvgSVGElement)
            {
                var svg = this as SvgSVGElement;

                DrawingVisual  visual = new DrawingVisual();
                DrawingContext dc     = visual.RenderOpen();

                Rect rect = new Rect(new System.Windows.Point(0, 0), new System.Windows.Size(svg.Width.Value, svg.Height.Value));
                dc.DrawRectangle(System.Windows.Media.Brushes.Transparent, (System.Windows.Media.Pen)null, rect);
                dc.Close();

                drawing_group.Children.Add(visual.Drawing);
            }

            return(drawing_group);
        }
예제 #40
0
 //==========================================================================
 public SvgTextElement(SvgDocument document, SvgBaseElement parent, XElement svgElement)
     : base(document, parent, svgElement)
 {
     // ...
 }
        //==========================================================================
        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
        }
예제 #42
0
 //==========================================================================
 public SvgFEBlendElement(SvgDocument document, SvgBaseElement parent, XElement feBlendElement)
     : base(document, parent, feBlendElement)
 {
     // ...
 }
예제 #43
0
 //==========================================================================
 public SvgTextElement(SvgDocument document, SvgBaseElement parent, XElement svgElement)
     : base(document, parent, svgElement)
 {
     // ...
 }
예제 #44
0
 //==========================================================================
 public SvgMetadataElement(SvgDocument document, SvgBaseElement parent, XElement metadataElement)
     : base(document, parent, metadataElement)
 {
 }
예제 #45
0
 //==========================================================================
 public override Brush ToBrush(SvgBaseElement element)
 {
     return(new SolidColorBrush(Color.ToColor()));
 }
        //==========================================================================
        public virtual Drawing Draw()
        {
            DrawingGroup drawing_group = new DrawingGroup();

            drawing_group.Opacity = Opacity.ToDouble();
            if (Transform != null)
            {
                drawing_group.Transform = Transform.ToTransform();
            }

            if (ViewBox != null)
            {
                drawing_group.Children.Add(ViewBox.Process());
            }

            foreach (SvgBaseElement child_element in Children)
            {
                SvgBaseElement element = child_element;
                if (element is SvgUseElement)
                {
                    element = (element as SvgUseElement).GetElement();
                }

                Drawing drawing = null;

                if (element is SvgDrawableBaseElement)
                {
                    if ((element as SvgDrawableBaseElement).Display != SvgDisplay.None)
                    {
                        drawing = (element as SvgDrawableBaseElement).Draw();
                    }
                }
                else if (element is SvgDrawableContainerBaseElement)
                {
                    if ((element as SvgDrawableContainerBaseElement).Display != SvgDisplay.None)
                    {
                        drawing = (element as SvgDrawableContainerBaseElement).Draw();
                    }
                }

                if (drawing != null)
                {
                    drawing_group.Children.Add(drawing);
                }
            }

            if (Filter != null)
            {
                SvgFilterElement filter_element = Document.Elements[Filter.Id] as SvgFilterElement;
                if (filter_element != null)
                {
                    drawing_group.BitmapEffect = filter_element.ToBitmapEffect();
                }
            }

            if (ClipPath != null)
            {
                SvgClipPathElement clip_path_element = Document.Elements[ClipPath.Id] as SvgClipPathElement;
                if (clip_path_element != null)
                {
                    drawing_group.ClipGeometry = clip_path_element.GetClipGeometry();
                }
            }

            if (Mask != null)
            {
                SvgMaskElement mask_element = Document.Elements[Mask.Id] as SvgMaskElement;
                if (mask_element != null)
                {
                    DrawingBrush opacity_mask = mask_element.GetOpacityMask();

                    /*
                     * if(Transform != null)
                     * opacity_mask.Transform = Transform.ToTransform();
                     */
                    drawing_group.OpacityMask = opacity_mask;
                }
            }

            return(drawing_group);
        }
예제 #47
0
 //==========================================================================
 public abstract Brush ToBrush(SvgBaseElement element);
예제 #48
0
 //==========================================================================
 public SvgClipPathElement(SvgDocument document, SvgBaseElement parent, XElement clipPathElement)
     : base(document, parent, clipPathElement)
 {
     // ...
 }
예제 #49
0
 //==========================================================================
 public SvgStyleElement(SvgDocument document, SvgBaseElement parent, XElement styleElement)
     : base(document, parent, styleElement)
 {
     // ...
 }
 //==========================================================================
 public SvgFlowParaElement(SvgDocument document, SvgBaseElement parent, XElement flowParaElement)
     : base(document, parent, flowParaElement)
 {
 }
 //==========================================================================
 public SvgForeignObjectElement(SvgDocument document, SvgBaseElement parent, XElement foreignObjectElement)
     : base(document, parent, foreignObjectElement)
 {
     // ...
 }
예제 #52
0
 //==========================================================================
 public SvgDefsElement(SvgDocument document, SvgBaseElement parent, XElement defsElement)
     : base(document, parent, defsElement)
 {
     // ...
 }
예제 #53
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>();
                    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 = 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));
                }
            }
        }
예제 #54
0
 //==========================================================================
 public SvgFlowRegionElement(SvgDocument document, SvgBaseElement parent, XElement flowRegionElement)
     : base(document, parent, flowRegionElement)
 {
     // ...
 }
        //==========================================================================
        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));
                }
            }
        }
예제 #56
0
 //==========================================================================
 public SvgGElement(SvgDocument document, SvgBaseElement parent, XElement gElement)
     : base(document, parent, gElement)
 {
     // ...
 }
예제 #57
0
 //==========================================================================
 public SvgAElement(SvgDocument document, SvgBaseElement parent, XElement aElement)
     : base(document, parent, aElement)
 {
     // ...
 }