Freigeben über


ListViewInsertionMark Klasse

Definition

Wird verwendet, um die erwartete Position für das Ablegen eines Elements anzugeben, wenn dieses zu einer neuen Position in einem ListView-Steuerelement gezogen wird. Diese Funktionalität steht nur unter Windows XP oder und höher zur Verfügung.

public ref class ListViewInsertionMark sealed
public sealed class ListViewInsertionMark
type ListViewInsertionMark = class
Public NotInheritable Class ListViewInsertionMark
Vererbung
ListViewInsertionMark

Beispiele

Das folgende Codebeispiel veranschaulicht die Verwendung der ListView Einfügemarke-Funktion und implementiert die Neuanordnung von Elementen per Drag-and-Drop mithilfe der standardmäßigen Ziehereignisse. Die Position der Einfügemarke wird in einem Handler für das Control.DragOver Ereignis aktualisiert. In diesem Handler wird die Position des Mauszeigers mit dem Mittelpunkt des nächsten Elements verglichen, und das Ergebnis wird verwendet, um zu bestimmen, ob die Einfügemarke links oder rechts vom Element angezeigt wird.

#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

    <STAThread()> _
    Shared Sub Main()
        Application.EnableVisualStyles()
        Application.Run(New ListViewInsertionMarkExample())
    End Sub
    
    ' 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
    
    ' Sets the target drop effect.
    Private Sub myListView_DragEnter(sender As Object, e As DragEventArgs)
        e.Effect = e.AllowedEffect
    End Sub
    
    ' 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

    ' 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
    
    ' 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
    
    ' 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

End Class

Hinweise

Sie können eine ListViewInsertionMark aus der InsertionMark -Eigenschaft eines ListView Steuerelements abrufen und verwenden, um die erwartete Ablageposition in einem Drag-and-Drop-Vorgang visuell anzugeben, wenn ein Element an eine neue Position gezogen wird.

Dieses Feature funktioniert nur, wenn die ListView.AutoArrange -Eigenschaft auf true festgelegt ist und wenn das ListView Steuerelement die Elemente nicht automatisch sortiert. Um die automatische Sortierung zu verhindern, muss die ListView.Sorting -Eigenschaft auf SortOrder.None festgelegt werden, und die ListView.View -Eigenschaft muss auf View.LargeIcon, View.SmallIconoder View.Tilefestgelegt werden. Darüber hinaus kann das Feature für Einfügemarken nicht mit dem ListView Gruppierungsfeature verwendet werden, da das Gruppierungsfeature die Elemente nach Gruppenmitgliedschaft sortiert.

Die ListViewInsertionMark -Klasse wird in der Regel in einem Handler für das Control.DragOver - oder Control.MouseMove -Ereignis verwendet, um die Position der Einfügemarke zu aktualisieren, wenn ein Element gezogen wird. Es wird auch in einem Handler für das - oder Control.MouseUp -Control.DragDropEreignis verwendet, um ein gezogenes Element an der richtigen Position einzufügen.

Führen Sie die folgenden Schritte aus, um die Position der Einfügemarke zu aktualisieren:

  1. Verwenden Sie in einem Handler für das Control.DragOver -Ereignis oder Control.MouseMove die ListView.InsertionMark -Eigenschaft, um auf das ListViewInsertionMark Objekt zuzugreifen, das dem ListView Steuerelement zugeordnet ist.

  2. Verwenden Sie die NearestIndex -Methode, um den Index des Elements abzurufen, das dem Mauszeiger am nächsten ist.

  3. Übergeben Sie den Indexwert an die ListView.GetItemRect -Methode, um das umgebende Rechteck des Elements abzurufen.

  4. Wenn sich der Mauszeiger links vom Mittelpunkt des umgebenden Rechtecks befindet, legen Sie die AppearsAfterItem -Eigenschaft auf falsefest; andernfalls legen Sie ihn auf fest true.

  5. Legen Sie die Index -Eigenschaft auf den Indexwert fest, der von der NearestIndex -Methode abgerufen wird. Die Einfügemarke wird neben dem Element mit dem angegebenen Index angezeigt, je nach AppearsAfterItem Eigenschaftswert entweder links oder rechts. Wenn ein Element über sich selbst gezogen wird, ist der Index -1 und die Einfügemarke ausgeblendet.

