<\/p>\n
Autocomplete kennen Sie vermutlich von Kombinationsfeldern. Hier können Sie einen oder mehrere Buchstaben eingeben und das Kombinationsfeld zeigt gleich den nächsten Eintrag der Datensatzherkunft an, der mit diesen Anfangsbuchstaben beginnt. Dieses Verhalten wollen wir auch gern für Textfelder programmieren. Dazu starten wir mit einer etwas einfacheren Variante, die Sie vielleicht vom VBA-Editor kennen: Wenn Sie dort beginnen, einen Objekt- oder Variablennamen zu schreiben, können Sie mit der Tastenkombination Strg + Leertaste dafür sorgen, dass IntelliSense aktiviert wird und passende Einträge anzeigt. Wir wollen dafür sorgen, dass an dieser Stelle einfach der erste passende Eintrag erscheint – wenn wir eine Liste der verfügbaren Einträge wollten, könnten wir ja direkt ein Kombinationsfeld verwenden.<\/b><\/p>\nAutocomplete per Tastenkombination<\/h2>\n
Im VBA-Editor verwendet man die Tastenkombination Strg + Leertaste<\/b>, um beispielsweise Klassen oder Variablen anzuzeigen, die mit den bisher eingetippten Buchstaben beginnen. Wenn Sie etwa im Direktfenster die Buchstaben Curr <\/b>eingeben und dann diese Tastenkombination verwenden, erscheint die Liste aus Bild 1 zur Auswahl. <\/p>\n
![\"Autocomplete](\"..\/fileadmin\/_temp_\/2019_04\/pic_1200_001.png\")
<\/p>\n
Bild 1: Autocomplete per Intellisense im VBA-Editor<\/span><\/b><\/p>\n Was für ein Verhalten wollen wir bei dieser ersten Technik erhalten und welche Voraussetzungen müssen dafür erfüllt sein Die Voraussetzung ist, dass das Textfeld an ein Feld einer Tabelle gebunden ist, aus dem wir die möglichen zu ergänzenden Texte gewinnen können.<\/p>\n Dann wollen wir dem Benutzer ermöglichen, einen oder mehrere Buchstaben einzugeben und dann mit der Tastenkombination Strg + Leertaste <\/b>den nächsten passenden Eintrag zu ergänzen – so, dass die ergänzten Buchstaben markiert sind. Wenn wir also etwa in ein Textfeld, das an das Feld Artikelname <\/b>der Tabelle tblArtikel <\/b>gebunden ist, die Zeichenkette Ch <\/b>eingeben und dann Strg + Leertaste <\/b>betätigen, soll die Zeichenkette zu Chai <\/b>ergänzt werden, wobei die ergänzten Buchstaben markiert sein sollen. Die Einfügemarke soll sich dabei hinter dem zuletzt eingegebenen Buchstaben befinden und vor dem ersten Buchstaben der Markierung (siehe Bild 2).<\/p>\n Bild 2: Autocomplete im Textfeld<\/span><\/b><\/p>\n Das weitere Verhalten hängt davon ab, was der Benutzer als nächstes macht. Hier ist die Auswahl der möglichen Schritte:<\/p>\n Die erste Aufgabe ist, die Tastenkombination Strg + Leertaste <\/b>abzufangen. Wir schauen in einem Kombinationsfeld, wann die Ergänzung stattfindet – beim Niederdrücken der Taste oder beim Loslassen der Taste. Das Ergebnis ist: Die Ergänzung erfolgt bereits beim Herunterdrücken der Taste. Also verwenden wir das Ereignis Bei Taste ab <\/b>des Textfeldes, das wir in unserem Beispiel txtArtikelname <\/b>genannt haben. <\/p>\n Dazu wählen wir im Eigenschaftenblatt für das Ereignis Bei Taste ab <\/b>den Eintrag [Ereignisprozedur] <\/b>aus und klicken dann auf die Schaltfläche mit den drei Punkten (…<\/b>) neben dem Eigenschaftsfeld.<\/p>\n Dies legt im Klassenmodul des Formulars die folgende leere Prozedur an:<\/p>\n Um zu ermitteln, welche Werte die Parameter KeyCode <\/b>und Shift <\/b>beim Betätigen der Tastenkombination Strg + Leertaste <\/b>liefern, geben wir diese innerhalb der Prozedur mit der folgenden Anweisung im Direktfenster aus:<\/p>\n Danach wechseln wir in die Formularansicht, setzen den Fokus in das Textfeld txtArtikel <\/b>und geben die Tastenkombination Strg + Leertaste <\/b>ein. Das Ergebnis ist, dass KeyCode <\/b>den Wert 32 <\/b>und Shift <\/b>den Wert 2 <\/b>liefert (32 <\/b>entspricht auch der Konstanten vbKeySpace<\/b>, 2 <\/b>der Konstanten acCtrlMask<\/b>).<\/p>\n Damit können wir schon eine Bedingung in das Ereignis einbauen, unter der wir aktiv werden wollen:<\/p>\n Danach gehen wir an die Umsetzung der ersten Aufgabe. Das Ergebnis sieht wie in Listing 1 aus. Die Prozedur verwendet drei Variablen. intPosStart <\/b>speichert die Position der Eingabemarke zwischen und strTreffer <\/b>eventuell gefundene Treffer. strText <\/b>speichert den beim Betätigen der Taste im Textfeld vorhandenen Text.<\/p>\n Listing 1: Automatisches Ergänzen bei Strg + Leertaste<\/span><\/b><\/p>\n Nach dem Prüfen der Tastenkombination speichert die Prozedur die aktuelle Position der Einfügemarke in der Variablen intSelStart <\/b>und den aktuellen Text in strText<\/b>. Dann sucht sie mit der DLookup<\/b>-Funktion in der zugrunde liegenden Tabelle nach einem Wert, der mit den Zeichen aus strText <\/b>beginnt.<\/p>\n Findet sie einen solchen Wert, wird dieser in strTreffer <\/b>geschrieben, sonst landet der zweite Parameter der Nz<\/b>-Funktion als Ergebnis in strTreffer <\/b>– in diesem Fall der vorherige Inhalt des Textfeldes aus strText<\/b>.<\/p>\n Danach folgt die Aktualisierung des Textfeldes. Dabei weisen wir der Eigenschaft Text <\/b>den Inhalt von strTreffer <\/b>zu und setzen die Eingabemarke über die Eigenschaft SelStart <\/b>auf die vorherige Position, also intSelStart<\/b>. Außerdem stellen wir die Eigenschaft SelLength <\/b>auf den Wert 255 <\/b>ein, was der größten Zeichenkette entspricht, die wir in dieses Textfeld eingeben können. Damit markieren wir schlicht den Text von der Position der Einfügemarke aus bis zum Schluss.<\/p>\n Danach folgt noch eine wichtige Anweisung (KeyCode = 0<\/b>). Diese sorgt dafür, dass die eingegebene Taste nicht an das Textfeld geschickt wird. Ohne diese Anweisung würde die Prozedur zwar wie gewünscht funktionieren, aber durch das anschließende Senden des Leerzeichens an das Textfeld würde der markierte Bereich wieder gelöscht und durch das Leerzeichen überschrieben werden.<\/p>\n Damit haben wir aber nur den Beginn gemacht. Nun kommen wir an den Punkt, wo der Benutzer das nächste Zeichen eingibt, eines löscht, die Einfügemarke mit den Tasten Nach links<\/b>, Nach rechts<\/b>, Pos1<\/b> oder Ende<\/b> bewegt oder das Feld verlässt.<\/p>\n An dieser Stelle wollen wir uns bereits um eine kleine Einschränkung kümmern: Der zuvor beschriebene Ablauf soll nicht durchgeführt werden, wenn der Benutzer die Tastenkombination Strg + Leerzeichen <\/b>betätigt, während die Einfügemarke sich nicht am Ende des bisher eingegebenen Textes befindet. Wir müssen also noch eine Prüfung der Position der Einfügemarke bezogen auf den vorhandenen Text hinzufügen. Diese fügen wir hinter den beiden Anweisungen zur Ermittlung der Startposition der Markierung und des Textes ein und prüfen, ob intSelStart <\/b>genau der Länge des eingegebenen Textes entspricht – was bedeutet, dass die Einfügemarke sich hinter dem letzten Zeichen befindet:<\/p>\n Wenn der Benutzer mit Strg + Leertaste <\/b>Autocomplete aktiviert und gegebenenfalls eine Ergänzung hinzugefügt hat und dann das Feld beispielsweise mit der Tabulator-Taste oder durch einen Mausklick auf ein anderes Steuer-element verlässt, soll der enthaltene Text inklusive des markierten Teils beibehalten werden.<\/p>\n Für dieses Verhalten brauchen wir gar nichts zu tun – es ist bereits implementiert.<\/p>\n Die Einfügemarke kann der Benutzer bei markiertem Text auf verschiedene Arten bewegen – zum Beispiel auf die folgenden:<\/p>\n Wichtig ist an dieser Stelle, dass diese Bewegungen keine Änderungen am Text vornehmen.<\/p>\n Wir wollen das Verhalten wie bei der Autocomplete-Funktion von Kombinationsfeldern abbilden. Dort wird bei Betätigung dieser Tasten die übliche Funktion ausgeführt und die Markierung im Text wird entfernt.<\/p>\n Und auch hier bekommen wir das gewünschte Verhalten wieder frei Haus geliefert – es ist bereits implementiert.<\/p>\n Sie ahnen es bereits: Auch hier brauchen Sie nichts zu tun. Wenn Sie die Zurück<\/b>– oder die Entf<\/b>-Taste betätigen, während der hintere Teil des Textes markiert ist, wird der markierte Text einfach gelöscht.<\/p>\n Nun wird es allerdings wieder interessant: Wenn der Benutzer ein weiteres Zeichen eingibt, gibt es zwei Möglichkeiten:<\/p>\n <\/p>\n Wir schauen uns erst den Fall an, dass der Benutzer das erste Zeichen der Markierung eingegeben hat. In diesem Fall wollen wir wissen, welches Zeichen der Benutzer eingegeben hat und dieses dann mit dem ersten Zeichen der Markierung vergleichen.<\/p>\n Das ist mit den Parametern KeyCode <\/b>und Shift<\/b>, die wir von der Ereignisprozedur geliefert bekommen, nicht so einfach – zumindest dann nicht, wenn es sich bei den Zeichen nicht um Buchstaben oder Zahlen handelt. Wenn Sie beispielsweise ein kleines a <\/b>eingeben, liefert KeyCode <\/b>den Wert 65<\/b>. Wenn Sie ein großes A <\/b>eingeben, also Umschalt + a<\/b>, liefert KeyCode <\/b>ebenfalls den Wert 65<\/b>. Zusätzlich liefert Shift <\/b>den Wert 1<\/b>, also acShiftMask<\/b>. Der Ascii-Wert für das große A <\/b>ist jedoch 65<\/b>, für das kleine a <\/b>lautet er 97<\/b>. Die Ascii-Werte für Zeichen ermitteln Sie mit der Asc<\/b>-Funktion:<\/p>\n Bei den Buchstaben ist das kein Problem: Wir könnten dann in einer kleinen Funktion prüfen, ob Shift <\/b>den Wert acShiftMask<\/b> liefert. Ist das der Fall, entspricht der Wert von KeyCode <\/b>dem Ascii-Wert 65<\/b>. Ist Shift <\/b>nicht gleich acShiftMask<\/b>, müssen wir zum Wert von KeyCode <\/b>die Zahl 32 <\/b>hinzu addieren. <\/p>\n Das funktioniert so für alle Buchstaben. Dann schauen wir uns weitere gängige Zeichen an, die in Textfeldern verwendet werden – zum Beispiel das Minus-Zeichen, das gern als Bindestrich verwendet wird. Die Asc<\/b>-Funktion liefert dafür:<\/p>\n KeyCode <\/b>liefert allerdings den Wert 189<\/b>. Damit würde die Funktion zum Übersetzen von KeyCode <\/b>in Ascii schon umfangreicher werden. Genau genommen müssten wir damit alle Zeichen übersetzen, da wir ja nie wissen, welche Zeichen der Benutzer benötigt.<\/p>\n Allerdings gibt es noch eine Alternative: die Ereignisprozedur Bei Taste<\/b>. Die sieht im leeren Zustand für unser Textfeld txtArtikelname <\/b>wie folgt aus:<\/p>\n Der hier verwendete Parameter KeyAscii <\/b>liefert genau die gleichen Werte, die auch die Asc<\/b>-Funktion zurückgibt. Damit könnten wir also für die weiterführende Eingabe von Zeichen arbeiten.<\/p>\n Aber wenn wir nun eine weitere Ereignisprozedur hinzunehmen, um die Eingabe regulärer Zeichen zu untersuchen – macht es dann Sinn, die Prüfung auf Strg + Leerzeichen <\/b>in der Ereignisprozedur Bei Taste ab <\/b>zu belassen Und kommen sich die beiden Prozeduren dann nicht ins Gehege, weil die Bei Taste<\/b>-Ereignisprozedur auch nochmal auf Strg + Leertaste <\/b>reagiert<\/p>\n Ja, es macht Sinn, denn die beiden Ereignisprozeduren kommen sich bei Eingabe der Tastenkombination Strg + Leertaste <\/b>nicht ins Gehege. Genau genommen wird das Ereignis Bei Taste <\/b>durch diese Tastenkombination überhaupt nicht ausgelöst. Also arbeiten wir zunächst mit dem Ereignis Bei Taste <\/b>weiter.<\/p>\n Die entsprechende Ereignisprozedur füllen wir wie folgt:<\/p>\n Der Plan ist prinzipiell gut: Wir erfassen wieder die Position der Markierung und die Länge der Markierung sowie den gesamten Text. Dann prüfen wir, ob es eine Markierung mit mehr als 0 <\/b>Zeichen gibt. Ist das der Fall, ermitteln wir den ersten Buchstaben der Markierung und tragen diesen in die Variable strNaechster <\/b>ein.<\/p>\n Wenn KeyAscii <\/b>dem Ascii-Wert von strNaechster <\/b>entspricht, hat der Benutzer genau das nächste Zeichen eingegeben. Dann schreiben wir den Text aus strText zurück in das Textfeld, lassen die Markierung gegenüber der vorherigen Markierung um ein Zeichen weiter hinten beginnen. Außerdem soll die Markierung auch wieder bis zum Ende der Zeichenkette gehen. <\/p>\n Allerdings haben wir die Rechnung gemacht, ohne zu berücksichtigen, das nach Abschluss der Ereignisprozedur auch das eingegebene Zeichen noch in das Textfeld geschrieben wird. Hilft auch hier das Einstellen des Parameters auf den Wert 0 <\/b>wie es auch schon beim Parameter KeyCode <\/b>der Ereignisprozedur für Bei Taste ab <\/b>war Hängen wir die Anweisung doch einfach noch hinten an:<\/p>\n Damit erhalten wir das gewünschte Ergebnis. Bild 3 zeigt, wie es nun abläuft: Wenn wir etwa die beiden Buchstaben Ch <\/b>eingeben und dann auf Strg + Leertaste <\/b>drücken, werden die beiden Buchstaben ai <\/b>ergänzt.<\/p>\n Bild 3: Autocomplete im Praxiseinsatz<\/span><\/b><\/p>\n Geben wir dann den Buchstaben a <\/b>ein, wird dieser übernommen und nur noch das i <\/b>befindet sich in der Markierung. Auf die gleiche Weise können wir nun auch noch das i <\/b>ergänzen, sodass die Markierung komplett verschwindet.<\/p>\n Im Gegensatz dazu steht der Fall, dass der Benutzer statt des Buchstabens i <\/b>am Ende den Buchstaben n <\/b>eingibt, sodass dort Chan <\/b>steht. Die Autocomplete-Funktion soll dann erneut nach einem passenden Eintrag in der zugrunde liegenden Tabelle suchen, der in diesem Fall Chang <\/b>lauten würde.<\/p>\n Dazu fügen wir der inneren If…Then<\/b>-Bedingung einen Else<\/b>-Zweig hinzu:<\/p>\n Dieser stellt zunächst einen neuen Basistext zusammen, und zwar aus dem nicht markierten Teil des Textes, in unserem Beispiel Cha<\/b>, und dem neu eingegebenen Buchstaben n<\/b>. strText <\/b>enthält dann die Zeichenkette Chan<\/b>. Damit durchsuchen wir mit der DLookup<\/b>-Funktion, die wir erstmal aus der Ereignisprozedur Bei Taste ab <\/b>übernehmen, erneut das Feld Artikelname <\/b>der Tabelle tblArtikel<\/b>. Mit dem Ergebnis Chang <\/b>füllen wir dann das Textfeld und stellen die Markierung so ein, dass diese hinter dem zuletzt eingegebenen Zeichen beginnt und bis zum Ende des Textes reicht. Auch hier sorgen wir mit KeyAscii = 0 <\/b>dafür, dass das eingegebene Zeichen nicht mehr in das Textfeld geschrieben wird. Das Ergebnis finden Sie in Bild 4.<\/p>\n Bild 4: Vorschlag für einen anderen Artikelnamen<\/span><\/b><\/p>\n Wenn wir nun an der vorherigen Stelle kein n <\/b>eingeben, sondern beispielsweise ein x<\/b>, sodass der aktuelle Inhalt des Textfeldes Chax <\/b>lautet, sollte die DLookup<\/b>-Funktion keinen Eintrag finden. In diesem Fall verwendet sie dann den bisherigen Wert für strText <\/b>als Ergebnis.<\/p>\n Das funktioniert auch für alle Zeichen wie gewünscht, aber nicht, wenn wir beispielsweise das Leerzeichen eingeben. In diesem Fall wird zwar der markierte Teil des Textes gelöscht, aber es wird kein Leerzeichen ausgegeben (siehe Bild 5).<\/p>\n Bild 5: Ein eingetipptes Leerzeichen löscht zwar den markierten Text, aber wird selbst nicht ausgegeben.<\/span><\/b><\/p>\n Wenn wir den relevanten Teil der Prozedur txtArtikelname_KeyPress <\/b>debuggen, fällt uns auf, dass zwar strText noch den Text bis zur Einfügemarke plus das Leerzeichen enthält, aber nach der Zuweisung an die Eigenschaft Text <\/b>des Textfeldes fehlt das Leerzeichen.<\/p>\n Offensichtlich liegt es daran, dass Access Leerzeichen am Ende einer in ein Textfeld eingegebenen Zeichenkette einfach kürzt. Das ist in diesem Fall natürlich ungünstig, da der Benutzer ja offensichtlich möchte, dass an dieser Stelle des Textes ein Leerzeichen erscheint – zum Beispiel, um zwei durch ein Leerzeichen getrennte Wörter einzugeben. Also müssen wir im Else<\/b>-Teil der Prozedur prüfen, ob der Benutzer ein Leerzeichen eingegeben hat. Ist das der Fall, brauchen wir Keyascii <\/b>nicht auf 0 <\/b>einzustellen.<\/p>\n Dazu fassen wir diese Anweisung einfach in eine entsprechende If…Then<\/b>-Bedingung ein:<\/p>\n Damit gelingt nun auch die Eingabe von Leerzeichen.<\/p>\n Damit können wir nun mit der Funktion experimentieren. Zur Erinnerung: Autocomplete wird bisher nur mit Strg + Leertaste <\/b>aktiviert. Dann suchen die beiden Prozeduren nach einer passenden Ergänzung. Danach können Sie durch Eingabe von passenden Buchstaben fortfahren oder mit nicht passenden Buchstaben eine neue Suche anstoßen.<\/p>\n Den ersten Fehler haben wir recht leicht produzieren können, indem wir das Feld mit der Tabulator-Taste betreten. Die Prozedur txtArtikelname_KeyPress <\/b>erkennt dies als den KeyAscii<\/b>-Wert 9 <\/b>und verfährt damit wie mit einem normalen Zeichen. Sie landet dann im Else<\/b>-Teil der inneren If…Then<\/b>-Bedingung und versucht, das in strTreffer <\/b>gelandete Tabulator-Zeichen für die Eigenschaft Text <\/b>des Textfeldes einzufügen. Dies führt zum Fehler, wenn das Feld ein Pflichtfeld ist, was bei Artikelname der Fall ist.<\/p>\n Für diesen Fall schließen wir die äußere If…Then<\/b>-Bedingung direkt in eine Select Case<\/b>-Bedingung ein, welche das Tabulator-Zeichen ausschließt:<\/p>\n Die bisherige Funktion startet Autocomplete immer erst dann, wenn der Benutzer die Tastenkombination Strg + Leertaste <\/b>betätigt. Es gibt aber noch eine weitere Einstiegsmöglichkeit: Dazu muss der Benutzer selbständig den hinteren Teil des Feldinhalts markieren. Befindet sich die Einfügemarke dann am Beginn der Markierung und gibt der Benutzer ein Zeichen ein, wird die Funktion auch aktiviert.<\/p>\n Wir könnten es noch mit weiteren Bedingungen und Variablen verhindern, dass der Benutzer Autocomplete auf die zuletzt genannte Weise auslöst. Aber es ist recht unwahrscheinlich, dass er genau dies tut, sodass wir davon absehen.<\/p>\n Sinnvoll ist diese Variante, wenn das Laden der Daten über ein Netzwerk geschieht und die Last niedrig gehalten werden soll. Man könnte natürlich auch alle Daten für das Feld einmalig beim Öffnen des Formulars in ein Array oder Recordset laden, um den Datenverkehr über das Netzwerk auf einen Zugriff zu beschränken. Das würde an dieser Stelle allerdings den Rahmen sprengen.<\/p>\n Wenn Ihre Anwendung jedoch eine lokale Desktopanwendung ist oder das Netzwerk so schnell ist, dass sie sich keine Sorgen über ein paar zusätzliche Zugriffe auf die Datenbank machen müssen, können Sie auch eine Variante programmieren, bei der Autocomplete immer aktiv ist.<\/p>\n Dazu legen wir eine Kopie des Formulars frmAutocomplete <\/b>mit dem Namen frmAutocomplete_ImmerAktiv <\/b>an. Das Ziel ist also nun, direkt bei der Eingabe des ersten Zeichens nach passenden Ergänzungen in dem an das Textfeld gebundene Feld der Datenherkunft zu suchen.<\/p>\n Dazu können wir die Prozedur txtArtikelname_KeyDown <\/b>entfernen, denn wir brauchen ja nicht mehr auf die Strg-Taste zu reagieren. Deshalb können wir nun alle Eingaben über die Prozedur txtArtikelname_KeyPress<\/b> abwickeln. Die Inhalte der Prozedur können wir allerdings teilweise übernehmen und anpassen. Das sieht im Endergebnis wie in Listing 2 aus.<\/p>\n Listing 2: Ständig aktives Autocomplete<\/span><\/b><\/p>\n Neu an der Prozedur txtArtikelname_KeyPress <\/b>ist, dass wir nicht mehr prüfen, ob intSelLength > 0 <\/b>ist, also ob überhaupt eine Markierung vorhanden ist. Stattdessen prüfen wir, nachdem wir die drei Variablen intSelStart<\/b>, intSelLength <\/b>und strText <\/b>wie gewohnt gefüllt haben, ob das erste Zeichen der Markierung sich am Ende des Textes befindet, also ob gar keine Markierung vorhanden ist (intSelStart = Len(strText)<\/b>). Zuvor prüfen wir zusätzlich zum Tabulator-Zeichen noch auf das Entf-Zeichen, das wir ebenfalls von der folgenden Behandlung ausklammern wollen.<\/p>\n Ist also gar keine Markierung vorhanden, entspricht das im Prinzip der Situation, die wir im vorherigen Beispiel beim Betätigen der Tastenkombination Strg + Leertaste<\/b> hatten.<\/p>\n Nur müssen wir hier nicht nur nach dem vorhandenen Text im Textfeld suchen, sondern gleich nach dem vorhandenen Text plus dem soeben eingegebenen Zeichen, also strText & Chr(KeyAscii) <\/b>– wir ermitteln das Zeichen über die Chr<\/b>-Funktion aus dem Ascii-Code. Damit als Suchbegriff rufen wir dann die DLookup<\/b>-Funktion auf und suchen nach passenden Ergänzungen. Diese tragen wir dann wie in den übrigen Fällen in das Textfeld ein, indem wir die Text<\/b>-Eigenschaft mit dem Wert aus strTreffer <\/b>füllen, SelStart <\/b>auf intSelStart + 1 <\/b>einstellen und SelLength <\/b>auf 255<\/b>. Schließlich stellen wir auch hier KeyAscii <\/b>auf den Wert 0 <\/b>ein, da wir das neue Zeichen ja schon zum Textfeld hinzugefügt haben.<\/p>\n Im Else<\/b>-Teil der Bedingung behalten wir dann die bereits bekannten Elemente aus dem ersten Beispiel bei. Damit bekommen wir dann direkt bei Eingabe des ersten Buchstabens einen Vorschlag für den passenden Eintrag (siehe Bild 6).<\/p>\n Bild 6: Autocomplete gleich nach dem ersten Zeichen<\/span><\/b><\/p>\n Bei den Experimenten mit dieser neuen Autocomplete-Version haben wir festgestellt, dass beispielsweise die Tastenkombination Strg + Entf<\/b>, die normalerweise den kompletten Inhalt von der Einfügemarke bis zum Beginn der Zeichenkette oder bis zum nächsten Exemplar bestimmter Zeichen wie dem Leerzeichen löschen sollte, nur ein Sonderzeichen erzeugt (siehe Bild 7). Deshalb ermitteln wir in der Prozedur mit Debug.Print KeyAscii <\/b>auch den Ascii-Code für dieses Zeichen, was 127 <\/b>ergibt. Dieses fügen wir dann auch noch in den ersten Zweig der Select Case<\/b>-Bedingung ein:<\/p>\n![\"Autocomplete](\"..\/fileadmin\/_temp_\/2019_04\/pic_1200_002.png\")
<\/p>\n\n
Tastenkombination abfangen<\/h2>\n
Private Sub <\/span>txtArtikelname_KeyDown(KeyCode As Integer<\/span>, Shift As Integer<\/span>)\r\nEnd Sub<\/span><\/pre>\nDebug.Print<\/span> KeyCode, Shift<\/pre>\nPrivate Sub <\/span>txtArtikelname_KeyDown(KeyCode As Integer<\/span>, Shift As Integer<\/span>)\r\n If <\/span>KeyCode = vbKeySpace And Shift = acCtrlMask Then<\/span>\r\n MsgBox<\/span> \"Action!\"\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>txtArtikelname_KeyDown(KeyCode As Integer<\/span>, Shift As Integer<\/span>)\r\n Dim <\/span>intSelStart As Integer<\/span>\r\n Dim <\/span>strTreffer As String<\/span>\r\n Dim <\/span>strText As String<\/span>\r\n If <\/span>KeyCode = vbKeySpace And Shift = acCtrlMask Then<\/span>\r\n intSelStart = Me!txtArtikelname.SelStart\r\n strText = Me!txtArtikelname.Text\r\n strTreffer = Nz(DLookup(\"Artikelname\", \"tblArtikel\", \"Artikelname LIKE ''\" & strText & \"*''\"), strText)\r\n Me!txtArtikelname.Text = strTreffer\r\n Me!txtArtikelname.SelStart = intSelStart\r\n Me!txtArtikelname.SelLength = 255\r\n KeyCode = 0\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\nEinschränkung: Einfügemarke nicht hinter dem letzten Zeichen<\/h2>\n
---\r\nstrText = Me!txtArtikelname.Text\r\nIf <\/span>intSelStart = Len<\/span>(strText) Then<\/span>\r\n ...\r\nEnd If<\/span>\r\nKeyCode = 0\r\n...<\/pre>\nVerlassen des Feldes mit Autocomplete<\/h2>\n
Bewegen der Einfügemarke<\/h2>\n
\n
Betätigen der Zurück- und der Entf-Taste<\/h2>\n
Eingabe weiterer Zeichen<\/h2>\n
\n
KeyCode, Shift und Ascii<\/h2>\n
Debug.Print<\/span> Asc(\"a\")\r\n97<\/pre>\nDebug.Print<\/span> Asc(\"-\")\r\n 45 <\/pre>\nPrivate Sub <\/span>txtArtikelname_KeyPress(KeyAscii As Integer<\/span>)\r\n Debug.Print<\/span> KeyAscii\r\nEnd Sub<\/span><\/pre>\nZeichen mit dem Bei Taste-Ereignis untersuchen<\/h2>\n
Private Sub <\/span>txtArtikelname_KeyPress(KeyAscii As Integer<\/span>)\r\n Dim <\/span>intSelStart As Integer<\/span>\r\n Dim <\/span>intSelLength As Integer<\/span>\r\n Dim <\/span>strText As String<\/span>\r\n Dim <\/span>strNaechster As String<\/span>\r\n intSelStart = Me!txtArtikelname.SelStart\r\n intSelLength = Me!txtArtikelname.SelLength\r\n strText = Me!txtArtikelname.Text\r\n If <\/span>intSelLength > 0 Then<\/span>\r\n strNaechster = Mid<\/span>(strText, intSelStart + 1, 1)\r\n If <\/span>KeyAscii = Asc(strNaechster) Then<\/span>\r\n With<\/span> Me!txtArtikelname\r\n .Text = strText\r\n .SelStart = intSelStart + 1\r\n .SelLength = 255\r\n End With<\/span>\r\n End If<\/span>\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>txtArtikelname_KeyPress(KeyAscii As Integer<\/span>)\r\n ...\r\n If <\/span>intSelLength > 0 Then<\/span>\r\n If ...\r\n ...\r\n KeyAscii = 0\r\n End If<\/span>\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\n![\"Autocomplete](\"..\/fileadmin\/_temp_\/2019_04\/pic_1200_003.png\")
<\/p>\nWenn der Benutzer ein anderes Zeichen eingibt<\/h2>\n
...\r\nElse<\/span>\r\n strText = Left<\/span>(strText, intSelStart) & Chr(KeyAscii)\r\n strTreffer = Nz(DLookup(\"Artikelname\", \"tblArtikel\", \"Artikelname LIKE ''\" & strText & \"*''\"), strText)\r\n With<\/span> Me!txtArtikelname\r\n .Text = strTreffer\r\n .SelStart = intSelStart + 1\r\n .SelLength = 255\r\n End With<\/span>\r\n KeyAscii = 0\r\nEnd If<\/span>\r\n...<\/pre>\n![\"Vorschlag](\"..\/fileadmin\/_temp_\/2019_04\/pic_1200_004.png\")
<\/p>\nWenn kein Treffer gefunden wird …<\/h2>\n
![\"Ein](\"..\/fileadmin\/_temp_\/2019_04\/pic_1200_005.png\")
<\/p>\nIf <\/span>Not<\/span> KeyAscii = 32 Then<\/span>\r\n KeyAscii = 0\r\nEnd If<\/span><\/pre>\nTest der Funktion<\/h2>\n
Select Case KeyAscii\r\n Case <\/span>9\r\n Case Else<\/span>\r\n If <\/span>intSelLength > 0 Then<\/span>\r\n ...\r\n End If<\/span>\r\nEnd Select<\/span><\/pre>\nAutocomplete nicht immer aktiv<\/h2>\n
Performance<\/h2>\n
Autocomplete immer aktiv<\/h2>\n
Private Sub <\/span>txtArtikelname_KeyPress(KeyAscii As Integer<\/span>)\r\n Dim <\/span>intSelStart As Integer<\/span>\r\n Dim <\/span>intSelLength As Integer<\/span>\r\n Dim <\/span>strText As String<\/span>\r\n Dim <\/span>strNaechster As String<\/span>\r\n Dim <\/span>strTreffer As String<\/span>\r\n intSelStart = Me!txtArtikelname.SelStart\r\n intSelLength = Me!txtArtikelname.SelLength\r\n strText = Me!txtArtikelname.Text\r\n Select Case KeyAscii\r\n Case <\/span>8, 9\r\n Case Else<\/span>\r\n If <\/span>intSelStart = Len<\/span>(strText) Then<\/span>\r\n strText = strText & Chr(KeyAscii)\r\n strTreffer = Nz(DLookup(\"Artikelname\", \"tblArtikel\", \"Artikelname LIKE ''\" & strText & \"*''\"), strText)\r\n With<\/span> Me!txtArtikelname\r\n .Text = strTreffer\r\n .SelStart = intSelStart + 1\r\n .SelLength = 255\r\n End With<\/span>\r\n KeyAscii = 0\r\n Else<\/span>\r\n strNaechster = Mid<\/span>(strText, intSelStart + 1, 1)\r\n If <\/span>KeyAscii = Asc(strNaechster) Then<\/span>\r\n With<\/span> Me!txtArtikelname\r\n .Text = strText\r\n .SelStart = intSelStart + 1\r\n .SelLength = 255\r\n End With<\/span>\r\n KeyAscii = 0\r\n Else<\/span>\r\n strText = Left<\/span>(strText, intSelStart) & Chr(KeyAscii)\r\n strTreffer = Nz(DLookup(\"Artikelname\", \"tblArtikel\", \"Artikelname LIKE ''\" & strText & \"*''\"), _\r\n strText)\r\n With<\/span> Me!txtArtikelname\r\n .Text = strTreffer\r\n .SelStart = intSelStart + 1\r\n .SelLength = 255\r\n End With<\/span>\r\n If <\/span>Not<\/span> KeyAscii = 32 Then<\/span>\r\n KeyAscii = 0\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>\n![\"Autocomplete](\"..\/fileadmin\/_temp_\/2019_04\/pic_1200_006.png\")
<\/p>\nWeitere Tests<\/h2>\n
![\"Sonderzeichen](\"..\/fileadmin\/_temp_\/2019_04\/pic_1200_007.png\")
<\/p>\n