ListViewInsertionMark ListViewInsertionMark ListViewInsertionMark ListViewInsertionMark Class

Définition

Sert à indiquer l'emplacement cible attendu lorsqu'un élément est glissé vers une nouvelle position dans un contrôle ListView.Used to indicate the expected drop location when an item is dragged to a new position in a ListView control. Cette fonctionnalité n'est disponible que sur Windows XP et versions ultérieures.This functionality is available only on Windows XP and later.

public ref class ListViewInsertionMark sealed
public sealed class ListViewInsertionMark
type ListViewInsertionMark = class
Public NotInheritable Class ListViewInsertionMark
Héritage
ListViewInsertionMarkListViewInsertionMarkListViewInsertionMarkListViewInsertionMark

Exemples

L’exemple de code suivant montre comment utiliser la ListView fonctionnalité de marque d’insertion et implémente la réorganisation des éléments par glisser-déplacer à l’aide des événements de glissement standard.The following code example demonstrates how to use the ListView insertion mark feature and implements drag-and-drop item reordering using the standard drag events. La position de la marque d’insertion est mise à jour dans un Control.DragOver gestionnaire pour l’événement.The position of the insertion mark is updated in a handler for the Control.DragOver event. Dans ce gestionnaire, la position du pointeur de la souris est comparée au milieu de l’élément le plus proche, et le résultat est utilisé pour déterminer si la marque d’insertion apparaît à gauche ou à droite de l’élément.In this handler, the position of the mouse pointer is compared to the midpoint of the nearest item, and the result is used to determine whether the insertion mark appears to the left or the right of the item.

#using <System.dll>
#using <System.Windows.Forms.dll>
#using <System.Drawing.dll>

