Partager via

GraphicsPathIterator.NextSubpath Méthode

  • Référence

Définition

Espace de noms:
System.Drawing.Drawing2D
Assembly:
System.Drawing.Common.dll
Assembly:
System.Drawing.dll
Paquet:
System.Drawing.Common v8.0.7
Paquet:
System.Drawing.Common v9.0.0-preview.6.24327.6

Déplace le sous-chemin vers le sous-chemin suivant dans le GraphicsPathspécifié.

Surcharges

NextSubpath(GraphicsPath, Boolean)

Obtient la figure suivante (sous-chemin) du chemin d’accès associé de cette GraphicsPathIterator.
NextSubpath(Int32, Int32, Boolean)

Déplace le GraphicsPathIterator vers le sous-chemin suivant dans le chemin d’accès. L’index de début et l’index de fin du sous-chemin suivant sont contenus dans les paramètres [out].

NextSubpath(GraphicsPath, Boolean)

Source:
GraphicsPathIterator.cs
Source:
GraphicsPathIterator.cs
Source:
GraphicsPathIterator.cs
Source:
GraphicsPathIterator.cs
Source:
GraphicsPathIterator.cs

Obtient la figure suivante (sous-chemin) du chemin d’accès associé de cette GraphicsPathIterator.

public:
 int NextSubpath(System::Drawing::Drawing2D::GraphicsPath ^ path, [Runtime::InteropServices::Out] bool % isClosed);
public int NextSubpath (System.Drawing.Drawing2D.GraphicsPath path, out bool isClosed);
member this.NextSubpath : System.Drawing.Drawing2D.GraphicsPath * bool -> int
Public Function NextSubpath (path As GraphicsPath, ByRef isClosed As Boolean) As Integer

Paramètres

path
GraphicsPath

Un GraphicsPath qui doit avoir ses points de données définis pour correspondre aux points de données de la figure récupérée (sous-chemin) pour cet itérateur.

isClosed
Boolean

[out] Indique si le sous-chemin actuel est fermé. Il est true si la figure est fermée, sinon elle est false.

Retours

Int32

Nombre de points de données dans la figure récupérée (sous-chemin). S’il n’y a plus de chiffres à récupérer, zéro est retourné.

Exemples

L’exemple suivant est conçu pour une utilisation avec Windows Forms et nécessite PaintEventArgse, un objet d’événement OnPaint. Le code effectue les actions suivantes :

  • Crée un objet GraphicsPath.

  • Ajoute trois lignes, un rectangle, un ellipse et deux marqueurs.

  • Répertorie les valeurs de tous les points du chemin vers le côté gauche de l’écran.

  • Crée un objet GraphicsPathIterator.

  • Crée un objet GraphicsPath, myPathSection, pour recevoir des points copiés.

  • Appelle la méthode NextSubpath, qui itère vers le troisième sous-chemin (figure) et copie tous les points contenus dans ce sous-chemin vers le chemin d’accès myPathSection, et retourne également le nombre de points copiés dans subpathPoints.

  • Répertorie le numéro de sous-chemin et le nombre de points qu’il contient sur le côté droit de l’écran.

void NextSubpathExample2( 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 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 of all the 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 for myPath.
   GraphicsPathIterator^ myPathIterator = gcnew GraphicsPathIterator( myPath );

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

   // Create the GraphicsPath section.
   GraphicsPath^ myPathSection = gcnew GraphicsPath;

   // Iterate to the 3rd subpath and list the number of points therein
   // to the screen.
   int subpathPoints;
   bool IsClosed2;

   // Iterate to the third subpath.
   subpathPoints = myPathIterator->NextSubpath( myPathSection, IsClosed2 );
   subpathPoints = myPathIterator->NextSubpath( myPathSection, IsClosed2 );
   subpathPoints = myPathIterator->NextSubpath( myPathSection, IsClosed2 );

   // Write the number of subpath points to the screen.
   e->Graphics->DrawString( String::Format( "Subpath: 3   Num Points: {0}", subpathPoints ), myFont, myBrush, 200, 20 );
}

public void NextSubpathExample2(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 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 of all the 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 for myPath.
    GraphicsPathIterator myPathIterator = new
        GraphicsPathIterator(myPath);
         
    // Rewind the iterator.
    myPathIterator.Rewind();
         
    // Create the GraphicsPath section.
    GraphicsPath myPathSection = new GraphicsPath();
         
    // Iterate to the 3rd subpath and list the number of points therein
         
    // to the screen.
    int subpathPoints;
    bool IsClosed2;
         
    // Iterate to the third subpath.
    subpathPoints = myPathIterator.NextSubpath(
        myPathSection, out IsClosed2);
    subpathPoints = myPathIterator.NextSubpath(
        myPathSection, out IsClosed2);
    subpathPoints = myPathIterator.NextSubpath(
        myPathSection, out IsClosed2);
         
    // Write the number of subpath points to the screen.
    e.Graphics.DrawString("Subpath: 3"  +
        "   Num Points: " +
        subpathPoints.ToString(),
        myFont,
        myBrush,
        200,
        20);
}

