GraphicsPathIterator.CopyData(PointF[], Byte[], Int32, Int32) Método
Definição
Copia as matrizes da propriedade PathPoints e da propriedade PathTypes do GraphicsPath associado em duas matrizes especificadas.Copies the PathPoints property and PathTypes property arrays of the associated GraphicsPath into the two specified arrays.
public:
int CopyData(cli::array <System::Drawing::PointF> ^ % points, cli::array <System::Byte> ^ % types, int startIndex, int endIndex);
public int CopyData (ref System.Drawing.PointF[] points, ref byte[] types, int startIndex, int endIndex);
member this.CopyData : PointF[] * Byte[] * int * int -> int
Public Function CopyData (ByRef points As PointF(), ByRef types As Byte(), startIndex As Integer, endIndex As Integer) As Integer
Parâmetros
- points
- PointF[]
Após o retorno, contém uma matriz de estruturas PointF que representa os pontos no caminho.Upon return, contains an array of PointF structures that represents the points in the path.
- types
- Byte[]
Após o retorno, contém uma matriz de bytes que representa os tipos de pontos no caminho.Upon return, contains an array of bytes that represents the types of points in the path.
- startIndex
- Int32
Especifica o índice inicial das matrizes.Specifies the starting index of the arrays.
- endIndex
- Int32
Especifica o índice final das matrizes.Specifies the ending index of the arrays.
Retornos
O número de pontos copiados.The number of points copied.
Exemplos
O exemplo a seguir foi projetado para uso com Windows Forms, e ele requer PaintEventArgs e um OnPaint objeto de evento.The following example is designed for use with Windows Forms, and it requires PaintEventArgse, an OnPaint event object. O código executa as seguintes ações:The code performs the following actions:
Cria um caminho de gráficos.Creates a graphics path.
Popula-o com vários primitivos e alguns marcadores.Populates it with several primitives and some markers.
Lista os dados de caminho no lado esquerdo da tela.Lists the path data on the left side of the screen.
Cria um GraphicsPathIterator e o retrocede.Creates a GraphicsPathIterator and rewinds it.
Incrementa o índice de dados de caminho para o segundo marcador.Increments the path data index to the second marker.
Chama o CopyData método para copiar os dados de caminho contidos entre os índices inicial e final para as matrizes de pontos e tipos.Calls the CopyData method to copy the path data contained between the start and end indexes to the points and types arrays.
Lista esses dados copiados no lado direito da tela.Lists this copied data on the right side of the screen.
public:
void CopyDataExample( PaintEventArgs^ e )
{
// Create a graphics path.
GraphicsPath^ myPath = gcnew GraphicsPath;
// Set up a points array.
array<Point>^ myPoints = {Point(20,20),Point(120,120),Point(20,120),Point(20,20)};
// Create a rectangle.
Rectangle myRect = Rectangle(120,120,100,100);
// Add the points, rectangle, and an ellipse to the path.
myPath->AddLines( myPoints );
myPath->SetMarkers();
myPath->AddRectangle( myRect );
myPath->SetMarkers();
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;
array<PointF>^myPathPoints = myPath->PathPoints;
array<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;
System::Drawing::Font^ myFont = gcnew System::Drawing::Font( "Arial",8 );
SolidBrush^ myBrush = gcnew SolidBrush( Color::Black );
// List the set of points and types and types to the left side
// of the screen.
for ( i = 0; i < myPathPointCount; i++ )
{
e->Graphics->DrawString( myPathPoints[ i ].X + ", " + myPathPoints[ i ].Y + ", " + myPathTypes[ i ], myFont, myBrush, 20, j );
j += 20;
}
// Create a GraphicsPathIterator for myPath and rewind it.
GraphicsPathIterator^ myPathIterator = gcnew GraphicsPathIterator( myPath );
myPathIterator->Rewind();
// Set up the arrays to receive the copied data.
array<PointF>^points = gcnew array<PointF>(myPathIterator->Count);
array<Byte>^types = gcnew array<Byte>(myPathIterator->Count);
int myStartIndex;
int myEndIndex;
// Increment the starting index to the second marker in the
// path.
myPathIterator->NextMarker( myStartIndex, myEndIndex );
myPathIterator->NextMarker( myStartIndex, myEndIndex );
// Copy all the points and types from the starting index to the
// ending index to the points array and the types array
// respectively.
int numPointsCopied = myPathIterator->CopyData( points, types, myStartIndex, myEndIndex );
// List the copied points to the right side of the screen.
j = 20;
int copiedStartIndex = 0;
for ( i = 0; i < numPointsCopied; i++ )
{
copiedStartIndex = myStartIndex + i;
e->Graphics->DrawString( String::Format( "Point: {0}, Value: {1}, Type: {2}", copiedStartIndex, points[ i ], types[ i ] ), myFont, myBrush, 200, j );
j += 20;
}
}
public void CopyDataExample(PaintEventArgs e)
{
// Create a graphics path.
GraphicsPath myPath = new GraphicsPath();
// Set up a points array.
Point[] myPoints =
{
new Point(20, 20),
new Point(120, 120),
new Point(20, 120),
new Point(20, 20)
};
// Create a rectangle.
Rectangle myRect = new Rectangle(120, 120, 100, 100);
// Add the points, rectangle, and an ellipse to the path.
myPath.AddLines(myPoints);
myPath.SetMarkers();
myPath.AddRectangle(myRect);
myPath.SetMarkers();
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.
for(i=0; i<myPathPointCount; i++)
{
e.Graphics.DrawString(myPathPoints[i].X.ToString()+
", " + myPathPoints[i].Y.ToString() + ", " +
myPathTypes[i].ToString(),
myFont,
myBrush,
20,
j);
j+=20;
}
// Create a GraphicsPathIterator for myPath and rewind it.
GraphicsPathIterator myPathIterator =
new GraphicsPathIterator(myPath);
myPathIterator.Rewind();
// Set up the arrays to receive the copied data.
PointF[] points = new PointF[myPathIterator.Count];
byte[] types = new byte[myPathIterator.Count];
int myStartIndex;
int myEndIndex;
// Increment the starting index to the second marker in the
// path.
myPathIterator.NextMarker(out myStartIndex, out myEndIndex);
myPathIterator.NextMarker(out myStartIndex, out myEndIndex);
// Copy all the points and types from the starting index to the
// ending index to the points array and the types array
// respectively.
int numPointsCopied = myPathIterator.CopyData(
ref points,
ref types,
myStartIndex,
myEndIndex);
// List the copied points to the right side of the screen.
j = 20;
int copiedStartIndex = 0;
for(i=0; i<numPointsCopied; i++)
{
copiedStartIndex = myStartIndex + i;
e.Graphics.DrawString(
"Point: " + copiedStartIndex.ToString() +
", Value: " + points[i].ToString() +
", Type: " + types[i].ToString(),
myFont,
myBrush,
200,
j);
j+=20;
}
}
Public Sub CopyDataExample(ByVal e As PaintEventArgs)
' Create a graphics path.
Dim myPath As New GraphicsPath
' Set up a points array.
Dim myPoints As Point() = {New Point(20, 20), _
New Point(120, 120), New Point(20, 120), New Point(20, 20)}
' Create a rectangle.
Dim myRect As New Rectangle(120, 120, 100, 100)
' Add the points, rectangle, and an ellipse to the path.
myPath.AddLines(myPoints)
myPath.SetMarkers()
myPath.AddRectangle(myRect)
myPath.SetMarkers()
myPath.AddEllipse(220, 220, 100, 100)
' Get the total number of points for the path, and 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 listing the array of points on the left side
' of 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)
' List the set of points and types and types to the left side of
' the screen.
For i = 0 To myPathPointCount - 1
e.Graphics.DrawString(myPathPoints(i).X.ToString() + ", " + _
myPathPoints(i).Y.ToString() + ", " + _
myPathTypes(i).ToString(), myFont, myBrush, 20, j)
j += 20
Next i
' Create a GraphicsPathIterator for myPath and rewind it.
Dim myPathIterator As New GraphicsPathIterator(myPath)
myPathIterator.Rewind()
' Set up the arrays to receive the copied data.
Dim points(myPathIterator.Count) As PointF
Dim types(myPathIterator.Count) As Byte
Dim myStartIndex As Integer
Dim myEndIndex As Integer
' Increment the starting index to the second marker in the path.
myPathIterator.NextMarker(myStartIndex, myEndIndex)
myPathIterator.NextMarker(myStartIndex, myEndIndex)
' Copy all the points and types from the starting index to the
' ending index to the points array and the types array
' respectively.
Dim numPointsCopied As Integer = myPathIterator.CopyData(points, _
types, myStartIndex, myEndIndex)
' List the copied points to the right side of the screen.
j = 20
Dim copiedStartIndex As Integer = 0
For i = 0 To numPointsCopied - 1
copiedStartIndex = myStartIndex + i
e.Graphics.DrawString("Point: " + _
copiedStartIndex.ToString() + ", Value: " + _
points(i).ToString() + ", Type: " + types(i).ToString(), _
myFont, myBrush, 200, j)
j += 20
Next i
End Sub
Comentários
Use os startIndex endIndex parâmetros e para copiar um intervalo especificado dos dados do caminho.Use the startIndex and endIndex parameters to copy a specified range of the path data.