GraphicsPathIterator.NextPathType(Byte, Int32, Int32) Método
Definición
Importante
Parte de la información hace referencia a la versión preliminar del producto, que puede haberse modificado sustancialmente antes de lanzar la versión definitiva. Microsoft no otorga ninguna garantía, explícita o implícita, con respecto a la información proporcionada aquí.
Obtiene el índice inicial y el índice final del siguiente grupo de puntos de datos que tienen el mismo tipo.
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 IntegerParámetros
- pathType
- Byte
[out] Recibe el tipo de punto compartido por todos los puntos del grupo. Los tipos posibles se pueden recuperar de la enumeración PathPointType.
- startIndex
- Int32
[out] Recibe el índice inicial del grupo de puntos.
- endIndex
- Int32
[out] Recibe el índice final del grupo de puntos.
Devoluciones
Este método devuelve el número de puntos de datos del grupo. Si no hay más grupos en la ruta de acceso, este método devuelve 0.
Ejemplos
El ejemplo siguiente está diseñado para su uso con Windows Forms y requiere PaintEventArgse, un objeto de evento OnPaint. El código realiza las siguientes acciones:
Crea un objeto GraphicsPath.
Agrega tres líneas, un rectángulo y una elipse.
Enumera los valores de todos los puntos al lado izquierdo de la pantalla.
Crea un GraphicsPathIterator y lo rebobina.
En un bucle
for, recorre en iteración los puntos mediante los métodos NextPathType y NextPathType.Usa los valores devueltos desde las llamadas iterativas para enumerar el número de subruta, el número de puntos en él y el tipo de la ruta de acceso apunta al lado derecho de la pantalla.
Muestra el valor del número total de puntos a la pantalla.
Tenga en cuenta que ListPathPoints es una función auxiliar que separa la mayoría (no todos) del código para mostrar del código de ruta de acceso de gráficos.
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
Se aplica a
Colaborar con nosotros en GitHub
El origen de este contenido se puede encontrar en GitHub, donde también puede crear y revisar problemas y solicitudes de incorporación de cambios. Para más información, consulte nuestra guía para colaboradores.
