<\/p>\n
Wenn Sie Daten im Listenfeld anzeigen, die durch den Benutzer etwa per Doppelklick bearbeitet oder per Schaltfläche gelöscht oder erweitert werden sollen, lässt sich dies leicht erledigen. Eher selten trifft man auf Listenfelder, deren Einträge man einfach durch Markieren und Betätigen der Entf-Taste löschen kann. Wie Sie dies programmieren, schauen wir uns im vorliegenden Beitrag an.<\/b><\/p>\n
Einfach Daten im Listenfeld markieren und mit der Entf-Taste löschen – das wäre in vielen Fällen eine praktische Erweiterung der sonst üblichen Löschen-Schaltfläche. Wenn man mehr als einen Datensatz aus der Liste löschen möchte, muss man sonst nämlich ordentlich mit der Maus arbeiten – markieren, auf Löschen klicken, markieren, auf Löschen klicken …<\/p>\n
Das können wir auch einfacher programmieren und dem Benutzer so die Anwendung vereinfachen.<\/p>\n
Als Erstes schauen wir uns an, wie wir Einträge aus einem ungebundenen Listenfeld löschen können. Dieses legen wir unter dem Namen lstUngebunden <\/b>in einem neuen Formular an. Das Formular soll beim Laden einige Einträge zum Listenfeld hinzufügen, was wir mit folgender Ereignisprozedur erledigen:<\/p>\n Die Prozedur stellt die Eigenschaft Herkunftsart <\/b>des Listenfeldes auf Wertliste <\/b>ein und fügt innerhalb einer For…Next<\/b>-Schleife zehn durchnummerierte Einträge zum Listenfeld hinzu.<\/p>\n Dies liefert das Listenfeld mit den Einträgen aus Bild 1. Wenn wir nun einen der Einträge per Tastatur mit der Entf<\/b>-Taste löschen wollen, müssen wir die Tastenereignisse des Listenfeldes hinzuziehen. In diesem Fall wollen wir den Eintrag löschen, sobald der Benutzer die Entf<\/b>-Taste herunterdrückt. Dazu hinterlegen wir die Ereignisprozedur aus Listing 1 für das Ereignis Bei Taste ab <\/b>des Listenfeldes.<\/p>\n Bild 1: Listenfeld mit Beispieldaten<\/span><\/b><\/p>\n Die Prozedur prüft, ob der Wert des Parameters KeyCode<\/b>, der beim Herunterdrücken der Taste geliefert wird, der Zahl 46 <\/b>entspricht. In diesem Fall ermittelt die Prozedur den Index des aktuell markierten Eintrags im Listenfeld und schreibt diesen in die Variable lngItem<\/b>.<\/p>\n Diese Variable prüft die folgende If…Then<\/b>-Bedingung auf den Wert -1<\/b>. Ist der Wert nicht gleich -1<\/b>, ruft die Prozedur die RemoveItem<\/b>-Methode des Listenfeldes auf und übergibt mit lngItem <\/b>den Index der zu löschenden Zeile. Damit wird der aktuell markierte Eintrag entfernt. Das Listenfeld behält den Fokus, aber danach ist kein Datensatz markiert (siehe Bild 2). Sollten wir die Markierung nach dem Löschen auf einen anderen Datensatz verschieben Denkbar wäre, dass der Benutzer beispielsweise von oben nach unten einige Datensätze löschen möchte. Also markieren wir nach dem Löschen den Datensatz, der sich direkt unterhalb des gelöschten Datensatzes befunden hat.<\/p>\n Bild 2: Listenfeld nach dem Löschen eines Datensatzes<\/span><\/b><\/p>\n Dazu haben wir hinter der Zeile mit der RemoveItem<\/b>-Methode zunächst die folgende Zeile eingefügt:<\/p>\n Damit kann der Benutzer nun durch mehrmaliges Betätigen der Entf<\/b>-Taste mehrere untereinander liegende Einträge hintereinander löschen, ohne zwischendurch einen neuen Datensatz markieren zu müssen. Soll ein Datensatz nicht gelöscht werden, kann der Benutzer den nächsten Datensatz mit den Nach oben<\/b>– und Nach unten<\/b>-Tasten ansteuern.<\/p>\n Allerdings war dies etwas zu kurz gedacht, denn die Prozedur lieferte einen Fehler, wenn wir den letzten vorhandenen Eintrag gelöscht haben – und auch das Löschen des letzten Eintrags der Liste lieferte regelmäßig einen Fehler.<\/p>\n Also haben wir noch ein paar verschachtelte Bedingungen hinzugefügt. Die erste fragt ab, ob das Listenfeld überhaupt noch Einträge enthält. Falls nicht, wird auch kein Eintrag mehr markiert. Falls doch, prüfen wir, ob lngItem<\/b>, also der Index des gelöschten und des nun zu markierenden Datensatzes, der letzte Eintrag im Listenfeld ist. Falls nein, wird einfach der Eintrag mit dem Index des gelöschten Eintrags markiert, also der erste Eintrag hinter dem gelöschten Eintrag. Sollten wir uns schon an der letzten Position befinden, markiert die Prozedur den letzten Eintrag des Listenfeldes.<\/p>\n Auf diese Weise können wir auch den hinteren Eintrag markieren und von dort aus alle Einträge von hinten nach vorne löschen, ohne dass wir zwischendurch einen Eintrag von Hand markieren müssen.<\/p>\n Nun wollen wir uns ansehen, wie wir Einträge aus einem Listenfeld löschen können, für das die Mehrfachauswahl aktiviert ist. Dazu fügen wir dem Beispielformular ein weiteres Listenfeld namens lstUngebundenMehrfach <\/b>hinzu, dessen Eigenschaft Mehrfachauswahl <\/b>wir auf Einfach <\/b>oder Erweitert <\/b>einstellen. Damit auch dieses Listenfeld mit einigen Beispieleinträgen gefüllt wird, fügen wir der For…Next<\/b>-Schleife der Prozedur Form_Load <\/b>die folgende Zeile hinzu:<\/p>\n In diesem Fall können wir nicht nur einen, sondern mehrere Einträge markieren (siehe Bild 3). Wir fügen der Prozedur, die durch das Ereignis Bei Taste ab <\/b>des Listenfeldes lstUngebundenMehrfach <\/b>ausgelöst wird, die Zeilen aus Listing 2 hinzu.<\/p>\n Bild 3: Löschen einer Mehrfachauswahl<\/span><\/b><\/p>\n Wenn wir dann die Einträge wie im Bild oben markieren und auf die Entf<\/b>-Taste klicken, wird nur der erste Eintrag gelöscht. Warum das Weil durch das Löschen des ersten Eintrags und damit der Aktualisierung des Listenfeldes auch die vorhandenen Markierungen entfernt werden.<\/p>\n <\/p>\n Also müssen wir dies etwas anders angehen und die Indizes der zu löschenden Einträge erst in einem Array zwischenspeichern.<\/p>\n Die programmieren wir in der neuen Version der Prozedur, die Sie in Listing 3 finden. Hier verwenden wir gleich drei neue Variablen, nämlich i <\/b>und l <\/b>mit dem Datentyp Long <\/b>und ein Array namens arrItems <\/b>ebenfalls mit dem Datentyp Long<\/b>. Wenn der Benutzer die Entf<\/b>-Taste gedrückt hat, durchlaufen wir wie zuvor eine For Each<\/b>-Schleife über alle markierten Elemente des Listenfeldes und redimensionieren das Array jeweils auf die Anzahl der erfolgten Durchläufe.<\/p>\n Listing 3: Zweiter Versuch, Einträge aus der Mehrfachauswahl eines Listenfeldes zu löschen<\/span><\/b><\/p>\n Um diese zu zählen, erhöhen wir jeweils die Variable i <\/b>um den Wert 1<\/b>. Der Position des Arrays mit dem Indexwert aus i <\/b>weisen wir dabei jeweils den Index beziehungsweise die Position des soeben bearbeiteten Listeneintrags zu – in diesem Beispiel erhalten also etwa die Zeilen 0<\/b>, 1 <\/b>und 2 <\/b>des Arrays die Werte 0<\/b>, 2 <\/b>und 4<\/b>. Nach dem Durchlaufen wissen wir über den Wert von i<\/b>, wieviele Zeilen gelöscht werden sollen. In einer For…Next<\/b>-Schleife mit der Schrittweite -1 <\/b>durchlaufen wir dann die Werte von i-1 <\/b>bis 0<\/b>.<\/p>\n Warum rückwärts Wenn wir vorwärts arbeiten, würden wir nicht die Einträge mit dem Index 0<\/b>, 2 <\/b>und 4 <\/b>löschen, sondern die mit dem Index 0<\/b>, 3 <\/b>und 6<\/b>. Warum Wenn wir den Eintrag mit dem Index 0 <\/b>löschen, rückt der Eintrag mit dem Index 2<\/b>, den wir auch löschen wollen, auf den Index 1<\/b>. Wir löschen dann den Eintrag, der zuvor den Index 3 <\/b>hatte.<\/p>\n Beim Löschen aus Auflistungen also immer rückwärts in der Schleife arbeiten! In der Schleife entfernen wir dann die jeweiligen Einträge wieder mit der RemoveItem<\/b>-Methode, wobei wir den Index diesmal dem Array arrItems <\/b>entnehmen. Nach dem Durchlaufen der Schleife sind dann alle gewünschten Einträge entfernt.<\/p>\n Wir sparen uns es an dieser Stelle auch, wie im ersten Beispiel gleich den ersten Eintrag nach dem gelöschten Eintrag zu markieren.<\/p>\n Nun schauen wir uns die beiden Beispiele von oben noch für gebundene Listenfelder an. Dazu erstellen wir eine kleine Beispieltabelle namens frmWerte <\/b>mit den Feldern ID <\/b>(Primärschlüsselfeld) und Wert <\/b>(Textfeld).<\/p>\n Das Formular frmListenfeldGebunden<\/b> ist genauso aufgebaut wie das vorherige Beispielformular.<\/p>\n Der Unterschied ist, dass wir die Eigenschaft Herkunftsart <\/b>bei Tabelle\/Abfrage <\/b>belassen. Außerdem stellen wir die Eigenschaft Datensatzherkunft<\/b> auf die folgende Abfrage ein (siehe Bild 4):<\/p>\n Bild 4: Einstellen der Datensatzherkunft der beiden Listenfelder<\/span><\/b><\/p>\n Damit die Listenfelder das erste Feld der Datenquelle als gebundene Spalte nutzen, die aber nicht angezeigt wird und nur das Feld Wert <\/b>anzeigen, stellen wir die Eigenschaft Spaltenanzahl <\/b>auf 2 <\/b>und die Eigenschaft Spaltenbreiten <\/b>auf 0cm <\/b>ein.<\/p>\n Die Prozedur zum Löschen einzelner Einträge aus dem gebundenen Listenfeld finden Sie in Listing 4. Sie prüft in der Select Case<\/b>-Bedingung, ob der Benutzer die Taste mit dem KeyCode<\/b>-Wert 46<\/b>, also die Entf<\/b>-Taste, gedrückt hat. In diesem Fall erstellt sie einen Verweis auf die aktuelle Datenbank und speichert diese in der Variablen db<\/b>.<\/p>\n Listing 4: Gebundenes Listenfeld: Einzelne Einträge löschen<\/span><\/b><\/p>\n Die Prozedur prüft dann, ob überhaupt ein Eintrag ausgewählt ist. Falls ja, löscht sie den Eintrag aus der Tabelle tblWerte<\/b>, dessen Feld ID <\/b>den Wert hat, den die Eigenschaft ItemData <\/b>für den Eintrag mit dem Index aus lngItem <\/b>liefert. lngItem <\/b>ist der Index des markierten Eintrags, ItemData <\/b>liefert den Wert der gebundenen Spalte für den Eintrag mit dem entsprechenden Index. <\/p>\n Nach dem Aktualisieren der Datensatzherkunft des Listenfeldes mit der Requery<\/b>-Methode folgt das Markieren des nächsten Datensatzes – also das Markieren des folgenden Datensatzes, sofern einer vorhanden ist, oder das Markieren des vorherigen Datensatzes, wenn der Benutzer zuvor den letzten Datensatz in der Liste gelöscht hat. Dazu prüft die Prozedur, ob das Listenfeld überhaupt noch einen Eintrag anzeigt. Falls nicht, wird entsprechend kein Eintrag markiert.<\/p>\n Falls doch, prüft die Prozedur, ob der gelöschte Eintrag nicht der letzte Eintrag war. In diesem Fall stellt sie den Index auf den gleichen Index-Wert ein, den der zuvor gelöschte Eintrag besaß. Bleibt noch die Möglichkeit, dass der Benutzer den letzten Eintrag der Liste gelöscht hat. In diesem Fall soll der nun letzte Eintrag im Listenfeld markiert werden.<\/p>\n Damit kommen wir zum Löschen mehrerer Datensätze aus dem gebundenen Listenfeld. Hier ist die Eigenschaft Mehrfachauswahl des Listenfeldes lstGebundenMehrfach <\/b>beispielsweise auf Erweitert <\/b>eingestellt. Damit kann der Benutzer die Einträge wie etwa die Dateien im Windows Explorer auswählen.<\/p>\n Nach der Auswahl und dem Betätigen der Entf<\/b>-Schaltfläche prüft die Prozedur, die durch das Ereignis Bei Taste ab <\/b>ausgelöst wird und die wie in Listing 5 aussieht, wieder den Wert des Parameters KeyCode <\/b>auf den Wert 46<\/b>. In diesem Fall wird die Variable db <\/b>über die Funktion CurrentDb <\/b>mit einem Verweis auf die aktuelle Datenbank gefüllt. Dann durchläuft die Prozedur in einer For Each<\/b>-Schleife alle markierten Einträge des Listenfeldes, auf die wir mit der Auflistung ItemsSelected <\/b>zugreifen.<\/p>\n Listing 5: Löschen mehrerer Einträge im gebundenen Listenfeld<\/span><\/b><\/p>\n Die von dieser Auflistung gelieferten Index-Werte landen jeweils in der Variant<\/b>-Variablen varItem<\/b>. Wir erweitern das Array arrItems <\/b>dann jeweils auf die Anzahl, die dem Wert der Zählervariablen i <\/b>entspricht und fügen ihm den aktuell durchlaufenen Wert aus der Variablen varItem <\/b>zu. Dann erhöhen wir i <\/b>um 1 <\/b>und bearbeiten den nächsten Eintrag der Auflistung.<\/p>\n Damit ausgestattet durchlaufen wir in einer For…Next<\/b>-Schleife rückwärts alle Elemente des Arrays von i – 1 <\/b>bis 0<\/b>. In der Variablen lngLoeschen <\/b>nehmen wir den Wert der gebundenen Spalte des Listenfeldes für den jeweils angegebenen Index-Wert aus dem Array arrItems <\/b>auf, den wir mit der ItemData<\/b>-Eigenschaft ermitteln. Diesen Wert nutzen wir dann als Vergleichswert für das Kriterium der DELETE<\/b>-Aktionsabfrage, welche den aktuellen Datensatz aus der Tabelle tblWerte <\/b>löscht. Schließlich aktualisieren wir nach dem Durchlaufen aller Elemente des Arrays die Datenherkunft des Listenfeldes mit der Requery<\/b>-Methode.<\/p>\n Das Löschen von Listenfeld-Einträgen erfolgt meist nach vorherigem Markieren der zu löschenden Daten und anschließendem Löschen mit einer dafür vorgesehenen Schaltfläche.<\/p>\n Dieser Beitrag zeigt einmal, wie Sie auch aus dem Listenfeld ganz einfach Datensätze durch Betätigen der Entf<\/b>-Schaltfläche löschen können, und zwar für ungebundene und gebundene Listenfelder.<\/p>\n Enthaltene Beispieldateien:<\/p>\n LoeschenImListenfeld.accdb<\/p>\nPrivate Sub <\/span>Form_Load()\r\n Dim <\/span>i As Integer<\/span>\r\n Me!lstUngebunden.RowSourceType = \"Value List\"\r\n For i = 1 To 10\r\n Me!lstUngebunden.AddItem \"Eintrag \" & i\r\n Next<\/span> i\r\nEnd Sub<\/span><\/pre>\n![\"Listenfeld](\"..\/fileadmin\/_temp_\/2018_03\/pic_1130_001.png\")
<\/p>\n![\"Listenfeld](\"..\/fileadmin\/_temp_\/2018_03\/pic_1130_002.png\")
<\/p>\nMe!lstUngebunden.ListIndex = lngItem<\/pre>\n
Mehrfachauswahl löschen<\/h2>\n
Me!lstUngebundenMehrfach.AddItem \"Eintrag \" & i<\/pre>\n
![\"Löschen](\"..\/fileadmin\/_temp_\/2018_03\/pic_1130_003.png\")
<\/p>\nPrivate Sub <\/span>lstUngebundenMehrfach_KeyDown(KeyCode As Integer<\/span>, Shift As Integer<\/span>)\r\n Dim <\/span>varItem As Variant<\/span>\r\n Dim <\/span>arrItems() As Long<\/span>\r\n Dim <\/span>l As Long<\/span>\r\n Dim <\/span>i As Integer<\/span>\r\n Select Case KeyCode\r\n Case <\/span>46\r\n For Each varItem In Me!lstUngebundenMehrfach.ItemsSelected\r\n ReDim Preserve arrItems(i)\r\n arrItems(i) = varItem\r\n i = i + 1\r\n Next<\/span> varItem\r\n For l = i - 1 To 0 Step -1\r\n Me!lstUngebundenMehrfach.RemoveItem arrItems(l)\r\n Next<\/span> l\r\n End Select<\/span>\r\nEnd Sub<\/span><\/pre>\nLöschen aus gebundenen Listenfeldern<\/h2>\n
![\"Einstellen](\"..\/fileadmin\/_temp_\/2018_03\/pic_1130_005.png\")
<\/p>\nSELECT tblWerte.ID, tblWerte.Wert FROM tblWerte;<\/pre>\n
Einzelne Einträge löschen<\/h2>\n
Private Sub <\/span>lstGebunden_KeyDown(KeyCode As Integer<\/span>, Shift As Integer<\/span>)\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>lngItem As Long<\/span>\r\n Select Case KeyCode\r\n Case <\/span>46\r\n Set<\/span> db = CurrentDb\r\n lngItem = Me!lstGebunden.ListIndex\r\n If <\/span>Not<\/span> lngItem = -1 Then<\/span>\r\n db.Execute \"DELETE FROM tblWerte WHERE ID = \" & Me!lstGebunden.ItemData(lngItem)\r\n Me!lstGebunden.Requery\r\n If <\/span>Not<\/span> Me!lstGebunden.ListCount = 0 Then<\/span>\r\n If <\/span>lngItem < Me!lstGebunden.ListCount Then<\/span>\r\n Me!lstGebunden.ListIndex = lngItem\r\n Else<\/span>\r\n Me!lstGebunden.ListIndex = Me!lstGebunden.ListCount - 1\r\n End If<\/span>\r\n End If<\/span>\r\n End If<\/span>\r\n End Select<\/span>\r\nEnd Sub<\/span><\/pre>\nLöschen einer Mehrfachauswahl aus dem gebundenen Listenfeld<\/h2>\n
Private Sub <\/span>lstGebundenMehrfach_KeyDown(KeyCode As Integer<\/span>, Shift As Integer<\/span>)\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>varItem As Variant<\/span>\r\n Dim <\/span>arrItems() As Long<\/span>\r\n Dim <\/span>lngLoeschen As Long<\/span>\r\n Dim <\/span>l As Long<\/span>\r\n Dim <\/span>i As Integer<\/span>\r\n Select Case KeyCode\r\n Case <\/span>46\r\n Set<\/span> db = CurrentDb\r\n For Each varItem In Me!lstGebundenMehrfach.ItemsSelected\r\n ReDim Preserve arrItems(i)\r\n arrItems(i) = varItem\r\n i = i + 1\r\n Next<\/span> varItem\r\n For l = i - 1 To 0 Step -1\r\n lngLoeschen = Me!lstGebundenMehrfach.ItemData(arrItems(l))\r\n db.Execute \"DELETE FROM tblWerte WHERE ID = \" & lngLoeschen\r\n Next<\/span> l\r\n Me!lstGebundenMehrfach.Requery\r\n End Select<\/span>\r\nEnd Sub<\/span><\/pre>\nZusammenfassung und Ausblick<\/h2>\n
Downloads zu diesem Beitrag<\/h3>\n