Bug Fixes

- Fixing path parsing algorithm to deal with nuanced arc cases and
hopefully improve performance
- Attempts at better memory management
- Working toward getting symbols to render correctly

Samples/SVGViewer/DebugRenderer.cs

+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Svg;
+using System.Drawing.Drawing2D;
+using System.Drawing;
+
+namespace SVGViewer
+{
+    class DebugRenderer : ISvgRenderer
+    {
+        private Region _clip = new Region();
+        private Matrix _transform = new Matrix();
+        private Stack<ISvgBoundable> _boundables = new Stack<ISvgBoundable>();
+
+        public void SetBoundable(ISvgBoundable boundable)
+        {
+            _boundables.Push(boundable);
+        }
+        public ISvgBoundable GetBoundable()
+        {
+            return _boundables.Peek();
+        }
+        public ISvgBoundable PopBoundable()
+        {
+            return _boundables.Pop();
+        }
+
+
+        public float DpiY
+        {
+            get { return 96; }
+        }
+
+        public void DrawImage(Image image, RectangleF destRect, RectangleF srcRect, GraphicsUnit graphicsUnit)
+        {
+            
+        }
+        public void DrawImageUnscaled(Image image, Point location)
+        {
+            
+        }
+        public void DrawPath(Pen pen, GraphicsPath path)
+        {
+            var newPath = (GraphicsPath)path.Clone();
+            newPath.Transform(_transform);
+
+        }
+        public void FillPath(Brush brush, GraphicsPath path)
+        {
+            var newPath = (GraphicsPath)path.Clone();
+            newPath.Transform(_transform);
+        }
+        public Region GetClip()
+        {
+            return _clip;
+        }
+        public void RotateTransform(float fAngle, MatrixOrder order = MatrixOrder.Append)
+        {
+            _transform.Rotate(fAngle, order);
+        }
+        public void ScaleTransform(float sx, float sy, MatrixOrder order = MatrixOrder.Append)
+        {
+            _transform.Scale(sx, sy, order);
+        }
+        public void SetClip(Region region, CombineMode combineMode = CombineMode.Replace)
+        {
+            switch (combineMode)
+            {
+                case CombineMode.Intersect:
+                    _clip.Intersect(region);
+                    break;
+                case CombineMode.Complement:
+                    _clip.Complement(region);
+                    break;
+                case CombineMode.Exclude:
+                    _clip.Exclude(region);
+                    break;
+                case CombineMode.Union:
+                    _clip.Union(region);
+                    break;
+                case CombineMode.Xor:
+                    _clip.Xor(region);
+                    break;
+                default:
+                    _clip = region;
+                    break;
+            }
+        }
+        public void TranslateTransform(float dx, float dy, MatrixOrder order = MatrixOrder.Append)
+        {
+            _transform.Translate(dx, dy, order);
+        }
+
+
+
+        public SmoothingMode SmoothingMode
+        {
+            get { return SmoothingMode.Default; }
+            set { /* Do Nothing */ }
+        }
+
+        public Matrix Transform
+        {
+            get { return _transform; }
+            set { _transform = value; }
+        }
+
+        public void Dispose()
+        {
+            
+        }
+    }
+}

Samples/SVGViewer/SVGViewer.csproj

@@ -93,6 +93,7 @@
     <Reference Include="System.Xml" />
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="DebugRenderer.cs" />
     <Compile Include="SvgViewer.cs">
       <SubType>Form</SubType>
     </Compile>

Samples/SVGViewer/SvgViewer.cs

@@ -43,6 +43,8 @@ namespace SVGViewer
         
         private void RenderSvg(SvgDocument svgDoc)
         {
+            var render = new DebugRenderer();
+            svgDoc.Draw(render);
             svgImage.Image = svgDoc.Draw();
         }
     }

Source/Basic Shapes/SvgImage.cs

@@ -205,8 +205,10 @@ namespace Svg
                     // we're assuming base64, as ascii encoding would be *highly* unsusual for images
                     // also assuming it's png or jpeg mimetype
                     byte[] imageBytes = Convert.FromBase64String(uriString.Substring(dataIdx));
-                    Image image = Image.FromStream(new MemoryStream(imageBytes));
-                    return image;
+                    using (var stream = new MemoryStream(imageBytes))
+                    {
+                        return Image.FromStream(stream);
+                    }
                 }
 
                 if (!uri.IsAbsoluteUri)
