public void Parses_Implicit_Line_Command_After_Move(string pathData)
{
var pathGeometry = new PathGeometry();
using (var context = new PathGeometryContext(pathGeometry))
using (var parser = new PathMarkupParser(context))
{
parser.Parse(pathData);
var figure = pathGeometry.Figures[0];
var segment = figure.Segments[0];
Assert.IsType <LineSegment>(segment);
var lineSegment = (LineSegment)segment;
Assert.Equal(new Point(10, 10), lineSegment.Point);
figure = pathGeometry.Figures[1];
segment = figure.Segments[0];
Assert.IsType <LineSegment>(segment);
lineSegment = (LineSegment)segment;
Assert.Equal(new Point(20, 20), lineSegment.Point);
}
}
public void Throws_InvalidDataException_On_None_Defined_Command(string pathData)
{
var pathGeometry = new PathGeometry();
using (var context = new PathGeometryContext(pathGeometry))
using (var parser = new PathMarkupParser(context))
{
Assert.Throws<InvalidDataException>(() => parser.Parse(pathData));
}
}
/// <summary>
///
/// </summary>
/// <param name="pg"></param>
/// <param name="dx"></param>
/// <param name="dy"></param>
/// <returns></returns>
public IPathGeometry ToPathGeometry(AM.PathGeometry pg, double dx, double dy)
{
var factory = _serviceProvider.GetService <IFactory>();
var geometry = factory.CreatePathGeometry(
ImmutableArray.Create <IPathFigure>(),
pg.FillRule == AM.FillRule.EvenOdd ? FillRule.EvenOdd : FillRule.Nonzero);
var context = new PathGeometryContext(factory, geometry);
foreach (var pf in pg.Figures)
{
context.BeginFigure(
factory.CreatePointShape(pf.StartPoint.X + dx, pf.StartPoint.Y + dy),
pf.IsFilled,
pf.IsClosed);
foreach (var segment in pf.Segments)
{
if (segment is AM.ArcSegment arcSegment)
{
context.ArcTo(
factory.CreatePointShape(arcSegment.Point.X + dx, arcSegment.Point.Y + dy),
factory.CreatePathSize(arcSegment.Size.Width, arcSegment.Size.Height),
arcSegment.RotationAngle,
arcSegment.IsLargeArc,
arcSegment.SweepDirection == AM.SweepDirection.Clockwise ? SweepDirection.Clockwise : SweepDirection.Counterclockwise);
}
else if (segment is AM.BezierSegment cubicBezierSegment)
{
context.CubicBezierTo(
factory.CreatePointShape(cubicBezierSegment.Point1.X + dx, cubicBezierSegment.Point1.Y + dy),
factory.CreatePointShape(cubicBezierSegment.Point2.X + dx, cubicBezierSegment.Point2.Y + dy),
factory.CreatePointShape(cubicBezierSegment.Point3.X + dx, cubicBezierSegment.Point3.Y + dy));
}
else if (segment is AM.LineSegment lineSegment)
{
context.LineTo(
factory.CreatePointShape(lineSegment.Point.X + dx, lineSegment.Point.Y + dy));
}
else if (segment is AM.QuadraticBezierSegment quadraticBezierSegment)
{
context.QuadraticBezierTo(
factory.CreatePointShape(quadraticBezierSegment.Point1.X + dx, quadraticBezierSegment.Point1.Y + dy),
factory.CreatePointShape(quadraticBezierSegment.Point2.X + dx, quadraticBezierSegment.Point2.Y + dy));
}
else
{
throw new NotSupportedException("Not supported segment type: " + segment.GetType());
}
}
}
return(geometry);
}
public void Parses_FillMode_Before_Move()
{
var pathGeometry = new PathGeometry();
using (var context = new PathGeometryContext(pathGeometry))
using (var parser = new PathMarkupParser(context))
{
parser.Parse("F 1M0,0");
Assert.Equal(FillRule.NonZero, pathGeometry.FillRule);
}
}
public void Should_Parse(string pathData)
{
var pathGeometry = new PathGeometry();
using (var context = new PathGeometryContext(pathGeometry))
using (var parser = new PathMarkupParser(context))
{
parser.Parse(pathData);
Assert.True(true);
}
}
/// <summary>
/// Parses the specified path data to a <see cref="PathGeometry"/>.
/// </summary>
/// <param name="pathData">The s.</param>
/// <returns></returns>
public static new PathGeometry Parse(string pathData)
{
var pathGeometry = new PathGeometry();
using (var context = new PathGeometryContext(pathGeometry))
using (var parser = new PathMarkupParser(context))
{
parser.Parse(pathData);
}
return(pathGeometry);
}
public void Parses_Close()
{
var pathGeometry = new PathGeometry();
using (var context = new PathGeometryContext(pathGeometry))
using (var parser = new PathMarkupParser(context))
{
parser.Parse("M0 0L10 10z");
var figure = pathGeometry.Figures[0];
Assert.True(figure.IsClosed);
}
}
public void Parses_Move()
{
var pathGeometry = new PathGeometry();
using (var context = new PathGeometryContext(pathGeometry))
using (var parser = new PathMarkupParser(context))
{
parser.Parse("M10 10");
var figure = pathGeometry.Figures[0];
Assert.Equal(new Point(10, 10), figure.StartPoint);
}
}
public void BeginFigure_Adds_New_Figure()
{
var geometry = new PathGeometry();
var target = new PathGeometryContext(geometry);
Assert.Empty(geometry.Figures);
target.BeginFigure(new PointShape());
Assert.NotNull(geometry.Figures[0]);
Assert.True(geometry.Figures[0].IsFilled);
Assert.True(geometry.Figures[0].IsClosed);
target.SetClosedState(false);
Assert.False(geometry.Figures[0].IsClosed);
}
public void CubicBezierTo_Adds_New_CubicBezierSegment()
{
var geometry = new PathGeometry();
var target = new PathGeometryContext(geometry);
target.BeginFigure(new PointShape());
Assert.Empty(geometry.Figures[0].Segments);
target.CubicBezierTo(new PointShape(), new PointShape(), new PointShape());
var segment = geometry.Figures[0].Segments[0];
Assert.IsType <CubicBezierSegment>(segment);
Assert.True(segment.IsStroked);
Assert.True(segment.IsSmoothJoin);
}
public void PolyQuadraticBezierTo_Adds_New_XPolyQuadraticBezierSegment()
{
var geometry = new PathGeometry();
var target = new PathGeometryContext(geometry);
target.BeginFigure(new PointShape());
Assert.Empty(geometry.Figures[0].Segments);
target.PolyQuadraticBezierTo(ImmutableArray.Create <PointShape>(new PointShape(), new PointShape(), new PointShape()));
var segment = geometry.Figures[0].Segments[0];
Assert.IsType <PolyQuadraticBezierSegment>(segment);
Assert.True(segment.IsStroked);
Assert.True(segment.IsSmoothJoin);
}
public void ArcTo_Adds_New_ArcSegment()
{
var geometry = _factory.CreatePathGeometry();
var target = new PathGeometryContext(_factory, geometry);
target.BeginFigure(_factory.CreatePointShape());
Assert.Empty(geometry.Figures[0].Segments);
target.ArcTo(_factory.CreatePointShape(), _factory.CreatePathSize());
var segment = geometry.Figures[0].Segments[0];
Assert.IsType <ArcSegment>(segment);
Assert.True(segment.IsStroked);
Assert.True(segment.IsSmoothJoin);
}
public void PolyLineTo_Adds_New_XPolyLineSegment()
{
var geometry = _factory.CreatePathGeometry();
var target = new PathGeometryContext(_factory, geometry);
target.BeginFigure(_factory.CreatePointShape());
Assert.Empty(geometry.Figures[0].Segments);
target.PolyLineTo(ImmutableArray.Create <IPointShape>(_factory.CreatePointShape(), _factory.CreatePointShape(), _factory.CreatePointShape()));
var segment = geometry.Figures[0].Segments[0];
Assert.IsType <PolyLineSegment>(segment);
Assert.True(segment.IsStroked);
Assert.True(segment.IsSmoothJoin);
}
public void Parses_Scientific_Notation_Double()
{
var pathGeometry = new PathGeometry();
using (var context = new PathGeometryContext(pathGeometry))
using (var parser = new PathMarkupParser(context))
{
parser.Parse("M -1.01725E-005 -1.01725e-005");
var figure = pathGeometry.Figures[0];
Assert.Equal(
new Point(
double.Parse("-1.01725E-005", NumberStyles.Float, CultureInfo.InvariantCulture),
double.Parse("-1.01725E-005", NumberStyles.Float, CultureInfo.InvariantCulture)),
figure.StartPoint);
}
}
/// <summary>
/// Parse a mini-language string representation of the <see cref="PathGeometry"/>.
/// </summary>
/// <remarks>
/// The path geometry syntax may start with a "wsp*Fwsp*(0|1)" which indicate the winding mode (F0 is EvenOdd while F1 is NonZero).
/// </remarks>
/// <param name="source">The string with geometry data.</param>
/// <returns>The new instance of the <see cref="PathGeometry"/> class.</returns>
public static PathGeometry Parse(string source)
{
var fillRule = FillRule.EvenOdd;
var geometry = PathGeometry.Create(ImmutableArray.Create <PathFigure>(), fillRule);
if (source != null)
{
int curIndex = 0;
while ((curIndex < source.Length) && Char.IsWhiteSpace(source, curIndex))
{
curIndex++;
}
if (curIndex < source.Length)
{
if (source[curIndex] == 'F')
{
curIndex++;
while ((curIndex < source.Length) && Char.IsWhiteSpace(source, curIndex))
{
curIndex++;
}
if ((curIndex == source.Length) || ((source[curIndex] != '0') && (source[curIndex] != '1')))
{
throw new FormatException("Illegal token.");
}
fillRule = source[curIndex] == '0' ? FillRule.EvenOdd : FillRule.Nonzero;
curIndex++;
}
}
var parser = new SvgToPathGeometryParser();
var context = new PathGeometryContext(geometry);
parser.Parse(context, source, curIndex);
}
geometry.FillRule = fillRule;
return(geometry);
}
public void Parses_Line()
{
var pathGeometry = new PathGeometry();
using (var context = new PathGeometryContext(pathGeometry))
using (var parser = new PathMarkupParser(context))
{
parser.Parse("M0 0L10 10");
var figure = pathGeometry.Figures[0];
var segment = figure.Segments[0];
Assert.IsType<LineSegment>(segment);
var lineSegment = (LineSegment)segment;
Assert.Equal(new Point(10, 10), lineSegment.Point);
}
}
public void Should_Parse_Flags_Without_Separator()
{
var pathGeometry = new PathGeometry();
using (var context = new PathGeometryContext(pathGeometry))
using (var parser = new PathMarkupParser(context))
{
parser.Parse("a.898.898 0 01.27.188");
var figure = pathGeometry.Figures[0];
var segments = figure.Segments;
Assert.NotNull(segments);
Assert.Equal(1, segments.Count);
var arcSegment = segments[0];
Assert.IsType <ArcSegment>(arcSegment);
}
}
public void CloseFigure_Should_Move_CurrentPoint_To_CreateFigurePoint()
{
var pathGeometry = new PathGeometry();
using (var context = new PathGeometryContext(pathGeometry))
using (var parser = new PathMarkupParser(context))
{
parser.Parse("M10,10L100,100Z m10,10");
Assert.Equal(2, pathGeometry.Figures.Count);
var figure = pathGeometry.Figures[0];
Assert.Equal(new Point(10, 10), figure.StartPoint);
Assert.Equal(true, figure.IsClosed);
Assert.Equal(new Point(100, 100), ((LineSegment)figure.Segments[0]).Point);
figure = pathGeometry.Figures[1];
Assert.Equal(new Point(20, 20), figure.StartPoint);
}
}
public void Inherits_From_XGeometryContext()
{
var target = new PathGeometryContext(new PathGeometry());
Assert.True(target is GeometryContext);
}
/// <summary>
///
/// </summary>
/// <param name="pg"></param>
/// <param name="dx"></param>
/// <param name="dy"></param>
/// <returns></returns>
public static Path.PathGeometry ToPathGeometry(this System.Windows.Media.PathGeometry pg, double dx, double dy)
{
var geometry = Path.PathGeometry.Create(
ImmutableArray.Create <Path.PathFigure>(),
pg.FillRule == System.Windows.Media.FillRule.EvenOdd ? Path.FillRule.EvenOdd : Path.FillRule.Nonzero);
var context = new PathGeometryContext(geometry);
foreach (var pf in pg.Figures)
{
context.BeginFigure(
PointShape.Create(pf.StartPoint.X + dx, pf.StartPoint.Y + dy),
pf.IsFilled,
pf.IsClosed);
foreach (var segment in pf.Segments)
{
if (segment is ArcSegment)
{
var arcSegment = segment as ArcSegment;
context.ArcTo(
PointShape.Create(arcSegment.Point.X + dx, arcSegment.Point.Y + dy),
PathSize.Create(arcSegment.Size.Width, arcSegment.Size.Height),
arcSegment.RotationAngle,
arcSegment.IsLargeArc,
arcSegment.SweepDirection == System.Windows.Media.SweepDirection.Clockwise ? Path.SweepDirection.Clockwise : Path.SweepDirection.Counterclockwise,
arcSegment.IsStroked,
arcSegment.IsSmoothJoin);
}
else if (segment is BezierSegment)
{
var cubicBezierSegment = segment as BezierSegment;
context.CubicBezierTo(
PointShape.Create(cubicBezierSegment.Point1.X + dx, cubicBezierSegment.Point1.Y + dy),
PointShape.Create(cubicBezierSegment.Point2.X + dx, cubicBezierSegment.Point2.Y + dy),
PointShape.Create(cubicBezierSegment.Point3.X + dx, cubicBezierSegment.Point3.Y + dy),
cubicBezierSegment.IsStroked,
cubicBezierSegment.IsSmoothJoin);
}
else if (segment is LineSegment)
{
var lineSegment = segment as LineSegment;
context.LineTo(
PointShape.Create(lineSegment.Point.X + dx, lineSegment.Point.Y + dy),
lineSegment.IsStroked,
lineSegment.IsSmoothJoin);
}
else if (segment is PolyBezierSegment)
{
var polyCubicBezierSegment = segment as PolyBezierSegment;
context.PolyCubicBezierTo(
ToPointShapes(polyCubicBezierSegment.Points, dx, dy),
polyCubicBezierSegment.IsStroked,
polyCubicBezierSegment.IsSmoothJoin);
}
else if (segment is PolyLineSegment)
{
var polyLineSegment = segment as PolyLineSegment;
context.PolyLineTo(
ToPointShapes(polyLineSegment.Points, dx, dy),
polyLineSegment.IsStroked,
polyLineSegment.IsSmoothJoin);
}
else if (segment is PolyQuadraticBezierSegment)
{
var polyQuadraticSegment = segment as PolyQuadraticBezierSegment;
context.PolyQuadraticBezierTo(
ToPointShapes(polyQuadraticSegment.Points, dx, dy),
polyQuadraticSegment.IsStroked,
polyQuadraticSegment.IsSmoothJoin);
}
else if (segment is QuadraticBezierSegment)
{
var quadraticBezierSegment = segment as QuadraticBezierSegment;
context.QuadraticBezierTo(
PointShape.Create(quadraticBezierSegment.Point1.X + dx, quadraticBezierSegment.Point1.Y + dy),
PointShape.Create(quadraticBezierSegment.Point2.X + dx, quadraticBezierSegment.Point2.Y + dy),
quadraticBezierSegment.IsStroked,
quadraticBezierSegment.IsSmoothJoin);
}
else
{
throw new NotSupportedException("Not supported segment type: " + segment.GetType());
}
}
}
return(geometry);
}
