Dann hinterlegen wir für das Ereignis Vor Aktualisierung <\/b>des Textfeldes txtPLZ<\/b>, das an das Feld PLZ <\/b>gebunden ist, die Ereignisprozedur aus Listing 1. Diese liest den Inhalt des Textfeldes txtPLZ <\/b>in die Variable strPLZ <\/b>ein und ersetzt einen eventuellen Nullwert durch eine leere Zeichenkette. Dann untersucht sie in einer For…Next<\/b>-Schleife alle Buchstaben der Zeichenkette strPLZ<\/b>. Dabei ermittelt sie den aktuellen Buchstaben mit Mid(strPLZ, i, 1) <\/b>und prüft dann mit der InStr<\/b>-Funktion, ob dieser in der Zeichenkette aus cStrZahlen <\/b>enthalten ist. Ist das nicht der Fall, liefert InStr <\/b>die Position, die gleich 0 <\/b>ist. Dann erscheint eine entsprechende Meldung und die Eingabe wird mit Cancel = True <\/b>abgebrochen – der Benutzer kann das Feld erst verlassen, wenn die Prüfung erfolgreich ist (siehe Bild 1). Dazu kann das Feld auch vollständig geleert werden.<\/p>\n
![\"Meldung](\"..\/fileadmin\/_temp_\/2022_04\/pic_1379_001.png\")
<\/p>\n
Bild 1: Meldung nach dem Vor Aktualisierung-Ereignis<\/span><\/b><\/p>\n Listing 1: Prüfen der PLZ nach der Eingabe<\/span><\/b><\/p>\n Die alternative Variante ist, die Zeichen direkt bei der Eingabe zu prüfen. Dazu benötigen wir eine andere Ereignisprozedur, nämlich Bei Taste ab<\/b>. Vorab ein Hinweis: Damit decken wir nicht alle Fälle ab. Dazu jedoch später mehr.<\/p>\n Da wir auch erst einmal die Eingabe der Postleitzahl beschreiben wollen, kopieren wir das Feld txtPLZ <\/b>in ein neues Textfeld namens txtPLZ2<\/b>. Für dieses hinterlegen wir dann die Ereignisprozedur txtPLZ2_KeyDown<\/b>. Was können wir mit dem Ereignis Bei Taste ab <\/b>erledigen?<\/p>\n Die dadurch ausgelöste Prozedur txtPLZ2_KeyDown <\/b>ist so aufgebaut:<\/p>\n Hier sehen wir zwei Parameter:<\/p>\n KeyCode <\/b>liefert aber nicht nur einen Zahlenwert für die aktuell angeklickte Taste. Sie können durch Einstellen von KeyCode <\/b>auf den Wert 0 <\/b>auch dafür sorgen, dass der Tastenanschlag nicht an das aktuelle Steuerelement weitergeleitet wird. Und Sie können sogar festlegen, dass statt des gedrückten Zeichens ein anderes Zeichen weitergegeben wird. Für uns ist allerdings nur interessant, die Eingabe eines nicht gewünschten Zeichens zu unterbinden, indem wir KeyCode <\/b>auf 0 <\/b>einstellen.<\/p>\n Wie finden wir heraus, welcher KeyCode <\/b>welchem Zeichen entspricht, um entsprechend darauf reagieren zu können? Ganz einfach: Wir geben den KeyCode <\/b>einfach im Direktbereich aus.<\/p>\n Damit erfahren wir durch Eingeben von Zeichen in das Feld txtPLZ2 <\/b>schnell, dass die Zahlen von 0 <\/b>bis 9 <\/b>den Werten 48 <\/b>bis 57 <\/b>für KeyCode <\/b>entsprechen. Wir können nun in einem ersten Ansatz dafür sorgen, dass der Benutzer nur noch diese Zeichen in das Textfeld eingeben kann. Dazu prüfen wir, ob KeyCode <\/b>einen Wert von 48 <\/b>bis 57 <\/b>enthält und falls nicht, geben wir mit dem Parameter KeyCode <\/b>den Wert 0 <\/b>zurück:<\/p>\n Das funktioniert genau wie angenommen: Nur die Tasten 0 <\/b>bis 9 <\/b>werden weitergeleitet und im Textfeld ausgegeben.<\/p>\n Wir haben allerdings ein kleines Problem: Auch die Tasten zum Bewegen der Einfügemarke, die Eingabetaste, die Tabulatortaste et cetera werden innerhalb des Textfeldes blockiert. Also geben wir auch solche Tasten wieder frei.<\/p>\n Wie Sie herausfinden, welche KeyCodes hinter den Tasten stecken, haben wir ja bereits beschrieben. Der Übersicht halber tragen wir die zusätzlichen Elemente in eine weitere Case<\/b>-Bedingung ein:<\/p>\n Gegebenenfalls verwenden Benutzer auch den Nummernblock der Tastatur, um Zahlen einzugeben. Das müssen wir berücksichtigen, denn die KeyCode<\/b>-Werte entsprechen nicht denen der normalen Zahlentasten, sondern den Zahlen von 96<\/b> bis 105<\/b>. Wir fügen diese dem Case<\/b>-Zweig für die normalen Zahlen hinzu:<\/p>\n Die Eingabetaste im Nummernblock hat allerdings auch den KeyCode<\/b>-Wert 13<\/b>, sodass hier keine Erweiterung notwendig ist.<\/p>\n Die vollständige Prozedur sieht nun wie folgt aus:<\/p>\n Für bessere Lesbarkeit können wir auch die Konstanten der Enumeration KeyCodeConstants<\/b> nutzen.<\/p>\n Bei der Gelegenheit fällt uns noch eine Ergänzung ein: Aktuell lassen wir alle Betätigungen der Tasten von 0 <\/b>bis 9 <\/b>zu – und wir prüfen noch nicht, ob der Benutzer dabei eine der Tasten Umschalt<\/b>, Strg <\/b>oder Alt <\/b>drückt. Das heißt, dass der Benutzer die Zahlen auch bei gedrückter Umschalttaste eingeben kann, was die Eingabe von Ausrufezeichen, Anführungszeichen und so weiter erlaubt. Wir müssen also im Case<\/b>-Zweig für die Zahlen noch prüfen, ob der Parameter Shift <\/b>den Wert 0 <\/b>enthält und falls nicht, das eingegebene Zeichen abfangen.<\/p>\n Dann sieht die Prozedur wie in Listing 2 aus.<\/p>\n Listing 2: Prüfen der PLZ nach der Eingabe mit KeyCode-Konstanten<\/span><\/b><\/p>\n Der Fall, den wir mit dieser Methode nicht verarbeiten können, ist das Einfügen von Texten über die Zwischenablage. Das heißt, der Benutzer hat beispielsweise den Text D-12345 <\/b>in die Zwischenablage kopiert, markiert dann das Textfeld txtPLZ2 <\/b>und betätigt entweder die Tastenkombination Strg + V <\/b>oder den Kontextmenübefehl Einfügen<\/b>.<\/p>\n <\/p>\n Als Erstes fällt auf: Wir haben die Tastenkombination Strg + V <\/b>noch gar nicht freigeschaltet. Das ist etwas aufwendiger, da wir auch noch prüfen müssen, ob die Strg<\/b>-Taste gleichzeitig gedrückt wird. Ob die Strg<\/b>-Taste gedrückt wird, ermitteln wir wie bei der Umschalt<\/b>-Taste und der Alt<\/b>-Taste über den Parameter Shift<\/b>. Shift <\/b>kann die folgenden Werte annehmen, die auch kombiniert werden können:<\/p>\n Auch hier gibt es entsprechende Konstanten. Allerdings verwenden wir nicht die der Enumeration KeyCodeConstants<\/b>, sondern entsprechende Access-Konstanten:<\/p>\n Die Betätigung der Tastenkombination lassen wir also mit dem folgenden Case<\/b>-Zweig in der Select Case<\/b>-Bedingung zu:<\/p>\n Beim Betätigen des Buchstaben c <\/b>prüfen wir also, ob der Benutzer dabei die Strg<\/b>-Taste (acCtrlMask<\/b>) betätigt hat. Falls dies nicht in Kombination mit der Strg<\/b>-Taste geschehen ist, wird dies mit KeyCode = 0 <\/b>unterbunden.<\/p>\n Aber was tun wir, wenn der Benutzer einen Text mit Strg + V <\/b>einfügt? Wir könnten natürlich an dieser Stelle den Inhalt der Zwischenablage abgreifen und untersuchen. Aber wie machen es uns ein wenig einfacher. Die Lücke füllen wir durch das Setzen des Zeitgeberintervalls auf 100 Millisekunden:<\/p>\n Ist TimerIntervall <\/b>auf einen Wert größer als 0 <\/b>gesetzt, wird im angegebenen Intervall das Ereignis Bei Zeitgeber <\/b>ausgelöst. Für dieses hinterlegen wir die folgende Prozedur:<\/p>\n Was geschieht hier? Wenn der Benutzer beispielsweise den Text D-12345 <\/b>aus der Zwischenablage in das Textfeld eingeben will, erkennt die KeyDown<\/b>-Ereignisprozedur, dass er Strg + V <\/b>betätigt hat. Der Text ist zu diesem Zeitpunkt aber noch nicht im Textfeld angekommen, sondern erst kurze Zeit später. Daher verwenden wir die Form_Timer<\/b>-Ereignisprozedur, um den eingefügten Text auszuwerten.<\/p>\n Hier schreiben wir den Text aus dem Textfeld zunächst in die Variable strPLZ<\/b>. Wir können nicht auf Me!txtPLZ2 <\/b>zugreifen, sondern müssen Me!txtPLZ2.Text <\/b>nutzen, da der Text noch nicht im Textfeld gespeichert wurde.<\/p>\n Danach durchlaufen wir eine For…Next<\/b>-Schleife über alle Zeichen des hineinkopierten Textes und prüfen, ob es dort andere Zeichen als die Zahlen von 0 <\/b>bis 9 <\/b>gibt. Nur diese Zahlen werden an eine neue Zeichenkette namens strTemp <\/b>angehängt. Wir prüfen also für jedes Zeichen, ob es eine Zahl ist, und übernehmen sie dann in strTemp<\/b>.<\/p>\n Aus D-12345 <\/b>in strPLZ <\/b>wird also 12345 <\/b>in strTemp<\/b>. Diesen Wert schreiben wir dann zurück in das Textfeld.<\/p>\n Es gibt auch noch die Möglichkeit, dass der Benutzer den Inhalt der Zwischenablage über den Befehl Einfügen <\/b>aus dem Kontextmenü in das Textfeld kopieren will. Entwickler nutzen vermutlich überwiegend die Tastenkombination Strg + V<\/b>, aber normale Benutzer verwenden vermutlich durchaus noch solche Kontextmenü-Befehle.<\/p>\n Wir können zwar den Rechtsklick auf das Textfeld abfangen, aber wir können nicht herausfinden, ob der Benutzer den Befehl Einfügen <\/b>aus dem Kontextmenü auswählt.<\/p>\n Was dann? In diesem Fall wird zwar nicht das Ereignis Bei Taste ab <\/b>ausgelöst, aber das Ereignis Bei Änderung<\/b>. Dieses können wir wieder nutzen, indem wir den geänderten Text untersuchen und nicht erlaubte Zeichen entfernen.<\/p>\n Die Prozedur txtPLZ2_Change <\/b>sieht schließlich wie in Listing 3 aus und enthält bis auf das Zurücksetzen des Zeitgeberintervalls die gleichen Anweisungen wie Form_Timer<\/b>.<\/p>\n Listing 3: Entfernen ungültiger Zeichen bei Änderung des Textfeldinhalts<\/span><\/b><\/p>\n Das Problem ist, dass nun bei jeder Änderung, also auch beim einfachen Eintippen oder Entfernen von Zeichen, der aktuelle Text des Textfeldes analysiert und anschließend der bereinigte Text wieder eingefügt wird. Dies interpretiert Access als erneuten Eintritt in das Feld, wodurch ein bestimmtes Verhalten der Einfügemarke ausgelöst wird. Dieses Verhalten ist in den Access-Optionen in dem Bereich aus Bild 2 festgelegt.<\/p>\n Bild 2: Einstellung für das Cursorverhalten bei Eintritt in ein Feld<\/span><\/b><\/p>\n In unserem Fall wird der komplette Feldinhalt markiert, was beispielsweise beim Löschen des letzten Zeichens der Zeichenfolge 47137 <\/b>dazu führt, dass die verbleibenden Zeichen 4713 <\/b>komplett markiert werden (siehe Bild 3). Wollte der Benutzer nun die letzten beiden Zeichen mit der Back<\/b>-Taste entfernen, entfernt er erst das letzte und dann alle anderen, die nach dem Entfernen des letzten Zeichens komplett markiert wurden.<\/p>\n Bild 3: Unerwünschtes Markieren des Inhalts<\/span><\/b><\/p>\n Aber auch beim Einfügen von Zeichen ist dieses Verhalten mehr als hinderlich. Will der Benutzer 47137 <\/b>eintippen, tippt er die 4<\/b>, die sodann markiert wird, was dazu führt, dass das markierte Zeichen bei Eingabe des folgenden Zeichens wieder gelöscht wird.<\/p>\n Etwas besser wird es, wenn wir nicht mehr dem Textfeld direkt die geprüfte Zeichenkette zuweisen, sondern der Eigenschaft Text<\/b> des Textfeldes:<\/p>\n Damit landet die Einfügemarke allerdings immer am Ende des eingefügten Textes. Das führt zum Beispiel zu Problemen, wenn der Benutzer Zeichen mitten im Text hinzufügen will – die Einfügemarke springt nach Eingabe des ersten Zeichens direkt ans Ende.<\/p>\n Das Verhalten ist nur akzeptabel, wenn der Benutzer tatsächlich den Inhalt der Zwischenablage in das Textfeld einfügen will.<\/p>\n Die bisher beschriebenen Beispiele finden Sie im Formular frmZeichenInTextfeldern<\/b>, die folgenden in frmZeichen-InTextfeldern_2<\/b>.<\/p>\n Ein Weg, dies zu umgehen, ist Folgender. Wir wollen verhindern, dass die Prozedur txtPLZ2_Change <\/b>ausgelöst wird, wenn der Benutzer einfach nur Zeichen eingibt. txtPLZ2_Change <\/b>soll nur feuern, wenn der Benutzer per Einfügen<\/b>-Befehl Daten aus der Zwischenablage einfügt. Bevor wir diese Änderung vornehmen, wollen wir den Code ein wenig aufräumen. Wir führen in den beiden Ereignisprozeduren Form_Timer <\/b>und txtPLZ2_Change <\/b>prinzipiell den gleichen Code auf. Das ruft nach einer Refactoring-Maßnahme. Dabei gliedern wir die redundanten Anweisungen in eine eigene Prozedur aus, hier ZeichenPruefen<\/b> (siehe Listing 4). Die Prozedur erwartet einen Verweis auf das zu untersuchende TextBox<\/b>-Element als ersten und eine Zeichenkette mit den zulässigen Zeichen als zweiten Parameter. Dazwischen erledigt sie die Schritte, die wir bereits weiter oben erläutert haben – und weist anschließend das Ergebnis der Text<\/b>-Eigenschaft des Textfeldes aus txt <\/b>zu.<\/p>\nPrivate Sub <\/span>txtPLZ_BeforeUpdate(Cancel As Integer<\/span>)\r\n Dim <\/span>i As Integer<\/span>\r\n Dim <\/span>strPLZ As String<\/span>\r\n strPLZ = Nz(Me!PLZ, \"\")\r\n For i = 1 To Len<\/span>(strPLZ)\r\n If <\/span>InStr<\/span>(1, cStrZahlen, Mid<\/span>(strPLZ, i, 1)) = 0 Then<\/span>\r\n MsgBox<\/span> \"Die PLZ darf nur aus Zahlen bestehen.\", vbOKOnly + vbExclamation, \"Ungültige PLZ\"\r\n Cancel = True<\/span>\r\n End If<\/span>\r\n Next<\/span> i\r\nEnd Sub<\/span><\/pre>\nPrüfung während der Eingabe<\/h2>\n
Private Sub <\/span>txtPLZ2_KeyDown(KeyCode As Integer<\/span>, Shift As Integer<\/span>)\r\nEnd Sub<\/span><\/pre>\n\n
Private Sub <\/span>txtPLZ2_KeyDown(KeyCode As Integer<\/span>, Shift As Integer<\/span>)\r\n Debug.Print<\/span> KeyCode\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>txtPLZ2_KeyDown(KeyCode As Integer<\/span>, Shift As Integer<\/span>)\r\n Select Case KeyCode\r\n Case <\/span>48 To 57\r\n Case Else<\/span>\r\n KeyCode = 0\r\n End Select<\/span>\r\nEnd Sub<\/span><\/pre>\n\n
Nummernblock berücksichtigen<\/h2>\n
Case <\/span>48 To 57, 96 To 105<\/pre>\nPrivate Sub <\/span>txtPLZ2_KeyDown(KeyCode As Integer<\/span>, Shift As Integer<\/span>)\r\n Select Case KeyCode\r\n Case <\/span>48 To 57, 96 To 105\r\n Case <\/span>8, 9, 13, 27, 37, 39, 46, 113\r\n Case Else<\/span>\r\n KeyCode = 0\r\n End Select<\/span>\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>txtPLZ2_KeyDown(KeyCode As Integer<\/span>, Shift As Integer<\/span>)\r\n Select Case KeyCode\r\n Case <\/span>vbKey0 To vbKey9, vbKeyNumpad0 To vbKeyNumpad9\r\n If <\/span>Not<\/span> Shift = 0 Then<\/span>\r\n KeyCode = 0\r\n End If<\/span>\r\n Case <\/span>vbKeyBack, vbKeyTab, vbKeyReturn, vbKeyEscape, vbKeyLeft, vbKeyRight, vbKeyDelete, vbKeyF2\r\n Case Else<\/span>\r\n KeyCode = 0\r\n End Select<\/span>\r\nEnd Sub<\/span><\/pre>\nEinfügen über die Zwischenablage<\/h2>\n
\n
\n
Case <\/span>vbKeyC\r\n If <\/span>Shift = acCtrlMask Then<\/span>\r\n Else<\/span>\r\n KeyCode = 0\r\n End If<\/span><\/pre>\nIf <\/span>Shift = acCtrlMask Then<\/span>\r\n Me.TimerInterval = 100\r\n...<\/pre>\nPrivate Sub <\/span>Form_Timer()\r\n Dim <\/span>i As Integer<\/span>\r\n Dim <\/span>strPLZ As String<\/span>\r\n Dim <\/span>strTemp As String<\/span>\r\n strPLZ = Nz(Me!txtPLZ2.Text, \"\")\r\n If <\/span>Not<\/span> Len<\/span>(strPLZ) = 0 Then<\/span>\r\n For i = 1 To Len<\/span>(strPLZ)\r\n If <\/span>Not<\/span> InStr<\/span>(1, cStrZahlen, Mid<\/span>(strPLZ, i, 1)) = 0 Then<\/span>\r\n strTemp = strTemp & Mid<\/span>(strPLZ, i, 1)\r\n End If<\/span>\r\n Next<\/span> i\r\n End If<\/span>\r\n Me!txtPLZ2 = strTemp\r\n Me.TimerInterval = 0\r\nEnd Sub<\/span><\/pre>\nWas geschieht beim Einfügen per Kontextmenü?<\/h2>\n
Private Sub <\/span>txtPLZ2_Change()\r\n Dim <\/span>i As Integer<\/span>\r\n Dim <\/span>strPLZ As String<\/span>\r\n Dim <\/span>strTemp As String<\/span>\r\n strPLZ = Nz(Me!txtPLZ2.Text, \"\")\r\n If <\/span>Not<\/span> Len<\/span>(strPLZ) = 0 Then<\/span>\r\n For i = 1 To Len<\/span>(strPLZ)\r\n If <\/span>Not<\/span> InStr<\/span>(1, cStrZahlen, Mid<\/span>(strPLZ, i, 1)) = 0 Then<\/span>\r\n strTemp = strTemp & Mid<\/span>(strPLZ, i, 1)\r\n End If<\/span>\r\n Next<\/span> i\r\n End If<\/span>\r\n Me!txtPLZ2 = strTemp\r\nEnd Sub<\/span><\/pre>\n![\"Einstellung](\"..\/fileadmin\/_temp_\/2022_04\/pic_1379_002.png\")
<\/p>\n![\"Unerwünschtes](\"..\/fileadmin\/_temp_\/2022_04\/pic_1379_00§.png\")
<\/p>\nMe!txtPLZ2.Text = ZeichenPruefen(Me!txtPLZ2, cStrZahlen)<\/pre>\n
Bei Änderung nicht bei Tastendruck auslösen<\/h2>\n