Public Sub NextSubpathExample2(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 for myPath.
    Dim myPathIterator As New GraphicsPathIterator(myPath)

    ' Rewind the iterator.
    myPathIterator.Rewind()

    ' Create the GraphicsPath section.
    Dim myPathSection As New GraphicsPath

    ' Draw the 3rd subpath and the number of points therein
    ' to the screen.
    Dim subpathPoints As Integer
    Dim IsClosed2 As Boolean

    ' Iterate to the third subpath.
    subpathPoints = myPathIterator.NextSubpath(myPathSection, _
        IsClosed2)
    subpathPoints = myPathIterator.NextSubpath(myPathSection, _
        IsClosed2)
    subpathPoints = myPathIterator.NextSubpath(myPathSection, _
        IsClosed2)

    ' Write the number of subpath points to the screen.
    e.Graphics.DrawString("Subpath: 3" + "   Num Points: " + _
    subpathPoints.ToString(), myFont, myBrush, 200, 20)
End Sub

S’applique à

NextSubpath(Int32, Int32, Boolean)

Source:
GraphicsPathIterator.cs
Source:
GraphicsPathIterator.cs
Source:
GraphicsPathIterator.cs
Source:
GraphicsPathIterator.cs
Source:
GraphicsPathIterator.cs

Déplace le GraphicsPathIterator vers le sous-chemin suivant dans le chemin d’accès. L’index de début et l’index de fin du sous-chemin suivant sont contenus dans les paramètres [out].

public:
 int NextSubpath([Runtime::InteropServices::Out] int % startIndex, [Runtime::InteropServices::Out] int % endIndex, [Runtime::InteropServices::Out] bool % isClosed);
public int NextSubpath (out int startIndex, out int endIndex, out bool isClosed);
member this.NextSubpath : int * int * bool -> int
Public Function NextSubpath (ByRef startIndex As Integer, ByRef endIndex As Integer, ByRef isClosed As Boolean) As Integer

Paramètres

startIndex
Int32

[out] Reçoit l’index de départ du sous-chemin suivant.

endIndex
Int32

[out] Reçoit l’index de fin du sous-chemin suivant.

isClosed
Boolean

[out] Indique si le sous-chemin est fermé.

Retours

Int32

Nombre de sous-chemins dans l’objet GraphicsPath.

Exemples

L’exemple suivant est conçu pour une utilisation avec Windows Forms et nécessite PaintEventArgse, un objet d’événement OnPaint. Le code effectue les actions suivantes :

  • Crée un objet GraphicsPath.

  • Ajoute trois lignes, un rectangle et un ellipse.

  • Dessine les valeurs du tableau de points à l’écran.

  • Crée un objet GraphicsPathIterator.

  • Appelle la méthode NextSubpath.

  • Utilise les valeurs retournées par les appels itératifs à NextSubpath pour dessiner les valeurs de début et d’arrêt de chaque sous-chemin vers l’écran.

  • Dessine la valeur du nombre total de sous-chemins à l’écran.

private:
   void NextSubpathExample( 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->AddRectangle( myRect );
      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;
      bool myIsClosed;

      // get the number of Subpaths.
      int numSubpaths = myPathIterator->NextSubpath( myPath, myIsClosed );
      numSubpaths -= 1;

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

      // List the Subpaths to the screen.
      j = 20;
      for ( i = 0; i < numSubpaths; i++ )
      {
         myPathIterator->NextSubpath( myStartIndex, myEndIndex, myIsClosed );
         String^ s = String::Format( "Subpath {0}:  Start: {1}", i, myStartIndex );
         s = s + String::Format( "  End: {0}  IsClosed: {1}", myEndIndex, myIsClosed );
         e->Graphics->DrawString( s, myFont, myBrush, 200, j );
         j += 20;
      }

      // Draw the total number of Subpaths to the screen.
      j += 20;
      e->Graphics->DrawString( String::Format( "Number Subpaths = {0}", numSubpaths ), myFont, myBrush, 200, j );
   }

private void NextSubpathExample(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.AddRectangle(myRect);
    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;
    bool myIsClosed;
             
    // get the number of Subpaths.
    int numSubpaths = myPathIterator.NextSubpath(myPath,
        out myIsClosed);
    numSubpaths -= 1;
             
    // Rewind the Iterator.
    myPathIterator.Rewind();
             
    // List the Subpaths to the screen.
    j=20;
    for(i=0;i<numSubpaths;i++)
    {
        myPathIterator.NextSubpath(out myStartIndex,
            out myEndIndex,
            out myIsClosed);
        e.Graphics.DrawString("Subpath " + i.ToString() +
            ":  Start: " + myStartIndex.ToString()+
            "  End: " + myEndIndex.ToString() +
            "  IsClosed: " + myIsClosed.ToString(),
            myFont,
            myBrush,
            200,
            j);
        j += 20;
    }
             
    // Draw the total number of Subpaths to the screen.
    j += 20;
    e.Graphics.DrawString("Number Subpaths = " +
        numSubpaths.ToString(),
        myFont,
        myBrush,
        200,
        j);
}

Public Sub NextSubpathExample(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.AddRectangle(myRect)
    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
    Dim myIsClosed As Boolean

    ' get the number of Subpaths.
    Dim numSubpaths As Integer = myPathIterator.NextSubpath(myPath, _
        myIsClosed)
    numSubpaths -= 1

    ' Rewind the Iterator.
    myPathIterator.Rewind()

    ' List the Subpaths to the screen.
    j = 20
    For i = 0 To numSubpaths - 1
        myPathIterator.NextSubpath(myStartIndex, myEndIndex, _
        myIsClosed)
        e.Graphics.DrawString("Subpath " + i.ToString() + _
            ":  Start: " + myStartIndex.ToString() + "  End: " + _
            myEndIndex.ToString() + "  IsClosed: " + _
            myIsClosed.ToString(), myFont, myBrush, 200, j)
        j += 20
    Next i

    ' Draw the total number of Subpaths to the screen.
    j += 20
    e.Graphics.DrawString("Number Subpaths = " + _
        numSubpaths.ToString(), myFont, myBrush, 200, j)
End Sub

S’applique à