@@ -219,16 +221,19 @@ namespace Svg
 
                 using (WebResponse webResponse = httpRequest.GetResponse())
                 {
-                    MemoryStream ms = BufferToMemoryStream(webResponse.GetResponseStream());
-                    if (uri.LocalPath.EndsWith(".svg", StringComparison.InvariantCultureIgnoreCase))
-                    {
-                        var doc = SvgDocument.Open<SvgDocument>(ms);
-                        doc.BaseUri = uri;
-                        return doc.Draw();
-                    }
-                    else
+                    using (var stream = webResponse.GetResponseStream())
                     {
-                        return Bitmap.FromStream(ms);
+                        stream.Position = 0;
+                        if (uri.LocalPath.EndsWith(".svg", StringComparison.InvariantCultureIgnoreCase))
+                        {
+                            var doc = SvgDocument.Open<SvgDocument>(stream);
+                            doc.BaseUri = uri;
+                            return doc.Draw();
+                        }
+                        else
+                        {
+                            return Bitmap.FromStream(stream);
+                        }
                     }
                 }
             }

Source/Css/SvgElementOps.cs

@@ -10,8 +10,12 @@ namespace Svg.Css
     {
         public Selector<SvgElement> Type(NamespacePrefix prefix, string name)
         {
-            var type = SvgElementFactory.AvailableElements.SingleOrDefault(e => e.ElementName == name);
-            return nodes => nodes.Where(n => n.GetType() == type.ElementType);
+            SvgElementFactory.ElementInfo type = null;
+            if (SvgElementFactory.AvailableElements.TryGetValue(name, out type)) 
+            {
+                return nodes => nodes.Where(n => n.GetType() == type.ElementType);
+            }
+            return nodes => Enumerable.Empty<SvgElement>();
         }
 
         public Selector<SvgElement> Universal(NamespacePrefix prefix)

Source/DataTypes/SvgUnit.cs

@@ -107,34 +107,37 @@ namespace Svg
             }
 
             float points;
-            IFontDefn currFont;
 
             switch (type)
             {
                 case SvgUnitType.Em:
-                    currFont = GetFont(renderer, owner);
-                    if (currFont == null)
+                    using (var currFont = GetFont(renderer, owner))
                     {
-                        points = (float)(value * 9);
-                        _deviceValue = (points / 72.0f) * ppi;
-                    }
-                    else
-                    {
-                        _deviceValue = value * (currFont.SizeInPoints / 72.0f) * ppi;
+                        if (currFont == null)
+                        {
+                            points = (float)(value * 9);
+                            _deviceValue = (points / 72.0f) * ppi;
+                        }
+                        else
+                        {
+                            _deviceValue = value * (currFont.SizeInPoints / 72.0f) * ppi;
+                        }
                     }
                     break;
                 case SvgUnitType.Ex:
-                    currFont = GetFont(renderer, owner);
-                    if (currFont == null)
-                    {
-                        points = (float)(value * 9);
-                        _deviceValue = (points * 0.5f / 72.0f) * ppi;
-                    }
-                    else
+                    using (var currFont = GetFont(renderer, owner))
                     {
-                        _deviceValue = value * 0.5f * (currFont.SizeInPoints / 72.0f) * ppi;
+                        if (currFont == null)
+                        {
+                            points = (float)(value * 9);
+                            _deviceValue = (points * 0.5f / 72.0f) * ppi;
+                        }
+                        else
+                        {
+                            _deviceValue = value * 0.5f * (currFont.SizeInPoints / 72.0f) * ppi;
+                        }
+                        break;
                     }
-                    break;
                 case SvgUnitType.Centimeter:
                     _deviceValue = (float)((value / cmInInch) * ppi);
                     break;

Source/DataTypes/SvgViewBox.cs

@@ -133,8 +133,8 @@ namespace Svg
 
             var fScaleX = width / this.Width;
             var fScaleY = height / this.Height; //(this.MinY < 0 ? -1 : 1) * 
-            var fMinX = this.MinX;
-            var fMinY = this.MinY;
+            var fMinX = -this.MinX;
+            var fMinY = -this.MinY;
 
             if (aspectRatio == null) aspectRatio = new SvgAspectRatio(SvgPreserveAspectRatio.xMidYMid, false);
             if (aspectRatio.Align != SvgPreserveAspectRatio.none)
@@ -197,7 +197,7 @@ namespace Svg
             renderer.SetClip(new Region(new RectangleF(x, y, width, height)), CombineMode.Intersect);
             renderer.ScaleTransform(fScaleX, fScaleY, MatrixOrder.Prepend);
             renderer.TranslateTransform(x, y);
-            renderer.TranslateTransform(-fMinX, -fMinY);
+            renderer.TranslateTransform(fMinX, fMinY);
         }
     }
 

