<\/p>\n
Zur Ein- oder Ausgabe eines Datums macht sich ein geeignetes Kalendersteuerelement im Formular besser als ein schnödes Textfeld. Das kann fest im Formular integriert sein, oder als Popup zur Auswahl erscheinen. In Buchungssystemen im Web sind solche Kalenderelemente allgegenwärtig. Auch Access wurde mit der Version 2007 ein solches Popup-Element spendiert, welches sich aber leider in keiner Weise steuern lässt. Grund genug also, um sich nach Alternativen umzuschauen.<\/b><\/p>\nExistierende Kalenderelemente<\/h2>\n
Einst war ein Kalendersteuerelement in Form der ActiveX-Datei mscal.ocx<\/b> optionaler Bestandteil der Office<\/b>-Installation. Das hat sich seit einiger Zeit geändert. Man ist nunmehr allein auf das Popup angewiesen, das bei Datumsfeldern zur Auswahl erscheint, wenn in das zugehörige Textfeld geklickt wird. Eine dauerhafte Ansicht des Kalenders ist somit verwehrt.<\/p>\n
Bild 1 zeigt das alte Kalender-ActiveX-Steuerelement links oben im Formular. Aus irgendeinem Grund befand es sich, möglicherweise aus älteren Office-Installationen, noch bei uns in englischer Version im System. Seine Darstellung lässt sich im Formularentwurf oder auch per VBA steuern. Das betrifft die Schriftarten und die Farbgebung. Es löst bei einigen Aktionen ein Ereignis aus und spiegelt in der Eigenschaft Value<\/b> das markierte Datum wieder. Sollte auf ihrem System die ActiveX-Datei nicht installiert sein, so meldet Access beim Aufruf des Formulars der Beispieldatenbank den etwas eigenartigen Fehler In diesem Formular befindet sich kein Steuerelement<\/b>. Entfernen Sie in diesem Fall im Entwurf des Formulars frmCalendarTest<\/b> einfach den Platzhalter des Steuerelements.<\/p>\n
![\"Demo](\"..\/fileadmin\/_temp_\/2017_05\/frmCalendarsTest.png\")
<\/p>\n
Bild 1: Demo einiger Datums- und Kalendersteuerelemente im Testformular<\/span><\/b><\/p>\n Da von diesem Fall auszugehen ist, fragt sich, wie mit anderen Mitteln eine ähnliche Darstellung und Funktion zu erreichen wäre. Testweise haben wir ein Listenfeld (rechts unten in der Abbildung) und ein Microsoft Listview Control <\/b>(links unten) als Kalender zu gestalten versucht. Mit einigen Zeilen Code und den entsprechenden Einstellungen für die Steuerelemente gelingt dies auch. Der inakzeptable Nachteil der Lösungen besteht darin, dass sich in diesen Steuerelementen nur ganze Zeilen markieren lassen, nicht aber einzelne Zellen. Eine Auswahl per Maus scheidet deshalb aus. Derlei ließe sich also lediglich zur Anzeige der Tage eines Monats verwenden. Doch das brauchen Sie wohl höchst selten. Bleiben noch zwei Alternativen: das Microsoft DateTime Picker Control<\/b> und die Access-Textbox mit Datumsformatierung. Ersteres zeigt sich im Formular rechts oben. Es entspringt der ActiveX-Datei mscomct2.ocx<\/b>, die früher ebenfalls mit Office installiert wurde (s. Bild 2).<\/p>\n Bild 2: Das Microsoft DateTime-Picker- ActiveX-Steuerelement<\/span><\/b><\/p>\n Wir erwähnen es nur der Vollständigkeit halber, denn außer einer abweichenden Gestalt bietet es gegenüber der dem Popup von Access (s. Bild 3) keine sonderlichen Vorteile. Nur die Schriftarten und Farben können hier zusätzlich eingestellt werden. Die Funktionalität ist bei beiden jedoch gleich.<\/p>\n Bild 3: Das Popup-Element zur Datumsauswahl bei Access-Textboxen<\/span><\/b><\/p>\n Normalerweise öffnet sich das Kalenderelement einer Textbox mit Datumsformatierung dann, wenn Sie auf das Symbol rechts neben dem Textfeld klicken. Es gibt aber eine Anweisung, die die Anzeige des Kalender-Popups erzwingt. Möchten Sie etwa, dass es sofort beim Eintritt in das Feld erscheint, oder auch beim Klicken in das Textfeld, so schreiben Sie die folgende Zeile in die entsprechenden Ereignisprozeduren:<\/p>\n Diese RunCommand<\/b>-Anweisung ermöglicht das öffnen des Popups per Code, falls die Datums-Textbox gerade den Fokus besitzt. Andernfalls ereignet sich eine Fehlermeldung. Verwenden Sie sie deshalb besser nur in den Ereignissen der Textbox selbst.<\/p>\n Sicher finden Sie auch noch weitere Fremdsteuerelemente in Form von ActiveX-Dateien bei Drittanbietern. Es gilt jedoch die Maxime, wegen der möglichen Registrierungsprobleme solche ActiveX-Komponenten nur dann einzusetzen, wenn es absolut notwendig ist. Und das ist hier nicht gegeben, denn ein Kalendersteuerelement lässt sich gut auch mit Access-Bordmitteln selbst erstellen!<\/p>\n Natürlich könnte man einfach 31 Steuerelemente, etwa Buttons oder Textboxen, in einem Formular so anordnen, dass diese einen Kalender ergäben. Um auf eine Datumsauswahl zu reagieren, bräuchte es dafür dann eben auch 31 Ereignisprozeduren. Das wäre zwar recht unkompliziert, ist aber wenig elegant.<\/p>\n Dabei reicht es im Prinzip ja für die Tage der Woche nur sieben Steuerelemente im Detailbereich zu platzieren und diese Wochen untereinander zu wiederholen. Damit sind wir allerdings auf eine Tabelle angewiesen, die die Datensätze für alle Wochen eines Monats bereitstellt. Nur eine Tabelle oder Abfrage als Datensatzherkunft kann bewirken, dass sich der Detailbereich wiederholt.<\/p>\n Bevor es Schritt für Schritt an die Entwicklung des Kalenderformulars geht, sollte noch definiert werden, was der Ausdruck Steuerelement<\/b> in unserem Zusammenhang bedeutet. Ein wirklich neues Steuerelement kann nun mal mit Access nicht erzeugt werden. Sie können lediglich aus bestehenden Elementen eine neue Funktionsgruppe erstellen, die den Anschein eines einzelnen Steuerelements erweckt. Damit das Ganze wiederverwendbar ist, sollte diese Funktionsgruppe möglichst in einem Formular ohne weitere Abhängigkeiten untergebracht werden, welches Sie später als Unterformular in andere einsetzen. Dieses Unterformular stellt dann quasi ein Pseudo-Steuerelement dar. In der Beispieldatenbank nennt es sich sfrmCalendar<\/b>. Das Präfix s<\/b> steht für Subform<\/b>.<\/p>\n Die Basistabelle tblCalendar<\/b> für das Kalenderformular in Bild 4 weist lediglich die sieben Datenfelder D1<\/b> bis D7<\/b> von Typ Long<\/b> für die einzelnen Tage der Woche auf. Für die Namen der Felder kann man eher nicht Kürzel für Wochentage, wie Mo<\/b> bis So<\/b>, verwenden, da der Erste eines Monats eben selten ein Montag ist.<\/p>\n Bild 4: Die Tabelle tblCalendar als Basis für den Kalender im Eigenbau<\/span><\/b><\/p>\n Die Nummerierung in den Namen der Felder ermöglicht später den gezielten Zugriff auf die Spalten der Tabelle. Ein Blick auf Bild 5 zeigt, was dahinter steckt. <\/p>\n Bild 5: Die gefüllte Tabelle tblCalendar im Datenblatt<\/span><\/b><\/p>\n Die Datensätze füllt nämlich eine VBA-Routine des Formulars zur Laufzeit unter Angabe des gewünschten Jahrs und Monats. Sie ordnet die Zahlen für die Tage so an, dass sich links immer die Montage befinden. Der Erste des Monats wiederum soll in der ersten Zeile auftauchen. Ist das kein Montag, so sind links von diesem Feld die Tage des Vormonats einzusetzen. Hier sind das der 28.<\/b> bis 31.<\/b>. ähnliches gilt für den Letzten des Monats, welcher sich im letzten Datensatz befinden soll, aber in der Regel kein Sonntag ist. Folglich ergeben sich in der letzten Zeile rechts vom Monatsletzten meist noch weitere Tage des Folgemonats. Je nach Monat und Jahr sind in der Tabelle mindestens vier, maximal sechs, Datensätze zu erzeugen.<\/p>\n Meist sind die Tage, welche nicht zum angezeigten Monat gehören, also jene des Vor- und Folgemonats, in Kalendern ausgegraut dargestellt. Um dieses Feature auch unserem Kalender zu spendieren, verwenden wir für die Textfelder im Formular eine Bedingte Formatierung<\/b>. Denn per VBA-Code kann zwar die Hintergrundfarbe einer Textbox über die Eigenschaft BackgroundColor<\/b> gesteuert werden, doch das betrifft dann sämtliche Zellen einer Spalte, die sich von diesem Datenfeld ableiten, nicht jedoch einzelne Zellen.<\/p>\n Um Bedingte Formatierung<\/b> kommt man hier also nicht herum. Da diese einen Vergleichsausdruck für die Steuerung des Formats verwendet, benötigen wir irgendein Indiz, welches die nicht zum Monat gehörigen Tage definiert. Und das ist hier das Minuszeichen. Alle auszugrauenden Tage haben einen negativen Wert. Damit ist auch klar, weshalb hier keine Datumstypen für die Felder der Tabelle zum Einsatz kommen, denn deren Werte können nicht negativ sein. Ein Long<\/b>– oder ein Integer<\/b>-Wert reichen zur Kennzeichnung aus.<\/p>\n Der direkte Bezug des Kalenders zu einer Tabelle bringt allerdings einen Nachteil mit sich. Benötigen Sie etwa zwei Kalendersteuerelemente in Ihrem Hauptformular, so wären diese ohne weiteres Zutun beide an dieselbe Tabelle gebunden und zeigten in der Folge auch die gleichen Daten an. In diesem Fall erstellen Sie eine Kopie der Tabelle und bezeichnen diese etwa mit tblCalendar2<\/b>. Die folgend beschriebene Routine zum Füllen der Tabelle kann unterschiedliche Tabellen berücksichtigen.<\/p>\n Die dafür verantwortliche Routine nennt sich FillCalendar<\/b> und ist in Listing 1 abgebildet, wobei hier einige Teile entfernt wurden, die nicht unmittelbar zum Erzeugen der Datensätze gehören.<\/p>\n Listing 1: Füllen einer Kalendertabelle über VBA-Code<\/span><\/b><\/p>\n Der Name der zu füllenden Tabelle steht im Kopf in der Eigenschaftsvariablen m_Table<\/b> des Formularmoduls. Dieser Variablen muss also erst ein Wert zugewiesen werden, was die Property-Let<\/b>-Prozedur Table<\/b> übernimmt:<\/p>\n Erst dann kann die eigentliche Routine aufgerufen werden. Sie weist dem Formular selbst zunächst als Datensatzherkunft (RecordSource<\/b>) die nun in m_Table<\/b> stehende Tabelle zu. Das Formular ist im Entwurf also noch nicht zwingend an eine Tabelle gebunden, sondern das geschieht hier zu Laufzeit.<\/p>\n Nun benötigen wir jenes Datum, welches in der linken oberen Ecke des Kalenders steht. über Property<\/b>-Prozeduren (hier nicht im Listing), wurde in den Variablen m_Month<\/b> und m_Year<\/b> der gewünschte Monat und das Jahr für den Kalender abgespeichert. Den Ersten dieses Monats erhalten Sie über die VBA-Funktion DateSerial<\/b>:<\/p>\n Das ist indessen noch nicht das Datum, welches links oben steht. Um zu ermitteln, wie viele Tage des Vormonats zu berücksichtigen sind, kommt die VBA-Funktion Weekday<\/b> zum Einsatz. Sie gibt eine Zahl zurück, die den Wochentag symbolisiert. Die 1<\/b> entspricht dabei Montag<\/b>, die 7<\/b> dem Sonntag<\/b>. Nun muss vom Ersten des Monats lediglich diese Zahl subtrahiert werden, und schon steht das Datum links oben fest. Es wird der Variablen StartDate<\/b> vom Type Date<\/b> zugewiesen. Nach diesen Vorarbeiten kann die Tabelle m_Table<\/b> über zwei verschachtelte Schleifen mit Daten versehen werden.<\/p>\n Doch vorher muss die Tabelle noch über die Execute<\/b>-Anweisung und den SQL-DELETE<\/b>-Ausdruck geleert werden. Anschließend öffnet ein Recordset rs<\/b> die Datensätze zum Beschreiben.<\/p>\n Die Zählervariable für die Schleife zum Hinzufügen von Datensätzen ist j<\/b>. Da maximal sechs Zeilen im Kalender stehen können, ist ihr Bereich auf 0<\/b> bis 5<\/b> eingestellt. Nach jedem Durchlauf wird per AddNew<\/b> ein neuer Datensatz erzeugt. Für den Zugriff auf die Feldwerte eines Datensatzes gibt es dann die folgende Schleife auf den Zähler i<\/b>, deren Bereich sich für die einzelnen Wochentage von 0<\/b> bis 6<\/b> erstreckt. In dieser wird fortlaufend der Wert des Kalenderdatums in StartDate<\/b> um eins erhöht. Das ist statthaft, weil ein Date<\/b>-Type imgrunde ein Double<\/b>-Wert ist, wobei die Nachkommastellen die Tageszeit angeben, die Vorkommastellen die Tage. Also führt Addition von 1<\/b> zum nächsten Tag.<\/p>\n Der Zugriff auf die Datenfelder geschieht namentlich über das Präfix D<\/b> und den Zahler i<\/b>, zu dem noch 1<\/b> addiert werden muss, weil die Felder von 1<\/b> bis 7<\/b> nummeriert sind, nicht von 0<\/b> bis 6<\/b>. Der Wert eines Felds errechnet sich aus dem Tagesanteil des Datums, welchen die VBA-Funktion Day<\/b> zurückgibt.<\/p>\n <\/p>\n Im Prinzip wäre es das auch schon, wollten wir nicht die Tage außerhalb des Zielmonats mit einem Minuszeichen versehen werden. Um jene zu eruieren, wird in der Variablen n<\/b> der Monatsanteil des Datums über die Funktion Month()<\/b> zwischengespeichert. Weicht dieser Wert vom Zielmonat ab (n <> m_Month<\/b>), so greift die IIf<\/b>-Bedingungsfunktion (entspricht Wenn()<\/b> in Abfragen), die entweder eine –1<\/b> oder eine 1<\/b> als Ergebnis zeitigt. Und das ist eben der Multiplikator für den Tageswert.<\/p>\n Da die äußere Schleife immer von 0<\/b> bis 5<\/b> zählt, würden auch immer sechs Zeilen im Kalender stehen. Um das etwa für den Monat Februar<\/b> zu verhindern, vergleicht die Zeile nach der inneren Schleife die Monate abermals und verlässt die äußere, sobald der Folgemonat erreicht ist.<\/p>\n Damit ist das Werk vollbracht. Die Requery<\/b>-Anweisung auf das Formular (Me<\/b>) baut die Ansicht auf Grundlage der neuen Datensätze nun neu auf.<\/p>\n Neben den eigentlichen Tagen des Kalenders im Detailbereich soll das Formular noch in den Spaltenköpfen die Wochentage anzeigen. Außerdem dienen zwei Kombinationsfelder im Formularkopf der Auswahl des gewünschten Jahres und Monats. Als zusätzliche Navigationselemente können die Werte dieser Comboboxen über darunter liegende Buttons jeweils um eins vor oder zurückgeschaltet werden. Bild 6 demonstriert den Aufbau.<\/p>\n Bild 6: Entwurfsansicht des Endlosformulars sfrmCalendar<\/span><\/b><\/p>\n Die Spaltenüberschriften sind durch Labels realisiert, die hier mit festen Wochentagen versehen sind. Im Detailbereich gibt es sieben Textboxen, die anfänglich an die Datenfelder D1<\/b> bis D7<\/b> der Tabelle tblCalendar<\/b> gebunden waren. Das aber muss umgangen werden, weil sonst ja negative Tageswerte erschienen. Der Ausdruck Abs<\/b> aber macht aus negativen Zahlen positive, lässt positive aber unverändert. Also ist der Steuerelementinhalt<\/b> der ersten beiden Textboxen dieser:<\/p>\n Damit werden die Tage korrekt ausgegeben. Fehlt nur noch die graue Hinterlegung der nicht zum Monat gehörigen Tage des Kalenders über die Bedingte Formatierung<\/b>.<\/p>\n Klicken Sie auf die erste Textbox im Detailbereich rechts und wählen im Kontextmenü den Eintrag Bedingte Formatierung…<\/b>. Das ruft einen Dialog, wie in Bild 7, auf den Plan. Hier sind zunächst eine oder mehrere Bedingungsregeln anzulegen. Uns reicht eine. Mit Klick auf Neue Regel <\/b>öffnet sich ein zweiter Dialog. Im Bereich für den Vergleichsausdruck dürfen Sie nicht die Option Feldwert<\/b> wählen, welche sich auf den Wert bezöge, den das Textfeld gerade anzeigt. Und das ist ja über die Abs<\/b>-Funktion immer ein positiver. Stattdessen wählen Sie Ausdruck<\/b> und setzen in das nebenstehende Feld den String [D1]<0<\/b>.<\/p>\n Bild 7: Dialoge zur Bedingten Formatierung der Datumtextfelder<\/span><\/b><\/p>\n Immer dann, wenn das Datenfeld D1<\/b> kleiner ist, als 0<\/b>, greift die Bedingung und damit die darunter eingestellte Formatierung. Für den Hintergrund wurde ein leichtes Grau genommen und für die Schriftfarbe ein Dunkelgrau, damit diese Tageswerte zur Laufzeit erscheinen, wie deaktivierte Steuerelemente. Nach dem Schließen beider Dialoge ist die Bedingte Formatierung<\/b> abgeschlossen.<\/p>\n Den Vorgang wiederholen Sie für die weiteren Textboxen des Detailbereichs, wobei hier natürlich jeweils das richtige Datenfeld im Vergleichsausdruck gewählt werden muss. Also die Felder D2<\/b> bis D7<\/b>. Das Ergebnis der Angelegenheit können Sie schon einmal in Bild 8 begutachten. <\/p>\n Bild 8: Das Formular sfrmCalendar zur Laufzeit ist hier standalone aufgerufen<\/span><\/b><\/p>\n Manche Kalender hinterlegen die Spalten für das Wochenende ebenfalls grau. Dafür braucht es keine Bedingte Formatierung<\/b>, weil es sich hier immer um die Textboxen txtD6<\/b> und txtD7<\/b> handelt. Setzen Sie also gegebenenfalls einfach den Hintergrund dieser Textfelder auf einen festen Wert abweichend von Weiß.<\/p>\n Die beiden oberen Kombinationsfelder müssen eingangs mit den passenden Einträgen versehen werden. Das geschieht im Ereignis Beim Laden<\/b> (Form_Load<\/b>) des Formulars über zwei Schleifen.<\/p>\n Die einfachere ist dabei die zum Setzen der Jahreszahlen:<\/p>\n Die Monatsnamen können Sie auch fest im Entwurf des Formulars festlegen, indem Sie die Eigenschaft Herkunftstyp<\/b> der Combobox auf Wertliste<\/b> einstellen und in der Eigenschaft Datensatzherkunft<\/b> die Monatsnamen semikolon-getrennt hineinschrieben. Dann aber gäbe das Kombinationsfeld cbMonth<\/b> nach Auswahl eines Eintrags nur den Monatsnamen als Wert aus. Für die Variable m_Month<\/b> zum Anlegen der Datensätze benötigen wir aber eher eine Zahl. Daher ist die Combobox auch zweispaltig ausgelegt. Die erste versteckte Spalte, an die auch der Wert des Steuerelements gebunden ist, enthält die Zahlen, die zweite Spalte die Monatsnamen. Auch dies könnte über die Eigenschaft Datensatzherkunft <\/b>geschehen, was zu diesem String führt:<\/p>\n In unserer Version übernimmt das jedoch dieser Schleifen-Code in Form_Load<\/b>:<\/p>\n Jede Zeile der Combobox bekommt in der ersten Spalte über String-Verkettung den Schleifenzähler i<\/b> verabreicht, gefolgt von einem Semikolon, an das sich der Monatsname anschließt. Den berechnen Sie einfach über ein künstliches Datum, welches die DateSerial<\/b>-Funktion zurückgibt. Aus dem Datum erhalten Sie per Format-Funktion und den Formatierungsausdruck mmmm<\/b> dann den Monatsnamen im Volltext als Anteil. Der Ausdruck mmm<\/b> hingegen führt zu abgekürzten Monaten:<\/p>\n Die Auswahl eines Eintrags aus diesen Comboboxen löst ein Ereignis aus, das zum erneuten Befüllen der Tabelle und Neuzeichnen des Kalenders über die Routine FillCalendar<\/b> führt:<\/p>\n Die entsprechenden Member<\/b>-Variablen m_Year<\/b> und m_Month<\/b> werden also mit neuen Werten versehen, die die Grundlage für die weiteren Vorgänge bilden.<\/p>\n Nachdem der Kalender neu angelegt ist, kommt jeweils die Anweisung RaiseEvent<\/b> ins Spiel. Dies löst ein Ereignis aus, das vom Formular, welches das Unterformularelement enthält, später abgefangen werden kann. Dazu sind zunächst über das Schlüsselwort Event<\/b> Ereignisse im Kopf des Kalenderformulars deklariert:<\/p>\n Diese Ereignisse können dezidiert mit RaiseEvent<\/b> aufgerufen werden, wobei als Parameter das geänderte Jahr oder der geänderte Monat übergeben werden. Um auf diese Ereignisse reagieren zu können, muss das Hauptformular das Kalenderunterformular dergestalt instanziieren:<\/p>\n Dadurch lässt sich eine Ereignisprozedur für die Objektinstanz oCalender<\/b> generieren:<\/p>\n Im VBA-Direktfenster wird damit der neu im Kalendersteuerelement gewählte Monat zur Information ausgegeben. Natürlich kann der Wert anschließend auch für beliebige weitere Vorgänge im Hauptformular genutzt werden.<\/p>\n Die vier Schaltflächen zum Weiter- oder Zurückschalten von Jahr und Monat wirken ähnlich, wie die Auswahl eines Combobox-Eintrags. Sie führen ebenfalls zum Neuanlegen des Kalenders und zum Auslösen der Ereignisse. Die Click<\/b>-Prozedur für den Button cmdMonthNext<\/b> zum Weiterschalten des Monats etwa sieht so aus:<\/p>\n m_Month<\/b> wird um eins erhöht. Für den Dezember<\/b> würde das bedeuten, dass nun die ungültige Zahl 13<\/b> herauskommt. Deshalb berücksichtigt die Routine diesen Umstand und macht über die If<\/b>-Zeile aus der 13<\/b> eine eins für den folgenden Januar<\/b>. Dem Monatskombinationsfeld cbMonth<\/b> wird dann der neue Wert zugewiesen, damit sich die Auswahl auch in diesem zeigt. Der Rest verläuft analog dem schon Dargestellten.<\/p>\n Den Code für die weiteren Schaltflächen führen wir hier nicht auf, weil er prinzipiell gleich aufgebaut ist.<\/p>\n Beim Klick auf einen Tag des Kalendersteuerelements soll dieses ein Ereignis auslösen, das das gewählte Datum als Parameter übergibt. Deshalb ist ein weiteres Ereignis im Modulkopf deklariert:<\/p>\n Dieses Ereignis soll per RaiseEvent<\/b> aufgerufen werden, wenn auf eine der sieben Textfelder geklickt wird. Die Ereignisprozeduren für die beiden ersten Textfelder:<\/p>\n Hier passiert weiter nichts, als dass die Hilfsprozedur fuClick<\/b> aufgerufen wird. Die nämlich berechnet das Datum eigenständig (s. Listing 2). Dass die Routine keine Parameterübergabe benötigt, sieht man an ihrer ersten Zeile. Die spricht das im Formular gerade aktive Steuerelement an (ActiveControl<\/b>), was infolge des Klicks eben das entsprechende Textfeld ist. Ihr Wert ist der über die Abs<\/b>-Funktion des Steuerelementinhalts erhaltene Tag des Monats.<\/p>\n Listing 2: Ermitteln des Datums aus der aktiven Textbox<\/span><\/b><\/p>\n Das Datum kann damit auf einfache Weise berechnet werden. Es ergibt sich über DateSerial<\/b> aus dem Jahr (m_Year<\/b>), Monat (m_Month<\/b>), plus dem Offset des in n<\/b> zwischengespeicherten Tags. Allerdings führt das zu einem Fehler, wenn ein außerhalb des Monats liegender Tag angeklickt wird. Das ist zum einen dann der Fall, wenn die Position des aktiven Datensatz (CurrentRecord<\/b>) kleiner ist, als 2<\/b> und der Tageswert in n<\/b> größer, als 20<\/b>. Dann handelt es sich um den Vormonat und in die Variable nAdd<\/b> wird der Wert -1<\/b> gesetzt. Zum anderen bedeutet eine Datensatzposition von größer als 5<\/b> und ein Tageswert von kleiner als 8<\/b>, dass es sich um den Folgemonat handeln muss. Dann steht in nAdd<\/b> der Wert 1<\/b>, der ansonsten 0<\/b> beträgt, wenn keine der beiden Bedingungen erfüllt ist. Der Wert von nAdd<\/b> wird schließlich dem Monat in m_Month<\/b> hinzuaddiert, wodurch DateSerial<\/b> wieder das korrekte Datum berechnet.<\/p>\n Die Routine löst am Ende das Ereignis DateSelected<\/b> aus, schreibt aber zuvor noch in ein Label, welches sich im Fußbereich des Kalenderformulars befindet, das Datum formatiert aus, damit hier ein Feedback über die Auswahl geschieht. Ein letztes Ereignis gibt es noch:<\/p>\n Es wird immer dann ausgelöst, wenn sich die Höhe des Kalendersteuerelements ändert. Grund dafür ist der Umstand, dass, je nach Monat, der Kalender vier bis sechs Zeilen hoch sein kann. Durch die Endlosdarstellung der Datensätze ändert sich folglich die Gesamthöhe des Formulars. Im Ereignis NewHeight<\/b> übergibt die Variable H<\/b> dann diese Höhe. Darauf kann das Hauptformular reagieren und für das Unterformular eine neue Ausdehnung anweisen:<\/p>\n Ob die fortwährende änderung der Höhe des Kalendersteuerelements im Hauptformular besonders chic ist, müssen Sie entscheiden. Zwar eliminieren Sie damit seinen manchmal auftauchenden grauen Hintergrund, aber im Sinne von Oberflächenergonomie ist das Flackern des Elements nicht unbedingt.<\/p>\n Die Höhe H<\/b> für das Event wird übrigens in der Prozedur FillCalendar<\/b> so berechnet:<\/p>\n Zunächst werden Höhe des Formularkopfs (adHeader<\/b>) und -fußes (acFooter<\/b>) zusammengezählt. Dann wird die Höhe des Detailbereichs (acDetail<\/b>) mit der Anzahl der Datensätze multipliziert und der Gesamthöhe hinzuaddiert.<\/p>\n Unter Umständen möchten Sie im Kalender per Code visuell ein Datum voreinstellen. über die Eigenschaften Month<\/b> und Year<\/b> des Moduls lassen sich zwar Monat und Jahr voreinstellen, nicht aber der Tag. Dafür gibt es die öffentliche Prozedur SelectDate<\/b> im Formular. Auch ihr Aufruf führt zu einem Neuzeichnen des Kalenders, wie die folgenden Zeilen belegen:<\/p>\n Das Jahr wird aus dem in D<\/b> übergebenen Datum über die Funktion VBA.Year<\/b> ermittelt, der Monat über VBA.Month<\/b>. Ohne diese Bibliothekspräfixe würde VBA denken, dass die im Formularcode deklarierten Prozeduren Year<\/b> und Month<\/b> gemeint sind. Die Werte werden nun aber diesen Property<\/b>-Prozeduren Year<\/b> und Month<\/b> tatsächlich zugewiesen. Die zusätzliche Formularvariable m_SelectedDate<\/b> erhält außerdem dieses Datum. Schließlich wird FillCalendar<\/b> wieder aufgerufen, wobei in diesem speziellen Fall im optionalen Parameter das auszuwählende Datum D<\/b> übergeben wird. Deren Deklarationszeile hat nämlich in der Beispieldatenbank, abweichend von Listing 1, diese Syntax:<\/p>\n Der Teil in FillCalendar<\/b>, welcher dieses Datum berücksichtig: <\/p>\n Wird FillCalendar<\/b> ohne Parameter aufgerufen, dann trifft IsMissing<\/b> zu und die Bedingung wird übergangen. Andernfalls schaut die nächste Zeile darauf, ob das in SelDate<\/b> übergebene Datum mit dem von StartDate<\/b> übereinstimmt. Zur Erinnerung: StartDate<\/b> wird in einer Schleife andauernd erhöht, bis alle Tage des Kalendermonats durchlaufen sind. Ist das passende Datum identifiziert, so speichert die Routine die Zahler i<\/b> und j<\/b> in den Variablen x<\/b> und y<\/b> zwischen. Dabei entspricht x<\/b> der Nummerierung der auszuwählenden Textbox und y<\/b> der Position des Datensatzes im Endlosformular. Nach Durchlaufen aller Monatstage und damit der Neuanlage der Datensätze in der Tabelle kommt es zu einem Zweig, der die richtige Textbox anhand der Koordinaten auswählt:<\/p>\n Der Datenbankzeiger wird über die Eigenschaft AbsolutePosition<\/b> des Formular-Recordsets zunächst auf die Koordinate y<\/b> eingestellt. Das aktiviert automatisch den entsprechenden Datensatz im Formular. Die Objektvariable ctl<\/b> vom Typ Textbox<\/b> wird nun auf das durch x<\/b> identifizierte Steuerelement gesetzt, also eines der Textfelder txtD1<\/b> bis txtD7<\/b>. SetFocus<\/b> selektiert schließlich das Textfeld, wobei das erst dann sichtbar wird, nachdem eine Markierung des Textinhalts über die Eigenschaften SelStart<\/b> und SelLength<\/b> vorgenommen wurde.<\/p>\n Die Gestalt des Kalendersteuerelements kann rudimentär beeinflusst werden. Das betrifft die Schriftart und -größe für alle enthaltenen Steuerelemente, sowie die Hintergrundfarbe. Sie setzen dazu Werte für die Eigenschaften FontName<\/b>, FontSize<\/b> und BackColor<\/b>, welche intern in die Member<\/b>-Variablen m_Fontname<\/b>, m_Fontsize<\/b> und m_BackColor<\/b> abgespeichert werden. Das Setzen von BackColor<\/b> wird in der Eigenschaftsprozedur direkt für die Hintergrundbereiche durchgeführt:<\/p>\n Zum Formatieren aller weiteren Steuerelemente gibt es eine Hilfsroutine FormatControls<\/b>, die alle im Formular enthaltenen anhand der Controls<\/b>-Auflistung in einer For-Each<\/b>-Schleife durchläuft:<\/p>\n![\"Das](\"..\/fileadmin\/_temp_\/2017_05\/DTpic_1099_kerOCX.png\")
<\/p>\n![\"Das](\"..\/fileadmin\/_temp_\/2017_05\/AccessDate.png\")
<\/p>\nPrivate Sub <\/span>txtDate_Click()\r\n RunCommand acCmdShowDatePicker\r\nEnd Sub<\/span>\r\nPrivate Sub <\/span>txtDate_Enter()\r\n RunCommand acCmdShowDatePicker\r\nEnd Sub<\/span><\/pre>\nKalender im Eigenbau<\/h2>\n
Wochentabelle für einen Monat<\/h2>\n
![\"Die](\"..\/fileadmin\/_temp_\/2017_05\/tblCalendar_DS.png\")
<\/p>\n![\"Die](\"..\/fileadmin\/_temp_\/2017_05\/tblCalendar_RT.png\")
<\/p>\nFüllen der Tabelle per VBA<\/h2>\n
Private <\/span>m_Table As String<\/span>\r\nProperty Get <\/span>Table() As String<\/span>\r\n Table = m_Table\r\nEnd Property<\/span>\r\nProperty Let <\/span>Table(ByVal Value As String<\/span>)\r\n m_Table = Value\r\n FillCalendar\r\nEnd Property<\/span> \r\nPrivate Sub <\/span>FillCalendar()\r\n Dim <\/span>rs As <\/span>DAO.Recordset\r\n Dim <\/span>i As Long<\/span>, j As Long<\/span>\r\n Dim <\/span>n As Long<\/span>\r\n Dim <\/span>StartDate As Date<\/span>\r\n Me.RecordSource = m_Table\r\n n = Weekday(DateSerial(m_Year, m_Month, 1), vbMonday)\r\n StartDate = DateSerial(m_Year, m_Month, 1) - n\r\n CurrentDb.Execute \"DELETE FROM \" & m_Table\r\n Set<\/span> rs = CurrentDb.OpenRecordset(\"SELECT * FROM \" & m_Table, dbOpenDynaset)\r\n For j = 0 To 5\r\n rs.AddNew<\/span>\r\n For i = 0 To 6\r\n StartDate = StartDate + 1\r\n n = VBA.Month(StartDate)\r\n rs.Fields(\"D\" & CStr(1 + i)).Value = Day(StartDate) * IIf(n <> m_Month, -1, 1)\r\n Next<\/span> i\r\n rs.Update\r\n If <\/span>n <> m_Month Then<\/span> Exit For<\/span>\r\n Next<\/span> j\r\n rs.Close\r\n Me.Requery\r\nEnd Sub<\/span><\/pre>\nfrm.Table = \"tblCalendar\"<\/pre>\n
DateSerial(m_Year, m_Month, 1)<\/pre>\n
Entwurf des Kalenderformulars<\/h2>\n
![\"Entwurfsansicht](\"..\/fileadmin\/_temp_\/2017_05\/sfrmCalendar_DS.png\")
<\/p>\n= Abs([D1])\r\n= Abs([D2])\r\n...<\/pre>\n
Bedingte Formatierung der Tageswerte<\/h2>\n
![\"Dialoge](\"..\/fileadmin\/_temp_\/2017_05\/FormatConditions.png\")
<\/p>\n![\"Das](\"..\/fileadmin\/_temp_\/2017_05\/sfrmCalendar_RT.png\")
<\/p>\nNavigation und Ereignisse<\/h2>\n
For i= 1950 To 2030\r\n Me!cbYear.AddItem i\r\nNext<\/span> i<\/pre>\n1;Januar;2;Februar;3;März;4;April;5;Mai;...<\/pre>\n
For i = 1 To 12\r\n Me!cbMonth.AddItem CStr(i) & \";\" & _\r\n Format(DateSerial(m_Year, i, 1), \"mmmm\") & \";\"\r\nNext<\/span> i<\/pre>\nJan; Feb; Mar; Apr; ...<\/pre>\n
Private Sub <\/span>cbMonth_AfterUpdate()\r\n m_Month = Me!cbMonth.Value\r\n <b>FillCalendar<\/b>\r\n RaiseEvent MonthChanged(m_Month)\r\nEnd Sub<\/span>\r\nPrivate Sub <\/span>cbYear_AfterUpdate()\r\n m_Year = Me!cbYear.Value\r\n <b>FillCalendar<\/b>\r\n RaiseEvent YearChanged(m_Year)\r\nEnd Sub<\/span><\/pre>\nPublic <\/span>Event YearChanged(ByVal NewYear As Long<\/span>)\r\nPublic <\/span>Event MonthChanged(ByVal NewMonth As Long<\/span>)<\/pre>\nPrivate <\/span>WithEvents oCalendar As <\/span>Form_sfrmCalendar<\/pre>\nPrivate Sub <\/span>oCalendar_MonthChanged(ByVal NewMonth As Long<\/span>)\r\n Debug.Print<\/span> \"Neuer Kalendermonat: \" & NewMonth\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>cmdMonthNext_Click()\r\n m_Month = m_Month + 1\r\n If <\/span>m_Month =13 Then<\/span> m_Month = 12\r\n Me!cbMonth.Value = m_Month\r\n FillCalendar\r\n RaiseEvent MonthChanged(m_Month)\r\nEnd Sub<\/span><\/pre>\nReaktion auf Datumsauswahl im Kalender<\/h2>\n
Public <\/span>Event DateSelected(ByVal Value As Date<\/span>)<\/pre>\nPrivate Sub <\/span>txtD1_Click()\r\n fuClick\r\nEnd Sub<\/span>\r\nPrivate Sub <\/span>txtD2_Click()\r\n fuClick\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>fuClick()\r\n Dim <\/span>n As Long<\/span>\r\n Dim <\/span>nAdd As Long<\/span>\r\n \r\n n = Me.ActiveControl.Value\r\n If <\/span>(Me.CurrentRecord < 2) And (n > 20) Then<\/span> nAdd = -1\r\n If <\/span>(Me.CurrentRecord > 5) And (n < 8) Then<\/span> nAdd = 1\r\n m_SelectedDate = DateSerial(m_Year, m_Month + nAdd, n)\r\n Me!LblDate.Caption = Format(m_SelectedDate, \"dddd\\, dd.mm.yyyy\")\r\n RaiseEvent DateSelected(m_SelectedDate)\r\nEnd Sub<\/span><\/pre>\nPublic <\/span>Event NewHeight(ByVal H As Long<\/span>)<\/pre>\nPrivate Sub <\/span>oCalendar_NewHeight(ByVal H As Long<\/span>)\r\n Me!ctlCalendar.Height = H\r\nEnd Sub<\/span><\/pre>\nH = Me.Section(acHeader).Height + Me.Section(acFooter).Height H = H + Me.Recordset.RecordCount * Me.Section(acDetail).Height<\/pre>\n
Vorauswahl eines Datums<\/h2>\n
Public Sub <\/span>SelectDate(ByVal D As Date<\/span>)\r\n Me.Year = VBA.Year(D)\r\n Me.Month = VBA.Month(D)\r\n m_SelectedDate = D\r\n FillCalendar D\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>FillCalendar(Optional<\/span> SelDate As Variant<\/span>)<\/pre>\nIf <\/span>Not<\/span> IsMissing(SelDate) Then<\/span>\r\n If <\/span>StartDate = SelDate Then<\/span> x = i + 1: y = j\r\nEnd If<\/span><\/pre>\nIf <\/span>Not<\/span> IsMissing(SelDate) Then<\/span>\r\n Dim <\/span>ctl As <\/span>Access.TextBox\r\n Me.Recordset.AbsolutePosition = y\r\n Set<\/span> ctl = Me.Controls(\"txtD\" & CStr(x))\r\n ctl.SetFocus\r\n ctl.SelStart = 1: ctl.SelLength = 2\r\nEnd If<\/span><\/pre>\nänderungen am Layout<\/h2>\n
Property Let <\/span>BackColor(ByVal Value As Long<\/span>)\r\n m_Backcolor = Value\r\n Me.Section(acDetail).BackColor = Value\r\n Me.Section(acFooter).BackColor = Value\r\n Me.Section(acHeader).BackColor = Value\r\nEnd Property<\/span><\/pre>\nPrivate Sub <\/span>FormatControls()\r\n Dim <\/span>ctl As <\/span>Access.Control\r\n \r\n For Each ctl In Me.Controls\r\n Select Case ctl.ControlType\r\n Case <\/span>acTextBox, acLabel, acCheckBox\r\n ctl.FontName = m_Fontname\r\n ctl.FontSize = m_FontSize\r\n ctl.BackColor = m_Backcolor\r\n End Select<\/span>\r\n