public void SetMouth()
{
int index = _laugh ? 0 : 1;
var figure = new PathFigure() { StartPoint = _mouthPoints[index, 0] };
figure.Segments = new PathSegmentCollection();
var segment1 = new QuadraticBezierSegment();
segment1.Point1 = _mouthPoints[index, 1];
segment1.Point2 = _mouthPoints[index, 2];
figure.Segments.Add(segment1);
var geometry = new PathGeometry();
geometry.Figures = new PathFigureCollection();
geometry.Figures.Add(figure);
mouth.Data = geometry;
_laugh = !_laugh;
}
public static WMedia.Geometry ToWindows(this Geometry geometry)
{
WMedia.Geometry wGeometry = null;
if (geometry is LineGeometry)
{
LineGeometry lineGeometry = geometry as LineGeometry;
wGeometry = new WMedia.LineGeometry
{
StartPoint = lineGeometry.StartPoint.ToWindows(),
EndPoint = lineGeometry.EndPoint.ToWindows()
};
}
else if (geometry is RectangleGeometry)
{
var rect = (geometry as RectangleGeometry).Rect;
wGeometry = new WMedia.RectangleGeometry
{
Rect = new WFoundation.Rect(rect.X, rect.Y, rect.Width, rect.Height)
};
}
else if (geometry is EllipseGeometry)
{
EllipseGeometry ellipseGeometry = geometry as EllipseGeometry;
wGeometry = new WMedia.EllipseGeometry
{
Center = ellipseGeometry.Center.ToWindows(),
RadiusX = ellipseGeometry.RadiusX,
RadiusY = ellipseGeometry.RadiusY
};
}
else if (geometry is GeometryGroup)
{
GeometryGroup geometryGroup = geometry as GeometryGroup;
wGeometry = new WMedia.GeometryGroup
{
FillRule = ConvertFillRule(geometryGroup.FillRule)
};
foreach (Geometry children in geometryGroup.Children)
{
WMedia.Geometry winChild = children.ToWindows();
(wGeometry as WMedia.GeometryGroup).Children.Add(winChild);
}
}
else if (geometry is PathGeometry)
{
PathGeometry pathGeometry = geometry as PathGeometry;
WMedia.PathGeometry wPathGeometry = new WMedia.PathGeometry
{
FillRule = ConvertFillRule(pathGeometry.FillRule)
};
foreach (PathFigure xamPathFigure in pathGeometry.Figures)
{
WMedia.PathFigure wPathFigure = new WMedia.PathFigure
{
StartPoint = xamPathFigure.StartPoint.ToWindows(),
IsFilled = xamPathFigure.IsFilled,
IsClosed = xamPathFigure.IsClosed
};
wPathGeometry.Figures.Add(wPathFigure);
foreach (PathSegment pathSegment in xamPathFigure.Segments)
{
// LineSegment
if (pathSegment is LineSegment)
{
LineSegment lineSegment = pathSegment as LineSegment;
WMedia.LineSegment winSegment = new WMedia.LineSegment
{
Point = lineSegment.Point.ToWindows()
};
wPathFigure.Segments.Add(winSegment);
}
// PolylineSegment
if (pathSegment is PolyLineSegment)
{
PolyLineSegment polyLineSegment = pathSegment as PolyLineSegment;
WMedia.PolyLineSegment wSegment = new WMedia.PolyLineSegment();
foreach (var point in polyLineSegment.Points)
{
wSegment.Points.Add(point.ToWindows());
}
wPathFigure.Segments.Add(wSegment);
}
// BezierSegment
if (pathSegment is BezierSegment)
{
BezierSegment bezierSegment = pathSegment as BezierSegment;
WMedia.BezierSegment wSegment = new WMedia.BezierSegment
{
Point1 = bezierSegment.Point1.ToWindows(),
Point2 = bezierSegment.Point2.ToWindows(),
Point3 = bezierSegment.Point3.ToWindows()
};
wPathFigure.Segments.Add(wSegment);
}
// PolyBezierSegment
else if (pathSegment is PolyBezierSegment)
{
PolyBezierSegment polyBezierSegment = pathSegment as PolyBezierSegment;
WMedia.PolyBezierSegment wSegment = new WMedia.PolyBezierSegment();
foreach (var point in polyBezierSegment.Points)
{
wSegment.Points.Add(point.ToWindows());
}
wPathFigure.Segments.Add(wSegment);
}
// QuadraticBezierSegment
if (pathSegment is QuadraticBezierSegment)
{
QuadraticBezierSegment quadraticBezierSegment = pathSegment as QuadraticBezierSegment;
WMedia.QuadraticBezierSegment wSegment = new WMedia.QuadraticBezierSegment
{
Point1 = quadraticBezierSegment.Point1.ToWindows(),
Point2 = quadraticBezierSegment.Point2.ToWindows()
};
wPathFigure.Segments.Add(wSegment);
}
// PolyQuadraticBezierSegment
else if (pathSegment is PolyQuadraticBezierSegment)
{
PolyQuadraticBezierSegment polyQuadraticBezierSegment = pathSegment as PolyQuadraticBezierSegment;
WMedia.PolyQuadraticBezierSegment wSegment = new WMedia.PolyQuadraticBezierSegment();
foreach (var point in polyQuadraticBezierSegment.Points)
{
wSegment.Points.Add(point.ToWindows());
}
wPathFigure.Segments.Add(wSegment);
}
// ArcSegment
else if (pathSegment is ArcSegment)
{
ArcSegment arcSegment = pathSegment as ArcSegment;
WMedia.ArcSegment wSegment = new WMedia.ArcSegment
{
Size = new WFoundation.Size(arcSegment.Size.Width, arcSegment.Size.Height),
RotationAngle = arcSegment.RotationAngle,
IsLargeArc = arcSegment.IsLargeArc,
SweepDirection = arcSegment.SweepDirection == SweepDirection.Clockwise ? WMedia.SweepDirection.Clockwise : WMedia.SweepDirection.Counterclockwise,
Point = arcSegment.Point.ToWindows()
};
wPathFigure.Segments.Add(wSegment);
}
}
}
wGeometry = wPathGeometry;
}
return(wGeometry);
}
public object ConvertToNative(Geometry geometry)
{
winMedia.Geometry winGeometry = null;
// Determine what type of geometry we're dealing with.
if (geometry is LineGeometry)
{
LineGeometry xamGeometry = geometry as LineGeometry;
winGeometry = new winMedia.LineGeometry
{
StartPoint = ConvertPoint(xamGeometry.StartPoint),
EndPoint = ConvertPoint(xamGeometry.EndPoint)
};
}
else if (geometry is RectangleGeometry)
{
Rect rect = (geometry as RectangleGeometry).Rect;
winGeometry = new winMedia.RectangleGeometry
{
Rect = new winFound.Rect(rect.X, rect.Y, rect.Width, rect.Height)
};
}
else if (geometry is EllipseGeometry)
{
EllipseGeometry xamGeometry = geometry as EllipseGeometry;
winGeometry = new winMedia.EllipseGeometry
{
Center = ConvertPoint(xamGeometry.Center),
RadiusX = xamGeometry.RadiusX,
RadiusY = xamGeometry.RadiusY
};
}
else if (geometry is GeometryGroup)
{
GeometryGroup xamGeometry = geometry as GeometryGroup;
winGeometry = new winMedia.GeometryGroup
{
FillRule = ConvertFillRule(xamGeometry.FillRule)
};
foreach (Geometry xamChild in xamGeometry.Children)
{
winMedia.Geometry winChild = ConvertToNative(xamChild) as winMedia.Geometry;
(winGeometry as winMedia.GeometryGroup).Children.Add(winChild);
}
}
else if (geometry is PathGeometry)
{
PathGeometry xamPathGeometry = geometry as PathGeometry;
winMedia.PathGeometry winPathGeometry = new winMedia.PathGeometry
{
FillRule = ConvertFillRule(xamPathGeometry.FillRule)
};
foreach (PathFigure xamPathFigure in xamPathGeometry.Figures)
{
winMedia.PathFigure winPathFigure = new winMedia.PathFigure
{
StartPoint = ConvertPoint(xamPathFigure.StartPoint),
IsFilled = xamPathFigure.IsFilled,
IsClosed = xamPathFigure.IsClosed
};
winPathGeometry.Figures.Add(winPathFigure);
foreach (PathSegment xamPathSegment in xamPathFigure.Segments)
{
// LineSegment
if (xamPathSegment is LineSegment)
{
LineSegment xamSegment = xamPathSegment as LineSegment;
winMedia.LineSegment winSegment = new winMedia.LineSegment
{
Point = ConvertPoint(xamSegment.Point)
};
winPathFigure.Segments.Add(winSegment);
}
// PolylineSegment
if (xamPathSegment is PolyLineSegment)
{
PolyLineSegment xamSegment = xamPathSegment as PolyLineSegment;
winMedia.PolyLineSegment winSegment = new winMedia.PolyLineSegment();
foreach (Point point in xamSegment.Points)
{
winSegment.Points.Add(ConvertPoint(point));
}
winPathFigure.Segments.Add(winSegment);
}
// BezierSegment
if (xamPathSegment is BezierSegment)
{
BezierSegment xamSegment = xamPathSegment as BezierSegment;
winMedia.BezierSegment winSegment = new winMedia.BezierSegment
{
Point1 = ConvertPoint(xamSegment.Point1),
Point2 = ConvertPoint(xamSegment.Point2),
Point3 = ConvertPoint(xamSegment.Point3)
};
winPathFigure.Segments.Add(winSegment);
}
// PolyBezierSegment
else if (xamPathSegment is PolyBezierSegment)
{
PolyBezierSegment xamSegment = xamPathSegment as PolyBezierSegment;
winMedia.PolyBezierSegment winSegment = new winMedia.PolyBezierSegment();
foreach (Point point in xamSegment.Points)
{
winSegment.Points.Add(ConvertPoint(point));
}
winPathFigure.Segments.Add(winSegment);
}
// QuadraticBezierSegment
if (xamPathSegment is QuadraticBezierSegment)
{
QuadraticBezierSegment xamSegment = xamPathSegment as QuadraticBezierSegment;
winMedia.QuadraticBezierSegment winSegment = new winMedia.QuadraticBezierSegment
{
Point1 = ConvertPoint(xamSegment.Point1),
Point2 = ConvertPoint(xamSegment.Point2),
};
winPathFigure.Segments.Add(winSegment);
}
// PolyQuadraticBezierSegment
else if (xamPathSegment is PolyQuadraticBezierSegment)
{
PolyQuadraticBezierSegment xamSegment = xamPathSegment as PolyQuadraticBezierSegment;
winMedia.PolyQuadraticBezierSegment winSegment = new winMedia.PolyQuadraticBezierSegment();
foreach (Point point in xamSegment.Points)
{
winSegment.Points.Add(ConvertPoint(point));
}
winPathFigure.Segments.Add(winSegment);
}
// ArcSegment
else if (xamPathSegment is ArcSegment)
{
ArcSegment xamSegment = xamPathSegment as ArcSegment;
winMedia.ArcSegment winSegment = new winMedia.ArcSegment();
winSegment.Size = new winFound.Size(xamSegment.Size.Width, xamSegment.Size.Height);
winSegment.RotationAngle = xamSegment.RotationAngle;
winSegment.IsLargeArc = xamSegment.IsLargeArc;
winSegment.SweepDirection = xamSegment.SweepDirection == SweepDirection.Clockwise ? winMedia.SweepDirection.Clockwise : winMedia.SweepDirection.Counterclockwise;
winSegment.Point = ConvertPoint(xamSegment.Point);
winPathFigure.Segments.Add(winSegment);
}
}
}
winGeometry = winPathGeometry;
}
// Set transform.
if (geometry.Transform != null)
{
winGeometry.Transform = (winMedia.Transform)geometry.Transform.GetNativeObject();
}
return(winGeometry);
}
/// <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 = 0;
_secondLastPoint = new Point(0, 0);
_lastPoint = new Point(0, 0);
_lastStart = new Point(0, 0);
_figureStarted = false;
var first = true;
var lastCmd = ' ';
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();
var num = ReadNumber(!AllowComma);
// ReSharper disable once CompareOfFloatsByEqualityOperator
pathGeometry.FillRule = num == 0 ? FillRule.EvenOdd : FillRule.Nonzero;
break;
case 'm':
case 'M':
// XAML allows multiple points after M/m
_lastPoint = ReadPoint(cmd, !AllowComma);
_figure = new PathFigure
{
StartPoint = _lastPoint,
IsFilled = IsFilled,
IsClosed = !IsClosed
};
//context.BeginFigure(_lastPoint, IsFilled, !IsClosed);
_figureStarted = true;
_lastStart = _lastPoint;
lastCmd = 'M';
while (IsNumber(AllowComma))
{
_lastPoint = ReadPoint(cmd, !AllowComma);
var lineSegment = new LineSegment {Point = _lastPoint};
_figure.Segments.Add(lineSegment);
//context.LineTo(_lastPoint, IsStroked, !IsSmoothJoin);
lastCmd = '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;
}
var lineSegment = new LineSegment {Point = _lastPoint};
_figure.Segments.Add(lineSegment);
//context.LineTo(_lastPoint, IsStroked, !IsSmoothJoin);
}
while (IsNumber(AllowComma));
lastCmd = 'L';
break;
case 'c':
case 'C': // cubic Bezier
case 's':
case 'S': // smooth cublic Bezier
EnsureFigure();
do
{
Point p;
if ((cmd == 's') || (cmd == 'S'))
{
p = lastCmd == 'C' ? Reflect() : _lastPoint;
_secondLastPoint = ReadPoint(cmd, !AllowComma);
}
else
{
p = ReadPoint(cmd, !AllowComma);
_secondLastPoint = ReadPoint(cmd, AllowComma);
}
_lastPoint = ReadPoint(cmd, AllowComma);
var bizierSegment = new BezierSegment
{
Point1 = p,
Point2 = _secondLastPoint,
Point3 = _lastPoint
};
_figure.Segments.Add(bizierSegment);
//context.BezierTo(p, _secondLastPoint, _lastPoint, IsStroked, !IsSmoothJoin);
lastCmd = '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'))
{
_secondLastPoint = lastCmd == 'Q' ? Reflect() : _lastPoint;
_lastPoint = ReadPoint(cmd, !AllowComma);
}
else
{
_secondLastPoint = ReadPoint(cmd, !AllowComma);
_lastPoint = ReadPoint(cmd, AllowComma);
}
var quadraticBezierSegment = new QuadraticBezierSegment
{
Point1 = _secondLastPoint,
Point2 = _lastPoint
};
_figure.Segments.Add(quadraticBezierSegment);
//context.QuadraticBezierTo(_secondLastPoint, _lastPoint, IsStroked, !IsSmoothJoin);
lastCmd = 'Q';
}
while (IsNumber(AllowComma));
break;
case 'a':
case 'A':
EnsureFigure();
do
{
// A 3,4 5, 0, 0, 6,7
var w = ReadNumber(!AllowComma);
var h = ReadNumber(AllowComma);
var rotation = ReadNumber(AllowComma);
var large = ReadBool();
var sweep = ReadBool();
_lastPoint = ReadPoint(cmd, AllowComma);
var arcSegment = new ArcSegment
{
Point = _lastPoint,
Size = new Size(w, h),
RotationAngle = rotation,
IsLargeArc = large,
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));
lastCmd = 'A';
break;
case 'z':
case 'Z':
EnsureFigure();
_figure.IsClosed = IsClosed;
//context.SetClosedState(IsClosed);
_figureStarted = false;
lastCmd = '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;
}
private void UpdatePath(uint id, Point position)
{
PathGeometry geometryForCurrentFinger = this.FingerPaths[id].Data as PathGeometry;
QuadraticBezierSegment segment = new QuadraticBezierSegment();
if (geometryForCurrentFinger.Figures[0].Segments.Count > 0)
{
QuadraticBezierSegment lastLine = geometryForCurrentFinger.Figures[0].Segments.Last() as QuadraticBezierSegment;
Point lastEndPoint = lastLine.Point2;
segment.Point1 = lastEndPoint;
}
else
{
segment.Point1 = geometryForCurrentFinger.Figures[0].StartPoint;
segment.Point2 = position;
}
segment.Point2 = position;
geometryForCurrentFinger.Figures[0].Segments.Add(segment);
geometryForCurrentFinger.Figures[0].IsFilled = true;
}
/// <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 = 0;
_secondLastPoint = new Point(0, 0);
_lastPoint = new Point(0, 0);
_lastStart = new Point(0, 0);
_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')) // Path starts with M|m
{
ThrowBadToken();
}
first = false;
}
switch (cmd)
{
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)
{
_pathGeometry = new PathGeometry();
_pathGeometry.Figures.Add(_figure);
}
return _pathGeometry;
}
public void Render()
{
const double FLARE_LEN = 200d;
const double MAX_WIDTH = 30d;
const double MIN_WIDTH = 10d;
this._canvas.Children.Clear();
foreach (var line in this.Lines) {
if (line.Points.Count < 2) { continue; }
if (line.IsClosed) {
PathSegmentCollection pathSegments = new PathSegmentCollection();
for (int i = 1; i < line.Points.Count - 2; i = i + 2) {
Point point1 = this._map.MapToScreen(line.Points[i]);
Point point2 = this._map.MapToScreen(line.Points[i + 1]);
QuadraticBezierSegment bezier = new QuadraticBezierSegment() {
Point1 = point1,
Point2 = point2
};
pathSegments.Add(bezier);
}
PathFigure pathFigure = new PathFigure() {
StartPoint = this._map.MapToScreen(line.Points[0]),
Segments = pathSegments
};
PathFigureCollection pathFigures = new PathFigureCollection();
pathFigures.Add(pathFigure);
PathGeometry pathGeometry = new PathGeometry() {
Figures = pathFigures
};
Path p = new Path() {
Stroke = new SolidColorBrush() {
Color = line.Color
},
StrokeStartLineCap = PenLineCap.Round,
StrokeEndLineCap = PenLineCap.Round,
StrokeLineJoin = PenLineJoin.Round,
StrokeThickness = MIN_WIDTH,
IsHitTestVisible = false,
Data = pathGeometry
};
this._canvas.Children.Add(p);
}
else {
Point? curr = null;
Point? prev = null;
double len = 0;
foreach (var point in line.Points.Reverse<MapPoint>()) {
curr = this._map.MapToScreen(point);
if (prev != null) {
len += Math.Sqrt(Math.Pow(prev.Value.X - curr.Value.X, 2) + Math.Pow(prev.Value.Y - curr.Value.Y, 2));
double size = MIN_WIDTH;
if (len <= FLARE_LEN) {
size = len * (MIN_WIDTH - MAX_WIDTH) / FLARE_LEN + MAX_WIDTH;
}
this._canvas.Children.Add(
new Line() {
X1 = curr.Value.X,
Y1 = curr.Value.Y,
X2 = prev.Value.X,
Y2 = prev.Value.Y,
Stroke = new SolidColorBrush() {
Color = Colors.Orange
},
StrokeStartLineCap = PenLineCap.Round,
StrokeEndLineCap = PenLineCap.Round,
StrokeLineJoin = PenLineJoin.Round,
StrokeThickness = size,
IsHitTestVisible = false
}
);
}
prev = curr;
}
}
}
}