CSS Support

- Very initial support of CSS stylesheets in the SVG via including the
ExCss and Fizzler libraries
- Bug fixes with path rendering
- Improvements to the API for loading an SVG file

Source/External/ExCSS/Model/Selector/NthFirstChildSelector.cs

+
+// ReSharper disable once CheckNamespace
+namespace ExCSS
+{
+    internal sealed class NthFirstChildSelector : NthChildSelector, IToString
+    {
+        public override string ToString(bool friendlyFormat, int indentation = 0)
+        {
+            return FormatSelector(PseudoSelectorPrefix.PseudoFunctionNthchild);
+        }
+    }
+}
\ No newline at end of file

Source/External/ExCSS/Model/Selector/NthLastChildSelector.cs

+using System;
+
+// ReSharper disable once CheckNamespace
+namespace ExCSS
+{
+    internal sealed class NthLastChildSelector : NthChildSelector, IToString
+    {
+        public override string ToString(bool friendlyFormat, int indentation = 0)
+        {
+            return FormatSelector(PseudoSelectorPrefix.PseudoFunctionNthlastchild);
+        }
+    }
+}
\ No newline at end of file

Source/External/ExCSS/Model/Selector/NthLastOfTypeSelector.cs

+
+// ReSharper disable once CheckNamespace
+namespace ExCSS
+{
+    internal sealed class NthLastOfTypeSelector : NthChildSelector, IToString
+    {
+        public override string ToString(bool friendlyFormat, int indentation = 0)
+        {
+            return FormatSelector(PseudoSelectorPrefix.PseudoFunctionNthLastOfType);
+        }
+    }
+}
\ No newline at end of file

Source/External/ExCSS/Model/Selector/NthOfTypeSelector.cs

+
+// ReSharper disable once CheckNamespace
+namespace ExCSS
+{
+    internal sealed class NthOfTypeSelector : NthChildSelector, IToString
+    {
+        public override string ToString(bool friendlyFormat, int indentation = 0)
+        {
+            return FormatSelector(PseudoSelectorPrefix.PseudoFunctionNthOfType);
+        }
+    }
+}
\ No newline at end of file

Source/External/ExCSS/Model/Selector/SelectorList.cs

+using System.Collections;
+using System.Collections.Generic;
+
+// ReSharper disable once CheckNamespace
+namespace ExCSS
+{
+    public abstract class SelectorList : BaseSelector, IEnumerable<BaseSelector>
+    {
+        protected List<BaseSelector> Selectors;
+
+        protected SelectorList()
+        {
+            Selectors = new List<BaseSelector>();
+        }
+
+        public int Length 
+        {
+            get { return Selectors.Count; } 
+        }
+
+        public BaseSelector this[int index]
+        {
+            get { return Selectors[index]; }
+            set { Selectors[index] = value; }
+        }
+
+        public SelectorList AppendSelector(BaseSelector selector)
+        {
+            Selectors.Add(selector);
+            return this;
+        }
+
+        public SelectorList RemoveSelector(SimpleSelector selector)
+        {
+            Selectors.Remove(selector);
+            return this;
+        }
+
+        public SelectorList ClearSelectors()
+        {
+            Selectors.Clear();
+            return this;
+        }
+
+        public IEnumerator<BaseSelector> GetEnumerator()
+        {
+            return Selectors.GetEnumerator();
+        }
+
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            return ((IEnumerable)Selectors).GetEnumerator();
+        }
+
+        public override abstract string ToString(bool friendlyFormat, int indentation = 0);
+    }
+}

Source/External/ExCSS/Model/Selector/SimpleSelector.cs

