GraphicsPathIterator.CopyData 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.
Überlädt
CopyData(PointF[], Byte[], Int32, Int32) |
Kopiert die PathPoints Eigenschaft und PathTypes Eigenschaftenarrays der zugeordneten GraphicsPath in die beiden angegebenen Arrays. |
CopyData(Span<PointF>, Span<Byte>, Int32, Int32) |
CopyData(PointF[], Byte[], Int32, Int32)
- Quelle:
- GraphicsPathIterator.cs
- Quelle:
- GraphicsPathIterator.cs
- Quelle:
- GraphicsPathIterator.cs
- Quelle:
- GraphicsPathIterator.cs
- Quelle:
- GraphicsPathIterator.cs
Kopiert die PathPoints Eigenschaft und PathTypes Eigenschaftenarrays der zugeordneten GraphicsPath in die beiden angegebenen 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
Parameter
- types
- Byte[]
Wenn sie zurückgegeben werden, enthält ein Bytearray, das die Arten von Punkten im Pfad darstellt.
- startIndex
- Int32
Gibt den Anfangsindex der Arrays an.
- endIndex
- Int32
Gibt den Endindex der Arrays an.
Gibt zurück
Die Anzahl der kopierten Punkte.
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 einen Grafikpfad.
Füllt sie mit mehreren Grundtypen und einigen Markierungen auf.
Listet die Pfaddaten auf der linken Seite des Bildschirms auf.
Erstellt eine GraphicsPathIterator und gibt sie zurück.
Erhöht den Pfaddatenindex auf die zweite Markierung.
Ruft die CopyData-Methode auf, um die Pfaddaten zwischen den Anfangs- und Endindizes in die Punkte und Typenarrays zu kopieren.
Listet diese kopierten Daten auf der rechten Seite des Bildschirms auf.
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
Hinweise
Verwenden Sie die Parameter startIndex
und endIndex
, um einen angegebenen Bereich der Pfaddaten zu kopieren.
Gilt für:
CopyData(Span<PointF>, Span<Byte>, Int32, Int32)
- Quelle:
- 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
Parameter
- startIndex
- Int32
- endIndex
- Int32
Gibt zurück
Gilt für:
Feedback
https://aka.ms/ContentUserFeedback.
Bald verfügbar: Im Laufe des Jahres 2024 werden wir GitHub-Issues stufenweise als Feedbackmechanismus für Inhalte abbauen und durch ein neues Feedbacksystem ersetzen. Weitere Informationen finden Sie unterFeedback senden und anzeigen für