<\/p>\n
Das im ersten Teil dieser Ausgabe beschriebene Kalendersteuerelement eignet sich vornehmlich zur Auswahl eines Datums. Benötigen Sie aber eine übersicht, wie die Termine des Outlook-Kalenders mit der Markierung von Datumsbereichen, etwa zur Darstellung Ihrer Urlaubsplanung, so sind die Anforderungen ganz andere. Auch für diesen Zweck stellen wir ein Pseudo-Steuerelement vor, das allein mit Access-Bordmitteln realisiert ist.<\/b><\/p>\nTerminkalender<\/h2>\n
Einsatzbereiche für solche kalendarischen übersichten gibt es viele. Feiertage können darin eingetragen werden, Geburtstage und andere Jubilaren, die Buchung von Ferienwohnungen oder Autovermietungen, die Einsatzplanung von Mitarbeitern, oder Sie markieren hier Ihre Urlaubstage. Dabei geht es weniger um die Auswahl von Terminen, als um deren Darstellung. Bild 1 zeigt bereits, wie unser Bespiel aussieht.<\/p>\n
![\"Demo](\"..\/fileadmin\/_temp_\/2017_05\/frmMonths_RT2.png\")
<\/p>\n
Bild 1: Demo des Unterformularsteuerelements Monatskalender nach Einbau in ein Hauptformular mit Markierungen<\/span><\/b><\/p>\n Natürlich bauen wir hier keinen komplexen Terminkalender nach, wie den von Outlook. Das Kalendersteuerelement sfrmCalendarMonths<\/b> ist eng an die einfache Version des Auswahlkalenders im ersten Teil dieser Ausgabe angelehnt, wie seine linke Seite schon vermuten lässt. Es dient in erster Linie der Visualisierung bereits vorliegender Termindaten. Beschreiben wir zunächst kurz seinen Aufbau.<\/p>\n Grundsätzlich werden hier drei Monate mit ihren Tagen angezeigt. Die Auswahl der Monate geschieht mit dem Kombinationsfeld links, die den mittleren Monat einstellt. Die übrigen Navigationselemente, wie die Jahres-Combo oder die Buttons zum Weiterschalten der Monate gleichen in ihrer Funktion genau der des einfachen Auswahlkalenders. Zusätzlich ist die Kalenderübersicht noch mit einer Titelzeile oben versehen, die Sie mit beliebigem Inhalt füllen können. Das eigentliche Feature aber sind die rot unterlegten Zellen, die durch die dem Steuerelement über eine öffentliche Funktion zugewiesene Datumsbereiche zustande kommen. Mehr gibt das Steuerelement in dieser Version nicht her. Es reagiert auch nicht auf Klicks in die Zellen. Das wäre eine Eigenschaft, die Sie mit dem Wissen aus dem ersten Teil dieser Ausgabe zum Auswahlkalender leicht selbst nachtragen könnten.<\/p>\n ähnlich, wie beim Auswahlkalender, kommt für die Darstellung der Tage eine Tabelle zum Einsatz, deren Felder dann von 21<\/b> Textboxen im Endlosformular ausgegeben werden. Hier reichen sieben Felder natürlich nicht aus. Für jede Spalte des Dreimonatskalenders muss ein eigenes Feld her, wenn nicht etwa eine umständliche Kreuztabellenabfrage verwendet werden soll.<\/p>\n Die Felder der Tabelle tblCalendarMonths<\/b> sind ebenfalls vom Zahlentyp Long<\/b>. Die Nummerierung geschieht über das Präfix D<\/b>, gefolgt von der Nummer des Wochentags und der Position des Monats im Kalender. D62<\/b> bezeichnet also etwa den sechsten Tag (Sonnabend<\/b>) und die 2<\/b> darin den mittleren Monat. Bild 2 verdeutlicht dies ausschnittsweise. Auch diese Tabelle wird vom Formular selbst mit Datensätzen gefüllt.<\/p>\n Bild 2: Ausschnitt der Monatskalendertabelle in der Entwurfsansicht<\/span><\/b><\/p>\n Allerdings speichern wir hier nicht jeweils die Tage der Monate ab, da diese ja mehrfach vorkommen -pro Monat einmal. Stattdessen nimmt ein Feld jeweils tatsächlich einen Datumswert auf. Warum ein Datum in einem Long<\/b>-Feld Sie ahnen es möglicherweise: Auch hier möchten wir Bedingte Formatierung<\/b> zur farblichen Unterscheidung der Zellen benutzen und nehmen wieder negative Werte als Indiz für eine Markierung. Schauen Sie auf die gefüllte Tabelle in Bild 3.<\/p>\n Bild 3: So präsentiert sich die Tabelle tblCalendarMonths, nachdem sie über das Formular mit Daten gefüllt wurde.<\/span><\/b><\/p>\n Ein negativer Wert führt später zur roten Hervorhebung der Zelle. Der Absolutwert einer Zahl stellt das Datum dar. Wir erwähnten bereits, dass ein Access- oder VBA-Datum tatsächlich ein Double<\/b>-Wert ist, dessen ganzzahliger Anteil den Tag angibt. Und diesen kann auch ein Long<\/b>-Wert aufnehmen. Beispiel:<\/p>\n Benötigen Sie also den Zeitanteil eines Datums nicht, so reicht zu dessen Speicherung ein Long<\/b>-Wert.<\/p>\n Die Tatsache, dass hier tatsächlich Datumswerte abgespeichert sind, macht es überdies später leichter, sie beim Klick auf die Textboxen zu ermitteln. Den Steuerelementinhalt unterziehen Sie dazu lediglich der Funktion CDate()<\/b>. Eine Berechnung aus der Zellenposition, wie beim Auswahlkalender, ist hier nicht nötig. Schauen wir im Folgenden an, wie die Daten der Tabelle generiert werden. Auch hier nennt sich die verantwortliche Prozedur FillCalendar<\/b>.<\/p>\n Die Prozedur FillCalendar<\/b> wird im Formularmodul immer dann aufgerufen, wenn sich der Monat oder Tag ändern. Das kann durch Auswahl in den entsprechenden Kombinationsfeldern geschehen, durch Betätigung der Buttons zum Weiterschalten, oder durch Zuweisung an die Eigenschaftsprozeduren Year<\/b> und Month<\/b>. Listing 1 zeigt wieder eine gekürzte Version, in der nur die für die Erzeugung der Datensätze relevanten Teile abgebildet sind.<\/p>\n Listing 1: Befüllen der Tabelle tblCalendarMonths<\/span><\/b><\/p>\n Zunächst wird in StartDate<\/b> der erste Tag des linken Monats ermittelt. Dazu wird vom Monat der Member<\/b>-Variablen m_Month<\/b> eins<\/b> abgezogen und das Datum mit DateSerial<\/b> berechnet. EndDate<\/b> wiederum speichert den letzten Tag des rechten Monats. Da die Anzahl der Tage eines Monats variabel ist, kann für den Tag<\/b>-Parameter in DateSerial<\/b> kein Wert angegeben werden. Man behilft sich in diesem Fall mit dem Folgemonat (m_Month + 2<\/b>) und dem Tag 0<\/b>. Das entspricht dem ersten Tag des Monats minus eins.<\/p>\n Die Execute<\/b>-Anweisung leert die Tabelle und OpenRecordset<\/b> öffnet eine beschreibbare Datensatzgruppe auf sie. Die folgende Schleifenkonstruktion weicht von der des Auswahlkalenders ab. Wir benötigen hier drei ineinander verschachtelte Schleifen. Die äußere auf die Zählervariable n<\/b> stellt die Zeilen der Kalender dar. Diese entspricht dann auch der Anzahl der Datensätze der Tabelle, weshalb der Durchlauf auch mit einem AddNew<\/b> beginnt. Die nächste Schleife mit dem Zähler i<\/b> betrifft die drei Monate, die innerste Schleife mit dem Zähler j<\/b> deren Wochentage.<\/p>\n Zur Berechnung des Datums eines Datenfeldes wird hier StartDate<\/b> nicht einfach fortlaufend erhöht. Stattdessen werden zu StartDate<\/b> zweimal Werte über die DateAdd<\/b>-Funktion addiert und das Ergebnis in der Date<\/b>-Variablen DTmp<\/b> zwischengespeichert. Die erste DateAdd<\/b>-Funktion addiert die Nummer des Monats aus dem Monatsschleifenzähler i<\/b>, wobei der Ausdruck m<\/b> der Funktion erst sagt, dass Monate zu addieren sind. Das zweite DateAdd<\/b> verwendet Tag-Werte (Ausdruck d<\/b>) und berechnet über den Wochentag in j<\/b> und das Siebenfache der betreffenden Woche n<\/b> einen weiteren Offset. Im Prinzip könnte dieser Wert aus DTmp<\/b> dann schon einem Tabellenfeld zugewiesen werden.<\/p>\n Da jedoch die Schleifendurchläufe dazu führen können, dass über die Addition der Tage ein über einen Monat hinausreichendes Datum ermittelt würde, gibt es eine Abbruchbedingung für die innere Schleife. Ist DTmp<\/b> größer, als der letzte Tag des Monats, so wird die Schleife verlassen. Dieser letzte Tag ist in der Variablen MaxDate<\/b> gespeichert und wird nach dem Beginn der zweiten Schleife jeweils neu berechnet.<\/p>\n Schließlich sind noch die Zeiträume zu berücksichtigen, die im Kalendersteuerelement rot zu unterlegen sind und durch negative Datumszahlen repräsentiert werden. Die Funktion IsInRanges<\/b>, auf welche wir noch zu sprechen kommen, wird dazu befragt.<\/p>\n Befindet sich das Schleifendatum DTmp<\/b> innerhalb eines der verabreichten Zeiträume, so gibt die Funktion True<\/b> zurück. In diesem Fall nimmt die Variable f<\/b> den Wert -1<\/b> an, andernfalls 1<\/b>. Und f<\/b> ist dann wieder der Multiplikator für den Datumswert, der dem Feld des Recordsets zugewiesen wird. Der Name des Felds ergibt sich aus dem Präfix D<\/b> und den Zählvariablen j<\/b> und i<\/b> über String-Verkettung.<\/p>\n <\/p>\n Dem Kalendersteuerelement können beliebig viele Datumsbereiche hinzugefügt werden, die dann in der Ansicht rot markiert werden. Sie können dabei auch außerhalb des dargestellten Bereichs liegen. Die Prozedur AddRange<\/b> (s. Listing 2) bewerkstelligt deren Speicherung.<\/p>\n Listing 2: Hinzufügen eines Zeitraums über AddRange<\/span><\/b><\/p>\n Als Parameter geben Sie das Startdatum des gewünschten Bereichs in StartDate<\/b> an und das Enddatum in EndDate<\/b>. Soll es nur ein Tag sein, dann müssen beide Werte identisch sein. Das Wertepaar speichert die Routine in einem modulweit gültigen Array<\/b> arrRanges<\/b> des benutzerdefinierten Typs TRange<\/b>, der im Kopf des Moduls deklariert ist. Hier muss erst per UBound<\/b> ermittelt werden, wie viele Elemente das Array bereits enthält. Ist noch kein Element vorhanden, so ist das Array noch nicht initialisiert, was bei UBound<\/b> zu einem Fehler führen würde. Deshalb ist die Fehlerbehandlung eingangs per On Error Resume Next<\/b> außer Kraft gesetzt. Die Variable n<\/b> nimmt die Anzahl der Elemente entgegen und erhöht sie um eins<\/b>.<\/p>\n Nun kann das Array mit ReDim<\/b> neu dimensioniert werden, wobei das Schlüsselwort Preserve<\/b> angibt, dass sein Inhalt dabei nicht verloren gehen soll. Im n-ten<\/b> Element das Arrays werden schließlich Start- und Enddatum abgespeichert. Der abschließende Aufruf von FillCalendar<\/b> führt dazu, dass der Zeitraum im Kalender auch sofort dargestellt wird.<\/p>\n Möchten Sie die Zeiträume modifizieren, so löschen Sie sie mit der Prozedur DeleteRanges<\/b> alle auf einen Schlag und fügen die neuen wieder hinzu. Das Löschen einzelner Datumsbereiche erlaubt das Modul nicht.<\/p>\n Die angesprochene Funktion IsInRanges<\/b> ermittelt dann, ob ein bestimmtes Datum sich innerhalb der Zeiträume des angelegten Arrays befindet (s. Listing 3). D<\/b> ist hier der Datumsparameter, den Sie der Funktion übergeben. Alle Zeiträume werden in einer Schleife durchlaufen und StartDate<\/b>, wie EndDate<\/b> eines Elements, mit ihm verglichen. Sobald das für ein Bereichselement zutrifft, erhält der Rückgabewert der Funktion True<\/b> und die Schleife wird verlassen.<\/p>\n Listing 3: Die Funktion ermittelt, ob sich das Datum D innerhalb der gespeicherten Datumsbereiche befindet.<\/span><\/b><\/p>\n Die Entwurfsansicht des Formulars sfrmCalendarMonths<\/b> (s. Bild 4) kommt ähnlich daher, wie die des Auswahlkalenders. Der Unterschied ist, dass hier natürlich mehr Textboxen im Detailbereich untergebracht sind, drei Labels für die Monatsnamen über den Wochentagen platziert sind und sich ein Bezeichnungsfeld für den Titel oben rechts befindet. Sowohl die Label für die Monatsnamen, wie die für die Wochentage, werden in der FillCalendar<\/b>-Prozedur des Formulars per VBA beschriftet.<\/p>\n Bild 4: Das Formular sfrmCalendarMonths gleich in der Entwurfsansicht dem des Beitrags zum einfachen Kalender.<\/span><\/b><\/p>\n Bei den Monatsnamen ist die Geschichte noch einfach. Die Beschriftung der Labels LM1<\/b> bis LM3<\/b> leitet sich vom Startdatum des Kalenders ab:<\/p>\n Der Monatsname des ersten Einzelkalenders ergibt sich aus dem Startdatum (StartDate<\/b>) über die Format<\/b>-Funktion. Für den zweiten Monat werden dem Startdatum einfach 31<\/b> Tage hinzuaddiert, für den dritten 62<\/b>.<\/p>\n Die Labels für die Wochentage waren im Auswahlkalender noch fest beschriftet. Hier geht das nicht, weil ja jeder Einzelkalender mit dem Ersten des Monats beginnt. Folglich variiert auch die Bezeichnung der jeweils ersten Spalte.<\/p>\n Die Labels für die Wochentage haben die durchnummerierten Namen L1<\/b> bis L21<\/b>. So kann einfach auf sie zugegriffen werden. Der folgende Prozedurteil von FillCalendar<\/b> überreicht diesen Steuerelementen ihre Beschriftung:<\/p>\n In der String-Variablen S<\/b> wird der Name des Labels aus den beiden Schleifenzählern i<\/b> und j<\/b> gebildet. Die Caption<\/b>-Eigenschaft der Steuerelemente der Controls<\/b>-Auflistung des Formulars kann nun angesprochen werden. Ihr Wert ergibt sich aus der Kombination von jeweiligem Monatsstartdatum plus Tag 1<\/b> bis 7<\/b> und der DateSerial<\/b>-Funktion im Verein mit der Format<\/b>-Funktion, deren Ausdruck ddd<\/b> anweist, die Wochentage abgekürzt auszugeben.<\/p>\n Etwas komplexer, als beim Auswahlkalender, ist der Steuerelementinhalt der Textboxen im Detailbereich gestaltet. Hier reicht die Abs<\/b>-Funktion allein nicht aus, da in der Tabelle ja nicht Integer<\/b>-Tage abgespeichert sind, sondern Datumswerte. Wir bemühen hier ausnahmsweise den Ausdrucks-Generator<\/b> von Access. In Bild 5 ist er für den Steuerelementinhalt der Textbox txtD11<\/b>, also der ersten links im Detailbereich, dargestellt. Der eigentlich in der Textbox auszugebende Tag ergibt sich über die Day<\/b>-Funktion von VBA auf das gespeicherte Datum D11<\/b> der Tabelle. Im Ausdruckseditor ist der Funktionsname eingedeutscht und lautet demzufolge Tag()<\/b>. Die Abs<\/b>-Funktion macht aus einem negativen Datum ein positives. Das alles reicht indessen immer noch nicht aus.<\/p>\n Bild 5: Ausdruck für den Steuerelementinhalt der ersten Textbox<\/span><\/b><\/p>\n Denn einige Zellen in der Tabelle sind leer, weil es etwa keinen 34.<\/b> eines Monats gibt. Bei diesen Feldinhalten kommt Abs<\/b> ins Schlingern. Die Textboxen gäben den Ausdruck #Fehler!<\/b> aus. Um das abzufangen, muss noch über IsNull<\/b> ermittelt werden, ob ein Feld nicht<\/b> leer ist. Nur dann gibt der Ausdruck über die If<\/b>-Bedingung (Wenn<\/b>) den Tag aus und andernfalls einen Leerstring.<\/p>\n Damit sich diejenigen Tage, welche sich in den spezifizierten Zeiträumen des Kalenders befinden, rot einfärben, kommt die gleiche Bedingte Formatierung<\/b> zum Zug, wie beim einfachen Auswahlkalender. Der Unterschied besteht lediglich in der Formatierung, die für den Hintergrund ein hellrot vorsieht, die Schriftfarbe aber unverändert lässt.<\/p>\n Der Vergleichsausdruck bleibt derselbe. Bild 6 zeigt den ersten Dialog zum Anlegen der bedingten Formatierung, den Sie über das Kontextmenü der Textbox aufrufen können.<\/p>\n Bild 6: Erster Dialog zur bedingten Formatierung der ersten Textbox<\/span><\/b><\/p>\n In Bild 7 sehen Sie den zweiten Dialog, in den Sie den benötigten Ausdruck eingeben.<\/p>\n Bild 7: Zweiter Dialog zur bedingten Formatierung der ersten Textbox<\/span><\/b><\/p>\n Nun ist es ein recht zeitraubendes Unterfangen, diesen Vorgang für alle 21 Textfelder zu wiederholen. Darum greifen wir zu einer kleinen Routine, welche die Bedingte Formatierung<\/b> per Code setzt.<\/p>\n öffnen Sie dazu das Formular sfrmCalendarMonths<\/b> im Entwurf, wechseln in den VBA-Editor und rufen dort im Direktfenster die Routine SetFormatConditions<\/b> von Modul1<\/b> auf. Diese Prozedur finden Sie in Listing 4.<\/p>\n Listing 4: Anlegen der bedingten Formatierung per Code<\/span><\/b><\/p>\n Screen.ActiveForm<\/b> gibt das aktuell im Arbeitsbereich von Access aktive Formular zurück, egal, ob es zur Laufzeit oder im Entwurf geöffnet ist. über die Controls<\/b>-Auflistung des Detailbereichs ermittelt eine Schleife alle Steuerelemente in der Schleifenvariablen ctl<\/b>.<\/p>\n Die ist gleich als Access.Textbox <\/b>deklariert, da sich im Detailbereich keine anders gearteten Steuerelemente befinden. Das Datenfeld, an welches die Textbox indirekt gebunden ist, können Sie aus dem Namen ermitteln. txtD11<\/b> etwa bezieht sich auf das Tabellenfeld D11<\/b>, txt62<\/b> auf D62<\/b>, et cetera. <\/p>\n Möglicherweise schon bestehende Bedingte Formatierungen<\/b> der Textbox löscht zuerst die Delete<\/b>-Anweisung der FormatConditions<\/b>-Auflistung. Deren Add<\/b>-Funktion schließlich legt eine neue Formatierung an, wobei als Parameter zwingend deren Typ anzugeben ist. Für einen Ausdruck<\/b> ist das die Konstante acExpression<\/b>.<\/p>\n Den nächsten Parameter können Sie in diesem Fall unberücksichtigt lassen, müssen jedoch anschließend den Vergleichsausdruck setzen. Der bildet sich aus dem Datenfeld in S<\/b> in rechteckigen Klammern plus dem Vergleich <0<\/b>. In der Objektvariablen fmtCond<\/b> ist nun die Bedingte Formatierung<\/b> gespeichert. Sie müssen ihr nur noch sagen, welche Formatierung gewünscht ist. BackColor<\/b> stellen Sie deshalb auf die über die RGB<\/b>-Funktion erhaltene hellrote Farbe ein. <\/p>\n Sie können nun in der Entwurfsansicht über die Dialoge zur Bedingten Formatierung<\/b> der Textboxen überprüfen, ob die Sache geklappt hat. Erst nach dem Schließen des Formulars und der Bestätigung der Nachfrage zum Speichern der änderungen, sind diese in ihm verewigt.<\/p>\n Nicht unerwähnt soll bleiben, dass diese Routine auch zur Laufzeit des Formulars funktioniert! Sie können bei einem angezeigten Formular jederzeit die Bedingten Formatierungen<\/b> von Steuerelementen per Code ändern. Die neuen Formatierungen reflektieren sich dann sofort in ihm, ein Umstand, von dem selten Gebrauch gemacht wird, der jedoch sehr mächtig ist!<\/p>\n übrigens sind die Ausdrücke zum Steuerelementinhalt<\/b> der Textboxen in der Beispieldatenbank auf ähnliche Weise zustande gekommen. Auch hier wäre die manuelle Anlage über den Ausdruckseditor sehr mühsam. Statt der FormatConditions<\/b> wurde hier jeweils die ctl.ControlSource<\/b> auf einen entsprechend generierten String gesetzt.<\/p>\n Wie beim Auswahlkalender auch können Sie nun im Formular frmCalendarMonths<\/b> ein Unterformularsteuerelement erzeugen und als dessen Inhalt das Formular sfrmCalendarMonths<\/b> angeben (s. Bild 8). Hier ist zusätzlich oben ein Button eingefügt, der das Hinzufügen von Zeitraummarkierungen demonstrieren soll. Beim Laden<\/b> des Hauptformulars werden einige Einstellungen für das Kalendersteuerelement vorgenommen, das als Objekt im Kopf des Moduls über die Variable oCalendar<\/b> deklariert ist:<\/p>\n Bild 8: Außer dem Button zur Markierung von Datumsbereichen enthält das Formular frmCalendarMonths nur das Unterformularsteuerelement und etwas VBA-Code<\/span><\/b><\/p>\n Seine Hintergrundfarbe wird im With<\/b>-Block auf einen Grauton gesetzt, das gewünschte Jahr auf 2018<\/b>, der Monat auf Juni,<\/b> und der Titel AiU-Belegungsplan<\/b> wird zugewiesen. Das ist bereits alles! Bild 9 demonstriert, wie das geöffnete Formular dann aussieht.<\/p>\n Bild 9: Demo des Unterformularsteuerelements Monatskalender nach Einbau in ein Hauptformular frmCalendarMonths<\/span><\/b><\/p>\n Das Kalendersteuerelement löst nur zwei Ereignisse aus:<\/p>\n Das passiert beim Betätigen eines der Navigationssteuerelemente. Wie Sie auf die in den Ereignisparametern übergebenen Monats- und Jahrangaben reagieren, bleibt Ihnen überlassen.<\/p>\n Ein Klick auf die Tage des Kalenders löst indessen, abweichend vom Auswahlkalender des ersten Teils, kein Ereignis aus. Implementieren Sie das auf analoge Weise selbst, wenn Sie es wünschen. Sie müssen nur für jede der 21 Textboxen das Click<\/b>-Ereignis generieren und dort die Funktion fuClick<\/b> anspringen lassen, die im einfachsten Fall etwa so aussähe:<\/p>\n Dies gäbe das angeklickte Datum im VBA-Direktfenster aus.<\/p>\n Dem Button für das Hinzufügen von Zeiträumen ist diese Prozedur hinterlegt:<\/p>\n Vier Zeiträume werden dem Kalender jeweils über Start- und Enddatum verabreicht, nachdem möglicherweise schon bestehende über die DeleteRanges<\/b>-Anweisung gelöscht wurden. Das unmittelbare Ergebnis sahen Sie bereits in der ersten Abbildung.<\/p>\nBasistabelle<\/h2>\n
![\"Ausschnitt](\"..\/fileadmin\/_temp_\/2017_05\/tblMonths_DS.png\")
<\/p>\n![\"So](\"..\/fileadmin\/_temp_\/2017_05\/tblMonths_RT.png\")
<\/p>\n Now() -> Datum: 21.07.2017 08:33\r\n CDbl(Now()) -> Double: 42937,35625\r\n Clng(CDbl(Now())) -> Long: 42937\r\n CDate(42938) -> Datum: 21.07.2017<\/pre>\n
Daten der Basistabelle erzeugen<\/h2>\n
Private Sub <\/span>FillCalendar()\r\n Dim <\/span>rs As <\/span>DAO.Recordset\r\n Dim <\/span>i As Long<\/span>, j As Long<\/span>, n As Long<\/span>, f As Long<\/span>\r\n Dim <\/span>StartDate As Date<\/span>, EndDate As Date<\/span>\r\n Dim <\/span>MaxDate As Date<\/span>, DTmp As Date<\/span>\r\n \r\n StartDate = DateSerial(m_Year, m_Month - 1, 1)\r\n EndDate = DateSerial(m_Year, m_Month + 2, 0)\r\n \r\n CurrentDb.Execute \"DELETE FROM tblCalendarMonths\"\r\n Set<\/span> rs = CurrentDb.OpenRecordset(\"tblCalendarMonths\", dbOpenDynaset)\r\n For n = 0 To 4\r\n rs.AddNew<\/span>\r\n For i = 1 To 3\r\n MaxDate = DateSerial(m_Year, m_Month + i - 1, 0)\r\n For j = 1 To 7\r\n DTmp = DateAdd(\"m\", i - 1, StartDate)\r\n DTmp = DateAdd(\"d\", n * 7 + j - 1, DTmp)\r\n If <\/span>DTmp > MaxDate Then<\/span> Exit For<\/span>\r\n If <\/span>IsInRanges(DTmp) Then<\/span> f = -1 Else f = 1\r\n rs.Fields(\"D\" & CStr(j) & CStr(i)).Value = f * CLng(DTmp)\r\n Next<\/span> j\r\n Next<\/span> i\r\n rs.Update\r\n Next<\/span> n\r\n \r\n rs.Close\r\n Me.Requery\r\nEnd Sub<\/span><\/pre>\nZeiträume zuweisen<\/h2>\n
Private <\/span>Type TRange\r\n StartDate As Date<\/span>\r\n EndDate As Date<\/span>\r\nEnd Type \r\nPrivate <\/span>arrRanges() As <\/span>TRange\r\nPublic Sub <\/span>AddRange(StartDate As Date<\/span>, EndDate As Date<\/span>)\r\n Dim <\/span>n As Long<\/span>\r\n \r\n On Error Resume Next<\/span>\r\n n = UBound<\/span>(arrRanges)\r\n If <\/span>Err.Number <> 0 Then<\/span>\r\n n = 0\r\n Else<\/span>\r\n n = n + 1\r\n End If<\/span>\r\n On Error GoTo<\/span> 0\r\n ReDim Preserve arrRanges(n)\r\n arrRanges(n).StartDate = StartDate\r\n arrRanges(n).EndDate = EndDate\r\n \r\n FillCalendar\r\nEnd Sub<\/span><\/pre>\nPublic Sub <\/span>DeleteRanges()\r\n Erase arrRanges\r\n FillCalendar\r\nEnd Sub<\/span> <\/pre>\nPrivate Function <\/span>IsInRanges(D As Date<\/span>) As Boolean<\/span>\r\n Dim <\/span>i As Long<\/span>, n As Long<\/span>\r\n \r\n On Error Resume Next<\/span>\r\n n = UBound<\/span>(arrRanges)\r\n If <\/span>Err.Number <> 0 Then<\/span>\r\n On Error GoTo<\/span> 0\r\n Exit Function<\/span>\r\n End If<\/span>\r\n On Error GoTo<\/span> 0\r\n \r\n For i = 0 To n\r\n If <\/span>(D >= arrRanges(i).StartDate) And (D <= arrRanges(i).EndDate) Then<\/span>\r\n IsInRanges = True<\/span>\r\n Exit For<\/span>\r\n End If<\/span>\r\n Next<\/span> i\r\nEnd Function<\/span><\/pre>\nEntwurf des Steuerelementformulars<\/h2>\n
![\"Das](\"..\/fileadmin\/_temp_\/2017_05\/sfrmMonths_DS.png\")
<\/p>\nMe!LM1.Caption = Format(StartDate, \"mmmm\")\r\nMe!LM2.Caption = Format(StartDate + 31, \"mmmm\")\r\nMe!LM3.Caption = Format(StartDate + 62, \"mmmm\")<\/pre>\n
For j = 0 To 2\r\n For i = 1 To 7\r\n S = \"L\" & CStr(i + j * 7)\r\n Me.Controls(S).Caption = Format( _\r\n DateSerial(m_Year, m_Month + j - 1, 0) + i, \"ddd\")\r\n Next<\/span> i\r\nNext<\/span> j<\/pre>\n![\"Ausdruck](\"..\/fileadmin\/_temp_\/2017_05\/frmMonths_FldExpr.png\")
<\/p>\nBedingte Formatierung der Textfelder<\/h2>\n
![\"Erster](\"..\/fileadmin\/_temp_\/2017_05\/frmMonths_Condition1.png\")
<\/p>\n![\"Zweiter](\"..\/fileadmin\/_temp_\/2017_05\/frmMonths_Condition2.png\")
<\/p>\nSub <\/span>SetFormatConditions()\r\n Dim <\/span>frm As <\/span>Access.Form\r\n Dim <\/span>ctl As <\/span>Access.TextBox\r\n Dim <\/span>S As String<\/span>\r\n Dim <\/span>fmtcond As <\/span>FormatCondition\r\n \r\n Set<\/span> frm = Screen.ActiveForm\r\n For Each ctl In frm.Section(acDetail).Controls\r\n S = Mid<\/span>(ctl.Name, 4)\r\n ctl.FormatConditions.Delete\r\n Set<\/span> fmtcond = ctl.FormatConditions.Add(acExpression, , \"[\" & S & \"]<0\")\r\n fmtcond.BackColor = RGB<\/span>(255, 160, 160)\r\n Next<\/span> ctl\r\nEnd Sub<\/span><\/pre>\nEinbau des Steuerelements in ein Hauptformular<\/h2>\n
![\"Außer](\"..\/fileadmin\/_temp_\/2017_05\/frmMonths_DS.png\")
<\/p>\nPrivate <\/span>WithEvents oCalendar As <\/span>Form_sfrmCalendarMonths\r\nPrivate Sub <\/span>Form_Load()\r\n Set<\/span> oCalendar = Me!ctlCalendar.Form\r\n With<\/span> oCalendar\r\n .BackColor = RGB<\/span>(224, 224, 224)\r\n .Year = 2018\r\n .Month = 6\r\n .Title = \"AiU-Belegungsplan\"\r\n End With<\/span>\r\nEnd Sub<\/span><\/pre>\n![\"Demo](\"..\/fileadmin\/_temp_\/2017_05\/frmMonths_RT1.png\")
<\/p>\nPrivate Sub <\/span>oCalendar_MonthChanged(ByVal NewMonth As Long<\/span>)\r\n''''\r\nEnd Sub<\/span>\r\nPrivate Sub <\/span>oCalendar_YearChanged(ByVal NewYear As Long<\/span>)\r\n''''\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>fuClick()\r\n Debug.Print<\/span> Me.ActiveControl.CDate(Abs(Value))\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>cmdSel1_Click()\r\n With<\/span> oCalendar\r\n .DeleteRanges\r\n .AddRange \"21.05.2018\", \"24.05.2018\"\r\n .AddRange \"06.06.2018\", \"12.06.2018\"\r\n .AddRange \"19.06.2018\", \"22.06.2018\"\r\n .AddRange \"02.07.2018\", \"16.07.2018\"\r\n End With<\/span>\r\nEnd Sub<\/span><\/pre>\n