<\/p>\n
Die Auswahl von Zeiträumen erfolgt üblicherweise durch das Eingeben zweier Datumsangaben in entsprechende Textfelder. Gegebenenfalls unterstützt die Anwendung den Benutzer noch durch das Bereitstellen einer Schaltfläche zum öffnen eines Kalenders, aus dem sich die gewünschten Daten einfach auswählen lassen. Das reicht für viele Fälle aus, zum Beispiel bei denen, die nach individuellen Zeiträumen ohne Regelmäßigkeiten verlangen.<\/p>\n
Die im Beitrag Kassenbuch <\/b>(s. Shortlink 486) vorgestellte Lösung dient der Verwaltung von Buchungsvorgängen, die beispielsweise als Grundlage für die Erstellung verschiedener Steuererklärungen wie etwa der Umsatzsteuervoranmeldung oder auch als übersicht über die angefallenen Ein- und Ausgänge dienen.<\/p>\n
Bei der Auswertung geht es dort meist um fest definierte Zeiträume: Umsatzsteuervoranmeldungen reicht man vierteljährlich oder monatlich ein, eine Einnahme-überschuss-Rechnung erstreckt sich über ein Kalenderjahr und auch für individuelle übersichten kommen wohl feste Intervalle wie Wochen, Monate, Quartale oder Jahre zum Tragen.<\/p>\n
Das Formular aus Bild 1 berücksichtigt dies: Damit kann der Benutzer zunächst die Art des Intervalls festlegen (Woche, Monat, Quartal oder Jahr), dann das Intervall selbst auswählen und schließlich den ausgewählten Zeitraum in den beiden unteren Textfeldern des Formulars manuell anpassen.<\/p>\n
![\"abb001.tif\"](\"..\/fileadmin\/_temp_\/2007_04\/Zeitraumauswahl_3-web-images\/abb001_opt.jpeg\")
\n <\/div>\nBild 1: Das Formular zur Die Anzahl der in den Kombinationsfeldern vorgegebenen Intervalle, das jeweilige Standardintervall sowie das angezeigte Start- und Enddatum können Sie beim öffnen des Formulars festlegen – dazu später mehr.<\/p>\n Um Fehleingaben zu verhindern, validiert das Formular den Inhalt der beiden Textfelder und gibt Meldungen aus, wenn eines der beiden Textfelder kein Datum enthält oder das Datum im ersten Textfeld hinter dem des zweiten Textfeldes liegt.<\/p>\n Zeitraumformular im Einsatz<\/p>\n Das Formular können Sie ganz gewöhnlich über einen Doppelklick auf den Eintrag im Datenbankfenster oder in der Navigationsleiste (Access 2007) öffnen. Nach der Auswahl des gewünschten Zeitraums schaltet das Betätigen der OK<\/b>-Schaltfläche das Formular unsichtbar. Die aufrufende Routine kann nun noch den Inhalt der beiden Textfelder mit dem ersten und dem letzten Tag auslesen und sollte das Formular dann schließen.<\/p>\n Das Formular enthält aber zusätzlich einige öffentliche Eigenschaften, mit denen Sie dieses beim öffnen konfigurieren können. Das zieht allerdings nach sich, dass Sie es nicht wie üblich mit DoCmd.OpenForm <\/b>öffnen, sondern es wie eine Klasse instanzieren.<\/p>\n Betrachten Sie zunächst, was passiert, wenn Sie das Formular ganz einfach mit der folgenden Anweisung öffnen:<\/p>\n Diese Anweisung benötigt den Parameter WindowMode:=acDialog <\/b>nicht, denn seine Eigenschaften Popup <\/b>und Modal <\/b>sind bereits auf Ja <\/b>eingestellt, was den gleichen Effekt hat: Das Formular gibt den Fokus erst beim Schließen oder Einstellen der Sichtbar<\/b>-Eigenschaft auf Nein <\/b>wieder an andere Access-Elemente ab.<\/p>\n Der Aufruf des Formulars löst zunächst das Ereignis Beim öffnen <\/b>und damit die Prozedur aus Listing 1 aus. Diese Routine stellt eine ganze Reihe von Eigenschaften ein und speichert diese in passenden Variablen, die später ausgelesen werden. Bei diesen Eigenschaften handelt es sich beispielsweise um die beim Start anzuzeigenden Intervalle für die vier verfügbaren Zeitraum-Varianten Woche, Monat, Quartal und Jahr.<\/p>\n Diese hängen entsprechend Listing 1 vom aktuellen Datum ab: Die im Kombinationsfeld cboWoche <\/b>angezeigte Kalenderwoche soll zum Beispiel die Woche sein, in der sich das mit Date <\/b>ermittelte aktuelle Datum befindet. Neben diesen „Standardwerten“ soll auch die Anzahl der verfügbaren Werte je Kombinationsfeld einstellbar sein. So enthalten beispielsweise die beiden Variablen mWochenVergangenheit <\/b>und WochenZukunft <\/b>die Anzahl der Einträge im Kombinationsfeld cboWochen<\/b>, die das Kombinationsfeld zusätzlich zur in mWoche <\/b>gespeicherten Kalenderwoche auflisten soll.<\/p>\n Schließlich weist die Form_Open<\/b>-Routine den vier Kombinationsfeldern noch die Werte für die Eigenschaft Herkunftstyp <\/b>(RowSourceType<\/b>) zu und sorgt mit der Requery<\/b>-Methode dafür, dass die Kombinationsfelder bei nächster Gelegenheit aktualisiert werden. Die Werte der RowSourceType<\/b>-Eigenschaft der vier Kombinationsfelder entsprechen vier passenden VBA-Funktionen, die die Kombinationsfelder bei Bedarf füllen. Wie diese so genannten Callback-Funktionen genau funktionieren und welche Alternativen es gibt, lesen Sie im Beitrag Kombinationsfelder dynamisch füllen <\/b>(Shortlink 476).<\/p>\n Die letzte Anweisung der Form_Open<\/b>-Prozedur ruft die Routine ZeitraumAktualisieren <\/b>auf (s. Listing 2). Diese wird nicht nur hier, sondern auch später nach jeder Aktualisierung der Optionsgruppe zum Auswählen des Intervalltyps und des Intervalls ausgeführt. Die erste Aktion dieser Routine ist die Prüfung der aktuell ausgewählten Option und die daraus folgende Aktivierung beziehungsweise Deaktivierung der Kombinationsfelder – wobei das zur aktuell ausgewählten Option gehörende Kombinationsfeld natürlich aktiviert und die anderen deaktiviert werden.<\/p>\n Listing 2: Diese Routine sorgt für die Auswertung der Optionen und Kombinationsfeldinhalte zum Füllen der Textfelder zur Angabe des Start- und Enddatums des festgelegten Intervalls.<\/p>\n <\/p>\n Das folgende Select Case<\/b>-Konstrukt enthält fünf Case<\/b>-Bedingungen, die mit den fünf Optionen der Optionsgruppe ogrZeitraum <\/b>korrespondieren. Sie ermitteln den jeweils aktuellen Inhalt des zurzeit aktiven Kombinationsfeldes und leiten daraus den in den beiden Textfeldern txtStartdatum <\/b>und txtEnddatum <\/b>anzuzeigenden Zeitraum ab.<\/p>\n Am Beispiel der Kalenderwoche sieht das so aus: Zunächst speichern zwei Variablen die in einem Ausdruck wie 25\/2007 <\/b>enthaltenen Informationen, nämlich die Woche (25<\/b>) und das Jahr (2007<\/b>). Das Startdatum ermittelt daraus dann die VBA-Funktion MontagEinerKalenderwoche<\/b>, das Enddatum die Funktion SonntagEinerKalenderwoche<\/b>. Das Füllen der Textfelder für die anderen Optionen erfolgt auf ähnliche Weise. Lediglich die fünfte Variante weicht ab: Sie sieht vor, dass die aufrufende Routine ein Start- und ein Enddatum vorgeben kann – dazu jedoch später mehr.<\/p>\n Die Callback-Funktionen zum Füllen der Kombinationsfelder sind ebenfalls alle vier ähnlich aufgebaut, daher soll dieser Beitrag nur eine davon beispielhaft vorstellen.<\/p>\n Dabei handelt es sich um diejenige zum Füllen des Kombinationsfeldes cboMonate<\/b>. Callback-Funktionen, deren Name als Wert der Eigenschaft RowSourceType <\/b>eines Kombinationsfeldes angegeben ist, müssen einer bestimmten Syntax gehorchen und werden mehrfach mit unterschiedlichen Parameterwerten aufgerufen, die in den einzelnen Teilen des Select Case<\/b>-Konstrukts abgearbeitet werden.<\/p>\n Im Fall der Routine aus Listing 3 wird zunächst der acLBInitialize<\/b>-Teil ausgeführt, der lediglich den im Kombinationsfeld anzuzeigenden Wert entsprechend der voreingestellten oder der von der aufrufenden Routine übergebenen Informationen einstellt.<\/p>\n Listing 3: Füllen eines der Kombinationsfelder per Callback-Funktion<\/p>\n Der acLBGetRowCount<\/b>-Teil legt die Anzahl der anzuzeigenden Listeneinträge fest, die sich aus der Summe aus dem aktuellen, soeben festgelegten Element, den vorherigen und den nachfolgenden Intervallen rekrutiert.<\/p>\n Fehlt noch acLBGetValue<\/b>: Dieser Teil liefert die Werte für das Kombinationsfeld, indem er mit dem Parameter row <\/b>als „Laufvariable“ und der DateAdd<\/b>-Funktion die benötigten Werte wie 1\/2007<\/b>, 2\/2007<\/b>, 3\/2007 <\/b>… zusammenstellt.<\/p>\n Für die Grundausstattung fehlt nur noch die Routine, die durch die OK<\/b>-Schaltfläche ausgelöst wird: Diese validiert die in den beiden Textfeldern txtStartdatum <\/b>und txtEnddatum <\/b>enthaltenen Informationen und macht – soweit beide Felder gültige Datumswerte enthalten und das Startdatum nicht hinter dem Enddatum liegt – das Formular unsichtbar, sodass die aufrufende Routine die in den Textfeldern enthaltenen Werte auslesen und das Formular endgültig schließen kann.<\/p>\n Zusätzlicher Komfort<\/b><\/p>\n Das Formular funktioniert nun prinzipiell so wie gewünscht: Es ermöglicht dem Benutzer, schnell vorgegebene Intervalle auszuwählen und diese nachträglich anzupassen.<\/p>\n Damit der Kunde (der Benutzer) sich nun einmal richtig wie ein König fühlt, soll er auch noch das im jeweiligen Kontext passende Intervall voreingestellt bekommen. Wenn Sie also beispielsweise in ein Kassenbuch eine Funktion zur Ausgabe einer monatlichen Vorsteueranmeldung einfügen, dann soll der Benutzer, wenn es an das Auswählen des passenden Zeitraums geht, auch direkt das Formular mit ausgewähltem Monate-Kombinationsfeld vorfinden – genau so, wie es in Bild 2 zu sehen ist. Nun soll das Formular allerdings weiterhin als modaler Dialog angezeigt werden – das heißt, dass der Benutzer den Fokus nicht auf ein anderes Formular verschieben kann, bevor er den Fokus nicht bewusst mit der OK<\/b>-Schaltfläche von diesem Formular herunternimmt.<\/p>\n Bild 2: Gleichzeitig gibt es eine ganze Reihe von Parametern, die man dem Formular übergeben muss, um alle Möglichkeiten auszuschöpfen: Welche Intervallart soll es zu Beginn anzeigen Wie viele Einträge sollen die einzelnen Kombinationsfelder liefern und welcher soll der standardmäßig angezeigte sein (dies muss übrigens für alle fünf Varianten einstellbar sein) Welchen Zeitraum sollen die Textfelder txtStartdatum<\/b> und txtEnddatum <\/b>anzeigen, wenn der Zeitraum benutzerdefiniert sein soll<\/p>\n Genau genommen muss die aufrufende Routine alle der wie folgt deklarierten Variablen von außen füllen können:<\/p>\n Die benötigten Informationen könnten Sie durch einen zusammengesetzten Wert per öffnungsargument übergeben und anschließend aus der OpenArgs<\/b>-Eigenschaft des aufgerufenen Formulars auslesen.<\/p>\n Das ist allerdings erstens wenig elegant und zweitens würden Sie an dieser Stelle eine gute Gelegenheit verpassen, einmal ein Formular nach bester objektorientierter Manier mit Variablen zu bestücken und diese von außen zu füllen.<\/p>\n Die passende Schnittstelle für das Festlegen einer dieser Variablen von außen liefern Sie beispielsweise mit der folgenden Property Let<\/b>-Prozedur:<\/p>\n Um nun auf diese öffentlich gemachte Eigenschaft des Formulars zuzugreifen, müssen Sie es zunächst instanzieren. Dies geschieht von der aufrufenden Routine aus, die sich üblicherweise hinter einer passenden Schaltfläche oder einem Menübefehl verbergen dürfte:<\/p>\n Das Formular ist an dieser Stelle noch nicht sichtbar. Sie können aber nun auf seine öffentlichen Eigenschaften zugreifen – beispielsweise so:<\/p>\n Diese Anpassungen sollen gleich dafür sorgen, dass das Formular das Kombinationsfeld zum Auswählen einer Kalenderwoche voreinstellt und neben der aktuellen Kalenderwoche nur die drei vorherigen und die drei folgenden Kalenderwochen im Kombinationsfeld zur Auswahl anbietet. Außerdem soll sich die Auswahl auf das Referenzdatum 1.8.2006 beziehen – das bedeutet, dass die Kombinationsfelder standardmäßig auf das Intervall eingestellt werden, die dieses Datum enthalten.<\/p>\n Das Formular ist nun noch unsichtbar und bevor Sie es sichtbar machen, sollten die Steuerelemente noch entsprechend den in den öffentlichen Eigenschaften angegebenen Einstellungen angepasst werden. Dies passiert alles in einer eigens dafür angelegten öffentlichen Methode namens Show<\/b>, die Sie ganz einfach so aufrufen:<\/p>\n Die dadurch ausgelöste Routine sieht wie in Listing 4 aus. Die Routine ermittelt zunächst die Woche, den Monat, das Quartal und das Jahr für das Referenzdatum, das zu Beginn auf das aktuelle Datum eingestellt ist, aber wie soeben beschrieben auf einen anderen Wert geändert werden kann.<\/p>\n Listing 4: Diese Routine macht das Formular nach vorherigem Instanzieren und Einstellen von Eigenschaften sichtbar.<\/p>\n Dann sorgt es mit der Requery<\/b>-Methode der vier Kombinationsfelder für deren Aktualisierung, ruft die Routine ZeitraeumeAktualisieren<\/b> auf, um das Gleiche für die beiden Textfelder txtStartdatum <\/b>und txtEnddatum <\/b>zu erledigen, und macht schließlich nach getaner Arbeit das Formular sichtbar.<\/p>\n Die Routine ZeitraeumeAktualisieren <\/b>wird somit beim Instanzieren des Formulars im Gegensatz zum öffnen mit DoCmd.OpenForm <\/b>zweimal aufgerufen: einmal in der Ereignisprozedur Beim öffnen <\/b>des Formulars, die bereits beim Instanzieren ausgelöst wird, und einmal beim Sichtbarmachen des Formulars mit der Methode Show<\/b>.<\/p>\n Modal oder nicht<\/b><\/p>\n Leider funktioniert das mit dem modalen Dialog beim Instanzieren mit New<\/b> bei Formularen nicht so wie geplant.<\/p>\n Die Eigenschaften Popup <\/b>und Gebunden <\/b>werden schlicht ignoriert, was das Aufhalten des aufrufenden Quellcodes angeht: Nach dem Anzeigen des Formulars mit der Show<\/b>-Methode müssen Sie also selbst dafür sorgen, dass die aufrufende Funktion nicht fortgesetzt wird. Das erreichen Sie durch die folgende Schleife, die ständig prüft, ob das soeben geöffnete Formular noch sichtbar ist oder nicht.<\/p>\n
komfortablen Auswahl von Zeiträumen<\/span><\/b><\/p>\n<\/p><\/div>\nDoCmd.OpenForm \"frmZeitraumAuswaehlen\"<\/pre>\n
\nPrivate Sub Form_Open(Cancel As Integer)
\r\n mZeitraum = eWoche\r\n mWoche = Kalenderwoche(Date)\r\n mMonat = Month(Date)\r\n mQuartal = Format(Date, \"q\")\r\n mJahr = Year(Date)\r\n mWochenVergangenheit = 52\r\n mWochenZukunft = 52\r\n mMonateVergangenheit = 12\r\n mMonateZukunft = 12\r\n mQuartaleVergangenheit = 12\r\n mQuartaleZukunft = 12\r\n mJahreVergangenheit = 20\r\n mJahreZukunft = 20\r\n mStartdatum = Date\r\n mEnddatum = Date\r\n mReferenzdatum = Date\r\n Me!cboWoche.RowSourceType = \"Wochen\"\r\n Me!cboWoche.Requery\r\n Me!cboMonat.RowSourceType = \"Monate\"\r\n Me!cboMonat.Requery\r\n Me!cboQuartal.RowSourceType = \"Quartale\"\r\n Me!cboQuartal.Requery\r\n Me!cboJahr.RowSourceType = \"Jahre\"\r\n Me!cboJahr.Requery\r\n ZeitraumAktualisieren\r\nEnd Sub<\/pre>\n<\/p><\/div>\n\nPrivate Sub ZeitraumAktualisieren()
\r\n Dim byteWoche As Byte\r\n Dim byteMonat As Byte\r\n Dim intJahr As Integer\r\n With Me!ogrZeitraum\r\n Me!cboWoche.Enabled = .value = 1\r\n Me!cboMonat.Enabled = .value = 2\r\n Me!cboQuartal.Enabled = .value = 3\r\n Me!cboJahr.Enabled = .value = 4\r\n End With\r\n Select Case ogrZeitraum.value\r\n Case 1\r\n byteWoche = Split(Me!cboWoche, \"\/\")(0)\r\n intJahr = Split(Me!cboWoche, \"\/\")(1)\r\n Me!txtStartdatum = MontagEinerKalenderwoche(byteWoche, intJahr)\r\n Me!txtEnddatum = DateAdd(\"d\", 6, Me!txtStartdatum)\r\n Case 2\r\n byteMonat = Split(Me!cboMonat, \"\/\")(0)\r\n intJahr = Split(Me!cboMonat, \"\/\")(1)\r\n Me!txtStartdatum = CDate(\"1.\" & byteMonat & \".\" & intJahr)\r\n Me!txtEnddatum = DateAdd(\"d\", -1, DateAdd(\"m\", 1, Me!txtStartdatum))\r\n Case 3\r\n byteMonat = Split(Me!cboQuartal, \"\/\")(0) * 3\r\n intJahr = Split(Me!cboQuartal, \"\/\")(1)\r\n Me!txtStartdatum = QuartalsbeginnErmitteln(\"1.\" & byteMonat & \".\"
& intJahr)\r\n Me!txtEnddatum = QuartalsendeErmitteln(\"1.\" & byteMonat & \".\" & intJahr)\r\n Case 4\r\n intJahr = Me!cboJahr\r\n Me!txtStartdatum = CDate(\"1.1.\" & intJahr)\r\n Me!txtEnddatum = CDate(\"31.12.\" & intJahr)\r\n Case 5\r\n Me!txtStartdatum = mStartdatum\r\n Me!txtEnddatum = mEnddatum\r\n End Select
\r\nEnd Sub<\/pre>\n<\/p><\/div>\n\nFunction Monate(fld As control, ID As Variant, row As Variant, col As Variant, _
code As Variant) As Variant
\r\n Select Case code
\r\n Case acLBInitialize\r\n Monate = True\r\n fld = mMonat & \"\/\" & mJahr
\r\n Case acLBOpen\r\n Monate = Timer
\r\n Case acLBGetRowCount\r\n Monate = 1 + mMonateVergangenheit + mMonateZukunft
\r\n Case acLBGetColumnCount\r\n Monate = 1
\r\n Case acLBGetColumnWidth\r\n Monate = -1
\r\n Case acLBGetValue\r\n Monate = format(DateAdd(\"m\", row - mMonateVergangenheit, _
mReferenzdatum), \"m\\\/yyyy\")
\r\n End Select
\r\nEnd Function<\/pre>\n<\/p><\/div>\n\n ![\"abb002.tif\"](\"..\/fileadmin\/_temp_\/2007_04\/Zeitraumauswahl_3-web-images\/abb002_opt.jpeg\")
\n <\/div>\n\n
Das Formular mit voreingestelltem Intervall<\/span><\/b><\/p>\n<\/p><\/div>\nDim mWoche As Integer\r\nDim mMonat As Integer\r\nDim mQuartal As Integer\r\nDim mJahr As Integer\r\nDim mStartdatum As Date\r\nDim mEnddatum As Date\r\nDim mZeitraum As eZeitraum\r\nDim mWochenVergangenheit As Integer\r\nDim mWochenZukunft As Integer\r\nDim mMonateVergangenheit As Integer\r\nDim mMonateZukunft As Integer\r\nDim mQuartaleVergangenheit As Integer\r\nDim mQuartaleZukunft As Integer\r\nDim mJahreVergangenheit As Integer\r\nDim mJahreZukunft As Integer<\/pre>\n
Public Property Let Woche(intWoche As Integer)\r\n mWoche = intWoche\r\nEnd Property<\/pre>\n
Dim objZeitraumAuswaehlen As _
Form_frmZeitraumAuswaehlen\r\nSet objZeitraumAuswaehlen = _
New Form_frmZeitraumAuswaehlen<\/pre>\nWith objZeitraumAuswaehlen\r\n .Zeitraum = eWoche\r\n .Referenzdatum = \"1.8.2006\"\r\n .WochenVergangenheit = 3\r\n .WochenZukunft = 3\r\n ''...\r\nEnd With<\/pre>\n
objZeitraumAuswaehlen.Show<\/pre>\n
\nPublic Sub Show()
\r\n mWoche = Kalenderwoche(mReferenzdatum)\r\n mMonat = Month(mReferenzdatum)\r\n mQuartal = format(mReferenzdatum, \"q\")\r\n mJahr = Year(mReferenzdatum)\r\n Me!cboJahr.Requery\r\n Me!cboMonat.Requery\r\n Me!cboQuartal.Requery\r\n Me!cboWoche.Requery\r\n ZeitraumAktualisieren\r\n Me.Visible = True\r\nEnd Sub<\/pre>\n<\/p><\/div>\nDo While objZeitraumAuswaehlen.Visible = True\r\n DoEvents\r\nLoop<\/pre>\n