+using System;
+using ExCSS.Model;
+// ReSharper disable once CheckNamespace
+
+namespace ExCSS
+{
+    public sealed class SimpleSelector : BaseSelector
+    {
+        private readonly string _code;
+        internal static readonly SimpleSelector All = new SimpleSelector("*");
+
+        public SimpleSelector(string selectorText)
+        {
+            _code = selectorText;
+        }
+
+        internal static SimpleSelector PseudoElement(string pseudoElement)
+        {
+            return new SimpleSelector("::" + pseudoElement);
+        }
+
+        internal static SimpleSelector PseudoClass(string pseudoClass)
+        {
+            return new SimpleSelector(":" + pseudoClass);
+        }
+
+        internal static SimpleSelector Class(string match)
+        {
+            return new SimpleSelector("." + match);
+        }
+
+        internal static SimpleSelector Id(string match)
+        {
+            return new SimpleSelector("#" + match);
+        }
+
+        internal static SimpleSelector AttributeUnmatched(string match)
+        {
+            return new SimpleSelector("[" + match + "]");
+        }
+
+        internal static SimpleSelector AttributeMatch(string match, string value)
+        {
+            var code = string.Format("[{0}=\"{1}\"]", match, GetValueAsString(value));
+            return new SimpleSelector(code);
+        }
+
+        internal static SimpleSelector AttributeNegatedMatch(string match, string value)
+        {
+            var code = string.Format("[{0}!=\"{1}\"]", match, GetValueAsString(value));
+            return new SimpleSelector(code);
+        }
+
+        internal static SimpleSelector AttributeSpaceSeparated(string match, string value)
+        {
+            var code = string.Format("[{0}~=\"{1}\"]", match, GetValueAsString(value));
+
+            return new SimpleSelector(code);
+        }
+
+        internal static SimpleSelector AttributeStartsWith(string match, string value)
+        {
+            var code = string.Format("[{0}^=\"{1}\"]", match, GetValueAsString(value));
+
+            return new SimpleSelector(code);
+        }
+
+        internal static SimpleSelector AttributeEndsWith(string match, string value)
+        {
+            var code = string.Format("[{0}$=\"{1}\"]", match, GetValueAsString(value));
+
+            return new SimpleSelector(code);
+        }
+
+        internal static SimpleSelector AttributeContains(string match, string value)
+        {
+            var code = string.Format("[{0}*=\"{1}\"]", match, GetValueAsString(value));
+
+            return new SimpleSelector(code);
+        }
+
+        internal static SimpleSelector AttributeDashSeparated(string match, string value)
+        {
+            var code = string.Format("[{0}|=\"{1}\"]", match, GetValueAsString(value));
+
+            return new SimpleSelector(code);
+        }
+
+        internal static SimpleSelector Type(string match)
+        {
+            return new SimpleSelector(match);
+        }
+
+        private static string GetValueAsString(string value)
+        {
+            var containsSpace = false;
+
+            for (var i = 0; i < value.Length; i++)
+            {
+                if (!value[i].IsSpaceCharacter())
+                {
+                    continue;
+                }
+                containsSpace = true;
+                break;
+            }
+
+            if (!containsSpace)
+            {
+                return value;
+            }
+
+            if (value.IndexOf(Specification.SingleQuote) != -1)
+            {
+                return '"' + value + '"';
+            }
+
+            return "'" + value + "'";
+        }
+
+        public override string ToString(bool friendlyFormat, int indentation = 0)
+        {
+            return _code;
+        }
+    }
+}

Source/External/ExCSS/Model/Specification.cs

+namespace ExCSS.Model
+{
+    internal static class Specification
+    {
+        internal const char EndOfFile = (char)0x1a;
+        internal const char Tilde = (char)0x7e;
+        internal const char Pipe = (char)0x7c;
+        internal const char Null = (char)0x0;
+        internal const char Ampersand = (char)0x26;
+        internal const char Hash = (char)0x23;
+        internal const char DollarSign = (char)0x24;
+        internal const char Simicolon = (char)0x3b;
+        internal const char Asterisk = (char)0x2a;
+        internal const char EqualSign = (char)0x3d;
+        internal const char PlusSign = (char)0x2b;
+        internal const char Comma = (char)0x2c;
+        internal const char Period = (char)0x2e;
+        internal const char Accent = (char)0x5e;
+        internal const char At = (char)0x40;
+        internal const char LessThan = (char)0x3c;
+        internal const char GreaterThan = (char)0x3e;
+        internal const char SingleQuote = (char)0x27;
+        internal const char DoubleQuote = (char)0x22;
+        internal const char QuestionMark = (char)0x3f;
+        internal const char Tab = (char)0x09;
+        internal const char LineFeed = (char)0x0a;
+        internal const char CarriageReturn = (char)0x0d;
+        internal const char FormFeed = (char)0x0c;
+        internal const char Space = (char)0x20;
+        internal const char Solidus = (char)0x2f;
+        internal const char ReverseSolidus = (char)0x5c;
+        internal const char Colon = (char)0x3a;
+        internal const char Em = (char)0x21;
+        internal const char MinusSign = (char)0x2d;
+        internal const char Replacement = (char)0xfffd;
+        internal const char Underscore = (char)0x5f;
+        internal const char ParenOpen = (char)0x28;
+        internal const char ParenClose = (char)0x29;
+        internal const char Percent = (char)0x25;
+        internal const char SquareBracketOpen =(char)0x5b;
+        internal const char SquareBracketClose = (char)0x5d;
+        internal const char CurlyBraceOpen = (char)0x7b;
+        internal const char CurlyBraceClose = (char)0x7d;
+        internal const int MaxPoint = 0x10FFFF;/// The maximum allowed codepoint (defined in Unicode).
+
+        internal static bool IsNonPrintable(this char c)
+        {
+            return (c >= 0x0 && c <= 0x8) || (c >= 0xe && c <= 0x1f) || (c >= 0x7f && c <= 0x9f);
+        }
+
+        internal static bool IsLetter(this char c)
+        {
+            return IsUppercaseAscii(c) || IsLowercaseAscii(c);
+        }
+
+        internal static bool IsName(this char c)
+        {
+            return c >= 0x80 || c.IsLetter() || c == Underscore || c == MinusSign || IsDigit(c);
+        }
+
+        internal static bool IsNameStart(this char c)
+        {
+            return c >= 0x80 || IsUppercaseAscii(c) || IsLowercaseAscii(c) || c == Underscore;
+        }
+
+        internal static bool IsLineBreak(this char c)
+        {
+            //line feed, carriage return
+            return c == LineFeed || c == CarriageReturn;
+        }
+
+        internal static bool IsSpaceCharacter(this char c)
+        {
+            //white space, tab, line feed, form feed, carriage return
+            return c == Space || c == Tab || c == LineFeed || c == FormFeed || c == CarriageReturn;
+        }
+
+        internal static bool IsDigit(this char c)
+        {
+            return c >= 0x30 && c <= 0x39;
+        }
+
+        internal static bool IsUppercaseAscii(this char c)
+        {
+            return c >= 0x41 && c <= 0x5a;
+        }
+
+        internal static bool IsLowercaseAscii(this char c)
+        {
+            return c >= 0x61 && c <= 0x7a;
+        }
+
+        internal static bool IsHex(this char c)
+        {
+            return IsDigit(c) || (c >= 0x41 && c <= 0x46) || (c >= 0x61 && c <= 0x66);
+        }
+    }
+}
\ No newline at end of file

