GraphicsPathIterator.CopyData(PointF[], Byte[], Int32, Int32) Método

Definición

Espacio de nombres:

System.Drawing.Drawing2D

Ensamblado:

System.Drawing.Common.dll

Paquete:

System.Drawing.Common v8.0.0

Source:

GraphicsPathIterator.cs

Copia la propiedad PathPoints y las matrices de propiedades PathTypes del objeto GraphicsPath asociado en las dos matrices 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[]

Cuando se devuelve, contiene una matriz de estructuras PointF que representa los puntos del trazado.

types

Byte[]

Cuando se devuelve, contiene una matriz de bytes que representa los tipos de los puntos del trazado.

startIndex

Int32

Especifica el índice inicial de las matrices.

endIndex

Int32

Especifica el índice final de las matrices.

Devoluciones

Int32

Número de puntos que se copian.

Ejemplos

El ejemplo siguiente está diseñado para su uso con Windows Forms y requiere PaintEventArgse, un OnPaint objeto de evento. El código realiza las siguientes acciones:

• Crea una ruta de acceso de gráficos.

• Lo rellena con varios primitivos y algunos marcadores.

• Listas los datos de ruta de acceso en el lado izquierdo de la pantalla.

• Crea un GraphicsPathIterator y lo rebobina.

• Incrementa el índice de datos de ruta de acceso al segundo marcador.

• Llama al CopyData método para copiar los datos de ruta de acceso contenidos entre los índices inicial y final en las matrices de puntos y tipos.

• Listas estos datos copiados en el lado derecho de la pantalla.

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

Comentarios

Use los startIndex parámetros y endIndex para copiar un intervalo especificado de los datos de ruta de acceso.