Silverlight日记：字符串装换成Path对象

一，需要动态绑定Path

 <UserControl x:Class="Secom.Emx2.SL.Common.Controls.EleSafe.Ele.Line"
     xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
     xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
     xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
     xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
     mc:Ignorable="d"
     d:DesignHeight="300" d:DesignWidth="400">

     <Path x:Name="myline" Stretch="Fill" Width="{Binding Width, ElementName=path, Mode=TwoWay}" Height="{Binding Height, ElementName=path, Mode=TwoWay}"/>
 </UserControl>

二，生成Path

  private LineType _lineType = LineType.VLine;
         public LineType LineType
         {
             get
             {
                 return _lineType;
             }
             set
             {
                 _lineType = value;
                 var pathString = string.Empty;
                 var eff = new DropShadowEffect();
                 eff.BlurRadius = ;
                 eff.Color = Colors.DarkGray;
                 eff.ShadowDepth = ;
                 var conv = new StringToPathGeometryConverter();
                 switch (_lineType)
                 {
                     case LineType.HLine:
                         eff.Direction = ;
                         pathString = "M0,0 L131.137,0";
                         break;
                     case LineType.VLine:
                     default:
                         eff.Direction = ;
                         pathString = "M87,60 L87,240.178";
                         break;
                 }

                 var pathData = conv.Convert(pathString);
                 myline.SetValue(Path.DataProperty, pathData);
                 //myline.SetValue(Path.EffectProperty, eff);
             }
         }