Source/External/ExCSS/Model/TextBlocks/Block.cs

+
+namespace ExCSS.Model.TextBlocks
+{
+    internal abstract class Block
+    {
+        internal GrammarSegment GrammarSegment { get;set; }
+
+        internal static PipeBlock Column
+        {
+            get { return PipeBlock.Token; }
+        }
+
+        internal static DelimiterBlock Delim(char value)
+        {
+            return new DelimiterBlock(value);
+        }
+
+        internal static NumericBlock Number(string value)
+        {
+            return new NumericBlock(value);
+        }
+
+        internal static RangeBlock Range(string start, string end)
+        {
+            return new RangeBlock().SetRange(start, end);
+        }
+    }
+}

Source/External/ExCSS/Model/TextBlocks/BracketBlock.cs

+
+namespace ExCSS.Model.TextBlocks
+{
+    internal class BracketBlock : Block
+    {
+        private readonly static BracketBlock RoundOpen= new BracketBlock { GrammarSegment = GrammarSegment.ParenOpen, _mirror = GrammarSegment.ParenClose };
+        private readonly static BracketBlock RoundClose = new BracketBlock { GrammarSegment = GrammarSegment.ParenClose, _mirror = GrammarSegment.ParenOpen };
+        private readonly static BracketBlock CurlyOpen = new BracketBlock { GrammarSegment = GrammarSegment.CurlyBraceOpen, _mirror = GrammarSegment.CurlyBracketClose };
+        private readonly static BracketBlock CurlyClose = new BracketBlock { GrammarSegment = GrammarSegment.CurlyBracketClose, _mirror = GrammarSegment.CurlyBraceOpen };
+        private readonly static BracketBlock SquareOpen = new BracketBlock { GrammarSegment = GrammarSegment.SquareBraceOpen, _mirror = GrammarSegment.SquareBracketClose };
+        private readonly static BracketBlock SquareClose = new BracketBlock { GrammarSegment = GrammarSegment.SquareBracketClose, _mirror = GrammarSegment.SquareBraceOpen };
+
+        private GrammarSegment _mirror;
+
+        BracketBlock()
+        {
+        }
+ 
+        internal char Open
+        {
+            get
+            {
+                switch (GrammarSegment)
+                {
+                    case GrammarSegment.ParenOpen:
+                        return '(';
+                       
+                    case GrammarSegment.SquareBraceOpen:
+                        return '[';
+                       
+                    default:
+                        return '{';
+                       
+                }
+            }
+        }
+
+        internal char Close
+        {
+            get
+            {
+                switch (GrammarSegment)
+                {
+                    case GrammarSegment.ParenOpen:
+                        return ')';
+                      
+                    case GrammarSegment.SquareBraceOpen:
+                        return ']';
+                       
+                    default:
+                        return '}';
+                      
+                }
+            }
+        }
+
+        internal GrammarSegment Mirror
+        {
+            get { return _mirror; }
+        }
+
+        internal static BracketBlock OpenRound
+        {
+            get { return RoundOpen; }
+        }
+
+        internal static BracketBlock CloseRound
+        {
+            get { return RoundClose; }
+        }
+
+        internal static BracketBlock OpenCurly
+        {
+            get { return CurlyOpen; }
+        }
+
+        internal static BracketBlock CloseCurly
+        {
+            get { return CurlyClose; }
+        }
+
+        internal static BracketBlock OpenSquare
+        {
+            get { return SquareOpen; }
+        }
+
+        internal static BracketBlock CloseSquare
+        {
+            get { return SquareClose; }
+        }
+
+        public override string ToString()
+        {
+            return ToString(false);
+        }
+
+        public string ToString(bool friendlyFormat, int indentation = 0)
+        {
+            switch (GrammarSegment)
+            {
+                case GrammarSegment.CurlyBraceOpen:
+                    return "{";
+
+                case GrammarSegment.CurlyBracketClose:
+                    return "}";
+
+                case GrammarSegment.ParenClose:
+                    return ")";
+
+                case GrammarSegment.ParenOpen:
+                    return "(";
+
+                case GrammarSegment.SquareBracketClose:
+                    return "]";
+
+                case GrammarSegment.SquareBraceOpen:
+                    return "[";
+            }
+
+            return string.Empty;
+        }
+    }
+}