Source/Document Structure/SvgSymbol.cs

@@ -91,6 +91,12 @@ namespace Svg.Document_Structure
             return true;
         }
 
+        // Only render if the parent is set to a Use element
+        protected override void Render(ISvgRenderer renderer)
+        {
+            if (_parent is SvgUse) base.Render(renderer);
+        }
+
         public override SvgElement DeepCopy()
         {
             return DeepCopy<SvgSymbol>();

Source/Document Structure/SvgUse.cs

@@ -41,7 +41,7 @@ namespace Svg
         protected internal override bool PushTransforms(ISvgRenderer renderer)
         {
             if (!base.PushTransforms(renderer)) return false;
-            renderer.TranslateTransform(this.X.ToDeviceValue(renderer, UnitRenderingType.Horizontal, this), 
+            renderer.TranslateTransform(this.X.ToDeviceValue(renderer, UnitRenderingType.Horizontal, this),
                                         this.Y.ToDeviceValue(renderer, UnitRenderingType.Vertical, this));
             return true;
         }
@@ -70,20 +70,22 @@ namespace Svg
 
         protected override void Render(ISvgRenderer renderer)
         {
-            if (!Visible || !Displayable)
-                return;
-
-            this.PushTransforms(renderer);
-
-            SvgVisualElement element = (SvgVisualElement)this.OwnerDocument.IdManager.GetElementById(this.ReferencedElement);
-            // For the time of rendering we want the referenced element to inherit
-            // this elements transforms
-            SvgElement parent = element._parent;
-            element._parent = this;
-            element.RenderElement(renderer);
-            element._parent = parent;
-
-            this.PopTransforms(renderer);
+            if (this.Visible && this.Displayable && this.PushTransforms(renderer))
+            {
+                this.SetClip(renderer);
+
+                var element = (SvgVisualElement)this.OwnerDocument.IdManager.GetElementById(this.ReferencedElement);
+                if (element != null)
+                {
+                    var origParent = element.Parent;
+                    element._parent = this;
+                    element.RenderElement(renderer);
+                    element._parent = origParent;
+                }
+
+                this.ResetClip(renderer);
+                this.PopTransforms(renderer);
+            }
         }
 
 

Source/Filter Effects/feColourMatrix/SvgColourMatrix.cs

@@ -86,17 +86,19 @@ namespace Svg.FilterEffects
             }
 
             var colorMatrix = new ColorMatrix(colorMatrixElements);
-            var imageAttrs = new ImageAttributes();
-            imageAttrs.SetColorMatrix(colorMatrix, ColorMatrixFlag.Default, ColorAdjustType.Bitmap);
-
-            var result = new Bitmap(inputImage.Width, inputImage.Height);
-            using (var g = Graphics.FromImage(result))
+            using (var imageAttrs = new ImageAttributes())
             {
-                g.DrawImage(inputImage, new Rectangle(0, 0, inputImage.Width, inputImage.Height),
-                            0, 0, inputImage.Width, inputImage.Height, GraphicsUnit.Pixel, imageAttrs);
-                g.Flush();
+                imageAttrs.SetColorMatrix(colorMatrix, ColorMatrixFlag.Default, ColorAdjustType.Bitmap);
+
+                var result = new Bitmap(inputImage.Width, inputImage.Height);
+                using (var g = Graphics.FromImage(result))
+                {
+                    g.DrawImage(inputImage, new Rectangle(0, 0, inputImage.Width, inputImage.Height),
+                                0, 0, inputImage.Width, inputImage.Height, GraphicsUnit.Pixel, imageAttrs);
+                    g.Flush();
+                }
+                buffer[this.Result] = result;
             }
-            buffer[this.Result] = result;
 		}
 
 

Source/Painting/SvgMarker.cs

