GraphicsPathIterator.NextMarker Methode

Definition

Namespace:

System.Drawing.Drawing2D

Assembly:

System.Drawing.Common.dll

Paket:

System.Drawing.Common v9.0.0-preview.6.24327.6

Verschiebt den Iterator zur nächsten Markierung im Pfad.

Überlädt

NextMarker(GraphicsPath)	Diesem GraphicsPathIterator-Objekt ist ein GraphicsPath Objekt zugeordnet. Die NextMarker(GraphicsPath)-Methode erhöht die zugeordnete GraphicsPath auf die nächste Markierung in ihrem Pfad und kopiert alle Punkte, die zwischen der aktuellen Markierung und dem nächsten Markierungsende (oder dem Pfadende) enthalten sind, in ein zweites GraphicsPath Objekt, das an den Parameter übergeben wird.
NextMarker(Int32, Int32)	Erhöht die GraphicsPathIterator auf die nächste Markierung im Pfad und gibt die Start- und Stoppindizes mithilfe der [out]-Parameter zurück.

NextMarker(GraphicsPath)

Quelle:

GraphicsPathIterator.cs

Diesem GraphicsPathIterator-Objekt ist ein GraphicsPath Objekt zugeordnet. Die NextMarker(GraphicsPath)-Methode erhöht die zugeordnete GraphicsPath auf die nächste Markierung in ihrem Pfad und kopiert alle Punkte, die zwischen der aktuellen Markierung und dem nächsten Markierungsende (oder dem Pfadende) enthalten sind, in ein zweites GraphicsPath Objekt, das an den Parameter übergeben wird.

public:
 int NextMarker(System::Drawing::Drawing2D::GraphicsPath ^ path);

public int NextMarker (System.Drawing.Drawing2D.GraphicsPath path);

member this.NextMarker : System.Drawing.Drawing2D.GraphicsPath -> int

Public Function NextMarker (path As GraphicsPath) As Integer

Parameter

path

GraphicsPath

Das GraphicsPath-Objekt, in das die Punkte kopiert werden.

Gibt zurück

Int32

Die Anzahl der Punkte zwischen dieser Markierung und der nächsten.

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 ein GraphicsPath -Objekt.

• Fügt drei Linien, ein Rechteck, eine Ellipse und zwei Markierungen hinzu.

• Listet die Werte aller Pfadpunkte auf der linken Seite des Bildschirms auf.

• Erstellt ein GraphicsPathIterator -Objekt.

• Erstellt ein GraphicsPath -Objekt, myPathSection, um kopierte Punkte zu empfangen.

• Ruft die NextMarker-Methode auf, die die erste Markierung durchläuft, und kopiert alle Punkte, die zwischen dieser Markierung und dem nächsten myPathSectionenthalten sind.

• Gibt die Anzahl der in markerPointskopierten Punkte zurück.

• Listet die Markierungsnummer (die erste Markierung) und die Anzahl der Punkte auf der rechten Seite des Bildschirms auf.

public:
   void NextMarkerExample2( PaintEventArgs^ e )
   {
      // Create a graphics path.
      GraphicsPath^ myPath = gcnew GraphicsPath;

      // Set up primitives to add to myPath.
      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, an ellipse, and 2 markers.
      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 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 listing all the values of the path's
      // 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 );

      // List the values for all of path points 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.
      GraphicsPathIterator^ myPathIterator = gcnew GraphicsPathIterator( myPath );

      // Rewind the iterator.
      myPathIterator->Rewind();

      // Create a GraphicsPath to receive a section of myPath.
      GraphicsPath^ myPathSection = gcnew GraphicsPath;

      // Retrieve and list the number of points contained in
      // the first marker to the right side of the screen.
      int markerPoints;
      markerPoints = myPathIterator->NextMarker( myPathSection );
      e->Graphics->DrawString( String::Format( "Marker: 1  Num Points: {0}", markerPoints ), myFont, myBrush, 200, 20 );
   }

