<\/p>\n
Neulich fiel mir in einer Benutzerumgebung auf, dass ich dort im Listenfeld per Eingabe eines Zeichens direkt zu den Einträgen springen konnte, die mit diesem Zeichen beginnen. Das ist immer ein schöner Anlass, dies in Access nach zu programmieren. Dieser Beitrag liefert also eine Erweiterung für Listenfelder, mit der Sie dem Benutzer die Auswahl der enthaltenen Einträge noch leichter machen können.<\/b><\/p>\n
Als Beispiel dient die Tabelle tblArtikel <\/b>der Südsturm-Beispieldatenbank. Diese verwenden wir als Datensatzherkunft eines neuen Listenfeldes in einem Formular namens lstArtikel<\/b> – und zwar über eine Abfrage, die nur die beiden Felder ArtikelID <\/b>und Artikelname <\/b>liefert. Dabei sortiert die Abfrage die Datensätze noch nach dem Artikelnamen (siehe Bild 1).<\/p>\n
![\"Abfrage](\"..\/fileadmin\/_temp_\/2018_02\/pic_1120_001.png\")
<\/p>\n
Bild 1: Abfrage als Datenherkunft des Listenfeldes<\/span><\/b><\/p>\n Mit dieser Abfrage statten wir dann das Listenfeld lstArtikel <\/b>im Formular frmListenfeldSchnellsuche <\/b>aus. Damit das Listenfeld nur die Spalte mit den Artikelnamen anzeigt und nicht den Primärschlüsselwert der Datensätze, stellen wir die Eigenschaft Spaltenanzahl <\/b>auf 2 <\/b>und Spaltenbreiten <\/b>auf 0cm <\/b>ein. Das Formular sieht dann im Entwurf wie in Bild 2 aus.<\/p>\n Bild 2: Entwurfsansicht des Beispielformulars<\/span><\/b><\/p>\n Nun wollen wir eine Funktion zum Listenfeld hinzufügen, die dafür sorgt, dass die Eingabe eines Buchstabens direkt zum ersten Datensatz springt, der mit diesem Buchstaben anfängt.<\/p>\n Als ich dann allerdings testweise in die Formularansicht des Formulars wechselte und einen Buchstaben eingegeben habe, während das Listenfeld den Fokus hat, stellte ich erstaunt fest, dass diese Funktion bereits in das Listenfeld von Access integriert ist! Das Eintippen des Buchstabens C beispielsweise sorgte direkt zur Markierung des ersten Datensatzes, der mit dem Buchstaben C beginnt (siehe Bild 3).<\/p>\n Bild 3: Formular in Aktion<\/span><\/b><\/p>\n Das zeigt mal wieder, dass auch eine Anwendung wie Access, die praktisch seit 2010 überhaupt nicht mehr weiterentwickelt wurde, noch Funktionen offenbart, die man bis dahin noch nie genutzt hat, geschweige denn erkannt hat. Nun: Ich gehe davon aus, dass der eine oder andere diese Funktion bereits kennt – an mir ist diese bisher jedoch vorübergegangen.<\/p>\n Nun denn: So einfach lassen wir uns nicht abspeisen und bieten Varianten zum Standardverhalten des Listenfeldes bei Eingabe eines Buchstabens an. Das Standardverhalten sieht wie folgt aus:<\/p>\n Wenn Sie einen Buchstaben eingeben, zu dem das Listenfeld in der ersten Spalte einen Wert enthält, der mit diesem Buchstaben beginnt, wird dieser Datensatz markiert.<\/p>\n Geben Sie den gleichen Buchstaben nochmals ein, wird die Markierung zum nächsten Eintrag verschoben, dessen Wert in der ersten Spalte mit diesem Buchstaben beginnt. Ist nur ein passender Eintrag vorhanden, bleibt dieser markiert. Liegen mehrere Einträge vor, durchläuft das Listenfeld diese Einträge immer wieder, wenn der Benutzer die gleiche Taste mehrfach betätigt. Ist kein passender Eintrag vorhanden, bleibt der aktuelle Eintrag markiert.<\/p>\n Die erste Variante, die wir uns ansehen wollen, entspricht dem Verhalten, das die Dateiliste im Windows Explorer bietet. Wenn die Dateiliste den Fokus hat und Sie geben einen Buchstaben ein, verhält sich die Liste wie das Listenfeld in Access, das heißt, dass der erste Eintrag markiert wird, dessen Dateiname mit dem angegebenen Anfangsbuchstaben beginnt.<\/p>\n Das funktioniert auch noch genauso wie im Listenfeld, wenn Sie beispielsweise drei Einträge haben, die mit p <\/b>beginnen und mehrfach die Taste p <\/b>drücken. Wenn Sie aber bei der Konstellation von Bild 4 erst p <\/b>und dann direkt l <\/b>drücken, springt die Markierung nicht erst zum Eintrag pic001 <\/b>und dann zum ersten Eintrag, der mit l <\/b>beginnt. Stattdessen tut sich nichts und die Markierung verharrt gefühlt eine Sekunde auf dem Eintrag mit dem Anfangsbuchstaben p<\/b>. Der Grund ist einfach: Im Windows Explorer können Sie auch durch zügige Eingabe mehrerer aufeinanderfolgender Zeichen zu Einträgen springen, die mit diesen Zeichen beginnen.<\/p>\n Bild 4: Tastatureingabe im Windows Explorer<\/span><\/b><\/p>\n Wenn Sie also wie im Beispiel in der Abbildung pic003 <\/b>eingeben, dann springt die Markierung erst zum ersten Eintrag mit p <\/b>und dann weiter zum Eintrag pic003.png<\/b>.<\/p>\n Der Explorer wartet also immer einige Augenblicke auf weitere schnell eingegebene Zeichen, bevor er davon ausgeht, dass nun doch ein anderer Eintrag angesteuert werden soll.<\/p>\n Diese Funktion wollen wir nun für das Listenfeld abbilden. Der erste Ansatz, den wir unternehmen, soll nur zum ersten Element mit dem Anfangsbuchstaben springen, den wir mit der Tastatur eingeben.<\/p>\n Dazu wollen wir es mit der FindFirst<\/b>-Methode probieren, die wir in der Prozedur, die durch das Ereignis Bei Taste ab <\/b>auslösen, wie folgt einsetzen:<\/p>\n Das Ergebnis ist allerdings ernüchternd, wie Bild 5 zeigt: Bei der Eingabe der Taste C <\/b>beispielsweise springt die Markierung noch zum richtigen Datensatz, aber wenn wir diese Taste mehrfach betätigen, sieht das Resultat wie in der Abbildung aus.<\/p>\n Bild 5: Die FindFirst-Methode funktioniert für unseren Anwendungszweck funktioniert.<\/span><\/b><\/p>\n Darüber hinaus gibt es nach ein paar weiteren Tastatureingaben noch eine nicht reproduzierbare Fehlermeldung (siehe Bild 6).<\/p>\n Bild 6: Fehlermeldung nach mehrmaligem Auslösen der Prozedur<\/span><\/b><\/p>\n Also müssen wir uns einen anderen Ansatz überlegen. Dieser ist nur sinnvoll, wenn das Listenfeld nicht allzuviele Datensätze enthält, denn wir durchlaufen hier die Listeneinträge, bis wir den ersten passenden Eintrag gefunden haben.<\/p>\n Der erste Entwurf des Codes sieht wie in Listing 1 aus. In dieser Prozedur durchlaufen wir alle Datensätze vom ersten bis zu dem Datensatz, dessen erstes Zeichen in der Spalte mit dem Index 1, i <\/b>mit dem eingetippten Zeichen übereinstimmt.<\/p>\n <\/p>\n Listing 1: Versuch, den ersten passenden Eintrag zu finden und zu markieren<\/span><\/b><\/p>\n Wenn wir diesen Code ausprobieren und etwa den Buchstaben B <\/b>eingeben, funktioniert es. Wenn wir allerdings einen Anfangsbuchstaben eingeben, für den es mehrere Artikelnamen gibt – wie beim Buchstaben C <\/b>-, erhalten wir das Ergebnis aus Bild 7. Wir landen also immer genau einen Eintrag unter dem erwarteten Ergebnis.<\/p>\n Bild 7: Falsche Selektion<\/span><\/b><\/p>\n Warum das so ist, lässt sich nicht so einfach erklären.<\/p>\n Zu Analysezwecken haben wir per Debug.Print<\/b>-Anweisung die jeweils durchlaufenen Werte für i<\/b>, den ersten Buchstaben des Artikels und den kompletten Artikelnamen ausgeben lassen. Auch das lieferte keine Auffälligkeiten – wenn wir beispielsweise den Buchstaben C <\/b>eingeben, erschien im Direktbereich die folgende Ausgabe:<\/p>\n Es wurde aber dennoch nicht der Eintrag Camembert Pierrot<\/b>, sondern Carnarvon Tigers <\/b>markiert – also genau ein Eintrag weiter unten. Wir gingen also davon aus, dass die Prozedur für Eintrag mit dem Index-Wert 3 <\/b>die Eigenschaft Selected <\/b>auf den Wert True <\/b>einstellt. Den entsprechenden Befehl haben wir dann über den Direktbereich abgesetzt:<\/p>\n Interessanterweise hat dies den richtigen Eintrag markiert (siehe Bild 8). Warum aber wird im Code der falsche Eintrag markiert Die Aufklärung erhofften wir uns über das Debuggen des Codes. Also haben wir einen Haltepunkt für den Prozedurkopf festgelegt, haben den Fokus auf das Listenfeld gelegt, den Buchstaben C <\/b>eingetippt und dann den Code Zeile für Zeile durchlaufen.<\/p>\n Bild 8: Markierung über den Direktbereich<\/span><\/b><\/p>\n Das Verrückte ist: In diesem Fall markiert der Code die richtige Zeile, also die erste, deren Artikelname mit dem Buchstaben C <\/b>beginnt. Das ist zwar nicht das erste Mal, dass eine Prozedur mit und ohne überwachung durch das Debugging verschiedene Resultate liefert, aber nach meiner Erinnerung habe ich bisher immer den Grund für die Abweichung gefunden.<\/p>\n In diesem Fall habe ich noch weiter experimentiert, indem ich beispielsweise den Haltepunkt nur in die erste Zeile gelegt habe und den Code dann mit F5 <\/b>durchlaufen ließ. Oder ich habe den Haltepunkt auf die letzte Zeile gelegt.<\/p>\n In allen Fällen mit Haltepunkt lieferte die Prozedur das richtige Ergebnis. Sobald ich die Prozedur ohne Haltepunkt durchlaufen ließ, erhielt ich das falsche Ergebnis.<\/p>\n Interessanterweise war das Ergebnis ja auch immer dann korrekt, wenn es nur einen Eintrag mit dem entsprechenden Anfangsbuchstaben gab – es konnte also kein Problem mit dem Index sein.<\/p>\n Dennoch konnten wir durch die Manipulation des Index-Wertes der Selected<\/b>-Eigenschaft eine funktionierende Lösung liefen. Wenn wir den Wert 1 <\/b>vom Index abziehen, arbeitet die Prozedur ohne Debugging korrekt:<\/p>\n Wenn wir diese Variante hingegen im Debugging-Modus ausprobieren, liefert sie zuverlässig falsche (richtige) Ergebnisse, nämlich immer den Eintrag, der sich eine Position vor dem gesuchten Eintrag befindet.<\/p>\n Nun haben wir allerdings gerade einmal die bereits vorhandene Funktion abgebildet – und das noch nicht einmal vollständig, denn wir zeigen ja immer nur den ersten Datensatz mit dem entsprechenden Anfangsbuchstaben an. Aber wir wollen ja auch noch weitergehen und die Eingabe mehrerer Anfangsbuchstaben vorsehen.<\/p>\n Wie könnte das aussehen Im Windows Explorer springt die Markierung auf jeden Fall zum ersten Eintrag des ersten eingegebenen Buchstabens. Dann gibt der Windows Explorer dem Benutzer jeweils ein paar Hundertstelsekunden Zeit, um weitere Buchstaben einzutippen.<\/p>\n Wir müssen also die Zeit zwischen der Eingabe der Buchstaben erfassen und diese prüfen.<\/p>\n Hat der Benutzer sich zwischen zwei Buchstaben nur kurz Zeit gelassen, interpretieren wir dies als die Fortsetzung der Eingabe des Suchbegriffs. Lässt er zwischen zwei Buchstaben eine längere Pause, interpretieren wir dies als die Eingabe eines neuen Buchstabens.<\/p>\n Stellt sich die erste Frage: Wie messen wir die Zeit Dazu nutzen wir eine API-Funktion namens GetTickCount<\/b>, die uns die Zeit in Millisekunden liefert.<\/p>\n Dabei verwenden wir eine Variable namens lngStart<\/b>, um den Startzeitpunkt zu speichern:<\/p>\n Den Startzeitpunkt nehmen wir mit der Funktion StartTimer <\/b>auf, welche den aktuellen Wert von GetTickCount <\/b>in der Variablen lngStart <\/b>speichert:<\/p>\n Den Zeitraum seit dem Aufruf von StartTimer <\/b>ermitteln wir dann mit der Funktion EndTimer<\/b>. Diese ermittelt wiederum mit der Funktion GetTickCount<\/b> die aktuelle Systemzeit und gibt die Differenz aus der aktuellen Systemzeit und der mit StartTimer <\/b>in lngStart <\/b>gespeicherten Systemzeit:<\/p>\n Das Ergebnis ist die zwischen den beiden Aufrufen verstrichene Zeit.<\/p>\n Damit können wir nun starten:<\/p>\n Wir kümmern uns erst einmal darum, dass der Suchbegriff ordnungsgemäß zusammengestellt wird. Diesen speichern wir in der Variablen strSuche<\/b>, die wir im Klassenmodul des Formulars deklarieren:<\/p>\n Dann leeren wir die bisherige Version der Prozedur lstArtikel_KeyDown <\/b>und ergänzen diese wie folgt:<\/p>\n Die Prozedur ermittelt mit der Funktion EndTimer <\/b>die aktuelle Zeit minus der in der Variablen lngStart <\/b>gespeicherten Zeit und speichert diese in der Variablen lngTimer<\/b>. Im ersten Durchgang ist lngStart <\/b>noch gleich 0<\/b>, sodass lngTimer <\/b>die aktuelle Systemzeit aufweist (zum Beispiel 413609750<\/b>).<\/p>\n Dieser Wert ist also jenseits von Gut und Böse, wenn man diesen heranzieht, um die Zeit seit dem letzten Tastaturanschlag zu ermitteln. lngTimer <\/b>wird also viel größer als 500 Millisekunden sein, was in der If…Then<\/b>-Bedingung dazu führt, dass der Buchstabe aus Chr(KeyCode) <\/b>in der Variablen strSuche <\/b>gespeichert wird.<\/p>\n Wenn dem letzten Tastenanschlag weniger als 500 Millisekunden vergangen sind, wird hingegen der aktuelle Buchstabe zu dem bereits in der Variablen strSuche <\/b>gespeicherten Eintrag hinzugefügt. In jedem Fall wird am Ende der Prozedur die Funktion StartTimer <\/b>aufgerufen, damit die Systemzeit dieses Tastenanschlages in der Variablen lngStart <\/b>gespeichert wird. Die Ausgabe durch die Debug.Print<\/b>-Anweisung sieht beispielsweise wie folgt aus:<\/p>\n Das heißt, dass wir nacheinander die Zeichenfolgen Chai <\/b>und dann, nach einer knappen Sekunde, die Zeichenfolge Chang <\/b>eingegeben haben. Soweit, so gut: Den Suchbegriff haben wir nun schon. Nun müssen wir noch dafür sorgen, dass dieser zum geeigneten Zeitpunkt markiert wird – also sobald der Benutzer einmal 500 Millisekunden lang kein Zeichen eingegeben hat.<\/p>\n Also bauen wir die Ereignisprozedur wie in Listing 2 auf.<\/p>\n Listing 2: Prozedur zum Markieren von Einträgen mit mehreren eingegebenen Zeichen<\/span><\/b><\/p>\n Dummerweise reagiert das Listenfeld nun nach der Eingabe einer Buchstabenkombination wie Chai <\/b>gar nicht wie gewünscht. Statt den Eintrag Chai <\/b>anzuzeigen, springt sie wild durch die Datensätze. Bei genauerem Hinsehen springt sie gar nicht so wild, sondern zeigt nacheinander die Datensätze mit den Anfangsbuchstaben C<\/b>, H<\/b>, A <\/b>und I <\/b>an.<\/p>\n Hier liegt also offensichtlich ein grundlegendes Problem vor: Die eingebaute Funktion zum Markieren von Einträgen mit dem eingetippten Anfangsbuchstaben lässt sich nicht von unserer Prozedur beeindrucken und tut einfach weiter ihren Dienst.<\/p>\n Wie bekommen wir das in den Griff Dazu müssen wir schlicht das Markieren des gewünschten Eintrags verlagern. Normalerweise reagiert das Listenfeld direkt auf das Herunterdrücken der Taste. Offensichtlich führt es seine Markierung auch noch nach dem Ausführen der Ereignisprozedur Bei Taste ab <\/b>aus, weshalb unsere Markierung verpufft.<\/p>\n Also tragen wir unsere Anweisungen, die bisher in der Prozedur lstArtikel_KeyDown <\/b>untergebracht waren, in der Prozedur lstArtikel_KeyUp <\/b>unter. Der Benutzer wird diesen Unterschied nicht bemerken; die zeitliche Differenz ist in diesem Fall äußerst gering.<\/p>\n Allerdings springt die Markierung nun doch einige Male hin- und her – erstens durch die eingebaute Funktion, die immer den Eintrag mit dem aktuell getippten Anfangsbuchstaben markiert und zweitens durch unsere eigene Prozedur. Aber auch dieses Problem können wir zumindest noch etwas eingrenzen.<\/p>\n Dazu deaktivieren wir das Neuzeichnen des Formulars für den Zeitraum, in dem der Benutzer die Taste herunterdrückt bis er sie wieder loslässt. Dazu fügen wir der Ereignisprozedur, die durch das Ereignis Bei Taste ab <\/b>ausgelöst wird, die folgende Anweisung hinzu:<\/p>\n Die Prozedur, die durch das Ereignis Bei Taste auf <\/b>ausgelöst wird, passen wir hingegen wie in Listing 3 an.<\/p>\n![\"Entwurfsansicht](\"..\/fileadmin\/_temp_\/2018_02\/pic_1120_002.png\")
<\/p>\nFunktion schon da …<\/h2>\n
![\"Formular](\"..\/fileadmin\/_temp_\/2018_02\/pic_1120_003.png\")
<\/p>\nVarianten<\/h2>\n
![\"Tastatureingabe](\"..\/fileadmin\/_temp_\/2018_02\/pic_1120_004.png\")
<\/p>\nPrivate Sub <\/span>lstArtikel_KeyDown(KeyCode As Integer<\/span>, Shift As Integer<\/span>)\r\n Dim <\/span>strSQL As String<\/span>\r\n strSQL = \"Artikelname LIKE ''''\" & Chr(KeyCode) & \"*''''\"\r\n Debug.Print<\/span> strSQL\r\n Me!lstArtikel.Recordset.FindFirst strSQL\r\nEnd Sub<\/span><\/pre>\n![\"Die](\"..\/fileadmin\/_temp_\/2018_02\/pic_1120_005.png\")
<\/p>\n![\"Fehlermeldung](\"..\/fileadmin\/_temp_\/2018_02\/pic_1120_006.png\")
<\/p>\nListeneinträge durchlaufen<\/h2>\n
Private Sub <\/span>lstArtikel_KeyDown(KeyCode As Integer<\/span>, Shift As Integer<\/span>)\r\n Dim <\/span>i As Integer<\/span>\r\n For i = 0 To Me!lstArtikel.ListCount - 1\r\n Debug.Print<\/span> i, Left<\/span>(Me!lstArtikel.Column(1, i), 1), Me!lstArtikel.Column(1, i)\r\n If <\/span>Left<\/span>(Me!lstArtikel.Column(1, i), 1) = Chr(KeyCode) Then<\/span>\r\n Me!lstArtikel.Selected(i) = True<\/span>\r\n Exit For<\/span>\r\n End If<\/span>\r\n Next<\/span> i\r\nEnd Sub<\/span><\/pre>\n![\"Falsche](\"..\/fileadmin\/_temp_\/2018_02\/pic_1120_007.png\")
<\/p>\n 0 A Alice Mutton\r\n 1 A Aniseed Syrup\r\n 2 B Boston Crab Meat\r\n 3 C Camembert Pierrot<\/pre>\n
Forms(0)!lstArtikel.Selected(3) = true<\/pre>\n
![\"Markierung](\"..\/fileadmin\/_temp_\/2018_02\/pic_1120_008.png\")
<\/p>\nMe!lstArtikel.Selected(i - 1) = True<\/span><\/pre>\nMehrere Buchstaben abfragen<\/h2>\n
Private <\/span>Declare Function GetTickCount Lib \"kernel32\" () As Long<\/span><\/pre>\nPrivate <\/span>lngStart As Long<\/span><\/pre>\nPublic Sub <\/span>StartTimer()\r\n lngStart = GetTickCount\r\nEnd Sub<\/span><\/pre>\nPublic Function <\/span>EndTimer() As Long<\/span>\r\n EndTimer = (GetTickCount - lngStart)\r\nEnd Function<\/span><\/pre>\n\n
Private <\/span>strSuche As String<\/span><\/pre>\nPrivate Sub <\/span>lstArtikel_KeyDown(KeyCode As Integer<\/span>, Shift As Integer<\/span>)\r\n Dim <\/span>i As Integer<\/span>\r\n Dim <\/span>lngTimer As Long<\/span>\r\n lngTimer = EndTimer\r\n If <\/span>lngTimer > 500 Then<\/span>\r\n strSuche = Chr(KeyCode)\r\n Else<\/span>\r\n strSuche = strSuche & Chr(KeyCode)\r\n End If<\/span>\r\n Debug.Print<\/span> strSuche, lngTimer\r\n StartTimer\r\nEnd Sub<\/span><\/pre>\nC 413609750 \r\nCH 78 \r\nCHA 140 \r\nCHAI 94 \r\nC 938 \r\nCH 109 \r\nCHA 109 \r\nCHAN 94 \r\nCHANG 172<\/pre>\n
Private Sub <\/span>lstArtikel_KeyDown(KeyCode As Integer<\/span>, Shift As Integer<\/span>)\r\n Dim <\/span>i As Integer<\/span>\r\n Dim <\/span>lngTimer As Long<\/span>\r\n lngTimer = EndTimer\r\n If <\/span>lngTimer > 5000 Then<\/span>\r\n strSuche = Chr(KeyCode)\r\n Else<\/span>\r\n strSuche = strSuche & Chr(KeyCode)\r\n For i = 0 To Me!lstArtikel.ListCount - 1\r\n Debug.Print<\/span> i, Left<\/span>(Me!lstArtikel.Column(1, i), 1), Me!lstArtikel.Column(1, i), _\r\n Left<\/span>(Me!lstArtikel.Column(1, i), Len<\/span>(strSuche)), strSuche\r\n If <\/span>Left<\/span>(Me!lstArtikel.Column(1, i), Len<\/span>(strSuche)) = strSuche Then<\/span>\r\n Me!lstArtikel.Selected(i - 1) = True<\/span>\r\n Exit For<\/span>\r\n End If<\/span>\r\n Next<\/span> i\r\n End If<\/span>\r\n Debug.Print<\/span> strSuche, lngTimer\r\n StartTimer\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>lstArtikel_KeyDown(KeyCode As Integer<\/span>, _\r\n Shift As Integer<\/span>)\r\n Me.Painting = False<\/span>\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>lstArtikel_KeyUp(KeyCode As Integer<\/span>, Shift As Integer<\/span>)\r\n Dim <\/span>i As Integer<\/span>\r\n Dim <\/span>lngTimer As Long<\/span>\r\n lngTimer = EndTimer\r\n If <\/span>lngTimer > 500 Then<\/span>\r\n strSuche = Chr(KeyCode)\r\n Else<\/span>\r\n strSuche = strSuche & Chr(KeyCode)\r\n End If<\/span>\r\n For i = 0 To Me!lstArtikel.ListCount - 1\r\n If <\/span>Left<\/span>(Me!lstArtikel.Column(1, i), Len<\/span>(strSuche)) = strSuche Then<\/span>\r\n Me!lstArtikel.Selected(i) = True<\/span>\r\n Exit For<\/span>\r\n End If<\/span>\r\n Next<\/span> i\r\n StartTimer\r\n Me.Painting = True<\/span>\r\nEnd Sub<\/span><\/pre>\n