Color support

src/WpfMath/TexFormulaParser.cs

@@ -14,7 +14,7 @@ namespace WpfMath
     // TODO: Use TextReader for lexing.
     public class TexFormulaParser
     {
-        // Special characters for parsing
+        #region Special characters for parsing
         private const char escapeChar = '\\';
 
         private const char leftGroupChar = '{';
@@ -25,8 +25,8 @@ public class TexFormulaParser
         private const char subScriptChar = '_';
         private const char superScriptChar = '^';
         private const char primeChar = '\'';
-
-        // Information used for parsing
+        #endregion
+        #region Information used for parsing
         private static HashSet<string> commands;
         private static IList<string> symbols;
         private static IList<string> delimeters;
@@ -49,7 +49,7 @@ public class TexFormulaParser
             new[] { "vert", "vert" },
             new[] { "Vert", "Vert" }
         };
-
+        #endregion
         static TexFormulaParser()
         {
             predefinedColors = new Dictionary<string, Color>();
@@ -80,7 +80,8 @@ private static void Initialize()
                 "left",
                 "right",
                 "sqrt",
-                "color",
+                "fgcolor",
+                "bgcolor",
                 "colorbox"
             };
 
@@ -365,6 +366,7 @@ private Atom ProcessCommand(
                     }
 
                 case "sqrt":
+                    {
                     // Command is radical.
 
                     SkipWhiteSpace(value, ref position);
@@ -393,20 +395,58 @@ private Atom ProcessCommand(
 
                     source = value.Segment(start, sqrtEnd - start);
                     return new Radical(source, sqrtFormula.RootAtom, degreeFormula?.RootAtom);
-
-                case "color":
+                    }
+                case "fgcolor":
                     {
+                        //Command to change the foreground color 
                         var colorName = ReadGroup(formula, value, ref position, leftGroupChar, rightGroupChar);
-                        var remainingString = value.Segment(position);
+
+                        string remainingString = value.Substring(position);
                         var remaining = Parse(remainingString, formula.TextStyle);
                         position = value.Length;
-                        if (predefinedColors.TryGetValue(colorName.ToString(), out var color))
+
+                        if (predefinedColors.TryGetValue(colorName, out Color color))
                         {
-                            source = value.Segment(start, position - start);
-                            return new StyledAtom(source, remaining.RootAtom, null, new SolidColorBrush(color));
+                            return new StyledAtom(remaining.RootAtom, null, new SolidColorBrush(color));
+                        }
+                        else
+                        {
+                            try
+                            {
+                                Color color1 = UserDefinedColorParser.ParseUserColor(colorName);
+                                return new StyledAtom(remaining.RootAtom, null, new SolidColorBrush(color1));
+                            }
+                            catch
+                            {
+                                throw new TexParseException(String.Format("Color {0} could either not be found or converted.", colorName));
+                            }
+
                         }
+                    }
+                case "bgcolor":
+                    {
+                        //Command to change the background color
+                        var colorName = ReadGroup(formula, value, ref position, leftGroupChar, rightGroupChar);
+                        string remainingString = value.Substring(position);
+                        var remaining = Parse(remainingString, formula.TextStyle);
+                        position = value.Length;
 
-                        throw new TexParseException($"Color {colorName} not found");
+                        if (predefinedColors.TryGetValue(colorName, out Color color))
+                        {
+                            return new StyledAtom(remaining.RootAtom, new SolidColorBrush(color), null);
+                        }
+                        else
+                        {
+                            try
+                            {
+                                Color color1 = UserDefinedColorParser.ParseUserColor(colorName);
+                                return new StyledAtom(remaining.RootAtom, new SolidColorBrush(color1), null);
+                            }
+                            catch (Exception ex)
+                            {
+                                throw new TexParseException(String.Format("Color {0} could either not be found or converted.", colorName));
+                            }
+                        }
                     }
                 case "colorbox":
                     {
@@ -418,8 +458,19 @@ private Atom ProcessCommand(
                             source = value.Segment(start, position - start);
                             return new StyledAtom(source, remaining.RootAtom, new SolidColorBrush(color), null);
                         }
+                        else
+                        {
+                            try
+                            {
+                                Color color1 = UserDefinedColorParser.ParseUserColor(colorName);
+                                return new StyledAtom(remaining.RootAtom, new SolidColorBrush(color1), null);
+                            }
+                            catch (Exception ex)
+                            {
+                                throw new TexParseException(String.Format("Color {0} could either not be found or converted.", colorName));
+                            }
+                        }
 
-                        throw new TexParseException($"Color {colorName} not found");
                     }
             }
 

