GraphicsPathIterator.CopyData Método

Definição

Sobrecargas

CopyData(PointF[], Byte[], Int32, Int32)

Copia a propriedade PathPoints e PathTypes matrizes de propriedades da GraphicsPath associada nas duas matrizes especificadas.

CopyData(Span<PointF>, Span<Byte>, Int32, Int32)

CopyData(PointF[], Byte[], Int32, Int32)

Origem:
GraphicsPathIterator.cs
Origem:
GraphicsPathIterator.cs
Origem:
GraphicsPathIterator.cs
Origem:
GraphicsPathIterator.cs
Origem:
GraphicsPathIterator.cs

Copia a propriedade PathPoints e PathTypes matrizes de propriedades da GraphicsPath associada nas duas matrizes especificadas.

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 de PointF que representa os pontos no caminho.

types
Byte[]

Após o retorno, contém uma matriz de bytes que representa os tipos de pontos no caminho.

startIndex
Int32

Especifica o índice inicial das matrizes.

endIndex
Int32

Especifica o índice final das matrizes.

Retornos

O número de pontos copiados.

Exemplos

O exemplo a seguir foi projetado para uso com o Windows Forms e requer PaintEventArgse, um objeto de evento OnPaint. O código executa as seguintes ações:

  • Cria um caminho gráfico.

  • Popula-o com vários primitivos e alguns marcadores.

  • Lista os dados de caminho no lado esquerdo da tela.

  • Cria um GraphicsPathIterator e o retrocede.

  • Incrementa o índice de dados de caminho para o segundo marcador.

  • Chama o método CopyData para copiar os dados de caminho contidos entre os índices inicial e final para as matrizes de pontos e tipos.

  • Lista esses dados copiados no lado direito da tela.

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 parâmetros startIndex e endIndex para copiar um intervalo especificado dos dados do caminho.

Aplica-se a

CopyData(Span<PointF>, Span<Byte>, Int32, Int32)

Origem:
GraphicsPathIterator.cs
public:
 int CopyData(Span<System::Drawing::PointF> points, Span<System::Byte> types, int startIndex, int endIndex);
public int CopyData (Span<System.Drawing.PointF> points, Span<byte> types, int startIndex, int endIndex);
member this.CopyData : Span<System.Drawing.PointF> * Span<byte> * int * int -> int
Public Function CopyData (points As Span(Of PointF), types As Span(Of Byte), startIndex As Integer, endIndex As Integer) As Integer

Parâmetros

points
Span<PointF>
types
Span<Byte>
startIndex
Int32
endIndex
Int32

Retornos

Aplica-se a