Merge pull request #107 from Ahrkylien/master

jogibear9988 · web-flow · commit 4b3bb8dd3c43 · 2025-03-31T15:20:21.000+02:00
Fix bugs #104 and #105
diff --git a/Source/SVGImage/SVG/SVG.cs b/Source/SVGImage/SVG/SVG.cs
@@ -17,7 +17,6 @@ namespace SVGImage.SVG
     using PaintServers;
     using Shapes;
     using Utils;
-    using Group = Shapes.Group;
 
     /// <summary>
     /// This is the class that reads and parses the XML file.
@@ -27,12 +26,12 @@ public class SVG
         internal Dictionary<string, Shape> m_shapes;
         internal Dictionary<string, List<StyleItem>> m_styles;
 
-        private List<Shape> m_elements;
+        private readonly List<Shape> m_elements = new List<Shape>();
         private Dictionary<string, Brush> m_customBrushes;
 
         public SVG()
         {
-            this.Size     = new Size(300, 150);
+            this.Size = new Size(300, 150);
             this.Filename = "";
             m_shapes = new Dictionary<string, Shape>();
             m_styles = new Dictionary<string, List<StyleItem>>();
@@ -84,7 +83,8 @@ public SVG(XmlNode svgTag, IExternalFileLoader externalFileLoader)
         public Dictionary<string, Brush> CustomBrushes
         {
             get => m_customBrushes;
-            set {
+            set
+            {
                 m_customBrushes = value;
                 if (m_customBrushes != null)
                 {
@@ -98,7 +98,8 @@ public Dictionary<string, Brush> CustomBrushes
 
         internal IDictionary<string, List<StyleItem>> Styles
         {
-            get {
+            get
+            {
                 return m_styles;
             }
         }
@@ -123,17 +124,7 @@ public Shape GetShape(string id)
 
         public PaintServerManager PaintServers { get; } = new PaintServerManager();
 
-        public IList<Shape> Elements 
-        {
-            get {
-                if (m_elements == null)
-                {
-                    return new List<Shape>();
-                }
-
-                return m_elements.AsReadOnly();
-            }
-        }
+        public IList<Shape> Elements => m_elements.AsReadOnly();
 
         public void LoadXml(string fileXml)
         {
@@ -273,7 +264,7 @@ private void Load(XmlDocument svgDocument)
 
             XmlNode svgTag = svgTags[0];
 
-            m_elements = this.Parse(svgTag);
+            Parse(svgTag);
         }
 
         private void Load(XmlNode svgTag)
@@ -284,7 +275,7 @@ private void Load(XmlNode svgTag)
             }
             this.LoadStyles(svgTag);
 
-            m_elements = this.Parse(svgTag);
+            Parse(svgTag);
         }
 
         private void LoadStyles(XmlNode doc)
@@ -295,8 +286,8 @@ private void LoadStyles(XmlNode doc)
             }
 
             var cssUrlNodes = (from XmlNode childNode in doc.ChildNodes
-                where childNode.NodeType == XmlNodeType.ProcessingInstruction && childNode.Name == "xml-stylesheet"
-                select (XmlProcessingInstruction) childNode).ToList();
+                               where childNode.NodeType == XmlNodeType.ProcessingInstruction && childNode.Name == "xml-stylesheet"
+                               select (XmlProcessingInstruction)childNode).ToList();
 
             if (cssUrlNodes.Count != 0)
             {
@@ -319,27 +310,26 @@ private void LoadStyles(XmlNode doc)
             }
         }
 
-        private List<Shape> Parse(XmlNode node)
+        private void Parse(XmlNode node)
         {
+            if (node == null || (node.Name != SVGTags.sSvg && node.Name != SVGTags.sPattern))
+                throw new FormatException("Not a valide SVG node");
+
             var vb = node.Attributes.GetNamedItem("viewBox");
             if (vb != null)
             {
                 var cord = vb.Value.Split(' ');
                 var cult = CultureInfo.InvariantCulture;
-                this.ViewBox = new Rect(double.Parse(cord[0], cult), 
+                this.ViewBox = new Rect(double.Parse(cord[0], cult),
                     double.Parse(cord[1], cult), double.Parse(cord[2], cult), double.Parse(cord[3], cult));
             }
 
             this.Size = new Size(XmlUtil.AttrValue(node, "width", 300), XmlUtil.AttrValue(node, "height", 150));
-            
-            var lstElements = new List<Shape>();
-            if (node == null || (node.Name != SVGTags.sSvg && node.Name != SVGTags.sPattern))
-                throw new FormatException("Not a valide SVG node");
-
-            foreach (XmlNode childnode in node.ChildNodes)
-                Group.AddToList(this, lstElements, childnode, null);
 
-            return lstElements;
+            // Since SVG has the same functionality as Group we treat it as such, and copy over the children.
+            // It might be more ideal if we would inherit from Group, but that also has its complications.
+            var svgGroup = new Group(this, node, null);
+            m_elements.AddRange(svgGroup.Elements);
         }
     }
 }
