File: Core\CSharp\System\Windows\Media\Parsers.cs
Project: wpf\src\PresentationCore.csproj (PresentationCore)
//------------------------------------------------------------------------------
//  Microsoft Avalon
//  Copyright (c) Microsoft Corporation, 2001
//
//  File:       Parsers.cs
//  Synopsis: Implements class Parsers for internal use of type converters
//  Created: 06/13/2002
//
//------------------------------------------------------------------------------
 
using System;
using System.Collections;
using System.Collections.Specialized;
using System.Diagnostics;
using MS.Internal;
using System.ComponentModel;
using System.Globalization;
using System.Windows.Media;
using System.Windows.Media.Media3D;
using System.Windows.Media.Animation;
using System.Windows.Media.Imaging;
using System.Windows;
 
using SR=MS.Internal.PresentationCore.SR;
using SRID=MS.Internal.PresentationCore.SRID;
 
namespace MS.Internal
{
    internal static partial class Parsers
    {
        private const int s_zeroChar = (int) '0';
        private const int s_aLower   = (int) 'a';
        private const int s_aUpper   = (int) 'A';
 
        static private int ParseHexChar(char c )
        {
            int intChar = (int) c;
 
            if ((intChar >= s_zeroChar) && (intChar <= (s_zeroChar+9)))
            {
                return (intChar-s_zeroChar);
            }
 
            if ((intChar >= s_aLower) && (intChar <= (s_aLower+5)))
            {
                return (intChar-s_aLower + 10);
            }
 
            if ((intChar >= s_aUpper) && (intChar <= (s_aUpper+5)))
            {
                return (intChar-s_aUpper + 10);
            }
            throw new FormatException(SR.Get(SRID.Parsers_IllegalToken));
        }
 
        static private Color ParseHexColor(string trimmedColor)
        {
            int a,r,g,b;
            a = 255;
 
            if ( trimmedColor.Length > 7 )
            {
                a = ParseHexChar(trimmedColor[1]) * 16 + ParseHexChar(trimmedColor[2]);
                r = ParseHexChar(trimmedColor[3]) * 16 + ParseHexChar(trimmedColor[4]);
                g = ParseHexChar(trimmedColor[5]) * 16 + ParseHexChar(trimmedColor[6]);
                b = ParseHexChar(trimmedColor[7]) * 16 + ParseHexChar(trimmedColor[8]);
            }
            else if ( trimmedColor.Length > 5)
            {
                r = ParseHexChar(trimmedColor[1]) * 16 + ParseHexChar(trimmedColor[2]);
                g = ParseHexChar(trimmedColor[3]) * 16 + ParseHexChar(trimmedColor[4]);
                b = ParseHexChar(trimmedColor[5]) * 16 + ParseHexChar(trimmedColor[6]);
            }
            else if (trimmedColor.Length > 4)
            {
                a = ParseHexChar(trimmedColor[1]);
                a = a + a*16;
                r = ParseHexChar(trimmedColor[2]);
                r = r + r*16;
                g = ParseHexChar(trimmedColor[3]);
                g = g + g*16;
                b = ParseHexChar(trimmedColor[4]);
                b = b + b*16;
            }
            else
            {
                r = ParseHexChar(trimmedColor[1]);
                r = r + r*16;
                g = ParseHexChar(trimmedColor[2]);
                g = g + g*16;
                b = ParseHexChar(trimmedColor[3]);
                b = b + b*16;
            }
 
            return ( Color.FromArgb ((byte)a, (byte)r, (byte)g, (byte)b) );
        }
 
    internal const string s_ContextColor = "ContextColor ";
    internal const string s_ContextColorNoSpace = "ContextColor";
 
    static private Color ParseContextColor(string trimmedColor, IFormatProvider formatProvider, ITypeDescriptorContext context)
        {
            if (!trimmedColor.StartsWith(s_ContextColor, StringComparison.OrdinalIgnoreCase))
            {
                throw new FormatException(SR.Get(SRID.Parsers_IllegalToken));
            }
 
            string tokens = trimmedColor.Substring(s_ContextColor.Length);
            tokens = tokens.Trim();
            string[] preSplit = tokens.Split(new Char[] { ' ' });
            if (preSplit.GetLength(0)< 2)
            {
                throw new FormatException(SR.Get(SRID.Parsers_IllegalToken));
            }
 
            tokens = tokens.Substring(preSplit[0].Length);
 
            TokenizerHelper th = new TokenizerHelper(tokens, formatProvider);
            string[] split = tokens.Split(new Char[] { ',', ' ' }, StringSplitOptions.RemoveEmptyEntries);
            int numTokens = split.GetLength(0);
 
            float alpha = Convert.ToSingle(th.NextTokenRequired(), formatProvider);
 
            float[] values = new float[numTokens - 1];
 
            for (int i = 0; i < numTokens - 1; i++)
            {
                values[i] = Convert.ToSingle(th.NextTokenRequired(), formatProvider);
            }
 
            string profileString = preSplit[0];
 
            UriHolder uriHolder = TypeConverterHelper.GetUriFromUriContext(context,profileString);
 
            Uri profileUri;
 
            if (uriHolder.BaseUri != null)
            {
                profileUri = new Uri(uriHolder.BaseUri, uriHolder.OriginalUri);
            }
            else
            {
                profileUri = uriHolder.OriginalUri;
            }
 
            Color result = Color.FromAValues(alpha, values, profileUri);
 
            // If the number of color values found does not match the number of channels in the profile, we must throw
            if (result.ColorContext.NumChannels != values.Length)
            {
                throw new FormatException(SR.Get(SRID.Parsers_IllegalToken));
            }
 
            return result;
        }
 