@@ -170,45 +170,47 @@ namespace Svg
         /// <param name="pMarkerPoint"></param>
         private void RenderPart2(float fAngle, ISvgRenderer pRenderer, SvgPath pOwner, PointF pMarkerPoint)
         {
-            Pen pRenderPen = CreatePen(pOwner, pRenderer);
-
-            GraphicsPath markerPath = GetClone(pOwner);
-
-            Matrix transMatrix = new Matrix();
-            transMatrix.Translate(pMarkerPoint.X, pMarkerPoint.Y);
-            if (Orient.IsAuto)
-                transMatrix.Rotate(fAngle);
-            else
-                transMatrix.Rotate(Orient.Angle);
-            switch (MarkerUnits)
-            {
-                case SvgMarkerUnits.strokeWidth:
-                    transMatrix.Translate(AdjustForViewBoxWidth(-RefX.ToDeviceValue(pRenderer, UnitRenderingType.Horizontal, this) * 
-                                            pOwner.StrokeWidth.ToDeviceValue(pRenderer, UnitRenderingType.Other, this)),
-                                          AdjustForViewBoxHeight(-RefY.ToDeviceValue(pRenderer, UnitRenderingType.Vertical, this) *
-                                            pOwner.StrokeWidth.ToDeviceValue(pRenderer, UnitRenderingType.Other, this)));
-                    break;
-                case SvgMarkerUnits.userSpaceOnUse:
-                    transMatrix.Translate(-RefX.ToDeviceValue(pRenderer, UnitRenderingType.Horizontal, this),
-                                          -RefY.ToDeviceValue(pRenderer, UnitRenderingType.Vertical, this));
-                    break;
-            }
-            markerPath.Transform(transMatrix);
-            pRenderer.DrawPath(pRenderPen, markerPath);
-
-            SvgPaintServer pFill = Fill;
-            SvgFillRule pFillRule = FillRule;								// TODO: What do we use the fill rule for?
-            float fOpacity = FillOpacity;
-
-            if (pFill != null)
+            using (var pRenderPen = CreatePen(pOwner, pRenderer))
             {
-                Brush pBrush = pFill.GetBrush(this, pRenderer, fOpacity);
-                pRenderer.FillPath(pBrush, markerPath);
-                pBrush.Dispose();
+                using (var markerPath = GetClone(pOwner))
+                {
+                    using (var transMatrix = new Matrix())
+                    {
+                        transMatrix.Translate(pMarkerPoint.X, pMarkerPoint.Y);
+                        if (Orient.IsAuto)
+                            transMatrix.Rotate(fAngle);
+                        else
+                            transMatrix.Rotate(Orient.Angle);
+                        switch (MarkerUnits)
+                        {
+                            case SvgMarkerUnits.strokeWidth:
+                                transMatrix.Translate(AdjustForViewBoxWidth(-RefX.ToDeviceValue(pRenderer, UnitRenderingType.Horizontal, this) *
+                                                        pOwner.StrokeWidth.ToDeviceValue(pRenderer, UnitRenderingType.Other, this)),
+                                                      AdjustForViewBoxHeight(-RefY.ToDeviceValue(pRenderer, UnitRenderingType.Vertical, this) *
+                                                        pOwner.StrokeWidth.ToDeviceValue(pRenderer, UnitRenderingType.Other, this)));
+                                break;
+                            case SvgMarkerUnits.userSpaceOnUse:
+                                transMatrix.Translate(-RefX.ToDeviceValue(pRenderer, UnitRenderingType.Horizontal, this),
+                                                      -RefY.ToDeviceValue(pRenderer, UnitRenderingType.Vertical, this));
+                                break;
+                        }
+                        markerPath.Transform(transMatrix);
+                        pRenderer.DrawPath(pRenderPen, markerPath);
+
+                        SvgPaintServer pFill = Fill;
+                        SvgFillRule pFillRule = FillRule;								// TODO: What do we use the fill rule for?
+                        float fOpacity = FillOpacity;
+
+                        if (pFill != null)
+                        {
+                            using (var pBrush = pFill.GetBrush(this, pRenderer, fOpacity))
+                            {
+                                pRenderer.FillPath(pBrush, markerPath);
+                            }
+                        }
+                    }
+                }
             }
-            pRenderPen.Dispose();
-            markerPath.Dispose();
-            transMatrix.Dispose();
         }
 
         /// <summary>
