Add: shape-rendering; Fix: CurrentCulture

Fix:
Now the application make sure to set back the old culture even an error
occurred.
SvgColourConverter.ConvertFrom
SvgPathBuilder.ConvertTo
SvgDocument.Write
SvgExtentions.GetXML

Add:
Attribute: "shape-rendering"

Change:
- Many other properties were unknowingly overloaded. I changed them to
override.
- Some methods or structures need the [CLSCompliant(false)] Attribute.
For example the Enums.TryParse extension. This extension has the where
condition IConvertible. IConvertible is [CLSCompliant(false)] and that
the reason why it is correct to mark the Enums.TryParse extension also
as [CLSCompliant(false)].
- Property "float Opacity" in SvgElement was unknowingly overloaded in
SvgGradientStop as string [stop-opacity]. In the end this property was
only used as float. I changed the SvgGradientStop.Opacity property from
string to float and to override.

Samples/SVGViewer/SvgViewer.cs

@@ -30,8 +30,6 @@ namespace SVGViewer
             }
         }
 
-        private string FXML = "";
-
         private void textBox1_TextChanged(object sender, EventArgs e)
         {
         	using(var s = new MemoryStream(UTF8Encoding.Default.GetBytes(textBox1.Text)))

Source/Basic Shapes/SvgCircle.cs

@@ -84,17 +84,6 @@ namespace Svg
             get { return this.Path(null).GetBounds(); }
         }
 
-        /// <summary>
-        /// Gets a value indicating whether the circle requires anti-aliasing when being rendered.
-        /// </summary>
-        /// <value>
-        /// 	<c>true</c> if the circle requires anti-aliasing; otherwise, <c>false</c>.
-        /// </value>
-        protected override bool RequiresSmoothRendering
-        {
-            get { return true; }
-        }
-
         /// <summary>
         /// Gets the <see cref="GraphicsPath"/> representing this element.
         /// </summary>

Source/Basic Shapes/SvgEllipse.cs

@@ -80,15 +80,6 @@ namespace Svg
         	}
         }
 
-        /// <summary>
-        /// Gets or sets a value to determine if anti-aliasing should occur when the element is being rendered.
-        /// </summary>
-        /// <value></value>
-        protected override bool RequiresSmoothRendering
-        {
-            get { return true; }
-        }
-
         /// <summary>
         /// Gets the bounds of the element.
         /// </summary>

Source/Basic Shapes/SvgPolygon.cs

@@ -31,7 +31,7 @@ namespace Svg
         /// Gets or sets the marker (end cap) of the path.
         /// </summary>
         [SvgAttribute("marker-end")]