using namespace System;
using namespace System::Drawing;
using namespace System::Windows::Forms;
public ref class ListViewInsertionMarkExample: public Form
{
private:
   ListView^ myListView;

public:

   ListViewInsertionMarkExample()
   {
      // Initialize myListView.
      myListView = gcnew ListView;
      myListView->Dock = DockStyle::Fill;
      myListView->View = View::LargeIcon;
      myListView->MultiSelect = false;
      myListView->ListViewItemSorter = gcnew ListViewIndexComparer;

      // Initialize the insertion mark.
      myListView->InsertionMark->Color = Color::Green;

      // Add items to myListView.
      myListView->Items->Add( "zero" );
      myListView->Items->Add( "one" );
      myListView->Items->Add( "two" );
      myListView->Items->Add( "three" );
      myListView->Items->Add( "four" );
      myListView->Items->Add( "five" );

      // Initialize the drag-and-drop operation when running
      // under Windows XP or a later operating system.
      if ( System::Environment::OSVersion->Version->Major > 5 || (System::Environment::OSVersion->Version->Major == 5 && System::Environment::OSVersion->Version->Minor >= 1) )
      {
         myListView->AllowDrop = true;
         myListView->ItemDrag += gcnew ItemDragEventHandler( this, &ListViewInsertionMarkExample::myListView_ItemDrag );
         myListView->DragEnter += gcnew DragEventHandler( this, &ListViewInsertionMarkExample::myListView_DragEnter );
         myListView->DragOver += gcnew DragEventHandler( this, &ListViewInsertionMarkExample::myListView_DragOver );
         myListView->DragLeave += gcnew EventHandler( this, &ListViewInsertionMarkExample::myListView_DragLeave );
         myListView->DragDrop += gcnew DragEventHandler( this, &ListViewInsertionMarkExample::myListView_DragDrop );
      }

      // Initialize the form.
      this->Text = "ListView Insertion Mark Example";
      this->Controls->Add( myListView );
   }

private:

   // Starts the drag-and-drop operation when an item is dragged.
   void myListView_ItemDrag( Object^ /*sender*/, ItemDragEventArgs^ e )
   {
      myListView->DoDragDrop( e->Item, DragDropEffects::Move );
   }

   // Sets the target drop effect.
   void myListView_DragEnter( Object^ /*sender*/, DragEventArgs^ e )
   {
      e->Effect = e->AllowedEffect;
   }

   // Moves the insertion mark as the item is dragged.
   void myListView_DragOver( Object^ /*sender*/, DragEventArgs^ e )
   {
      // Retrieve the client coordinates of the mouse pointer.
      Point targetPoint = myListView->PointToClient( Point(e->X,e->Y) );

      // Retrieve the index of the item closest to the mouse pointer.
      int targetIndex = myListView->InsertionMark->NearestIndex( targetPoint );

      // Confirm that the mouse pointer is not over the dragged item.
      if ( targetIndex > -1 )
      {
         // Determine whether the mouse pointer is to the left or
         // the right of the midpoint of the closest item and set
         // the InsertionMark.AppearsAfterItem property accordingly.
         Rectangle itemBounds = myListView->GetItemRect( targetIndex );
         if ( targetPoint.X > itemBounds.Left + (itemBounds.Width / 2) )
         {
            myListView->InsertionMark->AppearsAfterItem = true;
         }
         else
         {
            myListView->InsertionMark->AppearsAfterItem = false;
         }
      }

      // Set the location of the insertion mark. If the mouse is
      // over the dragged item, the targetIndex value is -1 and
      // the insertion mark disappears.
      myListView->InsertionMark->Index = targetIndex;
   }

   // Removes the insertion mark when the mouse leaves the control.
   void myListView_DragLeave( Object^ /*sender*/, EventArgs^ /*e*/ )
   {
      myListView->InsertionMark->Index = -1;
   }

   // Moves the item to the location of the insertion mark.
   void myListView_DragDrop( Object^ /*sender*/, DragEventArgs^ e )
   {
      // Retrieve the index of the insertion mark;
      int targetIndex = myListView->InsertionMark->Index;

      // If the insertion mark is not visible, exit the method.
      if ( targetIndex == -1 )
      {
         return;
      }

      // If the insertion mark is to the right of the item with
      // the corresponding index, increment the target index.
      if ( myListView->InsertionMark->AppearsAfterItem )
      {
         targetIndex++;
      }

      // Retrieve the dragged item.
      ListViewItem^ draggedItem = dynamic_cast<ListViewItem^>(e->Data->GetData( ListViewItem::typeid ));

      // Insert a copy of the dragged item at the target index.
      // A copy must be inserted before the original item is removed
      // to preserve item index values.
      myListView->Items->Insert( targetIndex, dynamic_cast<ListViewItem^>(draggedItem->Clone()) );

      // Remove the original copy of the dragged item.
      myListView->Items->Remove( draggedItem );

   }

   // Sorts ListViewItem objects by index.
   ref class ListViewIndexComparer: public System::Collections::IComparer
   {
   public:
      virtual int Compare( Object^ x, Object^ y )
      {
         return (dynamic_cast<ListViewItem^>(x))->Index - (dynamic_cast<ListViewItem^>(y))->Index;
      }
   };
};

[STAThread]
int main()
{
   Application::EnableVisualStyles();
   Application::Run( gcnew ListViewInsertionMarkExample );
}
using System;
using System.Drawing;
using System.Windows.Forms;

public class ListViewInsertionMarkExample : Form
{
    private ListView myListView; 