@@ -240,9 +242,11 @@ namespace Svg
             switch (MarkerUnits)
             {
                 case SvgMarkerUnits.strokeWidth:
-                    Matrix transMatrix = new Matrix();
-                    transMatrix.Scale(AdjustForViewBoxWidth(pPath.StrokeWidth), AdjustForViewBoxHeight(pPath.StrokeWidth));
-                    pRet.Transform(transMatrix);
+                    using (var transMatrix = new Matrix())
+                    {
+                        transMatrix.Scale(AdjustForViewBoxWidth(pPath.StrokeWidth), AdjustForViewBoxHeight(pPath.StrokeWidth));
+                        pRet.Transform(transMatrix);
+                    }
                     break;
                 case SvgMarkerUnits.userSpaceOnUse:
                     break;

Source/Painting/SvgRadialGradientServer.cs

@@ -128,11 +128,13 @@ namespace Svg
                 // Transform the path based on the scaling
                 var gradBounds = path.GetBounds();
                 var transCenter = new PointF(gradBounds.Left + gradBounds.Width / 2, gradBounds.Top + gradBounds.Height / 2);
-                var scaleMat = new Matrix();
-                scaleMat.Translate(-1 * transCenter.X, -1 * transCenter.Y, MatrixOrder.Append);
-                scaleMat.Scale(scale, scale, MatrixOrder.Append);
-                scaleMat.Translate(transCenter.X, transCenter.Y, MatrixOrder.Append);
-                path.Transform(scaleMat);
+                using (var scaleMat = new Matrix())
+                {
+                    scaleMat.Translate(-1 * transCenter.X, -1 * transCenter.Y, MatrixOrder.Append);
+                    scaleMat.Scale(scale, scale, MatrixOrder.Append);
+                    scaleMat.Translate(transCenter.X, transCenter.Y, MatrixOrder.Append);
+                    path.Transform(scaleMat);
+                }
 
                 // calculate the brush
                 var brush = new PathGradientBrush(path);
@@ -167,16 +169,18 @@ namespace Svg
             };
             var pathBounds = path.GetBounds();
             var pathCenter = new PointF(pathBounds.X + pathBounds.Width / 2, pathBounds.Y + pathBounds.Height / 2);
-            var transform = new Matrix();
-            transform.Translate(-1 * pathCenter.X, -1 * pathCenter.Y, MatrixOrder.Append);
-            transform.Scale(.95f, .95f, MatrixOrder.Append);
-            transform.Translate(pathCenter.X, pathCenter.Y, MatrixOrder.Append);
-
-            var boundsTest = RectangleF.Inflate(bounds, 0, 0);
-            while (!(path.IsVisible(points[0]) && path.IsVisible(points[1]) &&
-                     path.IsVisible(points[2]) && path.IsVisible(points[3])))
+            using (var transform = new Matrix())
             {
-                transform.TransformPoints(points);
+                transform.Translate(-1 * pathCenter.X, -1 * pathCenter.Y, MatrixOrder.Append);
+                transform.Scale(.95f, .95f, MatrixOrder.Append);
+                transform.Translate(pathCenter.X, pathCenter.Y, MatrixOrder.Append);
+
+                var boundsTest = RectangleF.Inflate(bounds, 0, 0);
+                while (!(path.IsVisible(points[0]) && path.IsVisible(points[1]) &&
+                         path.IsVisible(points[2]) && path.IsVisible(points[3])))
+                {
+                    transform.TransformPoints(points);
+                }
             }
             return bounds.Height / (points[2].Y - points[1].Y);
         }

Source/Rendering/ISvgRenderer.cs

@@ -12,11 +12,8 @@ namespace Svg
         void DrawImageUnscaled(Image image, Point location);
         void DrawPath(Pen pen, GraphicsPath path);
         void FillPath(Brush brush, GraphicsPath path);
-        float FontBaselineOffset(IFontDefn font);
         ISvgBoundable GetBoundable();
         Region GetClip();
-        IList<RectangleF> MeasureCharacters(string text, IFontDefn font);
-        SizeF MeasureString(string text, IFontDefn font);
         ISvgBoundable PopBoundable();
         void RotateTransform(float fAngle, MatrixOrder order = MatrixOrder.Append);
         void ScaleTransform(float sx, float sy, MatrixOrder order = MatrixOrder.Append);