public void NextMarkerExample2(PaintEventArgs e)
{
             
    // Create a graphics path.
    GraphicsPath myPath = new GraphicsPath();
             
    // Set up primitives to add to myPath.
    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, an ellipse, and 2 markers.
    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 the arrays of the points and types.
    int myPathPointCount = myPath.PointCount;
    PointF[] myPathPoints = myPath.PathPoints;
    byte[] myPathTypes = myPath.PathTypes;
             
    // Set up variables for listing all the values of the path's
    // points to the screen.
    int i;
    float j = 20;
    Font myFont = new Font("Arial", 8);
    SolidBrush myBrush = new SolidBrush(Color.Black);
             
    // List the values for all of path points 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.
    GraphicsPathIterator myPathIterator = new
        GraphicsPathIterator(myPath);
             
    // Rewind the iterator.
    myPathIterator.Rewind();
             
    // Create a GraphicsPath to receive a section of myPath.
    GraphicsPath myPathSection = new GraphicsPath();
             
    // Retrieve and list the number of points contained in
             
    // the first marker to the right side of the screen.
    int markerPoints;
    markerPoints = myPathIterator.NextMarker(myPathSection);
    e.Graphics.DrawString("Marker: 1" + "  Num Points: " +
        markerPoints.ToString(),  myFont, myBrush, 200, 20);
}

Public Sub NextMarkerExample2(ByVal e As PaintEventArgs)

    ' Create a graphics path.
    Dim myPath As New GraphicsPath

    ' Set up primitives to add to myPath.
    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, an ellipse, and 2 markers.
    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 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 array
    ' of 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)

    ' 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, 20, j)
        j += 20
    Next i

    ' Create a GraphicsPathIterator.
    Dim myPathIterator As New GraphicsPathIterator(myPath)

    ' Rewind the iterator.
    myPathIterator.Rewind()

    ' Create a GraphicsPath section.
    Dim myPathSection As New GraphicsPath

    ' List the points contained in the first marker
    ' to the screen.
    Dim markerPoints As Integer
    markerPoints = myPathIterator.NextMarker(myPathSection)
    e.Graphics.DrawString("Marker: 1" + "  Num Points: " + _
        markerPoints.ToString(), myFont, myBrush, 200, 20)
End Sub

Hinweise

Verwenden Sie die SetMarkers-Methode, um Markierungen in einem Pfad festzulegen. Markierungen werden verwendet, um Gruppen von Unterpfaden zu erstellen. Mindestens ein Unterpfad kann zwischen zwei Markierungen stehen.

NextMarker(Int32, Int32)

Quelle:

GraphicsPathIterator.cs

Erhöht die GraphicsPathIterator auf die nächste Markierung im Pfad und gibt die Start- und Stoppindizes mithilfe der [out]-Parameter zurück.

public:
 int NextMarker([Runtime::InteropServices::Out] int % startIndex, [Runtime::InteropServices::Out] int % endIndex);

public int NextMarker (out int startIndex, out int endIndex);

member this.NextMarker : int * int -> int

Public Function NextMarker (ByRef startIndex As Integer, ByRef endIndex As Integer) As Integer

Parameter

startIndex

Int32

[out] Der ganzzahlige Verweis, der für diesen Parameter bereitgestellt wird, empfängt den Index des Punkts, der einen Unterpfad startet.

endIndex

Int32

[out] Der ganzzahlige Verweis, der für diesen Parameter bereitgestellt wird, empfängt den Index des Punkts, der den Unterpfad beendet, auf den startIndex Punkte verweist.

Gibt zurück

Int32

Die Anzahl der Punkte zwischen dieser Markierung und der nächsten.

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 ein GraphicsPath -Objekt.

• Fügt drei Linien, ein Rechteck und eine Ellipse 3/4 mit Markierungen dazwischen hinzu.

• Zeichnet die Werte für das Array von Punkten auf dem Bildschirm.

• Erstellt ein GraphicsPathIterator -Objekt.

• Ruft die NextMarker-Methode auf.