    public ListViewInsertionMarkExample()
    {
        // Initialize myListView.
        myListView = new ListView();
        myListView.Dock = DockStyle.Fill;
        myListView.View = View.LargeIcon;
        myListView.MultiSelect = false;
        myListView.ListViewItemSorter = new ListViewIndexComparer();

        // Initialize the insertion mark.
        myListView.InsertionMark.Color = Color.Green;

        // Add items to myListView.
        myListView.Items.Add("zero");
        myListView.Items.Add("one");
        myListView.Items.Add("two");
        myListView.Items.Add("three");
        myListView.Items.Add("four");
        myListView.Items.Add("five");
        
        // Initialize the drag-and-drop operation when running
        // under Windows XP or a later operating system.
        if (OSFeature.Feature.IsPresent(OSFeature.Themes))
        {
            myListView.AllowDrop = true;
            myListView.ItemDrag += new ItemDragEventHandler(myListView_ItemDrag);
            myListView.DragEnter += new DragEventHandler(myListView_DragEnter);
            myListView.DragOver += new DragEventHandler(myListView_DragOver);
            myListView.DragLeave += new EventHandler(myListView_DragLeave);
            myListView.DragDrop += new DragEventHandler(myListView_DragDrop);
        }

        // Initialize the form.
        this.Text = "ListView Insertion Mark Example";
        this.Controls.Add(myListView);
    }

    [STAThread]
    static void Main() 
    {
        Application.EnableVisualStyles();
        Application.Run(new ListViewInsertionMarkExample());
    }

    // Starts the drag-and-drop operation when an item is dragged.
    private void myListView_ItemDrag(object sender, ItemDragEventArgs e)
    {
        myListView.DoDragDrop(e.Item, DragDropEffects.Move);
    }

    // Sets the target drop effect.
    private void myListView_DragEnter(object sender, DragEventArgs e)
    {
        e.Effect = e.AllowedEffect;
    }

    // Moves the insertion mark as the item is dragged.
    private void myListView_DragOver(object sender, DragEventArgs e)
    {
        // Retrieve the client coordinates of the mouse pointer.
        Point targetPoint = 
            myListView.PointToClient(new Point(e.X, e.Y));

        // Retrieve the index of the item closest to the mouse pointer.
        int targetIndex = myListView.InsertionMark.NearestIndex(targetPoint);

        // Confirm that the mouse pointer is not over the dragged item.
        if (targetIndex > -1) 
        {
            // Determine whether the mouse pointer is to the left or
            // the right of the midpoint of the closest item and set
            // the InsertionMark.AppearsAfterItem property accordingly.
            Rectangle itemBounds = myListView.GetItemRect(targetIndex);
            if ( targetPoint.X > itemBounds.Left + (itemBounds.Width / 2) )
            {
                myListView.InsertionMark.AppearsAfterItem = true;
            }
            else
            {
                myListView.InsertionMark.AppearsAfterItem = false;
            }
        }

        // Set the location of the insertion mark. If the mouse is
        // over the dragged item, the targetIndex value is -1 and
        // the insertion mark disappears.
        myListView.InsertionMark.Index = targetIndex;
    }

    // Removes the insertion mark when the mouse leaves the control.
    private void myListView_DragLeave(object sender, EventArgs e)
    {
        myListView.InsertionMark.Index = -1;
    }

    // Moves the item to the location of the insertion mark.
    private void myListView_DragDrop(object sender, DragEventArgs e)
    {
        // Retrieve the index of the insertion mark;
        int targetIndex = myListView.InsertionMark.Index;

        // If the insertion mark is not visible, exit the method.
        if (targetIndex == -1) 
        {
            return;
        }

        // If the insertion mark is to the right of the item with
        // the corresponding index, increment the target index.
        if (myListView.InsertionMark.AppearsAfterItem) 
        {
            targetIndex++;
        }

        // Retrieve the dragged item.
        ListViewItem draggedItem = 
            (ListViewItem)e.Data.GetData(typeof(ListViewItem));

        // Insert a copy of the dragged item at the target index.
        // A copy must be inserted before the original item is removed
        // to preserve item index values. 
        myListView.Items.Insert(
            targetIndex, (ListViewItem)draggedItem.Clone());

        // Remove the original copy of the dragged item.
        myListView.Items.Remove(draggedItem);
    }

