Die Eingabe von Datumsangaben ist erstens manchmal unkomfortabel und zweitens passiert es oft, dass Benutzer das Datum im falschen Format eingeben. Dem wollen wir mit der Lösung aus diesem Beitrag vorbeugen, indem wir die Eingabe vollständig über die Tasten „Nach oben“, „Nach unten“, „Nach rechts“ und „Nach links“ ermöglichen. Sobald der Benutzer den Fokus auf ein Datumsfeld setzt, wird das aktuelle Datum eingesetzt, sofern das Feld noch leer ist. Dann kann er mit „Nach links“ und „Nach rechts“ zwischen den einzelnen Datumsbestandteilen Tag, Monat und Jahr wechseln und mit den Tasten „Nach oben“ und „Nach unten“ stellt er schrittweise den gewünschten Wert ein. Die Funktionalität bilden wir anschließend auch noch in einer Klasse ab, sodass die Funktion einfach mit zwei Zeilen Code zu einem Datums-Textfeld hinzugefügt werden kann.<\/b><\/p>\n
Datumsfelder sind keine Hexerei. Man legt das Datumfeld in einer Tabelle an und legt die Tabelle als Datensatzquelle für ein Formular fest.<\/p>\n
In diesem zieht man das Datumsfeld in den Formularentwurf und kann dieses direkt nutzen. Die Eingabe wird sogar vereinfacht durch das Anklicken des kleinen Kalender-Icons neben dem Textfeld (siehe Bild 1).<\/p>\n
![\"Herkömmliches](\"..\/fileadmin\/_temp_\/2026_02\/pic_1590_001.png\")
<\/p>\n
Bild 1: Herkömmliches Textfeld mit Datum<\/span><\/b><\/p>\n Wenn man hier allerdings einen Standardwert wie das aktuelle Datum vorgibt und der Benutzer soll dann sein Geburtsdatum eingeben, wird er schnell auf dieses Calendar-Widget verzichten. Denn dort müsste er endlos klicken, bis er zum Beispiel ein Datum erreicht, dass viele Jahre zurückliegt.<\/p>\n Auch die manuelle Datumseingabe birgt Tücken, denn hier muss das Format eingehalten werden. Das ist kein Hexenwerk, dennoch kommt es dabei immer wieder zu Fehleingaben.<\/p>\n Also stellen wir in diesem Beitrag eine Lösung vor, mit der wir das Datum ganz einfach eingeben können – nämlich allein mit den Cursor-Tasten, also Nach oben<\/b>, Nach unten<\/b>, Nach links <\/b>und Nach rechts<\/b>.<\/p>\n Dabei sollen gleich beim Fokuserhalt wie in Bild 2 die Tage markiert werden. Damit weiß der Benutzer, dass er nun die Tage für das gewünschte Datum einstellen kann. Er braucht nur noch den gewünschten Wert für den Tag mit den Tasten Nach oben <\/b>und Nach unten <\/b>einzustellen.<\/p>\n Bild 2: Markierung des Tages<\/span><\/b><\/p>\n Dann betätigt er die Taste Nach rechts<\/b>, um zum Monat zu wechseln, und legt auf die gleiche Weise wie beim Tag den Monat fest.<\/p>\n Schließlich springt er mit Nach rechts <\/b>zu den Jahren und wählt auch noch das Jahr aus. Hierbei haben wir noch eine Komfortfunktion eingebaut, mit welcher der Benutzer bei gedrückter Umschalt<\/b>-Taste 10 Jahre vor- oder zurückspringen kann.<\/p>\n Möchte man anschließend den Tag oder den Monat korrigieren, kann man diese mit der Nach links<\/b>-Taste erneut ansteuern.<\/p>\n In die Umsetzung der Lösung sind einige Ereignisse des Textfeld-Steuerelements involviert. Als Erstes benötigen wir ein Ereignis, mit dem wir direkt beim Setzen des Fokus auf das Textfeld dafür sorgen, dass die ersten beiden Zeichen für die Angabe des Tages selektiert werden.<\/p>\n Hier bietet sich das Ereignis Bei Fokuserhalt <\/b>des Steuerelements an, für das wir die folgende Ereignisprozedur hinterlegen:<\/p>\n Diese ruft eine Prozedur namens txtGeburtsdatumAktivieren <\/b>auf. Wir lagern die Funktion des Ereignisses in eine eigene Prozedur aus, weil wir diese später noch von einer anderen Stelle aus aufrufen wollen.<\/p>\n Die Prozedur txtGeburtsdatumAktivieren <\/b>nimmt einen Parameter namens intDatePart<\/b> mit dem Datentyp eDatePart <\/b>entgegen. Mit diesem können wir festlegen, welcher Teil des Datums – Tag, Monat oder Jahr – markiert werden soll. Die Enumeration definieren wir wie folgt:<\/p>\n Dann referenziert die Prozedur das Textfeld txtGeburtsdatum <\/b>mit der Variablen txt<\/b>. Dann prüft sie, ob das Textfeld leer ist, und trägt in diesem Fall das aktuelle Datum ein.<\/p>\n Das können Sie beliebig anpassen, wenn für den jeweiligen Anwendungsfall ein anderes Datum angezeigt werden soll. Schließlich ruft die Prozedur noch eine weitere Routine namens SelectDatePart <\/b>auf und übergibt dieser einen Verweis auf das Textfeld und leitet den optionalen Parameter intDatePart <\/b>weiter:<\/p>\n Die Prozedur SelectDatePart <\/b>nimmt einen Verweis auf das Textfeld entgegen, sowie einen Wert der Enumeration eDatePart<\/b>, mit dem angegeben wird, ob der Tag, der Monat oder das Jahr selektiert werden soll.<\/p>\n Sie prüft, welchen Wert lngCurrentDatePart <\/b>hat, und stellt abhängig davon die beiden Eigenschaften SelStart <\/b>und SelLength <\/b>des mit txt <\/b>übergebenen Textfeldes ein. Wir gehen dabei davon aus, dass das Datum im Textfeld immer im Format dd.mm.yyyy <\/b>formatiert ist.<\/p>\n Für den Tag wird SelStart <\/b>mit dem Wert 0 <\/b>auf das erste Zeichen eingestellt und die Länge der Markierung auf zwei Zeichen, für den Monat auf die Position 3 <\/b>und die Länge 2 <\/b>und für das Jahr auf die Position 6 <\/b>und die Länge 4<\/b>:<\/p>\n Damit ist der erste Teil bereits erledigt – beim Fokuserhalt des Textfeldes wird gegebenenfalls das aktuelle Datum eingetragen und die ersten beiden Stellen für den Tag werden markiert.<\/p>\n Um die Eingaben des Benutzers im Datumsfeld zu erfassen, vor allem die Nutzung der Tasten Nach oben<\/b>, Nach unten<\/b>, Nach links <\/b>und Nach rechts<\/b>, verwenden wir das Ereignis Bei Taste ab<\/b> des Textfeldes. Die entsprechende Ereignisprozedur liefert beim Aufruf zwei Parameter:<\/p>\n Damit können wir sauber erfassen, wie der Benutzer über die Tastatur mit dem Textfeld arbeitet. Im ersten Schritt der Prozedur, deren ersten Teil wir in Listing 1 finden, deaktivieren wir mit Me.Painting = False <\/b>das Neuzeichnen des Formulars, bis die Eingabe abgeschlossen ist.<\/p>\n Listing 1: Navigieren im Datum und Anpassen der einzelnen Datumsteile (Teil 1)<\/span><\/b><\/p>\n Danach referenzieren wir mit der Variablen txt <\/b>das Textfeld txtGeburtsdatum<\/b>. Den Inhalt des Textfeldes untersuchen wir in den nächsten drei Anweisungen, um mit den Funktionen Day<\/b>, Month <\/b>und Year <\/b>den Tag, den Monat und das Jahr zu ermitteln.<\/p>\n Danach rufen wir eine Hilfsfunktion namens GetCurrentDatePart <\/b>auf, der wir einen Verweis auf das Textfeld übergeben. Sie soll bestimmen, ob gerade der Tag, der Monat oder das Jahr im Textfeld markiert ist. Dazu ermittelt sie die Startposition der Markierung und speichert sie in der Variablen lngSelStart<\/b>.<\/p>\n Dann prüft sie, ob sich die Position zwischen 0 <\/b>und 2 <\/b>befindet (Tag), zwischen 3 <\/b>und 5 <\/b>(Monat) oder zwischen 6 <\/b>und 9 <\/b>(Jahr), und schreibt die entsprechende Konstante der Enumeration eDatePart <\/b>in die Variable lngCurrentDatePart<\/b>. Dieser Wert wird schließlich zurückgegeben:<\/p>\n Die Ereignisprozedur txtGeburtsdatum_KeyDown <\/b>prüft nun, ob der Benutzer derzeit die Umschalttaste gedrückt hält, und speichert in diesem Fall den Wert 10 <\/b>in der Variablen lngYears<\/b>, sonst den Wert 1<\/b>. Dies dient dazu, dass wir später beim Ändern der Jahreszahl entweder in Einerschritten oder Zehnerschritten arbeiten können.<\/p>\n Nun beginnt die eigentliche Untersuchung der betätigten Taste. Dazu verwenden wir eine Select Case<\/b>-Bedingung, deren zu vergleichender Wert der Inhalt des Parameters KeyCode <\/b>ist.<\/p>\n Im ersten Teil prüfen wir, ob der Benutzer die Taste Nach links <\/b>oder Nach rechts <\/b>gedrückt hat. In diesem Fall treffen wir in einer weiteren Select Case<\/b>-Bedingung eine weitere Unterscheidung. Der erste Case<\/b>-Zweig wird für die Nach links<\/b>-Taste angesteuert (vbKeyLeft<\/b>).<\/p>\n Darin finden wir eine weitere Select Case<\/b>-Bedingung, in der wir den Wert von lngCurrentDatePart <\/b>untersuchen, also ob die Markierung gerade den Tag, den Monat oder das Jahr enthält. Im ersten Case<\/b>-Zweig vergleichen wir mit datepartday<\/b>. In diesem Fall stellen wir lngCurrentDatePart <\/b>auf datepartyear <\/b>ein, damit die Markierung auf das Jahr eingestellt werden kann. Beim Monat springen wir zum Tag, beim Jahr zum Monat.<\/p>\n Die zweite Case<\/b>-Bedingung im übergeordneten Select Case<\/b>-Konstrukt wird bei Verwendung der Taste Nach rechts <\/b>ausgelöst (vbKeyRight<\/b>). In diesem Fall stellen wir die Variable lngCurrentDatePart <\/b>auf den Wert für den Monat ein, wenn sie zuvor auf den Tag eingestellt war, auf das Jahr, wenn der Monat eingestellt war, und auf den Tag, wenn das Jahr eingestellt war. Wir verschieben die Markierung also von links nach rechts.<\/p>\n Nachdem wir in lngCurrentDatePart <\/b>eingestellt haben, welcher Teil nun markiert werden soll, rufen wir die bereits bekannte Prozedur SelectDatePart<\/b> und übergeben dieser den Verweis auf das Textfeld und den zu markierenden Datumsteil.<\/p>\n Schließlich stellen wir den Wert des Parameters KeyCode <\/b>auf 0 <\/b>ein. Damit sorgen wir dafür, dass dieser Tastenanschlag nicht weitergegeben wird.<\/p>\n Wurde die Ereignisprozedur durch die Taste Nach links <\/b>oder Nach rechts <\/b>betätigt, werden die Select Case<\/b>-Bedingungen beendet und die Prozedur aktiviert mit Me.Painting = True<\/b> wieder die Bildschirmaktualisierung für das Formular.<\/p>\n Die Änderung von Tag, Monat oder Jahr realisieren wir in der gleichen Ereignisprozedur, nur dass wir einen anderen Zweig in der Select Case<\/b>-Bedingung ansteuern. Dieser prüft dieses Mal den Parameter KeyCode <\/b>auf die beiden Werte vbKeyUp <\/b>(Nach oben<\/b>) und vbKeyDown <\/b>(Nach unten<\/b>) – siehe Listing 2.<\/p>\n Listing 2: Navigieren im Datum und Anpassen der einzelnen Datumsteile (Teil 2)<\/span><\/b><\/p>\n Auch hier differenzieren wir in einer zweiten Select Case<\/b>-Bedingung nach den beiden möglichen Werten. Und wieder unterschieden wir nach dem Wert von lngCurrentDatePart<\/b>. Dieses Mal nutzen wir die Zweige der dafür verwendeten Select Case<\/b>-Bedingung jedoch dafür, den jeweils markierten Wert zu ändern.<\/p>\n Wenn der Benutzer die Nach oben<\/b>-Taste betätigt hat und die Angabe des Tages im Textfeld markiert ist, soll der nächste Tag eingestellt werden. Leider kann man nicht einfach den Wert 1 <\/b>hinzuzählen, da es auch sein kann, dass das Textfeld bereits das Monatsende anzeigt – und dann müssen wir wieder bei 1 <\/b>beginnen. Also haben wir die Ermittlung des anzuzeigenden Tages in eine Funktion namens GetNextDay <\/b>ausgelagert, der wir das Datum aus dem Textfeld und den aktuellen Wert von lngDay <\/b>als Parameter übergeben.<\/p>\n Die Funktion prüft zuerst, ob das Hinzufügen eines Tages zum aktuellen Datum einen Tag im nächsten Monat liefern würde. Dazu ermitteln wir schlicht den Monat des aktuellen Datums (zum Beispiel 31.1.2026<\/b>) und den Monat des nächsten Tages (also 1.2.2026<\/b>). Sind die Monate nicht gleich, ist das aktuelle Datum der letzte Tag im aktuellen Monat und wir stellen lngDay <\/b>auf 1 <\/b>ein. Anderenfalls erhöhen wir lngDay <\/b>einfach um 1<\/b>. Den Wert von lngDay <\/b>geben wir anschließend als Funktionswert zurück:<\/p>\n Wenn sich in der Select Case<\/b>-Bedingung der Monat als markiertes Element des Datums herausstellt, wollen wir diesen Wert um 1 <\/b>erhöhen. Dazu nutzen wir die Funktion GetNextMonth<\/b>, denn auch den Monat können wir nicht einfach um 1 <\/b>erhöhen – es kann sein, dass das aktuelle Datum sich im Dezember befindet, und dann müssen wir den Monat wieder auf Januar einstellen.<\/p>\n GetNextMonth <\/b>erwartet nur den Wert von lngMonth <\/b>als Parameter und untersucht, ob dieser den Wert 12 <\/b>enthält. In diesem Fall wird lngMonth <\/b>auf 1 <\/b>eingestellt, andernfalls wird lngMonth <\/b>um 1 <\/b>erhöht und anschließend zurückgegeben:<\/p>\n Allein das Erhöhen des Jahres muss nicht genauer untersucht werden – hier addieren wir einfach den Wert 1<\/b> beziehungsweise 10, wenn die Umschalttaste aktiviert ist.<\/p>\n Einen ähnlichen Ablauf finden wir vor, wenn der Benutzer die Taste Nach unten <\/b>betätigt hat. Ist dann der Tag markiert, wird die Funktion GetPreviousDay <\/b>aufgerufen. Diese prüft zunächst, ob der Wert von lngDay <\/b>gleich 1 <\/b>ist. In diesem Fall soll lngDay <\/b>den Wert des letzten Tages des aktuellen Monats erhalten. Dazu nehmen wir das mit dem Parameter dat <\/b>übergebene Datum aus dem Textfeld, addieren einen Monat hinzu, ziehen einen Tag ab und ermitteln dann mit Day <\/b>den Tag. Beispiel: Wenn das aktuelle Datum 1.1.2026 <\/b>lautet, zählen wir mit DateAdd <\/b>einen Monat hinzu und erhalten den 1.2.2026<\/b>. Davon ziehen wir mit -1 <\/b>einen Tag ab und erhalten den 31.1.2026<\/b>. Der Wert für den Tag (31<\/b>) landet in lngDay<\/b>.<\/p>\n Hat lngDay <\/b>nicht den Wert 1<\/b>, können wir einfach den Wert 1 <\/b>abziehen, um den gewünschten Tag zu erhalten:<\/p>\n Wenn der Benutzer einen Monat vom aktuellen Monat abziehen möchte, wird die Funktion GetPreviousMonth<\/b> aufgerufen. Diese nimmt wieder die Nummer des Monats entgegen. Lautet diese 1<\/b>, wird lngMonth <\/b>auf 12 <\/b>eingestellt, sonst subtrahieren wir einfach den Wert 1<\/b>:<\/p>\n Nachdem wir den neuen Wert für den aktuell markierten Teil des Datums ermittelt und in einer der Variablen lngDay<\/b>, lngMonth <\/b>oder lngYear <\/b>gespeichert haben, stellen wir als Erstes das Datum mit DateSerial <\/b>zusammen und schreiben es wieder in das Textfeld.<\/p>\n Dann rufen wir die Prozedur SelectDatePart <\/b>auf und sorgen dafür, dass der vor der Änderung markierte Datumsteil wieder markiert wird. Auch hier wird KeyCode <\/b>wieder auf den Wert 0 <\/b>eingestellt, damit die betätigte Taste nicht an das Steuerelement weitergereicht wird.<\/p>\n Schließlich müssen wir uns noch um die übrigen Tasten kümmern, die der Benutzer betätigen könnte, wenn das Textfeld mit dem Datum aktiviert ist. Jegliche Eingabe wie die einer Zahl würde dazu führen, dass die aktuelle Markierung damit überschrieben wird.<\/p>\n Das wollen wir verhindern und legen im Else<\/b>-Zweig für alle nicht anderweitig behandelten Werte von KeyCode <\/b>den Wert 0 <\/b>für diesen Parameter fest.<\/p>\n Wir wollen nur zwei Tasten davon ausschließen, nämlich die Tabulator<\/b>-Taste, die Eingabe<\/b>-Taste und die Escape<\/b>-Taste. Diese ersten beiden sollen wie üblich funktionieren und bei Betätigung den Fokus auf das nächste Steuerelement in der Aktivierreihenfolge verschieben. Die Escape<\/b>-Taste sorgt dafür, dass die Änderung verworfen wird.<\/p>\n Deshalb fügen wir vbKeyTab <\/b>und vbKeyReturn <\/b>in einen eigenen Case<\/b>-Zweig ein, in dem aber keine weiteren Anweisungen ausgeführt werden. Ein weiterer Zweig für die Escape<\/b>-Taste sieht wie folgt aus:<\/p>\n Es kann passieren, dass der Benutzer mit der Maus in das Datums-Textfeld klickt. Ohne weitere Maßnahmen würde dies dazu führen, dass die Einfügemarke wie gewöhnlich an der Stelle des Mausklicks angezeigt wird oder der Benutzer den gewünschten Bereich damit markiert. Das wollen wir verhindern und stattdessen das folgende Verhalten erreichen:<\/p>\n Dazu hinterlegen wir die folgende Ereignisprozedur für das Ereignis Bei Maustaste auf<\/b>:<\/p>\n Sie holt mit der GetCurrentDatePart <\/b>eine der Konstanten der Enumeration eDatePart<\/b>, und zwar den, in dem sich die Einfügemarke oder der Beginn der Markierung durch die Maus befindet, und speichert diese in lngCurrentDatePart<\/b>.<\/p>\n Dann ruft sie die Prozedur txtGeburtsdatumAktivieren <\/b>auf und übergibt den Wert von lngCurrentDatePart<\/b>. Dies sorgt dafür, dass der entsprechende Datumsteil markiert wird.<\/p>\n Dieser Beitrag stellt eine Lösung vor, mit der wir die Eingabe von Datumswerten in Textfelder stark vereinfachen und außerdem fehlersicher machen können. Dabei sorgen wir dafür, dass der Benutzer nicht mehr das Datum selbst eingeben muss, sondern einfach mit den Tasten Nach links <\/b>und Nach rechts <\/b>zwischen Tag, Monat und Jahr navigiert und mit den Tasten Nach oben <\/b>und Nach unten <\/b>den jeweils markierten Datumsbereich einstellt.<\/p>\n Beim Einstellen des Jahres kann er zudem noch die Umschalt<\/b>-Taste zu Hilfe nehmen, um dieses in Zehnerschritten einzustellen.<\/p>\n In einem weiteren Beitrag mit dem Titel Datum einstellen mit Klasse <\/b>(www.access-im-unternehmen.de\/1591<\/b>) zeigen wir, wie die hier vorgestellte Lösung in ein Klassenmodul übertragen und mit wenigen Codezeilen beliebigen Datums-Textfeldern hinzugefügt werden kann.<\/p>\n Enthaltene Beispieldateien:<\/p>\n DatumSchnellPerCursorEinstellen.accdb<\/p>\n![\"Markierung](\"..\/fileadmin\/_temp_\/2026_02\/pic_1590_002.png\")
<\/p>\nProgrammierung der Lösung<\/h2>\n
Private Sub <\/span>txtGeburtsdatum_GotFocus()\r\n Call<\/span> txtGeburtsdatumAktivieren\r\nEnd Sub<\/span><\/pre>\nPublic <\/span>Enum eDatePart\r\n datepartday = 0\r\n datepartmonth = 1\r\n datepartyear = 2\r\nEnd Enum<\/pre>\nPrivate Sub <\/span>txtGeburtsdatumAktivieren(Optional<\/span> intDatePart As <\/span>eDatePart)\r\n Dim <\/span>txt As <\/span>TextBox\r\n Set<\/span> txt = Me.txtGeburtsdatum\r\n If <\/span>IsNull(txt) Then<\/span>\r\n txt.Value = Date\r\n End If<\/span>\r\n Call<\/span> SelectDatePart(txt, intDatePart)\r\nEnd Sub<\/span><\/pre>\nSelektieren eines Datumsteils<\/h2>\n
Private Sub <\/span>SelectDatePart(txt As <\/span>TextBox, _\r\n lngCurrentDatePart As <\/span>eDatePart)\r\n Select Case lngCurrentDatePart\r\n Case <\/span>datepartday\r\n txt.SelStart = 0\r\n txt.SelLength = 2\r\n Case <\/span>datepartmonth\r\n txt.SelStart = 3\r\n txt.SelLength = 2\r\n Case <\/span>datepartyear\r\n txt.SelStart = 6\r\n txt.SelLength = 4\r\n End Select<\/span>\r\nEnd Sub<\/span><\/pre>\nBewegen der Markierung im Datumsfeld<\/h2>\n
\n
Private Sub <\/span>txtGeburtsdatum_KeyDown(KeyCode As Integer<\/span>, Shift As Integer<\/span>)\r\n Dim <\/span>txt As <\/span>TextBox\r\n Dim <\/span>lngCurrentDatePart As <\/span>eDatePart\r\n Dim <\/span>lngDay As Long<\/span>\r\n Dim <\/span>lngMonth As Long<\/span>\r\n Dim <\/span>lngYear As Long<\/span>\r\n Dim <\/span>lngYears As Long<\/span>\r\n \r\n Me.Painting = False<\/span> \r\n Set<\/span> txt = Me.txtGeburtsdatum \r\n lngDay = Day(txt.Value)\r\n lngMonth = Month(txt.Value)\r\n lngYear = Year(txt.Value)\r\n \r\n lngCurrentDatePart = GetCurrentDatePart(txt)\r\n \r\n If <\/span>Shift = acShiftMask Then<\/span>\r\n lngYears = 10\r\n Else<\/span>\r\n lngYears = 1\r\n End If<\/span>\r\n \r\n Select Case KeyCode\r\n Case <\/span>vbKeyLeft, vbKeyRight\r\n Select Case KeyCode\r\n Case <\/span>vbKeyLeft\r\n Select Case lngCurrentDatePart\r\n Case <\/span>datepartday\r\n lngCurrentDatePart = datepartyear\r\n Case <\/span>datepartmonth\r\n lngCurrentDatePart = datepartday\r\n Case <\/span>datepartyear\r\n lngCurrentDatePart = datepartmonth\r\n End Select<\/span>\r\n Case <\/span>vbKeyRight\r\n Select Case lngCurrentDatePart\r\n Case <\/span>datepartday\r\n lngCurrentDatePart = datepartmonth\r\n Case <\/span>datepartmonth\r\n lngCurrentDatePart = datepartyear\r\n Case <\/span>datepartyear\r\n lngCurrentDatePart = datepartday\r\n End Select<\/span>\r\n End Select<\/span>\r\n Call<\/span> SelectDatePart(txt, lngCurrentDatePart)\r\n KeyCode = 0\r\n ...<\/pre>\nPrivate Function <\/span>GetCurrentDatePart(txt As <\/span>TextBox) _\r\n As <\/span>eDatePart\r\n Dim <\/span>lngSelStart As Long<\/span>\r\n Dim <\/span>lngCurrentDatePart As <\/span>eDatePart\r\n \r\n lngSelStart = txt.SelStart\r\n \r\n Select Case True<\/span>\r\n Case <\/span>lngSelStart >= 0 And lngSelStart <= 2\r\n lngCurrentDatePart = datepartday\r\n Case <\/span>lngSelStart >= 3 And lngSelStart <= 5\r\n lngCurrentDatePart = datepartmonth\r\n Case <\/span>lngSelStart >= 6 And lngSelStart <= 9\r\n lngCurrentDatePart = datepartyear\r\n End Select<\/span>\r\n \r\n GetCurrentDatePart = lngCurrentDatePart\r\nEnd Function<\/span><\/pre>\nÄndern von Tag, Monat und Jahr<\/h2>\n
...\r\n Case <\/span>vbKeyUp, vbKeyDown\r\n Select Case KeyCode\r\n Case <\/span>vbKeyUp\r\n Select Case lngCurrentDatePart\r\n Case <\/span>datepartday\r\n lngDay = GetNextDay(txt.Value, lngDay)\r\n Case <\/span>datepartmonth\r\n lngMonth = GetNextMonth(lngMonth)\r\n Case <\/span>datepartyear\r\n lngYear = lngYear + lngYears\r\n End Select<\/span>\r\n Case <\/span>vbKeyDown\r\n Select Case lngCurrentDatePart\r\n Case <\/span>datepartday\r\n lngDay = GetPreviousDay(txt.Value, lngDay)\r\n Case <\/span>datepartmonth\r\n lngMonth = GetPreviousMonth(lngMonth)\r\n Case <\/span>datepartyear\r\n lngYear = lngYear - lngYears\r\n End Select<\/span>\r\n End Select<\/span>\r\n txt.Value = DateSerial(lngYear, lngMonth, lngDay)\r\n Call<\/span> SelectDatePart(txt, lngCurrentDatePart)\r\n KeyCode = 0\r\n Case <\/span>vbKeyTab, vbKeyReturn\r\n Case Else<\/span>\r\n KeyCode = 0\r\n End Select<\/span>\r\n \r\n Me.Painting = True<\/span>\r\n \r\nEnd Sub<\/span><\/pre>\nPrivate Function <\/span>GetNextDay(dat As Date<\/span>, lngDay As Long<\/span>) _\r\n As Long<\/span>\r\n If <\/span>Month(dat) < Month(dat + 1) Then<\/span>\r\n lngDay = 1\r\n Else<\/span>\r\n lngDay = lngDay + 1\r\n End If<\/span>\r\n GetNextDay = lngDay\r\nEnd Function<\/span><\/pre>\nPrivate Function <\/span>GetNextMonth(lngMonth As Long<\/span>)\r\n If <\/span>lngMonth = 12 Then<\/span>\r\n lngMonth = 1\r\n Else<\/span>\r\n lngMonth = lngMonth + 1\r\n End If<\/span>\r\n GetNextMonth = lngMonth\r\nEnd Function<\/span><\/pre>\nPrivate Function <\/span>GetPreviousDay(dat As Date<\/span>, _\r\n lngDay As Long<\/span>) As Long<\/span>\r\n If <\/span>lngDay = 1 Then<\/span>\r\n lngDay = Day(DateAdd(\"m\", 1, dat) - 1)\r\n Else<\/span>\r\n lngDay = lngDay - 1\r\n End If<\/span>\r\n GetPreviousDay = lngDay\r\nEnd Function<\/span><\/pre>\nPrivate Function <\/span>GetPreviousMonth(lngMonth As Long<\/span>) _\r\n As Long<\/span>\r\n If <\/span>lngMonth = 1 Then<\/span>\r\n lngMonth = 12\r\n Else<\/span>\r\n lngMonth = lngMonth - 1\r\n End If<\/span>\r\n GetPreviousMonth = lngMonth\r\nEnd Function<\/span><\/pre>\nDatum wieder zusammensetzen, anzeigen und den aktuellen Part markieren<\/h2>\n
Weitere Tasten verarbeiten<\/h2>\n
Case <\/span>vbKeyEscape\r\n txt.Value = txt.OldValue\r\n Call<\/span> SelectDatePart(txt, intCurrentDatePart)\r\n KeyCode = 0<\/pre>\nMausaktionen im Datums-Textfeld steuern<\/h2>\n
\n
Private Sub <\/span>txtGeburtsdatum_MouseUp(Button As Integer<\/span>, _\r\n Shift As Integer<\/span>, X As Single<\/span>, Y As Single<\/span>)\r\n Dim <\/span>lngCurrentDatePart As <\/span>eDatePart\r\n lngCurrentDatePart = _\r\n GetCurrentDatePart(Me.txtGeburtsdatum)\r\n Call<\/span> txtGeburtsdatumAktivieren(lngCurrentDatePart)\r\nEnd Sub<\/span><\/pre>\nZusammenfassung und Ausblick<\/h2>\n
Downloads zu diesem Beitrag<\/h2>\n