Source/Rendering/SvgRenderer.cs

@@ -98,21 +98,6 @@ namespace Svg
             this._innerGraphics.Dispose();
         }
 
-        public float FontBaselineOffset(IFontDefn font)
-        {
-            return font.Ascent(this);
-        }
-
-        public IList<RectangleF> MeasureCharacters(string text, IFontDefn font)
-        {
-            return font.MeasureCharacters(this, text);
-        }
-
-        public SizeF MeasureString(string text, IFontDefn font)
-        {
-            return font.MeasureString(this, text);
-        }
-
         Graphics IGraphicsProvider.GetGraphics()
         {
             return _innerGraphics;

Source/SvgDocument.cs

@@ -171,9 +171,12 @@ namespace Svg
                 throw new FileNotFoundException("The specified document cannot be found.", path);
             }
 
-            var doc = Open<T>(File.OpenRead(path), entities);
-            doc.BaseUri = new Uri(System.IO.Path.GetFullPath(path));
-            return doc;
+            using (var stream = File.OpenRead(path))
+            {
+                var doc = Open<T>(stream, entities);
+                doc.BaseUri = new Uri(System.IO.Path.GetFullPath(path));
+                return doc;
+            }
         }
 
         /// <summary>

Source/SvgElement.cs

@@ -254,6 +254,8 @@ namespace Svg
             get { return this._customAttributes; }
         }
 
+        private static readonly Matrix _zeroMatrix = new Matrix(0, 0, 0, 0, 0, 0);
+
         /// <summary>
         /// Applies the required transforms to <see cref="ISvgRenderer"/>.
         /// </summary>
@@ -268,9 +270,9 @@ namespace Svg
             {
                 return true;
             }
-            if (this.Transforms.Count == 1 && this.Transforms[0].Matrix.Equals(new Matrix(0, 0, 0, 0, 0, 0))) return false;
+            if (this.Transforms.Count == 1 && this.Transforms[0].Matrix.Equals(_zeroMatrix)) return false;
 
-            Matrix transformMatrix = renderer.Transform;
+            Matrix transformMatrix = renderer.Transform.Clone();
 
             foreach (SvgTransform transformation in this.Transforms)
             {

Source/SvgElementFactory.cs

@@ -14,13 +14,13 @@ namespace Svg
     /// </summary>
     internal class SvgElementFactory
     {
-        private static List<ElementInfo> availableElements;
+        private static Dictionary<string, ElementInfo> availableElements;
         private static Parser cssParser = new Parser();
 
         /// <summary>
         /// Gets a list of available types that can be used when creating an <see cref="SvgElement"/>.
         /// </summary>
-        public static List<ElementInfo> AvailableElements
+        public static Dictionary<string, ElementInfo> AvailableElements
         {
             get
             {
@@ -31,7 +31,10 @@ namespace Svg
                                    && t.IsSubclassOf(typeof(SvgElement))
                                    select new ElementInfo { ElementName = ((SvgElementAttribute)t.GetCustomAttributes(typeof(SvgElementAttribute), true)[0]).ElementName, ElementType = t };
 
-                    availableElements = svgTypes.ToList();
+                    availableElements = (from t in svgTypes
+                                         where t.ElementName != "svg"
+                                         group t by t.ElementName into types
+                                         select types).ToDictionary(e => e.Key, e => e.SingleOrDefault());
                 }
 
                 return availableElements;
@@ -91,8 +94,8 @@ namespace Svg
                 }
                 else
                 {
-                    ElementInfo validType = AvailableElements.SingleOrDefault(e => e.ElementName == elementName);
-                    if (validType != null)
+                    ElementInfo validType = null;
+                    if (AvailableElements.TryGetValue(elementName, out validType))
                     {
                         createdElement = (SvgElement) Activator.CreateInstance(validType.ElementType);
                     }

Source/Text/GdiFontDefn.cs

@@ -86,5 +86,10 @@ namespace Svg
                 return provider.GetGraphics();
             }
         }
+
+        public void Dispose()
+        {
+            _font.Dispose();
+        }
     }
 }

Source/Text/IFontDefn.cs

@@ -7,7 +7,7 @@ using System.Drawing.Drawing2D;
 
 namespace Svg
 {
-    public interface IFontDefn
+    public interface IFontDefn : IDisposable
     {
         float Size { get; }
         float SizeInPoints { get; }