protected static IEnumerable <PathSegment> GetPathSegments(string attributeValue)
{
IList <IPathCommand> stack = null;
var bounds = new XyRect();
var cursor = new PxPoint(0, 0);
var start = new PxPoint(0, 0);
IPathCommand previous = null;
foreach (var command in GetCommands(attributeValue))
{
var c = CreateSegment(cursor, previous, start, command.Key, command.Value);
previous = c;
if (command.Key == 'M' || command.Key == 'm')
{
if (stack != null)
{
//If we get here, we have an existing path that has not been closed.
// We add a dummy closepath
stack.Add(new ClosePathCommand(cursor, start, false));
yield return(new PathSegment(stack, bounds, false));
}
stack = new List <IPathCommand>();
bounds = new XyRect();
start = c.NextPoint;
stack.Add(c);
}
else if (command.Key == 'Z' || command.Key == 'z')
{
if (stack != null)
{
stack.Add(c);
yield return(new PathSegment(stack, bounds, true));
}
stack = null;
bounds = new XyRect();
}
else
{
stack?.Add(c);
}
cursor = c.NextPoint;
bounds.AddPoint(cursor);
}
if (stack != null)
{
//If we get here, we have an existing path that has not been closed.
// We add a dummy closepath
stack.Add(new ClosePathCommand(cursor, start, false));
yield return(new PathSegment(stack, bounds, false));
}
}
public static Geometry GetGeometry(Point start, IList <IPathCommand> commands, bool fill)
{
StreamGeometry geometry = new StreamGeometry();
using (var dc = geometry.Open())
{
dc.BeginFigure(start, fill, false);
Vector startOffset = new Vector(start.X, start.Y);
IPathCommand previous = null;
foreach (IPathCommand command in commands)
{
Draw(dc, command, previous, startOffset);
previous = command;
}
dc.Close();
}
return(geometry);
}
private static PdfPoint GetEndPoint(IPathCommand command)
{
if (command is Line line)
{
return(line.To);
}
else if (command is BezierCurve curve)
{
return(curve.EndPoint);
}
else if (command is Move move)
{
return(move.Location);
}
else
{
throw new ArgumentException();
}
}
internal static PdfPoint GetStartPoint(IPathCommand command)
{
if (command is Line line)
{
return(line.From);
}
else if (command is BezierCurve curve)
{
return(curve.StartPoint);
}
else if (command is Move move)
{
return(move.Location);
}
else
{
throw new ArgumentException();
}
}
/// <summary>
/// Determines if the path is currently closed.
/// </summary>
public bool IsClosed()
{
var filteredCount = 0;
IPathCommand last = null;
IPathCommand first = null;
for (int i = Commands.Count - 1; i >= 0; i--)
{
var cmd = Commands[i];
if (cmd is Close)
{
return(true);
}
if (cmd is Line || cmd is BezierCurve || cmd is Move)
{
if (last == null)
{
last = cmd;
}
first = cmd;
filteredCount++;
}
}
if (filteredCount < 2 || last == null || first == null)
{
return(false);
}
if (!GetStartPoint(first).Equals(GetEndPoint(last)))
{
return(false);
}
return(true);
}
/// <inheritdoc cref="IPathGeometry{TDrawingContext, TPathArgs}.RemoveCommand(IPathCommand{TPathArgs})" />
public void RemoveCommand(IPathCommand <SKPath> segment)
{
_ = _commands.Remove(segment);
_drawingCommands = null;
Invalidate();
}
/// <inheritdoc cref="IPathGeometry{TDrawingContext, TPathArgs}.ContainsCommand(IPathCommand{TPathArgs})" />
public bool ContainsCommand(IPathCommand <SKPath> segment)
{
return(_commands.Contains(segment));
}
/// <inheritdoc cref="IPathGeometry{TDrawingContext, TPathArgs}.AddCommand(IPathCommand{TPathArgs})" />
public void AddCommand(IPathCommand <SKPath> segment)
{
_ = _commands.Add(segment);
_drawingCommands = null;
Invalidate();
}
public void RemoveCommand(IPathCommand <SKPath> segment)
{
commands.Remove(segment);
Invalidate();
}
public void AddCommand(IPathCommand <SKPath> segment)
{
commands.Add(segment);
Invalidate();
}
public bool ContainsCommand(IPathCommand <StreamGeometryContext> segment)
{
return(commands.Contains(segment));
}
public static void Write(this IPathCommand command, System.IO.BinaryWriter writer)
{
switch (command.Type)
{
case CommandType.MoveTo:
{
MoveTo pCommand = command as MoveTo;
writer.Write(pCommand.X);
writer.Write(pCommand.Y);
}
break;
case CommandType.LineTo:
{
LineTo pCommand = command as LineTo;
writer.Write(pCommand.X);
writer.Write(pCommand.Y);
}
break;
case CommandType.CurveTo:
{
CurveTo pCommand = command as CurveTo;
writer.Write(pCommand.ControlStart);
writer.Write(pCommand.ControlEnd);
writer.Write(pCommand.End);
}
break;
case CommandType.SmoothCurveTo:
{
SmoothCurveTo pCommand = command as SmoothCurveTo;
writer.Write(pCommand.ControlEnd);
writer.Write(pCommand.End);
}
break;
case CommandType.EllipticalArcTo:
{
EllipticalArcTo pCommand = command as EllipticalArcTo;
writer.Write(pCommand.Size.Width);
writer.Write(pCommand.Size.Height);
writer.Write(pCommand.End);
writer.Write(pCommand.RotationAngle);
writer.Write(pCommand.IsLargeArc);
writer.Write(pCommand.SweepDirection == SweepDirection.Clockwise);
}
break;
case CommandType.QuadraticBeizerCurveTo:
{
QuadraticBeizerCurveTo pCommand = command as QuadraticBeizerCurveTo;
writer.Write(pCommand.Control);
writer.Write(pCommand.End);
}
break;
case CommandType.SmoothQuadraticBeizerCurveTo:
{
SmoothQuadraticBeizerCurveTo pCommand = command as SmoothQuadraticBeizerCurveTo;
writer.Write(pCommand.End);
}
break;
case CommandType.ClosePath:
{
// Do nothing
}
break;
}
}
public void path(double x, double y, IPathCommand[] path, bool filled)
{
var ptr = _target.NativePointer;
var pathGeometry = new PathGeometry(ptr);
var sink = pathGeometry.Open();
var fromPoint = new DrawingPointF(f(x), f(y));
sink.BeginFigure(fromPoint, FigureBegin.Hollow);
bool newGeometryStarting = false;
foreach (var command in path)
{
if (newGeometryStarting)
{
pathGeometry = new PathGeometry(ptr);
sink = pathGeometry.Open();
sink.BeginFigure(fromPoint, FigureBegin.Hollow);
}
if (command.Command == PathCommand.LineTo)
{
var toPoint = new DrawingPointF(f(command.X), f(command.Y));
sink.AddLine(new DrawingPointF(f(command.X), f(command.Y)));
fromPoint = toPoint;
}
else if (command.Command == PathCommand.CurveTo)
{
var toPoint = new DrawingPointF(f(command.X), f(command.Y));
var firstControlPoint = new DrawingPointF(f(command.XC1), f(command.YC1));
var secondControlPoint = new DrawingPointF(f(command.XC2), f(command.YC2));
sink.AddBezier(new BezierSegment()
{
Point1 = firstControlPoint,
Point2 = secondControlPoint,
Point3 = toPoint
});
fromPoint = toPoint;
}
else if (command.Command == PathCommand.MoveTo)
{
sink.EndFigure(FigureEnd.Open);
fromPoint = new DrawingPointF(f(command.X), f(command.Y));
_target.FillGeometry(pathGeometry, _strokeBrush);
newGeometryStarting = true;
}
else
throw new Exception(string.Format(CultureInfo.InvariantCulture, "Unknown PathCommand: '{0}'", command.Command));
}
sink.EndFigure(FigureEnd.Open);
_target.FillGeometry(pathGeometry, _strokeBrush);
}
private static void Draw(StreamGeometryContext dc, IPathCommand element, IPathCommand previous, Vector startOffset)
{
if (element is LineTo)
{
dc.LineTo(new System.Windows.Point((element as LineTo).X + startOffset.X, (element as LineTo).Y + startOffset.Y), true, true);
}
else if (element is MoveTo)
{
dc.LineTo(new System.Windows.Point((element as MoveTo).X + startOffset.X, (element as MoveTo).Y + startOffset.Y), false, true);
}
else if (element is CurveTo)
{
Point controlStart = Point.Add((element as CurveTo).ControlStart.ToWinPoint(), startOffset);
Point controlEnd = Point.Add((element as CurveTo).ControlEnd.ToWinPoint(), startOffset);
Point end = Point.Add((element as CurveTo).End.ToWinPoint(), startOffset);
dc.BezierTo(controlStart, controlEnd, end, true, true);
}
else if (element is EllipticalArcTo)
{
dc.ArcTo(Point.Add((element as EllipticalArcTo).End.ToWinPoint(), startOffset), (element as EllipticalArcTo).Size.ToWinSize(), (element as EllipticalArcTo).RotationAngle, (element as EllipticalArcTo).IsLargeArc, (element as EllipticalArcTo).SweepDirection == Path.SweepDirection.Clockwise ? System.Windows.Media.SweepDirection.Clockwise : System.Windows.Media.SweepDirection.Counterclockwise, true, true);
}
else if (element is SmoothCurveTo)
{
SmoothCurveTo item = element as SmoothCurveTo;
// If previous command is not S or C, then control points are the same
Point controlStart = item.ControlEnd.ToWinPoint();
// Else reflect ControlEnd of previous command in StartPoint
if (previous is SmoothCurveTo)
{
controlStart = ReflectPointIn((previous as SmoothCurveTo).ControlEnd.ToWinPoint(), (previous as SmoothCurveTo).End.ToWinPoint());
}
else if (previous is CurveTo)
{
controlStart = ReflectPointIn((previous as CurveTo).ControlEnd.ToWinPoint(), (previous as CurveTo).End.ToWinPoint());
}
dc.BezierTo(Point.Add(controlStart, startOffset), Point.Add(item.ControlEnd.ToWinPoint(), startOffset), Point.Add(item.End.ToWinPoint(), startOffset), true, true);
}
else if (element is SmoothQuadraticBeizerCurveTo)
{
SmoothQuadraticBeizerCurveTo item = element as SmoothQuadraticBeizerCurveTo;
if (previous is SmoothQuadraticBeizerCurveTo)
{
throw new NotSupportedException();
}
else if (previous is QuadraticBeizerCurveTo)
{
throw new NotSupportedException();
}
else
{
// If previous command is not Q or T, then draw a line
dc.LineTo(item.End.ToWinPoint(), true, true);
}
}
else if (element is QuadraticBeizerCurveTo)
{
QuadraticBeizerCurveTo item = element as QuadraticBeizerCurveTo;
dc.QuadraticBezierTo(Point.Add(item.Control.ToWinPoint(), startOffset), Point.Add(item.End.ToWinPoint(), startOffset), true, true);
}
}
public static bool RenderFromXml(Stream xmlStream, IRenderContext renderContext, out Size imageSize)
{
XmlDocument doc = new XmlDocument();
doc.Load(xmlStream);
XmlNamespaceManager namespaceManager = new XmlNamespaceManager(doc.NameTable);
namespaceManager.AddNamespace("p", PreviewNamespace);
XmlNode previewNode = doc.SelectSingleNode("/p:preview", namespaceManager);
imageSize = new Size(double.Parse(previewNode.Attributes["width"].InnerText), double.Parse(previewNode.Attributes["height"].InnerText));
XmlNodeList renderNodes = previewNode.ChildNodes;
foreach (XmlNode renderNode in renderNodes)
{
XmlElement renderElement = renderNode as XmlElement;
if (renderElement == null)
{
continue;
}
if (renderElement.Name == "line")
{
Point start = Point.Parse(renderElement.Attributes["start"].InnerText);
Point end = Point.Parse(renderElement.Attributes["end"].InnerText);
double thickness = double.Parse(renderElement.Attributes["thickness"].InnerText);
renderContext.DrawLine(start, end, thickness);
}
else if (renderElement.Name == "rect")
{
Point start = Point.Parse(renderElement.Attributes["start"].InnerText);
Size size = Size.Parse(renderElement.Attributes["size"].InnerText);
double thickness = double.Parse(renderElement.Attributes["thickness"].InnerText);
bool fill = bool.Parse(renderElement.Attributes["fill"].InnerText);
renderContext.DrawRectangle(start, size, thickness, fill);
}
else if (renderElement.Name == "ellipse")
{
Point centre = Point.Parse(renderElement.Attributes["centre"].InnerText);
double radiusx = double.Parse(renderElement.Attributes["rx"].InnerText);
double radiusy = double.Parse(renderElement.Attributes["ry"].InnerText);
double thickness = double.Parse(renderElement.Attributes["thickness"].InnerText);
bool fill = bool.Parse(renderElement.Attributes["fill"].InnerText);
renderContext.DrawEllipse(centre, radiusx, radiusy, thickness, fill);
}
else if (renderElement.Name == "path")
{
Point start = Point.Parse(renderElement.Attributes["start"].InnerText);
double thickness = double.Parse(renderElement.Attributes["thickness"].InnerText);
bool fill = bool.Parse(renderElement.Attributes["fill"].InnerText);
string data = renderElement.InnerText;
List <IPathCommand> pathCommands = new List <IPathCommand>();
using (MemoryStream dataStream = new MemoryStream(Convert.FromBase64String(data)))
{
BinaryReader reader = new BinaryReader(dataStream);
int numCommands = reader.ReadInt32();
for (int l = 0; l < numCommands; l++)
{
CommandType pType = (CommandType)reader.ReadInt32();
IPathCommand theCommand = null;
switch (pType)
{
case CommandType.MoveTo:
theCommand = new MoveTo();
break;
case CommandType.LineTo:
theCommand = new LineTo();
break;
case CommandType.CurveTo:
theCommand = new CurveTo();
break;
case CommandType.EllipticalArcTo:
theCommand = new EllipticalArcTo();
break;
case CommandType.QuadraticBeizerCurveTo:
theCommand = new QuadraticBeizerCurveTo();
break;
case CommandType.SmoothCurveTo:
theCommand = new SmoothCurveTo();
break;
case CommandType.SmoothQuadraticBeizerCurveTo:
theCommand = new SmoothQuadraticBeizerCurveTo();
break;
default:
theCommand = new ClosePath();
break;
}
theCommand.Read(reader);
pathCommands.Add(theCommand);
}
}
renderContext.DrawPath(start, pathCommands, thickness, fill);
}
else if (renderElement.Name == "text")
{
Point anchor = Point.Parse(renderElement.Attributes["anchor"].InnerText);
TextAlignment alignment = (TextAlignment)Enum.Parse(typeof(TextAlignment), renderElement.Attributes["alignment"].InnerText);
List <TextRun> runs = new List <TextRun>();
foreach (XmlNode runNode in renderElement.ChildNodes)
{
if (runNode.Name != "run")
{
continue;
}
double size = double.Parse(runNode.Attributes["size"].InnerText);
TextRunFormattingType formattingType = (TextRunFormattingType)Enum.Parse(typeof(TextRunFormattingType), runNode.Attributes["formatting"].InnerText);
string text = runNode.InnerText;
runs.Add(new TextRun(text, new TextRunFormatting(formattingType, size)));
}
renderContext.DrawText(anchor, alignment, runs);
}
}
return(true);
}
public void RemoveCommand(IPathCommand <StreamGeometryContext> segment)
{
commands.Remove(segment);
Invalidate();
}
internal override void Read(System.IO.BinaryReader reader, BinaryReadInfo readInfo)
{
uint length = reader.ReadUInt32();
ID = reader.ReadUInt32();
uint numSections = reader.ReadUInt32();
string componentName = null;
bool canResize = false;
bool canFlip = false;
double minSize = ComponentHelper.GridSize;
List <ComponentProperty> properties = new List <ComponentProperty>();
List <ConnectionGroup> connections = new List <ConnectionGroup>();
List <RenderDescription> renderDescriptions = new List <RenderDescription>();
List <Conditional <FlagOptions> > flagOptions = new List <Conditional <FlagOptions> >();
ComponentDescriptionMetadata descriptionMetadata = new ComponentDescriptionMetadata();
uint?iconResourceId = null;
for (uint sectionCounter = 0; sectionCounter < numSections; sectionCounter++)
{
ushort sectionType = reader.ReadUInt16();
uint sectionLength = reader.ReadUInt32();
#region Metadata
if (sectionType == (uint)BinaryConstants.ComponentSectionType.Metadata)
{
componentName = reader.ReadString();
canResize = reader.ReadBoolean();
canFlip = reader.ReadBoolean();
minSize = reader.ReadDouble();
descriptionMetadata.Type = String.Format("Binary r{0} (*.cdcom)", readInfo.FormatVersion);
descriptionMetadata.GUID = new Guid(reader.ReadBytes(16));
descriptionMetadata.Author = reader.ReadString();
if (readInfo.IsSignatureValid && readInfo.Certificate != null && readInfo.IsCertificateTrusted)
{
descriptionMetadata.Author = readInfo.Certificate.GetNameInfo(X509NameType.EmailName, false);
}
descriptionMetadata.Version = new Version(reader.ReadUInt16(), reader.ReadUInt16());
descriptionMetadata.AdditionalInformation = reader.ReadString();
descriptionMetadata.ImplementSet = reader.ReadString();
descriptionMetadata.ImplementItem = reader.ReadString();
descriptionMetadata.Signature.IsHashValid = readInfo.IsSignatureValid;
descriptionMetadata.Signature.Certificate = readInfo.Certificate;
descriptionMetadata.Signature.IsCertificateTrusted = readInfo.IsCertificateTrusted;
int iconResource = reader.ReadInt32();
if (iconResource != -1)
{
iconResourceId = (uint)iconResource;
}
long created = reader.ReadInt64();
}
#endregion
#region Flags
else if (sectionType == (uint)BinaryConstants.ComponentSectionType.Flags)
{
uint numFlagGroups = reader.ReadUInt32();
for (uint j = 0; j < numFlagGroups; j++)
{
IConditionTreeItem conditions;
if (readInfo.FormatVersion > 1)
{
conditions = reader.ReadConditionTree();
}
else
{
conditions = reader.ReadConditionCollection();
}
FlagOptions value = (FlagOptions)reader.ReadUInt32();
flagOptions.Add(new Conditional <FlagOptions>(value, conditions));
}
}
#endregion
#region Properties
else if (sectionType == (uint)BinaryConstants.ComponentSectionType.Properties)
{
uint numProperties = reader.ReadUInt32();
for (uint j = 0; j < numProperties; j++)
{
string propertyName = reader.ReadString();
string serializedName = reader.ReadString();
string displayName = reader.ReadString();
BinaryType propType;
object rawDefaultValue = reader.ReadType(out propType);
PropertyUnion defaultValue = propType.ToPropertyUnion(rawDefaultValue);
string[] enumOptions = null;
if (propType == BinaryType.Enum)
{
enumOptions = new string[reader.ReadInt32()];
for (int k = 0; k < enumOptions.Length; k++)
{
enumOptions[k] = reader.ReadString();
}
}
// Format rules
List <ComponentPropertyFormat> formatRules = new List <ComponentPropertyFormat>();
uint numFormatRules = reader.ReadUInt32();
for (uint k = 0; k < numFormatRules; k++)
{
IConditionTreeItem conditions;
if (readInfo.FormatVersion > 1)
{
conditions = reader.ReadConditionTree();
}
else
{
conditions = reader.ReadConditionCollection();
}
string formatRule = reader.ReadString();
formatRules.Add(new ComponentPropertyFormat(formatRule, conditions));
}
// Other conditions
uint numOtherConditions = reader.ReadUInt32();
Dictionary <PropertyOtherConditionType, IConditionTreeItem> otherConditions = new Dictionary <PropertyOtherConditionType, IConditionTreeItem>((int)numOtherConditions);
for (uint k = 0; k < numOtherConditions; k++)
{
uint uintConditionType = reader.ReadUInt32();
IConditionTreeItem conditions;
if (readInfo.FormatVersion > 1)
{
conditions = reader.ReadConditionTree();
}
else
{
conditions = reader.ReadConditionCollection();
}
PropertyOtherConditionType conditionType = (PropertyOtherConditionType)uintConditionType;
otherConditions.Add(conditionType, conditions);
}
properties.Add(new ComponentProperty(propertyName, serializedName, displayName, BinaryIOExtentions.BinaryTypeToPropertyType(propType), defaultValue, formatRules.ToArray(), otherConditions, enumOptions));
}
}
#endregion
#region Configurations
else if (sectionType == (uint)BinaryConstants.ComponentSectionType.Configurations)
{
uint numConfigurations = reader.ReadUInt32();
for (int j = 0; j < numConfigurations; j++)
{
string configurationName = reader.ReadString();
string implementationName = reader.ReadString();
int numSetters = reader.ReadInt32();
var setters = new Dictionary <string, PropertyUnion>(numSetters);
for (int k = 0; k < numSetters; k++)
{
BinaryType tempType;
string name = reader.ReadString();
var setterValue = reader.ReadType(out tempType);
setters.Add(name, tempType.ToPropertyUnion(setterValue));
}
int iconID = reader.ReadInt32();
var configuration = new ComponentConfiguration(implementationName, configurationName, setters);
descriptionMetadata.Configurations.Add(configuration);
if (iconID != -1)
{
iconResources.Add(configuration, (uint)iconID);
}
}
}
#endregion
#region Connections
else if (sectionType == (uint)BinaryConstants.ComponentSectionType.Connections)
{
uint numConnectionGroups = reader.ReadUInt32();
List <ConnectionGroup> connectionGroups = new List <ConnectionGroup>();
for (int j = 0; j < numConnectionGroups; j++)
{
IConditionTreeItem conditions;
if (readInfo.FormatVersion > 1)
{
conditions = reader.ReadConditionTree();
}
else
{
conditions = reader.ReadConditionCollection();
}
List <ConnectionDescription> tConnections = new List <ConnectionDescription>();
uint numConnections = reader.ReadUInt32();
for (uint k = 0; k < numConnections; k++)
{
tConnections.Add(new ConnectionDescription(reader.ReadComponentPoint(), reader.ReadComponentPoint(), (ConnectionEdge)reader.ReadInt32(), reader.ReadString()));
}
connections.Add(new ConnectionGroup(conditions, tConnections.ToArray()));
}
}
#endregion
#region Render
else if (sectionType == (uint)BinaryConstants.ComponentSectionType.Render)
{
uint numRenderGroups = reader.ReadUInt32();
for (uint j = 0; j < numRenderGroups; j++)
{
IConditionTreeItem conditions;
if (readInfo.FormatVersion > 1)
{
conditions = reader.ReadConditionTree();
}
else
{
conditions = reader.ReadConditionCollection();
}
int numRenderCommands = (int)reader.ReadUInt32();
List <IRenderCommand> renderCommands = new List <IRenderCommand>(numRenderCommands);
for (int k = 0; k < numRenderCommands; k++)
{
RenderCommandType commandType = (RenderCommandType)reader.ReadUInt32();
switch (commandType)
{
case RenderCommandType.Line:
{
ComponentPoint start = reader.ReadComponentPoint();
ComponentPoint end = reader.ReadComponentPoint();
double thickness = reader.ReadDouble();
renderCommands.Add(new Line(start, end, thickness));
}
continue;
case RenderCommandType.Rect:
{
ComponentPoint location = reader.ReadComponentPoint();
double width = reader.ReadDouble();
double height = reader.ReadDouble();
double thickness = reader.ReadDouble();
bool fill = (reader.ReadUInt32() == 0 ? false : true);
renderCommands.Add(new Rectangle(location, width, height, thickness, fill));
}
continue;
case RenderCommandType.Ellipse:
{
ComponentPoint centre = reader.ReadComponentPoint();
double radiusX = reader.ReadDouble();
double radiusY = reader.ReadDouble();
double thickness = reader.ReadDouble();
bool fill = (reader.ReadUInt32() == 0 ? false : true);
renderCommands.Add(new Ellipse(centre, radiusX, radiusY, thickness, fill));
}
continue;
case RenderCommandType.Path:
{
ComponentPoint start = reader.ReadComponentPoint();
double thickness = reader.ReadDouble();
bool fill = (reader.ReadUInt32() == 0 ? false : true);
int numCommands = reader.ReadInt32();
List <IPathCommand> pathCommands = new List <IPathCommand>(numCommands);
for (int l = 0; l < numCommands; l++)
{
CommandType pType = (CommandType)reader.ReadInt32();
IPathCommand theCommand = null;
switch (pType)
{
case CommandType.MoveTo:
theCommand = new MoveTo();
break;
case CommandType.LineTo:
theCommand = new LineTo();
break;
case CommandType.CurveTo:
theCommand = new CurveTo();
break;
case CommandType.EllipticalArcTo:
theCommand = new EllipticalArcTo();
break;
case CommandType.QuadraticBeizerCurveTo:
theCommand = new QuadraticBeizerCurveTo();
break;
case CommandType.SmoothCurveTo:
theCommand = new SmoothCurveTo();
break;
case CommandType.SmoothQuadraticBeizerCurveTo:
theCommand = new SmoothQuadraticBeizerCurveTo();
break;
default:
theCommand = new ClosePath();
break;
}
theCommand.Read(reader);
pathCommands.Add(theCommand);
}
renderCommands.Add(new RenderPath(start, thickness, fill, pathCommands));
}
continue;
case RenderCommandType.Text:
{
byte formattedTextVersion = reader.ReadByte();
ComponentPoint location = reader.ReadComponentPoint();
TextAlignment alignment = (TextAlignment)reader.ReadUInt32();
uint numTextRuns = reader.ReadUInt32();
List <TextRun> textRuns = new List <TextRun>((int)numTextRuns);
for (uint l = 0; l < numTextRuns; l++)
{
TextRunFormattingType formattingType = (TextRunFormattingType)reader.ReadUInt32();
double runSize = reader.ReadDouble();
string runText = reader.ReadString();
textRuns.Add(new TextRun(runText, new TextRunFormatting(formattingType, runSize)));
}
renderCommands.Add(new Text(location, alignment, textRuns));
}
continue;
}
}
renderDescriptions.Add(new RenderDescription(conditions, renderCommands.ToArray()));
}
}
#endregion
#region Skip
else
{
// Unknown type - skip
reader.BaseStream.Seek(sectionLength, SeekOrigin.Current);
}
#endregion
}
ComponentDescription = new ComponentDescription(ID.ToString(), componentName, canResize, canFlip, minSize, properties.ToArray(), connections.ToArray(), renderDescriptions.ToArray(), flagOptions.ToArray(), descriptionMetadata);
if (iconResourceId.HasValue)
{
mainIconResource = iconResourceId.Value;
}
}
public static bool RenderFromXml(Stream xmlStream, IDrawingContext drawingContext, out Size imageSize)
{
var doc = XDocument.Load(xmlStream);
var previewNode = doc.Elements().First(x => x.Name == PreviewNamespace + "preview");
imageSize = new Size(double.Parse(previewNode.Attribute("width").Value),
double.Parse(previewNode.Attribute("height").Value));
var renderElements = previewNode.Elements();
foreach (var renderElement in renderElements)
{
if (renderElement.Name == "line")
{
Point start = Point.Parse(renderElement.Attribute("start").Value);
Point end = Point.Parse(renderElement.Attribute("end").Value);
double thickness = double.Parse(renderElement.Attribute("thickness").Value);
drawingContext.DrawLine(start, end, thickness);
}
else if (renderElement.Name == "rect")
{
Point start = Point.Parse(renderElement.Attribute("start").Value);
Size size = Size.Parse(renderElement.Attribute("size").Value);
double thickness = double.Parse(renderElement.Attribute("thickness").Value);
bool fill = bool.Parse(renderElement.Attribute("fill").Value);
drawingContext.DrawRectangle(start, size, thickness, fill);
}
else if (renderElement.Name == "ellipse")
{
Point centre = Point.Parse(renderElement.Attribute("centre").Value);
double radiusx = double.Parse(renderElement.Attribute("rx").Value);
double radiusy = double.Parse(renderElement.Attribute("ry").Value);
double thickness = double.Parse(renderElement.Attribute("thickness").Value);
bool fill = bool.Parse(renderElement.Attribute("fill").Value);
drawingContext.DrawEllipse(centre, radiusx, radiusy, thickness, fill);
}
else if (renderElement.Name == "path")
{
Point start = Point.Parse(renderElement.Attribute("start").Value);
double thickness = double.Parse(renderElement.Attribute("thickness").Value);
bool fill = bool.Parse(renderElement.Attribute("fill").Value);
string data = renderElement.Value;
List <IPathCommand> pathCommands = new List <IPathCommand>();
using (MemoryStream dataStream = new MemoryStream(Convert.FromBase64String(data)))
{
BinaryReader reader = new BinaryReader(dataStream);
int numCommands = reader.ReadInt32();
for (int l = 0; l < numCommands; l++)
{
CommandType pType = (CommandType)reader.ReadInt32();
IPathCommand theCommand = null;
switch (pType)
{
case CommandType.MoveTo:
theCommand = new MoveTo();
break;
case CommandType.LineTo:
theCommand = new LineTo();
break;
case CommandType.CurveTo:
theCommand = new CurveTo();
break;
case CommandType.EllipticalArcTo:
theCommand = new EllipticalArcTo();
break;
case CommandType.QuadraticBeizerCurveTo:
theCommand = new QuadraticBeizerCurveTo();
break;
case CommandType.SmoothCurveTo:
theCommand = new SmoothCurveTo();
break;
case CommandType.SmoothQuadraticBeizerCurveTo:
theCommand = new SmoothQuadraticBeizerCurveTo();
break;
default:
theCommand = new ClosePath();
break;
}
theCommand.Read(reader);
pathCommands.Add(theCommand);
}
}
drawingContext.DrawPath(start, pathCommands, thickness, fill);
}
else if (renderElement.Name == "text")
{
Point anchor = Point.Parse(renderElement.Attribute("anchor").Value);
TextAlignment alignment = (TextAlignment)Enum.Parse(typeof(TextAlignment), renderElement.Attribute("alignment").Value);
List <TextRun> runs = new List <TextRun>();
foreach (var runNode in renderElement.Elements())
{
if (runNode.Name != "run")
{
continue;
}
double size = double.Parse(runNode.Attribute("size").Value);
TextRunFormattingType formattingType = (TextRunFormattingType)Enum.Parse(typeof(TextRunFormattingType), runNode.Attribute("formatting").Value);
string text = runNode.Value;
runs.Add(new TextRun(text, new TextRunFormatting(formattingType, size)));
}
drawingContext.DrawText(anchor, alignment, runs);
}
}
return(true);
}
public static void Read(this IPathCommand command, System.IO.BinaryReader reader)
{
switch (command.Type)
{
case CommandType.MoveTo:
{
MoveTo pCommand = command as MoveTo;
pCommand.X = reader.ReadDouble();
pCommand.Y = reader.ReadDouble();
}
break;
case CommandType.LineTo:
{
LineTo pCommand = command as LineTo;
pCommand.X = reader.ReadDouble();
pCommand.Y = reader.ReadDouble();
}
break;
case CommandType.CurveTo:
{
CurveTo pCommand = command as CurveTo;
pCommand.ControlStart = reader.ReadPoint();
pCommand.ControlEnd = reader.ReadPoint();
pCommand.End = reader.ReadPoint();
}
break;
case CommandType.SmoothCurveTo:
{
SmoothCurveTo pCommand = command as SmoothCurveTo;
pCommand.ControlEnd = reader.ReadPoint();
pCommand.End = reader.ReadPoint();
}
break;
case CommandType.EllipticalArcTo:
{
EllipticalArcTo pCommand = command as EllipticalArcTo;
pCommand.Size = new System.Windows.Size(reader.ReadDouble(), reader.ReadDouble());
pCommand.End = reader.ReadPoint();
pCommand.RotationAngle = reader.ReadDouble();
pCommand.IsLargeArc = reader.ReadBoolean();
pCommand.SweepDirection = (reader.ReadBoolean() == false ? SweepDirection.Counterclockwise : SweepDirection.Clockwise);
}
break;
case CommandType.QuadraticBeizerCurveTo:
{
QuadraticBeizerCurveTo pCommand = command as QuadraticBeizerCurveTo;
pCommand.Control = reader.ReadPoint();
pCommand.End = reader.ReadPoint();
}
break;
case CommandType.SmoothQuadraticBeizerCurveTo:
{
SmoothQuadraticBeizerCurveTo pCommand = command as SmoothQuadraticBeizerCurveTo;
pCommand.End = reader.ReadPoint();
}
break;
case CommandType.ClosePath:
{
// Do nothing
}
break;
}
}
public void AddCommand(IPathCommand <StreamGeometryContext> segment)
{
commands.Add(segment);
Invalidate();
}
private static IPathCommand CreateSegment(PxPoint cursor, IPathCommand previous, PxPoint start, char command, IList <float> args)
{
switch (command)
{
case 'm': // relative moveto
return(new MovePathCommand(cursor, args.ToPoint(0, cursor)));
case 'M': // moveto
return(new MovePathCommand(cursor, args.ToPoint(0)));
case 'l': // relative lineto
return(new LinePathCommand(cursor, args.ToPoint(0, cursor)));
case 'L': // lineto
return(new LinePathCommand(cursor, args.ToPoint(0)));
case 'h': // relative horizontal lineto
return(new LinePathCommand(cursor, new PxPoint(args[0], 0).Add(cursor)));
case 'H': // horizontal lineto
return(new LinePathCommand(cursor, new PxPoint(args[0], cursor.Y)));
case 'v': // relative vertical lineto
return(new LinePathCommand(cursor, new PxPoint(0, args[0]).Add(cursor)));
case 'V': // vertical lineto
return(new LinePathCommand(cursor, new PxPoint(cursor.X, args[0])));
case 'q': // relative curveto
return(new QuadraticPathCommand(cursor, args.ToPoint(0, cursor), args.ToPoint(2, cursor)));
case 'Q': // curveto
return(new QuadraticPathCommand(cursor, args.ToPoint(0), args.ToPoint(2)));
case 't': // relative shorthand/smooth curveto
return(new QuadraticPathCommand(cursor, previous.ShortPoint, args.ToPoint(0, cursor)));
case 'T': // shorthand/smooth curveto
return(new QuadraticPathCommand(cursor, previous.ShortPoint, args.ToPoint(0)));
case 'c': // relative curveto
return(new CubicCurveCommand(cursor, args.ToPoint(0, cursor), args.ToPoint(2, cursor), args.ToPoint(4, cursor)));
case 'C': // curveto
return(new CubicCurveCommand(cursor, args.ToPoint(0), args.ToPoint(2), args.ToPoint(4)));
case 's': // relative shorthand/smooth curveto
return(new CubicCurveCommand(cursor, previous.ShortPoint, args.ToPoint(0, cursor), args.ToPoint(2, cursor)));
case 'S': // shorthand/smooth curveto
return(new CubicCurveCommand(cursor, previous.ShortPoint, args.ToPoint(0), args.ToPoint(2)));
case 'Z': // closepath
case 'z': // relative closepath
return(new ClosePathCommand(cursor, start, true));
case 'a':
return(new ArcPathCommand(
cursor,
args[0],
args[1],
args[2],
Math.Abs(args[3]) > float.Epsilon,
Math.Abs(args[4]) > float.Epsilon,
args.ToPoint(5, cursor)
));
case 'A':
return(new ArcPathCommand(cursor, args[0], args[1], args[2], Math.Abs(args[3]) > float.Epsilon,
Math.Abs(args[4]) > float.Epsilon, args.ToPoint(5)));
default:
throw new Exception();
}
}
private void ExecuteCommand(IPathCommand command)
{
command.Execute(_commands);
}
