一，需要动态绑定Path
1 <UserControl x:Class="Secom.Emx2.SL.Common.Controls.EleSafe.Ele.Line"
2 xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
3 xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
4 xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
5 xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
6 mc:Ignorable="d"
7 d:DesignHeight="300" d:DesignWidth="400">
8
9 <Path x:Name="myline" Stretch="Fill" Width="{Binding Width, ElementName=path, Mode=TwoWay}" Height="{Binding Height, ElementName=path, Mode=TwoWay}"/>
10 </UserControl>
二，生成Path
1 private LineType _lineType = LineType.VLine;
2 public LineType LineType
3 {
4 get
5 {
6 return _lineType;
7 }
8 set
9 {
10 _lineType = value;
11 var pathString = string.Empty;
12 var eff = new DropShadowEffect();
13 eff.BlurRadius = 5;
14 eff.Color = Colors.DarkGray;
15 eff.ShadowDepth = 0;
16 var conv = new StringToPathGeometryConverter();
17 switch (_lineType)
18 {
19 case LineType.HLine:
20 eff.Direction = 0;
21 pathString = "M0,0 L131.137,0";
22 break;
23 case LineType.VLine:
24 default:
25 eff.Direction = 90;
26 pathString = "M87,60 L87,240.178";
27 break;
28 }
29
30 var pathData = conv.Convert(pathString);
31 myline.SetValue(Path.DataProperty, pathData);
32 //myline.SetValue(Path.EffectProperty, eff);
33 }
34 }
三，字符串转换成Path对象类
1 /* ==============================
2 * Desc：StringToPathGeometry
3 * Author：hezp
4 * Date：2014/8/9 17:39:40
5 * ==============================*/
6 public class StringToPathGeometryConverter : IValueConverter
7 {
8 #region Const & Private Variables
9 const bool AllowSign = true;
10 const bool AllowComma = true;
11 const bool IsFilled = true;
12 const bool IsClosed = true;
13
14 IFormatProvider _formatProvider;
15
16 PathFigure _figure = null; // Figure object, which will accept parsed segments
17 string _pathString; // Input string to be parsed
18 int _pathLength;
19 int _curIndex; // Location to read next character from
20 bool _figureStarted; // StartFigure is effective
21
22 Point _lastStart; // Last figure starting point
23 Point _lastPoint; // Last point
24 Point _secondLastPoint; // The point before last point
25
26 char _token; // Non whitespace character returned by ReadToken
27 #endregion
28
29 #region Public Functionality
30 /// <summary>
31 /// Main conversion routine - converts string path data definition to PathGeometry object
32 /// </summary>
33 /// <param name="path">String with path data definition</param>
34 /// <returns>PathGeometry object created from string definition</returns>
35 public PathGeometry Convert(string path)
36 {
37 if (null == path)
38 throw new ArgumentException("Path string cannot be null!");
39
40 if (path.Length == 0)
41 throw new ArgumentException("Path string cannot be empty!");
42
43 return parse(path);
44 }
45
46 /// <summary>
47 /// Main back conversion routine - converts PathGeometry object to its string equivalent
48 /// </summary>
49 /// <param name="geometry">Path Geometry object</param>
50 /// <returns>String equivalent to PathGeometry contents</returns>
51 public string ConvertBack(PathGeometry geometry)
52 {
53 if (null == geometry)
54 throw new ArgumentException("Path Geometry cannot be null!");
55
56 return parseBack(geometry);
57 }
58 #endregion
59
60 #region Private Functionality
61 /// <summary>
62 /// Main parser routine, which loops over each char in received string, and performs actions according to command/parameter being passed
63 /// </summary>
64 /// <param name="path">String with path data definition</param>
65 /// <returns>PathGeometry object created from string definition</returns>
66 private PathGeometry parse(string path)
67 {
68 PathGeometry _pathGeometry = null;
69
70
71 _formatProvider = CultureInfo.InvariantCulture;
72 _pathString = path;
73 _pathLength = path.Length;
74 _curIndex = 0;
75
76 _secondLastPoint = new Point(0, 0);
77 _lastPoint = new Point(0, 0);
78 _lastStart = new Point(0, 0);
79
80 _figureStarted = false;
81
82 bool first = true;
83
84 char last_cmd = ‘ ‘;
85
86 while (ReadToken()) // Empty path is allowed in XAML
87 {
88 char cmd = _token;
89
90 if (first)
91 {
92 if ((cmd != ‘M‘) && (cmd != ‘m‘) && (cmd != ‘f‘) && (cmd != ‘F‘)) // Path starts with M|m
93 {
94 ThrowBadToken();
95 }
96
97 first = false;
98 }
99
100 switch (cmd)
101 {
102 case ‘f‘:
103 case ‘F‘:
104 _pathGeometry = new PathGeometry();
105 double _num = ReadNumber(!AllowComma);
106 _pathGeometry.FillRule = _num == 0 ? FillRule.EvenOdd : FillRule.Nonzero;
107 break;
108
109 case ‘m‘:
110 case ‘M‘:
111 // XAML allows multiple points after M/m
112 _lastPoint = ReadPoint(cmd, !AllowComma);
113
114 _figure = new PathFigure();
115 _figure.StartPoint = _lastPoint;
116 _figure.IsFilled = IsFilled;
117 _figure.IsClosed = !IsClosed;
118 //context.BeginFigure(_lastPoint, IsFilled, !IsClosed);
119 _figureStarted = true;
120 _lastStart = _lastPoint;
121 last_cmd = ‘M‘;
122
123 while (IsNumber(AllowComma))
124 {
125 _lastPoint = ReadPoint(cmd, !AllowComma);
126
127 LineSegment _lineSegment = new LineSegment();
128 _lineSegment.Point = _lastPoint;
129 _figure.Segments.Add(_lineSegment);
130 //context.LineTo(_lastPoint, IsStroked, !IsSmoothJoin);
131 last_cmd = ‘L‘;
132 }
133 break;
134
135 case ‘l‘:
136 case ‘L‘:
137 case ‘h‘:
138 case ‘H‘:
139 case ‘v‘:
140 case ‘V‘:
141 EnsureFigure();
142
143 do
144 {
145 switch (cmd)
146 {
147 case ‘l‘: _lastPoint = ReadPoint(cmd, !AllowComma); break;
148 case ‘L‘: _lastPoint = ReadPoint(cmd, !AllowComma); break;
149 case ‘h‘: _lastPoint.X += ReadNumber(!AllowComma); break;
150 case ‘H‘: _lastPoint.X = ReadNumber(!AllowComma); break;
151 case ‘v‘: _lastPoint.Y += ReadNumber(!AllowComma); break;
152 case ‘V‘: _lastPoint.Y = ReadNumber(!AllowComma); break;
153 }
154
155 LineSegment _lineSegment = new LineSegment();
156 _lineSegment.Point = _lastPoint;
157 _figure.Segments.Add(_lineSegment);
158 //context.LineTo(_lastPoint, IsStroked, !IsSmoothJoin);
159 }
160 while (IsNumber(AllowComma));
161
162 last_cmd = ‘L‘;
163 break;
164
165 case ‘c‘:
166 case ‘C‘: // cubic Bezier
167 case ‘s‘:
168 case ‘S‘: // smooth cublic Bezier
169 EnsureFigure();
170
171 do
172 {
173 Point p;
174
175 if ((cmd == ‘s‘) || (cmd == ‘S‘))
176 {
177 if (last_cmd == ‘C‘)
178 {
179 p = Reflect();
180 }
181 else
182 {
183 p = _lastPoint;
184 }
185
186 _secondLastPoint = ReadPoint(cmd, !AllowComma);
187 }
188 else
189 {
190 p = ReadPoint(cmd, !AllowComma);
191
192 _secondLastPoint = ReadPoint(cmd, AllowComma);
193 }
194
195 _lastPoint = ReadPoint(cmd, AllowComma);
196
197 BezierSegment _bizierSegment = new BezierSegment();
198 _bizierSegment.Point1 = p;
199 _bizierSegment.Point2 = _secondLastPoint;
200 _bizierSegment.Point3 = _lastPoint;
201 _figure.Segments.Add(_bizierSegment);
202 //context.BezierTo(p, _secondLastPoint, _lastPoint, IsStroked, !IsSmoothJoin);
203
204 last_cmd = ‘C‘;
205 }
206 while (IsNumber(AllowComma));
207
208 break;
209
210 case ‘q‘:
211 case ‘Q‘: // quadratic Bezier
212 case ‘t‘:
213 case ‘T‘: // smooth quadratic Bezier
214 EnsureFigure();
215
216 do
217 {
218 if ((cmd == ‘t‘) || (cmd == ‘T‘))
219 {
220 if (last_cmd == ‘Q‘)
221 {
222 _secondLastPoint = Reflect();
223 }
224 else
225 {
226 _secondLastPoint = _lastPoint;
227 }
228
229 _lastPoint = ReadPoint(cmd, !AllowComma);
230 }
231 else
232 {
233 _secondLastPoint = ReadPoint(cmd, !AllowComma);
234 _lastPoint = ReadPoint(cmd, AllowComma);
235 }
236
237 QuadraticBezierSegment _quadraticBezierSegment = new QuadraticBezierSegment();
238 _quadraticBezierSegment.Point1 = _secondLastPoint;
239 _quadraticBezierSegment.Point2 = _lastPoint;
240 _figure.Segments.Add(_quadraticBezierSegment);
241 //context.QuadraticBezierTo(_secondLastPoint, _lastPoint, IsStroked, !IsSmoothJoin);
242
243 last_cmd = ‘Q‘;
244 }
245 while (IsNumber(AllowComma));
246
247 break;
248
249 case ‘a‘:
250 case ‘A‘:
251 EnsureFigure();
252
253 do
254 {
255 // A 3,4 5, 0, 0, 6,7
256 double w = ReadNumber(!AllowComma);
257 double h = ReadNumber(AllowComma);
258 double rotation = ReadNumber(AllowComma);
259 bool large = ReadBool();
260 bool sweep = ReadBool();
261
262 _lastPoint = ReadPoint(cmd, AllowComma);
263
264 ArcSegment _arcSegment = new ArcSegment();
265 _arcSegment.Point = _lastPoint;
266 _arcSegment.Size = new Size(w, h);
267 _arcSegment.RotationAngle = rotation;
268 _arcSegment.IsLargeArc = large;
269 _arcSegment.SweepDirection = sweep ? SweepDirection.Clockwise : SweepDirection.Counterclockwise;
270 _figure.Segments.Add(_arcSegment);
271 //context.ArcTo(
272 // _lastPoint,
273 // new Size(w, h),
274 // rotation,
275 // large,
276 // sweep ? SweepDirection.Clockwise : SweepDirection.Counterclockwise,
277 // IsStroked,
278 // !IsSmoothJoin
279 // );
280 }
281 while (IsNumber(AllowComma));
282
283 last_cmd = ‘A‘;
284 break;
285
286 case ‘z‘:
287 case ‘Z‘:
288 EnsureFigure();
289 _figure.IsClosed = IsClosed;
290 //context.SetClosedState(IsClosed);
291
292 _figureStarted = false;
293 last_cmd = ‘Z‘;
294
295 _lastPoint = _lastStart; // Set reference point to be first point of current figure
296 break;
297
298 default:
299 ThrowBadToken();
300 break;
301 }
302
303 if (null != _figure)
304 {
305 if (_figure.IsClosed)
306 {
307 if (null == _pathGeometry)
308 _pathGeometry = new PathGeometry();
309
310 _pathGeometry.Figures.Add(_figure);
311
312 _figure = null;
313 first = true;
314 }
315 }
316
317
318 }
319
320 if (null != _figure)
321 {
322 if (null == _pathGeometry)
323 _pathGeometry = new PathGeometry();
324
325 if (!_pathGeometry.Figures.Contains(_figure))
326 _pathGeometry.Figures.Add(_figure);
327
328 }
329 return _pathGeometry;
330 }
331
332 void SkipDigits(bool signAllowed)
333 {
334 // Allow for a sign
335 if (signAllowed && More() && ((_pathString[_curIndex] == ‘-‘) || _pathString[_curIndex] == ‘+‘))
336 {
337 _curIndex++;
338 }
339
340 while (More() && (_pathString[_curIndex] >= ‘0‘) && (_pathString[_curIndex] <= ‘9‘))
341 {
342 _curIndex++;
343 }
344 }
345
346 bool ReadBool()
347 {
348 SkipWhiteSpace(AllowComma);
349
350 if (More())
351 {
352 _token = _pathString[_curIndex++];
353
354 if (_token == ‘0‘)
355 {
356 return false;
357 }
358 else if (_token == ‘1‘)
359 {
360 return true;
361 }
362 }
363
364 ThrowBadToken();
365
366 return false;
367 }
368
369 private Point Reflect()
370 {
371 return new Point(2 * _lastPoint.X - _secondLastPoint.X,
372 2 * _lastPoint.Y - _secondLastPoint.Y);
373 }
374
375 private void EnsureFigure()
376 {
377 if (!_figureStarted)
378 {
379 _figure = new PathFigure();
380 _figure.StartPoint = _lastStart;
381
382 //_context.BeginFigure(_lastStart, IsFilled, !IsClosed);
383 _figureStarted = true;
384 }
385 }
386
387 double ReadNumber(bool allowComma)
388 {
389 if (!IsNumber(allowComma))
390 {
391 ThrowBadToken();
392 }
393
394 bool simple = true;
395 int start = _curIndex;
396
397 //
398 // Allow for a sign
399 //
400 // There are numbers that cannot be preceded with a sign, for instance, -NaN, but it‘s
401 // fine to ignore that at this point, since the CLR parser will catch this later.
402 //
403 if (More() && ((_pathString[_curIndex] == ‘-‘) || _pathString[_curIndex] == ‘+‘))
404 {
405 _curIndex++;
406 }
407
408 // Check for Infinity (or -Infinity).
409 if (More() && (_pathString[_curIndex] == ‘I‘))
410 {
411 //
412 // Don‘t bother reading the characters, as the CLR parser will
413 // do this for us later.
414 //
415 _curIndex = Math.Min(_curIndex + 8, _pathLength); // "Infinity" has 8 characters
416 simple = false;
417 }
418 // Check for NaN
419 else if (More() && (_pathString[_curIndex] == ‘N‘))
420 {
421 //
422 // Don‘t bother reading the characters, as the CLR parser will
423 // do this for us later.
424 //
425 _curIndex = Math.Min(_curIndex + 3, _pathLength); // "NaN" has 3 characters
426 simple = false;
427 }
428 else
429 {
430 SkipDigits(!AllowSign);
431
432 // Optional period, followed by more digits
433 if (More() && (_pathString[_curIndex] == ‘.‘))
434 {
435 simple = false;
436 _curIndex++;
437 SkipDigits(!AllowSign);
438 }
439
440 // Exponent
441 if (More() && ((_pathString[_curIndex] == ‘E‘) || (_pathString[_curIndex] == ‘e‘)))
442 {
443 simple = false;
444 _curIndex++;
445 SkipDigits(AllowSign);
446 }
447 }
448
449 if (simple && (_curIndex <= (start + 8))) // 32-bit integer
450 {
451 int sign = 1;
452
453 if (_pathString[start] == ‘+‘)
454 {
455 start++;
456 }
457 else if (_pathString[start] == ‘-‘)
458 {
459 start++;
460 sign = -1;
461 }
462
463 int value = 0;
464
465 while (start < _curIndex)
466 {
467 value = value * 10 + (_pathString[start] - ‘0‘);
468 start++;
469 }
470
471 return value * sign;
472 }
473 else
474 {
475 string subString = _pathString.Substring(start, _curIndex - start);
476
477 try
478 {
479 return System.Convert.ToDouble(subString, _formatProvider);
480 }
481 catch (FormatException except)
482 {
483 throw new FormatException(string.Format("Unexpected character in path ‘{0}‘ at position {1}", _pathString, _curIndex - 1), except);
484 }
485 }
486 }
487
488 private bool IsNumber(bool allowComma)
489 {
490 bool commaMet = SkipWhiteSpace(allowComma);
491
492 if (More())
493 {
494 _token = _pathString[_curIndex];
495
496 // Valid start of a number
497 if ((_token == ‘.‘) || (_token == ‘-‘) || (_token == ‘+‘) || ((_token >= ‘0‘) && (_token <= ‘9‘))
498 || (_token == ‘I‘) // Infinity
499 || (_token == ‘N‘)) // NaN
500 {
501 return true;
502 }
503 }
504
505 if (commaMet) // Only allowed between numbers
506 {
507 ThrowBadToken();
508 }
509
510 return false;
511 }
512
513 private Point ReadPoint(char cmd, bool allowcomma)
514 {
515 double x = ReadNumber(allowcomma);
516 double y = ReadNumber(AllowComma);
517
518 if (cmd >= ‘a‘) // ‘A‘ < ‘a‘. lower case for relative
519 {
520 x += _lastPoint.X;
521 y += _lastPoint.Y;
522 }
523
524 return new Point(x, y);
525 }
526
527 private bool ReadToken()
528 {
529 SkipWhiteSpace(!AllowComma);
530
531 // Check for end of string
532 if (More())
533 {
534 _token = _pathString[_curIndex++];
535
536 return true;
537 }
538 else
539 {
540 return false;
541 }
542 }
543
544 bool More()
545 {
546 return _curIndex < _pathLength;
547 }
548
549 // Skip white space, one comma if allowed
550 private bool SkipWhiteSpace(bool allowComma)
551 {
552 bool commaMet = false;
553
554 while (More())
555 {
556 char ch = _pathString[_curIndex];
557
558 switch (ch)
559 {
560 case ‘ ‘:
561 case ‘\n‘:
562 case ‘\r‘:
563 case ‘\t‘: // SVG whitespace
564 break;
565
566 case ‘,‘:
567 if (allowComma)
568 {
569 commaMet = true;
570 allowComma = false; // one comma only
571 }
572 else
573 {
574 ThrowBadToken();
575 }
576 break;
577
578 default:
579 // Avoid calling IsWhiteSpace for ch in (‘ ‘ .. ‘z‘]
580 if (((ch > ‘ ‘) && (ch <= ‘z‘)) || !Char.IsWhiteSpace(ch))
581 {
582 return commaMet;
583 }
584 break;
585 }
586
587 _curIndex++;
588 }
589
590 return commaMet;
591 }
592
593 private void ThrowBadToken()
594 {
595 throw new FormatException(string.Format("Unexpected character in path ‘{0}‘ at position {1}", _pathString, _curIndex - 1));
596 }
597
598 static internal char GetNumericListSeparator(IFormatProvider provider)
599 {
600 char numericSeparator = ‘,‘;
601
602 // Get the NumberFormatInfo out of the provider, if possible
603 // If the IFormatProvider doesn‘t not contain a NumberFormatInfo, then
604 // this method returns the current culture‘s NumberFormatInfo.
605 NumberFormatInfo numberFormat = NumberFormatInfo.GetInstance(provider);
606
607 // Is the decimal separator is the same as the list separator?
608 // If so, we use the ";".
609 if ((numberFormat.NumberDecimalSeparator.Length > 0) && (numericSeparator == numberFormat.NumberDecimalSeparator[0]))
610 {
611 numericSeparator = ‘;‘;
612 }
613
614 return numericSeparator;
615 }
616
617 private string parseBack(PathGeometry geometry)
618 {
619 System.Text.StringBuilder sb = new System.Text.StringBuilder();
620 IFormatProvider provider = new System.Globalization.CultureInfo("en-us");
621 string format = null;
622
623 sb.Append("F" + (geometry.FillRule == FillRule.EvenOdd ? "0" : "1") + " ");
624
625 foreach (PathFigure figure in geometry.Figures)
626 {
627 sb.Append("M " + ((IFormattable)figure.StartPoint).ToString(format, provider) + " ");
628
629 foreach (PathSegment segment in figure.Segments)
630 {
631 char separator = GetNumericListSeparator(provider);
632
633 if (segment.GetType() == typeof(LineSegment))
634 {
635 LineSegment _lineSegment = segment as LineSegment;
636
637 sb.Append("L " + ((IFormattable)_lineSegment.Point).ToString(format, provider) + " ");
638 }
639 else if (segment.GetType() == typeof(BezierSegment))
640 {
641 BezierSegment _bezierSegment = segment as BezierSegment;
642
643 sb.Append(String.Format(provider,
644 "C{1:" + format + "}{0}{2:" + format + "}{0}{3:" + format + "} ",
645 separator,
646 _bezierSegment.Point1,
647 _bezierSegment.Point2,
648 _bezierSegment.Point3
649 ));
650 }
651 else if (segment.GetType() == typeof(QuadraticBezierSegment))
652 {
653 QuadraticBezierSegment _quadraticBezierSegment = segment as QuadraticBezierSegment;
654
655 sb.Append(String.Format(provider,
656 "Q{1:" + format + "}{0}{2:" + format + "} ",
657 separator,
658 _quadraticBezierSegment.Point1,
659 _quadraticBezierSegment.Point2));
660 }
661 else if (segment.GetType() == typeof(ArcSegment))
662 {
663 ArcSegment _arcSegment = segment as ArcSegment;
664
665 sb.Append(String.Format(provider,
666 "A{1:" + format + "}{0}{2:" + format + "}{0}{3}{0}{4}{0}{5:" + format + "} ",
667 separator,
668 _arcSegment.Size,
669 _arcSegment.RotationAngle,
670 _arcSegment.IsLargeArc ? "1" : "0",
671 _arcSegment.SweepDirection == SweepDirection.Clockwise ? "1" : "0",
672 _arcSegment.Point));
673 }
674 }
675
676 if (figure.IsClosed)
677 sb.Append("Z");
678 }
679
680 return sb.ToString();
681 }
682 #endregion
683
684 #region IValueConverter Members
685
686 public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
687 {
688 string path = value as string;
689 if (null != path)
690 return Convert(path);
691 else
692 return null;
693 }
694
695 public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
696 {
697 PathGeometry geometry = value as PathGeometry;
698
699 if (null != geometry)
700 return ConvertBack(geometry);
701 else
702 return default(string);
703 }
704
705 #endregion
706 }
时间： 2024-08-06 05:25:57