    // Sorts ListViewItem objects by index.
    private class ListViewIndexComparer : System.Collections.IComparer
    {
        public int Compare(object x, object y)
        {
            return ((ListViewItem)x).Index - ((ListViewItem)y).Index;
        }
    }

}
Imports System.Drawing
Imports System.Windows.Forms

Public Class ListViewInsertionMarkExample
    Inherits Form

    Private myListView As ListView
    
    Public Sub New()
        ' Initialize myListView.
        myListView = New ListView()
        myListView.Dock = DockStyle.Fill
        myListView.View = View.LargeIcon
        myListView.MultiSelect = False
        myListView.ListViewItemSorter = New ListViewIndexComparer()
        
        ' Initialize the insertion mark.
        myListView.InsertionMark.Color = Color.Green
        
        ' Add items to myListView.
        myListView.Items.Add("zero")
        myListView.Items.Add("one")
        myListView.Items.Add("two")
        myListView.Items.Add("three")
        myListView.Items.Add("four")
        myListView.Items.Add("five")
        
        ' Initialize the drag-and-drop operation when running
        ' under Windows XP or a later operating system.
        If OSFeature.Feature.IsPresent(OSFeature.Themes)
            myListView.AllowDrop = True
            AddHandler myListView.ItemDrag, AddressOf myListView_ItemDrag
            AddHandler myListView.DragEnter, AddressOf myListView_DragEnter
            AddHandler myListView.DragOver, AddressOf myListView_DragOver
            AddHandler myListView.DragLeave, AddressOf myListView_DragLeave
            AddHandler myListView.DragDrop, AddressOf myListView_DragDrop
        End If 

        ' Initialize the form.
        Me.Text = "ListView Insertion Mark Example"
        Me.Controls.Add(myListView)
    End Sub 'New

    <STAThread()> _
    Shared Sub Main()
        Application.EnableVisualStyles()
        Application.Run(New ListViewInsertionMarkExample())
    End Sub 'Main
    
    ' Starts the drag-and-drop operation when an item is dragged.
    Private Sub myListView_ItemDrag(sender As Object, e As ItemDragEventArgs)
        myListView.DoDragDrop(e.Item, DragDropEffects.Move)
    End Sub 'myListView_ItemDrag
    
    ' Sets the target drop effect.
    Private Sub myListView_DragEnter(sender As Object, e As DragEventArgs)
        e.Effect = e.AllowedEffect
    End Sub 'myListView_DragEnter
    
    ' Moves the insertion mark as the item is dragged.
    Private Sub myListView_DragOver(sender As Object, e As DragEventArgs)
        ' Retrieve the client coordinates of the mouse pointer.
        Dim targetPoint As Point = myListView.PointToClient(New Point(e.X, e.Y))
        
        ' Retrieve the index of the item closest to the mouse pointer.
        Dim targetIndex As Integer = _
            myListView.InsertionMark.NearestIndex(targetPoint)
        
        ' Confirm that the mouse pointer is not over the dragged item.
        If targetIndex > -1 Then
            ' Determine whether the mouse pointer is to the left or
            ' the right of the midpoint of the closest item and set
            ' the InsertionMark.AppearsAfterItem property accordingly.
            Dim itemBounds As Rectangle = myListView.GetItemRect(targetIndex)
            If targetPoint.X > itemBounds.Left + (itemBounds.Width / 2) Then
                myListView.InsertionMark.AppearsAfterItem = True
            Else
                myListView.InsertionMark.AppearsAfterItem = False
            End If
        End If
        
        ' Set the location of the insertion mark. If the mouse is
        ' over the dragged item, the targetIndex value is -1 and
        ' the insertion mark disappears.
        myListView.InsertionMark.Index = targetIndex
    End Sub 'myListView_DragOver

    ' Removes the insertion mark when the mouse leaves the control.
    Private Sub myListView_DragLeave(sender As Object, e As EventArgs)
        myListView.InsertionMark.Index = -1
    End Sub 'myListView_DragLeave
    
    ' Moves the item to the location of the insertion mark.
    Private Sub myListView_DragDrop(sender As Object, e As DragEventArgs)
        ' Retrieve the index of the insertion mark;
        Dim targetIndex As Integer = myListView.InsertionMark.Index
        
        ' If the insertion mark is not visible, exit the method.
        If targetIndex = -1 Then
            Return
        End If 

        ' If the insertion mark is to the right of the item with
        ' the corresponding index, increment the target index.
        If myListView.InsertionMark.AppearsAfterItem Then
            targetIndex += 1
        End If 

        ' Retrieve the dragged item.
        Dim draggedItem As ListViewItem = _
            CType(e.Data.GetData(GetType(ListViewItem)), ListViewItem)
        
        ' Insert a copy of the dragged item at the target index.
        ' A copy must be inserted before the original item is removed
        ' to preserve item index values.
        myListView.Items.Insert(targetIndex, _
            CType(draggedItem.Clone(), ListViewItem))
        
        ' Remove the original copy of the dragged item.
        myListView.Items.Remove(draggedItem)

    End Sub 'myListView_DragDrop
    
    ' Sorts ListViewItem objects by index.    
    Private Class ListViewIndexComparer
        Implements System.Collections.IComparer
        
        Public Function Compare(x As Object, y As Object) As Integer _
            Implements System.Collections.IComparer.Compare
            Return CType(x, ListViewItem).Index - CType(y, ListViewItem).Index
        End Function 'Compare

    End Class 'ListViewIndexComparer

