GraphicsPathIterator.NextPathType(Byte, Int32, Int32) Methode
Definition
Wichtig
Einige Informationen beziehen sich auf Vorabversionen, die vor dem Release ggf. grundlegend überarbeitet werden. Microsoft übernimmt hinsichtlich der hier bereitgestellten Informationen keine Gewährleistungen, seien sie ausdrücklich oder konkludent.
Ruft den Anfangsindex und den Endindex der nächsten Gruppe von Datenpunkten ab, die alle denselben Typ aufweisen.
public:
int NextPathType([Runtime::InteropServices::Out] System::Byte % pathType, [Runtime::InteropServices::Out] int % startIndex, [Runtime::InteropServices::Out] int % endIndex);public int NextPathType (out byte pathType, out int startIndex, out int endIndex);member this.NextPathType : byte * int * int -> intPublic Function NextPathType (ByRef pathType As Byte, ByRef startIndex As Integer, ByRef endIndex As Integer) As IntegerParameter
- pathType
- Byte
[out] Empfängt den Punkttyp, der von allen Punkten in der Gruppe gemeinsam verwendet wird. Mögliche Typen können aus der PathPointType Enumeration abgerufen werden.
- startIndex
- Int32
[out] Empfängt den Anfangsindex der Gruppe von Punkten.
- endIndex
- Int32
[out] Empfängt den Endindex der Gruppe von Punkten.
Gibt zurück
Diese Methode gibt die Anzahl der Datenpunkte in der Gruppe zurück. Wenn im Pfad keine weiteren Gruppen vorhanden sind, gibt diese Methode "0" zurück.
Beispiele
Das folgende Beispiel wurde für die Verwendung mit Windows Forms entwickelt und erfordert PaintEventArgse, ein OnPaint-Ereignisobjekt. Der Code führt die folgenden Aktionen aus:
Erstellt ein GraphicsPath -Objekt.
Fügt drei Linien, ein Rechteck und eine Ellipse hinzu.
Listet die Werte aller Punkte auf der linken Seite des Bildschirms auf.
Erstellt eine GraphicsPathIterator und gibt sie zurück.
In einer
forSchleife durchlaufen Sie die Punkte mithilfe der methoden NextPathType und NextPathType.Verwendet die von den iterativen Aufrufen zurückgegebenen Werte, um die Nummer des Unterpfads, die Anzahl der Darin enthaltenen Punkte und den Typ des Pfads auf die rechte Seite des Bildschirms auflisten.
Zeigt den Wert für die Gesamtanzahl der Punkte auf dem Bildschirm an.
Beachten Sie, dass ListPathPoints eine Hilfsfunktion ist, die die meisten (nicht alle) des Anzeigecodes vom Grafikpfadcode trennt.
public:
void NextPathTypeExample( PaintEventArgs^ e )
{
// Create the GraphicsPath.
GraphicsPath^ myPath = gcnew GraphicsPath;
array<Point>^ myPoints = {Point(20,20),Point(120,120),Point(20,120),Point(20,20)};
Rectangle myRect = Rectangle(120,120,100,100);
// Add 3 lines, a rectangle, and an ellipse.
myPath->AddLines( myPoints );
myPath->AddRectangle( myRect );
myPath->AddEllipse( 220, 220, 100, 100 );
// List all of the path points to the screen.
ListPathPoints( e, myPath, nullptr, 20, 1 );
// Create a GraphicsPathIterator.
GraphicsPathIterator^ myPathIterator = gcnew GraphicsPathIterator( myPath );
// Rewind the Iterator.
myPathIterator->Rewind();
// Iterate the subpaths and types, and list the results to
// the screen.
int i;
int j = 20;
int mySubPaths;
int subPathStartIndex;
int subPathEndIndex;
Boolean IsClosed;
Byte subPathPointType;
int pointTypeStartIndex;
int pointTypeEndIndex;
int numPointsFound;
System::Drawing::Font^ myFont = gcnew System::Drawing::Font( "Arial",8 );
SolidBrush^ myBrush = gcnew SolidBrush( Color::Black );
j = 20;
for ( i = 0; i < 3; i++ )
{
mySubPaths = myPathIterator->NextSubpath( subPathStartIndex, subPathEndIndex, IsClosed );
numPointsFound = myPathIterator->NextPathType( subPathPointType, pointTypeStartIndex, pointTypeEndIndex );
e->Graphics->DrawString( String::Format( "SubPath: {0} Points Found: {1} Type of Points: {2}", i,
numPointsFound, subPathPointType ), myFont, myBrush, 200.0f, (float)j );
j += 20;
}
// List the total number of path points to the screen.
ListPathPoints( e, myPath, myPathIterator, 200, 2 );
}
//-------------------------------------------------------
//This function is a helper function used by
// NextPathTypeExample.
//-------------------------------------------------------
void ListPathPoints( PaintEventArgs^ e, GraphicsPath^ myPath, GraphicsPathIterator^ myPathIterator, int xOffset, int listType )
{
// Get the total number of points for the path,
// and the arrays of the points and types.
int myPathPointCount = myPath->PointCount;
array<PointF>^myPathPoints = myPath->PathPoints;
array<Byte>^myPathTypes = myPath->PathTypes;
// Set up variables for drawing the points to the screen.
int i;
float j = 20;
System::Drawing::Font^ myFont = gcnew System::Drawing::Font( "Arial",8 );
SolidBrush^ myBrush = gcnew SolidBrush( Color::Black );
if ( listType == 1 )
{
// Draw the set of path points and types to the screen.
for ( i = 0; i < myPathPointCount; i++ )
{
e->Graphics->DrawString( myPathPoints[ i ].X + ", " + myPathPoints[ i ].Y + ", " + myPathTypes[ i ],
myFont, myBrush, (float)xOffset, (float)j );
j += 20;
}
}
else
if ( listType == 2 )
{
// Draw the total number of points to the screen.
int myPathTotalPoints = myPathIterator->Count;
e->Graphics->DrawString( String::Format( "Total Points = {0}", myPathTotalPoints ), myFont, myBrush, (float)xOffset, 100.0f );
}
else
{
e->Graphics->DrawString( "Wrong or no list type argument.", myFont, myBrush, (float)xOffset, 200.0f );
}
}
public void NextPathTypeExample(PaintEventArgs e)
{
// Create the GraphicsPath.
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);
// Add 3 lines, a rectangle, and an ellipse.
myPath.AddLines(myPoints);
myPath.AddRectangle(myRect);
myPath.AddEllipse(220, 220, 100, 100);
// List all of the path points to the screen.
ListPathPoints(e, myPath, null, 20, 1);
// Create a GraphicsPathIterator.
GraphicsPathIterator myPathIterator = new
GraphicsPathIterator(myPath);
// Rewind the Iterator.
myPathIterator.Rewind();
// Iterate the subpaths and types, and list the results to
// the screen.
int i, j = 20;
int mySubPaths, subPathStartIndex, subPathEndIndex;
Boolean IsClosed;
byte subPathPointType;
int pointTypeStartIndex, pointTypeEndIndex, numPointsFound;
Font myFont = new Font("Arial", 8);
SolidBrush myBrush = new SolidBrush(Color.Black);
j = 20;
for(i = 0;i < 3; i++)
{
mySubPaths = myPathIterator.NextSubpath(
out subPathStartIndex,
out subPathEndIndex,
out IsClosed);
numPointsFound = myPathIterator.NextPathType(
out subPathPointType,
out pointTypeStartIndex,
out pointTypeEndIndex);
e.Graphics.DrawString(
"SubPath: " + i +
" Points Found: " + numPointsFound.ToString() +
" Type of Points: " + subPathPointType.ToString(),
myFont,
myBrush,
200,
j);
j+=20;
}
// List the total number of path points to the screen.
ListPathPoints(e, myPath, myPathIterator, 200, 2);
}
//-------------------------------------------------------
//This function is a helper function used by
// NextPathTypeExample.
//-------------------------------------------------------
public void ListPathPoints(
PaintEventArgs e,
GraphicsPath myPath,
GraphicsPathIterator myPathIterator,
int xOffset,
int listType)
{
// Get the total number of points for the path,
// and the arrays of the points and types.
int myPathPointCount = myPath.PointCount;
PointF[] myPathPoints = myPath.PathPoints;
byte[] myPathTypes = myPath.PathTypes;
// Set up variables for drawing the points to the screen.
int i;
float j = 20;
Font myFont = new Font("Arial", 8);
SolidBrush myBrush = new SolidBrush(Color.Black);
if (listType == 1)
// List all the path points to the screen.
{
// Draw the set of path points and types to the screen.
for(i=0; i<myPathPointCount; i++)
{
e.Graphics.DrawString(myPathPoints[i].X.ToString()+
", " + myPathPoints[i].Y.ToString() + ", " +
myPathTypes[i].ToString(),
myFont,
myBrush,
xOffset,
j);
j+=20;
}
}
else if (listType == 2)
// Display the total number of path points.
{
// Draw the total number of points to the screen.
int myPathTotalPoints = myPathIterator.Count;
e.Graphics.DrawString("Total Points = " +
myPathTotalPoints.ToString(),
myFont,
myBrush,
xOffset,
100);
}
else
{
e.Graphics.DrawString("Wrong or no list type argument.",
myFont, myBrush, xOffset, 200);
}
}
Public Sub NextPathTypeExample(ByVal e As PaintEventArgs)
' Create the GraphicsPath.
Dim myPath As New GraphicsPath
Dim myPoints As Point() = {New Point(20, 20), _
New Point(120, 120), New Point(20, 120), New Point(20, 20)}
Dim myRect As New Rectangle(120, 120, 100, 100)
' Add 3 lines, a rectangle, and an ellipse.
myPath.AddLines(myPoints)
myPath.AddRectangle(myRect)
myPath.AddEllipse(220, 220, 100, 100)
' List all of the path points to the screen.
ListPathPointsHelper(e, myPath, Nothing, 20, 1)
' Create a GraphicsPathIterator.
Dim myPathIterator As New GraphicsPathIterator(myPath)
' Rewind the Iterator.
myPathIterator.Rewind()
' Iterate the subpaths and types, and list the results
' to the screen.
Dim j As Integer = 20
Dim i As Integer
Dim mySubPaths, subPathStartIndex, subPathEndIndex As Integer
Dim IsClosed As [Boolean]
Dim subPathPointType As Byte
Dim pointTypeStartIndex, pointTypeEndIndex, _
numPointsFound As Integer
Dim myFont As New Font("Arial", 8)
Dim myBrush As New SolidBrush(Color.Black)
j = 20
For i = 0 To 2
mySubPaths = myPathIterator.NextSubpath(subPathStartIndex, _
subPathEndIndex, IsClosed)
numPointsFound = myPathIterator.NextPathType(subPathPointType, _
pointTypeStartIndex, pointTypeEndIndex)
e.Graphics.DrawString("SubPath: " & i & " Points Found: " & _
numPointsFound.ToString() & " Type of Points: " & _
subPathPointType.ToString(), myFont, myBrush, 200, j)
j += 20
Next i
' List the total number of path points to the screen.
ListPathPointsHelper(e, myPath, myPathIterator, 200, 2)
End Sub
' This is a helper function used by NextPathTypeExample.
Public Sub ListPathPointsHelper(ByVal e As PaintEventArgs, _
ByVal myPath As GraphicsPath, ByVal myPathIterator As GraphicsPathIterator, _
ByVal xOffset As Integer, ByVal listType As Integer)
' Get the total number of points for the path,
' and the arrays of the points and types.
Dim myPathPointCount As Integer = myPath.PointCount
Dim myPathPoints As PointF() = myPath.PathPoints
Dim myPathTypes As Byte() = myPath.PathTypes
' Set up variables for drawing the points to the screen.
Dim i As Integer
Dim j As Single = 20
Dim myFont As New Font("Arial", 8)
Dim myBrush As New SolidBrush(Color.Black)
If listType = 1 Then
' List all the path points to the screen.
' Draw the set of path points and types to the screen.
For i = 0 To myPathPointCount - 1
e.Graphics.DrawString(myPathPoints(i).X.ToString() + ", " + _
myPathPoints(i).Y.ToString() + ", " + _
myPathTypes(i).ToString(), myFont, myBrush, xOffset, j)
j += 20
Next i
Else
If listType = 2 Then
' Display the total number of path points.
' Draw the total number of points to the screen.
Dim myPathTotalPoints As Integer = myPathIterator.Count
e.Graphics.DrawString("Total Points = " + _
myPathTotalPoints.ToString(), myFont, myBrush, xOffset, _
100)
Else
e.Graphics.DrawString("Wrong or no list type argument.", _
myFont, myBrush, xOffset, 200)
End If
End If
End Sub
Gilt für:
Zusammenarbeit auf GitHub
Die Quelle für diesen Inhalt finden Sie auf GitHub, wo Sie auch Issues und Pull Requests erstellen und überprüfen können. Weitere Informationen finden Sie in unserem Leitfaden für Mitwirkende.
