In vielen bisherigen Lösungen haben wir für die Schnellsuche im Listenfeld oder auch in Unterformularen in der Datenblattansicht ein Textfeld als Suchfeld verwendet. Direkt bei Eingabe eines jeden Zeichens wurde das Suchergebnis aktualisiert. In diesem Beitrag wollen wir einmal eine noch ergonomischere Version vorstellen. Der Unterschied soll so aussehen, dass man den Suchbegriff eingeben kann, während das Listenfeld den Fokus hat. Es soll also kein Wechseln vom Suchfeld zum Listenfeld und zurück nötig sein, wenn man durch die Suche den gewünschten Datensatz vorgefunden hat und diesen beispielsweise markieren und beispielsweise durch Betätigen der Eingabetaste eine Aktion für diesen Eintrag durchführen möchte. Wir zeigen dies am Beispiel aus dem Beitrag „m:n-Beziehung mit Listenfeld und Datenblatt“ (www.access-im-unternehmen.de\/1510).<\/b><\/p>\n
Im oben genannten Beitrag haben wir bereits eine effiziente Möglichkeit entwickelt, um eine m:n-Beziehung mithilfe eines Listenfeldes und eines Datenblattes in einem Unterformular abzubilden. Das Ziel war es, dass wir nicht wie in üblichen Bestellformularen einfach nur das gesuchte Produkt aus dem Auswahlfeld der hinzuzufügenden Bestellposition heraussuchen können.<\/p>\n
Stattdessen wollten wir die Möglichkeit bieten, solche Einträge aus einem Listenfeld auszuwählen und diese schnell per Doppelklick zu dem Datensatz im übergeordneten Formular hinzuzufügen. Bei dem Beispiel dreht es sich um Fahrzeuge und ihre Ausstattungen (siehe Bild 1).<\/p>\n
![\"Beispiel](\"..\/fileadmin\/_temp_\/2024_04\/pic_1509_001.png\")
<\/p>\n
Bild 1: Beispiel für die Listenfeldsuche<\/span><\/b><\/p>\n Es ist nun vielleicht bereits etwas effizienter, einen Eintrag aus dem Listenfeld auszuwählen und dieses per Doppelklick zum Fahrzeug hinzuzufügen – gerade, wenn die ausgewählten Einträge danach nicht mehr über das Listenfeld angeboten werden. Allerdings kann es sein, dass es über 200 Einträge in der Liste der Sonderausstattungen gibt. In diesem Fall ist es immer noch langwierig, wenn man sich durch die ganze Liste wühlen muss, um zum gesuchten Eintrag zu gelangen. Auch eine alphabetische Sortierung ist nicht unbedingt zielführend, weil manche Ausstattungen so benannt sind, dass der gesuchte Begriff noch nicht einmal vorn in der Bezeichnung der Ausstattung steht.<\/p>\n Der nächste Schritt wäre also eine Such- beziehungsweise Filterfunktion zum Listenfeld hinzuzufügen. Eine solche haben wir schon des Öfteren gebaut und wir haben immer ein Textfeld zum Listenfeld hinzugefügt, in das der Benutzer zeichenweise den Suchbegriff eingeben kann.<\/p>\n Der Inhalt des Listenfeldes wurde nach jeder Änderung aktualisiert, damit der Benutzer schnell sehen konnte, wenn der gesuchte Eintrag im sichtbaren Bereich auftauchte oder sogar ganz oben in der Liste stand.<\/p>\n Diesem Textfeld, das wir wie auch in diesem Fall meist txtSuche <\/b>nennen, fügen wir für die Ereigniseigenschaft Bei Änderung <\/b>den Wert [Ereignisprozedur]<\/b> hinzu und hinterlegen für diese eine Ereignisprozedur wie die folgende:<\/p>\n Diese ruft die Prozedur AusstattungslisteFuellen <\/b>auf und übergibt dieser den aktuellen Inhalt des Textfeldes txtSuche <\/b>als Parameter.<\/p>\n Die Prozedur AusstattungslisteFuellen <\/b>erwartet mit dem Parameter strSuche <\/b>den Suchbegriff, also die Zeichenkette, die in den anzuzeigenden Listenfeld-Einträgen enthalten sein muss (siehe Listing 1).<\/p>\n Listing 1: Prozedur zum Aktualisieren der Einträge im Listenfeld<\/span><\/b><\/p>\n Sie prüft zuerst, ob das Hauptformular aktuell einen neuen, leeren Datensatz enthält. In diesem Fall wird der zweite Teil der If…Then<\/b>-Bedingung ausgeführt, der dem Listenfeld eine Datensatzherkunft zuweist, die alle Einträge der Tabelle tblAusstattungen <\/b>liefert.<\/p>\n Anderenfalls ermittelt die Prozedur den Primärschlüsselwert des im Hauptformular angezeigten Fahrzeugs und speichert diesen in der Variablen lngFahrzeugID<\/b>.<\/p>\n Anschließend setzt sie in der Variablen strSQL <\/b>eine SQL-Anweisung zusammen, die alle Datensätze der Tabelle tblAusstattungen <\/b>liefert, die noch nicht mit dem aktuell angezeigten Fahrzeug verknüpft sind.<\/p>\n Diese Abfrage verwendet eine Unterabfrage, die alle Einträge der Tabelle tblFahrzeugeAusstattungen <\/b>liefert, deren FahrzeugID <\/b>mit dem Wert des aktuellen Fahrzeugs übereinstimmt.<\/p>\n Hier finden wir einen Platzhalter namens [Suche]<\/b>, der anschließend ersetzt wird. Befindet sich im Textfeld txtSuche <\/b>eine Zeichenkette mit einer Länge von 0 <\/b>Zeichen, wird [Suche]<\/b> einfach durch eine leere Zeichenkette ersetzt.<\/p>\n Anderenfalls fügen wir für [Suche]<\/b> ein vollständiges Kriterium wie Ausstattung LIKE “*Suchbegriff*“ AND <\/b>ein.<\/p>\n Schließlich wird der Inhalt aus strSQL <\/b>der Eigenschaft RowSource <\/b>(Datensatzherkunft<\/b>) des Listenfeldes zugewiesen und der Wert des Listenfeldes wird auf Null <\/b>eingestellt.<\/p>\n Auf diese Weise funktioniert die herkömmliche Suche über das Textfeld (siehe Bild 2) – das Listenfeld liefert nur noch solche Einträge, die zum angegebenen Suchbegriff passen.<\/p>\n Bild 2: Beispiel für eine Suche über das Textfeld<\/span><\/b><\/p>\n Nun stellen wir uns vor, wie das Arbeiten in diesem Formular funktioniert: Der Benutzer gibt einen Suchbegriff ein, bis er den gewünschten Eintrag sieht, und klickt diesen dann mit der Maus doppelt an, damit dieser zum Fahrzeug hinzugefügt wird (siehe Bild 3). Alternativ kann er auch den Fokus zum Listenfeld wechseln, den gewünschten Eintrag markieren und diesen mit der Eingabetaste zu den Ausstattungen des Fahrzeugs hinzufügen. Zusätzlich können wir auch noch dafür sorgen, dass das Suchfeld geleert wird und das Listenfeld wieder alle noch verfügbaren Einträge anzeigt – das dürfte in den meisten Settings sinnvoll sein.<\/p>\n Bild 3: Ein per Doppelklick hinzugefügter Eintrag<\/span><\/b><\/p>\n Wenn der Benutzer nun jedoch das nächste Ausstattungsmerkmal hinzufügen und dieses dazu suchen möchte, muss er den Fokus zunächst manuell wieder zum Suchen-Textfeld zurückversetzen.<\/p>\n Damit kommt man auf eine ganze Menge Mausklicks und Tastenanschläge, bis man alle Ausstattungsmerkmale hinzugefügt hat. Und damit kommt das Feature ins Spiel, dass uns die Aufgabe deutlich vereinfacht: Wir wollen den Suchbegriff nun einfach eingeben können, ohne dass wir das Listenfeld verlassen müssen! Der Benutzer soll also, während er durch das Listenfeld navigiert und per Eingabetaste Einträge zu den Ausstattungen hinzufügt, einfach den Inhalt des Suchfeldes aktualisieren und Buchstaben hinzufügen oder entfernen können.<\/p>\n Dazu müssen wir alle Tastenanschläge abfangen, die der Benutzer erledigt, während das Listenfeld den Fokus hat. Dazu verwenden wir das Ereignis Bei Taste <\/b>des Listenfeldes. Für dieses hinterlegen wir die Prozedur aus Listing 2. Diese erhält mit dem Parameter KeyAscii <\/b>den jeweiligen ASCII-Wert der gedrückten Taste. Davon interessieren uns die folgenden Zeichen inklusive des Leerzeichens, die wir in einer Konstanten namens cStrChars <\/b>speichern:<\/p>\n Listing 2: Prozedur zum Abfangen der Tastenanschläge über das Listenfeld<\/span><\/b><\/p>\n Wir fügen dann den Inhalt des Suchfeldes in die Variable strSuche <\/b>ein. Sollte txtSuche <\/b>den Wert Null <\/b>enthalten, landet eine leere Zeichenkette in strSuche<\/b>.<\/p>\n Wir ermitteln dann mit der Chr<\/b>-Funktion aus dem ASCII-Code das tatsächliche angeklickte Zeichen und prüfen, ob sich dieses in den Zeichen aus der Konstanten cStrChars <\/b>befindet. Falls ja, hängen wir dieses hingen an den bisherigen Suchbegriff an. Außerdem stellen wir den Wert des Parameters KeyAscii <\/b>auf den Wert 0 <\/b>ein. Damit sorgen wir dafür, dass das eingegebene Zeichen nicht an das Listenfeld weitergegeben wird.<\/p>\n Falls der Benutzer keines der Zeichen in der Konstanten cStrChars <\/b>angeklickt hat, untersuchen wir den Inhalt von KeyASCII <\/b>weiter.<\/p>\n Dabei schauen wir uns im Else<\/b>-Teil der If…Then<\/b>-Bedingung in einer Select Case<\/b>-Bedingung nur die beiden folgenden Fälle an:<\/p>\n In jedem Fall, bei dem sich der Inhalt des Textfeldes txtSuche <\/b>nun geändert hat, stellen wir die Eigenschaft TimerInterval <\/b>des Formulars auf den Wert 100 <\/b>ein. Dadurch sorgen wir dafür, dass in 100 Millisekunden das Ereignis Bei Zeitgeber <\/b>ausgelöst wird. Dies erfolgt deshalb, weil es ein Timing-Problem gibt – wenn wir die in dieser Prozedur enthaltenen Anweisungen direkt an Ort und Stelle ausführen, erzielen diese nicht die gewünschte Wirkung.<\/p>\n Also schauen wir uns den Inhalt der Prozedur Bei Zeitgeber <\/b>an. Diese sieht wie folgt aus:<\/p>\n Die Prozedur liest den aktuell markierten Eintrag des Listenfeldes lstAusstattungen <\/b>in die Variable lngAusstattungID <\/b>ein. Dann ruft sie die Prozedur AusstattungslisteFuellen<\/b> auf, die wir bereits weiter oben vorgestellt haben, und aktualisiert so den Inhalt des Listenfeldes an den geänderten Suchbegriff. Dadurch wird der Inhalt des Listenfeldes aktualisiert. Anschließend versucht die Prozedur, das Listenfeld wieder auf den zuvor gespeicherten Wert einzustellen. Sofern dieser Wert noch im Listenfeld angezeigt wird, gelingt dies auch, ansonsten verpufft diese Anweisung einfach. Schließlich stellt die Prozedur den Wert der Eigenschaft TimerInterval <\/b>wieder auf 0 <\/b>ein, damit das Ereignis nicht direkt nochmal aufgerufen wird.<\/p>\n Wenn wir schon die Tastenanschläge des Benutzers verfolgen – hätten wir dann nicht direkt auch die Eingabetaste berücksichtigen können, um den aktuell markierten Eintrag zu den Ausstattungen des angezeigten Fahrzeugs hinzuzufügen?<\/p>\n Nein, denn wir können diese Eingabe besser mit dem Ereignis Bei Taste ab <\/b>abfangen. Diese löst die folgende Ereignisprozedur aus und übergibt mit dem Parameter KeyCode <\/b>einen Wert, welcher der betätigten Taste entspricht. Diesen Wert untersuchen wir in einer Select Case<\/b>-Bedingung.<\/p>\n Für den Fall der Konstanten vbKeyReturn<\/b>, was der Eingabetaste entspricht, speichern wir wiederum den angeklickten Eintrag in der Variablen lngAusstattungID<\/b>. Ist dieser nicht gleich 0, rufen wir die Prozedur AusstattungHinzufuegen <\/b>auf, welche die Ausstattung zum aktuellen Fahrzeug hinzufügt.<\/p>\n Damit haben wir das Ziel erreicht. Wir können nun, während das Listenfeld den Fokus hat, Suchbegriffe eingeben, so direkt die angezeigten Einträge filtern, mit der Nach oben<\/b>– und Nach unten<\/b>-Taste zum gewünschten Eintrag navigieren und diesen durch Betätigen der Eingabetaste zum aktuellen Fahrzeug hinzufügen.<\/p>\n Da die hier vorgestellte Technik etwas mit der bestehenden Lösung der Zuordnung von Ausstattungen zu Fahrzeugen verwoben ist, haben wir die wichtigsten Komponenten allein für das Suchen nach Einträgen im Listenfeld nochmals extrahiert, und zwar im Formular frmSchnelleSuche<\/b>.<\/p>\n Hier haben wir nur das Listenfeld und das Textfeld zur Anzeige des aktuellen Suchausdrucks untergebracht (siehe Bild 4).<\/p>\n Bild 4: Reduziertes Beispiel<\/span><\/b><\/p>\n Für das dort enthaltene Listenfeld gleichen Namens haben wir ebenfalls das Bei Taste<\/b>-Ereignis implementiert. Der Code sieht wie in Listing 3 aus. Hier war interessanterweise nicht der Trick mit dem Zeitgeber nötig. Wir konnten am Ende der Prozedur ohne Probleme die Prozedur zum Füllen der Ausstattungsliste aufrufen.<\/p>\n Listing 3: Prozedur zum Abfangen der Tastenanschläge über das Listenfeld, extrahierte Version<\/span><\/b><\/p>\n Dadurch, dass wir hier einfach nur die Listenfeldeinträge filtern mussten und in diesem reduzierten Beispiel nicht noch berücksichtigen mussten, welche Ausstattungen dem aktuell angezeigten Fahrzeug bereits zugeordnet waren, benötigen wir nur diese einfache Prozedur:<\/p>\n Schließlich fehlt noch die Prozedur, falls der Benutzer einmal direkt einen Suchbegriff in das Suchfeld txtSuche <\/b>eingibt. Dieses sieht wie folgt aus und ruft einfach nur die Prozedur AusstattungslisteFuellen <\/b>mit dem aktuellen Inhalt des Textfeldes auf:<\/p>\n Schließlich haben wir im Rahmen der Erstellung der Beispieldatenbank zu diesem Beitrag noch einen Bug oder zumindest ein nicht erwartetes Verhalten von Listenfeldern entdeckt. Dies resultiert darin, dass wir in verschiedenen Prozeduren am Ende den Wert des Listenfeldes auf Null<\/b> eingestellt haben, zum Beispiel in AusstattungslisteFuellen<\/b>:<\/p>\n Das Problem ist in diesem Fall Folgendes: Wir haben beispielsweise einen Listenfeldeintrag doppelt angeklickt und dieser wurde dann aus dem Listenfeld entfernt sowie zur Tabelle tblFahrzeugeAusstattungen <\/b>hinzugefügt. Wenn wir anschließend versehentlich doppelt in den leeren Bereich des Listenfeldes geklickt haben, wurde der Fehler aus Bild 5 ausgelöst.<\/p>\n Bild 5: Fehler beim Klick an die falsche Stelle im Listenfeld<\/span><\/b><\/p>\n Dieser resultiert auf folgendem Umstand:<\/p>\nSuchfunktion zum Listenfeld hinzufügen<\/h2>\n
Private Sub <\/span>txtSuche_Change()\r\n AusstattungslisteFuellen Me!txtSuche.Text\r\nEnd Sub<\/span><\/pre>\nFüllen des Listenfeldes auf Basis des Suchkriteriums<\/h2>\n
Public Sub <\/span>AusstattungslisteFuellen(Optional<\/span> strSuche As String<\/span>)\r\n Dim <\/span>strSQL As String<\/span>\r\n Dim <\/span>lngFahrzeugID As Long<\/span>\r\n If <\/span>Me.NewRecord = False<\/span> Then<\/span>\r\n lngFahrzeugID = Nz(Me!FahrzeugID)\r\n strSQL = \"SELECT AusstattungID, Ausstattung \" _\r\n & \"FROM tblAusstattungen \" _\r\n & \"WHERE [Suche]AusstattungID \" _\r\n & \"Not<\/span> In (\" _\r\n & \"SELECT AusstattungID \" _\r\n & \"FROM tblFahrzeugeAusstattungen \" _\r\n & \"WHERE FahrzeugID = \" & lngFahrzeugID _\r\n & \") \" _\r\n & \"ORDER BY Ausstattung;\"\r\n If <\/span>Len<\/span>(strSuche) = 0 Then<\/span>\r\n strSQL = Replace<\/span>(strSQL, \"[Suche]\", \"\")\r\n Else<\/span>\r\n strSQL = Replace<\/span>(strSQL, \"[Suche]\", \"Ausstattung LIKE ''*\" & strSuche & \"*'' AND \")\r\n End If<\/span>\r\n Else<\/span>\r\n strSQL = \"SELECT AusstattungID, Ausstattung FROM tblAusstattungen ORDER BY Ausstattung\"\r\n End If<\/span>\r\n Me!lstAusstattungen.RowSource = strSQL\r\n Me!lstAusstattungen.Value = Null\r\nEnd Sub<\/span><\/pre>\n![\"Beispiel](\"..\/fileadmin\/_temp_\/2024_04\/pic_1509_002.png\")
<\/p>\nUpgrade der Schnellsuche<\/h2>\n
![\"Ein](\"..\/fileadmin\/_temp_\/2024_04\/pic_1509_003.png\")
<\/p>\nTastenanschläge über das Listenfeld abfangen<\/h2>\n
Private Sub <\/span>lstAusstattungen_KeyPress(KeyAscii As Integer<\/span>)\r\n Dim <\/span>strSuche As String<\/span>\r\n Const cStrChars As String<\/span> = \" abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZßäÄöÖüÜ\" _\r\n & \"1234567890!§$%&\/()=?*+~''#-_.:,;\"\r\n strSuche = Nz(Me!txtSuche, \"\")\r\n If <\/span>Not<\/span> InStr<\/span>(1, cStrChars, Chr(KeyAscii)) = 0 Then<\/span>\r\n Me!txtSuche = Me!txtSuche & Chr(KeyAscii)\r\n KeyAscii = 0\r\n Else<\/span>\r\n Select Case KeyAscii\r\n Case <\/span>8\r\n If <\/span>Not<\/span> Len<\/span>(Me!txtSuche) = 0 Then<\/span>\r\n Me!txtSuche = Left<\/span>(Me!txtSuche, Len<\/span>(Me!txtSuche) - 1)\r\n End If<\/span>\r\n Case <\/span>vbKeyEscape\r\n Me!txtSuche = Null\r\n KeyAscii = 0\r\n End Select<\/span>\r\n End If<\/span>\r\n If <\/span>Not<\/span> Nz(Me!txtSuche, \"\") = strSuche Then<\/span>\r\n Me.TimerInterval = 100\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\nabcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZßäÄöÖüÜ1234567890!§$%&\/()=?*+~''#-_.:,;<\/pre>\n
\n
Private Sub <\/span>Form_Timer()\r\n Dim <\/span>lngAusstattungID As Long<\/span>\r\n lngAusstattungID = Nz(Me!lstAusstattungen, 0)\r\n Call<\/span> AusstattungslisteFuellen(Nz(Me!txtSuche, \"\"))\r\n Me.lstAusstattungen = lngAusstattungID\r\n Me.TimerInterval = 0\r\nEnd Sub<\/span><\/pre>\nAusstattung bei Eingabetaste zum Fahrzeug hinzufügen<\/h2>\n
Ergebnis: Schnelles Suchen und Hinzufügen von Einträgen<\/h2>\n
Verwendete Technik heruntergebrochen<\/h2>\n
![\"Reduziertes](\"..\/fileadmin\/_temp_\/2024_04\/pic_1509_004.png\")
<\/p>\nPrivate Sub <\/span>lstAusstattungen_KeyPress(KeyAscii As Integer<\/span>)\r\n Dim <\/span>strSuche As String<\/span>\r\n Const cStrChars As String<\/span> = \" abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZßäÄöÖüÜ1234567890!§$%&\/()=?*+~''#-_.:,;\"\r\n strSuche = Nz(Me!txtSuche, \"\")\r\n If <\/span>Not<\/span> InStr<\/span>(1, cStrChars, Chr(KeyAscii)) = 0 Then<\/span>\r\n Me!txtSuche = Me!txtSuche & Chr(KeyAscii)\r\n KeyAscii = 0\r\n Else<\/span>\r\n Select Case KeyAscii\r\n Case <\/span>8\r\n If <\/span>Not<\/span> Len<\/span>(Me!txtSuche) = 0 Then<\/span>\r\n Me!txtSuche = Left<\/span>(Me!txtSuche, Len<\/span>(Me!txtSuche) - 1)\r\n End If<\/span>\r\n Case <\/span>vbKeyEscape\r\n Me!txtSuche = Null\r\n KeyAscii = 0\r\n End Select<\/span>\r\n End If<\/span>\r\n If <\/span>Not<\/span> Nz(Me!txtSuche, \"\") = strSuche Then<\/span>\r\n Dim <\/span>lngAusstattungID As Long<\/span>\r\n lngAusstattungID = Me!lstAusstattungen\r\n Call<\/span> AusstattungslisteFuellen(Nz(Me!txtSuche, \"\"))\r\n Me!lstAusstattungen = lngAusstattungID\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\nPublic Sub <\/span>AusstattungslisteFuellen( _\r\n Optional<\/span> strSuche As String<\/span>)\r\n Dim <\/span>strSQL As String<\/span>\r\n strSQL = \"SELECT AusstattungID, Ausstattung \" _\r\n & \"FROM tblAusstattungen \" _\r\n & \"WHERE Ausstattung LIKE ''*\" & strSuche & \"*'' \" _\r\n & \"ORDER BY Ausstattung;\"\r\n Me!lstAusstattungen.RowSource = strSQL\r\n Me!lstAusstattungen.Value = Null\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>txtSuche_Change()\r\n AusstattungslisteFuellen Me!txtSuche.Text\r\nEnd Sub<\/span><\/pre>\nZu guter Letzt: Ein Bug im Listenfeld<\/h2>\n
Public Sub <\/span>AusstattungslisteFuellen( _\r\n Optional<\/span> strSuche As String<\/span>)\r\n ...\r\n Me!lstAusstattungen.RowSource = strSQL\r\n Me!lstAusstattungen.Value = Null\r\nEnd Sub<\/span><\/pre>\n![\"Fehler](\"..\/fileadmin\/_temp_\/2024_04\/pic_1509_005.png\")
<\/p>\n