GraphicsPathIterator.NextMarker Metoda

Definicja

Przestrzeń nazw:

System.Drawing.Drawing2D

Zestaw:

System.Drawing.Common.dll

Pakiet:

System.Drawing.Common v9.0.0-rc.2.24474.1

Przenosi iterator do następnego znacznika w ścieżce.

Przeciążenia

NextMarker(GraphicsPath)	Ten obiekt GraphicsPathIterator ma skojarzony obiekt GraphicsPath. Metoda NextMarker(GraphicsPath) zwiększa skojarzoną GraphicsPath do następnego znacznika w ścieżce i kopiuje wszystkie punkty zawarte między bieżącym znacznikiem a następnym znacznikiem (lub końcem ścieżki) do drugiego obiektu GraphicsPath przekazanego do parametru.
NextMarker(Int32, Int32)	Zwiększa GraphicsPathIterator do następnego znacznika w ścieżce i zwraca indeksy początkowe i zatrzymane za pomocą parametrów [out].

NextMarker(GraphicsPath)

Źródło:

GraphicsPathIterator.cs

Ten obiekt GraphicsPathIterator ma skojarzony obiekt GraphicsPath. Metoda NextMarker(GraphicsPath) zwiększa skojarzoną GraphicsPath do następnego znacznika w ścieżce i kopiuje wszystkie punkty zawarte między bieżącym znacznikiem a następnym znacznikiem (lub końcem ścieżki) do drugiego obiektu GraphicsPath przekazanego do parametru.

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

Parametry

path

GraphicsPath

Obiekt GraphicsPath, do którego zostaną skopiowane punkty.

Zwraca

Int32

Liczba punktów między tym znacznikiem a następnym.

Przykłady

Poniższy przykład został zaprojektowany do użycia z formularzami systemu Windows i wymaga PaintEventArgseobiektu zdarzenia OnPaint. Kod wykonuje następujące akcje:

• Tworzy obiekt GraphicsPath.

• Dodaje trzy linie, prostokąt, wielokropek i dwa znaczniki.

• Wyświetla listę wartości wszystkich punktów ścieżki po lewej stronie ekranu.

• Tworzy obiekt GraphicsPathIterator.

• Tworzy obiekt GraphicsPath, myPathSection, do odbierania skopiowanych punktów.

• Wywołuje metodę NextMarker, która iteruje do pierwszego znacznika i kopiuje wszystkie punkty zawarte między tym znacznikiem a obok myPathSection.

• Zwraca liczbę punktów skopiowanych do markerPoints.

• Wyświetla numer znacznika (pierwszy znacznik) i liczbę punktów, które zawiera po prawej stronie ekranu.

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

Uwagi

Użyj metody SetMarkers, aby ustawić znaczniki w ścieżce. Znaczniki służą do tworzenia grup podścieżek. Co najmniej jeden podścież może znajdować się między dwoma znacznikami.

NextMarker(Int32, Int32)

Źródło:

GraphicsPathIterator.cs

Zwiększa GraphicsPathIterator do następnego znacznika w ścieżce i zwraca indeksy początkowe i zatrzymane za pomocą parametrów [out].

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

Parametry

startIndex

Int32

[out] Odwołanie całkowite dostarczone do tego parametru odbiera indeks punktu, który uruchamia ścieżkę podrzędną.

endIndex

Int32

[out] Odwołanie całkowite podane do tego parametru odbiera indeks punktu, który kończy ścieżkę podrzędną, do której startIndex wskazuje.

Zwraca

Int32

Liczba punktów między tym znacznikiem a następnym.

Przykłady

Poniższy przykład został zaprojektowany do użycia z formularzami systemu Windows i wymaga PaintEventArgseobiektu zdarzenia OnPaint. Kod wykonuje następujące akcje:

• Tworzy obiekt GraphicsPath.

• Dodaje trzy linie, prostokąt i wielokropek 3/4 ze znacznikami między nimi.

• Rysuje wartości tablicy punktów na ekranie.

• Tworzy obiekt GraphicsPathIterator.

• Wywołuje metodę NextMarker.

• Używa wartości zwracanych z iteracyjnych wywołań, aby NextMarker narysować punkty początkowe i zatrzymane dla każdego znacznika na ekranie.

• Rysuje wartość całkowitej liczby punktów na ekranie.

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

Uwagi

Użyj metody SetMarkers, aby ustawić znaczniki w ścieżce. Znaczniki służą do tworzenia grup podścieżek. Co najmniej jeden podścież może znajdować się między dwoma znacznikami.