<\/p>\n
Textfelder sind keine übermäßig flexiblen Eingabesteuerelemente. Man gibt Text ein, löscht oder bearbeitet diesen oder kopiert Inhalte beziehungsweise fügt diese ein. Einige Anwendungen aber liefern für Textfelder überraschenden Komfort: Diese zeigen beispielsweise den zuletzt eingegebenen passenden Wert an, sobald man ein oder mehrere Zeichen in das Textfeld eingegeben hat. Der Benutzer kann dann per Tab- oder Eingabetaste die aktuell angezeigte Auswahl einfach übernehmen. Dies schauen wir uns genauer an und bauen eine passende Funktion für Access-Textfelder nach.<\/b><\/p>\n
Was benötigen wir also, um diese Funktion nachzubilden Zunächst einmal ein Textfeld, das wir damit ausstatten wollen.<\/p>\n
Wir konzentrieren uns zunächst auf ein einzelnes Textfeld und bauen anschließend eine Klasse, mit der wir die Funktion ganz einfach mit wenigen Codezeilen auf beliebige Textfelder übertragen können.<\/p>\n
Außerdem brauchen wir eine Tabelle, welche die zuletzt in ein Feld eingegebenen Daten speichert. Diese könnte im Entwurf beispielsweise wie in Bild 1 aussehen.<\/p>\n
![\"Erster](\"..\/fileadmin\/_temp_\/2015_01\/pic_966_001.png\")
<\/p>\n
Bild 1: Erster Entwurf der Tabelle zum Speichern der zuletzt verwendeten Werte<\/span><\/b><\/p>\n Hier finden Sie neben dem Primärschlüsselwert drei Felder, die den eigentlichen Wert, den Namen des Formulars sowie den Namen des Steuerelements aufnehmen, dessen Inhalte gespeichert und wieder zur Verfügung gestellt werden sollen.<\/p>\n Dazu bauen wir gleich einen eindeutigen Index über die drei Felder LetzterWert<\/b>, Formularname <\/b>und Steuerelementname <\/b>ein, der dafür sorgt, dass jeder Wert nur einmal je Formular und Steuerelement gespeichert wird.<\/p>\n Fürs Erste ist dies ein sinnvoller Ansatz. Wenn man jedoch ein wenig weiterdenkt, fällt auf, dass ein Feld ja möglicherweise nicht nur in einem einzigen Formular abgebildet wird, sondern vielleicht auch noch in weiteren Formularen. Es scheint also keine gute Idee zu sein, die Speicherung der zuletzt verwendeten Werte für ein Feld auf Formularname und Steuerelementname zu beziehen, sondern eher auf den reinen Feldnamen.<\/p>\n Woher bekommen wir den üblicherweise aus der Eigenschaft Steuerelementinhalt <\/b>des Textfeldes. Dies gilt aber auch nur für solche Textfelder, die an ein Feld einer Tabelle gebunden sind.<\/p>\n Aber wollen wir uns nur auf gebundene Felder beschränken Was ist, wenn wir etwa ein Feld zur Eingabe eines Filterkriteriums mit der Funktion zur Anzeige der zuletzt verwendeten Werte nutzen möchten Dieses ist ja normalerweise nicht an ein Feld einer Tabelle gebunden.<\/p>\n Also müssen wir uns ein anderes Merkmal aussuchen, mit dem wir die betroffenen Steuerelemente markieren. Dafür gibt es jedoch einen passenden Kandidaten: die Eigenschaft Marke<\/b>, unter VBA mit der Eigenschaft Tag <\/b>ansprechbar. <\/p>\n Wir hinterlegen also für alle Felder, welche die gleichen zuletzt verwendeten Werte anzeigen sollen, einen entsprechenden Bezeichner in der Marke<\/b>-Eigenschaft.<\/p>\n Die Tabelle tblLetzteWerte <\/b>ändern wir entsprechend, indem wir die beiden Felder Formularname <\/b>und Steuerelementname <\/b>entfernen und dafür das Feld LetzterWertMarke <\/b>einfügen (s. Bild 2).<\/p>\n Bild 2: Zweiter Entwurf der Tabelle zum Speichern der zuletzt verwendeten Werte<\/span><\/b><\/p>\n Zuletzt eingegebene Werte speichern<\/b><\/p>\n Nun müssen wir uns darum kümmern, dass überhaupt Werte in diese Tabelle gelangen. Dazu legen Sie ein erstes Formular mit einem einzigen Textfeld an und nennen dieses txtBeispieltext<\/b>. Im Eigenschaftsfenster stellen Sie außerdem die Eigenschaft Marke <\/b>auf den Wert Beispielfeld <\/b>ein (s. Bild 3).<\/p>\n Bild 3: Ausstatten des Textfeldes mit der Marke-Eigenschaft<\/span><\/b><\/p>\n Nun sollen vom Benutzer eingegebene Werte nach der Eingabe in der Tabelle tblLetzteWerte <\/b>gespeichert werden. Dazu nutzen wir die Ereignisprozedur, die durch das Ereignis Nach Aktualisierung <\/b>des Textfeldes ausgelöst wird. Wählen Sie hier den Wert [Ereignisprozedur] <\/b>aus und klicken Sie dann auf die Schaltfläche mit den drei Punkten (…<\/b>).<\/p>\n Es erscheint der VBA-Editor und zeigt die noch leere Prozedur txtLetzteWerte_AfterUpdate <\/b>an. Diese soll nun zunächst einfach den aktuellen Wert des Textfeldes in die Tabelle tblLetzteWerte <\/b>eintragen – samt dem verwendeten Wert für die Eigenschaft Marke<\/b>.<\/p>\n Die Prozedur sieht nun wie in Listing 1 aus und verwendet eine INSERT INTO<\/b>-SQL-Abfrage, um den Datensatz in der Tabelle zu speichern.<\/p>\n Listing 1: Speichern des aktuellen Wertes des Textfeldes txtBeispieltext in der Tabelle tblLetzteWerte<\/span><\/b><\/p>\n Dummerweise funktioniert diese Methode nur, solange Sie keinen Wert ein zweites Mal in die Tabelle eintragen. Dann schlägt nämlich die weiter oben vorgenommene Restriktion zu, nach der jede Kombination aus dem Wert Marke <\/b>und dem Inhalt des Textfeldes nur einmal in der Tabelle gespeichert werden darf (s. Bild 4). Wie kommen wir aus diesem Dilemma heraus<\/p>\n Bild 4: Fehler beim erneuten Hinzufügen der gleichen Kombination aus Marke und Wert<\/span><\/b><\/p>\n Dazu gibt es gleich mehrere Möglichkeiten. Die erste ist die folgende: Wir deaktivieren vorher die Fehlerbehandlung mit On Error Resume Next<\/b>. Dies unterbindet schlicht die Fehlermeldung. Der einzufügende Datensatz ist schließlich schon vorhanden, warum diesen also nochmals einfügen<\/p>\n An dieser Stelle müssen wir uns überlegen, wie und vor allem in welcher Reihenfolge die zuletzt verwendeten Werte im Textfeld angezeigt werden sollen. Benötigen wir eine alphabetische Reihenfolge Wollen wir die Werte in der Reihenfolge der Eingabe anzeigen Oder sollen sogar die am häufigsten verwendeten Werte bevorzugt angezeigt werden<\/p>\n Die Antwort auf diese Frage hängt von mehreren Faktoren ab. Der erste ist: Soll der passende Wert einfach nur als Auto-Ergänzung im Textfeld angezeigt werden – also etwa so wie in Bild 5<\/p>\n Bild 5: Automatische Ergänzung des eingegebenen Ausdrucks<\/span><\/b><\/p>\n Oder sollen diese in einer Art Kombinationsfeld oder gar in einer Kombination aus Textfeld und Listenfeld erscheinen In beiden Fällen sollte es eigentlich konfigurierbar sein, ob die Werte in der Reihenfolge der letzten Eingabe erscheinen oder in alphabetischer Reihenfolge.<\/p>\n Die Abfrage der Werte in alphabetischer Reihenfolge ist kein Problem: Wir können die dazu verwendete Abfrage ja einfach entsprechend sortieren. Wie aber sieht es aus, wenn die zuletzt eingegebenen Werte eine höhere Priorität haben sollen In diesem Fall gibt es wieder zwei Varianten: Erstens können wir die Zeit der letzten Eingabe in einem weiteren Feld der Tabelle speichern. Zweitens können wir das Primärschlüsselfeld nutzen, das ja mit einem Autowert gefüllt wird. Je höher der Wert im Primärschlüsselfeld, desto neuer ist der eingegebene Wert.<\/p>\n Dies ziehen wir dem Hinzufügen eines eigenen Datumsfeldes vor, müssen dafür aber die Prozedur zum Hinzufügen des aktuell eingegebenen Eintrags etwas anpassen: Dies soll nämlich nun einen eventuell bereits vorhandenen Eintrag mit dem gleichen Wert löschen, bevor der neue Wert angelegt wird.<\/p>\n Dadurch erhält der zuletzt angelegte Wert automatisch den höchsten Wert, auch wenn er zuvor bereits einmal angelegt wurde.<\/p>\n Dies sieht dann beispielsweise wie in Bild 6 aus: Der Wert Erster Wert <\/b>wird nach der ersten Eingabe erneut eingegeben. Die Prozedur löscht dann den ersten Wert und legt automatisch einen neuen Eintrag mit identischem Wert an. Die Prozedur sieht nun wie in Listing 2 aus.<\/p>\n Bild 6: Bei Eingabe eines bereits vorhandenen Werts wird der alte Wert gelöscht.<\/span><\/b><\/p>\n Zuletzt verwendete Werte abrufen<\/b><\/p>\n Die Voraussetzungen für die Anzeige der zuletzt verwendeten Werte sind somit geschaffen. Nun schauen wir uns die verschiedenen Varianten an, um diese Werte anzuzeigen.<\/p>\n Im ersten Ansatz soll einfach nur der naheliegendste Wert bezogen auf die bis dahin eingegebenen Zeichen angezeigt werden – und zwar so, dass die bereits eingegebenen Zeichen nicht markiert und die zu ergänzenden Zeichen markiert erscheinen.<\/p>\n Dazu benötigen wir die zuletzt eingegebenen Werte. Aber wie viele Und wie viele Werte sollen überhaupt gespeichert werden Zehn, hundert, tausend oder gar noch mehr Machen wir uns doch um die Anzahl zunächst keinen Kopf und verwenden einfach alle zuletzt eingelesenen Werte für das Textfeld mit dem entsprechenden Wert der Eigenschaft Marke. Diese lesen wir gleich beim öffnen des Formulars in ein Array rstLetzteWerte <\/b>ein, das wir auch modulweit verfügbar machen wollen. Also deklarieren wir dieses wie folgt im Kopf des Klassenmoduls des Formulars:<\/p>\n Die Funktion zum Einlesen der zuletzt verwendeten Werte soll diese allerdings nicht in der Reihenfolge der Verwendung liefern, sondern einfach in der alphabetischen Reihenfolge. Die Funktion heißt LetzteWerteEinlesen <\/b>und sieht wie in Listing 3 aus. Sie erwartet den Wert der Tag<\/b>-Eigenschaft des betroffenen Textfeldes und füllt die modulweit deklarierte Variable strLetzteWerte <\/b>mit den entsprechenden Werten.<\/p>\n Listing 3: Diese Funktion liest die zuletzt verwendeten Werte für das angegebene Steuerelement ein.<\/span><\/b><\/p>\n Diese bezieht sie natürlich aus der Tabelle tblLetzteWerte<\/b>. Auf diese greift sie über ein Recordset zu, das alle Datensätze dieser Tabelle liefert, deren Feld LetzterWertMarke <\/b>dem mit strTag <\/b>übergebenen Wert entspricht. Die Funktion durchläuft alle Datensätze dieses Recordsets in einer Do While<\/b>-Schleife und erledigt darin drei Schritte:<\/p>\n Diese Funktion wird gleich beim Laden des Formulars ausgelöst:<\/p>\n Ergänzen des aktuellen Ausdrucks<\/b><\/p>\n Nun kommt der interessante Teil: Wir wollen dafür sorgen, dass beim Eingeben eines oder mehrerer Zeichen in das Textfeld ein passender Wert aus dem Array strLetzteWerte <\/b>gefunden wird und die fehlenden Zeichen hinten an den bereits eingegebenen Ausdruck anhängen und als markiert kennzeichnen.<\/p>\n Den ersten Teil der Prozedur, die durch das Ereignis Bei Taste auf <\/b>des Textfeldes ausgelöst wird, finden Sie in Listing 4. Die Prozdur prüft zunächst den Wert des Parameters KeyCode<\/b>, der einen dem zuletzt eingegebenen Zeichen entsprechenden Zahlenwert enthält.<\/p>\n Listing 4: Diese Ereignisprozedur ergänzt den aktuellen Ausdruck (Teil I)<\/span><\/b><\/p>\n Der besseren Lesbarkeit halber haben wir diese in der Select Case<\/b>-Bedingung, die diese prüft, durch die entsprechenden Konstanten ersetzt, also etwa 9 <\/b>durch vbKeyTab<\/b>, 37 <\/b>durch vbKeyLeft<\/b>, 39 <\/b>durch vbKeyRight <\/b>und 8 <\/b>durch vbKeyBack<\/b>.<\/p>\n Wenn der Benutzer die Tabulatortaste, die Nach Links<\/b>– oder die Nach Rechts<\/b>-Taste verwendet, soll die Prozedur verlassen werden. Im Falle der Tabulatortaste verlässt der Fokus das Textfeld, im Falle der Nach Links<\/b>– und der Nach Rechts<\/b>-Taste springt der Cursor einfach nach links oder rechts. Eine eventuell bereits eingeblendete Erweiterung des aktuellen Ausdrucks bleibt somit erhalten.<\/p>\n Sollte der Benutzer die Zurück-Taste betätigt haben, wird diese ebenfalls einfach ausgeführt – aber die Prozedur wird nicht verändert. Genau wie die Eingabe eines Zeichens soll auch das Löschen eines Zeichens dazu führen, dass die Prozedur nach passenden Werten sucht.<\/p>\n Sollte der Benutzer ein beliebiges Zeichen mit Ausnahme der soeben erwähnten und in den ersten beiden Zweigen der Select Case<\/b>-Bedingung abgearbeiteten eingegeben haben, tritt der dritte Zweig der Select Case<\/b>-Bedingung in Aktion. Dort führt die Prozedur folgende Aktionen aus:<\/p>\n <\/p>\n Damit geht es nun weiter mit Listing 5. Hier prüft die Prozedur nun, ob überhaupt schon ein Zeichen eingegeben wurde. Ist dies nicht der Fall, endet die Prozedur hier. Anderenfalls stellt sie die Variable intStarttemp <\/b>auf den Wert 1 <\/b>ein. Damit ermittelt die Prozedur nun mithilfe der Mid<\/b>-Funktion und den Werten der beiden Variablen intSelStart <\/b>und intSelLength <\/b>den aktuellen Inhalt des Textfeldes und trägt diesen in die Variable strFeldTemp <\/b>ein. Die Länge dieser Zeichenkette landet anschließend in der Variablen intLenTemp<\/b>. Ist diese größer als 0<\/b>, prüft die Prozedur mit der Hilfsfunktion ArrayGefuellt<\/b>, ob das Array strLetzteWerte <\/b>überhaupt einen Wert enthält (s. Listing 6).<\/p>\n Listing 5: Diese Funktion prüft, ob ein Array gefüllt ist.<\/span><\/b><\/p>\n Ist dies nicht der Fall, soll dieses Array zunächst mit der Funktion LetzteWerteEinlesen <\/b>gefüllt werden. Bei diesem Aufruf verwerten wir auch den Rückgabewert der Funktion. Diesen vergleicht die Prozedur mit dem Wert 0<\/b>. Ist der Wert größer, enthält das neu gefüllte Array mindestens einen Eintrag und wir können prüfen, ob der aktuelle Wert des Textfeldes mit einem der Werte des Arrays übereinstimmt. Anderenfalls wird die Prozedur an dieser Stelle beendet.<\/p>\n Nun starten wir in einer For…Next<\/b>-Schleife den Vergleich des aktuellen Ausdrucks aus strFeldTemp <\/b>mit den ersten Zeichen der in strLetzteWerte <\/b>gespeicherten Zeichenketten. Wenn wir also die Zeichen Ers <\/b>eingegeben haben, vergleicht die Prozedur diese Zeichenkette jeweils mit den ersten drei Zeichen der Werte aus strLetzteWerte<\/b>. Stimmen diese überein, prüft eine weitere If…Then<\/b>-Bedingung, ob die in intSelStart <\/b>gespeicherte Position der Einfügemarke mit der Länge der Zeichenkette aus strAktuellerWert <\/b>übereinstimmt. Ist dies der Fall, prüft die Prozedur lediglich noch, ob der Benutzer die Zurück-Taste betätigt hat (vbKeyBack<\/b>). In diesem Fall wird der Wert für die aktuelle Markierung um eine Position nach links verschoben.<\/p>\n Anderenfalls stellt die Prozedur den Inhalt des Textfeldes über die Eigenschaft Text auf die bisher eingegebenen Zeichen (also etwa Ers<\/b>) plus die folgenden Zeichen des gefundenen Ausdrucks aus dem Array strLetzteWerte <\/b>ein (beispielsweise ter Wert<\/b>). Beides ergibt also nun zusammen Erster Wert<\/b>. Warum tragen wir also nicht direkt den kompletten Wert aus dem Array strLetzterWert <\/b>ein Weil dies auch die Groß-\/Kleinschreibung ändern könnte. Vielleicht hat der Benutzer ja die Zeichen ers <\/b>eingegeben, was dann in Ers <\/b>geändert werden würde.<\/p>\n Schließlich stellt die Prozedur die beiden Eigenschaften SelStart <\/b>und SelLength <\/b>so ein, dass alle Zeichen, die automatisch ergänzt wurden, markiert werden – in diesem Fall also die Zeichen ter Wert<\/b> von Erster Wert<\/b>. Den Start der Markierung entnimmt die Prozedur dabei der Variablen intSelStart<\/b>, die Länge der Markierung berechnet sie aus der Länge der Zeichenkette aus dem Array strLetzteWerte <\/b>und der Anzahl der bisher eingegebenen Zeichen.<\/p>\n AfterUpdate verhindern<\/b><\/p>\n Damit wäre prinzipiell alles erledigt – wenn die Zuweisung eines Wertes an die Eigenschaft Text <\/b>nicht ungünstigerweise das Ereignis Nach Aktualisierung <\/b>des Textfeldes auslösen würde. Und diese sorgt ja gerade dafür, dass die zuletzt eingegebenen Werte in der Tabelle tblLetzteWerte <\/b>erscheinen. Wenn diese aber nun jedes Mal ausgelöst wird, wenn der Benutzer ein neues Zeichen eingegeben hat, für das im Array strLetzteWerte <\/b>ein Wert gefunden wurde, ist die Tabelle tblLetzteWerte <\/b>schnell voller unsinniger Werte.<\/p>\n Da wir nicht verhindern können, dass das Ereignis Nach Aktualisierung <\/b>im genannten Fall ausgelöst wird, müssen wir dafür sorgen, dass die enthaltenen Anweisungen nur ausgeführt werden, wenn dies sinnvoll ist.<\/p>\n Dazu verwenden wir eine modulweit deklarierte Variable namens bolKey<\/b>:<\/p>\n Diese stellen wir in der Prozedur, die durch das Ereignis Bei Taste auf <\/b>des Textfeldes ausgelöst wird, auf den Wert True <\/b>ein – aber nur, wenn wir die Eigenschaft Text <\/b>des Textfeldes ändern wollen, und dann mit der vorherigen Anweisung.<\/p>\n Die Prozedur, die durch das Ereignis Nach Aktualisierung <\/b>des Textfeldes ausgelöst wird, müssen wir nun noch entsprechend anpassen (s. Listing 7).<\/p>\n Listing 7: Neue Version der Ereignisprozedur, die durch Nach Aktualisierung ausgelöst wird.<\/span><\/b><\/p>\n Dazu fügen Sie gleich zu Beginn eine If…Then<\/b>-Bedingung hinzu, die den Wert von bolKey <\/b>prüft. Hat diese Variable nicht den Wert True<\/b>, soll der eingegebene Wert in die Tabelle der zuletzt gespeicherten Werte geschrieben werden. Außerdem soll die Funktion LetzteWerteEinlesen <\/b>die zuletzt eingegebenen Werte ermitteln.<\/p>\n Hat bolKey <\/b>den Wert True<\/b>, geschieht dies nicht. Stattdessen soll bolKey <\/b>einfach auf False <\/b>gesetzt werden, damit der Wert beim eventuell nun folgenden Verlassen des Textfeldes gespeichert werden kann.<\/p>\n Letzte Werte per Klasse<\/b><\/p>\n Nun sollen Sie die hier beschriebenen Codepassagen nicht für jedes Steuerelement neu hinzufügen müssen. Alternativ erstellen wir eine Klasse, die alle wichtigen Elemente enthält. Diese heißt clsLetzteWerte<\/b> und soll neben den bereits bekannten Funktionen noch einige Erweiterungen bekommen.<\/p>\n Die erste betrifft die Anzahl der zuletzt gespeicherten Werte je Textfeld. Diese soll man mit einer Eigenschaft namens MengeLetzteWerte <\/b>einstellen können. Wenn mehr Einträge als dort angegeben für den entsprechenden Wert der Eigenschaft Tag<\/b>\/Marke <\/b>des Textfeldes in der Tabelle tblLetzteWerte <\/b>gespeichert sind, sollen die ältesten Einträge gelöscht werden.<\/p>\n Außerdem wollen wir dem Benutzer die Auswahl der zuletzt verwendeten Einträge mit den Schaltflächen Seite nach oben <\/b>und Seite nach unten <\/b>ermöglichen. Diese Option soll allerdings unabhängig von den bereits eingegebenen Zeichen erfolgen.<\/p>\n Klasse nutzen<\/b><\/p>\n Schauen wir uns zunächst an, wie Sie die Klasse nutzen können – später schauen wir uns die Klasse selbst an. Dazu erstellen Sie ein neues Formular namens frmBeispielMehrereFelder<\/b>, das Sie mit zwei Textfeldern namens txtVorname <\/b>und txtNachname <\/b>ausstatten (s. Bild 7).<\/p>\n Bild 7: Entwurf eines Formulars mit zwei Textfeldern, die mit der Klasse clsLetzteWerte ausgestattet werden sollen<\/span><\/b><\/p>\n Für dieses Formular legen Sie zunächst zwei Variablen an, welche die Verweise auf die beiden Instanzen der Klasse clsLetzteWerte <\/b>aufnehmen. Diese landen im Kopf des Klassenformulars:<\/p>\n Die Instanzierung übernimmt die Prozedur, die durch das Ereignis Beim Laden<\/b> des Formulars ausgelöst wird. Für diese hinterlegen Sie den Code aus Listing 8.<\/p>\n Listing 8: Beim Laden werden die Textfelder mit Zusatzfunktionen ausgestattet.<\/span><\/b><\/p>\n Die Prozedur erstellt zunächst ein neues Objekt auf Basis der Klasse clsLetzteWerte <\/b>und speichert einen Verweis darauf in der Variablen objLWVorname<\/b>.<\/p>\n Dann stellt es eine Eigenschaft namens Textbox <\/b>auf das Textfeld (hier txtVorname<\/b>) ein, das mit der Zusatzfunktion zum schnellen Auswählen der bereits eingegebene Werte ausgestattet werden soll. Außerdem liefert die Klasse noch eine Eigenschaft namens MengeLetzteWerte<\/b>, für die Sie die Anzahl der zu speichernden Werte für dieses Textfeld hinterlegen können.<\/p>\n Das Gleiche erledigen Sie für das Textfeld txtNachname<\/b>. Hier heißt die Variable objLWNachname<\/b>.<\/p>\n Sie dürfen nicht vergessen, auch noch eine Prozedur für das Ereignis Beim Entladen <\/b>anzulegen. Dieses leert die Objektvariablen wieder:<\/p>\n Lassen Sie diesen Schritt aus, stürzt Access beim Schließen des Formulars ab.<\/p>\n Wenn wir nun die Formularansicht des Formulars öffnen, erscheint direkt eine Meldung (s. Bild 8). Diese besagt, dass wir vergessen haben, einen Wert für die Marke<\/b>-Eigenschaft des Textfeldes txtVorname <\/b>anzugeben. Nach dem Schließen dieser Meldung erscheint die gleiche Meldung nochmals für das Textfeld txtNachname<\/b>.<\/p>\n Bild 8: Für eines der Textfelder wurde noch kein Wert für die Eigenschaft Tag\/Marke eingestellt.<\/span><\/b><\/p>\n Wenn wir nun die Werte txtVorname <\/b>und txtNachname <\/b>für die Marke<\/b>-Eigenschaft des jeweiligen Textfeldes hinterlegen, erscheinen die Meldungen beim nächsten öffnen nicht mehr.<\/p>\n Wenn Sie das Formular nun testen, werden neue Werte jeweils in der Tabelle tblLetzteWerte <\/b>gespeichert. Diese sieht dann etwa wie in Bild 9 aus.<\/p>\n Bild 9: Die Tabelle mit einigen Werten sorgt in dieser Konstellation dafür, dass das Betätigen der Seite nach unten-Taste den Vornamen Volkmar im Textfeld txtVorname anzeigt.<\/span><\/b><\/p>\n Wenn Sie dann im Textfeld txtVorname<\/b> die Taste Seite nach unten <\/b>drücken, erscheint als erster Wert der Name Volkmar<\/b>. Dies ist korrekt: Volkmar <\/b>ist der zuletzt eingegebene Name und das Textfeld soll die Namen in der Reihenfolge der Eingabe liefern.<\/p>\n Im Gegensatz dazu sollte die Eingabe des Buchstabens A <\/b>für die Ergänzung des Inhalts um die Buchstaben ndré <\/b>sorgen.<\/p>\n Erstellen der Klasse<\/b><\/p>\n Die Klasse enthält im Wesentlichen den Code, den Sie bereits in den vorherigen Ausführungen kennen gelernt haben. Hinzu kommen einige änderungen, die dazu erforderlich sind, dass Sie die Klasse als solche nutzen können – etwa die Eigenschaften der Klasse.<\/p>\n Schließlich haben wir noch die Funktion hinzugefügt, mit der Sie die zuletzt verwendeten Werte per Seite nach oben<\/b>\/Seite nach unten<\/b>-Taste auswählen können. Die Klasse fügen Sie mit dem Menübefehl Einfügen|Klassenmodul <\/b>hinzu. Speichern Sie diese gleich unter dem Namen clsLetzteWerte<\/b>.<\/p>\n Zum Speichern des Verweises auf die Textbox deklarieren wir die folgende Eigenschaft:<\/p>\n Der Benutzer soll das Textfeld nun mit einer Anweisung wie der folgenden übergeben können:<\/p>\n Dazu fügen Sie eine Property Set<\/b>-Prozedur wie in Listing 9 zum Klassenmodul hinzu. Diese Prozedur stellt zunächst die Variable m_Textbox <\/b>auf das mit Textbox <\/b>übergebene Textfeld ein. Dann legt es fest, welche Ereignisprozeduren in dieser Klasse implementiert und ausgelöst werden können, nämlich AfterUpdate <\/b>(Nach Aktualisierung<\/b>), OnKeyUp <\/b>(Bei Taste auf<\/b>) und OnGotFocus <\/b>(Bei Fokuserhalt<\/b>).<\/p>\n Listing 9: Property Set-Prozedur zum Einstellen des Textfeldes<\/span><\/b><\/p>\n Wenn die Tag-Eigenschaft gefüllt ist, ruft die Prozedur zwei Funktionen auf: LetzteWerteEinlesenAlphabet <\/b>und LetzteWerteEinlesenEingabe<\/b>. Beide basieren auf der bereits bekannten Funktion LetzteWerteEinlesen<\/b>, verwenden aber eine unterschiedliche Sortierung – eben nach dem Alphabet und nach der umgekehrten Reihenfolge der Eingabe. Diese beiden Funktionen füllen die folgenden Arrays:<\/p>\n![\"Zweiter](\"..\/fileadmin\/_temp_\/2015_01\/pic_966_002.png\")
<\/p>\n![\"Ausstatten](\"..\/fileadmin\/_temp_\/2015_01\/pic_966_003.png\")
<\/p>\nPrivate Sub <\/span>txtBeispieltext_AfterUpdate()\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Set<\/span> db = CurrentDb\r\n db.Execute \"INSERT INTO tblLetzteWerte(LetzterWert, LetzterWertMarke) VALUES(''\" _\r\n & Me!txtBeispieltext & \"'', ''\" _\r\n & Me!txtBeispieltext.Tag & \"'')\", dbFailOnError\r\nEnd Sub<\/span><\/pre>\n![\"Fehler](\"..\/fileadmin\/_temp_\/2015_01\/pic_966_004.png\")
<\/p>\n![\"Automatische](\"..\/fileadmin\/_temp_\/2015_01\/pic_966_005.png\")
<\/p>\n![\"Bei](\"..\/fileadmin\/_temp_\/2015_01\/pic_966_006.png\")
<\/p>\nPrivate <\/span>strLetzteWerte() As String<\/span><\/pre>\nPrivate Function <\/span>LetzteWerteEinlesen(strTag As String<\/span>) As Long<\/span>\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>rst As <\/span>DAO.Recordset\r\n Dim <\/span>i As Integer<\/span>\r\n Set<\/span> db = CurrentDb\r\n Set<\/span> rst = db.OpenRecordset(\"SELECT LetzterWert FROM tblLetzteWerte " _\r\n & "WHERE LetzterWertMarke = ''\" & strTag _\r\n & \"'' ORDER BY LetzterWert\", dbOpenDynaset)\r\n Do While<\/span> Not<\/span> rst.EOF\r\n ReDim Preserve strLetzteWerte(i) As String<\/span>\r\n strLetzteWerte(i) = rst!LetzterWert\r\n i = i + 1\r\n rst.MoveNext<\/span>\r\n Loop<\/span>\r\n LetzteWerteEinlesen = i\r\nEnd Function<\/span><\/pre>\n\n
Private Sub <\/span>Form_Load()\r\n LetzteWerteEinlesen Me!txtBeispieltext.Tag\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>txtBeispieltext_KeyUp(KeyCode As Integer<\/span>, Shift As Integer<\/span>)\r\n Dim <\/span>strAktuellerWert As String<\/span>\r\n Dim <\/span>intSelStart As Integer<\/span>\r\n Dim <\/span>intSelLength As Integer<\/span>\r\n Dim <\/span>strFeldTemp As String<\/span>\r\n Dim <\/span>intStarttemp As String<\/span>\r\n Dim <\/span>intLenTemp As Integer<\/span>\r\n Dim <\/span>i As Integer<\/span>\r\n Select Case KeyCode\r\n Case <\/span>vbKeyTab, vbKeyLeft, vbKeyRight<\/span> \r\n Exit Sub<\/span>\r\n Case <\/span>vbKeyBack\r\n Case Else<\/span>\r\n strAktuellerWert = Me!txtBeispieltext.Text\r\n intSelStart = Me!txtBeispieltext.SelStart\r\n intSelLength = Me!txtBeispieltext.SelLength\r\n End Select<\/span><\/pre>\n\n
Private Function <\/span>ArrayGefuellt(var() As String<\/span>) As Boolean<\/span>\r\n Dim <\/span>intTest As Integer<\/span>\r\n If <\/span>IsArray(var) Then<\/span>\r\n On Error Resume Next<\/span>\r\n intTest = LBound<\/span>(var())\r\n If <\/span>Err.Number = 0 Then<\/span>\r\n ArrayGefuellt = True<\/span>\r\n Else<\/span>\r\n ArrayGefuellt = False<\/span>\r\n End If<\/span>\r\n Else<\/span>\r\n ArrayGefuellt = False<\/span>\r\n End If<\/span>\r\nEnd Function<\/span><\/pre>\nPrivate <\/span>bolKey As Boolean<\/span><\/pre>\nPrivate Sub <\/span>txtBeispieltext_AfterUpdate()\r\n Dim <\/span>db As <\/span>DAO.Database\r\n If <\/span>Not<\/span> bolKey Then<\/span>\r\n Set<\/span> db = CurrentDb\r\n db.Execute \"DELETE FROM tblLetzteWerte WHERE LetzterWert = ''\" _\r\n & Me!txtBeispieltext & \"'' AND LetzterWertMarke = ''\" _\r\n & Me!txtBeispieltext.Tag & \"''\", dbFailOnError\r\n db.Execute \"INSERT INTO tblLetzteWerte(LetzterWert, LetzterWertMarke) \" _\r\n & \"VALUES(''\" & Me!txtBeispieltext & \"'', ''\" & Me!txtBeispieltext.Tag _\r\n & \"'')\", dbFailOnError\r\n LetzteWerteEinlesen Me!txtBeispieltext.Tag\r\n Else<\/span>\r\n bolKey = False<\/span>\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\n![\"Entwurf](\"..\/fileadmin\/_temp_\/2015_01\/pic_966_007.png\")
<\/p>\nDim <\/span>objLWVorname As <\/span>clsLetzteWerte\r\nDim <\/span>objLWNachname As <\/span>clsLetzteWerte<\/pre>\nPrivate Sub <\/span>Form_Load()\r\n Set<\/span> objLWVorname = New<\/span> clsLetzteWerte\r\n With<\/span> objLWVorname\r\n Set<\/span> .Textbox = Me!txtVorname\r\n .MengeLetzteWerte = 20\r\n End With<\/span>\r\n Set<\/span> objLWNachname = New<\/span> clsLetzteWerte\r\n With<\/span> objLWNachname\r\n Set<\/span> .Textbox = Me!txtNachname\r\n .MengeLetzteWerte = 20\r\n End With<\/span>\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>Form_Unload(Cancel As Integer<\/span>)\r\n Set<\/span> objLWVorname = Nothing\r\n Set<\/span> objLWNachname = Nothing\r\nEnd Sub<\/span><\/pre>\n![\"Für](\"..\/fileadmin\/_temp_\/2015_01\/pic_966_008.png\")
<\/p>\n![\"Die](\"..\/fileadmin\/_temp_\/2015_01\/pic_966_009.png\")
<\/p>\nPrivate <\/span>WithEvents m_Textbox As <\/span>Textbox<\/pre>\nSet<\/span> objLWVorname.Textbox = Me!txtVorname<\/pre>\nPublic Property Set<\/span> <\/span>Textbox(Textbox As <\/span>Textbox)\r\n Set<\/span> m_Textbox = Textbox\r\n With<\/span> m_Textbox\r\n .AfterUpdate = \"[Event Procedure]\"\r\n .OnKeyUp = \"[Event Procedure]\"\r\n .OnGotFocus = \"[Event Procedure]\"\r\n End With<\/span>\r\n If <\/span>Not<\/span> Len<\/span>(m_Textbox.Tag) = 0 Then<\/span>\r\n LetzteWerteEinlesenAlphabet m_Textbox.Tag\r\n LetzteWerteEinlesenEingabe m_Textbox.Tag\r\n Else<\/span>\r\n MsgBox<\/span> \"Das Textfeld ''\" & m_Textbox.Name _\r\n & \"'' kann nicht mit der Funktion zur Anzeige der letzten Werte \" _\r\n & \"verwendet werden, da die Tag\/Marke-Eigenschaft leer ist.\"\r\n End If<\/span>\r\nEnd Property<\/span><\/pre>\nPrivate <\/span>strLetzteWerteAlphabet() As String<\/span>\r\nPrivate <\/span>strLetzteWerteEingabe() As String<\/span><\/pre>\n