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); }