三，字符串转换成Path对象类

     /* ==============================
      * Desc：StringToPathGeometry
      * Author：hezp
      * Date：2014/8/9 17:39:40
      * ==============================*/
     public class StringToPathGeometryConverter : IValueConverter
     {
         #region Const & Private Variables
         const bool AllowSign = true;
         const bool AllowComma = true;
         const bool IsFilled = true;
         const bool IsClosed = true;

         IFormatProvider _formatProvider;

         PathFigure _figure = null;     // Figure object, which will accept parsed segments
         string _pathString;        // Input string to be parsed
         int _pathLength;
         int _curIndex;          // Location to read next character from
         bool _figureStarted;     // StartFigure is effective 

         Point _lastStart;         // Last figure starting point
         Point _lastPoint;         // Last point
         Point _secondLastPoint;   // The point before last point

         char _token;             // Non whitespace character returned by ReadToken
         #endregion

         #region Public Functionality
         /// <summary>
         /// Main conversion routine - converts string path data definition to PathGeometry object
         /// </summary>
         /// <param name="path">String with path data definition</param>
         /// <returns>PathGeometry object created from string definition</returns>
         public PathGeometry Convert(string path)
         {
             if (null == path)
                 throw new ArgumentException("Path string cannot be null!");

             if (path.Length == )
                 throw new ArgumentException("Path string cannot be empty!");

             return parse(path);
         }

         /// <summary>
         /// Main back conversion routine - converts PathGeometry object to its string equivalent
         /// </summary>
         /// <param name="geometry">Path Geometry object</param>
         /// <returns>String equivalent to PathGeometry contents</returns>
         public string ConvertBack(PathGeometry geometry)
         {
             if (null == geometry)
                 throw new ArgumentException("Path Geometry cannot be null!");

             return parseBack(geometry);
         }
         #endregion

         #region Private Functionality
         /// <summary>
         /// Main parser routine, which loops over each char in received string, and performs actions according to command/parameter being passed
         /// </summary>
         /// <param name="path">String with path data definition</param>
         /// <returns>PathGeometry object created from string definition</returns>
         private PathGeometry parse(string path)
         {
             PathGeometry _pathGeometry = null;

             _formatProvider = CultureInfo.InvariantCulture;
             _pathString = path;
             _pathLength = path.Length;
             _curIndex = ;

             _secondLastPoint = new Point(, );
             _lastPoint = new Point(, );
             _lastStart = new Point(, );

             _figureStarted = false;

             bool first = true;

             char last_cmd = ' ';

             while (ReadToken()) // Empty path is allowed in XAML
             {
                 char cmd = _token;

                 if (first)
                 {
                     if ((cmd != 'M') && (cmd != 'm') && (cmd != 'f') && (cmd != 'F'))  // Path starts with M|m
                     {
                         ThrowBadToken();
                     }

                     first = false;
                 }

                 switch (cmd)
                 {
                     case 'f':
                     case 'F':
                         _pathGeometry = new PathGeometry();
                         double _num = ReadNumber(!AllowComma);
                         _pathGeometry.FillRule = _num ==  ? FillRule.EvenOdd : FillRule.Nonzero;
                         break;

                     case 'm':
                     case 'M':
                         // XAML allows multiple points after M/m
                         _lastPoint = ReadPoint(cmd, !AllowComma);

                         _figure = new PathFigure();
                         _figure.StartPoint = _lastPoint;
                         _figure.IsFilled = IsFilled;
                         _figure.IsClosed = !IsClosed;
                         //context.BeginFigure(_lastPoint, IsFilled, !IsClosed);
                         _figureStarted = true;
                         _lastStart = _lastPoint;
                         last_cmd = 'M';

                         while (IsNumber(AllowComma))
                         {
                             _lastPoint = ReadPoint(cmd, !AllowComma);

                             LineSegment _lineSegment = new LineSegment();
                             _lineSegment.Point = _lastPoint;
                             _figure.Segments.Add(_lineSegment);
                             //context.LineTo(_lastPoint, IsStroked, !IsSmoothJoin);
                             last_cmd = 'L';
                         }
                         break;

                     case 'l':
                     case 'L':
                     case 'h':
                     case 'H':
                     case 'v':
                     case 'V':
                         EnsureFigure();

                         do
                         {
                             switch (cmd)
                             {
                                 case 'l': _lastPoint = ReadPoint(cmd, !AllowComma); break;
                                 case 'L': _lastPoint = ReadPoint(cmd, !AllowComma); break;
                                 case 'h': _lastPoint.X += ReadNumber(!AllowComma); break;
                                 case 'H': _lastPoint.X = ReadNumber(!AllowComma); break;
                                 case 'v': _lastPoint.Y += ReadNumber(!AllowComma); break;
                                 case 'V': _lastPoint.Y = ReadNumber(!AllowComma); break;
                             }

                             LineSegment _lineSegment = new LineSegment();
                             _lineSegment.Point = _lastPoint;
                             _figure.Segments.Add(_lineSegment);
                             //context.LineTo(_lastPoint, IsStroked, !IsSmoothJoin);
                         }
                         while (IsNumber(AllowComma));

                         last_cmd = 'L';
                         break;

                     case 'c':
                     case 'C': // cubic Bezier
                     case 's':
                     case 'S': // smooth cublic Bezier
                         EnsureFigure();

                         do
                         {
                             Point p;

                             if ((cmd == 's') || (cmd == 'S'))
                             {
                                 if (last_cmd == 'C')
                                 {
                                     p = Reflect();
                                 }
                                 else
                                 {
                                     p = _lastPoint;
                                 }

                                 _secondLastPoint = ReadPoint(cmd, !AllowComma);
                             }
                             else
                             {
                                 p = ReadPoint(cmd, !AllowComma);

                                 _secondLastPoint = ReadPoint(cmd, AllowComma);
                             }

                             _lastPoint = ReadPoint(cmd, AllowComma);

                             BezierSegment _bizierSegment = new BezierSegment();
                             _bizierSegment.Point1 = p;
                             _bizierSegment.Point2 = _secondLastPoint;
                             _bizierSegment.Point3 = _lastPoint;
                             _figure.Segments.Add(_bizierSegment);
                             //context.BezierTo(p, _secondLastPoint, _lastPoint, IsStroked, !IsSmoothJoin);

                             last_cmd = 'C';
                         }
                         while (IsNumber(AllowComma));

                         break;

                     case 'q':
                     case 'Q': // quadratic Bezier
                     case 't':
                     case 'T': // smooth quadratic Bezier
                         EnsureFigure();

                         do
                         {
                             if ((cmd == 't') || (cmd == 'T'))
                             {
                                 if (last_cmd == 'Q')
                                 {
                                     _secondLastPoint = Reflect();
                                 }
                                 else
                                 {
                                     _secondLastPoint = _lastPoint;
                                 }

                                 _lastPoint = ReadPoint(cmd, !AllowComma);
                             }
                             else
                             {
                                 _secondLastPoint = ReadPoint(cmd, !AllowComma);
                                 _lastPoint = ReadPoint(cmd, AllowComma);
                             }

                             QuadraticBezierSegment _quadraticBezierSegment = new QuadraticBezierSegment();
                             _quadraticBezierSegment.Point1 = _secondLastPoint;
                             _quadraticBezierSegment.Point2 = _lastPoint;
                             _figure.Segments.Add(_quadraticBezierSegment);
                             //context.QuadraticBezierTo(_secondLastPoint, _lastPoint, IsStroked, !IsSmoothJoin);

                             last_cmd = 'Q';
                         }
                         while (IsNumber(AllowComma));

                         break;

                     case 'a':
                     case 'A':
                         EnsureFigure();

                         do
                         {
                             // A 3,4 5, 0, 0, 6,7
                             double w = ReadNumber(!AllowComma);
                             double h = ReadNumber(AllowComma);
                             double rotation = ReadNumber(AllowComma);
                             bool large = ReadBool();
                             bool sweep = ReadBool();

                             _lastPoint = ReadPoint(cmd, AllowComma);

                             ArcSegment _arcSegment = new ArcSegment();
                             _arcSegment.Point = _lastPoint;
                             _arcSegment.Size = new Size(w, h);
                             _arcSegment.RotationAngle = rotation;
                             _arcSegment.IsLargeArc = large;
                             _arcSegment.SweepDirection = sweep ? SweepDirection.Clockwise : SweepDirection.Counterclockwise;
                             _figure.Segments.Add(_arcSegment);
                             //context.ArcTo(
                             //    _lastPoint,
                             //    new Size(w, h),
                             //    rotation,
                             //    large,
                             //    sweep ? SweepDirection.Clockwise : SweepDirection.Counterclockwise,
                             //    IsStroked,
                             //    !IsSmoothJoin
                             //    );
                         }
                         while (IsNumber(AllowComma));

                         last_cmd = 'A';
                         break;

                     case 'z':
                     case 'Z':
                         EnsureFigure();
                         _figure.IsClosed = IsClosed;
                         //context.SetClosedState(IsClosed);

                         _figureStarted = false;
                         last_cmd = 'Z';

                         _lastPoint = _lastStart; // Set reference point to be first point of current figure
                         break;

                     default:
                         ThrowBadToken();
                         break;
                 }

                 if (null != _figure)
                 {
                     if (_figure.IsClosed)
                     {
                         if (null == _pathGeometry)
                             _pathGeometry = new PathGeometry();

                         _pathGeometry.Figures.Add(_figure);

                         _figure = null;
                         first = true;
                     }
                 }

             }

             if (null != _figure)
             {
                 if (null == _pathGeometry)
                     _pathGeometry = new PathGeometry();

                 if (!_pathGeometry.Figures.Contains(_figure))
                     _pathGeometry.Figures.Add(_figure);

             }
             return _pathGeometry;
         }

         void SkipDigits(bool signAllowed)
         {
             // Allow for a sign
             if (signAllowed && More() && ((_pathString[_curIndex] == '-') || _pathString[_curIndex] == '+'))
             {
                 _curIndex++;
             }

             while (More() && (_pathString[_curIndex] >= '') && (_pathString[_curIndex] <= ''))
             {
                 _curIndex++;
             }
         }

         bool ReadBool()
         {
             SkipWhiteSpace(AllowComma);

             if (More())
             {
                 _token = _pathString[_curIndex++];

                 if (_token == '')
                 {
                     return false;
                 }
                 else if (_token == '')
                 {
                     return true;
                 }
             }

             ThrowBadToken();

             return false;
         }

         private Point Reflect()
         {
             return new Point( * _lastPoint.X - _secondLastPoint.X,
                               * _lastPoint.Y - _secondLastPoint.Y);
         }

         private void EnsureFigure()
         {
             if (!_figureStarted)
             {
                 _figure = new PathFigure();
                 _figure.StartPoint = _lastStart;

                 //_context.BeginFigure(_lastStart, IsFilled, !IsClosed);
                 _figureStarted = true;
             }
         }

         double ReadNumber(bool allowComma)
         {
             if (!IsNumber(allowComma))
             {
                 ThrowBadToken();
             }

             bool simple = true;
             int start = _curIndex;

             //
             // Allow for a sign
             //
             // There are numbers that cannot be preceded with a sign, for instance, -NaN, but it's
             // fine to ignore that at this point, since the CLR parser will catch this later.
             //
             if (More() && ((_pathString[_curIndex] == '-') || _pathString[_curIndex] == '+'))
             {
                 _curIndex++;
             }

             // Check for Infinity (or -Infinity).
             if (More() && (_pathString[_curIndex] == 'I'))
             {
                 //
                 // Don't bother reading the characters, as the CLR parser will
                 // do this for us later.
                 //
                 _curIndex = Math.Min(_curIndex + , _pathLength); // "Infinity" has 8 characters
                 simple = false;
             }
             // Check for NaN
             else if (More() && (_pathString[_curIndex] == 'N'))
             {
                 //
                 // Don't bother reading the characters, as the CLR parser will
                 // do this for us later.
                 //
                 _curIndex = Math.Min(_curIndex + , _pathLength); // "NaN" has 3 characters
                 simple = false;
             }
             else
             {
                 SkipDigits(!AllowSign);

                 // Optional period, followed by more digits
                 if (More() && (_pathString[_curIndex] == '.'))
                 {
                     simple = false;
                     _curIndex++;
                     SkipDigits(!AllowSign);
                 }

                 // Exponent
                 if (More() && ((_pathString[_curIndex] == 'E') || (_pathString[_curIndex] == 'e')))
                 {
                     simple = false;
                     _curIndex++;
                     SkipDigits(AllowSign);
                 }
             }

             if (simple && (_curIndex <= (start + ))) // 32-bit integer
             {
                 int sign = ;

                 if (_pathString[start] == '+')
                 {
                     start++;
                 }
                 else if (_pathString[start] == '-')
                 {
                     start++;
                     sign = -;
                 }

                 int value = ;

                 while (start < _curIndex)
                 {
                     value = value *  + (_pathString[start] - '');
                     start++;
                 }

                 return value * sign;
             }
             else
             {
                 string subString = _pathString.Substring(start, _curIndex - start);

                 try
                 {
                     return System.Convert.ToDouble(subString, _formatProvider);
                 }
                 catch (FormatException except)
                 {
                     throw new FormatException(string.Format("Unexpected character in path '{0}' at position {1}", _pathString, _curIndex - ), except);
                 }
             }
         }

         private bool IsNumber(bool allowComma)
         {
             bool commaMet = SkipWhiteSpace(allowComma);

             if (More())
             {
                 _token = _pathString[_curIndex];

                 // Valid start of a number
                 if ((_token == '.') || (_token == '-') || (_token == '+') || ((_token >= '') && (_token <= ''))
                     || (_token == 'I')  // Infinity
                     || (_token == 'N')) // NaN
                 {
                     return true;
                 }
             }

             if (commaMet) // Only allowed between numbers
             {
                 ThrowBadToken();
             }

             return false;
         }

         private Point ReadPoint(char cmd, bool allowcomma)
         {
             double x = ReadNumber(allowcomma);
             double y = ReadNumber(AllowComma);

             if (cmd >= 'a') // 'A' < 'a'. lower case for relative
             {
                 x += _lastPoint.X;
                 y += _lastPoint.Y;
             }

             return new Point(x, y);
         }

         private bool ReadToken()
         {
             SkipWhiteSpace(!AllowComma);

             // Check for end of string
             if (More())
             {
                 _token = _pathString[_curIndex++];

                 return true;
             }
             else
             {
                 return false;
             }
         }

         bool More()
         {
             return _curIndex < _pathLength;
         }

         // Skip white space, one comma if allowed
         private bool SkipWhiteSpace(bool allowComma)
         {
             bool commaMet = false;

             while (More())
             {
                 char ch = _pathString[_curIndex];

                 switch (ch)
                 {
                     case ' ':
                     case '\n':
                     case '\r':
                     case '\t': // SVG whitespace
                         break;

                     case ',':
                         if (allowComma)
                         {
                             commaMet = true;
                             allowComma = false; // one comma only
                         }
                         else
                         {
                             ThrowBadToken();
                         }
                         break;

                     default:
                         // Avoid calling IsWhiteSpace for ch in (' ' .. 'z']
                         if (((ch > ' ') && (ch <= 'z')) || !Char.IsWhiteSpace(ch))
                         {
                             return commaMet;
                         }
                         break;
                 }

                 _curIndex++;
             }

             return commaMet;
         }

         private void ThrowBadToken()
         {
             throw new FormatException(string.Format("Unexpected character in path '{0}' at position {1}", _pathString, _curIndex - ));
         }

         static internal char GetNumericListSeparator(IFormatProvider provider)
         {
             char numericSeparator = ',';

             // Get the NumberFormatInfo out of the provider, if possible
             // If the IFormatProvider doesn't not contain a NumberFormatInfo, then
             // this method returns the current culture's NumberFormatInfo.
             NumberFormatInfo numberFormat = NumberFormatInfo.GetInstance(provider);

             // Is the decimal separator is the same as the list separator?
             // If so, we use the ";".
             if ((numberFormat.NumberDecimalSeparator.Length > ) && (numericSeparator == numberFormat.NumberDecimalSeparator[]))
             {
                 numericSeparator = ';';
             }

             return numericSeparator;
         }

         private string parseBack(PathGeometry geometry)
         {
             System.Text.StringBuilder sb = new System.Text.StringBuilder();
             IFormatProvider provider = new System.Globalization.CultureInfo("en-us");
             string format = null;

             sb.Append("F" + (geometry.FillRule == FillRule.EvenOdd ? "" : "") + " ");

             foreach (PathFigure figure in geometry.Figures)
             {
                 sb.Append("M " + ((IFormattable)figure.StartPoint).ToString(format, provider) + " ");

                 foreach (PathSegment segment in figure.Segments)
                 {
                     char separator = GetNumericListSeparator(provider);

                     if (segment.GetType() == typeof(LineSegment))
                     {
                         LineSegment _lineSegment = segment as LineSegment;

                         sb.Append("L " + ((IFormattable)_lineSegment.Point).ToString(format, provider) + " ");
                     }
                     else if (segment.GetType() == typeof(BezierSegment))
                     {
                         BezierSegment _bezierSegment = segment as BezierSegment;

                         sb.Append(String.Format(provider,
                              "C{1:" + format + "}{0}{2:" + format + "}{0}{3:" + format + "} ",
                              separator,
                              _bezierSegment.Point1,
                              _bezierSegment.Point2,
                              _bezierSegment.Point3
                              ));
                     }
                     else if (segment.GetType() == typeof(QuadraticBezierSegment))
                     {
                         QuadraticBezierSegment _quadraticBezierSegment = segment as QuadraticBezierSegment;

                         sb.Append(String.Format(provider,
                              "Q{1:" + format + "}{0}{2:" + format + "} ",
                              separator,
                              _quadraticBezierSegment.Point1,
                              _quadraticBezierSegment.Point2));
                     }
                     else if (segment.GetType() == typeof(ArcSegment))
                     {
                         ArcSegment _arcSegment = segment as ArcSegment;

                         sb.Append(String.Format(provider,
                              "A{1:" + format + "}{0}{2:" + format + "}{0}{3}{0}{4}{0}{5:" + format + "} ",
                              separator,
                              _arcSegment.Size,
                              _arcSegment.RotationAngle,
                              _arcSegment.IsLargeArc ? "" : "",
                              _arcSegment.SweepDirection == SweepDirection.Clockwise ? "" : "",
                              _arcSegment.Point));
                     }
                 }

                 if (figure.IsClosed)
                     sb.Append("Z");
             }

             return sb.ToString();
         }
         #endregion

         #region IValueConverter Members

         public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
         {
             string path = value as string;
             if (null != path)
                 return Convert(path);
             else
                 return null;
         }

         public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
         {
             PathGeometry geometry = value as PathGeometry;

             if (null != geometry)
                 return ConvertBack(geometry);
             else
                 return default(string);
         }

         #endregion
     }