public void Visit(ISvgPathElement element)
{
SvgPathElement pe = element as SvgPathElement;
if (pe == null || string.IsNullOrEmpty(pe.PathScript))
{
return;
}
var geometry = new PathGeometry();
FillRule fillRule;
if (TryGetFillRule(pe, out fillRule))
{
geometry.FillRule = fillRule;
}
try
{
geometry.Figures = PathFigureCollection.Parse(pe.PathScript);
}
catch
{
return;
}
var shape = WrapGeometry(geometry, element);
DisplayShape(shape, element);
}
public Geometry CreateGeometryEx(SvgPathElement element)
{
PathGeometry geometry = new PathGeometry();
string pathScript = element.PathScript;
if (string.IsNullOrWhiteSpace(pathScript))
{
return(geometry);
}
var comparer = StringComparison.OrdinalIgnoreCase;
string fillRule = element.GetPropertyValue("fill-rule");
string clipRule = element.GetAttribute("clip-rule");
if (!string.IsNullOrWhiteSpace(clipRule) && string.Equals(clipRule, "evenodd", comparer) ||
string.Equals(clipRule, CssConstants.ValNonzero, comparer))
{
fillRule = clipRule;
}
if (string.Equals(fillRule, "evenodd", comparer))
{
geometry.FillRule = FillRule.EvenOdd;
}
else if (string.Equals(fillRule, CssConstants.ValNonzero, comparer))
{
geometry.FillRule = FillRule.Nonzero;
}
try
{
geometry.Figures = PathFigureCollection.Parse(pathScript);
if (_flattenClosedPath && element.IsClosed &&
geometry.MayHaveCurves() == element.MayHaveCurves)
{
int closedCount = 0;
foreach (var figure in geometry.Figures)
{
if (figure.IsClosed)
{
closedCount++;
}
}
if (geometry.Figures.Count == closedCount)
{
return(geometry.GetFlattenedPathGeometry(_flattenTolerance, _flattenToleranceType));
}
}
return(geometry);
}
catch (FormatException ex)
{
Trace.TraceError(ex.GetType().Name + ": " + ex.Message);
//return null;
return(CreateGeometry(element));
}
}
public Geometry CreateGeometryEx(SvgPathElement element)
{
PathGeometry geometry = new PathGeometry();
string pathScript = element.PathScript;
if (string.IsNullOrWhiteSpace(pathScript))
{
return(geometry);
}
string fillRule = element.GetPropertyValue("fill-rule");
string clipRule = element.GetAttribute("clip-rule");
if (!string.IsNullOrWhiteSpace(clipRule) &&
string.Equals(clipRule, "evenodd") || string.Equals(clipRule, "nonzero"))
{
fillRule = clipRule;
}
if (fillRule == "evenodd")
{
geometry.FillRule = FillRule.EvenOdd;
}
else if (fillRule == "nonzero")
{
geometry.FillRule = FillRule.Nonzero;
}
try
{
geometry.Figures = PathFigureCollection.Parse(pathScript);
if (_flattenClosedPath && element.IsClosed &&
geometry.MayHaveCurves() == element.MayHaveCurves)
{
int closedCount = 0;
foreach (var figure in geometry.Figures)
{
if (figure.IsClosed)
{
closedCount++;
}
}
if (geometry.Figures.Count == closedCount)
{
return(geometry.GetFlattenedPathGeometry(_flattenTolerance, _flattenToleranceType));
}
}
return(geometry);
}
catch
{
return(CreateGeometry(element));
}
}
internal void Build(Wheel wheel, SvgSvgElement root)
{
SvgGroupElement helperLinesGroup = new SvgGroupElement("HelperLines");
helperLinesGroup.Style = Styles.HelperLineStyle;
root.AddChild(helperLinesGroup);
// Wheel pitch circle
helperLinesGroup.AddChild(SvgHelper.CreateCircle(wheel.Center, wheel.PitchDiameter / 2.0));
// Wheel addendum circle
helperLinesGroup.AddChild(SvgHelper.CreateCircle(wheel.Center, wheel.PitchDiameter / 2.0 + wheel.Addendum));
// Wheel dedendum circle
helperLinesGroup.AddChild(SvgHelper.CreateCircle(wheel.Center, wheel.PitchDiameter / 2.0 - wheel.Dedendum));
// wheel center
double halfCrossLength = 10;
helperLinesGroup.AddChild(new SvgLineElement(wheel.Center.X - halfCrossLength, wheel.Center.Y, wheel.Center.X + halfCrossLength, wheel.Center.Y));
helperLinesGroup.AddChild(new SvgLineElement(wheel.Center.X, wheel.Center.Y - halfCrossLength, wheel.Center.X, wheel.Center.Y + halfCrossLength));
SvgGroupElement mainGroup = new SvgGroupElement("Main");
mainGroup.Style = Styles.MinorLineStyle;
root.AddChild(mainGroup);
WheelTooth[] teeth = wheel.GetTeeth(0);
StringBuilder pathBuilder = new StringBuilder();
pathBuilder.AppendFormat(CultureInfo.InvariantCulture, "M{0},{1}", (float)teeth[0].DedendumIntersectLeft.X, (float)teeth[0].DedendumIntersectLeft.Y);
for (int i = 0; i < teeth.Length; i++)
{
WheelTooth tooth = teeth[i];
WheelTooth nextTooth = teeth[(i + 1) % teeth.Length];
InsertWheelToothPath(wheel, tooth, nextTooth, pathBuilder);
}
pathBuilder.Append(" z");
SvgPath svgPath = new SvgPath(pathBuilder.ToString());
SvgPathElement svgPathElement = new SvgPathElement();
svgPathElement.D = svgPath;
mainGroup.AddChild(svgPathElement);
if (wheel.CenterHoleDiameter > 0)
{
mainGroup.AddChild(SvgHelper.CreateCircle(wheel.Center, wheel.CenterHoleDiameter / 2.0));
}
}
private void AddSlice(SvgGroupElement group, double radius, double angle, double angularWidth)
{
PointF firstPointOnCircle = GetPointOnCircle(radius, angle - angularWidth / 2.0);
PointF secondPointOnCircle = GetPointOnCircle(radius, angle + angularWidth / 2.0);
// for an explanation of the arc syntax see: http://www.codestore.net/store.nsf/unid/EPSD-5DTT4L
string path = String.Format(
CultureInfo.InvariantCulture,
"M0,0 L{0},{1} A{2},{2} 0 0,1 {3},{4} z",
firstPointOnCircle.X, firstPointOnCircle.Y, (float)radius, secondPointOnCircle.X, secondPointOnCircle.Y);
SvgPath svgPath = new SvgPath(path);
SvgPathElement svgPathElement = new SvgPathElement();
svgPathElement.D = svgPath;
group.AddChild(svgPathElement);
}
public override SvgPathSegList VisitPathElement(SvgPathElement element) => element.Segments;
public virtual void VisitPathElement(SvgPathElement element) => DefaultVisit(element);
public Geometry CreateGeometry(SvgPathElement element)
{
PathGeometry geometry = new PathGeometry();
var comparer = StringComparison.OrdinalIgnoreCase;
string fillRule = element.GetPropertyValue("fill-rule");
string clipRule = element.GetAttribute("clip-rule");
if (!string.IsNullOrWhiteSpace(clipRule) && string.Equals(clipRule, "evenodd", comparer) ||
string.Equals(clipRule, CssConstants.ValNonzero, comparer))
{
fillRule = clipRule;
}
if (string.Equals(fillRule, "evenodd", comparer))
{
geometry.FillRule = FillRule.EvenOdd;
}
else if (string.Equals(fillRule, CssConstants.ValNonzero, comparer))
{
geometry.FillRule = FillRule.Nonzero;
}
SvgPointF initPoint = new SvgPointF(0, 0);
SvgPointF lastPoint = new SvgPointF(0, 0);
SvgPointF ptXY = new SvgPointF(0, 0);
SvgPathSeg segment = null;
SvgPathSegMoveto pathMoveTo = null;
SvgPathSegLineto pathLineTo = null;
SvgPathSegCurveto pathCurveTo = null;
SvgPathSegArc pathArc = null;
SvgPathSegList segments = element.PathSegList;
int numSegs = segments.NumberOfItems;
if (numSegs == 0)
{
return(geometry);
}
PathFigure pathFigure = null;
for (int i = 0; i < numSegs; i++)
{
segment = segments.GetItem(i);
switch (segment.PathType)
{
case SvgPathType.MoveTo: //if (DynamicCast.Cast(segment, out pathMoveTo))
pathMoveTo = (SvgPathSegMoveto)segment;
if (pathFigure != null)
{
pathFigure.IsClosed = false;
pathFigure.IsFilled = true;
geometry.Figures.Add(pathFigure);
pathFigure = null;
}
lastPoint = initPoint = pathMoveTo.AbsXY;
pathFigure = new PathFigure();
pathFigure.StartPoint = new Point(initPoint.ValueX, initPoint.ValueY);
break;
case SvgPathType.LineTo: //else if (DynamicCast.Cast(segment, out pathLineTo))
pathLineTo = (SvgPathSegLineto)segment;
ptXY = pathLineTo.AbsXY;
pathFigure.Segments.Add(new LineSegment(new Point(ptXY.ValueX, ptXY.ValueY), true));
lastPoint = ptXY;
break;
case SvgPathType.CurveTo: //else if (DynamicCast.Cast(segment, out pathCurveTo))
pathCurveTo = (SvgPathSegCurveto)segment;
SvgPointF xy = pathCurveTo.AbsXY;
SvgPointF x1y1 = pathCurveTo.CubicX1Y1;
SvgPointF x2y2 = pathCurveTo.CubicX2Y2;
pathFigure.Segments.Add(new BezierSegment(new Point(x1y1.ValueX, x1y1.ValueY),
new Point(x2y2.ValueX, x2y2.ValueY), new Point(xy.ValueX, xy.ValueY), true));
lastPoint = xy;
break;
case SvgPathType.ArcTo: //else if (DynamicCast.Cast(segment, out pathArc))
pathArc = (SvgPathSegArc)segment;
ptXY = pathArc.AbsXY;
if (lastPoint.Equals(ptXY))
{
// If the endpoints (x, y) and (x0, y0) are identical, then this
// is equivalent to omitting the elliptical arc segment entirely.
}
else if (pathArc.R1.Equals(0) || pathArc.R2.Equals(0))
{
// Ensure radii are valid
pathFigure.Segments.Add(new LineSegment(new Point(ptXY.ValueX, ptXY.ValueY), true));
}
else
{
CalculatedArcValues calcValues = pathArc.GetCalculatedArcValues();
pathFigure.Segments.Add(new ArcSegment(new Point(ptXY.ValueX, ptXY.ValueY),
new Size(pathArc.R1, pathArc.R2), pathArc.Angle, pathArc.LargeArcFlag,
pathArc.SweepFlag ? SweepDirection.Clockwise : SweepDirection.Counterclockwise,
true));
}
lastPoint = ptXY;
break;
case SvgPathType.Close: //else if (segment is SvgPathSegClosePath)
if (pathFigure != null)
{
pathFigure.IsClosed = true;
pathFigure.IsFilled = true;
geometry.Figures.Add(pathFigure);
pathFigure = null;
}
lastPoint = initPoint;
break;
}
}
if (pathFigure != null)
{
pathFigure.IsClosed = false;
pathFigure.IsFilled = true;
geometry.Figures.Add(pathFigure);
}
return(geometry);
}
public static GraphicsPath CreatePath(SvgPathElement element)
{
GraphicsPath gp = new GraphicsPath();
SvgPointF initPoint = new SvgPointF(0, 0);
SvgPointF lastPoint = new SvgPointF(0, 0);
SvgPointF ptXY = new SvgPointF(0, 0);
SvgPathSeg segment = null;
SvgPathSegMoveto pathMoveTo = null;
SvgPathSegLineto pathLineTo = null;
SvgPathSegCurveto pathCurveTo = null;
SvgPathSegArc pathArc = null;
SvgPathSegList segments = element.PathSegList;
int nElems = segments.NumberOfItems;
for (int i = 0; i < nElems; i++)
{
segment = segments.GetItem(i);
switch (segment.PathType)
{
case SvgPathType.MoveTo: //if (DynamicCast.Cast(segment, out pathMoveTo))
pathMoveTo = (SvgPathSegMoveto)segment;
gp.StartFigure();
lastPoint = initPoint = pathMoveTo.AbsXY;
break;
case SvgPathType.LineTo: //else if (DynamicCast.Cast(segment, out pathLineTo))
pathLineTo = (SvgPathSegLineto)segment;
ptXY = pathLineTo.AbsXY;
gp.AddLine(lastPoint.X, lastPoint.Y, ptXY.X, ptXY.Y);
lastPoint = ptXY;
break;
case SvgPathType.CurveTo: //else if (DynamicCast.Cast(segment, out pathCurveTo))
pathCurveTo = (SvgPathSegCurveto)segment;
SvgPointF xy = pathCurveTo.AbsXY;
SvgPointF x1y1 = pathCurveTo.CubicX1Y1;
SvgPointF x2y2 = pathCurveTo.CubicX2Y2;
gp.AddBezier(lastPoint.X, lastPoint.Y, x1y1.X, x1y1.Y, x2y2.X, x2y2.Y, xy.X, xy.Y);
lastPoint = xy;
break;
case SvgPathType.ArcTo: //else if (DynamicCast.Cast(segment, out pathArc))
pathArc = (SvgPathSegArc)segment;
ptXY = pathArc.AbsXY;
if (lastPoint.Equals(ptXY))
{
// If the endpoints (x, y) and (x0, y0) are identical, then this
// is equivalent to omitting the elliptical arc segment entirely.
}
else if (pathArc.R1.Equals(0) || pathArc.R2.Equals(0))
{
// Ensure radii are valid
gp.AddLine(lastPoint.X, lastPoint.Y, ptXY.X, ptXY.Y);
}
else
{
CalculatedArcValues calcValues = pathArc.GetCalculatedArcValues();
GraphicsPath subPath = new GraphicsPath();
subPath.StartFigure();
subPath.AddArc((float)(calcValues.Cx - calcValues.CorrRx),
(float)(calcValues.Cy - calcValues.CorrRy),
(float)calcValues.CorrRx * 2, (float)calcValues.CorrRy * 2,
(float)calcValues.AngleStart, (float)calcValues.AngleExtent);
Matrix matrix = new Matrix();
matrix.Translate(-(float)calcValues.Cx, -(float)calcValues.Cy);
subPath.Transform(matrix);
matrix = new Matrix();
matrix.Rotate((float)pathArc.Angle);
subPath.Transform(matrix);
matrix = new Matrix();
matrix.Translate((float)calcValues.Cx, (float)calcValues.Cy);
subPath.Transform(matrix);
gp.AddPath(subPath, true);
}
lastPoint = ptXY;
break;
case SvgPathType.Close: //else if (segment is SvgPathSegClosePath)
gp.CloseFigure();
lastPoint = initPoint;
break;
}
}
string fillRule = element.GetPropertyValue("fill-rule");
if (fillRule == "evenodd")
{
gp.FillMode = FillMode.Alternate;
}
else
{
gp.FillMode = FillMode.Winding;
}
return(gp);
}
private CanvasGeometry CreatePath(CanvasDrawingSession session, SvgPathElement element)
{
if (this.PathCache.ContainsKey(element))
{
return(this.PathCache[element]);
}
var open = false;
var v = new Vector2 {
X = 0.0F, Y = 0.0F
};
CanvasGeometry geometry;
using (var builder = new CanvasPathBuilder(this.ResourceCreator))
{
var fillRule = element.Style.FillRule;
if (fillRule.HasValue && fillRule.Value.Value != SvgFillRuleType.EvenOdd)
{
builder.SetFilledRegionDetermination(CanvasFilledRegionDetermination.Winding);
}
foreach (var segment in element.Segments)
{
if (segment.PathSegmentType == SvgPathSegment.SvgPathSegmentType.ClosePath)
{
builder.EndFigure(CanvasFigureLoop.Closed);
open = false;
continue;
}
else if (segment.PathSegmentType == SvgPathSegment.SvgPathSegmentType.MoveToAbsolute)
{
if (open)
{
builder.EndFigure(CanvasFigureLoop.Open);
}
var casted = (SvgPathSegmentMoveToAbsolute)segment;
v.X = casted.X;
v.Y = casted.Y;
builder.BeginFigure(v);
open = true;
continue;
}
else if (segment.PathSegmentType == SvgPathSegment.SvgPathSegmentType.MoveToRelative)
{
if (open)
{
builder.EndFigure(CanvasFigureLoop.Open);
}
var casted = (SvgPathSegmentMoveToRelative)segment;
v.X += casted.X;
v.Y += casted.Y;
builder.BeginFigure(v);
open = true;
continue;
}
if (!open)
{
builder.BeginFigure(v);
open = true;
}
if (segment.PathSegmentType == SvgPathSegment.SvgPathSegmentType.LineToAbsolute)
{
var casted = (SvgPathSegmentLineToAbsolute)segment;
v.X = casted.X;
v.Y = casted.Y;
builder.AddLine(v);
}
else if (segment.PathSegmentType == SvgPathSegment.SvgPathSegmentType.LineToRelative)
{
var casted = (SvgPathSegmentLineToRelative)segment;
v.X += casted.X;
v.Y += casted.Y;
builder.AddLine(v);
}
else if (segment.PathSegmentType == SvgPathSegment.SvgPathSegmentType.CurveToCubicAbsolute)
{
var casted = (SvgPathSegmentCurveToCubicAbsolute)segment;
v.X = casted.X;
v.Y = casted.Y;
builder.AddCubicBezier(new Vector2 {
X = casted.X1, Y = casted.Y1
}, new Vector2 {
X = casted.X2, Y = casted.Y2
}, v);
}
else if (segment.PathSegmentType == SvgPathSegment.SvgPathSegmentType.CurveToCubicRelative)
{
var casted = (SvgPathSegmentCurveToCubicRelative)segment;
var c1 = v;
c1.X += casted.X1;
c1.Y += casted.Y1;
var c2 = v;
c2.X += casted.X2;
c2.Y += casted.Y2;
v.X += casted.X;
v.Y += casted.Y;
builder.AddCubicBezier(c1, c2, v);
}
else if (segment.PathSegmentType == SvgPathSegment.SvgPathSegmentType.CurveToQuadraticAbsolute)
{
var casted = (SvgPathSegmentCurveToQuadraticAbsolute)segment;
v.X = casted.X;
v.Y = casted.Y;
builder.AddQuadraticBezier(new Vector2 {
X = casted.X1, Y = casted.Y1
}, v);
}
else if (segment.PathSegmentType == SvgPathSegment.SvgPathSegmentType.CurveToQuadraticRelative)
{
var casted = (SvgPathSegmentCurveToQuadraticRelative)segment;
var c1 = v;
c1.X += casted.X1;
c1.Y += casted.Y1;
v.X += casted.X;
v.Y += casted.Y;
builder.AddQuadraticBezier(c1, v);
}
else if (segment.PathSegmentType == SvgPathSegment.SvgPathSegmentType.ArcAbsolute)
{
var casted = (SvgPathSegmentArcAbsolute)segment;
var size = casted.LargeArcFlag ? CanvasArcSize.Large : CanvasArcSize.Small;
var sweepDirection = casted.SweepFlag ? CanvasSweepDirection.Clockwise : CanvasSweepDirection.CounterClockwise;
builder.AddArc(new Vector2 {
X = casted.X, Y = casted.Y
}, casted.RadiusX, casted.RadiusY, 180.0F * casted.Angle / (float)Math.PI, sweepDirection, size);
}
else if (segment.PathSegmentType == SvgPathSegment.SvgPathSegmentType.ArcRelative)
{
var casted = (SvgPathSegmentArcRelative)segment;
v.X += casted.X;
v.Y += casted.Y;
var size = casted.LargeArcFlag ? CanvasArcSize.Large : CanvasArcSize.Small;
var sweepDirection = casted.SweepFlag ? CanvasSweepDirection.Clockwise : CanvasSweepDirection.CounterClockwise;
builder.AddArc(v, casted.RadiusX, casted.RadiusY, 180.0F * casted.Angle / (float)Math.PI, sweepDirection, size);
}
else if (segment.PathSegmentType == SvgPathSegment.SvgPathSegmentType.LineToHorizontalAbsolute)
{
var casted = (SvgPathSegmentLineToHorizontalAbsolute)segment;
v.X = casted.X;
builder.AddLine(v);
}
else if (segment.PathSegmentType == SvgPathSegment.SvgPathSegmentType.LineToHorizontalRelative)
{
var casted = (SvgPathSegmentLineToHorizontalRelative)segment;
v.X += casted.X;
builder.AddLine(v);
}
else if (segment.PathSegmentType == SvgPathSegment.SvgPathSegmentType.LineToVerticalAbsolute)
{
var casted = (SvgPathSegmentLineToVerticalAbsolute)segment;
v.Y = casted.Y;
builder.AddLine(v);
}
else if (segment.PathSegmentType == SvgPathSegment.SvgPathSegmentType.LineToVerticalRelative)
{
var casted = (SvgPathSegmentLineToVerticalRelative)segment;
v.Y += casted.Y;
builder.AddLine(v);
}
else if (segment.PathSegmentType == SvgPathSegment.SvgPathSegmentType.CurveToCubicSmoothAbsolute)
{
var casted = (SvgPathSegmentCurveToCubicSmoothAbsolute)segment;
var c1 = v;
v.X = casted.X;
v.Y = casted.Y;
builder.AddCubicBezier(c1, new Vector2 {
X = casted.X2, Y = casted.Y2
}, v);
}
else if (segment.PathSegmentType == SvgPathSegment.SvgPathSegmentType.CurveToCubicSmoothRelative)
{
var casted = (SvgPathSegmentCurveToCubicSmoothRelative)segment;
var c1 = v;
var c2 = v;
c2.X += casted.X2;
c2.Y += casted.Y2;
v.X += casted.X;
v.Y += casted.Y;
builder.AddCubicBezier(c1, c2, v);
}
else if (segment.PathSegmentType == SvgPathSegment.SvgPathSegmentType.CurveToQuadraticSmoothAbsolute)
{
var casted = (SvgPathSegmentCurveToQuadraticSmoothAbsolute)segment;
var c1 = v;
v.X = casted.X;
v.Y = casted.Y;
builder.AddQuadraticBezier(c1, v);
}
else if (segment.PathSegmentType == SvgPathSegment.SvgPathSegmentType.CurveToQuadraticSmoothRelative)
{
var casted = (SvgPathSegmentCurveToQuadraticSmoothRelative)segment;
var c1 = v;
v.X += casted.X;
v.Y += casted.Y;
builder.AddQuadraticBezier(c1, v);
}
}
if (open)
{
builder.EndFigure(CanvasFigureLoop.Open);
}
geometry = CanvasGeometry.CreatePath(builder);
}
this.DisposableObjects.Add(geometry);
this.PathCache.Add(element, geometry);
return(geometry);
}
protected abstract void RenderPath(TSession session, SvgPathElement element);
private void button2_Click(object sender, System.EventArgs e)
{
SvgSvgElement root = new SvgSvgElement("4in", "4in", "0,0 100,100");
//adding multiple children
root.AddChildren(
new SvgRectElement(5, 5, 5, 5),
new SvgEllipseElement(30, 10, 8, 12),
new SvgTextElement("Textastic!", 3, 20)
);
//group and path
SvgGroupElement grp = new SvgGroupElement("green_group");
grp.Style = "fill:green;stroke:black;";
SvgEllipseElement ell = new SvgEllipseElement();
ell.CX = 50;
ell.CY = 50;
ell.RX = 10;
ell.RY = 20;
SvgPathElement pathy = new SvgPathElement();
pathy.D = "M 20,80 C 20,90 30,80 70,100 C 70,100 40,60 50,60 z";
pathy.Style = ell.Style;
root.AddChild(grp);
//cloning and style arithmetic
grp.AddChildren(ell, pathy);
grp.Style.Set("fill", "blue");
SvgGroupElement grp2 = (SvgGroupElement)SvgFactory.CloneElement(grp);
grp2.Id = "cloned_red_group";
grp2.Style.Set("fill", "red");
grp2.Style += "opacity:0.5";
grp2.Transform = "scale (1.2, 1.2) translate(10)";
root.AddChild(grp2);
//output
string s = root.WriteSVGString(true);
tbOut.Text = s;
StreamWriter tw = new StreamWriter("c:\\temp\\foo.svg", false);
tw.Write(s);
tw.Close();
svgOut.SRC = "c:\\temp\\foo.svg";
}
protected override void RenderPath(CanvasDrawingSession session, SvgPathElement element)
{
var geometry = this.CreatePath(session, element); // NO Dispose!
this.RenderGeometory(session, geometry, element.Transform.Result, element.Style);
}
private SvgPathSegLinetoAbs getLineto()
{
SvgPathElement path = getPathElement();
return((SvgPathSegLinetoAbs)path.CreateSvgPathSegLinetoAbs(20, 30));
}
private void button2_Click(object sender, System.EventArgs e)
{
SvgSvgElement root = new SvgSvgElement("4in", "4in", "0,0 100,100");
//adding multiple children
root.AddChildren(
new SvgRectElement(5, 5, 5, 5),
new SvgEllipseElement(30, 10, 8, 12),
new SvgTextElement("Textastic!", 3, 20)
);
//group and path
SvgGroupElement grp = new SvgGroupElement("green_group")
{
Style = "fill:green;stroke:black;"
};
SvgEllipseElement ell = new SvgEllipseElement {
CX = 50,
CY = 50,
RX = 10,
RY = 20
};
SvgPathElement pathy = new SvgPathElement {
D = "M 20,80 C 20,90 30,80 70,100 C 70,100 40,60 50,60 z",
Style = ell.Style
};
root.AddChild(grp);
//cloning and style arithmetic
grp.AddChildren(ell, pathy);
grp.Style.Set("fill", "blue");
SvgGroupElement grp2 = (SvgGroupElement)SvgFactory.CloneElement(grp);
grp2.Id = "cloned_red_group";
grp2.Style.Set("fill", "red");
grp2.Style += "opacity:0.5";
grp2.Transform = "scale (1.2, 1.2) translate(10)";
root.AddChild(grp2);
//output
string s = root.WriteSVGString(true);
tbOut.Text = s;
string tempFile = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "foo.svg");
StreamWriter tw = new StreamWriter(tempFile, false);
tw.Write(s);
tw.Close();
svgOut.Navigate(new Uri(tempFile));
svgOut.Refresh(WebBrowserRefreshOption.Completely);
}
public override void VisitPathElement(SvgPathElement element) => VisitPathSegList(element, element.Segments);
private void button2_Click(object sender, System.EventArgs e)
{
var root = new SvgSvgElement("4in", "4in", "-10,-10 250,250");
//adding multiple children
root.AddChildren(
new SvgRectElement(5, 5, 5, 5),
new SvgEllipseElement(20, 20, 8, 12)
{
Style = "fill:yellow;stroke:red"
},
new SvgAElement("https://github.com/managed-commons/SvgNet").AddChildren(
new SvgTextElement("Textastic!", 30, 20)
{
Style = "fill:midnightblue;stroke:navy;stroke-width:1px;font-size:30px;font-family:Calibri"
})
);
//group and path
var grp = new SvgGroupElement("green_group")
{
Style = "fill:green;stroke:black;"
};
grp.AddChild(new SvgRectElement(30, 30, 5, 20));
var ell = new SvgEllipseElement
{
CX = 50,
CY = 50,
RX = 10,
RY = 20
};
var pathy = new SvgPathElement
{
D = "M 20,80 C 20,90 30,80 70,100 C 70,100 40,60 50,60 z",
Style = ell.Style
};
root.AddChild(grp);
//cloning and style arithmetic
grp.AddChildren(ell, pathy);
grp.Style.Set("fill", "blue");
var grp2 = (SvgGroupElement)SvgFactory.CloneElement(grp);
grp2.Id = "cloned_red_group";
grp2.Style.Set("fill", "red");
grp2.Style += "opacity:0.5";
grp2.Transform = "scale (1.2, 1.2) translate(10)";
root.AddChild(grp2);
//output
string s = root.WriteSVGString(true);
tbOut.Text = s;
string tempFile = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "foo.svg");
using (var tw = new StreamWriter(tempFile, false))
tw.Write(s);
svgOut.Navigate(new Uri(tempFile));
svgOut.Refresh(WebBrowserRefreshOption.Completely);
}
public override void VisitPathElement(SvgPathElement element)
{
base.VisitPathElement(element);
VisitSvgGeometryElement(element);
}