End Class 'ListViewInsertionMarkExample 

Remarques

Vous pouvez récupérer un ListViewInsertionMark à partir InsertionMark de la propriété ListView d’un contrôle et l’utiliser pour indiquer visuellement l’emplacement cible attendu dans une opération de glisser-déplacer lorsqu’un élément est déplacé vers une nouvelle position.You can retrieve a ListViewInsertionMark from the InsertionMark property of a ListView control and use it to visually indicate the expected drop location in a drag-and-drop operation when an item is dragged to a new position.

Cette fonctionnalité fonctionne uniquement lorsque la ListView.AutoArrange propriété a la true valeur et lorsque le ListView contrôle ne trie pas automatiquement les éléments.This feature works only when the ListView.AutoArrange property is set to true and when the ListView control does not sort the items automatically. Pour empêcher le tri automatique, ListView.Sorting la propriété doit avoir la SortOrder.None valeur et ListView.View la propriété doit avoir la View.LargeIconvaleur View.SmallIcon, ou View.Tile.To prevent automatic sorting, the ListView.Sorting property must be set to SortOrder.None and the ListView.View property must be set to View.LargeIcon, View.SmallIcon, or View.Tile. En outre, la fonctionnalité de marque d’insertion ne peut pas ListView être utilisée avec la fonctionnalité de regroupement, car la fonctionnalité de regroupement trie les éléments par appartenance au groupe.Additionally, the insertion mark feature cannot be used with the ListView grouping feature because the grouping feature orders the items by group membership.

La ListViewInsertionMark classe est généralement utilisée dans un gestionnaire pour l' Control.DragOver événement Control.MouseMove ou pour mettre à jour la position de la marque d’insertion lorsqu’un élément est glissé.The ListViewInsertionMark class is typically used in a handler for the Control.DragOver or Control.MouseMove event to update the position of the insertion mark as an item is dragged. Il est également utilisé dans un gestionnaire pour l' Control.DragDrop événement Control.MouseUp ou pour insérer un élément déplacé à l’emplacement approprié.It is also used in a handler for the Control.DragDrop or Control.MouseUp event to insert a dragged item at the correct location.