src/WpfMath/UserDefinedColorParser.cs

@@ -0,0 +1,264 @@
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+using System.Text;
+using System.Text.RegularExpressions;
+using System.Windows;
+using System.Windows.Media;
+using WpfMath.Exceptions;
+
+namespace WpfMath
+{
+    /// <summary>
+    /// Parses definitions of colors from a <see cref="string"/>.
+    /// </summary>
+    public class UserDefinedColorParser
+    {
+        /// <summary>
+        /// Parses the <paramref name="input"/> to its <see cref="Color"/> equivalent.
+        /// </summary>
+        /// <param name="input"></param>
+        /// <returns></returns>
+        public static Color ParseUserColor(string input)
+        {
+            Color resultColor = new Color();
+            ColorStringTypes CST = GetColorString(input.Trim());
+            switch (CST)
+            {
+                case ColorStringTypes.Byte_longString:
+                    {
+                        byte[] channelbytes = ByteStringValues(input.Trim(), 4);
+                        resultColor.A = channelbytes[0];
+                        resultColor.R = channelbytes[1];
+                        resultColor.G = channelbytes[2];
+                        resultColor.B = channelbytes[3];
+                        break;
+                    }
+
+                case ColorStringTypes.Byte_shortString:
+                    {
+                        byte[] channelbytes = ByteStringValues(input.Trim(), 3);
+                        resultColor.A = 255;
+                        resultColor.R = channelbytes[0];
+                        resultColor.G = channelbytes[1];
+                        resultColor.B = channelbytes[2];
+                        break;
+                    }
+                case ColorStringTypes.Hex_longString:
+                    {
+                        byte[] channelbytes = ByteHexStringValues(input.Trim(), 8);
+                        resultColor.A = channelbytes[0];
+                        resultColor.R = channelbytes[1];
+                        resultColor.G = channelbytes[2];
+                        resultColor.B = channelbytes[3];
+                        break;
+                    }
+                case ColorStringTypes.Hex_shortString:
+                    {
+                        byte[] channelbytes = ByteHexStringValues(input.Trim(), 6);
+                        resultColor.A = 255;
+                        resultColor.R = channelbytes[0];
+                        resultColor.G = channelbytes[1];
+                        resultColor.B = channelbytes[2];
+                        break;
+                    }
+                case ColorStringTypes.None:
+                    throw new TexParseException($"The text: {input} could not be parsed.");
+                default:
+                    break;
+            }
+            return resultColor;
+        }
+
+        #region Color Parsing Helpers
+        /// <summary>
+        /// Specifies the type of <see cref="Color"/> the string might represent.
+        /// </summary>
+        private enum ColorStringTypes
+        {
+            /// <summary>
+            /// Type is a <see cref="string"/> consisting of byte values of the color.
+            /// </summary>
+            Byte_longString,
+            /// <summary>
+            /// Type is a <see cref="string"/> consisting of byte values of the color.<para/>
+            /// Alpha channel is strictly = 255.
+            /// </summary>
+            Byte_shortString,
+            //FloatString,----->Will include this later.
+            /// <summary>
+            /// Type is a Hexadecimal <see cref="string"/> consisting of Hexadecimal values of the color.
+            /// </summary>
+            Hex_longString,
+            /// <summary>
+            /// Type is a Hexadecimal <see cref="string"/> consisting of Hexadecimal values of the color.<para/>
+            /// Alpha channel is strictly = FF.
+            /// </summary>
+            Hex_shortString,
+
+
+            /// <summary>
+            /// An unrecognized ColorStringType.
+            /// </summary>
+            None
+        }
+
+        /// <summary>
+        /// Gets the type of <see cref="ColorStringTypes"/> from the <paramref name="input"/>.
+        /// </summary>
+        /// <param name="input"></param>
+        /// <returns></returns>
+        private static ColorStringTypes GetColorString(string input)
+        {
+            if (IsByteHexTrain(input,6)==true)
+            {
+                return ColorStringTypes.Hex_shortString;
+            }
+            else if (IsByteHexTrain(input,8))
+            {
+                return ColorStringTypes.Hex_longString;
+            }
+            else if (IsByteTrain(input, 3) == true)
+            {
+                return ColorStringTypes.Byte_shortString;
+            }
+            else if (IsByteTrain(input, 4) == true)
+            {
+                return ColorStringTypes.Byte_longString;
+            }
+            else
+            {
+                return ColorStringTypes.None;
+            }
+        }
+
+        /// <summary>
+        /// Returns a value that tells if the <paramref name="input"/> contains byte values, separated by a ",".
+        /// </summary>
+        /// <example>
+        /// 23,78,56=>true
+        /// 789,fp=>false
+        /// </example>
+        /// <param name="input"></param>
+        /// <param name="num"></param>
+        /// <returns></returns>
+        private static bool IsByteTrain(string input, int num)
+        {
+            bool StrCheck = false;
+            string[] arrStr = input.Trim().Split(',');
+            if (num == arrStr.Length)
+            {
+                int i = 0;
+                foreach (var item in arrStr)
+                {
+                    if (Byte.TryParse(item, out byte result) == true)
+                    {
+                        i += 1;
+                    }
+                    else { continue; }
+                }
+                StrCheck = i == num ? true : false;
+            }
+            else
+            {
+                StrCheck = false;
+            }
+            return StrCheck;
+        }
+
+        /// <summary>
+        /// Returns a value that tells if the <paramref name="input"/> contains byte hex values,
+        /// </summary>
+        /// <param name="input"></param>
+        /// <param name="num"></param>
+        /// <returns></returns>
+        /// <remarks><paramref name="input"/> should be left in the raw state(e.g.;#56e245, not 56e245).</remarks>
+        private static bool IsByteHexTrain(string input, int num)
+        {
+            bool StrCheck = false;
+            string subStr = input.Substring(1);
+            if (num == subStr.Length)
+            {
+                int c = 0;
+                for (int i = 1; i < num; i+=2)
+                {
+                    string item = subStr[i - 1].ToString() + subStr[1].ToString();
+                    if (Byte.TryParse(item, System.Globalization.NumberStyles.AllowHexSpecifier, CultureInfo.InvariantCulture, out byte result) == true)
+                    {
+                        c+=2;
+                    }
+                    else { continue; }
+                }
+
+                StrCheck = (c == num )? true : false;
+            }
+            else
+            {
+                StrCheck = false;
+            }
+            return StrCheck;
+        }
+
+        /// <summary>
+        /// Gets the <see cref="byte"/> values from the <paramref name="input"/> if the number of items are ==<paramref name="num"/>.
+        /// </summary>
+        /// <param name="input"></param>
+        /// <param name="num"></param>
+        /// <returns></returns>
+        private static byte[] ByteStringValues(string input,int num)
+        {
+            List<byte> resultByteArr = new List<byte>();
+            string[] arrStr = input.Split(',');
+            if (num == arrStr.Length)
+            {
+                foreach (var item in arrStr)
+                {
+                    if (Byte.TryParse(item, out byte result) == true)
+                    {
+                        resultByteArr.Add(result);
+                    }
+                    else { continue; }
+                }
+
+            }
+            return resultByteArr.ToArray();
+        }
+
+        /// <summary>
+        /// Gets the <see cref="byte"/> values from the Hex <paramref name="input"/> if the number of items are ==<paramref name="num"/>.
+        /// </summary>
+        /// <param name="input"></param>
+        /// <param name="num"></param>
+        /// <returns></returns>
+        private static byte[] ByteHexStringValues(string input, int num)
+        {
+            List<string> hexTwos = new List<string>();
+            List<byte> resultByteLst = new List<byte>();
+            for (int i = 0; i <input.Length; i++)
+            {
+                if (i%2==0&&i>0)
+                {
+                    //add the current and previous strings as one to the "hexTwos" list
+                    string str = input[i].ToString() + input[i - 1].ToString();
+                    hexTwos.Add(str);
+                }
+            }
+
+            if ((num/2)==hexTwos.Count)
+            {
+                foreach (string item in hexTwos)
+                {
+                    if (Byte.TryParse(item, NumberStyles.AllowHexSpecifier,CultureInfo.InvariantCulture, out byte hexbyteres) )
+                    {
+                        resultByteLst.Add(hexbyteres);
+                    }
+                }
+            }
+            return resultByteLst.ToArray();
+        }
+
+        #endregion
+
+    }
+}