- \n
- AfterLabelEdit<\/b>: Wird ausgelöst, nachdem der Benutzer die Bearbeitung einer Beschriftung beendet hat. Dient zur Prüfung oder Speicherung des geänderten Textes.<\/li>\n
- BeforeLabelEdit<\/b>: Tritt auf, bevor ein Benutzer die Beschriftung bearbeiten darf. Ermöglicht das Zulassen oder Verhindern des Editierens, wenn der Benutzer ein Element zu Bearbeiten anklicken will.<\/li>\n
- Click<\/b>: Wird ausgelöst, wenn der Benutzer auf das Steuerelement klickt (einfacher Klick, unabhängig vom ausgewählten Element).<\/li>\n
- ColumnClick<\/b>: Wird ausgelöst, wenn der Benutzer auf eine Spaltenüberschrift klickt. Wird häufig genutzt, um die Sortierung nach Spalten zu steuern.<\/li>\n
- DblClick<\/b>: Wird ausgelöst, wenn der Benutzer auf ein Element doppelklickt. Dient oft zum Öffnen oder Bearbeiten des gewählten Eintrags.<\/li>\n
- ItemCheck<\/b>: Tritt auf, wenn ein Kontrollkästchen neben einem ListItem<\/b> aktiviert oder deaktiviert wird. Nur relevant, wenn Checkboxes = True <\/b>gesetzt ist.<\/li>\n
- ItemClick<\/b>: Wird ausgelöst, wenn der Benutzer auf ein bestimmtes ListItem<\/b>-Element klickt. Liefert direkten Zugriff auf das betroffene Element.<\/li>\n
- KeyDown<\/b>: Wird ausgelöst, wenn eine Taste gedrückt wird. Liefert Informationen über Tastencode und Status von Umschalt<\/b>-, Strg<\/b>– oder Alt<\/b>-Tasten.<\/li>\n
- KeyPress<\/b>: Wird ausgelöst, wenn ein druckbares Zeichen eingegeben wird. Dient häufig zur Filterung von Eingaben.<\/li>\n
- KeyUp<\/b>: Wird ausgelöst, wenn eine Taste losgelassen wird. Kann genutzt werden, um Tastenkombinationen auszuwerten.<\/li>\n
- MouseDown<\/b>: Wird ausgelöst, wenn eine Maustaste gedrückt wird. Liefert Informationen über Maustaste, Position und Status der Umschalttasten.<\/li>\n
- MouseMove<\/b>: Wird ausgelöst, wenn der Mauszeiger über das Steuerelement bewegt wird. Nützlich für eigene Hover-Effekte.<\/li>\n
- MouseUp<\/b>: Wird ausgelöst, wenn eine zuvor gedrückte Maustaste losgelassen wird.<\/li>\n
- OLECompleteDrag<\/b>: Wird ausgelöst, nachdem eine Drag and Drop-Operation abgeschlossen wurde. Dient zum Bereinigen oder Aktualisieren des Zustands.<\/li>\n
- OLEDragDrop<\/b>: Wird ausgelöst, wenn ein Objekt über dem Steuerelement abgelegt wird. Hier wird üblicherweise der Drop-Inhalt verarbeitet.<\/li>\n
- OLEDragOver<\/b>: Wird fortlaufend ausgelöst, während ein Objekt über dem Steuerelement bewegt wird. Eignet sich zur Anzeige von Drop-Zielen.<\/li>\n
- OLEGiveFeedback<\/b>: Wird während einer Drag and Drop-Operation ausgelöst. Ermöglicht die Anpassung des Mauszeigers oder Feedback-Verhaltens.<\/li>\n
- OLESetData<\/b>: Wird ausgelöst, wenn das Steuerelement Daten bereitstellen soll, die per Drag and Drop übergeben werden.<\/li>\n
- OLEStartDrag<\/b>: Wird ausgelöst, wenn der Benutzer eine Drag and Drop-Operation startet. Hier werden üblicherweise die zu übertragenden Daten festgelegt.<\/li>\n
- Updated<\/b>: wird in VBA nicht ausgelöst<\/li>\n<\/ul>\n
Spaltenköpfe und Einträge vor dem erneuten Füllen leeren<\/h2>\n
Manchmal werden die angelegten Einträge für die Spaltenköpfe und die Zeilen des ListView<\/b>-Steuerelements beim Schließen gespeichert, sodass ein erneutes Öffnen und der Versuch, die Elemente erneut anzulegen, zu einem Fehler führt.<\/p>\n
Daher sollte man diese Elemente vorsichtshalber immer löschen, bevor man das ListView<\/b>-Steuerelement erneut füllt:<\/p>\n
objListView.ColumnHeaders.Clear\r\nobjListView.ListItems.Clear<\/pre>\n
Spalten anordnen<\/h2>\n
Damit der Benutzer die Spalten eines ListView<\/b>-Steuerelements anordnen kann, müssen wir die Eigenschaft AllowColumnReorder <\/b>auf True <\/b>einstellen:<\/p>\n
objListView.AllowColumnReorder = True<\/span><\/pre>\nDanach kann der Benutzer die Spalten wie in Bild 1 umsortieren.<\/p>\n
![\"Umsortierte](\"..\/fileadmin\/_temp_\/2025_06\/pic_1573_001.png\")
<\/p>\nBild 1: Umsortierte Spalten im ListView-Steuerelement<\/span><\/b><\/p>\n
Leider gibt es kein Ereignis, dass durch das Umsortieren ausgelöst wird, sodass wir die Anordnung nicht ohne größeren Aufwand speichern und beim nächsten Öffnen des Formulars wiederherstellen können (siehe Formular frmListView_SpaltenAnordnen <\/b>der Beispieldatenbank).<\/p>\n
Selektierte Spalten vollständig markieren<\/h2>\n
Vom Listenfeld von Access sind wir gewohnt, dass markierte Einträge vollständig markiert werden. Im ListView<\/b>-Steuerelement wird standardmäßig nur die erste Spalte des ausgewählten Eintrags markiert. Dies können wir ändern, indem wir die Eigenschaft FullRowSelect <\/b>auf True <\/b>einstellen:<\/p>\n
objListView.FullRowSelect = True<\/span><\/pre>\nMarkieren wir nun eine Zeile, werden alle Spalten markiert (siehe Bild 2) – siehe frmListView_EintragMarkieren<\/b>.<\/p>\n
![\"Vollständige](\"..\/fileadmin\/_temp_\/2025_06\/pic_1573_004.png\")
<\/p>\nBild 2: Vollständige Zeile markieren<\/span><\/b><\/p>\n
Markierung bei Fokusverlust beibehalten<\/h2>\n
Standardmäßig ist die Markierung des aktuellen Eintrags nicht mehr sichtbar, wenn das ListView<\/b>-Steuerelement den Fokus verliert.<\/p>\n
Dem können wir zumindest teilweise entgegenwirken, indem wir die Eigenschaft HideSelection <\/b>auf False <\/b>einstellen:<\/p>\n
objListView.HideSelection = False<\/span><\/pre>\nDie aktuelle Zeile wird nun immerhin noch grau hinterlegt (siehe Bild 3).<\/p>\n
![\"Markierung](\"..\/fileadmin\/_temp_\/2025_06\/pic_1573_005.png\")
<\/p>\nBild 3: Markierung im ListView-Steuerelement bei Fokusverlust beibehalten<\/span><\/b><\/p>\n
Objektvariable modulweit deklarieren<\/h2>\n
In den folgenden Beispielen wollen wir aus anderen Prozeduren heraus auf das ListView<\/b>-Steuerelement zugreifen. Dazu könnten wir dieses immer wieder neu deklarieren und referenzieren, aber diesen Aufwand wollen wir uns sparen. Also deklarieren wir objListView <\/b>wie folgt im Kopf der Prozedur:<\/p>\n
Dim <\/span>objListView As <\/span>MSComctlLib.ListView<\/pre>\nDann reicht es, wenn wir diese Variable einmal in der Ereignisprozedur Beim Laden <\/b>füllen:<\/p>\n
Set<\/span> objListView = Me.ctlListView.Object<\/pre>\nIn den weiteren Prozeduren können wir anschließend einfach auf objListView <\/b>zugreifen.<\/p>\n
Markierten Eintrag auslesen<\/h2>\n
Im Formular frmListView_Auslesen <\/b>zeigen wir, wie der aktuell markierte Listeneintrag ausgelesen werden kann. Dabei greifen wir auf den Key und den Text der ersten Spalte zu und geben diese Informationen in einem Meldungsfenster aus (siehe Bild 4).<\/p>\n
![\"Eintrag](\"..\/fileadmin\/_temp_\/2025_06\/pic_1573_002.png\")
<\/p>\nBild 4: Eintrag im ListView-Steuerelement auslesen<\/span><\/b><\/p>\n
Für die Schaltfläche cmdAktuellenEintragAuslesen <\/b>hinterlegen wir den folgenden Code:<\/p>\n
Private Sub <\/span>cmdAktuellenEintragAuslesen_Click()\r\n Dim <\/span>objListItem As <\/span>MSComctlLib.ListItem\r\n Set<\/span> objListItem = objListView.SelectedItem\r\n If <\/span>Not<\/span> objListItem Is Nothing Then<\/span>\r\n MsgBox<\/span> \"Es wurde der Eintrag mit dem Key ''\" _\r\n & objListItem.Key & \"'' und dem Text ''\" _\r\n & objListItem.Text & \"'' ausgewählt.\"\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\nHier lesen wir mit der Eigenschaft SelectedItem <\/b>den aktuellen Eintrag aus. Ist das Ergebnis nicht Nothing<\/b>, können wir über die Eigenschaften Key <\/b>und Text <\/b>von objListItem <\/b>auf die entsprechenden Werte zugreifen.<\/p>\n
Werte weiterer Spalten auslesen<\/h2>\n
Gegebenenfalls sind auch noch die übrigen Spalten des aktuell markierten Eintrags interessant. Diese wollen wir ein einer Meldung wie in Bild 5 ausgeben.<\/p>\n
![\"Weitere](\"..\/fileadmin\/_temp_\/2025_06\/pic_1573_003.png\")
<\/p>\nBild 5: Weitere Spalten des markierten Eintrags auslesen<\/span><\/b><\/p>\n
Dazu fügen wir für die zweite Schaltfläche diese Prozedur hinzu:<\/p>\n
Private Sub <\/span>cmdWeitereSpaltenAuslesen_Click()\r\n ...\r\n Dim <\/span>objListSubItem As <\/span>MSComctlLib.ListSubItem\r\n Dim <\/span>strSubItems As String<\/span>\r\n Set<\/span> objListItem = objListView.SelectedItem\r\n If <\/span>Not<\/span> objListItem Is Nothing Then<\/span>\r\n For Each objListSubItem In objListItem.ListSubItems\r\n With<\/span> objListSubItem\r\n strSubItems = strSubItems & vbCrLf<\/span> _\r\n & .Index & \" \" & .Key & \" \" & .Text\r\n End With<\/span>\r\n Next<\/span> objListSubItem\r\n End If<\/span>\r\n MsgBox<\/span> \"Weitere Spalten: \" & strSubItems\r\nEnd Sub<\/span><\/pre>\nDie Prozedur deklariert zusätzlich eine Variable des Typs ListSubItem<\/b>. Nachdem wir mit objListItem <\/b>den aktuellen Eintrag markiert haben, durchlaufen wir in einer For Each<\/b>-Schleife alle Elemente der Auflistung ListSubItems<\/b>. Für diese stellen wir jeweils eine Zeile mit dem Index<\/b>, dem Key <\/b>und dem Text <\/b>in der Variablen strSubItems <\/b>zusammen.<\/p>\n
Einen Eintrag markieren<\/h2>\n
Wir wollen nicht nur den aktuellen Eintrag auslesen, sondern diesen auch einstellen können. Dazu haben wir das Formular frmListView_EintragSelektieren <\/b>angelegt. Hier finden wir drei Schaltflächen. Die erste Schaltfläche löst die folgende Prozedur aus und selektiert damit den zweiten Eintrag durch Angabe des Index<\/b>-Wertes dieses Eintrags beim Zuweisen des Wertes True <\/b>an die Eigenschaft Selected<\/b>:<\/p>\n
Private Sub <\/span>cmdZweitenEintragPerIndex_Click()\r\n objListView.ListItems(2).Selected = True<\/span>\r\n Me.ctlListView.SetFocus\r\nEnd Sub<\/span><\/pre>\nWir können auch einen Eintrag über den Key<\/b>-Wert selektieren. Das erledigen wir mit der zweiten Schaltfläche:<\/p>\n
Private Sub <\/span>cmdDrittenEintragPerKey_Click()\r\n objListView.ListItems(\"a31\").Selected = True<\/span>\r\n Me.ctlListView.SetFocus\r\nEnd Sub<\/span><\/pre>\nSchließlich wollen wir auch noch die Selektion leeren können. <\/p>\n
Die folgende Prozedur ermittelt den markierten Eintrag und wählt diesen ab:<\/p>\n
Private Sub <\/span>cmdAlleEintraegeAbwaehlen_Click()\r\n Dim <\/span>objListItem As <\/span>MSComctlLib.ListItem\r\n Set<\/span> objListItem = objListView.SelectedItem\r\n objListItem.Selected = False<\/span>\r\nEnd Sub<\/span><\/pre>\nMehrfachauswahl im ListView-Steuerelement<\/h2>\n
Im Formular frmListView_Mehrfachauswahl_Auslesen <\/b>setzen wir uns mit der Mehrfachauswahl im ListView<\/b>-Steuerelement auseinander (siehe Bild 6). Dazu stellen wir zunächst die Eigenschaft auf True <\/b>ein:<\/p>\n
![\"Markieren](\"..\/fileadmin\/_temp_\/2025_06\/pic_1573_010.png\")
<\/p>\nBild 6: Markieren von Einträgen im ListView-Steuerelement<\/span><\/b><\/p>\n
objListView.MultiSelect = True<\/span><\/pre>\nDamit können wir nun wie in bei gedrückter Umschalt<\/b>– oder Strg<\/b>-Taste wie im Windows Explorer mehrere Einträge gleichzeitig markieren.<\/p>\n
Private Sub <\/span>cmdAktuelleEintraegeAuslesen_Click()\r\n Dim <\/span>objListItem As <\/span>MSComctlLib.ListItem\r\n Dim <\/span>strSelected As String<\/span>\r\n For Each objListItem In objListView.ListItems\r\n If <\/span>objListItem.Selected Then<\/span>\r\n strSelected = strSelected & vbCrLf<\/span> _\r\n & objListItem.Key & \" \" & objListItem.Text\r\n End If<\/span>\r\n Next<\/span> objListItem\r\n MsgBox<\/span> \"Markierte Einträge:\" & strSelected\r\nEnd Sub<\/span><\/pre>\nDie Prozedur durchläuft alle Einträge des Listenfeldes. Darin prüft sie mit der Selected<\/b>-Eigenschaft, ob der jeweilige Eintrag markiert ist.<\/p>\n
Wenn wir anschließend die Schaltfläche betätigen, erhalten wir eine Liste der markierten Einträge (siehe Bild 7).<\/p>\n
![\"Ausgabe](\"..\/fileadmin\/_temp_\/2025_06\/pic_1573_006.png\")
<\/p>\nBild 7: Ausgabe der Einträge einer Mehrfachauswahl<\/span><\/b><\/p>\n
Mehrere Einträge im ListView per VBA selektieren<\/h2>\n
Nun wollen wir mehrere Einträge in einer Mehrfachauswahl per VBA selektieren (siehe frmListView_MehrereEintraegeSelektieren<\/b>). Im Beispiel wollen wir mit einer Schaltfläche den ersten und den dritten Eintrag selektieren.<\/p>\n
Die Schaltfläche löst die folgende Prozedur aus:<\/p>\n
Private Sub <\/span>cmdMehrereEintraegeSelektieren_Click()\r\n Dim <\/span>objListItem As <\/span>MSComctlLib.ListItem\r\n Set<\/span> objListItem = objListView.ListItems(1)\r\n objListItem.Selected = True<\/span>\r\n Set<\/span> objListItem = objListView.ListItems(3)\r\n objListItem.Selected = True<\/span>\r\n Me.ctlListView.SetFocus\r\nEnd Sub<\/span><\/pre>\nHier selektieren wir zuerst den ersten Eintrag und markieren diesen und führen die gleichen Schritte dann für den dritten Eintrag aus. Das Ergebnis sehen wir in Bild 8.<\/p>\n
![\"Mehrfachauswahl](\"..\/fileadmin\/_temp_\/2025_06\/pic_1573_011.png\")
<\/p>\nBild 8: Mehrfachauswahl per VBA selektieren<\/span><\/b><\/p>\n
Die zweite Schaltfläche wählt alle Einträge wieder ab.<\/p>\n
Sie durchläuft alle Einträge und stellt für den Wert der Eigenschaft Selected <\/b>jeweils auf False <\/b>ein:<\/p>\n
Private Sub <\/span>cmdAlleEintraegeAbwaehlen_Click()\r\n Dim <\/span>objListItem As <\/span>MSComctlLib.ListItem\r\n For Each objListItem In objListView.ListItems\r\n objListItem.Selected = False<\/span>\r\n Next<\/span> objListItem\r\nEnd Sub<\/span><\/pre>\nSortieren der Einträge<\/h2>\n
Wie können die Einträge des Listenfeldes jeweils nach einer Spalte aufsteigend oder absteigend sortieren (siehe Formular frmListView_Sortieren<\/b>). Dazu benötigen wir eine Prozedur, die durch das Ereignis ColumnClick <\/b>des ListView<\/b>-Steuerelements ausgelöst wird.<\/p>\n
Diese Ereignisprozedur legen wir an, indem wir im Codefenster für das Klassenmodul des Formulars aus der linken Liste den Eintrag für das ListView<\/b>-Steuerelement auswählen und aus der rechten den Eintrag ColumnClick <\/b>(siehe Bild 9).<\/p>\n
![\"Anlegen](\"..\/fileadmin\/_temp_\/2025_06\/pic_1573_007.png\")
<\/p>\nBild 9: Anlegen einer Ereignisprozedur für das ListView-Steuerelement<\/span><\/b><\/p>\n
Die so erstellte Ereignisprozedur lvwListView_ColumnClick <\/b>füllen wir wie folgt:<\/p>\n
Private Sub <\/span>ctlListView_ColumnClick(ByVal ColumnHeader _\r\n As Object<\/span>)\r\n Static <\/span>intAktuelleSortierspalte As Integer<\/span>\r\n Static <\/span>bolAufsteigend As Boolean<\/span>\r\n objListView.SortKey = ColumnHeader.Index - 1\r\n If <\/span>intAktuelleSortierspalte = ColumnHeader.Index - 1 Then<\/span>\r\n bolAufsteigend = Not<\/span> bolAufsteigend\r\n objListView.SortOrder = Abs(bolAufsteigend)\r\n Else<\/span>\r\n objListView.SortOrder = lvwAscending\r\n End If<\/span>\r\n objListView.Sorted = True<\/span>\r\n intAktuelleSortierspalte = ColumnHeader.Index - 1\r\nEnd Sub<\/span><\/pre>\nSie enthält zwei als statisch deklarierte Variablen. Das heißt, dass diese Variablen auch nach dem Verlassen der Prozedur ihre Werte behalten, aber außerhalb der Prozedur dennoch nicht zugreifbar sind. Die Prozedur liest bekommt mit dem Parameter Columnheader <\/b>einen Verweis auf den Spaltenkopf, den der Benutzer angeklickt hat.<\/p>\n
Aus diesem lesen wir den aktuellen Sortierindex aus. Diesen ermitteln wir aus ColumnHeader.Index – 1<\/b> und weisen diesen der Eigenschaft SortKey <\/b>des ListView<\/b>-Steuerelements zu. Damit legen wir fest, welche Spalte sortiert werden soll.<\/p>\n
Danach prüfen wir, ob intAktuelleSortierspalte <\/b>den gleichen Wert wie ColumnHeader.Index – 1 <\/b>hat. In diesem Fall kehren wir den Wert der Variablen bolAufsteigend<\/b>, der standardmäßig 0 <\/b>ist, um und weisen den Wert ohne Vorzeichen der Eigenschaft SortOrder <\/b>zu.<\/p>\n
Der Wert 0 <\/b>entspricht der Konstanten lvwAscending <\/b>(aufsteigend), der Wert 1 <\/b>der Konstanten lvwDescending <\/b>(absteigend).<\/p>\n
Falls intAktuelleSortierspalte <\/b>nicht der markierten Spalte entspricht, soll die Sortierreihenfolge auf lvwAscending <\/b>(aufsteigend) eingestellt werden. Das ist immer der Fall, wenn nicht die gleiche Spalte wie zuvor angeklickt wurde.<\/p>\n
Durch das Einstellen der Eigenschaft Sorted <\/b>auf den Wert True <\/b>wird die Sortierung angewendet.<\/p>\n
Schließlich stellt die Prozedur die Variable intAktuelleSortierspalte <\/b>auf den aktuellen Index minus 1 ein. Damit stellen wir sicher, dass wir, wenn der Benutzer erneut auf den gleichen Spaltenkopf klickt, diese Spalte nun andersherum sortieren.<\/p>\n
Wert der ersten Spalte ändern<\/h2>\n
Wir können zwar im ListView<\/b>-Steuerelement nicht direkt Daten bearbeiten, wie es im Datenblatt der Fall ist. Aber wir können immerhin den Wert der ersten Spalte anpassen.<\/p>\n
Dies müssen wir wie in allerdings zunächst aktivieren, indem wir die Eigenschaft LabelEdit <\/b>auf den Wert lvwAutomatic <\/b>einstellen:<\/p>\n
objListView.LabelEdit = lvwAutomatic<\/pre>\n
Standardmäßig steht dieser Wert auf lvwManual<\/b>. Sobald wir diesen geändert haben, können wir den Wert der ersten Spalte anklicken und dieser wird wie im Windows Explorer zum Ändern markiert (siehe Bild 10).<\/p>\n
![\"Umbenennen](\"..\/fileadmin\/_temp_\/2025_06\/pic_1573_008.png\")
<\/p>\nBild 10: Umbenennen eines Eintrags<\/span><\/b><\/p>\n
Auf Änderungen reagieren<\/h2>\n
Wenn man im ListView<\/b>-Steuerelement reale Daten anzeigt und den Benutzer diese ändern lässt, werden die Änderungen nicht automatisch in die Datenherkunft übernommen. Wir verwenden in diesem Beispiel zwar nur einige Beispieldaten, aber wir stellen dennoch die Vorgehensweise vor, um auf Änderungen zu reagieren und den neuen Wert zu ermitteln.<\/p>\n
Wir haben gleich zwei Ereignisse, die durch das Ändern eines Eintrags ausgelöst werden. BeforeLabelEdit <\/b>wird bereits beim Anklicken des jeweiligen Eintrags zum Ändern ausgelöst, aber bevor dieser zum Ändern freigegeben wird. Wir können hier beispielsweise prüfen, ob der aktuelle Eintrag geändert werden darf. Falls nicht, können wir in der Prozedur eine Meldung ausgeben und brechen den Änderungsvorgang durch Setzen des Parameters Cancel <\/b>auf den Wert True <\/b>ab.<\/p>\n
Interessanter ist die zweite Ereignisprozedur AfterLabelEdit<\/b>. Diese wird ausgelöst, wenn der Benutzer die Änderung eingetragen hat und beispielsweise mit der Eingabetaste abschließt. Diese Prozedur liefert nicht nur den Parameter Cancel<\/b>, mit dem wir den Änderungsvorgang abbrechen können, wenn der eingegebene Wert beispielsweise nicht validiert werden kann, sondern auch noch den Parameter NewString<\/b>, der den neu eingetragenen Wert zurückliefert.<\/p>\n
Wir fügen die Prozedur ctlListView_AfterLabelEdit<\/b> über die beiden Auswahlfelder des Codefensters hinzu und füllen sie wie in Listing 1. Die Prozedur deklariert eine Variable namens objListItem<\/b>, in die wir mit der Eigenschaft SelectedItem <\/b>den aktuell markierten Eintrag beim Durchführen der Änderung eintragen. Aus diesem Eintrag lesen wir den Key und den Text aus und speichern beide in den Variablen strKey <\/b>und strOldString<\/b>.<\/p>\n
Private Sub <\/span>ctlListView_AfterLabelEdit(Cancel As Integer<\/span>, NewString As String<\/span>)\r\n Dim <\/span>objListItem As <\/span>MSComctlLib.ListItem\r\n Dim <\/span>strKey As String<\/span>\r\n Dim <\/span>strOldString As String<\/span>\r\n \r\n Set<\/span> objListItem = objListView.SelectedItem\r\n strKey = objListItem.Key\r\n strOldString = objListItem.Text\r\n \r\n MsgBox<\/span> \"Der Eintrag mit dem Key ''\" & strKey & \"'' soll geändert werden von ''\" & strOldString & \"'' auf ''\" & NewString & \"''.\"\r\nEnd Sub<\/span><\/pre>\nListing 1: Reagieren auf die Änderung eines ListView-Eintrags<\/span><\/b><\/p>\n
Danach geben wir diese Informationen in einer Meldung wie in Bild 11 aus.<\/p>\n
![\"Ereignis](\"..\/fileadmin\/_temp_\/2025_06\/pic_1573_009.png\")
<\/p>\nBild 11: Ereignis vor dem Umbenennen<\/span><\/b><\/p>\n
Auf Doppelklick reagieren<\/h2>\n
Der einfache Klick selektiert einen Eintrag, daher macht es wenig Sinn, hier noch weitere Funktionen zu hinterlegen. Wenn wir zum Beispiel Details zu einem Datensatz im ListView<\/b>-Steuerelement anzeigen wollen, können wir das beispielsweise per Doppelklick machen (siehe frmListView_AktionPerDoppelklick<\/b>).<\/p>\n
Dazu nutzen wir das Ereignis DblClick<\/b>, das wir über das Codefenster anlegen und wie folgt füllen:<\/p>\n
Private Sub <\/span>ctlListView_DblClick()\r\n Dim <\/span>objListItem As <\/span>MSComctlLib.ListItem\r\n Dim <\/span>lngIndex As Long<\/span>\r\n Dim <\/span>strKey As String<\/span>\r\n Dim <\/span>strText As String<\/span>\r\n - BeforeLabelEdit<\/b>: Tritt auf, bevor ein Benutzer die Beschriftung bearbeiten darf. Ermöglicht das Zulassen oder Verhindern des Editierens, wenn der Benutzer ein Element zu Bearbeiten anklicken will.<\/li>\n