Pour mettre à jour la position de la marque d’insertion, procédez comme suit:To update the position of the insertion mark, follow these steps:

  1. Dans un gestionnaire pour l' Control.DragOver événement Control.MouseMove ou, utilisez la ListView.InsertionMark propriété pour accéder à ListViewInsertionMark l’objet associé au ListView contrôle.In a handler for the Control.DragOver or Control.MouseMove event, use the ListView.InsertionMark property to access the ListViewInsertionMark object associated with the ListView control.

  2. Utilisez la NearestIndex méthode pour récupérer l’index de l’élément le plus proche du pointeur de la souris.Use the NearestIndex method to retrieve the index of the item closest to the mouse pointer.

  3. Transmettez la valeur d’index ListView.GetItemRect à la méthode pour récupérer le rectangle englobant de l’élément.Pass the index value to the ListView.GetItemRect method to retrieve the bounding rectangle of the item.

  4. Si le pointeur de la souris se trouve à gauche du milieu du rectangle englobant, affectez la AppearsAfterItem valeur à falsela propriété; truesinon, affectez-lui la valeur.If the mouse pointer is located to the left of the midpoint of the bounding rectangle, set the AppearsAfterItem property to false; otherwise, set it to true.

  5. Affectez Index à la propriété la valeur d’index Récupérée NearestIndex à partir de la méthode.Set the Index property to the index value retrieved from the NearestIndex method. La marque d’insertion apparaît en regard de l’élément avec l’index spécifié, à gauche ou à droite, en fonction de AppearsAfterItem la valeur de la propriété.The insertion mark appears next to item with the specified index, either to the left or the right, depending on the AppearsAfterItem property value. Si un élément est glissé sur lui-même, l’index est-1 et la marque d’insertion est masquée.If an item is dragged over itself, the index is -1 and the insertion mark is hidden.

Pour insérer l’élément déplacé à l’emplacement approprié, procédez comme suit:To insert the dragged item at the correct location, follow these steps:

  1. Dans un gestionnaire pour l' Control.DragDrop événement Control.MouseUp ou, utilisez la Index propriété pour déterminer l’emplacement actuel de la marque d’insertion.In a handler for the Control.DragDrop or Control.MouseUp event, use the Index property to determine the current location of the insertion mark. Stockez cette valeur à utiliser ultérieurement comme index d’insertion.Store this value to be used later as the insertion index.

  2. Si la AppearsAfterItem propriété a truela valeur, incrémentez la valeur de l’index d’insertion stocké.If the AppearsAfterItem property is set to true, increment the stored insertion index value.

  3. Utilisez la ListView.ListViewItemCollection.Insert méthode pour insérer un clone de l’élément déplacé dans la ListView.Items collection au niveau de l’index d’insertion stocké.Use the ListView.ListViewItemCollection.Insert method to insert a clone of the dragged item into the ListView.Items collection at the stored insertion index.

  4. Utilisez la ListView.ListViewItemCollection.Remove méthode pour supprimer la copie d’origine de l’élément déplacé.Use the ListView.ListViewItemCollection.Remove method to remove the original copy of the dragged item.

Vous devez insérer un clone de l’élément déplacé avant que la copie d’origine ne soit supprimée, de ListView.Items sorte que les valeurs d’index de la collection ne soient pas modifiées avant l’insertion.You must insert a clone of the dragged item before the original copy is removed so the index values in the ListView.Items collection are not altered before the insertion.

Pour vous assurer que les éléments sont affichés dans le même ordre que leurs valeurs d’index, vous devez ListView.ListViewItemSorter affecter à la propriété une implémentation IComparer de l’interface qui trie les éléments par valeur d’index.To ensure that the items are displayed in the same order as their index values, you must set the ListView.ListViewItemSorter property to an implementation of the IComparer interface that sorts items by index value. Pour plus d’informations, consultez la section exemple.For more information, see the Example section.

Vous pouvez modifier la couleur de la marque d’insertion à l' Color aide de la propriété.You can modify the color of the insertion mark by using the Color property. Si vous avez besoin de la taille ou de la position de la marque d’insertion, vous pouvez récupérer son Bounds rectangle englobant via la propriété.If you need the size or position of the insertion mark, you can get its bounding rectangle through the Bounds property.