Führen Sie die folgenden Schritte aus, um das gezogene Element an der richtigen Position einzufügen:

  1. Verwenden Sie in einem Handler für das Control.DragDrop - oder Control.MouseUp -Ereignis die Index -Eigenschaft, um die aktuelle Position der Einfügemarke zu bestimmen. Speichern Sie diesen Wert, der später als Einfügeindex verwendet werden soll.

  2. Wenn die AppearsAfterItem -Eigenschaft auf truefestgelegt ist, inkrementieren Sie den gespeicherten Einfügeindexwert.

  3. Verwenden Sie die ListView.ListViewItemCollection.Insert -Methode, um einen Klon des gezogenen Elements in die ListView.Items Auflistung am gespeicherten Einfügeindex einzufügen.

  4. Verwenden Sie die ListView.ListViewItemCollection.Remove -Methode, um die ursprüngliche Kopie des gezogenen Elements zu entfernen.

Sie müssen einen Klon des gezogenen Elements einfügen, bevor die ursprüngliche Kopie entfernt wird, damit die Indexwerte in der ListView.Items Auflistung vor dem Einfügen nicht geändert werden.

Um sicherzustellen, dass die Elemente in derselben Reihenfolge wie ihre Indexwerte angezeigt werden, müssen Sie die ListView.ListViewItemSorter -Eigenschaft auf eine Implementierung der Schnittstelle festlegen, die IComparer Elemente nach Indexwert sortiert. Weitere Informationen finden Sie im Abschnitt Beispiel.

Sie können die Farbe der Einfügemarke mithilfe der Color -Eigenschaft ändern. Wenn Sie die Größe oder Position der Einfügemarke benötigen, können Sie das umgebende Rechteck über die Bounds -Eigenschaft abrufen.

Hinweis

Das Feature "Einfügemarke" ist nur unter Windows XP und der Windows Server 2003-Familie verfügbar, wenn Ihre Anwendung die Application.EnableVisualStyles -Methode aufruft. Bei früheren Betriebssystemen wird jeglicher Code, der sich auf die Einfügemarke bezieht, ignoriert, und die Einfügemarke wird nicht angezeigt. Daher funktioniert jeder Code, der von der Einfügemarkungsfunktion abhängt, möglicherweise nicht ordnungsgemäß. Möglicherweise möchten Sie einen Test einschließen, der bestimmt, ob die Einfügemarke-Funktion verfügbar ist, und alternative Funktionen bereitstellen, wenn sie nicht verfügbar ist. Beispielsweise können Sie den gesamten Code umgehen, der die Neupositionierung von Elementen per Drag-and-Drop implementiert, wenn sie unter Betriebssystemen ausgeführt wird, die keine Einfügemarken unterstützen.

Das Feature "Einfügemarke" wird von derselben Bibliothek bereitgestellt, die das Feature "Betriebssystemdesigns" bereitstellt. Um die Verfügbarkeit dieser Bibliothek zu überprüfen, rufen Sie die FeatureSupport.IsPresent(Object) Methodenüberladung auf, und übergeben Sie den OSFeature.Themes Wert.

Eigenschaften

AppearsAfterItem

Ruft einen Wert ab, der angibt, ob die Einfügemarke rechts neben dem Element mit dem in der Index-Eigenschaft angegebenen Index angezeigt wird, oder legt diesen fest.

Bounds

Ruft das umschließende Rechteck der Einfügemarke ab.

Color

Ruft die Farbe der Einfügemarke ab oder legt diese fest.

Index

Ruft den Index des Elements ab, neben dem die Einfügemarke angezeigt wird, oder legt diesen fest.

Methoden

Equals(Object)

Bestimmt, ob das angegebene Objekt gleich dem aktuellen Objekt ist.

(Geerbt von Object)
GetHashCode()

Fungiert als Standardhashfunktion.

(Geerbt von Object)
GetType()

Ruft den Type der aktuellen Instanz ab.

(Geerbt von Object)
MemberwiseClone()

Erstellt eine flache Kopie des aktuellen Object.

(Geerbt von Object)
NearestIndex(Point)

Ruft den Index des dem angegebenen Punkt am nächsten liegenden Elements ab.

ToString()

Gibt eine Zeichenfolge zurück, die das aktuelle Objekt darstellt.

(Geerbt von Object)

Gilt für:

Weitere Informationen