-        public Uri MarkerEnd
+        public virtual Uri MarkerEnd
         {
             get { return this.Attributes.GetAttribute<Uri>("marker-end").ReplaceWithNullIfNone(); }
             set { this.Attributes["marker-end"] = value; }
@@ -42,7 +42,7 @@ namespace Svg
         /// Gets or sets the marker (start cap) of the path.
         /// </summary>
         [SvgAttribute("marker-mid")]
-        public Uri MarkerMid
+        public virtual Uri MarkerMid
         {
             get { return this.Attributes.GetAttribute<Uri>("marker-mid").ReplaceWithNullIfNone(); }
             set { this.Attributes["marker-mid"] = value; }
@@ -53,17 +53,12 @@ namespace Svg
         /// Gets or sets the marker (start cap) of the path.
         /// </summary>
         [SvgAttribute("marker-start")]
-        public Uri MarkerStart
+        public virtual Uri MarkerStart
         {
             get { return this.Attributes.GetAttribute<Uri>("marker-start").ReplaceWithNullIfNone(); }
             set { this.Attributes["marker-start"] = value; }
         }
 
-        protected override bool RequiresSmoothRendering
-        {
-            get { return true; }
-        }
-
         public override GraphicsPath Path(ISvgRenderer renderer)
         {
             if ((this._path == null || this.IsPathDirty)	&& base.StrokeWidth > 0)

Source/Basic Shapes/SvgPolyline.cs

@@ -18,7 +18,7 @@ namespace Svg
         /// Gets or sets the marker (end cap) of the path.
         /// </summary>
         [SvgAttribute("marker-end")]
-        public Uri MarkerEnd
+        public override Uri MarkerEnd
         {
             get { return this.Attributes.GetAttribute<Uri>("marker-end").ReplaceWithNullIfNone(); }
             set { this.Attributes["marker-end"] = value; }
@@ -29,7 +29,7 @@ namespace Svg
         /// Gets or sets the marker (start cap) of the path.
         /// </summary>
         [SvgAttribute("marker-mid")]
-        public Uri MarkerMid
+        public override Uri MarkerMid
         {
             get { return this.Attributes.GetAttribute<Uri>("marker-mid").ReplaceWithNullIfNone(); }
             set { this.Attributes["marker-mid"] = value; }
@@ -40,7 +40,7 @@ namespace Svg
         /// Gets or sets the marker (start cap) of the path.
         /// </summary>
         [SvgAttribute("marker-start")]
-        public Uri MarkerStart
+        public override Uri MarkerStart
         {
             get { return this.Attributes.GetAttribute<Uri>("marker-start").ReplaceWithNullIfNone(); }
             set { this.Attributes["marker-start"] = value; }

Source/Basic Shapes/SvgRectangle.cs

@@ -159,7 +159,13 @@ namespace Svg
         /// </summary>
         protected override bool RequiresSmoothRendering
         {
-            get { return (CornerRadiusX.Value > 0 || CornerRadiusY.Value > 0); }
+            get
+            {
+                if (base.RequiresSmoothRendering)
+                    return (CornerRadiusX.Value > 0 || CornerRadiusY.Value > 0);
+                else
+                    return false;
+            }
         }
 
         /// <summary>

Source/Basic Shapes/SvgVisualElement.cs

@@ -11,7 +11,7 @@ namespace Svg
     /// </summary>
     public abstract partial class SvgVisualElement : SvgElement, ISvgBoundable, ISvgStylable, ISvgClipable
     {
-        private bool _requiresSmoothRendering;
+        private bool? _requiresSmoothRendering;
         private Region _previousClip;
 
         /// <summary>
@@ -86,7 +86,28 @@ namespace Svg
         /// </summary>
         protected virtual bool RequiresSmoothRendering
         {
-            get { return this._requiresSmoothRendering; }
+            get
+            {
+                if (_requiresSmoothRendering == null)
+                    _requiresSmoothRendering = ConvertShapeRendering2AntiAlias(ShapeRendering);
+
+                return _requiresSmoothRendering.Value;
+            }
+        }
+
+        private bool ConvertShapeRendering2AntiAlias(SvgShapeRendering shapeRendering)
+        {
+            switch (shapeRendering)
+            {
+                case SvgShapeRendering.OptimizeSpeed:
+                case SvgShapeRendering.CrispEdges:
+                case SvgShapeRendering.GeometricPrecision:
+                    return false;
+                default:
+                    // SvgShapeRendering.Auto
+                    // SvgShapeRendering.Inherit
+                    return true;
+            }
         }
 
         /// <summary>
@@ -95,7 +116,6 @@ namespace Svg
         public SvgVisualElement()
         {
             this.IsPathDirty = true;
-            this._requiresSmoothRendering = false;
         }
 
         protected virtual bool Renderable { get { return true; } }

Source/Document Structure/SvgFragment.cs

@@ -132,7 +132,7 @@ namespace Svg
         /// Refers to the size of the font from baseline to baseline when multiple lines of text are set solid in a multiline layout environment.
         /// </summary>
         [SvgAttribute("font-size")]
-        public virtual SvgUnit FontSize
+        public override SvgUnit FontSize
         {
             get { return (this.Attributes["font-size"] == null) ? SvgUnit.Empty : (SvgUnit)this.Attributes["font-size"]; }
             set { this.Attributes["font-size"] = value; }
@@ -142,7 +142,7 @@ namespace Svg
         /// Indicates which font family is to be used to render the text.
         /// </summary>
         [SvgAttribute("font-family")]
-        public virtual string FontFamily
+        public override string FontFamily
         {
             get { return this.Attributes["font-family"] as string; }
             set { this.Attributes["font-family"] = value; }

Source/Painting/EnumConverters.cs

@@ -183,6 +183,21 @@ namespace Svg
         public SvgTextPathSpacingConverter() : base(SvgTextPathSpacing.Exact) { }
     }
     
+    public sealed class SvgShapeRenderingConverter : EnumBaseConverter<SvgShapeRendering>
+    {
+        public SvgShapeRenderingConverter() : base(SvgShapeRendering.Inherit) { }
+    }
+
+    public sealed class SvgTextRenderingConverter : EnumBaseConverter<SvgTextRendering>
+    {
+        public SvgTextRenderingConverter() : base(SvgTextRendering.Inherit) { }
+    }
+
+    public sealed class SvgImageRenderingConverter : EnumBaseConverter<SvgImageRendering>
+    {
+        public SvgImageRenderingConverter() : base(SvgImageRendering.Inherit) { }
+    }
+    
     public sealed class SvgFontVariantConverter : EnumBaseConverter<SvgFontVariant>
     {
         public SvgFontVariantConverter() : base(SvgFontVariant.Normal) { }
@@ -287,6 +302,7 @@ namespace Svg
 
     public static class Enums 
     {
+        [CLSCompliant(false)]
         public static bool TryParse<TEnum>(string value, out TEnum result) where TEnum : struct, IConvertible
         {
             var retValue = value == null ?

Source/Painting/SvgColourConverter.cs

@@ -33,6 +33,7 @@ namespace Svg
             if (colour != null)
             {
                 var oldCulture = Thread.CurrentThread.CurrentCulture;
+                try {
                     Thread.CurrentThread.CurrentCulture = System.Globalization.CultureInfo.InvariantCulture;
 
                     colour = colour.Trim();
@@ -44,7 +45,7 @@ namespace Svg
                             int start = colour.IndexOf("(") + 1;
 
                             //get the values from the RGB string
-                        string[] values = colour.Substring(start, colour.IndexOf(")") - start).Split(new char[]{',', ' '}, StringSplitOptions.RemoveEmptyEntries);
+                            string[] values = colour.Substring(start, colour.IndexOf(")") - start).Split(new char[] { ',', ' ' }, StringSplitOptions.RemoveEmptyEntries);
 
                             //determine the alpha value if this is an RGBA (it will be the 4th value if there is one)
                             int alphaValue = 255;
@@ -53,14 +54,14 @@ namespace Svg
                                 //the alpha portion of the rgba is not an int 0-255 it is a decimal between 0 and 1
                                 //so we have to determine the corosponding byte value
                                 var alphastring = values[3];
-                            if(alphastring.StartsWith("."))
+                                if (alphastring.StartsWith("."))
                                 {
                                     alphastring = "0" + alphastring;
                                 }
 
                                 var alphaDecimal = decimal.Parse(alphastring);
 
-                            if(alphaDecimal <= 1)
+                                if (alphaDecimal <= 1)
                                 {
                                     alphaValue = (int)(alphaDecimal * 255);
                                 }
@@ -90,27 +91,27 @@ namespace Svg
                         }
                     }
                     // HSL support
-                else if ( colour.StartsWith( "hsl" ) ) {
+                    else if (colour.StartsWith("hsl")) {
                         try
                         {
                             int start = colour.IndexOf("(") + 1;
 
                             //get the values from the RGB string
-                        string[] values = colour.Substring(start, colour.IndexOf(")") - start).Split(new char[]{',', ' '}, StringSplitOptions.RemoveEmptyEntries);
-                        if ( values[1].EndsWith( "%" ) )
+                            string[] values = colour.Substring(start, colour.IndexOf(")") - start).Split(new char[] { ',', ' ' }, StringSplitOptions.RemoveEmptyEntries);
+                            if (values[1].EndsWith("%"))
                             {
-                            values[1] = values[1].TrimEnd( '%' );
+                                values[1] = values[1].TrimEnd('%');
                             }
-                        if ( values[2].EndsWith( "%" ) ) 
+                            if (values[2].EndsWith("%"))
                             {
-                            values[2] = values[2].TrimEnd( '%' );
+                                values[2] = values[2].TrimEnd('%');
                             }
                             // Get the HSL values in a range from 0 to 1.
-                        double h = double.Parse( values[0] ) / 360.0;
-                        double s = double.Parse( values[1] ) / 100.0;
-                        double l = double.Parse( values[2] ) / 100.0;
+                            double h = double.Parse(values[0]) / 360.0;
+                            double s = double.Parse(values[1]) / 100.0;
+                            double l = double.Parse(values[2]) / 100.0;
                             // Convert the HSL color to an RGB color
-                        Color colorpart = Hsl2Rgb( h, s, l );
+                            Color colorpart = Hsl2Rgb(h, s, l);
                             return colorpart;
                         }
                         catch
@@ -155,8 +156,13 @@ namespace Svg
                         case "windowtext": return SystemColors.WindowText;
                     }
 
+                }
+                finally
+                {
+                    // Make sure to set back the old culture even an error occurred.
                     Thread.CurrentThread.CurrentCulture = oldCulture;
                 }
+            }
 
             return base.ConvertFrom(context, culture, value);
         }

Source/Painting/SvgGradientServer.cs

@@ -180,7 +180,7 @@ namespace Svg
                 var currentStop = this.Stops[radial ? this.Stops.Count - 1 - actualStops : actualStops];
                 var boundWidth = renderer.GetBoundable().Bounds.Width;
 
-                mergedOpacity = opacity * currentStop.GetOpacity();
+                mergedOpacity = opacity * currentStop.Opacity;
                 position =
                     radial
                     ? 1 - (currentStop.Offset.ToDeviceValue(renderer, UnitRenderingType.Horizontal, this) / boundWidth)

Source/Painting/SvgGradientStop.cs

@@ -57,7 +57,7 @@ namespace Svg
         /// </summary>
         [SvgAttribute("stop-color")]
         [TypeConverter(typeof(SvgPaintServerFactory))]
-        public SvgPaintServer StopColor
+        public override SvgPaintServer StopColor
         {
             get 
             {
@@ -72,16 +72,10 @@ namespace Svg
         /// Gets or sets the opacity of the gradient stop (0-1).
         /// </summary>
         [SvgAttribute("stop-opacity")]
-        public string Opacity
+        public override float Opacity
         {
-            get { return this.Attributes["stop-opacity"] as string; }
-            set { this.Attributes["stop-opacity"] = value; }
-        }
-
-        public float GetOpacity()
-        {
-            var opacity = this.Opacity;
-            return string.IsNullOrEmpty(opacity) ? 1.0f : float.Parse(opacity);
+            get { return (this.Attributes["stop-opacity"] == null) ? 1.0f : (float)this.Attributes["stop-opacity"]; }
+            set { this.Attributes["stop-opacity"] = FixOpacityValue(value); }
         }
 
         /// <summary>

Source/Painting/SvgPatternServer.cs

@@ -135,7 +135,7 @@ namespace Svg
             set { this.Attributes["gradientTransform"] = value; }
         }
 
-        protected Matrix EffectivePatternTransform
+        private Matrix EffectivePatternTransform
         {
             get
             {

Source/Painting/SvgRadialGradientServer.cs

@@ -147,7 +147,7 @@ namespace Svg
                 {
                     var stop = Stops.Last();
                     var origColor = stop.GetColor(renderingElement);
-                    var renderColor = System.Drawing.Color.FromArgb((int)(opacity * stop.GetOpacity() * 255), origColor);
+                    var renderColor = System.Drawing.Color.FromArgb((int)(opacity * stop.Opacity * 255), origColor);
 
                     var origClip = renderer.GetClip();
                     try

Source/Paths/SvgPath.cs

@@ -104,14 +104,6 @@ namespace Svg
             OnAttributeChanged(new AttributeEventArgs{ Attribute = "d", Value = this.Attributes.GetAttribute<SvgPathSegmentList>("d") });
         }
 
-        /// <summary>
-        /// Gets or sets a value to determine if anti-aliasing should occur when the element is being rendered.
-        /// </summary>
-        protected override bool RequiresSmoothRendering
-        {
-            get { return true; }
-        }
-
         /// <summary>
         /// Gets the bounds of the element.
         /// </summary>

Source/Paths/SvgPathBuilder.cs

@@ -522,11 +522,17 @@ namespace Svg
                 if (paths != null)
                 {
                     var curretCulture = CultureInfo.CurrentCulture;
+                    try {
                         Thread.CurrentThread.CurrentCulture = CultureInfo.InvariantCulture;
                         var s = string.Join(" ", paths.Select(p => p.ToString()).ToArray());
-                    Thread.CurrentThread.CurrentCulture = curretCulture;
                         return s;
                     }
+                    finally
+                    {
+                        // Make sure to set back the old culture even an error occurred.
+                        Thread.CurrentThread.CurrentCulture = curretCulture;
+                    }
+                }
             }
 
             return base.ConvertTo(context, culture, value, destinationType);

Source/Rendering/SvgRendering.cs

+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.ComponentModel;
+
+namespace Svg
+{
+    /// <summary>
+    /// The creator of SVG content might want to provide a hint about what tradeoffs to make as the browser renders <path> element or basic shapes. The shape-rendering attribute provides these hints.
+    /// </summary>
+    /// <references>https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/shape-rendering</references>
+    /// <remarks>
+    /// Default is <see cref="Inherit"/>. That means the value comes from the parent element. If parents are also not set, then the value is <see cref="Auto"/>.
+    /// </remarks>
+    [TypeConverter(typeof(SvgShapeRenderingConverter))]
+    public enum SvgShapeRendering
+    {
+        /// <summary>
+        /// Indicates that the SVG shape rendering properties from the parent will be used.
+        /// </summary>
+        /// <AnitAlias>Based of parent. If parents are also not set, then <see cref="Auto"/></AnitAlias>
+        Inherit,
+
+        /// <summary>
+        /// Indicates that the user agent shall make appropriate tradeoffs to balance speed, crisp edges and geometric precision, but with geometric precision given more importance than speed and crisp edges.
+        /// </summary>
+        /// <AnitAlias>true</AnitAlias>
+        Auto,
+
+        /// <summary>
+        /// Indicates that the user agent shall emphasize rendering speed over geometric precision and crisp edges. This option will sometimes cause the user agent to turn off shape anti-aliasing.
+        /// </summary>
+        /// <AnitAlias>false</AnitAlias>
+        OptimizeSpeed,
+
+        /// <summary>
+        /// Indicates that the user agent shall attempt to emphasize the contrast between clean edges of artwork over rendering speed and geometric precision. To achieve crisp edges, the user agent might turn off anti-aliasing for all lines and curves or possibly just for straight lines which are close to vertical or horizontal. Also, the user agent might adjust line positions and line widths to align edges with device pixels.
+        /// </summary>
+        /// <AnitAlias>false</AnitAlias>
+        CrispEdges,
+
+        /// <summary>
+        /// Indicates that the user agent shall emphasize geometric precision over speed and crisp edges.
+        /// </summary>
+        /// <AnitAlias>false</AnitAlias>
+        GeometricPrecision
+    }
+
+
+    /// <summary>
+    /// The creator of SVG content might want to provide a hint about what tradeoffs to make as the browser renders text. The text-rendering attribute provides these hints.
+    /// </summary>
+    /// <references>https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/text-rendering</references>
+    /// <remarks>Not Implemented yet.</remarks>
+    [TypeConverter(typeof(SvgTextRenderingConverter))]
+    public enum SvgTextRendering
+    {
+        /// <summary>
+        /// Indicates that the SVG shape rendering properties from the parent will be used.
+        /// </summary>
+        Inherit,
+
+        /// <summary>
+        /// Indicates that the browser shall make appropriate tradeoffs to balance speed, legibility and geometric precision, but with legibility given more importance than speed and geometric precision.
+        /// </summary>
+        Auto,
+
+        /// <summary>
+        /// Indicates that the user agent shall emphasize rendering speed over legibility and geometric precision. This option will sometimes cause some browsers to turn off text anti-aliasing.
+        /// </summary>
+        OptimizeSpeed,
+
+        /// <summary>
+        /// Indicates that the browser shall emphasize legibility over rendering speed and geometric precision. The user agent will often choose whether to apply anti-aliasing techniques, built-in font hinting or both to produce the most legible text.
+        /// </summary>
+        OptimizeLegibility,
+
+        /// <summary>
+        /// Indicates that the browser shall emphasize geometric precision over legibility and rendering speed. This option will usually cause the user agent to suspend the use of hinting so that glyph outlines are drawn with comparable geometric precision to the rendering of path data.
+        /// </summary>
+        GeometricPrecision
+    }
+
+
+    /// <summary>
+    /// The image-rendering attribute provides a hint to the browser about how to make speed vs. quality tradeoffs as it performs image processing.
+    /// </summary>
+    /// <references>https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/image-rendering</references>
+    /// <remarks>Not Implemented yet.</remarks>
+    [TypeConverter(typeof(SvgImageRenderingConverter))]
+    public enum SvgImageRendering
+    {
+        /// <summary>
+        /// Indicates that the SVG shape rendering properties from the parent will be used.
+        /// </summary>
+        Inherit,
+
+        /// <summary>
+        /// Indicates that the user agent shall make appropriate tradeoffs to balance speed and quality, but quality shall be given more importance than speed.
+        /// </summary>
+        Auto,
+
+        /// <summary>
+        /// Indicates that the user agent shall emphasize rendering speed over quality.
+        /// </summary>
+        OptimizeSpeed,
+
+        /// <summary>
+        /// Indicates that the user agent shall emphasize quality over rendering speed.
+        /// </summary>
+        OptimizeQuality
+    }
+}

Source/Svg.csproj

@@ -115,6 +115,7 @@
     <Compile Include="Paths\CoordinateParser.cs" />
     <Compile Include="Rendering\IGraphicsProvider.cs" />
     <Compile Include="Rendering\ISvgRenderer.cs" />
+    <Compile Include="Rendering\SvgRendering.cs" />
     <Compile Include="SvgElementStyle.cs" />
     <Compile Include="SvgNodeReader.cs" />
     <Compile Include="Css\CssQuery.cs" />

Source/SvgDocument.cs

@@ -563,13 +563,17 @@ namespace Svg
         {
             //Save previous culture and switch to invariant for writing
             var previousCulture = Thread.CurrentThread.CurrentCulture;
+            try {
                 Thread.CurrentThread.CurrentCulture = CultureInfo.InvariantCulture;
-
                 base.Write(writer);
-
+            }
+            finally
+            {
+                // Make sure to set back the old culture even an error occurred.
                 //Switch culture back
                 Thread.CurrentThread.CurrentCulture = previousCulture;
             }
+        }
 
         public void Write(Stream stream)
         {

Source/SvgElementStyle.cs

@@ -26,7 +26,7 @@ namespace Svg
             set { this._dirty = value; }
         }
 
-        private static float FixOpacityValue(float value)
+        protected static float FixOpacityValue(float value)
         {
             const float max = 1.0f;
             const float min = 0.0f;
@@ -131,7 +131,7 @@ namespace Svg
         /// <remarks>Apparently this can be set on non-sensical elements.  Don't ask; just check the tests.</remarks>
         [SvgAttribute("stop-color", true)]
         [TypeConverter(typeof(SvgPaintServerFactory))]
-        public SvgPaintServer StopColor
+        public virtual SvgPaintServer StopColor
         {
             get { return this.Attributes["stop-color"] as SvgPaintServer; }
             set { this.Attributes["stop-color"] = value; }
@@ -147,6 +147,16 @@ namespace Svg
             set { this.Attributes["opacity"] = FixOpacityValue(value); }
         }
 
+        /// <summary>
+        /// Refers to the AnitAlias rendering of shapes.
+        /// </summary>
+        [SvgAttribute("shape-rendering")]
+        public virtual SvgShapeRendering ShapeRendering
+        {
+            get { return this.Attributes.GetInheritedAttribute<SvgShapeRendering>("shape-rendering"); }
+            set { this.Attributes["shape-rendering"] = value; }
+        }
+
         /// <summary>
         /// Indicates which font family is to be used to render the text.
         /// </summary>