diff --git a/Source/SVGImage/SVG/SVGImage.cs b/Source/SVGImage/SVG/SVGImage.cs
@@ -124,11 +124,11 @@ static SVGImage()
 
         public SVGImage()
         {
-            this.ClipToBounds        = true;
+            this.ClipToBounds = true;
             this.SnapsToDevicePixels = true;
 
-            m_offsetTransform        = new TranslateTransform();
-            m_scaleTransform         = new ScaleTransform();
+            m_offsetTransform = new TranslateTransform();
+            m_scaleTransform = new ScaleTransform();
         }
 
         public SVG SVG
@@ -219,10 +219,12 @@ public IExternalFileLoader ExternalFileLoader
         /// <seealso cref="UriSource"/>
         public Uri UriSource
         {
-            get {
+            get
+            {
                 return (Uri)GetValue(UriSourceProperty);
             }
-            set {
+            set
+            {
                 this.SetValue(UriSourceProperty, value);
             }
         }
@@ -235,10 +237,12 @@ public Uri UriSource
         /// </value>
         public Uri BaseUri
         {
-            get {
+            get
+            {
                 return _baseUri;
             }
-            set {
+            set
+            {
                 _baseUri = value;
             }
         }
@@ -252,13 +256,13 @@ public void ReRenderSvg()
             else if (this.IsInitialized && _loadImage != null)
             {
                 _render = new SVGRender();
-                _render.ExternalFileLoader  = this.ExternalFileLoader;
-                _render.OverrideColor       = OverrideColor;
-                _render.OverrideFillColor   = OverrideFillColor;
+                _render.ExternalFileLoader = this.ExternalFileLoader;
+                _render.OverrideColor = OverrideColor;
+                _render.OverrideFillColor = OverrideFillColor;
                 _render.OverrideStrokeColor = OverrideStrokeColor;
-                _render.CustomBrushes       = CustomBrushes;
+                _render.CustomBrushes = CustomBrushes;
                 _render.OverrideStrokeWidth = OverrideStrokeWidth;
-                _render.UseAnimations       = this.UseAnimations;
+                _render.UseAnimations = this.UseAnimations;
 
                 _loadImage(_render);
                 _loadImage = null;
@@ -275,12 +279,12 @@ public void SetImage(string svgFilename)
             if (this.IsInitialized || DesignerProperties.GetIsInDesignMode(this))
             {
                 _render = new SVGRender();
-                _render.ExternalFileLoader  = this.ExternalFileLoader;
-                _render.UseAnimations       = false;
-                _render.OverrideColor       = OverrideColor;
-                _render.OverrideFillColor   = OverrideFillColor;
+                _render.ExternalFileLoader = this.ExternalFileLoader;
+                _render.UseAnimations = false;
+                _render.OverrideColor = OverrideColor;
+                _render.OverrideFillColor = OverrideFillColor;
                 _render.OverrideStrokeColor = OverrideStrokeColor;
-                _render.CustomBrushes       = CustomBrushes;
+                _render.CustomBrushes = CustomBrushes;
                 _render.OverrideStrokeWidth = OverrideStrokeWidth;
 
                 _loadImage(_render);
@@ -298,13 +302,13 @@ public void SetImage(Stream stream)
             if (this.IsInitialized || DesignerProperties.GetIsInDesignMode(this))
             {
                 _render = new SVGRender();
-                _render.ExternalFileLoader  = this.ExternalFileLoader;
-                _render.OverrideColor       = OverrideColor;
-                _render.OverrideFillColor   = OverrideFillColor;
+                _render.ExternalFileLoader = this.ExternalFileLoader;
+                _render.OverrideColor = OverrideColor;
+                _render.OverrideFillColor = OverrideFillColor;
                 _render.OverrideStrokeColor = OverrideStrokeColor;
-                _render.CustomBrushes       = CustomBrushes;
+                _render.CustomBrushes = CustomBrushes;
                 _render.OverrideStrokeWidth = OverrideStrokeWidth;
-                _render.UseAnimations       = false;
+                _render.UseAnimations = false;
 
                 _loadImage(_render);
                 _loadImage = null;
@@ -322,13 +326,13 @@ public void SetImage(Uri uriSource)
             if (this.IsInitialized || DesignerProperties.GetIsInDesignMode(this))
             {
                 _render = new SVGRender();
-                _render.ExternalFileLoader  = this.ExternalFileLoader;
-                _render.OverrideColor       = OverrideColor;
-                _render.OverrideFillColor   = OverrideFillColor;
+                _render.ExternalFileLoader = this.ExternalFileLoader;
+                _render.OverrideColor = OverrideColor;
+                _render.OverrideFillColor = OverrideFillColor;
                 _render.OverrideStrokeColor = OverrideStrokeColor;
-                _render.CustomBrushes       = CustomBrushes;
+                _render.CustomBrushes = CustomBrushes;
                 _render.OverrideStrokeWidth = OverrideStrokeWidth;
-                _render.UseAnimations       = false;
+                _render.UseAnimations = false;
 
                 _loadImage(_render);
                 _loadImage = null;
@@ -352,13 +356,13 @@ protected override void OnInitialized(EventArgs e)
             if (_loadImage != null)
             {
                 _render = new SVGRender();
-                _render.ExternalFileLoader  = this.ExternalFileLoader;
-                _render.OverrideColor       = OverrideColor;
-                _render.OverrideFillColor   = OverrideFillColor;
+                _render.ExternalFileLoader = this.ExternalFileLoader;
+                _render.OverrideColor = OverrideColor;
+                _render.OverrideFillColor = OverrideFillColor;
                 _render.OverrideStrokeColor = OverrideStrokeColor;
-                _render.CustomBrushes       = CustomBrushes;
+                _render.CustomBrushes = CustomBrushes;
                 _render.OverrideStrokeWidth = OverrideStrokeWidth;
-                _render.UseAnimations       = this.UseAnimations;
+                _render.UseAnimations = this.UseAnimations;
 
                 _loadImage(_render);
                 _loadImage = null;
@@ -675,7 +679,14 @@ Uri ResolveUri(Uri svgSource)
             svgPath = svgPath.Replace('/', '\\');
 
             Assembly assembly = Assembly.GetExecutingAssembly();
-            string localFile = Path.Combine(Path.GetDirectoryName(assembly.Location), svgPath);
+
+#if (DOTNET40 || DOTNET45)
+            var appBaseDirectory = Path.GetDirectoryName(assembly.Location);
+#else
+            var appBaseDirectory = AppContext.BaseDirectory;
+#endif
+
+            string localFile = Path.Combine(appBaseDirectory, svgPath);
 
             if (File.Exists(localFile))
             {
@@ -845,7 +856,7 @@ DrawingGroup LoadDrawing(Uri svgSource)
 
         private static void OnUriSourceChanged(DependencyObject obj, DependencyPropertyChangedEventArgs args)
         {
-            SVGImage svgImage= obj as SVGImage;
+            SVGImage svgImage = obj as SVGImage;
             if (svgImage == null)
             {
                 return;
@@ -854,13 +865,13 @@ private static void OnUriSourceChanged(DependencyObject obj, DependencyPropertyC
             var sourceUri = (Uri)args.NewValue;
             if (sourceUri != null)
             {
-                svgImage.SetImage(sourceUri);    
+                svgImage.SetImage(sourceUri);
             }
             else
             {
                 svgImage.SetImage((Drawing)null);
             }
-            
+
         }
 
         static void OnSizeTypeChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
diff --git a/Source/SVGImage/SVG/Shapes/Group.cs b/Source/SVGImage/SVG/Shapes/Group.cs
@@ -24,21 +24,23 @@ public Group(SVG svg, XmlNode node, Shape parent) : base(svg, node)
                 this.m_clip = result as Clip;
             }
 
-            this.Parent = parent;
+            Parent = parent;
             foreach (XmlNode childnode in node.ChildNodes)
             {
-                Shape shape = AddToList(svg, this.m_elements, childnode, this);
-                if (shape != null) shape.Parent = this;
+                Shape shape = AddToList(svg, childnode, this);
+                if (shape != null)
+                    shape.Parent = this;
             }
         }
 
-        public IList<Shape> Elements => this.m_elements.AsReadOnly();
+        public IList<Shape> Elements => m_elements.AsReadOnly();
 
         public bool IsSwitch { get; set; }
 
-        public static Shape AddToList(SVG svg, List<Shape> list, XmlNode childnode, Shape parent)
+        private Shape AddToList(SVG svg, XmlNode childnode, Shape parent, bool isDefinition = false)
         {
-            if (childnode.NodeType != XmlNodeType.Element) return null;
+            if (childnode.NodeType != XmlNodeType.Element)
+                return null;
 
             Shape retVal = null;
 
@@ -72,7 +74,7 @@ public static Shape AddToList(SVG svg, List<Shape> list, XmlNode childnode, Shap
             else if (nodeName == SVGTags.sShapeGroup)
                 retVal = new Group(svg, childnode, parent);
             else if (nodeName == SVGTags.sSwitch)
-                retVal = new Group(svg, childnode, parent) {IsSwitch = true};
+                retVal = new Group(svg, childnode, parent) { IsSwitch = true };
             else if (nodeName == SVGTags.sShapeUse)
                 retVal = new UseShape(svg, childnode);
             else if (nodeName == SVGTags.sShapeImage)
@@ -99,7 +101,7 @@ public static Shape AddToList(SVG svg, List<Shape> list, XmlNode childnode, Shap
             }
             else if (nodeName == SVGTags.sDefinitions)
             {
-                ReadDefs(svg, list, childnode);
+                ReadDefs(svg, childnode);
                 return null;
             }
             else if (nodeName == SVGTags.sSymbol)
@@ -109,7 +111,8 @@ public static Shape AddToList(SVG svg, List<Shape> list, XmlNode childnode, Shap
 
             if (retVal != null)
             {
-                list.Add(retVal);
+                if (!isDefinition)
+                    m_elements.Add(retVal);
                 if (retVal.Id.Length > 0)
                     svg.AddShape(retVal.Id, retVal);
             }
@@ -122,9 +125,8 @@ public static Shape AddToList(SVG svg, List<Shape> list, XmlNode childnode, Shap
             return retVal;
         }
 
-        private static void ReadDefs(SVG svg, List<Shape> list, XmlNode node)
+        private void ReadDefs(SVG svg, XmlNode node)
         {
-            list = new List<Shape>(); // temp list, not needed. 
             //ShapeGroups defined in the 'def' section is added the the 'Shapes' dictionary in SVG for later reference
             foreach (XmlNode childnode in node.ChildNodes)
             {
@@ -137,7 +139,7 @@ private static void ReadDefs(SVG svg, List<Shape> list, XmlNode node)
                     continue;
                 }
 
-                Group.AddToList(svg, list, childnode, null);
+                AddToList(svg, childnode, null, isDefinition: true);
             }
         }
 

Original file line number	Diff line number	Diff line change
`@@ -17,7 +17,6 @@ namespace SVGImage.SVG`
`17`	`17`	`using PaintServers;`
`18`	`18`	`using Shapes;`
`19`	`19`	`using Utils;`
`20`		`- using Group = Shapes.Group;`
`21`	`20`
`22`	`21`	`/// <summary>`
`23`	`22`	`/// This is the class that reads and parses the XML file.`
`@@ -27,12 +26,12 @@ public class SVG`
`27`	`26`	`internal Dictionary<string, Shape> m_shapes;`
`28`	`27`	`internal Dictionary<string, List<StyleItem>> m_styles;`
`29`	`28`
`30`		`- private List<Shape> m_elements;`
	`29`	`+ private readonly List<Shape> m_elements = new List<Shape>();`
`31`	`30`	`private Dictionary<string, Brush> m_customBrushes;`
`32`	`31`
`33`	`32`	`public SVG()`
`34`	`33`	`{`
`35`		`- this.Size = new Size(300, 150);`
	`34`	`+ this.Size = new Size(300, 150);`
`36`	`35`	`this.Filename = "";`
`37`	`36`	`m_shapes = new Dictionary<string, Shape>();`
`38`	`37`	`m_styles = new Dictionary<string, List<StyleItem>>();`
`@@ -84,7 +83,8 @@ public SVG(XmlNode svgTag, IExternalFileLoader externalFileLoader)`
`84`	`83`	`public Dictionary<string, Brush> CustomBrushes`
`85`	`84`	`{`
`86`	`85`	`get => m_customBrushes;`
`87`		`- set {`
	`86`	`+ set`
	`87`	`+ {`
`88`	`88`	`m_customBrushes = value;`
`89`	`89`	`if (m_customBrushes != null)`
`90`	`90`	`{`
`@@ -98,7 +98,8 @@ public Dictionary<string, Brush> CustomBrushes`
`98`	`98`
`99`	`99`	`internal IDictionary<string, List<StyleItem>> Styles`
`100`	`100`	`{`
`101`		`- get {`
	`101`	`+ get`
	`102`	`+ {`
`102`	`103`	`return m_styles;`
`103`	`104`	`}`
`104`	`105`	`}`
`@@ -123,17 +124,7 @@ public Shape GetShape(string id)`
`123`	`124`
`124`	`125`	`public PaintServerManager PaintServers { get; } = new PaintServerManager();`
`125`	`126`
`126`		`- public IList<Shape> Elements`
`127`		`- {`
`128`		`- get {`
`129`		`- if (m_elements == null)`
`130`		`- {`
`131`		`- return new List<Shape>();`
`132`		`- }`
`133`		`-`
`134`		`- return m_elements.AsReadOnly();`
`135`		`- }`
`136`		`- }`
	`127`	`+ public IList<Shape> Elements => m_elements.AsReadOnly();`
`137`	`128`
`138`	`129`	`public void LoadXml(string fileXml)`
`139`	`130`	`{`
`@@ -273,7 +264,7 @@ private void Load(XmlDocument svgDocument)`
`273`	`264`
`274`	`265`	`XmlNode svgTag = svgTags[0];`
`275`	`266`
`276`		`- m_elements = this.Parse(svgTag);`
	`267`	`+ Parse(svgTag);`
`277`	`268`	`}`
`278`	`269`
`279`	`270`	`private void Load(XmlNode svgTag)`
`@@ -284,7 +275,7 @@ private void Load(XmlNode svgTag)`
`284`	`275`	`}`
`285`	`276`	`this.LoadStyles(svgTag);`
`286`	`277`
`287`		`- m_elements = this.Parse(svgTag);`
	`278`	`+ Parse(svgTag);`
`288`	`279`	`}`
`289`	`280`
`290`	`281`	`private void LoadStyles(XmlNode doc)`
`@@ -295,8 +286,8 @@ private void LoadStyles(XmlNode doc)`
`295`	`286`	`}`
`296`	`287`
`297`	`288`	`var cssUrlNodes = (from XmlNode childNode in doc.ChildNodes`
`298`		`- where childNode.NodeType == XmlNodeType.ProcessingInstruction && childNode.Name == "xml-stylesheet"`
`299`		`- select (XmlProcessingInstruction) childNode).ToList();`
	`289`	`+ where childNode.NodeType == XmlNodeType.ProcessingInstruction && childNode.Name == "xml-stylesheet"`
	`290`	`+ select (XmlProcessingInstruction)childNode).ToList();`
`300`	`291`
`301`	`292`	`if (cssUrlNodes.Count != 0)`
`302`	`293`	`{`
`@@ -319,27 +310,26 @@ private void LoadStyles(XmlNode doc)`
`319`	`310`	`}`
`320`	`311`	`}`
`321`	`312`
`322`		`- private List<Shape> Parse(XmlNode node)`
	`313`	`+ private void Parse(XmlNode node)`
`323`	`314`	`{`
	`315`	`+ if (node == null \|\| (node.Name != SVGTags.sSvg && node.Name != SVGTags.sPattern))`
	`316`	`+ throw new FormatException("Not a valide SVG node");`
	`317`	`+`
`324`	`318`	`var vb = node.Attributes.GetNamedItem("viewBox");`
`325`	`319`	`if (vb != null)`
`326`	`320`	`{`
`327`	`321`	`var cord = vb.Value.Split(' ');`
`328`	`322`	`var cult = CultureInfo.InvariantCulture;`
`329`		`- this.ViewBox = new Rect(double.Parse(cord[0], cult),`
	`323`	`+ this.ViewBox = new Rect(double.Parse(cord[0], cult),`
`330`	`324`	`double.Parse(cord[1], cult), double.Parse(cord[2], cult), double.Parse(cord[3], cult));`
`331`	`325`	`}`
`332`	`326`
`333`	`327`	`this.Size = new Size(XmlUtil.AttrValue(node, "width", 300), XmlUtil.AttrValue(node, "height", 150));`
`334`		`-`
`335`		`- var lstElements = new List<Shape>();`
`336`		`- if (node == null \|\| (node.Name != SVGTags.sSvg && node.Name != SVGTags.sPattern))`
`337`		`- throw new FormatException("Not a valide SVG node");`
`338`		`-`
`339`		`- foreach (XmlNode childnode in node.ChildNodes)`
`340`		`- Group.AddToList(this, lstElements, childnode, null);`
`341`	`328`
`342`		`- return lstElements;`
	`329`	`+ // Since SVG has the same functionality as Group we treat it as such, and copy over the children.`
	`330`	`+ // It might be more ideal if we would inherit from Group, but that also has its complications.`
	`331`	`+ var svgGroup = new Group(this, node, null);`
	`332`	`+ m_elements.AddRange(svgGroup.Elements);`
`343`	`333`	`}`
`344`	`334`	`}`
`345`	`335`	`}`
Original file line number	Diff line number	Diff line change
`@@ -24,21 +24,23 @@ public Group(SVG svg, XmlNode node, Shape parent) : base(svg, node)`
`24`	`24`	`this.m_clip = result as Clip;`
`25`	`25`	`}`
`26`	`26`
`27`		`- this.Parent = parent;`
	`27`	`+ Parent = parent;`
`28`	`28`	`foreach (XmlNode childnode in node.ChildNodes)`
`29`	`29`	`{`
`30`		`- Shape shape = AddToList(svg, this.m_elements, childnode, this);`
`31`		`- if (shape != null) shape.Parent = this;`
	`30`	`+ Shape shape = AddToList(svg, childnode, this);`
	`31`	`+ if (shape != null)`
	`32`	`+ shape.Parent = this;`
`32`	`33`	`}`
`33`	`34`	`}`
`34`	`35`
`35`		`- public IList<Shape> Elements => this.m_elements.AsReadOnly();`
	`36`	`+ public IList<Shape> Elements => m_elements.AsReadOnly();`
`36`	`37`
`37`	`38`	`public bool IsSwitch { get; set; }`
`38`	`39`
`39`		`- public static Shape AddToList(SVG svg, List<Shape> list, XmlNode childnode, Shape parent)`
	`40`	`+ private Shape AddToList(SVG svg, XmlNode childnode, Shape parent, bool isDefinition = false)`
`40`	`41`	`{`
`41`		`- if (childnode.NodeType != XmlNodeType.Element) return null;`
	`42`	`+ if (childnode.NodeType != XmlNodeType.Element)`
	`43`	`+ return null;`
`42`	`44`
`43`	`45`	`Shape retVal = null;`
`44`	`46`
`@@ -72,7 +74,7 @@ public static Shape AddToList(SVG svg, List<Shape> list, XmlNode childnode, Shap`
`72`	`74`	`else if (nodeName == SVGTags.sShapeGroup)`
`73`	`75`	`retVal = new Group(svg, childnode, parent);`
`74`	`76`	`else if (nodeName == SVGTags.sSwitch)`
`75`		`- retVal = new Group(svg, childnode, parent) {IsSwitch = true};`
	`77`	`+ retVal = new Group(svg, childnode, parent) { IsSwitch = true };`
`76`	`78`	`else if (nodeName == SVGTags.sShapeUse)`
`77`	`79`	`retVal = new UseShape(svg, childnode);`
`78`	`80`	`else if (nodeName == SVGTags.sShapeImage)`
`@@ -99,7 +101,7 @@ public static Shape AddToList(SVG svg, List<Shape> list, XmlNode childnode, Shap`
`99`	`101`	`}`
`100`	`102`	`else if (nodeName == SVGTags.sDefinitions)`
`101`	`103`	`{`
`102`		`- ReadDefs(svg, list, childnode);`
	`104`	`+ ReadDefs(svg, childnode);`
`103`	`105`	`return null;`
`104`	`106`	`}`
`105`	`107`	`else if (nodeName == SVGTags.sSymbol)`
`@@ -109,7 +111,8 @@ public static Shape AddToList(SVG svg, List<Shape> list, XmlNode childnode, Shap`
`109`	`111`
`110`	`112`	`if (retVal != null)`
`111`	`113`	`{`
`112`		`- list.Add(retVal);`
	`114`	`+ if (!isDefinition)`
	`115`	`+ m_elements.Add(retVal);`
`113`	`116`	`if (retVal.Id.Length > 0)`
`114`	`117`	`svg.AddShape(retVal.Id, retVal);`
`115`	`118`	`}`
`@@ -122,9 +125,8 @@ public static Shape AddToList(SVG svg, List<Shape> list, XmlNode childnode, Shap`
`122`	`125`	`return retVal;`
`123`	`126`	`}`
`124`	`127`
`125`		`- private static void ReadDefs(SVG svg, List<Shape> list, XmlNode node)`
	`128`	`+ private void ReadDefs(SVG svg, XmlNode node)`
`126`	`129`	`{`
`127`		`- list = new List<Shape>(); // temp list, not needed.`
`128`	`130`	`//ShapeGroups defined in the 'def' section is added the the 'Shapes' dictionary in SVG for later reference`
`129`	`131`	`foreach (XmlNode childnode in node.ChildNodes)`
`130`	`132`	`{`
`@@ -137,7 +139,7 @@ private static void ReadDefs(SVG svg, List<Shape> list, XmlNode node)`
`137`	`139`	`continue;`
`138`	`140`	`}`
`139`	`141`
`140`		`- Group.AddToList(svg, list, childnode, null);`
	`142`	`+ AddToList(svg, childnode, null, isDefinition: true);`
`141`	`143`	`}`
`142`	`144`	`}`
`143`	`145`