Notes

La fonctionnalité de marque d’insertion est disponible uniquement sur Windows XP et la famille Windows Server 2003 lorsque votre application Application.EnableVisualStyles appelle la méthode.The insertion mark feature is available only on Windows XP and the Windows Server 2003 family when your application calls the Application.EnableVisualStyles method. Sur les systèmes d’exploitation antérieurs, tout code relatif à la marque d’insertion est ignoré et la marque d’insertion n’apparaît pas.On earlier operating systems, any code relating to the insertion mark will be ignored and the insertion mark will not appear. Par conséquent, tout code qui dépend de la fonctionnalité de marque d’insertion peut ne pas fonctionner correctement.As a result, any code that depends on the insertion mark feature may not work correctly. Vous pouvez inclure un test qui détermine si la fonctionnalité de marque d’insertion est disponible, et fournir d’autres fonctionnalités lorsqu’elle n’est pas disponible.You may want to include a test that determines whether the insertion mark feature is available, and provide alternate functionality when it is unavailable. Par exemple, vous pouvez ignorer tout le code qui implémente le repositionnement des éléments par glisser-déplacer lorsqu’il s’exécute sur des systèmes d’exploitation qui ne prennent pas en charge les marques d’insertion.For example, you may want to bypass all code that implements drag-and-drop item repositioning when running on operating systems that do not support insertion marks.

La fonctionnalité de marque d’insertion est fournie par la même bibliothèque qui fournit la fonctionnalité de thèmes de système d’exploitation.The insertion mark feature is provided by the same library that provides the operating system themes feature. Pour vérifier la disponibilité de cette bibliothèque, appelez la FeatureSupport.IsPresent(Object) surcharge de méthode et transmettez la OSFeature.Themes valeur.To check for the availability of this library, call the FeatureSupport.IsPresent(Object) method overload and pass in the OSFeature.Themes value.

Propriétés

AppearsAfterItem AppearsAfterItem AppearsAfterItem AppearsAfterItem

Obtient ou définit une valeur indiquant si la marque d'insertion apparaît à droite de l'élément avec l'index spécifié par la propriété Index.Gets or sets a value indicating whether the insertion mark appears to the right of the item with the index specified by the Index property.

Bounds Bounds Bounds Bounds

Obtient le rectangle englobant de la marque d'insertion.Gets the bounding rectangle of the insertion mark.

Color Color Color Color

Obtient ou définit la couleur de la marque d'insertion.Gets or sets the color of the insertion mark.

Index Index Index Index

Obtient ou définit l'index de l'élément auprès duquel la marque d'insertion apparaît.Gets or sets the index of the item next to which the insertion mark appears.

Méthodes

Equals(Object) Equals(Object) Equals(Object) Equals(Object)

Détermine si l'objet spécifié est identique à l'objet actuel.Determines whether the specified object is equal to the current object.

(Inherited from Object)
GetHashCode() GetHashCode() GetHashCode() GetHashCode()

Fait office de fonction de hachage par défaut.Serves as the default hash function.

(Inherited from Object)
GetType() GetType() GetType() GetType()

Obtient le Type de l'instance actuelle.Gets the Type of the current instance.

(Inherited from Object)
MemberwiseClone() MemberwiseClone() MemberwiseClone() MemberwiseClone()

Crée une copie superficielle de l'objet Object actuel.Creates a shallow copy of the current Object.

(Inherited from Object)
NearestIndex(Point) NearestIndex(Point) NearestIndex(Point) NearestIndex(Point)

Récupère l'index de l'élément le plus proche du point spécifié.Retrieves the index of the item closest to the specified point.

ToString() ToString() ToString() ToString()

Retourne une chaîne qui représente l'objet actuel.Returns a string that represents the current object.

(Inherited from Object)

S’applique à

Voir aussi