|
|
|
@ -5,50 +5,61 @@ using System; |
|
|
|
using System.Collections.Generic; |
|
|
|
using System.Globalization; |
|
|
|
using System.IO; |
|
|
|
using System.Linq; |
|
|
|
using System.Text; |
|
|
|
using System.Text.RegularExpressions; |
|
|
|
using Avalonia.Platform; |
|
|
|
|
|
|
|
namespace Avalonia.Media |
|
|
|
{ |
|
|
|
/// <summary>
|
|
|
|
/// Parses a path markup string.
|
|
|
|
/// </summary>
|
|
|
|
public class PathMarkupParser |
|
|
|
public class PathMarkupParser : IDisposable |
|
|
|
{ |
|
|
|
private static readonly Dictionary<char, Command> Commands = new Dictionary<char, Command> |
|
|
|
{ |
|
|
|
{ 'F', Command.FillRule }, |
|
|
|
{ 'M', Command.Move }, |
|
|
|
{ 'L', Command.Line }, |
|
|
|
{ 'H', Command.HorizontalLine }, |
|
|
|
{ 'V', Command.VerticalLine }, |
|
|
|
{ 'Q', Command.QuadraticBezierCurve }, |
|
|
|
{ 'T', Command.SmoothQuadraticBezierCurve }, |
|
|
|
{ 'C', Command.CubicBezierCurve }, |
|
|
|
{ 'S', Command.SmoothCubicBezierCurve }, |
|
|
|
{ 'A', Command.Arc }, |
|
|
|
{ 'Z', Command.Close }, |
|
|
|
}; |
|
|
|
|
|
|
|
private static readonly Dictionary<char, FillRule> FillRules = new Dictionary<char, FillRule> |
|
|
|
private static readonly string s_separatorPattern; |
|
|
|
private static readonly Dictionary<char, Command> s_commands = |
|
|
|
new Dictionary<char, Command> |
|
|
|
{ |
|
|
|
{ 'F', Command.FillRule }, |
|
|
|
{ 'M', Command.Move }, |
|
|
|
{ 'L', Command.Line }, |
|
|
|
{ 'H', Command.HorizontalLine }, |
|
|
|
{ 'V', Command.VerticalLine }, |
|
|
|
{ 'Q', Command.QuadraticBezierCurve }, |
|
|
|
{ 'T', Command.SmoothQuadraticBezierCurve }, |
|
|
|
{ 'C', Command.CubicBezierCurve }, |
|
|
|
{ 'S', Command.SmoothCubicBezierCurve }, |
|
|
|
{ 'A', Command.Arc }, |
|
|
|
{ 'Z', Command.Close }, |
|
|
|
}; |
|
|
|
|
|
|
|
private IGeometryContext _geometryContext; |
|
|
|
private Point _currentPoint; |
|
|
|
private Point? _previousControlPoint; |
|
|
|
private bool? _isOpen; |
|
|
|
private bool _isDisposed; |
|
|
|
|
|
|
|
static PathMarkupParser() |
|
|
|
{ |
|
|
|
{'0', FillRule.EvenOdd }, |
|
|
|
{'1', FillRule.NonZero } |
|
|
|
}; |
|
|
|
|
|
|
|
private readonly StreamGeometryContext _context; |
|
|
|
s_separatorPattern = CreatesSeparatorPattern(); |
|
|
|
} |
|
|
|
|
|
|
|
/// <summary>
|
|
|
|
/// Initializes a new instance of the <see cref="PathMarkupParser"/> class.
|
|
|
|
/// </summary>
|
|
|
|
/// <param name="context">The context for the geometry.</param>
|
|
|
|
public PathMarkupParser(StreamGeometryContext context) |
|
|
|
/// <param name="geometryContext">The geometry context.</param>
|
|
|
|
/// <exception cref="ArgumentNullException">geometryContext</exception>
|
|
|
|
public PathMarkupParser(IGeometryContext geometryContext) |
|
|
|
{ |
|
|
|
_context = context; |
|
|
|
if (geometryContext == null) |
|
|
|
{ |
|
|
|
throw new ArgumentNullException(nameof(geometryContext)); |
|
|
|
} |
|
|
|
|
|
|
|
_geometryContext = geometryContext; |
|
|
|
} |
|
|
|
|
|
|
|
/// <summary>
|
|
|
|
/// Defines the command currently being processed.
|
|
|
|
/// </summary>
|
|
|
|
private enum Command |
|
|
|
{ |
|
|
|
None, |
|
|
|
@ -62,358 +73,568 @@ namespace Avalonia.Media |
|
|
|
SmoothCubicBezierCurve, |
|
|
|
SmoothQuadraticBezierCurve, |
|
|
|
Arc, |
|
|
|
Close, |
|
|
|
Close |
|
|
|
} |
|
|
|
|
|
|
|
/// <summary>
|
|
|
|
/// Parses the specified markup string.
|
|
|
|
/// Parses the specified path data and writes the result to the geometryContext of this instance.
|
|
|
|
/// </summary>
|
|
|
|
/// <param name="s">The markup string.</param>
|
|
|
|
public void Parse(string s) |
|
|
|
/// <param name="pathData">The path data.</param>
|
|
|
|
public void Parse(string pathData) |
|
|
|
{ |
|
|
|
var tokens = ParseTokens(pathData); |
|
|
|
|
|
|
|
CreateGeometry(tokens); |
|
|
|
} |
|
|
|
|
|
|
|
void IDisposable.Dispose() |
|
|
|
{ |
|
|
|
Dispose(true); |
|
|
|
} |
|
|
|
|
|
|
|
protected virtual void Dispose(bool disposing) |
|
|
|
{ |
|
|
|
bool openFigure = false; |
|
|
|
if (_isDisposed) |
|
|
|
{ |
|
|
|
return; |
|
|
|
} |
|
|
|
|
|
|
|
using (StringReader reader = new StringReader(s)) |
|
|
|
if (disposing) |
|
|
|
{ |
|
|
|
Command command = Command.None; |
|
|
|
Point point = new Point(); |
|
|
|
bool relative = false; |
|
|
|
Point? previousControlPoint = null; |
|
|
|
_geometryContext = null; |
|
|
|
} |
|
|
|
|
|
|
|
_isDisposed = true; |
|
|
|
} |
|
|
|
|
|
|
|
private static string CreatesSeparatorPattern() |
|
|
|
{ |
|
|
|
var stringBuilder = new StringBuilder(); |
|
|
|
|
|
|
|
while (ReadCommand(reader, ref command, ref relative)) |
|
|
|
foreach (var command in s_commands.Keys) |
|
|
|
{ |
|
|
|
stringBuilder.Append(command); |
|
|
|
|
|
|
|
stringBuilder.Append(char.ToLower(command)); |
|
|
|
} |
|
|
|
|
|
|
|
return @"(?=[" + stringBuilder + "])"; |
|
|
|
} |
|
|
|
|
|
|
|
private static IEnumerable<CommandToken> ParseTokens(string s) |
|
|
|
{ |
|
|
|
return Regex.Split(s, s_separatorPattern).Where(t => !string.IsNullOrEmpty(t)).Select(CommandToken.Parse); |
|
|
|
} |
|
|
|
|
|
|
|
private static Point MirrorControlPoint(Point controlPoint, Point center) |
|
|
|
{ |
|
|
|
var dir = controlPoint - center; |
|
|
|
|
|
|
|
return center + -dir; |
|
|
|
} |
|
|
|
|
|
|
|
private void CreateGeometry(IEnumerable<CommandToken> commandTokens) |
|
|
|
{ |
|
|
|
_currentPoint = new Point(); |
|
|
|
|
|
|
|
foreach (var commandToken in commandTokens) |
|
|
|
{ |
|
|
|
try |
|
|
|
{ |
|
|
|
switch (command) |
|
|
|
while (true) |
|
|
|
{ |
|
|
|
case Command.FillRule: |
|
|
|
_context.SetFillRule(ReadFillRule(reader)); |
|
|
|
previousControlPoint = null; |
|
|
|
break; |
|
|
|
|
|
|
|
case Command.Move: |
|
|
|
if (openFigure) |
|
|
|
{ |
|
|
|
_context.EndFigure(false); |
|
|
|
} |
|
|
|
|
|
|
|
point = ReadPoint(reader, point, relative); |
|
|
|
_context.BeginFigure(point, true); |
|
|
|
openFigure = true; |
|
|
|
previousControlPoint = null; |
|
|
|
break; |
|
|
|
|
|
|
|
case Command.Line: |
|
|
|
point = ReadPoint(reader, point, relative); |
|
|
|
_context.LineTo(point); |
|
|
|
previousControlPoint = null; |
|
|
|
break; |
|
|
|
|
|
|
|
case Command.HorizontalLine: |
|
|
|
if (!relative) |
|
|
|
{ |
|
|
|
point = point.WithX(ReadDouble(reader)); |
|
|
|
} |
|
|
|
else |
|
|
|
{ |
|
|
|
point = new Point(point.X + ReadDouble(reader), point.Y); |
|
|
|
} |
|
|
|
|
|
|
|
_context.LineTo(point); |
|
|
|
previousControlPoint = null; |
|
|
|
break; |
|
|
|
|
|
|
|
case Command.VerticalLine: |
|
|
|
if (!relative) |
|
|
|
{ |
|
|
|
point = point.WithY(ReadDouble(reader)); |
|
|
|
} |
|
|
|
else |
|
|
|
{ |
|
|
|
point = new Point(point.X, point.Y + ReadDouble(reader)); |
|
|
|
} |
|
|
|
|
|
|
|
_context.LineTo(point); |
|
|
|
previousControlPoint = null; |
|
|
|
break; |
|
|
|
|
|
|
|
case Command.QuadraticBezierCurve: |
|
|
|
{ |
|
|
|
Point handle = ReadPoint(reader, point, relative); |
|
|
|
previousControlPoint = handle; |
|
|
|
ReadSeparator(reader); |
|
|
|
point = ReadPoint(reader, point, relative); |
|
|
|
_context.QuadraticBezierTo(handle, point); |
|
|
|
switch (commandToken.Command) |
|
|
|
{ |
|
|
|
case Command.None: |
|
|
|
break; |
|
|
|
case Command.FillRule: |
|
|
|
SetFillRule(commandToken); |
|
|
|
break; |
|
|
|
case Command.Move: |
|
|
|
AddMove(commandToken); |
|
|
|
break; |
|
|
|
case Command.Line: |
|
|
|
AddLine(commandToken); |
|
|
|
break; |
|
|
|
case Command.HorizontalLine: |
|
|
|
AddHorizontalLine(commandToken); |
|
|
|
break; |
|
|
|
case Command.VerticalLine: |
|
|
|
AddVerticalLine(commandToken); |
|
|
|
break; |
|
|
|
} |
|
|
|
|
|
|
|
case Command.SmoothQuadraticBezierCurve: |
|
|
|
{ |
|
|
|
Point end = ReadPoint(reader, point, relative); |
|
|
|
|
|
|
|
if(previousControlPoint != null) |
|
|
|
previousControlPoint = MirrorControlPoint((Point)previousControlPoint, point); |
|
|
|
|
|
|
|
_context.QuadraticBezierTo(previousControlPoint ?? point, end); |
|
|
|
point = end; |
|
|
|
case Command.CubicBezierCurve: |
|
|
|
AddCubicBezierCurve(commandToken); |
|
|
|
break; |
|
|
|
} |
|
|
|
|
|
|
|
case Command.CubicBezierCurve: |
|
|
|
{ |
|
|
|
Point point1 = ReadPoint(reader, point, relative); |
|
|
|
ReadSeparator(reader); |
|
|
|
Point point2 = ReadPoint(reader, point, relative); |
|
|
|
previousControlPoint = point2; |
|
|
|
ReadSeparator(reader); |
|
|
|
point = ReadPoint(reader, point, relative); |
|
|
|
_context.CubicBezierTo(point1, point2, point); |
|
|
|
case Command.QuadraticBezierCurve: |
|
|
|
AddQuadraticBezierCurve(commandToken); |
|
|
|
break; |
|
|
|
} |
|
|
|
|
|
|
|
case Command.SmoothCubicBezierCurve: |
|
|
|
{ |
|
|
|
Point point2 = ReadPoint(reader, point, relative); |
|
|
|
ReadSeparator(reader); |
|
|
|
Point end = ReadPoint(reader, point, relative); |
|
|
|
|
|
|
|
if(previousControlPoint != null) |
|
|
|
previousControlPoint = MirrorControlPoint((Point)previousControlPoint, point); |
|
|
|
|
|
|
|
_context.CubicBezierTo(previousControlPoint ?? point, point2, end); |
|
|
|
previousControlPoint = point2; |
|
|
|
point = end; |
|
|
|
case Command.SmoothCubicBezierCurve: |
|
|
|
AddSmoothCubicBezierCurve(commandToken); |
|
|
|
break; |
|
|
|
} |
|
|
|
|
|
|
|
case Command.Arc: |
|
|
|
{ |
|
|
|
Size size = ReadSize(reader); |
|
|
|
ReadSeparator(reader); |
|
|
|
double rotationAngle = ReadDouble(reader); |
|
|
|
ReadSeparator(reader); |
|
|
|
bool isLargeArc = ReadBool(reader); |
|
|
|
ReadSeparator(reader); |
|
|
|
SweepDirection sweepDirection = ReadBool(reader) ? SweepDirection.Clockwise : SweepDirection.CounterClockwise; |
|
|
|
ReadSeparator(reader); |
|
|
|
point = ReadPoint(reader, point, relative); |
|
|
|
|
|
|
|
_context.ArcTo(point, size, rotationAngle, isLargeArc, sweepDirection); |
|
|
|
previousControlPoint = null; |
|
|
|
case Command.SmoothQuadraticBezierCurve: |
|
|
|
AddSmoothQuadraticBezierCurve(commandToken); |
|
|
|
break; |
|
|
|
} |
|
|
|
case Command.Arc: |
|
|
|
AddArc(commandToken); |
|
|
|
break; |
|
|
|
case Command.Close: |
|
|
|
CloseFigure(); |
|
|
|
break; |
|
|
|
default: |
|
|
|
throw new NotSupportedException("Unsupported command"); |
|
|
|
} |
|
|
|
|
|
|
|
case Command.Close: |
|
|
|
_context.EndFigure(true); |
|
|
|
openFigure = false; |
|
|
|
previousControlPoint = null; |
|
|
|
break; |
|
|
|
if (commandToken.HasImplicitCommands) |
|
|
|
{ |
|
|
|
continue; |
|
|
|
} |
|
|
|
|
|
|
|
default: |
|
|
|
throw new NotSupportedException("Unsupported command"); |
|
|
|
break; |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
if (openFigure) |
|
|
|
catch (InvalidDataException) |
|
|
|
{ |
|
|
|
break; |
|
|
|
} |
|
|
|
catch (NotSupportedException) |
|
|
|
{ |
|
|
|
_context.EndFigure(false); |
|
|
|
break; |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
if (_isOpen != null) |
|
|
|
{ |
|
|
|
_geometryContext.EndFigure(false); |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
private Point MirrorControlPoint(Point controlPoint, Point center) |
|
|
|
private void CreateFigure() |
|
|
|
{ |
|
|
|
Point dir = (controlPoint - center); |
|
|
|
return center + -dir; |
|
|
|
if (_isOpen != null) |
|
|
|
{ |
|
|
|
_geometryContext.EndFigure(false); |
|
|
|
} |
|
|
|
|
|
|
|
_geometryContext.BeginFigure(_currentPoint); |
|
|
|
|
|
|
|
_isOpen = true; |
|
|
|
} |
|
|
|
|
|
|
|
private static bool ReadCommand( |
|
|
|
StringReader reader, |
|
|
|
ref Command command, |
|
|
|
ref bool relative) |
|
|
|
private void SetFillRule(CommandToken commandToken) |
|
|
|
{ |
|
|
|
ReadWhitespace(reader); |
|
|
|
var fillRule = commandToken.ReadFillRule(); |
|
|
|
|
|
|
|
int i = reader.Peek(); |
|
|
|
_geometryContext.SetFillRule(fillRule); |
|
|
|
} |
|
|
|
|
|
|
|
if (i == -1) |
|
|
|
private void CloseFigure() |
|
|
|
{ |
|
|
|
if (_isOpen == true) |
|
|
|
{ |
|
|
|
return false; |
|
|
|
_geometryContext.EndFigure(true); |
|
|
|
} |
|
|
|
else |
|
|
|
|
|
|
|
_previousControlPoint = null; |
|
|
|
|
|
|
|
_isOpen = null; |
|
|
|
} |
|
|
|
|
|
|
|
private void AddMove(CommandToken commandToken) |
|
|
|
{ |
|
|
|
var currentPoint = commandToken.IsRelative |
|
|
|
? commandToken.ReadRelativePoint(_currentPoint) |
|
|
|
: commandToken.ReadPoint(); |
|
|
|
|
|
|
|
_currentPoint = currentPoint; |
|
|
|
|
|
|
|
CreateFigure(); |
|
|
|
|
|
|
|
if (!commandToken.HasImplicitCommands) |
|
|
|
{ |
|
|
|
return; |
|
|
|
} |
|
|
|
|
|
|
|
while (commandToken.HasImplicitCommands) |
|
|
|
{ |
|
|
|
char c = (char)i; |
|
|
|
Command next = Command.None; |
|
|
|
AddLine(commandToken); |
|
|
|
|
|
|
|
if (!Commands.TryGetValue(char.ToUpperInvariant(c), out next)) |
|
|
|
if (commandToken.IsRelative) |
|
|
|
{ |
|
|
|
if ((char.IsDigit(c) || c == '.' || c == '+' || c == '-') && |
|
|
|
(command != Command.None)) |
|
|
|
{ |
|
|
|
return true; |
|
|
|
} |
|
|
|
else |
|
|
|
{ |
|
|
|
throw new InvalidDataException("Unexpected path command '" + c + "'."); |
|
|
|
} |
|
|
|
continue; |
|
|
|
} |
|
|
|
|
|
|
|
command = next; |
|
|
|
relative = char.IsLower(c); |
|
|
|
reader.Read(); |
|
|
|
return true; |
|
|
|
_currentPoint = currentPoint; |
|
|
|
|
|
|
|
CreateFigure(); |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
private static FillRule ReadFillRule(StringReader reader) |
|
|
|
private void AddLine(CommandToken commandToken) |
|
|
|
{ |
|
|
|
int i = reader.Read(); |
|
|
|
if (i == -1) |
|
|
|
_currentPoint = commandToken.IsRelative |
|
|
|
? commandToken.ReadRelativePoint(_currentPoint) |
|
|
|
: commandToken.ReadPoint(); |
|
|
|
|
|
|
|
if (_isOpen == null) |
|
|
|
{ |
|
|
|
throw new InvalidDataException("Invalid fill rule"); |
|
|
|
CreateFigure(); |
|
|
|
} |
|
|
|
char c = (char)i; |
|
|
|
FillRule rule; |
|
|
|
|
|
|
|
if (!FillRules.TryGetValue(c, out rule)) |
|
|
|
_geometryContext.LineTo(_currentPoint); |
|
|
|
} |
|
|
|
|
|
|
|
private void AddHorizontalLine(CommandToken commandToken) |
|
|
|
{ |
|
|
|
_currentPoint = commandToken.IsRelative |
|
|
|
? new Point(_currentPoint.X + commandToken.ReadDouble(), _currentPoint.Y) |
|
|
|
: _currentPoint.WithX(commandToken.ReadDouble()); |
|
|
|
|
|
|
|
if (_isOpen == null) |
|
|
|
{ |
|
|
|
throw new InvalidDataException("Invalid fill rule"); |
|
|
|
CreateFigure(); |
|
|
|
} |
|
|
|
|
|
|
|
return rule; |
|
|
|
_geometryContext.LineTo(_currentPoint); |
|
|
|
} |
|
|
|
|
|
|
|
private static double ReadDouble(StringReader reader) |
|
|
|
private void AddVerticalLine(CommandToken commandToken) |
|
|
|
{ |
|
|
|
ReadWhitespace(reader); |
|
|
|
_currentPoint = commandToken.IsRelative |
|
|
|
? new Point(_currentPoint.X, _currentPoint.Y + commandToken.ReadDouble()) |
|
|
|
: _currentPoint.WithY(commandToken.ReadDouble()); |
|
|
|
|
|
|
|
// TODO: Handle Infinity, NaN and scientific notation.
|
|
|
|
StringBuilder b = new StringBuilder(); |
|
|
|
bool readSign = false; |
|
|
|
bool readPoint = false; |
|
|
|
bool readExponent = false; |
|
|
|
int i; |
|
|
|
|
|
|
|
while ((i = reader.Peek()) != -1) |
|
|
|
if (_isOpen == null) |
|
|
|
{ |
|
|
|
char c = char.ToUpperInvariant((char)i); |
|
|
|
CreateFigure(); |
|
|
|
} |
|
|
|
|
|
|
|
if (((c == '+' || c == '-') && !readSign) || |
|
|
|
(c == '.' && !readPoint) || |
|
|
|
(c == 'E' && !readExponent) || |
|
|
|
char.IsDigit(c)) |
|
|
|
{ |
|
|
|
if (b.Length != 0 && !readExponent && c == '-') |
|
|
|
break; |
|
|
|
|
|
|
|
b.Append(c); |
|
|
|
reader.Read(); |
|
|
|
_geometryContext.LineTo(_currentPoint); |
|
|
|
} |
|
|
|
|
|
|
|
if (!readSign) |
|
|
|
{ |
|
|
|
readSign = c == '+' || c == '-'; |
|
|
|
} |
|
|
|
private void AddCubicBezierCurve(CommandToken commandToken) |
|
|
|
{ |
|
|
|
var point1 = commandToken.IsRelative |
|
|
|
? commandToken.ReadRelativePoint(_currentPoint) |
|
|
|
: commandToken.ReadPoint(); |
|
|
|
|
|
|
|
if (!readPoint) |
|
|
|
{ |
|
|
|
readPoint = c == '.'; |
|
|
|
} |
|
|
|
var point2 = commandToken.IsRelative |
|
|
|
? commandToken.ReadRelativePoint(_currentPoint) |
|
|
|
: commandToken.ReadPoint(); |
|
|
|
|
|
|
|
if (c == 'E') |
|
|
|
{ |
|
|
|
readSign = false; |
|
|
|
readExponent = true; |
|
|
|
} |
|
|
|
} |
|
|
|
else |
|
|
|
{ |
|
|
|
break; |
|
|
|
} |
|
|
|
_previousControlPoint = point2; |
|
|
|
|
|
|
|
var point3 = commandToken.IsRelative |
|
|
|
? commandToken.ReadRelativePoint(_currentPoint) |
|
|
|
: commandToken.ReadPoint(); |
|
|
|
|
|
|
|
if (_isOpen == null) |
|
|
|
{ |
|
|
|
CreateFigure(); |
|
|
|
} |
|
|
|
|
|
|
|
return double.Parse(b.ToString(), CultureInfo.InvariantCulture); |
|
|
|
_geometryContext.CubicBezierTo(point1, point2, point3); |
|
|
|
|
|
|
|
_currentPoint = point3; |
|
|
|
} |
|
|
|
|
|
|
|
private static Point ReadPoint(StringReader reader, Point current, bool relative) |
|
|
|
private void AddQuadraticBezierCurve(CommandToken commandToken) |
|
|
|
{ |
|
|
|
if (!relative) |
|
|
|
var start = commandToken.IsRelative |
|
|
|
? commandToken.ReadRelativePoint(_currentPoint) |
|
|
|
: commandToken.ReadPoint(); |
|
|
|
|
|
|
|
_previousControlPoint = start; |
|
|
|
|
|
|
|
var end = commandToken.IsRelative |
|
|
|
? commandToken.ReadRelativePoint(_currentPoint) |
|
|
|
: commandToken.ReadPoint(); |
|
|
|
|
|
|
|
if (_isOpen == null) |
|
|
|
{ |
|
|
|
current = new Point(); |
|
|
|
CreateFigure(); |
|
|
|
} |
|
|
|
|
|
|
|
ReadWhitespace(reader); |
|
|
|
double x = current.X + ReadDouble(reader); |
|
|
|
ReadSeparator(reader); |
|
|
|
double y = current.Y + ReadDouble(reader); |
|
|
|
return new Point(x, y); |
|
|
|
_geometryContext.QuadraticBezierTo(start, end); |
|
|
|
|
|
|
|
_currentPoint = end; |
|
|
|
} |
|
|
|
|
|
|
|
private static Size ReadSize(StringReader reader) |
|
|
|
private void AddSmoothCubicBezierCurve(CommandToken commandToken) |
|
|
|
{ |
|
|
|
ReadWhitespace(reader); |
|
|
|
double x = ReadDouble(reader); |
|
|
|
ReadSeparator(reader); |
|
|
|
double y = ReadDouble(reader); |
|
|
|
return new Size(x, y); |
|
|
|
var point2 = commandToken.IsRelative |
|
|
|
? commandToken.ReadRelativePoint(_currentPoint) |
|
|
|
: commandToken.ReadPoint(); |
|
|
|
|
|
|
|
var end = commandToken.IsRelative |
|
|
|
? commandToken.ReadRelativePoint(_currentPoint) |
|
|
|
: commandToken.ReadPoint(); |
|
|
|
|
|
|
|
if (_previousControlPoint != null) |
|
|
|
{ |
|
|
|
_previousControlPoint = MirrorControlPoint((Point)_previousControlPoint, _currentPoint); |
|
|
|
} |
|
|
|
|
|
|
|
if (_isOpen == null) |
|
|
|
{ |
|
|
|
CreateFigure(); |
|
|
|
} |
|
|
|
|
|
|
|
_geometryContext.CubicBezierTo(_previousControlPoint ?? _currentPoint, point2, end); |
|
|
|
|
|
|
|
_previousControlPoint = point2; |
|
|
|
|
|
|
|
_currentPoint = end; |
|
|
|
} |
|
|
|
|
|
|
|
private static bool ReadBool(StringReader reader) |
|
|
|
private void AddSmoothQuadraticBezierCurve(CommandToken commandToken) |
|
|
|
{ |
|
|
|
return ReadDouble(reader) != 0; |
|
|
|
var end = commandToken.IsRelative |
|
|
|
? commandToken.ReadRelativePoint(_currentPoint) |
|
|
|
: commandToken.ReadPoint(); |
|
|
|
|
|
|
|
if (_previousControlPoint != null) |
|
|
|
{ |
|
|
|
_previousControlPoint = MirrorControlPoint((Point)_previousControlPoint, _currentPoint); |
|
|
|
} |
|
|
|
|
|
|
|
if (_isOpen == null) |
|
|
|
{ |
|
|
|
CreateFigure(); |
|
|
|
} |
|
|
|
|
|
|
|
_geometryContext.QuadraticBezierTo(_previousControlPoint ?? _currentPoint, end); |
|
|
|
|
|
|
|
_currentPoint = end; |
|
|
|
} |
|
|
|
|
|
|
|
private static Point ReadRelativePoint(StringReader reader, Point lastPoint) |
|
|
|
private void AddArc(CommandToken commandToken) |
|
|
|
{ |
|
|
|
ReadWhitespace(reader); |
|
|
|
double x = ReadDouble(reader); |
|
|
|
ReadSeparator(reader); |
|
|
|
double y = ReadDouble(reader); |
|
|
|
return new Point(lastPoint.X + x, lastPoint.Y + y); |
|
|
|
var size = commandToken.ReadSize(); |
|
|
|
|
|
|
|
var rotationAngle = commandToken.ReadDouble(); |
|
|
|
|
|
|
|
var isLargeArc = commandToken.ReadBool(); |
|
|
|
|
|
|
|
var sweepDirection = commandToken.ReadBool() ? SweepDirection.Clockwise : SweepDirection.CounterClockwise; |
|
|
|
|
|
|
|
var end = commandToken.IsRelative |
|
|
|
? commandToken.ReadRelativePoint(_currentPoint) |
|
|
|
: commandToken.ReadPoint(); |
|
|
|
|
|
|
|
if (_isOpen == null) |
|
|
|
{ |
|
|
|
CreateFigure(); |
|
|
|
} |
|
|
|
|
|
|
|
_geometryContext.ArcTo(end, size, rotationAngle, isLargeArc, sweepDirection); |
|
|
|
|
|
|
|
_currentPoint = end; |
|
|
|
|
|
|
|
_previousControlPoint = null; |
|
|
|
} |
|
|
|
|
|
|
|
private static void ReadSeparator(StringReader reader) |
|
|
|
private class CommandToken |
|
|
|
{ |
|
|
|
int i; |
|
|
|
bool readComma = false; |
|
|
|
private const string ArgumentExpression = @"-?[0-9]*\.?\d+"; |
|
|
|
|
|
|
|
while ((i = reader.Peek()) != -1) |
|
|
|
private CommandToken(Command command, bool isRelative, IEnumerable<string> arguments) |
|
|
|
{ |
|
|
|
char c = (char)i; |
|
|
|
Command = command; |
|
|
|
|
|
|
|
IsRelative = isRelative; |
|
|
|
|
|
|
|
Arguments = new List<string>(arguments); |
|
|
|
} |
|
|
|
|
|
|
|
public Command Command { get; } |
|
|
|
|
|
|
|
if (char.IsWhiteSpace(c)) |
|
|
|
public bool IsRelative { get; } |
|
|
|
|
|
|
|
public bool HasImplicitCommands |
|
|
|
{ |
|
|
|
get |
|
|
|
{ |
|
|
|
reader.Read(); |
|
|
|
if (CurrentPosition == 0 && Arguments.Count > 0) |
|
|
|
{ |
|
|
|
return true; |
|
|
|
} |
|
|
|
|
|
|
|
return CurrentPosition < Arguments.Count - 1; |
|
|
|
} |
|
|
|
else if (c == ',') |
|
|
|
} |
|
|
|
|
|
|
|
private int CurrentPosition { get; set; } |
|
|
|
|
|
|
|
private List<string> Arguments { get; } |
|
|
|
|
|
|
|
public static CommandToken Parse(string s) |
|
|
|
{ |
|
|
|
using (var reader = new StringReader(s)) |
|
|
|
{ |
|
|
|
if (readComma) |
|
|
|
var command = Command.None; |
|
|
|
|
|
|
|
var isRelative = false; |
|
|
|
|
|
|
|
if (!ReadCommand(reader, ref command, ref isRelative)) |
|
|
|
{ |
|
|
|
throw new InvalidDataException("Unexpected ','."); |
|
|
|
throw new InvalidDataException("No path command declared."); |
|
|
|
} |
|
|
|
|
|
|
|
readComma = true; |
|
|
|
reader.Read(); |
|
|
|
var commandArguments = reader.ReadToEnd(); |
|
|
|
|
|
|
|
var argumentMatches = Regex.Matches(commandArguments, ArgumentExpression); |
|
|
|
|
|
|
|
var arguments = new List<string>(); |
|
|
|
|
|
|
|
foreach (Match match in argumentMatches) |
|
|
|
{ |
|
|
|
arguments.Add(match.Value); |
|
|
|
} |
|
|
|
|
|
|
|
return new CommandToken(command, isRelative, arguments); |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
public FillRule ReadFillRule() |
|
|
|
{ |
|
|
|
if (CurrentPosition == Arguments.Count) |
|
|
|
{ |
|
|
|
throw new InvalidDataException("Invalid fill rule"); |
|
|
|
} |
|
|
|
else |
|
|
|
|
|
|
|
var value = Arguments[CurrentPosition]; |
|
|
|
|
|
|
|
CurrentPosition++; |
|
|
|
|
|
|
|
switch (value) |
|
|
|
{ |
|
|
|
break; |
|
|
|
case "0": |
|
|
|
{ |
|
|
|
return FillRule.EvenOdd; |
|
|
|
} |
|
|
|
|
|
|
|
case "1": |
|
|
|
{ |
|
|
|
return FillRule.NonZero; |
|
|
|
} |
|
|
|
|
|
|
|
default: |
|
|
|
throw new InvalidDataException("Invalid fill rule"); |
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
private static void ReadWhitespace(StringReader reader) |
|
|
|
{ |
|
|
|
int i; |
|
|
|
public bool ReadBool() |
|
|
|
{ |
|
|
|
if (CurrentPosition == Arguments.Count) |
|
|
|
{ |
|
|
|
throw new InvalidDataException("Invalid boolean value"); |
|
|
|
} |
|
|
|
|
|
|
|
var value = Arguments[CurrentPosition]; |
|
|
|
|
|
|
|
CurrentPosition++; |
|
|
|
|
|
|
|
switch (value) |
|
|
|
{ |
|
|
|
case "1": |
|
|
|
{ |
|
|
|
return true; |
|
|
|
} |
|
|
|
|
|
|
|
case "0": |
|
|
|
{ |
|
|
|
return false; |
|
|
|
} |
|
|
|
|
|
|
|
default: |
|
|
|
throw new InvalidDataException("Invalid boolean value"); |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
public double ReadDouble() |
|
|
|
{ |
|
|
|
if (CurrentPosition == Arguments.Count) |
|
|
|
{ |
|
|
|
throw new InvalidDataException("Invalid double value"); |
|
|
|
} |
|
|
|
|
|
|
|
var value = Arguments[CurrentPosition]; |
|
|
|
|
|
|
|
CurrentPosition++; |
|
|
|
|
|
|
|
return double.Parse(value, CultureInfo.InvariantCulture); |
|
|
|
} |
|
|
|
|
|
|
|
public Size ReadSize() |
|
|
|
{ |
|
|
|
var width = ReadDouble(); |
|
|
|
|
|
|
|
var height = ReadDouble(); |
|
|
|
|
|
|
|
return new Size(width, height); |
|
|
|
} |
|
|
|
|
|
|
|
public Point ReadPoint() |
|
|
|
{ |
|
|
|
var x = ReadDouble(); |
|
|
|
|
|
|
|
var y = ReadDouble(); |
|
|
|
|
|
|
|
return new Point(x, y); |
|
|
|
} |
|
|
|
|
|
|
|
public Point ReadRelativePoint(Point origin) |
|
|
|
{ |
|
|
|
var x = ReadDouble(); |
|
|
|
|
|
|
|
var y = ReadDouble(); |
|
|
|
|
|
|
|
return new Point(origin.X + x, origin.Y + y); |
|
|
|
} |
|
|
|
|
|
|
|
while ((i = reader.Peek()) != -1) |
|
|
|
private static bool ReadCommand(TextReader reader, ref Command command, ref bool relative) |
|
|
|
{ |
|
|
|
char c = (char)i; |
|
|
|
ReadWhitespace(reader); |
|
|
|
|
|
|
|
if (char.IsWhiteSpace(c)) |
|
|
|
var i = reader.Peek(); |
|
|
|
|
|
|
|
if (i == -1) |
|
|
|
{ |
|
|
|
reader.Read(); |
|
|
|
return false; |
|
|
|
} |
|
|
|
else |
|
|
|
|
|
|
|
var c = (char)i; |
|
|
|
|
|
|
|
if (!s_commands.TryGetValue(char.ToUpperInvariant(c), out var next)) |
|
|
|
{ |
|
|
|
break; |
|
|
|
throw new InvalidDataException("Unexpected path command '" + c + "'."); |
|
|
|
} |
|
|
|
|
|
|
|
command = next; |
|
|
|
|
|
|
|
relative = char.IsLower(c); |
|
|
|
|
|
|
|
reader.Read(); |
|
|
|
|
|
|
|
return true; |
|
|
|
} |
|
|
|
|
|
|
|
private static void ReadWhitespace(TextReader reader) |
|
|
|
{ |
|
|
|
int i; |
|
|
|
|
|
|
|
while ((i = reader.Peek()) != -1) |
|
|
|
{ |
|
|
|
var c = (char)i; |
|
|
|
|
|
|
|
if (char.IsWhiteSpace(c)) |
|
|
|
{ |
|
|
|
reader.Read(); |
|
|
|
} |
|
|
|
else |
|
|
|
{ |
|
|
|
break; |
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
|
|
Benedikt Schroeder
8 years ago