public void PathIterator2(Graphics g)
{
GraphicsPath myPath = new GraphicsPath();
Point[] myPoints =
{
new Point(20, 20),
new Point(120, 120),
new Point(20, 120),
new Point(20, 20)
};
Rectangle myRect = new Rectangle(120, 120, 100, 100);
myPath.AddLines(myPoints);
myPath.AddRectangle(myRect);
myPath.AddEllipse(220, 220, 100, 100);
// Get the total number of points for the path, and arrays of
// the points and types.
int myPathPointCount = myPath.PointCount;
PointF[] myPathPoints = myPath.PathPoints;
byte[] myPathTypes = myPath.PathTypes;
// Set up variables for listing the array of points on the left
// side of the screen.
int i;
float j = 20;
Font myFont = new Font("Arial", 8);
SolidBrush myBrush = new SolidBrush(Color.Black);
// List the set of points and types and types to the left side
// of the screen.
g.DrawString("Original Data",
myFont,
myBrush,
20,
j);
j += 20;
for(i=0; i<myPathPointCount; i++)
{
g.DrawString(myPathPoints[i].X.ToString()+
", " + myPathPoints[i].Y.ToString() + ", " +
myPathTypes[i].ToString(),
myFont,
myBrush,
20,
j);
j+=20;
}
// Create a GraphicsPathIterator for myPath.
GraphicsPathIterator myPathIterator =
new GraphicsPathIterator(myPath);
myPathIterator.Rewind();
PointF[] points = new PointF[myPathIterator.Count];
byte[] types = new byte[myPathIterator.Count];
int numPoints = myPathIterator.Enumerate(ref points, ref types);
// Draw the set of copied points and types to the screen.
j = 20;
g.DrawString("Copied Data",
myFont,
myBrush,
200,
j);
j += 20;
for(i=0; i<points.Length; i++)
{
g.DrawString("Point: " + i +
", " + "Value: " + points[i].ToString() + ", " +
"Type: " + types[i].ToString(),
myFont,
myBrush,
200,
j);
j+=20;
}
}
public virtual void Enumerate()
{
GraphicsPath path = new GraphicsPath ();
path.AddLine (new Point (100, 100), new Point (400, 100));
path.AddLine (new Point (400, 200), new Point (10, 100));
path.StartFigure ();
path.AddBezier( 10, 10, 50, 250, 100, 5, 200, 280);
path.StartFigure ();
path.AddRectangle (new Rectangle (10, 20, 300, 400));
path.StartFigure ();
path.AddLine (new Point (400, 400), new Point (400, 10));
path.Reverse ();
GraphicsPathIterator iterator = new GraphicsPathIterator (path);
PointF [] actualPoints = new PointF [14];
byte [] actualTypes = new byte [14];
iterator.Enumerate (ref actualPoints, ref actualTypes);
PointF [] expectedPoints = new PointF [] { new PointF(400f, 10f),
new PointF(400f, 400f),
new PointF(10f, 420f),
new PointF(310f, 420f),
new PointF(310f, 20f),
new PointF(10f, 20f),
new PointF(200f, 280f),
new PointF(100f, 5f),
new PointF(50f, 250f),
new PointF(10f, 10f),
new PointF(10f, 100f),
new PointF(400f, 200f),
new PointF(400f, 100f),
new PointF(100f, 100f)};
for(int i = 0; i < expectedPoints.Length; i++) {
DrawingTest.AssertAlmostEqual(expectedPoints [i], actualPoints [i]);
}
byte [] expectedTypes = new byte [] { (byte) PathPointType.Start,
(byte) PathPointType.Line,
(byte) PathPointType.Start,
(byte) PathPointType.Line,
(byte) PathPointType.Line,
(byte) (PathPointType.Line | PathPointType.CloseSubpath),
(byte) PathPointType.Start,
(byte) PathPointType.Bezier3,
(byte) PathPointType.Bezier3,
(byte) PathPointType.Bezier3,
(byte) PathPointType.Start,
(byte) PathPointType.Line,
(byte) PathPointType.Line,
(byte) PathPointType.Line};
for (int i=0; i < expectedTypes.Length; i++) {
Assert.AreEqual (expectedTypes [i], actualTypes [i]);
}
}
public void Enumerate_DifferentSize ()
{
using (GraphicsPath gp = new GraphicsPath ()) {
gp.AddLines (pts_2f);
using (GraphicsPathIterator gpi = new GraphicsPathIterator (gp)) {
PointF [] points = new PointF [1];
byte [] types = new byte [2];
Assert.AreEqual (0, gpi.Enumerate (ref points, ref types));
}
}
}