        static private Color ParseScRgbColor(string trimmedColor, IFormatProvider formatProvider)
        {
            if (!trimmedColor.StartsWith("sc#", StringComparison.Ordinal))
            {
                throw new FormatException(SR.Get(SRID.Parsers_IllegalToken));
            }
 
            string tokens = trimmedColor.Substring(3, trimmedColor.Length - 3);
 
            // The tokenizer helper will tokenize a list based on the IFormatProvider.
            TokenizerHelper th = new TokenizerHelper(tokens, formatProvider);
            float[] values = new float[4];
 
            for (int i = 0; i < 3; i++)
            {
                values[i] = Convert.ToSingle(th.NextTokenRequired(), formatProvider);
            }
 
            if (th.NextToken())
            {
                values[3] = Convert.ToSingle(th.GetCurrentToken(), formatProvider);
 
                // We should be out of tokens at this point
                if (th.NextToken())
                {
                    throw new FormatException(SR.Get(SRID.Parsers_IllegalToken));
                }
 
                return Color.FromScRgb(values[0], values[1], values[2], values[3]);
            }
            else
            {
                return Color.FromScRgb(1.0f, values[0], values[1], values[2]);
            }
        }
 
        /// <summary>
        /// ParseColor
        /// <param name="color"> string with color description </param>
        /// <param name="formatProvider">IFormatProvider for processing string</param>
        /// </summary>
        internal static Color ParseColor(string color, IFormatProvider formatProvider)
        {
            return ParseColor(color, formatProvider, null);
        }
 
        /// <summary>
        /// ParseColor
        /// <param name="color"> string with color description </param>
        /// <param name="formatProvider">IFormatProvider for processing string</param>
        /// <param name="context">ITypeDescriptorContext</param>
        /// </summary>
        internal static Color ParseColor(string color, IFormatProvider formatProvider, ITypeDescriptorContext context)
        {
            bool isPossibleKnowColor;
            bool isNumericColor;
            bool isScRgbColor;
            bool isContextColor;
            string trimmedColor = KnownColors.MatchColor(color, out isPossibleKnowColor, out isNumericColor, out isContextColor, out isScRgbColor);
 
            if ((isPossibleKnowColor == false) &&
                (isNumericColor == false) &&
                (isScRgbColor == false) &&
                (isContextColor== false))
            {
                throw new FormatException(SR.Get(SRID.Parsers_IllegalToken));
            }
 
            //Is it a number?
            if (isNumericColor)
            {
                return ParseHexColor(trimmedColor);
            }
            else if (isContextColor)
            {
                return ParseContextColor(trimmedColor, formatProvider, context);
            }
            else if (isScRgbColor)
            {
                return ParseScRgbColor(trimmedColor, formatProvider);
            }
            else
            {
                KnownColor kc = KnownColors.ColorStringToKnownColor(trimmedColor);
 
                if (kc == KnownColor.UnknownColor)
                {
                    throw new FormatException(SR.Get(SRID.Parsers_IllegalToken));
                }
 
                return Color.FromUInt32((uint)kc);
            }
        }
 
        /// <summary>
        /// ParseBrush
        /// <param name="brush"> string with brush description </param>
        /// <param name="formatProvider">IFormatProvider for processing string</param>
        /// <param name="context">ITypeDescriptorContext</param>
        /// </summary>
        internal static Brush ParseBrush(string brush, IFormatProvider formatProvider, ITypeDescriptorContext context)
        {
            bool isPossibleKnownColor;
            bool isNumericColor;
            bool isScRgbColor;
            bool isContextColor;
            string trimmedColor = KnownColors.MatchColor(brush, out isPossibleKnownColor, out isNumericColor, out isContextColor, out isScRgbColor);
 
            if (trimmedColor.Length == 0)
            {
                throw new FormatException(SR.Get(SRID.Parser_Empty));
            }
 
            // Note that because trimmedColor is exactly brush.Trim() we don't have to worry about
            // extra tokens as we do with TokenizerHelper.  If we return one of the solid color
            // brushes then the ParseColor routine (or ColorStringToKnownColor) matched the entire
            // input.
            if (isNumericColor)
            {
                return (new SolidColorBrush(ParseHexColor(trimmedColor)));
            }
 
            if (isContextColor)
            {
                return (new SolidColorBrush(ParseContextColor(trimmedColor, formatProvider, context)));
            }
 
            if (isScRgbColor)
            {
                return (new SolidColorBrush(ParseScRgbColor(trimmedColor, formatProvider)));
            }
 
            if (isPossibleKnownColor)
            {
                SolidColorBrush scp = KnownColors.ColorStringToKnownBrush(trimmedColor);
 
                if (scp != null)
                {
                    return scp;
                }
            }
 
            // If it's not a color, so the content is illegal.
            throw new FormatException(SR.Get(SRID.Parsers_IllegalToken));
        }
 
 
        /// <summary>
        /// ParseTransform - parse a Transform from a string
        /// </summary>
        internal static Transform ParseTransform(
            string transformString,
            IFormatProvider formatProvider)
        {
            Matrix matrix = Matrix.Parse(transformString);
 
            return new MatrixTransform(matrix);
        }
 
        /// <summary>
        /// Parse a PathFigureCollection string.
        /// </summary>
        internal static PathFigureCollection ParsePathFigureCollection(
            string pathString,
            IFormatProvider formatProvider)
        {
            PathStreamGeometryContext context = new PathStreamGeometryContext();
 
            AbbreviatedGeometryParser parser = new AbbreviatedGeometryParser();
 
            parser.ParseToGeometryContext(context, pathString, 0 /* curIndex */);
            
            PathGeometry pathGeometry = context.GetPathGeometry();
 
            return pathGeometry.Figures;
        }
 
 
    }
}