• Verwendet die von den iterativen Aufrufen zurückgegebenen Werte, um NextMarker die Start- und Stopppunkte für jede Markierung auf dem Bildschirm zu zeichnen.

• Zeichnet den Wert für die Gesamtanzahl der Punkte auf dem Bildschirm.

private:
   void NextMarkerExample( 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, an ellipse, and 2 markers.
      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 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 array
      // of 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 );

      // 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, 20, j );
         j += 20;
      }

      // Create a GraphicsPathIterator.
      GraphicsPathIterator^ myPathIterator = gcnew GraphicsPathIterator( myPath );
      int myStartIndex;
      int myEndIndex;

      // Rewind the Iterator.
      myPathIterator->Rewind();

      // Draw the Markers and their start and end points
      // to the screen.
      j = 20;
      for ( i = 0; i < 3; i++ )
      {
         myPathIterator->NextMarker( myStartIndex, myEndIndex );
         e->Graphics->DrawString( String::Format( "Marker {0}:  Start: {1}  End: {2}", i, myStartIndex, myEndIndex ),
               myFont, myBrush, 200, j );
         j += 20;
      }

      // Draw the total number of points to the screen.
      j += 20;
      int myPathTotalPoints = myPathIterator->Count;
      e->Graphics->DrawString( String::Format( "Total Points = {0}", myPathTotalPoints ), myFont, myBrush, 200, j );
   }

private void NextMarkerExample(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, an ellipse, and 2 markers.
    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 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 array
             
    // of points to the screen.
    int i;
    float j = 20;
    Font myFont = new Font("Arial", 8);
    SolidBrush myBrush = new SolidBrush(Color.Black);
             
    // 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,
            20,
            j);
        j+=20;
    }
             
    // Create a GraphicsPathIterator.
    GraphicsPathIterator myPathIterator = new
        GraphicsPathIterator(myPath);
    int myStartIndex;
    int myEndIndex;
             
    // Rewind the Iterator.
    myPathIterator.Rewind();
             
    // Draw the Markers and their start and end points
             
    // to the screen.
    j=20;
    for(i=0;i<3;i++)
    {
        myPathIterator.NextMarker(out myStartIndex, out myEndIndex);
        e.Graphics.DrawString("Marker " + i.ToString() +
            ":  Start: " + myStartIndex.ToString()+
            "  End: " + myEndIndex.ToString(),
            myFont,
            myBrush,
            200,
            j);
        j += 20;
    }
             
    // Draw the total number of points to the screen.
    j += 20;
    int myPathTotalPoints = myPathIterator.Count;
    e.Graphics.DrawString("Total Points = " +
        myPathTotalPoints.ToString(),
        myFont,
        myBrush,
        200,
        j);
}

Public Sub NextMarkerExample(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, an ellipse, and 2 markers.
    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 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 array of 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)

    ' 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, 20, j)
        j += 20
    Next i

    ' Create a GraphicsPathIterator.
    Dim myPathIterator As New GraphicsPathIterator(myPath)
    Dim myStartIndex As Integer
    Dim myEndIndex As Integer

    ' Rewind the Iterator.
    myPathIterator.Rewind()

    ' Draw the Markers and their start and end points to the screen.
    j = 20
    For i = 0 To 2
        myPathIterator.NextMarker(myStartIndex, myEndIndex)
        e.Graphics.DrawString("Marker " + i.ToString() + _
            ":  Start: " + myStartIndex.ToString() + "  End: " + _
            myEndIndex.ToString(), myFont, myBrush, 200, j)
        j += 20
    Next i

    ' Draw the total number of points to the screen.
    j += 20
    Dim myPathTotalPoints As Integer = myPathIterator.Count
    e.Graphics.DrawString("Total Points = " + _
        myPathTotalPoints.ToString(), myFont, myBrush, 200, j)
End Sub

Hinweise

Verwenden Sie die SetMarkers-Methode, um Markierungen in einem Pfad festzulegen. Markierungen werden verwendet, um Gruppen von Unterpfaden zu erstellen. Mindestens ein Unterpfad kann zwischen zwei Markierungen stehen.